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 *); 187692ad7caSAdrian Chadd static void wpi_fatal_intr(struct wpi_softc *); 1886607310bSBenjamin Close static void wpi_intr(void *); 189692ad7caSAdrian Chadd static int wpi_cmd2(struct wpi_softc *, struct wpi_buf *); 1906607310bSBenjamin Close static int wpi_tx_data(struct wpi_softc *, struct mbuf *, 191692ad7caSAdrian Chadd struct ieee80211_node *); 192692ad7caSAdrian Chadd static int wpi_tx_data_raw(struct wpi_softc *, struct mbuf *, 193692ad7caSAdrian Chadd struct ieee80211_node *, 194692ad7caSAdrian Chadd const struct ieee80211_bpf_params *); 195b032f27cSSam Leffler static int wpi_raw_xmit(struct ieee80211_node *, struct mbuf *, 196b032f27cSSam Leffler const struct ieee80211_bpf_params *); 197692ad7caSAdrian Chadd static void wpi_start(struct ifnet *); 198692ad7caSAdrian Chadd static void wpi_start_locked(struct ifnet *); 1994eaf2ee3SAdrian Chadd static void wpi_start_task(void *, int); 200692ad7caSAdrian Chadd static void wpi_watchdog_rfkill(void *); 201692ad7caSAdrian Chadd static void wpi_watchdog(void *); 202692ad7caSAdrian Chadd static int wpi_ioctl(struct ifnet *, u_long, caddr_t); 203692ad7caSAdrian Chadd static int wpi_cmd(struct wpi_softc *, int, const void *, size_t, int); 204692ad7caSAdrian Chadd static int wpi_mrr_setup(struct wpi_softc *); 205692ad7caSAdrian Chadd static int wpi_add_node(struct wpi_softc *, struct ieee80211_node *); 206692ad7caSAdrian Chadd static int wpi_add_broadcast_node(struct wpi_softc *, int); 207692ad7caSAdrian Chadd static int wpi_add_ibss_node(struct wpi_softc *, struct ieee80211_node *); 208692ad7caSAdrian Chadd static void wpi_del_node(struct wpi_softc *, struct ieee80211_node *); 209692ad7caSAdrian Chadd static int wpi_updateedca(struct ieee80211com *); 210692ad7caSAdrian Chadd static void wpi_set_promisc(struct wpi_softc *); 211692ad7caSAdrian Chadd static void wpi_update_promisc(struct ifnet *); 212692ad7caSAdrian Chadd static void wpi_update_mcast(struct ifnet *); 213692ad7caSAdrian Chadd static void wpi_set_led(struct wpi_softc *, uint8_t, uint8_t, uint8_t); 214692ad7caSAdrian Chadd static int wpi_set_timing(struct wpi_softc *, struct ieee80211_node *); 215692ad7caSAdrian Chadd static void wpi_power_calibration(struct wpi_softc *); 216692ad7caSAdrian Chadd static int wpi_set_txpower(struct wpi_softc *, int); 217692ad7caSAdrian Chadd static int wpi_get_power_index(struct wpi_softc *, 218692ad7caSAdrian Chadd struct wpi_power_group *, struct ieee80211_channel *, int); 219692ad7caSAdrian Chadd static int wpi_set_pslevel(struct wpi_softc *, uint8_t, int, int); 220692ad7caSAdrian Chadd static int wpi_send_btcoex(struct wpi_softc *); 221692ad7caSAdrian Chadd static int wpi_send_rxon(struct wpi_softc *, int, int); 222692ad7caSAdrian Chadd static int wpi_config(struct wpi_softc *); 223692ad7caSAdrian Chadd static uint16_t wpi_get_active_dwell_time(struct wpi_softc *, 224692ad7caSAdrian Chadd struct ieee80211_channel *, uint8_t); 225692ad7caSAdrian Chadd static uint16_t wpi_limit_dwell(struct wpi_softc *, uint16_t); 226692ad7caSAdrian Chadd static uint16_t wpi_get_passive_dwell_time(struct wpi_softc *, 227692ad7caSAdrian Chadd struct ieee80211_channel *); 228692ad7caSAdrian Chadd static int wpi_scan(struct wpi_softc *, struct ieee80211_channel *); 229692ad7caSAdrian Chadd static int wpi_auth(struct wpi_softc *, struct ieee80211vap *); 2306f8421f8SAdrian Chadd static int wpi_config_beacon(struct wpi_vap *); 231692ad7caSAdrian Chadd static int wpi_setup_beacon(struct wpi_softc *, struct ieee80211_node *); 2326f8421f8SAdrian Chadd static void wpi_update_beacon(struct ieee80211vap *, int); 233d138d3baSAdrian Chadd static void wpi_newassoc(struct ieee80211_node *, int); 234692ad7caSAdrian Chadd static int wpi_run(struct wpi_softc *, struct ieee80211vap *); 235692ad7caSAdrian Chadd static int wpi_key_alloc(struct ieee80211vap *, struct ieee80211_key *, 236692ad7caSAdrian Chadd ieee80211_keyix *, ieee80211_keyix *); 237692ad7caSAdrian Chadd static int wpi_key_set(struct ieee80211vap *, 238692ad7caSAdrian Chadd const struct ieee80211_key *, 239692ad7caSAdrian Chadd const uint8_t mac[IEEE80211_ADDR_LEN]); 240692ad7caSAdrian Chadd static int wpi_key_delete(struct ieee80211vap *, 241692ad7caSAdrian Chadd const struct ieee80211_key *); 242692ad7caSAdrian Chadd static int wpi_post_alive(struct wpi_softc *); 243692ad7caSAdrian Chadd static int wpi_load_bootcode(struct wpi_softc *, const uint8_t *, int); 244692ad7caSAdrian Chadd static int wpi_load_firmware(struct wpi_softc *); 245692ad7caSAdrian Chadd static int wpi_read_firmware(struct wpi_softc *); 246692ad7caSAdrian Chadd static void wpi_unload_firmware(struct wpi_softc *); 247692ad7caSAdrian Chadd static int wpi_clock_wait(struct wpi_softc *); 248692ad7caSAdrian Chadd static int wpi_apm_init(struct wpi_softc *); 249692ad7caSAdrian Chadd static void wpi_apm_stop_master(struct wpi_softc *); 250692ad7caSAdrian Chadd static void wpi_apm_stop(struct wpi_softc *); 251692ad7caSAdrian Chadd static void wpi_nic_config(struct wpi_softc *); 252692ad7caSAdrian Chadd static int wpi_hw_init(struct wpi_softc *); 253692ad7caSAdrian Chadd static void wpi_hw_stop(struct wpi_softc *); 254692ad7caSAdrian Chadd static void wpi_radio_on(void *, int); 255692ad7caSAdrian Chadd static void wpi_radio_off(void *, int); 256692ad7caSAdrian Chadd static void wpi_init_locked(struct wpi_softc *); 257692ad7caSAdrian Chadd static void wpi_init(void *); 258692ad7caSAdrian Chadd static void wpi_stop_locked(struct wpi_softc *); 259692ad7caSAdrian Chadd static void wpi_stop(struct wpi_softc *); 2606607310bSBenjamin Close static void wpi_scan_start(struct ieee80211com *); 2616607310bSBenjamin Close static void wpi_scan_end(struct ieee80211com *); 2626607310bSBenjamin Close static void wpi_set_channel(struct ieee80211com *); 263b032f27cSSam Leffler static void wpi_scan_curchan(struct ieee80211_scan_state *, unsigned long); 264b032f27cSSam Leffler static void wpi_scan_mindwell(struct ieee80211_scan_state *); 265692ad7caSAdrian Chadd static void wpi_hw_reset(void *, int); 2666607310bSBenjamin Close 2676607310bSBenjamin Close static device_method_t wpi_methods[] = { 2686607310bSBenjamin Close /* Device interface */ 2696607310bSBenjamin Close DEVMETHOD(device_probe, wpi_probe), 2706607310bSBenjamin Close DEVMETHOD(device_attach, wpi_attach), 2716607310bSBenjamin Close DEVMETHOD(device_detach, wpi_detach), 2726607310bSBenjamin Close DEVMETHOD(device_shutdown, wpi_shutdown), 2736607310bSBenjamin Close DEVMETHOD(device_suspend, wpi_suspend), 2746607310bSBenjamin Close DEVMETHOD(device_resume, wpi_resume), 2756607310bSBenjamin Close 276da67681dSMarius Strobl DEVMETHOD_END 2776607310bSBenjamin Close }; 2786607310bSBenjamin Close 2796607310bSBenjamin Close static driver_t wpi_driver = { 2806607310bSBenjamin Close "wpi", 2816607310bSBenjamin Close wpi_methods, 2826607310bSBenjamin Close sizeof (struct wpi_softc) 2836607310bSBenjamin Close }; 2846607310bSBenjamin Close static devclass_t wpi_devclass; 2856607310bSBenjamin Close 286da67681dSMarius Strobl DRIVER_MODULE(wpi, pci, wpi_driver, wpi_devclass, NULL, NULL); 2876607310bSBenjamin Close 288129145a4SBernhard Schmidt MODULE_VERSION(wpi, 1); 289129145a4SBernhard Schmidt 290692ad7caSAdrian Chadd MODULE_DEPEND(wpi, pci, 1, 1, 1); 291692ad7caSAdrian Chadd MODULE_DEPEND(wpi, wlan, 1, 1, 1); 292692ad7caSAdrian Chadd MODULE_DEPEND(wpi, firmware, 1, 1, 1); 2936607310bSBenjamin Close 2946607310bSBenjamin Close static int 2956607310bSBenjamin Close wpi_probe(device_t dev) 2966607310bSBenjamin Close { 2976607310bSBenjamin Close const struct wpi_ident *ident; 2986607310bSBenjamin Close 2996607310bSBenjamin Close for (ident = wpi_ident_table; ident->name != NULL; ident++) { 3006607310bSBenjamin Close if (pci_get_vendor(dev) == ident->vendor && 3016607310bSBenjamin Close pci_get_device(dev) == ident->device) { 3026607310bSBenjamin Close device_set_desc(dev, ident->name); 303da67681dSMarius Strobl return (BUS_PROBE_DEFAULT); 3046607310bSBenjamin Close } 3056607310bSBenjamin Close } 3066607310bSBenjamin Close return ENXIO; 3076607310bSBenjamin Close } 3086607310bSBenjamin Close 3096607310bSBenjamin Close static int 3106607310bSBenjamin Close wpi_attach(device_t dev) 3116607310bSBenjamin Close { 312692ad7caSAdrian Chadd struct wpi_softc *sc = (struct wpi_softc *)device_get_softc(dev); 313b032f27cSSam Leffler struct ieee80211com *ic; 314692ad7caSAdrian Chadd struct ifnet *ifp; 315cb0de40fSAdrian Chadd int i, error, rid; 316cb0de40fSAdrian Chadd #ifdef WPI_DEBUG 317cb0de40fSAdrian Chadd int supportsa = 1; 3186607310bSBenjamin Close const struct wpi_ident *ident; 319cb0de40fSAdrian Chadd #endif 32029aca940SSam Leffler uint8_t macaddr[IEEE80211_ADDR_LEN]; 3216607310bSBenjamin Close 3226607310bSBenjamin Close sc->sc_dev = dev; 3236607310bSBenjamin Close 324692ad7caSAdrian Chadd #ifdef WPI_DEBUG 325692ad7caSAdrian Chadd error = resource_int_value(device_get_name(sc->sc_dev), 326692ad7caSAdrian Chadd device_get_unit(sc->sc_dev), "debug", &(sc->sc_debug)); 327692ad7caSAdrian Chadd if (error != 0) 328692ad7caSAdrian Chadd sc->sc_debug = 0; 329692ad7caSAdrian Chadd #else 330692ad7caSAdrian Chadd sc->sc_debug = 0; 331692ad7caSAdrian Chadd #endif 332692ad7caSAdrian Chadd 333692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 334692ad7caSAdrian Chadd 335692ad7caSAdrian Chadd /* 336692ad7caSAdrian Chadd * Get the offset of the PCI Express Capability Structure in PCI 337692ad7caSAdrian Chadd * Configuration Space. 338692ad7caSAdrian Chadd */ 339692ad7caSAdrian Chadd error = pci_find_cap(dev, PCIY_EXPRESS, &sc->sc_cap_off); 340692ad7caSAdrian Chadd if (error != 0) { 341692ad7caSAdrian Chadd device_printf(dev, "PCIe capability structure not found!\n"); 342692ad7caSAdrian Chadd return error; 343692ad7caSAdrian Chadd } 3446607310bSBenjamin Close 3456607310bSBenjamin Close /* 3466607310bSBenjamin Close * Some card's only support 802.11b/g not a, check to see if 3476607310bSBenjamin Close * this is one such card. A 0x0 in the subdevice table indicates 3486607310bSBenjamin Close * the entire subdevice range is to be ignored. 3496607310bSBenjamin Close */ 350cb0de40fSAdrian Chadd #ifdef WPI_DEBUG 3516607310bSBenjamin Close for (ident = wpi_ident_table; ident->name != NULL; ident++) { 3526607310bSBenjamin Close if (ident->subdevice && 3536607310bSBenjamin Close pci_get_subdevice(dev) == ident->subdevice) { 3546607310bSBenjamin Close supportsa = 0; 3556607310bSBenjamin Close break; 3566607310bSBenjamin Close } 3576607310bSBenjamin Close } 358cb0de40fSAdrian Chadd #endif 3596607310bSBenjamin Close 360692ad7caSAdrian Chadd /* Clear device-specific "PCI retry timeout" register (41h). */ 3616607310bSBenjamin Close pci_write_config(dev, 0x41, 0, 1); 3626607310bSBenjamin Close 363692ad7caSAdrian Chadd /* Enable bus-mastering. */ 3646607310bSBenjamin Close pci_enable_busmaster(dev); 3656607310bSBenjamin Close 366da67681dSMarius Strobl rid = PCIR_BAR(0); 367da67681dSMarius Strobl sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 3686607310bSBenjamin Close RF_ACTIVE); 3696607310bSBenjamin Close if (sc->mem == NULL) { 370692ad7caSAdrian Chadd device_printf(dev, "can't map mem space\n"); 3716607310bSBenjamin Close error = ENOMEM; 372692ad7caSAdrian Chadd return error; 3736607310bSBenjamin Close } 3746607310bSBenjamin Close sc->sc_st = rman_get_bustag(sc->mem); 3756607310bSBenjamin Close sc->sc_sh = rman_get_bushandle(sc->mem); 3766607310bSBenjamin Close 377692ad7caSAdrian Chadd i = 1; 378da67681dSMarius Strobl rid = 0; 379692ad7caSAdrian Chadd if (pci_alloc_msi(dev, &i) == 0) 380692ad7caSAdrian Chadd rid = 1; 381692ad7caSAdrian Chadd /* Install interrupt handler. */ 382692ad7caSAdrian Chadd sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | 383692ad7caSAdrian Chadd (rid != 0 ? 0 : RF_SHAREABLE)); 3846607310bSBenjamin Close if (sc->irq == NULL) { 385692ad7caSAdrian Chadd device_printf(dev, "can't map interrupt\n"); 3866607310bSBenjamin Close error = ENOMEM; 3876607310bSBenjamin Close goto fail; 3886607310bSBenjamin Close } 3896607310bSBenjamin Close 390692ad7caSAdrian Chadd WPI_LOCK_INIT(sc); 3917964dd56SAdrian Chadd WPI_NT_LOCK_INIT(sc); 39263f57699SAdrian Chadd WPI_TXQ_LOCK_INIT(sc); 393692ad7caSAdrian Chadd 394692ad7caSAdrian Chadd /* Allocate DMA memory for firmware transfers. */ 3956607310bSBenjamin Close if ((error = wpi_alloc_fwmem(sc)) != 0) { 396692ad7caSAdrian Chadd device_printf(dev, 397692ad7caSAdrian Chadd "could not allocate memory for firmware, error %d\n", 398692ad7caSAdrian Chadd error); 3996607310bSBenjamin Close goto fail; 4006607310bSBenjamin Close } 4016607310bSBenjamin Close 402692ad7caSAdrian Chadd /* Allocate shared page. */ 4036607310bSBenjamin Close if ((error = wpi_alloc_shared(sc)) != 0) { 4046607310bSBenjamin Close device_printf(dev, "could not allocate shared page\n"); 4056607310bSBenjamin Close goto fail; 4066607310bSBenjamin Close } 4076607310bSBenjamin Close 408692ad7caSAdrian Chadd /* Allocate TX rings - 4 for QoS purposes, 1 for commands. */ 409692ad7caSAdrian Chadd for (i = 0; i < WPI_NTXQUEUES; i++) { 410692ad7caSAdrian Chadd if ((error = wpi_alloc_tx_ring(sc, &sc->txq[i], i)) != 0) { 411692ad7caSAdrian Chadd device_printf(dev, 412692ad7caSAdrian Chadd "could not allocate TX ring %d, error %d\n", i, 413692ad7caSAdrian Chadd error); 4146607310bSBenjamin Close goto fail; 4156607310bSBenjamin Close } 4166607310bSBenjamin Close } 4176607310bSBenjamin Close 418692ad7caSAdrian Chadd /* Allocate RX ring. */ 419692ad7caSAdrian Chadd if ((error = wpi_alloc_rx_ring(sc)) != 0) { 420692ad7caSAdrian Chadd device_printf(dev, "could not allocate RX ring, error %d\n", 421692ad7caSAdrian Chadd error); 4226607310bSBenjamin Close goto fail; 4236607310bSBenjamin Close } 4246607310bSBenjamin Close 425692ad7caSAdrian Chadd /* Clear pending interrupts. */ 426692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 4276607310bSBenjamin Close 428b032f27cSSam Leffler ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211); 4296607310bSBenjamin Close if (ifp == NULL) { 430692ad7caSAdrian Chadd device_printf(dev, "can not allocate ifnet structure\n"); 4316607310bSBenjamin Close goto fail; 4326607310bSBenjamin Close } 4336607310bSBenjamin Close 434692ad7caSAdrian Chadd ic = ifp->if_l2com; 4356607310bSBenjamin Close ic->ic_ifp = ifp; 4366607310bSBenjamin Close ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 4376607310bSBenjamin Close ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ 4386607310bSBenjamin Close 439692ad7caSAdrian Chadd /* Set device capabilities. */ 4406607310bSBenjamin Close ic->ic_caps = 441c43feedeSSam Leffler IEEE80211_C_STA /* station mode supported */ 442692ad7caSAdrian Chadd | IEEE80211_C_IBSS /* IBSS mode supported */ 443c43feedeSSam Leffler | IEEE80211_C_MONITOR /* monitor mode supported */ 444692ad7caSAdrian Chadd | IEEE80211_C_AHDEMO /* adhoc demo mode */ 445692ad7caSAdrian Chadd | IEEE80211_C_BGSCAN /* capable of bg scanning */ 4466607310bSBenjamin Close | IEEE80211_C_TXPMGT /* tx power management */ 4476607310bSBenjamin Close | IEEE80211_C_SHSLOT /* short slot time supported */ 4486607310bSBenjamin Close | IEEE80211_C_WPA /* 802.11i */ 449692ad7caSAdrian Chadd | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 4506607310bSBenjamin Close #if 0 4516607310bSBenjamin Close | IEEE80211_C_HOSTAP /* Host access point mode */ 4526607310bSBenjamin Close #endif 453692ad7caSAdrian Chadd | IEEE80211_C_WME /* 802.11e */ 454692ad7caSAdrian Chadd | IEEE80211_C_PMGT /* Station-side power mgmt */ 4556607310bSBenjamin Close ; 4566607310bSBenjamin Close 457692ad7caSAdrian Chadd ic->ic_cryptocaps = 458692ad7caSAdrian Chadd IEEE80211_CRYPTO_AES_CCM; 459692ad7caSAdrian Chadd 4606607310bSBenjamin Close /* 4616607310bSBenjamin Close * Read in the eeprom and also setup the channels for 4626607310bSBenjamin Close * net80211. We don't set the rates as net80211 does this for us 4636607310bSBenjamin Close */ 464692ad7caSAdrian Chadd if ((error = wpi_read_eeprom(sc, macaddr)) != 0) { 465692ad7caSAdrian Chadd device_printf(dev, "could not read EEPROM, error %d\n", 466692ad7caSAdrian Chadd error); 467692ad7caSAdrian Chadd goto fail; 468692ad7caSAdrian Chadd } 4696607310bSBenjamin Close 470692ad7caSAdrian Chadd #ifdef WPI_DEBUG 471692ad7caSAdrian Chadd if (bootverbose) { 472bb086d4eSAdrian Chadd device_printf(sc->sc_dev, "Regulatory Domain: %.4s\n", 473bb086d4eSAdrian Chadd sc->domain); 4746607310bSBenjamin Close device_printf(sc->sc_dev, "Hardware Type: %c\n", 4756607310bSBenjamin Close sc->type > 1 ? 'B': '?'); 4766607310bSBenjamin Close device_printf(sc->sc_dev, "Hardware Revision: %c\n", 477f736d898SAdrian Chadd ((sc->rev & 0xf0) == 0xd0) ? 'D': '?'); 4786607310bSBenjamin Close device_printf(sc->sc_dev, "SKU %s support 802.11a\n", 4796607310bSBenjamin Close supportsa ? "does" : "does not"); 4806607310bSBenjamin Close 481bb086d4eSAdrian Chadd /* XXX hw_config uses the PCIDEV for the Hardware rev. Must 482bb086d4eSAdrian Chadd check what sc->rev really represents - benjsc 20070615 */ 4836607310bSBenjamin Close } 484692ad7caSAdrian Chadd #endif 4856607310bSBenjamin Close 4866607310bSBenjamin Close if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 4876607310bSBenjamin Close ifp->if_softc = sc; 4886607310bSBenjamin Close ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 4896607310bSBenjamin Close ifp->if_init = wpi_init; 4906607310bSBenjamin Close ifp->if_ioctl = wpi_ioctl; 4916607310bSBenjamin Close ifp->if_start = wpi_start; 492e50d35e6SMaxim Sobolev IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 493e50d35e6SMaxim Sobolev ifp->if_snd.ifq_drv_maxlen = ifqmaxlen; 4946607310bSBenjamin Close IFQ_SET_READY(&ifp->if_snd); 4956607310bSBenjamin Close 49629aca940SSam Leffler ieee80211_ifattach(ic, macaddr); 497692ad7caSAdrian Chadd ic->ic_vap_create = wpi_vap_create; 498692ad7caSAdrian Chadd ic->ic_vap_delete = wpi_vap_delete; 499b032f27cSSam Leffler ic->ic_raw_xmit = wpi_raw_xmit; 500692ad7caSAdrian Chadd ic->ic_node_alloc = wpi_node_alloc; 501692ad7caSAdrian Chadd sc->sc_node_free = ic->ic_node_free; 502692ad7caSAdrian Chadd ic->ic_node_free = wpi_node_free; 503692ad7caSAdrian Chadd ic->ic_wme.wme_update = wpi_updateedca; 504692ad7caSAdrian Chadd ic->ic_update_promisc = wpi_update_promisc; 505692ad7caSAdrian Chadd ic->ic_update_mcast = wpi_update_mcast; 506d138d3baSAdrian Chadd ic->ic_newassoc = wpi_newassoc; 5076607310bSBenjamin Close ic->ic_scan_start = wpi_scan_start; 5086607310bSBenjamin Close ic->ic_scan_end = wpi_scan_end; 5096607310bSBenjamin Close ic->ic_set_channel = wpi_set_channel; 510692ad7caSAdrian Chadd sc->sc_scan_curchan = ic->ic_scan_curchan; 5116607310bSBenjamin Close ic->ic_scan_curchan = wpi_scan_curchan; 5126607310bSBenjamin Close ic->ic_scan_mindwell = wpi_scan_mindwell; 513692ad7caSAdrian Chadd ic->ic_setregdomain = wpi_setregdomain; 5146607310bSBenjamin Close 515692ad7caSAdrian Chadd wpi_radiotap_attach(sc); 5166607310bSBenjamin Close 517692ad7caSAdrian Chadd callout_init_mtx(&sc->calib_to, &sc->sc_mtx, 0); 518692ad7caSAdrian Chadd callout_init_mtx(&sc->watchdog_to, &sc->sc_mtx, 0); 519692ad7caSAdrian Chadd callout_init_mtx(&sc->watchdog_rfkill, &sc->sc_mtx, 0); 520692ad7caSAdrian Chadd TASK_INIT(&sc->sc_reinittask, 0, wpi_hw_reset, sc); 521692ad7caSAdrian Chadd TASK_INIT(&sc->sc_radiooff_task, 0, wpi_radio_off, sc); 522692ad7caSAdrian Chadd TASK_INIT(&sc->sc_radioon_task, 0, wpi_radio_on, sc); 5234eaf2ee3SAdrian Chadd TASK_INIT(&sc->sc_start_task, 0, wpi_start_task, sc); 524692ad7caSAdrian Chadd 525692ad7caSAdrian Chadd wpi_sysctlattach(sc); 5266607310bSBenjamin Close 5276607310bSBenjamin Close /* 5286607310bSBenjamin Close * Hook our interrupt after all initialization is complete. 5296607310bSBenjamin Close */ 5306607310bSBenjamin Close error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, 53182f1b132SAndrew Thompson NULL, wpi_intr, sc, &sc->sc_ih); 5326607310bSBenjamin Close if (error != 0) { 533692ad7caSAdrian Chadd device_printf(dev, "can't establish interrupt, error %d\n", 534692ad7caSAdrian Chadd error); 5356607310bSBenjamin Close goto fail; 5366607310bSBenjamin Close } 5376607310bSBenjamin Close 53882f1b132SAndrew Thompson if (bootverbose) 5396607310bSBenjamin Close ieee80211_announce(ic); 540692ad7caSAdrian Chadd 541692ad7caSAdrian Chadd #ifdef WPI_DEBUG 542692ad7caSAdrian Chadd if (sc->sc_debug & WPI_DEBUG_HW) 5436607310bSBenjamin Close ieee80211_announce_channels(ic); 5446607310bSBenjamin Close #endif 545692ad7caSAdrian Chadd 546692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5476607310bSBenjamin Close return 0; 5486607310bSBenjamin Close 5496607310bSBenjamin Close fail: wpi_detach(dev); 550692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 551692ad7caSAdrian Chadd return error; 5526607310bSBenjamin Close } 5536607310bSBenjamin Close 554692ad7caSAdrian Chadd /* 555692ad7caSAdrian Chadd * Attach the interface to 802.11 radiotap. 556692ad7caSAdrian Chadd */ 557692ad7caSAdrian Chadd static void 558692ad7caSAdrian Chadd wpi_radiotap_attach(struct wpi_softc *sc) 5596607310bSBenjamin Close { 560b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 561692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 562692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 563692ad7caSAdrian Chadd ieee80211_radiotap_attach(ic, 564692ad7caSAdrian Chadd &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap), 565692ad7caSAdrian Chadd WPI_TX_RADIOTAP_PRESENT, 566692ad7caSAdrian Chadd &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), 567692ad7caSAdrian Chadd WPI_RX_RADIOTAP_PRESENT); 568692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5696607310bSBenjamin Close } 5706607310bSBenjamin Close 571692ad7caSAdrian Chadd static void 572692ad7caSAdrian Chadd wpi_sysctlattach(struct wpi_softc *sc) 573692ad7caSAdrian Chadd { 574692ad7caSAdrian Chadd #ifdef WPI_DEBUG 575692ad7caSAdrian Chadd struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 576692ad7caSAdrian Chadd struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 5776607310bSBenjamin Close 578692ad7caSAdrian Chadd SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 579692ad7caSAdrian Chadd "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug, 580692ad7caSAdrian Chadd "control debugging printfs"); 581692ad7caSAdrian Chadd #endif 5826607310bSBenjamin Close } 5836607310bSBenjamin Close 58421f6580eSAdrian Chadd static void 58521f6580eSAdrian Chadd wpi_init_beacon(struct wpi_vap *wvp) 58621f6580eSAdrian Chadd { 58721f6580eSAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 58821f6580eSAdrian Chadd struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; 58921f6580eSAdrian Chadd 59021f6580eSAdrian Chadd cmd->id = WPI_ID_BROADCAST; 59121f6580eSAdrian Chadd cmd->ofdm_mask = 0xff; 59221f6580eSAdrian Chadd cmd->cck_mask = 0x0f; 59321f6580eSAdrian Chadd cmd->lifetime = htole32(WPI_LIFETIME_INFINITE); 59421f6580eSAdrian Chadd cmd->flags = htole32(WPI_TX_AUTO_SEQ | WPI_TX_INSERT_TSTAMP); 59521f6580eSAdrian Chadd 59621f6580eSAdrian Chadd bcn->code = WPI_CMD_SET_BEACON; 59721f6580eSAdrian Chadd bcn->ac = WPI_CMD_QUEUE_NUM; 59821f6580eSAdrian Chadd bcn->size = sizeof(struct wpi_cmd_beacon); 59921f6580eSAdrian Chadd } 60021f6580eSAdrian Chadd 601b032f27cSSam Leffler static struct ieee80211vap * 602fcd9500fSBernhard Schmidt wpi_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, 603fcd9500fSBernhard Schmidt enum ieee80211_opmode opmode, int flags, 604b032f27cSSam Leffler const uint8_t bssid[IEEE80211_ADDR_LEN], 605b032f27cSSam Leffler const uint8_t mac[IEEE80211_ADDR_LEN]) 606b032f27cSSam Leffler { 607b032f27cSSam Leffler struct wpi_vap *wvp; 608b032f27cSSam Leffler struct ieee80211vap *vap; 609b032f27cSSam Leffler 610b032f27cSSam Leffler if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 611b032f27cSSam Leffler return NULL; 612692ad7caSAdrian Chadd 613b032f27cSSam Leffler wvp = (struct wpi_vap *) malloc(sizeof(struct wpi_vap), 614b032f27cSSam Leffler M_80211_VAP, M_NOWAIT | M_ZERO); 615b032f27cSSam Leffler if (wvp == NULL) 616b032f27cSSam Leffler return NULL; 617d036bb20SAdrian Chadd vap = &wvp->wv_vap; 618b032f27cSSam Leffler ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac); 619692ad7caSAdrian Chadd 620b56fed3dSAdrian Chadd if (opmode == IEEE80211_M_IBSS) { 621b56fed3dSAdrian Chadd WPI_VAP_LOCK_INIT(wvp); 62221f6580eSAdrian Chadd wpi_init_beacon(wvp); 623b56fed3dSAdrian Chadd } 62421f6580eSAdrian Chadd 625692ad7caSAdrian Chadd /* Override with driver methods. */ 626692ad7caSAdrian Chadd vap->iv_key_alloc = wpi_key_alloc; 627692ad7caSAdrian Chadd vap->iv_key_set = wpi_key_set; 628692ad7caSAdrian Chadd vap->iv_key_delete = wpi_key_delete; 629d036bb20SAdrian Chadd wvp->wv_newstate = vap->iv_newstate; 630b032f27cSSam Leffler vap->iv_newstate = wpi_newstate; 631692ad7caSAdrian Chadd vap->iv_update_beacon = wpi_update_beacon; 632b032f27cSSam Leffler 633b6108616SRui Paulo ieee80211_ratectl_init(vap); 634692ad7caSAdrian Chadd /* Complete setup. */ 6357167f5fcSAdrian Chadd ieee80211_vap_attach(vap, ieee80211_media_change, 6367167f5fcSAdrian Chadd ieee80211_media_status); 637b032f27cSSam Leffler ic->ic_opmode = opmode; 638b032f27cSSam Leffler return vap; 639b032f27cSSam Leffler } 640b032f27cSSam Leffler 641b032f27cSSam Leffler static void 642b032f27cSSam Leffler wpi_vap_delete(struct ieee80211vap *vap) 643b032f27cSSam Leffler { 644b032f27cSSam Leffler struct wpi_vap *wvp = WPI_VAP(vap); 6456f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 6466f8421f8SAdrian Chadd enum ieee80211_opmode opmode = vap->iv_opmode; 647b032f27cSSam Leffler 648b6108616SRui Paulo ieee80211_ratectl_deinit(vap); 649b032f27cSSam Leffler ieee80211_vap_detach(vap); 650692ad7caSAdrian Chadd 6516f8421f8SAdrian Chadd if (opmode == IEEE80211_M_IBSS) { 6526f8421f8SAdrian Chadd if (bcn->m != NULL) 6536f8421f8SAdrian Chadd m_freem(bcn->m); 654b56fed3dSAdrian Chadd 655b56fed3dSAdrian Chadd WPI_VAP_LOCK_DESTROY(wvp); 6566f8421f8SAdrian Chadd } 6576f8421f8SAdrian Chadd 658b032f27cSSam Leffler free(wvp, M_80211_VAP); 659b032f27cSSam Leffler } 660b032f27cSSam Leffler 6616607310bSBenjamin Close static int 662692ad7caSAdrian Chadd wpi_detach(device_t dev) 6636607310bSBenjamin Close { 664692ad7caSAdrian Chadd struct wpi_softc *sc = device_get_softc(dev); 665692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 666692ad7caSAdrian Chadd struct ieee80211com *ic; 667692ad7caSAdrian Chadd int qid; 6686607310bSBenjamin Close 669692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 6706607310bSBenjamin Close 671692ad7caSAdrian Chadd if (ifp != NULL) { 672692ad7caSAdrian Chadd ic = ifp->if_l2com; 6736607310bSBenjamin Close 674692ad7caSAdrian Chadd ieee80211_draintask(ic, &sc->sc_reinittask); 675692ad7caSAdrian Chadd ieee80211_draintask(ic, &sc->sc_radiooff_task); 6760c66281cSAdrian Chadd ieee80211_draintask(ic, &sc->sc_radioon_task); 6774eaf2ee3SAdrian Chadd ieee80211_draintask(ic, &sc->sc_start_task); 678692ad7caSAdrian Chadd 679692ad7caSAdrian Chadd wpi_stop(sc); 680692ad7caSAdrian Chadd 681692ad7caSAdrian Chadd callout_drain(&sc->watchdog_to); 682692ad7caSAdrian Chadd callout_drain(&sc->watchdog_rfkill); 683692ad7caSAdrian Chadd callout_drain(&sc->calib_to); 684692ad7caSAdrian Chadd ieee80211_ifdetach(ic); 6856607310bSBenjamin Close } 6866607310bSBenjamin Close 687692ad7caSAdrian Chadd /* Uninstall interrupt handler. */ 688692ad7caSAdrian Chadd if (sc->irq != NULL) { 689692ad7caSAdrian Chadd bus_teardown_intr(dev, sc->irq, sc->sc_ih); 690692ad7caSAdrian Chadd bus_release_resource(dev, SYS_RES_IRQ, rman_get_rid(sc->irq), 691692ad7caSAdrian Chadd sc->irq); 692692ad7caSAdrian Chadd pci_release_msi(dev); 69382f1b132SAndrew Thompson } 6946607310bSBenjamin Close 695692ad7caSAdrian Chadd if (sc->txq[0].data_dmat) { 696692ad7caSAdrian Chadd /* Free DMA resources. */ 697692ad7caSAdrian Chadd for (qid = 0; qid < WPI_NTXQUEUES; qid++) 698692ad7caSAdrian Chadd wpi_free_tx_ring(sc, &sc->txq[qid]); 699692ad7caSAdrian Chadd 700692ad7caSAdrian Chadd wpi_free_rx_ring(sc); 701692ad7caSAdrian Chadd wpi_free_shared(sc); 7026607310bSBenjamin Close } 7036607310bSBenjamin Close 704692ad7caSAdrian Chadd if (sc->fw_dma.tag) 705692ad7caSAdrian Chadd wpi_free_fwmem(sc); 7066607310bSBenjamin Close 707692ad7caSAdrian Chadd if (sc->mem != NULL) 708692ad7caSAdrian Chadd bus_release_resource(dev, SYS_RES_MEMORY, 709692ad7caSAdrian Chadd rman_get_rid(sc->mem), sc->mem); 710692ad7caSAdrian Chadd 711692ad7caSAdrian Chadd if (ifp != NULL) 712692ad7caSAdrian Chadd if_free(ifp); 713692ad7caSAdrian Chadd 714692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 71563f57699SAdrian Chadd WPI_TXQ_LOCK_DESTROY(sc); 7167964dd56SAdrian Chadd WPI_NT_LOCK_DESTROY(sc); 717692ad7caSAdrian Chadd WPI_LOCK_DESTROY(sc); 7186607310bSBenjamin Close return 0; 7196607310bSBenjamin Close } 7206607310bSBenjamin Close 7216607310bSBenjamin Close static int 7226607310bSBenjamin Close wpi_shutdown(device_t dev) 7236607310bSBenjamin Close { 7246607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 7256607310bSBenjamin Close 726692ad7caSAdrian Chadd wpi_stop(sc); 7276607310bSBenjamin Close return 0; 7286607310bSBenjamin Close } 7296607310bSBenjamin Close 7306607310bSBenjamin Close static int 7316607310bSBenjamin Close wpi_suspend(device_t dev) 7326607310bSBenjamin Close { 7336607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 734ada977b1SBernhard Schmidt struct ieee80211com *ic = sc->sc_ifp->if_l2com; 7356607310bSBenjamin Close 736ada977b1SBernhard Schmidt ieee80211_suspend_all(ic); 7376607310bSBenjamin Close return 0; 7386607310bSBenjamin Close } 7396607310bSBenjamin Close 7406607310bSBenjamin Close static int 7416607310bSBenjamin Close wpi_resume(device_t dev) 7426607310bSBenjamin Close { 7436607310bSBenjamin Close struct wpi_softc *sc = device_get_softc(dev); 744ada977b1SBernhard Schmidt struct ieee80211com *ic = sc->sc_ifp->if_l2com; 7456607310bSBenjamin Close 746692ad7caSAdrian Chadd /* Clear device-specific "PCI retry timeout" register (41h). */ 7476607310bSBenjamin Close pci_write_config(dev, 0x41, 0, 1); 7486607310bSBenjamin Close 749ada977b1SBernhard Schmidt ieee80211_resume_all(ic); 7506607310bSBenjamin Close return 0; 7516607310bSBenjamin Close } 7526607310bSBenjamin Close 753692ad7caSAdrian Chadd /* 754692ad7caSAdrian Chadd * Grab exclusive access to NIC memory. 755692ad7caSAdrian Chadd */ 756692ad7caSAdrian Chadd static int 757692ad7caSAdrian Chadd wpi_nic_lock(struct wpi_softc *sc) 758692ad7caSAdrian Chadd { 759692ad7caSAdrian Chadd int ntries; 760692ad7caSAdrian Chadd 761692ad7caSAdrian Chadd /* Request exclusive access to NIC. */ 762692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 763692ad7caSAdrian Chadd 764692ad7caSAdrian Chadd /* Spin until we actually get the lock. */ 765692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 766692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_GP_CNTRL) & 767692ad7caSAdrian Chadd (WPI_GP_CNTRL_MAC_ACCESS_ENA | WPI_GP_CNTRL_SLEEP)) == 768692ad7caSAdrian Chadd WPI_GP_CNTRL_MAC_ACCESS_ENA) 769692ad7caSAdrian Chadd return 0; 770692ad7caSAdrian Chadd DELAY(10); 771692ad7caSAdrian Chadd } 772692ad7caSAdrian Chadd 773692ad7caSAdrian Chadd device_printf(sc->sc_dev, "could not lock memory\n"); 774692ad7caSAdrian Chadd 775692ad7caSAdrian Chadd return ETIMEDOUT; 776692ad7caSAdrian Chadd } 777692ad7caSAdrian Chadd 778692ad7caSAdrian Chadd /* 779692ad7caSAdrian Chadd * Release lock on NIC memory. 780692ad7caSAdrian Chadd */ 781692ad7caSAdrian Chadd static __inline void 782692ad7caSAdrian Chadd wpi_nic_unlock(struct wpi_softc *sc) 783692ad7caSAdrian Chadd { 784692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 785692ad7caSAdrian Chadd } 786692ad7caSAdrian Chadd 787692ad7caSAdrian Chadd static __inline uint32_t 788692ad7caSAdrian Chadd wpi_prph_read(struct wpi_softc *sc, uint32_t addr) 789692ad7caSAdrian Chadd { 790692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_RADDR, WPI_PRPH_DWORD | addr); 791692ad7caSAdrian Chadd WPI_BARRIER_READ_WRITE(sc); 792692ad7caSAdrian Chadd return WPI_READ(sc, WPI_PRPH_RDATA); 793692ad7caSAdrian Chadd } 794692ad7caSAdrian Chadd 795692ad7caSAdrian Chadd static __inline void 796692ad7caSAdrian Chadd wpi_prph_write(struct wpi_softc *sc, uint32_t addr, uint32_t data) 797692ad7caSAdrian Chadd { 798692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_WADDR, WPI_PRPH_DWORD | addr); 799692ad7caSAdrian Chadd WPI_BARRIER_WRITE(sc); 800692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_PRPH_WDATA, data); 801692ad7caSAdrian Chadd } 802692ad7caSAdrian Chadd 803692ad7caSAdrian Chadd static __inline void 804692ad7caSAdrian Chadd wpi_prph_setbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) 805692ad7caSAdrian Chadd { 806692ad7caSAdrian Chadd wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) | mask); 807692ad7caSAdrian Chadd } 808692ad7caSAdrian Chadd 809692ad7caSAdrian Chadd static __inline void 810692ad7caSAdrian Chadd wpi_prph_clrbits(struct wpi_softc *sc, uint32_t addr, uint32_t mask) 811692ad7caSAdrian Chadd { 812692ad7caSAdrian Chadd wpi_prph_write(sc, addr, wpi_prph_read(sc, addr) & ~mask); 813692ad7caSAdrian Chadd } 814692ad7caSAdrian Chadd 815692ad7caSAdrian Chadd static __inline void 816692ad7caSAdrian Chadd wpi_prph_write_region_4(struct wpi_softc *sc, uint32_t addr, 817692ad7caSAdrian Chadd const uint32_t *data, int count) 818692ad7caSAdrian Chadd { 819692ad7caSAdrian Chadd for (; count > 0; count--, data++, addr += 4) 820692ad7caSAdrian Chadd wpi_prph_write(sc, addr, *data); 821692ad7caSAdrian Chadd } 822692ad7caSAdrian Chadd 823692ad7caSAdrian Chadd static __inline uint32_t 824692ad7caSAdrian Chadd wpi_mem_read(struct wpi_softc *sc, uint32_t addr) 825692ad7caSAdrian Chadd { 826692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_MEM_RADDR, addr); 827692ad7caSAdrian Chadd WPI_BARRIER_READ_WRITE(sc); 828692ad7caSAdrian Chadd return WPI_READ(sc, WPI_MEM_RDATA); 829692ad7caSAdrian Chadd } 830692ad7caSAdrian Chadd 831692ad7caSAdrian Chadd static __inline void 832692ad7caSAdrian Chadd wpi_mem_read_region_4(struct wpi_softc *sc, uint32_t addr, uint32_t *data, 833692ad7caSAdrian Chadd int count) 834692ad7caSAdrian Chadd { 835692ad7caSAdrian Chadd for (; count > 0; count--, addr += 4) 836692ad7caSAdrian Chadd *data++ = wpi_mem_read(sc, addr); 837692ad7caSAdrian Chadd } 838692ad7caSAdrian Chadd 839692ad7caSAdrian Chadd static int 840692ad7caSAdrian Chadd wpi_read_prom_data(struct wpi_softc *sc, uint32_t addr, void *data, int count) 841692ad7caSAdrian Chadd { 842692ad7caSAdrian Chadd uint8_t *out = data; 843692ad7caSAdrian Chadd uint32_t val; 844692ad7caSAdrian Chadd int error, ntries; 845692ad7caSAdrian Chadd 846692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 847692ad7caSAdrian Chadd 848692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 849692ad7caSAdrian Chadd return error; 850692ad7caSAdrian Chadd 851692ad7caSAdrian Chadd for (; count > 0; count -= 2, addr++) { 852692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_EEPROM, addr << 2); 853692ad7caSAdrian Chadd for (ntries = 0; ntries < 10; ntries++) { 854692ad7caSAdrian Chadd val = WPI_READ(sc, WPI_EEPROM); 855692ad7caSAdrian Chadd if (val & WPI_EEPROM_READ_VALID) 856692ad7caSAdrian Chadd break; 857692ad7caSAdrian Chadd DELAY(5); 858692ad7caSAdrian Chadd } 859692ad7caSAdrian Chadd if (ntries == 10) { 860692ad7caSAdrian Chadd device_printf(sc->sc_dev, 861692ad7caSAdrian Chadd "timeout reading ROM at 0x%x\n", addr); 862692ad7caSAdrian Chadd return ETIMEDOUT; 863692ad7caSAdrian Chadd } 864692ad7caSAdrian Chadd *out++= val >> 16; 865692ad7caSAdrian Chadd if (count > 1) 866692ad7caSAdrian Chadd *out ++= val >> 24; 867692ad7caSAdrian Chadd } 868692ad7caSAdrian Chadd 869692ad7caSAdrian Chadd wpi_nic_unlock(sc); 870692ad7caSAdrian Chadd 871692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 872692ad7caSAdrian Chadd 873692ad7caSAdrian Chadd return 0; 874692ad7caSAdrian Chadd } 875692ad7caSAdrian Chadd 876692ad7caSAdrian Chadd static void 877692ad7caSAdrian Chadd wpi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nsegs, int error) 878692ad7caSAdrian Chadd { 879692ad7caSAdrian Chadd if (error != 0) 880692ad7caSAdrian Chadd return; 881692ad7caSAdrian Chadd KASSERT(nsegs == 1, ("too many DMA segments, %d should be 1", nsegs)); 882692ad7caSAdrian Chadd *(bus_addr_t *)arg = segs[0].ds_addr; 883692ad7caSAdrian Chadd } 884692ad7caSAdrian Chadd 885692ad7caSAdrian Chadd /* 886692ad7caSAdrian Chadd * Allocates a contiguous block of dma memory of the requested size and 887692ad7caSAdrian Chadd * alignment. 888692ad7caSAdrian Chadd */ 889692ad7caSAdrian Chadd static int 890692ad7caSAdrian Chadd wpi_dma_contig_alloc(struct wpi_softc *sc, struct wpi_dma_info *dma, 891692ad7caSAdrian Chadd void **kvap, bus_size_t size, bus_size_t alignment) 892692ad7caSAdrian Chadd { 893692ad7caSAdrian Chadd int error; 894692ad7caSAdrian Chadd 895692ad7caSAdrian Chadd dma->tag = NULL; 896692ad7caSAdrian Chadd dma->size = size; 897692ad7caSAdrian Chadd 898692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), alignment, 899692ad7caSAdrian Chadd 0, BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, size, 900692ad7caSAdrian Chadd 1, size, BUS_DMA_NOWAIT, NULL, NULL, &dma->tag); 901692ad7caSAdrian Chadd if (error != 0) 902692ad7caSAdrian Chadd goto fail; 903692ad7caSAdrian Chadd 904692ad7caSAdrian Chadd error = bus_dmamem_alloc(dma->tag, (void **)&dma->vaddr, 905692ad7caSAdrian Chadd BUS_DMA_NOWAIT | BUS_DMA_ZERO | BUS_DMA_COHERENT, &dma->map); 906692ad7caSAdrian Chadd if (error != 0) 907692ad7caSAdrian Chadd goto fail; 908692ad7caSAdrian Chadd 909692ad7caSAdrian Chadd error = bus_dmamap_load(dma->tag, dma->map, dma->vaddr, size, 910692ad7caSAdrian Chadd wpi_dma_map_addr, &dma->paddr, BUS_DMA_NOWAIT); 911692ad7caSAdrian Chadd if (error != 0) 912692ad7caSAdrian Chadd goto fail; 913692ad7caSAdrian Chadd 914692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 915692ad7caSAdrian Chadd 916692ad7caSAdrian Chadd if (kvap != NULL) 917692ad7caSAdrian Chadd *kvap = dma->vaddr; 918692ad7caSAdrian Chadd 919692ad7caSAdrian Chadd return 0; 920692ad7caSAdrian Chadd 921692ad7caSAdrian Chadd fail: wpi_dma_contig_free(dma); 922692ad7caSAdrian Chadd return error; 923692ad7caSAdrian Chadd } 924692ad7caSAdrian Chadd 925692ad7caSAdrian Chadd static void 926692ad7caSAdrian Chadd wpi_dma_contig_free(struct wpi_dma_info *dma) 927692ad7caSAdrian Chadd { 928692ad7caSAdrian Chadd if (dma->vaddr != NULL) { 929692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, 930692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE); 931692ad7caSAdrian Chadd bus_dmamap_unload(dma->tag, dma->map); 932692ad7caSAdrian Chadd bus_dmamem_free(dma->tag, dma->vaddr, dma->map); 933692ad7caSAdrian Chadd dma->vaddr = NULL; 934692ad7caSAdrian Chadd } 935692ad7caSAdrian Chadd if (dma->tag != NULL) { 936692ad7caSAdrian Chadd bus_dma_tag_destroy(dma->tag); 937692ad7caSAdrian Chadd dma->tag = NULL; 938692ad7caSAdrian Chadd } 939692ad7caSAdrian Chadd } 940692ad7caSAdrian Chadd 941692ad7caSAdrian Chadd /* 942692ad7caSAdrian Chadd * Allocate a shared page between host and NIC. 943692ad7caSAdrian Chadd */ 944692ad7caSAdrian Chadd static int 945692ad7caSAdrian Chadd wpi_alloc_shared(struct wpi_softc *sc) 946692ad7caSAdrian Chadd { 947692ad7caSAdrian Chadd /* Shared buffer must be aligned on a 4KB boundary. */ 948692ad7caSAdrian Chadd return wpi_dma_contig_alloc(sc, &sc->shared_dma, 949692ad7caSAdrian Chadd (void **)&sc->shared, sizeof (struct wpi_shared), 4096); 950692ad7caSAdrian Chadd } 951692ad7caSAdrian Chadd 952692ad7caSAdrian Chadd static void 953692ad7caSAdrian Chadd wpi_free_shared(struct wpi_softc *sc) 954692ad7caSAdrian Chadd { 955692ad7caSAdrian Chadd wpi_dma_contig_free(&sc->shared_dma); 956692ad7caSAdrian Chadd } 957692ad7caSAdrian Chadd 958692ad7caSAdrian Chadd /* 959692ad7caSAdrian Chadd * Allocate DMA-safe memory for firmware transfer. 960692ad7caSAdrian Chadd */ 961692ad7caSAdrian Chadd static int 962692ad7caSAdrian Chadd wpi_alloc_fwmem(struct wpi_softc *sc) 963692ad7caSAdrian Chadd { 964692ad7caSAdrian Chadd /* Must be aligned on a 16-byte boundary. */ 965692ad7caSAdrian Chadd return wpi_dma_contig_alloc(sc, &sc->fw_dma, NULL, 966692ad7caSAdrian Chadd WPI_FW_TEXT_MAXSZ + WPI_FW_DATA_MAXSZ, 16); 967692ad7caSAdrian Chadd } 968692ad7caSAdrian Chadd 969692ad7caSAdrian Chadd static void 970692ad7caSAdrian Chadd wpi_free_fwmem(struct wpi_softc *sc) 971692ad7caSAdrian Chadd { 972692ad7caSAdrian Chadd wpi_dma_contig_free(&sc->fw_dma); 973692ad7caSAdrian Chadd } 974692ad7caSAdrian Chadd 975692ad7caSAdrian Chadd static int 976692ad7caSAdrian Chadd wpi_alloc_rx_ring(struct wpi_softc *sc) 977692ad7caSAdrian Chadd { 978692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 979692ad7caSAdrian Chadd bus_size_t size; 980692ad7caSAdrian Chadd int i, error; 981692ad7caSAdrian Chadd 982692ad7caSAdrian Chadd ring->cur = 0; 983692ad7caSAdrian Chadd ring->update = 0; 984692ad7caSAdrian Chadd 985692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 986692ad7caSAdrian Chadd 987692ad7caSAdrian Chadd /* Allocate RX descriptors (16KB aligned.) */ 988692ad7caSAdrian Chadd size = WPI_RX_RING_COUNT * sizeof (uint32_t); 989692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->desc_dma, 990692ad7caSAdrian Chadd (void **)&ring->desc, size, WPI_RING_DMA_ALIGN); 991692ad7caSAdrian Chadd if (error != 0) { 992692ad7caSAdrian Chadd device_printf(sc->sc_dev, 993692ad7caSAdrian Chadd "%s: could not allocate RX ring DMA memory, error %d\n", 994692ad7caSAdrian Chadd __func__, error); 995692ad7caSAdrian Chadd goto fail; 996692ad7caSAdrian Chadd } 997692ad7caSAdrian Chadd 998692ad7caSAdrian Chadd /* Create RX buffer DMA tag. */ 999692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 1000692ad7caSAdrian Chadd BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 1001692ad7caSAdrian Chadd MJUMPAGESIZE, 1, MJUMPAGESIZE, BUS_DMA_NOWAIT, NULL, NULL, 1002692ad7caSAdrian Chadd &ring->data_dmat); 1003692ad7caSAdrian Chadd if (error != 0) { 1004692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1005692ad7caSAdrian Chadd "%s: could not create RX buf DMA tag, error %d\n", 1006692ad7caSAdrian Chadd __func__, error); 1007692ad7caSAdrian Chadd goto fail; 1008692ad7caSAdrian Chadd } 1009692ad7caSAdrian Chadd 1010692ad7caSAdrian Chadd /* 1011692ad7caSAdrian Chadd * Allocate and map RX buffers. 1012692ad7caSAdrian Chadd */ 1013692ad7caSAdrian Chadd for (i = 0; i < WPI_RX_RING_COUNT; i++) { 1014692ad7caSAdrian Chadd struct wpi_rx_data *data = &ring->data[i]; 1015692ad7caSAdrian Chadd bus_addr_t paddr; 1016692ad7caSAdrian Chadd 1017692ad7caSAdrian Chadd error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 1018692ad7caSAdrian Chadd if (error != 0) { 1019692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1020692ad7caSAdrian Chadd "%s: could not create RX buf DMA map, error %d\n", 1021692ad7caSAdrian Chadd __func__, error); 1022692ad7caSAdrian Chadd goto fail; 1023692ad7caSAdrian Chadd } 1024692ad7caSAdrian Chadd 1025692ad7caSAdrian Chadd data->m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 1026692ad7caSAdrian Chadd if (data->m == NULL) { 1027692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1028692ad7caSAdrian Chadd "%s: could not allocate RX mbuf\n", __func__); 1029692ad7caSAdrian Chadd error = ENOBUFS; 1030692ad7caSAdrian Chadd goto fail; 1031692ad7caSAdrian Chadd } 1032692ad7caSAdrian Chadd 1033692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, 1034692ad7caSAdrian Chadd mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, 1035692ad7caSAdrian Chadd &paddr, BUS_DMA_NOWAIT); 1036692ad7caSAdrian Chadd if (error != 0 && error != EFBIG) { 1037692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1038692ad7caSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, 1039692ad7caSAdrian Chadd error); 1040692ad7caSAdrian Chadd goto fail; 1041692ad7caSAdrian Chadd } 1042692ad7caSAdrian Chadd 1043692ad7caSAdrian Chadd /* Set physical address of RX buffer. */ 1044692ad7caSAdrian Chadd ring->desc[i] = htole32(paddr); 1045692ad7caSAdrian Chadd } 1046692ad7caSAdrian Chadd 1047692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1048692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1049692ad7caSAdrian Chadd 1050692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1051692ad7caSAdrian Chadd 1052692ad7caSAdrian Chadd return 0; 1053692ad7caSAdrian Chadd 1054692ad7caSAdrian Chadd fail: wpi_free_rx_ring(sc); 1055692ad7caSAdrian Chadd 1056692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1057692ad7caSAdrian Chadd 1058692ad7caSAdrian Chadd return error; 1059692ad7caSAdrian Chadd } 1060692ad7caSAdrian Chadd 1061692ad7caSAdrian Chadd static void 1062692ad7caSAdrian Chadd wpi_update_rx_ring(struct wpi_softc *sc) 1063692ad7caSAdrian Chadd { 1064692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1065692ad7caSAdrian Chadd 106601729242SAdrian Chadd if (ring->update != 0) { 106701729242SAdrian Chadd /* Wait for INT_WAKEUP event. */ 106801729242SAdrian Chadd return; 106901729242SAdrian Chadd } 107001729242SAdrian Chadd 1071692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) { 1072692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s: wakeup request\n", 1073692ad7caSAdrian Chadd __func__); 1074692ad7caSAdrian Chadd 1075692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 1076692ad7caSAdrian Chadd ring->update = 1; 1077692ad7caSAdrian Chadd } else 1078692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, ring->cur & ~7); 1079692ad7caSAdrian Chadd } 1080692ad7caSAdrian Chadd 1081692ad7caSAdrian Chadd static void 1082692ad7caSAdrian Chadd wpi_reset_rx_ring(struct wpi_softc *sc) 1083692ad7caSAdrian Chadd { 1084692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1085692ad7caSAdrian Chadd int ntries; 1086692ad7caSAdrian Chadd 1087692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1088692ad7caSAdrian Chadd 1089692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 1090692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_CONFIG, 0); 1091692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 1092692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_FH_RX_STATUS) & 1093692ad7caSAdrian Chadd WPI_FH_RX_STATUS_IDLE) 1094692ad7caSAdrian Chadd break; 1095692ad7caSAdrian Chadd DELAY(10); 1096692ad7caSAdrian Chadd } 1097692ad7caSAdrian Chadd #ifdef WPI_DEBUG 1098692ad7caSAdrian Chadd if (ntries == 1000) { 1099692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1100692ad7caSAdrian Chadd "timeout resetting Rx ring\n"); 1101692ad7caSAdrian Chadd } 1102692ad7caSAdrian Chadd #endif 1103692ad7caSAdrian Chadd wpi_nic_unlock(sc); 1104692ad7caSAdrian Chadd } 1105692ad7caSAdrian Chadd 1106692ad7caSAdrian Chadd ring->cur = 0; 1107692ad7caSAdrian Chadd ring->update = 0; 1108692ad7caSAdrian Chadd } 1109692ad7caSAdrian Chadd 1110692ad7caSAdrian Chadd static void 1111692ad7caSAdrian Chadd wpi_free_rx_ring(struct wpi_softc *sc) 1112692ad7caSAdrian Chadd { 1113692ad7caSAdrian Chadd struct wpi_rx_ring *ring = &sc->rxq; 1114692ad7caSAdrian Chadd int i; 1115692ad7caSAdrian Chadd 1116692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1117692ad7caSAdrian Chadd 1118692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->desc_dma); 1119692ad7caSAdrian Chadd 1120692ad7caSAdrian Chadd for (i = 0; i < WPI_RX_RING_COUNT; i++) { 1121692ad7caSAdrian Chadd struct wpi_rx_data *data = &ring->data[i]; 1122692ad7caSAdrian Chadd 1123692ad7caSAdrian Chadd if (data->m != NULL) { 1124692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1125692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 1126692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1127692ad7caSAdrian Chadd m_freem(data->m); 1128692ad7caSAdrian Chadd data->m = NULL; 1129692ad7caSAdrian Chadd } 1130692ad7caSAdrian Chadd if (data->map != NULL) 1131692ad7caSAdrian Chadd bus_dmamap_destroy(ring->data_dmat, data->map); 1132692ad7caSAdrian Chadd } 1133692ad7caSAdrian Chadd if (ring->data_dmat != NULL) { 1134692ad7caSAdrian Chadd bus_dma_tag_destroy(ring->data_dmat); 1135692ad7caSAdrian Chadd ring->data_dmat = NULL; 1136692ad7caSAdrian Chadd } 1137692ad7caSAdrian Chadd } 1138692ad7caSAdrian Chadd 1139692ad7caSAdrian Chadd static int 1140692ad7caSAdrian Chadd wpi_alloc_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring, int qid) 1141692ad7caSAdrian Chadd { 1142692ad7caSAdrian Chadd bus_addr_t paddr; 1143692ad7caSAdrian Chadd bus_size_t size; 1144692ad7caSAdrian Chadd int i, error; 1145692ad7caSAdrian Chadd 1146692ad7caSAdrian Chadd ring->qid = qid; 1147692ad7caSAdrian Chadd ring->queued = 0; 1148692ad7caSAdrian Chadd ring->cur = 0; 1149692ad7caSAdrian Chadd ring->update = 0; 1150692ad7caSAdrian Chadd 1151692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1152692ad7caSAdrian Chadd 1153692ad7caSAdrian Chadd /* Allocate TX descriptors (16KB aligned.) */ 1154692ad7caSAdrian Chadd size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_desc); 1155692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->desc_dma, (void **)&ring->desc, 1156692ad7caSAdrian Chadd size, WPI_RING_DMA_ALIGN); 1157692ad7caSAdrian Chadd if (error != 0) { 1158692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1159692ad7caSAdrian Chadd "%s: could not allocate TX ring DMA memory, error %d\n", 1160692ad7caSAdrian Chadd __func__, error); 1161692ad7caSAdrian Chadd goto fail; 1162692ad7caSAdrian Chadd } 1163692ad7caSAdrian Chadd 1164692ad7caSAdrian Chadd /* Update shared area with ring physical address. */ 1165692ad7caSAdrian Chadd sc->shared->txbase[qid] = htole32(ring->desc_dma.paddr); 1166692ad7caSAdrian Chadd bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, 1167692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1168692ad7caSAdrian Chadd 1169692ad7caSAdrian Chadd /* 1170692ad7caSAdrian Chadd * We only use rings 0 through 4 (4 EDCA + cmd) so there is no need 1171692ad7caSAdrian Chadd * to allocate commands space for other rings. 1172692ad7caSAdrian Chadd * XXX Do we really need to allocate descriptors for other rings? 1173692ad7caSAdrian Chadd */ 11748e4cf38aSAdrian Chadd if (qid > WPI_CMD_QUEUE_NUM) 1175692ad7caSAdrian Chadd return 0; 1176692ad7caSAdrian Chadd 1177692ad7caSAdrian Chadd size = WPI_TX_RING_COUNT * sizeof (struct wpi_tx_cmd); 1178692ad7caSAdrian Chadd error = wpi_dma_contig_alloc(sc, &ring->cmd_dma, (void **)&ring->cmd, 1179692ad7caSAdrian Chadd size, 4); 1180692ad7caSAdrian Chadd if (error != 0) { 1181692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1182692ad7caSAdrian Chadd "%s: could not allocate TX cmd DMA memory, error %d\n", 1183692ad7caSAdrian Chadd __func__, error); 1184692ad7caSAdrian Chadd goto fail; 1185692ad7caSAdrian Chadd } 1186692ad7caSAdrian Chadd 1187692ad7caSAdrian Chadd error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 1188692ad7caSAdrian Chadd BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1189692ad7caSAdrian Chadd WPI_MAX_SCATTER - 1, MCLBYTES, BUS_DMA_NOWAIT, NULL, NULL, 1190692ad7caSAdrian Chadd &ring->data_dmat); 1191692ad7caSAdrian Chadd if (error != 0) { 1192692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1193692ad7caSAdrian Chadd "%s: could not create TX buf DMA tag, error %d\n", 1194692ad7caSAdrian Chadd __func__, error); 1195692ad7caSAdrian Chadd goto fail; 1196692ad7caSAdrian Chadd } 1197692ad7caSAdrian Chadd 1198692ad7caSAdrian Chadd paddr = ring->cmd_dma.paddr; 1199692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1200692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1201692ad7caSAdrian Chadd 1202692ad7caSAdrian Chadd data->cmd_paddr = paddr; 1203692ad7caSAdrian Chadd paddr += sizeof (struct wpi_tx_cmd); 1204692ad7caSAdrian Chadd 1205692ad7caSAdrian Chadd error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 1206692ad7caSAdrian Chadd if (error != 0) { 1207692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1208692ad7caSAdrian Chadd "%s: could not create TX buf DMA map, error %d\n", 1209692ad7caSAdrian Chadd __func__, error); 1210692ad7caSAdrian Chadd goto fail; 1211692ad7caSAdrian Chadd } 1212692ad7caSAdrian Chadd } 1213692ad7caSAdrian Chadd 1214692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1215692ad7caSAdrian Chadd 1216692ad7caSAdrian Chadd return 0; 1217692ad7caSAdrian Chadd 1218692ad7caSAdrian Chadd fail: wpi_free_tx_ring(sc, ring); 1219692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1220692ad7caSAdrian Chadd return error; 1221692ad7caSAdrian Chadd } 1222692ad7caSAdrian Chadd 1223692ad7caSAdrian Chadd static void 1224692ad7caSAdrian Chadd wpi_update_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1225692ad7caSAdrian Chadd { 122601729242SAdrian Chadd if (ring->update != 0) { 122701729242SAdrian Chadd /* Wait for INT_WAKEUP event. */ 122801729242SAdrian Chadd return; 122901729242SAdrian Chadd } 123001729242SAdrian Chadd 1231692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) { 1232692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, "%s (%d): requesting wakeup\n", 1233692ad7caSAdrian Chadd __func__, ring->qid); 1234692ad7caSAdrian Chadd 1235692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 1236692ad7caSAdrian Chadd ring->update = 1; 1237692ad7caSAdrian Chadd } else 1238692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_HBUS_TARG_WRPTR, ring->qid << 8 | ring->cur); 1239692ad7caSAdrian Chadd } 1240692ad7caSAdrian Chadd 1241692ad7caSAdrian Chadd static void 1242692ad7caSAdrian Chadd wpi_reset_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1243692ad7caSAdrian Chadd { 1244692ad7caSAdrian Chadd int i; 1245692ad7caSAdrian Chadd 1246692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1247692ad7caSAdrian Chadd 1248692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1249692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1250692ad7caSAdrian Chadd 1251692ad7caSAdrian Chadd if (data->m != NULL) { 1252692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1253692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 1254692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1255692ad7caSAdrian Chadd m_freem(data->m); 1256692ad7caSAdrian Chadd data->m = NULL; 1257692ad7caSAdrian Chadd } 1258692ad7caSAdrian Chadd } 1259692ad7caSAdrian Chadd /* Clear TX descriptors. */ 1260692ad7caSAdrian Chadd memset(ring->desc, 0, ring->desc_dma.size); 1261692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1262692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1263692ad7caSAdrian Chadd sc->qfullmsk &= ~(1 << ring->qid); 1264692ad7caSAdrian Chadd ring->queued = 0; 1265692ad7caSAdrian Chadd ring->cur = 0; 1266692ad7caSAdrian Chadd ring->update = 0; 1267692ad7caSAdrian Chadd } 1268692ad7caSAdrian Chadd 1269692ad7caSAdrian Chadd static void 1270692ad7caSAdrian Chadd wpi_free_tx_ring(struct wpi_softc *sc, struct wpi_tx_ring *ring) 1271692ad7caSAdrian Chadd { 1272692ad7caSAdrian Chadd int i; 1273692ad7caSAdrian Chadd 1274692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 1275692ad7caSAdrian Chadd 1276692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->desc_dma); 1277692ad7caSAdrian Chadd wpi_dma_contig_free(&ring->cmd_dma); 1278692ad7caSAdrian Chadd 1279692ad7caSAdrian Chadd for (i = 0; i < WPI_TX_RING_COUNT; i++) { 1280692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[i]; 1281692ad7caSAdrian Chadd 1282692ad7caSAdrian Chadd if (data->m != NULL) { 1283692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 1284692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 1285692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1286692ad7caSAdrian Chadd m_freem(data->m); 1287692ad7caSAdrian Chadd } 1288692ad7caSAdrian Chadd if (data->map != NULL) 1289692ad7caSAdrian Chadd bus_dmamap_destroy(ring->data_dmat, data->map); 1290692ad7caSAdrian Chadd } 1291692ad7caSAdrian Chadd if (ring->data_dmat != NULL) { 1292692ad7caSAdrian Chadd bus_dma_tag_destroy(ring->data_dmat); 1293692ad7caSAdrian Chadd ring->data_dmat = NULL; 1294692ad7caSAdrian Chadd } 1295692ad7caSAdrian Chadd } 1296692ad7caSAdrian Chadd 1297692ad7caSAdrian Chadd /* 1298692ad7caSAdrian Chadd * Extract various information from EEPROM. 1299692ad7caSAdrian Chadd */ 1300692ad7caSAdrian Chadd static int 1301692ad7caSAdrian Chadd wpi_read_eeprom(struct wpi_softc *sc, uint8_t macaddr[IEEE80211_ADDR_LEN]) 1302692ad7caSAdrian Chadd { 1303692ad7caSAdrian Chadd #define WPI_CHK(res) do { \ 1304692ad7caSAdrian Chadd if ((error = res) != 0) \ 1305692ad7caSAdrian Chadd goto fail; \ 1306692ad7caSAdrian Chadd } while (0) 1307692ad7caSAdrian Chadd int error, i; 1308692ad7caSAdrian Chadd 1309692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1310692ad7caSAdrian Chadd 1311692ad7caSAdrian Chadd /* Adapter has to be powered on for EEPROM access to work. */ 1312692ad7caSAdrian Chadd if ((error = wpi_apm_init(sc)) != 0) { 1313692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1314692ad7caSAdrian Chadd "%s: could not power ON adapter, error %d\n", __func__, 1315692ad7caSAdrian Chadd error); 1316692ad7caSAdrian Chadd return error; 1317692ad7caSAdrian Chadd } 1318692ad7caSAdrian Chadd 1319692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_EEPROM_GP) & 0x6) == 0) { 1320692ad7caSAdrian Chadd device_printf(sc->sc_dev, "bad EEPROM signature\n"); 1321692ad7caSAdrian Chadd error = EIO; 1322692ad7caSAdrian Chadd goto fail; 1323692ad7caSAdrian Chadd } 1324692ad7caSAdrian Chadd /* Clear HW ownership of EEPROM. */ 1325692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_EEPROM_GP, WPI_EEPROM_GP_IF_OWNER); 1326692ad7caSAdrian Chadd 1327692ad7caSAdrian Chadd /* Read the hardware capabilities, revision and SKU type. */ 1328692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_SKU_CAP, &sc->cap, 1329692ad7caSAdrian Chadd sizeof(sc->cap))); 1330692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_REVISION, &sc->rev, 1331692ad7caSAdrian Chadd sizeof(sc->rev))); 1332692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_TYPE, &sc->type, 1333692ad7caSAdrian Chadd sizeof(sc->type))); 1334692ad7caSAdrian Chadd 1335f736d898SAdrian Chadd sc->rev = le16toh(sc->rev); 13367167f5fcSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, "cap=%x rev=%x type=%x\n", sc->cap, 1337f736d898SAdrian Chadd sc->rev, sc->type); 1338692ad7caSAdrian Chadd 1339692ad7caSAdrian Chadd /* Read the regulatory domain (4 ASCII characters.) */ 1340692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_DOMAIN, sc->domain, 1341692ad7caSAdrian Chadd sizeof(sc->domain))); 1342692ad7caSAdrian Chadd 1343692ad7caSAdrian Chadd /* Read MAC address. */ 1344692ad7caSAdrian Chadd WPI_CHK(wpi_read_prom_data(sc, WPI_EEPROM_MAC, macaddr, 1345692ad7caSAdrian Chadd IEEE80211_ADDR_LEN)); 1346692ad7caSAdrian Chadd 1347692ad7caSAdrian Chadd /* Read the list of authorized channels. */ 1348692ad7caSAdrian Chadd for (i = 0; i < WPI_CHAN_BANDS_COUNT; i++) 1349692ad7caSAdrian Chadd WPI_CHK(wpi_read_eeprom_channels(sc, i)); 1350692ad7caSAdrian Chadd 1351692ad7caSAdrian Chadd /* Read the list of TX power groups. */ 1352692ad7caSAdrian Chadd for (i = 0; i < WPI_POWER_GROUPS_COUNT; i++) 1353692ad7caSAdrian Chadd WPI_CHK(wpi_read_eeprom_group(sc, i)); 1354692ad7caSAdrian Chadd 1355692ad7caSAdrian Chadd fail: wpi_apm_stop(sc); /* Power OFF adapter. */ 1356692ad7caSAdrian Chadd 1357692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, error ? TRACE_STR_END_ERR : TRACE_STR_END, 1358692ad7caSAdrian Chadd __func__); 1359692ad7caSAdrian Chadd 1360692ad7caSAdrian Chadd return error; 1361692ad7caSAdrian Chadd #undef WPI_CHK 1362692ad7caSAdrian Chadd } 1363692ad7caSAdrian Chadd 1364692ad7caSAdrian Chadd /* 1365692ad7caSAdrian Chadd * Translate EEPROM flags to net80211. 1366692ad7caSAdrian Chadd */ 1367692ad7caSAdrian Chadd static uint32_t 1368692ad7caSAdrian Chadd wpi_eeprom_channel_flags(struct wpi_eeprom_chan *channel) 1369692ad7caSAdrian Chadd { 1370692ad7caSAdrian Chadd uint32_t nflags; 1371692ad7caSAdrian Chadd 1372692ad7caSAdrian Chadd nflags = 0; 1373692ad7caSAdrian Chadd if ((channel->flags & WPI_EEPROM_CHAN_ACTIVE) == 0) 1374692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_PASSIVE; 1375692ad7caSAdrian Chadd if ((channel->flags & WPI_EEPROM_CHAN_IBSS) == 0) 1376692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_NOADHOC; 1377692ad7caSAdrian Chadd if (channel->flags & WPI_EEPROM_CHAN_RADAR) { 1378692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_DFS; 1379692ad7caSAdrian Chadd /* XXX apparently IBSS may still be marked */ 1380692ad7caSAdrian Chadd nflags |= IEEE80211_CHAN_NOADHOC; 1381692ad7caSAdrian Chadd } 1382692ad7caSAdrian Chadd 1383692ad7caSAdrian Chadd return nflags; 1384692ad7caSAdrian Chadd } 1385692ad7caSAdrian Chadd 1386692ad7caSAdrian Chadd static void 1387692ad7caSAdrian Chadd wpi_read_eeprom_band(struct wpi_softc *sc, int n) 1388692ad7caSAdrian Chadd { 1389692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1390692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 1391692ad7caSAdrian Chadd struct wpi_eeprom_chan *channels = sc->eeprom_channels[n]; 1392692ad7caSAdrian Chadd const struct wpi_chan_band *band = &wpi_bands[n]; 1393692ad7caSAdrian Chadd struct ieee80211_channel *c; 1394692ad7caSAdrian Chadd uint8_t chan; 1395692ad7caSAdrian Chadd int i, nflags; 1396692ad7caSAdrian Chadd 1397692ad7caSAdrian Chadd for (i = 0; i < band->nchan; i++) { 1398692ad7caSAdrian Chadd if (!(channels[i].flags & WPI_EEPROM_CHAN_VALID)) { 13997e0d5232SAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1400692ad7caSAdrian Chadd "Channel Not Valid: %d, band %d\n", 1401692ad7caSAdrian Chadd band->chan[i],n); 1402692ad7caSAdrian Chadd continue; 1403692ad7caSAdrian Chadd } 1404692ad7caSAdrian Chadd 1405692ad7caSAdrian Chadd chan = band->chan[i]; 1406692ad7caSAdrian Chadd nflags = wpi_eeprom_channel_flags(&channels[i]); 1407692ad7caSAdrian Chadd 1408692ad7caSAdrian Chadd c = &ic->ic_channels[ic->ic_nchans++]; 1409692ad7caSAdrian Chadd c->ic_ieee = chan; 1410692ad7caSAdrian Chadd c->ic_maxregpower = channels[i].maxpwr; 1411692ad7caSAdrian Chadd c->ic_maxpower = 2*c->ic_maxregpower; 1412692ad7caSAdrian Chadd 1413692ad7caSAdrian Chadd if (n == 0) { /* 2GHz band */ 14147167f5fcSAdrian Chadd c->ic_freq = ieee80211_ieee2mhz(chan, 14157167f5fcSAdrian Chadd IEEE80211_CHAN_G); 14167167f5fcSAdrian Chadd 1417692ad7caSAdrian Chadd /* G =>'s B is supported */ 1418692ad7caSAdrian Chadd c->ic_flags = IEEE80211_CHAN_B | nflags; 1419692ad7caSAdrian Chadd c = &ic->ic_channels[ic->ic_nchans++]; 1420692ad7caSAdrian Chadd c[0] = c[-1]; 1421692ad7caSAdrian Chadd c->ic_flags = IEEE80211_CHAN_G | nflags; 1422692ad7caSAdrian Chadd } else { /* 5GHz band */ 14237167f5fcSAdrian Chadd c->ic_freq = ieee80211_ieee2mhz(chan, 14247167f5fcSAdrian Chadd IEEE80211_CHAN_A); 14257167f5fcSAdrian Chadd 1426692ad7caSAdrian Chadd c->ic_flags = IEEE80211_CHAN_A | nflags; 1427692ad7caSAdrian Chadd } 1428692ad7caSAdrian Chadd 1429692ad7caSAdrian Chadd /* Save maximum allowed TX power for this channel. */ 1430692ad7caSAdrian Chadd sc->maxpwr[chan] = channels[i].maxpwr; 1431692ad7caSAdrian Chadd 1432692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1433692ad7caSAdrian Chadd "adding chan %d (%dMHz) flags=0x%x maxpwr=%d passive=%d," 1434692ad7caSAdrian Chadd " offset %d\n", chan, c->ic_freq, 1435692ad7caSAdrian Chadd channels[i].flags, sc->maxpwr[chan], 1436fae61c69SAdrian Chadd IEEE80211_IS_CHAN_PASSIVE(c), ic->ic_nchans); 1437692ad7caSAdrian Chadd } 1438692ad7caSAdrian Chadd } 1439692ad7caSAdrian Chadd 1440692ad7caSAdrian Chadd /** 1441692ad7caSAdrian Chadd * Read the eeprom to find out what channels are valid for the given 1442692ad7caSAdrian Chadd * band and update net80211 with what we find. 1443692ad7caSAdrian Chadd */ 1444692ad7caSAdrian Chadd static int 1445692ad7caSAdrian Chadd wpi_read_eeprom_channels(struct wpi_softc *sc, int n) 1446692ad7caSAdrian Chadd { 1447692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1448692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 1449692ad7caSAdrian Chadd const struct wpi_chan_band *band = &wpi_bands[n]; 1450692ad7caSAdrian Chadd int error; 1451692ad7caSAdrian Chadd 1452692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1453692ad7caSAdrian Chadd 1454692ad7caSAdrian Chadd error = wpi_read_prom_data(sc, band->addr, &sc->eeprom_channels[n], 1455692ad7caSAdrian Chadd band->nchan * sizeof (struct wpi_eeprom_chan)); 1456692ad7caSAdrian Chadd if (error != 0) { 1457692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1458692ad7caSAdrian Chadd return error; 1459692ad7caSAdrian Chadd } 1460692ad7caSAdrian Chadd 1461692ad7caSAdrian Chadd wpi_read_eeprom_band(sc, n); 1462692ad7caSAdrian Chadd 1463692ad7caSAdrian Chadd ieee80211_sort_channels(ic->ic_channels, ic->ic_nchans); 1464692ad7caSAdrian Chadd 1465692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1466692ad7caSAdrian Chadd 1467692ad7caSAdrian Chadd return 0; 1468692ad7caSAdrian Chadd } 1469692ad7caSAdrian Chadd 1470692ad7caSAdrian Chadd static struct wpi_eeprom_chan * 1471692ad7caSAdrian Chadd wpi_find_eeprom_channel(struct wpi_softc *sc, struct ieee80211_channel *c) 1472692ad7caSAdrian Chadd { 1473692ad7caSAdrian Chadd int i, j; 1474692ad7caSAdrian Chadd 1475692ad7caSAdrian Chadd for (j = 0; j < WPI_CHAN_BANDS_COUNT; j++) 1476692ad7caSAdrian Chadd for (i = 0; i < wpi_bands[j].nchan; i++) 1477692ad7caSAdrian Chadd if (wpi_bands[j].chan[i] == c->ic_ieee) 1478692ad7caSAdrian Chadd return &sc->eeprom_channels[j][i]; 1479692ad7caSAdrian Chadd 1480692ad7caSAdrian Chadd return NULL; 1481692ad7caSAdrian Chadd } 1482692ad7caSAdrian Chadd 1483692ad7caSAdrian Chadd /* 1484692ad7caSAdrian Chadd * Enforce flags read from EEPROM. 1485692ad7caSAdrian Chadd */ 1486692ad7caSAdrian Chadd static int 1487692ad7caSAdrian Chadd wpi_setregdomain(struct ieee80211com *ic, struct ieee80211_regdomain *rd, 1488692ad7caSAdrian Chadd int nchan, struct ieee80211_channel chans[]) 1489692ad7caSAdrian Chadd { 1490692ad7caSAdrian Chadd struct ifnet *ifp = ic->ic_ifp; 1491692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 1492692ad7caSAdrian Chadd int i; 1493692ad7caSAdrian Chadd 1494692ad7caSAdrian Chadd for (i = 0; i < nchan; i++) { 1495692ad7caSAdrian Chadd struct ieee80211_channel *c = &chans[i]; 1496692ad7caSAdrian Chadd struct wpi_eeprom_chan *channel; 1497692ad7caSAdrian Chadd 1498692ad7caSAdrian Chadd channel = wpi_find_eeprom_channel(sc, c); 1499692ad7caSAdrian Chadd if (channel == NULL) { 1500692ad7caSAdrian Chadd if_printf(ic->ic_ifp, 1501692ad7caSAdrian Chadd "%s: invalid channel %u freq %u/0x%x\n", 1502692ad7caSAdrian Chadd __func__, c->ic_ieee, c->ic_freq, c->ic_flags); 1503692ad7caSAdrian Chadd return EINVAL; 1504692ad7caSAdrian Chadd } 1505692ad7caSAdrian Chadd c->ic_flags |= wpi_eeprom_channel_flags(channel); 1506692ad7caSAdrian Chadd } 1507692ad7caSAdrian Chadd 1508692ad7caSAdrian Chadd return 0; 1509692ad7caSAdrian Chadd } 1510692ad7caSAdrian Chadd 1511692ad7caSAdrian Chadd static int 1512692ad7caSAdrian Chadd wpi_read_eeprom_group(struct wpi_softc *sc, int n) 1513692ad7caSAdrian Chadd { 1514692ad7caSAdrian Chadd struct wpi_power_group *group = &sc->groups[n]; 1515692ad7caSAdrian Chadd struct wpi_eeprom_group rgroup; 1516692ad7caSAdrian Chadd int i, error; 1517692ad7caSAdrian Chadd 1518692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1519692ad7caSAdrian Chadd 1520692ad7caSAdrian Chadd if ((error = wpi_read_prom_data(sc, WPI_EEPROM_POWER_GRP + n * 32, 1521692ad7caSAdrian Chadd &rgroup, sizeof rgroup)) != 0) { 1522692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1523692ad7caSAdrian Chadd return error; 1524692ad7caSAdrian Chadd } 1525692ad7caSAdrian Chadd 1526692ad7caSAdrian Chadd /* Save TX power group information. */ 1527692ad7caSAdrian Chadd group->chan = rgroup.chan; 1528692ad7caSAdrian Chadd group->maxpwr = rgroup.maxpwr; 1529692ad7caSAdrian Chadd /* Retrieve temperature at which the samples were taken. */ 1530692ad7caSAdrian Chadd group->temp = (int16_t)le16toh(rgroup.temp); 1531692ad7caSAdrian Chadd 1532692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1533692ad7caSAdrian Chadd "power group %d: chan=%d maxpwr=%d temp=%d\n", n, group->chan, 1534692ad7caSAdrian Chadd group->maxpwr, group->temp); 1535692ad7caSAdrian Chadd 1536692ad7caSAdrian Chadd for (i = 0; i < WPI_SAMPLES_COUNT; i++) { 1537692ad7caSAdrian Chadd group->samples[i].index = rgroup.samples[i].index; 1538692ad7caSAdrian Chadd group->samples[i].power = rgroup.samples[i].power; 1539692ad7caSAdrian Chadd 1540692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EEPROM, 1541692ad7caSAdrian Chadd "\tsample %d: index=%d power=%d\n", i, 1542692ad7caSAdrian Chadd group->samples[i].index, group->samples[i].power); 1543692ad7caSAdrian Chadd } 1544692ad7caSAdrian Chadd 1545692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1546692ad7caSAdrian Chadd 1547692ad7caSAdrian Chadd return 0; 1548692ad7caSAdrian Chadd } 1549692ad7caSAdrian Chadd 1550eca2eb39SAdrian Chadd static int 1551eca2eb39SAdrian Chadd wpi_add_node_entry_adhoc(struct wpi_softc *sc) 1552eca2eb39SAdrian Chadd { 1553eca2eb39SAdrian Chadd int newid = WPI_ID_IBSS_MIN; 1554eca2eb39SAdrian Chadd 1555eca2eb39SAdrian Chadd for (; newid <= WPI_ID_IBSS_MAX; newid++) { 1556eca2eb39SAdrian Chadd if ((sc->nodesmsk & (1 << newid)) == 0) { 1557eca2eb39SAdrian Chadd sc->nodesmsk |= 1 << newid; 1558eca2eb39SAdrian Chadd return newid; 1559eca2eb39SAdrian Chadd } 1560eca2eb39SAdrian Chadd } 1561eca2eb39SAdrian Chadd 1562eca2eb39SAdrian Chadd return WPI_ID_UNDEFINED; 1563eca2eb39SAdrian Chadd } 1564eca2eb39SAdrian Chadd 1565eca2eb39SAdrian Chadd static __inline int 15660ebca245SAdrian Chadd wpi_add_node_entry_sta(struct wpi_softc *sc) 15670ebca245SAdrian Chadd { 15680ebca245SAdrian Chadd sc->nodesmsk |= 1 << WPI_ID_BSS; 15690ebca245SAdrian Chadd 15700ebca245SAdrian Chadd return WPI_ID_BSS; 15710ebca245SAdrian Chadd } 15720ebca245SAdrian Chadd 15730ebca245SAdrian Chadd static __inline int 1574eca2eb39SAdrian Chadd wpi_check_node_entry(struct wpi_softc *sc, uint8_t id) 1575eca2eb39SAdrian Chadd { 1576eca2eb39SAdrian Chadd if (id == WPI_ID_UNDEFINED) 1577eca2eb39SAdrian Chadd return 0; 1578eca2eb39SAdrian Chadd 1579eca2eb39SAdrian Chadd return (sc->nodesmsk >> id) & 1; 1580eca2eb39SAdrian Chadd } 1581eca2eb39SAdrian Chadd 1582eca2eb39SAdrian Chadd static __inline void 1583eca2eb39SAdrian Chadd wpi_clear_node_table(struct wpi_softc *sc) 1584eca2eb39SAdrian Chadd { 1585eca2eb39SAdrian Chadd sc->nodesmsk = 0; 1586eca2eb39SAdrian Chadd } 1587eca2eb39SAdrian Chadd 1588eca2eb39SAdrian Chadd static __inline void 1589eca2eb39SAdrian Chadd wpi_del_node_entry(struct wpi_softc *sc, uint8_t id) 1590eca2eb39SAdrian Chadd { 1591eca2eb39SAdrian Chadd sc->nodesmsk &= ~(1 << id); 1592eca2eb39SAdrian Chadd } 1593eca2eb39SAdrian Chadd 1594692ad7caSAdrian Chadd static struct ieee80211_node * 1595692ad7caSAdrian Chadd wpi_node_alloc(struct ieee80211vap *vap, const uint8_t mac[IEEE80211_ADDR_LEN]) 1596692ad7caSAdrian Chadd { 1597692ad7caSAdrian Chadd struct wpi_node *wn; 1598692ad7caSAdrian Chadd 1599692ad7caSAdrian Chadd wn = malloc(sizeof (struct wpi_node), M_80211_NODE, 1600692ad7caSAdrian Chadd M_NOWAIT | M_ZERO); 1601692ad7caSAdrian Chadd 1602692ad7caSAdrian Chadd if (wn == NULL) 1603692ad7caSAdrian Chadd return NULL; 1604692ad7caSAdrian Chadd 1605692ad7caSAdrian Chadd wn->id = WPI_ID_UNDEFINED; 1606692ad7caSAdrian Chadd 1607692ad7caSAdrian Chadd return &wn->ni; 1608692ad7caSAdrian Chadd } 1609692ad7caSAdrian Chadd 1610692ad7caSAdrian Chadd static void 1611692ad7caSAdrian Chadd wpi_node_free(struct ieee80211_node *ni) 1612692ad7caSAdrian Chadd { 1613692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 1614692ad7caSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 1615a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 1616692ad7caSAdrian Chadd 16170ebca245SAdrian Chadd if (wn->id != WPI_ID_UNDEFINED) { 16187964dd56SAdrian Chadd WPI_NT_LOCK(sc); 1619eca2eb39SAdrian Chadd if (wpi_check_node_entry(sc, wn->id)) { 1620eca2eb39SAdrian Chadd wpi_del_node_entry(sc, wn->id); 1621692ad7caSAdrian Chadd wpi_del_node(sc, ni); 1622eca2eb39SAdrian Chadd } 16237964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 1624692ad7caSAdrian Chadd } 1625692ad7caSAdrian Chadd 1626692ad7caSAdrian Chadd sc->sc_node_free(ni); 1627692ad7caSAdrian Chadd } 1628692ad7caSAdrian Chadd 16296607310bSBenjamin Close /** 16306607310bSBenjamin Close * Called by net80211 when ever there is a change to 80211 state machine 16316607310bSBenjamin Close */ 16326607310bSBenjamin Close static int 1633b032f27cSSam Leffler wpi_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 16346607310bSBenjamin Close { 1635b032f27cSSam Leffler struct wpi_vap *wvp = WPI_VAP(vap); 1636b032f27cSSam Leffler struct ieee80211com *ic = vap->iv_ic; 16376607310bSBenjamin Close struct ifnet *ifp = ic->ic_ifp; 16386607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 1639692ad7caSAdrian Chadd int error = 0; 16406607310bSBenjamin Close 1641692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1642692ad7caSAdrian Chadd 1643692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "%s: %s -> %s\n", __func__, 1644b032f27cSSam Leffler ieee80211_state_name[vap->iv_state], 1645692ad7caSAdrian Chadd ieee80211_state_name[nstate]); 16466607310bSBenjamin Close 16475efea30fSAndrew Thompson IEEE80211_UNLOCK(ic); 16485efea30fSAndrew Thompson WPI_LOCK(sc); 1649692ad7caSAdrian Chadd switch (nstate) { 1650692ad7caSAdrian Chadd case IEEE80211_S_SCAN: 1651692ad7caSAdrian Chadd if ((vap->iv_opmode == IEEE80211_M_IBSS || 1652692ad7caSAdrian Chadd vap->iv_opmode == IEEE80211_M_AHDEMO) && 1653692ad7caSAdrian Chadd (sc->rxon.filter & htole32(WPI_FILTER_BSS))) { 1654692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 1655692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 16563934c8a5SBernhard Schmidt device_printf(sc->sc_dev, 1657692ad7caSAdrian Chadd "%s: could not send RXON\n", __func__); 16583934c8a5SBernhard Schmidt } 16593934c8a5SBernhard Schmidt } 1660692ad7caSAdrian Chadd break; 1661692ad7caSAdrian Chadd 1662692ad7caSAdrian Chadd case IEEE80211_S_ASSOC: 1663692ad7caSAdrian Chadd if (vap->iv_state != IEEE80211_S_RUN) 1664692ad7caSAdrian Chadd break; 1665692ad7caSAdrian Chadd /* FALLTHROUGH */ 1666692ad7caSAdrian Chadd case IEEE80211_S_AUTH: 16673934c8a5SBernhard Schmidt /* 16683934c8a5SBernhard Schmidt * The node must be registered in the firmware before auth. 16693934c8a5SBernhard Schmidt * Also the associd must be cleared on RUN -> ASSOC 16703934c8a5SBernhard Schmidt * transitions. 16713934c8a5SBernhard Schmidt */ 1672692ad7caSAdrian Chadd if ((error = wpi_auth(sc, vap)) != 0) { 16735efea30fSAndrew Thompson device_printf(sc->sc_dev, 1674692ad7caSAdrian Chadd "%s: could not move to AUTH state, error %d\n", 16755efea30fSAndrew Thompson __func__, error); 16765efea30fSAndrew Thompson } 1677692ad7caSAdrian Chadd break; 1678692ad7caSAdrian Chadd 1679692ad7caSAdrian Chadd case IEEE80211_S_RUN: 1680692ad7caSAdrian Chadd /* 1681692ad7caSAdrian Chadd * RUN -> RUN transition; Just restart the timers. 1682692ad7caSAdrian Chadd */ 1683692ad7caSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) { 1684b032f27cSSam Leffler wpi_calib_timeout(sc); 1685692ad7caSAdrian Chadd break; 1686692ad7caSAdrian Chadd } 1687692ad7caSAdrian Chadd 1688692ad7caSAdrian Chadd /* 1689692ad7caSAdrian Chadd * !RUN -> RUN requires setting the association id 1690692ad7caSAdrian Chadd * which is done with a firmware cmd. We also defer 1691692ad7caSAdrian Chadd * starting the timers until that work is done. 1692692ad7caSAdrian Chadd */ 1693692ad7caSAdrian Chadd if ((error = wpi_run(sc, vap)) != 0) { 1694692ad7caSAdrian Chadd device_printf(sc->sc_dev, 1695692ad7caSAdrian Chadd "%s: could not move to RUN state\n", __func__); 1696692ad7caSAdrian Chadd } 1697692ad7caSAdrian Chadd break; 1698692ad7caSAdrian Chadd 1699692ad7caSAdrian Chadd default: 1700692ad7caSAdrian Chadd break; 1701b032f27cSSam Leffler } 17025efea30fSAndrew Thompson WPI_UNLOCK(sc); 17035efea30fSAndrew Thompson IEEE80211_LOCK(ic); 1704692ad7caSAdrian Chadd if (error != 0) { 1705692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 1706692ad7caSAdrian Chadd return error; 1707692ad7caSAdrian Chadd } 1708692ad7caSAdrian Chadd 1709692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1710692ad7caSAdrian Chadd 1711d036bb20SAdrian Chadd return wvp->wv_newstate(vap, nstate, arg); 17126607310bSBenjamin Close } 17136607310bSBenjamin Close 17146607310bSBenjamin Close static void 1715692ad7caSAdrian Chadd wpi_calib_timeout(void *arg) 17166607310bSBenjamin Close { 1717692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 1718692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1719692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 1720692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 17216607310bSBenjamin Close 1722692ad7caSAdrian Chadd if (vap->iv_state != IEEE80211_S_RUN) 1723692ad7caSAdrian Chadd return; 17246607310bSBenjamin Close 1725692ad7caSAdrian Chadd wpi_power_calibration(sc); 1726692ad7caSAdrian Chadd 1727692ad7caSAdrian Chadd callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); 17286607310bSBenjamin Close } 17296607310bSBenjamin Close 1730692ad7caSAdrian Chadd static __inline uint8_t 1731692ad7caSAdrian Chadd rate2plcp(const uint8_t rate) 17326607310bSBenjamin Close { 1733692ad7caSAdrian Chadd switch (rate) { 1734692ad7caSAdrian Chadd case 12: return 0xd; 1735692ad7caSAdrian Chadd case 18: return 0xf; 1736692ad7caSAdrian Chadd case 24: return 0x5; 1737692ad7caSAdrian Chadd case 36: return 0x7; 1738692ad7caSAdrian Chadd case 48: return 0x9; 1739692ad7caSAdrian Chadd case 72: return 0xb; 1740692ad7caSAdrian Chadd case 96: return 0x1; 1741692ad7caSAdrian Chadd case 108: return 0x3; 1742692ad7caSAdrian Chadd case 2: return 10; 1743692ad7caSAdrian Chadd case 4: return 20; 1744692ad7caSAdrian Chadd case 11: return 55; 1745692ad7caSAdrian Chadd case 22: return 110; 1746692ad7caSAdrian Chadd default: return 0; 1747692ad7caSAdrian Chadd } 17486607310bSBenjamin Close } 17496607310bSBenjamin Close 1750692ad7caSAdrian Chadd static __inline uint8_t 1751692ad7caSAdrian Chadd plcp2rate(const uint8_t plcp) 17526607310bSBenjamin Close { 1753692ad7caSAdrian Chadd switch (plcp) { 1754692ad7caSAdrian Chadd case 0xd: return 12; 1755692ad7caSAdrian Chadd case 0xf: return 18; 1756692ad7caSAdrian Chadd case 0x5: return 24; 1757692ad7caSAdrian Chadd case 0x7: return 36; 1758692ad7caSAdrian Chadd case 0x9: return 48; 1759692ad7caSAdrian Chadd case 0xb: return 72; 1760692ad7caSAdrian Chadd case 0x1: return 96; 1761692ad7caSAdrian Chadd case 0x3: return 108; 1762692ad7caSAdrian Chadd case 10: return 2; 1763692ad7caSAdrian Chadd case 20: return 4; 1764692ad7caSAdrian Chadd case 55: return 11; 1765692ad7caSAdrian Chadd case 110: return 22; 1766692ad7caSAdrian Chadd default: return 0; 17676607310bSBenjamin Close } 1768692ad7caSAdrian Chadd } 1769692ad7caSAdrian Chadd 1770692ad7caSAdrian Chadd /* Quickly determine if a given rate is CCK or OFDM. */ 1771692ad7caSAdrian Chadd #define WPI_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22) 17726607310bSBenjamin Close 17736607310bSBenjamin Close static void 1774692ad7caSAdrian Chadd wpi_rx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc, 17756607310bSBenjamin Close struct wpi_rx_data *data) 17766607310bSBenjamin Close { 1777b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 1778692ad7caSAdrian Chadd const struct ieee80211_cipher *cip = NULL; 1779b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 17806607310bSBenjamin Close struct wpi_rx_ring *ring = &sc->rxq; 17816607310bSBenjamin Close struct wpi_rx_stat *stat; 17826607310bSBenjamin Close struct wpi_rx_head *head; 17836607310bSBenjamin Close struct wpi_rx_tail *tail; 1784692ad7caSAdrian Chadd struct ieee80211_frame *wh; 17856607310bSBenjamin Close struct ieee80211_node *ni; 1786692ad7caSAdrian Chadd struct mbuf *m, *m1; 178782f1b132SAndrew Thompson bus_addr_t paddr; 1788692ad7caSAdrian Chadd uint32_t flags; 1789692ad7caSAdrian Chadd uint16_t len; 179082f1b132SAndrew Thompson int error; 17916607310bSBenjamin Close 17926607310bSBenjamin Close stat = (struct wpi_rx_stat *)(desc + 1); 17936607310bSBenjamin Close 17946607310bSBenjamin Close if (stat->len > WPI_STAT_MAXLEN) { 1795692ad7caSAdrian Chadd device_printf(sc->sc_dev, "invalid RX statistic header\n"); 1796fae61c69SAdrian Chadd goto fail1; 17976607310bSBenjamin Close } 17986607310bSBenjamin Close 1799a71ad787SBernhard Schmidt bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTREAD); 18006607310bSBenjamin Close head = (struct wpi_rx_head *)((caddr_t)(stat + 1) + stat->len); 1801692ad7caSAdrian Chadd len = le16toh(head->len); 1802692ad7caSAdrian Chadd tail = (struct wpi_rx_tail *)((caddr_t)(head + 1) + len); 1803692ad7caSAdrian Chadd flags = le32toh(tail->flags); 18046607310bSBenjamin Close 1805692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: idx %d len %d stat len %u rssi %d" 1806692ad7caSAdrian Chadd " rate %x chan %d tstamp %ju\n", __func__, ring->cur, 1807692ad7caSAdrian Chadd le32toh(desc->len), len, (int8_t)stat->rssi, 1808692ad7caSAdrian Chadd head->plcp, head->chan, (uintmax_t)le64toh(tail->tstamp)); 18096607310bSBenjamin Close 1810692ad7caSAdrian Chadd /* Discard frames with a bad FCS early. */ 1811692ad7caSAdrian Chadd if ((flags & WPI_RX_NOERROR) != WPI_RX_NOERROR) { 1812692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: RX flags error %x\n", 1813692ad7caSAdrian Chadd __func__, flags); 1814fae61c69SAdrian Chadd goto fail1; 1815fcec677dSJuli Mallett } 1816692ad7caSAdrian Chadd /* Discard frames that are too short. */ 1817692ad7caSAdrian Chadd if (len < sizeof (*wh)) { 1818692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, "%s: frame too short: %d\n", 1819692ad7caSAdrian Chadd __func__, len); 1820fae61c69SAdrian Chadd goto fail1; 1821fcec677dSJuli Mallett } 1822fcec677dSJuli Mallett 1823692ad7caSAdrian Chadd m1 = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 1824692ad7caSAdrian Chadd if (m1 == NULL) { 1825692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_ANY, "%s: no mbuf to restock ring\n", 1826692ad7caSAdrian Chadd __func__); 1827fae61c69SAdrian Chadd goto fail1; 182882f1b132SAndrew Thompson } 1829a71ad787SBernhard Schmidt bus_dmamap_unload(ring->data_dmat, data->map); 1830a71ad787SBernhard Schmidt 1831692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, mtod(m1, void *), 1832692ad7caSAdrian Chadd MJUMPAGESIZE, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); 183382f1b132SAndrew Thompson if (error != 0 && error != EFBIG) { 183482f1b132SAndrew Thompson device_printf(sc->sc_dev, 183582f1b132SAndrew Thompson "%s: bus_dmamap_load failed, error %d\n", __func__, error); 1836692ad7caSAdrian Chadd m_freem(m1); 1837692ad7caSAdrian Chadd 1838692ad7caSAdrian Chadd /* Try to reload the old mbuf. */ 1839692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, 1840692ad7caSAdrian Chadd mtod(data->m, void *), MJUMPAGESIZE, wpi_dma_map_addr, 1841692ad7caSAdrian Chadd &paddr, BUS_DMA_NOWAIT); 1842692ad7caSAdrian Chadd if (error != 0 && error != EFBIG) { 1843692ad7caSAdrian Chadd panic("%s: could not load old RX mbuf", __func__); 1844692ad7caSAdrian Chadd } 1845692ad7caSAdrian Chadd /* Physical address may have changed. */ 1846692ad7caSAdrian Chadd ring->desc[ring->cur] = htole32(paddr); 1847692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->desc_dma.map, 1848692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1849fae61c69SAdrian Chadd goto fail1; 185082f1b132SAndrew Thompson } 18516607310bSBenjamin Close 185282f1b132SAndrew Thompson m = data->m; 1853692ad7caSAdrian Chadd data->m = m1; 1854692ad7caSAdrian Chadd /* Update RX descriptor. */ 1855692ad7caSAdrian Chadd ring->desc[ring->cur] = htole32(paddr); 1856692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 1857692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 1858692ad7caSAdrian Chadd 1859692ad7caSAdrian Chadd /* Finalize mbuf. */ 18606607310bSBenjamin Close m->m_pkthdr.rcvif = ifp; 18616607310bSBenjamin Close m->m_data = (caddr_t)(head + 1); 1862692ad7caSAdrian Chadd m->m_pkthdr.len = m->m_len = len; 18636607310bSBenjamin Close 1864692ad7caSAdrian Chadd /* Grab a reference to the source node. */ 1865692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 1866692ad7caSAdrian Chadd ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh); 1867692ad7caSAdrian Chadd 1868692ad7caSAdrian Chadd if (ni != NULL) 1869692ad7caSAdrian Chadd cip = ni->ni_ucastkey.wk_cipher; 1870692ad7caSAdrian Chadd if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) && 1871692ad7caSAdrian Chadd !IEEE80211_IS_MULTICAST(wh->i_addr1) && 1872692ad7caSAdrian Chadd cip != NULL && cip->ic_cipher == IEEE80211_CIPHER_AES_CCM) { 1873fae61c69SAdrian Chadd if ((flags & WPI_RX_CIPHER_MASK) != WPI_RX_CIPHER_CCMP) 1874fae61c69SAdrian Chadd goto fail2; 1875fae61c69SAdrian Chadd 1876692ad7caSAdrian Chadd /* Check whether decryption was successful or not. */ 1877692ad7caSAdrian Chadd if ((flags & WPI_RX_DECRYPT_MASK) != WPI_RX_DECRYPT_OK) { 1878692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RECV, 1879692ad7caSAdrian Chadd "CCMP decryption failed 0x%x\n", flags); 1880fae61c69SAdrian Chadd goto fail2; 1881692ad7caSAdrian Chadd } 1882692ad7caSAdrian Chadd m->m_flags |= M_WEP; 1883692ad7caSAdrian Chadd } 18846607310bSBenjamin Close 18855463c4a4SSam Leffler if (ieee80211_radiotap_active(ic)) { 18866607310bSBenjamin Close struct wpi_rx_radiotap_header *tap = &sc->sc_rxtap; 18876607310bSBenjamin Close 18886607310bSBenjamin Close tap->wr_flags = 0; 1889692ad7caSAdrian Chadd if (head->flags & htole16(WPI_STAT_FLAG_SHPREAMBLE)) 1890692ad7caSAdrian Chadd tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE; 18918e4cf38aSAdrian Chadd tap->wr_dbm_antsignal = (int8_t)(stat->rssi + WPI_RSSI_OFFSET); 18920b455e8fSAdrian Chadd tap->wr_dbm_antnoise = WPI_RSSI_OFFSET; 18936607310bSBenjamin Close tap->wr_tsft = tail->tstamp; 18946607310bSBenjamin Close tap->wr_antenna = (le16toh(head->flags) >> 4) & 0xf; 1895692ad7caSAdrian Chadd tap->wr_rate = plcp2rate(head->plcp); 18966607310bSBenjamin Close } 18976607310bSBenjamin Close 18986607310bSBenjamin Close WPI_UNLOCK(sc); 18996607310bSBenjamin Close 1900692ad7caSAdrian Chadd /* Send the frame to the 802.11 layer. */ 1901b032f27cSSam Leffler if (ni != NULL) { 19028e4cf38aSAdrian Chadd (void)ieee80211_input(ni, m, stat->rssi, WPI_RSSI_OFFSET); 1903692ad7caSAdrian Chadd /* Node is no longer needed. */ 19046607310bSBenjamin Close ieee80211_free_node(ni); 1905b032f27cSSam Leffler } else 19068e4cf38aSAdrian Chadd (void)ieee80211_input_all(ic, m, stat->rssi, WPI_RSSI_OFFSET); 1907b032f27cSSam Leffler 19086607310bSBenjamin Close WPI_LOCK(sc); 1909fae61c69SAdrian Chadd 1910fae61c69SAdrian Chadd return; 1911fae61c69SAdrian Chadd 1912fae61c69SAdrian Chadd fail2: ieee80211_free_node(ni); 1913fae61c69SAdrian Chadd m_freem(m); 1914fae61c69SAdrian Chadd 1915fae61c69SAdrian Chadd fail1: if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 19166607310bSBenjamin Close } 19176607310bSBenjamin Close 19186607310bSBenjamin Close static void 1919692ad7caSAdrian Chadd wpi_rx_statistics(struct wpi_softc *sc, struct wpi_rx_desc *desc, 1920692ad7caSAdrian Chadd struct wpi_rx_data *data) 19216607310bSBenjamin Close { 1922692ad7caSAdrian Chadd /* Ignore */ 19236607310bSBenjamin Close } 19246607310bSBenjamin Close 19256607310bSBenjamin Close static void 1926692ad7caSAdrian Chadd wpi_tx_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) 19276607310bSBenjamin Close { 1928692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 1929692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[desc->qid & 0x3]; 1930692ad7caSAdrian Chadd struct wpi_tx_data *data = &ring->data[desc->idx]; 1931692ad7caSAdrian Chadd struct wpi_tx_stat *stat = (struct wpi_tx_stat *)(desc + 1); 1932692ad7caSAdrian Chadd struct mbuf *m; 1933692ad7caSAdrian Chadd struct ieee80211_node *ni; 1934692ad7caSAdrian Chadd struct ieee80211vap *vap; 19354eaf2ee3SAdrian Chadd struct ieee80211com *ic; 1936e336bd54SAdrian Chadd int ackfailcnt = stat->ackfailcnt / 2; /* wpi_mrr_setup() */ 1937692ad7caSAdrian Chadd int status = le32toh(stat->status); 1938692ad7caSAdrian Chadd 1939692ad7caSAdrian Chadd KASSERT(data->ni != NULL, ("no node")); 1940692ad7caSAdrian Chadd 1941692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 1942692ad7caSAdrian Chadd 1943692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: " 1944692ad7caSAdrian Chadd "qid %d idx %d retries %d btkillcnt %d rate %x duration %d " 1945fae61c69SAdrian Chadd "status %x\n", __func__, desc->qid, desc->idx, ackfailcnt, 1946692ad7caSAdrian Chadd stat->btkillcnt, stat->rate, le32toh(stat->duration), status); 1947692ad7caSAdrian Chadd 1948692ad7caSAdrian Chadd /* Unmap and free mbuf. */ 1949692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_POSTWRITE); 1950692ad7caSAdrian Chadd bus_dmamap_unload(ring->data_dmat, data->map); 1951692ad7caSAdrian Chadd m = data->m, data->m = NULL; 1952692ad7caSAdrian Chadd ni = data->ni, data->ni = NULL; 1953692ad7caSAdrian Chadd vap = ni->ni_vap; 19544eaf2ee3SAdrian Chadd ic = vap->iv_ic; 1955692ad7caSAdrian Chadd 1956692ad7caSAdrian Chadd /* 1957692ad7caSAdrian Chadd * Update rate control statistics for the node. 1958692ad7caSAdrian Chadd */ 1959692ad7caSAdrian Chadd WPI_UNLOCK(sc); 1960692ad7caSAdrian Chadd if ((status & 0xff) != 1) { 1961692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 1962692ad7caSAdrian Chadd ieee80211_ratectl_tx_complete(vap, ni, 1963fae61c69SAdrian Chadd IEEE80211_RATECTL_TX_FAILURE, &ackfailcnt, NULL); 1964692ad7caSAdrian Chadd } else { 1965692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1); 1966692ad7caSAdrian Chadd ieee80211_ratectl_tx_complete(vap, ni, 1967fae61c69SAdrian Chadd IEEE80211_RATECTL_TX_SUCCESS, &ackfailcnt, NULL); 1968692ad7caSAdrian Chadd } 1969692ad7caSAdrian Chadd 1970692ad7caSAdrian Chadd ieee80211_tx_complete(ni, m, (status & 0xff) != 1); 1971692ad7caSAdrian Chadd WPI_LOCK(sc); 1972692ad7caSAdrian Chadd 1973692ad7caSAdrian Chadd sc->sc_tx_timer = 0; 1974692ad7caSAdrian Chadd if (--ring->queued < WPI_TX_RING_LOMARK) { 1975692ad7caSAdrian Chadd sc->qfullmsk &= ~(1 << ring->qid); 1976692ad7caSAdrian Chadd if (sc->qfullmsk == 0 && 1977692ad7caSAdrian Chadd (ifp->if_drv_flags & IFF_DRV_OACTIVE)) { 1978692ad7caSAdrian Chadd ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 19794eaf2ee3SAdrian Chadd ieee80211_runtask(ic, &sc->sc_start_task); 1980692ad7caSAdrian Chadd } 1981692ad7caSAdrian Chadd } 1982692ad7caSAdrian Chadd 1983692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 1984692ad7caSAdrian Chadd } 1985692ad7caSAdrian Chadd 1986692ad7caSAdrian Chadd /* 1987692ad7caSAdrian Chadd * Process a "command done" firmware notification. This is where we wakeup 1988692ad7caSAdrian Chadd * processes waiting for a synchronous command completion. 1989692ad7caSAdrian Chadd */ 1990692ad7caSAdrian Chadd static void 1991692ad7caSAdrian Chadd wpi_cmd_done(struct wpi_softc *sc, struct wpi_rx_desc *desc) 1992692ad7caSAdrian Chadd { 19938e4cf38aSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; 19946607310bSBenjamin Close struct wpi_tx_data *data; 19956607310bSBenjamin Close 1996692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "cmd notification qid=%x idx=%d flags=%x " 19976607310bSBenjamin Close "type=%s len=%d\n", desc->qid, desc->idx, 19986607310bSBenjamin Close desc->flags, wpi_cmd_str(desc->type), 1999692ad7caSAdrian Chadd le32toh(desc->len)); 20006607310bSBenjamin Close 20018e4cf38aSAdrian Chadd if ((desc->qid & WPI_RX_DESC_QID_MSK) != WPI_CMD_QUEUE_NUM) 2002692ad7caSAdrian Chadd return; /* Not a command ack. */ 20036607310bSBenjamin Close 200445ac43f3SAdrian Chadd KASSERT(ring->queued == 0, ("ring->queued must be 0")); 200545ac43f3SAdrian Chadd 20066607310bSBenjamin Close data = &ring->data[desc->idx]; 20076607310bSBenjamin Close 2008692ad7caSAdrian Chadd /* If the command was mapped in an mbuf, free it. */ 20096607310bSBenjamin Close if (data->m != NULL) { 2010692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 2011692ad7caSAdrian Chadd BUS_DMASYNC_POSTWRITE); 20126607310bSBenjamin Close bus_dmamap_unload(ring->data_dmat, data->map); 20136607310bSBenjamin Close m_freem(data->m); 20146607310bSBenjamin Close data->m = NULL; 20156607310bSBenjamin Close } 20166607310bSBenjamin Close 20176607310bSBenjamin Close wakeup(&ring->cmd[desc->idx]); 20186607310bSBenjamin Close } 20196607310bSBenjamin Close 20206607310bSBenjamin Close static void 20216607310bSBenjamin Close wpi_notif_intr(struct wpi_softc *sc) 20226607310bSBenjamin Close { 2023b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 2024b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 2025692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2026692ad7caSAdrian Chadd int hw; 20276607310bSBenjamin Close 2028f015cb78SBernhard Schmidt bus_dmamap_sync(sc->shared_dma.tag, sc->shared_dma.map, 2029f015cb78SBernhard Schmidt BUS_DMASYNC_POSTREAD); 2030f015cb78SBernhard Schmidt 20316607310bSBenjamin Close hw = le32toh(sc->shared->next); 2032692ad7caSAdrian Chadd hw = (hw == 0) ? WPI_RX_RING_COUNT - 1 : hw - 1; 2033692ad7caSAdrian Chadd 2034fae61c69SAdrian Chadd while (sc->rxq.cur != hw) { 2035692ad7caSAdrian Chadd sc->rxq.cur = (sc->rxq.cur + 1) % WPI_RX_RING_COUNT; 2036692ad7caSAdrian Chadd 2037692ad7caSAdrian Chadd struct wpi_rx_data *data = &sc->rxq.data[sc->rxq.cur]; 2038692ad7caSAdrian Chadd struct wpi_rx_desc *desc; 2039f015cb78SBernhard Schmidt 2040f015cb78SBernhard Schmidt bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2041f015cb78SBernhard Schmidt BUS_DMASYNC_POSTREAD); 2042692ad7caSAdrian Chadd desc = mtod(data->m, struct wpi_rx_desc *); 20436607310bSBenjamin Close 2044692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_NOTIFY, 2045692ad7caSAdrian Chadd "%s: cur=%d; qid %x idx %d flags %x type %d(%s) len %d\n", 2046692ad7caSAdrian Chadd __func__, sc->rxq.cur, desc->qid, desc->idx, desc->flags, 2047692ad7caSAdrian Chadd desc->type, wpi_cmd_str(desc->type), le32toh(desc->len)); 20486607310bSBenjamin Close 20498e4cf38aSAdrian Chadd if (!(desc->qid & WPI_UNSOLICITED_RX_NOTIF)) { 20508e4cf38aSAdrian Chadd /* Reply to a command. */ 2051692ad7caSAdrian Chadd wpi_cmd_done(sc, desc); 20528e4cf38aSAdrian Chadd } 20536607310bSBenjamin Close 20546607310bSBenjamin Close switch (desc->type) { 20556607310bSBenjamin Close case WPI_RX_DONE: 2056692ad7caSAdrian Chadd /* An 802.11 frame has been received. */ 2057692ad7caSAdrian Chadd wpi_rx_done(sc, desc, data); 205871258eb2SAdrian Chadd 205971258eb2SAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { 206071258eb2SAdrian Chadd /* wpi_stop() was called. */ 206171258eb2SAdrian Chadd return; 206271258eb2SAdrian Chadd } 206371258eb2SAdrian Chadd 20646607310bSBenjamin Close break; 20656607310bSBenjamin Close 20666607310bSBenjamin Close case WPI_TX_DONE: 2067692ad7caSAdrian Chadd /* An 802.11 frame has been transmitted. */ 2068692ad7caSAdrian Chadd wpi_tx_done(sc, desc); 20696607310bSBenjamin Close break; 20706607310bSBenjamin Close 2071692ad7caSAdrian Chadd case WPI_RX_STATISTICS: 2072692ad7caSAdrian Chadd case WPI_BEACON_STATISTICS: 2073692ad7caSAdrian Chadd wpi_rx_statistics(sc, desc, data); 2074692ad7caSAdrian Chadd break; 2075692ad7caSAdrian Chadd 2076692ad7caSAdrian Chadd case WPI_BEACON_MISSED: 2077692ad7caSAdrian Chadd { 2078692ad7caSAdrian Chadd struct wpi_beacon_missed *miss = 2079692ad7caSAdrian Chadd (struct wpi_beacon_missed *)(desc + 1); 2080692ad7caSAdrian Chadd int misses; 2081692ad7caSAdrian Chadd 2082692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2083692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2084692ad7caSAdrian Chadd misses = le32toh(miss->consecutive); 2085692ad7caSAdrian Chadd 2086692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, 2087692ad7caSAdrian Chadd "%s: beacons missed %d/%d\n", __func__, misses, 2088692ad7caSAdrian Chadd le32toh(miss->total)); 2089692ad7caSAdrian Chadd 2090692ad7caSAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN && 20919facf2b9SAdrian Chadd (ic->ic_flags & IEEE80211_F_SCAN) == 0) { 2092692ad7caSAdrian Chadd if (misses >= vap->iv_bmissthreshold) { 2093692ad7caSAdrian Chadd WPI_UNLOCK(sc); 2094692ad7caSAdrian Chadd ieee80211_beacon_miss(ic); 2095692ad7caSAdrian Chadd WPI_LOCK(sc); 2096692ad7caSAdrian Chadd } 2097692ad7caSAdrian Chadd } 2098692ad7caSAdrian Chadd break; 2099692ad7caSAdrian Chadd } 21006607310bSBenjamin Close case WPI_UC_READY: 21016607310bSBenjamin Close { 21026607310bSBenjamin Close struct wpi_ucode_info *uc = 21036607310bSBenjamin Close (struct wpi_ucode_info *)(desc + 1); 21046607310bSBenjamin Close 2105692ad7caSAdrian Chadd /* The microcontroller is ready. */ 2106692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2107692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2108692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, 2109692ad7caSAdrian Chadd "microcode alive notification version=%d.%d " 2110692ad7caSAdrian Chadd "subtype=%x alive=%x\n", uc->major, uc->minor, 2111692ad7caSAdrian Chadd uc->subtype, le32toh(uc->valid)); 21126607310bSBenjamin Close 21136607310bSBenjamin Close if (le32toh(uc->valid) != 1) { 21146607310bSBenjamin Close device_printf(sc->sc_dev, 21156607310bSBenjamin Close "microcontroller initialization failed\n"); 21166607310bSBenjamin Close wpi_stop_locked(sc); 21176607310bSBenjamin Close } 2118692ad7caSAdrian Chadd /* Save the address of the error log in SRAM. */ 2119692ad7caSAdrian Chadd sc->errptr = le32toh(uc->errptr); 21206607310bSBenjamin Close break; 21216607310bSBenjamin Close } 21226607310bSBenjamin Close case WPI_STATE_CHANGED: 21236607310bSBenjamin Close { 2124692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2125692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 2126692ad7caSAdrian Chadd 21276607310bSBenjamin Close uint32_t *status = (uint32_t *)(desc + 1); 2128fae61c69SAdrian Chadd 2129692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "state changed to %x\n", 2130692ad7caSAdrian Chadd le32toh(*status)); 2131fae61c69SAdrian Chadd 21326607310bSBenjamin Close if (le32toh(*status) & 1) { 21337964dd56SAdrian Chadd WPI_NT_LOCK(sc); 2134eca2eb39SAdrian Chadd wpi_clear_node_table(sc); 21357964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 2136692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_radiooff_task); 2137692ad7caSAdrian Chadd return; 21386607310bSBenjamin Close } 21396607310bSBenjamin Close break; 21406607310bSBenjamin Close } 21416607310bSBenjamin Close case WPI_START_SCAN: 21426607310bSBenjamin Close { 2143692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2144692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 21456845408dSAndrew Thompson #ifdef WPI_DEBUG 21466607310bSBenjamin Close struct wpi_start_scan *scan = 21476607310bSBenjamin Close (struct wpi_start_scan *)(desc + 1); 2148692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, 2149692ad7caSAdrian Chadd "%s: scanning channel %d status %x\n", 2150692ad7caSAdrian Chadd __func__, scan->chan, le32toh(scan->status)); 21516845408dSAndrew Thompson #endif 21526607310bSBenjamin Close break; 21536607310bSBenjamin Close } 21546607310bSBenjamin Close case WPI_STOP_SCAN: 21556607310bSBenjamin Close { 2156692ad7caSAdrian Chadd bus_dmamap_sync(sc->rxq.data_dmat, data->map, 2157692ad7caSAdrian Chadd BUS_DMASYNC_POSTREAD); 21586845408dSAndrew Thompson #ifdef WPI_DEBUG 21596607310bSBenjamin Close struct wpi_stop_scan *scan = 21606607310bSBenjamin Close (struct wpi_stop_scan *)(desc + 1); 2161692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, 2162692ad7caSAdrian Chadd "scan finished nchan=%d status=%d chan=%d\n", 2163692ad7caSAdrian Chadd scan->nchan, scan->status, scan->chan); 21646845408dSAndrew Thompson #endif 216582f1b132SAndrew Thompson sc->sc_scan_timer = 0; 2166692ad7caSAdrian Chadd WPI_UNLOCK(sc); 2167b032f27cSSam Leffler ieee80211_scan_next(vap); 2168692ad7caSAdrian Chadd WPI_LOCK(sc); 21696607310bSBenjamin Close break; 21706607310bSBenjamin Close } 2171692ad7caSAdrian Chadd } 2172fae61c69SAdrian Chadd } 2173692ad7caSAdrian Chadd 2174692ad7caSAdrian Chadd /* Tell the firmware what we have processed. */ 2175692ad7caSAdrian Chadd wpi_update_rx_ring(sc); 2176692ad7caSAdrian Chadd } 2177692ad7caSAdrian Chadd 2178692ad7caSAdrian Chadd /* 2179692ad7caSAdrian Chadd * Process an INT_WAKEUP interrupt raised when the microcontroller wakes up 2180692ad7caSAdrian Chadd * from power-down sleep mode. 2181692ad7caSAdrian Chadd */ 2182692ad7caSAdrian Chadd static void 2183692ad7caSAdrian Chadd wpi_wakeup_intr(struct wpi_softc *sc) 2184a7099588SBenjamin Close { 2185692ad7caSAdrian Chadd int qid; 2186a7099588SBenjamin Close 2187692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, 2188692ad7caSAdrian Chadd "%s: ucode wakeup from power-down sleep\n", __func__); 2189692ad7caSAdrian Chadd 2190692ad7caSAdrian Chadd /* Wakeup RX and TX rings. */ 2191692ad7caSAdrian Chadd if (sc->rxq.update) { 2192692ad7caSAdrian Chadd sc->rxq.update = 0; 2193fae61c69SAdrian Chadd wpi_update_rx_ring(sc); 2194a7099588SBenjamin Close } 219563f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 2196ebf62e08SAdrian Chadd for (qid = 0; qid < WPI_DRV_NTXQUEUES; qid++) { 2197692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[qid]; 2198692ad7caSAdrian Chadd 2199692ad7caSAdrian Chadd if (ring->update) { 2200692ad7caSAdrian Chadd ring->update = 0; 2201fae61c69SAdrian Chadd wpi_update_tx_ring(sc, ring); 2202a7099588SBenjamin Close } 22036607310bSBenjamin Close } 220463f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 22056607310bSBenjamin Close 2206692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_MAC_ACCESS_REQ); 22076607310bSBenjamin Close } 22086607310bSBenjamin Close 2209692ad7caSAdrian Chadd /* 2210692ad7caSAdrian Chadd * Dump the error log of the firmware when a firmware panic occurs. Although 2211692ad7caSAdrian Chadd * we can't debug the firmware because it is neither open source nor free, it 2212692ad7caSAdrian Chadd * can help us to identify certain classes of problems. 2213692ad7caSAdrian Chadd */ 2214692ad7caSAdrian Chadd static void 2215692ad7caSAdrian Chadd wpi_fatal_intr(struct wpi_softc *sc) 2216692ad7caSAdrian Chadd { 2217692ad7caSAdrian Chadd struct wpi_fw_dump dump; 2218692ad7caSAdrian Chadd uint32_t i, offset, count; 2219692ad7caSAdrian Chadd const uint32_t size_errmsg = 2220692ad7caSAdrian Chadd (sizeof (wpi_fw_errmsg) / sizeof ((wpi_fw_errmsg)[0])); 2221692ad7caSAdrian Chadd 2222692ad7caSAdrian Chadd /* Check that the error log address is valid. */ 2223692ad7caSAdrian Chadd if (sc->errptr < WPI_FW_DATA_BASE || 2224692ad7caSAdrian Chadd sc->errptr + sizeof (dump) > 2225692ad7caSAdrian Chadd WPI_FW_DATA_BASE + WPI_FW_DATA_MAXSZ) { 2226692ad7caSAdrian Chadd printf("%s: bad firmware error log address 0x%08x\n", __func__, 2227692ad7caSAdrian Chadd sc->errptr); 2228692ad7caSAdrian Chadd return; 2229692ad7caSAdrian Chadd } 2230692ad7caSAdrian Chadd if (wpi_nic_lock(sc) != 0) { 2231692ad7caSAdrian Chadd printf("%s: could not read firmware error log\n", __func__); 2232692ad7caSAdrian Chadd return; 2233692ad7caSAdrian Chadd } 2234692ad7caSAdrian Chadd /* Read number of entries in the log. */ 2235692ad7caSAdrian Chadd count = wpi_mem_read(sc, sc->errptr); 2236692ad7caSAdrian Chadd if (count == 0 || count * sizeof (dump) > WPI_FW_DATA_MAXSZ) { 2237692ad7caSAdrian Chadd printf("%s: invalid count field (count = %u)\n", __func__, 2238692ad7caSAdrian Chadd count); 2239692ad7caSAdrian Chadd wpi_nic_unlock(sc); 2240692ad7caSAdrian Chadd return; 2241692ad7caSAdrian Chadd } 2242692ad7caSAdrian Chadd /* Skip "count" field. */ 2243692ad7caSAdrian Chadd offset = sc->errptr + sizeof (uint32_t); 2244692ad7caSAdrian Chadd printf("firmware error log (count = %u):\n", count); 2245692ad7caSAdrian Chadd for (i = 0; i < count; i++) { 2246692ad7caSAdrian Chadd wpi_mem_read_region_4(sc, offset, (uint32_t *)&dump, 2247692ad7caSAdrian Chadd sizeof (dump) / sizeof (uint32_t)); 2248692ad7caSAdrian Chadd 2249692ad7caSAdrian Chadd printf(" error type = \"%s\" (0x%08X)\n", 2250692ad7caSAdrian Chadd (dump.desc < size_errmsg) ? 2251692ad7caSAdrian Chadd wpi_fw_errmsg[dump.desc] : "UNKNOWN", 2252692ad7caSAdrian Chadd dump.desc); 2253692ad7caSAdrian Chadd printf(" error data = 0x%08X\n", 2254692ad7caSAdrian Chadd dump.data); 2255692ad7caSAdrian Chadd printf(" branch link = 0x%08X%08X\n", 2256692ad7caSAdrian Chadd dump.blink[0], dump.blink[1]); 2257692ad7caSAdrian Chadd printf(" interrupt link = 0x%08X%08X\n", 2258692ad7caSAdrian Chadd dump.ilink[0], dump.ilink[1]); 2259692ad7caSAdrian Chadd printf(" time = %u\n", dump.time); 2260692ad7caSAdrian Chadd 2261692ad7caSAdrian Chadd offset += sizeof (dump); 2262692ad7caSAdrian Chadd } 2263692ad7caSAdrian Chadd wpi_nic_unlock(sc); 2264692ad7caSAdrian Chadd /* Dump driver status (TX and RX rings) while we're here. */ 2265692ad7caSAdrian Chadd printf("driver status:\n"); 226663f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 2267ebf62e08SAdrian Chadd for (i = 0; i < WPI_DRV_NTXQUEUES; i++) { 2268692ad7caSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[i]; 2269692ad7caSAdrian Chadd printf(" tx ring %2d: qid=%-2d cur=%-3d queued=%-3d\n", 2270692ad7caSAdrian Chadd i, ring->qid, ring->cur, ring->queued); 2271692ad7caSAdrian Chadd } 227263f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 2273692ad7caSAdrian Chadd printf(" rx ring: cur=%d\n", sc->rxq.cur); 22746607310bSBenjamin Close } 22756607310bSBenjamin Close 22766607310bSBenjamin Close static void 22776607310bSBenjamin Close wpi_intr(void *arg) 22786607310bSBenjamin Close { 22796607310bSBenjamin Close struct wpi_softc *sc = arg; 2280692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 2281692ad7caSAdrian Chadd uint32_t r1, r2; 22826607310bSBenjamin Close 22836607310bSBenjamin Close WPI_LOCK(sc); 22846607310bSBenjamin Close 2285692ad7caSAdrian Chadd /* Disable interrupts. */ 2286692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, 0); 2287692ad7caSAdrian Chadd 2288692ad7caSAdrian Chadd r1 = WPI_READ(sc, WPI_INT); 2289692ad7caSAdrian Chadd 22907f1299c5SAdrian Chadd if (r1 == 0xffffffff || (r1 & 0xfffffff0) == 0xa5a5a5a0) 22917f1299c5SAdrian Chadd goto end; /* Hardware gone! */ 22926607310bSBenjamin Close 2293692ad7caSAdrian Chadd r2 = WPI_READ(sc, WPI_FH_INT); 22946607310bSBenjamin Close 2295692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_INTR, "%s: reg1=0x%08x reg2=0x%08x\n", __func__, 2296692ad7caSAdrian Chadd r1, r2); 2297692ad7caSAdrian Chadd 2298692ad7caSAdrian Chadd if (r1 == 0 && r2 == 0) 2299692ad7caSAdrian Chadd goto done; /* Interrupt not for us. */ 2300692ad7caSAdrian Chadd 2301692ad7caSAdrian Chadd /* Acknowledge interrupts. */ 2302692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, r1); 2303692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_INT, r2); 2304692ad7caSAdrian Chadd 2305692ad7caSAdrian Chadd if (r1 & (WPI_INT_SW_ERR | WPI_INT_HW_ERR)) { 23065efea30fSAndrew Thompson struct ieee80211com *ic = ifp->if_l2com; 23075efea30fSAndrew Thompson 23086607310bSBenjamin Close device_printf(sc->sc_dev, "fatal firmware error\n"); 2309692ad7caSAdrian Chadd wpi_fatal_intr(sc); 2310692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 2311692ad7caSAdrian Chadd "(%s)\n", (r1 & WPI_INT_SW_ERR) ? "(Software Error)" : 2312692ad7caSAdrian Chadd "(Hardware Error)"); 2313692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_reinittask); 23147f1299c5SAdrian Chadd goto end; 23156607310bSBenjamin Close } 23166607310bSBenjamin Close 2317692ad7caSAdrian Chadd if ((r1 & (WPI_INT_FH_RX | WPI_INT_SW_RX)) || 2318692ad7caSAdrian Chadd (r2 & WPI_FH_INT_RX)) 23196607310bSBenjamin Close wpi_notif_intr(sc); 23206607310bSBenjamin Close 2321692ad7caSAdrian Chadd if (r1 & WPI_INT_ALIVE) 2322692ad7caSAdrian Chadd wakeup(sc); /* Firmware is alive. */ 23236607310bSBenjamin Close 2324692ad7caSAdrian Chadd if (r1 & WPI_INT_WAKEUP) 2325692ad7caSAdrian Chadd wpi_wakeup_intr(sc); 2326692ad7caSAdrian Chadd 2327692ad7caSAdrian Chadd done: 2328692ad7caSAdrian Chadd /* Re-enable interrupts. */ 2329692ad7caSAdrian Chadd if (ifp->if_flags & IFF_UP) 2330692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); 23316607310bSBenjamin Close 23327f1299c5SAdrian Chadd end: WPI_UNLOCK(sc); 23336607310bSBenjamin Close } 23346607310bSBenjamin Close 23356607310bSBenjamin Close static int 2336692ad7caSAdrian Chadd wpi_cmd2(struct wpi_softc *sc, struct wpi_buf *buf) 23376607310bSBenjamin Close { 23386607310bSBenjamin Close struct ieee80211_frame *wh; 2339692ad7caSAdrian Chadd struct wpi_tx_cmd *cmd; 2340692ad7caSAdrian Chadd struct wpi_tx_data *data; 2341692ad7caSAdrian Chadd struct wpi_tx_desc *desc; 2342692ad7caSAdrian Chadd struct wpi_tx_ring *ring; 2343692ad7caSAdrian Chadd struct mbuf *m1; 2344692ad7caSAdrian Chadd bus_dma_segment_t *seg, segs[WPI_MAX_SCATTER]; 23458a28176aSAdrian Chadd int error, i, hdrlen, nsegs, totlen, pad; 23466607310bSBenjamin Close 234763f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 234863f57699SAdrian Chadd 2349565248e2SAdrian Chadd KASSERT(buf->size <= sizeof(buf->data), ("buffer overflow")); 2350565248e2SAdrian Chadd 2351692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2352692ad7caSAdrian Chadd 235363f57699SAdrian Chadd if (sc->txq_active == 0) { 235463f57699SAdrian Chadd /* wpi_stop() was called */ 235563f57699SAdrian Chadd error = ENETDOWN; 235663f57699SAdrian Chadd goto fail; 235763f57699SAdrian Chadd } 235863f57699SAdrian Chadd 2359692ad7caSAdrian Chadd wh = mtod(buf->m, struct ieee80211_frame *); 23608a28176aSAdrian Chadd hdrlen = ieee80211_anyhdrsize(wh); 2361692ad7caSAdrian Chadd totlen = buf->m->m_pkthdr.len; 2362692ad7caSAdrian Chadd 23638a28176aSAdrian Chadd if (hdrlen & 3) { 23648a28176aSAdrian Chadd /* First segment length must be a multiple of 4. */ 23658a28176aSAdrian Chadd pad = 4 - (hdrlen & 3); 23668a28176aSAdrian Chadd } else 23678a28176aSAdrian Chadd pad = 0; 23688a28176aSAdrian Chadd 2369692ad7caSAdrian Chadd ring = &sc->txq[buf->ac]; 23706607310bSBenjamin Close desc = &ring->desc[ring->cur]; 23716607310bSBenjamin Close data = &ring->data[ring->cur]; 23726607310bSBenjamin Close 2373692ad7caSAdrian Chadd /* Prepare TX firmware command. */ 23746607310bSBenjamin Close cmd = &ring->cmd[ring->cur]; 2375692ad7caSAdrian Chadd cmd->code = buf->code; 23766607310bSBenjamin Close cmd->flags = 0; 23776607310bSBenjamin Close cmd->qid = ring->qid; 23786607310bSBenjamin Close cmd->idx = ring->cur; 23796607310bSBenjamin Close 2380692ad7caSAdrian Chadd memcpy(cmd->data, buf->data, buf->size); 23816607310bSBenjamin Close 2382692ad7caSAdrian Chadd /* Save and trim IEEE802.11 header. */ 23838a28176aSAdrian Chadd memcpy((uint8_t *)(cmd->data + buf->size), wh, hdrlen); 23848a28176aSAdrian Chadd m_adj(buf->m, hdrlen); 23856607310bSBenjamin Close 2386692ad7caSAdrian Chadd error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, buf->m, 2387692ad7caSAdrian Chadd segs, &nsegs, BUS_DMA_NOWAIT); 23886607310bSBenjamin Close if (error != 0 && error != EFBIG) { 2389692ad7caSAdrian Chadd device_printf(sc->sc_dev, 2390692ad7caSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, error); 239163f57699SAdrian Chadd goto fail; 23926607310bSBenjamin Close } 23936607310bSBenjamin Close if (error != 0) { 2394692ad7caSAdrian Chadd /* Too many DMA segments, linearize mbuf. */ 2395893edbeaSAdrian Chadd m1 = m_collapse(buf->m, M_NOWAIT, WPI_MAX_SCATTER - 1); 2396692ad7caSAdrian Chadd if (m1 == NULL) { 23976607310bSBenjamin Close device_printf(sc->sc_dev, 2398692ad7caSAdrian Chadd "%s: could not defrag mbuf\n", __func__); 239963f57699SAdrian Chadd error = ENOBUFS; 240063f57699SAdrian Chadd goto fail; 24016607310bSBenjamin Close } 2402692ad7caSAdrian Chadd buf->m = m1; 24036607310bSBenjamin Close 24046607310bSBenjamin Close error = bus_dmamap_load_mbuf_sg(ring->data_dmat, data->map, 2405692ad7caSAdrian Chadd buf->m, segs, &nsegs, BUS_DMA_NOWAIT); 24066607310bSBenjamin Close if (error != 0) { 24076607310bSBenjamin Close device_printf(sc->sc_dev, 24087167f5fcSAdrian Chadd "%s: can't map mbuf (error %d)\n", __func__, 24097167f5fcSAdrian Chadd error); 241063f57699SAdrian Chadd goto fail; 24116607310bSBenjamin Close } 24126607310bSBenjamin Close } 24136607310bSBenjamin Close 2414893edbeaSAdrian Chadd KASSERT(nsegs < WPI_MAX_SCATTER, 2415893edbeaSAdrian Chadd ("too many DMA segments, nsegs (%d) should be less than %d", 2416893edbeaSAdrian Chadd nsegs, WPI_MAX_SCATTER)); 2417893edbeaSAdrian Chadd 2418692ad7caSAdrian Chadd data->m = buf->m; 2419692ad7caSAdrian Chadd data->ni = buf->ni; 24206607310bSBenjamin Close 2421692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: qid %d idx %d len %d nsegs %d\n", 2422692ad7caSAdrian Chadd __func__, ring->qid, ring->cur, totlen, nsegs); 24236607310bSBenjamin Close 2424692ad7caSAdrian Chadd /* Fill TX descriptor. */ 24258a28176aSAdrian Chadd desc->nsegs = WPI_PAD32(totlen + pad) << 4 | (1 + nsegs); 2426692ad7caSAdrian Chadd /* First DMA segment is used by the TX command. */ 2427692ad7caSAdrian Chadd desc->segs[0].addr = htole32(data->cmd_paddr); 24288a28176aSAdrian Chadd desc->segs[0].len = htole32(4 + buf->size + hdrlen + pad); 2429692ad7caSAdrian Chadd /* Other DMA segments are for data payload. */ 2430692ad7caSAdrian Chadd seg = &segs[0]; 24316607310bSBenjamin Close for (i = 1; i <= nsegs; i++) { 2432692ad7caSAdrian Chadd desc->segs[i].addr = htole32(seg->ds_addr); 2433692ad7caSAdrian Chadd desc->segs[i].len = htole32(seg->ds_len); 2434692ad7caSAdrian Chadd seg++; 24356607310bSBenjamin Close } 24366607310bSBenjamin Close 24376607310bSBenjamin Close bus_dmamap_sync(ring->data_dmat, data->map, BUS_DMASYNC_PREWRITE); 2438692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 2439692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 24406607310bSBenjamin Close bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 24416607310bSBenjamin Close BUS_DMASYNC_PREWRITE); 24426607310bSBenjamin Close 2443692ad7caSAdrian Chadd /* Kick TX ring. */ 24446607310bSBenjamin Close ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; 2445692ad7caSAdrian Chadd wpi_update_tx_ring(sc, ring); 2446692ad7caSAdrian Chadd 244745ac43f3SAdrian Chadd if (ring->qid < WPI_CMD_QUEUE_NUM) { 2448692ad7caSAdrian Chadd /* Mark TX ring as full if we reach a certain threshold. */ 2449692ad7caSAdrian Chadd if (++ring->queued > WPI_TX_RING_HIMARK) 2450692ad7caSAdrian Chadd sc->qfullmsk |= 1 << ring->qid; 2451692ad7caSAdrian Chadd 245210550f61SAdrian Chadd sc->sc_tx_timer = 5; 245345ac43f3SAdrian Chadd } 245410550f61SAdrian Chadd 2455692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 2456692ad7caSAdrian Chadd 245763f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 245863f57699SAdrian Chadd 2459692ad7caSAdrian Chadd return 0; 246063f57699SAdrian Chadd 246163f57699SAdrian Chadd fail: m_freem(buf->m); 246263f57699SAdrian Chadd 246363f57699SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 246463f57699SAdrian Chadd 246563f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 246663f57699SAdrian Chadd 246763f57699SAdrian Chadd return error; 2468692ad7caSAdrian Chadd } 2469692ad7caSAdrian Chadd 2470692ad7caSAdrian Chadd /* 2471692ad7caSAdrian Chadd * Construct the data packet for a transmit buffer. 2472692ad7caSAdrian Chadd */ 2473692ad7caSAdrian Chadd static int 2474692ad7caSAdrian Chadd wpi_tx_data(struct wpi_softc *sc, struct mbuf *m, struct ieee80211_node *ni) 2475692ad7caSAdrian Chadd { 2476692ad7caSAdrian Chadd const struct ieee80211_txparam *tp; 2477692ad7caSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 2478692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 2479a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 2480692ad7caSAdrian Chadd struct ieee80211_channel *chan; 2481692ad7caSAdrian Chadd struct ieee80211_frame *wh; 2482692ad7caSAdrian Chadd struct ieee80211_key *k = NULL; 2483692ad7caSAdrian Chadd struct wpi_buf tx_data; 2484565248e2SAdrian Chadd struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; 2485692ad7caSAdrian Chadd uint32_t flags; 2486692ad7caSAdrian Chadd uint16_t qos; 2487692ad7caSAdrian Chadd uint8_t tid, type; 2488f15520d9SAdrian Chadd int ac, error, swcrypt, rate, ismcast, totlen; 2489692ad7caSAdrian Chadd 2490692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2491692ad7caSAdrian Chadd type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 2492692ad7caSAdrian Chadd ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 2493692ad7caSAdrian Chadd 2494692ad7caSAdrian Chadd /* Select EDCA Access Category and TX ring for this frame. */ 2495692ad7caSAdrian Chadd if (IEEE80211_QOS_HAS_SEQ(wh)) { 2496692ad7caSAdrian Chadd qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0]; 2497692ad7caSAdrian Chadd tid = qos & IEEE80211_QOS_TID; 2498692ad7caSAdrian Chadd } else { 2499692ad7caSAdrian Chadd qos = 0; 2500692ad7caSAdrian Chadd tid = 0; 2501692ad7caSAdrian Chadd } 2502692ad7caSAdrian Chadd ac = M_WME_GETAC(m); 2503692ad7caSAdrian Chadd 2504692ad7caSAdrian Chadd chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ? 2505692ad7caSAdrian Chadd ni->ni_chan : ic->ic_curchan; 2506692ad7caSAdrian Chadd tp = &vap->iv_txparms[ieee80211_chan2mode(chan)]; 2507692ad7caSAdrian Chadd 2508692ad7caSAdrian Chadd /* Choose a TX rate index. */ 2509692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) 2510692ad7caSAdrian Chadd rate = tp->mgmtrate; 2511692ad7caSAdrian Chadd else if (ismcast) 2512692ad7caSAdrian Chadd rate = tp->mcastrate; 2513692ad7caSAdrian Chadd else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) 2514692ad7caSAdrian Chadd rate = tp->ucastrate; 2515692ad7caSAdrian Chadd else if (m->m_flags & M_EAPOL) 2516692ad7caSAdrian Chadd rate = tp->mgmtrate; 2517692ad7caSAdrian Chadd else { 2518692ad7caSAdrian Chadd /* XXX pass pktlen */ 2519692ad7caSAdrian Chadd (void) ieee80211_ratectl_rate(ni, NULL, 0); 2520692ad7caSAdrian Chadd rate = ni->ni_txrate; 2521692ad7caSAdrian Chadd } 2522692ad7caSAdrian Chadd 2523692ad7caSAdrian Chadd /* Encrypt the frame if need be. */ 2524692ad7caSAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { 2525692ad7caSAdrian Chadd /* Retrieve key for TX. */ 2526692ad7caSAdrian Chadd k = ieee80211_crypto_encap(ni, m); 2527692ad7caSAdrian Chadd if (k == NULL) { 2528692ad7caSAdrian Chadd error = ENOBUFS; 2529692ad7caSAdrian Chadd goto fail; 2530692ad7caSAdrian Chadd } 2531f15520d9SAdrian Chadd swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; 2532f15520d9SAdrian Chadd 2533692ad7caSAdrian Chadd /* 802.11 header may have moved. */ 2534692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2535692ad7caSAdrian Chadd } 25368a28176aSAdrian Chadd totlen = m->m_pkthdr.len; 2537692ad7caSAdrian Chadd 2538692ad7caSAdrian Chadd if (ieee80211_radiotap_active_vap(vap)) { 2539692ad7caSAdrian Chadd struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; 2540692ad7caSAdrian Chadd 25418a28176aSAdrian Chadd tap->wt_flags = 0; 2542692ad7caSAdrian Chadd tap->wt_rate = rate; 2543692ad7caSAdrian Chadd if (k != NULL) 2544692ad7caSAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 2545692ad7caSAdrian Chadd 2546692ad7caSAdrian Chadd ieee80211_radiotap_tx(vap, m); 2547692ad7caSAdrian Chadd } 2548692ad7caSAdrian Chadd 2549692ad7caSAdrian Chadd flags = 0; 2550692ad7caSAdrian Chadd if (!ismcast) { 2551692ad7caSAdrian Chadd /* Unicast frame, check if an ACK is expected. */ 2552692ad7caSAdrian Chadd if (!qos || (qos & IEEE80211_QOS_ACKPOLICY) != 2553692ad7caSAdrian Chadd IEEE80211_QOS_ACKPOLICY_NOACK) 2554692ad7caSAdrian Chadd flags |= WPI_TX_NEED_ACK; 2555692ad7caSAdrian Chadd } 2556692ad7caSAdrian Chadd 2557fae61c69SAdrian Chadd if (wh->i_fc[1] & IEEE80211_FC1_MORE_FRAG) 2558fae61c69SAdrian Chadd flags |= WPI_TX_MORE_FRAG; /* Cannot happen yet. */ 2559fae61c69SAdrian Chadd 2560692ad7caSAdrian Chadd /* Check if frame must be protected using RTS/CTS or CTS-to-self. */ 2561692ad7caSAdrian Chadd if (!ismcast) { 2562692ad7caSAdrian Chadd /* NB: Group frames are sent using CCK in 802.11b/g. */ 2563692ad7caSAdrian Chadd if (totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold) { 2564692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2565692ad7caSAdrian Chadd } else if ((ic->ic_flags & IEEE80211_F_USEPROT) && 2566692ad7caSAdrian Chadd WPI_RATE_IS_OFDM(rate)) { 2567692ad7caSAdrian Chadd if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 2568692ad7caSAdrian Chadd flags |= WPI_TX_NEED_CTS; 2569692ad7caSAdrian Chadd else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 2570692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2571692ad7caSAdrian Chadd } 2572692ad7caSAdrian Chadd 2573692ad7caSAdrian Chadd if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) 2574692ad7caSAdrian Chadd flags |= WPI_TX_FULL_TXOP; 2575692ad7caSAdrian Chadd } 2576692ad7caSAdrian Chadd 2577565248e2SAdrian Chadd memset(tx, 0, sizeof (struct wpi_cmd_data)); 2578692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) { 2579692ad7caSAdrian Chadd uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2580692ad7caSAdrian Chadd 2581692ad7caSAdrian Chadd /* Tell HW to set timestamp in probe responses. */ 2582692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) 2583692ad7caSAdrian Chadd flags |= WPI_TX_INSERT_TSTAMP; 2584692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || 2585692ad7caSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) 2586565248e2SAdrian Chadd tx->timeout = htole16(3); 2587692ad7caSAdrian Chadd else 2588565248e2SAdrian Chadd tx->timeout = htole16(2); 2589692ad7caSAdrian Chadd } 2590692ad7caSAdrian Chadd 2591692ad7caSAdrian Chadd if (ismcast || type != IEEE80211_FC0_TYPE_DATA) 2592565248e2SAdrian Chadd tx->id = WPI_ID_BROADCAST; 2593692ad7caSAdrian Chadd else { 2594692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) { 2595692ad7caSAdrian Chadd device_printf(sc->sc_dev, 2596692ad7caSAdrian Chadd "%s: undefined node id\n", __func__); 2597692ad7caSAdrian Chadd error = EINVAL; 2598692ad7caSAdrian Chadd goto fail; 2599692ad7caSAdrian Chadd } 2600692ad7caSAdrian Chadd 2601565248e2SAdrian Chadd tx->id = wn->id; 2602692ad7caSAdrian Chadd } 2603692ad7caSAdrian Chadd 2604692ad7caSAdrian Chadd if (type != IEEE80211_FC0_TYPE_MGT) 2605565248e2SAdrian Chadd tx->data_ntries = tp->maxretry; 2606692ad7caSAdrian Chadd 2607f15520d9SAdrian Chadd if (k != NULL && !swcrypt) { 2608f15520d9SAdrian Chadd switch (k->wk_cipher->ic_cipher) { 2609f15520d9SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 2610565248e2SAdrian Chadd tx->security = WPI_CIPHER_CCMP; 2611f15520d9SAdrian Chadd break; 2612f15520d9SAdrian Chadd 2613f15520d9SAdrian Chadd default: 2614f15520d9SAdrian Chadd break; 2615f15520d9SAdrian Chadd } 2616f15520d9SAdrian Chadd 2617565248e2SAdrian Chadd memcpy(tx->key, k->wk_key, k->wk_keylen); 2618f15520d9SAdrian Chadd } 2619f15520d9SAdrian Chadd 2620565248e2SAdrian Chadd tx->len = htole16(totlen); 2621565248e2SAdrian Chadd tx->flags = htole32(flags); 2622565248e2SAdrian Chadd tx->plcp = rate2plcp(rate); 2623565248e2SAdrian Chadd tx->tid = tid; 2624565248e2SAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 2625565248e2SAdrian Chadd tx->ofdm_mask = 0xff; 2626565248e2SAdrian Chadd tx->cck_mask = 0x0f; 2627565248e2SAdrian Chadd tx->rts_ntries = 7; 2628692ad7caSAdrian Chadd 2629692ad7caSAdrian Chadd tx_data.ni = ni; 2630692ad7caSAdrian Chadd tx_data.m = m; 2631565248e2SAdrian Chadd tx_data.size = sizeof(struct wpi_cmd_data); 2632692ad7caSAdrian Chadd tx_data.code = WPI_CMD_TX_DATA; 2633692ad7caSAdrian Chadd tx_data.ac = ac; 2634692ad7caSAdrian Chadd 2635692ad7caSAdrian Chadd return wpi_cmd2(sc, &tx_data); 2636692ad7caSAdrian Chadd 2637692ad7caSAdrian Chadd fail: m_freem(m); 2638692ad7caSAdrian Chadd return error; 2639692ad7caSAdrian Chadd } 2640692ad7caSAdrian Chadd 2641692ad7caSAdrian Chadd static int 26427167f5fcSAdrian Chadd wpi_tx_data_raw(struct wpi_softc *sc, struct mbuf *m, 26437167f5fcSAdrian Chadd struct ieee80211_node *ni, const struct ieee80211_bpf_params *params) 2644692ad7caSAdrian Chadd { 2645692ad7caSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 2646*735c6067SAdrian Chadd struct ieee80211_key *k = NULL; 2647692ad7caSAdrian Chadd struct ieee80211_frame *wh; 2648692ad7caSAdrian Chadd struct wpi_buf tx_data; 2649565248e2SAdrian Chadd struct wpi_cmd_data *tx = (struct wpi_cmd_data *)&tx_data.data; 2650692ad7caSAdrian Chadd uint32_t flags; 2651692ad7caSAdrian Chadd uint8_t type; 2652*735c6067SAdrian Chadd int ac, rate, swcrypt, totlen; 2653692ad7caSAdrian Chadd 2654692ad7caSAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2655692ad7caSAdrian Chadd type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 2656692ad7caSAdrian Chadd 2657692ad7caSAdrian Chadd ac = params->ibp_pri & 3; 2658692ad7caSAdrian Chadd 2659692ad7caSAdrian Chadd /* Choose a TX rate index. */ 2660692ad7caSAdrian Chadd rate = params->ibp_rate0; 2661692ad7caSAdrian Chadd 2662692ad7caSAdrian Chadd flags = 0; 2663692ad7caSAdrian Chadd if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0) 2664692ad7caSAdrian Chadd flags |= WPI_TX_NEED_ACK; 2665692ad7caSAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_RTS) 2666692ad7caSAdrian Chadd flags |= WPI_TX_NEED_RTS; 2667692ad7caSAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CTS) 2668692ad7caSAdrian Chadd flags |= WPI_TX_NEED_CTS; 2669692ad7caSAdrian Chadd if (flags & (WPI_TX_NEED_RTS | WPI_TX_NEED_CTS)) 2670692ad7caSAdrian Chadd flags |= WPI_TX_FULL_TXOP; 2671692ad7caSAdrian Chadd 2672*735c6067SAdrian Chadd /* Encrypt the frame if need be. */ 2673*735c6067SAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CRYPTO) { 2674*735c6067SAdrian Chadd /* Retrieve key for TX. */ 2675*735c6067SAdrian Chadd k = ieee80211_crypto_encap(ni, m); 2676*735c6067SAdrian Chadd if (k == NULL) { 2677*735c6067SAdrian Chadd m_freem(m); 2678*735c6067SAdrian Chadd return ENOBUFS; 2679*735c6067SAdrian Chadd } 2680*735c6067SAdrian Chadd swcrypt = k->wk_flags & IEEE80211_KEY_SWCRYPT; 2681*735c6067SAdrian Chadd 2682*735c6067SAdrian Chadd /* 802.11 header may have moved. */ 2683*735c6067SAdrian Chadd wh = mtod(m, struct ieee80211_frame *); 2684*735c6067SAdrian Chadd } 2685*735c6067SAdrian Chadd totlen = m->m_pkthdr.len; 2686*735c6067SAdrian Chadd 2687692ad7caSAdrian Chadd if (ieee80211_radiotap_active_vap(vap)) { 2688692ad7caSAdrian Chadd struct wpi_tx_radiotap_header *tap = &sc->sc_txtap; 2689692ad7caSAdrian Chadd 2690692ad7caSAdrian Chadd tap->wt_flags = 0; 2691692ad7caSAdrian Chadd tap->wt_rate = rate; 2692*735c6067SAdrian Chadd if (params->ibp_flags & IEEE80211_BPF_CRYPTO) 2693*735c6067SAdrian Chadd tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 2694692ad7caSAdrian Chadd 2695692ad7caSAdrian Chadd ieee80211_radiotap_tx(vap, m); 2696692ad7caSAdrian Chadd } 2697692ad7caSAdrian Chadd 2698565248e2SAdrian Chadd memset(tx, 0, sizeof (struct wpi_cmd_data)); 2699692ad7caSAdrian Chadd if (type == IEEE80211_FC0_TYPE_MGT) { 2700692ad7caSAdrian Chadd uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2701692ad7caSAdrian Chadd 2702692ad7caSAdrian Chadd /* Tell HW to set timestamp in probe responses. */ 2703692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP) 2704692ad7caSAdrian Chadd flags |= WPI_TX_INSERT_TSTAMP; 2705692ad7caSAdrian Chadd if (subtype == IEEE80211_FC0_SUBTYPE_ASSOC_REQ || 2706692ad7caSAdrian Chadd subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) 2707565248e2SAdrian Chadd tx->timeout = htole16(3); 2708692ad7caSAdrian Chadd else 2709565248e2SAdrian Chadd tx->timeout = htole16(2); 2710692ad7caSAdrian Chadd } 2711692ad7caSAdrian Chadd 2712*735c6067SAdrian Chadd if (k != NULL && !swcrypt) { 2713*735c6067SAdrian Chadd switch (k->wk_cipher->ic_cipher) { 2714*735c6067SAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 2715*735c6067SAdrian Chadd tx->security = WPI_CIPHER_CCMP; 2716*735c6067SAdrian Chadd break; 2717*735c6067SAdrian Chadd 2718*735c6067SAdrian Chadd default: 2719*735c6067SAdrian Chadd break; 2720*735c6067SAdrian Chadd } 2721*735c6067SAdrian Chadd 2722*735c6067SAdrian Chadd memcpy(tx->key, k->wk_key, k->wk_keylen); 2723*735c6067SAdrian Chadd } 2724*735c6067SAdrian Chadd 2725565248e2SAdrian Chadd tx->len = htole16(totlen); 2726565248e2SAdrian Chadd tx->flags = htole32(flags); 2727565248e2SAdrian Chadd tx->plcp = rate2plcp(rate); 2728565248e2SAdrian Chadd tx->id = WPI_ID_BROADCAST; 2729565248e2SAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 2730565248e2SAdrian Chadd tx->rts_ntries = params->ibp_try1; 2731565248e2SAdrian Chadd tx->data_ntries = params->ibp_try0; 2732692ad7caSAdrian Chadd 2733692ad7caSAdrian Chadd tx_data.ni = ni; 2734692ad7caSAdrian Chadd tx_data.m = m; 2735565248e2SAdrian Chadd tx_data.size = sizeof(struct wpi_cmd_data); 2736692ad7caSAdrian Chadd tx_data.code = WPI_CMD_TX_DATA; 2737692ad7caSAdrian Chadd tx_data.ac = ac; 2738692ad7caSAdrian Chadd 2739692ad7caSAdrian Chadd return wpi_cmd2(sc, &tx_data); 2740692ad7caSAdrian Chadd } 2741692ad7caSAdrian Chadd 2742692ad7caSAdrian Chadd static int 2743692ad7caSAdrian Chadd wpi_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 2744692ad7caSAdrian Chadd const struct ieee80211_bpf_params *params) 2745692ad7caSAdrian Chadd { 2746692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 2747692ad7caSAdrian Chadd struct ifnet *ifp = ic->ic_ifp; 2748692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 2749692ad7caSAdrian Chadd int error = 0; 2750692ad7caSAdrian Chadd 2751692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2752692ad7caSAdrian Chadd 2753692ad7caSAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { 2754692ad7caSAdrian Chadd ieee80211_free_node(ni); 2755692ad7caSAdrian Chadd m_freem(m); 2756692ad7caSAdrian Chadd return ENETDOWN; 2757692ad7caSAdrian Chadd } 2758692ad7caSAdrian Chadd 2759692ad7caSAdrian Chadd WPI_LOCK(sc); 2760692ad7caSAdrian Chadd if (params == NULL) { 2761692ad7caSAdrian Chadd /* 2762692ad7caSAdrian Chadd * Legacy path; interpret frame contents to decide 2763692ad7caSAdrian Chadd * precisely how to send the frame. 2764692ad7caSAdrian Chadd */ 2765692ad7caSAdrian Chadd error = wpi_tx_data(sc, m, ni); 2766692ad7caSAdrian Chadd } else { 2767692ad7caSAdrian Chadd /* 2768692ad7caSAdrian Chadd * Caller supplied explicit parameters to use in 2769692ad7caSAdrian Chadd * sending the frame. 2770692ad7caSAdrian Chadd */ 2771692ad7caSAdrian Chadd error = wpi_tx_data_raw(sc, m, ni, params); 2772692ad7caSAdrian Chadd } 2773692ad7caSAdrian Chadd WPI_UNLOCK(sc); 2774692ad7caSAdrian Chadd 2775692ad7caSAdrian Chadd if (error != 0) { 2776692ad7caSAdrian Chadd /* NB: m is reclaimed on tx failure */ 2777692ad7caSAdrian Chadd ieee80211_free_node(ni); 2778692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 2779692ad7caSAdrian Chadd 2780692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 2781692ad7caSAdrian Chadd 2782692ad7caSAdrian Chadd return error; 2783692ad7caSAdrian Chadd } 2784692ad7caSAdrian Chadd 2785692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 27866607310bSBenjamin Close 27876607310bSBenjamin Close return 0; 27886607310bSBenjamin Close } 27896607310bSBenjamin Close 27906607310bSBenjamin Close /** 27916607310bSBenjamin Close * Process data waiting to be sent on the IFNET output queue 27926607310bSBenjamin Close */ 27936607310bSBenjamin Close static void 27946607310bSBenjamin Close wpi_start(struct ifnet *ifp) 27956607310bSBenjamin Close { 27966607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 2797b032f27cSSam Leffler 2798b032f27cSSam Leffler WPI_LOCK(sc); 2799b032f27cSSam Leffler wpi_start_locked(ifp); 2800b032f27cSSam Leffler WPI_UNLOCK(sc); 2801b032f27cSSam Leffler } 2802b032f27cSSam Leffler 2803b032f27cSSam Leffler static void 2804b032f27cSSam Leffler wpi_start_locked(struct ifnet *ifp) 2805b032f27cSSam Leffler { 2806b032f27cSSam Leffler struct wpi_softc *sc = ifp->if_softc; 28076607310bSBenjamin Close struct ieee80211_node *ni; 2808b032f27cSSam Leffler struct mbuf *m; 2809b032f27cSSam Leffler 2810b032f27cSSam Leffler WPI_LOCK_ASSERT(sc); 28116607310bSBenjamin Close 2812692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: called\n", __func__); 2813692ad7caSAdrian Chadd 2814692ad7caSAdrian Chadd if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0 || 2815692ad7caSAdrian Chadd (ifp->if_drv_flags & IFF_DRV_OACTIVE)) 281682f1b132SAndrew Thompson return; 281782f1b132SAndrew Thompson 28186607310bSBenjamin Close for (;;) { 2819692ad7caSAdrian Chadd if (sc->qfullmsk != 0) { 2820692ad7caSAdrian Chadd ifp->if_drv_flags |= IFF_DRV_OACTIVE; 2821692ad7caSAdrian Chadd break; 2822692ad7caSAdrian Chadd } 2823fcec677dSJuli Mallett IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 2824b032f27cSSam Leffler if (m == NULL) 28256607310bSBenjamin Close break; 2826b032f27cSSam Leffler ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 2827692ad7caSAdrian Chadd if (wpi_tx_data(sc, m, ni) != 0) { 2828692ad7caSAdrian Chadd WPI_UNLOCK(sc); 28296607310bSBenjamin Close ieee80211_free_node(ni); 2830b032f27cSSam Leffler WPI_LOCK(sc); 2831692ad7caSAdrian Chadd if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 283210550f61SAdrian Chadd } 2833b032f27cSSam Leffler } 2834b032f27cSSam Leffler 2835692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_XMIT, "%s: done\n", __func__); 2836692ad7caSAdrian Chadd } 2837b032f27cSSam Leffler 2838692ad7caSAdrian Chadd static void 28394eaf2ee3SAdrian Chadd wpi_start_task(void *arg0, int pending) 28404eaf2ee3SAdrian Chadd { 28414eaf2ee3SAdrian Chadd struct wpi_softc *sc = arg0; 28424eaf2ee3SAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 28434eaf2ee3SAdrian Chadd 28444eaf2ee3SAdrian Chadd wpi_start(ifp); 28454eaf2ee3SAdrian Chadd } 28464eaf2ee3SAdrian Chadd 28474eaf2ee3SAdrian Chadd static void 2848692ad7caSAdrian Chadd wpi_watchdog_rfkill(void *arg) 2849692ad7caSAdrian Chadd { 2850692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 2851692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 2852692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 2853692ad7caSAdrian Chadd 2854692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_WATCHDOG, "RFkill Watchdog: tick\n"); 2855692ad7caSAdrian Chadd 2856692ad7caSAdrian Chadd /* No need to lock firmware memory. */ 2857692ad7caSAdrian Chadd if ((wpi_prph_read(sc, WPI_APMG_RFKILL) & 0x1) == 0) { 2858692ad7caSAdrian Chadd /* Radio kill switch is still off. */ 2859692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, 2860692ad7caSAdrian Chadd sc); 2861692ad7caSAdrian Chadd } else 2862692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_radioon_task); 2863692ad7caSAdrian Chadd } 2864692ad7caSAdrian Chadd 2865692ad7caSAdrian Chadd /** 2866692ad7caSAdrian Chadd * Called every second, wpi_watchdog used by the watch dog timer 2867692ad7caSAdrian Chadd * to check that the card is still alive 2868692ad7caSAdrian Chadd */ 2869692ad7caSAdrian Chadd static void 2870692ad7caSAdrian Chadd wpi_watchdog(void *arg) 2871692ad7caSAdrian Chadd { 2872692ad7caSAdrian Chadd struct wpi_softc *sc = arg; 2873692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 2874692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 2875692ad7caSAdrian Chadd 2876692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_WATCHDOG, "Watchdog: tick\n"); 2877692ad7caSAdrian Chadd 2878692ad7caSAdrian Chadd if (sc->sc_tx_timer > 0) { 2879692ad7caSAdrian Chadd if (--sc->sc_tx_timer == 0) { 2880692ad7caSAdrian Chadd if_printf(ifp, "device timeout\n"); 2881c8dfaf38SGleb Smirnoff if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 2882692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_reinittask); 2883692ad7caSAdrian Chadd } 2884692ad7caSAdrian Chadd } 2885692ad7caSAdrian Chadd 2886692ad7caSAdrian Chadd if (sc->sc_scan_timer > 0) { 2887692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2888692ad7caSAdrian Chadd if (--sc->sc_scan_timer == 0 && vap != NULL) { 2889692ad7caSAdrian Chadd if_printf(ifp, "scan timeout\n"); 2890692ad7caSAdrian Chadd ieee80211_cancel_scan(vap); 2891692ad7caSAdrian Chadd ieee80211_runtask(ic, &sc->sc_reinittask); 2892692ad7caSAdrian Chadd } 2893692ad7caSAdrian Chadd } 2894692ad7caSAdrian Chadd 2895692ad7caSAdrian Chadd if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2896692ad7caSAdrian Chadd callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); 28976607310bSBenjamin Close } 28986607310bSBenjamin Close 28996607310bSBenjamin Close static int 29006607310bSBenjamin Close wpi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 29016607310bSBenjamin Close { 29026607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 2903b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 2904692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2905b032f27cSSam Leffler struct ifreq *ifr = (struct ifreq *) data; 2906692ad7caSAdrian Chadd int error = 0, startall = 0, stop = 0; 29076607310bSBenjamin Close 29086607310bSBenjamin Close switch (cmd) { 2909692ad7caSAdrian Chadd case SIOCGIFADDR: 2910692ad7caSAdrian Chadd error = ether_ioctl(ifp, cmd, data); 2911692ad7caSAdrian Chadd break; 29126607310bSBenjamin Close case SIOCSIFFLAGS: 291331a8c1edSAndrew Thompson WPI_LOCK(sc); 2914692ad7caSAdrian Chadd if (ifp->if_flags & IFF_UP) { 2915b032f27cSSam Leffler if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { 2916692ad7caSAdrian Chadd wpi_init_locked(sc); 2917692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & 2918692ad7caSAdrian Chadd WPI_GP_CNTRL_RFKILL) 2919b032f27cSSam Leffler startall = 1; 2920692ad7caSAdrian Chadd else 2921692ad7caSAdrian Chadd stop = 1; 2922b032f27cSSam Leffler } 2923692ad7caSAdrian Chadd } else if (ifp->if_drv_flags & IFF_DRV_RUNNING) 29246607310bSBenjamin Close wpi_stop_locked(sc); 29256607310bSBenjamin Close WPI_UNLOCK(sc); 2926b032f27cSSam Leffler if (startall) 2927b032f27cSSam Leffler ieee80211_start_all(ic); 2928692ad7caSAdrian Chadd else if (vap != NULL && stop) 2929692ad7caSAdrian Chadd ieee80211_stop(vap); 293031a8c1edSAndrew Thompson break; 293131a8c1edSAndrew Thompson case SIOCGIFMEDIA: 293231a8c1edSAndrew Thompson error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 293331a8c1edSAndrew Thompson break; 293431a8c1edSAndrew Thompson default: 293531a8c1edSAndrew Thompson error = EINVAL; 293631a8c1edSAndrew Thompson break; 293731a8c1edSAndrew Thompson } 29386607310bSBenjamin Close return error; 29396607310bSBenjamin Close } 29406607310bSBenjamin Close 29416607310bSBenjamin Close /* 29426607310bSBenjamin Close * Send a command to the firmware. 29436607310bSBenjamin Close */ 29446607310bSBenjamin Close static int 2945692ad7caSAdrian Chadd wpi_cmd(struct wpi_softc *sc, int code, const void *buf, size_t size, 2946692ad7caSAdrian Chadd int async) 29476607310bSBenjamin Close { 29488e4cf38aSAdrian Chadd struct wpi_tx_ring *ring = &sc->txq[WPI_CMD_QUEUE_NUM]; 29496607310bSBenjamin Close struct wpi_tx_desc *desc; 2950692ad7caSAdrian Chadd struct wpi_tx_data *data; 29516607310bSBenjamin Close struct wpi_tx_cmd *cmd; 2952692ad7caSAdrian Chadd struct mbuf *m; 2953692ad7caSAdrian Chadd bus_addr_t paddr; 2954692ad7caSAdrian Chadd int totlen, error; 29556607310bSBenjamin Close 295663f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 295763f57699SAdrian Chadd 2958692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 2959692ad7caSAdrian Chadd 296063f57699SAdrian Chadd if (sc->txq_active == 0) { 296163f57699SAdrian Chadd /* wpi_stop() was called */ 296263f57699SAdrian Chadd error = 0; 296363f57699SAdrian Chadd goto fail; 296463f57699SAdrian Chadd } 296563f57699SAdrian Chadd 2966692ad7caSAdrian Chadd if (async == 0) 29676607310bSBenjamin Close WPI_LOCK_ASSERT(sc); 29686607310bSBenjamin Close 2969692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "wpi_cmd %s size %zu async %d\n", 2970692ad7caSAdrian Chadd wpi_cmd_str(code), size, async); 29716607310bSBenjamin Close 29726607310bSBenjamin Close desc = &ring->desc[ring->cur]; 2973692ad7caSAdrian Chadd data = &ring->data[ring->cur]; 2974692ad7caSAdrian Chadd totlen = 4 + size; 2975692ad7caSAdrian Chadd 2976692ad7caSAdrian Chadd if (size > sizeof cmd->data) { 2977692ad7caSAdrian Chadd /* Command is too large to fit in a descriptor. */ 297863f57699SAdrian Chadd if (totlen > MCLBYTES) { 297963f57699SAdrian Chadd error = EINVAL; 298063f57699SAdrian Chadd goto fail; 298163f57699SAdrian Chadd } 2982692ad7caSAdrian Chadd m = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE); 298363f57699SAdrian Chadd if (m == NULL) { 298463f57699SAdrian Chadd error = ENOMEM; 298563f57699SAdrian Chadd goto fail; 298663f57699SAdrian Chadd } 2987692ad7caSAdrian Chadd cmd = mtod(m, struct wpi_tx_cmd *); 2988692ad7caSAdrian Chadd error = bus_dmamap_load(ring->data_dmat, data->map, cmd, 2989692ad7caSAdrian Chadd totlen, wpi_dma_map_addr, &paddr, BUS_DMA_NOWAIT); 2990692ad7caSAdrian Chadd if (error != 0) { 2991692ad7caSAdrian Chadd m_freem(m); 299263f57699SAdrian Chadd goto fail; 2993692ad7caSAdrian Chadd } 2994692ad7caSAdrian Chadd data->m = m; 2995692ad7caSAdrian Chadd } else { 29966607310bSBenjamin Close cmd = &ring->cmd[ring->cur]; 2997692ad7caSAdrian Chadd paddr = data->cmd_paddr; 2998692ad7caSAdrian Chadd } 29996607310bSBenjamin Close 30006607310bSBenjamin Close cmd->code = code; 30016607310bSBenjamin Close cmd->flags = 0; 30026607310bSBenjamin Close cmd->qid = ring->qid; 30036607310bSBenjamin Close cmd->idx = ring->cur; 30046607310bSBenjamin Close memcpy(cmd->data, buf, size); 30056607310bSBenjamin Close 3006692ad7caSAdrian Chadd desc->nsegs = 1 + (WPI_PAD32(size) << 4); 3007692ad7caSAdrian Chadd desc->segs[0].addr = htole32(paddr); 3008692ad7caSAdrian Chadd desc->segs[0].len = htole32(totlen); 30096607310bSBenjamin Close 3010692ad7caSAdrian Chadd if (size > sizeof cmd->data) { 3011692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, data->map, 3012692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3013692ad7caSAdrian Chadd } else { 3014692ad7caSAdrian Chadd bus_dmamap_sync(ring->data_dmat, ring->cmd_dma.map, 3015692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3016692ad7caSAdrian Chadd } 3017692ad7caSAdrian Chadd bus_dmamap_sync(ring->desc_dma.tag, ring->desc_dma.map, 3018692ad7caSAdrian Chadd BUS_DMASYNC_PREWRITE); 3019692ad7caSAdrian Chadd 3020692ad7caSAdrian Chadd /* Kick command ring. */ 3021692ad7caSAdrian Chadd ring->cur = (ring->cur + 1) % WPI_TX_RING_COUNT; 3022692ad7caSAdrian Chadd wpi_update_tx_ring(sc, ring); 3023692ad7caSAdrian Chadd 3024692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 30256607310bSBenjamin Close 302663f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 302763f57699SAdrian Chadd 3028ff62db1dSAdrian Chadd if (async) 30296607310bSBenjamin Close return 0; 30306607310bSBenjamin Close 303176fdf7ebSAdrian Chadd return mtx_sleep(cmd, &sc->sc_mtx, PCATCH, "wpicmd", hz); 303263f57699SAdrian Chadd 303363f57699SAdrian Chadd fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 303463f57699SAdrian Chadd 303563f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 303663f57699SAdrian Chadd 303763f57699SAdrian Chadd return error; 30386607310bSBenjamin Close } 30396607310bSBenjamin Close 30406607310bSBenjamin Close /* 3041692ad7caSAdrian Chadd * Configure HW multi-rate retries. 30426607310bSBenjamin Close */ 30436607310bSBenjamin Close static int 30446607310bSBenjamin Close wpi_mrr_setup(struct wpi_softc *sc) 30456607310bSBenjamin Close { 3046b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 3047b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 30486607310bSBenjamin Close struct wpi_mrr_setup mrr; 30496607310bSBenjamin Close int i, error; 30506607310bSBenjamin Close 3051692ad7caSAdrian Chadd /* CCK rates (not used with 802.11a). */ 3052692ad7caSAdrian Chadd for (i = WPI_RIDX_CCK1; i <= WPI_RIDX_CCK11; i++) { 30536607310bSBenjamin Close mrr.rates[i].flags = 0; 3054692ad7caSAdrian Chadd mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; 3055692ad7caSAdrian Chadd /* Fallback to the immediate lower CCK rate (if any.) */ 3056692ad7caSAdrian Chadd mrr.rates[i].next = 3057692ad7caSAdrian Chadd (i == WPI_RIDX_CCK1) ? WPI_RIDX_CCK1 : i - 1; 3058692ad7caSAdrian Chadd /* Try one time at this rate before falling back to "next". */ 30596607310bSBenjamin Close mrr.rates[i].ntries = 1; 30606607310bSBenjamin Close } 3061692ad7caSAdrian Chadd /* OFDM rates (not used with 802.11b). */ 3062692ad7caSAdrian Chadd for (i = WPI_RIDX_OFDM6; i <= WPI_RIDX_OFDM54; i++) { 30636607310bSBenjamin Close mrr.rates[i].flags = 0; 3064692ad7caSAdrian Chadd mrr.rates[i].plcp = wpi_ridx_to_plcp[i]; 3065692ad7caSAdrian Chadd /* Fallback to the immediate lower rate (if any.) */ 3066692ad7caSAdrian Chadd /* We allow fallback from OFDM/6 to CCK/2 in 11b/g mode. */ 3067692ad7caSAdrian Chadd mrr.rates[i].next = (i == WPI_RIDX_OFDM6) ? 30686607310bSBenjamin Close ((ic->ic_curmode == IEEE80211_MODE_11A) ? 3069692ad7caSAdrian Chadd WPI_RIDX_OFDM6 : WPI_RIDX_CCK2) : 30706607310bSBenjamin Close i - 1; 3071692ad7caSAdrian Chadd /* Try one time at this rate before falling back to "next". */ 30726607310bSBenjamin Close mrr.rates[i].ntries = 1; 30736607310bSBenjamin Close } 3074692ad7caSAdrian Chadd /* Setup MRR for control frames. */ 3075692ad7caSAdrian Chadd mrr.which = htole32(WPI_MRR_CTL); 30766607310bSBenjamin Close error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); 30776607310bSBenjamin Close if (error != 0) { 30786607310bSBenjamin Close device_printf(sc->sc_dev, 30796607310bSBenjamin Close "could not setup MRR for control frames\n"); 30806607310bSBenjamin Close return error; 30816607310bSBenjamin Close } 3082692ad7caSAdrian Chadd /* Setup MRR for data frames. */ 3083692ad7caSAdrian Chadd mrr.which = htole32(WPI_MRR_DATA); 30846607310bSBenjamin Close error = wpi_cmd(sc, WPI_CMD_MRR_SETUP, &mrr, sizeof mrr, 0); 30856607310bSBenjamin Close if (error != 0) { 30866607310bSBenjamin Close device_printf(sc->sc_dev, 30876607310bSBenjamin Close "could not setup MRR for data frames\n"); 30886607310bSBenjamin Close return error; 30896607310bSBenjamin Close } 30906607310bSBenjamin Close return 0; 30916607310bSBenjamin Close } 30926607310bSBenjamin Close 3093692ad7caSAdrian Chadd static int 3094692ad7caSAdrian Chadd wpi_add_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3095692ad7caSAdrian Chadd { 3096692ad7caSAdrian Chadd struct ieee80211com *ic = ni->ni_ic; 3097a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3098692ad7caSAdrian Chadd struct wpi_node_info node; 3099692ad7caSAdrian Chadd 3100692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3101692ad7caSAdrian Chadd 3102692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) 3103692ad7caSAdrian Chadd return EINVAL; 3104692ad7caSAdrian Chadd 3105692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 31063de934a7SAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); 3107692ad7caSAdrian Chadd node.id = wn->id; 3108692ad7caSAdrian Chadd node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 3109692ad7caSAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3110692ad7caSAdrian Chadd node.action = htole32(WPI_ACTION_SET_RATE); 3111692ad7caSAdrian Chadd node.antenna = WPI_ANTENNA_BOTH; 3112692ad7caSAdrian Chadd 3113692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 3114692ad7caSAdrian Chadd } 3115692ad7caSAdrian Chadd 3116692ad7caSAdrian Chadd /* 3117692ad7caSAdrian Chadd * Broadcast node is used to send group-addressed and management frames. 3118692ad7caSAdrian Chadd */ 3119692ad7caSAdrian Chadd static int 3120692ad7caSAdrian Chadd wpi_add_broadcast_node(struct wpi_softc *sc, int async) 3121692ad7caSAdrian Chadd { 3122692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3123692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 3124692ad7caSAdrian Chadd struct wpi_node_info node; 3125692ad7caSAdrian Chadd 3126692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3127692ad7caSAdrian Chadd 3128692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 3129692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ifp->if_broadcastaddr); 3130692ad7caSAdrian Chadd node.id = WPI_ID_BROADCAST; 3131692ad7caSAdrian Chadd node.plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 3132692ad7caSAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3133692ad7caSAdrian Chadd node.action = htole32(WPI_ACTION_SET_RATE); 3134692ad7caSAdrian Chadd node.antenna = WPI_ANTENNA_BOTH; 3135692ad7caSAdrian Chadd 3136692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, async); 3137692ad7caSAdrian Chadd } 3138692ad7caSAdrian Chadd 3139692ad7caSAdrian Chadd static int 31400ebca245SAdrian Chadd wpi_add_sta_node(struct wpi_softc *sc, struct ieee80211_node *ni) 31410ebca245SAdrian Chadd { 31420ebca245SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 31430ebca245SAdrian Chadd int error; 31440ebca245SAdrian Chadd 31450ebca245SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 31460ebca245SAdrian Chadd 31470ebca245SAdrian Chadd wn->id = wpi_add_node_entry_sta(sc); 31480ebca245SAdrian Chadd 31490ebca245SAdrian Chadd if ((error = wpi_add_node(sc, ni)) != 0) { 31500ebca245SAdrian Chadd wpi_del_node_entry(sc, wn->id); 31510ebca245SAdrian Chadd wn->id = WPI_ID_UNDEFINED; 31520ebca245SAdrian Chadd return error; 31530ebca245SAdrian Chadd } 31540ebca245SAdrian Chadd 31550ebca245SAdrian Chadd return 0; 31560ebca245SAdrian Chadd } 31570ebca245SAdrian Chadd 31580ebca245SAdrian Chadd static int 3159692ad7caSAdrian Chadd wpi_add_ibss_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3160692ad7caSAdrian Chadd { 3161a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3162eca2eb39SAdrian Chadd int error; 3163692ad7caSAdrian Chadd 3164692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3165692ad7caSAdrian Chadd 3166692ad7caSAdrian Chadd if (wn->id != WPI_ID_UNDEFINED) 3167692ad7caSAdrian Chadd return EINVAL; 3168692ad7caSAdrian Chadd 3169eca2eb39SAdrian Chadd if ((wn->id = wpi_add_node_entry_adhoc(sc)) == WPI_ID_UNDEFINED) { 3170eca2eb39SAdrian Chadd device_printf(sc->sc_dev, "%s: h/w table is full\n", __func__); 3171eca2eb39SAdrian Chadd return ENOMEM; 3172eca2eb39SAdrian Chadd } 3173692ad7caSAdrian Chadd 3174eca2eb39SAdrian Chadd if ((error = wpi_add_node(sc, ni)) != 0) { 3175eca2eb39SAdrian Chadd wpi_del_node_entry(sc, wn->id); 3176eca2eb39SAdrian Chadd wn->id = WPI_ID_UNDEFINED; 3177eca2eb39SAdrian Chadd return error; 3178eca2eb39SAdrian Chadd } 3179692ad7caSAdrian Chadd 3180eca2eb39SAdrian Chadd return 0; 3181692ad7caSAdrian Chadd } 3182692ad7caSAdrian Chadd 3183692ad7caSAdrian Chadd static void 3184692ad7caSAdrian Chadd wpi_del_node(struct wpi_softc *sc, struct ieee80211_node *ni) 3185692ad7caSAdrian Chadd { 3186a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 3187692ad7caSAdrian Chadd struct wpi_cmd_del_node node; 3188692ad7caSAdrian Chadd int error; 3189692ad7caSAdrian Chadd 3190692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3191692ad7caSAdrian Chadd 3192692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) { 3193692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: undefined node id passed\n", 3194692ad7caSAdrian Chadd __func__); 3195692ad7caSAdrian Chadd return; 3196692ad7caSAdrian Chadd } 3197692ad7caSAdrian Chadd 3198692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 31993de934a7SAdrian Chadd IEEE80211_ADDR_COPY(node.macaddr, ni->ni_macaddr); 3200692ad7caSAdrian Chadd node.count = 1; 3201692ad7caSAdrian Chadd 3202692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_DEL_NODE, &node, sizeof node, 1); 3203692ad7caSAdrian Chadd if (error != 0) { 3204692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3205692ad7caSAdrian Chadd "%s: could not delete node %u, error %d\n", __func__, 3206692ad7caSAdrian Chadd wn->id, error); 3207692ad7caSAdrian Chadd } 3208692ad7caSAdrian Chadd } 3209692ad7caSAdrian Chadd 3210692ad7caSAdrian Chadd static int 3211692ad7caSAdrian Chadd wpi_updateedca(struct ieee80211com *ic) 3212692ad7caSAdrian Chadd { 3213692ad7caSAdrian Chadd #define WPI_EXP2(x) ((1 << (x)) - 1) /* CWmin = 2^ECWmin - 1 */ 3214692ad7caSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 3215692ad7caSAdrian Chadd struct wpi_edca_params cmd; 3216692ad7caSAdrian Chadd int aci, error; 3217692ad7caSAdrian Chadd 3218692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3219692ad7caSAdrian Chadd 3220692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3221692ad7caSAdrian Chadd cmd.flags = htole32(WPI_EDCA_UPDATE); 3222692ad7caSAdrian Chadd for (aci = 0; aci < WME_NUM_AC; aci++) { 3223692ad7caSAdrian Chadd const struct wmeParams *ac = 3224692ad7caSAdrian Chadd &ic->ic_wme.wme_chanParams.cap_wmeParams[aci]; 3225692ad7caSAdrian Chadd cmd.ac[aci].aifsn = ac->wmep_aifsn; 3226692ad7caSAdrian Chadd cmd.ac[aci].cwmin = htole16(WPI_EXP2(ac->wmep_logcwmin)); 3227692ad7caSAdrian Chadd cmd.ac[aci].cwmax = htole16(WPI_EXP2(ac->wmep_logcwmax)); 3228692ad7caSAdrian Chadd cmd.ac[aci].txoplimit = 3229692ad7caSAdrian Chadd htole16(IEEE80211_TXOP_TO_US(ac->wmep_txopLimit)); 3230692ad7caSAdrian Chadd 3231692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_EDCA, 3232692ad7caSAdrian Chadd "setting WME for queue %d aifsn=%d cwmin=%d cwmax=%d " 3233692ad7caSAdrian Chadd "txoplimit=%d\n", aci, cmd.ac[aci].aifsn, 3234692ad7caSAdrian Chadd cmd.ac[aci].cwmin, cmd.ac[aci].cwmax, 3235692ad7caSAdrian Chadd cmd.ac[aci].txoplimit); 3236692ad7caSAdrian Chadd } 3237692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_EDCA_PARAMS, &cmd, sizeof cmd, 1); 3238692ad7caSAdrian Chadd 3239692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3240692ad7caSAdrian Chadd 3241692ad7caSAdrian Chadd return error; 3242692ad7caSAdrian Chadd #undef WPI_EXP2 3243692ad7caSAdrian Chadd } 3244692ad7caSAdrian Chadd 3245692ad7caSAdrian Chadd static void 3246692ad7caSAdrian Chadd wpi_set_promisc(struct wpi_softc *sc) 3247692ad7caSAdrian Chadd { 3248692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3249692ad7caSAdrian Chadd uint32_t promisc_filter; 3250692ad7caSAdrian Chadd 3251692ad7caSAdrian Chadd promisc_filter = WPI_FILTER_PROMISC | WPI_FILTER_CTL; 3252692ad7caSAdrian Chadd 3253692ad7caSAdrian Chadd if (ifp->if_flags & IFF_PROMISC) 3254692ad7caSAdrian Chadd sc->rxon.filter |= htole32(promisc_filter); 3255692ad7caSAdrian Chadd else 3256692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(promisc_filter); 3257692ad7caSAdrian Chadd } 3258692ad7caSAdrian Chadd 3259692ad7caSAdrian Chadd static void 3260692ad7caSAdrian Chadd wpi_update_promisc(struct ifnet *ifp) 3261692ad7caSAdrian Chadd { 3262692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 3263692ad7caSAdrian Chadd 326410550f61SAdrian Chadd WPI_LOCK(sc); 3265692ad7caSAdrian Chadd wpi_set_promisc(sc); 3266692ad7caSAdrian Chadd 3267692ad7caSAdrian Chadd if (wpi_send_rxon(sc, 1, 1) != 0) { 3268692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 3269692ad7caSAdrian Chadd __func__); 3270692ad7caSAdrian Chadd } 3271692ad7caSAdrian Chadd WPI_UNLOCK(sc); 3272692ad7caSAdrian Chadd } 3273692ad7caSAdrian Chadd 3274692ad7caSAdrian Chadd static void 3275692ad7caSAdrian Chadd wpi_update_mcast(struct ifnet *ifp) 3276692ad7caSAdrian Chadd { 3277692ad7caSAdrian Chadd /* Ignore */ 3278692ad7caSAdrian Chadd } 3279692ad7caSAdrian Chadd 32806607310bSBenjamin Close static void 32816607310bSBenjamin Close wpi_set_led(struct wpi_softc *sc, uint8_t which, uint8_t off, uint8_t on) 32826607310bSBenjamin Close { 32836607310bSBenjamin Close struct wpi_cmd_led led; 32846607310bSBenjamin Close 3285692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3286692ad7caSAdrian Chadd 32876607310bSBenjamin Close led.which = which; 32886607310bSBenjamin Close led.unit = htole32(100000); /* on/off in unit of 100ms */ 32896607310bSBenjamin Close led.off = off; 32906607310bSBenjamin Close led.on = on; 32916607310bSBenjamin Close (void)wpi_cmd(sc, WPI_CMD_SET_LED, &led, sizeof led, 1); 32926607310bSBenjamin Close } 32936607310bSBenjamin Close 3294692ad7caSAdrian Chadd static int 3295692ad7caSAdrian Chadd wpi_set_timing(struct wpi_softc *sc, struct ieee80211_node *ni) 32966607310bSBenjamin Close { 3297692ad7caSAdrian Chadd struct wpi_cmd_timing cmd; 32986607310bSBenjamin Close uint64_t val, mod; 32996607310bSBenjamin Close 3300692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 33016607310bSBenjamin Close 3302692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3303692ad7caSAdrian Chadd memcpy(&cmd.tstamp, ni->ni_tstamp.data, sizeof (uint64_t)); 3304692ad7caSAdrian Chadd cmd.bintval = htole16(ni->ni_intval); 3305692ad7caSAdrian Chadd cmd.lintval = htole16(10); 33066607310bSBenjamin Close 3307692ad7caSAdrian Chadd /* Compute remaining time until next beacon. */ 3308692ad7caSAdrian Chadd val = (uint64_t)ni->ni_intval * IEEE80211_DUR_TU; 3309692ad7caSAdrian Chadd mod = le64toh(cmd.tstamp) % val; 3310692ad7caSAdrian Chadd cmd.binitval = htole32((uint32_t)(val - mod)); 33116607310bSBenjamin Close 3312692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, "timing bintval=%u tstamp=%ju, init=%u\n", 3313692ad7caSAdrian Chadd ni->ni_intval, le64toh(cmd.tstamp), (uint32_t)(val - mod)); 33146607310bSBenjamin Close 3315692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_TIMING, &cmd, sizeof cmd, 1); 33166607310bSBenjamin Close } 33176607310bSBenjamin Close 33186607310bSBenjamin Close /* 3319692ad7caSAdrian Chadd * This function is called periodically (every 60 seconds) to adjust output 3320692ad7caSAdrian Chadd * power to temperature changes. 3321692ad7caSAdrian Chadd */ 3322692ad7caSAdrian Chadd static void 3323692ad7caSAdrian Chadd wpi_power_calibration(struct wpi_softc *sc) 3324692ad7caSAdrian Chadd { 3325692ad7caSAdrian Chadd int temp; 3326692ad7caSAdrian Chadd 3327692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 3328692ad7caSAdrian Chadd 3329692ad7caSAdrian Chadd /* Update sensor data. */ 3330692ad7caSAdrian Chadd temp = (int)WPI_READ(sc, WPI_UCODE_GP2); 3331692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "Temp in calibration is: %d\n", temp); 3332692ad7caSAdrian Chadd 3333692ad7caSAdrian Chadd /* Sanity-check read value. */ 3334692ad7caSAdrian Chadd if (temp < -260 || temp > 25) { 3335692ad7caSAdrian Chadd /* This can't be correct, ignore. */ 3336692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, 3337692ad7caSAdrian Chadd "out-of-range temperature reported: %d\n", temp); 3338692ad7caSAdrian Chadd return; 3339692ad7caSAdrian Chadd } 3340692ad7caSAdrian Chadd 3341692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d->%d\n", sc->temp, temp); 3342692ad7caSAdrian Chadd 3343692ad7caSAdrian Chadd /* Adjust Tx power if need be. */ 3344692ad7caSAdrian Chadd if (abs(temp - sc->temp) <= 6) 3345692ad7caSAdrian Chadd return; 3346692ad7caSAdrian Chadd 3347692ad7caSAdrian Chadd sc->temp = temp; 3348692ad7caSAdrian Chadd 3349692ad7caSAdrian Chadd if (wpi_set_txpower(sc, 1) != 0) { 3350692ad7caSAdrian Chadd /* just warn, too bad for the automatic calibration... */ 3351692ad7caSAdrian Chadd device_printf(sc->sc_dev,"could not adjust Tx power\n"); 3352692ad7caSAdrian Chadd } 3353692ad7caSAdrian Chadd } 3354692ad7caSAdrian Chadd 3355692ad7caSAdrian Chadd /* 3356692ad7caSAdrian Chadd * Set TX power for current channel. 33576607310bSBenjamin Close */ 33586607310bSBenjamin Close static int 3359692ad7caSAdrian Chadd wpi_set_txpower(struct wpi_softc *sc, int async) 33606607310bSBenjamin Close { 3361f319a41cSAdrian Chadd struct ieee80211com *ic = sc->sc_ifp->if_l2com; 3362692ad7caSAdrian Chadd struct ieee80211_channel *ch; 3363692ad7caSAdrian Chadd struct wpi_power_group *group; 3364692ad7caSAdrian Chadd struct wpi_cmd_txpower cmd; 3365692ad7caSAdrian Chadd uint8_t chan; 3366692ad7caSAdrian Chadd int idx, i; 33676607310bSBenjamin Close 3368692ad7caSAdrian Chadd /* Retrieve current channel from last RXON. */ 3369692ad7caSAdrian Chadd chan = sc->rxon.chan; 3370692ad7caSAdrian Chadd ch = &ic->ic_channels[chan]; 33716607310bSBenjamin Close 3372692ad7caSAdrian Chadd /* Find the TX power group to which this channel belongs. */ 3373692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(ch)) { 3374692ad7caSAdrian Chadd for (group = &sc->groups[1]; group < &sc->groups[4]; group++) 3375692ad7caSAdrian Chadd if (chan <= group->chan) 3376692ad7caSAdrian Chadd break; 3377692ad7caSAdrian Chadd } else 3378692ad7caSAdrian Chadd group = &sc->groups[0]; 3379692ad7caSAdrian Chadd 3380692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3381692ad7caSAdrian Chadd cmd.band = IEEE80211_IS_CHAN_5GHZ(ch) ? 0 : 1; 3382692ad7caSAdrian Chadd cmd.chan = htole16(chan); 3383692ad7caSAdrian Chadd 3384692ad7caSAdrian Chadd /* Set TX power for all OFDM and CCK rates. */ 3385692ad7caSAdrian Chadd for (i = 0; i <= WPI_RIDX_MAX ; i++) { 3386692ad7caSAdrian Chadd /* Retrieve TX power for this channel/rate. */ 3387692ad7caSAdrian Chadd idx = wpi_get_power_index(sc, group, ch, i); 3388692ad7caSAdrian Chadd 3389692ad7caSAdrian Chadd cmd.rates[i].plcp = wpi_ridx_to_plcp[i]; 3390692ad7caSAdrian Chadd 3391692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(ch)) { 3392692ad7caSAdrian Chadd cmd.rates[i].rf_gain = wpi_rf_gain_5ghz[idx]; 3393692ad7caSAdrian Chadd cmd.rates[i].dsp_gain = wpi_dsp_gain_5ghz[idx]; 3394692ad7caSAdrian Chadd } else { 3395692ad7caSAdrian Chadd cmd.rates[i].rf_gain = wpi_rf_gain_2ghz[idx]; 3396692ad7caSAdrian Chadd cmd.rates[i].dsp_gain = wpi_dsp_gain_2ghz[idx]; 3397692ad7caSAdrian Chadd } 3398692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, 3399692ad7caSAdrian Chadd "chan %d/ridx %d: power index %d\n", chan, i, idx); 3400692ad7caSAdrian Chadd } 3401692ad7caSAdrian Chadd 3402692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_TXPOWER, &cmd, sizeof cmd, async); 3403692ad7caSAdrian Chadd } 3404692ad7caSAdrian Chadd 3405692ad7caSAdrian Chadd /* 3406692ad7caSAdrian Chadd * Determine Tx power index for a given channel/rate combination. 3407692ad7caSAdrian Chadd * This takes into account the regulatory information from EEPROM and the 3408692ad7caSAdrian Chadd * current temperature. 3409692ad7caSAdrian Chadd */ 3410692ad7caSAdrian Chadd static int 3411692ad7caSAdrian Chadd wpi_get_power_index(struct wpi_softc *sc, struct wpi_power_group *group, 3412692ad7caSAdrian Chadd struct ieee80211_channel *c, int ridx) 3413692ad7caSAdrian Chadd { 3414692ad7caSAdrian Chadd /* Fixed-point arithmetic division using a n-bit fractional part. */ 3415692ad7caSAdrian Chadd #define fdivround(a, b, n) \ 3416692ad7caSAdrian Chadd ((((1 << n) * (a)) / (b) + (1 << n) / 2) / (1 << n)) 3417692ad7caSAdrian Chadd 3418692ad7caSAdrian Chadd /* Linear interpolation. */ 3419692ad7caSAdrian Chadd #define interpolate(x, x1, y1, x2, y2, n) \ 3420692ad7caSAdrian Chadd ((y1) + fdivround(((x) - (x1)) * ((y2) - (y1)), (x2) - (x1), n)) 3421692ad7caSAdrian Chadd 3422f319a41cSAdrian Chadd struct ieee80211com *ic = sc->sc_ifp->if_l2com; 3423692ad7caSAdrian Chadd struct wpi_power_sample *sample; 3424692ad7caSAdrian Chadd int pwr, idx; 3425692ad7caSAdrian Chadd u_int chan; 3426692ad7caSAdrian Chadd 3427692ad7caSAdrian Chadd /* Get channel number. */ 3428692ad7caSAdrian Chadd chan = ieee80211_chan2ieee(ic, c); 3429692ad7caSAdrian Chadd 3430692ad7caSAdrian Chadd /* Default TX power is group maximum TX power minus 3dB. */ 3431692ad7caSAdrian Chadd pwr = group->maxpwr / 2; 3432692ad7caSAdrian Chadd 3433692ad7caSAdrian Chadd /* Decrease TX power for highest OFDM rates to reduce distortion. */ 3434692ad7caSAdrian Chadd switch (ridx) { 3435692ad7caSAdrian Chadd case WPI_RIDX_OFDM36: 3436692ad7caSAdrian Chadd pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 0 : 5; 3437692ad7caSAdrian Chadd break; 3438692ad7caSAdrian Chadd case WPI_RIDX_OFDM48: 3439692ad7caSAdrian Chadd pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 7 : 10; 3440692ad7caSAdrian Chadd break; 3441692ad7caSAdrian Chadd case WPI_RIDX_OFDM54: 3442692ad7caSAdrian Chadd pwr -= IEEE80211_IS_CHAN_2GHZ(c) ? 9 : 12; 3443692ad7caSAdrian Chadd break; 3444692ad7caSAdrian Chadd } 3445692ad7caSAdrian Chadd 3446692ad7caSAdrian Chadd /* Never exceed the channel maximum allowed TX power. */ 3447692ad7caSAdrian Chadd pwr = min(pwr, sc->maxpwr[chan]); 3448692ad7caSAdrian Chadd 3449692ad7caSAdrian Chadd /* Retrieve TX power index into gain tables from samples. */ 3450692ad7caSAdrian Chadd for (sample = group->samples; sample < &group->samples[3]; sample++) 3451692ad7caSAdrian Chadd if (pwr > sample[1].power) 3452692ad7caSAdrian Chadd break; 3453692ad7caSAdrian Chadd /* Fixed-point linear interpolation using a 19-bit fractional part. */ 3454692ad7caSAdrian Chadd idx = interpolate(pwr, sample[0].power, sample[0].index, 3455692ad7caSAdrian Chadd sample[1].power, sample[1].index, 19); 3456692ad7caSAdrian Chadd 3457692ad7caSAdrian Chadd /*- 3458692ad7caSAdrian Chadd * Adjust power index based on current temperature: 3459692ad7caSAdrian Chadd * - if cooler than factory-calibrated: decrease output power 3460692ad7caSAdrian Chadd * - if warmer than factory-calibrated: increase output power 3461692ad7caSAdrian Chadd */ 3462692ad7caSAdrian Chadd idx -= (sc->temp - group->temp) * 11 / 100; 3463692ad7caSAdrian Chadd 3464692ad7caSAdrian Chadd /* Decrease TX power for CCK rates (-5dB). */ 3465692ad7caSAdrian Chadd if (ridx >= WPI_RIDX_CCK1) 3466692ad7caSAdrian Chadd idx += 10; 3467692ad7caSAdrian Chadd 3468692ad7caSAdrian Chadd /* Make sure idx stays in a valid range. */ 3469692ad7caSAdrian Chadd if (idx < 0) 3470692ad7caSAdrian Chadd return 0; 3471692ad7caSAdrian Chadd if (idx > WPI_MAX_PWR_INDEX) 3472692ad7caSAdrian Chadd return WPI_MAX_PWR_INDEX; 3473692ad7caSAdrian Chadd return idx; 3474692ad7caSAdrian Chadd 3475692ad7caSAdrian Chadd #undef interpolate 3476692ad7caSAdrian Chadd #undef fdivround 3477692ad7caSAdrian Chadd } 3478692ad7caSAdrian Chadd 3479692ad7caSAdrian Chadd /* 3480692ad7caSAdrian Chadd * Set STA mode power saving level (between 0 and 5). 3481692ad7caSAdrian Chadd * Level 0 is CAM (Continuously Aware Mode), 5 is for maximum power saving. 3482692ad7caSAdrian Chadd */ 3483692ad7caSAdrian Chadd static int 3484692ad7caSAdrian Chadd wpi_set_pslevel(struct wpi_softc *sc, uint8_t dtim, int level, int async) 3485692ad7caSAdrian Chadd { 3486692ad7caSAdrian Chadd struct wpi_pmgt_cmd cmd; 3487692ad7caSAdrian Chadd const struct wpi_pmgt *pmgt; 3488692ad7caSAdrian Chadd uint32_t max, skip_dtim; 3489692ad7caSAdrian Chadd uint32_t reg; 3490692ad7caSAdrian Chadd int i; 3491692ad7caSAdrian Chadd 3492692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_PWRSAVE, 3493692ad7caSAdrian Chadd "%s: dtim=%d, level=%d, async=%d\n", 3494692ad7caSAdrian Chadd __func__, dtim, level, async); 3495692ad7caSAdrian Chadd 3496692ad7caSAdrian Chadd /* Select which PS parameters to use. */ 3497692ad7caSAdrian Chadd if (dtim <= 10) 3498692ad7caSAdrian Chadd pmgt = &wpi_pmgt[0][level]; 3499692ad7caSAdrian Chadd else 3500692ad7caSAdrian Chadd pmgt = &wpi_pmgt[1][level]; 3501692ad7caSAdrian Chadd 3502692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3503692ad7caSAdrian Chadd if (level != 0) /* not CAM */ 3504692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_ALLOW_SLEEP); 3505692ad7caSAdrian Chadd /* Retrieve PCIe Active State Power Management (ASPM). */ 3506692ad7caSAdrian Chadd reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1); 3507692ad7caSAdrian Chadd if (!(reg & 0x1)) /* L0s Entry disabled. */ 3508692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_PCI_PMGT); 3509692ad7caSAdrian Chadd 3510692ad7caSAdrian Chadd cmd.rxtimeout = htole32(pmgt->rxtimeout * IEEE80211_DUR_TU); 3511692ad7caSAdrian Chadd cmd.txtimeout = htole32(pmgt->txtimeout * IEEE80211_DUR_TU); 3512692ad7caSAdrian Chadd 3513692ad7caSAdrian Chadd if (dtim == 0) { 3514692ad7caSAdrian Chadd dtim = 1; 3515692ad7caSAdrian Chadd skip_dtim = 0; 3516692ad7caSAdrian Chadd } else 3517692ad7caSAdrian Chadd skip_dtim = pmgt->skip_dtim; 3518692ad7caSAdrian Chadd 3519692ad7caSAdrian Chadd if (skip_dtim != 0) { 3520692ad7caSAdrian Chadd cmd.flags |= htole16(WPI_PS_SLEEP_OVER_DTIM); 3521692ad7caSAdrian Chadd max = pmgt->intval[4]; 3522692ad7caSAdrian Chadd if (max == (uint32_t)-1) 3523692ad7caSAdrian Chadd max = dtim * (skip_dtim + 1); 3524692ad7caSAdrian Chadd else if (max > dtim) 3525692ad7caSAdrian Chadd max = (max / dtim) * dtim; 3526692ad7caSAdrian Chadd } else 3527692ad7caSAdrian Chadd max = dtim; 3528692ad7caSAdrian Chadd 3529692ad7caSAdrian Chadd for (i = 0; i < 5; i++) 3530692ad7caSAdrian Chadd cmd.intval[i] = htole32(MIN(max, pmgt->intval[i])); 3531692ad7caSAdrian Chadd 3532692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_SET_POWER_MODE, &cmd, sizeof cmd, async); 3533692ad7caSAdrian Chadd } 3534692ad7caSAdrian Chadd 3535692ad7caSAdrian Chadd static int 3536692ad7caSAdrian Chadd wpi_send_btcoex(struct wpi_softc *sc) 3537692ad7caSAdrian Chadd { 3538692ad7caSAdrian Chadd struct wpi_bluetooth cmd; 3539692ad7caSAdrian Chadd 3540692ad7caSAdrian Chadd memset(&cmd, 0, sizeof cmd); 3541692ad7caSAdrian Chadd cmd.flags = WPI_BT_COEX_MODE_4WIRE; 3542692ad7caSAdrian Chadd cmd.lead_time = WPI_BT_LEAD_TIME_DEF; 3543692ad7caSAdrian Chadd cmd.max_kill = WPI_BT_MAX_KILL_DEF; 3544692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_RESET, "%s: configuring bluetooth coexistence\n", 3545692ad7caSAdrian Chadd __func__); 3546692ad7caSAdrian Chadd return wpi_cmd(sc, WPI_CMD_BT_COEX, &cmd, sizeof(cmd), 0); 3547692ad7caSAdrian Chadd } 3548692ad7caSAdrian Chadd 3549692ad7caSAdrian Chadd static int 3550692ad7caSAdrian Chadd wpi_send_rxon(struct wpi_softc *sc, int assoc, int async) 3551692ad7caSAdrian Chadd { 3552692ad7caSAdrian Chadd int error; 3553692ad7caSAdrian Chadd 3554692ad7caSAdrian Chadd if (assoc && (sc->rxon.filter & htole32(WPI_FILTER_BSS))) { 3555692ad7caSAdrian Chadd struct wpi_assoc rxon_assoc; 3556692ad7caSAdrian Chadd 3557692ad7caSAdrian Chadd rxon_assoc.flags = sc->rxon.flags; 3558692ad7caSAdrian Chadd rxon_assoc.filter = sc->rxon.filter; 3559692ad7caSAdrian Chadd rxon_assoc.ofdm_mask = sc->rxon.ofdm_mask; 3560692ad7caSAdrian Chadd rxon_assoc.cck_mask = sc->rxon.cck_mask; 3561692ad7caSAdrian Chadd rxon_assoc.reserved = 0; 3562692ad7caSAdrian Chadd 3563692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON_ASSOC, &rxon_assoc, 3564692ad7caSAdrian Chadd sizeof (struct wpi_assoc), async); 3565692ad7caSAdrian Chadd } else { 35667964dd56SAdrian Chadd if (async) 35677964dd56SAdrian Chadd WPI_NT_LOCK(sc); 35687964dd56SAdrian Chadd 3569692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_RXON, &sc->rxon, 3570692ad7caSAdrian Chadd sizeof (struct wpi_rxon), async); 3571eca2eb39SAdrian Chadd 3572eca2eb39SAdrian Chadd wpi_clear_node_table(sc); 35737964dd56SAdrian Chadd 35747964dd56SAdrian Chadd if (async) 35757964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 3576692ad7caSAdrian Chadd } 3577692ad7caSAdrian Chadd if (error != 0) { 3578692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RXON command failed, error %d\n", 3579692ad7caSAdrian Chadd error); 3580692ad7caSAdrian Chadd return error; 3581692ad7caSAdrian Chadd } 3582692ad7caSAdrian Chadd 3583692ad7caSAdrian Chadd /* Configuration has changed, set Tx power accordingly. */ 3584692ad7caSAdrian Chadd if ((error = wpi_set_txpower(sc, async)) != 0) { 35856607310bSBenjamin Close device_printf(sc->sc_dev, 3586692ad7caSAdrian Chadd "%s: could not set TX power, error %d\n", __func__, error); 35876607310bSBenjamin Close return error; 35886607310bSBenjamin Close } 35896607310bSBenjamin Close 3590692ad7caSAdrian Chadd if (!(sc->rxon.filter & htole32(WPI_FILTER_BSS))) { 3591692ad7caSAdrian Chadd /* Add broadcast node. */ 3592692ad7caSAdrian Chadd error = wpi_add_broadcast_node(sc, async); 3593692ad7caSAdrian Chadd if (error != 0) { 3594692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3595692ad7caSAdrian Chadd "could not add broadcast node, error %d\n", error); 3596692ad7caSAdrian Chadd return error; 3597692ad7caSAdrian Chadd } 3598692ad7caSAdrian Chadd } 35996607310bSBenjamin Close 3600692ad7caSAdrian Chadd return 0; 36016607310bSBenjamin Close } 36026607310bSBenjamin Close 36036607310bSBenjamin Close /** 36046607310bSBenjamin Close * Configure the card to listen to a particular channel, this transisions the 36056607310bSBenjamin Close * card in to being able to receive frames from remote devices. 36066607310bSBenjamin Close */ 36076607310bSBenjamin Close static int 36086607310bSBenjamin Close wpi_config(struct wpi_softc *sc) 36096607310bSBenjamin Close { 3610b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 3611b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 36123de934a7SAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3613692ad7caSAdrian Chadd uint32_t flags; 36146607310bSBenjamin Close int error; 36156607310bSBenjamin Close 3616692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3617692ad7caSAdrian Chadd 3618692ad7caSAdrian Chadd /* Set power saving level to CAM during initialization. */ 3619692ad7caSAdrian Chadd if ((error = wpi_set_pslevel(sc, 0, 0, 0)) != 0) { 3620692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3621692ad7caSAdrian Chadd "%s: could not set power saving level\n", __func__); 36226607310bSBenjamin Close return error; 36236607310bSBenjamin Close } 36246607310bSBenjamin Close 3625692ad7caSAdrian Chadd /* Configure bluetooth coexistence. */ 3626692ad7caSAdrian Chadd if ((error = wpi_send_btcoex(sc)) != 0) { 36276607310bSBenjamin Close device_printf(sc->sc_dev, 36286607310bSBenjamin Close "could not configure bluetooth coexistence\n"); 36296607310bSBenjamin Close return error; 36306607310bSBenjamin Close } 36316607310bSBenjamin Close 3632692ad7caSAdrian Chadd /* Configure adapter. */ 3633692ad7caSAdrian Chadd memset(&sc->rxon, 0, sizeof (struct wpi_rxon)); 36343de934a7SAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.myaddr, vap->iv_myaddr); 3635692ad7caSAdrian Chadd 3636692ad7caSAdrian Chadd /* Set default channel. */ 3637692ad7caSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, ic->ic_curchan); 3638692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 3639692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) 3640692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 3641692ad7caSAdrian Chadd 3642fae61c69SAdrian Chadd sc->rxon.filter = WPI_FILTER_MULTICAST; 36436607310bSBenjamin Close switch (ic->ic_opmode) { 36446607310bSBenjamin Close case IEEE80211_M_STA: 3645692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_STA; 36466607310bSBenjamin Close break; 36476607310bSBenjamin Close case IEEE80211_M_IBSS: 3648692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_IBSS; 3649fae61c69SAdrian Chadd sc->rxon.filter |= WPI_FILTER_BEACON; 36506607310bSBenjamin Close break; 3651692ad7caSAdrian Chadd /* XXX workaround for passive channels selection */ 3652692ad7caSAdrian Chadd case IEEE80211_M_AHDEMO: 36536607310bSBenjamin Close case IEEE80211_M_HOSTAP: 3654692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_HOSTAP; 36556607310bSBenjamin Close break; 36566607310bSBenjamin Close case IEEE80211_M_MONITOR: 3657692ad7caSAdrian Chadd sc->rxon.mode = WPI_MODE_MONITOR; 36586607310bSBenjamin Close break; 3659820e6a1fSRui Paulo default: 36607167f5fcSAdrian Chadd device_printf(sc->sc_dev, "unknown opmode %d\n", 36617167f5fcSAdrian Chadd ic->ic_opmode); 3662820e6a1fSRui Paulo return EINVAL; 36636607310bSBenjamin Close } 3664fae61c69SAdrian Chadd sc->rxon.filter = htole32(sc->rxon.filter); 3665692ad7caSAdrian Chadd wpi_set_promisc(sc); 3666692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; /* not yet negotiated */ 3667692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0xff; /* not yet negotiated */ 3668692ad7caSAdrian Chadd 3669692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 0)) != 0) { 3670692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 3671692ad7caSAdrian Chadd __func__); 3672692ad7caSAdrian Chadd return error; 3673692ad7caSAdrian Chadd } 3674692ad7caSAdrian Chadd 3675692ad7caSAdrian Chadd /* Setup rate scalling. */ 3676692ad7caSAdrian Chadd if ((error = wpi_mrr_setup(sc)) != 0) { 3677692ad7caSAdrian Chadd device_printf(sc->sc_dev, "could not setup MRR, error %d\n", 3678692ad7caSAdrian Chadd error); 3679692ad7caSAdrian Chadd return error; 3680692ad7caSAdrian Chadd } 3681692ad7caSAdrian Chadd 3682692ad7caSAdrian Chadd /* Disable beacon notifications (unused). */ 3683692ad7caSAdrian Chadd flags = WPI_STATISTICS_BEACON_DISABLE; 3684692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_GET_STATISTICS, &flags, sizeof flags, 1); 36856607310bSBenjamin Close if (error != 0) { 3686692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3687692ad7caSAdrian Chadd "could not disable beacon statistics, error %d\n", error); 36886607310bSBenjamin Close return error; 36896607310bSBenjamin Close } 36906607310bSBenjamin Close 3691692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3692692ad7caSAdrian Chadd 3693692ad7caSAdrian Chadd return 0; 3694692ad7caSAdrian Chadd } 3695692ad7caSAdrian Chadd 3696692ad7caSAdrian Chadd static uint16_t 3697692ad7caSAdrian Chadd wpi_get_active_dwell_time(struct wpi_softc *sc, 3698692ad7caSAdrian Chadd struct ieee80211_channel *c, uint8_t n_probes) 3699692ad7caSAdrian Chadd { 3700692ad7caSAdrian Chadd /* No channel? Default to 2GHz settings. */ 3701692ad7caSAdrian Chadd if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) { 3702692ad7caSAdrian Chadd return (WPI_ACTIVE_DWELL_TIME_2GHZ + 3703692ad7caSAdrian Chadd WPI_ACTIVE_DWELL_FACTOR_2GHZ * (n_probes + 1)); 3704692ad7caSAdrian Chadd } 3705692ad7caSAdrian Chadd 3706692ad7caSAdrian Chadd /* 5GHz dwell time. */ 3707692ad7caSAdrian Chadd return (WPI_ACTIVE_DWELL_TIME_5GHZ + 3708692ad7caSAdrian Chadd WPI_ACTIVE_DWELL_FACTOR_5GHZ * (n_probes + 1)); 3709692ad7caSAdrian Chadd } 3710692ad7caSAdrian Chadd 3711692ad7caSAdrian Chadd /* 3712692ad7caSAdrian Chadd * Limit the total dwell time to 85% of the beacon interval. 3713692ad7caSAdrian Chadd * 3714692ad7caSAdrian Chadd * Returns the dwell time in milliseconds. 3715692ad7caSAdrian Chadd */ 3716692ad7caSAdrian Chadd static uint16_t 3717692ad7caSAdrian Chadd wpi_limit_dwell(struct wpi_softc *sc, uint16_t dwell_time) 3718692ad7caSAdrian Chadd { 3719692ad7caSAdrian Chadd struct ieee80211com *ic = sc->sc_ifp->if_l2com; 3720692ad7caSAdrian Chadd struct ieee80211vap *vap = NULL; 3721692ad7caSAdrian Chadd int bintval = 0; 3722692ad7caSAdrian Chadd 3723692ad7caSAdrian Chadd /* bintval is in TU (1.024mS) */ 3724692ad7caSAdrian Chadd if (! TAILQ_EMPTY(&ic->ic_vaps)) { 3725692ad7caSAdrian Chadd vap = TAILQ_FIRST(&ic->ic_vaps); 3726692ad7caSAdrian Chadd bintval = vap->iv_bss->ni_intval; 3727692ad7caSAdrian Chadd } 3728692ad7caSAdrian Chadd 3729692ad7caSAdrian Chadd /* 3730692ad7caSAdrian Chadd * If it's non-zero, we should calculate the minimum of 3731692ad7caSAdrian Chadd * it and the DWELL_BASE. 3732692ad7caSAdrian Chadd * 3733692ad7caSAdrian Chadd * XXX Yes, the math should take into account that bintval 3734692ad7caSAdrian Chadd * is 1.024mS, not 1mS.. 3735692ad7caSAdrian Chadd */ 3736692ad7caSAdrian Chadd if (bintval > 0) { 3737692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, "%s: bintval=%d\n", __func__, 3738692ad7caSAdrian Chadd bintval); 3739692ad7caSAdrian Chadd return (MIN(WPI_PASSIVE_DWELL_BASE, ((bintval * 85) / 100))); 3740692ad7caSAdrian Chadd } 3741692ad7caSAdrian Chadd 3742692ad7caSAdrian Chadd /* No association context? Default. */ 3743692ad7caSAdrian Chadd return (WPI_PASSIVE_DWELL_BASE); 3744692ad7caSAdrian Chadd } 3745692ad7caSAdrian Chadd 3746692ad7caSAdrian Chadd static uint16_t 3747692ad7caSAdrian Chadd wpi_get_passive_dwell_time(struct wpi_softc *sc, struct ieee80211_channel *c) 3748692ad7caSAdrian Chadd { 3749692ad7caSAdrian Chadd uint16_t passive; 3750692ad7caSAdrian Chadd 3751692ad7caSAdrian Chadd if (c == NULL || IEEE80211_IS_CHAN_2GHZ(c)) 3752692ad7caSAdrian Chadd passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_2GHZ; 3753692ad7caSAdrian Chadd else 3754692ad7caSAdrian Chadd passive = WPI_PASSIVE_DWELL_BASE + WPI_PASSIVE_DWELL_TIME_5GHZ; 3755692ad7caSAdrian Chadd 3756692ad7caSAdrian Chadd /* Clamp to the beacon interval if we're associated. */ 3757692ad7caSAdrian Chadd return (wpi_limit_dwell(sc, passive)); 3758692ad7caSAdrian Chadd } 3759692ad7caSAdrian Chadd 3760692ad7caSAdrian Chadd /* 3761692ad7caSAdrian Chadd * Send a scan request to the firmware. 3762692ad7caSAdrian Chadd */ 3763692ad7caSAdrian Chadd static int 3764692ad7caSAdrian Chadd wpi_scan(struct wpi_softc *sc, struct ieee80211_channel *c) 3765692ad7caSAdrian Chadd { 3766692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 3767692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 3768692ad7caSAdrian Chadd struct ieee80211_scan_state *ss = ic->ic_scan; 37693de934a7SAdrian Chadd struct ieee80211vap *vap = ss->ss_vap; 3770692ad7caSAdrian Chadd struct wpi_scan_hdr *hdr; 3771692ad7caSAdrian Chadd struct wpi_cmd_data *tx; 3772692ad7caSAdrian Chadd struct wpi_scan_essid *essids; 3773692ad7caSAdrian Chadd struct wpi_scan_chan *chan; 3774692ad7caSAdrian Chadd struct ieee80211_frame *wh; 3775692ad7caSAdrian Chadd struct ieee80211_rateset *rs; 3776692ad7caSAdrian Chadd uint16_t dwell_active, dwell_passive; 3777692ad7caSAdrian Chadd uint8_t *buf, *frm; 3778692ad7caSAdrian Chadd int buflen, error, i, nssid; 3779692ad7caSAdrian Chadd 3780692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3781692ad7caSAdrian Chadd 3782692ad7caSAdrian Chadd /* 3783692ad7caSAdrian Chadd * We are absolutely not allowed to send a scan command when another 3784692ad7caSAdrian Chadd * scan command is pending. 3785692ad7caSAdrian Chadd */ 3786692ad7caSAdrian Chadd if (sc->sc_scan_timer) { 3787692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: called whilst scanning!\n", 3788692ad7caSAdrian Chadd __func__); 378996dadeb0SAdrian Chadd 379096dadeb0SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 379196dadeb0SAdrian Chadd 3792692ad7caSAdrian Chadd return (EAGAIN); 3793692ad7caSAdrian Chadd } 3794692ad7caSAdrian Chadd 3795692ad7caSAdrian Chadd buf = malloc(WPI_SCAN_MAXSZ, M_DEVBUF, M_NOWAIT | M_ZERO); 3796692ad7caSAdrian Chadd if (buf == NULL) { 3797692ad7caSAdrian Chadd device_printf(sc->sc_dev, 3798692ad7caSAdrian Chadd "%s: could not allocate buffer for scan command\n", 3799692ad7caSAdrian Chadd __func__); 380096dadeb0SAdrian Chadd error = ENOMEM; 380196dadeb0SAdrian Chadd goto fail; 3802692ad7caSAdrian Chadd } 3803692ad7caSAdrian Chadd hdr = (struct wpi_scan_hdr *)buf; 3804692ad7caSAdrian Chadd 3805692ad7caSAdrian Chadd /* 3806692ad7caSAdrian Chadd * Move to the next channel if no packets are received within 10 msecs 3807692ad7caSAdrian Chadd * after sending the probe request. 3808692ad7caSAdrian Chadd */ 3809692ad7caSAdrian Chadd hdr->quiet_time = htole16(10); /* timeout in milliseconds */ 3810692ad7caSAdrian Chadd hdr->quiet_threshold = htole16(1); /* min # of packets */ 3811692ad7caSAdrian Chadd /* 3812692ad7caSAdrian Chadd * Max needs to be greater than active and passive and quiet! 3813692ad7caSAdrian Chadd * It's also in microseconds! 3814692ad7caSAdrian Chadd */ 3815692ad7caSAdrian Chadd hdr->max_svc = htole32(250 * IEEE80211_DUR_TU); 3816692ad7caSAdrian Chadd hdr->pause_svc = htole32((4 << 24) | 3817692ad7caSAdrian Chadd (100 * IEEE80211_DUR_TU)); /* Hardcode for now */ 3818692ad7caSAdrian Chadd hdr->filter = htole32(WPI_FILTER_MULTICAST | WPI_FILTER_BEACON); 3819692ad7caSAdrian Chadd 3820692ad7caSAdrian Chadd tx = (struct wpi_cmd_data *)(hdr + 1); 3821692ad7caSAdrian Chadd tx->flags = htole32(WPI_TX_AUTO_SEQ); 3822692ad7caSAdrian Chadd tx->id = WPI_ID_BROADCAST; 3823692ad7caSAdrian Chadd tx->lifetime = htole32(WPI_LIFETIME_INFINITE); 3824692ad7caSAdrian Chadd 3825692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(c)) { 3826692ad7caSAdrian Chadd /* Send probe requests at 6Mbps. */ 3827692ad7caSAdrian Chadd tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_OFDM6]; 3828692ad7caSAdrian Chadd rs = &ic->ic_sup_rates[IEEE80211_MODE_11A]; 3829692ad7caSAdrian Chadd } else { 3830692ad7caSAdrian Chadd hdr->flags = htole32(WPI_RXON_24GHZ | WPI_RXON_AUTO); 3831692ad7caSAdrian Chadd /* Send probe requests at 1Mbps. */ 3832692ad7caSAdrian Chadd tx->plcp = wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 3833692ad7caSAdrian Chadd rs = &ic->ic_sup_rates[IEEE80211_MODE_11G]; 3834692ad7caSAdrian Chadd } 3835692ad7caSAdrian Chadd 3836692ad7caSAdrian Chadd essids = (struct wpi_scan_essid *)(tx + 1); 3837692ad7caSAdrian Chadd nssid = MIN(ss->ss_nssid, WPI_SCAN_MAX_ESSIDS); 3838692ad7caSAdrian Chadd for (i = 0; i < nssid; i++) { 3839692ad7caSAdrian Chadd essids[i].id = IEEE80211_ELEMID_SSID; 3840692ad7caSAdrian Chadd essids[i].len = MIN(ss->ss_ssid[i].len, IEEE80211_NWID_LEN); 3841692ad7caSAdrian Chadd memcpy(essids[i].data, ss->ss_ssid[i].ssid, essids[i].len); 3842692ad7caSAdrian Chadd #ifdef WPI_DEBUG 3843692ad7caSAdrian Chadd if (sc->sc_debug & WPI_DEBUG_SCAN) { 3844692ad7caSAdrian Chadd printf("Scanning Essid: "); 3845692ad7caSAdrian Chadd ieee80211_print_essid(essids[i].data, essids[i].len); 3846692ad7caSAdrian Chadd printf("\n"); 3847692ad7caSAdrian Chadd } 3848692ad7caSAdrian Chadd #endif 3849692ad7caSAdrian Chadd } 3850692ad7caSAdrian Chadd 3851692ad7caSAdrian Chadd /* 3852692ad7caSAdrian Chadd * Build a probe request frame. Most of the following code is a 3853692ad7caSAdrian Chadd * copy & paste of what is done in net80211. 3854692ad7caSAdrian Chadd */ 3855692ad7caSAdrian Chadd wh = (struct ieee80211_frame *)(essids + WPI_SCAN_MAX_ESSIDS); 3856692ad7caSAdrian Chadd wh->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_MGT | 3857692ad7caSAdrian Chadd IEEE80211_FC0_SUBTYPE_PROBE_REQ; 3858692ad7caSAdrian Chadd wh->i_fc[1] = IEEE80211_FC1_DIR_NODS; 3859692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr1, ifp->if_broadcastaddr); 38603de934a7SAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr2, vap->iv_myaddr); 3861692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(wh->i_addr3, ifp->if_broadcastaddr); 3862692ad7caSAdrian Chadd *(uint16_t *)&wh->i_dur[0] = 0; /* filled by h/w */ 3863692ad7caSAdrian Chadd *(uint16_t *)&wh->i_seq[0] = 0; /* filled by h/w */ 3864692ad7caSAdrian Chadd 3865692ad7caSAdrian Chadd frm = (uint8_t *)(wh + 1); 3866692ad7caSAdrian Chadd frm = ieee80211_add_ssid(frm, NULL, 0); 3867692ad7caSAdrian Chadd frm = ieee80211_add_rates(frm, rs); 3868692ad7caSAdrian Chadd if (rs->rs_nrates > IEEE80211_RATE_SIZE) 3869692ad7caSAdrian Chadd frm = ieee80211_add_xrates(frm, rs); 3870692ad7caSAdrian Chadd 3871692ad7caSAdrian Chadd /* Set length of probe request. */ 3872692ad7caSAdrian Chadd tx->len = htole16(frm - (uint8_t *)wh); 3873692ad7caSAdrian Chadd 3874692ad7caSAdrian Chadd /* 3875692ad7caSAdrian Chadd * Construct information about the channel that we 3876692ad7caSAdrian Chadd * want to scan. The firmware expects this to be directly 3877692ad7caSAdrian Chadd * after the scan probe request 3878692ad7caSAdrian Chadd */ 3879692ad7caSAdrian Chadd chan = (struct wpi_scan_chan *)frm; 3880692ad7caSAdrian Chadd chan->chan = htole16(ieee80211_chan2ieee(ic, c)); 3881692ad7caSAdrian Chadd chan->flags = 0; 3882692ad7caSAdrian Chadd if (nssid) { 3883692ad7caSAdrian Chadd hdr->crc_threshold = WPI_SCAN_CRC_TH_DEFAULT; 3884692ad7caSAdrian Chadd chan->flags |= WPI_CHAN_NPBREQS(nssid); 3885692ad7caSAdrian Chadd } else 3886692ad7caSAdrian Chadd hdr->crc_threshold = WPI_SCAN_CRC_TH_NEVER; 3887692ad7caSAdrian Chadd 3888fae61c69SAdrian Chadd if (!IEEE80211_IS_CHAN_PASSIVE(c)) 3889692ad7caSAdrian Chadd chan->flags |= WPI_CHAN_ACTIVE; 3890692ad7caSAdrian Chadd 3891692ad7caSAdrian Chadd /* 3892692ad7caSAdrian Chadd * Calculate the active/passive dwell times. 3893692ad7caSAdrian Chadd */ 3894692ad7caSAdrian Chadd 3895692ad7caSAdrian Chadd dwell_active = wpi_get_active_dwell_time(sc, c, nssid); 3896692ad7caSAdrian Chadd dwell_passive = wpi_get_passive_dwell_time(sc, c); 3897692ad7caSAdrian Chadd 3898692ad7caSAdrian Chadd /* Make sure they're valid. */ 3899692ad7caSAdrian Chadd if (dwell_passive <= dwell_active) 3900692ad7caSAdrian Chadd dwell_passive = dwell_active + 1; 3901692ad7caSAdrian Chadd 3902692ad7caSAdrian Chadd chan->active = htole16(dwell_active); 3903692ad7caSAdrian Chadd chan->passive = htole16(dwell_passive); 3904692ad7caSAdrian Chadd 3905692ad7caSAdrian Chadd chan->dsp_gain = 0x6e; /* Default level */ 3906692ad7caSAdrian Chadd 3907692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_5GHZ(c)) 3908692ad7caSAdrian Chadd chan->rf_gain = 0x3b; 3909692ad7caSAdrian Chadd else 3910692ad7caSAdrian Chadd chan->rf_gain = 0x28; 3911692ad7caSAdrian Chadd 3912692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_SCAN, "Scanning %u Passive: %d\n", 3913fae61c69SAdrian Chadd chan->chan, IEEE80211_IS_CHAN_PASSIVE(c)); 3914692ad7caSAdrian Chadd 3915692ad7caSAdrian Chadd hdr->nchan++; 3916692ad7caSAdrian Chadd chan++; 3917692ad7caSAdrian Chadd 3918692ad7caSAdrian Chadd buflen = (uint8_t *)chan - buf; 3919692ad7caSAdrian Chadd hdr->len = htole16(buflen); 3920692ad7caSAdrian Chadd 3921692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_CMD, "sending scan command nchan=%d\n", 3922692ad7caSAdrian Chadd hdr->nchan); 3923692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_SCAN, buf, buflen, 1); 3924692ad7caSAdrian Chadd free(buf, M_DEVBUF); 3925692ad7caSAdrian Chadd 392696dadeb0SAdrian Chadd if (error != 0) 392796dadeb0SAdrian Chadd goto fail; 392896dadeb0SAdrian Chadd 3929692ad7caSAdrian Chadd sc->sc_scan_timer = 5; 3930692ad7caSAdrian Chadd 3931692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3932692ad7caSAdrian Chadd 393396dadeb0SAdrian Chadd return 0; 393496dadeb0SAdrian Chadd 393596dadeb0SAdrian Chadd fail: DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 393696dadeb0SAdrian Chadd 39376607310bSBenjamin Close return error; 39386607310bSBenjamin Close } 39396607310bSBenjamin Close 3940692ad7caSAdrian Chadd static int 3941692ad7caSAdrian Chadd wpi_auth(struct wpi_softc *sc, struct ieee80211vap *vap) 3942692ad7caSAdrian Chadd { 3943692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 3944692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 3945692ad7caSAdrian Chadd int error; 3946692ad7caSAdrian Chadd 3947692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 3948692ad7caSAdrian Chadd 3949692ad7caSAdrian Chadd /* Update adapter configuration. */ 3950692ad7caSAdrian Chadd sc->rxon.associd = 0; 3951692ad7caSAdrian Chadd sc->rxon.filter &= ~htole32(WPI_FILTER_BSS); 3952692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); 3953692ad7caSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, ni->ni_chan); 3954692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 3955692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) 3956692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 3957692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHSLOT) 3958692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); 3959692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 3960692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); 3961692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_A(ni->ni_chan)) { 3962692ad7caSAdrian Chadd sc->rxon.cck_mask = 0; 3963692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 3964692ad7caSAdrian Chadd } else if (IEEE80211_IS_CHAN_B(ni->ni_chan)) { 3965692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x03; 3966692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0; 3967692ad7caSAdrian Chadd } else { 3968692ad7caSAdrian Chadd /* Assume 802.11b/g. */ 3969692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; 3970692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 3971692ad7caSAdrian Chadd } 3972692ad7caSAdrian Chadd 3973692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x cck %x ofdm %x\n", 3974692ad7caSAdrian Chadd sc->rxon.chan, sc->rxon.flags, sc->rxon.cck_mask, 3975692ad7caSAdrian Chadd sc->rxon.ofdm_mask); 3976692ad7caSAdrian Chadd 3977692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 3978692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 3979692ad7caSAdrian Chadd __func__); 3980692ad7caSAdrian Chadd } 3981692ad7caSAdrian Chadd 3982692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 3983692ad7caSAdrian Chadd 3984692ad7caSAdrian Chadd return error; 3985692ad7caSAdrian Chadd } 3986692ad7caSAdrian Chadd 3987692ad7caSAdrian Chadd static int 39886f8421f8SAdrian Chadd wpi_config_beacon(struct wpi_vap *wvp) 39896f8421f8SAdrian Chadd { 3990d036bb20SAdrian Chadd struct ieee80211com *ic = wvp->wv_vap.iv_ic; 39916f8421f8SAdrian Chadd struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; 39926f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 39936f8421f8SAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 39946f8421f8SAdrian Chadd struct wpi_cmd_beacon *cmd = (struct wpi_cmd_beacon *)&bcn->data; 39956f8421f8SAdrian Chadd struct ieee80211_tim_ie *tie; 39966f8421f8SAdrian Chadd struct mbuf *m; 39976f8421f8SAdrian Chadd uint8_t *ptr; 39986f8421f8SAdrian Chadd int error; 39996f8421f8SAdrian Chadd 40006f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 40016f8421f8SAdrian Chadd 4002b56fed3dSAdrian Chadd WPI_VAP_LOCK_ASSERT(wvp); 40036f8421f8SAdrian Chadd 40046f8421f8SAdrian Chadd cmd->len = htole16(bcn->m->m_pkthdr.len); 40056f8421f8SAdrian Chadd cmd->plcp = (ic->ic_curmode == IEEE80211_MODE_11A) ? 40066f8421f8SAdrian Chadd wpi_ridx_to_plcp[WPI_RIDX_OFDM6] : wpi_ridx_to_plcp[WPI_RIDX_CCK1]; 40076f8421f8SAdrian Chadd 40086f8421f8SAdrian Chadd /* XXX seems to be unused */ 40096f8421f8SAdrian Chadd if (*(bo->bo_tim) == IEEE80211_ELEMID_TIM) { 40106f8421f8SAdrian Chadd tie = (struct ieee80211_tim_ie *) bo->bo_tim; 40116f8421f8SAdrian Chadd ptr = mtod(bcn->m, uint8_t *); 40126f8421f8SAdrian Chadd 40136f8421f8SAdrian Chadd cmd->tim = htole16(bo->bo_tim - ptr); 40146f8421f8SAdrian Chadd cmd->timsz = tie->tim_len; 40156f8421f8SAdrian Chadd } 40166f8421f8SAdrian Chadd 40176f8421f8SAdrian Chadd /* Necessary for recursion in ieee80211_beacon_update(). */ 40186f8421f8SAdrian Chadd m = bcn->m; 40196f8421f8SAdrian Chadd bcn->m = m_dup(m, M_NOWAIT); 40206f8421f8SAdrian Chadd if (bcn->m == NULL) { 40216f8421f8SAdrian Chadd device_printf(sc->sc_dev, 40226f8421f8SAdrian Chadd "%s: could not copy beacon frame\n", __func__); 40236f8421f8SAdrian Chadd error = ENOMEM; 40246f8421f8SAdrian Chadd goto end; 40256f8421f8SAdrian Chadd } 40266f8421f8SAdrian Chadd 40276f8421f8SAdrian Chadd if ((error = wpi_cmd2(sc, bcn)) != 0) { 40286f8421f8SAdrian Chadd device_printf(sc->sc_dev, 40296f8421f8SAdrian Chadd "%s: could not update beacon frame, error %d", __func__, 40306f8421f8SAdrian Chadd error); 40316f8421f8SAdrian Chadd } 40326f8421f8SAdrian Chadd 40336f8421f8SAdrian Chadd /* Restore mbuf. */ 40346f8421f8SAdrian Chadd end: bcn->m = m; 40356f8421f8SAdrian Chadd 40366f8421f8SAdrian Chadd return error; 40376f8421f8SAdrian Chadd } 40386f8421f8SAdrian Chadd 40396f8421f8SAdrian Chadd static int 4040692ad7caSAdrian Chadd wpi_setup_beacon(struct wpi_softc *sc, struct ieee80211_node *ni) 4041692ad7caSAdrian Chadd { 4042565248e2SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(ni->ni_vap); 4043692ad7caSAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 40446f8421f8SAdrian Chadd struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; 4045692ad7caSAdrian Chadd struct mbuf *m; 40466f8421f8SAdrian Chadd int error; 4047692ad7caSAdrian Chadd 4048692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4049692ad7caSAdrian Chadd 4050692ad7caSAdrian Chadd if (ni->ni_chan == IEEE80211_CHAN_ANYC) 4051692ad7caSAdrian Chadd return EINVAL; 4052692ad7caSAdrian Chadd 40536f8421f8SAdrian Chadd m = ieee80211_beacon_alloc(ni, bo); 4054692ad7caSAdrian Chadd if (m == NULL) { 4055692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4056692ad7caSAdrian Chadd "%s: could not allocate beacon frame\n", __func__); 4057692ad7caSAdrian Chadd return ENOMEM; 4058692ad7caSAdrian Chadd } 4059692ad7caSAdrian Chadd 4060b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 40616f8421f8SAdrian Chadd if (bcn->m != NULL) 40626f8421f8SAdrian Chadd m_freem(bcn->m); 4063692ad7caSAdrian Chadd 4064692ad7caSAdrian Chadd bcn->m = m; 4065692ad7caSAdrian Chadd 40666f8421f8SAdrian Chadd error = wpi_config_beacon(wvp); 4067b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 40686f8421f8SAdrian Chadd 40696f8421f8SAdrian Chadd return error; 4070692ad7caSAdrian Chadd } 4071692ad7caSAdrian Chadd 4072692ad7caSAdrian Chadd static void 4073692ad7caSAdrian Chadd wpi_update_beacon(struct ieee80211vap *vap, int item) 4074692ad7caSAdrian Chadd { 40755f25a0e9SAdrian Chadd struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc; 40766f8421f8SAdrian Chadd struct wpi_vap *wvp = WPI_VAP(vap); 40776f8421f8SAdrian Chadd struct wpi_buf *bcn = &wvp->wv_bcbuf; 40786f8421f8SAdrian Chadd struct ieee80211_beacon_offsets *bo = &wvp->wv_boff; 4079692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 40806f8421f8SAdrian Chadd int mcast = 0; 40816f8421f8SAdrian Chadd 40826f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4083692ad7caSAdrian Chadd 4084b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 40856f8421f8SAdrian Chadd if (bcn->m == NULL) { 40866f8421f8SAdrian Chadd bcn->m = ieee80211_beacon_alloc(ni, bo); 40876f8421f8SAdrian Chadd if (bcn->m == NULL) { 4088692ad7caSAdrian Chadd device_printf(sc->sc_dev, 40896f8421f8SAdrian Chadd "%s: could not allocate beacon frame\n", __func__); 40906f8421f8SAdrian Chadd 40916f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, 40926f8421f8SAdrian Chadd __func__); 40936f8421f8SAdrian Chadd 4094b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 40956f8421f8SAdrian Chadd return; 40966f8421f8SAdrian Chadd } 4097692ad7caSAdrian Chadd } 4098b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 40996f8421f8SAdrian Chadd 41006f8421f8SAdrian Chadd if (item == IEEE80211_BEACON_TIM) 41016f8421f8SAdrian Chadd mcast = 1; /* TODO */ 41026f8421f8SAdrian Chadd 41036f8421f8SAdrian Chadd setbit(bo->bo_flags, item); 41046f8421f8SAdrian Chadd ieee80211_beacon_update(ni, bo, bcn->m, mcast); 41056f8421f8SAdrian Chadd 4106b56fed3dSAdrian Chadd WPI_VAP_LOCK(wvp); 41076f8421f8SAdrian Chadd wpi_config_beacon(wvp); 4108b56fed3dSAdrian Chadd WPI_VAP_UNLOCK(wvp); 41096f8421f8SAdrian Chadd 41106f8421f8SAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4111692ad7caSAdrian Chadd } 4112692ad7caSAdrian Chadd 4113d138d3baSAdrian Chadd static void 4114d138d3baSAdrian Chadd wpi_newassoc(struct ieee80211_node *ni, int isnew) 4115d138d3baSAdrian Chadd { 4116d138d3baSAdrian Chadd struct ieee80211vap *vap = ni->ni_vap; 4117d138d3baSAdrian Chadd struct wpi_softc *sc = ni->ni_ic->ic_ifp->if_softc; 4118d138d3baSAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4119d138d3baSAdrian Chadd int error; 4120d138d3baSAdrian Chadd 4121d138d3baSAdrian Chadd WPI_NT_LOCK(sc); 4122d138d3baSAdrian Chadd 4123d138d3baSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4124d138d3baSAdrian Chadd 4125d138d3baSAdrian Chadd if (vap->iv_opmode != IEEE80211_M_STA && wn->id == WPI_ID_UNDEFINED) { 4126d138d3baSAdrian Chadd if ((error = wpi_add_ibss_node(sc, ni)) != 0) { 4127d138d3baSAdrian Chadd device_printf(sc->sc_dev, 4128d138d3baSAdrian Chadd "%s: could not add IBSS node, error %d\n", 4129d138d3baSAdrian Chadd __func__, error); 4130d138d3baSAdrian Chadd } 4131d138d3baSAdrian Chadd } 4132d138d3baSAdrian Chadd WPI_NT_UNLOCK(sc); 4133d138d3baSAdrian Chadd } 4134d138d3baSAdrian Chadd 4135692ad7caSAdrian Chadd static int 4136692ad7caSAdrian Chadd wpi_run(struct wpi_softc *sc, struct ieee80211vap *vap) 4137692ad7caSAdrian Chadd { 4138692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4139692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 4140692ad7caSAdrian Chadd int error; 4141692ad7caSAdrian Chadd 4142692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 4143692ad7caSAdrian Chadd 4144692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_MONITOR) { 4145692ad7caSAdrian Chadd /* Link LED blinks while monitoring. */ 4146692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 5, 5); 4147692ad7caSAdrian Chadd return 0; 4148692ad7caSAdrian Chadd } 4149692ad7caSAdrian Chadd 4150692ad7caSAdrian Chadd /* XXX kernel panic workaround */ 4151692ad7caSAdrian Chadd if (ni->ni_chan == IEEE80211_CHAN_ANYC) { 4152692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: incomplete configuration\n", 4153692ad7caSAdrian Chadd __func__); 4154692ad7caSAdrian Chadd return EINVAL; 4155692ad7caSAdrian Chadd } 4156692ad7caSAdrian Chadd 4157692ad7caSAdrian Chadd if ((error = wpi_set_timing(sc, ni)) != 0) { 4158692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4159692ad7caSAdrian Chadd "%s: could not set timing, error %d\n", __func__, error); 4160692ad7caSAdrian Chadd return error; 4161692ad7caSAdrian Chadd } 4162692ad7caSAdrian Chadd 4163692ad7caSAdrian Chadd /* Update adapter configuration. */ 4164692ad7caSAdrian Chadd IEEE80211_ADDR_COPY(sc->rxon.bssid, ni->ni_bssid); 4165692ad7caSAdrian Chadd sc->rxon.associd = htole16(IEEE80211_NODE_AID(ni)); 4166692ad7caSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, ni->ni_chan); 4167692ad7caSAdrian Chadd sc->rxon.flags = htole32(WPI_RXON_TSF | WPI_RXON_CTS_TO_SELF); 4168692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) 4169692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | WPI_RXON_24GHZ); 4170692ad7caSAdrian Chadd /* Short preamble and slot time are negotiated when associating. */ 4171692ad7caSAdrian Chadd sc->rxon.flags &= ~htole32(WPI_RXON_SHPREAMBLE | WPI_RXON_SHSLOT); 4172692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHSLOT) 4173692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHSLOT); 4174692ad7caSAdrian Chadd if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 4175692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_SHPREAMBLE); 4176692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_A(ni->ni_chan)) { 4177692ad7caSAdrian Chadd sc->rxon.cck_mask = 0; 4178692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 4179692ad7caSAdrian Chadd } else if (IEEE80211_IS_CHAN_B(ni->ni_chan)) { 4180692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x03; 4181692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0; 4182692ad7caSAdrian Chadd } else { 4183692ad7caSAdrian Chadd /* Assume 802.11b/g. */ 4184692ad7caSAdrian Chadd sc->rxon.cck_mask = 0x0f; 4185692ad7caSAdrian Chadd sc->rxon.ofdm_mask = 0x15; 4186692ad7caSAdrian Chadd } 4187692ad7caSAdrian Chadd sc->rxon.filter |= htole32(WPI_FILTER_BSS); 4188692ad7caSAdrian Chadd 4189692ad7caSAdrian Chadd /* XXX put somewhere HC_QOS_SUPPORT_ASSOC + HC_IBSS_START */ 4190692ad7caSAdrian Chadd 4191692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_STATE, "rxon chan %d flags %x\n", 4192692ad7caSAdrian Chadd sc->rxon.chan, sc->rxon.flags); 4193692ad7caSAdrian Chadd 4194692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 1)) != 0) { 4195692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not send RXON\n", 4196692ad7caSAdrian Chadd __func__); 4197692ad7caSAdrian Chadd return error; 4198692ad7caSAdrian Chadd } 4199692ad7caSAdrian Chadd 4200692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_IBSS) { 4201692ad7caSAdrian Chadd if ((error = wpi_setup_beacon(sc, ni)) != 0) { 4202692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4203692ad7caSAdrian Chadd "%s: could not setup beacon, error %d\n", __func__, 4204692ad7caSAdrian Chadd error); 4205692ad7caSAdrian Chadd return error; 4206692ad7caSAdrian Chadd } 4207692ad7caSAdrian Chadd } 4208692ad7caSAdrian Chadd 4209692ad7caSAdrian Chadd if (vap->iv_opmode == IEEE80211_M_STA) { 4210692ad7caSAdrian Chadd /* Add BSS node. */ 42117964dd56SAdrian Chadd WPI_NT_LOCK(sc); 42120ebca245SAdrian Chadd error = wpi_add_sta_node(sc, ni); 42137964dd56SAdrian Chadd WPI_NT_UNLOCK(sc); 42140ebca245SAdrian Chadd if (error != 0) { 4215692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4216692ad7caSAdrian Chadd "%s: could not add BSS node, error %d\n", __func__, 4217692ad7caSAdrian Chadd error); 4218692ad7caSAdrian Chadd return error; 4219692ad7caSAdrian Chadd } 4220692ad7caSAdrian Chadd } 4221692ad7caSAdrian Chadd 4222692ad7caSAdrian Chadd /* Link LED always on while associated. */ 4223692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 0, 1); 4224692ad7caSAdrian Chadd 4225692ad7caSAdrian Chadd /* Start periodic calibration timer. */ 4226692ad7caSAdrian Chadd callout_reset(&sc->calib_to, 60*hz, wpi_calib_timeout, sc); 4227692ad7caSAdrian Chadd 4228692ad7caSAdrian Chadd /* Enable power-saving mode if requested by user. */ 4229692ad7caSAdrian Chadd if (vap->iv_flags & IEEE80211_F_PMGTON) 4230692ad7caSAdrian Chadd (void)wpi_set_pslevel(sc, 0, 3, 1); 4231fae61c69SAdrian Chadd else 4232fae61c69SAdrian Chadd (void)wpi_set_pslevel(sc, 0, 0, 1); 4233692ad7caSAdrian Chadd 4234692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4235692ad7caSAdrian Chadd 4236692ad7caSAdrian Chadd return 0; 4237692ad7caSAdrian Chadd } 4238692ad7caSAdrian Chadd 4239692ad7caSAdrian Chadd static int 4240692ad7caSAdrian Chadd wpi_key_alloc(struct ieee80211vap *vap, struct ieee80211_key *k, 4241692ad7caSAdrian Chadd ieee80211_keyix *keyix, ieee80211_keyix *rxkeyix) 4242692ad7caSAdrian Chadd { 42435f25a0e9SAdrian Chadd struct wpi_softc *sc = vap->iv_ic->ic_ifp->if_softc; 4244692ad7caSAdrian Chadd 4245692ad7caSAdrian Chadd if (!(&vap->iv_nw_keys[0] <= k && 4246692ad7caSAdrian Chadd k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) { 4247692ad7caSAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) { 4248692ad7caSAdrian Chadd /* should not happen */ 4249692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "%s: bogus group key\n", 4250692ad7caSAdrian Chadd __func__); 4251692ad7caSAdrian Chadd return 0; 4252692ad7caSAdrian Chadd } 4253692ad7caSAdrian Chadd *keyix = 0; /* NB: use key index 0 for ucast key */ 4254692ad7caSAdrian Chadd } else { 4255692ad7caSAdrian Chadd *keyix = *rxkeyix = k - vap->iv_nw_keys; 4256692ad7caSAdrian Chadd 4257692ad7caSAdrian Chadd if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_AES_CCM) 4258692ad7caSAdrian Chadd k->wk_flags |= IEEE80211_KEY_SWCRYPT; 4259692ad7caSAdrian Chadd } 4260692ad7caSAdrian Chadd return 1; 4261692ad7caSAdrian Chadd } 4262692ad7caSAdrian Chadd 4263692ad7caSAdrian Chadd static int 4264692ad7caSAdrian Chadd wpi_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k, 4265692ad7caSAdrian Chadd const uint8_t mac[IEEE80211_ADDR_LEN]) 4266692ad7caSAdrian Chadd { 4267692ad7caSAdrian Chadd const struct ieee80211_cipher *cip = k->wk_cipher; 4268692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4269692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 4270692ad7caSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 4271a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4272692ad7caSAdrian Chadd struct wpi_node_info node; 4273692ad7caSAdrian Chadd uint16_t kflags; 4274692ad7caSAdrian Chadd int error; 4275692ad7caSAdrian Chadd 4276692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4277692ad7caSAdrian Chadd 4278692ad7caSAdrian Chadd switch (cip->ic_cipher) { 4279692ad7caSAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 4280692ad7caSAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) 4281692ad7caSAdrian Chadd return 1; 4282692ad7caSAdrian Chadd 4283692ad7caSAdrian Chadd kflags = WPI_KFLAG_CCMP; 4284692ad7caSAdrian Chadd break; 4285692ad7caSAdrian Chadd default: 4286692ad7caSAdrian Chadd /* null_key_set() */ 4287692ad7caSAdrian Chadd return 1; 4288692ad7caSAdrian Chadd } 4289692ad7caSAdrian Chadd 4290692ad7caSAdrian Chadd if (wn->id == WPI_ID_UNDEFINED) 4291692ad7caSAdrian Chadd return 0; 4292692ad7caSAdrian Chadd 4293692ad7caSAdrian Chadd kflags |= WPI_KFLAG_KID(k->wk_keyix); 4294692ad7caSAdrian Chadd if (k->wk_flags & IEEE80211_KEY_GROUP) 4295692ad7caSAdrian Chadd kflags |= WPI_KFLAG_MULTICAST; 4296692ad7caSAdrian Chadd 42976607310bSBenjamin Close memset(&node, 0, sizeof node); 4298692ad7caSAdrian Chadd node.id = wn->id; 4299692ad7caSAdrian Chadd node.control = WPI_NODE_UPDATE; 4300692ad7caSAdrian Chadd node.flags = WPI_FLAG_KEY_SET; 4301692ad7caSAdrian Chadd node.kflags = htole16(kflags); 4302692ad7caSAdrian Chadd memcpy(node.key, k->wk_key, k->wk_keylen); 4303692ad7caSAdrian Chadd 4304692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "set key id=%d for node %d\n", k->wk_keyix, 4305692ad7caSAdrian Chadd node.id); 4306692ad7caSAdrian Chadd 4307692ad7caSAdrian Chadd error = wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 43086607310bSBenjamin Close if (error != 0) { 4309692ad7caSAdrian Chadd device_printf(sc->sc_dev, "can't update node info, error %d\n", 4310692ad7caSAdrian Chadd error); 4311692ad7caSAdrian Chadd return 0; 4312692ad7caSAdrian Chadd } 4313692ad7caSAdrian Chadd 4314692ad7caSAdrian Chadd return 1; 4315692ad7caSAdrian Chadd } 4316692ad7caSAdrian Chadd 4317692ad7caSAdrian Chadd static int 4318692ad7caSAdrian Chadd wpi_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) 4319692ad7caSAdrian Chadd { 4320692ad7caSAdrian Chadd const struct ieee80211_cipher *cip = k->wk_cipher; 4321692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 4322692ad7caSAdrian Chadd struct ieee80211_node *ni = vap->iv_bss; 4323692ad7caSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 4324a5e093b0SAdrian Chadd struct wpi_node *wn = WPI_NODE(ni); 4325692ad7caSAdrian Chadd struct wpi_node_info node; 4326692ad7caSAdrian Chadd 4327692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4328692ad7caSAdrian Chadd 4329692ad7caSAdrian Chadd switch (cip->ic_cipher) { 4330692ad7caSAdrian Chadd case IEEE80211_CIPHER_AES_CCM: 4331692ad7caSAdrian Chadd break; 4332692ad7caSAdrian Chadd default: 4333692ad7caSAdrian Chadd /* null_key_delete() */ 4334692ad7caSAdrian Chadd return 1; 4335692ad7caSAdrian Chadd } 4336692ad7caSAdrian Chadd 4337692ad7caSAdrian Chadd if (vap->iv_state != IEEE80211_S_RUN || 4338692ad7caSAdrian Chadd (k->wk_flags & IEEE80211_KEY_GROUP)) 4339692ad7caSAdrian Chadd return 1; /* Nothing to do. */ 4340692ad7caSAdrian Chadd 4341692ad7caSAdrian Chadd memset(&node, 0, sizeof node); 4342692ad7caSAdrian Chadd node.id = wn->id; 4343692ad7caSAdrian Chadd node.control = WPI_NODE_UPDATE; 4344692ad7caSAdrian Chadd node.flags = WPI_FLAG_KEY_SET; 4345692ad7caSAdrian Chadd 4346692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_KEY, "delete keys for node %d\n", node.id); 4347692ad7caSAdrian Chadd (void)wpi_cmd(sc, WPI_CMD_ADD_NODE, &node, sizeof node, 1); 4348692ad7caSAdrian Chadd 4349692ad7caSAdrian Chadd return 1; 4350692ad7caSAdrian Chadd } 4351692ad7caSAdrian Chadd 4352692ad7caSAdrian Chadd /* 4353692ad7caSAdrian Chadd * This function is called after the runtime firmware notifies us of its 4354692ad7caSAdrian Chadd * readiness (called in a process context). 4355692ad7caSAdrian Chadd */ 4356692ad7caSAdrian Chadd static int 4357692ad7caSAdrian Chadd wpi_post_alive(struct wpi_softc *sc) 4358692ad7caSAdrian Chadd { 4359692ad7caSAdrian Chadd int ntries, error; 4360692ad7caSAdrian Chadd 4361692ad7caSAdrian Chadd /* Check (again) that the radio is not disabled. */ 4362692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4363692ad7caSAdrian Chadd return error; 4364692ad7caSAdrian Chadd 4365692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4366692ad7caSAdrian Chadd 4367692ad7caSAdrian Chadd /* NB: Runtime firmware must be up and running. */ 4368692ad7caSAdrian Chadd if (!(wpi_prph_read(sc, WPI_APMG_RFKILL) & 1)) { 4369692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4370692ad7caSAdrian Chadd "RF switch: radio disabled (%s)\n", __func__); 4371692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4372692ad7caSAdrian Chadd return EPERM; /* :-) */ 4373692ad7caSAdrian Chadd } 4374692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4375692ad7caSAdrian Chadd 4376692ad7caSAdrian Chadd /* Wait for thermal sensor to calibrate. */ 4377692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 4378692ad7caSAdrian Chadd if ((sc->temp = (int)WPI_READ(sc, WPI_UCODE_GP2)) != 0) 4379692ad7caSAdrian Chadd break; 4380692ad7caSAdrian Chadd DELAY(10); 4381692ad7caSAdrian Chadd } 4382692ad7caSAdrian Chadd 4383692ad7caSAdrian Chadd if (ntries == 1000) { 4384692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4385692ad7caSAdrian Chadd "timeout waiting for thermal sensor calibration\n"); 4386692ad7caSAdrian Chadd return ETIMEDOUT; 4387692ad7caSAdrian Chadd } 4388692ad7caSAdrian Chadd 4389692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TEMP, "temperature %d\n", sc->temp); 4390692ad7caSAdrian Chadd return 0; 4391692ad7caSAdrian Chadd } 4392692ad7caSAdrian Chadd 4393692ad7caSAdrian Chadd /* 4394692ad7caSAdrian Chadd * The firmware boot code is small and is intended to be copied directly into 4395692ad7caSAdrian Chadd * the NIC internal memory (no DMA transfer). 4396692ad7caSAdrian Chadd */ 4397692ad7caSAdrian Chadd static int 4398692ad7caSAdrian Chadd wpi_load_bootcode(struct wpi_softc *sc, const uint8_t *ucode, int size) 4399692ad7caSAdrian Chadd { 4400692ad7caSAdrian Chadd int error, ntries; 4401692ad7caSAdrian Chadd 4402692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, "Loading microcode size 0x%x\n", size); 4403692ad7caSAdrian Chadd 4404692ad7caSAdrian Chadd size /= sizeof (uint32_t); 4405692ad7caSAdrian Chadd 4406692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4407692ad7caSAdrian Chadd return error; 4408692ad7caSAdrian Chadd 4409692ad7caSAdrian Chadd /* Copy microcode image into NIC memory. */ 4410692ad7caSAdrian Chadd wpi_prph_write_region_4(sc, WPI_BSM_SRAM_BASE, 4411692ad7caSAdrian Chadd (const uint32_t *)ucode, size); 4412692ad7caSAdrian Chadd 4413692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_MEM_SRC, 0); 4414692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_MEM_DST, WPI_FW_TEXT_BASE); 4415692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_DWCOUNT, size); 4416692ad7caSAdrian Chadd 4417692ad7caSAdrian Chadd /* Start boot load now. */ 4418692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START); 4419692ad7caSAdrian Chadd 4420692ad7caSAdrian Chadd /* Wait for transfer to complete. */ 4421692ad7caSAdrian Chadd for (ntries = 0; ntries < 1000; ntries++) { 4422692ad7caSAdrian Chadd uint32_t status = WPI_READ(sc, WPI_FH_TX_STATUS); 4423692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 4424692ad7caSAdrian Chadd "firmware status=0x%x, val=0x%x, result=0x%x\n", status, 4425692ad7caSAdrian Chadd WPI_FH_TX_STATUS_IDLE(6), 4426692ad7caSAdrian Chadd status & WPI_FH_TX_STATUS_IDLE(6)); 4427692ad7caSAdrian Chadd if (status & WPI_FH_TX_STATUS_IDLE(6)) { 4428692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_HW, 4429692ad7caSAdrian Chadd "Status Match! - ntries = %d\n", ntries); 4430692ad7caSAdrian Chadd break; 4431692ad7caSAdrian Chadd } 4432692ad7caSAdrian Chadd DELAY(10); 4433692ad7caSAdrian Chadd } 4434692ad7caSAdrian Chadd if (ntries == 1000) { 4435692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not load boot firmware\n", 4436692ad7caSAdrian Chadd __func__); 4437692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4438692ad7caSAdrian Chadd return ETIMEDOUT; 4439692ad7caSAdrian Chadd } 4440692ad7caSAdrian Chadd 4441692ad7caSAdrian Chadd /* Enable boot after power up. */ 4442692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_WR_CTRL, WPI_BSM_WR_CTRL_START_EN); 4443692ad7caSAdrian Chadd 4444692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4445692ad7caSAdrian Chadd return 0; 4446692ad7caSAdrian Chadd } 4447692ad7caSAdrian Chadd 4448692ad7caSAdrian Chadd static int 4449692ad7caSAdrian Chadd wpi_load_firmware(struct wpi_softc *sc) 4450692ad7caSAdrian Chadd { 4451692ad7caSAdrian Chadd struct wpi_fw_info *fw = &sc->fw; 4452692ad7caSAdrian Chadd struct wpi_dma_info *dma = &sc->fw_dma; 4453692ad7caSAdrian Chadd int error; 4454692ad7caSAdrian Chadd 4455692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4456692ad7caSAdrian Chadd 4457692ad7caSAdrian Chadd /* Copy initialization sections into pre-allocated DMA-safe memory. */ 4458692ad7caSAdrian Chadd memcpy(dma->vaddr, fw->init.data, fw->init.datasz); 4459692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4460692ad7caSAdrian Chadd memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->init.text, fw->init.textsz); 4461692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4462692ad7caSAdrian Chadd 4463692ad7caSAdrian Chadd /* Tell adapter where to find initialization sections. */ 4464692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4465692ad7caSAdrian Chadd return error; 4466692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); 4467692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->init.datasz); 4468692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, 4469692ad7caSAdrian Chadd dma->paddr + WPI_FW_DATA_MAXSZ); 4470692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, fw->init.textsz); 4471692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4472692ad7caSAdrian Chadd 4473692ad7caSAdrian Chadd /* Load firmware boot code. */ 4474692ad7caSAdrian Chadd error = wpi_load_bootcode(sc, fw->boot.text, fw->boot.textsz); 4475692ad7caSAdrian Chadd if (error != 0) { 4476692ad7caSAdrian Chadd device_printf(sc->sc_dev, "%s: could not load boot firmware\n", 4477692ad7caSAdrian Chadd __func__); 44786607310bSBenjamin Close return error; 44796607310bSBenjamin Close } 44806607310bSBenjamin Close 4481692ad7caSAdrian Chadd /* Now press "execute". */ 4482692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_RESET, 0); 4483692ad7caSAdrian Chadd 4484692ad7caSAdrian Chadd /* Wait at most one second for first alive notification. */ 448576fdf7ebSAdrian Chadd if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { 4486692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4487692ad7caSAdrian Chadd "%s: timeout waiting for adapter to initialize, error %d\n", 4488692ad7caSAdrian Chadd __func__, error); 44896607310bSBenjamin Close return error; 44906607310bSBenjamin Close } 44916607310bSBenjamin Close 4492692ad7caSAdrian Chadd /* Copy runtime sections into pre-allocated DMA-safe memory. */ 4493692ad7caSAdrian Chadd memcpy(dma->vaddr, fw->main.data, fw->main.datasz); 4494692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4495692ad7caSAdrian Chadd memcpy(dma->vaddr + WPI_FW_DATA_MAXSZ, fw->main.text, fw->main.textsz); 4496692ad7caSAdrian Chadd bus_dmamap_sync(dma->tag, dma->map, BUS_DMASYNC_PREWRITE); 4497692ad7caSAdrian Chadd 4498692ad7caSAdrian Chadd /* Tell adapter where to find runtime sections. */ 4499692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4500692ad7caSAdrian Chadd return error; 4501692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_ADDR, dma->paddr); 4502692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_DATA_SIZE, fw->main.datasz); 4503692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_ADDR, 4504692ad7caSAdrian Chadd dma->paddr + WPI_FW_DATA_MAXSZ); 4505692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_BSM_DRAM_TEXT_SIZE, 4506692ad7caSAdrian Chadd WPI_FW_UPDATED | fw->main.textsz); 4507692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4508692ad7caSAdrian Chadd 4509692ad7caSAdrian Chadd return 0; 4510692ad7caSAdrian Chadd } 4511692ad7caSAdrian Chadd 4512692ad7caSAdrian Chadd static int 4513692ad7caSAdrian Chadd wpi_read_firmware(struct wpi_softc *sc) 4514692ad7caSAdrian Chadd { 4515692ad7caSAdrian Chadd const struct firmware *fp; 4516692ad7caSAdrian Chadd struct wpi_fw_info *fw = &sc->fw; 4517692ad7caSAdrian Chadd const struct wpi_firmware_hdr *hdr; 4518692ad7caSAdrian Chadd int error; 4519692ad7caSAdrian Chadd 4520692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4521692ad7caSAdrian Chadd 4522692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, 4523692ad7caSAdrian Chadd "Attempting Loading Firmware from %s module\n", WPI_FW_NAME); 4524692ad7caSAdrian Chadd 4525692ad7caSAdrian Chadd WPI_UNLOCK(sc); 4526692ad7caSAdrian Chadd fp = firmware_get(WPI_FW_NAME); 4527692ad7caSAdrian Chadd WPI_LOCK(sc); 4528692ad7caSAdrian Chadd 4529692ad7caSAdrian Chadd if (fp == NULL) { 4530692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4531692ad7caSAdrian Chadd "could not load firmware image '%s'\n", WPI_FW_NAME); 4532692ad7caSAdrian Chadd return EINVAL; 4533692ad7caSAdrian Chadd } 4534692ad7caSAdrian Chadd 4535692ad7caSAdrian Chadd sc->fw_fp = fp; 4536692ad7caSAdrian Chadd 4537692ad7caSAdrian Chadd if (fp->datasize < sizeof (struct wpi_firmware_hdr)) { 4538692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4539692ad7caSAdrian Chadd "firmware file too short: %zu bytes\n", fp->datasize); 4540692ad7caSAdrian Chadd error = EINVAL; 4541692ad7caSAdrian Chadd goto fail; 4542692ad7caSAdrian Chadd } 4543692ad7caSAdrian Chadd 4544692ad7caSAdrian Chadd fw->size = fp->datasize; 4545692ad7caSAdrian Chadd fw->data = (const uint8_t *)fp->data; 4546692ad7caSAdrian Chadd 4547692ad7caSAdrian Chadd /* Extract firmware header information. */ 4548692ad7caSAdrian Chadd hdr = (const struct wpi_firmware_hdr *)fw->data; 4549692ad7caSAdrian Chadd 4550692ad7caSAdrian Chadd /* | RUNTIME FIRMWARE | INIT FIRMWARE | BOOT FW | 4551692ad7caSAdrian Chadd |HDR|<--TEXT-->|<--DATA-->|<--TEXT-->|<--DATA-->|<--TEXT-->| */ 4552692ad7caSAdrian Chadd 4553692ad7caSAdrian Chadd fw->main.textsz = le32toh(hdr->rtextsz); 4554692ad7caSAdrian Chadd fw->main.datasz = le32toh(hdr->rdatasz); 4555692ad7caSAdrian Chadd fw->init.textsz = le32toh(hdr->itextsz); 4556692ad7caSAdrian Chadd fw->init.datasz = le32toh(hdr->idatasz); 4557692ad7caSAdrian Chadd fw->boot.textsz = le32toh(hdr->btextsz); 4558692ad7caSAdrian Chadd fw->boot.datasz = 0; 4559692ad7caSAdrian Chadd 4560692ad7caSAdrian Chadd /* Sanity-check firmware header. */ 4561692ad7caSAdrian Chadd if (fw->main.textsz > WPI_FW_TEXT_MAXSZ || 4562692ad7caSAdrian Chadd fw->main.datasz > WPI_FW_DATA_MAXSZ || 4563692ad7caSAdrian Chadd fw->init.textsz > WPI_FW_TEXT_MAXSZ || 4564692ad7caSAdrian Chadd fw->init.datasz > WPI_FW_DATA_MAXSZ || 4565692ad7caSAdrian Chadd fw->boot.textsz > WPI_FW_BOOT_TEXT_MAXSZ || 4566692ad7caSAdrian Chadd (fw->boot.textsz & 3) != 0) { 4567692ad7caSAdrian Chadd device_printf(sc->sc_dev, "invalid firmware header\n"); 4568692ad7caSAdrian Chadd error = EINVAL; 4569692ad7caSAdrian Chadd goto fail; 4570692ad7caSAdrian Chadd } 4571692ad7caSAdrian Chadd 4572692ad7caSAdrian Chadd /* Check that all firmware sections fit. */ 4573692ad7caSAdrian Chadd if (fw->size < sizeof (*hdr) + fw->main.textsz + fw->main.datasz + 4574692ad7caSAdrian Chadd fw->init.textsz + fw->init.datasz + fw->boot.textsz) { 4575692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4576692ad7caSAdrian Chadd "firmware file too short: %zu bytes\n", fw->size); 4577692ad7caSAdrian Chadd error = EINVAL; 4578692ad7caSAdrian Chadd goto fail; 4579692ad7caSAdrian Chadd } 4580692ad7caSAdrian Chadd 4581692ad7caSAdrian Chadd /* Get pointers to firmware sections. */ 4582692ad7caSAdrian Chadd fw->main.text = (const uint8_t *)(hdr + 1); 4583692ad7caSAdrian Chadd fw->main.data = fw->main.text + fw->main.textsz; 4584692ad7caSAdrian Chadd fw->init.text = fw->main.data + fw->main.datasz; 4585692ad7caSAdrian Chadd fw->init.data = fw->init.text + fw->init.textsz; 4586692ad7caSAdrian Chadd fw->boot.text = fw->init.data + fw->init.datasz; 4587692ad7caSAdrian Chadd 4588692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, 4589692ad7caSAdrian Chadd "Firmware Version: Major %d, Minor %d, Driver %d, \n" 45907167f5fcSAdrian Chadd "runtime (text: %u, data: %u) init (text: %u, data %u) " 45917167f5fcSAdrian Chadd "boot (text %u)\n", hdr->major, hdr->minor, le32toh(hdr->driver), 4592692ad7caSAdrian Chadd fw->main.textsz, fw->main.datasz, 4593692ad7caSAdrian Chadd fw->init.textsz, fw->init.datasz, fw->boot.textsz); 4594692ad7caSAdrian Chadd 4595692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.text %p\n", fw->main.text); 4596692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->main.data %p\n", fw->main.data); 4597692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.text %p\n", fw->init.text); 4598692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->init.data %p\n", fw->init.data); 4599692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_FIRMWARE, "fw->boot.text %p\n", fw->boot.text); 4600692ad7caSAdrian Chadd 4601692ad7caSAdrian Chadd return 0; 4602692ad7caSAdrian Chadd 4603692ad7caSAdrian Chadd fail: wpi_unload_firmware(sc); 4604692ad7caSAdrian Chadd return error; 4605692ad7caSAdrian Chadd } 4606692ad7caSAdrian Chadd 4607692ad7caSAdrian Chadd /** 4608692ad7caSAdrian Chadd * Free the referenced firmware image 4609692ad7caSAdrian Chadd */ 4610692ad7caSAdrian Chadd static void 4611692ad7caSAdrian Chadd wpi_unload_firmware(struct wpi_softc *sc) 4612692ad7caSAdrian Chadd { 4613692ad7caSAdrian Chadd if (sc->fw_fp != NULL) { 4614692ad7caSAdrian Chadd firmware_put(sc->fw_fp, FIRMWARE_UNLOAD); 4615692ad7caSAdrian Chadd sc->fw_fp = NULL; 4616692ad7caSAdrian Chadd } 4617692ad7caSAdrian Chadd } 4618692ad7caSAdrian Chadd 4619692ad7caSAdrian Chadd static int 4620692ad7caSAdrian Chadd wpi_clock_wait(struct wpi_softc *sc) 4621692ad7caSAdrian Chadd { 4622692ad7caSAdrian Chadd int ntries; 4623692ad7caSAdrian Chadd 4624692ad7caSAdrian Chadd /* Set "initialization complete" bit. */ 4625692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); 4626692ad7caSAdrian Chadd 4627692ad7caSAdrian Chadd /* Wait for clock stabilization. */ 4628692ad7caSAdrian Chadd for (ntries = 0; ntries < 2500; ntries++) { 4629692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_MAC_CLOCK_READY) 4630692ad7caSAdrian Chadd return 0; 4631692ad7caSAdrian Chadd DELAY(100); 4632692ad7caSAdrian Chadd } 4633692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4634692ad7caSAdrian Chadd "%s: timeout waiting for clock stabilization\n", __func__); 4635692ad7caSAdrian Chadd 4636692ad7caSAdrian Chadd return ETIMEDOUT; 4637692ad7caSAdrian Chadd } 4638692ad7caSAdrian Chadd 4639692ad7caSAdrian Chadd static int 4640692ad7caSAdrian Chadd wpi_apm_init(struct wpi_softc *sc) 4641692ad7caSAdrian Chadd { 4642692ad7caSAdrian Chadd uint32_t reg; 4643692ad7caSAdrian Chadd int error; 4644692ad7caSAdrian Chadd 4645692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4646692ad7caSAdrian Chadd 4647692ad7caSAdrian Chadd /* Disable L0s exit timer (NMI bug workaround). */ 4648692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_DIS_L0S_TIMER); 4649692ad7caSAdrian Chadd /* Don't wait for ICH L0s (ICH bug workaround). */ 4650692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO_CHICKEN, WPI_GIO_CHICKEN_L1A_NO_L0S_RX); 4651692ad7caSAdrian Chadd 4652692ad7caSAdrian Chadd /* Set FH wait threshold to max (HW bug under stress workaround). */ 4653692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_DBG_HPET_MEM, 0xffff0000); 4654692ad7caSAdrian Chadd 4655692ad7caSAdrian Chadd /* Retrieve PCIe Active State Power Management (ASPM). */ 4656692ad7caSAdrian Chadd reg = pci_read_config(sc->sc_dev, sc->sc_cap_off + 0x10, 1); 4657692ad7caSAdrian Chadd /* Workaround for HW instability in PCIe L0->L0s->L1 transition. */ 4658692ad7caSAdrian Chadd if (reg & 0x02) /* L1 Entry enabled. */ 4659692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); 4660692ad7caSAdrian Chadd else 4661692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GIO, WPI_GIO_L0S_ENA); 4662692ad7caSAdrian Chadd 4663692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_ANA_PLL, WPI_ANA_PLL_INIT); 4664692ad7caSAdrian Chadd 4665692ad7caSAdrian Chadd /* Wait for clock stabilization before accessing prph. */ 4666692ad7caSAdrian Chadd if ((error = wpi_clock_wait(sc)) != 0) 4667692ad7caSAdrian Chadd return error; 4668692ad7caSAdrian Chadd 4669692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4670692ad7caSAdrian Chadd return error; 4671692ad7caSAdrian Chadd /* Enable DMA and BSM (Bootstrap State Machine). */ 4672692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_EN, 4673692ad7caSAdrian Chadd WPI_APMG_CLK_CTRL_DMA_CLK_RQT | WPI_APMG_CLK_CTRL_BSM_CLK_RQT); 4674692ad7caSAdrian Chadd DELAY(20); 4675692ad7caSAdrian Chadd /* Disable L1-Active. */ 4676692ad7caSAdrian Chadd wpi_prph_setbits(sc, WPI_APMG_PCI_STT, WPI_APMG_PCI_STT_L1A_DIS); 4677fae61c69SAdrian Chadd /* ??? */ 4678fae61c69SAdrian Chadd wpi_prph_clrbits(sc, WPI_APMG_PS, 0x00000E00); 4679692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4680692ad7caSAdrian Chadd 46816607310bSBenjamin Close return 0; 46826607310bSBenjamin Close } 46836607310bSBenjamin Close 46846607310bSBenjamin Close static void 4685692ad7caSAdrian Chadd wpi_apm_stop_master(struct wpi_softc *sc) 46866607310bSBenjamin Close { 46876607310bSBenjamin Close int ntries; 46886607310bSBenjamin Close 4689692ad7caSAdrian Chadd /* Stop busmaster DMA activity. */ 4690692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_RESET, WPI_RESET_STOP_MASTER); 46916607310bSBenjamin Close 4692692ad7caSAdrian Chadd if ((WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_PS_MASK) == 4693692ad7caSAdrian Chadd WPI_GP_CNTRL_MAC_PS) 4694692ad7caSAdrian Chadd return; /* Already asleep. */ 46956607310bSBenjamin Close 46966607310bSBenjamin Close for (ntries = 0; ntries < 100; ntries++) { 4697692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_RESET) & WPI_RESET_MASTER_DISABLED) 4698692ad7caSAdrian Chadd return; 46996607310bSBenjamin Close DELAY(10); 47006607310bSBenjamin Close } 47017167f5fcSAdrian Chadd device_printf(sc->sc_dev, "%s: timeout waiting for master\n", 47027167f5fcSAdrian Chadd __func__); 47036607310bSBenjamin Close } 4704692ad7caSAdrian Chadd 4705692ad7caSAdrian Chadd static void 4706692ad7caSAdrian Chadd wpi_apm_stop(struct wpi_softc *sc) 4707692ad7caSAdrian Chadd { 4708692ad7caSAdrian Chadd wpi_apm_stop_master(sc); 4709692ad7caSAdrian Chadd 4710692ad7caSAdrian Chadd /* Reset the entire device. */ 4711692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_RESET, WPI_RESET_SW); 4712692ad7caSAdrian Chadd DELAY(10); 4713692ad7caSAdrian Chadd /* Clear "initialization complete" bit. */ 4714692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_GP_CNTRL, WPI_GP_CNTRL_INIT_DONE); 4715692ad7caSAdrian Chadd } 4716692ad7caSAdrian Chadd 4717692ad7caSAdrian Chadd static void 4718692ad7caSAdrian Chadd wpi_nic_config(struct wpi_softc *sc) 4719692ad7caSAdrian Chadd { 4720692ad7caSAdrian Chadd uint32_t rev; 4721692ad7caSAdrian Chadd 4722692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 4723692ad7caSAdrian Chadd 4724692ad7caSAdrian Chadd /* voodoo from the Linux "driver".. */ 4725692ad7caSAdrian Chadd rev = pci_read_config(sc->sc_dev, PCIR_REVID, 1); 4726692ad7caSAdrian Chadd if ((rev & 0xc0) == 0x40) 4727692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MB); 4728692ad7caSAdrian Chadd else if (!(rev & 0x80)) 4729692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_ALM_MM); 4730692ad7caSAdrian Chadd 4731692ad7caSAdrian Chadd if (sc->cap == 0x80) 4732692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_SKU_MRC); 4733692ad7caSAdrian Chadd 4734f736d898SAdrian Chadd if ((sc->rev & 0xf0) == 0xd0) 4735692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); 4736692ad7caSAdrian Chadd else 4737692ad7caSAdrian Chadd WPI_CLRBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_REV_D); 4738692ad7caSAdrian Chadd 4739692ad7caSAdrian Chadd if (sc->type > 1) 4740692ad7caSAdrian Chadd WPI_SETBITS(sc, WPI_HW_IF_CONFIG, WPI_HW_IF_CONFIG_TYPE_B); 47416607310bSBenjamin Close } 47426607310bSBenjamin Close 47436607310bSBenjamin Close static int 4744692ad7caSAdrian Chadd wpi_hw_init(struct wpi_softc *sc) 47456607310bSBenjamin Close { 4746692ad7caSAdrian Chadd int chnl, ntries, error; 47476607310bSBenjamin Close 4748692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 47496607310bSBenjamin Close 4750692ad7caSAdrian Chadd /* Clear pending interrupts. */ 4751692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 4752692ad7caSAdrian Chadd 4753692ad7caSAdrian Chadd if ((error = wpi_apm_init(sc)) != 0) { 4754692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4755692ad7caSAdrian Chadd "%s: could not power ON adapter, error %d\n", __func__, 4756692ad7caSAdrian Chadd error); 4757692ad7caSAdrian Chadd return error; 4758692ad7caSAdrian Chadd } 4759692ad7caSAdrian Chadd 4760692ad7caSAdrian Chadd /* Select VMAIN power source. */ 4761692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4762692ad7caSAdrian Chadd return error; 4763692ad7caSAdrian Chadd wpi_prph_clrbits(sc, WPI_APMG_PS, WPI_APMG_PS_PWR_SRC_MASK); 4764692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4765692ad7caSAdrian Chadd /* Spin until VMAIN gets selected. */ 47666607310bSBenjamin Close for (ntries = 0; ntries < 5000; ntries++) { 4767692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GPIO_IN) & WPI_GPIO_IN_VMAIN) 47686607310bSBenjamin Close break; 47696607310bSBenjamin Close DELAY(10); 47706607310bSBenjamin Close } 47716607310bSBenjamin Close if (ntries == 5000) { 4772692ad7caSAdrian Chadd device_printf(sc->sc_dev, "timeout selecting power source\n"); 47736607310bSBenjamin Close return ETIMEDOUT; 47746607310bSBenjamin Close } 4775692ad7caSAdrian Chadd 4776692ad7caSAdrian Chadd /* Perform adapter initialization. */ 4777692ad7caSAdrian Chadd wpi_nic_config(sc); 4778692ad7caSAdrian Chadd 4779692ad7caSAdrian Chadd /* Initialize RX ring. */ 4780692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4781692ad7caSAdrian Chadd return error; 4782692ad7caSAdrian Chadd /* Set physical address of RX ring. */ 4783692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_BASE, sc->rxq.desc_dma.paddr); 4784692ad7caSAdrian Chadd /* Set physical address of RX read pointer. */ 4785692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_RPTR_ADDR, sc->shared_dma.paddr + 4786692ad7caSAdrian Chadd offsetof(struct wpi_shared, next)); 4787692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, 0); 4788692ad7caSAdrian Chadd /* Enable RX. */ 4789692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_CONFIG, 4790692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_DMA_ENA | 4791692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_RDRBD_ENA | 4792692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_WRSTATUS_ENA | 4793692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_MAXFRAG | 4794692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_NRBD(WPI_RX_RING_COUNT_LOG) | 4795692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_IRQ_DST_HOST | 4796692ad7caSAdrian Chadd WPI_FH_RX_CONFIG_IRQ_TIMEOUT(1)); 4797692ad7caSAdrian Chadd (void)WPI_READ(sc, WPI_FH_RSSR_TBL); /* barrier */ 4798692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4799692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_RX_WPTR, (WPI_RX_RING_COUNT - 1) & ~7); 4800692ad7caSAdrian Chadd 4801692ad7caSAdrian Chadd /* Initialize TX rings. */ 4802692ad7caSAdrian Chadd if ((error = wpi_nic_lock(sc)) != 0) 4803692ad7caSAdrian Chadd return error; 4804692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 2); /* bypass mode */ 4805692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_ARASTAT, 1); /* enable RA0 */ 4806692ad7caSAdrian Chadd /* Enable all 6 TX rings. */ 4807692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0x3f); 4808692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE1, 0x10000); 4809692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_SBYPASS_MODE2, 0x30002); 4810692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXF4MF, 4); 4811692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXF5MF, 5); 4812692ad7caSAdrian Chadd /* Set physical address of TX rings. */ 4813692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_BASE, sc->shared_dma.paddr); 4814692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_MSG_CONFIG, 0xffff05a5); 4815692ad7caSAdrian Chadd 4816692ad7caSAdrian Chadd /* Enable all DMA channels. */ 4817692ad7caSAdrian Chadd for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { 4818692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_CBBC_CTRL(chnl), 0); 4819692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_CBBC_BASE(chnl), 0); 4820692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0x80200008); 4821692ad7caSAdrian Chadd } 4822692ad7caSAdrian Chadd wpi_nic_unlock(sc); 4823692ad7caSAdrian Chadd (void)WPI_READ(sc, WPI_FH_TX_BASE); /* barrier */ 4824692ad7caSAdrian Chadd 4825692ad7caSAdrian Chadd /* Clear "radio off" and "commands blocked" bits. */ 4826692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 4827692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_CMD_BLOCKED); 4828692ad7caSAdrian Chadd 4829692ad7caSAdrian Chadd /* Clear pending interrupts. */ 4830692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 4831692ad7caSAdrian Chadd /* Enable interrupts. */ 4832692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, WPI_INT_MASK_DEF); 4833692ad7caSAdrian Chadd 4834692ad7caSAdrian Chadd /* _Really_ make sure "radio off" bit is cleared! */ 4835692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 4836692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_UCODE_GP1_CLR, WPI_UCODE_GP1_RFKILL); 4837692ad7caSAdrian Chadd 4838692ad7caSAdrian Chadd if ((error = wpi_load_firmware(sc)) != 0) { 4839692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4840692ad7caSAdrian Chadd "%s: could not load firmware, error %d\n", __func__, 4841692ad7caSAdrian Chadd error); 4842692ad7caSAdrian Chadd return error; 4843692ad7caSAdrian Chadd } 4844692ad7caSAdrian Chadd /* Wait at most one second for firmware alive notification. */ 484576fdf7ebSAdrian Chadd if ((error = mtx_sleep(sc, &sc->sc_mtx, PCATCH, "wpiinit", hz)) != 0) { 4846692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4847692ad7caSAdrian Chadd "%s: timeout waiting for adapter to initialize, error %d\n", 4848692ad7caSAdrian Chadd __func__, error); 4849692ad7caSAdrian Chadd return error; 48506607310bSBenjamin Close } 48516607310bSBenjamin Close 4852692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 4853692ad7caSAdrian Chadd 4854692ad7caSAdrian Chadd /* Do post-firmware initialization. */ 4855692ad7caSAdrian Chadd return wpi_post_alive(sc); 4856692ad7caSAdrian Chadd } 4857692ad7caSAdrian Chadd 4858692ad7caSAdrian Chadd static void 4859692ad7caSAdrian Chadd wpi_hw_stop(struct wpi_softc *sc) 48606607310bSBenjamin Close { 4861692ad7caSAdrian Chadd int chnl, qid, ntries; 48626607310bSBenjamin Close 4863692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 48646607310bSBenjamin Close 4865692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_UCODE_GP1) & WPI_UCODE_GP1_MAC_SLEEP) 4866692ad7caSAdrian Chadd wpi_nic_lock(sc); 48676607310bSBenjamin Close 4868692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_RESET, WPI_RESET_NEVO); 48696607310bSBenjamin Close 4870692ad7caSAdrian Chadd /* Disable interrupts. */ 4871692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT_MASK, 0); 4872692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_INT, 0xffffffff); 4873692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_INT, 0xffffffff); 48746607310bSBenjamin Close 4875692ad7caSAdrian Chadd /* Make sure we no longer hold the NIC lock. */ 4876692ad7caSAdrian Chadd wpi_nic_unlock(sc); 48776607310bSBenjamin Close 4878692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 4879692ad7caSAdrian Chadd /* Stop TX scheduler. */ 4880692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_MODE, 0); 4881692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_ALM_SCHED_TXFACT, 0); 4882692ad7caSAdrian Chadd 4883692ad7caSAdrian Chadd /* Stop all DMA channels. */ 4884692ad7caSAdrian Chadd for (chnl = 0; chnl < WPI_NDMACHNLS; chnl++) { 4885692ad7caSAdrian Chadd WPI_WRITE(sc, WPI_FH_TX_CONFIG(chnl), 0); 4886692ad7caSAdrian Chadd for (ntries = 0; ntries < 200; ntries++) { 4887692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_FH_TX_STATUS) & 4888692ad7caSAdrian Chadd WPI_FH_TX_STATUS_IDLE(chnl)) 48896607310bSBenjamin Close break; 48906607310bSBenjamin Close DELAY(10); 48916607310bSBenjamin Close } 4892692ad7caSAdrian Chadd } 4893692ad7caSAdrian Chadd wpi_nic_unlock(sc); 48946607310bSBenjamin Close } 48956607310bSBenjamin Close 4896692ad7caSAdrian Chadd /* Stop RX ring. */ 4897692ad7caSAdrian Chadd wpi_reset_rx_ring(sc); 48986607310bSBenjamin Close 4899692ad7caSAdrian Chadd /* Reset all TX rings. */ 4900692ad7caSAdrian Chadd for (qid = 0; qid < WPI_NTXQUEUES; qid++) 4901692ad7caSAdrian Chadd wpi_reset_tx_ring(sc, &sc->txq[qid]); 4902692ad7caSAdrian Chadd 4903692ad7caSAdrian Chadd if (wpi_nic_lock(sc) == 0) { 4904692ad7caSAdrian Chadd wpi_prph_write(sc, WPI_APMG_CLK_DIS, 4905692ad7caSAdrian Chadd WPI_APMG_CLK_CTRL_DMA_CLK_RQT); 4906692ad7caSAdrian Chadd wpi_nic_unlock(sc); 49076607310bSBenjamin Close } 4908692ad7caSAdrian Chadd DELAY(5); 4909692ad7caSAdrian Chadd /* Power OFF adapter. */ 4910692ad7caSAdrian Chadd wpi_apm_stop(sc); 49116607310bSBenjamin Close } 49126607310bSBenjamin Close 49136607310bSBenjamin Close static void 4914692ad7caSAdrian Chadd wpi_radio_on(void *arg0, int pending) 49156607310bSBenjamin Close { 4916692ad7caSAdrian Chadd struct wpi_softc *sc = arg0; 491782f1b132SAndrew Thompson struct ifnet *ifp = sc->sc_ifp; 4918b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 4919b032f27cSSam Leffler struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 492082f1b132SAndrew Thompson 4921692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RF switch: radio enabled\n"); 492282f1b132SAndrew Thompson 4923b032f27cSSam Leffler if (vap != NULL) { 4924692ad7caSAdrian Chadd wpi_init(sc); 4925692ad7caSAdrian Chadd ieee80211_init(vap); 492682f1b132SAndrew Thompson } 492782f1b132SAndrew Thompson 4928692ad7caSAdrian Chadd if (WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL) { 4929692ad7caSAdrian Chadd WPI_LOCK(sc); 4930692ad7caSAdrian Chadd callout_stop(&sc->watchdog_rfkill); 4931692ad7caSAdrian Chadd WPI_UNLOCK(sc); 4932692ad7caSAdrian Chadd } 493382f1b132SAndrew Thompson } 493482f1b132SAndrew Thompson 493582f1b132SAndrew Thompson static void 4936692ad7caSAdrian Chadd wpi_radio_off(void *arg0, int pending) 4937692ad7caSAdrian Chadd { 4938692ad7caSAdrian Chadd struct wpi_softc *sc = arg0; 4939692ad7caSAdrian Chadd struct ifnet *ifp = sc->sc_ifp; 4940692ad7caSAdrian Chadd struct ieee80211com *ic = ifp->if_l2com; 4941692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 4942692ad7caSAdrian Chadd 4943692ad7caSAdrian Chadd device_printf(sc->sc_dev, "RF switch: radio disabled\n"); 4944692ad7caSAdrian Chadd 4945692ad7caSAdrian Chadd wpi_stop(sc); 4946692ad7caSAdrian Chadd if (vap != NULL) 4947692ad7caSAdrian Chadd ieee80211_stop(vap); 4948692ad7caSAdrian Chadd 4949811fe0a8SAdrian Chadd WPI_LOCK(sc); 4950692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, sc); 4951811fe0a8SAdrian Chadd WPI_UNLOCK(sc); 4952692ad7caSAdrian Chadd } 4953692ad7caSAdrian Chadd 4954692ad7caSAdrian Chadd static void 4955692ad7caSAdrian Chadd wpi_init_locked(struct wpi_softc *sc) 495682f1b132SAndrew Thompson { 4957b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 4958692ad7caSAdrian Chadd int error; 49596607310bSBenjamin Close 4960692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_BEGIN, __func__); 49616607310bSBenjamin Close 4962692ad7caSAdrian Chadd WPI_LOCK_ASSERT(sc); 49636607310bSBenjamin Close 4964692ad7caSAdrian Chadd /* Check that the radio is not disabled by hardware switch. */ 4965692ad7caSAdrian Chadd if (!(WPI_READ(sc, WPI_GP_CNTRL) & WPI_GP_CNTRL_RFKILL)) { 49666607310bSBenjamin Close device_printf(sc->sc_dev, 4967692ad7caSAdrian Chadd "RF switch: radio disabled (%s)\n", __func__); 4968692ad7caSAdrian Chadd callout_reset(&sc->watchdog_rfkill, hz, wpi_watchdog_rfkill, 4969692ad7caSAdrian Chadd sc); 49706607310bSBenjamin Close return; 49716607310bSBenjamin Close } 49726607310bSBenjamin Close 4973692ad7caSAdrian Chadd /* Read firmware images from the filesystem. */ 4974692ad7caSAdrian Chadd if ((error = wpi_read_firmware(sc)) != 0) { 49756607310bSBenjamin Close device_printf(sc->sc_dev, 4976692ad7caSAdrian Chadd "%s: could not read firmware, error %d\n", __func__, 4977692ad7caSAdrian Chadd error); 4978692ad7caSAdrian Chadd goto fail; 49796607310bSBenjamin Close } 49806607310bSBenjamin Close 4981692ad7caSAdrian Chadd /* Initialize hardware and upload firmware. */ 4982692ad7caSAdrian Chadd error = wpi_hw_init(sc); 4983692ad7caSAdrian Chadd wpi_unload_firmware(sc); 4984692ad7caSAdrian Chadd if (error != 0) { 4985692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4986692ad7caSAdrian Chadd "%s: could not initialize hardware, error %d\n", __func__, 4987692ad7caSAdrian Chadd error); 4988692ad7caSAdrian Chadd goto fail; 4989692ad7caSAdrian Chadd } 4990692ad7caSAdrian Chadd 4991692ad7caSAdrian Chadd /* Configure adapter now that it is ready. */ 499263f57699SAdrian Chadd sc->txq_active = 1; 4993692ad7caSAdrian Chadd if ((error = wpi_config(sc)) != 0) { 4994692ad7caSAdrian Chadd device_printf(sc->sc_dev, 4995692ad7caSAdrian Chadd "%s: could not configure device, error %d\n", __func__, 4996692ad7caSAdrian Chadd error); 4997692ad7caSAdrian Chadd goto fail; 499882f1b132SAndrew Thompson } 499982f1b132SAndrew Thompson 50006607310bSBenjamin Close ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 50016607310bSBenjamin Close ifp->if_drv_flags |= IFF_DRV_RUNNING; 5002692ad7caSAdrian Chadd 500382f1b132SAndrew Thompson callout_reset(&sc->watchdog_to, hz, wpi_watchdog, sc); 5004692ad7caSAdrian Chadd 5005692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END, __func__); 5006692ad7caSAdrian Chadd 5007692ad7caSAdrian Chadd return; 5008692ad7caSAdrian Chadd 5009692ad7caSAdrian Chadd fail: wpi_stop_locked(sc); 5010692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_END_ERR, __func__); 50116607310bSBenjamin Close } 50126607310bSBenjamin Close 50136607310bSBenjamin Close static void 5014b032f27cSSam Leffler wpi_init(void *arg) 50156607310bSBenjamin Close { 5016b032f27cSSam Leffler struct wpi_softc *sc = arg; 5017b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 5018b032f27cSSam Leffler struct ieee80211com *ic = ifp->if_l2com; 50196607310bSBenjamin Close 50206607310bSBenjamin Close WPI_LOCK(sc); 5021692ad7caSAdrian Chadd wpi_init_locked(sc); 50226607310bSBenjamin Close WPI_UNLOCK(sc); 50236607310bSBenjamin Close 5024b032f27cSSam Leffler if (ifp->if_drv_flags & IFF_DRV_RUNNING) 5025692ad7caSAdrian Chadd ieee80211_start_all(ic); 50266607310bSBenjamin Close } 5027b032f27cSSam Leffler 50286607310bSBenjamin Close static void 50296607310bSBenjamin Close wpi_stop_locked(struct wpi_softc *sc) 50306607310bSBenjamin Close { 5031b032f27cSSam Leffler struct ifnet *ifp = sc->sc_ifp; 50326607310bSBenjamin Close 5033692ad7caSAdrian Chadd WPI_LOCK_ASSERT(sc); 5034692ad7caSAdrian Chadd 503563f57699SAdrian Chadd WPI_TXQ_LOCK(sc); 503663f57699SAdrian Chadd sc->txq_active = 0; 503763f57699SAdrian Chadd WPI_TXQ_UNLOCK(sc); 503863f57699SAdrian Chadd 503982f1b132SAndrew Thompson sc->sc_scan_timer = 0; 5040692ad7caSAdrian Chadd sc->sc_tx_timer = 0; 504182f1b132SAndrew Thompson callout_stop(&sc->watchdog_to); 504282f1b132SAndrew Thompson callout_stop(&sc->calib_to); 5043692ad7caSAdrian Chadd ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 504482f1b132SAndrew Thompson 5045692ad7caSAdrian Chadd /* Power OFF hardware. */ 5046692ad7caSAdrian Chadd wpi_hw_stop(sc); 50476607310bSBenjamin Close } 50486607310bSBenjamin Close 50496607310bSBenjamin Close static void 5050b032f27cSSam Leffler wpi_stop(struct wpi_softc *sc) 50516607310bSBenjamin Close { 5052b032f27cSSam Leffler WPI_LOCK(sc); 5053b032f27cSSam Leffler wpi_stop_locked(sc); 5054b032f27cSSam Leffler WPI_UNLOCK(sc); 50556607310bSBenjamin Close } 50566607310bSBenjamin Close 50576607310bSBenjamin Close /* 5058692ad7caSAdrian Chadd * Callback from net80211 to start a scan. 50596607310bSBenjamin Close */ 50606607310bSBenjamin Close static void 50616607310bSBenjamin Close wpi_scan_start(struct ieee80211com *ic) 50626607310bSBenjamin Close { 5063f319a41cSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 50646607310bSBenjamin Close 50655efea30fSAndrew Thompson wpi_set_led(sc, WPI_LED_LINK, 20, 2); 50666607310bSBenjamin Close } 50676607310bSBenjamin Close 5068692ad7caSAdrian Chadd /* 5069692ad7caSAdrian Chadd * Callback from net80211 to terminate a scan. 50706607310bSBenjamin Close */ 50716607310bSBenjamin Close static void 50726607310bSBenjamin Close wpi_scan_end(struct ieee80211com *ic) 50736607310bSBenjamin Close { 5074692ad7caSAdrian Chadd struct ifnet *ifp = ic->ic_ifp; 5075692ad7caSAdrian Chadd struct wpi_softc *sc = ifp->if_softc; 5076692ad7caSAdrian Chadd struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 5077692ad7caSAdrian Chadd 50780b093122SAdrian Chadd if (vap->iv_state == IEEE80211_S_RUN) 5079692ad7caSAdrian Chadd wpi_set_led(sc, WPI_LED_LINK, 0, 1); 50806607310bSBenjamin Close } 50816607310bSBenjamin Close 50826607310bSBenjamin Close /** 50836607310bSBenjamin Close * Called by the net80211 framework to indicate to the driver 50846607310bSBenjamin Close * that the channel should be changed 50856607310bSBenjamin Close */ 50866607310bSBenjamin Close static void 50876607310bSBenjamin Close wpi_set_channel(struct ieee80211com *ic) 50886607310bSBenjamin Close { 5089692ad7caSAdrian Chadd const struct ieee80211_channel *c = ic->ic_curchan; 50906607310bSBenjamin Close struct ifnet *ifp = ic->ic_ifp; 50916607310bSBenjamin Close struct wpi_softc *sc = ifp->if_softc; 50925efea30fSAndrew Thompson int error; 50936607310bSBenjamin Close 5094692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 5095692ad7caSAdrian Chadd 5096692ad7caSAdrian Chadd WPI_LOCK(sc); 5097692ad7caSAdrian Chadd sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq); 5098692ad7caSAdrian Chadd sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags); 5099692ad7caSAdrian Chadd sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq); 5100692ad7caSAdrian Chadd sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags); 5101692ad7caSAdrian Chadd 510282f1b132SAndrew Thompson /* 510382f1b132SAndrew Thompson * Only need to set the channel in Monitor mode. AP scanning and auth 510482f1b132SAndrew Thompson * are already taken care of by their respective firmware commands. 510582f1b132SAndrew Thompson */ 51065efea30fSAndrew Thompson if (ic->ic_opmode == IEEE80211_M_MONITOR) { 5107692ad7caSAdrian Chadd sc->rxon.chan = ieee80211_chan2ieee(ic, c); 5108692ad7caSAdrian Chadd if (IEEE80211_IS_CHAN_2GHZ(c)) { 5109692ad7caSAdrian Chadd sc->rxon.flags |= htole32(WPI_RXON_AUTO | 5110692ad7caSAdrian Chadd WPI_RXON_24GHZ); 5111692ad7caSAdrian Chadd } else { 5112692ad7caSAdrian Chadd sc->rxon.flags &= ~htole32(WPI_RXON_AUTO | 5113692ad7caSAdrian Chadd WPI_RXON_24GHZ); 51145efea30fSAndrew Thompson } 5115692ad7caSAdrian Chadd if ((error = wpi_send_rxon(sc, 0, 0)) != 0) 5116692ad7caSAdrian Chadd device_printf(sc->sc_dev, 5117692ad7caSAdrian Chadd "%s: error %d settting channel\n", __func__, 5118692ad7caSAdrian Chadd error); 5119692ad7caSAdrian Chadd } 5120692ad7caSAdrian Chadd WPI_UNLOCK(sc); 51216607310bSBenjamin Close } 51226607310bSBenjamin Close 51236607310bSBenjamin Close /** 51246607310bSBenjamin Close * Called by net80211 to indicate that we need to scan the current 51256607310bSBenjamin Close * channel. The channel is previously be set via the wpi_set_channel 51266607310bSBenjamin Close * callback. 51276607310bSBenjamin Close */ 51286607310bSBenjamin Close static void 5129b032f27cSSam Leffler wpi_scan_curchan(struct ieee80211_scan_state *ss, unsigned long maxdwell) 51306607310bSBenjamin Close { 5131b032f27cSSam Leffler struct ieee80211vap *vap = ss->ss_vap; 5132692ad7caSAdrian Chadd struct ieee80211com *ic = vap->iv_ic; 5133f319a41cSAdrian Chadd struct wpi_softc *sc = ic->ic_ifp->if_softc; 5134692ad7caSAdrian Chadd int error; 51356607310bSBenjamin Close 5136692ad7caSAdrian Chadd if (sc->rxon.chan != ieee80211_chan2ieee(ic, ic->ic_curchan)) { 51375efea30fSAndrew Thompson WPI_LOCK(sc); 5138692ad7caSAdrian Chadd error = wpi_scan(sc, ic->ic_curchan); 51395efea30fSAndrew Thompson WPI_UNLOCK(sc); 5140692ad7caSAdrian Chadd if (error != 0) 5141692ad7caSAdrian Chadd ieee80211_cancel_scan(vap); 5142692ad7caSAdrian Chadd } else { 5143692ad7caSAdrian Chadd /* Send probe request when associated. */ 5144692ad7caSAdrian Chadd sc->sc_scan_curchan(ss, maxdwell); 5145692ad7caSAdrian Chadd } 51466607310bSBenjamin Close } 51476607310bSBenjamin Close 51486607310bSBenjamin Close /** 51496607310bSBenjamin Close * Called by the net80211 framework to indicate 51506607310bSBenjamin Close * the minimum dwell time has been met, terminate the scan. 51516607310bSBenjamin Close * We don't actually terminate the scan as the firmware will notify 51526607310bSBenjamin Close * us when it's finished and we have no way to interrupt it. 51536607310bSBenjamin Close */ 51546607310bSBenjamin Close static void 5155b032f27cSSam Leffler wpi_scan_mindwell(struct ieee80211_scan_state *ss) 51566607310bSBenjamin Close { 51576607310bSBenjamin Close /* NB: don't try to abort scan; wait for firmware to finish */ 51586607310bSBenjamin Close } 51596607310bSBenjamin Close 51606607310bSBenjamin Close static void 5161692ad7caSAdrian Chadd wpi_hw_reset(void *arg, int pending) 51626607310bSBenjamin Close { 51636607310bSBenjamin Close struct wpi_softc *sc = arg; 516482f1b132SAndrew Thompson struct ifnet *ifp = sc->sc_ifp; 51655efea30fSAndrew Thompson struct ieee80211com *ic = ifp->if_l2com; 5166b032f27cSSam Leffler struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 516782f1b132SAndrew Thompson 5168692ad7caSAdrian Chadd DPRINTF(sc, WPI_DEBUG_TRACE, TRACE_STR_DOING, __func__); 51696607310bSBenjamin Close 5170692ad7caSAdrian Chadd wpi_stop(sc); 5171692ad7caSAdrian Chadd if (vap != NULL) 5172692ad7caSAdrian Chadd ieee80211_stop(vap); 5173692ad7caSAdrian Chadd wpi_init(sc); 5174692ad7caSAdrian Chadd if (vap != NULL) 5175692ad7caSAdrian Chadd ieee80211_init(vap); 51766607310bSBenjamin Close } 5177