xref: /freebsd/sys/dev/usb/wlan/if_ural.c (revision 8cfe54400eacd3365af1af9d81d7fec778c8cfa1)
102ac6454SAndrew Thompson /*	$FreeBSD$	*/
202ac6454SAndrew Thompson 
302ac6454SAndrew Thompson /*-
402ac6454SAndrew Thompson  * Copyright (c) 2005, 2006
502ac6454SAndrew Thompson  *	Damien Bergamini <damien.bergamini@free.fr>
602ac6454SAndrew Thompson  *
702ac6454SAndrew Thompson  * Copyright (c) 2006, 2008
85d38a4d4SEd Schouten  *	Hans Petter Selasky <hselasky@FreeBSD.org>
902ac6454SAndrew Thompson  *
1002ac6454SAndrew Thompson  * Permission to use, copy, modify, and distribute this software for any
1102ac6454SAndrew Thompson  * purpose with or without fee is hereby granted, provided that the above
1202ac6454SAndrew Thompson  * copyright notice and this permission notice appear in all copies.
1302ac6454SAndrew Thompson  *
1402ac6454SAndrew Thompson  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1502ac6454SAndrew Thompson  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1602ac6454SAndrew Thompson  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1702ac6454SAndrew Thompson  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1802ac6454SAndrew Thompson  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1902ac6454SAndrew Thompson  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
2002ac6454SAndrew Thompson  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2102ac6454SAndrew Thompson  */
2202ac6454SAndrew Thompson 
2302ac6454SAndrew Thompson #include <sys/cdefs.h>
2402ac6454SAndrew Thompson __FBSDID("$FreeBSD$");
2502ac6454SAndrew Thompson 
2602ac6454SAndrew Thompson /*-
2702ac6454SAndrew Thompson  * Ralink Technology RT2500USB chipset driver
2802ac6454SAndrew Thompson  * http://www.ralinktech.com/
2902ac6454SAndrew Thompson  */
3002ac6454SAndrew Thompson 
315efea30fSAndrew Thompson #include <sys/param.h>
325efea30fSAndrew Thompson #include <sys/sockio.h>
335efea30fSAndrew Thompson #include <sys/sysctl.h>
345efea30fSAndrew Thompson #include <sys/lock.h>
355efea30fSAndrew Thompson #include <sys/mutex.h>
365efea30fSAndrew Thompson #include <sys/mbuf.h>
375efea30fSAndrew Thompson #include <sys/kernel.h>
385efea30fSAndrew Thompson #include <sys/socket.h>
395efea30fSAndrew Thompson #include <sys/systm.h>
405efea30fSAndrew Thompson #include <sys/malloc.h>
415efea30fSAndrew Thompson #include <sys/module.h>
425efea30fSAndrew Thompson #include <sys/bus.h>
435efea30fSAndrew Thompson #include <sys/endian.h>
445efea30fSAndrew Thompson #include <sys/kdb.h>
455efea30fSAndrew Thompson 
465efea30fSAndrew Thompson #include <machine/bus.h>
475efea30fSAndrew Thompson #include <machine/resource.h>
485efea30fSAndrew Thompson #include <sys/rman.h>
495efea30fSAndrew Thompson 
505efea30fSAndrew Thompson #include <net/bpf.h>
515efea30fSAndrew Thompson #include <net/if.h>
5276039bc8SGleb Smirnoff #include <net/if_var.h>
535efea30fSAndrew Thompson #include <net/if_arp.h>
545efea30fSAndrew Thompson #include <net/ethernet.h>
555efea30fSAndrew Thompson #include <net/if_dl.h>
565efea30fSAndrew Thompson #include <net/if_media.h>
575efea30fSAndrew Thompson #include <net/if_types.h>
585efea30fSAndrew Thompson 
595efea30fSAndrew Thompson #ifdef INET
605efea30fSAndrew Thompson #include <netinet/in.h>
615efea30fSAndrew Thompson #include <netinet/in_systm.h>
625efea30fSAndrew Thompson #include <netinet/in_var.h>
635efea30fSAndrew Thompson #include <netinet/if_ether.h>
645efea30fSAndrew Thompson #include <netinet/ip.h>
655efea30fSAndrew Thompson #endif
665efea30fSAndrew Thompson 
675efea30fSAndrew Thompson #include <net80211/ieee80211_var.h>
685efea30fSAndrew Thompson #include <net80211/ieee80211_regdomain.h>
695efea30fSAndrew Thompson #include <net80211/ieee80211_radiotap.h>
70b6108616SRui Paulo #include <net80211/ieee80211_ratectl.h>
7102ac6454SAndrew Thompson 
725efea30fSAndrew Thompson #include <dev/usb/usb.h>
73ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h>
745efea30fSAndrew Thompson #include "usbdevs.h"
7502ac6454SAndrew Thompson 
76ed6d949aSAndrew Thompson #define	USB_DEBUG_VAR ural_debug
77ed6d949aSAndrew Thompson #include <dev/usb/usb_debug.h>
785efea30fSAndrew Thompson 
7902ac6454SAndrew Thompson #include <dev/usb/wlan/if_uralreg.h>
8002ac6454SAndrew Thompson #include <dev/usb/wlan/if_uralvar.h>
8102ac6454SAndrew Thompson 
82b850ecc1SAndrew Thompson #ifdef USB_DEBUG
8302ac6454SAndrew Thompson static int ural_debug = 0;
8402ac6454SAndrew Thompson 
856472ac3dSEd Schouten static SYSCTL_NODE(_hw_usb, OID_AUTO, ural, CTLFLAG_RW, 0, "USB ural");
869360ae40SAndrew Thompson SYSCTL_INT(_hw_usb_ural, OID_AUTO, debug, CTLFLAG_RW, &ural_debug, 0,
8702ac6454SAndrew Thompson     "Debug level");
8802ac6454SAndrew Thompson #endif
8902ac6454SAndrew Thompson 
9002ac6454SAndrew Thompson #define URAL_RSSI(rssi)					\
9102ac6454SAndrew Thompson 	((rssi) > (RAL_NOISE_FLOOR + RAL_RSSI_CORR) ?	\
9202ac6454SAndrew Thompson 	 ((rssi) - (RAL_NOISE_FLOOR + RAL_RSSI_CORR)) : 0)
9302ac6454SAndrew Thompson 
9402ac6454SAndrew Thompson /* various supported device vendors/products */
95f1a16106SHans Petter Selasky static const STRUCT_USB_HOST_ID ural_devs[] = {
969e6b5313SAndrew Thompson #define	URAL_DEV(v,p)  { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
979e6b5313SAndrew Thompson 	URAL_DEV(ASUS, WL167G),
989e6b5313SAndrew Thompson 	URAL_DEV(ASUS, RT2570),
999e6b5313SAndrew Thompson 	URAL_DEV(BELKIN, F5D7050),
1009e6b5313SAndrew Thompson 	URAL_DEV(BELKIN, F5D7051),
1019e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, HU200TS),
1029e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, WUSB54G),
1039e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, WUSB54GP),
1049e6b5313SAndrew Thompson 	URAL_DEV(CONCEPTRONIC2, C54RU),
1059e6b5313SAndrew Thompson 	URAL_DEV(DLINK, DWLG122),
1069e6b5313SAndrew Thompson 	URAL_DEV(GIGABYTE, GN54G),
1079e6b5313SAndrew Thompson 	URAL_DEV(GIGABYTE, GNWBKG),
1089e6b5313SAndrew Thompson 	URAL_DEV(GUILLEMOT, HWGUSB254),
1099e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54),
1109e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54AI),
1119e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54YB),
1129e6b5313SAndrew Thompson 	URAL_DEV(MELCO, NINWIFI),
1139e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570),
1149e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570_2),
1159e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570_3),
1169e6b5313SAndrew Thompson 	URAL_DEV(NOVATECH, NV902),
1179e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570),
1189e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570_2),
1199e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570_3),
1209e6b5313SAndrew Thompson 	URAL_DEV(SIEMENS2, WL54G),
1219e6b5313SAndrew Thompson 	URAL_DEV(SMC, 2862WG),
1229e6b5313SAndrew Thompson 	URAL_DEV(SPHAIRON, UB801R),
1239e6b5313SAndrew Thompson 	URAL_DEV(SURECOM, RT2570),
1249e6b5313SAndrew Thompson 	URAL_DEV(VTECH, RT2570),
1259e6b5313SAndrew Thompson 	URAL_DEV(ZINWELL, RT2570),
1269e6b5313SAndrew Thompson #undef URAL_DEV
12702ac6454SAndrew Thompson };
12802ac6454SAndrew Thompson 
129e0a69b51SAndrew Thompson static usb_callback_t ural_bulk_read_callback;
130e0a69b51SAndrew Thompson static usb_callback_t ural_bulk_write_callback;
13102ac6454SAndrew Thompson 
132e0a69b51SAndrew Thompson static usb_error_t	ural_do_request(struct ural_softc *sc,
133760bc48eSAndrew Thompson 			    struct usb_device_request *req, void *data);
13402ac6454SAndrew Thompson static struct ieee80211vap *ural_vap_create(struct ieee80211com *,
135fcd9500fSBernhard Schmidt 			    const char [IFNAMSIZ], int, enum ieee80211_opmode,
136fcd9500fSBernhard Schmidt 			    int, const uint8_t [IEEE80211_ADDR_LEN],
137fcd9500fSBernhard Schmidt 			    const uint8_t [IEEE80211_ADDR_LEN]);
13802ac6454SAndrew Thompson static void		ural_vap_delete(struct ieee80211vap *);
13902ac6454SAndrew Thompson static void		ural_tx_free(struct ural_tx_data *, int);
14002ac6454SAndrew Thompson static void		ural_setup_tx_list(struct ural_softc *);
14102ac6454SAndrew Thompson static void		ural_unsetup_tx_list(struct ural_softc *);
14202ac6454SAndrew Thompson static int		ural_newstate(struct ieee80211vap *,
14302ac6454SAndrew Thompson 			    enum ieee80211_state, int);
14402ac6454SAndrew Thompson static void		ural_setup_tx_desc(struct ural_softc *,
14502ac6454SAndrew Thompson 			    struct ural_tx_desc *, uint32_t, int, int);
14602ac6454SAndrew Thompson static int		ural_tx_bcn(struct ural_softc *, struct mbuf *,
14702ac6454SAndrew Thompson 			    struct ieee80211_node *);
14802ac6454SAndrew Thompson static int		ural_tx_mgt(struct ural_softc *, struct mbuf *,
14902ac6454SAndrew Thompson 			    struct ieee80211_node *);
15002ac6454SAndrew Thompson static int		ural_tx_data(struct ural_softc *, struct mbuf *,
15102ac6454SAndrew Thompson 			    struct ieee80211_node *);
15202ac6454SAndrew Thompson static void		ural_start(struct ifnet *);
15302ac6454SAndrew Thompson static int		ural_ioctl(struct ifnet *, u_long, caddr_t);
15402ac6454SAndrew Thompson static void		ural_set_testmode(struct ural_softc *);
15502ac6454SAndrew Thompson static void		ural_eeprom_read(struct ural_softc *, uint16_t, void *,
15602ac6454SAndrew Thompson 			    int);
15702ac6454SAndrew Thompson static uint16_t		ural_read(struct ural_softc *, uint16_t);
15802ac6454SAndrew Thompson static void		ural_read_multi(struct ural_softc *, uint16_t, void *,
15902ac6454SAndrew Thompson 			    int);
16002ac6454SAndrew Thompson static void		ural_write(struct ural_softc *, uint16_t, uint16_t);
16102ac6454SAndrew Thompson static void		ural_write_multi(struct ural_softc *, uint16_t, void *,
16202ac6454SAndrew Thompson 			    int) __unused;
16302ac6454SAndrew Thompson static void		ural_bbp_write(struct ural_softc *, uint8_t, uint8_t);
16402ac6454SAndrew Thompson static uint8_t		ural_bbp_read(struct ural_softc *, uint8_t);
16502ac6454SAndrew Thompson static void		ural_rf_write(struct ural_softc *, uint8_t, uint32_t);
16602ac6454SAndrew Thompson static void		ural_scan_start(struct ieee80211com *);
16702ac6454SAndrew Thompson static void		ural_scan_end(struct ieee80211com *);
16802ac6454SAndrew Thompson static void		ural_set_channel(struct ieee80211com *);
16902ac6454SAndrew Thompson static void		ural_set_chan(struct ural_softc *,
17002ac6454SAndrew Thompson 			    struct ieee80211_channel *);
17102ac6454SAndrew Thompson static void		ural_disable_rf_tune(struct ural_softc *);
17202ac6454SAndrew Thompson static void		ural_enable_tsf_sync(struct ural_softc *);
1735463c4a4SSam Leffler static void 		ural_enable_tsf(struct ural_softc *);
17402ac6454SAndrew Thompson static void		ural_update_slot(struct ifnet *);
17502ac6454SAndrew Thompson static void		ural_set_txpreamble(struct ural_softc *);
17602ac6454SAndrew Thompson static void		ural_set_basicrates(struct ural_softc *,
17702ac6454SAndrew Thompson 			    const struct ieee80211_channel *);
17802ac6454SAndrew Thompson static void		ural_set_bssid(struct ural_softc *, const uint8_t *);
17902ac6454SAndrew Thompson static void		ural_set_macaddr(struct ural_softc *, uint8_t *);
18077ddf3d3SAndrew Thompson static void		ural_update_promisc(struct ifnet *);
1815efea30fSAndrew Thompson static void		ural_setpromisc(struct ural_softc *);
18202ac6454SAndrew Thompson static const char	*ural_get_rf(int);
18302ac6454SAndrew Thompson static void		ural_read_eeprom(struct ural_softc *);
18402ac6454SAndrew Thompson static int		ural_bbp_init(struct ural_softc *);
18502ac6454SAndrew Thompson static void		ural_set_txantenna(struct ural_softc *, int);
18602ac6454SAndrew Thompson static void		ural_set_rxantenna(struct ural_softc *, int);
1875efea30fSAndrew Thompson static void		ural_init_locked(struct ural_softc *);
18802ac6454SAndrew Thompson static void		ural_init(void *);
1895efea30fSAndrew Thompson static void		ural_stop(struct ural_softc *);
19002ac6454SAndrew Thompson static int		ural_raw_xmit(struct ieee80211_node *, struct mbuf *,
19102ac6454SAndrew Thompson 			    const struct ieee80211_bpf_params *);
192b6108616SRui Paulo static void		ural_ratectl_start(struct ural_softc *,
19302ac6454SAndrew Thompson 			    struct ieee80211_node *);
194b6108616SRui Paulo static void		ural_ratectl_timeout(void *);
195b6108616SRui Paulo static void		ural_ratectl_task(void *, int);
19602ac6454SAndrew Thompson static int		ural_pause(struct ural_softc *sc, int timeout);
19702ac6454SAndrew Thompson 
19802ac6454SAndrew Thompson /*
19902ac6454SAndrew Thompson  * Default values for MAC registers; values taken from the reference driver.
20002ac6454SAndrew Thompson  */
20102ac6454SAndrew Thompson static const struct {
20202ac6454SAndrew Thompson 	uint16_t	reg;
20302ac6454SAndrew Thompson 	uint16_t	val;
20402ac6454SAndrew Thompson } ural_def_mac[] = {
20502ac6454SAndrew Thompson 	{ RAL_TXRX_CSR5,  0x8c8d },
20602ac6454SAndrew Thompson 	{ RAL_TXRX_CSR6,  0x8b8a },
20702ac6454SAndrew Thompson 	{ RAL_TXRX_CSR7,  0x8687 },
20802ac6454SAndrew Thompson 	{ RAL_TXRX_CSR8,  0x0085 },
20902ac6454SAndrew Thompson 	{ RAL_MAC_CSR13,  0x1111 },
21002ac6454SAndrew Thompson 	{ RAL_MAC_CSR14,  0x1e11 },
21102ac6454SAndrew Thompson 	{ RAL_TXRX_CSR21, 0xe78f },
21202ac6454SAndrew Thompson 	{ RAL_MAC_CSR9,   0xff1d },
21302ac6454SAndrew Thompson 	{ RAL_MAC_CSR11,  0x0002 },
21402ac6454SAndrew Thompson 	{ RAL_MAC_CSR22,  0x0053 },
21502ac6454SAndrew Thompson 	{ RAL_MAC_CSR15,  0x0000 },
21602ac6454SAndrew Thompson 	{ RAL_MAC_CSR8,   RAL_FRAME_SIZE },
21702ac6454SAndrew Thompson 	{ RAL_TXRX_CSR19, 0x0000 },
21802ac6454SAndrew Thompson 	{ RAL_TXRX_CSR18, 0x005a },
21902ac6454SAndrew Thompson 	{ RAL_PHY_CSR2,   0x0000 },
22002ac6454SAndrew Thompson 	{ RAL_TXRX_CSR0,  0x1ec0 },
22102ac6454SAndrew Thompson 	{ RAL_PHY_CSR4,   0x000f }
22202ac6454SAndrew Thompson };
22302ac6454SAndrew Thompson 
22402ac6454SAndrew Thompson /*
22502ac6454SAndrew Thompson  * Default values for BBP registers; values taken from the reference driver.
22602ac6454SAndrew Thompson  */
22702ac6454SAndrew Thompson static const struct {
22802ac6454SAndrew Thompson 	uint8_t	reg;
22902ac6454SAndrew Thompson 	uint8_t	val;
23002ac6454SAndrew Thompson } ural_def_bbp[] = {
23102ac6454SAndrew Thompson 	{  3, 0x02 },
23202ac6454SAndrew Thompson 	{  4, 0x19 },
23302ac6454SAndrew Thompson 	{ 14, 0x1c },
23402ac6454SAndrew Thompson 	{ 15, 0x30 },
23502ac6454SAndrew Thompson 	{ 16, 0xac },
23602ac6454SAndrew Thompson 	{ 17, 0x48 },
23702ac6454SAndrew Thompson 	{ 18, 0x18 },
23802ac6454SAndrew Thompson 	{ 19, 0xff },
23902ac6454SAndrew Thompson 	{ 20, 0x1e },
24002ac6454SAndrew Thompson 	{ 21, 0x08 },
24102ac6454SAndrew Thompson 	{ 22, 0x08 },
24202ac6454SAndrew Thompson 	{ 23, 0x08 },
24302ac6454SAndrew Thompson 	{ 24, 0x80 },
24402ac6454SAndrew Thompson 	{ 25, 0x50 },
24502ac6454SAndrew Thompson 	{ 26, 0x08 },
24602ac6454SAndrew Thompson 	{ 27, 0x23 },
24702ac6454SAndrew Thompson 	{ 30, 0x10 },
24802ac6454SAndrew Thompson 	{ 31, 0x2b },
24902ac6454SAndrew Thompson 	{ 32, 0xb9 },
25002ac6454SAndrew Thompson 	{ 34, 0x12 },
25102ac6454SAndrew Thompson 	{ 35, 0x50 },
25202ac6454SAndrew Thompson 	{ 39, 0xc4 },
25302ac6454SAndrew Thompson 	{ 40, 0x02 },
25402ac6454SAndrew Thompson 	{ 41, 0x60 },
25502ac6454SAndrew Thompson 	{ 53, 0x10 },
25602ac6454SAndrew Thompson 	{ 54, 0x18 },
25702ac6454SAndrew Thompson 	{ 56, 0x08 },
25802ac6454SAndrew Thompson 	{ 57, 0x10 },
25902ac6454SAndrew Thompson 	{ 58, 0x08 },
26002ac6454SAndrew Thompson 	{ 61, 0x60 },
26102ac6454SAndrew Thompson 	{ 62, 0x10 },
26202ac6454SAndrew Thompson 	{ 75, 0xff }
26302ac6454SAndrew Thompson };
26402ac6454SAndrew Thompson 
26502ac6454SAndrew Thompson /*
26602ac6454SAndrew Thompson  * Default values for RF register R2 indexed by channel numbers.
26702ac6454SAndrew Thompson  */
26802ac6454SAndrew Thompson static const uint32_t ural_rf2522_r2[] = {
26902ac6454SAndrew Thompson 	0x307f6, 0x307fb, 0x30800, 0x30805, 0x3080a, 0x3080f, 0x30814,
27002ac6454SAndrew Thompson 	0x30819, 0x3081e, 0x30823, 0x30828, 0x3082d, 0x30832, 0x3083e
27102ac6454SAndrew Thompson };
27202ac6454SAndrew Thompson 
27302ac6454SAndrew Thompson static const uint32_t ural_rf2523_r2[] = {
27402ac6454SAndrew Thompson 	0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
27502ac6454SAndrew Thompson 	0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
27602ac6454SAndrew Thompson };
27702ac6454SAndrew Thompson 
27802ac6454SAndrew Thompson static const uint32_t ural_rf2524_r2[] = {
27902ac6454SAndrew Thompson 	0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
28002ac6454SAndrew Thompson 	0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
28102ac6454SAndrew Thompson };
28202ac6454SAndrew Thompson 
28302ac6454SAndrew Thompson static const uint32_t ural_rf2525_r2[] = {
28402ac6454SAndrew Thompson 	0x20327, 0x20328, 0x20329, 0x2032a, 0x2032b, 0x2032c, 0x2032d,
28502ac6454SAndrew Thompson 	0x2032e, 0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20346
28602ac6454SAndrew Thompson };
28702ac6454SAndrew Thompson 
28802ac6454SAndrew Thompson static const uint32_t ural_rf2525_hi_r2[] = {
28902ac6454SAndrew Thompson 	0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20344, 0x20345,
29002ac6454SAndrew Thompson 	0x20346, 0x20347, 0x20348, 0x20349, 0x2034a, 0x2034b, 0x2034e
29102ac6454SAndrew Thompson };
29202ac6454SAndrew Thompson 
29302ac6454SAndrew Thompson static const uint32_t ural_rf2525e_r2[] = {
29402ac6454SAndrew Thompson 	0x2044d, 0x2044e, 0x2044f, 0x20460, 0x20461, 0x20462, 0x20463,
29502ac6454SAndrew Thompson 	0x20464, 0x20465, 0x20466, 0x20467, 0x20468, 0x20469, 0x2046b
29602ac6454SAndrew Thompson };
29702ac6454SAndrew Thompson 
29802ac6454SAndrew Thompson static const uint32_t ural_rf2526_hi_r2[] = {
29902ac6454SAndrew Thompson 	0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d, 0x0022d,
30002ac6454SAndrew Thompson 	0x0022e, 0x0022e, 0x0022f, 0x0022d, 0x00240, 0x00240, 0x00241
30102ac6454SAndrew Thompson };
30202ac6454SAndrew Thompson 
30302ac6454SAndrew Thompson static const uint32_t ural_rf2526_r2[] = {
30402ac6454SAndrew Thompson 	0x00226, 0x00227, 0x00227, 0x00228, 0x00228, 0x00229, 0x00229,
30502ac6454SAndrew Thompson 	0x0022a, 0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d
30602ac6454SAndrew Thompson };
30702ac6454SAndrew Thompson 
30802ac6454SAndrew Thompson /*
30902ac6454SAndrew Thompson  * For dual-band RF, RF registers R1 and R4 also depend on channel number;
31002ac6454SAndrew Thompson  * values taken from the reference driver.
31102ac6454SAndrew Thompson  */
31202ac6454SAndrew Thompson static const struct {
31302ac6454SAndrew Thompson 	uint8_t		chan;
31402ac6454SAndrew Thompson 	uint32_t	r1;
31502ac6454SAndrew Thompson 	uint32_t	r2;
31602ac6454SAndrew Thompson 	uint32_t	r4;
31702ac6454SAndrew Thompson } ural_rf5222[] = {
31802ac6454SAndrew Thompson 	{   1, 0x08808, 0x0044d, 0x00282 },
31902ac6454SAndrew Thompson 	{   2, 0x08808, 0x0044e, 0x00282 },
32002ac6454SAndrew Thompson 	{   3, 0x08808, 0x0044f, 0x00282 },
32102ac6454SAndrew Thompson 	{   4, 0x08808, 0x00460, 0x00282 },
32202ac6454SAndrew Thompson 	{   5, 0x08808, 0x00461, 0x00282 },
32302ac6454SAndrew Thompson 	{   6, 0x08808, 0x00462, 0x00282 },
32402ac6454SAndrew Thompson 	{   7, 0x08808, 0x00463, 0x00282 },
32502ac6454SAndrew Thompson 	{   8, 0x08808, 0x00464, 0x00282 },
32602ac6454SAndrew Thompson 	{   9, 0x08808, 0x00465, 0x00282 },
32702ac6454SAndrew Thompson 	{  10, 0x08808, 0x00466, 0x00282 },
32802ac6454SAndrew Thompson 	{  11, 0x08808, 0x00467, 0x00282 },
32902ac6454SAndrew Thompson 	{  12, 0x08808, 0x00468, 0x00282 },
33002ac6454SAndrew Thompson 	{  13, 0x08808, 0x00469, 0x00282 },
33102ac6454SAndrew Thompson 	{  14, 0x08808, 0x0046b, 0x00286 },
33202ac6454SAndrew Thompson 
33302ac6454SAndrew Thompson 	{  36, 0x08804, 0x06225, 0x00287 },
33402ac6454SAndrew Thompson 	{  40, 0x08804, 0x06226, 0x00287 },
33502ac6454SAndrew Thompson 	{  44, 0x08804, 0x06227, 0x00287 },
33602ac6454SAndrew Thompson 	{  48, 0x08804, 0x06228, 0x00287 },
33702ac6454SAndrew Thompson 	{  52, 0x08804, 0x06229, 0x00287 },
33802ac6454SAndrew Thompson 	{  56, 0x08804, 0x0622a, 0x00287 },
33902ac6454SAndrew Thompson 	{  60, 0x08804, 0x0622b, 0x00287 },
34002ac6454SAndrew Thompson 	{  64, 0x08804, 0x0622c, 0x00287 },
34102ac6454SAndrew Thompson 
34202ac6454SAndrew Thompson 	{ 100, 0x08804, 0x02200, 0x00283 },
34302ac6454SAndrew Thompson 	{ 104, 0x08804, 0x02201, 0x00283 },
34402ac6454SAndrew Thompson 	{ 108, 0x08804, 0x02202, 0x00283 },
34502ac6454SAndrew Thompson 	{ 112, 0x08804, 0x02203, 0x00283 },
34602ac6454SAndrew Thompson 	{ 116, 0x08804, 0x02204, 0x00283 },
34702ac6454SAndrew Thompson 	{ 120, 0x08804, 0x02205, 0x00283 },
34802ac6454SAndrew Thompson 	{ 124, 0x08804, 0x02206, 0x00283 },
34902ac6454SAndrew Thompson 	{ 128, 0x08804, 0x02207, 0x00283 },
35002ac6454SAndrew Thompson 	{ 132, 0x08804, 0x02208, 0x00283 },
35102ac6454SAndrew Thompson 	{ 136, 0x08804, 0x02209, 0x00283 },
35202ac6454SAndrew Thompson 	{ 140, 0x08804, 0x0220a, 0x00283 },
35302ac6454SAndrew Thompson 
35402ac6454SAndrew Thompson 	{ 149, 0x08808, 0x02429, 0x00281 },
35502ac6454SAndrew Thompson 	{ 153, 0x08808, 0x0242b, 0x00281 },
35602ac6454SAndrew Thompson 	{ 157, 0x08808, 0x0242d, 0x00281 },
35702ac6454SAndrew Thompson 	{ 161, 0x08808, 0x0242f, 0x00281 }
35802ac6454SAndrew Thompson };
35902ac6454SAndrew Thompson 
360760bc48eSAndrew Thompson static const struct usb_config ural_config[URAL_N_TRANSFER] = {
36102ac6454SAndrew Thompson 	[URAL_BULK_WR] = {
36202ac6454SAndrew Thompson 		.type = UE_BULK,
36302ac6454SAndrew Thompson 		.endpoint = UE_ADDR_ANY,
36402ac6454SAndrew Thompson 		.direction = UE_DIR_OUT,
3654eae601eSAndrew Thompson 		.bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4),
3664eae601eSAndrew Thompson 		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
3674eae601eSAndrew Thompson 		.callback = ural_bulk_write_callback,
3684eae601eSAndrew Thompson 		.timeout = 5000,	/* ms */
36902ac6454SAndrew Thompson 	},
37002ac6454SAndrew Thompson 	[URAL_BULK_RD] = {
37102ac6454SAndrew Thompson 		.type = UE_BULK,
37202ac6454SAndrew Thompson 		.endpoint = UE_ADDR_ANY,
37302ac6454SAndrew Thompson 		.direction = UE_DIR_IN,
3744eae601eSAndrew Thompson 		.bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE),
3754eae601eSAndrew Thompson 		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
3764eae601eSAndrew Thompson 		.callback = ural_bulk_read_callback,
37702ac6454SAndrew Thompson 	},
37802ac6454SAndrew Thompson };
37902ac6454SAndrew Thompson 
38002ac6454SAndrew Thompson static device_probe_t ural_match;
38102ac6454SAndrew Thompson static device_attach_t ural_attach;
38202ac6454SAndrew Thompson static device_detach_t ural_detach;
38302ac6454SAndrew Thompson 
38402ac6454SAndrew Thompson static device_method_t ural_methods[] = {
38502ac6454SAndrew Thompson 	/* Device interface */
38602ac6454SAndrew Thompson 	DEVMETHOD(device_probe,		ural_match),
38702ac6454SAndrew Thompson 	DEVMETHOD(device_attach,	ural_attach),
38802ac6454SAndrew Thompson 	DEVMETHOD(device_detach,	ural_detach),
389645e4d17SHans Petter Selasky 	DEVMETHOD_END
39002ac6454SAndrew Thompson };
39102ac6454SAndrew Thompson 
39202ac6454SAndrew Thompson static driver_t ural_driver = {
39302ac6454SAndrew Thompson 	.name = "ural",
39402ac6454SAndrew Thompson 	.methods = ural_methods,
39502ac6454SAndrew Thompson 	.size = sizeof(struct ural_softc),
39602ac6454SAndrew Thompson };
39702ac6454SAndrew Thompson 
39802ac6454SAndrew Thompson static devclass_t ural_devclass;
39902ac6454SAndrew Thompson 
4009aef556dSAndrew Thompson DRIVER_MODULE(ural, uhub, ural_driver, ural_devclass, NULL, 0);
40102ac6454SAndrew Thompson MODULE_DEPEND(ural, usb, 1, 1, 1);
40202ac6454SAndrew Thompson MODULE_DEPEND(ural, wlan, 1, 1, 1);
403910cb8feSAndrew Thompson MODULE_VERSION(ural, 1);
40402ac6454SAndrew Thompson 
40502ac6454SAndrew Thompson static int
40602ac6454SAndrew Thompson ural_match(device_t self)
40702ac6454SAndrew Thompson {
408760bc48eSAndrew Thompson 	struct usb_attach_arg *uaa = device_get_ivars(self);
40902ac6454SAndrew Thompson 
410f29a0724SAndrew Thompson 	if (uaa->usb_mode != USB_MODE_HOST)
41102ac6454SAndrew Thompson 		return (ENXIO);
41202ac6454SAndrew Thompson 	if (uaa->info.bConfigIndex != 0)
41302ac6454SAndrew Thompson 		return (ENXIO);
41402ac6454SAndrew Thompson 	if (uaa->info.bIfaceIndex != RAL_IFACE_INDEX)
41502ac6454SAndrew Thompson 		return (ENXIO);
41602ac6454SAndrew Thompson 
417a593f6b8SAndrew Thompson 	return (usbd_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa));
41802ac6454SAndrew Thompson }
41902ac6454SAndrew Thompson 
42002ac6454SAndrew Thompson static int
42102ac6454SAndrew Thompson ural_attach(device_t self)
42202ac6454SAndrew Thompson {
423760bc48eSAndrew Thompson 	struct usb_attach_arg *uaa = device_get_ivars(self);
42402ac6454SAndrew Thompson 	struct ural_softc *sc = device_get_softc(self);
4255efea30fSAndrew Thompson 	struct ifnet *ifp;
4265efea30fSAndrew Thompson 	struct ieee80211com *ic;
4275efea30fSAndrew Thompson 	uint8_t iface_index, bands;
42802ac6454SAndrew Thompson 	int error;
42902ac6454SAndrew Thompson 
430a593f6b8SAndrew Thompson 	device_set_usb_desc(self);
43102ac6454SAndrew Thompson 	sc->sc_udev = uaa->device;
43202ac6454SAndrew Thompson 	sc->sc_dev = self;
43302ac6454SAndrew Thompson 
43402ac6454SAndrew Thompson 	mtx_init(&sc->sc_mtx, device_get_nameunit(self),
43502ac6454SAndrew Thompson 	    MTX_NETWORK_LOCK, MTX_DEF);
43602ac6454SAndrew Thompson 
43702ac6454SAndrew Thompson 	iface_index = RAL_IFACE_INDEX;
438a593f6b8SAndrew Thompson 	error = usbd_transfer_setup(uaa->device,
43902ac6454SAndrew Thompson 	    &iface_index, sc->sc_xfer, ural_config,
44002ac6454SAndrew Thompson 	    URAL_N_TRANSFER, sc, &sc->sc_mtx);
44102ac6454SAndrew Thompson 	if (error) {
44202ac6454SAndrew Thompson 		device_printf(self, "could not allocate USB transfers, "
443a593f6b8SAndrew Thompson 		    "err=%s\n", usbd_errstr(error));
44402ac6454SAndrew Thompson 		goto detach;
44502ac6454SAndrew Thompson 	}
44602ac6454SAndrew Thompson 
44702ac6454SAndrew Thompson 	RAL_LOCK(sc);
44802ac6454SAndrew Thompson 	/* retrieve RT2570 rev. no */
44902ac6454SAndrew Thompson 	sc->asic_rev = ural_read(sc, RAL_MAC_CSR0);
45002ac6454SAndrew Thompson 
45102ac6454SAndrew Thompson 	/* retrieve MAC address and various other things from EEPROM */
45202ac6454SAndrew Thompson 	ural_read_eeprom(sc);
45302ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
45402ac6454SAndrew Thompson 
4555efea30fSAndrew Thompson 	device_printf(self, "MAC/BBP RT2570 (rev 0x%02x), RF %s\n",
45602ac6454SAndrew Thompson 	    sc->asic_rev, ural_get_rf(sc->rf_rev));
45702ac6454SAndrew Thompson 
45802ac6454SAndrew Thompson 	ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211);
45902ac6454SAndrew Thompson 	if (ifp == NULL) {
46002ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "can not if_alloc()\n");
4615efea30fSAndrew Thompson 		goto detach;
46202ac6454SAndrew Thompson 	}
46302ac6454SAndrew Thompson 	ic = ifp->if_l2com;
46402ac6454SAndrew Thompson 
46502ac6454SAndrew Thompson 	ifp->if_softc = sc;
46602ac6454SAndrew Thompson 	if_initname(ifp, "ural", device_get_unit(sc->sc_dev));
46702ac6454SAndrew Thompson 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
46802ac6454SAndrew Thompson 	ifp->if_init = ural_init;
46902ac6454SAndrew Thompson 	ifp->if_ioctl = ural_ioctl;
47002ac6454SAndrew Thompson 	ifp->if_start = ural_start;
471e50d35e6SMaxim Sobolev 	IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
472e50d35e6SMaxim Sobolev 	ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
47302ac6454SAndrew Thompson 	IFQ_SET_READY(&ifp->if_snd);
47402ac6454SAndrew Thompson 
47502ac6454SAndrew Thompson 	ic->ic_ifp = ifp;
47602ac6454SAndrew Thompson 	ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
47702ac6454SAndrew Thompson 
47802ac6454SAndrew Thompson 	/* set device capabilities */
47902ac6454SAndrew Thompson 	ic->ic_caps =
48002ac6454SAndrew Thompson 	      IEEE80211_C_STA		/* station mode supported */
48102ac6454SAndrew Thompson 	    | IEEE80211_C_IBSS		/* IBSS mode supported */
48202ac6454SAndrew Thompson 	    | IEEE80211_C_MONITOR	/* monitor mode supported */
48302ac6454SAndrew Thompson 	    | IEEE80211_C_HOSTAP	/* HostAp mode supported */
48402ac6454SAndrew Thompson 	    | IEEE80211_C_TXPMGT	/* tx power management */
48502ac6454SAndrew Thompson 	    | IEEE80211_C_SHPREAMBLE	/* short preamble supported */
48602ac6454SAndrew Thompson 	    | IEEE80211_C_SHSLOT	/* short slot time supported */
48702ac6454SAndrew Thompson 	    | IEEE80211_C_BGSCAN	/* bg scanning supported */
48802ac6454SAndrew Thompson 	    | IEEE80211_C_WPA		/* 802.11i */
48902ac6454SAndrew Thompson 	    ;
49002ac6454SAndrew Thompson 
49102ac6454SAndrew Thompson 	bands = 0;
49202ac6454SAndrew Thompson 	setbit(&bands, IEEE80211_MODE_11B);
49302ac6454SAndrew Thompson 	setbit(&bands, IEEE80211_MODE_11G);
49402ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_5222)
49502ac6454SAndrew Thompson 		setbit(&bands, IEEE80211_MODE_11A);
49602ac6454SAndrew Thompson 	ieee80211_init_channels(ic, NULL, &bands);
49702ac6454SAndrew Thompson 
49829aca940SSam Leffler 	ieee80211_ifattach(ic, sc->sc_bssid);
49977ddf3d3SAndrew Thompson 	ic->ic_update_promisc = ural_update_promisc;
50002ac6454SAndrew Thompson 	ic->ic_raw_xmit = ural_raw_xmit;
50102ac6454SAndrew Thompson 	ic->ic_scan_start = ural_scan_start;
50202ac6454SAndrew Thompson 	ic->ic_scan_end = ural_scan_end;
50302ac6454SAndrew Thompson 	ic->ic_set_channel = ural_set_channel;
50402ac6454SAndrew Thompson 
50502ac6454SAndrew Thompson 	ic->ic_vap_create = ural_vap_create;
50602ac6454SAndrew Thompson 	ic->ic_vap_delete = ural_vap_delete;
50702ac6454SAndrew Thompson 
5085463c4a4SSam Leffler 	ieee80211_radiotap_attach(ic,
5095463c4a4SSam Leffler 	    &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
5105463c4a4SSam Leffler 		RAL_TX_RADIOTAP_PRESENT,
5115463c4a4SSam Leffler 	    &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
5125463c4a4SSam Leffler 		RAL_RX_RADIOTAP_PRESENT);
51302ac6454SAndrew Thompson 
51402ac6454SAndrew Thompson 	if (bootverbose)
51502ac6454SAndrew Thompson 		ieee80211_announce(ic);
51602ac6454SAndrew Thompson 
5175efea30fSAndrew Thompson 	return (0);
5185efea30fSAndrew Thompson 
5195efea30fSAndrew Thompson detach:
5205efea30fSAndrew Thompson 	ural_detach(self);
5215efea30fSAndrew Thompson 	return (ENXIO);			/* failure */
52202ac6454SAndrew Thompson }
52302ac6454SAndrew Thompson 
52402ac6454SAndrew Thompson static int
52502ac6454SAndrew Thompson ural_detach(device_t self)
52602ac6454SAndrew Thompson {
52702ac6454SAndrew Thompson 	struct ural_softc *sc = device_get_softc(self);
52802ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
52902ac6454SAndrew Thompson 	struct ieee80211com *ic;
53002ac6454SAndrew Thompson 
531645e4d17SHans Petter Selasky 	/* prevent further ioctls */
532645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
533645e4d17SHans Petter Selasky 	sc->sc_detached = 1;
534645e4d17SHans Petter Selasky 	RAL_UNLOCK(sc);
535645e4d17SHans Petter Selasky 
53602ac6454SAndrew Thompson 	/* stop all USB transfers */
537a593f6b8SAndrew Thompson 	usbd_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER);
53802ac6454SAndrew Thompson 
53902ac6454SAndrew Thompson 	/* free TX list, if any */
54002ac6454SAndrew Thompson 	RAL_LOCK(sc);
54102ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
54202ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
54302ac6454SAndrew Thompson 
54402ac6454SAndrew Thompson 	if (ifp) {
54502ac6454SAndrew Thompson 		ic = ifp->if_l2com;
54602ac6454SAndrew Thompson 		ieee80211_ifdetach(ic);
54702ac6454SAndrew Thompson 		if_free(ifp);
54802ac6454SAndrew Thompson 	}
54902ac6454SAndrew Thompson 	mtx_destroy(&sc->sc_mtx);
55002ac6454SAndrew Thompson 
55102ac6454SAndrew Thompson 	return (0);
55202ac6454SAndrew Thompson }
55302ac6454SAndrew Thompson 
554e0a69b51SAndrew Thompson static usb_error_t
55577ddf3d3SAndrew Thompson ural_do_request(struct ural_softc *sc,
556760bc48eSAndrew Thompson     struct usb_device_request *req, void *data)
55777ddf3d3SAndrew Thompson {
558e0a69b51SAndrew Thompson 	usb_error_t err;
55977ddf3d3SAndrew Thompson 	int ntries = 10;
56077ddf3d3SAndrew Thompson 
56177ddf3d3SAndrew Thompson 	while (ntries--) {
562a593f6b8SAndrew Thompson 		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
56377ddf3d3SAndrew Thompson 		    req, data, 0, NULL, 250 /* ms */);
56477ddf3d3SAndrew Thompson 		if (err == 0)
56577ddf3d3SAndrew Thompson 			break;
56677ddf3d3SAndrew Thompson 
56777ddf3d3SAndrew Thompson 		DPRINTFN(1, "Control request failed, %s (retrying)\n",
568a593f6b8SAndrew Thompson 		    usbd_errstr(err));
56977ddf3d3SAndrew Thompson 		if (ural_pause(sc, hz / 100))
57077ddf3d3SAndrew Thompson 			break;
57177ddf3d3SAndrew Thompson 	}
57277ddf3d3SAndrew Thompson 	return (err);
57377ddf3d3SAndrew Thompson }
57477ddf3d3SAndrew Thompson 
57502ac6454SAndrew Thompson static struct ieee80211vap *
576fcd9500fSBernhard Schmidt ural_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
577fcd9500fSBernhard Schmidt     enum ieee80211_opmode opmode, int flags,
57802ac6454SAndrew Thompson     const uint8_t bssid[IEEE80211_ADDR_LEN],
57902ac6454SAndrew Thompson     const uint8_t mac[IEEE80211_ADDR_LEN])
58002ac6454SAndrew Thompson {
58102ac6454SAndrew Thompson 	struct ural_softc *sc = ic->ic_ifp->if_softc;
58202ac6454SAndrew Thompson 	struct ural_vap *uvp;
58302ac6454SAndrew Thompson 	struct ieee80211vap *vap;
58402ac6454SAndrew Thompson 
58502ac6454SAndrew Thompson 	if (!TAILQ_EMPTY(&ic->ic_vaps))		/* only one at a time */
58602ac6454SAndrew Thompson 		return NULL;
58702ac6454SAndrew Thompson 	uvp = (struct ural_vap *) malloc(sizeof(struct ural_vap),
58802ac6454SAndrew Thompson 	    M_80211_VAP, M_NOWAIT | M_ZERO);
58902ac6454SAndrew Thompson 	if (uvp == NULL)
59002ac6454SAndrew Thompson 		return NULL;
59102ac6454SAndrew Thompson 	vap = &uvp->vap;
59202ac6454SAndrew Thompson 	/* enable s/w bmiss handling for sta mode */
593bb2f69e8SHans Petter Selasky 
594bb2f69e8SHans Petter Selasky 	if (ieee80211_vap_setup(ic, vap, name, unit, opmode,
595bb2f69e8SHans Petter Selasky 	    flags | IEEE80211_CLONE_NOBEACONS, bssid, mac) != 0) {
596bb2f69e8SHans Petter Selasky 		/* out of memory */
597bb2f69e8SHans Petter Selasky 		free(uvp, M_80211_VAP);
598bb2f69e8SHans Petter Selasky 		return (NULL);
599bb2f69e8SHans Petter Selasky 	}
60002ac6454SAndrew Thompson 
60102ac6454SAndrew Thompson 	/* override state transition machine */
60202ac6454SAndrew Thompson 	uvp->newstate = vap->iv_newstate;
60302ac6454SAndrew Thompson 	vap->iv_newstate = ural_newstate;
60402ac6454SAndrew Thompson 
605b6108616SRui Paulo 	usb_callout_init_mtx(&uvp->ratectl_ch, &sc->sc_mtx, 0);
606b6108616SRui Paulo 	TASK_INIT(&uvp->ratectl_task, 0, ural_ratectl_task, uvp);
607b6108616SRui Paulo 	ieee80211_ratectl_init(vap);
608b6108616SRui Paulo 	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
60902ac6454SAndrew Thompson 
61002ac6454SAndrew Thompson 	/* complete setup */
61102ac6454SAndrew Thompson 	ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
61202ac6454SAndrew Thompson 	ic->ic_opmode = opmode;
61302ac6454SAndrew Thompson 	return vap;
61402ac6454SAndrew Thompson }
61502ac6454SAndrew Thompson 
61602ac6454SAndrew Thompson static void
61702ac6454SAndrew Thompson ural_vap_delete(struct ieee80211vap *vap)
61802ac6454SAndrew Thompson {
61902ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6205efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
62102ac6454SAndrew Thompson 
622b6108616SRui Paulo 	usb_callout_drain(&uvp->ratectl_ch);
623b6108616SRui Paulo 	ieee80211_draintask(ic, &uvp->ratectl_task);
624b6108616SRui Paulo 	ieee80211_ratectl_deinit(vap);
62502ac6454SAndrew Thompson 	ieee80211_vap_detach(vap);
62602ac6454SAndrew Thompson 	free(uvp, M_80211_VAP);
62702ac6454SAndrew Thompson }
62802ac6454SAndrew Thompson 
62902ac6454SAndrew Thompson static void
63002ac6454SAndrew Thompson ural_tx_free(struct ural_tx_data *data, int txerr)
63102ac6454SAndrew Thompson {
63202ac6454SAndrew Thompson 	struct ural_softc *sc = data->sc;
63302ac6454SAndrew Thompson 
63402ac6454SAndrew Thompson 	if (data->m != NULL) {
63502ac6454SAndrew Thompson 		if (data->m->m_flags & M_TXCB)
63602ac6454SAndrew Thompson 			ieee80211_process_callback(data->ni, data->m,
63702ac6454SAndrew Thompson 			    txerr ? ETIMEDOUT : 0);
63802ac6454SAndrew Thompson 		m_freem(data->m);
63902ac6454SAndrew Thompson 		data->m = NULL;
64002ac6454SAndrew Thompson 
64102ac6454SAndrew Thompson 		ieee80211_free_node(data->ni);
64202ac6454SAndrew Thompson 		data->ni = NULL;
64302ac6454SAndrew Thompson 	}
64402ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
64502ac6454SAndrew Thompson 	sc->tx_nfree++;
64602ac6454SAndrew Thompson }
64702ac6454SAndrew Thompson 
64802ac6454SAndrew Thompson static void
64902ac6454SAndrew Thompson ural_setup_tx_list(struct ural_softc *sc)
65002ac6454SAndrew Thompson {
65102ac6454SAndrew Thompson 	struct ural_tx_data *data;
65202ac6454SAndrew Thompson 	int i;
65302ac6454SAndrew Thompson 
65402ac6454SAndrew Thompson 	sc->tx_nfree = 0;
65502ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
65602ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
65702ac6454SAndrew Thompson 
65802ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
65902ac6454SAndrew Thompson 		data = &sc->tx_data[i];
66002ac6454SAndrew Thompson 
66102ac6454SAndrew Thompson 		data->sc = sc;
66202ac6454SAndrew Thompson 		STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
66302ac6454SAndrew Thompson 		sc->tx_nfree++;
66402ac6454SAndrew Thompson 	}
66502ac6454SAndrew Thompson }
66602ac6454SAndrew Thompson 
66702ac6454SAndrew Thompson static void
66802ac6454SAndrew Thompson ural_unsetup_tx_list(struct ural_softc *sc)
66902ac6454SAndrew Thompson {
67002ac6454SAndrew Thompson 	struct ural_tx_data *data;
67102ac6454SAndrew Thompson 	int i;
67202ac6454SAndrew Thompson 
67302ac6454SAndrew Thompson 	/* make sure any subsequent use of the queues will fail */
67402ac6454SAndrew Thompson 	sc->tx_nfree = 0;
67502ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
67602ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
67702ac6454SAndrew Thompson 
67802ac6454SAndrew Thompson 	/* free up all node references and mbufs */
67902ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
68002ac6454SAndrew Thompson 		data = &sc->tx_data[i];
68102ac6454SAndrew Thompson 
68202ac6454SAndrew Thompson 		if (data->m != NULL) {
68302ac6454SAndrew Thompson 			m_freem(data->m);
68402ac6454SAndrew Thompson 			data->m = NULL;
68502ac6454SAndrew Thompson 		}
68602ac6454SAndrew Thompson 		if (data->ni != NULL) {
68702ac6454SAndrew Thompson 			ieee80211_free_node(data->ni);
68802ac6454SAndrew Thompson 			data->ni = NULL;
68902ac6454SAndrew Thompson 		}
69002ac6454SAndrew Thompson 	}
69102ac6454SAndrew Thompson }
69202ac6454SAndrew Thompson 
6935efea30fSAndrew Thompson static int
6945efea30fSAndrew Thompson ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
69502ac6454SAndrew Thompson {
69602ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6975efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
6985efea30fSAndrew Thompson 	struct ural_softc *sc = ic->ic_ifp->if_softc;
69902ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
70002ac6454SAndrew Thompson 	struct ieee80211_node *ni;
70102ac6454SAndrew Thompson 	struct mbuf *m;
70202ac6454SAndrew Thompson 
7035efea30fSAndrew Thompson 	DPRINTF("%s -> %s\n",
7045efea30fSAndrew Thompson 		ieee80211_state_name[vap->iv_state],
7055efea30fSAndrew Thompson 		ieee80211_state_name[nstate]);
70602ac6454SAndrew Thompson 
7075efea30fSAndrew Thompson 	IEEE80211_UNLOCK(ic);
7085efea30fSAndrew Thompson 	RAL_LOCK(sc);
709b6108616SRui Paulo 	usb_callout_stop(&uvp->ratectl_ch);
7105efea30fSAndrew Thompson 
7115efea30fSAndrew Thompson 	switch (nstate) {
71202ac6454SAndrew Thompson 	case IEEE80211_S_INIT:
7135efea30fSAndrew Thompson 		if (vap->iv_state == IEEE80211_S_RUN) {
71402ac6454SAndrew Thompson 			/* abort TSF synchronization */
71502ac6454SAndrew Thompson 			ural_write(sc, RAL_TXRX_CSR19, 0);
71602ac6454SAndrew Thompson 
71702ac6454SAndrew Thompson 			/* force tx led to stop blinking */
71802ac6454SAndrew Thompson 			ural_write(sc, RAL_MAC_CSR20, 0);
71902ac6454SAndrew Thompson 		}
72002ac6454SAndrew Thompson 		break;
72102ac6454SAndrew Thompson 
72202ac6454SAndrew Thompson 	case IEEE80211_S_RUN:
7238d8bdb01SAndrew Thompson 		ni = ieee80211_ref_node(vap->iv_bss);
72402ac6454SAndrew Thompson 
72502ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR) {
726bb571462SHans Petter Selasky 			if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
727bb571462SHans Petter Selasky 				RAL_UNLOCK(sc);
728bb571462SHans Petter Selasky 				IEEE80211_LOCK(ic);
729bb571462SHans Petter Selasky 				ieee80211_free_node(ni);
730bb571462SHans Petter Selasky 				return (-1);
731bb571462SHans Petter Selasky 			}
73202ac6454SAndrew Thompson 			ural_update_slot(ic->ic_ifp);
73302ac6454SAndrew Thompson 			ural_set_txpreamble(sc);
73402ac6454SAndrew Thompson 			ural_set_basicrates(sc, ic->ic_bsschan);
73502ac6454SAndrew Thompson 			IEEE80211_ADDR_COPY(sc->sc_bssid, ni->ni_bssid);
73602ac6454SAndrew Thompson 			ural_set_bssid(sc, sc->sc_bssid);
73702ac6454SAndrew Thompson 		}
73802ac6454SAndrew Thompson 
73902ac6454SAndrew Thompson 		if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
74002ac6454SAndrew Thompson 		    vap->iv_opmode == IEEE80211_M_IBSS) {
74102ac6454SAndrew Thompson 			m = ieee80211_beacon_alloc(ni, &uvp->bo);
74202ac6454SAndrew Thompson 			if (m == NULL) {
74302ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
74402ac6454SAndrew Thompson 				    "could not allocate beacon\n");
7455efea30fSAndrew Thompson 				RAL_UNLOCK(sc);
7465efea30fSAndrew Thompson 				IEEE80211_LOCK(ic);
7478d8bdb01SAndrew Thompson 				ieee80211_free_node(ni);
7485efea30fSAndrew Thompson 				return (-1);
74902ac6454SAndrew Thompson 			}
7506fca0210SAndrew Thompson 			ieee80211_ref_node(ni);
75102ac6454SAndrew Thompson 			if (ural_tx_bcn(sc, m, ni) != 0) {
75202ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
75302ac6454SAndrew Thompson 				    "could not send beacon\n");
7545efea30fSAndrew Thompson 				RAL_UNLOCK(sc);
7555efea30fSAndrew Thompson 				IEEE80211_LOCK(ic);
7568d8bdb01SAndrew Thompson 				ieee80211_free_node(ni);
7575efea30fSAndrew Thompson 				return (-1);
75802ac6454SAndrew Thompson 			}
75902ac6454SAndrew Thompson 		}
76002ac6454SAndrew Thompson 
76102ac6454SAndrew Thompson 		/* make tx led blink on tx (controlled by ASIC) */
76202ac6454SAndrew Thompson 		ural_write(sc, RAL_MAC_CSR20, 1);
76302ac6454SAndrew Thompson 
76402ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR)
76502ac6454SAndrew Thompson 			ural_enable_tsf_sync(sc);
7665463c4a4SSam Leffler 		else
7675463c4a4SSam Leffler 			ural_enable_tsf(sc);
76802ac6454SAndrew Thompson 
76902ac6454SAndrew Thompson 		/* enable automatic rate adaptation */
7705463c4a4SSam Leffler 		/* XXX should use ic_bsschan but not valid until after newstate call below */
7715463c4a4SSam Leffler 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
77202ac6454SAndrew Thompson 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
773b6108616SRui Paulo 			ural_ratectl_start(sc, ni);
7748d8bdb01SAndrew Thompson 		ieee80211_free_node(ni);
77502ac6454SAndrew Thompson 		break;
77602ac6454SAndrew Thompson 
77702ac6454SAndrew Thompson 	default:
77802ac6454SAndrew Thompson 		break;
77902ac6454SAndrew Thompson 	}
78002ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
78102ac6454SAndrew Thompson 	IEEE80211_LOCK(ic);
7825efea30fSAndrew Thompson 	return (uvp->newstate(vap, nstate, arg));
78302ac6454SAndrew Thompson }
78402ac6454SAndrew Thompson 
78502ac6454SAndrew Thompson 
78602ac6454SAndrew Thompson static void
787ed6d949aSAndrew Thompson ural_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
78802ac6454SAndrew Thompson {
789ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
79002ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
7915463c4a4SSam Leffler 	struct ieee80211vap *vap;
79202ac6454SAndrew Thompson 	struct ural_tx_data *data;
79302ac6454SAndrew Thompson 	struct mbuf *m;
794ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
795ed6d949aSAndrew Thompson 	int len;
796ed6d949aSAndrew Thompson 
797ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
79802ac6454SAndrew Thompson 
79902ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
80002ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
801ed6d949aSAndrew Thompson 		DPRINTFN(11, "transfer complete, %d bytes\n", len);
80202ac6454SAndrew Thompson 
80302ac6454SAndrew Thompson 		/* free resources */
804ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
80502ac6454SAndrew Thompson 		ural_tx_free(data, 0);
806ed6d949aSAndrew Thompson 		usbd_xfer_set_priv(xfer, NULL);
80702ac6454SAndrew Thompson 
80802ac6454SAndrew Thompson 		ifp->if_opackets++;
80902ac6454SAndrew Thompson 		ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
81002ac6454SAndrew Thompson 
81102ac6454SAndrew Thompson 		/* FALLTHROUGH */
81202ac6454SAndrew Thompson 	case USB_ST_SETUP:
81302ac6454SAndrew Thompson tr_setup:
81402ac6454SAndrew Thompson 		data = STAILQ_FIRST(&sc->tx_q);
81502ac6454SAndrew Thompson 		if (data) {
81602ac6454SAndrew Thompson 			STAILQ_REMOVE_HEAD(&sc->tx_q, next);
81702ac6454SAndrew Thompson 			m = data->m;
81802ac6454SAndrew Thompson 
8196d917491SHans Petter Selasky 			if (m->m_pkthdr.len > (int)(RAL_FRAME_SIZE + RAL_TX_DESC_SIZE)) {
82002ac6454SAndrew Thompson 				DPRINTFN(0, "data overflow, %u bytes\n",
82102ac6454SAndrew Thompson 				    m->m_pkthdr.len);
82202ac6454SAndrew Thompson 				m->m_pkthdr.len = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE);
82302ac6454SAndrew Thompson 			}
824ed6d949aSAndrew Thompson 			pc = usbd_xfer_get_frame(xfer, 0);
825ed6d949aSAndrew Thompson 			usbd_copy_in(pc, 0, &data->desc, RAL_TX_DESC_SIZE);
826ed6d949aSAndrew Thompson 			usbd_m_copy_in(pc, RAL_TX_DESC_SIZE, m, 0,
82702ac6454SAndrew Thompson 			    m->m_pkthdr.len);
82802ac6454SAndrew Thompson 
8295463c4a4SSam Leffler 			vap = data->ni->ni_vap;
8305463c4a4SSam Leffler 			if (ieee80211_radiotap_active_vap(vap)) {
83102ac6454SAndrew Thompson 				struct ural_tx_radiotap_header *tap = &sc->sc_txtap;
83202ac6454SAndrew Thompson 
83302ac6454SAndrew Thompson 				tap->wt_flags = 0;
83402ac6454SAndrew Thompson 				tap->wt_rate = data->rate;
83502ac6454SAndrew Thompson 				tap->wt_antenna = sc->tx_ant;
83602ac6454SAndrew Thompson 
8375463c4a4SSam Leffler 				ieee80211_radiotap_tx(vap, m);
83802ac6454SAndrew Thompson 			}
83902ac6454SAndrew Thompson 
84002ac6454SAndrew Thompson 			/* xfer length needs to be a multiple of two! */
84102ac6454SAndrew Thompson 			len = (RAL_TX_DESC_SIZE + m->m_pkthdr.len + 1) & ~1;
84202ac6454SAndrew Thompson 			if ((len % 64) == 0)
84302ac6454SAndrew Thompson 				len += 2;
84402ac6454SAndrew Thompson 
84502ac6454SAndrew Thompson 			DPRINTFN(11, "sending frame len=%u xferlen=%u\n",
84602ac6454SAndrew Thompson 			    m->m_pkthdr.len, len);
84702ac6454SAndrew Thompson 
848ed6d949aSAndrew Thompson 			usbd_xfer_set_frame_len(xfer, 0, len);
849ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, data);
85002ac6454SAndrew Thompson 
851a593f6b8SAndrew Thompson 			usbd_transfer_submit(xfer);
85202ac6454SAndrew Thompson 		}
853941da6d3SWeongyo Jeong 		RAL_UNLOCK(sc);
854941da6d3SWeongyo Jeong 		ural_start(ifp);
855941da6d3SWeongyo Jeong 		RAL_LOCK(sc);
85602ac6454SAndrew Thompson 		break;
85702ac6454SAndrew Thompson 
85802ac6454SAndrew Thompson 	default:			/* Error */
85902ac6454SAndrew Thompson 		DPRINTFN(11, "transfer error, %s\n",
860ed6d949aSAndrew Thompson 		    usbd_errstr(error));
86102ac6454SAndrew Thompson 
86202ac6454SAndrew Thompson 		ifp->if_oerrors++;
863ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
86402ac6454SAndrew Thompson 		if (data != NULL) {
865ed6d949aSAndrew Thompson 			ural_tx_free(data, error);
866ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, NULL);
86702ac6454SAndrew Thompson 		}
86802ac6454SAndrew Thompson 
869ed6d949aSAndrew Thompson 		if (error == USB_ERR_STALLED) {
87002ac6454SAndrew Thompson 			/* try to clear stall first */
871ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
87202ac6454SAndrew Thompson 			goto tr_setup;
87302ac6454SAndrew Thompson 		}
874ed6d949aSAndrew Thompson 		if (error == USB_ERR_TIMEOUT)
87502ac6454SAndrew Thompson 			device_printf(sc->sc_dev, "device timeout\n");
87602ac6454SAndrew Thompson 		break;
87702ac6454SAndrew Thompson 	}
87802ac6454SAndrew Thompson }
87902ac6454SAndrew Thompson 
88002ac6454SAndrew Thompson static void
881ed6d949aSAndrew Thompson ural_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
88202ac6454SAndrew Thompson {
883ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
88402ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
88502ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
88602ac6454SAndrew Thompson 	struct ieee80211_node *ni;
88702ac6454SAndrew Thompson 	struct mbuf *m = NULL;
888ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
88902ac6454SAndrew Thompson 	uint32_t flags;
8905463c4a4SSam Leffler 	int8_t rssi = 0, nf = 0;
891ed6d949aSAndrew Thompson 	int len;
892ed6d949aSAndrew Thompson 
893ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
89402ac6454SAndrew Thompson 
89502ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
89602ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
89702ac6454SAndrew Thompson 
898ed6d949aSAndrew Thompson 		DPRINTFN(15, "rx done, actlen=%d\n", len);
89902ac6454SAndrew Thompson 
9006d917491SHans Petter Selasky 		if (len < (int)(RAL_RX_DESC_SIZE + IEEE80211_MIN_LEN)) {
90102ac6454SAndrew Thompson 			DPRINTF("%s: xfer too short %d\n",
90202ac6454SAndrew Thompson 			    device_get_nameunit(sc->sc_dev), len);
90302ac6454SAndrew Thompson 			ifp->if_ierrors++;
90402ac6454SAndrew Thompson 			goto tr_setup;
90502ac6454SAndrew Thompson 		}
90602ac6454SAndrew Thompson 
90702ac6454SAndrew Thompson 		len -= RAL_RX_DESC_SIZE;
90802ac6454SAndrew Thompson 		/* rx descriptor is located at the end */
909ed6d949aSAndrew Thompson 		pc = usbd_xfer_get_frame(xfer, 0);
910ed6d949aSAndrew Thompson 		usbd_copy_out(pc, len, &sc->sc_rx_desc, RAL_RX_DESC_SIZE);
91102ac6454SAndrew Thompson 
91202ac6454SAndrew Thompson 		rssi = URAL_RSSI(sc->sc_rx_desc.rssi);
9135463c4a4SSam Leffler 		nf = RAL_NOISE_FLOOR;
91402ac6454SAndrew Thompson 		flags = le32toh(sc->sc_rx_desc.flags);
91502ac6454SAndrew Thompson 		if (flags & (RAL_RX_PHY_ERROR | RAL_RX_CRC_ERROR)) {
91602ac6454SAndrew Thompson 			/*
91702ac6454SAndrew Thompson 		         * This should not happen since we did not
91802ac6454SAndrew Thompson 		         * request to receive those frames when we
91902ac6454SAndrew Thompson 		         * filled RAL_TXRX_CSR2:
92002ac6454SAndrew Thompson 		         */
92102ac6454SAndrew Thompson 			DPRINTFN(5, "PHY or CRC error\n");
92202ac6454SAndrew Thompson 			ifp->if_ierrors++;
92302ac6454SAndrew Thompson 			goto tr_setup;
92402ac6454SAndrew Thompson 		}
92502ac6454SAndrew Thompson 
926c6499eccSGleb Smirnoff 		m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
92702ac6454SAndrew Thompson 		if (m == NULL) {
92802ac6454SAndrew Thompson 			DPRINTF("could not allocate mbuf\n");
92902ac6454SAndrew Thompson 			ifp->if_ierrors++;
93002ac6454SAndrew Thompson 			goto tr_setup;
93102ac6454SAndrew Thompson 		}
932ed6d949aSAndrew Thompson 		usbd_copy_out(pc, 0, mtod(m, uint8_t *), len);
93302ac6454SAndrew Thompson 
93402ac6454SAndrew Thompson 		/* finalize mbuf */
93502ac6454SAndrew Thompson 		m->m_pkthdr.rcvif = ifp;
93602ac6454SAndrew Thompson 		m->m_pkthdr.len = m->m_len = (flags >> 16) & 0xfff;
93702ac6454SAndrew Thompson 
9385463c4a4SSam Leffler 		if (ieee80211_radiotap_active(ic)) {
93902ac6454SAndrew Thompson 			struct ural_rx_radiotap_header *tap = &sc->sc_rxtap;
94002ac6454SAndrew Thompson 
9415463c4a4SSam Leffler 			/* XXX set once */
9425463c4a4SSam Leffler 			tap->wr_flags = 0;
94302ac6454SAndrew Thompson 			tap->wr_rate = ieee80211_plcp2rate(sc->sc_rx_desc.rate,
94402ac6454SAndrew Thompson 			    (flags & RAL_RX_OFDM) ?
94502ac6454SAndrew Thompson 			    IEEE80211_T_OFDM : IEEE80211_T_CCK);
94602ac6454SAndrew Thompson 			tap->wr_antenna = sc->rx_ant;
9475463c4a4SSam Leffler 			tap->wr_antsignal = nf + rssi;
9485463c4a4SSam Leffler 			tap->wr_antnoise = nf;
94902ac6454SAndrew Thompson 		}
95002ac6454SAndrew Thompson 		/* Strip trailing 802.11 MAC FCS. */
95102ac6454SAndrew Thompson 		m_adj(m, -IEEE80211_CRC_LEN);
95202ac6454SAndrew Thompson 
95302ac6454SAndrew Thompson 		/* FALLTHROUGH */
95402ac6454SAndrew Thompson 	case USB_ST_SETUP:
95502ac6454SAndrew Thompson tr_setup:
956ed6d949aSAndrew Thompson 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
957a593f6b8SAndrew Thompson 		usbd_transfer_submit(xfer);
95802ac6454SAndrew Thompson 
95902ac6454SAndrew Thompson 		/*
96002ac6454SAndrew Thompson 		 * At the end of a USB callback it is always safe to unlock
96102ac6454SAndrew Thompson 		 * the private mutex of a device! That is why we do the
96202ac6454SAndrew Thompson 		 * "ieee80211_input" here, and not some lines up!
96302ac6454SAndrew Thompson 		 */
96402ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
965941da6d3SWeongyo Jeong 		if (m) {
96602ac6454SAndrew Thompson 			ni = ieee80211_find_rxnode(ic,
96702ac6454SAndrew Thompson 			    mtod(m, struct ieee80211_frame_min *));
96802ac6454SAndrew Thompson 			if (ni != NULL) {
9695463c4a4SSam Leffler 				(void) ieee80211_input(ni, m, rssi, nf);
97002ac6454SAndrew Thompson 				ieee80211_free_node(ni);
97102ac6454SAndrew Thompson 			} else
9725463c4a4SSam Leffler 				(void) ieee80211_input_all(ic, m, rssi, nf);
97302ac6454SAndrew Thompson 		}
974941da6d3SWeongyo Jeong 		if ((ifp->if_drv_flags & IFF_DRV_OACTIVE) == 0 &&
975941da6d3SWeongyo Jeong 		    !IFQ_IS_EMPTY(&ifp->if_snd))
976941da6d3SWeongyo Jeong 			ural_start(ifp);
977941da6d3SWeongyo Jeong 		RAL_LOCK(sc);
97802ac6454SAndrew Thompson 		return;
97902ac6454SAndrew Thompson 
98002ac6454SAndrew Thompson 	default:			/* Error */
981ed6d949aSAndrew Thompson 		if (error != USB_ERR_CANCELLED) {
98202ac6454SAndrew Thompson 			/* try to clear stall first */
983ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
98402ac6454SAndrew Thompson 			goto tr_setup;
98502ac6454SAndrew Thompson 		}
98602ac6454SAndrew Thompson 		return;
98702ac6454SAndrew Thompson 	}
98802ac6454SAndrew Thompson }
98902ac6454SAndrew Thompson 
99002ac6454SAndrew Thompson static uint8_t
99102ac6454SAndrew Thompson ural_plcp_signal(int rate)
99202ac6454SAndrew Thompson {
99302ac6454SAndrew Thompson 	switch (rate) {
99402ac6454SAndrew Thompson 	/* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
99502ac6454SAndrew Thompson 	case 12:	return 0xb;
99602ac6454SAndrew Thompson 	case 18:	return 0xf;
99702ac6454SAndrew Thompson 	case 24:	return 0xa;
99802ac6454SAndrew Thompson 	case 36:	return 0xe;
99902ac6454SAndrew Thompson 	case 48:	return 0x9;
100002ac6454SAndrew Thompson 	case 72:	return 0xd;
100102ac6454SAndrew Thompson 	case 96:	return 0x8;
100202ac6454SAndrew Thompson 	case 108:	return 0xc;
100302ac6454SAndrew Thompson 
100402ac6454SAndrew Thompson 	/* CCK rates (NB: not IEEE std, device-specific) */
100502ac6454SAndrew Thompson 	case 2:		return 0x0;
100602ac6454SAndrew Thompson 	case 4:		return 0x1;
100702ac6454SAndrew Thompson 	case 11:	return 0x2;
100802ac6454SAndrew Thompson 	case 22:	return 0x3;
100902ac6454SAndrew Thompson 	}
101002ac6454SAndrew Thompson 	return 0xff;		/* XXX unsupported/unknown rate */
101102ac6454SAndrew Thompson }
101202ac6454SAndrew Thompson 
101302ac6454SAndrew Thompson static void
101402ac6454SAndrew Thompson ural_setup_tx_desc(struct ural_softc *sc, struct ural_tx_desc *desc,
101502ac6454SAndrew Thompson     uint32_t flags, int len, int rate)
101602ac6454SAndrew Thompson {
101702ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
101802ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
101902ac6454SAndrew Thompson 	uint16_t plcp_length;
102002ac6454SAndrew Thompson 	int remainder;
102102ac6454SAndrew Thompson 
102202ac6454SAndrew Thompson 	desc->flags = htole32(flags);
102302ac6454SAndrew Thompson 	desc->flags |= htole32(RAL_TX_NEWSEQ);
102402ac6454SAndrew Thompson 	desc->flags |= htole32(len << 16);
102502ac6454SAndrew Thompson 
102602ac6454SAndrew Thompson 	desc->wme = htole16(RAL_AIFSN(2) | RAL_LOGCWMIN(3) | RAL_LOGCWMAX(5));
102702ac6454SAndrew Thompson 	desc->wme |= htole16(RAL_IVOFFSET(sizeof (struct ieee80211_frame)));
102802ac6454SAndrew Thompson 
102902ac6454SAndrew Thompson 	/* setup PLCP fields */
103002ac6454SAndrew Thompson 	desc->plcp_signal  = ural_plcp_signal(rate);
103102ac6454SAndrew Thompson 	desc->plcp_service = 4;
103202ac6454SAndrew Thompson 
103302ac6454SAndrew Thompson 	len += IEEE80211_CRC_LEN;
103426d39e2cSSam Leffler 	if (ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM) {
103502ac6454SAndrew Thompson 		desc->flags |= htole32(RAL_TX_OFDM);
103602ac6454SAndrew Thompson 
103702ac6454SAndrew Thompson 		plcp_length = len & 0xfff;
103802ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 6;
103902ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0x3f;
104002ac6454SAndrew Thompson 	} else {
104102ac6454SAndrew Thompson 		plcp_length = (16 * len + rate - 1) / rate;
104202ac6454SAndrew Thompson 		if (rate == 22) {
104302ac6454SAndrew Thompson 			remainder = (16 * len) % 22;
104402ac6454SAndrew Thompson 			if (remainder != 0 && remainder < 7)
104502ac6454SAndrew Thompson 				desc->plcp_service |= RAL_PLCP_LENGEXT;
104602ac6454SAndrew Thompson 		}
104702ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 8;
104802ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0xff;
104902ac6454SAndrew Thompson 
105002ac6454SAndrew Thompson 		if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
105102ac6454SAndrew Thompson 			desc->plcp_signal |= 0x08;
105202ac6454SAndrew Thompson 	}
105302ac6454SAndrew Thompson 
105402ac6454SAndrew Thompson 	desc->iv = 0;
105502ac6454SAndrew Thompson 	desc->eiv = 0;
105602ac6454SAndrew Thompson }
105702ac6454SAndrew Thompson 
105802ac6454SAndrew Thompson #define RAL_TX_TIMEOUT	5000
105902ac6454SAndrew Thompson 
106002ac6454SAndrew Thompson static int
106102ac6454SAndrew Thompson ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
106202ac6454SAndrew Thompson {
106302ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
106402ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
106502ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
106602ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
106702ac6454SAndrew Thompson 	struct ural_tx_data *data;
106802ac6454SAndrew Thompson 
106902ac6454SAndrew Thompson 	if (sc->tx_nfree == 0) {
107002ac6454SAndrew Thompson 		ifp->if_drv_flags |= IFF_DRV_OACTIVE;
107102ac6454SAndrew Thompson 		m_freem(m0);
107202ac6454SAndrew Thompson 		ieee80211_free_node(ni);
1073bb571462SHans Petter Selasky 		return (EIO);
1074bb571462SHans Petter Selasky 	}
1075bb571462SHans Petter Selasky 	if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
1076bb571462SHans Petter Selasky 		m_freem(m0);
1077bb571462SHans Petter Selasky 		ieee80211_free_node(ni);
1078bb571462SHans Petter Selasky 		return (ENXIO);
107902ac6454SAndrew Thompson 	}
108002ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
108102ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
108202ac6454SAndrew Thompson 	sc->tx_nfree--;
108302ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
108402ac6454SAndrew Thompson 
108502ac6454SAndrew Thompson 	data->m = m0;
108602ac6454SAndrew Thompson 	data->ni = ni;
108702ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
108802ac6454SAndrew Thompson 
108902ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc,
109002ac6454SAndrew Thompson 	    RAL_TX_IFS_NEWBACKOFF | RAL_TX_TIMESTAMP, m0->m_pkthdr.len,
109102ac6454SAndrew Thompson 	    tp->mgmtrate);
109202ac6454SAndrew Thompson 
109302ac6454SAndrew Thompson 	DPRINTFN(10, "sending beacon frame len=%u rate=%u\n",
109402ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
109502ac6454SAndrew Thompson 
109602ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1097a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
109802ac6454SAndrew Thompson 
109902ac6454SAndrew Thompson 	return (0);
110002ac6454SAndrew Thompson }
110102ac6454SAndrew Thompson 
110202ac6454SAndrew Thompson static int
110302ac6454SAndrew Thompson ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
110402ac6454SAndrew Thompson {
110502ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
110602ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
110702ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
110802ac6454SAndrew Thompson 	struct ural_tx_data *data;
110902ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
111002ac6454SAndrew Thompson 	struct ieee80211_key *k;
111102ac6454SAndrew Thompson 	uint32_t flags;
111202ac6454SAndrew Thompson 	uint16_t dur;
111302ac6454SAndrew Thompson 
111402ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
111502ac6454SAndrew Thompson 
111602ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
111702ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
111802ac6454SAndrew Thompson 	sc->tx_nfree--;
111902ac6454SAndrew Thompson 
112002ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
112102ac6454SAndrew Thompson 
112202ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
112302ac6454SAndrew Thompson 	if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
112402ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
112502ac6454SAndrew Thompson 		if (k == NULL) {
112602ac6454SAndrew Thompson 			m_freem(m0);
112702ac6454SAndrew Thompson 			return ENOBUFS;
112802ac6454SAndrew Thompson 		}
112902ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
113002ac6454SAndrew Thompson 	}
113102ac6454SAndrew Thompson 
113202ac6454SAndrew Thompson 	data->m = m0;
113302ac6454SAndrew Thompson 	data->ni = ni;
113402ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
113502ac6454SAndrew Thompson 
113602ac6454SAndrew Thompson 	flags = 0;
113702ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
113802ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
113902ac6454SAndrew Thompson 
114026d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, tp->mgmtrate,
114102ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
1142*8cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
114302ac6454SAndrew Thompson 
114402ac6454SAndrew Thompson 		/* tell hardware to add timestamp for probe responses */
114502ac6454SAndrew Thompson 		if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
114602ac6454SAndrew Thompson 		    IEEE80211_FC0_TYPE_MGT &&
114702ac6454SAndrew Thompson 		    (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
114802ac6454SAndrew Thompson 		    IEEE80211_FC0_SUBTYPE_PROBE_RESP)
114902ac6454SAndrew Thompson 			flags |= RAL_TX_TIMESTAMP;
115002ac6454SAndrew Thompson 	}
115102ac6454SAndrew Thompson 
115202ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, tp->mgmtrate);
115302ac6454SAndrew Thompson 
115402ac6454SAndrew Thompson 	DPRINTFN(10, "sending mgt frame len=%u rate=%u\n",
115502ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
115602ac6454SAndrew Thompson 
115702ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1158a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
115902ac6454SAndrew Thompson 
116002ac6454SAndrew Thompson 	return 0;
116102ac6454SAndrew Thompson }
116202ac6454SAndrew Thompson 
116302ac6454SAndrew Thompson static int
116402ac6454SAndrew Thompson ural_sendprot(struct ural_softc *sc,
116502ac6454SAndrew Thompson     const struct mbuf *m, struct ieee80211_node *ni, int prot, int rate)
116602ac6454SAndrew Thompson {
116702ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
116802ac6454SAndrew Thompson 	const struct ieee80211_frame *wh;
116902ac6454SAndrew Thompson 	struct ural_tx_data *data;
117002ac6454SAndrew Thompson 	struct mbuf *mprot;
117102ac6454SAndrew Thompson 	int protrate, ackrate, pktlen, flags, isshort;
117202ac6454SAndrew Thompson 	uint16_t dur;
117302ac6454SAndrew Thompson 
117402ac6454SAndrew Thompson 	KASSERT(prot == IEEE80211_PROT_RTSCTS || prot == IEEE80211_PROT_CTSONLY,
117502ac6454SAndrew Thompson 	    ("protection %d", prot));
117602ac6454SAndrew Thompson 
117702ac6454SAndrew Thompson 	wh = mtod(m, const struct ieee80211_frame *);
117802ac6454SAndrew Thompson 	pktlen = m->m_pkthdr.len + IEEE80211_CRC_LEN;
117902ac6454SAndrew Thompson 
118026d39e2cSSam Leffler 	protrate = ieee80211_ctl_rate(ic->ic_rt, rate);
118126d39e2cSSam Leffler 	ackrate = ieee80211_ack_rate(ic->ic_rt, rate);
118202ac6454SAndrew Thompson 
118302ac6454SAndrew Thompson 	isshort = (ic->ic_flags & IEEE80211_F_SHPREAMBLE) != 0;
11840f817de7SJung-uk Kim 	dur = ieee80211_compute_duration(ic->ic_rt, pktlen, rate, isshort)
118526d39e2cSSam Leffler 	    + ieee80211_ack_duration(ic->ic_rt, rate, isshort);
118602ac6454SAndrew Thompson 	flags = RAL_TX_RETRY(7);
118702ac6454SAndrew Thompson 	if (prot == IEEE80211_PROT_RTSCTS) {
118802ac6454SAndrew Thompson 		/* NB: CTS is the same size as an ACK */
118926d39e2cSSam Leffler 		dur += ieee80211_ack_duration(ic->ic_rt, rate, isshort);
119002ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
119102ac6454SAndrew Thompson 		mprot = ieee80211_alloc_rts(ic, wh->i_addr1, wh->i_addr2, dur);
119202ac6454SAndrew Thompson 	} else {
119302ac6454SAndrew Thompson 		mprot = ieee80211_alloc_cts(ic, ni->ni_vap->iv_myaddr, dur);
119402ac6454SAndrew Thompson 	}
119502ac6454SAndrew Thompson 	if (mprot == NULL) {
119602ac6454SAndrew Thompson 		/* XXX stat + msg */
119702ac6454SAndrew Thompson 		return ENOBUFS;
119802ac6454SAndrew Thompson 	}
119902ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
120002ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
120102ac6454SAndrew Thompson 	sc->tx_nfree--;
120202ac6454SAndrew Thompson 
120302ac6454SAndrew Thompson 	data->m = mprot;
120402ac6454SAndrew Thompson 	data->ni = ieee80211_ref_node(ni);
120502ac6454SAndrew Thompson 	data->rate = protrate;
120602ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, mprot->m_pkthdr.len, protrate);
120702ac6454SAndrew Thompson 
120802ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1209a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
121002ac6454SAndrew Thompson 
121102ac6454SAndrew Thompson 	return 0;
121202ac6454SAndrew Thompson }
121302ac6454SAndrew Thompson 
121402ac6454SAndrew Thompson static int
121502ac6454SAndrew Thompson ural_tx_raw(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
121602ac6454SAndrew Thompson     const struct ieee80211_bpf_params *params)
121702ac6454SAndrew Thompson {
1218515db61dSSam Leffler 	struct ieee80211com *ic = ni->ni_ic;
121902ac6454SAndrew Thompson 	struct ural_tx_data *data;
122002ac6454SAndrew Thompson 	uint32_t flags;
122102ac6454SAndrew Thompson 	int error;
122202ac6454SAndrew Thompson 	int rate;
122302ac6454SAndrew Thompson 
122402ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
122502ac6454SAndrew Thompson 	KASSERT(params != NULL, ("no raw xmit params"));
122602ac6454SAndrew Thompson 
1227515db61dSSam Leffler 	rate = params->ibp_rate0;
1228515db61dSSam Leffler 	if (!ieee80211_isratevalid(ic->ic_rt, rate)) {
122902ac6454SAndrew Thompson 		m_freem(m0);
123002ac6454SAndrew Thompson 		return EINVAL;
123102ac6454SAndrew Thompson 	}
123202ac6454SAndrew Thompson 	flags = 0;
123302ac6454SAndrew Thompson 	if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
123402ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
123502ac6454SAndrew Thompson 	if (params->ibp_flags & (IEEE80211_BPF_RTS|IEEE80211_BPF_CTS)) {
123602ac6454SAndrew Thompson 		error = ural_sendprot(sc, m0, ni,
123702ac6454SAndrew Thompson 		    params->ibp_flags & IEEE80211_BPF_RTS ?
123802ac6454SAndrew Thompson 			 IEEE80211_PROT_RTSCTS : IEEE80211_PROT_CTSONLY,
123902ac6454SAndrew Thompson 		    rate);
124096ca458fSAndrew Thompson 		if (error || sc->tx_nfree == 0) {
124102ac6454SAndrew Thompson 			m_freem(m0);
124296ca458fSAndrew Thompson 			return ENOBUFS;
124302ac6454SAndrew Thompson 		}
124402ac6454SAndrew Thompson 		flags |= RAL_TX_IFS_SIFS;
124502ac6454SAndrew Thompson 	}
124602ac6454SAndrew Thompson 
124796ca458fSAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
124896ca458fSAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
124996ca458fSAndrew Thompson 	sc->tx_nfree--;
125096ca458fSAndrew Thompson 
125102ac6454SAndrew Thompson 	data->m = m0;
125202ac6454SAndrew Thompson 	data->ni = ni;
125302ac6454SAndrew Thompson 	data->rate = rate;
125402ac6454SAndrew Thompson 
125502ac6454SAndrew Thompson 	/* XXX need to setup descriptor ourself */
125602ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
125702ac6454SAndrew Thompson 
125802ac6454SAndrew Thompson 	DPRINTFN(10, "sending raw frame len=%u rate=%u\n",
125902ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
126002ac6454SAndrew Thompson 
126102ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1262a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
126302ac6454SAndrew Thompson 
126402ac6454SAndrew Thompson 	return 0;
126502ac6454SAndrew Thompson }
126602ac6454SAndrew Thompson 
126702ac6454SAndrew Thompson static int
126802ac6454SAndrew Thompson ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
126902ac6454SAndrew Thompson {
127002ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
127102ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
127202ac6454SAndrew Thompson 	struct ural_tx_data *data;
127302ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
127402ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
127502ac6454SAndrew Thompson 	struct ieee80211_key *k;
127602ac6454SAndrew Thompson 	uint32_t flags = 0;
127702ac6454SAndrew Thompson 	uint16_t dur;
127802ac6454SAndrew Thompson 	int error, rate;
127902ac6454SAndrew Thompson 
128002ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
128102ac6454SAndrew Thompson 
128202ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
128302ac6454SAndrew Thompson 
128402ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)];
128502ac6454SAndrew Thompson 	if (IEEE80211_IS_MULTICAST(wh->i_addr1))
128602ac6454SAndrew Thompson 		rate = tp->mcastrate;
128702ac6454SAndrew Thompson 	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
128802ac6454SAndrew Thompson 		rate = tp->ucastrate;
128902ac6454SAndrew Thompson 	else
129002ac6454SAndrew Thompson 		rate = ni->ni_txrate;
129102ac6454SAndrew Thompson 
129202ac6454SAndrew Thompson 	if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
129302ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
129402ac6454SAndrew Thompson 		if (k == NULL) {
129502ac6454SAndrew Thompson 			m_freem(m0);
129602ac6454SAndrew Thompson 			return ENOBUFS;
129702ac6454SAndrew Thompson 		}
129802ac6454SAndrew Thompson 		/* packet header may have moved, reset our local pointer */
129902ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
130002ac6454SAndrew Thompson 	}
130102ac6454SAndrew Thompson 
130202ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
130302ac6454SAndrew Thompson 		int prot = IEEE80211_PROT_NONE;
130402ac6454SAndrew Thompson 		if (m0->m_pkthdr.len + IEEE80211_CRC_LEN > vap->iv_rtsthreshold)
130502ac6454SAndrew Thompson 			prot = IEEE80211_PROT_RTSCTS;
130602ac6454SAndrew Thompson 		else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
130726d39e2cSSam Leffler 		    ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM)
130802ac6454SAndrew Thompson 			prot = ic->ic_protmode;
130902ac6454SAndrew Thompson 		if (prot != IEEE80211_PROT_NONE) {
131002ac6454SAndrew Thompson 			error = ural_sendprot(sc, m0, ni, prot, rate);
131196ca458fSAndrew Thompson 			if (error || sc->tx_nfree == 0) {
131202ac6454SAndrew Thompson 				m_freem(m0);
131396ca458fSAndrew Thompson 				return ENOBUFS;
131402ac6454SAndrew Thompson 			}
131502ac6454SAndrew Thompson 			flags |= RAL_TX_IFS_SIFS;
131602ac6454SAndrew Thompson 		}
131702ac6454SAndrew Thompson 	}
131802ac6454SAndrew Thompson 
131902ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
132002ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
132102ac6454SAndrew Thompson 	sc->tx_nfree--;
132202ac6454SAndrew Thompson 
132302ac6454SAndrew Thompson 	data->m = m0;
132402ac6454SAndrew Thompson 	data->ni = ni;
132502ac6454SAndrew Thompson 	data->rate = rate;
132602ac6454SAndrew Thompson 
132702ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
132802ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
132902ac6454SAndrew Thompson 		flags |= RAL_TX_RETRY(7);
133002ac6454SAndrew Thompson 
133126d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, rate,
133202ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
1333*8cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
133402ac6454SAndrew Thompson 	}
133502ac6454SAndrew Thompson 
133602ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
133702ac6454SAndrew Thompson 
133802ac6454SAndrew Thompson 	DPRINTFN(10, "sending data frame len=%u rate=%u\n",
133902ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
134002ac6454SAndrew Thompson 
134102ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1342a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
134302ac6454SAndrew Thompson 
134402ac6454SAndrew Thompson 	return 0;
134502ac6454SAndrew Thompson }
134602ac6454SAndrew Thompson 
134702ac6454SAndrew Thompson static void
134802ac6454SAndrew Thompson ural_start(struct ifnet *ifp)
134902ac6454SAndrew Thompson {
135002ac6454SAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
135102ac6454SAndrew Thompson 	struct ieee80211_node *ni;
135202ac6454SAndrew Thompson 	struct mbuf *m;
135302ac6454SAndrew Thompson 
135402ac6454SAndrew Thompson 	RAL_LOCK(sc);
135502ac6454SAndrew Thompson 	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
135602ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
135702ac6454SAndrew Thompson 		return;
135802ac6454SAndrew Thompson 	}
135902ac6454SAndrew Thompson 	for (;;) {
136002ac6454SAndrew Thompson 		IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
136102ac6454SAndrew Thompson 		if (m == NULL)
136202ac6454SAndrew Thompson 			break;
136396ca458fSAndrew Thompson 		if (sc->tx_nfree < RAL_TX_MINFREE) {
136402ac6454SAndrew Thompson 			IFQ_DRV_PREPEND(&ifp->if_snd, m);
136502ac6454SAndrew Thompson 			ifp->if_drv_flags |= IFF_DRV_OACTIVE;
136602ac6454SAndrew Thompson 			break;
136702ac6454SAndrew Thompson 		}
136802ac6454SAndrew Thompson 		ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
136902ac6454SAndrew Thompson 		if (ural_tx_data(sc, m, ni) != 0) {
137002ac6454SAndrew Thompson 			ieee80211_free_node(ni);
137102ac6454SAndrew Thompson 			ifp->if_oerrors++;
137202ac6454SAndrew Thompson 			break;
137302ac6454SAndrew Thompson 		}
137402ac6454SAndrew Thompson 	}
137502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
137602ac6454SAndrew Thompson }
137702ac6454SAndrew Thompson 
137802ac6454SAndrew Thompson static int
137902ac6454SAndrew Thompson ural_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
138002ac6454SAndrew Thompson {
138102ac6454SAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
138202ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
138302ac6454SAndrew Thompson 	struct ifreq *ifr = (struct ifreq *) data;
1384645e4d17SHans Petter Selasky 	int error;
1385645e4d17SHans Petter Selasky 	int startall = 0;
1386645e4d17SHans Petter Selasky 
1387645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
1388645e4d17SHans Petter Selasky 	error = sc->sc_detached ? ENXIO : 0;
1389645e4d17SHans Petter Selasky 	RAL_UNLOCK(sc);
1390645e4d17SHans Petter Selasky 	if (error)
1391645e4d17SHans Petter Selasky 		return (error);
139202ac6454SAndrew Thompson 
139302ac6454SAndrew Thompson 	switch (cmd) {
139402ac6454SAndrew Thompson 	case SIOCSIFFLAGS:
139502ac6454SAndrew Thompson 		RAL_LOCK(sc);
139602ac6454SAndrew Thompson 		if (ifp->if_flags & IFF_UP) {
139702ac6454SAndrew Thompson 			if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) {
13985efea30fSAndrew Thompson 				ural_init_locked(sc);
139902ac6454SAndrew Thompson 				startall = 1;
140002ac6454SAndrew Thompson 			} else
14015efea30fSAndrew Thompson 				ural_setpromisc(sc);
140202ac6454SAndrew Thompson 		} else {
14035efea30fSAndrew Thompson 			if (ifp->if_drv_flags & IFF_DRV_RUNNING)
14045efea30fSAndrew Thompson 				ural_stop(sc);
140502ac6454SAndrew Thompson 		}
140602ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
140702ac6454SAndrew Thompson 		if (startall)
140802ac6454SAndrew Thompson 			ieee80211_start_all(ic);
140902ac6454SAndrew Thompson 		break;
141002ac6454SAndrew Thompson 	case SIOCGIFMEDIA:
141102ac6454SAndrew Thompson 	case SIOCSIFMEDIA:
141202ac6454SAndrew Thompson 		error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
141302ac6454SAndrew Thompson 		break;
141402ac6454SAndrew Thompson 	default:
141502ac6454SAndrew Thompson 		error = ether_ioctl(ifp, cmd, data);
141602ac6454SAndrew Thompson 		break;
141702ac6454SAndrew Thompson 	}
141802ac6454SAndrew Thompson 	return error;
141902ac6454SAndrew Thompson }
142002ac6454SAndrew Thompson 
142102ac6454SAndrew Thompson static void
142202ac6454SAndrew Thompson ural_set_testmode(struct ural_softc *sc)
142302ac6454SAndrew Thompson {
1424760bc48eSAndrew Thompson 	struct usb_device_request req;
1425e0a69b51SAndrew Thompson 	usb_error_t error;
142602ac6454SAndrew Thompson 
142702ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
142802ac6454SAndrew Thompson 	req.bRequest = RAL_VENDOR_REQUEST;
142902ac6454SAndrew Thompson 	USETW(req.wValue, 4);
143002ac6454SAndrew Thompson 	USETW(req.wIndex, 1);
143102ac6454SAndrew Thompson 	USETW(req.wLength, 0);
143202ac6454SAndrew Thompson 
143302ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
143402ac6454SAndrew Thompson 	if (error != 0) {
143502ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not set test mode: %s\n",
1436a593f6b8SAndrew Thompson 		    usbd_errstr(error));
143702ac6454SAndrew Thompson 	}
143802ac6454SAndrew Thompson }
143902ac6454SAndrew Thompson 
144002ac6454SAndrew Thompson static void
144102ac6454SAndrew Thompson ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)
144202ac6454SAndrew Thompson {
1443760bc48eSAndrew Thompson 	struct usb_device_request req;
1444e0a69b51SAndrew Thompson 	usb_error_t error;
144502ac6454SAndrew Thompson 
144602ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
144702ac6454SAndrew Thompson 	req.bRequest = RAL_READ_EEPROM;
144802ac6454SAndrew Thompson 	USETW(req.wValue, 0);
144902ac6454SAndrew Thompson 	USETW(req.wIndex, addr);
145002ac6454SAndrew Thompson 	USETW(req.wLength, len);
145102ac6454SAndrew Thompson 
145202ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
145302ac6454SAndrew Thompson 	if (error != 0) {
145402ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1455a593f6b8SAndrew Thompson 		    usbd_errstr(error));
145602ac6454SAndrew Thompson 	}
145702ac6454SAndrew Thompson }
145802ac6454SAndrew Thompson 
145902ac6454SAndrew Thompson static uint16_t
146002ac6454SAndrew Thompson ural_read(struct ural_softc *sc, uint16_t reg)
146102ac6454SAndrew Thompson {
1462760bc48eSAndrew Thompson 	struct usb_device_request req;
1463e0a69b51SAndrew Thompson 	usb_error_t error;
146402ac6454SAndrew Thompson 	uint16_t val;
146502ac6454SAndrew Thompson 
146602ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
146702ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MAC;
146802ac6454SAndrew Thompson 	USETW(req.wValue, 0);
146902ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
147002ac6454SAndrew Thompson 	USETW(req.wLength, sizeof (uint16_t));
147102ac6454SAndrew Thompson 
147202ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, &val);
147302ac6454SAndrew Thompson 	if (error != 0) {
147402ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1475a593f6b8SAndrew Thompson 		    usbd_errstr(error));
147602ac6454SAndrew Thompson 		return 0;
147702ac6454SAndrew Thompson 	}
147802ac6454SAndrew Thompson 
147902ac6454SAndrew Thompson 	return le16toh(val);
148002ac6454SAndrew Thompson }
148102ac6454SAndrew Thompson 
148202ac6454SAndrew Thompson static void
148302ac6454SAndrew Thompson ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
148402ac6454SAndrew Thompson {
1485760bc48eSAndrew Thompson 	struct usb_device_request req;
1486e0a69b51SAndrew Thompson 	usb_error_t error;
148702ac6454SAndrew Thompson 
148802ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
148902ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MULTI_MAC;
149002ac6454SAndrew Thompson 	USETW(req.wValue, 0);
149102ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
149202ac6454SAndrew Thompson 	USETW(req.wLength, len);
149302ac6454SAndrew Thompson 
149402ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
149502ac6454SAndrew Thompson 	if (error != 0) {
149602ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1497a593f6b8SAndrew Thompson 		    usbd_errstr(error));
149802ac6454SAndrew Thompson 	}
149902ac6454SAndrew Thompson }
150002ac6454SAndrew Thompson 
150102ac6454SAndrew Thompson static void
150202ac6454SAndrew Thompson ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)
150302ac6454SAndrew Thompson {
1504760bc48eSAndrew Thompson 	struct usb_device_request req;
1505e0a69b51SAndrew Thompson 	usb_error_t error;
150602ac6454SAndrew Thompson 
150702ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
150802ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MAC;
150902ac6454SAndrew Thompson 	USETW(req.wValue, val);
151002ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
151102ac6454SAndrew Thompson 	USETW(req.wLength, 0);
151202ac6454SAndrew Thompson 
151302ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
151402ac6454SAndrew Thompson 	if (error != 0) {
151502ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1516a593f6b8SAndrew Thompson 		    usbd_errstr(error));
151702ac6454SAndrew Thompson 	}
151802ac6454SAndrew Thompson }
151902ac6454SAndrew Thompson 
152002ac6454SAndrew Thompson static void
152102ac6454SAndrew Thompson ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
152202ac6454SAndrew Thompson {
1523760bc48eSAndrew Thompson 	struct usb_device_request req;
1524e0a69b51SAndrew Thompson 	usb_error_t error;
152502ac6454SAndrew Thompson 
152602ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
152702ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MULTI_MAC;
152802ac6454SAndrew Thompson 	USETW(req.wValue, 0);
152902ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
153002ac6454SAndrew Thompson 	USETW(req.wLength, len);
153102ac6454SAndrew Thompson 
153202ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
153302ac6454SAndrew Thompson 	if (error != 0) {
153402ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1535a593f6b8SAndrew Thompson 		    usbd_errstr(error));
153602ac6454SAndrew Thompson 	}
153702ac6454SAndrew Thompson }
153802ac6454SAndrew Thompson 
153902ac6454SAndrew Thompson static void
154002ac6454SAndrew Thompson ural_bbp_write(struct ural_softc *sc, uint8_t reg, uint8_t val)
154102ac6454SAndrew Thompson {
154202ac6454SAndrew Thompson 	uint16_t tmp;
154302ac6454SAndrew Thompson 	int ntries;
154402ac6454SAndrew Thompson 
154502ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
154602ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
154702ac6454SAndrew Thompson 			break;
154802ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
154902ac6454SAndrew Thompson 			break;
155002ac6454SAndrew Thompson 	}
155102ac6454SAndrew Thompson 	if (ntries == 100) {
155202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to BBP\n");
155302ac6454SAndrew Thompson 		return;
155402ac6454SAndrew Thompson 	}
155502ac6454SAndrew Thompson 
155602ac6454SAndrew Thompson 	tmp = reg << 8 | val;
155702ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, tmp);
155802ac6454SAndrew Thompson }
155902ac6454SAndrew Thompson 
156002ac6454SAndrew Thompson static uint8_t
156102ac6454SAndrew Thompson ural_bbp_read(struct ural_softc *sc, uint8_t reg)
156202ac6454SAndrew Thompson {
156302ac6454SAndrew Thompson 	uint16_t val;
156402ac6454SAndrew Thompson 	int ntries;
156502ac6454SAndrew Thompson 
156602ac6454SAndrew Thompson 	val = RAL_BBP_WRITE | reg << 8;
156702ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, val);
156802ac6454SAndrew Thompson 
156902ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
157002ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
157102ac6454SAndrew Thompson 			break;
157202ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
157302ac6454SAndrew Thompson 			break;
157402ac6454SAndrew Thompson 	}
157502ac6454SAndrew Thompson 	if (ntries == 100) {
157602ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read BBP\n");
157702ac6454SAndrew Thompson 		return 0;
157802ac6454SAndrew Thompson 	}
157902ac6454SAndrew Thompson 
158002ac6454SAndrew Thompson 	return ural_read(sc, RAL_PHY_CSR7) & 0xff;
158102ac6454SAndrew Thompson }
158202ac6454SAndrew Thompson 
158302ac6454SAndrew Thompson static void
158402ac6454SAndrew Thompson ural_rf_write(struct ural_softc *sc, uint8_t reg, uint32_t val)
158502ac6454SAndrew Thompson {
158602ac6454SAndrew Thompson 	uint32_t tmp;
158702ac6454SAndrew Thompson 	int ntries;
158802ac6454SAndrew Thompson 
158902ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
159002ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR10) & RAL_RF_LOBUSY))
159102ac6454SAndrew Thompson 			break;
159202ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
159302ac6454SAndrew Thompson 			break;
159402ac6454SAndrew Thompson 	}
159502ac6454SAndrew Thompson 	if (ntries == 100) {
159602ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to RF\n");
159702ac6454SAndrew Thompson 		return;
159802ac6454SAndrew Thompson 	}
159902ac6454SAndrew Thompson 
160002ac6454SAndrew Thompson 	tmp = RAL_RF_BUSY | RAL_RF_20BIT | (val & 0xfffff) << 2 | (reg & 0x3);
160102ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR9,  tmp & 0xffff);
160202ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR10, tmp >> 16);
160302ac6454SAndrew Thompson 
160402ac6454SAndrew Thompson 	/* remember last written value in sc */
160502ac6454SAndrew Thompson 	sc->rf_regs[reg] = val;
160602ac6454SAndrew Thompson 
160702ac6454SAndrew Thompson 	DPRINTFN(15, "RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff);
160802ac6454SAndrew Thompson }
160902ac6454SAndrew Thompson 
161002ac6454SAndrew Thompson static void
161102ac6454SAndrew Thompson ural_scan_start(struct ieee80211com *ic)
161202ac6454SAndrew Thompson {
16135efea30fSAndrew Thompson 	struct ifnet *ifp = ic->ic_ifp;
16145efea30fSAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
161502ac6454SAndrew Thompson 
161602ac6454SAndrew Thompson 	RAL_LOCK(sc);
16175efea30fSAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
16185efea30fSAndrew Thompson 	ural_set_bssid(sc, ifp->if_broadcastaddr);
161902ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
162002ac6454SAndrew Thompson }
162102ac6454SAndrew Thompson 
162202ac6454SAndrew Thompson static void
162302ac6454SAndrew Thompson ural_scan_end(struct ieee80211com *ic)
162402ac6454SAndrew Thompson {
162502ac6454SAndrew Thompson 	struct ural_softc *sc = ic->ic_ifp->if_softc;
162602ac6454SAndrew Thompson 
162702ac6454SAndrew Thompson 	RAL_LOCK(sc);
16285efea30fSAndrew Thompson 	ural_enable_tsf_sync(sc);
16295efea30fSAndrew Thompson 	ural_set_bssid(sc, sc->sc_bssid);
163002ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
163102ac6454SAndrew Thompson 
163202ac6454SAndrew Thompson }
163302ac6454SAndrew Thompson 
163402ac6454SAndrew Thompson static void
163502ac6454SAndrew Thompson ural_set_channel(struct ieee80211com *ic)
163602ac6454SAndrew Thompson {
163702ac6454SAndrew Thompson 	struct ural_softc *sc = ic->ic_ifp->if_softc;
163802ac6454SAndrew Thompson 
163902ac6454SAndrew Thompson 	RAL_LOCK(sc);
16405efea30fSAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
164102ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
164202ac6454SAndrew Thompson }
164302ac6454SAndrew Thompson 
164402ac6454SAndrew Thompson static void
164502ac6454SAndrew Thompson ural_set_chan(struct ural_softc *sc, struct ieee80211_channel *c)
164602ac6454SAndrew Thompson {
164702ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
164802ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
164902ac6454SAndrew Thompson 	uint8_t power, tmp;
165002ac6454SAndrew Thompson 	int i, chan;
165102ac6454SAndrew Thompson 
165202ac6454SAndrew Thompson 	chan = ieee80211_chan2ieee(ic, c);
165302ac6454SAndrew Thompson 	if (chan == 0 || chan == IEEE80211_CHAN_ANY)
165402ac6454SAndrew Thompson 		return;
165502ac6454SAndrew Thompson 
165602ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_2GHZ(c))
165702ac6454SAndrew Thompson 		power = min(sc->txpow[chan - 1], 31);
165802ac6454SAndrew Thompson 	else
165902ac6454SAndrew Thompson 		power = 31;
166002ac6454SAndrew Thompson 
166102ac6454SAndrew Thompson 	/* adjust txpower using ifconfig settings */
166202ac6454SAndrew Thompson 	power -= (100 - ic->ic_txpowlimit) / 8;
166302ac6454SAndrew Thompson 
166402ac6454SAndrew Thompson 	DPRINTFN(2, "setting channel to %u, txpower to %u\n", chan, power);
166502ac6454SAndrew Thompson 
166602ac6454SAndrew Thompson 	switch (sc->rf_rev) {
166702ac6454SAndrew Thompson 	case RAL_RF_2522:
166802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x00814);
166902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2522_r2[chan - 1]);
167002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
167102ac6454SAndrew Thompson 		break;
167202ac6454SAndrew Thompson 
167302ac6454SAndrew Thompson 	case RAL_RF_2523:
167402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
167502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2523_r2[chan - 1]);
167602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
167702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
167802ac6454SAndrew Thompson 		break;
167902ac6454SAndrew Thompson 
168002ac6454SAndrew Thompson 	case RAL_RF_2524:
168102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x0c808);
168202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2524_r2[chan - 1]);
168302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
168402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
168502ac6454SAndrew Thompson 		break;
168602ac6454SAndrew Thompson 
168702ac6454SAndrew Thompson 	case RAL_RF_2525:
168802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
168902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_hi_r2[chan - 1]);
169002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
169102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
169202ac6454SAndrew Thompson 
169302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
169402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_r2[chan - 1]);
169502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
169602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
169702ac6454SAndrew Thompson 		break;
169802ac6454SAndrew Thompson 
169902ac6454SAndrew Thompson 	case RAL_RF_2525E:
170002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
170102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525e_r2[chan - 1]);
170202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
170302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
170402ac6454SAndrew Thompson 		break;
170502ac6454SAndrew Thompson 
170602ac6454SAndrew Thompson 	case RAL_RF_2526:
170702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_hi_r2[chan - 1]);
170802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
170902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
171002ac6454SAndrew Thompson 
171102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_r2[chan - 1]);
171202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
171302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
171402ac6454SAndrew Thompson 		break;
171502ac6454SAndrew Thompson 
171602ac6454SAndrew Thompson 	/* dual-band RF */
171702ac6454SAndrew Thompson 	case RAL_RF_5222:
171802ac6454SAndrew Thompson 		for (i = 0; ural_rf5222[i].chan != chan; i++);
171902ac6454SAndrew Thompson 
172002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, ural_rf5222[i].r1);
172102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf5222[i].r2);
172202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
172302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, ural_rf5222[i].r4);
172402ac6454SAndrew Thompson 		break;
172502ac6454SAndrew Thompson 	}
172602ac6454SAndrew Thompson 
172702ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR &&
172802ac6454SAndrew Thompson 	    (ic->ic_flags & IEEE80211_F_SCAN) == 0) {
172902ac6454SAndrew Thompson 		/* set Japan filter bit for channel 14 */
173002ac6454SAndrew Thompson 		tmp = ural_bbp_read(sc, 70);
173102ac6454SAndrew Thompson 
173202ac6454SAndrew Thompson 		tmp &= ~RAL_JAPAN_FILTER;
173302ac6454SAndrew Thompson 		if (chan == 14)
173402ac6454SAndrew Thompson 			tmp |= RAL_JAPAN_FILTER;
173502ac6454SAndrew Thompson 
173602ac6454SAndrew Thompson 		ural_bbp_write(sc, 70, tmp);
173702ac6454SAndrew Thompson 
173802ac6454SAndrew Thompson 		/* clear CRC errors */
173902ac6454SAndrew Thompson 		ural_read(sc, RAL_STA_CSR0);
174002ac6454SAndrew Thompson 
174102ac6454SAndrew Thompson 		ural_pause(sc, hz / 100);
174202ac6454SAndrew Thompson 		ural_disable_rf_tune(sc);
174302ac6454SAndrew Thompson 	}
174402ac6454SAndrew Thompson 
174502ac6454SAndrew Thompson 	/* XXX doesn't belong here */
174602ac6454SAndrew Thompson 	/* update basic rate set */
174702ac6454SAndrew Thompson 	ural_set_basicrates(sc, c);
174877ddf3d3SAndrew Thompson 
174977ddf3d3SAndrew Thompson 	/* give the hardware some time to do the switchover */
175077ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 100);
175102ac6454SAndrew Thompson }
175202ac6454SAndrew Thompson 
175302ac6454SAndrew Thompson /*
175402ac6454SAndrew Thompson  * Disable RF auto-tuning.
175502ac6454SAndrew Thompson  */
175602ac6454SAndrew Thompson static void
175702ac6454SAndrew Thompson ural_disable_rf_tune(struct ural_softc *sc)
175802ac6454SAndrew Thompson {
175902ac6454SAndrew Thompson 	uint32_t tmp;
176002ac6454SAndrew Thompson 
176102ac6454SAndrew Thompson 	if (sc->rf_rev != RAL_RF_2523) {
176202ac6454SAndrew Thompson 		tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
176302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, tmp);
176402ac6454SAndrew Thompson 	}
176502ac6454SAndrew Thompson 
176602ac6454SAndrew Thompson 	tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
176702ac6454SAndrew Thompson 	ural_rf_write(sc, RAL_RF3, tmp);
176802ac6454SAndrew Thompson 
176902ac6454SAndrew Thompson 	DPRINTFN(2, "disabling RF autotune\n");
177002ac6454SAndrew Thompson }
177102ac6454SAndrew Thompson 
177202ac6454SAndrew Thompson /*
177302ac6454SAndrew Thompson  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
177402ac6454SAndrew Thompson  * synchronization.
177502ac6454SAndrew Thompson  */
177602ac6454SAndrew Thompson static void
177702ac6454SAndrew Thompson ural_enable_tsf_sync(struct ural_softc *sc)
177802ac6454SAndrew Thompson {
177902ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
178002ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
178102ac6454SAndrew Thompson 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
178202ac6454SAndrew Thompson 	uint16_t logcwmin, preload, tmp;
178302ac6454SAndrew Thompson 
178402ac6454SAndrew Thompson 	/* first, disable TSF synchronization */
178502ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
178602ac6454SAndrew Thompson 
178702ac6454SAndrew Thompson 	tmp = (16 * vap->iv_bss->ni_intval) << 4;
178802ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR18, tmp);
178902ac6454SAndrew Thompson 
179002ac6454SAndrew Thompson 	logcwmin = (ic->ic_opmode == IEEE80211_M_IBSS) ? 2 : 0;
179102ac6454SAndrew Thompson 	preload = (ic->ic_opmode == IEEE80211_M_IBSS) ? 320 : 6;
179202ac6454SAndrew Thompson 	tmp = logcwmin << 12 | preload;
179302ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR20, tmp);
179402ac6454SAndrew Thompson 
179502ac6454SAndrew Thompson 	/* finally, enable TSF synchronization */
179602ac6454SAndrew Thompson 	tmp = RAL_ENABLE_TSF | RAL_ENABLE_TBCN;
179702ac6454SAndrew Thompson 	if (ic->ic_opmode == IEEE80211_M_STA)
179802ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(1);
179902ac6454SAndrew Thompson 	else
180002ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(2) | RAL_ENABLE_BEACON_GENERATOR;
180102ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, tmp);
180202ac6454SAndrew Thompson 
180302ac6454SAndrew Thompson 	DPRINTF("enabling TSF synchronization\n");
180402ac6454SAndrew Thompson }
180502ac6454SAndrew Thompson 
18065463c4a4SSam Leffler static void
18075463c4a4SSam Leffler ural_enable_tsf(struct ural_softc *sc)
18085463c4a4SSam Leffler {
18095463c4a4SSam Leffler 	/* first, disable TSF synchronization */
18105463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, 0);
18115463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, RAL_ENABLE_TSF | RAL_ENABLE_TSF_SYNC(2));
18125463c4a4SSam Leffler }
18135463c4a4SSam Leffler 
181402ac6454SAndrew Thompson #define RAL_RXTX_TURNAROUND	5	/* us */
181502ac6454SAndrew Thompson static void
181602ac6454SAndrew Thompson ural_update_slot(struct ifnet *ifp)
181702ac6454SAndrew Thompson {
181802ac6454SAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
181902ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
182002ac6454SAndrew Thompson 	uint16_t slottime, sifs, eifs;
182102ac6454SAndrew Thompson 
182202ac6454SAndrew Thompson 	slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
182302ac6454SAndrew Thompson 
182402ac6454SAndrew Thompson 	/*
182502ac6454SAndrew Thompson 	 * These settings may sound a bit inconsistent but this is what the
182602ac6454SAndrew Thompson 	 * reference driver does.
182702ac6454SAndrew Thompson 	 */
182802ac6454SAndrew Thompson 	if (ic->ic_curmode == IEEE80211_MODE_11B) {
182902ac6454SAndrew Thompson 		sifs = 16 - RAL_RXTX_TURNAROUND;
183002ac6454SAndrew Thompson 		eifs = 364;
183102ac6454SAndrew Thompson 	} else {
183202ac6454SAndrew Thompson 		sifs = 10 - RAL_RXTX_TURNAROUND;
183302ac6454SAndrew Thompson 		eifs = 64;
183402ac6454SAndrew Thompson 	}
183502ac6454SAndrew Thompson 
183602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR10, slottime);
183702ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR11, sifs);
183802ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR12, eifs);
183902ac6454SAndrew Thompson }
184002ac6454SAndrew Thompson 
184102ac6454SAndrew Thompson static void
184202ac6454SAndrew Thompson ural_set_txpreamble(struct ural_softc *sc)
184302ac6454SAndrew Thompson {
184402ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
184502ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
184602ac6454SAndrew Thompson 	uint16_t tmp;
184702ac6454SAndrew Thompson 
184802ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR10);
184902ac6454SAndrew Thompson 
185002ac6454SAndrew Thompson 	tmp &= ~RAL_SHORT_PREAMBLE;
185102ac6454SAndrew Thompson 	if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
185202ac6454SAndrew Thompson 		tmp |= RAL_SHORT_PREAMBLE;
185302ac6454SAndrew Thompson 
185402ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR10, tmp);
185502ac6454SAndrew Thompson }
185602ac6454SAndrew Thompson 
185702ac6454SAndrew Thompson static void
185802ac6454SAndrew Thompson ural_set_basicrates(struct ural_softc *sc, const struct ieee80211_channel *c)
185902ac6454SAndrew Thompson {
186002ac6454SAndrew Thompson 	/* XXX wrong, take from rate set */
186102ac6454SAndrew Thompson 	/* update basic rate set */
186202ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_5GHZ(c)) {
186302ac6454SAndrew Thompson 		/* 11a basic rates: 6, 12, 24Mbps */
186402ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x150);
186502ac6454SAndrew Thompson 	} else if (IEEE80211_IS_CHAN_ANYG(c)) {
186602ac6454SAndrew Thompson 		/* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
186702ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x15f);
186802ac6454SAndrew Thompson 	} else {
186902ac6454SAndrew Thompson 		/* 11b basic rates: 1, 2Mbps */
187002ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x3);
187102ac6454SAndrew Thompson 	}
187202ac6454SAndrew Thompson }
187302ac6454SAndrew Thompson 
187402ac6454SAndrew Thompson static void
187502ac6454SAndrew Thompson ural_set_bssid(struct ural_softc *sc, const uint8_t *bssid)
187602ac6454SAndrew Thompson {
187702ac6454SAndrew Thompson 	uint16_t tmp;
187802ac6454SAndrew Thompson 
187902ac6454SAndrew Thompson 	tmp = bssid[0] | bssid[1] << 8;
188002ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR5, tmp);
188102ac6454SAndrew Thompson 
188202ac6454SAndrew Thompson 	tmp = bssid[2] | bssid[3] << 8;
188302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR6, tmp);
188402ac6454SAndrew Thompson 
188502ac6454SAndrew Thompson 	tmp = bssid[4] | bssid[5] << 8;
188602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR7, tmp);
188702ac6454SAndrew Thompson 
188802ac6454SAndrew Thompson 	DPRINTF("setting BSSID to %6D\n", bssid, ":");
188902ac6454SAndrew Thompson }
189002ac6454SAndrew Thompson 
189102ac6454SAndrew Thompson static void
189202ac6454SAndrew Thompson ural_set_macaddr(struct ural_softc *sc, uint8_t *addr)
189302ac6454SAndrew Thompson {
189402ac6454SAndrew Thompson 	uint16_t tmp;
189502ac6454SAndrew Thompson 
189602ac6454SAndrew Thompson 	tmp = addr[0] | addr[1] << 8;
189702ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR2, tmp);
189802ac6454SAndrew Thompson 
189902ac6454SAndrew Thompson 	tmp = addr[2] | addr[3] << 8;
190002ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR3, tmp);
190102ac6454SAndrew Thompson 
190202ac6454SAndrew Thompson 	tmp = addr[4] | addr[5] << 8;
190302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR4, tmp);
190402ac6454SAndrew Thompson 
190502ac6454SAndrew Thompson 	DPRINTF("setting MAC address to %6D\n", addr, ":");
190602ac6454SAndrew Thompson }
190702ac6454SAndrew Thompson 
190802ac6454SAndrew Thompson static void
19095efea30fSAndrew Thompson ural_setpromisc(struct ural_softc *sc)
191002ac6454SAndrew Thompson {
191102ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
191202ac6454SAndrew Thompson 	uint32_t tmp;
191302ac6454SAndrew Thompson 
191402ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR2);
191502ac6454SAndrew Thompson 
191602ac6454SAndrew Thompson 	tmp &= ~RAL_DROP_NOT_TO_ME;
191702ac6454SAndrew Thompson 	if (!(ifp->if_flags & IFF_PROMISC))
191802ac6454SAndrew Thompson 		tmp |= RAL_DROP_NOT_TO_ME;
191902ac6454SAndrew Thompson 
192002ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
192102ac6454SAndrew Thompson 
192202ac6454SAndrew Thompson 	DPRINTF("%s promiscuous mode\n", (ifp->if_flags & IFF_PROMISC) ?
192302ac6454SAndrew Thompson 	    "entering" : "leaving");
192402ac6454SAndrew Thompson }
192502ac6454SAndrew Thompson 
192677ddf3d3SAndrew Thompson static void
192777ddf3d3SAndrew Thompson ural_update_promisc(struct ifnet *ifp)
192877ddf3d3SAndrew Thompson {
192977ddf3d3SAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
193077ddf3d3SAndrew Thompson 
193177ddf3d3SAndrew Thompson 	if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)
193277ddf3d3SAndrew Thompson 		return;
193377ddf3d3SAndrew Thompson 
193477ddf3d3SAndrew Thompson 	RAL_LOCK(sc);
19355efea30fSAndrew Thompson 	ural_setpromisc(sc);
193677ddf3d3SAndrew Thompson 	RAL_UNLOCK(sc);
193777ddf3d3SAndrew Thompson }
193877ddf3d3SAndrew Thompson 
193902ac6454SAndrew Thompson static const char *
194002ac6454SAndrew Thompson ural_get_rf(int rev)
194102ac6454SAndrew Thompson {
194202ac6454SAndrew Thompson 	switch (rev) {
194302ac6454SAndrew Thompson 	case RAL_RF_2522:	return "RT2522";
194402ac6454SAndrew Thompson 	case RAL_RF_2523:	return "RT2523";
194502ac6454SAndrew Thompson 	case RAL_RF_2524:	return "RT2524";
194602ac6454SAndrew Thompson 	case RAL_RF_2525:	return "RT2525";
194702ac6454SAndrew Thompson 	case RAL_RF_2525E:	return "RT2525e";
194802ac6454SAndrew Thompson 	case RAL_RF_2526:	return "RT2526";
194902ac6454SAndrew Thompson 	case RAL_RF_5222:	return "RT5222";
195002ac6454SAndrew Thompson 	default:		return "unknown";
195102ac6454SAndrew Thompson 	}
195202ac6454SAndrew Thompson }
195302ac6454SAndrew Thompson 
195402ac6454SAndrew Thompson static void
195502ac6454SAndrew Thompson ural_read_eeprom(struct ural_softc *sc)
195602ac6454SAndrew Thompson {
195702ac6454SAndrew Thompson 	uint16_t val;
195802ac6454SAndrew Thompson 
195902ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_CONFIG0, &val, 2);
196002ac6454SAndrew Thompson 	val = le16toh(val);
196102ac6454SAndrew Thompson 	sc->rf_rev =   (val >> 11) & 0x7;
196202ac6454SAndrew Thompson 	sc->hw_radio = (val >> 10) & 0x1;
196302ac6454SAndrew Thompson 	sc->led_mode = (val >> 6)  & 0x7;
196402ac6454SAndrew Thompson 	sc->rx_ant =   (val >> 4)  & 0x3;
196502ac6454SAndrew Thompson 	sc->tx_ant =   (val >> 2)  & 0x3;
196602ac6454SAndrew Thompson 	sc->nb_ant =   val & 0x3;
196702ac6454SAndrew Thompson 
196802ac6454SAndrew Thompson 	/* read MAC address */
196902ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_ADDRESS, sc->sc_bssid, 6);
197002ac6454SAndrew Thompson 
197102ac6454SAndrew Thompson 	/* read default values for BBP registers */
197202ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_BBP_BASE, sc->bbp_prom, 2 * 16);
197302ac6454SAndrew Thompson 
197402ac6454SAndrew Thompson 	/* read Tx power for all b/g channels */
197502ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_TXPOWER, sc->txpow, 14);
197602ac6454SAndrew Thompson }
197702ac6454SAndrew Thompson 
197802ac6454SAndrew Thompson static int
197902ac6454SAndrew Thompson ural_bbp_init(struct ural_softc *sc)
198002ac6454SAndrew Thompson {
19816d917491SHans Petter Selasky #define N(a)	((int)(sizeof (a) / sizeof ((a)[0])))
198202ac6454SAndrew Thompson 	int i, ntries;
198302ac6454SAndrew Thompson 
198402ac6454SAndrew Thompson 	/* wait for BBP to be ready */
198502ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
198602ac6454SAndrew Thompson 		if (ural_bbp_read(sc, RAL_BBP_VERSION) != 0)
198702ac6454SAndrew Thompson 			break;
198802ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
198902ac6454SAndrew Thompson 			break;
199002ac6454SAndrew Thompson 	}
199102ac6454SAndrew Thompson 	if (ntries == 100) {
199202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "timeout waiting for BBP\n");
199302ac6454SAndrew Thompson 		return EIO;
199402ac6454SAndrew Thompson 	}
199502ac6454SAndrew Thompson 
199602ac6454SAndrew Thompson 	/* initialize BBP registers to default values */
199702ac6454SAndrew Thompson 	for (i = 0; i < N(ural_def_bbp); i++)
199802ac6454SAndrew Thompson 		ural_bbp_write(sc, ural_def_bbp[i].reg, ural_def_bbp[i].val);
199902ac6454SAndrew Thompson 
200002ac6454SAndrew Thompson #if 0
200102ac6454SAndrew Thompson 	/* initialize BBP registers to values stored in EEPROM */
200202ac6454SAndrew Thompson 	for (i = 0; i < 16; i++) {
200302ac6454SAndrew Thompson 		if (sc->bbp_prom[i].reg == 0xff)
200402ac6454SAndrew Thompson 			continue;
200502ac6454SAndrew Thompson 		ural_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
200602ac6454SAndrew Thompson 	}
200702ac6454SAndrew Thompson #endif
200802ac6454SAndrew Thompson 
200902ac6454SAndrew Thompson 	return 0;
201002ac6454SAndrew Thompson #undef N
201102ac6454SAndrew Thompson }
201202ac6454SAndrew Thompson 
201302ac6454SAndrew Thompson static void
201402ac6454SAndrew Thompson ural_set_txantenna(struct ural_softc *sc, int antenna)
201502ac6454SAndrew Thompson {
201602ac6454SAndrew Thompson 	uint16_t tmp;
201702ac6454SAndrew Thompson 	uint8_t tx;
201802ac6454SAndrew Thompson 
201902ac6454SAndrew Thompson 	tx = ural_bbp_read(sc, RAL_BBP_TX) & ~RAL_BBP_ANTMASK;
202002ac6454SAndrew Thompson 	if (antenna == 1)
202102ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTA;
202202ac6454SAndrew Thompson 	else if (antenna == 2)
202302ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTB;
202402ac6454SAndrew Thompson 	else
202502ac6454SAndrew Thompson 		tx |= RAL_BBP_DIVERSITY;
202602ac6454SAndrew Thompson 
202702ac6454SAndrew Thompson 	/* need to force I/Q flip for RF 2525e, 2526 and 5222 */
202802ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526 ||
202902ac6454SAndrew Thompson 	    sc->rf_rev == RAL_RF_5222)
203002ac6454SAndrew Thompson 		tx |= RAL_BBP_FLIPIQ;
203102ac6454SAndrew Thompson 
203202ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_TX, tx);
203302ac6454SAndrew Thompson 
203402ac6454SAndrew Thompson 	/* update values in PHY_CSR5 and PHY_CSR6 */
203502ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR5) & ~0x7;
203602ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR5, tmp | (tx & 0x7));
203702ac6454SAndrew Thompson 
203802ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR6) & ~0x7;
203902ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR6, tmp | (tx & 0x7));
204002ac6454SAndrew Thompson }
204102ac6454SAndrew Thompson 
204202ac6454SAndrew Thompson static void
204302ac6454SAndrew Thompson ural_set_rxantenna(struct ural_softc *sc, int antenna)
204402ac6454SAndrew Thompson {
204502ac6454SAndrew Thompson 	uint8_t rx;
204602ac6454SAndrew Thompson 
204702ac6454SAndrew Thompson 	rx = ural_bbp_read(sc, RAL_BBP_RX) & ~RAL_BBP_ANTMASK;
204802ac6454SAndrew Thompson 	if (antenna == 1)
204902ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTA;
205002ac6454SAndrew Thompson 	else if (antenna == 2)
205102ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTB;
205202ac6454SAndrew Thompson 	else
205302ac6454SAndrew Thompson 		rx |= RAL_BBP_DIVERSITY;
205402ac6454SAndrew Thompson 
205502ac6454SAndrew Thompson 	/* need to force no I/Q flip for RF 2525e and 2526 */
205602ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526)
205702ac6454SAndrew Thompson 		rx &= ~RAL_BBP_FLIPIQ;
205802ac6454SAndrew Thompson 
205902ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_RX, rx);
206002ac6454SAndrew Thompson }
206102ac6454SAndrew Thompson 
206202ac6454SAndrew Thompson static void
20635efea30fSAndrew Thompson ural_init_locked(struct ural_softc *sc)
206402ac6454SAndrew Thompson {
20656d917491SHans Petter Selasky #define N(a)	((int)(sizeof (a) / sizeof ((a)[0])))
206602ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
206702ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
206802ac6454SAndrew Thompson 	uint16_t tmp;
206902ac6454SAndrew Thompson 	int i, ntries;
207002ac6454SAndrew Thompson 
207102ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
207202ac6454SAndrew Thompson 
207302ac6454SAndrew Thompson 	ural_set_testmode(sc);
207402ac6454SAndrew Thompson 	ural_write(sc, 0x308, 0x00f0);	/* XXX magic */
207502ac6454SAndrew Thompson 
20765efea30fSAndrew Thompson 	ural_stop(sc);
207702ac6454SAndrew Thompson 
207802ac6454SAndrew Thompson 	/* initialize MAC registers to default values */
207902ac6454SAndrew Thompson 	for (i = 0; i < N(ural_def_mac); i++)
208002ac6454SAndrew Thompson 		ural_write(sc, ural_def_mac[i].reg, ural_def_mac[i].val);
208102ac6454SAndrew Thompson 
208202ac6454SAndrew Thompson 	/* wait for BBP and RF to wake up (this can take a long time!) */
208302ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
208402ac6454SAndrew Thompson 		tmp = ural_read(sc, RAL_MAC_CSR17);
208502ac6454SAndrew Thompson 		if ((tmp & (RAL_BBP_AWAKE | RAL_RF_AWAKE)) ==
208602ac6454SAndrew Thompson 		    (RAL_BBP_AWAKE | RAL_RF_AWAKE))
208702ac6454SAndrew Thompson 			break;
208802ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
208902ac6454SAndrew Thompson 			break;
209002ac6454SAndrew Thompson 	}
209102ac6454SAndrew Thompson 	if (ntries == 100) {
209202ac6454SAndrew Thompson 		device_printf(sc->sc_dev,
209302ac6454SAndrew Thompson 		    "timeout waiting for BBP/RF to wakeup\n");
209402ac6454SAndrew Thompson 		goto fail;
209502ac6454SAndrew Thompson 	}
209602ac6454SAndrew Thompson 
209702ac6454SAndrew Thompson 	/* we're ready! */
209802ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_HOST_READY);
209902ac6454SAndrew Thompson 
210002ac6454SAndrew Thompson 	/* set basic rate set (will be updated later) */
210102ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR11, 0x15f);
210202ac6454SAndrew Thompson 
210302ac6454SAndrew Thompson 	if (ural_bbp_init(sc) != 0)
210402ac6454SAndrew Thompson 		goto fail;
210502ac6454SAndrew Thompson 
210602ac6454SAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
210702ac6454SAndrew Thompson 
210802ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
210902ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
211002ac6454SAndrew Thompson 
211102ac6454SAndrew Thompson 	ural_set_txantenna(sc, sc->tx_ant);
211202ac6454SAndrew Thompson 	ural_set_rxantenna(sc, sc->rx_ant);
211302ac6454SAndrew Thompson 
211429aca940SSam Leffler 	ural_set_macaddr(sc, IF_LLADDR(ifp));
211502ac6454SAndrew Thompson 
211602ac6454SAndrew Thompson 	/*
211702ac6454SAndrew Thompson 	 * Allocate Tx and Rx xfer queues.
211802ac6454SAndrew Thompson 	 */
211902ac6454SAndrew Thompson 	ural_setup_tx_list(sc);
212002ac6454SAndrew Thompson 
212102ac6454SAndrew Thompson 	/* kick Rx */
212202ac6454SAndrew Thompson 	tmp = RAL_DROP_PHY | RAL_DROP_CRC;
212302ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR) {
212402ac6454SAndrew Thompson 		tmp |= RAL_DROP_CTL | RAL_DROP_BAD_VERSION;
212502ac6454SAndrew Thompson 		if (ic->ic_opmode != IEEE80211_M_HOSTAP)
212602ac6454SAndrew Thompson 			tmp |= RAL_DROP_TODS;
212702ac6454SAndrew Thompson 		if (!(ifp->if_flags & IFF_PROMISC))
212802ac6454SAndrew Thompson 			tmp |= RAL_DROP_NOT_TO_ME;
212902ac6454SAndrew Thompson 	}
213002ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
213102ac6454SAndrew Thompson 
213202ac6454SAndrew Thompson 	ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
213302ac6454SAndrew Thompson 	ifp->if_drv_flags |= IFF_DRV_RUNNING;
2134ed6d949aSAndrew Thompson 	usbd_xfer_set_stall(sc->sc_xfer[URAL_BULK_WR]);
2135a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_RD]);
213602ac6454SAndrew Thompson 	return;
213702ac6454SAndrew Thompson 
21385efea30fSAndrew Thompson fail:	ural_stop(sc);
213902ac6454SAndrew Thompson #undef N
214002ac6454SAndrew Thompson }
214102ac6454SAndrew Thompson 
214202ac6454SAndrew Thompson static void
214302ac6454SAndrew Thompson ural_init(void *priv)
214402ac6454SAndrew Thompson {
214502ac6454SAndrew Thompson 	struct ural_softc *sc = priv;
214602ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
214702ac6454SAndrew Thompson 	struct ieee80211com *ic = ifp->if_l2com;
214802ac6454SAndrew Thompson 
214902ac6454SAndrew Thompson 	RAL_LOCK(sc);
21505efea30fSAndrew Thompson 	ural_init_locked(sc);
215102ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
215202ac6454SAndrew Thompson 
215302ac6454SAndrew Thompson 	if (ifp->if_drv_flags & IFF_DRV_RUNNING)
215402ac6454SAndrew Thompson 		ieee80211_start_all(ic);		/* start all vap's */
215502ac6454SAndrew Thompson }
215602ac6454SAndrew Thompson 
215702ac6454SAndrew Thompson static void
21585efea30fSAndrew Thompson ural_stop(struct ural_softc *sc)
215902ac6454SAndrew Thompson {
216002ac6454SAndrew Thompson 	struct ifnet *ifp = sc->sc_ifp;
216102ac6454SAndrew Thompson 
216202ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
216302ac6454SAndrew Thompson 
216402ac6454SAndrew Thompson 	ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
216502ac6454SAndrew Thompson 
216602ac6454SAndrew Thompson 	/*
216702ac6454SAndrew Thompson 	 * Drain all the transfers, if not already drained:
216802ac6454SAndrew Thompson 	 */
216902ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
2170a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_WR]);
2171a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_RD]);
217202ac6454SAndrew Thompson 	RAL_LOCK(sc);
217302ac6454SAndrew Thompson 
217402ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
217502ac6454SAndrew Thompson 
217602ac6454SAndrew Thompson 	/* disable Rx */
217702ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, RAL_DISABLE_RX);
217802ac6454SAndrew Thompson 	/* reset ASIC and BBP (but won't reset MAC registers!) */
217902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_RESET_ASIC | RAL_RESET_BBP);
218002ac6454SAndrew Thompson 	/* wait a little */
218102ac6454SAndrew Thompson 	ural_pause(sc, hz / 10);
218202ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, 0);
218377ddf3d3SAndrew Thompson 	/* wait a little */
218477ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 10);
218502ac6454SAndrew Thompson }
218602ac6454SAndrew Thompson 
218702ac6454SAndrew Thompson static int
218802ac6454SAndrew Thompson ural_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
218902ac6454SAndrew Thompson 	const struct ieee80211_bpf_params *params)
219002ac6454SAndrew Thompson {
219102ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
219202ac6454SAndrew Thompson 	struct ifnet *ifp = ic->ic_ifp;
219302ac6454SAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
219402ac6454SAndrew Thompson 
219502ac6454SAndrew Thompson 	RAL_LOCK(sc);
219602ac6454SAndrew Thompson 	/* prevent management frames from being sent if we're not ready */
219702ac6454SAndrew Thompson 	if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
219802ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
219902ac6454SAndrew Thompson 		m_freem(m);
220002ac6454SAndrew Thompson 		ieee80211_free_node(ni);
220102ac6454SAndrew Thompson 		return ENETDOWN;
220202ac6454SAndrew Thompson 	}
220396ca458fSAndrew Thompson 	if (sc->tx_nfree < RAL_TX_MINFREE) {
220402ac6454SAndrew Thompson 		ifp->if_drv_flags |= IFF_DRV_OACTIVE;
220502ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
220602ac6454SAndrew Thompson 		m_freem(m);
220702ac6454SAndrew Thompson 		ieee80211_free_node(ni);
220802ac6454SAndrew Thompson 		return EIO;
220902ac6454SAndrew Thompson 	}
221002ac6454SAndrew Thompson 
221102ac6454SAndrew Thompson 	ifp->if_opackets++;
221202ac6454SAndrew Thompson 
221302ac6454SAndrew Thompson 	if (params == NULL) {
221402ac6454SAndrew Thompson 		/*
221502ac6454SAndrew Thompson 		 * Legacy path; interpret frame contents to decide
221602ac6454SAndrew Thompson 		 * precisely how to send the frame.
221702ac6454SAndrew Thompson 		 */
221802ac6454SAndrew Thompson 		if (ural_tx_mgt(sc, m, ni) != 0)
221902ac6454SAndrew Thompson 			goto bad;
222002ac6454SAndrew Thompson 	} else {
222102ac6454SAndrew Thompson 		/*
222202ac6454SAndrew Thompson 		 * Caller supplied explicit parameters to use in
222302ac6454SAndrew Thompson 		 * sending the frame.
222402ac6454SAndrew Thompson 		 */
222502ac6454SAndrew Thompson 		if (ural_tx_raw(sc, m, ni, params) != 0)
222602ac6454SAndrew Thompson 			goto bad;
222702ac6454SAndrew Thompson 	}
222802ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
222902ac6454SAndrew Thompson 	return 0;
223002ac6454SAndrew Thompson bad:
223102ac6454SAndrew Thompson 	ifp->if_oerrors++;
223202ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
223302ac6454SAndrew Thompson 	ieee80211_free_node(ni);
223402ac6454SAndrew Thompson 	return EIO;		/* XXX */
223502ac6454SAndrew Thompson }
223602ac6454SAndrew Thompson 
223702ac6454SAndrew Thompson static void
2238b6108616SRui Paulo ural_ratectl_start(struct ural_softc *sc, struct ieee80211_node *ni)
223902ac6454SAndrew Thompson {
224002ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
224102ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
224202ac6454SAndrew Thompson 
224302ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
224402ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
224502ac6454SAndrew Thompson 
2246b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
224702ac6454SAndrew Thompson }
224802ac6454SAndrew Thompson 
224902ac6454SAndrew Thompson static void
2250b6108616SRui Paulo ural_ratectl_timeout(void *arg)
225102ac6454SAndrew Thompson {
225202ac6454SAndrew Thompson 	struct ural_vap *uvp = arg;
22535efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
22545efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
225502ac6454SAndrew Thompson 
2256b6108616SRui Paulo 	ieee80211_runtask(ic, &uvp->ratectl_task);
225702ac6454SAndrew Thompson }
225802ac6454SAndrew Thompson 
225902ac6454SAndrew Thompson static void
2260b6108616SRui Paulo ural_ratectl_task(void *arg, int pending)
226102ac6454SAndrew Thompson {
22625efea30fSAndrew Thompson 	struct ural_vap *uvp = arg;
22635efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
22645efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
22655efea30fSAndrew Thompson 	struct ifnet *ifp = ic->ic_ifp;
22665efea30fSAndrew Thompson 	struct ural_softc *sc = ifp->if_softc;
22678d8bdb01SAndrew Thompson 	struct ieee80211_node *ni;
226802ac6454SAndrew Thompson 	int ok, fail;
2269b6108616SRui Paulo 	int sum, retrycnt;
227002ac6454SAndrew Thompson 
22718d8bdb01SAndrew Thompson 	ni = ieee80211_ref_node(vap->iv_bss);
22725efea30fSAndrew Thompson 	RAL_LOCK(sc);
227302ac6454SAndrew Thompson 	/* read and clear statistic registers (STA_CSR0 to STA_CSR10) */
227402ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof(sc->sta));
227502ac6454SAndrew Thompson 
227602ac6454SAndrew Thompson 	ok = sc->sta[7] +		/* TX ok w/o retry */
227702ac6454SAndrew Thompson 	     sc->sta[8];		/* TX ok w/ retry */
227802ac6454SAndrew Thompson 	fail = sc->sta[9];		/* TX retry-fail count */
2279b6108616SRui Paulo 	sum = ok+fail;
2280b6108616SRui Paulo 	retrycnt = sc->sta[8] + fail;
228102ac6454SAndrew Thompson 
2282b6108616SRui Paulo 	ieee80211_ratectl_tx_update(vap, ni, &sum, &ok, &retrycnt);
2283b6108616SRui Paulo 	(void) ieee80211_ratectl_rate(ni, NULL, 0);
228402ac6454SAndrew Thompson 
228502ac6454SAndrew Thompson 	ifp->if_oerrors += fail;	/* count TX retry-fail as Tx errors */
228602ac6454SAndrew Thompson 
2287b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
22885efea30fSAndrew Thompson 	RAL_UNLOCK(sc);
22898d8bdb01SAndrew Thompson 	ieee80211_free_node(ni);
229002ac6454SAndrew Thompson }
229102ac6454SAndrew Thompson 
229202ac6454SAndrew Thompson static int
229302ac6454SAndrew Thompson ural_pause(struct ural_softc *sc, int timeout)
229402ac6454SAndrew Thompson {
229502ac6454SAndrew Thompson 
2296a593f6b8SAndrew Thompson 	usb_pause_mtx(&sc->sc_mtx, timeout);
229702ac6454SAndrew Thompson 	return (0);
229802ac6454SAndrew Thompson }
2299