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