if_urtwn.c revision 294473
1251538Srpaulo/*	$OpenBSD: if_urtwn.c,v 1.16 2011/02/10 17:26:40 jakemsr Exp $	*/
2251538Srpaulo
3251538Srpaulo/*-
4251538Srpaulo * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr>
5264912Skevlo * Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org>
6292176Savos * Copyright (c) 2015 Andriy Voskoboinyk <avos@FreeBSD.org>
7251538Srpaulo *
8251538Srpaulo * Permission to use, copy, modify, and distribute this software for any
9251538Srpaulo * purpose with or without fee is hereby granted, provided that the above
10251538Srpaulo * copyright notice and this permission notice appear in all copies.
11251538Srpaulo *
12251538Srpaulo * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13251538Srpaulo * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14251538Srpaulo * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15251538Srpaulo * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16251538Srpaulo * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17251538Srpaulo * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18251538Srpaulo * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19251538Srpaulo */
20251538Srpaulo
21251538Srpaulo#include <sys/cdefs.h>
22251538Srpaulo__FBSDID("$FreeBSD: head/sys/dev/usb/wlan/if_urtwn.c 294473 2016-01-20 23:55:39Z avos $");
23251538Srpaulo
24251538Srpaulo/*
25264912Skevlo * Driver for Realtek RTL8188CE-VAU/RTL8188CUS/RTL8188EU/RTL8188RU/RTL8192CU.
26251538Srpaulo */
27251538Srpaulo
28288353Sadrian#include "opt_wlan.h"
29288353Sadrian
30251538Srpaulo#include <sys/param.h>
31251538Srpaulo#include <sys/sockio.h>
32251538Srpaulo#include <sys/sysctl.h>
33251538Srpaulo#include <sys/lock.h>
34251538Srpaulo#include <sys/mutex.h>
35291902Skevlo#include <sys/condvar.h>
36251538Srpaulo#include <sys/mbuf.h>
37251538Srpaulo#include <sys/kernel.h>
38251538Srpaulo#include <sys/socket.h>
39251538Srpaulo#include <sys/systm.h>
40251538Srpaulo#include <sys/malloc.h>
41251538Srpaulo#include <sys/module.h>
42251538Srpaulo#include <sys/bus.h>
43251538Srpaulo#include <sys/endian.h>
44251538Srpaulo#include <sys/linker.h>
45251538Srpaulo#include <sys/firmware.h>
46251538Srpaulo#include <sys/kdb.h>
47251538Srpaulo
48251538Srpaulo#include <machine/bus.h>
49251538Srpaulo#include <machine/resource.h>
50251538Srpaulo#include <sys/rman.h>
51251538Srpaulo
52251538Srpaulo#include <net/bpf.h>
53251538Srpaulo#include <net/if.h>
54257176Sglebius#include <net/if_var.h>
55251538Srpaulo#include <net/if_arp.h>
56251538Srpaulo#include <net/ethernet.h>
57251538Srpaulo#include <net/if_dl.h>
58251538Srpaulo#include <net/if_media.h>
59251538Srpaulo#include <net/if_types.h>
60251538Srpaulo
61251538Srpaulo#include <netinet/in.h>
62251538Srpaulo#include <netinet/in_systm.h>
63251538Srpaulo#include <netinet/in_var.h>
64251538Srpaulo#include <netinet/if_ether.h>
65251538Srpaulo#include <netinet/ip.h>
66251538Srpaulo
67251538Srpaulo#include <net80211/ieee80211_var.h>
68288088Sadrian#include <net80211/ieee80211_input.h>
69251538Srpaulo#include <net80211/ieee80211_regdomain.h>
70251538Srpaulo#include <net80211/ieee80211_radiotap.h>
71251538Srpaulo#include <net80211/ieee80211_ratectl.h>
72251538Srpaulo
73251538Srpaulo#include <dev/usb/usb.h>
74251538Srpaulo#include <dev/usb/usbdi.h>
75291902Skevlo#include <dev/usb/usb_device.h>
76251538Srpaulo#include "usbdevs.h"
77251538Srpaulo
78251538Srpaulo#include <dev/usb/usb_debug.h>
79251538Srpaulo
80251538Srpaulo#include <dev/usb/wlan/if_urtwnreg.h>
81289167Sadrian#include <dev/usb/wlan/if_urtwnvar.h>
82251538Srpaulo
83251538Srpaulo#ifdef USB_DEBUG
84294471Savosenum {
85294471Savos	URTWN_DEBUG_XMIT	= 0x00000001,	/* basic xmit operation */
86294471Savos	URTWN_DEBUG_RECV	= 0x00000002,	/* basic recv operation */
87294471Savos	URTWN_DEBUG_STATE	= 0x00000004,	/* 802.11 state transitions */
88294471Savos	URTWN_DEBUG_RA		= 0x00000008,	/* f/w rate adaptation setup */
89294471Savos	URTWN_DEBUG_USB		= 0x00000010,	/* usb requests */
90294471Savos	URTWN_DEBUG_FIRMWARE	= 0x00000020,	/* firmware(9) loading debug */
91294471Savos	URTWN_DEBUG_BEACON	= 0x00000040,	/* beacon handling */
92294471Savos	URTWN_DEBUG_INTR	= 0x00000080,	/* ISR */
93294471Savos	URTWN_DEBUG_TEMP	= 0x00000100,	/* temperature calibration */
94294471Savos	URTWN_DEBUG_ROM		= 0x00000200,	/* various ROM info */
95294471Savos	URTWN_DEBUG_KEY		= 0x00000400,	/* crypto keys management */
96294471Savos	URTWN_DEBUG_TXPWR	= 0x00000800,	/* dump Tx power values */
97294471Savos	URTWN_DEBUG_ANY		= 0xffffffff
98294471Savos};
99251538Srpaulo
100294471Savos#define URTWN_DPRINTF(_sc, _m, ...) do {			\
101294471Savos	if ((_sc)->sc_debug & (_m))				\
102294471Savos		device_printf((_sc)->sc_dev, __VA_ARGS__);	\
103294471Savos} while(0)
104294471Savos
105294471Savos#else
106294471Savos#define URTWN_DPRINTF(_sc, _m, ...)	do { (void) sc; } while (0)
107251538Srpaulo#endif
108251538Srpaulo
109288088Sadrian#define	IEEE80211_HAS_ADDR4(wh)	IEEE80211_IS_DSTODS(wh)
110251538Srpaulo
111251538Srpaulo/* various supported device vendors/products */
112251596Srpaulostatic const STRUCT_USB_HOST_ID urtwn_devs[] = {
113251538Srpaulo#define URTWN_DEV(v,p)  { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
114264912Skevlo#define	URTWN_RTL8188E_DEV(v,p)	\
115264912Skevlo	{ USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, URTWN_RTL8188E) }
116264912Skevlo#define URTWN_RTL8188E  1
117251538Srpaulo	URTWN_DEV(ABOCOM,	RTL8188CU_1),
118251538Srpaulo	URTWN_DEV(ABOCOM,	RTL8188CU_2),
119251538Srpaulo	URTWN_DEV(ABOCOM,	RTL8192CU),
120251538Srpaulo	URTWN_DEV(ASUS,		RTL8192CU),
121266721Skevlo	URTWN_DEV(ASUS,		USBN10NANO),
122251538Srpaulo	URTWN_DEV(AZUREWAVE,	RTL8188CE_1),
123251538Srpaulo	URTWN_DEV(AZUREWAVE,	RTL8188CE_2),
124251538Srpaulo	URTWN_DEV(AZUREWAVE,	RTL8188CU),
125251538Srpaulo	URTWN_DEV(BELKIN,	F7D2102),
126251538Srpaulo	URTWN_DEV(BELKIN,	RTL8188CU),
127251538Srpaulo	URTWN_DEV(BELKIN,	RTL8192CU),
128251538Srpaulo	URTWN_DEV(CHICONY,	RTL8188CUS_1),
129251538Srpaulo	URTWN_DEV(CHICONY,	RTL8188CUS_2),
130251538Srpaulo	URTWN_DEV(CHICONY,	RTL8188CUS_3),
131251538Srpaulo	URTWN_DEV(CHICONY,	RTL8188CUS_4),
132251538Srpaulo	URTWN_DEV(CHICONY,	RTL8188CUS_5),
133251538Srpaulo	URTWN_DEV(COREGA,	RTL8192CU),
134251538Srpaulo	URTWN_DEV(DLINK,	RTL8188CU),
135251538Srpaulo	URTWN_DEV(DLINK,	RTL8192CU_1),
136251538Srpaulo	URTWN_DEV(DLINK,	RTL8192CU_2),
137251538Srpaulo	URTWN_DEV(DLINK,	RTL8192CU_3),
138252196Skevlo	URTWN_DEV(DLINK,	DWA131B),
139251538Srpaulo	URTWN_DEV(EDIMAX,	EW7811UN),
140251538Srpaulo	URTWN_DEV(EDIMAX,	RTL8192CU),
141251538Srpaulo	URTWN_DEV(FEIXUN,	RTL8188CU),
142251538Srpaulo	URTWN_DEV(FEIXUN,	RTL8192CU),
143251538Srpaulo	URTWN_DEV(GUILLEMOT,	HWNUP150),
144251538Srpaulo	URTWN_DEV(HAWKING,	RTL8192CU),
145251538Srpaulo	URTWN_DEV(HP3,		RTL8188CU),
146251538Srpaulo	URTWN_DEV(NETGEAR,	WNA1000M),
147251538Srpaulo	URTWN_DEV(NETGEAR,	RTL8192CU),
148251538Srpaulo	URTWN_DEV(NETGEAR4,	RTL8188CU),
149251538Srpaulo	URTWN_DEV(NOVATECH,	RTL8188CU),
150251538Srpaulo	URTWN_DEV(PLANEX2,	RTL8188CU_1),
151251538Srpaulo	URTWN_DEV(PLANEX2,	RTL8188CU_2),
152251538Srpaulo	URTWN_DEV(PLANEX2,	RTL8188CU_3),
153251538Srpaulo	URTWN_DEV(PLANEX2,	RTL8188CU_4),
154251538Srpaulo	URTWN_DEV(PLANEX2,	RTL8188CUS),
155251538Srpaulo	URTWN_DEV(PLANEX2,	RTL8192CU),
156251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CE_0),
157251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CE_1),
158251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CTV),
159251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CU_0),
160251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CU_1),
161251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CU_2),
162282119Skevlo	URTWN_DEV(REALTEK,	RTL8188CU_3),
163251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CU_COMBO),
164251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188CUS),
165251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188RU_1),
166251538Srpaulo	URTWN_DEV(REALTEK,	RTL8188RU_2),
167272410Shselasky	URTWN_DEV(REALTEK,	RTL8188RU_3),
168251538Srpaulo	URTWN_DEV(REALTEK,	RTL8191CU),
169251538Srpaulo	URTWN_DEV(REALTEK,	RTL8192CE),
170251538Srpaulo	URTWN_DEV(REALTEK,	RTL8192CU),
171251538Srpaulo	URTWN_DEV(SITECOMEU,	RTL8188CU_1),
172251538Srpaulo	URTWN_DEV(SITECOMEU,	RTL8188CU_2),
173251538Srpaulo	URTWN_DEV(SITECOMEU,	RTL8192CU),
174251538Srpaulo	URTWN_DEV(TRENDNET,	RTL8188CU),
175251538Srpaulo	URTWN_DEV(TRENDNET,	RTL8192CU),
176251538Srpaulo	URTWN_DEV(ZYXEL,	RTL8192CU),
177264912Skevlo	/* URTWN_RTL8188E */
178273589Skevlo	URTWN_RTL8188E_DEV(DLINK,	DWA123D1),
179270191Skevlo	URTWN_RTL8188E_DEV(DLINK,	DWA125D1),
180273589Skevlo	URTWN_RTL8188E_DEV(ELECOM,	WDC150SU2M),
181264912Skevlo	URTWN_RTL8188E_DEV(REALTEK,	RTL8188ETV),
182264912Skevlo	URTWN_RTL8188E_DEV(REALTEK,	RTL8188EU),
183264912Skevlo#undef URTWN_RTL8188E_DEV
184251538Srpaulo#undef URTWN_DEV
185251538Srpaulo};
186251538Srpaulo
187251538Srpaulostatic device_probe_t	urtwn_match;
188251538Srpaulostatic device_attach_t	urtwn_attach;
189251538Srpaulostatic device_detach_t	urtwn_detach;
190251538Srpaulo
191251538Srpaulostatic usb_callback_t   urtwn_bulk_tx_callback;
192251538Srpaulostatic usb_callback_t	urtwn_bulk_rx_callback;
193251538Srpaulo
194294471Savosstatic void		urtwn_sysctlattach(struct urtwn_softc *);
195294471Savosstatic void		urtwn_drain_mbufq(struct urtwn_softc *);
196287197Sglebiusstatic usb_error_t	urtwn_do_request(struct urtwn_softc *,
197287197Sglebius			    struct usb_device_request *, void *);
198251538Srpaulostatic struct ieee80211vap *urtwn_vap_create(struct ieee80211com *,
199251538Srpaulo		    const char [IFNAMSIZ], int, enum ieee80211_opmode, int,
200251538Srpaulo                    const uint8_t [IEEE80211_ADDR_LEN],
201251538Srpaulo                    const uint8_t [IEEE80211_ADDR_LEN]);
202251538Srpaulostatic void		urtwn_vap_delete(struct ieee80211vap *);
203292207Savosstatic struct mbuf *	urtwn_rx_copy_to_mbuf(struct urtwn_softc *,
204292207Savos			    struct r92c_rx_stat *, int);
205292207Savosstatic struct mbuf *	urtwn_report_intr(struct usb_xfer *,
206292207Savos			    struct urtwn_data *);
207292207Savosstatic struct mbuf *	urtwn_rxeof(struct urtwn_softc *, uint8_t *, int);
208292167Savosstatic void		urtwn_r88e_ratectl_tx_complete(struct urtwn_softc *,
209292167Savos			    void *);
210292207Savosstatic struct ieee80211_node *urtwn_rx_frame(struct urtwn_softc *,
211292207Savos			    struct mbuf *, int8_t *);
212289891Savosstatic void		urtwn_txeof(struct urtwn_softc *, struct urtwn_data *,
213289891Savos			    int);
214281069Srpaulostatic int		urtwn_alloc_list(struct urtwn_softc *,
215251538Srpaulo			    struct urtwn_data[], int, int);
216251538Srpaulostatic int		urtwn_alloc_rx_list(struct urtwn_softc *);
217251538Srpaulostatic int		urtwn_alloc_tx_list(struct urtwn_softc *);
218251538Srpaulostatic void		urtwn_free_list(struct urtwn_softc *,
219251538Srpaulo			    struct urtwn_data data[], int);
220289066Skevlostatic void		urtwn_free_rx_list(struct urtwn_softc *);
221289066Skevlostatic void		urtwn_free_tx_list(struct urtwn_softc *);
222251538Srpaulostatic struct urtwn_data *	_urtwn_getbuf(struct urtwn_softc *);
223251538Srpaulostatic struct urtwn_data *	urtwn_getbuf(struct urtwn_softc *);
224291698Savosstatic usb_error_t	urtwn_write_region_1(struct urtwn_softc *, uint16_t,
225251538Srpaulo			    uint8_t *, int);
226291698Savosstatic usb_error_t	urtwn_write_1(struct urtwn_softc *, uint16_t, uint8_t);
227291698Savosstatic usb_error_t	urtwn_write_2(struct urtwn_softc *, uint16_t, uint16_t);
228291698Savosstatic usb_error_t	urtwn_write_4(struct urtwn_softc *, uint16_t, uint32_t);
229291698Savosstatic usb_error_t	urtwn_read_region_1(struct urtwn_softc *, uint16_t,
230251538Srpaulo			    uint8_t *, int);
231251538Srpaulostatic uint8_t		urtwn_read_1(struct urtwn_softc *, uint16_t);
232251538Srpaulostatic uint16_t		urtwn_read_2(struct urtwn_softc *, uint16_t);
233251538Srpaulostatic uint32_t		urtwn_read_4(struct urtwn_softc *, uint16_t);
234281069Srpaulostatic int		urtwn_fw_cmd(struct urtwn_softc *, uint8_t,
235251538Srpaulo			    const void *, int);
236292174Savosstatic void		urtwn_cmdq_cb(void *, int);
237292174Savosstatic int		urtwn_cmd_sleepable(struct urtwn_softc *, const void *,
238292174Savos			    size_t, CMD_FUNC_PROTO);
239264912Skevlostatic void		urtwn_r92c_rf_write(struct urtwn_softc *, int,
240264912Skevlo			    uint8_t, uint32_t);
241281069Srpaulostatic void		urtwn_r88e_rf_write(struct urtwn_softc *, int,
242264912Skevlo			    uint8_t, uint32_t);
243251538Srpaulostatic uint32_t		urtwn_rf_read(struct urtwn_softc *, int, uint8_t);
244281069Srpaulostatic int		urtwn_llt_write(struct urtwn_softc *, uint32_t,
245251538Srpaulo			    uint32_t);
246291264Savosstatic int		urtwn_efuse_read_next(struct urtwn_softc *, uint8_t *);
247291264Savosstatic int		urtwn_efuse_read_data(struct urtwn_softc *, uint8_t *,
248291264Savos			    uint8_t, uint8_t);
249294471Savos#ifdef USB_DEBUG
250291264Savosstatic void		urtwn_dump_rom_contents(struct urtwn_softc *,
251291264Savos			    uint8_t *, uint16_t);
252291264Savos#endif
253291264Savosstatic int		urtwn_efuse_read(struct urtwn_softc *, uint8_t *,
254291264Savos			    uint16_t);
255291698Savosstatic int		urtwn_efuse_switch_power(struct urtwn_softc *);
256251538Srpaulostatic int		urtwn_read_chipid(struct urtwn_softc *);
257291264Savosstatic int		urtwn_read_rom(struct urtwn_softc *);
258291264Savosstatic int		urtwn_r88e_read_rom(struct urtwn_softc *);
259251538Srpaulostatic int		urtwn_ra_init(struct urtwn_softc *);
260290631Savosstatic void		urtwn_init_beacon(struct urtwn_softc *,
261290631Savos			    struct urtwn_vap *);
262290631Savosstatic int		urtwn_setup_beacon(struct urtwn_softc *,
263290631Savos			    struct ieee80211_node *);
264290631Savosstatic void		urtwn_update_beacon(struct ieee80211vap *, int);
265290631Savosstatic int		urtwn_tx_beacon(struct urtwn_softc *sc,
266290631Savos			    struct urtwn_vap *);
267292175Savosstatic int		urtwn_key_alloc(struct ieee80211vap *,
268292175Savos			    struct ieee80211_key *, ieee80211_keyix *,
269292175Savos			    ieee80211_keyix *);
270292175Savosstatic void		urtwn_key_set_cb(struct urtwn_softc *,
271292175Savos			    union sec_param *);
272292175Savosstatic void		urtwn_key_del_cb(struct urtwn_softc *,
273292175Savos			    union sec_param *);
274292175Savosstatic int		urtwn_key_set(struct ieee80211vap *,
275292175Savos			    const struct ieee80211_key *);
276292175Savosstatic int		urtwn_key_delete(struct ieee80211vap *,
277292175Savos			    const struct ieee80211_key *);
278290651Savosstatic void		urtwn_tsf_task_adhoc(void *, int);
279290631Savosstatic void		urtwn_tsf_sync_enable(struct urtwn_softc *,
280290631Savos			    struct ieee80211vap *);
281292203Savosstatic void		urtwn_get_tsf(struct urtwn_softc *, uint64_t *);
282251538Srpaulostatic void		urtwn_set_led(struct urtwn_softc *, int, int);
283289811Savosstatic void		urtwn_set_mode(struct urtwn_softc *, uint8_t);
284290651Savosstatic void		urtwn_ibss_recv_mgmt(struct ieee80211_node *,
285290651Savos			    struct mbuf *, int,
286290651Savos			    const struct ieee80211_rx_stats *, int, int);
287281069Srpaulostatic int		urtwn_newstate(struct ieee80211vap *,
288251538Srpaulo			    enum ieee80211_state, int);
289294473Savosstatic void		urtwn_calib_to(void *);
290294473Savosstatic void		urtwn_calib_cb(struct urtwn_softc *,
291294473Savos			    union sec_param *);
292251538Srpaulostatic void		urtwn_watchdog(void *);
293251538Srpaulostatic void		urtwn_update_avgrssi(struct urtwn_softc *, int, int8_t);
294251538Srpaulostatic int8_t		urtwn_get_rssi(struct urtwn_softc *, int, void *);
295264912Skevlostatic int8_t		urtwn_r88e_get_rssi(struct urtwn_softc *, int, void *);
296290630Savosstatic int		urtwn_tx_data(struct urtwn_softc *,
297251538Srpaulo			    struct ieee80211_node *, struct mbuf *,
298251538Srpaulo			    struct urtwn_data *);
299292221Savosstatic int		urtwn_tx_raw(struct urtwn_softc *,
300292221Savos			    struct ieee80211_node *, struct mbuf *,
301292221Savos			    struct urtwn_data *,
302292221Savos			    const struct ieee80211_bpf_params *);
303290630Savosstatic void		urtwn_tx_start(struct urtwn_softc *, struct mbuf *,
304290630Savos			    uint8_t, struct urtwn_data *);
305287197Sglebiusstatic int		urtwn_transmit(struct ieee80211com *, struct mbuf *);
306287197Sglebiusstatic void		urtwn_start(struct urtwn_softc *);
307287197Sglebiusstatic void		urtwn_parent(struct ieee80211com *);
308264912Skevlostatic int		urtwn_r92c_power_on(struct urtwn_softc *);
309264912Skevlostatic int		urtwn_r88e_power_on(struct urtwn_softc *);
310251538Srpaulostatic int		urtwn_llt_init(struct urtwn_softc *);
311251538Srpaulostatic void		urtwn_fw_reset(struct urtwn_softc *);
312264912Skevlostatic void		urtwn_r88e_fw_reset(struct urtwn_softc *);
313281069Srpaulostatic int		urtwn_fw_loadpage(struct urtwn_softc *, int,
314251538Srpaulo			    const uint8_t *, int);
315251538Srpaulostatic int		urtwn_load_firmware(struct urtwn_softc *);
316291902Skevlostatic int		urtwn_dma_init(struct urtwn_softc *);
317291698Savosstatic int		urtwn_mac_init(struct urtwn_softc *);
318251538Srpaulostatic void		urtwn_bb_init(struct urtwn_softc *);
319251538Srpaulostatic void		urtwn_rf_init(struct urtwn_softc *);
320251538Srpaulostatic void		urtwn_cam_init(struct urtwn_softc *);
321292175Savosstatic int		urtwn_cam_write(struct urtwn_softc *, uint32_t,
322292175Savos			    uint32_t);
323251538Srpaulostatic void		urtwn_pa_bias_init(struct urtwn_softc *);
324251538Srpaulostatic void		urtwn_rxfilter_init(struct urtwn_softc *);
325251538Srpaulostatic void		urtwn_edca_init(struct urtwn_softc *);
326281069Srpaulostatic void		urtwn_write_txpower(struct urtwn_softc *, int,
327251538Srpaulo			    uint16_t[]);
328251538Srpaulostatic void		urtwn_get_txpower(struct urtwn_softc *, int,
329281069Srpaulo		      	    struct ieee80211_channel *,
330251538Srpaulo			    struct ieee80211_channel *, uint16_t[]);
331264912Skevlostatic void		urtwn_r88e_get_txpower(struct urtwn_softc *, int,
332281069Srpaulo		      	    struct ieee80211_channel *,
333264912Skevlo			    struct ieee80211_channel *, uint16_t[]);
334251538Srpaulostatic void		urtwn_set_txpower(struct urtwn_softc *,
335281069Srpaulo		    	    struct ieee80211_channel *,
336251538Srpaulo			    struct ieee80211_channel *);
337290048Savosstatic void		urtwn_set_rx_bssid_all(struct urtwn_softc *, int);
338290048Savosstatic void		urtwn_set_gain(struct urtwn_softc *, uint8_t);
339251538Srpaulostatic void		urtwn_scan_start(struct ieee80211com *);
340251538Srpaulostatic void		urtwn_scan_end(struct ieee80211com *);
341251538Srpaulostatic void		urtwn_set_channel(struct ieee80211com *);
342292014Savosstatic int		urtwn_wme_update(struct ieee80211com *);
343294465Savosstatic void		urtwn_update_slot(struct ieee80211com *);
344294465Savosstatic void		urtwn_update_slot_cb(struct urtwn_softc *,
345294465Savos			    union sec_param *);
346294465Savosstatic void		urtwn_update_aifs(struct urtwn_softc *, uint8_t);
347290564Savosstatic void		urtwn_set_promisc(struct urtwn_softc *);
348290564Savosstatic void		urtwn_update_promisc(struct ieee80211com *);
349289066Skevlostatic void		urtwn_update_mcast(struct ieee80211com *);
350292167Savosstatic struct ieee80211_node *urtwn_r88e_node_alloc(struct ieee80211vap *,
351292167Savos			    const uint8_t mac[IEEE80211_ADDR_LEN]);
352292167Savosstatic void		urtwn_r88e_newassoc(struct ieee80211_node *, int);
353292167Savosstatic void		urtwn_r88e_node_free(struct ieee80211_node *);
354251538Srpaulostatic void		urtwn_set_chan(struct urtwn_softc *,
355281069Srpaulo		    	    struct ieee80211_channel *,
356251538Srpaulo			    struct ieee80211_channel *);
357251538Srpaulostatic void		urtwn_iq_calib(struct urtwn_softc *);
358251538Srpaulostatic void		urtwn_lc_calib(struct urtwn_softc *);
359294473Savosstatic void		urtwn_temp_calib(struct urtwn_softc *);
360291698Savosstatic int		urtwn_init(struct urtwn_softc *);
361287197Sglebiusstatic void		urtwn_stop(struct urtwn_softc *);
362251538Srpaulostatic void		urtwn_abort_xfers(struct urtwn_softc *);
363251538Srpaulostatic int		urtwn_raw_xmit(struct ieee80211_node *, struct mbuf *,
364251538Srpaulo			    const struct ieee80211_bpf_params *);
365266472Shselaskystatic void		urtwn_ms_delay(struct urtwn_softc *);
366251538Srpaulo
367251538Srpaulo/* Aliases. */
368251538Srpaulo#define	urtwn_bb_write	urtwn_write_4
369251538Srpaulo#define urtwn_bb_read	urtwn_read_4
370251538Srpaulo
371251538Srpaulostatic const struct usb_config urtwn_config[URTWN_N_TRANSFER] = {
372251538Srpaulo	[URTWN_BULK_RX] = {
373251538Srpaulo		.type = UE_BULK,
374251538Srpaulo		.endpoint = UE_ADDR_ANY,
375251538Srpaulo		.direction = UE_DIR_IN,
376251538Srpaulo		.bufsize = URTWN_RXBUFSZ,
377251538Srpaulo		.flags = {
378251538Srpaulo			.pipe_bof = 1,
379251538Srpaulo			.short_xfer_ok = 1
380251538Srpaulo		},
381251538Srpaulo		.callback = urtwn_bulk_rx_callback,
382251538Srpaulo	},
383251538Srpaulo	[URTWN_BULK_TX_BE] = {
384251538Srpaulo		.type = UE_BULK,
385251538Srpaulo		.endpoint = 0x03,
386251538Srpaulo		.direction = UE_DIR_OUT,
387251538Srpaulo		.bufsize = URTWN_TXBUFSZ,
388251538Srpaulo		.flags = {
389251538Srpaulo			.ext_buffer = 1,
390251538Srpaulo			.pipe_bof = 1,
391251538Srpaulo			.force_short_xfer = 1
392251538Srpaulo		},
393251538Srpaulo		.callback = urtwn_bulk_tx_callback,
394251538Srpaulo		.timeout = URTWN_TX_TIMEOUT,	/* ms */
395251538Srpaulo	},
396251538Srpaulo	[URTWN_BULK_TX_BK] = {
397251538Srpaulo		.type = UE_BULK,
398251538Srpaulo		.endpoint = 0x03,
399251538Srpaulo		.direction = UE_DIR_OUT,
400251538Srpaulo		.bufsize = URTWN_TXBUFSZ,
401251538Srpaulo		.flags = {
402251538Srpaulo			.ext_buffer = 1,
403251538Srpaulo			.pipe_bof = 1,
404251538Srpaulo			.force_short_xfer = 1,
405251538Srpaulo		},
406251538Srpaulo		.callback = urtwn_bulk_tx_callback,
407251538Srpaulo		.timeout = URTWN_TX_TIMEOUT,	/* ms */
408251538Srpaulo	},
409251538Srpaulo	[URTWN_BULK_TX_VI] = {
410251538Srpaulo		.type = UE_BULK,
411251538Srpaulo		.endpoint = 0x02,
412251538Srpaulo		.direction = UE_DIR_OUT,
413251538Srpaulo		.bufsize = URTWN_TXBUFSZ,
414251538Srpaulo		.flags = {
415251538Srpaulo			.ext_buffer = 1,
416251538Srpaulo			.pipe_bof = 1,
417251538Srpaulo			.force_short_xfer = 1
418251538Srpaulo		},
419251538Srpaulo		.callback = urtwn_bulk_tx_callback,
420251538Srpaulo		.timeout = URTWN_TX_TIMEOUT,	/* ms */
421251538Srpaulo	},
422251538Srpaulo	[URTWN_BULK_TX_VO] = {
423251538Srpaulo		.type = UE_BULK,
424251538Srpaulo		.endpoint = 0x02,
425251538Srpaulo		.direction = UE_DIR_OUT,
426251538Srpaulo		.bufsize = URTWN_TXBUFSZ,
427251538Srpaulo		.flags = {
428251538Srpaulo			.ext_buffer = 1,
429251538Srpaulo			.pipe_bof = 1,
430251538Srpaulo			.force_short_xfer = 1
431251538Srpaulo		},
432251538Srpaulo		.callback = urtwn_bulk_tx_callback,
433251538Srpaulo		.timeout = URTWN_TX_TIMEOUT,	/* ms */
434251538Srpaulo	},
435251538Srpaulo};
436251538Srpaulo
437292014Savosstatic const struct wme_to_queue {
438292014Savos	uint16_t reg;
439292014Savos	uint8_t qid;
440292014Savos} wme2queue[WME_NUM_AC] = {
441292014Savos	{ R92C_EDCA_BE_PARAM, URTWN_BULK_TX_BE},
442292014Savos	{ R92C_EDCA_BK_PARAM, URTWN_BULK_TX_BK},
443292014Savos	{ R92C_EDCA_VI_PARAM, URTWN_BULK_TX_VI},
444292014Savos	{ R92C_EDCA_VO_PARAM, URTWN_BULK_TX_VO}
445292014Savos};
446292014Savos
447251538Srpaulostatic int
448251538Srpaulourtwn_match(device_t self)
449251538Srpaulo{
450251538Srpaulo	struct usb_attach_arg *uaa = device_get_ivars(self);
451251538Srpaulo
452251538Srpaulo	if (uaa->usb_mode != USB_MODE_HOST)
453251538Srpaulo		return (ENXIO);
454251538Srpaulo	if (uaa->info.bConfigIndex != URTWN_CONFIG_INDEX)
455251538Srpaulo		return (ENXIO);
456251538Srpaulo	if (uaa->info.bIfaceIndex != URTWN_IFACE_INDEX)
457251538Srpaulo		return (ENXIO);
458251538Srpaulo
459251538Srpaulo	return (usbd_lookup_id_by_uaa(urtwn_devs, sizeof(urtwn_devs), uaa));
460251538Srpaulo}
461251538Srpaulo
462251538Srpaulostatic int
463251538Srpaulourtwn_attach(device_t self)
464251538Srpaulo{
465251538Srpaulo	struct usb_attach_arg *uaa = device_get_ivars(self);
466251538Srpaulo	struct urtwn_softc *sc = device_get_softc(self);
467287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
468293339Savos	uint8_t bands[howmany(IEEE80211_MODE_MAX, 8)];
469251538Srpaulo	int error;
470251538Srpaulo
471251538Srpaulo	device_set_usb_desc(self);
472251538Srpaulo	sc->sc_udev = uaa->device;
473251538Srpaulo	sc->sc_dev = self;
474264912Skevlo	if (USB_GET_DRIVER_INFO(uaa) == URTWN_RTL8188E)
475264912Skevlo		sc->chip |= URTWN_CHIP_88E;
476251538Srpaulo
477294471Savos#ifdef USB_DEBUG
478294471Savos	int debug;
479294471Savos	if (resource_int_value(device_get_name(sc->sc_dev),
480294471Savos	    device_get_unit(sc->sc_dev), "debug", &debug) == 0)
481294471Savos		sc->sc_debug = debug;
482294471Savos#endif
483294471Savos
484251538Srpaulo	mtx_init(&sc->sc_mtx, device_get_nameunit(self),
485251538Srpaulo	    MTX_NETWORK_LOCK, MTX_DEF);
486292174Savos	URTWN_CMDQ_LOCK_INIT(sc);
487292167Savos	URTWN_NT_LOCK_INIT(sc);
488294473Savos	callout_init(&sc->sc_calib_to, 0);
489251538Srpaulo	callout_init(&sc->sc_watchdog_ch, 0);
490287197Sglebius	mbufq_init(&sc->sc_snd, ifqmaxlen);
491251538Srpaulo
492291902Skevlo	sc->sc_iface_index = URTWN_IFACE_INDEX;
493291902Skevlo	error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index,
494291902Skevlo	    sc->sc_xfer, urtwn_config, URTWN_N_TRANSFER, sc, &sc->sc_mtx);
495251538Srpaulo	if (error) {
496251538Srpaulo		device_printf(self, "could not allocate USB transfers, "
497251538Srpaulo		    "err=%s\n", usbd_errstr(error));
498251538Srpaulo		goto detach;
499251538Srpaulo	}
500251538Srpaulo
501251538Srpaulo	URTWN_LOCK(sc);
502251538Srpaulo
503251538Srpaulo	error = urtwn_read_chipid(sc);
504251538Srpaulo	if (error) {
505251538Srpaulo		device_printf(sc->sc_dev, "unsupported test chip\n");
506251538Srpaulo		URTWN_UNLOCK(sc);
507251538Srpaulo		goto detach;
508251538Srpaulo	}
509251538Srpaulo
510251538Srpaulo	/* Determine number of Tx/Rx chains. */
511251538Srpaulo	if (sc->chip & URTWN_CHIP_92C) {
512251538Srpaulo		sc->ntxchains = (sc->chip & URTWN_CHIP_92C_1T2R) ? 1 : 2;
513251538Srpaulo		sc->nrxchains = 2;
514251538Srpaulo	} else {
515251538Srpaulo		sc->ntxchains = 1;
516251538Srpaulo		sc->nrxchains = 1;
517251538Srpaulo	}
518251538Srpaulo
519264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
520291264Savos		error = urtwn_r88e_read_rom(sc);
521264912Skevlo	else
522291264Savos		error = urtwn_read_rom(sc);
523291264Savos	if (error != 0) {
524291264Savos		device_printf(sc->sc_dev, "%s: cannot read rom, error %d\n",
525291264Savos		    __func__, error);
526291264Savos		URTWN_UNLOCK(sc);
527291264Savos		goto detach;
528291264Savos	}
529264912Skevlo
530251538Srpaulo	device_printf(sc->sc_dev, "MAC/BB RTL%s, RF 6052 %dT%dR\n",
531251538Srpaulo	    (sc->chip & URTWN_CHIP_92C) ? "8192CU" :
532264912Skevlo	    (sc->chip & URTWN_CHIP_88E) ? "8188EU" :
533251538Srpaulo	    (sc->board_type == R92C_BOARD_TYPE_HIGHPA) ? "8188RU" :
534251538Srpaulo	    (sc->board_type == R92C_BOARD_TYPE_MINICARD) ? "8188CE-VAU" :
535251538Srpaulo	    "8188CUS", sc->ntxchains, sc->nrxchains);
536251538Srpaulo
537251538Srpaulo	URTWN_UNLOCK(sc);
538251538Srpaulo
539283537Sglebius	ic->ic_softc = sc;
540283527Sglebius	ic->ic_name = device_get_nameunit(self);
541251538Srpaulo	ic->ic_phytype = IEEE80211_T_OFDM;	/* not only, but not used */
542251538Srpaulo	ic->ic_opmode = IEEE80211_M_STA;	/* default to BSS mode */
543251538Srpaulo
544251538Srpaulo	/* set device capabilities */
545251538Srpaulo	ic->ic_caps =
546251538Srpaulo		  IEEE80211_C_STA		/* station mode */
547251538Srpaulo		| IEEE80211_C_MONITOR		/* monitor mode */
548290651Savos		| IEEE80211_C_IBSS		/* adhoc mode */
549290631Savos		| IEEE80211_C_HOSTAP		/* hostap mode */
550251538Srpaulo		| IEEE80211_C_SHPREAMBLE	/* short preamble supported */
551251538Srpaulo		| IEEE80211_C_SHSLOT		/* short slot time supported */
552251538Srpaulo		| IEEE80211_C_BGSCAN		/* capable of bg scanning */
553251538Srpaulo		| IEEE80211_C_WPA		/* 802.11i */
554292014Savos		| IEEE80211_C_WME		/* 802.11e */
555251538Srpaulo		;
556251538Srpaulo
557292175Savos	ic->ic_cryptocaps =
558292175Savos	    IEEE80211_CRYPTO_WEP |
559292175Savos	    IEEE80211_CRYPTO_TKIP |
560292175Savos	    IEEE80211_CRYPTO_AES_CCM;
561292175Savos
562293339Savos	memset(bands, 0, sizeof(bands));
563293339Savos	setbit(bands, IEEE80211_MODE_11B);
564293339Savos	setbit(bands, IEEE80211_MODE_11G);
565293339Savos	ieee80211_init_channels(ic, NULL, bands);
566251538Srpaulo
567287197Sglebius	ieee80211_ifattach(ic);
568251538Srpaulo	ic->ic_raw_xmit = urtwn_raw_xmit;
569251538Srpaulo	ic->ic_scan_start = urtwn_scan_start;
570251538Srpaulo	ic->ic_scan_end = urtwn_scan_end;
571251538Srpaulo	ic->ic_set_channel = urtwn_set_channel;
572287197Sglebius	ic->ic_transmit = urtwn_transmit;
573287197Sglebius	ic->ic_parent = urtwn_parent;
574251538Srpaulo	ic->ic_vap_create = urtwn_vap_create;
575251538Srpaulo	ic->ic_vap_delete = urtwn_vap_delete;
576292014Savos	ic->ic_wme.wme_update = urtwn_wme_update;
577294465Savos	ic->ic_updateslot = urtwn_update_slot;
578290564Savos	ic->ic_update_promisc = urtwn_update_promisc;
579251538Srpaulo	ic->ic_update_mcast = urtwn_update_mcast;
580292167Savos	if (sc->chip & URTWN_CHIP_88E) {
581292167Savos		ic->ic_node_alloc = urtwn_r88e_node_alloc;
582292167Savos		ic->ic_newassoc = urtwn_r88e_newassoc;
583292167Savos		sc->sc_node_free = ic->ic_node_free;
584292167Savos		ic->ic_node_free = urtwn_r88e_node_free;
585292167Savos	}
586251538Srpaulo
587281069Srpaulo	ieee80211_radiotap_attach(ic, &sc->sc_txtap.wt_ihdr,
588251538Srpaulo	    sizeof(sc->sc_txtap), URTWN_TX_RADIOTAP_PRESENT,
589251538Srpaulo	    &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
590251538Srpaulo	    URTWN_RX_RADIOTAP_PRESENT);
591251538Srpaulo
592292174Savos	TASK_INIT(&sc->cmdq_task, 0, urtwn_cmdq_cb, sc);
593292174Savos
594294471Savos	urtwn_sysctlattach(sc);
595294471Savos
596251538Srpaulo	if (bootverbose)
597251538Srpaulo		ieee80211_announce(ic);
598251538Srpaulo
599251538Srpaulo	return (0);
600251538Srpaulo
601251538Srpaulodetach:
602251538Srpaulo	urtwn_detach(self);
603251538Srpaulo	return (ENXIO);			/* failure */
604251538Srpaulo}
605251538Srpaulo
606294471Savosstatic void
607294471Savosurtwn_sysctlattach(struct urtwn_softc *sc)
608294471Savos{
609294471Savos#ifdef USB_DEBUG
610294471Savos	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
611294471Savos	struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
612294471Savos
613294471Savos	SYSCTL_ADD_U32(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
614294471Savos	    "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug,
615294471Savos	    "control debugging printfs");
616294471Savos#endif
617294471Savos}
618294471Savos
619251538Srpaulostatic int
620251538Srpaulourtwn_detach(device_t self)
621251538Srpaulo{
622251538Srpaulo	struct urtwn_softc *sc = device_get_softc(self);
623287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
624263153Skevlo	unsigned int x;
625281069Srpaulo
626263153Skevlo	/* Prevent further ioctls. */
627263153Skevlo	URTWN_LOCK(sc);
628263153Skevlo	sc->sc_flags |= URTWN_DETACHED;
629263153Skevlo	URTWN_UNLOCK(sc);
630251538Srpaulo
631291698Savos	urtwn_stop(sc);
632291698Savos
633251538Srpaulo	callout_drain(&sc->sc_watchdog_ch);
634294473Savos	callout_drain(&sc->sc_calib_to);
635251538Srpaulo
636288353Sadrian	/* stop all USB transfers */
637288353Sadrian	usbd_transfer_unsetup(sc->sc_xfer, URTWN_N_TRANSFER);
638288353Sadrian
639263153Skevlo	/* Prevent further allocations from RX/TX data lists. */
640263153Skevlo	URTWN_LOCK(sc);
641263153Skevlo	STAILQ_INIT(&sc->sc_tx_active);
642263153Skevlo	STAILQ_INIT(&sc->sc_tx_inactive);
643263153Skevlo	STAILQ_INIT(&sc->sc_tx_pending);
644263153Skevlo
645263153Skevlo	STAILQ_INIT(&sc->sc_rx_active);
646263153Skevlo	STAILQ_INIT(&sc->sc_rx_inactive);
647263153Skevlo	URTWN_UNLOCK(sc);
648263153Skevlo
649263153Skevlo	/* drain USB transfers */
650263153Skevlo	for (x = 0; x != URTWN_N_TRANSFER; x++)
651263153Skevlo		usbd_transfer_drain(sc->sc_xfer[x]);
652263153Skevlo
653263153Skevlo	/* Free data buffers. */
654263153Skevlo	URTWN_LOCK(sc);
655263153Skevlo	urtwn_free_tx_list(sc);
656263153Skevlo	urtwn_free_rx_list(sc);
657263153Skevlo	URTWN_UNLOCK(sc);
658263153Skevlo
659292174Savos	if (ic->ic_softc == sc) {
660292174Savos		ieee80211_draintask(ic, &sc->cmdq_task);
661292174Savos		ieee80211_ifdetach(ic);
662292174Savos	}
663292174Savos
664292167Savos	URTWN_NT_LOCK_DESTROY(sc);
665292174Savos	URTWN_CMDQ_LOCK_DESTROY(sc);
666251538Srpaulo	mtx_destroy(&sc->sc_mtx);
667251538Srpaulo
668251538Srpaulo	return (0);
669251538Srpaulo}
670251538Srpaulo
671251538Srpaulostatic void
672289066Skevlourtwn_drain_mbufq(struct urtwn_softc *sc)
673251538Srpaulo{
674289066Skevlo	struct mbuf *m;
675289066Skevlo	struct ieee80211_node *ni;
676289066Skevlo	URTWN_ASSERT_LOCKED(sc);
677289066Skevlo	while ((m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
678289066Skevlo		ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
679289066Skevlo		m->m_pkthdr.rcvif = NULL;
680289066Skevlo		ieee80211_free_node(ni);
681289066Skevlo		m_freem(m);
682251538Srpaulo	}
683251538Srpaulo}
684251538Srpaulo
685251538Srpaulostatic usb_error_t
686251538Srpaulourtwn_do_request(struct urtwn_softc *sc, struct usb_device_request *req,
687251538Srpaulo    void *data)
688251538Srpaulo{
689251538Srpaulo	usb_error_t err;
690251538Srpaulo	int ntries = 10;
691251538Srpaulo
692251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
693251538Srpaulo
694251538Srpaulo	while (ntries--) {
695251538Srpaulo		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
696251538Srpaulo		    req, data, 0, NULL, 250 /* ms */);
697251538Srpaulo		if (err == 0)
698251538Srpaulo			break;
699251538Srpaulo
700294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_USB,
701294471Savos		    "%s: control request failed, %s (retries left: %d)\n",
702294471Savos		    __func__, usbd_errstr(err), ntries);
703251538Srpaulo		usb_pause_mtx(&sc->sc_mtx, hz / 100);
704251538Srpaulo	}
705251538Srpaulo	return (err);
706251538Srpaulo}
707251538Srpaulo
708251538Srpaulostatic struct ieee80211vap *
709251538Srpaulourtwn_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
710251538Srpaulo    enum ieee80211_opmode opmode, int flags,
711251538Srpaulo    const uint8_t bssid[IEEE80211_ADDR_LEN],
712251538Srpaulo    const uint8_t mac[IEEE80211_ADDR_LEN])
713251538Srpaulo{
714290631Savos	struct urtwn_softc *sc = ic->ic_softc;
715251538Srpaulo	struct urtwn_vap *uvp;
716251538Srpaulo	struct ieee80211vap *vap;
717251538Srpaulo
718251538Srpaulo	if (!TAILQ_EMPTY(&ic->ic_vaps))		/* only one at a time */
719251538Srpaulo		return (NULL);
720251538Srpaulo
721287197Sglebius	uvp = malloc(sizeof(struct urtwn_vap), M_80211_VAP, M_WAITOK | M_ZERO);
722251538Srpaulo	vap = &uvp->vap;
723251538Srpaulo	/* enable s/w bmiss handling for sta mode */
724251538Srpaulo
725281069Srpaulo	if (ieee80211_vap_setup(ic, vap, name, unit, opmode,
726287197Sglebius	    flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) {
727257743Shselasky		/* out of memory */
728257743Shselasky		free(uvp, M_80211_VAP);
729257743Shselasky		return (NULL);
730257743Shselasky	}
731257743Shselasky
732290651Savos	if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_IBSS)
733290631Savos		urtwn_init_beacon(sc, uvp);
734290631Savos
735251538Srpaulo	/* override state transition machine */
736251538Srpaulo	uvp->newstate = vap->iv_newstate;
737251538Srpaulo	vap->iv_newstate = urtwn_newstate;
738290631Savos	vap->iv_update_beacon = urtwn_update_beacon;
739292175Savos	vap->iv_key_alloc = urtwn_key_alloc;
740292175Savos	vap->iv_key_set = urtwn_key_set;
741292175Savos	vap->iv_key_delete = urtwn_key_delete;
742290651Savos	if (opmode == IEEE80211_M_IBSS) {
743290651Savos		uvp->recv_mgmt = vap->iv_recv_mgmt;
744290651Savos		vap->iv_recv_mgmt = urtwn_ibss_recv_mgmt;
745290651Savos		TASK_INIT(&uvp->tsf_task_adhoc, 0, urtwn_tsf_task_adhoc, vap);
746290651Savos	}
747251538Srpaulo
748292167Savos	if (URTWN_CHIP_HAS_RATECTL(sc))
749292167Savos		ieee80211_ratectl_init(vap);
750251538Srpaulo	/* complete setup */
751251538Srpaulo	ieee80211_vap_attach(vap, ieee80211_media_change,
752287197Sglebius	    ieee80211_media_status, mac);
753251538Srpaulo	ic->ic_opmode = opmode;
754251538Srpaulo	return (vap);
755251538Srpaulo}
756251538Srpaulo
757251538Srpaulostatic void
758251538Srpaulourtwn_vap_delete(struct ieee80211vap *vap)
759251538Srpaulo{
760290651Savos	struct ieee80211com *ic = vap->iv_ic;
761292167Savos	struct urtwn_softc *sc = ic->ic_softc;
762251538Srpaulo	struct urtwn_vap *uvp = URTWN_VAP(vap);
763251538Srpaulo
764290651Savos	if (uvp->bcn_mbuf != NULL)
765290651Savos		m_freem(uvp->bcn_mbuf);
766290651Savos	if (vap->iv_opmode == IEEE80211_M_IBSS)
767290651Savos		ieee80211_draintask(ic, &uvp->tsf_task_adhoc);
768292167Savos	if (URTWN_CHIP_HAS_RATECTL(sc))
769292167Savos		ieee80211_ratectl_deinit(vap);
770251538Srpaulo	ieee80211_vap_detach(vap);
771251538Srpaulo	free(uvp, M_80211_VAP);
772251538Srpaulo}
773251538Srpaulo
774251538Srpaulostatic struct mbuf *
775292207Savosurtwn_rx_copy_to_mbuf(struct urtwn_softc *sc, struct r92c_rx_stat *stat,
776292207Savos    int totlen)
777251538Srpaulo{
778287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
779251538Srpaulo	struct mbuf *m;
780292207Savos	uint32_t rxdw0;
781292207Savos	int pktlen;
782251538Srpaulo
783251538Srpaulo	/*
784251538Srpaulo	 * don't pass packets to the ieee80211 framework if the driver isn't
785251538Srpaulo	 * RUNNING.
786251538Srpaulo	 */
787287197Sglebius	if (!(sc->sc_flags & URTWN_RUNNING))
788251538Srpaulo		return (NULL);
789251538Srpaulo
790251538Srpaulo	rxdw0 = le32toh(stat->rxdw0);
791251538Srpaulo	if (rxdw0 & (R92C_RXDW0_CRCERR | R92C_RXDW0_ICVERR)) {
792251538Srpaulo		/*
793251538Srpaulo		 * This should not happen since we setup our Rx filter
794251538Srpaulo		 * to not receive these frames.
795251538Srpaulo		 */
796294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_RECV,
797294471Savos		    "%s: RX flags error (%s)\n", __func__,
798292207Savos		    rxdw0 & R92C_RXDW0_CRCERR ? "CRC" : "ICV");
799292207Savos		goto fail;
800251538Srpaulo	}
801292207Savos
802292207Savos	pktlen = MS(rxdw0, R92C_RXDW0_PKTLEN);
803292207Savos	if (pktlen < sizeof(struct ieee80211_frame_ack)) {
804294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_RECV,
805294471Savos		    "%s: frame is too short: %d\n", __func__, pktlen);
806292207Savos		goto fail;
807271303Skevlo	}
808251538Srpaulo
809292207Savos	if (__predict_false(totlen > MCLBYTES)) {
810292207Savos		/* convert to m_getjcl if this happens */
811292207Savos		device_printf(sc->sc_dev, "%s: frame too long: %d (%d)\n",
812292207Savos		    __func__, pktlen, totlen);
813292207Savos		goto fail;
814251538Srpaulo	}
815251538Srpaulo
816260463Skevlo	m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
817292207Savos	if (__predict_false(m == NULL)) {
818292207Savos		device_printf(sc->sc_dev, "%s: could not allocate RX mbuf\n",
819292207Savos		    __func__);
820292207Savos		goto fail;
821251538Srpaulo	}
822251538Srpaulo
823251538Srpaulo	/* Finalize mbuf. */
824292207Savos	memcpy(mtod(m, uint8_t *), (uint8_t *)stat, totlen);
825292207Savos	m->m_pkthdr.len = m->m_len = totlen;
826292207Savos
827251538Srpaulo	return (m);
828292207Savosfail:
829292207Savos	counter_u64_add(ic->ic_ierrors, 1);
830292207Savos	return (NULL);
831251538Srpaulo}
832251538Srpaulo
833251538Srpaulostatic struct mbuf *
834292207Savosurtwn_report_intr(struct usb_xfer *xfer, struct urtwn_data *data)
835251538Srpaulo{
836251538Srpaulo	struct urtwn_softc *sc = data->sc;
837287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
838251538Srpaulo	struct r92c_rx_stat *stat;
839251538Srpaulo	uint8_t *buf;
840292167Savos	int len;
841251538Srpaulo
842251538Srpaulo	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
843251538Srpaulo
844251538Srpaulo	if (len < sizeof(*stat)) {
845287197Sglebius		counter_u64_add(ic->ic_ierrors, 1);
846251538Srpaulo		return (NULL);
847251538Srpaulo	}
848251538Srpaulo
849251538Srpaulo	buf = data->buf;
850292167Savos	stat = (struct r92c_rx_stat *)buf;
851292167Savos
852292167Savos	if (sc->chip & URTWN_CHIP_88E) {
853292167Savos		int report_sel = MS(le32toh(stat->rxdw3), R88E_RXDW3_RPT);
854292167Savos
855292167Savos		switch (report_sel) {
856292167Savos		case R88E_RXDW3_RPT_RX:
857292207Savos			return (urtwn_rxeof(sc, buf, len));
858292167Savos		case R88E_RXDW3_RPT_TX1:
859292167Savos			urtwn_r88e_ratectl_tx_complete(sc, &stat[1]);
860292167Savos			break;
861292167Savos		default:
862294471Savos			URTWN_DPRINTF(sc, URTWN_DEBUG_INTR,
863294471Savos			    "%s: case %d was not handled\n", __func__,
864294471Savos			    report_sel);
865292167Savos			break;
866292167Savos		}
867292167Savos	} else
868292207Savos		return (urtwn_rxeof(sc, buf, len));
869292167Savos
870292167Savos	return (NULL);
871292167Savos}
872292167Savos
873292167Savosstatic struct mbuf *
874292207Savosurtwn_rxeof(struct urtwn_softc *sc, uint8_t *buf, int len)
875292167Savos{
876292167Savos	struct r92c_rx_stat *stat;
877292167Savos	struct mbuf *m, *m0 = NULL, *prevm = NULL;
878292167Savos	uint32_t rxdw0;
879292167Savos	int totlen, pktlen, infosz, npkts;
880292167Savos
881251538Srpaulo	/* Get the number of encapsulated frames. */
882251538Srpaulo	stat = (struct r92c_rx_stat *)buf;
883251538Srpaulo	npkts = MS(le32toh(stat->rxdw2), R92C_RXDW2_PKTCNT);
884294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_RECV,
885294471Savos	    "%s: Rx %d frames in one chunk\n", __func__, npkts);
886251538Srpaulo
887251538Srpaulo	/* Process all of them. */
888251538Srpaulo	while (npkts-- > 0) {
889251538Srpaulo		if (len < sizeof(*stat))
890251538Srpaulo			break;
891251538Srpaulo		stat = (struct r92c_rx_stat *)buf;
892251538Srpaulo		rxdw0 = le32toh(stat->rxdw0);
893251538Srpaulo
894251538Srpaulo		pktlen = MS(rxdw0, R92C_RXDW0_PKTLEN);
895251538Srpaulo		if (pktlen == 0)
896251538Srpaulo			break;
897251538Srpaulo
898251538Srpaulo		infosz = MS(rxdw0, R92C_RXDW0_INFOSZ) * 8;
899251538Srpaulo
900251538Srpaulo		/* Make sure everything fits in xfer. */
901251538Srpaulo		totlen = sizeof(*stat) + infosz + pktlen;
902251538Srpaulo		if (totlen > len)
903251538Srpaulo			break;
904251538Srpaulo
905292207Savos		m = urtwn_rx_copy_to_mbuf(sc, stat, totlen);
906251538Srpaulo		if (m0 == NULL)
907251538Srpaulo			m0 = m;
908251538Srpaulo		if (prevm == NULL)
909251538Srpaulo			prevm = m;
910251538Srpaulo		else {
911251538Srpaulo			prevm->m_next = m;
912251538Srpaulo			prevm = m;
913251538Srpaulo		}
914251538Srpaulo
915251538Srpaulo		/* Next chunk is 128-byte aligned. */
916251538Srpaulo		totlen = (totlen + 127) & ~127;
917251538Srpaulo		buf += totlen;
918251538Srpaulo		len -= totlen;
919251538Srpaulo	}
920251538Srpaulo
921251538Srpaulo	return (m0);
922251538Srpaulo}
923251538Srpaulo
924251538Srpaulostatic void
925292167Savosurtwn_r88e_ratectl_tx_complete(struct urtwn_softc *sc, void *arg)
926292167Savos{
927292167Savos	struct r88e_tx_rpt_ccx *rpt = arg;
928292167Savos	struct ieee80211vap *vap;
929292167Savos	struct ieee80211_node *ni;
930292167Savos	uint8_t macid;
931292167Savos	int ntries;
932292167Savos
933292167Savos	macid = MS(rpt->rptb1, R88E_RPTB1_MACID);
934292167Savos	ntries = MS(rpt->rptb2, R88E_RPTB2_RETRY_CNT);
935292167Savos
936292167Savos	URTWN_NT_LOCK(sc);
937292167Savos	ni = sc->node_list[macid];
938292167Savos	if (ni != NULL) {
939292167Savos		vap = ni->ni_vap;
940294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_INTR, "%s: frame for macid %d was"
941294471Savos		    "%s sent (%d retries)\n", __func__, macid,
942294471Savos		    (rpt->rptb1 & R88E_RPTB1_PKT_OK) ? "" : " not",
943294471Savos		    ntries);
944292167Savos
945292167Savos		if (rpt->rptb1 & R88E_RPTB1_PKT_OK) {
946292167Savos			ieee80211_ratectl_tx_complete(vap, ni,
947292167Savos			    IEEE80211_RATECTL_TX_SUCCESS, &ntries, NULL);
948292167Savos		} else {
949292167Savos			ieee80211_ratectl_tx_complete(vap, ni,
950292167Savos			    IEEE80211_RATECTL_TX_FAILURE, &ntries, NULL);
951292167Savos		}
952294471Savos	} else {
953294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_INTR, "%s: macid %d, ni is NULL\n",
954294471Savos		    __func__, macid);
955294471Savos	}
956292167Savos	URTWN_NT_UNLOCK(sc);
957292167Savos}
958292167Savos
959292207Savosstatic struct ieee80211_node *
960292207Savosurtwn_rx_frame(struct urtwn_softc *sc, struct mbuf *m, int8_t *rssi_p)
961292207Savos{
962292207Savos	struct ieee80211com *ic = &sc->sc_ic;
963292207Savos	struct ieee80211_frame_min *wh;
964292207Savos	struct r92c_rx_stat *stat;
965292207Savos	uint32_t rxdw0, rxdw3;
966292207Savos	uint8_t rate, cipher;
967292207Savos	int8_t rssi = URTWN_NOISE_FLOOR + 1;
968292207Savos	int infosz;
969292207Savos
970292207Savos	stat = mtod(m, struct r92c_rx_stat *);
971292207Savos	rxdw0 = le32toh(stat->rxdw0);
972292207Savos	rxdw3 = le32toh(stat->rxdw3);
973292207Savos
974292207Savos	rate = MS(rxdw3, R92C_RXDW3_RATE);
975292207Savos	cipher = MS(rxdw0, R92C_RXDW0_CIPHER);
976292207Savos	infosz = MS(rxdw0, R92C_RXDW0_INFOSZ) * 8;
977292207Savos
978292207Savos	/* Get RSSI from PHY status descriptor if present. */
979292207Savos	if (infosz != 0 && (rxdw0 & R92C_RXDW0_PHYST)) {
980292207Savos		if (sc->chip & URTWN_CHIP_88E)
981292207Savos			rssi = urtwn_r88e_get_rssi(sc, rate, &stat[1]);
982292207Savos		else
983292207Savos			rssi = urtwn_get_rssi(sc, rate, &stat[1]);
984292207Savos		/* Update our average RSSI. */
985292207Savos		urtwn_update_avgrssi(sc, rate, rssi);
986292207Savos	}
987292207Savos
988292207Savos	if (ieee80211_radiotap_active(ic)) {
989292207Savos		struct urtwn_rx_radiotap_header *tap = &sc->sc_rxtap;
990292207Savos
991292207Savos		tap->wr_flags = 0;
992292207Savos
993292207Savos		urtwn_get_tsf(sc, &tap->wr_tsft);
994292207Savos		if (__predict_false(le32toh((uint32_t)tap->wr_tsft) <
995292207Savos				    le32toh(stat->rxdw5))) {
996292207Savos			tap->wr_tsft = le32toh(tap->wr_tsft  >> 32) - 1;
997292207Savos			tap->wr_tsft = (uint64_t)htole32(tap->wr_tsft) << 32;
998292207Savos		} else
999292207Savos			tap->wr_tsft &= 0xffffffff00000000;
1000292207Savos		tap->wr_tsft += stat->rxdw5;
1001292207Savos
1002292207Savos		/* Map HW rate index to 802.11 rate. */
1003292207Savos		if (!(rxdw3 & R92C_RXDW3_HT)) {
1004292207Savos			tap->wr_rate = ridx2rate[rate];
1005292207Savos		} else if (rate >= 12) {	/* MCS0~15. */
1006292207Savos			/* Bit 7 set means HT MCS instead of rate. */
1007292207Savos			tap->wr_rate = 0x80 | (rate - 12);
1008292207Savos		}
1009292207Savos		tap->wr_dbm_antsignal = rssi;
1010292207Savos		tap->wr_dbm_antnoise = URTWN_NOISE_FLOOR;
1011292207Savos	}
1012292207Savos
1013292207Savos	*rssi_p = rssi;
1014292207Savos
1015292207Savos	/* Drop descriptor. */
1016292207Savos	m_adj(m, sizeof(*stat) + infosz);
1017292207Savos	wh = mtod(m, struct ieee80211_frame_min *);
1018292207Savos
1019292207Savos	if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) &&
1020292207Savos	    cipher != R92C_CAM_ALGO_NONE) {
1021292207Savos		m->m_flags |= M_WEP;
1022292207Savos	}
1023292207Savos
1024292207Savos	if (m->m_len >= sizeof(*wh))
1025292207Savos		return (ieee80211_find_rxnode(ic, wh));
1026292207Savos
1027292207Savos	return (NULL);
1028292207Savos}
1029292207Savos
1030292167Savosstatic void
1031251538Srpaulourtwn_bulk_rx_callback(struct usb_xfer *xfer, usb_error_t error)
1032251538Srpaulo{
1033251538Srpaulo	struct urtwn_softc *sc = usbd_xfer_softc(xfer);
1034287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
1035251538Srpaulo	struct ieee80211_node *ni;
1036251538Srpaulo	struct mbuf *m = NULL, *next;
1037251538Srpaulo	struct urtwn_data *data;
1038292207Savos	int8_t nf, rssi;
1039251538Srpaulo
1040251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
1041251538Srpaulo
1042251538Srpaulo	switch (USB_GET_STATE(xfer)) {
1043251538Srpaulo	case USB_ST_TRANSFERRED:
1044251538Srpaulo		data = STAILQ_FIRST(&sc->sc_rx_active);
1045251538Srpaulo		if (data == NULL)
1046251538Srpaulo			goto tr_setup;
1047251538Srpaulo		STAILQ_REMOVE_HEAD(&sc->sc_rx_active, next);
1048292207Savos		m = urtwn_report_intr(xfer, data);
1049251538Srpaulo		STAILQ_INSERT_TAIL(&sc->sc_rx_inactive, data, next);
1050251538Srpaulo		/* FALLTHROUGH */
1051251538Srpaulo	case USB_ST_SETUP:
1052251538Srpaulotr_setup:
1053251538Srpaulo		data = STAILQ_FIRST(&sc->sc_rx_inactive);
1054251538Srpaulo		if (data == NULL) {
1055251538Srpaulo			KASSERT(m == NULL, ("mbuf isn't NULL"));
1056251538Srpaulo			return;
1057251538Srpaulo		}
1058251538Srpaulo		STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next);
1059251538Srpaulo		STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next);
1060251538Srpaulo		usbd_xfer_set_frame_data(xfer, 0, data->buf,
1061251538Srpaulo		    usbd_xfer_max_len(xfer));
1062251538Srpaulo		usbd_transfer_submit(xfer);
1063251538Srpaulo
1064251538Srpaulo		/*
1065251538Srpaulo		 * To avoid LOR we should unlock our private mutex here to call
1066251538Srpaulo		 * ieee80211_input() because here is at the end of a USB
1067251538Srpaulo		 * callback and safe to unlock.
1068251538Srpaulo		 */
1069251538Srpaulo		while (m != NULL) {
1070251538Srpaulo			next = m->m_next;
1071251538Srpaulo			m->m_next = NULL;
1072292207Savos
1073292207Savos			ni = urtwn_rx_frame(sc, m, &rssi);
1074292207Savos			URTWN_UNLOCK(sc);
1075292207Savos
1076251538Srpaulo			nf = URTWN_NOISE_FLOOR;
1077251538Srpaulo			if (ni != NULL) {
1078289799Savos				(void)ieee80211_input(ni, m, rssi - nf, nf);
1079251538Srpaulo				ieee80211_free_node(ni);
1080289799Savos			} else {
1081289799Savos				(void)ieee80211_input_all(ic, m, rssi - nf,
1082289799Savos				    nf);
1083289799Savos			}
1084292207Savos
1085292207Savos			URTWN_LOCK(sc);
1086251538Srpaulo			m = next;
1087251538Srpaulo		}
1088251538Srpaulo		break;
1089251538Srpaulo	default:
1090251538Srpaulo		/* needs it to the inactive queue due to a error. */
1091251538Srpaulo		data = STAILQ_FIRST(&sc->sc_rx_active);
1092251538Srpaulo		if (data != NULL) {
1093251538Srpaulo			STAILQ_REMOVE_HEAD(&sc->sc_rx_active, next);
1094251538Srpaulo			STAILQ_INSERT_TAIL(&sc->sc_rx_inactive, data, next);
1095251538Srpaulo		}
1096251538Srpaulo		if (error != USB_ERR_CANCELLED) {
1097251538Srpaulo			usbd_xfer_set_stall(xfer);
1098287197Sglebius			counter_u64_add(ic->ic_ierrors, 1);
1099251538Srpaulo			goto tr_setup;
1100251538Srpaulo		}
1101251538Srpaulo		break;
1102251538Srpaulo	}
1103251538Srpaulo}
1104251538Srpaulo
1105251538Srpaulostatic void
1106289891Savosurtwn_txeof(struct urtwn_softc *sc, struct urtwn_data *data, int status)
1107251538Srpaulo{
1108251538Srpaulo
1109251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
1110289891Savos
1111290631Savos	if (data->ni != NULL)	/* not a beacon frame */
1112290631Savos		ieee80211_tx_complete(data->ni, data->m, status);
1113289891Savos
1114287197Sglebius	data->ni = NULL;
1115287197Sglebius	data->m = NULL;
1116289891Savos
1117251538Srpaulo	sc->sc_txtimer = 0;
1118289891Savos
1119289891Savos	STAILQ_INSERT_TAIL(&sc->sc_tx_inactive, data, next);
1120251538Srpaulo}
1121251538Srpaulo
1122289066Skevlostatic int
1123289066Skevlourtwn_alloc_list(struct urtwn_softc *sc, struct urtwn_data data[],
1124289066Skevlo    int ndata, int maxsz)
1125289066Skevlo{
1126289066Skevlo	int i, error;
1127289066Skevlo
1128289066Skevlo	for (i = 0; i < ndata; i++) {
1129289066Skevlo		struct urtwn_data *dp = &data[i];
1130289066Skevlo		dp->sc = sc;
1131289066Skevlo		dp->m = NULL;
1132289066Skevlo		dp->buf = malloc(maxsz, M_USBDEV, M_NOWAIT);
1133289066Skevlo		if (dp->buf == NULL) {
1134289066Skevlo			device_printf(sc->sc_dev,
1135289066Skevlo			    "could not allocate buffer\n");
1136289066Skevlo			error = ENOMEM;
1137289066Skevlo			goto fail;
1138289066Skevlo		}
1139289066Skevlo		dp->ni = NULL;
1140289066Skevlo	}
1141289066Skevlo
1142289066Skevlo	return (0);
1143289066Skevlofail:
1144289066Skevlo	urtwn_free_list(sc, data, ndata);
1145289066Skevlo	return (error);
1146289066Skevlo}
1147289066Skevlo
1148289066Skevlostatic int
1149289066Skevlourtwn_alloc_rx_list(struct urtwn_softc *sc)
1150289066Skevlo{
1151289066Skevlo        int error, i;
1152289066Skevlo
1153289066Skevlo	error = urtwn_alloc_list(sc, sc->sc_rx, URTWN_RX_LIST_COUNT,
1154289066Skevlo	    URTWN_RXBUFSZ);
1155289066Skevlo	if (error != 0)
1156289066Skevlo		return (error);
1157289066Skevlo
1158289066Skevlo	STAILQ_INIT(&sc->sc_rx_active);
1159289066Skevlo	STAILQ_INIT(&sc->sc_rx_inactive);
1160289066Skevlo
1161289066Skevlo	for (i = 0; i < URTWN_RX_LIST_COUNT; i++)
1162289066Skevlo		STAILQ_INSERT_HEAD(&sc->sc_rx_inactive, &sc->sc_rx[i], next);
1163289066Skevlo
1164289066Skevlo	return (0);
1165289066Skevlo}
1166289066Skevlo
1167289066Skevlostatic int
1168289066Skevlourtwn_alloc_tx_list(struct urtwn_softc *sc)
1169289066Skevlo{
1170289066Skevlo	int error, i;
1171289066Skevlo
1172289066Skevlo	error = urtwn_alloc_list(sc, sc->sc_tx, URTWN_TX_LIST_COUNT,
1173289066Skevlo	    URTWN_TXBUFSZ);
1174289066Skevlo	if (error != 0)
1175289066Skevlo		return (error);
1176289066Skevlo
1177289066Skevlo	STAILQ_INIT(&sc->sc_tx_active);
1178289066Skevlo	STAILQ_INIT(&sc->sc_tx_inactive);
1179289066Skevlo	STAILQ_INIT(&sc->sc_tx_pending);
1180289066Skevlo
1181289066Skevlo	for (i = 0; i < URTWN_TX_LIST_COUNT; i++)
1182289066Skevlo		STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, &sc->sc_tx[i], next);
1183289066Skevlo
1184289066Skevlo	return (0);
1185289066Skevlo}
1186289066Skevlo
1187251538Srpaulostatic void
1188289066Skevlourtwn_free_list(struct urtwn_softc *sc, struct urtwn_data data[], int ndata)
1189289066Skevlo{
1190289066Skevlo	int i;
1191289066Skevlo
1192289066Skevlo	for (i = 0; i < ndata; i++) {
1193289066Skevlo		struct urtwn_data *dp = &data[i];
1194289066Skevlo
1195289066Skevlo		if (dp->buf != NULL) {
1196289066Skevlo			free(dp->buf, M_USBDEV);
1197289066Skevlo			dp->buf = NULL;
1198289066Skevlo		}
1199289066Skevlo		if (dp->ni != NULL) {
1200289066Skevlo			ieee80211_free_node(dp->ni);
1201289066Skevlo			dp->ni = NULL;
1202289066Skevlo		}
1203289066Skevlo	}
1204289066Skevlo}
1205289066Skevlo
1206289066Skevlostatic void
1207289066Skevlourtwn_free_rx_list(struct urtwn_softc *sc)
1208289066Skevlo{
1209289066Skevlo	urtwn_free_list(sc, sc->sc_rx, URTWN_RX_LIST_COUNT);
1210289066Skevlo}
1211289066Skevlo
1212289066Skevlostatic void
1213289066Skevlourtwn_free_tx_list(struct urtwn_softc *sc)
1214289066Skevlo{
1215289066Skevlo	urtwn_free_list(sc, sc->sc_tx, URTWN_TX_LIST_COUNT);
1216289066Skevlo}
1217289066Skevlo
1218289066Skevlostatic void
1219251538Srpaulourtwn_bulk_tx_callback(struct usb_xfer *xfer, usb_error_t error)
1220251538Srpaulo{
1221251538Srpaulo	struct urtwn_softc *sc = usbd_xfer_softc(xfer);
1222251538Srpaulo	struct urtwn_data *data;
1223251538Srpaulo
1224251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
1225251538Srpaulo
1226251538Srpaulo	switch (USB_GET_STATE(xfer)){
1227251538Srpaulo	case USB_ST_TRANSFERRED:
1228251538Srpaulo		data = STAILQ_FIRST(&sc->sc_tx_active);
1229251538Srpaulo		if (data == NULL)
1230251538Srpaulo			goto tr_setup;
1231251538Srpaulo		STAILQ_REMOVE_HEAD(&sc->sc_tx_active, next);
1232289891Savos		urtwn_txeof(sc, data, 0);
1233251538Srpaulo		/* FALLTHROUGH */
1234251538Srpaulo	case USB_ST_SETUP:
1235251538Srpaulotr_setup:
1236251538Srpaulo		data = STAILQ_FIRST(&sc->sc_tx_pending);
1237251538Srpaulo		if (data == NULL) {
1238294471Savos			URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT,
1239294471Savos			    "%s: empty pending queue\n", __func__);
1240288353Sadrian			goto finish;
1241251538Srpaulo		}
1242251538Srpaulo		STAILQ_REMOVE_HEAD(&sc->sc_tx_pending, next);
1243251538Srpaulo		STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next);
1244251538Srpaulo		usbd_xfer_set_frame_data(xfer, 0, data->buf, data->buflen);
1245251538Srpaulo		usbd_transfer_submit(xfer);
1246251538Srpaulo		break;
1247251538Srpaulo	default:
1248251538Srpaulo		data = STAILQ_FIRST(&sc->sc_tx_active);
1249251538Srpaulo		if (data == NULL)
1250251538Srpaulo			goto tr_setup;
1251289891Savos		STAILQ_REMOVE_HEAD(&sc->sc_tx_active, next);
1252289891Savos		urtwn_txeof(sc, data, 1);
1253251538Srpaulo		if (error != USB_ERR_CANCELLED) {
1254251538Srpaulo			usbd_xfer_set_stall(xfer);
1255251538Srpaulo			goto tr_setup;
1256251538Srpaulo		}
1257251538Srpaulo		break;
1258251538Srpaulo	}
1259288353Sadrianfinish:
1260288353Sadrian	/* Kick-start more transmit */
1261288353Sadrian	urtwn_start(sc);
1262251538Srpaulo}
1263251538Srpaulo
1264251538Srpaulostatic struct urtwn_data *
1265251538Srpaulo_urtwn_getbuf(struct urtwn_softc *sc)
1266251538Srpaulo{
1267251538Srpaulo	struct urtwn_data *bf;
1268251538Srpaulo
1269251538Srpaulo	bf = STAILQ_FIRST(&sc->sc_tx_inactive);
1270251538Srpaulo	if (bf != NULL)
1271251538Srpaulo		STAILQ_REMOVE_HEAD(&sc->sc_tx_inactive, next);
1272294471Savos	else {
1273294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT,
1274294471Savos		    "%s: out of xmit buffers\n", __func__);
1275294471Savos	}
1276251538Srpaulo	return (bf);
1277251538Srpaulo}
1278251538Srpaulo
1279251538Srpaulostatic struct urtwn_data *
1280251538Srpaulourtwn_getbuf(struct urtwn_softc *sc)
1281251538Srpaulo{
1282251538Srpaulo        struct urtwn_data *bf;
1283251538Srpaulo
1284251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
1285251538Srpaulo
1286251538Srpaulo	bf = _urtwn_getbuf(sc);
1287294471Savos	if (bf == NULL) {
1288294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT, "%s: stop queue\n",
1289294471Savos		    __func__);
1290294471Savos	}
1291251538Srpaulo	return (bf);
1292251538Srpaulo}
1293251538Srpaulo
1294291698Savosstatic usb_error_t
1295251538Srpaulourtwn_write_region_1(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf,
1296251538Srpaulo    int len)
1297251538Srpaulo{
1298251538Srpaulo	usb_device_request_t req;
1299251538Srpaulo
1300251538Srpaulo	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
1301251538Srpaulo	req.bRequest = R92C_REQ_REGS;
1302251538Srpaulo	USETW(req.wValue, addr);
1303251538Srpaulo	USETW(req.wIndex, 0);
1304251538Srpaulo	USETW(req.wLength, len);
1305251538Srpaulo	return (urtwn_do_request(sc, &req, buf));
1306251538Srpaulo}
1307251538Srpaulo
1308291698Savosstatic usb_error_t
1309251538Srpaulourtwn_write_1(struct urtwn_softc *sc, uint16_t addr, uint8_t val)
1310251538Srpaulo{
1311291698Savos	return (urtwn_write_region_1(sc, addr, &val, sizeof(val)));
1312251538Srpaulo}
1313251538Srpaulo
1314291698Savosstatic usb_error_t
1315251538Srpaulourtwn_write_2(struct urtwn_softc *sc, uint16_t addr, uint16_t val)
1316251538Srpaulo{
1317251538Srpaulo	val = htole16(val);
1318291698Savos	return (urtwn_write_region_1(sc, addr, (uint8_t *)&val, sizeof(val)));
1319251538Srpaulo}
1320251538Srpaulo
1321291698Savosstatic usb_error_t
1322251538Srpaulourtwn_write_4(struct urtwn_softc *sc, uint16_t addr, uint32_t val)
1323251538Srpaulo{
1324251538Srpaulo	val = htole32(val);
1325291698Savos	return (urtwn_write_region_1(sc, addr, (uint8_t *)&val, sizeof(val)));
1326251538Srpaulo}
1327251538Srpaulo
1328291698Savosstatic usb_error_t
1329251538Srpaulourtwn_read_region_1(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf,
1330251538Srpaulo    int len)
1331251538Srpaulo{
1332251538Srpaulo	usb_device_request_t req;
1333251538Srpaulo
1334251538Srpaulo	req.bmRequestType = UT_READ_VENDOR_DEVICE;
1335251538Srpaulo	req.bRequest = R92C_REQ_REGS;
1336251538Srpaulo	USETW(req.wValue, addr);
1337251538Srpaulo	USETW(req.wIndex, 0);
1338251538Srpaulo	USETW(req.wLength, len);
1339251538Srpaulo	return (urtwn_do_request(sc, &req, buf));
1340251538Srpaulo}
1341251538Srpaulo
1342251538Srpaulostatic uint8_t
1343251538Srpaulourtwn_read_1(struct urtwn_softc *sc, uint16_t addr)
1344251538Srpaulo{
1345251538Srpaulo	uint8_t val;
1346251538Srpaulo
1347251538Srpaulo	if (urtwn_read_region_1(sc, addr, &val, 1) != 0)
1348251538Srpaulo		return (0xff);
1349251538Srpaulo	return (val);
1350251538Srpaulo}
1351251538Srpaulo
1352251538Srpaulostatic uint16_t
1353251538Srpaulourtwn_read_2(struct urtwn_softc *sc, uint16_t addr)
1354251538Srpaulo{
1355251538Srpaulo	uint16_t val;
1356251538Srpaulo
1357251538Srpaulo	if (urtwn_read_region_1(sc, addr, (uint8_t *)&val, 2) != 0)
1358251538Srpaulo		return (0xffff);
1359251538Srpaulo	return (le16toh(val));
1360251538Srpaulo}
1361251538Srpaulo
1362251538Srpaulostatic uint32_t
1363251538Srpaulourtwn_read_4(struct urtwn_softc *sc, uint16_t addr)
1364251538Srpaulo{
1365251538Srpaulo	uint32_t val;
1366251538Srpaulo
1367251538Srpaulo	if (urtwn_read_region_1(sc, addr, (uint8_t *)&val, 4) != 0)
1368251538Srpaulo		return (0xffffffff);
1369251538Srpaulo	return (le32toh(val));
1370251538Srpaulo}
1371251538Srpaulo
1372251538Srpaulostatic int
1373251538Srpaulourtwn_fw_cmd(struct urtwn_softc *sc, uint8_t id, const void *buf, int len)
1374251538Srpaulo{
1375251538Srpaulo	struct r92c_fw_cmd cmd;
1376291698Savos	usb_error_t error;
1377251538Srpaulo	int ntries;
1378251538Srpaulo
1379251538Srpaulo	/* Wait for current FW box to be empty. */
1380251538Srpaulo	for (ntries = 0; ntries < 100; ntries++) {
1381251538Srpaulo		if (!(urtwn_read_1(sc, R92C_HMETFR) & (1 << sc->fwcur)))
1382251538Srpaulo			break;
1383266472Shselasky		urtwn_ms_delay(sc);
1384251538Srpaulo	}
1385251538Srpaulo	if (ntries == 100) {
1386251538Srpaulo		device_printf(sc->sc_dev,
1387251538Srpaulo		    "could not send firmware command\n");
1388251538Srpaulo		return (ETIMEDOUT);
1389251538Srpaulo	}
1390251538Srpaulo	memset(&cmd, 0, sizeof(cmd));
1391251538Srpaulo	cmd.id = id;
1392251538Srpaulo	if (len > 3)
1393251538Srpaulo		cmd.id |= R92C_CMD_FLAG_EXT;
1394251538Srpaulo	KASSERT(len <= sizeof(cmd.msg), ("urtwn_fw_cmd\n"));
1395251538Srpaulo	memcpy(cmd.msg, buf, len);
1396251538Srpaulo
1397251538Srpaulo	/* Write the first word last since that will trigger the FW. */
1398291698Savos	error = urtwn_write_region_1(sc, R92C_HMEBOX_EXT(sc->fwcur),
1399251538Srpaulo	    (uint8_t *)&cmd + 4, 2);
1400291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
1401291698Savos		return (EIO);
1402291698Savos	error = urtwn_write_region_1(sc, R92C_HMEBOX(sc->fwcur),
1403251538Srpaulo	    (uint8_t *)&cmd + 0, 4);
1404291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
1405291698Savos		return (EIO);
1406251538Srpaulo
1407251538Srpaulo	sc->fwcur = (sc->fwcur + 1) % R92C_H2C_NBOX;
1408251538Srpaulo	return (0);
1409251538Srpaulo}
1410251538Srpaulo
1411292174Savosstatic void
1412292174Savosurtwn_cmdq_cb(void *arg, int pending)
1413292174Savos{
1414292174Savos	struct urtwn_softc *sc = arg;
1415292174Savos	struct urtwn_cmdq *item;
1416292174Savos
1417292174Savos	/*
1418292174Savos	 * Device must be powered on (via urtwn_power_on())
1419292174Savos	 * before any command may be sent.
1420292174Savos	 */
1421292174Savos	URTWN_LOCK(sc);
1422292174Savos	if (!(sc->sc_flags & URTWN_RUNNING)) {
1423292174Savos		URTWN_UNLOCK(sc);
1424292174Savos		return;
1425292174Savos	}
1426292174Savos
1427292174Savos	URTWN_CMDQ_LOCK(sc);
1428292174Savos	while (sc->cmdq[sc->cmdq_first].func != NULL) {
1429292174Savos		item = &sc->cmdq[sc->cmdq_first];
1430292174Savos		sc->cmdq_first = (sc->cmdq_first + 1) % URTWN_CMDQ_SIZE;
1431292174Savos		URTWN_CMDQ_UNLOCK(sc);
1432292174Savos
1433292174Savos		item->func(sc, &item->data);
1434292174Savos
1435292174Savos		URTWN_CMDQ_LOCK(sc);
1436292174Savos		memset(item, 0, sizeof (*item));
1437292174Savos	}
1438292174Savos	URTWN_CMDQ_UNLOCK(sc);
1439292174Savos	URTWN_UNLOCK(sc);
1440292174Savos}
1441292174Savos
1442292174Savosstatic int
1443292174Savosurtwn_cmd_sleepable(struct urtwn_softc *sc, const void *ptr, size_t len,
1444292174Savos    CMD_FUNC_PROTO)
1445292174Savos{
1446292174Savos	struct ieee80211com *ic = &sc->sc_ic;
1447292174Savos
1448292174Savos	KASSERT(len <= sizeof(union sec_param), ("buffer overflow"));
1449292174Savos
1450292174Savos	URTWN_CMDQ_LOCK(sc);
1451292174Savos	if (sc->cmdq[sc->cmdq_last].func != NULL) {
1452292174Savos		device_printf(sc->sc_dev, "%s: cmdq overflow\n", __func__);
1453292174Savos		URTWN_CMDQ_UNLOCK(sc);
1454292174Savos
1455292174Savos		return (EAGAIN);
1456292174Savos	}
1457292174Savos
1458292174Savos	if (ptr != NULL)
1459292174Savos		memcpy(&sc->cmdq[sc->cmdq_last].data, ptr, len);
1460292174Savos	sc->cmdq[sc->cmdq_last].func = func;
1461292174Savos	sc->cmdq_last = (sc->cmdq_last + 1) % URTWN_CMDQ_SIZE;
1462292174Savos	URTWN_CMDQ_UNLOCK(sc);
1463292174Savos
1464292174Savos	ieee80211_runtask(ic, &sc->cmdq_task);
1465292174Savos
1466292174Savos	return (0);
1467292174Savos}
1468292174Savos
1469264912Skevlostatic __inline void
1470251538Srpaulourtwn_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr, uint32_t val)
1471251538Srpaulo{
1472264912Skevlo
1473264912Skevlo	sc->sc_rf_write(sc, chain, addr, val);
1474264912Skevlo}
1475264912Skevlo
1476264912Skevlostatic void
1477264912Skevlourtwn_r92c_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr,
1478264912Skevlo    uint32_t val)
1479264912Skevlo{
1480251538Srpaulo	urtwn_bb_write(sc, R92C_LSSI_PARAM(chain),
1481251538Srpaulo	    SM(R92C_LSSI_PARAM_ADDR, addr) |
1482251538Srpaulo	    SM(R92C_LSSI_PARAM_DATA, val));
1483251538Srpaulo}
1484251538Srpaulo
1485264912Skevlostatic void
1486264912Skevlourtwn_r88e_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr,
1487264912Skevlouint32_t val)
1488264912Skevlo{
1489264912Skevlo	urtwn_bb_write(sc, R92C_LSSI_PARAM(chain),
1490264912Skevlo	    SM(R88E_LSSI_PARAM_ADDR, addr) |
1491264912Skevlo	    SM(R92C_LSSI_PARAM_DATA, val));
1492264912Skevlo}
1493264912Skevlo
1494251538Srpaulostatic uint32_t
1495251538Srpaulourtwn_rf_read(struct urtwn_softc *sc, int chain, uint8_t addr)
1496251538Srpaulo{
1497251538Srpaulo	uint32_t reg[R92C_MAX_CHAINS], val;
1498251538Srpaulo
1499251538Srpaulo	reg[0] = urtwn_bb_read(sc, R92C_HSSI_PARAM2(0));
1500251538Srpaulo	if (chain != 0)
1501251538Srpaulo		reg[chain] = urtwn_bb_read(sc, R92C_HSSI_PARAM2(chain));
1502251538Srpaulo
1503251538Srpaulo	urtwn_bb_write(sc, R92C_HSSI_PARAM2(0),
1504251538Srpaulo	    reg[0] & ~R92C_HSSI_PARAM2_READ_EDGE);
1505266472Shselasky	urtwn_ms_delay(sc);
1506251538Srpaulo
1507251538Srpaulo	urtwn_bb_write(sc, R92C_HSSI_PARAM2(chain),
1508251538Srpaulo	    RW(reg[chain], R92C_HSSI_PARAM2_READ_ADDR, addr) |
1509251538Srpaulo	    R92C_HSSI_PARAM2_READ_EDGE);
1510266472Shselasky	urtwn_ms_delay(sc);
1511251538Srpaulo
1512251538Srpaulo	urtwn_bb_write(sc, R92C_HSSI_PARAM2(0),
1513251538Srpaulo	    reg[0] | R92C_HSSI_PARAM2_READ_EDGE);
1514266472Shselasky	urtwn_ms_delay(sc);
1515251538Srpaulo
1516251538Srpaulo	if (urtwn_bb_read(sc, R92C_HSSI_PARAM1(chain)) & R92C_HSSI_PARAM1_PI)
1517251538Srpaulo		val = urtwn_bb_read(sc, R92C_HSPI_READBACK(chain));
1518251538Srpaulo	else
1519251538Srpaulo		val = urtwn_bb_read(sc, R92C_LSSI_READBACK(chain));
1520251538Srpaulo	return (MS(val, R92C_LSSI_READBACK_DATA));
1521251538Srpaulo}
1522251538Srpaulo
1523251538Srpaulostatic int
1524251538Srpaulourtwn_llt_write(struct urtwn_softc *sc, uint32_t addr, uint32_t data)
1525251538Srpaulo{
1526291698Savos	usb_error_t error;
1527251538Srpaulo	int ntries;
1528251538Srpaulo
1529291698Savos	error = urtwn_write_4(sc, R92C_LLT_INIT,
1530251538Srpaulo	    SM(R92C_LLT_INIT_OP, R92C_LLT_INIT_OP_WRITE) |
1531251538Srpaulo	    SM(R92C_LLT_INIT_ADDR, addr) |
1532251538Srpaulo	    SM(R92C_LLT_INIT_DATA, data));
1533291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
1534291698Savos		return (EIO);
1535251538Srpaulo	/* Wait for write operation to complete. */
1536251538Srpaulo	for (ntries = 0; ntries < 20; ntries++) {
1537251538Srpaulo		if (MS(urtwn_read_4(sc, R92C_LLT_INIT), R92C_LLT_INIT_OP) ==
1538251538Srpaulo		    R92C_LLT_INIT_OP_NO_ACTIVE)
1539251538Srpaulo			return (0);
1540266472Shselasky		urtwn_ms_delay(sc);
1541251538Srpaulo	}
1542251538Srpaulo	return (ETIMEDOUT);
1543251538Srpaulo}
1544251538Srpaulo
1545291264Savosstatic int
1546291264Savosurtwn_efuse_read_next(struct urtwn_softc *sc, uint8_t *val)
1547251538Srpaulo{
1548251538Srpaulo	uint32_t reg;
1549291698Savos	usb_error_t error;
1550251538Srpaulo	int ntries;
1551251538Srpaulo
1552291264Savos	if (sc->last_rom_addr >= URTWN_EFUSE_MAX_LEN)
1553291264Savos		return (EFAULT);
1554291264Savos
1555251538Srpaulo	reg = urtwn_read_4(sc, R92C_EFUSE_CTRL);
1556291264Savos	reg = RW(reg, R92C_EFUSE_CTRL_ADDR, sc->last_rom_addr);
1557251538Srpaulo	reg &= ~R92C_EFUSE_CTRL_VALID;
1558291264Savos
1559291698Savos	error = urtwn_write_4(sc, R92C_EFUSE_CTRL, reg);
1560291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
1561291698Savos		return (EIO);
1562251538Srpaulo	/* Wait for read operation to complete. */
1563251538Srpaulo	for (ntries = 0; ntries < 100; ntries++) {
1564251538Srpaulo		reg = urtwn_read_4(sc, R92C_EFUSE_CTRL);
1565251538Srpaulo		if (reg & R92C_EFUSE_CTRL_VALID)
1566291264Savos			break;
1567266472Shselasky		urtwn_ms_delay(sc);
1568251538Srpaulo	}
1569291264Savos	if (ntries == 100) {
1570291264Savos		device_printf(sc->sc_dev,
1571291264Savos		    "could not read efuse byte at address 0x%x\n",
1572291264Savos		    sc->last_rom_addr);
1573291264Savos		return (ETIMEDOUT);
1574291264Savos	}
1575291264Savos
1576291264Savos	*val = MS(reg, R92C_EFUSE_CTRL_DATA);
1577291264Savos	sc->last_rom_addr++;
1578291264Savos
1579291264Savos	return (0);
1580251538Srpaulo}
1581251538Srpaulo
1582291264Savosstatic int
1583291264Savosurtwn_efuse_read_data(struct urtwn_softc *sc, uint8_t *rom, uint8_t off,
1584291264Savos    uint8_t msk)
1585291264Savos{
1586291264Savos	uint8_t reg;
1587291264Savos	int i, error;
1588291264Savos
1589291264Savos	for (i = 0; i < 4; i++) {
1590291264Savos		if (msk & (1 << i))
1591291264Savos			continue;
1592291264Savos		error = urtwn_efuse_read_next(sc, &reg);
1593291264Savos		if (error != 0)
1594291264Savos			return (error);
1595294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "rom[0x%03X] == 0x%02X\n",
1596294471Savos		    off * 8 + i * 2, reg);
1597291264Savos		rom[off * 8 + i * 2 + 0] = reg;
1598291264Savos
1599291264Savos		error = urtwn_efuse_read_next(sc, &reg);
1600291264Savos		if (error != 0)
1601291264Savos			return (error);
1602294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "rom[0x%03X] == 0x%02X\n",
1603294471Savos		    off * 8 + i * 2 + 1, reg);
1604291264Savos		rom[off * 8 + i * 2 + 1] = reg;
1605291264Savos	}
1606291264Savos
1607291264Savos	return (0);
1608291264Savos}
1609291264Savos
1610294471Savos#ifdef USB_DEBUG
1611251538Srpaulostatic void
1612291264Savosurtwn_dump_rom_contents(struct urtwn_softc *sc, uint8_t *rom, uint16_t size)
1613251538Srpaulo{
1614251538Srpaulo	int i;
1615251538Srpaulo
1616291264Savos	/* Dump ROM contents. */
1617291264Savos	device_printf(sc->sc_dev, "%s:", __func__);
1618291264Savos	for (i = 0; i < size; i++) {
1619291264Savos		if (i % 32 == 0)
1620291264Savos			printf("\n%03X: ", i);
1621291264Savos		else if (i % 4 == 0)
1622291264Savos			printf(" ");
1623291264Savos
1624291264Savos		printf("%02X", rom[i]);
1625291264Savos	}
1626291264Savos	printf("\n");
1627291264Savos}
1628291264Savos#endif
1629291264Savos
1630291264Savosstatic int
1631291264Savosurtwn_efuse_read(struct urtwn_softc *sc, uint8_t *rom, uint16_t size)
1632291264Savos{
1633291264Savos#define URTWN_CHK(res) do {	\
1634291264Savos	if ((error = res) != 0)	\
1635291264Savos		goto end;	\
1636291264Savos} while(0)
1637291264Savos	uint8_t msk, off, reg;
1638291264Savos	int error;
1639291264Savos
1640291698Savos	URTWN_CHK(urtwn_efuse_switch_power(sc));
1641264912Skevlo
1642291264Savos	/* Read full ROM image. */
1643291264Savos	sc->last_rom_addr = 0;
1644291264Savos	memset(rom, 0xff, size);
1645291264Savos
1646291264Savos	URTWN_CHK(urtwn_efuse_read_next(sc, &reg));
1647291264Savos	while (reg != 0xff) {
1648291264Savos		/* check for extended header */
1649291264Savos		if ((sc->chip & URTWN_CHIP_88E) && (reg & 0x1f) == 0x0f) {
1650291264Savos			off = reg >> 5;
1651291264Savos			URTWN_CHK(urtwn_efuse_read_next(sc, &reg));
1652291264Savos
1653291264Savos			if ((reg & 0x0f) != 0x0f)
1654291264Savos				off = ((reg & 0xf0) >> 1) | off;
1655291264Savos			else
1656291264Savos				continue;
1657291264Savos		} else
1658291264Savos			off = reg >> 4;
1659251538Srpaulo		msk = reg & 0xf;
1660291264Savos
1661291264Savos		URTWN_CHK(urtwn_efuse_read_data(sc, rom, off, msk));
1662291264Savos		URTWN_CHK(urtwn_efuse_read_next(sc, &reg));
1663251538Srpaulo	}
1664291264Savos
1665291264Savosend:
1666291264Savos
1667294471Savos#ifdef USB_DEBUG
1668294471Savos	if (sc->sc_debug & URTWN_DEBUG_ROM)
1669291264Savos		urtwn_dump_rom_contents(sc, rom, size);
1670251538Srpaulo#endif
1671291264Savos
1672282623Skevlo	urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_OFF);
1673291264Savos
1674291264Savos	if (error != 0) {
1675291264Savos		device_printf(sc->sc_dev, "%s: error while reading ROM\n",
1676291264Savos		    __func__);
1677291264Savos	}
1678291264Savos
1679291264Savos	return (error);
1680291264Savos#undef URTWN_CHK
1681282623Skevlo}
1682281592Skevlo
1683291698Savosstatic int
1684264912Skevlourtwn_efuse_switch_power(struct urtwn_softc *sc)
1685264912Skevlo{
1686291698Savos	usb_error_t error;
1687264912Skevlo	uint32_t reg;
1688251538Srpaulo
1689291698Savos	error = urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_ON);
1690291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
1691291698Savos		return (EIO);
1692281918Skevlo
1693264912Skevlo	reg = urtwn_read_2(sc, R92C_SYS_ISO_CTRL);
1694264912Skevlo	if (!(reg & R92C_SYS_ISO_CTRL_PWC_EV12V)) {
1695291698Savos		error = urtwn_write_2(sc, R92C_SYS_ISO_CTRL,
1696264912Skevlo		    reg | R92C_SYS_ISO_CTRL_PWC_EV12V);
1697291698Savos		if (error != USB_ERR_NORMAL_COMPLETION)
1698291698Savos			return (EIO);
1699264912Skevlo	}
1700264912Skevlo	reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN);
1701264912Skevlo	if (!(reg & R92C_SYS_FUNC_EN_ELDR)) {
1702291698Savos		error = urtwn_write_2(sc, R92C_SYS_FUNC_EN,
1703264912Skevlo		    reg | R92C_SYS_FUNC_EN_ELDR);
1704291698Savos		if (error != USB_ERR_NORMAL_COMPLETION)
1705291698Savos			return (EIO);
1706264912Skevlo	}
1707264912Skevlo	reg = urtwn_read_2(sc, R92C_SYS_CLKR);
1708264912Skevlo	if ((reg & (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) !=
1709264912Skevlo	    (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) {
1710291698Savos		error = urtwn_write_2(sc, R92C_SYS_CLKR,
1711264912Skevlo		    reg | R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M);
1712291698Savos		if (error != USB_ERR_NORMAL_COMPLETION)
1713291698Savos			return (EIO);
1714264912Skevlo	}
1715291698Savos
1716291698Savos	return (0);
1717264912Skevlo}
1718264912Skevlo
1719251538Srpaulostatic int
1720251538Srpaulourtwn_read_chipid(struct urtwn_softc *sc)
1721251538Srpaulo{
1722251538Srpaulo	uint32_t reg;
1723251538Srpaulo
1724264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
1725264912Skevlo		return (0);
1726264912Skevlo
1727251538Srpaulo	reg = urtwn_read_4(sc, R92C_SYS_CFG);
1728251538Srpaulo	if (reg & R92C_SYS_CFG_TRP_VAUX_EN)
1729251538Srpaulo		return (EIO);
1730251538Srpaulo
1731251538Srpaulo	if (reg & R92C_SYS_CFG_TYPE_92C) {
1732251538Srpaulo		sc->chip |= URTWN_CHIP_92C;
1733251538Srpaulo		/* Check if it is a castrated 8192C. */
1734251538Srpaulo		if (MS(urtwn_read_4(sc, R92C_HPON_FSM),
1735251538Srpaulo		    R92C_HPON_FSM_CHIP_BONDING_ID) ==
1736251538Srpaulo		    R92C_HPON_FSM_CHIP_BONDING_ID_92C_1T2R)
1737251538Srpaulo			sc->chip |= URTWN_CHIP_92C_1T2R;
1738251538Srpaulo	}
1739251538Srpaulo	if (reg & R92C_SYS_CFG_VENDOR_UMC) {
1740251538Srpaulo		sc->chip |= URTWN_CHIP_UMC;
1741251538Srpaulo		if (MS(reg, R92C_SYS_CFG_CHIP_VER_RTL) == 0)
1742251538Srpaulo			sc->chip |= URTWN_CHIP_UMC_A_CUT;
1743251538Srpaulo	}
1744251538Srpaulo	return (0);
1745251538Srpaulo}
1746251538Srpaulo
1747291264Savosstatic int
1748251538Srpaulourtwn_read_rom(struct urtwn_softc *sc)
1749251538Srpaulo{
1750291264Savos	struct r92c_rom *rom = &sc->rom.r92c_rom;
1751291264Savos	int error;
1752251538Srpaulo
1753251538Srpaulo	/* Read full ROM image. */
1754291264Savos	error = urtwn_efuse_read(sc, (uint8_t *)rom, sizeof(*rom));
1755291264Savos	if (error != 0)
1756291264Savos		return (error);
1757251538Srpaulo
1758251538Srpaulo	/* XXX Weird but this is what the vendor driver does. */
1759291264Savos	sc->last_rom_addr = 0x1fa;
1760291264Savos	error = urtwn_efuse_read_next(sc, &sc->pa_setting);
1761291264Savos	if (error != 0)
1762291264Savos		return (error);
1763294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "%s: PA setting=0x%x\n", __func__,
1764294471Savos	    sc->pa_setting);
1765251538Srpaulo
1766251538Srpaulo	sc->board_type = MS(rom->rf_opt1, R92C_ROM_RF1_BOARD_TYPE);
1767251538Srpaulo
1768251538Srpaulo	sc->regulatory = MS(rom->rf_opt1, R92C_ROM_RF1_REGULATORY);
1769294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "%s: regulatory type=%d\n",
1770294471Savos	    __func__, sc->regulatory);
1771287197Sglebius	IEEE80211_ADDR_COPY(sc->sc_ic.ic_macaddr, rom->macaddr);
1772251538Srpaulo
1773264912Skevlo	sc->sc_rf_write = urtwn_r92c_rf_write;
1774264912Skevlo	sc->sc_power_on = urtwn_r92c_power_on;
1775291264Savos
1776291264Savos	return (0);
1777251538Srpaulo}
1778251538Srpaulo
1779291264Savosstatic int
1780264912Skevlourtwn_r88e_read_rom(struct urtwn_softc *sc)
1781264912Skevlo{
1782294198Savos	struct r88e_rom *rom = &sc->rom.r88e_rom;
1783294198Savos	int error;
1784264912Skevlo
1785294198Savos	error = urtwn_efuse_read(sc, (uint8_t *)rom, sizeof(sc->rom.r88e_rom));
1786291264Savos	if (error != 0)
1787291264Savos		return (error);
1788264912Skevlo
1789294198Savos	sc->bw20_tx_pwr_diff = (rom->tx_pwr_diff >> 4);
1790264912Skevlo	if (sc->bw20_tx_pwr_diff & 0x08)
1791264912Skevlo		sc->bw20_tx_pwr_diff |= 0xf0;
1792294198Savos	sc->ofdm_tx_pwr_diff = (rom->tx_pwr_diff & 0xf);
1793264912Skevlo	if (sc->ofdm_tx_pwr_diff & 0x08)
1794264912Skevlo		sc->ofdm_tx_pwr_diff |= 0xf0;
1795294198Savos	sc->regulatory = MS(rom->rf_board_opt, R92C_ROM_RF1_REGULATORY);
1796294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "%s: regulatory type %d\n",
1797294471Savos	    __func__,sc->regulatory);
1798294198Savos	IEEE80211_ADDR_COPY(sc->sc_ic.ic_macaddr, rom->macaddr);
1799264912Skevlo
1800264912Skevlo	sc->sc_rf_write = urtwn_r88e_rf_write;
1801264912Skevlo	sc->sc_power_on = urtwn_r88e_power_on;
1802291264Savos
1803291264Savos	return (0);
1804264912Skevlo}
1805264912Skevlo
1806251538Srpaulo/*
1807251538Srpaulo * Initialize rate adaptation in firmware.
1808251538Srpaulo */
1809251538Srpaulostatic int
1810251538Srpaulourtwn_ra_init(struct urtwn_softc *sc)
1811251538Srpaulo{
1812287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
1813251538Srpaulo	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
1814251538Srpaulo	struct ieee80211_node *ni;
1815251538Srpaulo	struct ieee80211_rateset *rs;
1816251538Srpaulo	struct r92c_fw_cmd_macid_cfg cmd;
1817251538Srpaulo	uint32_t rates, basicrates;
1818251538Srpaulo	uint8_t mode;
1819251538Srpaulo	int maxrate, maxbasicrate, error, i, j;
1820251538Srpaulo
1821251538Srpaulo	ni = ieee80211_ref_node(vap->iv_bss);
1822251538Srpaulo	rs = &ni->ni_rates;
1823251538Srpaulo
1824251538Srpaulo	/* Get normal and basic rates mask. */
1825251538Srpaulo	rates = basicrates = 0;
1826251538Srpaulo	maxrate = maxbasicrate = 0;
1827251538Srpaulo	for (i = 0; i < rs->rs_nrates; i++) {
1828251538Srpaulo		/* Convert 802.11 rate to HW rate index. */
1829289758Savos		for (j = 0; j < nitems(ridx2rate); j++)
1830289758Savos			if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) ==
1831289758Savos			    ridx2rate[j])
1832251538Srpaulo				break;
1833289758Savos		if (j == nitems(ridx2rate))	/* Unknown rate, skip. */
1834251538Srpaulo			continue;
1835251538Srpaulo		rates |= 1 << j;
1836251538Srpaulo		if (j > maxrate)
1837251538Srpaulo			maxrate = j;
1838251538Srpaulo		if (rs->rs_rates[i] & IEEE80211_RATE_BASIC) {
1839251538Srpaulo			basicrates |= 1 << j;
1840251538Srpaulo			if (j > maxbasicrate)
1841251538Srpaulo				maxbasicrate = j;
1842251538Srpaulo		}
1843251538Srpaulo	}
1844251538Srpaulo	if (ic->ic_curmode == IEEE80211_MODE_11B)
1845251538Srpaulo		mode = R92C_RAID_11B;
1846251538Srpaulo	else
1847251538Srpaulo		mode = R92C_RAID_11BG;
1848294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_RA,
1849294471Savos	    "%s: mode 0x%x, rates 0x%08x, basicrates 0x%08x\n", __func__,
1850251538Srpaulo	    mode, rates, basicrates);
1851251538Srpaulo
1852251538Srpaulo	/* Set rates mask for group addressed frames. */
1853251538Srpaulo	cmd.macid = URTWN_MACID_BC | URTWN_MACID_VALID;
1854251538Srpaulo	cmd.mask = htole32(mode << 28 | basicrates);
1855251538Srpaulo	error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd));
1856251538Srpaulo	if (error != 0) {
1857252401Srpaulo		ieee80211_free_node(ni);
1858251538Srpaulo		device_printf(sc->sc_dev,
1859251538Srpaulo		    "could not add broadcast station\n");
1860251538Srpaulo		return (error);
1861251538Srpaulo	}
1862251538Srpaulo	/* Set initial MRR rate. */
1863294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_RA, "%s: maxbasicrate %d\n", __func__,
1864294471Savos	    maxbasicrate);
1865251538Srpaulo	urtwn_write_1(sc, R92C_INIDATA_RATE_SEL(URTWN_MACID_BC),
1866251538Srpaulo	    maxbasicrate);
1867251538Srpaulo
1868251538Srpaulo	/* Set rates mask for unicast frames. */
1869251538Srpaulo	cmd.macid = URTWN_MACID_BSS | URTWN_MACID_VALID;
1870251538Srpaulo	cmd.mask = htole32(mode << 28 | rates);
1871251538Srpaulo	error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd));
1872251538Srpaulo	if (error != 0) {
1873252401Srpaulo		ieee80211_free_node(ni);
1874251538Srpaulo		device_printf(sc->sc_dev, "could not add BSS station\n");
1875251538Srpaulo		return (error);
1876251538Srpaulo	}
1877251538Srpaulo	/* Set initial MRR rate. */
1878294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_RA, "%s: maxrate %d\n", __func__,
1879294471Savos	    maxrate);
1880251538Srpaulo	urtwn_write_1(sc, R92C_INIDATA_RATE_SEL(URTWN_MACID_BSS),
1881251538Srpaulo	    maxrate);
1882251538Srpaulo
1883251538Srpaulo	/* Indicate highest supported rate. */
1884252403Srpaulo	ni->ni_txrate = rs->rs_rates[rs->rs_nrates - 1];
1885252401Srpaulo	ieee80211_free_node(ni);
1886252401Srpaulo
1887251538Srpaulo	return (0);
1888251538Srpaulo}
1889251538Srpaulo
1890290439Savosstatic void
1891290631Savosurtwn_init_beacon(struct urtwn_softc *sc, struct urtwn_vap *uvp)
1892251538Srpaulo{
1893290631Savos	struct r92c_tx_desc *txd = &uvp->bcn_desc;
1894290631Savos
1895290631Savos	txd->txdw0 = htole32(
1896290631Savos	    SM(R92C_TXDW0_OFFSET, sizeof(*txd)) | R92C_TXDW0_BMCAST |
1897290631Savos	    R92C_TXDW0_OWN | R92C_TXDW0_FSG | R92C_TXDW0_LSG);
1898290631Savos	txd->txdw1 = htole32(
1899290631Savos	    SM(R92C_TXDW1_QSEL, R92C_TXDW1_QSEL_BEACON) |
1900290631Savos	    SM(R92C_TXDW1_RAID, R92C_RAID_11B));
1901290631Savos
1902291858Savos	if (sc->chip & URTWN_CHIP_88E) {
1903290631Savos		txd->txdw1 |= htole32(SM(R88E_TXDW1_MACID, URTWN_MACID_BC));
1904291858Savos		txd->txdseq |= htole16(R88E_TXDSEQ_HWSEQ_EN);
1905291858Savos	} else {
1906290631Savos		txd->txdw1 |= htole32(SM(R92C_TXDW1_MACID, URTWN_MACID_BC));
1907291858Savos		txd->txdw4 |= htole32(R92C_TXDW4_HWSEQ_EN);
1908291858Savos	}
1909290631Savos
1910290631Savos	txd->txdw4 = htole32(R92C_TXDW4_DRVRATE);
1911290631Savos	txd->txdw5 = htole32(SM(R92C_TXDW5_DATARATE, URTWN_RIDX_CCK1));
1912251538Srpaulo}
1913251538Srpaulo
1914290631Savosstatic int
1915290631Savosurtwn_setup_beacon(struct urtwn_softc *sc, struct ieee80211_node *ni)
1916290631Savos{
1917290631Savos 	struct ieee80211vap *vap = ni->ni_vap;
1918290631Savos	struct urtwn_vap *uvp = URTWN_VAP(vap);
1919290631Savos	struct mbuf *m;
1920290631Savos	int error;
1921290631Savos
1922290631Savos	URTWN_ASSERT_LOCKED(sc);
1923290631Savos
1924290631Savos	if (ni->ni_chan == IEEE80211_CHAN_ANYC)
1925290631Savos		return (EINVAL);
1926290631Savos
1927290631Savos	m = ieee80211_beacon_alloc(ni);
1928290631Savos	if (m == NULL) {
1929290631Savos		device_printf(sc->sc_dev,
1930290631Savos		    "%s: could not allocate beacon frame\n", __func__);
1931290631Savos		return (ENOMEM);
1932290631Savos	}
1933290631Savos
1934290631Savos	if (uvp->bcn_mbuf != NULL)
1935290631Savos		m_freem(uvp->bcn_mbuf);
1936290631Savos
1937290631Savos	uvp->bcn_mbuf = m;
1938290631Savos
1939290631Savos	if ((error = urtwn_tx_beacon(sc, uvp)) != 0)
1940290631Savos		return (error);
1941290631Savos
1942290631Savos	/* XXX bcnq stuck workaround */
1943290631Savos	if ((error = urtwn_tx_beacon(sc, uvp)) != 0)
1944290631Savos		return (error);
1945290631Savos
1946294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_BEACON, "%s: beacon was %srecognized\n",
1947294471Savos	    __func__, urtwn_read_1(sc, R92C_TDECTRL + 2) &
1948294471Savos	    (R92C_TDECTRL_BCN_VALID >> 16) ? "" : "not ");
1949294471Savos
1950290631Savos	return (0);
1951290631Savos}
1952290631Savos
1953251538Srpaulostatic void
1954290631Savosurtwn_update_beacon(struct ieee80211vap *vap, int item)
1955290631Savos{
1956290631Savos	struct urtwn_softc *sc = vap->iv_ic->ic_softc;
1957290631Savos	struct urtwn_vap *uvp = URTWN_VAP(vap);
1958290631Savos	struct ieee80211_beacon_offsets *bo = &vap->iv_bcn_off;
1959290631Savos	struct ieee80211_node *ni = vap->iv_bss;
1960290631Savos	int mcast = 0;
1961290631Savos
1962290631Savos	URTWN_LOCK(sc);
1963290631Savos	if (uvp->bcn_mbuf == NULL) {
1964290631Savos		uvp->bcn_mbuf = ieee80211_beacon_alloc(ni);
1965290631Savos		if (uvp->bcn_mbuf == NULL) {
1966290631Savos			device_printf(sc->sc_dev,
1967290631Savos			    "%s: could not allocate beacon frame\n", __func__);
1968290631Savos			URTWN_UNLOCK(sc);
1969290631Savos			return;
1970290631Savos		}
1971290631Savos	}
1972290631Savos	URTWN_UNLOCK(sc);
1973290631Savos
1974290631Savos	if (item == IEEE80211_BEACON_TIM)
1975290631Savos		mcast = 1;	/* XXX */
1976290631Savos
1977290631Savos	setbit(bo->bo_flags, item);
1978290631Savos	ieee80211_beacon_update(ni, uvp->bcn_mbuf, mcast);
1979290631Savos
1980290631Savos	URTWN_LOCK(sc);
1981290631Savos	urtwn_tx_beacon(sc, uvp);
1982290631Savos	URTWN_UNLOCK(sc);
1983290631Savos}
1984290631Savos
1985290631Savos/*
1986290631Savos * Push a beacon frame into the chip. Beacon will
1987290631Savos * be repeated by the chip every R92C_BCN_INTERVAL.
1988290631Savos */
1989290631Savosstatic int
1990290631Savosurtwn_tx_beacon(struct urtwn_softc *sc, struct urtwn_vap *uvp)
1991290631Savos{
1992290631Savos	struct r92c_tx_desc *desc = &uvp->bcn_desc;
1993290631Savos	struct urtwn_data *bf;
1994290631Savos
1995290631Savos	URTWN_ASSERT_LOCKED(sc);
1996290631Savos
1997290631Savos	bf = urtwn_getbuf(sc);
1998290631Savos	if (bf == NULL)
1999290631Savos		return (ENOMEM);
2000290631Savos
2001290631Savos	memcpy(bf->buf, desc, sizeof(*desc));
2002290631Savos	urtwn_tx_start(sc, uvp->bcn_mbuf, IEEE80211_FC0_TYPE_MGT, bf);
2003290631Savos
2004290631Savos	sc->sc_txtimer = 5;
2005290631Savos	callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc);
2006290631Savos
2007290631Savos	return (0);
2008290631Savos}
2009290631Savos
2010292175Savosstatic int
2011292175Savosurtwn_key_alloc(struct ieee80211vap *vap, struct ieee80211_key *k,
2012292175Savos    ieee80211_keyix *keyix, ieee80211_keyix *rxkeyix)
2013292175Savos{
2014292175Savos	struct urtwn_softc *sc = vap->iv_ic->ic_softc;
2015292175Savos	uint8_t i;
2016292175Savos
2017292175Savos	if (!(&vap->iv_nw_keys[0] <= k &&
2018292175Savos	     k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) {
2019292175Savos		if (!(k->wk_flags & IEEE80211_KEY_SWCRYPT)) {
2020292175Savos			URTWN_LOCK(sc);
2021292175Savos			/*
2022292175Savos			 * First 4 slots for group keys,
2023292175Savos			 * what is left - for pairwise.
2024292175Savos			 * XXX incompatible with IBSS RSN.
2025292175Savos			 */
2026292175Savos			for (i = IEEE80211_WEP_NKID;
2027292175Savos			     i < R92C_CAM_ENTRY_COUNT; i++) {
2028292175Savos				if ((sc->keys_bmap & (1 << i)) == 0) {
2029292175Savos					sc->keys_bmap |= 1 << i;
2030292175Savos					*keyix = i;
2031292175Savos					break;
2032292175Savos				}
2033292175Savos			}
2034292175Savos			URTWN_UNLOCK(sc);
2035292175Savos			if (i == R92C_CAM_ENTRY_COUNT) {
2036292175Savos				device_printf(sc->sc_dev,
2037292175Savos				    "%s: no free space in the key table\n",
2038292175Savos				    __func__);
2039292175Savos				return 0;
2040292175Savos			}
2041292175Savos		} else
2042292175Savos			*keyix = 0;
2043292175Savos	} else {
2044292175Savos		*keyix = k - vap->iv_nw_keys;
2045292175Savos	}
2046292175Savos	*rxkeyix = *keyix;
2047292175Savos	return 1;
2048292175Savos}
2049292175Savos
2050290631Savosstatic void
2051292175Savosurtwn_key_set_cb(struct urtwn_softc *sc, union sec_param *data)
2052292175Savos{
2053292175Savos	struct ieee80211_key *k = &data->key;
2054292175Savos	uint8_t algo, keyid;
2055292175Savos	int i, error;
2056292175Savos
2057292175Savos	if (k->wk_keyix < IEEE80211_WEP_NKID)
2058292175Savos		keyid = k->wk_keyix;
2059292175Savos	else
2060292175Savos		keyid = 0;
2061292175Savos
2062292175Savos	/* Map net80211 cipher to HW crypto algorithm. */
2063292175Savos	switch (k->wk_cipher->ic_cipher) {
2064292175Savos	case IEEE80211_CIPHER_WEP:
2065292175Savos		if (k->wk_keylen < 8)
2066292175Savos			algo = R92C_CAM_ALGO_WEP40;
2067292175Savos		else
2068292175Savos			algo = R92C_CAM_ALGO_WEP104;
2069292175Savos		break;
2070292175Savos	case IEEE80211_CIPHER_TKIP:
2071292175Savos		algo = R92C_CAM_ALGO_TKIP;
2072292175Savos		break;
2073292175Savos	case IEEE80211_CIPHER_AES_CCM:
2074292175Savos		algo = R92C_CAM_ALGO_AES;
2075292175Savos		break;
2076292175Savos	default:
2077292175Savos		device_printf(sc->sc_dev, "%s: undefined cipher %d\n",
2078292175Savos		    __func__, k->wk_cipher->ic_cipher);
2079292175Savos		return;
2080292175Savos	}
2081292175Savos
2082294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_KEY,
2083294471Savos	    "%s: keyix %d, keyid %d, algo %d/%d, flags %04X, len %d, "
2084294471Savos	    "macaddr %s\n", __func__, k->wk_keyix, keyid,
2085294471Savos	    k->wk_cipher->ic_cipher, algo, k->wk_flags, k->wk_keylen,
2086294471Savos	    ether_sprintf(k->wk_macaddr));
2087292175Savos
2088292175Savos	/* Write key. */
2089292175Savos	for (i = 0; i < 4; i++) {
2090292175Savos		error = urtwn_cam_write(sc, R92C_CAM_KEY(k->wk_keyix, i),
2091292175Savos		    LE_READ_4(&k->wk_key[i * 4]));
2092292175Savos		if (error != 0)
2093292175Savos			goto fail;
2094292175Savos	}
2095292175Savos
2096292175Savos	/* Write CTL0 last since that will validate the CAM entry. */
2097292175Savos	error = urtwn_cam_write(sc, R92C_CAM_CTL1(k->wk_keyix),
2098292175Savos	    LE_READ_4(&k->wk_macaddr[2]));
2099292175Savos	if (error != 0)
2100292175Savos		goto fail;
2101292175Savos	error = urtwn_cam_write(sc, R92C_CAM_CTL0(k->wk_keyix),
2102292175Savos	    SM(R92C_CAM_ALGO, algo) |
2103292175Savos	    SM(R92C_CAM_KEYID, keyid) |
2104292175Savos	    SM(R92C_CAM_MACLO, LE_READ_2(&k->wk_macaddr[0])) |
2105292175Savos	    R92C_CAM_VALID);
2106292175Savos	if (error != 0)
2107292175Savos		goto fail;
2108292175Savos
2109292175Savos	return;
2110292175Savos
2111292175Savosfail:
2112292175Savos	device_printf(sc->sc_dev, "%s fails, error %d\n", __func__, error);
2113292175Savos}
2114292175Savos
2115292175Savosstatic void
2116292175Savosurtwn_key_del_cb(struct urtwn_softc *sc, union sec_param *data)
2117292175Savos{
2118292175Savos	struct ieee80211_key *k = &data->key;
2119292175Savos	int i;
2120292175Savos
2121294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_KEY,
2122294471Savos	    "%s: keyix %d, flags %04X, macaddr %s\n", __func__,
2123292175Savos	    k->wk_keyix, k->wk_flags, ether_sprintf(k->wk_macaddr));
2124292175Savos
2125292175Savos	urtwn_cam_write(sc, R92C_CAM_CTL0(k->wk_keyix), 0);
2126292175Savos	urtwn_cam_write(sc, R92C_CAM_CTL1(k->wk_keyix), 0);
2127292175Savos
2128292175Savos	/* Clear key. */
2129292175Savos	for (i = 0; i < 4; i++)
2130292175Savos		urtwn_cam_write(sc, R92C_CAM_KEY(k->wk_keyix, i), 0);
2131292175Savos	sc->keys_bmap &= ~(1 << k->wk_keyix);
2132292175Savos}
2133292175Savos
2134292175Savosstatic int
2135292175Savosurtwn_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k)
2136292175Savos{
2137292175Savos	struct urtwn_softc *sc = vap->iv_ic->ic_softc;
2138292175Savos
2139292175Savos	if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
2140292175Savos		/* Not for us. */
2141292175Savos		return (1);
2142292175Savos	}
2143292175Savos
2144292175Savos	return (!urtwn_cmd_sleepable(sc, k, sizeof(*k), urtwn_key_set_cb));
2145292175Savos}
2146292175Savos
2147292175Savosstatic int
2148292175Savosurtwn_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k)
2149292175Savos{
2150292175Savos	struct urtwn_softc *sc = vap->iv_ic->ic_softc;
2151292175Savos
2152292175Savos	if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
2153292175Savos		/* Not for us. */
2154292175Savos		return (1);
2155292175Savos	}
2156292175Savos
2157292175Savos	return (!urtwn_cmd_sleepable(sc, k, sizeof(*k), urtwn_key_del_cb));
2158292175Savos}
2159292175Savos
2160292175Savosstatic void
2161290651Savosurtwn_tsf_task_adhoc(void *arg, int pending)
2162290651Savos{
2163290651Savos	struct ieee80211vap *vap = arg;
2164290651Savos	struct urtwn_softc *sc = vap->iv_ic->ic_softc;
2165290651Savos	struct ieee80211_node *ni;
2166290651Savos	uint32_t reg;
2167290651Savos
2168290651Savos	URTWN_LOCK(sc);
2169290651Savos	ni = ieee80211_ref_node(vap->iv_bss);
2170290651Savos	reg = urtwn_read_1(sc, R92C_BCN_CTRL);
2171290651Savos
2172290651Savos	/* Accept beacons with the same BSSID. */
2173290651Savos	urtwn_set_rx_bssid_all(sc, 0);
2174290651Savos
2175290651Savos	/* Enable synchronization. */
2176290651Savos	reg &= ~R92C_BCN_CTRL_DIS_TSF_UDT0;
2177290651Savos	urtwn_write_1(sc, R92C_BCN_CTRL, reg);
2178290651Savos
2179290651Savos	/* Synchronize. */
2180290651Savos	usb_pause_mtx(&sc->sc_mtx, hz * ni->ni_intval * 5 / 1000);
2181290651Savos
2182290651Savos	/* Disable synchronization. */
2183290651Savos	reg |= R92C_BCN_CTRL_DIS_TSF_UDT0;
2184290651Savos	urtwn_write_1(sc, R92C_BCN_CTRL, reg);
2185290651Savos
2186290651Savos	/* Remove beacon filter. */
2187290651Savos	urtwn_set_rx_bssid_all(sc, 1);
2188290651Savos
2189290651Savos	/* Enable beaconing. */
2190290651Savos	urtwn_write_1(sc, R92C_MBID_NUM,
2191290651Savos	    urtwn_read_1(sc, R92C_MBID_NUM) | R92C_MBID_TXBCN_RPT0);
2192290651Savos	reg |= R92C_BCN_CTRL_EN_BCN;
2193290651Savos
2194290651Savos	urtwn_write_1(sc, R92C_BCN_CTRL, reg);
2195290651Savos	ieee80211_free_node(ni);
2196290651Savos	URTWN_UNLOCK(sc);
2197290651Savos}
2198290651Savos
2199290651Savosstatic void
2200290631Savosurtwn_tsf_sync_enable(struct urtwn_softc *sc, struct ieee80211vap *vap)
2201290631Savos{
2202290651Savos	struct ieee80211com *ic = &sc->sc_ic;
2203290651Savos	struct urtwn_vap *uvp = URTWN_VAP(vap);
2204290651Savos
2205290631Savos	/* Reset TSF. */
2206290631Savos	urtwn_write_1(sc, R92C_DUAL_TSF_RST, R92C_DUAL_TSF_RST0);
2207290631Savos
2208290631Savos	switch (vap->iv_opmode) {
2209290631Savos	case IEEE80211_M_STA:
2210290631Savos		/* Enable TSF synchronization. */
2211290631Savos		urtwn_write_1(sc, R92C_BCN_CTRL,
2212290631Savos		    urtwn_read_1(sc, R92C_BCN_CTRL) &
2213290631Savos		    ~R92C_BCN_CTRL_DIS_TSF_UDT0);
2214290631Savos		break;
2215290651Savos	case IEEE80211_M_IBSS:
2216290651Savos		ieee80211_runtask(ic, &uvp->tsf_task_adhoc);
2217290651Savos		break;
2218290631Savos	case IEEE80211_M_HOSTAP:
2219290631Savos		/* Enable beaconing. */
2220290631Savos		urtwn_write_1(sc, R92C_MBID_NUM,
2221290631Savos		    urtwn_read_1(sc, R92C_MBID_NUM) | R92C_MBID_TXBCN_RPT0);
2222290631Savos		urtwn_write_1(sc, R92C_BCN_CTRL,
2223290631Savos		    urtwn_read_1(sc, R92C_BCN_CTRL) | R92C_BCN_CTRL_EN_BCN);
2224290631Savos		break;
2225290631Savos	default:
2226290631Savos		device_printf(sc->sc_dev, "undefined opmode %d\n",
2227290631Savos		    vap->iv_opmode);
2228290631Savos		return;
2229290631Savos	}
2230290631Savos}
2231290631Savos
2232290631Savosstatic void
2233292203Savosurtwn_get_tsf(struct urtwn_softc *sc, uint64_t *buf)
2234292203Savos{
2235292203Savos	urtwn_read_region_1(sc, R92C_TSFTR, (uint8_t *)buf, sizeof(*buf));
2236292203Savos}
2237292203Savos
2238292203Savosstatic void
2239251538Srpaulourtwn_set_led(struct urtwn_softc *sc, int led, int on)
2240251538Srpaulo{
2241251538Srpaulo	uint8_t reg;
2242281069Srpaulo
2243251538Srpaulo	if (led == URTWN_LED_LINK) {
2244264912Skevlo		if (sc->chip & URTWN_CHIP_88E) {
2245264912Skevlo			reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0xf0;
2246264912Skevlo			urtwn_write_1(sc, R92C_LEDCFG2, reg | 0x60);
2247264912Skevlo			if (!on) {
2248264912Skevlo				reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0x90;
2249264912Skevlo				urtwn_write_1(sc, R92C_LEDCFG2,
2250264912Skevlo				    reg | R92C_LEDCFG0_DIS);
2251264912Skevlo				urtwn_write_1(sc, R92C_MAC_PINMUX_CFG,
2252264912Skevlo				    urtwn_read_1(sc, R92C_MAC_PINMUX_CFG) &
2253264912Skevlo				    0xfe);
2254264912Skevlo			}
2255264912Skevlo		} else {
2256264912Skevlo			reg = urtwn_read_1(sc, R92C_LEDCFG0) & 0x70;
2257264912Skevlo			if (!on)
2258264912Skevlo				reg |= R92C_LEDCFG0_DIS;
2259264912Skevlo			urtwn_write_1(sc, R92C_LEDCFG0, reg);
2260264912Skevlo		}
2261264912Skevlo		sc->ledlink = on;       /* Save LED state. */
2262251538Srpaulo	}
2263251538Srpaulo}
2264251538Srpaulo
2265289811Savosstatic void
2266289811Savosurtwn_set_mode(struct urtwn_softc *sc, uint8_t mode)
2267289811Savos{
2268289811Savos	uint8_t reg;
2269289811Savos
2270289811Savos	reg = urtwn_read_1(sc, R92C_MSR);
2271289811Savos	reg = (reg & ~R92C_MSR_MASK) | mode;
2272289811Savos	urtwn_write_1(sc, R92C_MSR, reg);
2273289811Savos}
2274289811Savos
2275290651Savosstatic void
2276290651Savosurtwn_ibss_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, int subtype,
2277290651Savos    const struct ieee80211_rx_stats *rxs,
2278290651Savos    int rssi, int nf)
2279290651Savos{
2280290651Savos	struct ieee80211vap *vap = ni->ni_vap;
2281290651Savos	struct urtwn_softc *sc = vap->iv_ic->ic_softc;
2282290651Savos	struct urtwn_vap *uvp = URTWN_VAP(vap);
2283290651Savos	uint64_t ni_tstamp, curr_tstamp;
2284290651Savos
2285290651Savos	uvp->recv_mgmt(ni, m, subtype, rxs, rssi, nf);
2286290651Savos
2287290651Savos	if (vap->iv_state == IEEE80211_S_RUN &&
2288290651Savos	    (subtype == IEEE80211_FC0_SUBTYPE_BEACON ||
2289290651Savos	    subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)) {
2290290651Savos		ni_tstamp = le64toh(ni->ni_tstamp.tsf);
2291290651Savos		URTWN_LOCK(sc);
2292290651Savos		urtwn_get_tsf(sc, &curr_tstamp);
2293290651Savos		URTWN_UNLOCK(sc);
2294290651Savos		curr_tstamp = le64toh(curr_tstamp);
2295290651Savos
2296290651Savos		if (ni_tstamp >= curr_tstamp)
2297290651Savos			(void) ieee80211_ibss_merge(ni);
2298290651Savos	}
2299290651Savos}
2300290651Savos
2301251538Srpaulostatic int
2302251538Srpaulourtwn_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
2303251538Srpaulo{
2304251538Srpaulo	struct urtwn_vap *uvp = URTWN_VAP(vap);
2305251538Srpaulo	struct ieee80211com *ic = vap->iv_ic;
2306286949Sadrian	struct urtwn_softc *sc = ic->ic_softc;
2307251538Srpaulo	struct ieee80211_node *ni;
2308251538Srpaulo	enum ieee80211_state ostate;
2309290631Savos	uint32_t reg;
2310290631Savos	uint8_t mode;
2311290631Savos	int error = 0;
2312251538Srpaulo
2313251538Srpaulo	ostate = vap->iv_state;
2314294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_STATE, "%s -> %s\n",
2315294471Savos	    ieee80211_state_name[ostate], ieee80211_state_name[nstate]);
2316251538Srpaulo
2317251538Srpaulo	IEEE80211_UNLOCK(ic);
2318251538Srpaulo	URTWN_LOCK(sc);
2319251538Srpaulo	callout_stop(&sc->sc_watchdog_ch);
2320251538Srpaulo
2321251538Srpaulo	if (ostate == IEEE80211_S_RUN) {
2322294473Savos		/* Stop calibration. */
2323294473Savos		callout_stop(&sc->sc_calib_to);
2324294473Savos
2325251538Srpaulo		/* Turn link LED off. */
2326251538Srpaulo		urtwn_set_led(sc, URTWN_LED_LINK, 0);
2327251538Srpaulo
2328251538Srpaulo		/* Set media status to 'No Link'. */
2329289811Savos		urtwn_set_mode(sc, R92C_MSR_NOLINK);
2330251538Srpaulo
2331251538Srpaulo		/* Stop Rx of data frames. */
2332251538Srpaulo		urtwn_write_2(sc, R92C_RXFLTMAP2, 0);
2333251538Srpaulo
2334251538Srpaulo		/* Disable TSF synchronization. */
2335251538Srpaulo		urtwn_write_1(sc, R92C_BCN_CTRL,
2336290631Savos		    (urtwn_read_1(sc, R92C_BCN_CTRL) & ~R92C_BCN_CTRL_EN_BCN) |
2337251538Srpaulo		    R92C_BCN_CTRL_DIS_TSF_UDT0);
2338251538Srpaulo
2339290631Savos		/* Disable beaconing. */
2340290631Savos		urtwn_write_1(sc, R92C_MBID_NUM,
2341290631Savos		    urtwn_read_1(sc, R92C_MBID_NUM) & ~R92C_MBID_TXBCN_RPT0);
2342290631Savos
2343290631Savos		/* Reset TSF. */
2344290631Savos		urtwn_write_1(sc, R92C_DUAL_TSF_RST, R92C_DUAL_TSF_RST0);
2345290631Savos
2346251538Srpaulo		/* Reset EDCA parameters. */
2347251538Srpaulo		urtwn_write_4(sc, R92C_EDCA_VO_PARAM, 0x002f3217);
2348251538Srpaulo		urtwn_write_4(sc, R92C_EDCA_VI_PARAM, 0x005e4317);
2349251538Srpaulo		urtwn_write_4(sc, R92C_EDCA_BE_PARAM, 0x00105320);
2350251538Srpaulo		urtwn_write_4(sc, R92C_EDCA_BK_PARAM, 0x0000a444);
2351251538Srpaulo	}
2352251538Srpaulo
2353251538Srpaulo	switch (nstate) {
2354251538Srpaulo	case IEEE80211_S_INIT:
2355251538Srpaulo		/* Turn link LED off. */
2356251538Srpaulo		urtwn_set_led(sc, URTWN_LED_LINK, 0);
2357251538Srpaulo		break;
2358251538Srpaulo	case IEEE80211_S_SCAN:
2359251538Srpaulo		/* Pause AC Tx queues. */
2360251538Srpaulo		urtwn_write_1(sc, R92C_TXPAUSE,
2361293180Savos		    urtwn_read_1(sc, R92C_TXPAUSE) | R92C_TX_QUEUE_AC);
2362251538Srpaulo		break;
2363251538Srpaulo	case IEEE80211_S_AUTH:
2364251538Srpaulo		urtwn_set_chan(sc, ic->ic_curchan, NULL);
2365251538Srpaulo		break;
2366251538Srpaulo	case IEEE80211_S_RUN:
2367251538Srpaulo		if (vap->iv_opmode == IEEE80211_M_MONITOR) {
2368251538Srpaulo			/* Turn link LED on. */
2369251538Srpaulo			urtwn_set_led(sc, URTWN_LED_LINK, 1);
2370251538Srpaulo			break;
2371251538Srpaulo		}
2372251538Srpaulo
2373251538Srpaulo		ni = ieee80211_ref_node(vap->iv_bss);
2374290631Savos
2375290631Savos		if (ic->ic_bsschan == IEEE80211_CHAN_ANYC ||
2376290631Savos		    ni->ni_chan == IEEE80211_CHAN_ANYC) {
2377290631Savos			device_printf(sc->sc_dev,
2378290631Savos			    "%s: could not move to RUN state\n", __func__);
2379290631Savos			error = EINVAL;
2380290631Savos			goto end_run;
2381290631Savos		}
2382290631Savos
2383290631Savos		switch (vap->iv_opmode) {
2384290631Savos		case IEEE80211_M_STA:
2385290631Savos			mode = R92C_MSR_INFRA;
2386290631Savos			break;
2387290651Savos		case IEEE80211_M_IBSS:
2388290651Savos			mode = R92C_MSR_ADHOC;
2389290651Savos			break;
2390290631Savos		case IEEE80211_M_HOSTAP:
2391290631Savos			mode = R92C_MSR_AP;
2392290631Savos			break;
2393290631Savos		default:
2394290631Savos			device_printf(sc->sc_dev, "undefined opmode %d\n",
2395290631Savos			    vap->iv_opmode);
2396290631Savos			error = EINVAL;
2397290631Savos			goto end_run;
2398290631Savos		}
2399290631Savos
2400251538Srpaulo		/* Set media status to 'Associated'. */
2401290631Savos		urtwn_set_mode(sc, mode);
2402251538Srpaulo
2403251538Srpaulo		/* Set BSSID. */
2404251538Srpaulo		urtwn_write_4(sc, R92C_BSSID + 0, LE_READ_4(&ni->ni_bssid[0]));
2405251538Srpaulo		urtwn_write_4(sc, R92C_BSSID + 4, LE_READ_2(&ni->ni_bssid[4]));
2406251538Srpaulo
2407251538Srpaulo		if (ic->ic_curmode == IEEE80211_MODE_11B)
2408251538Srpaulo			urtwn_write_1(sc, R92C_INIRTS_RATE_SEL, 0);
2409251538Srpaulo		else	/* 802.11b/g */
2410251538Srpaulo			urtwn_write_1(sc, R92C_INIRTS_RATE_SEL, 3);
2411251538Srpaulo
2412251538Srpaulo		/* Enable Rx of data frames. */
2413251538Srpaulo		urtwn_write_2(sc, R92C_RXFLTMAP2, 0xffff);
2414251538Srpaulo
2415251538Srpaulo		/* Flush all AC queues. */
2416251538Srpaulo		urtwn_write_1(sc, R92C_TXPAUSE, 0);
2417251538Srpaulo
2418251538Srpaulo		/* Set beacon interval. */
2419251538Srpaulo		urtwn_write_2(sc, R92C_BCN_INTERVAL, ni->ni_intval);
2420251538Srpaulo
2421251538Srpaulo		/* Allow Rx from our BSSID only. */
2422290564Savos		if (ic->ic_promisc == 0) {
2423290631Savos			reg = urtwn_read_4(sc, R92C_RCR);
2424290631Savos
2425290631Savos			if (vap->iv_opmode != IEEE80211_M_HOSTAP)
2426290631Savos				reg |= R92C_RCR_CBSSID_DATA;
2427290651Savos			if (vap->iv_opmode != IEEE80211_M_IBSS)
2428290651Savos				reg |= R92C_RCR_CBSSID_BCN;
2429290631Savos
2430290631Savos			urtwn_write_4(sc, R92C_RCR, reg);
2431290564Savos		}
2432251538Srpaulo
2433290651Savos		if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
2434290651Savos		    vap->iv_opmode == IEEE80211_M_IBSS) {
2435290631Savos			error = urtwn_setup_beacon(sc, ni);
2436290631Savos			if (error != 0) {
2437290631Savos				device_printf(sc->sc_dev,
2438290631Savos				    "unable to push beacon into the chip, "
2439290631Savos				    "error %d\n", error);
2440290631Savos				goto end_run;
2441290631Savos			}
2442290631Savos		}
2443290631Savos
2444251538Srpaulo		/* Enable TSF synchronization. */
2445290631Savos		urtwn_tsf_sync_enable(sc, vap);
2446251538Srpaulo
2447251538Srpaulo		urtwn_write_1(sc, R92C_SIFS_CCK + 1, 10);
2448251538Srpaulo		urtwn_write_1(sc, R92C_SIFS_OFDM + 1, 10);
2449251538Srpaulo		urtwn_write_1(sc, R92C_SPEC_SIFS + 1, 10);
2450251538Srpaulo		urtwn_write_1(sc, R92C_MAC_SPEC_SIFS + 1, 10);
2451251538Srpaulo		urtwn_write_1(sc, R92C_R2T_SIFS + 1, 10);
2452251538Srpaulo		urtwn_write_1(sc, R92C_T2T_SIFS + 1, 10);
2453251538Srpaulo
2454251538Srpaulo		/* Intialize rate adaptation. */
2455292167Savos		if (!(sc->chip & URTWN_CHIP_88E))
2456264912Skevlo			urtwn_ra_init(sc);
2457251538Srpaulo		/* Turn link LED on. */
2458251538Srpaulo		urtwn_set_led(sc, URTWN_LED_LINK, 1);
2459251538Srpaulo
2460251538Srpaulo		sc->avg_pwdb = -1;	/* Reset average RSSI. */
2461251538Srpaulo		/* Reset temperature calibration state machine. */
2462294473Savos		sc->sc_flags &= ~URTWN_TEMP_MEASURED;
2463251538Srpaulo		sc->thcal_lctemp = 0;
2464294473Savos		/* Start periodic calibration. */
2465294473Savos		callout_reset(&sc->sc_calib_to, 2*hz, urtwn_calib_to, sc);
2466290631Savos
2467290631Savosend_run:
2468251538Srpaulo		ieee80211_free_node(ni);
2469251538Srpaulo		break;
2470251538Srpaulo	default:
2471251538Srpaulo		break;
2472251538Srpaulo	}
2473290631Savos
2474251538Srpaulo	URTWN_UNLOCK(sc);
2475251538Srpaulo	IEEE80211_LOCK(ic);
2476290631Savos	return (error != 0 ? error : uvp->newstate(vap, nstate, arg));
2477251538Srpaulo}
2478251538Srpaulo
2479251538Srpaulostatic void
2480294473Savosurtwn_calib_to(void *arg)
2481294473Savos{
2482294473Savos	struct urtwn_softc *sc = arg;
2483294473Savos
2484294473Savos	/* Do it in a process context. */
2485294473Savos	urtwn_cmd_sleepable(sc, NULL, 0, urtwn_calib_cb);
2486294473Savos}
2487294473Savos
2488294473Savosstatic void
2489294473Savosurtwn_calib_cb(struct urtwn_softc *sc, union sec_param *data)
2490294473Savos{
2491294473Savos	/* Do temperature compensation. */
2492294473Savos	urtwn_temp_calib(sc);
2493294473Savos
2494294473Savos	if ((urtwn_read_1(sc, R92C_MSR) & R92C_MSR_MASK) != R92C_MSR_NOLINK)
2495294473Savos		callout_reset(&sc->sc_calib_to, 2*hz, urtwn_calib_to, sc);
2496294473Savos}
2497294473Savos
2498294473Savosstatic void
2499251538Srpaulourtwn_watchdog(void *arg)
2500251538Srpaulo{
2501251538Srpaulo	struct urtwn_softc *sc = arg;
2502251538Srpaulo
2503251538Srpaulo	if (sc->sc_txtimer > 0) {
2504251538Srpaulo		if (--sc->sc_txtimer == 0) {
2505251538Srpaulo			device_printf(sc->sc_dev, "device timeout\n");
2506287197Sglebius			counter_u64_add(sc->sc_ic.ic_oerrors, 1);
2507251538Srpaulo			return;
2508251538Srpaulo		}
2509251538Srpaulo		callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc);
2510251538Srpaulo	}
2511251538Srpaulo}
2512251538Srpaulo
2513251538Srpaulostatic void
2514251538Srpaulourtwn_update_avgrssi(struct urtwn_softc *sc, int rate, int8_t rssi)
2515251538Srpaulo{
2516251538Srpaulo	int pwdb;
2517251538Srpaulo
2518251538Srpaulo	/* Convert antenna signal to percentage. */
2519251538Srpaulo	if (rssi <= -100 || rssi >= 20)
2520251538Srpaulo		pwdb = 0;
2521251538Srpaulo	else if (rssi >= 0)
2522251538Srpaulo		pwdb = 100;
2523251538Srpaulo	else
2524251538Srpaulo		pwdb = 100 + rssi;
2525264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E)) {
2526289758Savos		if (rate <= URTWN_RIDX_CCK11) {
2527264912Skevlo			/* CCK gain is smaller than OFDM/MCS gain. */
2528264912Skevlo			pwdb += 6;
2529264912Skevlo			if (pwdb > 100)
2530264912Skevlo				pwdb = 100;
2531264912Skevlo			if (pwdb <= 14)
2532264912Skevlo				pwdb -= 4;
2533264912Skevlo			else if (pwdb <= 26)
2534264912Skevlo				pwdb -= 8;
2535264912Skevlo			else if (pwdb <= 34)
2536264912Skevlo				pwdb -= 6;
2537264912Skevlo			else if (pwdb <= 42)
2538264912Skevlo				pwdb -= 2;
2539264912Skevlo		}
2540251538Srpaulo	}
2541251538Srpaulo	if (sc->avg_pwdb == -1)	/* Init. */
2542251538Srpaulo		sc->avg_pwdb = pwdb;
2543251538Srpaulo	else if (sc->avg_pwdb < pwdb)
2544251538Srpaulo		sc->avg_pwdb = ((sc->avg_pwdb * 19 + pwdb) / 20) + 1;
2545251538Srpaulo	else
2546251538Srpaulo		sc->avg_pwdb = ((sc->avg_pwdb * 19 + pwdb) / 20);
2547294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_RA, "%s: PWDB %d, EMA %d\n", __func__,
2548294471Savos	    pwdb, sc->avg_pwdb);
2549251538Srpaulo}
2550251538Srpaulo
2551251538Srpaulostatic int8_t
2552251538Srpaulourtwn_get_rssi(struct urtwn_softc *sc, int rate, void *physt)
2553251538Srpaulo{
2554251538Srpaulo	static const int8_t cckoff[] = { 16, -12, -26, -46 };
2555251538Srpaulo	struct r92c_rx_phystat *phy;
2556251538Srpaulo	struct r92c_rx_cck *cck;
2557251538Srpaulo	uint8_t rpt;
2558251538Srpaulo	int8_t rssi;
2559251538Srpaulo
2560289758Savos	if (rate <= URTWN_RIDX_CCK11) {
2561251538Srpaulo		cck = (struct r92c_rx_cck *)physt;
2562251538Srpaulo		if (sc->sc_flags & URTWN_FLAG_CCK_HIPWR) {
2563251538Srpaulo			rpt = (cck->agc_rpt >> 5) & 0x3;
2564251538Srpaulo			rssi = (cck->agc_rpt & 0x1f) << 1;
2565251538Srpaulo		} else {
2566251538Srpaulo			rpt = (cck->agc_rpt >> 6) & 0x3;
2567251538Srpaulo			rssi = cck->agc_rpt & 0x3e;
2568251538Srpaulo		}
2569251538Srpaulo		rssi = cckoff[rpt] - rssi;
2570251538Srpaulo	} else {	/* OFDM/HT. */
2571251538Srpaulo		phy = (struct r92c_rx_phystat *)physt;
2572251538Srpaulo		rssi = ((le32toh(phy->phydw1) >> 1) & 0x7f) - 110;
2573251538Srpaulo	}
2574251538Srpaulo	return (rssi);
2575251538Srpaulo}
2576251538Srpaulo
2577264912Skevlostatic int8_t
2578264912Skevlourtwn_r88e_get_rssi(struct urtwn_softc *sc, int rate, void *physt)
2579264912Skevlo{
2580264912Skevlo	struct r92c_rx_phystat *phy;
2581264912Skevlo	struct r88e_rx_cck *cck;
2582264912Skevlo	uint8_t cck_agc_rpt, lna_idx, vga_idx;
2583264912Skevlo	int8_t rssi;
2584264912Skevlo
2585264972Skevlo	rssi = 0;
2586289758Savos	if (rate <= URTWN_RIDX_CCK11) {
2587264912Skevlo		cck = (struct r88e_rx_cck *)physt;
2588264912Skevlo		cck_agc_rpt = cck->agc_rpt;
2589264912Skevlo		lna_idx = (cck_agc_rpt & 0xe0) >> 5;
2590281069Srpaulo		vga_idx = cck_agc_rpt & 0x1f;
2591264912Skevlo		switch (lna_idx) {
2592264912Skevlo		case 7:
2593264912Skevlo			if (vga_idx <= 27)
2594264912Skevlo				rssi = -100 + 2* (27 - vga_idx);
2595264912Skevlo			else
2596264912Skevlo				rssi = -100;
2597264912Skevlo			break;
2598264912Skevlo		case 6:
2599264912Skevlo			rssi = -48 + 2 * (2 - vga_idx);
2600264912Skevlo			break;
2601264912Skevlo		case 5:
2602264912Skevlo			rssi = -42 + 2 * (7 - vga_idx);
2603264912Skevlo			break;
2604264912Skevlo		case 4:
2605264912Skevlo			rssi = -36 + 2 * (7 - vga_idx);
2606264912Skevlo			break;
2607264912Skevlo		case 3:
2608264912Skevlo			rssi = -24 + 2 * (7 - vga_idx);
2609264912Skevlo			break;
2610264912Skevlo		case 2:
2611264912Skevlo			rssi = -12 + 2 * (5 - vga_idx);
2612264912Skevlo			break;
2613264912Skevlo		case 1:
2614264912Skevlo			rssi = 8 - (2 * vga_idx);
2615264912Skevlo			break;
2616264912Skevlo		case 0:
2617264912Skevlo			rssi = 14 - (2 * vga_idx);
2618264912Skevlo			break;
2619264912Skevlo		}
2620264912Skevlo		rssi += 6;
2621264912Skevlo	} else {	/* OFDM/HT. */
2622264912Skevlo		phy = (struct r92c_rx_phystat *)physt;
2623264912Skevlo		rssi = ((le32toh(phy->phydw1) >> 1) & 0x7f) - 110;
2624264912Skevlo	}
2625264912Skevlo	return (rssi);
2626264912Skevlo}
2627264912Skevlo
2628292167Savosstatic __inline uint8_t
2629292167Savosrate2ridx(uint8_t rate)
2630292167Savos{
2631292167Savos	switch (rate) {
2632292167Savos	case 12:	return 4;
2633292167Savos	case 18:	return 5;
2634292167Savos	case 24:	return 6;
2635292167Savos	case 36:	return 7;
2636292167Savos	case 48:	return 8;
2637292167Savos	case 72:	return 9;
2638292167Savos	case 96:	return 10;
2639292167Savos	case 108:	return 11;
2640292167Savos	case 2:		return 0;
2641292167Savos	case 4:		return 1;
2642292167Savos	case 11:	return 2;
2643292167Savos	case 22:	return 3;
2644292167Savos	default:	return 0;
2645292167Savos	}
2646292167Savos}
2647292167Savos
2648251538Srpaulostatic int
2649290630Savosurtwn_tx_data(struct urtwn_softc *sc, struct ieee80211_node *ni,
2650290630Savos    struct mbuf *m, struct urtwn_data *data)
2651251538Srpaulo{
2652292167Savos	const struct ieee80211_txparam *tp;
2653287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
2654251538Srpaulo	struct ieee80211vap *vap = ni->ni_vap;
2655292167Savos	struct ieee80211_key *k = NULL;
2656292167Savos	struct ieee80211_channel *chan;
2657292167Savos	struct ieee80211_frame *wh;
2658251538Srpaulo	struct r92c_tx_desc *txd;
2659292167Savos	uint8_t macid, raid, rate, ridx, subtype, type, tid, qsel;
2660292014Savos	int hasqos, ismcast;
2661251538Srpaulo
2662251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
2663251538Srpaulo
2664251538Srpaulo	/*
2665251538Srpaulo	 * Software crypto.
2666251538Srpaulo	 */
2667290630Savos	wh = mtod(m, struct ieee80211_frame *);
2668264912Skevlo	type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
2669290630Savos	subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
2670292014Savos	hasqos = IEEE80211_QOS_HAS_SEQ(wh);
2671290630Savos	ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1);
2672264912Skevlo
2673292014Savos	/* Select TX ring for this frame. */
2674292014Savos	if (hasqos) {
2675292014Savos		tid = ((const struct ieee80211_qosframe *)wh)->i_qos[0];
2676292014Savos		tid &= IEEE80211_QOS_TID;
2677292014Savos	} else
2678292014Savos		tid = 0;
2679292014Savos
2680292167Savos	chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ?
2681292167Savos		ni->ni_chan : ic->ic_curchan;
2682292167Savos	tp = &vap->iv_txparms[ieee80211_chan2mode(chan)];
2683292167Savos
2684292167Savos	/* Choose a TX rate index. */
2685292167Savos	if (type == IEEE80211_FC0_TYPE_MGT)
2686292167Savos		rate = tp->mgmtrate;
2687292167Savos	else if (ismcast)
2688292167Savos		rate = tp->mcastrate;
2689292167Savos	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
2690292167Savos		rate = tp->ucastrate;
2691292167Savos	else if (m->m_flags & M_EAPOL)
2692292167Savos		rate = tp->mgmtrate;
2693292167Savos	else {
2694292167Savos		if (URTWN_CHIP_HAS_RATECTL(sc)) {
2695292167Savos			/* XXX pass pktlen */
2696292167Savos			(void) ieee80211_ratectl_rate(ni, NULL, 0);
2697292167Savos			rate = ni->ni_txrate;
2698292167Savos		} else {
2699292167Savos			if (ic->ic_curmode != IEEE80211_MODE_11B)
2700292167Savos				rate = 108;
2701292167Savos			else
2702292167Savos				rate = 22;
2703292167Savos		}
2704292167Savos	}
2705292167Savos
2706292167Savos	ridx = rate2ridx(rate);
2707292167Savos	if (ic->ic_curmode != IEEE80211_MODE_11B)
2708292167Savos		raid = R92C_RAID_11BG;
2709292167Savos	else
2710292167Savos		raid = R92C_RAID_11B;
2711292167Savos
2712260444Skevlo	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
2713290630Savos		k = ieee80211_crypto_encap(ni, m);
2714251538Srpaulo		if (k == NULL) {
2715251538Srpaulo			device_printf(sc->sc_dev,
2716251538Srpaulo			    "ieee80211_crypto_encap returns NULL.\n");
2717251538Srpaulo			return (ENOBUFS);
2718251538Srpaulo		}
2719251538Srpaulo
2720251538Srpaulo		/* in case packet header moved, reset pointer */
2721290630Savos		wh = mtod(m, struct ieee80211_frame *);
2722251538Srpaulo	}
2723281069Srpaulo
2724251538Srpaulo	/* Fill Tx descriptor. */
2725251538Srpaulo	txd = (struct r92c_tx_desc *)data->buf;
2726251538Srpaulo	memset(txd, 0, sizeof(*txd));
2727251538Srpaulo
2728251538Srpaulo	txd->txdw0 |= htole32(
2729251538Srpaulo	    SM(R92C_TXDW0_OFFSET, sizeof(*txd)) |
2730251538Srpaulo	    R92C_TXDW0_OWN | R92C_TXDW0_FSG | R92C_TXDW0_LSG);
2731290630Savos	if (ismcast)
2732251538Srpaulo		txd->txdw0 |= htole32(R92C_TXDW0_BMCAST);
2733290630Savos
2734290630Savos	if (!ismcast) {
2735292167Savos		if (sc->chip & URTWN_CHIP_88E) {
2736292167Savos			struct urtwn_node *un = URTWN_NODE(ni);
2737292167Savos			macid = un->id;
2738292167Savos		} else
2739292167Savos			macid = URTWN_MACID_BSS;
2740290630Savos
2741290630Savos		if (type == IEEE80211_FC0_TYPE_DATA) {
2742292014Savos			qsel = tid % URTWN_MAX_TID;
2743290630Savos
2744292167Savos			if (sc->chip & URTWN_CHIP_88E) {
2745292167Savos				txd->txdw2 |= htole32(
2746292167Savos				    R88E_TXDW2_AGGBK |
2747292167Savos				    R88E_TXDW2_CCX_RPT);
2748292167Savos			} else
2749290630Savos				txd->txdw1 |= htole32(R92C_TXDW1_AGGBK);
2750290630Savos
2751290630Savos			if (ic->ic_flags & IEEE80211_F_USEPROT) {
2752290630Savos				switch (ic->ic_protmode) {
2753290630Savos				case IEEE80211_PROT_CTSONLY:
2754290630Savos					txd->txdw4 |= htole32(
2755290630Savos					    R92C_TXDW4_CTS2SELF |
2756290630Savos					    R92C_TXDW4_HWRTSEN);
2757290630Savos					break;
2758290630Savos				case IEEE80211_PROT_RTSCTS:
2759290630Savos					txd->txdw4 |= htole32(
2760290630Savos					    R92C_TXDW4_RTSEN |
2761290630Savos					    R92C_TXDW4_HWRTSEN);
2762290630Savos					break;
2763290630Savos				default:
2764290630Savos					break;
2765290630Savos				}
2766290630Savos			}
2767290630Savos			txd->txdw4 |= htole32(SM(R92C_TXDW4_RTSRATE,
2768290630Savos			    URTWN_RIDX_OFDM24));
2769290630Savos			txd->txdw5 |= htole32(0x0001ff00);
2770290630Savos		} else	/* IEEE80211_FC0_TYPE_MGT */
2771290630Savos			qsel = R92C_TXDW1_QSEL_MGNT;
2772251538Srpaulo	} else {
2773290630Savos		macid = URTWN_MACID_BC;
2774290630Savos		qsel = R92C_TXDW1_QSEL_MGNT;
2775290630Savos	}
2776251538Srpaulo
2777290630Savos	txd->txdw1 |= htole32(
2778290630Savos	    SM(R92C_TXDW1_QSEL, qsel) |
2779290630Savos	    SM(R92C_TXDW1_RAID, raid));
2780290630Savos
2781290630Savos	if (sc->chip & URTWN_CHIP_88E)
2782290630Savos		txd->txdw1 |= htole32(SM(R88E_TXDW1_MACID, macid));
2783290630Savos	else
2784290630Savos		txd->txdw1 |= htole32(SM(R92C_TXDW1_MACID, macid));
2785290630Savos
2786290630Savos	txd->txdw5 |= htole32(SM(R92C_TXDW5_DATARATE, ridx));
2787291858Savos	/* Force this rate if needed. */
2788292167Savos	if (URTWN_CHIP_HAS_RATECTL(sc) || ismcast ||
2789292167Savos	    (m->m_flags & M_EAPOL) || type != IEEE80211_FC0_TYPE_DATA)
2790251538Srpaulo		txd->txdw4 |= htole32(R92C_TXDW4_DRVRATE);
2791251538Srpaulo
2792292014Savos	if (!hasqos) {
2793251538Srpaulo		/* Use HW sequence numbering for non-QoS frames. */
2794291858Savos		if (sc->chip & URTWN_CHIP_88E)
2795291858Savos			txd->txdseq = htole16(R88E_TXDSEQ_HWSEQ_EN);
2796291858Savos		else
2797291858Savos			txd->txdw4 |= htole32(R92C_TXDW4_HWSEQ_EN);
2798290630Savos	} else {
2799290630Savos		/* Set sequence number. */
2800290630Savos		txd->txdseq = htole16(M_SEQNO_GET(m) % IEEE80211_SEQ_RANGE);
2801290630Savos	}
2802251538Srpaulo
2803292175Savos	if (k != NULL && !(k->wk_flags & IEEE80211_KEY_SWCRYPT)) {
2804292175Savos		uint8_t cipher;
2805292175Savos
2806292175Savos		switch (k->wk_cipher->ic_cipher) {
2807292175Savos		case IEEE80211_CIPHER_WEP:
2808292175Savos		case IEEE80211_CIPHER_TKIP:
2809292175Savos			cipher = R92C_TXDW1_CIPHER_RC4;
2810292175Savos			break;
2811292175Savos		case IEEE80211_CIPHER_AES_CCM:
2812292175Savos			cipher = R92C_TXDW1_CIPHER_AES;
2813292175Savos			break;
2814292175Savos		default:
2815292175Savos			device_printf(sc->sc_dev, "%s: unknown cipher %d\n",
2816292175Savos			    __func__, k->wk_cipher->ic_cipher);
2817292175Savos			return (EINVAL);
2818292175Savos		}
2819292175Savos
2820292175Savos		txd->txdw1 |= htole32(SM(R92C_TXDW1_CIPHER, cipher));
2821292175Savos	}
2822292175Savos
2823251538Srpaulo	if (ieee80211_radiotap_active_vap(vap)) {
2824251538Srpaulo		struct urtwn_tx_radiotap_header *tap = &sc->sc_txtap;
2825251538Srpaulo
2826251538Srpaulo		tap->wt_flags = 0;
2827290630Savos		if (k != NULL)
2828290630Savos			tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
2829290630Savos		ieee80211_radiotap_tx(vap, m);
2830251538Srpaulo	}
2831251538Srpaulo
2832290630Savos	data->ni = ni;
2833251538Srpaulo
2834290630Savos	urtwn_tx_start(sc, m, type, data);
2835290630Savos
2836290630Savos	return (0);
2837290630Savos}
2838290630Savos
2839292221Savosstatic int
2840292221Savosurtwn_tx_raw(struct urtwn_softc *sc, struct ieee80211_node *ni,
2841292221Savos    struct mbuf *m, struct urtwn_data *data,
2842292221Savos    const struct ieee80211_bpf_params *params)
2843292221Savos{
2844292221Savos	struct ieee80211vap *vap = ni->ni_vap;
2845292221Savos	struct ieee80211_key *k = NULL;
2846292221Savos	struct ieee80211_frame *wh;
2847292221Savos	struct r92c_tx_desc *txd;
2848292221Savos	uint8_t cipher, ridx, type;
2849292221Savos
2850292221Savos	/* Encrypt the frame if need be. */
2851292221Savos	cipher = R92C_TXDW1_CIPHER_NONE;
2852292221Savos	if (params->ibp_flags & IEEE80211_BPF_CRYPTO) {
2853292221Savos		/* Retrieve key for TX. */
2854292221Savos		k = ieee80211_crypto_encap(ni, m);
2855292221Savos		if (k == NULL)
2856292221Savos			return (ENOBUFS);
2857292221Savos
2858292221Savos		if (!(k->wk_flags & IEEE80211_KEY_SWCRYPT)) {
2859292221Savos			switch (k->wk_cipher->ic_cipher) {
2860292221Savos			case IEEE80211_CIPHER_WEP:
2861292221Savos			case IEEE80211_CIPHER_TKIP:
2862292221Savos				cipher = R92C_TXDW1_CIPHER_RC4;
2863292221Savos				break;
2864292221Savos			case IEEE80211_CIPHER_AES_CCM:
2865292221Savos				cipher = R92C_TXDW1_CIPHER_AES;
2866292221Savos				break;
2867292221Savos			default:
2868292221Savos				device_printf(sc->sc_dev,
2869292221Savos				    "%s: unknown cipher %d\n",
2870292221Savos				    __func__, k->wk_cipher->ic_cipher);
2871292221Savos				return (EINVAL);
2872292221Savos			}
2873292221Savos		}
2874292221Savos	}
2875292221Savos
2876292221Savos	wh = mtod(m, struct ieee80211_frame *);
2877292221Savos	type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
2878292221Savos
2879292221Savos	/* Fill Tx descriptor. */
2880292221Savos	txd = (struct r92c_tx_desc *)data->buf;
2881292221Savos	memset(txd, 0, sizeof(*txd));
2882292221Savos
2883292221Savos	txd->txdw0 |= htole32(
2884292221Savos	    SM(R92C_TXDW0_OFFSET, sizeof(*txd)) |
2885292221Savos	    R92C_TXDW0_OWN | R92C_TXDW0_FSG | R92C_TXDW0_LSG);
2886292221Savos	if (IEEE80211_IS_MULTICAST(wh->i_addr1))
2887292221Savos		txd->txdw0 |= htole32(R92C_TXDW0_BMCAST);
2888292221Savos
2889292221Savos	if (params->ibp_flags & IEEE80211_BPF_RTS)
2890292221Savos		txd->txdw4 |= htole32(R92C_TXDW4_RTSEN);
2891292221Savos	if (params->ibp_flags & IEEE80211_BPF_CTS)
2892292221Savos		txd->txdw4 |= htole32(R92C_TXDW4_CTS2SELF);
2893292221Savos	if (txd->txdw4 & htole32(R92C_TXDW4_RTSEN | R92C_TXDW4_CTS2SELF)) {
2894292221Savos		txd->txdw4 |= htole32(R92C_TXDW4_HWRTSEN);
2895292221Savos		txd->txdw4 |= htole32(SM(R92C_TXDW4_RTSRATE,
2896292221Savos		    URTWN_RIDX_OFDM24));
2897292221Savos	}
2898292221Savos
2899292221Savos	if (sc->chip & URTWN_CHIP_88E)
2900292221Savos		txd->txdw1 |= htole32(SM(R88E_TXDW1_MACID, URTWN_MACID_BC));
2901292221Savos	else
2902292221Savos		txd->txdw1 |= htole32(SM(R92C_TXDW1_MACID, URTWN_MACID_BC));
2903292221Savos
2904292221Savos	txd->txdw1 |= htole32(SM(R92C_TXDW1_QSEL, R92C_TXDW1_QSEL_MGNT));
2905292221Savos	txd->txdw1 |= htole32(SM(R92C_TXDW1_CIPHER, cipher));
2906292221Savos
2907292221Savos	/* Choose a TX rate index. */
2908292221Savos	ridx = rate2ridx(params->ibp_rate0);
2909292221Savos	txd->txdw5 |= htole32(SM(R92C_TXDW5_DATARATE, ridx));
2910292221Savos	txd->txdw5 |= htole32(0x0001ff00);
2911292221Savos	txd->txdw4 |= htole32(R92C_TXDW4_DRVRATE);
2912292221Savos
2913292221Savos	if (!IEEE80211_QOS_HAS_SEQ(wh)) {
2914292221Savos		/* Use HW sequence numbering for non-QoS frames. */
2915292221Savos		if (sc->chip & URTWN_CHIP_88E)
2916292221Savos			txd->txdseq = htole16(R88E_TXDSEQ_HWSEQ_EN);
2917292221Savos		else
2918292221Savos			txd->txdw4 |= htole32(R92C_TXDW4_HWSEQ_EN);
2919292221Savos	} else {
2920292221Savos		/* Set sequence number. */
2921292221Savos		txd->txdseq = htole16(M_SEQNO_GET(m) % IEEE80211_SEQ_RANGE);
2922292221Savos	}
2923292221Savos
2924292221Savos	if (ieee80211_radiotap_active_vap(vap)) {
2925292221Savos		struct urtwn_tx_radiotap_header *tap = &sc->sc_txtap;
2926292221Savos
2927292221Savos		tap->wt_flags = 0;
2928292221Savos		if (k != NULL)
2929292221Savos			tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP;
2930292221Savos		ieee80211_radiotap_tx(vap, m);
2931292221Savos	}
2932292221Savos
2933292221Savos	data->ni = ni;
2934292221Savos
2935292221Savos	urtwn_tx_start(sc, m, type, data);
2936292221Savos
2937292221Savos	return (0);
2938292221Savos}
2939292221Savos
2940290630Savosstatic void
2941290630Savosurtwn_tx_start(struct urtwn_softc *sc, struct mbuf *m, uint8_t type,
2942290630Savos    struct urtwn_data *data)
2943290630Savos{
2944290630Savos	struct usb_xfer *xfer;
2945290630Savos	struct r92c_tx_desc *txd;
2946290630Savos	uint16_t ac, sum;
2947290630Savos	int i, xferlen;
2948290630Savos
2949290630Savos	URTWN_ASSERT_LOCKED(sc);
2950290630Savos
2951290630Savos	ac = M_WME_GETAC(m);
2952290630Savos
2953290630Savos	switch (type) {
2954290630Savos	case IEEE80211_FC0_TYPE_CTL:
2955290630Savos	case IEEE80211_FC0_TYPE_MGT:
2956290630Savos		xfer = sc->sc_xfer[URTWN_BULK_TX_VO];
2957290630Savos		break;
2958290630Savos	default:
2959292014Savos		xfer = sc->sc_xfer[wme2queue[ac].qid];
2960290630Savos		break;
2961290630Savos	}
2962290630Savos
2963290630Savos	txd = (struct r92c_tx_desc *)data->buf;
2964290630Savos	txd->txdw0 |= htole32(SM(R92C_TXDW0_PKTLEN, m->m_pkthdr.len));
2965290630Savos
2966290630Savos	/* Compute Tx descriptor checksum. */
2967290630Savos	sum = 0;
2968290630Savos	for (i = 0; i < sizeof(*txd) / 2; i++)
2969290630Savos		sum ^= ((uint16_t *)txd)[i];
2970290630Savos	txd->txdsum = sum;	/* NB: already little endian. */
2971290630Savos
2972290630Savos	xferlen = sizeof(*txd) + m->m_pkthdr.len;
2973290630Savos	m_copydata(m, 0, m->m_pkthdr.len, (caddr_t)&txd[1]);
2974290630Savos
2975251538Srpaulo	data->buflen = xferlen;
2976290630Savos	data->m = m;
2977251538Srpaulo
2978251538Srpaulo	STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next);
2979251538Srpaulo	usbd_transfer_start(xfer);
2980251538Srpaulo}
2981251538Srpaulo
2982287197Sglebiusstatic int
2983287197Sglebiusurtwn_transmit(struct ieee80211com *ic, struct mbuf *m)
2984251538Srpaulo{
2985287197Sglebius	struct urtwn_softc *sc = ic->ic_softc;
2986287197Sglebius	int error;
2987261863Srpaulo
2988261863Srpaulo	URTWN_LOCK(sc);
2989287197Sglebius	if ((sc->sc_flags & URTWN_RUNNING) == 0) {
2990287197Sglebius		URTWN_UNLOCK(sc);
2991287197Sglebius		return (ENXIO);
2992287197Sglebius	}
2993287197Sglebius	error = mbufq_enqueue(&sc->sc_snd, m);
2994287197Sglebius	if (error) {
2995287197Sglebius		URTWN_UNLOCK(sc);
2996287197Sglebius		return (error);
2997287197Sglebius	}
2998287197Sglebius	urtwn_start(sc);
2999261863Srpaulo	URTWN_UNLOCK(sc);
3000287197Sglebius
3001287197Sglebius	return (0);
3002261863Srpaulo}
3003261863Srpaulo
3004261863Srpaulostatic void
3005287197Sglebiusurtwn_start(struct urtwn_softc *sc)
3006261863Srpaulo{
3007251538Srpaulo	struct ieee80211_node *ni;
3008251538Srpaulo	struct mbuf *m;
3009251538Srpaulo	struct urtwn_data *bf;
3010251538Srpaulo
3011261863Srpaulo	URTWN_ASSERT_LOCKED(sc);
3012287197Sglebius	while ((m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
3013251538Srpaulo		bf = urtwn_getbuf(sc);
3014251538Srpaulo		if (bf == NULL) {
3015287197Sglebius			mbufq_prepend(&sc->sc_snd, m);
3016251538Srpaulo			break;
3017251538Srpaulo		}
3018251538Srpaulo		ni = (struct ieee80211_node *)m->m_pkthdr.rcvif;
3019251538Srpaulo		m->m_pkthdr.rcvif = NULL;
3020290630Savos		if (urtwn_tx_data(sc, ni, m, bf) != 0) {
3021287197Sglebius			if_inc_counter(ni->ni_vap->iv_ifp,
3022287197Sglebius			    IFCOUNTER_OERRORS, 1);
3023251538Srpaulo			STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next);
3024288353Sadrian			m_freem(m);
3025251538Srpaulo			ieee80211_free_node(ni);
3026251538Srpaulo			break;
3027251538Srpaulo		}
3028251538Srpaulo		sc->sc_txtimer = 5;
3029251538Srpaulo		callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc);
3030251538Srpaulo	}
3031251538Srpaulo}
3032251538Srpaulo
3033287197Sglebiusstatic void
3034287197Sglebiusurtwn_parent(struct ieee80211com *ic)
3035251538Srpaulo{
3036286949Sadrian	struct urtwn_softc *sc = ic->ic_softc;
3037251538Srpaulo
3038263153Skevlo	URTWN_LOCK(sc);
3039287197Sglebius	if (sc->sc_flags & URTWN_DETACHED) {
3040287197Sglebius		URTWN_UNLOCK(sc);
3041287197Sglebius		return;
3042287197Sglebius	}
3043291698Savos	URTWN_UNLOCK(sc);
3044291698Savos
3045287197Sglebius	if (ic->ic_nrunning > 0) {
3046291698Savos		if (urtwn_init(sc) != 0) {
3047291698Savos			struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3048291698Savos			if (vap != NULL)
3049291698Savos				ieee80211_stop(vap);
3050291698Savos		} else
3051291698Savos			ieee80211_start_all(ic);
3052291698Savos	} else
3053287197Sglebius		urtwn_stop(sc);
3054251538Srpaulo}
3055251538Srpaulo
3056264912Skevlostatic __inline int
3057251538Srpaulourtwn_power_on(struct urtwn_softc *sc)
3058251538Srpaulo{
3059264912Skevlo
3060264912Skevlo	return sc->sc_power_on(sc);
3061264912Skevlo}
3062264912Skevlo
3063264912Skevlostatic int
3064264912Skevlourtwn_r92c_power_on(struct urtwn_softc *sc)
3065264912Skevlo{
3066251538Srpaulo	uint32_t reg;
3067291698Savos	usb_error_t error;
3068251538Srpaulo	int ntries;
3069251538Srpaulo
3070251538Srpaulo	/* Wait for autoload done bit. */
3071251538Srpaulo	for (ntries = 0; ntries < 1000; ntries++) {
3072251538Srpaulo		if (urtwn_read_1(sc, R92C_APS_FSMCO) & R92C_APS_FSMCO_PFM_ALDN)
3073251538Srpaulo			break;
3074266472Shselasky		urtwn_ms_delay(sc);
3075251538Srpaulo	}
3076251538Srpaulo	if (ntries == 1000) {
3077251538Srpaulo		device_printf(sc->sc_dev,
3078251538Srpaulo		    "timeout waiting for chip autoload\n");
3079251538Srpaulo		return (ETIMEDOUT);
3080251538Srpaulo	}
3081251538Srpaulo
3082251538Srpaulo	/* Unlock ISO/CLK/Power control register. */
3083291698Savos	error = urtwn_write_1(sc, R92C_RSV_CTRL, 0);
3084291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3085291698Savos		return (EIO);
3086251538Srpaulo	/* Move SPS into PWM mode. */
3087291698Savos	error = urtwn_write_1(sc, R92C_SPS0_CTRL, 0x2b);
3088291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3089291698Savos		return (EIO);
3090266472Shselasky	urtwn_ms_delay(sc);
3091251538Srpaulo
3092251538Srpaulo	reg = urtwn_read_1(sc, R92C_LDOV12D_CTRL);
3093251538Srpaulo	if (!(reg & R92C_LDOV12D_CTRL_LDV12_EN)) {
3094291698Savos		error = urtwn_write_1(sc, R92C_LDOV12D_CTRL,
3095251538Srpaulo		    reg | R92C_LDOV12D_CTRL_LDV12_EN);
3096291698Savos		if (error != USB_ERR_NORMAL_COMPLETION)
3097291698Savos			return (EIO);
3098266472Shselasky		urtwn_ms_delay(sc);
3099291698Savos		error = urtwn_write_1(sc, R92C_SYS_ISO_CTRL,
3100251538Srpaulo		    urtwn_read_1(sc, R92C_SYS_ISO_CTRL) &
3101251538Srpaulo		    ~R92C_SYS_ISO_CTRL_MD2PP);
3102291698Savos		if (error != USB_ERR_NORMAL_COMPLETION)
3103291698Savos			return (EIO);
3104251538Srpaulo	}
3105251538Srpaulo
3106251538Srpaulo	/* Auto enable WLAN. */
3107291698Savos	error = urtwn_write_2(sc, R92C_APS_FSMCO,
3108251538Srpaulo	    urtwn_read_2(sc, R92C_APS_FSMCO) | R92C_APS_FSMCO_APFM_ONMAC);
3109291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3110291698Savos		return (EIO);
3111251538Srpaulo	for (ntries = 0; ntries < 1000; ntries++) {
3112262822Skevlo		if (!(urtwn_read_2(sc, R92C_APS_FSMCO) &
3113262822Skevlo		    R92C_APS_FSMCO_APFM_ONMAC))
3114251538Srpaulo			break;
3115266472Shselasky		urtwn_ms_delay(sc);
3116251538Srpaulo	}
3117251538Srpaulo	if (ntries == 1000) {
3118251538Srpaulo		device_printf(sc->sc_dev,
3119251538Srpaulo		    "timeout waiting for MAC auto ON\n");
3120251538Srpaulo		return (ETIMEDOUT);
3121251538Srpaulo	}
3122251538Srpaulo
3123251538Srpaulo	/* Enable radio, GPIO and LED functions. */
3124291698Savos	error = urtwn_write_2(sc, R92C_APS_FSMCO,
3125251538Srpaulo	    R92C_APS_FSMCO_AFSM_HSUS |
3126251538Srpaulo	    R92C_APS_FSMCO_PDN_EN |
3127251538Srpaulo	    R92C_APS_FSMCO_PFM_ALDN);
3128291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3129291698Savos		return (EIO);
3130251538Srpaulo	/* Release RF digital isolation. */
3131291698Savos	error = urtwn_write_2(sc, R92C_SYS_ISO_CTRL,
3132251538Srpaulo	    urtwn_read_2(sc, R92C_SYS_ISO_CTRL) & ~R92C_SYS_ISO_CTRL_DIOR);
3133291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3134291698Savos		return (EIO);
3135251538Srpaulo
3136251538Srpaulo	/* Initialize MAC. */
3137291698Savos	error = urtwn_write_1(sc, R92C_APSD_CTRL,
3138251538Srpaulo	    urtwn_read_1(sc, R92C_APSD_CTRL) & ~R92C_APSD_CTRL_OFF);
3139291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3140291698Savos		return (EIO);
3141251538Srpaulo	for (ntries = 0; ntries < 200; ntries++) {
3142251538Srpaulo		if (!(urtwn_read_1(sc, R92C_APSD_CTRL) &
3143251538Srpaulo		    R92C_APSD_CTRL_OFF_STATUS))
3144251538Srpaulo			break;
3145266472Shselasky		urtwn_ms_delay(sc);
3146251538Srpaulo	}
3147251538Srpaulo	if (ntries == 200) {
3148251538Srpaulo		device_printf(sc->sc_dev,
3149251538Srpaulo		    "timeout waiting for MAC initialization\n");
3150251538Srpaulo		return (ETIMEDOUT);
3151251538Srpaulo	}
3152251538Srpaulo
3153251538Srpaulo	/* Enable MAC DMA/WMAC/SCHEDULE/SEC blocks. */
3154251538Srpaulo	reg = urtwn_read_2(sc, R92C_CR);
3155251538Srpaulo	reg |= R92C_CR_HCI_TXDMA_EN | R92C_CR_HCI_RXDMA_EN |
3156251538Srpaulo	    R92C_CR_TXDMA_EN | R92C_CR_RXDMA_EN | R92C_CR_PROTOCOL_EN |
3157251538Srpaulo	    R92C_CR_SCHEDULE_EN | R92C_CR_MACTXEN | R92C_CR_MACRXEN |
3158251538Srpaulo	    R92C_CR_ENSEC;
3159291698Savos	error = urtwn_write_2(sc, R92C_CR, reg);
3160291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3161291698Savos		return (EIO);
3162251538Srpaulo
3163291698Savos	error = urtwn_write_1(sc, 0xfe10, 0x19);
3164291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3165291698Savos		return (EIO);
3166251538Srpaulo	return (0);
3167251538Srpaulo}
3168251538Srpaulo
3169251538Srpaulostatic int
3170264912Skevlourtwn_r88e_power_on(struct urtwn_softc *sc)
3171264912Skevlo{
3172264912Skevlo	uint32_t reg;
3173291698Savos	usb_error_t error;
3174264912Skevlo	int ntries;
3175264912Skevlo
3176264912Skevlo	/* Wait for power ready bit. */
3177264912Skevlo	for (ntries = 0; ntries < 5000; ntries++) {
3178281918Skevlo		if (urtwn_read_4(sc, R92C_APS_FSMCO) & R92C_APS_FSMCO_SUS_HOST)
3179264912Skevlo			break;
3180266472Shselasky		urtwn_ms_delay(sc);
3181264912Skevlo	}
3182264912Skevlo	if (ntries == 5000) {
3183264912Skevlo		device_printf(sc->sc_dev,
3184264912Skevlo		    "timeout waiting for chip power up\n");
3185264912Skevlo		return (ETIMEDOUT);
3186264912Skevlo	}
3187264912Skevlo
3188264912Skevlo	/* Reset BB. */
3189291698Savos	error = urtwn_write_1(sc, R92C_SYS_FUNC_EN,
3190264912Skevlo	    urtwn_read_1(sc, R92C_SYS_FUNC_EN) & ~(R92C_SYS_FUNC_EN_BBRSTB |
3191264912Skevlo	    R92C_SYS_FUNC_EN_BB_GLB_RST));
3192291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3193291698Savos		return (EIO);
3194264912Skevlo
3195291698Savos	error = urtwn_write_1(sc, R92C_AFE_XTAL_CTRL + 2,
3196281918Skevlo	    urtwn_read_1(sc, R92C_AFE_XTAL_CTRL + 2) | 0x80);
3197291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3198291698Savos		return (EIO);
3199264912Skevlo
3200264912Skevlo	/* Disable HWPDN. */
3201291698Savos	error = urtwn_write_2(sc, R92C_APS_FSMCO,
3202281918Skevlo	    urtwn_read_2(sc, R92C_APS_FSMCO) & ~R92C_APS_FSMCO_APDM_HPDN);
3203291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3204291698Savos		return (EIO);
3205264912Skevlo
3206264912Skevlo	/* Disable WL suspend. */
3207291698Savos	error = urtwn_write_2(sc, R92C_APS_FSMCO,
3208281918Skevlo	    urtwn_read_2(sc, R92C_APS_FSMCO) &
3209281918Skevlo	    ~(R92C_APS_FSMCO_AFSM_HSUS | R92C_APS_FSMCO_AFSM_PCIE));
3210291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3211291698Savos		return (EIO);
3212264912Skevlo
3213291698Savos	error = urtwn_write_2(sc, R92C_APS_FSMCO,
3214281918Skevlo	    urtwn_read_2(sc, R92C_APS_FSMCO) | R92C_APS_FSMCO_APFM_ONMAC);
3215291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3216291698Savos		return (EIO);
3217264912Skevlo	for (ntries = 0; ntries < 5000; ntries++) {
3218281918Skevlo		if (!(urtwn_read_2(sc, R92C_APS_FSMCO) &
3219281918Skevlo		    R92C_APS_FSMCO_APFM_ONMAC))
3220264912Skevlo			break;
3221266472Shselasky		urtwn_ms_delay(sc);
3222264912Skevlo	}
3223264912Skevlo	if (ntries == 5000)
3224264912Skevlo		return (ETIMEDOUT);
3225264912Skevlo
3226264912Skevlo	/* Enable LDO normal mode. */
3227291698Savos	error = urtwn_write_1(sc, R92C_LPLDO_CTRL,
3228281918Skevlo	    urtwn_read_1(sc, R92C_LPLDO_CTRL) & ~0x10);
3229291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3230291698Savos		return (EIO);
3231264912Skevlo
3232264912Skevlo	/* Enable MAC DMA/WMAC/SCHEDULE/SEC blocks. */
3233291698Savos	error = urtwn_write_2(sc, R92C_CR, 0);
3234291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3235291698Savos		return (EIO);
3236264912Skevlo	reg = urtwn_read_2(sc, R92C_CR);
3237264912Skevlo	reg |= R92C_CR_HCI_TXDMA_EN | R92C_CR_HCI_RXDMA_EN |
3238264912Skevlo	    R92C_CR_TXDMA_EN | R92C_CR_RXDMA_EN | R92C_CR_PROTOCOL_EN |
3239264912Skevlo	    R92C_CR_SCHEDULE_EN | R92C_CR_ENSEC | R92C_CR_CALTMR_EN;
3240291698Savos	error = urtwn_write_2(sc, R92C_CR, reg);
3241291698Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3242291698Savos		return (EIO);
3243264912Skevlo
3244264912Skevlo	return (0);
3245264912Skevlo}
3246264912Skevlo
3247264912Skevlostatic int
3248251538Srpaulourtwn_llt_init(struct urtwn_softc *sc)
3249251538Srpaulo{
3250264912Skevlo	int i, error, page_count, pktbuf_count;
3251251538Srpaulo
3252264912Skevlo	page_count = (sc->chip & URTWN_CHIP_88E) ?
3253264912Skevlo	    R88E_TX_PAGE_COUNT : R92C_TX_PAGE_COUNT;
3254264912Skevlo	pktbuf_count = (sc->chip & URTWN_CHIP_88E) ?
3255264912Skevlo	    R88E_TXPKTBUF_COUNT : R92C_TXPKTBUF_COUNT;
3256264912Skevlo
3257264912Skevlo	/* Reserve pages [0; page_count]. */
3258264912Skevlo	for (i = 0; i < page_count; i++) {
3259251538Srpaulo		if ((error = urtwn_llt_write(sc, i, i + 1)) != 0)
3260251538Srpaulo			return (error);
3261251538Srpaulo	}
3262251538Srpaulo	/* NB: 0xff indicates end-of-list. */
3263251538Srpaulo	if ((error = urtwn_llt_write(sc, i, 0xff)) != 0)
3264251538Srpaulo		return (error);
3265251538Srpaulo	/*
3266264912Skevlo	 * Use pages [page_count + 1; pktbuf_count - 1]
3267251538Srpaulo	 * as ring buffer.
3268251538Srpaulo	 */
3269264912Skevlo	for (++i; i < pktbuf_count - 1; i++) {
3270251538Srpaulo		if ((error = urtwn_llt_write(sc, i, i + 1)) != 0)
3271251538Srpaulo			return (error);
3272251538Srpaulo	}
3273251538Srpaulo	/* Make the last page point to the beginning of the ring buffer. */
3274264912Skevlo	error = urtwn_llt_write(sc, i, page_count + 1);
3275251538Srpaulo	return (error);
3276251538Srpaulo}
3277251538Srpaulo
3278251538Srpaulostatic void
3279251538Srpaulourtwn_fw_reset(struct urtwn_softc *sc)
3280251538Srpaulo{
3281251538Srpaulo	uint16_t reg;
3282251538Srpaulo	int ntries;
3283251538Srpaulo
3284251538Srpaulo	/* Tell 8051 to reset itself. */
3285251538Srpaulo	urtwn_write_1(sc, R92C_HMETFR + 3, 0x20);
3286251538Srpaulo
3287251538Srpaulo	/* Wait until 8051 resets by itself. */
3288251538Srpaulo	for (ntries = 0; ntries < 100; ntries++) {
3289251538Srpaulo		reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN);
3290251538Srpaulo		if (!(reg & R92C_SYS_FUNC_EN_CPUEN))
3291251538Srpaulo			return;
3292266472Shselasky		urtwn_ms_delay(sc);
3293251538Srpaulo	}
3294251538Srpaulo	/* Force 8051 reset. */
3295251538Srpaulo	urtwn_write_2(sc, R92C_SYS_FUNC_EN, reg & ~R92C_SYS_FUNC_EN_CPUEN);
3296251538Srpaulo}
3297251538Srpaulo
3298264912Skevlostatic void
3299264912Skevlourtwn_r88e_fw_reset(struct urtwn_softc *sc)
3300264912Skevlo{
3301264912Skevlo	uint16_t reg;
3302264912Skevlo
3303264912Skevlo	reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN);
3304264912Skevlo	urtwn_write_2(sc, R92C_SYS_FUNC_EN, reg & ~R92C_SYS_FUNC_EN_CPUEN);
3305264912Skevlo	urtwn_write_2(sc, R92C_SYS_FUNC_EN, reg | R92C_SYS_FUNC_EN_CPUEN);
3306264912Skevlo}
3307264912Skevlo
3308251538Srpaulostatic int
3309251538Srpaulourtwn_fw_loadpage(struct urtwn_softc *sc, int page, const uint8_t *buf, int len)
3310251538Srpaulo{
3311251538Srpaulo	uint32_t reg;
3312291698Savos	usb_error_t error = USB_ERR_NORMAL_COMPLETION;
3313291698Savos	int off, mlen;
3314251538Srpaulo
3315251538Srpaulo	reg = urtwn_read_4(sc, R92C_MCUFWDL);
3316251538Srpaulo	reg = RW(reg, R92C_MCUFWDL_PAGE, page);
3317251538Srpaulo	urtwn_write_4(sc, R92C_MCUFWDL, reg);
3318251538Srpaulo
3319251538Srpaulo	off = R92C_FW_START_ADDR;
3320251538Srpaulo	while (len > 0) {
3321251538Srpaulo		if (len > 196)
3322251538Srpaulo			mlen = 196;
3323251538Srpaulo		else if (len > 4)
3324251538Srpaulo			mlen = 4;
3325251538Srpaulo		else
3326251538Srpaulo			mlen = 1;
3327251538Srpaulo		/* XXX fix this deconst */
3328281069Srpaulo		error = urtwn_write_region_1(sc, off,
3329251538Srpaulo		    __DECONST(uint8_t *, buf), mlen);
3330291698Savos		if (error != USB_ERR_NORMAL_COMPLETION)
3331251538Srpaulo			break;
3332251538Srpaulo		off += mlen;
3333251538Srpaulo		buf += mlen;
3334251538Srpaulo		len -= mlen;
3335251538Srpaulo	}
3336251538Srpaulo	return (error);
3337251538Srpaulo}
3338251538Srpaulo
3339251538Srpaulostatic int
3340251538Srpaulourtwn_load_firmware(struct urtwn_softc *sc)
3341251538Srpaulo{
3342251538Srpaulo	const struct firmware *fw;
3343251538Srpaulo	const struct r92c_fw_hdr *hdr;
3344251538Srpaulo	const char *imagename;
3345251538Srpaulo	const u_char *ptr;
3346251538Srpaulo	size_t len;
3347251538Srpaulo	uint32_t reg;
3348251538Srpaulo	int mlen, ntries, page, error;
3349251538Srpaulo
3350264864Skevlo	URTWN_UNLOCK(sc);
3351251538Srpaulo	/* Read firmware image from the filesystem. */
3352264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
3353264912Skevlo		imagename = "urtwn-rtl8188eufw";
3354264912Skevlo	else if ((sc->chip & (URTWN_CHIP_UMC_A_CUT | URTWN_CHIP_92C)) ==
3355264912Skevlo		    URTWN_CHIP_UMC_A_CUT)
3356251538Srpaulo		imagename = "urtwn-rtl8192cfwU";
3357251538Srpaulo	else
3358251538Srpaulo		imagename = "urtwn-rtl8192cfwT";
3359251538Srpaulo
3360251538Srpaulo	fw = firmware_get(imagename);
3361264864Skevlo	URTWN_LOCK(sc);
3362251538Srpaulo	if (fw == NULL) {
3363251538Srpaulo		device_printf(sc->sc_dev,
3364251538Srpaulo		    "failed loadfirmware of file %s\n", imagename);
3365251538Srpaulo		return (ENOENT);
3366251538Srpaulo	}
3367251538Srpaulo
3368251538Srpaulo	len = fw->datasize;
3369251538Srpaulo
3370251538Srpaulo	if (len < sizeof(*hdr)) {
3371251538Srpaulo		device_printf(sc->sc_dev, "firmware too short\n");
3372251538Srpaulo		error = EINVAL;
3373251538Srpaulo		goto fail;
3374251538Srpaulo	}
3375251538Srpaulo	ptr = fw->data;
3376251538Srpaulo	hdr = (const struct r92c_fw_hdr *)ptr;
3377251538Srpaulo	/* Check if there is a valid FW header and skip it. */
3378251538Srpaulo	if ((le16toh(hdr->signature) >> 4) == 0x88c ||
3379264912Skevlo	    (le16toh(hdr->signature) >> 4) == 0x88e ||
3380251538Srpaulo	    (le16toh(hdr->signature) >> 4) == 0x92c) {
3381294471Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_FIRMWARE,
3382294471Savos		    "FW V%d.%d %02d-%02d %02d:%02d\n",
3383251538Srpaulo		    le16toh(hdr->version), le16toh(hdr->subversion),
3384251538Srpaulo		    hdr->month, hdr->date, hdr->hour, hdr->minute);
3385251538Srpaulo		ptr += sizeof(*hdr);
3386251538Srpaulo		len -= sizeof(*hdr);
3387251538Srpaulo	}
3388251538Srpaulo
3389264912Skevlo	if (urtwn_read_1(sc, R92C_MCUFWDL) & R92C_MCUFWDL_RAM_DL_SEL) {
3390264912Skevlo		if (sc->chip & URTWN_CHIP_88E)
3391264912Skevlo			urtwn_r88e_fw_reset(sc);
3392264912Skevlo		else
3393264912Skevlo			urtwn_fw_reset(sc);
3394251538Srpaulo		urtwn_write_1(sc, R92C_MCUFWDL, 0);
3395251538Srpaulo	}
3396264912Skevlo
3397268487Skevlo	if (!(sc->chip & URTWN_CHIP_88E)) {
3398268487Skevlo		urtwn_write_2(sc, R92C_SYS_FUNC_EN,
3399268487Skevlo		    urtwn_read_2(sc, R92C_SYS_FUNC_EN) |
3400268487Skevlo		    R92C_SYS_FUNC_EN_CPUEN);
3401268487Skevlo	}
3402251538Srpaulo	urtwn_write_1(sc, R92C_MCUFWDL,
3403251538Srpaulo	    urtwn_read_1(sc, R92C_MCUFWDL) | R92C_MCUFWDL_EN);
3404251538Srpaulo	urtwn_write_1(sc, R92C_MCUFWDL + 2,
3405251538Srpaulo	    urtwn_read_1(sc, R92C_MCUFWDL + 2) & ~0x08);
3406251538Srpaulo
3407263154Skevlo	/* Reset the FWDL checksum. */
3408263154Skevlo	urtwn_write_1(sc, R92C_MCUFWDL,
3409263154Skevlo	    urtwn_read_1(sc, R92C_MCUFWDL) | R92C_MCUFWDL_CHKSUM_RPT);
3410263154Skevlo
3411251538Srpaulo	for (page = 0; len > 0; page++) {
3412251538Srpaulo		mlen = min(len, R92C_FW_PAGE_SIZE);
3413251538Srpaulo		error = urtwn_fw_loadpage(sc, page, ptr, mlen);
3414251538Srpaulo		if (error != 0) {
3415251538Srpaulo			device_printf(sc->sc_dev,
3416251538Srpaulo			    "could not load firmware page\n");
3417251538Srpaulo			goto fail;
3418251538Srpaulo		}
3419251538Srpaulo		ptr += mlen;
3420251538Srpaulo		len -= mlen;
3421251538Srpaulo	}
3422251538Srpaulo	urtwn_write_1(sc, R92C_MCUFWDL,
3423251538Srpaulo	    urtwn_read_1(sc, R92C_MCUFWDL) & ~R92C_MCUFWDL_EN);
3424251538Srpaulo	urtwn_write_1(sc, R92C_MCUFWDL + 1, 0);
3425251538Srpaulo
3426251538Srpaulo	/* Wait for checksum report. */
3427251538Srpaulo	for (ntries = 0; ntries < 1000; ntries++) {
3428251538Srpaulo		if (urtwn_read_4(sc, R92C_MCUFWDL) & R92C_MCUFWDL_CHKSUM_RPT)
3429251538Srpaulo			break;
3430266472Shselasky		urtwn_ms_delay(sc);
3431251538Srpaulo	}
3432251538Srpaulo	if (ntries == 1000) {
3433251538Srpaulo		device_printf(sc->sc_dev,
3434251538Srpaulo		    "timeout waiting for checksum report\n");
3435251538Srpaulo		error = ETIMEDOUT;
3436251538Srpaulo		goto fail;
3437251538Srpaulo	}
3438251538Srpaulo
3439251538Srpaulo	reg = urtwn_read_4(sc, R92C_MCUFWDL);
3440251538Srpaulo	reg = (reg & ~R92C_MCUFWDL_WINTINI_RDY) | R92C_MCUFWDL_RDY;
3441251538Srpaulo	urtwn_write_4(sc, R92C_MCUFWDL, reg);
3442264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
3443264912Skevlo		urtwn_r88e_fw_reset(sc);
3444251538Srpaulo	/* Wait for firmware readiness. */
3445251538Srpaulo	for (ntries = 0; ntries < 1000; ntries++) {
3446251538Srpaulo		if (urtwn_read_4(sc, R92C_MCUFWDL) & R92C_MCUFWDL_WINTINI_RDY)
3447251538Srpaulo			break;
3448266472Shselasky		urtwn_ms_delay(sc);
3449251538Srpaulo	}
3450251538Srpaulo	if (ntries == 1000) {
3451251538Srpaulo		device_printf(sc->sc_dev,
3452251538Srpaulo		    "timeout waiting for firmware readiness\n");
3453251538Srpaulo		error = ETIMEDOUT;
3454251538Srpaulo		goto fail;
3455251538Srpaulo	}
3456251538Srpaulofail:
3457251538Srpaulo	firmware_put(fw, FIRMWARE_UNLOAD);
3458251538Srpaulo	return (error);
3459251538Srpaulo}
3460251538Srpaulo
3461291902Skevlostatic int
3462251538Srpaulourtwn_dma_init(struct urtwn_softc *sc)
3463251538Srpaulo{
3464291902Skevlo	struct usb_endpoint *ep, *ep_end;
3465291698Savos	usb_error_t usb_err;
3466291902Skevlo	uint32_t reg;
3467291902Skevlo	int hashq, hasnq, haslq, nqueues, ntx;
3468291902Skevlo	int error, pagecount, npubqpages, nqpages, nrempages, tx_boundary;
3469281069Srpaulo
3470291695Savos	/* Initialize LLT table. */
3471291695Savos	error = urtwn_llt_init(sc);
3472291695Savos	if (error != 0)
3473291695Savos		return (error);
3474291695Savos
3475291902Skevlo	/* Determine the number of bulk-out pipes. */
3476291902Skevlo	ntx = 0;
3477291902Skevlo	ep = sc->sc_udev->endpoints;
3478291902Skevlo	ep_end = sc->sc_udev->endpoints + sc->sc_udev->endpoints_max;
3479291902Skevlo	for (; ep != ep_end; ep++) {
3480291902Skevlo		if ((ep->edesc == NULL) ||
3481291902Skevlo		    (ep->iface_index != sc->sc_iface_index))
3482291902Skevlo			continue;
3483291902Skevlo		if (UE_GET_DIR(ep->edesc->bEndpointAddress) == UE_DIR_OUT)
3484291902Skevlo			ntx++;
3485291902Skevlo	}
3486291902Skevlo	if (ntx == 0) {
3487291902Skevlo		device_printf(sc->sc_dev,
3488291902Skevlo		    "%d: invalid number of Tx bulk pipes\n", ntx);
3489291698Savos		return (EIO);
3490291902Skevlo	}
3491291695Savos
3492251538Srpaulo	/* Get Tx queues to USB endpoints mapping. */
3493291902Skevlo	hashq = hasnq = haslq = nqueues = 0;
3494291902Skevlo	switch (ntx) {
3495291902Skevlo	case 1: hashq = 1; break;
3496291902Skevlo	case 2: hashq = hasnq = 1; break;
3497291902Skevlo	case 3: case 4: hashq = hasnq = haslq = 1; break;
3498291902Skevlo	}
3499251538Srpaulo	nqueues = hashq + hasnq + haslq;
3500251538Srpaulo	if (nqueues == 0)
3501251538Srpaulo		return (EIO);
3502251538Srpaulo
3503291902Skevlo	npubqpages = nqpages = nrempages = pagecount = 0;
3504291902Skevlo	if (sc->chip & URTWN_CHIP_88E)
3505291902Skevlo		tx_boundary = R88E_TX_PAGE_BOUNDARY;
3506291902Skevlo	else {
3507291902Skevlo		pagecount = R92C_TX_PAGE_COUNT;
3508291902Skevlo		npubqpages = R92C_PUBQ_NPAGES;
3509291902Skevlo		tx_boundary = R92C_TX_PAGE_BOUNDARY;
3510291902Skevlo	}
3511291902Skevlo
3512251538Srpaulo	/* Set number of pages for normal priority queue. */
3513291902Skevlo	if (sc->chip & URTWN_CHIP_88E) {
3514291902Skevlo		usb_err = urtwn_write_2(sc, R92C_RQPN_NPQ, 0xd);
3515291902Skevlo		if (usb_err != USB_ERR_NORMAL_COMPLETION)
3516291902Skevlo			return (EIO);
3517291902Skevlo		usb_err = urtwn_write_4(sc, R92C_RQPN, 0x808e000d);
3518291902Skevlo		if (usb_err != USB_ERR_NORMAL_COMPLETION)
3519291902Skevlo			return (EIO);
3520291902Skevlo	} else {
3521291902Skevlo		/* Get the number of pages for each queue. */
3522291902Skevlo		nqpages = (pagecount - npubqpages) / nqueues;
3523291902Skevlo		/*
3524291902Skevlo		 * The remaining pages are assigned to the high priority
3525291902Skevlo		 * queue.
3526291902Skevlo		 */
3527291902Skevlo		nrempages = (pagecount - npubqpages) % nqueues;
3528291902Skevlo		usb_err = urtwn_write_1(sc, R92C_RQPN_NPQ, hasnq ? nqpages : 0);
3529291902Skevlo		if (usb_err != USB_ERR_NORMAL_COMPLETION)
3530291902Skevlo			return (EIO);
3531291902Skevlo		usb_err = urtwn_write_4(sc, R92C_RQPN,
3532291902Skevlo		    /* Set number of pages for public queue. */
3533291902Skevlo		    SM(R92C_RQPN_PUBQ, npubqpages) |
3534291902Skevlo		    /* Set number of pages for high priority queue. */
3535291902Skevlo		    SM(R92C_RQPN_HPQ, hashq ? nqpages + nrempages : 0) |
3536291902Skevlo		    /* Set number of pages for low priority queue. */
3537291902Skevlo		    SM(R92C_RQPN_LPQ, haslq ? nqpages : 0) |
3538291902Skevlo		    /* Load values. */
3539291902Skevlo		    R92C_RQPN_LD);
3540291902Skevlo		if (usb_err != USB_ERR_NORMAL_COMPLETION)
3541291902Skevlo			return (EIO);
3542291902Skevlo	}
3543251538Srpaulo
3544291902Skevlo	usb_err = urtwn_write_1(sc, R92C_TXPKTBUF_BCNQ_BDNY, tx_boundary);
3545291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3546291698Savos		return (EIO);
3547291902Skevlo	usb_err = urtwn_write_1(sc, R92C_TXPKTBUF_MGQ_BDNY, tx_boundary);
3548291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3549291698Savos		return (EIO);
3550291902Skevlo	usb_err = urtwn_write_1(sc, R92C_TXPKTBUF_WMAC_LBK_BF_HD, tx_boundary);
3551291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3552291698Savos		return (EIO);
3553291902Skevlo	usb_err = urtwn_write_1(sc, R92C_TRXFF_BNDY, tx_boundary);
3554291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3555291698Savos		return (EIO);
3556291902Skevlo	usb_err = urtwn_write_1(sc, R92C_TDECTRL + 1, tx_boundary);
3557291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3558291698Savos		return (EIO);
3559251538Srpaulo
3560251538Srpaulo	/* Set queue to USB pipe mapping. */
3561251538Srpaulo	reg = urtwn_read_2(sc, R92C_TRXDMA_CTRL);
3562251538Srpaulo	reg &= ~R92C_TRXDMA_CTRL_QMAP_M;
3563251538Srpaulo	if (nqueues == 1) {
3564251538Srpaulo		if (hashq)
3565251538Srpaulo			reg |= R92C_TRXDMA_CTRL_QMAP_HQ;
3566251538Srpaulo		else if (hasnq)
3567251538Srpaulo			reg |= R92C_TRXDMA_CTRL_QMAP_NQ;
3568251538Srpaulo		else
3569251538Srpaulo			reg |= R92C_TRXDMA_CTRL_QMAP_LQ;
3570251538Srpaulo	} else if (nqueues == 2) {
3571292056Skevlo		/*
3572292056Skevlo		 * All 2-endpoints configs have high and normal
3573292056Skevlo		 * priority queues.
3574292056Skevlo		 */
3575292056Skevlo		reg |= R92C_TRXDMA_CTRL_QMAP_HQ_NQ;
3576251538Srpaulo	} else
3577251538Srpaulo		reg |= R92C_TRXDMA_CTRL_QMAP_3EP;
3578291902Skevlo	usb_err = urtwn_write_2(sc, R92C_TRXDMA_CTRL, reg);
3579291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3580291698Savos		return (EIO);
3581251538Srpaulo
3582251538Srpaulo	/* Set Tx/Rx transfer page boundary. */
3583291902Skevlo	usb_err = urtwn_write_2(sc, R92C_TRXFF_BNDY + 2,
3584291902Skevlo	    (sc->chip & URTWN_CHIP_88E) ? 0x23ff : 0x27ff);
3585291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3586291698Savos		return (EIO);
3587251538Srpaulo
3588291902Skevlo	/* Set Tx/Rx transfer page size. */
3589291902Skevlo	usb_err = urtwn_write_1(sc, R92C_PBP,
3590291902Skevlo	    SM(R92C_PBP_PSRX, R92C_PBP_128) |
3591291902Skevlo	    SM(R92C_PBP_PSTX, R92C_PBP_128));
3592291902Skevlo	if (usb_err != USB_ERR_NORMAL_COMPLETION)
3593264912Skevlo		return (EIO);
3594264912Skevlo
3595264912Skevlo	return (0);
3596264912Skevlo}
3597264912Skevlo
3598291698Savosstatic int
3599251538Srpaulourtwn_mac_init(struct urtwn_softc *sc)
3600251538Srpaulo{
3601291698Savos	usb_error_t error;
3602251538Srpaulo	int i;
3603251538Srpaulo
3604251538Srpaulo	/* Write MAC initialization values. */
3605264912Skevlo	if (sc->chip & URTWN_CHIP_88E) {
3606264912Skevlo		for (i = 0; i < nitems(rtl8188eu_mac); i++) {
3607291698Savos			error = urtwn_write_1(sc, rtl8188eu_mac[i].reg,
3608264912Skevlo			    rtl8188eu_mac[i].val);
3609291698Savos			if (error != USB_ERR_NORMAL_COMPLETION)
3610291698Savos				return (EIO);
3611264912Skevlo		}
3612264912Skevlo		urtwn_write_1(sc, R92C_MAX_AGGR_NUM, 0x07);
3613264912Skevlo	} else {
3614264912Skevlo		for (i = 0; i < nitems(rtl8192cu_mac); i++)
3615291698Savos			error = urtwn_write_1(sc, rtl8192cu_mac[i].reg,
3616264912Skevlo			    rtl8192cu_mac[i].val);
3617291698Savos			if (error != USB_ERR_NORMAL_COMPLETION)
3618291698Savos				return (EIO);
3619264912Skevlo	}
3620291698Savos
3621291698Savos	return (0);
3622251538Srpaulo}
3623251538Srpaulo
3624251538Srpaulostatic void
3625251538Srpaulourtwn_bb_init(struct urtwn_softc *sc)
3626251538Srpaulo{
3627251538Srpaulo	const struct urtwn_bb_prog *prog;
3628251538Srpaulo	uint32_t reg;
3629264912Skevlo	uint8_t crystalcap;
3630251538Srpaulo	int i;
3631251538Srpaulo
3632251538Srpaulo	/* Enable BB and RF. */
3633251538Srpaulo	urtwn_write_2(sc, R92C_SYS_FUNC_EN,
3634251538Srpaulo	    urtwn_read_2(sc, R92C_SYS_FUNC_EN) |
3635251538Srpaulo	    R92C_SYS_FUNC_EN_BBRSTB | R92C_SYS_FUNC_EN_BB_GLB_RST |
3636251538Srpaulo	    R92C_SYS_FUNC_EN_DIO_RF);
3637251538Srpaulo
3638264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E))
3639264912Skevlo		urtwn_write_2(sc, R92C_AFE_PLL_CTRL, 0xdb83);
3640251538Srpaulo
3641251538Srpaulo	urtwn_write_1(sc, R92C_RF_CTRL,
3642251538Srpaulo	    R92C_RF_CTRL_EN | R92C_RF_CTRL_RSTB | R92C_RF_CTRL_SDMRSTB);
3643251538Srpaulo	urtwn_write_1(sc, R92C_SYS_FUNC_EN,
3644251538Srpaulo	    R92C_SYS_FUNC_EN_USBA | R92C_SYS_FUNC_EN_USBD |
3645251538Srpaulo	    R92C_SYS_FUNC_EN_BB_GLB_RST | R92C_SYS_FUNC_EN_BBRSTB);
3646251538Srpaulo
3647264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E)) {
3648264912Skevlo		urtwn_write_1(sc, R92C_LDOHCI12_CTRL, 0x0f);
3649264912Skevlo		urtwn_write_1(sc, 0x15, 0xe9);
3650264912Skevlo		urtwn_write_1(sc, R92C_AFE_XTAL_CTRL + 1, 0x80);
3651264912Skevlo	}
3652251538Srpaulo
3653251538Srpaulo	/* Select BB programming based on board type. */
3654264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
3655264912Skevlo		prog = &rtl8188eu_bb_prog;
3656264912Skevlo	else if (!(sc->chip & URTWN_CHIP_92C)) {
3657251538Srpaulo		if (sc->board_type == R92C_BOARD_TYPE_MINICARD)
3658251538Srpaulo			prog = &rtl8188ce_bb_prog;
3659251538Srpaulo		else if (sc->board_type == R92C_BOARD_TYPE_HIGHPA)
3660251538Srpaulo			prog = &rtl8188ru_bb_prog;
3661251538Srpaulo		else
3662251538Srpaulo			prog = &rtl8188cu_bb_prog;
3663251538Srpaulo	} else {
3664251538Srpaulo		if (sc->board_type == R92C_BOARD_TYPE_MINICARD)
3665251538Srpaulo			prog = &rtl8192ce_bb_prog;
3666251538Srpaulo		else
3667251538Srpaulo			prog = &rtl8192cu_bb_prog;
3668251538Srpaulo	}
3669251538Srpaulo	/* Write BB initialization values. */
3670251538Srpaulo	for (i = 0; i < prog->count; i++) {
3671251538Srpaulo		urtwn_bb_write(sc, prog->regs[i], prog->vals[i]);
3672266472Shselasky		urtwn_ms_delay(sc);
3673251538Srpaulo	}
3674251538Srpaulo
3675251538Srpaulo	if (sc->chip & URTWN_CHIP_92C_1T2R) {
3676251538Srpaulo		/* 8192C 1T only configuration. */
3677251538Srpaulo		reg = urtwn_bb_read(sc, R92C_FPGA0_TXINFO);
3678251538Srpaulo		reg = (reg & ~0x00000003) | 0x2;
3679251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_TXINFO, reg);
3680251538Srpaulo
3681251538Srpaulo		reg = urtwn_bb_read(sc, R92C_FPGA1_TXINFO);
3682251538Srpaulo		reg = (reg & ~0x00300033) | 0x00200022;
3683251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA1_TXINFO, reg);
3684251538Srpaulo
3685251538Srpaulo		reg = urtwn_bb_read(sc, R92C_CCK0_AFESETTING);
3686251538Srpaulo		reg = (reg & ~0xff000000) | 0x45 << 24;
3687251538Srpaulo		urtwn_bb_write(sc, R92C_CCK0_AFESETTING, reg);
3688251538Srpaulo
3689251538Srpaulo		reg = urtwn_bb_read(sc, R92C_OFDM0_TRXPATHENA);
3690251538Srpaulo		reg = (reg & ~0x000000ff) | 0x23;
3691251538Srpaulo		urtwn_bb_write(sc, R92C_OFDM0_TRXPATHENA, reg);
3692251538Srpaulo
3693251538Srpaulo		reg = urtwn_bb_read(sc, R92C_OFDM0_AGCPARAM1);
3694251538Srpaulo		reg = (reg & ~0x00000030) | 1 << 4;
3695251538Srpaulo		urtwn_bb_write(sc, R92C_OFDM0_AGCPARAM1, reg);
3696251538Srpaulo
3697251538Srpaulo		reg = urtwn_bb_read(sc, 0xe74);
3698251538Srpaulo		reg = (reg & ~0x0c000000) | 2 << 26;
3699251538Srpaulo		urtwn_bb_write(sc, 0xe74, reg);
3700251538Srpaulo		reg = urtwn_bb_read(sc, 0xe78);
3701251538Srpaulo		reg = (reg & ~0x0c000000) | 2 << 26;
3702251538Srpaulo		urtwn_bb_write(sc, 0xe78, reg);
3703251538Srpaulo		reg = urtwn_bb_read(sc, 0xe7c);
3704251538Srpaulo		reg = (reg & ~0x0c000000) | 2 << 26;
3705251538Srpaulo		urtwn_bb_write(sc, 0xe7c, reg);
3706251538Srpaulo		reg = urtwn_bb_read(sc, 0xe80);
3707251538Srpaulo		reg = (reg & ~0x0c000000) | 2 << 26;
3708251538Srpaulo		urtwn_bb_write(sc, 0xe80, reg);
3709251538Srpaulo		reg = urtwn_bb_read(sc, 0xe88);
3710251538Srpaulo		reg = (reg & ~0x0c000000) | 2 << 26;
3711251538Srpaulo		urtwn_bb_write(sc, 0xe88, reg);
3712251538Srpaulo	}
3713251538Srpaulo
3714251538Srpaulo	/* Write AGC values. */
3715251538Srpaulo	for (i = 0; i < prog->agccount; i++) {
3716251538Srpaulo		urtwn_bb_write(sc, R92C_OFDM0_AGCRSSITABLE,
3717251538Srpaulo		    prog->agcvals[i]);
3718266472Shselasky		urtwn_ms_delay(sc);
3719251538Srpaulo	}
3720251538Srpaulo
3721264912Skevlo	if (sc->chip & URTWN_CHIP_88E) {
3722264912Skevlo		urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(0), 0x69553422);
3723266472Shselasky		urtwn_ms_delay(sc);
3724264912Skevlo		urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(0), 0x69553420);
3725266472Shselasky		urtwn_ms_delay(sc);
3726264912Skevlo
3727294198Savos		crystalcap = sc->rom.r88e_rom.crystalcap;
3728264912Skevlo		if (crystalcap == 0xff)
3729264912Skevlo			crystalcap = 0x20;
3730264912Skevlo		crystalcap &= 0x3f;
3731264912Skevlo		reg = urtwn_bb_read(sc, R92C_AFE_XTAL_CTRL);
3732264912Skevlo		urtwn_bb_write(sc, R92C_AFE_XTAL_CTRL,
3733264912Skevlo		    RW(reg, R92C_AFE_XTAL_CTRL_ADDR,
3734264912Skevlo		    crystalcap | crystalcap << 6));
3735264912Skevlo	} else {
3736264912Skevlo		if (urtwn_bb_read(sc, R92C_HSSI_PARAM2(0)) &
3737264912Skevlo		    R92C_HSSI_PARAM2_CCK_HIPWR)
3738264912Skevlo			sc->sc_flags |= URTWN_FLAG_CCK_HIPWR;
3739264912Skevlo	}
3740251538Srpaulo}
3741251538Srpaulo
3742289066Skevlostatic void
3743251538Srpaulourtwn_rf_init(struct urtwn_softc *sc)
3744251538Srpaulo{
3745251538Srpaulo	const struct urtwn_rf_prog *prog;
3746251538Srpaulo	uint32_t reg, type;
3747251538Srpaulo	int i, j, idx, off;
3748251538Srpaulo
3749251538Srpaulo	/* Select RF programming based on board type. */
3750264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
3751264912Skevlo		prog = rtl8188eu_rf_prog;
3752264912Skevlo	else if (!(sc->chip & URTWN_CHIP_92C)) {
3753251538Srpaulo		if (sc->board_type == R92C_BOARD_TYPE_MINICARD)
3754251538Srpaulo			prog = rtl8188ce_rf_prog;
3755251538Srpaulo		else if (sc->board_type == R92C_BOARD_TYPE_HIGHPA)
3756251538Srpaulo			prog = rtl8188ru_rf_prog;
3757251538Srpaulo		else
3758251538Srpaulo			prog = rtl8188cu_rf_prog;
3759251538Srpaulo	} else
3760251538Srpaulo		prog = rtl8192ce_rf_prog;
3761251538Srpaulo
3762251538Srpaulo	for (i = 0; i < sc->nrxchains; i++) {
3763251538Srpaulo		/* Save RF_ENV control type. */
3764251538Srpaulo		idx = i / 2;
3765251538Srpaulo		off = (i % 2) * 16;
3766251538Srpaulo		reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACESW(idx));
3767251538Srpaulo		type = (reg >> off) & 0x10;
3768251538Srpaulo
3769251538Srpaulo		/* Set RF_ENV enable. */
3770251538Srpaulo		reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACEOE(i));
3771251538Srpaulo		reg |= 0x100000;
3772251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_RFIFACEOE(i), reg);
3773266472Shselasky		urtwn_ms_delay(sc);
3774251538Srpaulo		/* Set RF_ENV output high. */
3775251538Srpaulo		reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACEOE(i));
3776251538Srpaulo		reg |= 0x10;
3777251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_RFIFACEOE(i), reg);
3778266472Shselasky		urtwn_ms_delay(sc);
3779251538Srpaulo		/* Set address and data lengths of RF registers. */
3780251538Srpaulo		reg = urtwn_bb_read(sc, R92C_HSSI_PARAM2(i));
3781251538Srpaulo		reg &= ~R92C_HSSI_PARAM2_ADDR_LENGTH;
3782251538Srpaulo		urtwn_bb_write(sc, R92C_HSSI_PARAM2(i), reg);
3783266472Shselasky		urtwn_ms_delay(sc);
3784251538Srpaulo		reg = urtwn_bb_read(sc, R92C_HSSI_PARAM2(i));
3785251538Srpaulo		reg &= ~R92C_HSSI_PARAM2_DATA_LENGTH;
3786251538Srpaulo		urtwn_bb_write(sc, R92C_HSSI_PARAM2(i), reg);
3787266472Shselasky		urtwn_ms_delay(sc);
3788251538Srpaulo
3789251538Srpaulo		/* Write RF initialization values for this chain. */
3790251538Srpaulo		for (j = 0; j < prog[i].count; j++) {
3791251538Srpaulo			if (prog[i].regs[j] >= 0xf9 &&
3792251538Srpaulo			    prog[i].regs[j] <= 0xfe) {
3793251538Srpaulo				/*
3794251538Srpaulo				 * These are fake RF registers offsets that
3795251538Srpaulo				 * indicate a delay is required.
3796251538Srpaulo				 */
3797266472Shselasky				usb_pause_mtx(&sc->sc_mtx, hz / 20);	/* 50ms */
3798251538Srpaulo				continue;
3799251538Srpaulo			}
3800251538Srpaulo			urtwn_rf_write(sc, i, prog[i].regs[j],
3801251538Srpaulo			    prog[i].vals[j]);
3802266472Shselasky			urtwn_ms_delay(sc);
3803251538Srpaulo		}
3804251538Srpaulo
3805251538Srpaulo		/* Restore RF_ENV control type. */
3806251538Srpaulo		reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACESW(idx));
3807251538Srpaulo		reg &= ~(0x10 << off) | (type << off);
3808251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_RFIFACESW(idx), reg);
3809251538Srpaulo
3810251538Srpaulo		/* Cache RF register CHNLBW. */
3811251538Srpaulo		sc->rf_chnlbw[i] = urtwn_rf_read(sc, i, R92C_RF_CHNLBW);
3812251538Srpaulo	}
3813251538Srpaulo
3814251538Srpaulo	if ((sc->chip & (URTWN_CHIP_UMC_A_CUT | URTWN_CHIP_92C)) ==
3815251538Srpaulo	    URTWN_CHIP_UMC_A_CUT) {
3816251538Srpaulo		urtwn_rf_write(sc, 0, R92C_RF_RX_G1, 0x30255);
3817251538Srpaulo		urtwn_rf_write(sc, 0, R92C_RF_RX_G2, 0x50a00);
3818251538Srpaulo	}
3819251538Srpaulo}
3820251538Srpaulo
3821251538Srpaulostatic void
3822251538Srpaulourtwn_cam_init(struct urtwn_softc *sc)
3823251538Srpaulo{
3824251538Srpaulo	/* Invalidate all CAM entries. */
3825251538Srpaulo	urtwn_write_4(sc, R92C_CAMCMD,
3826251538Srpaulo	    R92C_CAMCMD_POLLING | R92C_CAMCMD_CLR);
3827251538Srpaulo}
3828251538Srpaulo
3829292175Savosstatic int
3830292175Savosurtwn_cam_write(struct urtwn_softc *sc, uint32_t addr, uint32_t data)
3831292175Savos{
3832292175Savos	usb_error_t error;
3833292175Savos
3834292175Savos	error = urtwn_write_4(sc, R92C_CAMWRITE, data);
3835292175Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3836292175Savos		return (EIO);
3837292175Savos	error = urtwn_write_4(sc, R92C_CAMCMD,
3838292175Savos	    R92C_CAMCMD_POLLING | R92C_CAMCMD_WRITE |
3839292175Savos	    SM(R92C_CAMCMD_ADDR, addr));
3840292175Savos	if (error != USB_ERR_NORMAL_COMPLETION)
3841292175Savos		return (EIO);
3842292175Savos
3843292175Savos	return (0);
3844292175Savos}
3845292175Savos
3846251538Srpaulostatic void
3847251538Srpaulourtwn_pa_bias_init(struct urtwn_softc *sc)
3848251538Srpaulo{
3849251538Srpaulo	uint8_t reg;
3850251538Srpaulo	int i;
3851251538Srpaulo
3852251538Srpaulo	for (i = 0; i < sc->nrxchains; i++) {
3853251538Srpaulo		if (sc->pa_setting & (1 << i))
3854251538Srpaulo			continue;
3855251538Srpaulo		urtwn_rf_write(sc, i, R92C_RF_IPA, 0x0f406);
3856251538Srpaulo		urtwn_rf_write(sc, i, R92C_RF_IPA, 0x4f406);
3857251538Srpaulo		urtwn_rf_write(sc, i, R92C_RF_IPA, 0x8f406);
3858251538Srpaulo		urtwn_rf_write(sc, i, R92C_RF_IPA, 0xcf406);
3859251538Srpaulo	}
3860251538Srpaulo	if (!(sc->pa_setting & 0x10)) {
3861251538Srpaulo		reg = urtwn_read_1(sc, 0x16);
3862251538Srpaulo		reg = (reg & ~0xf0) | 0x90;
3863251538Srpaulo		urtwn_write_1(sc, 0x16, reg);
3864251538Srpaulo	}
3865251538Srpaulo}
3866251538Srpaulo
3867251538Srpaulostatic void
3868251538Srpaulourtwn_rxfilter_init(struct urtwn_softc *sc)
3869251538Srpaulo{
3870290564Savos	struct ieee80211com *ic = &sc->sc_ic;
3871290564Savos	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
3872290564Savos	uint32_t rcr;
3873290564Savos	uint16_t filter;
3874290564Savos
3875290564Savos	URTWN_ASSERT_LOCKED(sc);
3876290564Savos
3877251538Srpaulo	/* Accept all multicast frames. */
3878251538Srpaulo	urtwn_write_4(sc, R92C_MAR + 0, 0xffffffff);
3879251538Srpaulo	urtwn_write_4(sc, R92C_MAR + 4, 0xffffffff);
3880290564Savos
3881290564Savos	/* Filter for management frames. */
3882290564Savos	filter = 0x7f3f;
3883290631Savos	switch (vap->iv_opmode) {
3884290631Savos	case IEEE80211_M_STA:
3885290564Savos		filter &= ~(
3886290564Savos		    R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_ASSOC_REQ) |
3887290564Savos		    R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_REASSOC_REQ) |
3888290564Savos		    R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_PROBE_REQ));
3889290631Savos		break;
3890290631Savos	case IEEE80211_M_HOSTAP:
3891290631Savos		filter &= ~(
3892290631Savos		    R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_ASSOC_RESP) |
3893290631Savos		    R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_REASSOC_RESP) |
3894290631Savos		    R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_BEACON));
3895290631Savos		break;
3896290631Savos	case IEEE80211_M_MONITOR:
3897290651Savos	case IEEE80211_M_IBSS:
3898290631Savos		break;
3899290631Savos	default:
3900290631Savos		device_printf(sc->sc_dev, "%s: undefined opmode %d\n",
3901290631Savos		    __func__, vap->iv_opmode);
3902290631Savos		break;
3903290564Savos	}
3904290564Savos	urtwn_write_2(sc, R92C_RXFLTMAP0, filter);
3905290564Savos
3906251538Srpaulo	/* Reject all control frames. */
3907251538Srpaulo	urtwn_write_2(sc, R92C_RXFLTMAP1, 0x0000);
3908290564Savos
3909290564Savos	/* Reject all data frames. */
3910290564Savos	urtwn_write_2(sc, R92C_RXFLTMAP2, 0x0000);
3911290564Savos
3912290564Savos	rcr = R92C_RCR_AM | R92C_RCR_AB | R92C_RCR_APM |
3913290564Savos	      R92C_RCR_HTC_LOC_CTRL | R92C_RCR_APP_PHYSTS |
3914290564Savos	      R92C_RCR_APP_ICV | R92C_RCR_APP_MIC;
3915290564Savos
3916290564Savos	if (vap->iv_opmode == IEEE80211_M_MONITOR) {
3917290564Savos		/* Accept all frames. */
3918290564Savos		rcr |= R92C_RCR_ACF | R92C_RCR_ADF | R92C_RCR_AMF |
3919290564Savos		       R92C_RCR_AAP;
3920290564Savos	}
3921290564Savos
3922290564Savos	/* Set Rx filter. */
3923290564Savos	urtwn_write_4(sc, R92C_RCR, rcr);
3924290564Savos
3925290564Savos	if (ic->ic_promisc != 0) {
3926290564Savos		/* Update Rx filter. */
3927290564Savos		urtwn_set_promisc(sc);
3928290564Savos	}
3929251538Srpaulo}
3930251538Srpaulo
3931251538Srpaulostatic void
3932251538Srpaulourtwn_edca_init(struct urtwn_softc *sc)
3933251538Srpaulo{
3934251538Srpaulo	urtwn_write_2(sc, R92C_SPEC_SIFS, 0x100a);
3935251538Srpaulo	urtwn_write_2(sc, R92C_MAC_SPEC_SIFS, 0x100a);
3936251538Srpaulo	urtwn_write_2(sc, R92C_SIFS_CCK, 0x100a);
3937251538Srpaulo	urtwn_write_2(sc, R92C_SIFS_OFDM, 0x100a);
3938251538Srpaulo	urtwn_write_4(sc, R92C_EDCA_BE_PARAM, 0x005ea42b);
3939251538Srpaulo	urtwn_write_4(sc, R92C_EDCA_BK_PARAM, 0x0000a44f);
3940251538Srpaulo	urtwn_write_4(sc, R92C_EDCA_VI_PARAM, 0x005ea324);
3941251538Srpaulo	urtwn_write_4(sc, R92C_EDCA_VO_PARAM, 0x002fa226);
3942251538Srpaulo}
3943251538Srpaulo
3944289066Skevlostatic void
3945251538Srpaulourtwn_write_txpower(struct urtwn_softc *sc, int chain,
3946251538Srpaulo    uint16_t power[URTWN_RIDX_COUNT])
3947251538Srpaulo{
3948251538Srpaulo	uint32_t reg;
3949251538Srpaulo
3950251538Srpaulo	/* Write per-CCK rate Tx power. */
3951251538Srpaulo	if (chain == 0) {
3952251538Srpaulo		reg = urtwn_bb_read(sc, R92C_TXAGC_A_CCK1_MCS32);
3953251538Srpaulo		reg = RW(reg, R92C_TXAGC_A_CCK1,  power[0]);
3954251538Srpaulo		urtwn_bb_write(sc, R92C_TXAGC_A_CCK1_MCS32, reg);
3955251538Srpaulo		reg = urtwn_bb_read(sc, R92C_TXAGC_B_CCK11_A_CCK2_11);
3956251538Srpaulo		reg = RW(reg, R92C_TXAGC_A_CCK2,  power[1]);
3957251538Srpaulo		reg = RW(reg, R92C_TXAGC_A_CCK55, power[2]);
3958251538Srpaulo		reg = RW(reg, R92C_TXAGC_A_CCK11, power[3]);
3959251538Srpaulo		urtwn_bb_write(sc, R92C_TXAGC_B_CCK11_A_CCK2_11, reg);
3960251538Srpaulo	} else {
3961251538Srpaulo		reg = urtwn_bb_read(sc, R92C_TXAGC_B_CCK1_55_MCS32);
3962251538Srpaulo		reg = RW(reg, R92C_TXAGC_B_CCK1,  power[0]);
3963251538Srpaulo		reg = RW(reg, R92C_TXAGC_B_CCK2,  power[1]);
3964251538Srpaulo		reg = RW(reg, R92C_TXAGC_B_CCK55, power[2]);
3965251538Srpaulo		urtwn_bb_write(sc, R92C_TXAGC_B_CCK1_55_MCS32, reg);
3966251538Srpaulo		reg = urtwn_bb_read(sc, R92C_TXAGC_B_CCK11_A_CCK2_11);
3967251538Srpaulo		reg = RW(reg, R92C_TXAGC_B_CCK11, power[3]);
3968251538Srpaulo		urtwn_bb_write(sc, R92C_TXAGC_B_CCK11_A_CCK2_11, reg);
3969251538Srpaulo	}
3970251538Srpaulo	/* Write per-OFDM rate Tx power. */
3971251538Srpaulo	urtwn_bb_write(sc, R92C_TXAGC_RATE18_06(chain),
3972251538Srpaulo	    SM(R92C_TXAGC_RATE06, power[ 4]) |
3973251538Srpaulo	    SM(R92C_TXAGC_RATE09, power[ 5]) |
3974251538Srpaulo	    SM(R92C_TXAGC_RATE12, power[ 6]) |
3975251538Srpaulo	    SM(R92C_TXAGC_RATE18, power[ 7]));
3976251538Srpaulo	urtwn_bb_write(sc, R92C_TXAGC_RATE54_24(chain),
3977251538Srpaulo	    SM(R92C_TXAGC_RATE24, power[ 8]) |
3978251538Srpaulo	    SM(R92C_TXAGC_RATE36, power[ 9]) |
3979251538Srpaulo	    SM(R92C_TXAGC_RATE48, power[10]) |
3980251538Srpaulo	    SM(R92C_TXAGC_RATE54, power[11]));
3981251538Srpaulo	/* Write per-MCS Tx power. */
3982251538Srpaulo	urtwn_bb_write(sc, R92C_TXAGC_MCS03_MCS00(chain),
3983251538Srpaulo	    SM(R92C_TXAGC_MCS00,  power[12]) |
3984251538Srpaulo	    SM(R92C_TXAGC_MCS01,  power[13]) |
3985251538Srpaulo	    SM(R92C_TXAGC_MCS02,  power[14]) |
3986251538Srpaulo	    SM(R92C_TXAGC_MCS03,  power[15]));
3987251538Srpaulo	urtwn_bb_write(sc, R92C_TXAGC_MCS07_MCS04(chain),
3988251538Srpaulo	    SM(R92C_TXAGC_MCS04,  power[16]) |
3989251538Srpaulo	    SM(R92C_TXAGC_MCS05,  power[17]) |
3990251538Srpaulo	    SM(R92C_TXAGC_MCS06,  power[18]) |
3991251538Srpaulo	    SM(R92C_TXAGC_MCS07,  power[19]));
3992251538Srpaulo	urtwn_bb_write(sc, R92C_TXAGC_MCS11_MCS08(chain),
3993251538Srpaulo	    SM(R92C_TXAGC_MCS08,  power[20]) |
3994261506Skevlo	    SM(R92C_TXAGC_MCS09,  power[21]) |
3995251538Srpaulo	    SM(R92C_TXAGC_MCS10,  power[22]) |
3996251538Srpaulo	    SM(R92C_TXAGC_MCS11,  power[23]));
3997251538Srpaulo	urtwn_bb_write(sc, R92C_TXAGC_MCS15_MCS12(chain),
3998251538Srpaulo	    SM(R92C_TXAGC_MCS12,  power[24]) |
3999251538Srpaulo	    SM(R92C_TXAGC_MCS13,  power[25]) |
4000251538Srpaulo	    SM(R92C_TXAGC_MCS14,  power[26]) |
4001251538Srpaulo	    SM(R92C_TXAGC_MCS15,  power[27]));
4002251538Srpaulo}
4003251538Srpaulo
4004289066Skevlostatic void
4005251538Srpaulourtwn_get_txpower(struct urtwn_softc *sc, int chain,
4006251538Srpaulo    struct ieee80211_channel *c, struct ieee80211_channel *extc,
4007251538Srpaulo    uint16_t power[URTWN_RIDX_COUNT])
4008251538Srpaulo{
4009287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
4010291264Savos	struct r92c_rom *rom = &sc->rom.r92c_rom;
4011251538Srpaulo	uint16_t cckpow, ofdmpow, htpow, diff, max;
4012251538Srpaulo	const struct urtwn_txpwr *base;
4013251538Srpaulo	int ridx, chan, group;
4014251538Srpaulo
4015251538Srpaulo	/* Determine channel group. */
4016251538Srpaulo	chan = ieee80211_chan2ieee(ic, c);	/* XXX center freq! */
4017251538Srpaulo	if (chan <= 3)
4018251538Srpaulo		group = 0;
4019251538Srpaulo	else if (chan <= 9)
4020251538Srpaulo		group = 1;
4021251538Srpaulo	else
4022251538Srpaulo		group = 2;
4023251538Srpaulo
4024251538Srpaulo	/* Get original Tx power based on board type and RF chain. */
4025251538Srpaulo	if (!(sc->chip & URTWN_CHIP_92C)) {
4026251538Srpaulo		if (sc->board_type == R92C_BOARD_TYPE_HIGHPA)
4027251538Srpaulo			base = &rtl8188ru_txagc[chain];
4028251538Srpaulo		else
4029251538Srpaulo			base = &rtl8192cu_txagc[chain];
4030251538Srpaulo	} else
4031251538Srpaulo		base = &rtl8192cu_txagc[chain];
4032251538Srpaulo
4033251538Srpaulo	memset(power, 0, URTWN_RIDX_COUNT * sizeof(power[0]));
4034251538Srpaulo	if (sc->regulatory == 0) {
4035289758Savos		for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++)
4036251538Srpaulo			power[ridx] = base->pwr[0][ridx];
4037251538Srpaulo	}
4038289758Savos	for (ridx = URTWN_RIDX_OFDM6; ridx < URTWN_RIDX_COUNT; ridx++) {
4039251538Srpaulo		if (sc->regulatory == 3) {
4040251538Srpaulo			power[ridx] = base->pwr[0][ridx];
4041251538Srpaulo			/* Apply vendor limits. */
4042251538Srpaulo			if (extc != NULL)
4043251538Srpaulo				max = rom->ht40_max_pwr[group];
4044251538Srpaulo			else
4045251538Srpaulo				max = rom->ht20_max_pwr[group];
4046251538Srpaulo			max = (max >> (chain * 4)) & 0xf;
4047251538Srpaulo			if (power[ridx] > max)
4048251538Srpaulo				power[ridx] = max;
4049251538Srpaulo		} else if (sc->regulatory == 1) {
4050251538Srpaulo			if (extc == NULL)
4051251538Srpaulo				power[ridx] = base->pwr[group][ridx];
4052251538Srpaulo		} else if (sc->regulatory != 2)
4053251538Srpaulo			power[ridx] = base->pwr[0][ridx];
4054251538Srpaulo	}
4055251538Srpaulo
4056251538Srpaulo	/* Compute per-CCK rate Tx power. */
4057251538Srpaulo	cckpow = rom->cck_tx_pwr[chain][group];
4058289758Savos	for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++) {
4059251538Srpaulo		power[ridx] += cckpow;
4060251538Srpaulo		if (power[ridx] > R92C_MAX_TX_PWR)
4061251538Srpaulo			power[ridx] = R92C_MAX_TX_PWR;
4062251538Srpaulo	}
4063251538Srpaulo
4064251538Srpaulo	htpow = rom->ht40_1s_tx_pwr[chain][group];
4065251538Srpaulo	if (sc->ntxchains > 1) {
4066251538Srpaulo		/* Apply reduction for 2 spatial streams. */
4067251538Srpaulo		diff = rom->ht40_2s_tx_pwr_diff[group];
4068251538Srpaulo		diff = (diff >> (chain * 4)) & 0xf;
4069251538Srpaulo		htpow = (htpow > diff) ? htpow - diff : 0;
4070251538Srpaulo	}
4071251538Srpaulo
4072251538Srpaulo	/* Compute per-OFDM rate Tx power. */
4073251538Srpaulo	diff = rom->ofdm_tx_pwr_diff[group];
4074251538Srpaulo	diff = (diff >> (chain * 4)) & 0xf;
4075251538Srpaulo	ofdmpow = htpow + diff;	/* HT->OFDM correction. */
4076289758Savos	for (ridx = URTWN_RIDX_OFDM6; ridx <= URTWN_RIDX_OFDM54; ridx++) {
4077251538Srpaulo		power[ridx] += ofdmpow;
4078251538Srpaulo		if (power[ridx] > R92C_MAX_TX_PWR)
4079251538Srpaulo			power[ridx] = R92C_MAX_TX_PWR;
4080251538Srpaulo	}
4081251538Srpaulo
4082251538Srpaulo	/* Compute per-MCS Tx power. */
4083251538Srpaulo	if (extc == NULL) {
4084251538Srpaulo		diff = rom->ht20_tx_pwr_diff[group];
4085251538Srpaulo		diff = (diff >> (chain * 4)) & 0xf;
4086251538Srpaulo		htpow += diff;	/* HT40->HT20 correction. */
4087251538Srpaulo	}
4088251538Srpaulo	for (ridx = 12; ridx <= 27; ridx++) {
4089251538Srpaulo		power[ridx] += htpow;
4090251538Srpaulo		if (power[ridx] > R92C_MAX_TX_PWR)
4091251538Srpaulo			power[ridx] = R92C_MAX_TX_PWR;
4092251538Srpaulo	}
4093294471Savos#ifdef USB_DEBUG
4094294471Savos	if (sc->sc_debug & URTWN_DEBUG_TXPWR) {
4095251538Srpaulo		/* Dump per-rate Tx power values. */
4096251538Srpaulo		printf("Tx power for chain %d:\n", chain);
4097289758Savos		for (ridx = URTWN_RIDX_CCK1; ridx < URTWN_RIDX_COUNT; ridx++)
4098251538Srpaulo			printf("Rate %d = %u\n", ridx, power[ridx]);
4099251538Srpaulo	}
4100251538Srpaulo#endif
4101251538Srpaulo}
4102251538Srpaulo
4103289066Skevlostatic void
4104264912Skevlourtwn_r88e_get_txpower(struct urtwn_softc *sc, int chain,
4105264912Skevlo    struct ieee80211_channel *c, struct ieee80211_channel *extc,
4106264912Skevlo    uint16_t power[URTWN_RIDX_COUNT])
4107264912Skevlo{
4108287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
4109294198Savos	struct r88e_rom *rom = &sc->rom.r88e_rom;
4110264912Skevlo	uint16_t cckpow, ofdmpow, bw20pow, htpow;
4111264912Skevlo	const struct urtwn_r88e_txpwr *base;
4112264912Skevlo	int ridx, chan, group;
4113264912Skevlo
4114264912Skevlo	/* Determine channel group. */
4115264912Skevlo	chan = ieee80211_chan2ieee(ic, c);	/* XXX center freq! */
4116264912Skevlo	if (chan <= 2)
4117264912Skevlo		group = 0;
4118264912Skevlo	else if (chan <= 5)
4119264912Skevlo		group = 1;
4120264912Skevlo	else if (chan <= 8)
4121264912Skevlo		group = 2;
4122264912Skevlo	else if (chan <= 11)
4123264912Skevlo		group = 3;
4124264912Skevlo	else if (chan <= 13)
4125264912Skevlo		group = 4;
4126264912Skevlo	else
4127264912Skevlo		group = 5;
4128264912Skevlo
4129264912Skevlo	/* Get original Tx power based on board type and RF chain. */
4130264912Skevlo	base = &rtl8188eu_txagc[chain];
4131264912Skevlo
4132264912Skevlo	memset(power, 0, URTWN_RIDX_COUNT * sizeof(power[0]));
4133264912Skevlo	if (sc->regulatory == 0) {
4134289758Savos		for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++)
4135264912Skevlo			power[ridx] = base->pwr[0][ridx];
4136264912Skevlo	}
4137289758Savos	for (ridx = URTWN_RIDX_OFDM6; ridx < URTWN_RIDX_COUNT; ridx++) {
4138264912Skevlo		if (sc->regulatory == 3)
4139264912Skevlo			power[ridx] = base->pwr[0][ridx];
4140264912Skevlo		else if (sc->regulatory == 1) {
4141264912Skevlo			if (extc == NULL)
4142264912Skevlo				power[ridx] = base->pwr[group][ridx];
4143264912Skevlo		} else if (sc->regulatory != 2)
4144264912Skevlo			power[ridx] = base->pwr[0][ridx];
4145264912Skevlo	}
4146264912Skevlo
4147264912Skevlo	/* Compute per-CCK rate Tx power. */
4148294198Savos	cckpow = rom->cck_tx_pwr[group];
4149289758Savos	for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++) {
4150264912Skevlo		power[ridx] += cckpow;
4151264912Skevlo		if (power[ridx] > R92C_MAX_TX_PWR)
4152264912Skevlo			power[ridx] = R92C_MAX_TX_PWR;
4153264912Skevlo	}
4154264912Skevlo
4155294198Savos	htpow = rom->ht40_tx_pwr[group];
4156264912Skevlo
4157264912Skevlo	/* Compute per-OFDM rate Tx power. */
4158264912Skevlo	ofdmpow = htpow + sc->ofdm_tx_pwr_diff;
4159289758Savos	for (ridx = URTWN_RIDX_OFDM6; ridx <= URTWN_RIDX_OFDM54; ridx++) {
4160264912Skevlo		power[ridx] += ofdmpow;
4161264912Skevlo		if (power[ridx] > R92C_MAX_TX_PWR)
4162264912Skevlo			power[ridx] = R92C_MAX_TX_PWR;
4163264912Skevlo	}
4164264912Skevlo
4165264912Skevlo	bw20pow = htpow + sc->bw20_tx_pwr_diff;
4166264912Skevlo	for (ridx = 12; ridx <= 27; ridx++) {
4167264912Skevlo		power[ridx] += bw20pow;
4168264912Skevlo		if (power[ridx] > R92C_MAX_TX_PWR)
4169264912Skevlo			power[ridx] = R92C_MAX_TX_PWR;
4170264912Skevlo	}
4171264912Skevlo}
4172264912Skevlo
4173289066Skevlostatic void
4174251538Srpaulourtwn_set_txpower(struct urtwn_softc *sc, struct ieee80211_channel *c,
4175251538Srpaulo    struct ieee80211_channel *extc)
4176251538Srpaulo{
4177251538Srpaulo	uint16_t power[URTWN_RIDX_COUNT];
4178251538Srpaulo	int i;
4179251538Srpaulo
4180251538Srpaulo	for (i = 0; i < sc->ntxchains; i++) {
4181251538Srpaulo		/* Compute per-rate Tx power values. */
4182264912Skevlo		if (sc->chip & URTWN_CHIP_88E)
4183264912Skevlo			urtwn_r88e_get_txpower(sc, i, c, extc, power);
4184264912Skevlo		else
4185264912Skevlo			urtwn_get_txpower(sc, i, c, extc, power);
4186251538Srpaulo		/* Write per-rate Tx power values to hardware. */
4187251538Srpaulo		urtwn_write_txpower(sc, i, power);
4188251538Srpaulo	}
4189251538Srpaulo}
4190251538Srpaulo
4191251538Srpaulostatic void
4192290048Savosurtwn_set_rx_bssid_all(struct urtwn_softc *sc, int enable)
4193290048Savos{
4194290048Savos	uint32_t reg;
4195290048Savos
4196290048Savos	reg = urtwn_read_4(sc, R92C_RCR);
4197290048Savos	if (enable)
4198290048Savos		reg &= ~R92C_RCR_CBSSID_BCN;
4199290048Savos	else
4200290048Savos		reg |= R92C_RCR_CBSSID_BCN;
4201290048Savos	urtwn_write_4(sc, R92C_RCR, reg);
4202290048Savos}
4203290048Savos
4204290048Savosstatic void
4205290048Savosurtwn_set_gain(struct urtwn_softc *sc, uint8_t gain)
4206290048Savos{
4207290048Savos	uint32_t reg;
4208290048Savos
4209290048Savos	reg = urtwn_bb_read(sc, R92C_OFDM0_AGCCORE1(0));
4210290048Savos	reg = RW(reg, R92C_OFDM0_AGCCORE1_GAIN, gain);
4211290048Savos	urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(0), reg);
4212290048Savos
4213290048Savos	if (!(sc->chip & URTWN_CHIP_88E)) {
4214290048Savos		reg = urtwn_bb_read(sc, R92C_OFDM0_AGCCORE1(1));
4215290048Savos		reg = RW(reg, R92C_OFDM0_AGCCORE1_GAIN, gain);
4216290048Savos		urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(1), reg);
4217290048Savos	}
4218290048Savos}
4219290048Savos
4220290048Savosstatic void
4221251538Srpaulourtwn_scan_start(struct ieee80211com *ic)
4222251538Srpaulo{
4223290048Savos	struct urtwn_softc *sc = ic->ic_softc;
4224290048Savos
4225290048Savos	URTWN_LOCK(sc);
4226290048Savos	/* Receive beacons / probe responses from any BSSID. */
4227290651Savos	if (ic->ic_opmode != IEEE80211_M_IBSS)
4228290651Savos		urtwn_set_rx_bssid_all(sc, 1);
4229290651Savos
4230290048Savos	/* Set gain for scanning. */
4231290048Savos	urtwn_set_gain(sc, 0x20);
4232290048Savos	URTWN_UNLOCK(sc);
4233251538Srpaulo}
4234251538Srpaulo
4235251538Srpaulostatic void
4236251538Srpaulourtwn_scan_end(struct ieee80211com *ic)
4237251538Srpaulo{
4238290048Savos	struct urtwn_softc *sc = ic->ic_softc;
4239290048Savos
4240290048Savos	URTWN_LOCK(sc);
4241290048Savos	/* Restore limitations. */
4242290651Savos	if (ic->ic_promisc == 0 && ic->ic_opmode != IEEE80211_M_IBSS)
4243290564Savos		urtwn_set_rx_bssid_all(sc, 0);
4244290651Savos
4245290048Savos	/* Set gain under link. */
4246290048Savos	urtwn_set_gain(sc, 0x32);
4247290048Savos	URTWN_UNLOCK(sc);
4248251538Srpaulo}
4249251538Srpaulo
4250251538Srpaulostatic void
4251251538Srpaulourtwn_set_channel(struct ieee80211com *ic)
4252251538Srpaulo{
4253286949Sadrian	struct urtwn_softc *sc = ic->ic_softc;
4254292173Savos	struct ieee80211_channel *c = ic->ic_curchan;
4255281070Srpaulo	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
4256251538Srpaulo
4257251538Srpaulo	URTWN_LOCK(sc);
4258281070Srpaulo	if (vap->iv_state == IEEE80211_S_SCAN) {
4259281070Srpaulo		/* Make link LED blink during scan. */
4260281070Srpaulo		urtwn_set_led(sc, URTWN_LED_LINK, !sc->ledlink);
4261281070Srpaulo	}
4262292173Savos	urtwn_set_chan(sc, c, NULL);
4263292173Savos	sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq);
4264292173Savos	sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags);
4265292173Savos	sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq);
4266292173Savos	sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags);
4267251538Srpaulo	URTWN_UNLOCK(sc);
4268251538Srpaulo}
4269251538Srpaulo
4270292014Savosstatic int
4271292014Savosurtwn_wme_update(struct ieee80211com *ic)
4272292014Savos{
4273292014Savos	const struct wmeParams *wmep =
4274292014Savos	    ic->ic_wme.wme_chanParams.cap_wmeParams;
4275292014Savos	struct urtwn_softc *sc = ic->ic_softc;
4276292014Savos	uint8_t aifs, acm, slottime;
4277292014Savos	int ac;
4278292014Savos
4279292014Savos	acm = 0;
4280292165Savos	slottime = IEEE80211_GET_SLOTTIME(ic);
4281292014Savos
4282292014Savos	URTWN_LOCK(sc);
4283292014Savos	for (ac = WME_AC_BE; ac < WME_NUM_AC; ac++) {
4284292014Savos		/* AIFS[AC] = AIFSN[AC] * aSlotTime + aSIFSTime. */
4285292014Savos		aifs = wmep[ac].wmep_aifsn * slottime + IEEE80211_DUR_SIFS;
4286292014Savos		urtwn_write_4(sc, wme2queue[ac].reg,
4287292014Savos		    SM(R92C_EDCA_PARAM_TXOP, wmep[ac].wmep_txopLimit) |
4288292014Savos		    SM(R92C_EDCA_PARAM_ECWMIN, wmep[ac].wmep_logcwmin) |
4289292014Savos		    SM(R92C_EDCA_PARAM_ECWMAX, wmep[ac].wmep_logcwmax) |
4290292014Savos		    SM(R92C_EDCA_PARAM_AIFS, aifs));
4291292014Savos		if (ac != WME_AC_BE)
4292292014Savos			acm |= wmep[ac].wmep_acm << ac;
4293292014Savos	}
4294292014Savos
4295292014Savos	if (acm != 0)
4296292014Savos		acm |= R92C_ACMHWCTRL_EN;
4297292014Savos	urtwn_write_1(sc, R92C_ACMHWCTRL,
4298292014Savos	    (urtwn_read_1(sc, R92C_ACMHWCTRL) & ~R92C_ACMHWCTRL_ACM_MASK) |
4299292014Savos	    acm);
4300292014Savos
4301292014Savos	URTWN_UNLOCK(sc);
4302292014Savos
4303292014Savos	return 0;
4304292014Savos}
4305292014Savos
4306251538Srpaulostatic void
4307294465Savosurtwn_update_slot(struct ieee80211com *ic)
4308294465Savos{
4309294465Savos	urtwn_cmd_sleepable(ic->ic_softc, NULL, 0, urtwn_update_slot_cb);
4310294465Savos}
4311294465Savos
4312294465Savosstatic void
4313294465Savosurtwn_update_slot_cb(struct urtwn_softc *sc, union sec_param *data)
4314294465Savos{
4315294465Savos	struct ieee80211com *ic = &sc->sc_ic;
4316294465Savos	uint8_t slottime;
4317294465Savos
4318294465Savos	slottime = IEEE80211_GET_SLOTTIME(ic);
4319294465Savos
4320294471Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_ANY, "%s: setting slot time to %uus\n",
4321294471Savos	    __func__, slottime);
4322294465Savos
4323294465Savos	urtwn_write_1(sc, R92C_SLOT, slottime);
4324294465Savos	urtwn_update_aifs(sc, slottime);
4325294465Savos}
4326294465Savos
4327294465Savosstatic void
4328294465Savosurtwn_update_aifs(struct urtwn_softc *sc, uint8_t slottime)
4329294465Savos{
4330294465Savos	const struct wmeParams *wmep =
4331294465Savos	    sc->sc_ic.ic_wme.wme_chanParams.cap_wmeParams;
4332294465Savos	uint8_t aifs, ac;
4333294465Savos
4334294465Savos	for (ac = WME_AC_BE; ac < WME_NUM_AC; ac++) {
4335294465Savos		/* AIFS[AC] = AIFSN[AC] * aSlotTime + aSIFSTime. */
4336294465Savos		aifs = wmep[ac].wmep_aifsn * slottime + IEEE80211_DUR_SIFS;
4337294465Savos		urtwn_write_1(sc, wme2queue[ac].reg, aifs);
4338294465Savos        }
4339294465Savos}
4340294465Savos
4341294465Savosstatic void
4342290564Savosurtwn_set_promisc(struct urtwn_softc *sc)
4343290564Savos{
4344290564Savos	struct ieee80211com *ic = &sc->sc_ic;
4345290564Savos	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
4346290564Savos	uint32_t rcr, mask1, mask2;
4347290564Savos
4348290564Savos	URTWN_ASSERT_LOCKED(sc);
4349290564Savos
4350290564Savos	if (vap->iv_opmode == IEEE80211_M_MONITOR)
4351290564Savos		return;
4352290564Savos
4353290564Savos	mask1 = R92C_RCR_ACF | R92C_RCR_ADF | R92C_RCR_AMF | R92C_RCR_AAP;
4354290564Savos	mask2 = R92C_RCR_APM;
4355290564Savos
4356290564Savos	if (vap->iv_state == IEEE80211_S_RUN) {
4357290564Savos		switch (vap->iv_opmode) {
4358290564Savos		case IEEE80211_M_STA:
4359290631Savos			mask2 |= R92C_RCR_CBSSID_DATA;
4360290631Savos			/* FALLTHROUGH */
4361290631Savos		case IEEE80211_M_HOSTAP:
4362290631Savos			mask2 |= R92C_RCR_CBSSID_BCN;
4363290564Savos			break;
4364290651Savos		case IEEE80211_M_IBSS:
4365290651Savos			mask2 |= R92C_RCR_CBSSID_DATA;
4366290651Savos			break;
4367290564Savos		default:
4368290564Savos			device_printf(sc->sc_dev, "%s: undefined opmode %d\n",
4369290564Savos			    __func__, vap->iv_opmode);
4370290564Savos			return;
4371290564Savos		}
4372290564Savos	}
4373290564Savos
4374290564Savos	rcr = urtwn_read_4(sc, R92C_RCR);
4375290564Savos	if (ic->ic_promisc == 0)
4376290564Savos		rcr = (rcr & ~mask1) | mask2;
4377290564Savos	else
4378290564Savos		rcr = (rcr & ~mask2) | mask1;
4379290564Savos	urtwn_write_4(sc, R92C_RCR, rcr);
4380290564Savos}
4381290564Savos
4382290564Savosstatic void
4383290564Savosurtwn_update_promisc(struct ieee80211com *ic)
4384290564Savos{
4385290564Savos	struct urtwn_softc *sc = ic->ic_softc;
4386290564Savos
4387290564Savos	URTWN_LOCK(sc);
4388290564Savos	if (sc->sc_flags & URTWN_RUNNING)
4389290564Savos		urtwn_set_promisc(sc);
4390290564Savos	URTWN_UNLOCK(sc);
4391290564Savos}
4392290564Savos
4393290564Savosstatic void
4394283540Sglebiusurtwn_update_mcast(struct ieee80211com *ic)
4395251538Srpaulo{
4396251538Srpaulo	/* XXX do nothing?  */
4397251538Srpaulo}
4398251538Srpaulo
4399292167Savosstatic struct ieee80211_node *
4400292167Savosurtwn_r88e_node_alloc(struct ieee80211vap *vap,
4401292167Savos    const uint8_t mac[IEEE80211_ADDR_LEN])
4402292167Savos{
4403292167Savos	struct urtwn_node *un;
4404292167Savos
4405292167Savos	un = malloc(sizeof (struct urtwn_node), M_80211_NODE,
4406292167Savos	    M_NOWAIT | M_ZERO);
4407292167Savos
4408292167Savos	if (un == NULL)
4409292167Savos		return NULL;
4410292167Savos
4411292167Savos	un->id = URTWN_MACID_UNDEFINED;
4412292167Savos
4413292167Savos	return &un->ni;
4414292167Savos}
4415292167Savos
4416251538Srpaulostatic void
4417292167Savosurtwn_r88e_newassoc(struct ieee80211_node *ni, int isnew)
4418292167Savos{
4419292167Savos	struct urtwn_softc *sc = ni->ni_ic->ic_softc;
4420292167Savos	struct urtwn_node *un = URTWN_NODE(ni);
4421292167Savos	uint8_t id;
4422292167Savos
4423292167Savos	if (!isnew)
4424292167Savos		return;
4425292167Savos
4426292167Savos	URTWN_NT_LOCK(sc);
4427292167Savos	for (id = 0; id <= URTWN_MACID_MAX(sc); id++) {
4428292167Savos		if (id != URTWN_MACID_BC && sc->node_list[id] == NULL) {
4429292167Savos			un->id = id;
4430292167Savos			sc->node_list[id] = ni;
4431292167Savos			break;
4432292167Savos		}
4433292167Savos	}
4434292167Savos	URTWN_NT_UNLOCK(sc);
4435292167Savos
4436292167Savos	if (id > URTWN_MACID_MAX(sc)) {
4437292167Savos		device_printf(sc->sc_dev, "%s: node table is full\n",
4438292167Savos		    __func__);
4439292167Savos	}
4440292167Savos}
4441292167Savos
4442292167Savosstatic void
4443292167Savosurtwn_r88e_node_free(struct ieee80211_node *ni)
4444292167Savos{
4445292167Savos	struct urtwn_softc *sc = ni->ni_ic->ic_softc;
4446292167Savos	struct urtwn_node *un = URTWN_NODE(ni);
4447292167Savos
4448292167Savos	URTWN_NT_LOCK(sc);
4449292167Savos	if (un->id != URTWN_MACID_UNDEFINED)
4450292167Savos		sc->node_list[un->id] = NULL;
4451292167Savos	URTWN_NT_UNLOCK(sc);
4452292167Savos
4453292167Savos	sc->sc_node_free(ni);
4454292167Savos}
4455292167Savos
4456292167Savosstatic void
4457251538Srpaulourtwn_set_chan(struct urtwn_softc *sc, struct ieee80211_channel *c,
4458251538Srpaulo    struct ieee80211_channel *extc)
4459251538Srpaulo{
4460287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
4461251538Srpaulo	uint32_t reg;
4462251538Srpaulo	u_int chan;
4463251538Srpaulo	int i;
4464251538Srpaulo
4465251538Srpaulo	chan = ieee80211_chan2ieee(ic, c);	/* XXX center freq! */
4466251538Srpaulo	if (chan == 0 || chan == IEEE80211_CHAN_ANY) {
4467251538Srpaulo		device_printf(sc->sc_dev,
4468251538Srpaulo		    "%s: invalid channel %x\n", __func__, chan);
4469251538Srpaulo		return;
4470251538Srpaulo	}
4471251538Srpaulo
4472251538Srpaulo	/* Set Tx power for this new channel. */
4473251538Srpaulo	urtwn_set_txpower(sc, c, extc);
4474251538Srpaulo
4475251538Srpaulo	for (i = 0; i < sc->nrxchains; i++) {
4476251538Srpaulo		urtwn_rf_write(sc, i, R92C_RF_CHNLBW,
4477251538Srpaulo		    RW(sc->rf_chnlbw[i], R92C_RF_CHNLBW_CHNL, chan));
4478251538Srpaulo	}
4479251538Srpaulo#ifndef IEEE80211_NO_HT
4480251538Srpaulo	if (extc != NULL) {
4481251538Srpaulo		/* Is secondary channel below or above primary? */
4482251538Srpaulo		int prichlo = c->ic_freq < extc->ic_freq;
4483251538Srpaulo
4484251538Srpaulo		urtwn_write_1(sc, R92C_BWOPMODE,
4485251538Srpaulo		    urtwn_read_1(sc, R92C_BWOPMODE) & ~R92C_BWOPMODE_20MHZ);
4486251538Srpaulo
4487251538Srpaulo		reg = urtwn_read_1(sc, R92C_RRSR + 2);
4488251538Srpaulo		reg = (reg & ~0x6f) | (prichlo ? 1 : 2) << 5;
4489251538Srpaulo		urtwn_write_1(sc, R92C_RRSR + 2, reg);
4490251538Srpaulo
4491251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_RFMOD,
4492251538Srpaulo		    urtwn_bb_read(sc, R92C_FPGA0_RFMOD) | R92C_RFMOD_40MHZ);
4493251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA1_RFMOD,
4494251538Srpaulo		    urtwn_bb_read(sc, R92C_FPGA1_RFMOD) | R92C_RFMOD_40MHZ);
4495251538Srpaulo
4496251538Srpaulo		/* Set CCK side band. */
4497251538Srpaulo		reg = urtwn_bb_read(sc, R92C_CCK0_SYSTEM);
4498251538Srpaulo		reg = (reg & ~0x00000010) | (prichlo ? 0 : 1) << 4;
4499251538Srpaulo		urtwn_bb_write(sc, R92C_CCK0_SYSTEM, reg);
4500251538Srpaulo
4501251538Srpaulo		reg = urtwn_bb_read(sc, R92C_OFDM1_LSTF);
4502251538Srpaulo		reg = (reg & ~0x00000c00) | (prichlo ? 1 : 2) << 10;
4503251538Srpaulo		urtwn_bb_write(sc, R92C_OFDM1_LSTF, reg);
4504251538Srpaulo
4505251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_ANAPARAM2,
4506251538Srpaulo		    urtwn_bb_read(sc, R92C_FPGA0_ANAPARAM2) &
4507251538Srpaulo		    ~R92C_FPGA0_ANAPARAM2_CBW20);
4508251538Srpaulo
4509251538Srpaulo		reg = urtwn_bb_read(sc, 0x818);
4510251538Srpaulo		reg = (reg & ~0x0c000000) | (prichlo ? 2 : 1) << 26;
4511251538Srpaulo		urtwn_bb_write(sc, 0x818, reg);
4512251538Srpaulo
4513251538Srpaulo		/* Select 40MHz bandwidth. */
4514251538Srpaulo		urtwn_rf_write(sc, 0, R92C_RF_CHNLBW,
4515251538Srpaulo		    (sc->rf_chnlbw[0] & ~0xfff) | chan);
4516251538Srpaulo	} else
4517251538Srpaulo#endif
4518251538Srpaulo	{
4519251538Srpaulo		urtwn_write_1(sc, R92C_BWOPMODE,
4520251538Srpaulo		    urtwn_read_1(sc, R92C_BWOPMODE) | R92C_BWOPMODE_20MHZ);
4521251538Srpaulo
4522251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA0_RFMOD,
4523251538Srpaulo		    urtwn_bb_read(sc, R92C_FPGA0_RFMOD) & ~R92C_RFMOD_40MHZ);
4524251538Srpaulo		urtwn_bb_write(sc, R92C_FPGA1_RFMOD,
4525251538Srpaulo		    urtwn_bb_read(sc, R92C_FPGA1_RFMOD) & ~R92C_RFMOD_40MHZ);
4526251538Srpaulo
4527264912Skevlo		if (!(sc->chip & URTWN_CHIP_88E)) {
4528264912Skevlo			urtwn_bb_write(sc, R92C_FPGA0_ANAPARAM2,
4529264912Skevlo			    urtwn_bb_read(sc, R92C_FPGA0_ANAPARAM2) |
4530264912Skevlo			    R92C_FPGA0_ANAPARAM2_CBW20);
4531264912Skevlo		}
4532281069Srpaulo
4533251538Srpaulo		/* Select 20MHz bandwidth. */
4534251538Srpaulo		urtwn_rf_write(sc, 0, R92C_RF_CHNLBW,
4535281069Srpaulo		    (sc->rf_chnlbw[0] & ~0xfff) | chan |
4536264912Skevlo		    ((sc->chip & URTWN_CHIP_88E) ? R88E_RF_CHNLBW_BW20 :
4537264912Skevlo		    R92C_RF_CHNLBW_BW20));
4538251538Srpaulo	}
4539251538Srpaulo}
4540251538Srpaulo
4541251538Srpaulostatic void
4542251538Srpaulourtwn_iq_calib(struct urtwn_softc *sc)
4543251538Srpaulo{
4544251538Srpaulo	/* TODO */
4545251538Srpaulo}
4546251538Srpaulo
4547251538Srpaulostatic void
4548251538Srpaulourtwn_lc_calib(struct urtwn_softc *sc)
4549251538Srpaulo{
4550251538Srpaulo	uint32_t rf_ac[2];
4551251538Srpaulo	uint8_t txmode;
4552251538Srpaulo	int i;
4553251538Srpaulo
4554251538Srpaulo	txmode = urtwn_read_1(sc, R92C_OFDM1_LSTF + 3);
4555251538Srpaulo	if ((txmode & 0x70) != 0) {
4556251538Srpaulo		/* Disable all continuous Tx. */
4557251538Srpaulo		urtwn_write_1(sc, R92C_OFDM1_LSTF + 3, txmode & ~0x70);
4558251538Srpaulo
4559251538Srpaulo		/* Set RF mode to standby mode. */
4560251538Srpaulo		for (i = 0; i < sc->nrxchains; i++) {
4561251538Srpaulo			rf_ac[i] = urtwn_rf_read(sc, i, R92C_RF_AC);
4562251538Srpaulo			urtwn_rf_write(sc, i, R92C_RF_AC,
4563251538Srpaulo			    RW(rf_ac[i], R92C_RF_AC_MODE,
4564251538Srpaulo				R92C_RF_AC_MODE_STANDBY));
4565251538Srpaulo		}
4566251538Srpaulo	} else {
4567251538Srpaulo		/* Block all Tx queues. */
4568293180Savos		urtwn_write_1(sc, R92C_TXPAUSE, R92C_TX_QUEUE_ALL);
4569251538Srpaulo	}
4570251538Srpaulo	/* Start calibration. */
4571251538Srpaulo	urtwn_rf_write(sc, 0, R92C_RF_CHNLBW,
4572251538Srpaulo	    urtwn_rf_read(sc, 0, R92C_RF_CHNLBW) | R92C_RF_CHNLBW_LCSTART);
4573251538Srpaulo
4574251538Srpaulo	/* Give calibration the time to complete. */
4575266472Shselasky	usb_pause_mtx(&sc->sc_mtx, hz / 10);		/* 100ms */
4576251538Srpaulo
4577251538Srpaulo	/* Restore configuration. */
4578251538Srpaulo	if ((txmode & 0x70) != 0) {
4579251538Srpaulo		/* Restore Tx mode. */
4580251538Srpaulo		urtwn_write_1(sc, R92C_OFDM1_LSTF + 3, txmode);
4581251538Srpaulo		/* Restore RF mode. */
4582251538Srpaulo		for (i = 0; i < sc->nrxchains; i++)
4583251538Srpaulo			urtwn_rf_write(sc, i, R92C_RF_AC, rf_ac[i]);
4584251538Srpaulo	} else {
4585251538Srpaulo		/* Unblock all Tx queues. */
4586251538Srpaulo		urtwn_write_1(sc, R92C_TXPAUSE, 0x00);
4587251538Srpaulo	}
4588251538Srpaulo}
4589251538Srpaulo
4590294473Savosstatic void
4591294473Savosurtwn_temp_calib(struct urtwn_softc *sc)
4592294473Savos{
4593294473Savos	uint8_t temp;
4594294473Savos
4595294473Savos	URTWN_ASSERT_LOCKED(sc);
4596294473Savos
4597294473Savos	if (!(sc->sc_flags & URTWN_TEMP_MEASURED)) {
4598294473Savos		/* Start measuring temperature. */
4599294473Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP,
4600294473Savos		    "%s: start measuring temperature\n", __func__);
4601294473Savos		if (sc->chip & URTWN_CHIP_88E) {
4602294473Savos			urtwn_rf_write(sc, 0, R88E_RF_T_METER,
4603294473Savos			    R88E_RF_T_METER_START);
4604294473Savos		} else {
4605294473Savos			urtwn_rf_write(sc, 0, R92C_RF_T_METER,
4606294473Savos			    R92C_RF_T_METER_START);
4607294473Savos		}
4608294473Savos		sc->sc_flags |= URTWN_TEMP_MEASURED;
4609294473Savos		return;
4610294473Savos	}
4611294473Savos	sc->sc_flags &= ~URTWN_TEMP_MEASURED;
4612294473Savos
4613294473Savos	/* Read measured temperature. */
4614294473Savos	if (sc->chip & URTWN_CHIP_88E) {
4615294473Savos		temp = MS(urtwn_rf_read(sc, 0, R88E_RF_T_METER),
4616294473Savos		    R88E_RF_T_METER_VAL);
4617294473Savos	} else {
4618294473Savos		temp = MS(urtwn_rf_read(sc, 0, R92C_RF_T_METER),
4619294473Savos		    R92C_RF_T_METER_VAL);
4620294473Savos	}
4621294473Savos	if (temp == 0) {	/* Read failed, skip. */
4622294473Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP,
4623294473Savos		    "%s: temperature read failed, skipping\n", __func__);
4624294473Savos		return;
4625294473Savos	}
4626294473Savos
4627294473Savos	URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP,
4628294473Savos	    "%s: temperature: previous %u, current %u\n",
4629294473Savos	    __func__, sc->thcal_lctemp, temp);
4630294473Savos
4631294473Savos	/*
4632294473Savos	 * Redo LC calibration if temperature changed significantly since
4633294473Savos	 * last calibration.
4634294473Savos	 */
4635294473Savos	if (sc->thcal_lctemp == 0) {
4636294473Savos		/* First LC calibration is performed in urtwn_init(). */
4637294473Savos		sc->thcal_lctemp = temp;
4638294473Savos	} else if (abs(temp - sc->thcal_lctemp) > 1) {
4639294473Savos		URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP,
4640294473Savos		    "%s: LC calib triggered by temp: %u -> %u\n",
4641294473Savos		    __func__, sc->thcal_lctemp, temp);
4642294473Savos		urtwn_lc_calib(sc);
4643294473Savos		/* Record temperature of last LC calibration. */
4644294473Savos		sc->thcal_lctemp = temp;
4645294473Savos	}
4646294473Savos}
4647294473Savos
4648291698Savosstatic int
4649287197Sglebiusurtwn_init(struct urtwn_softc *sc)
4650251538Srpaulo{
4651287197Sglebius	struct ieee80211com *ic = &sc->sc_ic;
4652287197Sglebius	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
4653287197Sglebius	uint8_t macaddr[IEEE80211_ADDR_LEN];
4654251538Srpaulo	uint32_t reg;
4655291698Savos	usb_error_t usb_err = USB_ERR_NORMAL_COMPLETION;
4656251538Srpaulo	int error;
4657251538Srpaulo
4658291698Savos	URTWN_LOCK(sc);
4659291698Savos	if (sc->sc_flags & URTWN_RUNNING) {
4660291698Savos		URTWN_UNLOCK(sc);
4661291698Savos		return (0);
4662291698Savos	}
4663264864Skevlo
4664251538Srpaulo	/* Init firmware commands ring. */
4665251538Srpaulo	sc->fwcur = 0;
4666251538Srpaulo
4667251538Srpaulo	/* Allocate Tx/Rx buffers. */
4668251538Srpaulo	error = urtwn_alloc_rx_list(sc);
4669251538Srpaulo	if (error != 0)
4670251538Srpaulo		goto fail;
4671281069Srpaulo
4672251538Srpaulo	error = urtwn_alloc_tx_list(sc);
4673251538Srpaulo	if (error != 0)
4674251538Srpaulo		goto fail;
4675251538Srpaulo
4676251538Srpaulo	/* Power on adapter. */
4677251538Srpaulo	error = urtwn_power_on(sc);
4678251538Srpaulo	if (error != 0)
4679251538Srpaulo		goto fail;
4680251538Srpaulo
4681251538Srpaulo	/* Initialize DMA. */
4682251538Srpaulo	error = urtwn_dma_init(sc);
4683251538Srpaulo	if (error != 0)
4684251538Srpaulo		goto fail;
4685251538Srpaulo
4686251538Srpaulo	/* Set info size in Rx descriptors (in 64-bit words). */
4687251538Srpaulo	urtwn_write_1(sc, R92C_RX_DRVINFO_SZ, 4);
4688251538Srpaulo
4689251538Srpaulo	/* Init interrupts. */
4690264912Skevlo	if (sc->chip & URTWN_CHIP_88E) {
4691291698Savos		usb_err = urtwn_write_4(sc, R88E_HISR, 0xffffffff);
4692291698Savos		if (usb_err != USB_ERR_NORMAL_COMPLETION)
4693291698Savos			goto fail;
4694291698Savos		usb_err = urtwn_write_4(sc, R88E_HIMR, R88E_HIMR_CPWM | R88E_HIMR_CPWM2 |
4695264912Skevlo		    R88E_HIMR_TBDER | R88E_HIMR_PSTIMEOUT);
4696291698Savos		if (usb_err != USB_ERR_NORMAL_COMPLETION)
4697291698Savos			goto fail;
4698291698Savos		usb_err = urtwn_write_4(sc, R88E_HIMRE, R88E_HIMRE_RXFOVW |
4699264912Skevlo		    R88E_HIMRE_TXFOVW | R88E_HIMRE_RXERR | R88E_HIMRE_TXERR);
4700291698Savos		if (usb_err != USB_ERR_NORMAL_COMPLETION)
4701291698Savos			goto fail;
4702291698Savos		usb_err = urtwn_write_1(sc, R92C_USB_SPECIAL_OPTION,
4703264912Skevlo		    urtwn_read_1(sc, R92C_USB_SPECIAL_OPTION) |
4704264912Skevlo		    R92C_USB_SPECIAL_OPTION_INT_BULK_SEL);
4705291698Savos		if (usb_err != USB_ERR_NORMAL_COMPLETION)
4706291698Savos			goto fail;
4707264912Skevlo	} else {
4708291698Savos		usb_err = urtwn_write_4(sc, R92C_HISR, 0xffffffff);
4709291698Savos		if (usb_err != USB_ERR_NORMAL_COMPLETION)
4710291698Savos			goto fail;
4711291698Savos		usb_err = urtwn_write_4(sc, R92C_HIMR, 0xffffffff);
4712291698Savos		if (usb_err != USB_ERR_NORMAL_COMPLETION)
4713291698Savos			goto fail;
4714264912Skevlo	}
4715251538Srpaulo
4716251538Srpaulo	/* Set MAC address. */
4717287197Sglebius	IEEE80211_ADDR_COPY(macaddr, vap ? vap->iv_myaddr : ic->ic_macaddr);
4718291698Savos	usb_err = urtwn_write_region_1(sc, R92C_MACID, macaddr, IEEE80211_ADDR_LEN);
4719291698Savos	if (usb_err != USB_ERR_NORMAL_COMPLETION)
4720291698Savos		goto fail;
4721251538Srpaulo
4722251538Srpaulo	/* Set initial network type. */
4723289811Savos	urtwn_set_mode(sc, R92C_MSR_INFRA);
4724251538Srpaulo
4725290564Savos	/* Initialize Rx filter. */
4726251538Srpaulo	urtwn_rxfilter_init(sc);
4727251538Srpaulo
4728282623Skevlo	/* Set response rate. */
4729251538Srpaulo	reg = urtwn_read_4(sc, R92C_RRSR);
4730251538Srpaulo	reg = RW(reg, R92C_RRSR_RATE_BITMAP, R92C_RRSR_RATE_CCK_ONLY_1M);
4731251538Srpaulo	urtwn_write_4(sc, R92C_RRSR, reg);
4732251538Srpaulo
4733251538Srpaulo	/* Set short/long retry limits. */
4734251538Srpaulo	urtwn_write_2(sc, R92C_RL,
4735251538Srpaulo	    SM(R92C_RL_SRL, 0x30) | SM(R92C_RL_LRL, 0x30));
4736251538Srpaulo
4737251538Srpaulo	/* Initialize EDCA parameters. */
4738251538Srpaulo	urtwn_edca_init(sc);
4739251538Srpaulo
4740251538Srpaulo	/* Setup rate fallback. */
4741264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E)) {
4742264912Skevlo		urtwn_write_4(sc, R92C_DARFRC + 0, 0x00000000);
4743264912Skevlo		urtwn_write_4(sc, R92C_DARFRC + 4, 0x10080404);
4744264912Skevlo		urtwn_write_4(sc, R92C_RARFRC + 0, 0x04030201);
4745264912Skevlo		urtwn_write_4(sc, R92C_RARFRC + 4, 0x08070605);
4746264912Skevlo	}
4747251538Srpaulo
4748251538Srpaulo	urtwn_write_1(sc, R92C_FWHW_TXQ_CTRL,
4749251538Srpaulo	    urtwn_read_1(sc, R92C_FWHW_TXQ_CTRL) |
4750251538Srpaulo	    R92C_FWHW_TXQ_CTRL_AMPDU_RTY_NEW);
4751251538Srpaulo	/* Set ACK timeout. */
4752251538Srpaulo	urtwn_write_1(sc, R92C_ACKTO, 0x40);
4753251538Srpaulo
4754251538Srpaulo	/* Setup USB aggregation. */
4755251538Srpaulo	reg = urtwn_read_4(sc, R92C_TDECTRL);
4756251538Srpaulo	reg = RW(reg, R92C_TDECTRL_BLK_DESC_NUM, 6);
4757251538Srpaulo	urtwn_write_4(sc, R92C_TDECTRL, reg);
4758251538Srpaulo	urtwn_write_1(sc, R92C_TRXDMA_CTRL,
4759251538Srpaulo	    urtwn_read_1(sc, R92C_TRXDMA_CTRL) |
4760251538Srpaulo	    R92C_TRXDMA_CTRL_RXDMA_AGG_EN);
4761251538Srpaulo	urtwn_write_1(sc, R92C_RXDMA_AGG_PG_TH, 48);
4762264912Skevlo	if (sc->chip & URTWN_CHIP_88E)
4763264912Skevlo		urtwn_write_1(sc, R92C_RXDMA_AGG_PG_TH + 1, 4);
4764282266Skevlo	else {
4765264912Skevlo		urtwn_write_1(sc, R92C_USB_DMA_AGG_TO, 4);
4766282266Skevlo		urtwn_write_1(sc, R92C_USB_SPECIAL_OPTION,
4767282266Skevlo		    urtwn_read_1(sc, R92C_USB_SPECIAL_OPTION) |
4768282266Skevlo		    R92C_USB_SPECIAL_OPTION_AGG_EN);
4769282266Skevlo		urtwn_write_1(sc, R92C_USB_AGG_TH, 8);
4770282266Skevlo		urtwn_write_1(sc, R92C_USB_AGG_TO, 6);
4771282266Skevlo	}
4772251538Srpaulo
4773251538Srpaulo	/* Initialize beacon parameters. */
4774264912Skevlo	urtwn_write_2(sc, R92C_BCN_CTRL, 0x1010);
4775251538Srpaulo	urtwn_write_2(sc, R92C_TBTT_PROHIBIT, 0x6404);
4776251538Srpaulo	urtwn_write_1(sc, R92C_DRVERLYINT, 0x05);
4777251538Srpaulo	urtwn_write_1(sc, R92C_BCNDMATIM, 0x02);
4778251538Srpaulo	urtwn_write_2(sc, R92C_BCNTCFG, 0x660f);
4779251538Srpaulo
4780264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E)) {
4781264912Skevlo		/* Setup AMPDU aggregation. */
4782264912Skevlo		urtwn_write_4(sc, R92C_AGGLEN_LMT, 0x99997631);	/* MCS7~0 */
4783264912Skevlo		urtwn_write_1(sc, R92C_AGGR_BREAK_TIME, 0x16);
4784264912Skevlo		urtwn_write_2(sc, R92C_MAX_AGGR_NUM, 0x0708);
4785251538Srpaulo
4786264912Skevlo		urtwn_write_1(sc, R92C_BCN_MAX_ERR, 0xff);
4787264912Skevlo	}
4788251538Srpaulo
4789251538Srpaulo	/* Load 8051 microcode. */
4790251538Srpaulo	error = urtwn_load_firmware(sc);
4791251538Srpaulo	if (error != 0)
4792251538Srpaulo		goto fail;
4793251538Srpaulo
4794251538Srpaulo	/* Initialize MAC/BB/RF blocks. */
4795291698Savos	error = urtwn_mac_init(sc);
4796291698Savos	if (error != 0) {
4797291698Savos		device_printf(sc->sc_dev,
4798291698Savos		    "%s: error while initializing MAC block\n", __func__);
4799291698Savos		goto fail;
4800291698Savos	}
4801251538Srpaulo	urtwn_bb_init(sc);
4802251538Srpaulo	urtwn_rf_init(sc);
4803251538Srpaulo
4804290564Savos	/* Reinitialize Rx filter (D3845 is not committed yet). */
4805290564Savos	urtwn_rxfilter_init(sc);
4806290564Savos
4807264912Skevlo	if (sc->chip & URTWN_CHIP_88E) {
4808264912Skevlo		urtwn_write_2(sc, R92C_CR,
4809264912Skevlo		    urtwn_read_2(sc, R92C_CR) | R92C_CR_MACTXEN |
4810264912Skevlo		    R92C_CR_MACRXEN);
4811264912Skevlo	}
4812264912Skevlo
4813251538Srpaulo	/* Turn CCK and OFDM blocks on. */
4814251538Srpaulo	reg = urtwn_bb_read(sc, R92C_FPGA0_RFMOD);
4815251538Srpaulo	reg |= R92C_RFMOD_CCK_EN;
4816291698Savos	usb_err = urtwn_bb_write(sc, R92C_FPGA0_RFMOD, reg);
4817291698Savos	if (usb_err != USB_ERR_NORMAL_COMPLETION)
4818291698Savos		goto fail;
4819251538Srpaulo	reg = urtwn_bb_read(sc, R92C_FPGA0_RFMOD);
4820251538Srpaulo	reg |= R92C_RFMOD_OFDM_EN;
4821291698Savos	usb_err = urtwn_bb_write(sc, R92C_FPGA0_RFMOD, reg);
4822291698Savos	if (usb_err != USB_ERR_NORMAL_COMPLETION)
4823291698Savos		goto fail;
4824251538Srpaulo
4825251538Srpaulo	/* Clear per-station keys table. */
4826251538Srpaulo	urtwn_cam_init(sc);
4827251538Srpaulo
4828292175Savos	/* Enable decryption / encryption. */
4829292175Savos	urtwn_write_2(sc, R92C_SECCFG,
4830292175Savos	    R92C_SECCFG_TXUCKEY_DEF | R92C_SECCFG_RXUCKEY_DEF |
4831292175Savos	    R92C_SECCFG_TXENC_ENA | R92C_SECCFG_RXDEC_ENA |
4832292175Savos	    R92C_SECCFG_TXBCKEY_DEF | R92C_SECCFG_RXBCKEY_DEF);
4833292175Savos
4834292175Savos	/*
4835292175Savos	 * Install static keys (if any).
4836292175Savos	 * Must be called after urtwn_cam_init().
4837292175Savos	 */
4838292175Savos	ieee80211_runtask(ic, &sc->cmdq_task);
4839292175Savos
4840251538Srpaulo	/* Enable hardware sequence numbering. */
4841293180Savos	urtwn_write_1(sc, R92C_HWSEQ_CTRL, R92C_TX_QUEUE_ALL);
4842251538Srpaulo
4843292167Savos	/* Enable per-packet TX report. */
4844292167Savos	if (sc->chip & URTWN_CHIP_88E) {
4845292167Savos		urtwn_write_1(sc, R88E_TX_RPT_CTRL,
4846292167Savos		    urtwn_read_1(sc, R88E_TX_RPT_CTRL) | R88E_TX_RPT1_ENA);
4847292167Savos	}
4848292167Savos
4849251538Srpaulo	/* Perform LO and IQ calibrations. */
4850251538Srpaulo	urtwn_iq_calib(sc);
4851251538Srpaulo	/* Perform LC calibration. */
4852251538Srpaulo	urtwn_lc_calib(sc);
4853251538Srpaulo
4854251538Srpaulo	/* Fix USB interference issue. */
4855264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E)) {
4856264912Skevlo		urtwn_write_1(sc, 0xfe40, 0xe0);
4857264912Skevlo		urtwn_write_1(sc, 0xfe41, 0x8d);
4858264912Skevlo		urtwn_write_1(sc, 0xfe42, 0x80);
4859251538Srpaulo
4860264912Skevlo		urtwn_pa_bias_init(sc);
4861264912Skevlo	}
4862251538Srpaulo
4863251538Srpaulo	/* Initialize GPIO setting. */
4864251538Srpaulo	urtwn_write_1(sc, R92C_GPIO_MUXCFG,
4865251538Srpaulo	    urtwn_read_1(sc, R92C_GPIO_MUXCFG) & ~R92C_GPIO_MUXCFG_ENBT);
4866251538Srpaulo
4867251538Srpaulo	/* Fix for lower temperature. */
4868264912Skevlo	if (!(sc->chip & URTWN_CHIP_88E))
4869264912Skevlo		urtwn_write_1(sc, 0x15, 0xe9);
4870251538Srpaulo
4871251538Srpaulo	usbd_transfer_start(sc->sc_xfer[URTWN_BULK_RX]);
4872251538Srpaulo
4873287197Sglebius	sc->sc_flags |= URTWN_RUNNING;
4874251538Srpaulo
4875251538Srpaulo	callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc);
4876251538Srpaulofail:
4877291698Savos	if (usb_err != USB_ERR_NORMAL_COMPLETION)
4878291698Savos		error = EIO;
4879291698Savos
4880291698Savos	URTWN_UNLOCK(sc);
4881291698Savos
4882291698Savos	return (error);
4883251538Srpaulo}
4884251538Srpaulo
4885251538Srpaulostatic void
4886287197Sglebiusurtwn_stop(struct urtwn_softc *sc)
4887251538Srpaulo{
4888251538Srpaulo
4889291698Savos	URTWN_LOCK(sc);
4890291698Savos	if (!(sc->sc_flags & URTWN_RUNNING)) {
4891291698Savos		URTWN_UNLOCK(sc);
4892291698Savos		return;
4893291698Savos	}
4894291698Savos
4895294473Savos	sc->sc_flags &= ~(URTWN_RUNNING | URTWN_TEMP_MEASURED);
4896294473Savos	sc->thcal_lctemp = 0;
4897251538Srpaulo	callout_stop(&sc->sc_watchdog_ch);
4898251538Srpaulo	urtwn_abort_xfers(sc);
4899288353Sadrian
4900288353Sadrian	urtwn_drain_mbufq(sc);
4901291698Savos	URTWN_UNLOCK(sc);
4902251538Srpaulo}
4903251538Srpaulo
4904251538Srpaulostatic void
4905251538Srpaulourtwn_abort_xfers(struct urtwn_softc *sc)
4906251538Srpaulo{
4907251538Srpaulo	int i;
4908251538Srpaulo
4909251538Srpaulo	URTWN_ASSERT_LOCKED(sc);
4910251538Srpaulo
4911251538Srpaulo	/* abort any pending transfers */
4912251538Srpaulo	for (i = 0; i < URTWN_N_TRANSFER; i++)
4913251538Srpaulo		usbd_transfer_stop(sc->sc_xfer[i]);
4914251538Srpaulo}
4915251538Srpaulo
4916251538Srpaulostatic int
4917251538Srpaulourtwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
4918251538Srpaulo    const struct ieee80211_bpf_params *params)
4919251538Srpaulo{
4920251538Srpaulo	struct ieee80211com *ic = ni->ni_ic;
4921286949Sadrian	struct urtwn_softc *sc = ic->ic_softc;
4922251538Srpaulo	struct urtwn_data *bf;
4923290630Savos	int error;
4924251538Srpaulo
4925251538Srpaulo	/* prevent management frames from being sent if we're not ready */
4926290630Savos	URTWN_LOCK(sc);
4927287197Sglebius	if (!(sc->sc_flags & URTWN_RUNNING)) {
4928290630Savos		error = ENETDOWN;
4929290630Savos		goto end;
4930251538Srpaulo	}
4931290630Savos
4932251538Srpaulo	bf = urtwn_getbuf(sc);
4933251538Srpaulo	if (bf == NULL) {
4934290630Savos		error = ENOBUFS;
4935290630Savos		goto end;
4936251538Srpaulo	}
4937251538Srpaulo
4938292221Savos	if (params == NULL) {
4939292221Savos		/*
4940292221Savos		 * Legacy path; interpret frame contents to decide
4941292221Savos		 * precisely how to send the frame.
4942292221Savos		 */
4943292221Savos		error = urtwn_tx_data(sc, ni, m, bf);
4944292221Savos	} else {
4945292221Savos		/*
4946292221Savos		 * Caller supplied explicit parameters to use in
4947292221Savos		 * sending the frame.
4948292221Savos		 */
4949292221Savos		error = urtwn_tx_raw(sc, ni, m, bf, params);
4950292221Savos	}
4951292221Savos	if (error != 0) {
4952251538Srpaulo		STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next);
4953290630Savos		goto end;
4954251538Srpaulo	}
4955290630Savos
4956288353Sadrian	sc->sc_txtimer = 5;
4957290630Savos	callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc);
4958290630Savos
4959290630Savosend:
4960290630Savos	if (error != 0)
4961290630Savos		m_freem(m);
4962290630Savos
4963251538Srpaulo	URTWN_UNLOCK(sc);
4964251538Srpaulo
4965290630Savos	return (error);
4966251538Srpaulo}
4967251538Srpaulo
4968266472Shselaskystatic void
4969266472Shselaskyurtwn_ms_delay(struct urtwn_softc *sc)
4970266472Shselasky{
4971266472Shselasky	usb_pause_mtx(&sc->sc_mtx, hz / 1000);
4972266472Shselasky}
4973266472Shselasky
4974251538Srpaulostatic device_method_t urtwn_methods[] = {
4975251538Srpaulo	/* Device interface */
4976251538Srpaulo	DEVMETHOD(device_probe,		urtwn_match),
4977251538Srpaulo	DEVMETHOD(device_attach,	urtwn_attach),
4978251538Srpaulo	DEVMETHOD(device_detach,	urtwn_detach),
4979251538Srpaulo
4980264912Skevlo	DEVMETHOD_END
4981251538Srpaulo};
4982251538Srpaulo
4983251538Srpaulostatic driver_t urtwn_driver = {
4984251538Srpaulo	"urtwn",
4985251538Srpaulo	urtwn_methods,
4986251538Srpaulo	sizeof(struct urtwn_softc)
4987251538Srpaulo};
4988251538Srpaulo
4989251538Srpaulostatic devclass_t urtwn_devclass;
4990251538Srpaulo
4991251538SrpauloDRIVER_MODULE(urtwn, uhub, urtwn_driver, urtwn_devclass, NULL, NULL);
4992251538SrpauloMODULE_DEPEND(urtwn, usb, 1, 1, 1);
4993251538SrpauloMODULE_DEPEND(urtwn, wlan, 1, 1, 1);
4994251538SrpauloMODULE_DEPEND(urtwn, firmware, 1, 1, 1);
4995251538SrpauloMODULE_VERSION(urtwn, 1);
4996292080SimpUSB_PNP_HOST_INFO(urtwn_devs);
4997