xref: /freebsd/sys/dev/usb/wlan/if_ural.c (revision 7067450010931479f8dd97e51e4c5bf6a4d34c7e)
102ac6454SAndrew Thompson 
202ac6454SAndrew Thompson /*-
302ac6454SAndrew Thompson  * Copyright (c) 2005, 2006
402ac6454SAndrew Thompson  *	Damien Bergamini <damien.bergamini@free.fr>
502ac6454SAndrew Thompson  *
602ac6454SAndrew Thompson  * Copyright (c) 2006, 2008
75d38a4d4SEd Schouten  *	Hans Petter Selasky <hselasky@FreeBSD.org>
802ac6454SAndrew Thompson  *
902ac6454SAndrew Thompson  * Permission to use, copy, modify, and distribute this software for any
1002ac6454SAndrew Thompson  * purpose with or without fee is hereby granted, provided that the above
1102ac6454SAndrew Thompson  * copyright notice and this permission notice appear in all copies.
1202ac6454SAndrew Thompson  *
1302ac6454SAndrew Thompson  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1402ac6454SAndrew Thompson  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1502ac6454SAndrew Thompson  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1602ac6454SAndrew Thompson  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1702ac6454SAndrew Thompson  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1802ac6454SAndrew Thompson  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1902ac6454SAndrew Thompson  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2002ac6454SAndrew Thompson  */
2102ac6454SAndrew Thompson 
2202ac6454SAndrew Thompson #include <sys/cdefs.h>
2302ac6454SAndrew Thompson /*-
2402ac6454SAndrew Thompson  * Ralink Technology RT2500USB chipset driver
2502ac6454SAndrew Thompson  * http://www.ralinktech.com/
2602ac6454SAndrew Thompson  */
2702ac6454SAndrew Thompson 
2863a55eabSAndriy Voskoboinyk #include "opt_wlan.h"
2963a55eabSAndriy Voskoboinyk 
305efea30fSAndrew Thompson #include <sys/param.h>
315efea30fSAndrew Thompson #include <sys/sockio.h>
325efea30fSAndrew Thompson #include <sys/sysctl.h>
335efea30fSAndrew Thompson #include <sys/lock.h>
345efea30fSAndrew Thompson #include <sys/mutex.h>
355efea30fSAndrew Thompson #include <sys/mbuf.h>
365efea30fSAndrew Thompson #include <sys/kernel.h>
375efea30fSAndrew Thompson #include <sys/socket.h>
385efea30fSAndrew Thompson #include <sys/systm.h>
395efea30fSAndrew Thompson #include <sys/malloc.h>
405efea30fSAndrew Thompson #include <sys/module.h>
415efea30fSAndrew Thompson #include <sys/bus.h>
425efea30fSAndrew Thompson #include <sys/endian.h>
435efea30fSAndrew Thompson #include <sys/kdb.h>
445efea30fSAndrew Thompson 
455efea30fSAndrew Thompson #include <net/bpf.h>
465efea30fSAndrew Thompson #include <net/if.h>
4776039bc8SGleb Smirnoff #include <net/if_var.h>
485efea30fSAndrew Thompson #include <net/if_arp.h>
495efea30fSAndrew Thompson #include <net/ethernet.h>
505efea30fSAndrew Thompson #include <net/if_dl.h>
515efea30fSAndrew Thompson #include <net/if_media.h>
525efea30fSAndrew Thompson #include <net/if_types.h>
535efea30fSAndrew Thompson 
545efea30fSAndrew Thompson #ifdef INET
555efea30fSAndrew Thompson #include <netinet/in.h>
565efea30fSAndrew Thompson #include <netinet/in_systm.h>
575efea30fSAndrew Thompson #include <netinet/in_var.h>
585efea30fSAndrew Thompson #include <netinet/if_ether.h>
595efea30fSAndrew Thompson #include <netinet/ip.h>
605efea30fSAndrew Thompson #endif
615efea30fSAndrew Thompson 
625efea30fSAndrew Thompson #include <net80211/ieee80211_var.h>
635efea30fSAndrew Thompson #include <net80211/ieee80211_regdomain.h>
645efea30fSAndrew Thompson #include <net80211/ieee80211_radiotap.h>
65b6108616SRui Paulo #include <net80211/ieee80211_ratectl.h>
6602ac6454SAndrew Thompson 
675efea30fSAndrew Thompson #include <dev/usb/usb.h>
68ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h>
695efea30fSAndrew Thompson #include "usbdevs.h"
7002ac6454SAndrew Thompson 
71ed6d949aSAndrew Thompson #define	USB_DEBUG_VAR ural_debug
72ed6d949aSAndrew Thompson #include <dev/usb/usb_debug.h>
735efea30fSAndrew Thompson 
7402ac6454SAndrew Thompson #include <dev/usb/wlan/if_uralreg.h>
7502ac6454SAndrew Thompson #include <dev/usb/wlan/if_uralvar.h>
7602ac6454SAndrew Thompson 
77b850ecc1SAndrew Thompson #ifdef USB_DEBUG
7802ac6454SAndrew Thompson static int ural_debug = 0;
7902ac6454SAndrew Thompson 
80f8d2b1f3SPawel Biernacki static SYSCTL_NODE(_hw_usb, OID_AUTO, ural, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
81f8d2b1f3SPawel Biernacki     "USB ural");
82ece4b0bdSHans Petter Selasky SYSCTL_INT(_hw_usb_ural, OID_AUTO, debug, CTLFLAG_RWTUN, &ural_debug, 0,
8302ac6454SAndrew Thompson     "Debug level");
8402ac6454SAndrew Thompson #endif
8502ac6454SAndrew Thompson 
8602ac6454SAndrew Thompson #define URAL_RSSI(rssi)					\
8702ac6454SAndrew Thompson 	((rssi) > (RAL_NOISE_FLOOR + RAL_RSSI_CORR) ?	\
8802ac6454SAndrew Thompson 	 ((rssi) - (RAL_NOISE_FLOOR + RAL_RSSI_CORR)) : 0)
8902ac6454SAndrew Thompson 
9002ac6454SAndrew Thompson /* various supported device vendors/products */
91f1a16106SHans Petter Selasky static const STRUCT_USB_HOST_ID ural_devs[] = {
929e6b5313SAndrew Thompson #define	URAL_DEV(v,p)  { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
939e6b5313SAndrew Thompson 	URAL_DEV(ASUS, WL167G),
949e6b5313SAndrew Thompson 	URAL_DEV(ASUS, RT2570),
959e6b5313SAndrew Thompson 	URAL_DEV(BELKIN, F5D7050),
969e6b5313SAndrew Thompson 	URAL_DEV(BELKIN, F5D7051),
979e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, HU200TS),
989e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, WUSB54G),
999e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, WUSB54GP),
1009e6b5313SAndrew Thompson 	URAL_DEV(CONCEPTRONIC2, C54RU),
1019e6b5313SAndrew Thompson 	URAL_DEV(DLINK, DWLG122),
1029e6b5313SAndrew Thompson 	URAL_DEV(GIGABYTE, GN54G),
1039e6b5313SAndrew Thompson 	URAL_DEV(GIGABYTE, GNWBKG),
1049e6b5313SAndrew Thompson 	URAL_DEV(GUILLEMOT, HWGUSB254),
1059e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54),
1069e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54AI),
1079e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54YB),
1089e6b5313SAndrew Thompson 	URAL_DEV(MELCO, NINWIFI),
1099e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570),
1109e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570_2),
1119e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570_3),
1129e6b5313SAndrew Thompson 	URAL_DEV(NOVATECH, NV902),
1139e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570),
1149e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570_2),
1159e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570_3),
1169e6b5313SAndrew Thompson 	URAL_DEV(SIEMENS2, WL54G),
1179e6b5313SAndrew Thompson 	URAL_DEV(SMC, 2862WG),
1189e6b5313SAndrew Thompson 	URAL_DEV(SPHAIRON, UB801R),
1199e6b5313SAndrew Thompson 	URAL_DEV(SURECOM, RT2570),
1209e6b5313SAndrew Thompson 	URAL_DEV(VTECH, RT2570),
1219e6b5313SAndrew Thompson 	URAL_DEV(ZINWELL, RT2570),
1229e6b5313SAndrew Thompson #undef URAL_DEV
12302ac6454SAndrew Thompson };
12402ac6454SAndrew Thompson 
125e0a69b51SAndrew Thompson static usb_callback_t ural_bulk_read_callback;
126e0a69b51SAndrew Thompson static usb_callback_t ural_bulk_write_callback;
12702ac6454SAndrew Thompson 
128e0a69b51SAndrew Thompson static usb_error_t	ural_do_request(struct ural_softc *sc,
129760bc48eSAndrew Thompson 			    struct usb_device_request *req, void *data);
13002ac6454SAndrew Thompson static struct ieee80211vap *ural_vap_create(struct ieee80211com *,
131fcd9500fSBernhard Schmidt 			    const char [IFNAMSIZ], int, enum ieee80211_opmode,
132fcd9500fSBernhard Schmidt 			    int, const uint8_t [IEEE80211_ADDR_LEN],
133fcd9500fSBernhard Schmidt 			    const uint8_t [IEEE80211_ADDR_LEN]);
13402ac6454SAndrew Thompson static void		ural_vap_delete(struct ieee80211vap *);
13502ac6454SAndrew Thompson static void		ural_tx_free(struct ural_tx_data *, int);
13602ac6454SAndrew Thompson static void		ural_setup_tx_list(struct ural_softc *);
13702ac6454SAndrew Thompson static void		ural_unsetup_tx_list(struct ural_softc *);
13802ac6454SAndrew Thompson static int		ural_newstate(struct ieee80211vap *,
13902ac6454SAndrew Thompson 			    enum ieee80211_state, int);
14002ac6454SAndrew Thompson static void		ural_setup_tx_desc(struct ural_softc *,
14102ac6454SAndrew Thompson 			    struct ural_tx_desc *, uint32_t, int, int);
14202ac6454SAndrew Thompson static int		ural_tx_bcn(struct ural_softc *, struct mbuf *,
14302ac6454SAndrew Thompson 			    struct ieee80211_node *);
14402ac6454SAndrew Thompson static int		ural_tx_mgt(struct ural_softc *, struct mbuf *,
14502ac6454SAndrew Thompson 			    struct ieee80211_node *);
14602ac6454SAndrew Thompson static int		ural_tx_data(struct ural_softc *, struct mbuf *,
14702ac6454SAndrew Thompson 			    struct ieee80211_node *);
1487a79cebfSGleb Smirnoff static int		ural_transmit(struct ieee80211com *, struct mbuf *);
1497a79cebfSGleb Smirnoff static void		ural_start(struct ural_softc *);
1507a79cebfSGleb Smirnoff static void		ural_parent(struct ieee80211com *);
15102ac6454SAndrew Thompson static void		ural_set_testmode(struct ural_softc *);
15202ac6454SAndrew Thompson static void		ural_eeprom_read(struct ural_softc *, uint16_t, void *,
15302ac6454SAndrew Thompson 			    int);
15402ac6454SAndrew Thompson static uint16_t		ural_read(struct ural_softc *, uint16_t);
15502ac6454SAndrew Thompson static void		ural_read_multi(struct ural_softc *, uint16_t, void *,
15602ac6454SAndrew Thompson 			    int);
15702ac6454SAndrew Thompson static void		ural_write(struct ural_softc *, uint16_t, uint16_t);
15802ac6454SAndrew Thompson static void		ural_write_multi(struct ural_softc *, uint16_t, void *,
15902ac6454SAndrew Thompson 			    int) __unused;
16002ac6454SAndrew Thompson static void		ural_bbp_write(struct ural_softc *, uint8_t, uint8_t);
16102ac6454SAndrew Thompson static uint8_t		ural_bbp_read(struct ural_softc *, uint8_t);
16202ac6454SAndrew Thompson static void		ural_rf_write(struct ural_softc *, uint8_t, uint32_t);
16302ac6454SAndrew Thompson static void		ural_scan_start(struct ieee80211com *);
16402ac6454SAndrew Thompson static void		ural_scan_end(struct ieee80211com *);
16583829b48SAndriy Voskoboinyk static void		ural_getradiocaps(struct ieee80211com *, int, int *,
16683829b48SAndriy Voskoboinyk 			    struct ieee80211_channel[]);
16702ac6454SAndrew Thompson static void		ural_set_channel(struct ieee80211com *);
16802ac6454SAndrew Thompson static void		ural_set_chan(struct ural_softc *,
16902ac6454SAndrew Thompson 			    struct ieee80211_channel *);
17002ac6454SAndrew Thompson static void		ural_disable_rf_tune(struct ural_softc *);
17102ac6454SAndrew Thompson static void		ural_enable_tsf_sync(struct ural_softc *);
1725463c4a4SSam Leffler static void 		ural_enable_tsf(struct ural_softc *);
1737a79cebfSGleb Smirnoff static void		ural_update_slot(struct ural_softc *);
17402ac6454SAndrew Thompson static void		ural_set_txpreamble(struct ural_softc *);
17502ac6454SAndrew Thompson static void		ural_set_basicrates(struct ural_softc *,
17602ac6454SAndrew Thompson 			    const struct ieee80211_channel *);
17702ac6454SAndrew Thompson static void		ural_set_bssid(struct ural_softc *, const uint8_t *);
1787a79cebfSGleb Smirnoff static void		ural_set_macaddr(struct ural_softc *, const uint8_t *);
179272f6adeSGleb Smirnoff static void		ural_update_promisc(struct ieee80211com *);
1805efea30fSAndrew Thompson static void		ural_setpromisc(struct ural_softc *);
18102ac6454SAndrew Thompson static const char	*ural_get_rf(int);
18202ac6454SAndrew Thompson static void		ural_read_eeprom(struct ural_softc *);
18302ac6454SAndrew Thompson static int		ural_bbp_init(struct ural_softc *);
18402ac6454SAndrew Thompson static void		ural_set_txantenna(struct ural_softc *, int);
18502ac6454SAndrew Thompson static void		ural_set_rxantenna(struct ural_softc *, int);
1867a79cebfSGleb Smirnoff static void		ural_init(struct ural_softc *);
1875efea30fSAndrew Thompson static void		ural_stop(struct ural_softc *);
18802ac6454SAndrew Thompson static int		ural_raw_xmit(struct ieee80211_node *, struct mbuf *,
18902ac6454SAndrew Thompson 			    const struct ieee80211_bpf_params *);
190b6108616SRui Paulo static void		ural_ratectl_start(struct ural_softc *,
19102ac6454SAndrew Thompson 			    struct ieee80211_node *);
192b6108616SRui Paulo static void		ural_ratectl_timeout(void *);
193b6108616SRui Paulo static void		ural_ratectl_task(void *, int);
19402ac6454SAndrew Thompson static int		ural_pause(struct ural_softc *sc, int timeout);
19502ac6454SAndrew Thompson 
19602ac6454SAndrew Thompson /*
19702ac6454SAndrew Thompson  * Default values for MAC registers; values taken from the reference driver.
19802ac6454SAndrew Thompson  */
19902ac6454SAndrew Thompson static const struct {
20002ac6454SAndrew Thompson 	uint16_t	reg;
20102ac6454SAndrew Thompson 	uint16_t	val;
20202ac6454SAndrew Thompson } ural_def_mac[] = {
20302ac6454SAndrew Thompson 	{ RAL_TXRX_CSR5,  0x8c8d },
20402ac6454SAndrew Thompson 	{ RAL_TXRX_CSR6,  0x8b8a },
20502ac6454SAndrew Thompson 	{ RAL_TXRX_CSR7,  0x8687 },
20602ac6454SAndrew Thompson 	{ RAL_TXRX_CSR8,  0x0085 },
20702ac6454SAndrew Thompson 	{ RAL_MAC_CSR13,  0x1111 },
20802ac6454SAndrew Thompson 	{ RAL_MAC_CSR14,  0x1e11 },
20902ac6454SAndrew Thompson 	{ RAL_TXRX_CSR21, 0xe78f },
21002ac6454SAndrew Thompson 	{ RAL_MAC_CSR9,   0xff1d },
21102ac6454SAndrew Thompson 	{ RAL_MAC_CSR11,  0x0002 },
21202ac6454SAndrew Thompson 	{ RAL_MAC_CSR22,  0x0053 },
21302ac6454SAndrew Thompson 	{ RAL_MAC_CSR15,  0x0000 },
21402ac6454SAndrew Thompson 	{ RAL_MAC_CSR8,   RAL_FRAME_SIZE },
21502ac6454SAndrew Thompson 	{ RAL_TXRX_CSR19, 0x0000 },
21602ac6454SAndrew Thompson 	{ RAL_TXRX_CSR18, 0x005a },
21702ac6454SAndrew Thompson 	{ RAL_PHY_CSR2,   0x0000 },
21802ac6454SAndrew Thompson 	{ RAL_TXRX_CSR0,  0x1ec0 },
21902ac6454SAndrew Thompson 	{ RAL_PHY_CSR4,   0x000f }
22002ac6454SAndrew Thompson };
22102ac6454SAndrew Thompson 
22202ac6454SAndrew Thompson /*
22302ac6454SAndrew Thompson  * Default values for BBP registers; values taken from the reference driver.
22402ac6454SAndrew Thompson  */
22502ac6454SAndrew Thompson static const struct {
22602ac6454SAndrew Thompson 	uint8_t	reg;
22702ac6454SAndrew Thompson 	uint8_t	val;
22802ac6454SAndrew Thompson } ural_def_bbp[] = {
22902ac6454SAndrew Thompson 	{  3, 0x02 },
23002ac6454SAndrew Thompson 	{  4, 0x19 },
23102ac6454SAndrew Thompson 	{ 14, 0x1c },
23202ac6454SAndrew Thompson 	{ 15, 0x30 },
23302ac6454SAndrew Thompson 	{ 16, 0xac },
23402ac6454SAndrew Thompson 	{ 17, 0x48 },
23502ac6454SAndrew Thompson 	{ 18, 0x18 },
23602ac6454SAndrew Thompson 	{ 19, 0xff },
23702ac6454SAndrew Thompson 	{ 20, 0x1e },
23802ac6454SAndrew Thompson 	{ 21, 0x08 },
23902ac6454SAndrew Thompson 	{ 22, 0x08 },
24002ac6454SAndrew Thompson 	{ 23, 0x08 },
24102ac6454SAndrew Thompson 	{ 24, 0x80 },
24202ac6454SAndrew Thompson 	{ 25, 0x50 },
24302ac6454SAndrew Thompson 	{ 26, 0x08 },
24402ac6454SAndrew Thompson 	{ 27, 0x23 },
24502ac6454SAndrew Thompson 	{ 30, 0x10 },
24602ac6454SAndrew Thompson 	{ 31, 0x2b },
24702ac6454SAndrew Thompson 	{ 32, 0xb9 },
24802ac6454SAndrew Thompson 	{ 34, 0x12 },
24902ac6454SAndrew Thompson 	{ 35, 0x50 },
25002ac6454SAndrew Thompson 	{ 39, 0xc4 },
25102ac6454SAndrew Thompson 	{ 40, 0x02 },
25202ac6454SAndrew Thompson 	{ 41, 0x60 },
25302ac6454SAndrew Thompson 	{ 53, 0x10 },
25402ac6454SAndrew Thompson 	{ 54, 0x18 },
25502ac6454SAndrew Thompson 	{ 56, 0x08 },
25602ac6454SAndrew Thompson 	{ 57, 0x10 },
25702ac6454SAndrew Thompson 	{ 58, 0x08 },
25802ac6454SAndrew Thompson 	{ 61, 0x60 },
25902ac6454SAndrew Thompson 	{ 62, 0x10 },
26002ac6454SAndrew Thompson 	{ 75, 0xff }
26102ac6454SAndrew Thompson };
26202ac6454SAndrew Thompson 
26302ac6454SAndrew Thompson /*
26402ac6454SAndrew Thompson  * Default values for RF register R2 indexed by channel numbers.
26502ac6454SAndrew Thompson  */
26602ac6454SAndrew Thompson static const uint32_t ural_rf2522_r2[] = {
26702ac6454SAndrew Thompson 	0x307f6, 0x307fb, 0x30800, 0x30805, 0x3080a, 0x3080f, 0x30814,
26802ac6454SAndrew Thompson 	0x30819, 0x3081e, 0x30823, 0x30828, 0x3082d, 0x30832, 0x3083e
26902ac6454SAndrew Thompson };
27002ac6454SAndrew Thompson 
27102ac6454SAndrew Thompson static const uint32_t ural_rf2523_r2[] = {
27202ac6454SAndrew Thompson 	0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
27302ac6454SAndrew Thompson 	0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
27402ac6454SAndrew Thompson };
27502ac6454SAndrew Thompson 
27602ac6454SAndrew Thompson static const uint32_t ural_rf2524_r2[] = {
27702ac6454SAndrew Thompson 	0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
27802ac6454SAndrew Thompson 	0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
27902ac6454SAndrew Thompson };
28002ac6454SAndrew Thompson 
28102ac6454SAndrew Thompson static const uint32_t ural_rf2525_r2[] = {
28202ac6454SAndrew Thompson 	0x20327, 0x20328, 0x20329, 0x2032a, 0x2032b, 0x2032c, 0x2032d,
28302ac6454SAndrew Thompson 	0x2032e, 0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20346
28402ac6454SAndrew Thompson };
28502ac6454SAndrew Thompson 
28602ac6454SAndrew Thompson static const uint32_t ural_rf2525_hi_r2[] = {
28702ac6454SAndrew Thompson 	0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20344, 0x20345,
28802ac6454SAndrew Thompson 	0x20346, 0x20347, 0x20348, 0x20349, 0x2034a, 0x2034b, 0x2034e
28902ac6454SAndrew Thompson };
29002ac6454SAndrew Thompson 
29102ac6454SAndrew Thompson static const uint32_t ural_rf2525e_r2[] = {
29202ac6454SAndrew Thompson 	0x2044d, 0x2044e, 0x2044f, 0x20460, 0x20461, 0x20462, 0x20463,
29302ac6454SAndrew Thompson 	0x20464, 0x20465, 0x20466, 0x20467, 0x20468, 0x20469, 0x2046b
29402ac6454SAndrew Thompson };
29502ac6454SAndrew Thompson 
29602ac6454SAndrew Thompson static const uint32_t ural_rf2526_hi_r2[] = {
29702ac6454SAndrew Thompson 	0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d, 0x0022d,
29802ac6454SAndrew Thompson 	0x0022e, 0x0022e, 0x0022f, 0x0022d, 0x00240, 0x00240, 0x00241
29902ac6454SAndrew Thompson };
30002ac6454SAndrew Thompson 
30102ac6454SAndrew Thompson static const uint32_t ural_rf2526_r2[] = {
30202ac6454SAndrew Thompson 	0x00226, 0x00227, 0x00227, 0x00228, 0x00228, 0x00229, 0x00229,
30302ac6454SAndrew Thompson 	0x0022a, 0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d
30402ac6454SAndrew Thompson };
30502ac6454SAndrew Thompson 
30602ac6454SAndrew Thompson /*
30702ac6454SAndrew Thompson  * For dual-band RF, RF registers R1 and R4 also depend on channel number;
30802ac6454SAndrew Thompson  * values taken from the reference driver.
30902ac6454SAndrew Thompson  */
31002ac6454SAndrew Thompson static const struct {
31102ac6454SAndrew Thompson 	uint8_t		chan;
31202ac6454SAndrew Thompson 	uint32_t	r1;
31302ac6454SAndrew Thompson 	uint32_t	r2;
31402ac6454SAndrew Thompson 	uint32_t	r4;
31502ac6454SAndrew Thompson } ural_rf5222[] = {
31602ac6454SAndrew Thompson 	{   1, 0x08808, 0x0044d, 0x00282 },
31702ac6454SAndrew Thompson 	{   2, 0x08808, 0x0044e, 0x00282 },
31802ac6454SAndrew Thompson 	{   3, 0x08808, 0x0044f, 0x00282 },
31902ac6454SAndrew Thompson 	{   4, 0x08808, 0x00460, 0x00282 },
32002ac6454SAndrew Thompson 	{   5, 0x08808, 0x00461, 0x00282 },
32102ac6454SAndrew Thompson 	{   6, 0x08808, 0x00462, 0x00282 },
32202ac6454SAndrew Thompson 	{   7, 0x08808, 0x00463, 0x00282 },
32302ac6454SAndrew Thompson 	{   8, 0x08808, 0x00464, 0x00282 },
32402ac6454SAndrew Thompson 	{   9, 0x08808, 0x00465, 0x00282 },
32502ac6454SAndrew Thompson 	{  10, 0x08808, 0x00466, 0x00282 },
32602ac6454SAndrew Thompson 	{  11, 0x08808, 0x00467, 0x00282 },
32702ac6454SAndrew Thompson 	{  12, 0x08808, 0x00468, 0x00282 },
32802ac6454SAndrew Thompson 	{  13, 0x08808, 0x00469, 0x00282 },
32902ac6454SAndrew Thompson 	{  14, 0x08808, 0x0046b, 0x00286 },
33002ac6454SAndrew Thompson 
33102ac6454SAndrew Thompson 	{  36, 0x08804, 0x06225, 0x00287 },
33202ac6454SAndrew Thompson 	{  40, 0x08804, 0x06226, 0x00287 },
33302ac6454SAndrew Thompson 	{  44, 0x08804, 0x06227, 0x00287 },
33402ac6454SAndrew Thompson 	{  48, 0x08804, 0x06228, 0x00287 },
33502ac6454SAndrew Thompson 	{  52, 0x08804, 0x06229, 0x00287 },
33602ac6454SAndrew Thompson 	{  56, 0x08804, 0x0622a, 0x00287 },
33702ac6454SAndrew Thompson 	{  60, 0x08804, 0x0622b, 0x00287 },
33802ac6454SAndrew Thompson 	{  64, 0x08804, 0x0622c, 0x00287 },
33902ac6454SAndrew Thompson 
34002ac6454SAndrew Thompson 	{ 100, 0x08804, 0x02200, 0x00283 },
34102ac6454SAndrew Thompson 	{ 104, 0x08804, 0x02201, 0x00283 },
34202ac6454SAndrew Thompson 	{ 108, 0x08804, 0x02202, 0x00283 },
34302ac6454SAndrew Thompson 	{ 112, 0x08804, 0x02203, 0x00283 },
34402ac6454SAndrew Thompson 	{ 116, 0x08804, 0x02204, 0x00283 },
34502ac6454SAndrew Thompson 	{ 120, 0x08804, 0x02205, 0x00283 },
34602ac6454SAndrew Thompson 	{ 124, 0x08804, 0x02206, 0x00283 },
34702ac6454SAndrew Thompson 	{ 128, 0x08804, 0x02207, 0x00283 },
34802ac6454SAndrew Thompson 	{ 132, 0x08804, 0x02208, 0x00283 },
34902ac6454SAndrew Thompson 	{ 136, 0x08804, 0x02209, 0x00283 },
35002ac6454SAndrew Thompson 	{ 140, 0x08804, 0x0220a, 0x00283 },
35102ac6454SAndrew Thompson 
35202ac6454SAndrew Thompson 	{ 149, 0x08808, 0x02429, 0x00281 },
35302ac6454SAndrew Thompson 	{ 153, 0x08808, 0x0242b, 0x00281 },
35402ac6454SAndrew Thompson 	{ 157, 0x08808, 0x0242d, 0x00281 },
35502ac6454SAndrew Thompson 	{ 161, 0x08808, 0x0242f, 0x00281 }
35602ac6454SAndrew Thompson };
35702ac6454SAndrew Thompson 
35883829b48SAndriy Voskoboinyk static const uint8_t ural_chan_5ghz[] =
35983829b48SAndriy Voskoboinyk 	{ 36, 40, 44, 48, 52, 56, 60, 64,
36083829b48SAndriy Voskoboinyk 	  100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140,
36183829b48SAndriy Voskoboinyk 	  149, 153, 157, 161 };
36283829b48SAndriy Voskoboinyk 
363760bc48eSAndrew Thompson static const struct usb_config ural_config[URAL_N_TRANSFER] = {
36402ac6454SAndrew Thompson 	[URAL_BULK_WR] = {
36502ac6454SAndrew Thompson 		.type = UE_BULK,
36602ac6454SAndrew Thompson 		.endpoint = UE_ADDR_ANY,
36702ac6454SAndrew Thompson 		.direction = UE_DIR_OUT,
3684eae601eSAndrew Thompson 		.bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4),
3694eae601eSAndrew Thompson 		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
3704eae601eSAndrew Thompson 		.callback = ural_bulk_write_callback,
3714eae601eSAndrew Thompson 		.timeout = 5000,	/* ms */
37202ac6454SAndrew Thompson 	},
37302ac6454SAndrew Thompson 	[URAL_BULK_RD] = {
37402ac6454SAndrew Thompson 		.type = UE_BULK,
37502ac6454SAndrew Thompson 		.endpoint = UE_ADDR_ANY,
37602ac6454SAndrew Thompson 		.direction = UE_DIR_IN,
3774eae601eSAndrew Thompson 		.bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE),
3784eae601eSAndrew Thompson 		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
3794eae601eSAndrew Thompson 		.callback = ural_bulk_read_callback,
38002ac6454SAndrew Thompson 	},
38102ac6454SAndrew Thompson };
38202ac6454SAndrew Thompson 
38302ac6454SAndrew Thompson static device_probe_t ural_match;
38402ac6454SAndrew Thompson static device_attach_t ural_attach;
38502ac6454SAndrew Thompson static device_detach_t ural_detach;
38602ac6454SAndrew Thompson 
38702ac6454SAndrew Thompson static device_method_t ural_methods[] = {
38802ac6454SAndrew Thompson 	/* Device interface */
38902ac6454SAndrew Thompson 	DEVMETHOD(device_probe,		ural_match),
39002ac6454SAndrew Thompson 	DEVMETHOD(device_attach,	ural_attach),
39102ac6454SAndrew Thompson 	DEVMETHOD(device_detach,	ural_detach),
392645e4d17SHans Petter Selasky 	DEVMETHOD_END
39302ac6454SAndrew Thompson };
39402ac6454SAndrew Thompson 
39502ac6454SAndrew Thompson static driver_t ural_driver = {
39602ac6454SAndrew Thompson 	.name = "ural",
39702ac6454SAndrew Thompson 	.methods = ural_methods,
39802ac6454SAndrew Thompson 	.size = sizeof(struct ural_softc),
39902ac6454SAndrew Thompson };
40002ac6454SAndrew Thompson 
401bc9372d7SJohn Baldwin DRIVER_MODULE(ural, uhub, ural_driver, NULL, NULL);
40202ac6454SAndrew Thompson MODULE_DEPEND(ural, usb, 1, 1, 1);
40302ac6454SAndrew Thompson MODULE_DEPEND(ural, wlan, 1, 1, 1);
404910cb8feSAndrew Thompson MODULE_VERSION(ural, 1);
405f809f280SWarner Losh USB_PNP_HOST_INFO(ural_devs);
40602ac6454SAndrew Thompson 
40702ac6454SAndrew Thompson static int
40802ac6454SAndrew Thompson ural_match(device_t self)
40902ac6454SAndrew Thompson {
410760bc48eSAndrew Thompson 	struct usb_attach_arg *uaa = device_get_ivars(self);
41102ac6454SAndrew Thompson 
412f29a0724SAndrew Thompson 	if (uaa->usb_mode != USB_MODE_HOST)
41302ac6454SAndrew Thompson 		return (ENXIO);
41402ac6454SAndrew Thompson 	if (uaa->info.bConfigIndex != 0)
41502ac6454SAndrew Thompson 		return (ENXIO);
41602ac6454SAndrew Thompson 	if (uaa->info.bIfaceIndex != RAL_IFACE_INDEX)
41702ac6454SAndrew Thompson 		return (ENXIO);
41802ac6454SAndrew Thompson 
419a593f6b8SAndrew Thompson 	return (usbd_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa));
42002ac6454SAndrew Thompson }
42102ac6454SAndrew Thompson 
42202ac6454SAndrew Thompson static int
42302ac6454SAndrew Thompson ural_attach(device_t self)
42402ac6454SAndrew Thompson {
425760bc48eSAndrew Thompson 	struct usb_attach_arg *uaa = device_get_ivars(self);
42602ac6454SAndrew Thompson 	struct ural_softc *sc = device_get_softc(self);
4277a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
4280046e186SAndriy Voskoboinyk 	uint8_t iface_index;
42902ac6454SAndrew Thompson 	int error;
43002ac6454SAndrew Thompson 
431a593f6b8SAndrew Thompson 	device_set_usb_desc(self);
43202ac6454SAndrew Thompson 	sc->sc_udev = uaa->device;
43302ac6454SAndrew Thompson 	sc->sc_dev = self;
43402ac6454SAndrew Thompson 
43502ac6454SAndrew Thompson 	mtx_init(&sc->sc_mtx, device_get_nameunit(self),
43602ac6454SAndrew Thompson 	    MTX_NETWORK_LOCK, MTX_DEF);
4377a79cebfSGleb Smirnoff 	mbufq_init(&sc->sc_snd, ifqmaxlen);
43802ac6454SAndrew Thompson 
43902ac6454SAndrew Thompson 	iface_index = RAL_IFACE_INDEX;
440a593f6b8SAndrew Thompson 	error = usbd_transfer_setup(uaa->device,
44102ac6454SAndrew Thompson 	    &iface_index, sc->sc_xfer, ural_config,
44202ac6454SAndrew Thompson 	    URAL_N_TRANSFER, sc, &sc->sc_mtx);
44302ac6454SAndrew Thompson 	if (error) {
44402ac6454SAndrew Thompson 		device_printf(self, "could not allocate USB transfers, "
445a593f6b8SAndrew Thompson 		    "err=%s\n", usbd_errstr(error));
44602ac6454SAndrew Thompson 		goto detach;
44702ac6454SAndrew Thompson 	}
44802ac6454SAndrew Thompson 
44902ac6454SAndrew Thompson 	RAL_LOCK(sc);
45002ac6454SAndrew Thompson 	/* retrieve RT2570 rev. no */
45102ac6454SAndrew Thompson 	sc->asic_rev = ural_read(sc, RAL_MAC_CSR0);
45202ac6454SAndrew Thompson 
45302ac6454SAndrew Thompson 	/* retrieve MAC address and various other things from EEPROM */
45402ac6454SAndrew Thompson 	ural_read_eeprom(sc);
45502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
45602ac6454SAndrew Thompson 
4575efea30fSAndrew Thompson 	device_printf(self, "MAC/BBP RT2570 (rev 0x%02x), RF %s\n",
45802ac6454SAndrew Thompson 	    sc->asic_rev, ural_get_rf(sc->rf_rev));
45902ac6454SAndrew Thompson 
46059686fe9SGleb Smirnoff 	ic->ic_softc = sc;
461c8550c02SGleb Smirnoff 	ic->ic_name = device_get_nameunit(self);
46202ac6454SAndrew Thompson 	ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
46302ac6454SAndrew Thompson 
46402ac6454SAndrew Thompson 	/* set device capabilities */
46502ac6454SAndrew Thompson 	ic->ic_caps =
46602ac6454SAndrew Thompson 	      IEEE80211_C_STA		/* station mode supported */
46702ac6454SAndrew Thompson 	    | IEEE80211_C_IBSS		/* IBSS mode supported */
46802ac6454SAndrew Thompson 	    | IEEE80211_C_MONITOR	/* monitor mode supported */
46902ac6454SAndrew Thompson 	    | IEEE80211_C_HOSTAP	/* HostAp mode supported */
47002ac6454SAndrew Thompson 	    | IEEE80211_C_TXPMGT	/* tx power management */
47102ac6454SAndrew Thompson 	    | IEEE80211_C_SHPREAMBLE	/* short preamble supported */
47202ac6454SAndrew Thompson 	    | IEEE80211_C_SHSLOT	/* short slot time supported */
47302ac6454SAndrew Thompson 	    | IEEE80211_C_BGSCAN	/* bg scanning supported */
47402ac6454SAndrew Thompson 	    | IEEE80211_C_WPA		/* 802.11i */
47502ac6454SAndrew Thompson 	    ;
47602ac6454SAndrew Thompson 
47783829b48SAndriy Voskoboinyk 	ural_getradiocaps(ic, IEEE80211_CHAN_MAX, &ic->ic_nchans,
47883829b48SAndriy Voskoboinyk 	    ic->ic_channels);
47902ac6454SAndrew Thompson 
4807a79cebfSGleb Smirnoff 	ieee80211_ifattach(ic);
48177ddf3d3SAndrew Thompson 	ic->ic_update_promisc = ural_update_promisc;
48202ac6454SAndrew Thompson 	ic->ic_raw_xmit = ural_raw_xmit;
48302ac6454SAndrew Thompson 	ic->ic_scan_start = ural_scan_start;
48402ac6454SAndrew Thompson 	ic->ic_scan_end = ural_scan_end;
48583829b48SAndriy Voskoboinyk 	ic->ic_getradiocaps = ural_getradiocaps;
48602ac6454SAndrew Thompson 	ic->ic_set_channel = ural_set_channel;
4877a79cebfSGleb Smirnoff 	ic->ic_parent = ural_parent;
4887a79cebfSGleb Smirnoff 	ic->ic_transmit = ural_transmit;
48902ac6454SAndrew Thompson 	ic->ic_vap_create = ural_vap_create;
49002ac6454SAndrew Thompson 	ic->ic_vap_delete = ural_vap_delete;
49102ac6454SAndrew Thompson 
4925463c4a4SSam Leffler 	ieee80211_radiotap_attach(ic,
4935463c4a4SSam Leffler 	    &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
4945463c4a4SSam Leffler 		RAL_TX_RADIOTAP_PRESENT,
4955463c4a4SSam Leffler 	    &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
4965463c4a4SSam Leffler 		RAL_RX_RADIOTAP_PRESENT);
49702ac6454SAndrew Thompson 
49802ac6454SAndrew Thompson 	if (bootverbose)
49902ac6454SAndrew Thompson 		ieee80211_announce(ic);
50002ac6454SAndrew Thompson 
5015efea30fSAndrew Thompson 	return (0);
5025efea30fSAndrew Thompson 
5035efea30fSAndrew Thompson detach:
5045efea30fSAndrew Thompson 	ural_detach(self);
5055efea30fSAndrew Thompson 	return (ENXIO);			/* failure */
50602ac6454SAndrew Thompson }
50702ac6454SAndrew Thompson 
50802ac6454SAndrew Thompson static int
50902ac6454SAndrew Thompson ural_detach(device_t self)
51002ac6454SAndrew Thompson {
51102ac6454SAndrew Thompson 	struct ural_softc *sc = device_get_softc(self);
5127a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
51302ac6454SAndrew Thompson 
514645e4d17SHans Petter Selasky 	/* prevent further ioctls */
515645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
516645e4d17SHans Petter Selasky 	sc->sc_detached = 1;
517645e4d17SHans Petter Selasky 	RAL_UNLOCK(sc);
518645e4d17SHans Petter Selasky 
51902ac6454SAndrew Thompson 	/* stop all USB transfers */
520a593f6b8SAndrew Thompson 	usbd_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER);
52102ac6454SAndrew Thompson 
52202ac6454SAndrew Thompson 	/* free TX list, if any */
52302ac6454SAndrew Thompson 	RAL_LOCK(sc);
52402ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
52502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
52602ac6454SAndrew Thompson 
5277a79cebfSGleb Smirnoff 	if (ic->ic_softc == sc)
52802ac6454SAndrew Thompson 		ieee80211_ifdetach(ic);
5297a79cebfSGleb Smirnoff 	mbufq_drain(&sc->sc_snd);
53002ac6454SAndrew Thompson 	mtx_destroy(&sc->sc_mtx);
53102ac6454SAndrew Thompson 
53202ac6454SAndrew Thompson 	return (0);
53302ac6454SAndrew Thompson }
53402ac6454SAndrew Thompson 
535e0a69b51SAndrew Thompson static usb_error_t
53677ddf3d3SAndrew Thompson ural_do_request(struct ural_softc *sc,
537760bc48eSAndrew Thompson     struct usb_device_request *req, void *data)
53877ddf3d3SAndrew Thompson {
539e0a69b51SAndrew Thompson 	usb_error_t err;
54077ddf3d3SAndrew Thompson 	int ntries = 10;
54177ddf3d3SAndrew Thompson 
54277ddf3d3SAndrew Thompson 	while (ntries--) {
543a593f6b8SAndrew Thompson 		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
54477ddf3d3SAndrew Thompson 		    req, data, 0, NULL, 250 /* ms */);
54577ddf3d3SAndrew Thompson 		if (err == 0)
54677ddf3d3SAndrew Thompson 			break;
54777ddf3d3SAndrew Thompson 
54877ddf3d3SAndrew Thompson 		DPRINTFN(1, "Control request failed, %s (retrying)\n",
549a593f6b8SAndrew Thompson 		    usbd_errstr(err));
55077ddf3d3SAndrew Thompson 		if (ural_pause(sc, hz / 100))
55177ddf3d3SAndrew Thompson 			break;
55277ddf3d3SAndrew Thompson 	}
55377ddf3d3SAndrew Thompson 	return (err);
55477ddf3d3SAndrew Thompson }
55577ddf3d3SAndrew Thompson 
55602ac6454SAndrew Thompson static struct ieee80211vap *
557fcd9500fSBernhard Schmidt ural_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
558fcd9500fSBernhard Schmidt     enum ieee80211_opmode opmode, int flags,
55902ac6454SAndrew Thompson     const uint8_t bssid[IEEE80211_ADDR_LEN],
56002ac6454SAndrew Thompson     const uint8_t mac[IEEE80211_ADDR_LEN])
56102ac6454SAndrew Thompson {
562d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
56302ac6454SAndrew Thompson 	struct ural_vap *uvp;
56402ac6454SAndrew Thompson 	struct ieee80211vap *vap;
56502ac6454SAndrew Thompson 
56602ac6454SAndrew Thompson 	if (!TAILQ_EMPTY(&ic->ic_vaps))		/* only one at a time */
56702ac6454SAndrew Thompson 		return NULL;
56897ad4604SKevin Lo 	uvp = malloc(sizeof(struct ural_vap), M_80211_VAP, M_WAITOK | M_ZERO);
56902ac6454SAndrew Thompson 	vap = &uvp->vap;
57002ac6454SAndrew Thompson 	/* enable s/w bmiss handling for sta mode */
571bb2f69e8SHans Petter Selasky 
572bb2f69e8SHans Petter Selasky 	if (ieee80211_vap_setup(ic, vap, name, unit, opmode,
5737a79cebfSGleb Smirnoff 	    flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) {
574bb2f69e8SHans Petter Selasky 		/* out of memory */
575bb2f69e8SHans Petter Selasky 		free(uvp, M_80211_VAP);
576bb2f69e8SHans Petter Selasky 		return (NULL);
577bb2f69e8SHans Petter Selasky 	}
57802ac6454SAndrew Thompson 
57902ac6454SAndrew Thompson 	/* override state transition machine */
58002ac6454SAndrew Thompson 	uvp->newstate = vap->iv_newstate;
58102ac6454SAndrew Thompson 	vap->iv_newstate = ural_newstate;
58202ac6454SAndrew Thompson 
583b6108616SRui Paulo 	usb_callout_init_mtx(&uvp->ratectl_ch, &sc->sc_mtx, 0);
584b6108616SRui Paulo 	TASK_INIT(&uvp->ratectl_task, 0, ural_ratectl_task, uvp);
585b6108616SRui Paulo 	ieee80211_ratectl_init(vap);
586b6108616SRui Paulo 	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
58702ac6454SAndrew Thompson 
58802ac6454SAndrew Thompson 	/* complete setup */
5897a79cebfSGleb Smirnoff 	ieee80211_vap_attach(vap, ieee80211_media_change,
5907a79cebfSGleb Smirnoff 	    ieee80211_media_status, mac);
59102ac6454SAndrew Thompson 	ic->ic_opmode = opmode;
59202ac6454SAndrew Thompson 	return vap;
59302ac6454SAndrew Thompson }
59402ac6454SAndrew Thompson 
59502ac6454SAndrew Thompson static void
59602ac6454SAndrew Thompson ural_vap_delete(struct ieee80211vap *vap)
59702ac6454SAndrew Thompson {
59802ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
5995efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
60002ac6454SAndrew Thompson 
601b6108616SRui Paulo 	usb_callout_drain(&uvp->ratectl_ch);
602b6108616SRui Paulo 	ieee80211_draintask(ic, &uvp->ratectl_task);
603b6108616SRui Paulo 	ieee80211_ratectl_deinit(vap);
60402ac6454SAndrew Thompson 	ieee80211_vap_detach(vap);
60502ac6454SAndrew Thompson 	free(uvp, M_80211_VAP);
60602ac6454SAndrew Thompson }
60702ac6454SAndrew Thompson 
60802ac6454SAndrew Thompson static void
60902ac6454SAndrew Thompson ural_tx_free(struct ural_tx_data *data, int txerr)
61002ac6454SAndrew Thompson {
61102ac6454SAndrew Thompson 	struct ural_softc *sc = data->sc;
61202ac6454SAndrew Thompson 
61302ac6454SAndrew Thompson 	if (data->m != NULL) {
6147a79cebfSGleb Smirnoff 		ieee80211_tx_complete(data->ni, data->m, txerr);
61502ac6454SAndrew Thompson 		data->m = NULL;
61602ac6454SAndrew Thompson 		data->ni = NULL;
61702ac6454SAndrew Thompson 	}
61802ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
61902ac6454SAndrew Thompson 	sc->tx_nfree++;
62002ac6454SAndrew Thompson }
62102ac6454SAndrew Thompson 
62202ac6454SAndrew Thompson static void
62302ac6454SAndrew Thompson ural_setup_tx_list(struct ural_softc *sc)
62402ac6454SAndrew Thompson {
62502ac6454SAndrew Thompson 	struct ural_tx_data *data;
62602ac6454SAndrew Thompson 	int i;
62702ac6454SAndrew Thompson 
62802ac6454SAndrew Thompson 	sc->tx_nfree = 0;
62902ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
63002ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
63102ac6454SAndrew Thompson 
63202ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
63302ac6454SAndrew Thompson 		data = &sc->tx_data[i];
63402ac6454SAndrew Thompson 
63502ac6454SAndrew Thompson 		data->sc = sc;
63602ac6454SAndrew Thompson 		STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
63702ac6454SAndrew Thompson 		sc->tx_nfree++;
63802ac6454SAndrew Thompson 	}
63902ac6454SAndrew Thompson }
64002ac6454SAndrew Thompson 
64102ac6454SAndrew Thompson static void
64202ac6454SAndrew Thompson ural_unsetup_tx_list(struct ural_softc *sc)
64302ac6454SAndrew Thompson {
64402ac6454SAndrew Thompson 	struct ural_tx_data *data;
64502ac6454SAndrew Thompson 	int i;
64602ac6454SAndrew Thompson 
64702ac6454SAndrew Thompson 	/* make sure any subsequent use of the queues will fail */
64802ac6454SAndrew Thompson 	sc->tx_nfree = 0;
64902ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
65002ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
65102ac6454SAndrew Thompson 
65202ac6454SAndrew Thompson 	/* free up all node references and mbufs */
65302ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
65402ac6454SAndrew Thompson 		data = &sc->tx_data[i];
65502ac6454SAndrew Thompson 
65602ac6454SAndrew Thompson 		if (data->m != NULL) {
65702ac6454SAndrew Thompson 			m_freem(data->m);
65802ac6454SAndrew Thompson 			data->m = NULL;
65902ac6454SAndrew Thompson 		}
66002ac6454SAndrew Thompson 		if (data->ni != NULL) {
66102ac6454SAndrew Thompson 			ieee80211_free_node(data->ni);
66202ac6454SAndrew Thompson 			data->ni = NULL;
66302ac6454SAndrew Thompson 		}
66402ac6454SAndrew Thompson 	}
66502ac6454SAndrew Thompson }
66602ac6454SAndrew Thompson 
6675efea30fSAndrew Thompson static int
6685efea30fSAndrew Thompson ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
66902ac6454SAndrew Thompson {
67002ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6715efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
672d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
67302ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
67402ac6454SAndrew Thompson 	struct ieee80211_node *ni;
67502ac6454SAndrew Thompson 	struct mbuf *m;
67602ac6454SAndrew Thompson 
6775efea30fSAndrew Thompson 	DPRINTF("%s -> %s\n",
6785efea30fSAndrew Thompson 		ieee80211_state_name[vap->iv_state],
6795efea30fSAndrew Thompson 		ieee80211_state_name[nstate]);
68002ac6454SAndrew Thompson 
6815efea30fSAndrew Thompson 	IEEE80211_UNLOCK(ic);
6825efea30fSAndrew Thompson 	RAL_LOCK(sc);
683b6108616SRui Paulo 	usb_callout_stop(&uvp->ratectl_ch);
6845efea30fSAndrew Thompson 
6855efea30fSAndrew Thompson 	switch (nstate) {
68602ac6454SAndrew Thompson 	case IEEE80211_S_INIT:
6875efea30fSAndrew Thompson 		if (vap->iv_state == IEEE80211_S_RUN) {
68802ac6454SAndrew Thompson 			/* abort TSF synchronization */
68902ac6454SAndrew Thompson 			ural_write(sc, RAL_TXRX_CSR19, 0);
69002ac6454SAndrew Thompson 
69102ac6454SAndrew Thompson 			/* force tx led to stop blinking */
69202ac6454SAndrew Thompson 			ural_write(sc, RAL_MAC_CSR20, 0);
69302ac6454SAndrew Thompson 		}
69402ac6454SAndrew Thompson 		break;
69502ac6454SAndrew Thompson 
69602ac6454SAndrew Thompson 	case IEEE80211_S_RUN:
6978d8bdb01SAndrew Thompson 		ni = ieee80211_ref_node(vap->iv_bss);
69802ac6454SAndrew Thompson 
69902ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR) {
7001517a7baSAdrian Chadd 			if (ic->ic_bsschan == IEEE80211_CHAN_ANYC)
7011517a7baSAdrian Chadd 				goto fail;
7021517a7baSAdrian Chadd 
7037a79cebfSGleb Smirnoff 			ural_update_slot(sc);
70402ac6454SAndrew Thompson 			ural_set_txpreamble(sc);
70502ac6454SAndrew Thompson 			ural_set_basicrates(sc, ic->ic_bsschan);
706ae132f11SAndriy Voskoboinyk 			IEEE80211_ADDR_COPY(sc->sc_bssid, ni->ni_bssid);
707ae132f11SAndriy Voskoboinyk 			ural_set_bssid(sc, sc->sc_bssid);
70802ac6454SAndrew Thompson 		}
70902ac6454SAndrew Thompson 
71002ac6454SAndrew Thompson 		if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
71102ac6454SAndrew Thompson 		    vap->iv_opmode == IEEE80211_M_IBSS) {
712210ab3c2SAdrian Chadd 			m = ieee80211_beacon_alloc(ni);
71302ac6454SAndrew Thompson 			if (m == NULL) {
71402ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
71502ac6454SAndrew Thompson 				    "could not allocate beacon\n");
7161517a7baSAdrian Chadd 				goto fail;
71702ac6454SAndrew Thompson 			}
7186fca0210SAndrew Thompson 			ieee80211_ref_node(ni);
71902ac6454SAndrew Thompson 			if (ural_tx_bcn(sc, m, ni) != 0) {
72002ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
72102ac6454SAndrew Thompson 				    "could not send beacon\n");
7221517a7baSAdrian Chadd 				goto fail;
72302ac6454SAndrew Thompson 			}
72402ac6454SAndrew Thompson 		}
72502ac6454SAndrew Thompson 
72602ac6454SAndrew Thompson 		/* make tx led blink on tx (controlled by ASIC) */
72702ac6454SAndrew Thompson 		ural_write(sc, RAL_MAC_CSR20, 1);
72802ac6454SAndrew Thompson 
72902ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR)
73002ac6454SAndrew Thompson 			ural_enable_tsf_sync(sc);
7315463c4a4SSam Leffler 		else
7325463c4a4SSam Leffler 			ural_enable_tsf(sc);
73302ac6454SAndrew Thompson 
73402ac6454SAndrew Thompson 		/* enable automatic rate adaptation */
7355463c4a4SSam Leffler 		/* XXX should use ic_bsschan but not valid until after newstate call below */
7365463c4a4SSam Leffler 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
73702ac6454SAndrew Thompson 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
738b6108616SRui Paulo 			ural_ratectl_start(sc, ni);
7398d8bdb01SAndrew Thompson 		ieee80211_free_node(ni);
74002ac6454SAndrew Thompson 		break;
74102ac6454SAndrew Thompson 
74202ac6454SAndrew Thompson 	default:
74302ac6454SAndrew Thompson 		break;
74402ac6454SAndrew Thompson 	}
74502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
74602ac6454SAndrew Thompson 	IEEE80211_LOCK(ic);
7475efea30fSAndrew Thompson 	return (uvp->newstate(vap, nstate, arg));
7481517a7baSAdrian Chadd 
7491517a7baSAdrian Chadd fail:
7501517a7baSAdrian Chadd 	RAL_UNLOCK(sc);
7511517a7baSAdrian Chadd 	IEEE80211_LOCK(ic);
7521517a7baSAdrian Chadd 	ieee80211_free_node(ni);
7531517a7baSAdrian Chadd 	return (-1);
75402ac6454SAndrew Thompson }
75502ac6454SAndrew Thompson 
75602ac6454SAndrew Thompson static void
757ed6d949aSAndrew Thompson ural_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
75802ac6454SAndrew Thompson {
759ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
7605463c4a4SSam Leffler 	struct ieee80211vap *vap;
76102ac6454SAndrew Thompson 	struct ural_tx_data *data;
76202ac6454SAndrew Thompson 	struct mbuf *m;
763ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
764ed6d949aSAndrew Thompson 	int len;
765ed6d949aSAndrew Thompson 
766ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
76702ac6454SAndrew Thompson 
76802ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
76902ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
770ed6d949aSAndrew Thompson 		DPRINTFN(11, "transfer complete, %d bytes\n", len);
77102ac6454SAndrew Thompson 
77202ac6454SAndrew Thompson 		/* free resources */
773ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
77402ac6454SAndrew Thompson 		ural_tx_free(data, 0);
775ed6d949aSAndrew Thompson 		usbd_xfer_set_priv(xfer, NULL);
77602ac6454SAndrew Thompson 
77702ac6454SAndrew Thompson 		/* FALLTHROUGH */
77802ac6454SAndrew Thompson 	case USB_ST_SETUP:
77902ac6454SAndrew Thompson tr_setup:
78002ac6454SAndrew Thompson 		data = STAILQ_FIRST(&sc->tx_q);
78102ac6454SAndrew Thompson 		if (data) {
78202ac6454SAndrew Thompson 			STAILQ_REMOVE_HEAD(&sc->tx_q, next);
78302ac6454SAndrew Thompson 			m = data->m;
78402ac6454SAndrew Thompson 
7856d917491SHans Petter Selasky 			if (m->m_pkthdr.len > (int)(RAL_FRAME_SIZE + RAL_TX_DESC_SIZE)) {
78602ac6454SAndrew Thompson 				DPRINTFN(0, "data overflow, %u bytes\n",
78702ac6454SAndrew Thompson 				    m->m_pkthdr.len);
78802ac6454SAndrew Thompson 				m->m_pkthdr.len = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE);
78902ac6454SAndrew Thompson 			}
790ed6d949aSAndrew Thompson 			pc = usbd_xfer_get_frame(xfer, 0);
791ed6d949aSAndrew Thompson 			usbd_copy_in(pc, 0, &data->desc, RAL_TX_DESC_SIZE);
792ed6d949aSAndrew Thompson 			usbd_m_copy_in(pc, RAL_TX_DESC_SIZE, m, 0,
79302ac6454SAndrew Thompson 			    m->m_pkthdr.len);
79402ac6454SAndrew Thompson 
7955463c4a4SSam Leffler 			vap = data->ni->ni_vap;
7965463c4a4SSam Leffler 			if (ieee80211_radiotap_active_vap(vap)) {
79702ac6454SAndrew Thompson 				struct ural_tx_radiotap_header *tap = &sc->sc_txtap;
79802ac6454SAndrew Thompson 
79902ac6454SAndrew Thompson 				tap->wt_flags = 0;
80002ac6454SAndrew Thompson 				tap->wt_rate = data->rate;
80102ac6454SAndrew Thompson 				tap->wt_antenna = sc->tx_ant;
80202ac6454SAndrew Thompson 
8035463c4a4SSam Leffler 				ieee80211_radiotap_tx(vap, m);
80402ac6454SAndrew Thompson 			}
80502ac6454SAndrew Thompson 
80602ac6454SAndrew Thompson 			/* xfer length needs to be a multiple of two! */
80702ac6454SAndrew Thompson 			len = (RAL_TX_DESC_SIZE + m->m_pkthdr.len + 1) & ~1;
80802ac6454SAndrew Thompson 			if ((len % 64) == 0)
80902ac6454SAndrew Thompson 				len += 2;
81002ac6454SAndrew Thompson 
81102ac6454SAndrew Thompson 			DPRINTFN(11, "sending frame len=%u xferlen=%u\n",
81202ac6454SAndrew Thompson 			    m->m_pkthdr.len, len);
81302ac6454SAndrew Thompson 
814ed6d949aSAndrew Thompson 			usbd_xfer_set_frame_len(xfer, 0, len);
815ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, data);
81602ac6454SAndrew Thompson 
817a593f6b8SAndrew Thompson 			usbd_transfer_submit(xfer);
81802ac6454SAndrew Thompson 		}
8197a79cebfSGleb Smirnoff 		ural_start(sc);
82002ac6454SAndrew Thompson 		break;
82102ac6454SAndrew Thompson 
82202ac6454SAndrew Thompson 	default:			/* Error */
82302ac6454SAndrew Thompson 		DPRINTFN(11, "transfer error, %s\n",
824ed6d949aSAndrew Thompson 		    usbd_errstr(error));
82502ac6454SAndrew Thompson 
826ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
82702ac6454SAndrew Thompson 		if (data != NULL) {
828ed6d949aSAndrew Thompson 			ural_tx_free(data, error);
829ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, NULL);
83002ac6454SAndrew Thompson 		}
83102ac6454SAndrew Thompson 
832ed6d949aSAndrew Thompson 		if (error == USB_ERR_STALLED) {
83302ac6454SAndrew Thompson 			/* try to clear stall first */
834ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
83502ac6454SAndrew Thompson 			goto tr_setup;
83602ac6454SAndrew Thompson 		}
837ed6d949aSAndrew Thompson 		if (error == USB_ERR_TIMEOUT)
83802ac6454SAndrew Thompson 			device_printf(sc->sc_dev, "device timeout\n");
83902ac6454SAndrew Thompson 		break;
84002ac6454SAndrew Thompson 	}
84102ac6454SAndrew Thompson }
84202ac6454SAndrew Thompson 
84302ac6454SAndrew Thompson static void
844ed6d949aSAndrew Thompson ural_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
84502ac6454SAndrew Thompson {
846ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
8477a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
84802ac6454SAndrew Thompson 	struct ieee80211_node *ni;
84902ac6454SAndrew Thompson 	struct mbuf *m = NULL;
850ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
85102ac6454SAndrew Thompson 	uint32_t flags;
8525463c4a4SSam Leffler 	int8_t rssi = 0, nf = 0;
853ed6d949aSAndrew Thompson 	int len;
854ed6d949aSAndrew Thompson 
855ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
85602ac6454SAndrew Thompson 
85702ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
85802ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
85902ac6454SAndrew Thompson 
860ed6d949aSAndrew Thompson 		DPRINTFN(15, "rx done, actlen=%d\n", len);
86102ac6454SAndrew Thompson 
8626d917491SHans Petter Selasky 		if (len < (int)(RAL_RX_DESC_SIZE + IEEE80211_MIN_LEN)) {
86302ac6454SAndrew Thompson 			DPRINTF("%s: xfer too short %d\n",
86402ac6454SAndrew Thompson 			    device_get_nameunit(sc->sc_dev), len);
8657a79cebfSGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
86602ac6454SAndrew Thompson 			goto tr_setup;
86702ac6454SAndrew Thompson 		}
86802ac6454SAndrew Thompson 
86902ac6454SAndrew Thompson 		len -= RAL_RX_DESC_SIZE;
87002ac6454SAndrew Thompson 		/* rx descriptor is located at the end */
871ed6d949aSAndrew Thompson 		pc = usbd_xfer_get_frame(xfer, 0);
872ed6d949aSAndrew Thompson 		usbd_copy_out(pc, len, &sc->sc_rx_desc, RAL_RX_DESC_SIZE);
87302ac6454SAndrew Thompson 
87402ac6454SAndrew Thompson 		rssi = URAL_RSSI(sc->sc_rx_desc.rssi);
8755463c4a4SSam Leffler 		nf = RAL_NOISE_FLOOR;
87602ac6454SAndrew Thompson 		flags = le32toh(sc->sc_rx_desc.flags);
87702ac6454SAndrew Thompson 		if (flags & (RAL_RX_PHY_ERROR | RAL_RX_CRC_ERROR)) {
87802ac6454SAndrew Thompson 			/*
87902ac6454SAndrew Thompson 		         * This should not happen since we did not
88002ac6454SAndrew Thompson 		         * request to receive those frames when we
88102ac6454SAndrew Thompson 		         * filled RAL_TXRX_CSR2:
88202ac6454SAndrew Thompson 		         */
88302ac6454SAndrew Thompson 			DPRINTFN(5, "PHY or CRC error\n");
8847a79cebfSGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
88502ac6454SAndrew Thompson 			goto tr_setup;
88602ac6454SAndrew Thompson 		}
88702ac6454SAndrew Thompson 
888c6499eccSGleb Smirnoff 		m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
88902ac6454SAndrew Thompson 		if (m == NULL) {
89002ac6454SAndrew Thompson 			DPRINTF("could not allocate mbuf\n");
8917a79cebfSGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
89202ac6454SAndrew Thompson 			goto tr_setup;
89302ac6454SAndrew Thompson 		}
894ed6d949aSAndrew Thompson 		usbd_copy_out(pc, 0, mtod(m, uint8_t *), len);
89502ac6454SAndrew Thompson 
89602ac6454SAndrew Thompson 		/* finalize mbuf */
89702ac6454SAndrew Thompson 		m->m_pkthdr.len = m->m_len = (flags >> 16) & 0xfff;
89802ac6454SAndrew Thompson 
8995463c4a4SSam Leffler 		if (ieee80211_radiotap_active(ic)) {
90002ac6454SAndrew Thompson 			struct ural_rx_radiotap_header *tap = &sc->sc_rxtap;
90102ac6454SAndrew Thompson 
9025463c4a4SSam Leffler 			/* XXX set once */
9035463c4a4SSam Leffler 			tap->wr_flags = 0;
90402ac6454SAndrew Thompson 			tap->wr_rate = ieee80211_plcp2rate(sc->sc_rx_desc.rate,
90502ac6454SAndrew Thompson 			    (flags & RAL_RX_OFDM) ?
90602ac6454SAndrew Thompson 			    IEEE80211_T_OFDM : IEEE80211_T_CCK);
90702ac6454SAndrew Thompson 			tap->wr_antenna = sc->rx_ant;
9085463c4a4SSam Leffler 			tap->wr_antsignal = nf + rssi;
9095463c4a4SSam Leffler 			tap->wr_antnoise = nf;
91002ac6454SAndrew Thompson 		}
91102ac6454SAndrew Thompson 		/* Strip trailing 802.11 MAC FCS. */
91202ac6454SAndrew Thompson 		m_adj(m, -IEEE80211_CRC_LEN);
91302ac6454SAndrew Thompson 
91402ac6454SAndrew Thompson 		/* FALLTHROUGH */
91502ac6454SAndrew Thompson 	case USB_ST_SETUP:
91602ac6454SAndrew Thompson tr_setup:
917ed6d949aSAndrew Thompson 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
918a593f6b8SAndrew Thompson 		usbd_transfer_submit(xfer);
91902ac6454SAndrew Thompson 
92002ac6454SAndrew Thompson 		/*
92102ac6454SAndrew Thompson 		 * At the end of a USB callback it is always safe to unlock
92202ac6454SAndrew Thompson 		 * the private mutex of a device! That is why we do the
92302ac6454SAndrew Thompson 		 * "ieee80211_input" here, and not some lines up!
92402ac6454SAndrew Thompson 		 */
92502ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
926941da6d3SWeongyo Jeong 		if (m) {
92702ac6454SAndrew Thompson 			ni = ieee80211_find_rxnode(ic,
92802ac6454SAndrew Thompson 			    mtod(m, struct ieee80211_frame_min *));
92902ac6454SAndrew Thompson 			if (ni != NULL) {
9305463c4a4SSam Leffler 				(void) ieee80211_input(ni, m, rssi, nf);
93102ac6454SAndrew Thompson 				ieee80211_free_node(ni);
93202ac6454SAndrew Thompson 			} else
9335463c4a4SSam Leffler 				(void) ieee80211_input_all(ic, m, rssi, nf);
93402ac6454SAndrew Thompson 		}
935941da6d3SWeongyo Jeong 		RAL_LOCK(sc);
9367a79cebfSGleb Smirnoff 		ural_start(sc);
93702ac6454SAndrew Thompson 		return;
93802ac6454SAndrew Thompson 
93902ac6454SAndrew Thompson 	default:			/* Error */
940ed6d949aSAndrew Thompson 		if (error != USB_ERR_CANCELLED) {
94102ac6454SAndrew Thompson 			/* try to clear stall first */
942ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
94302ac6454SAndrew Thompson 			goto tr_setup;
94402ac6454SAndrew Thompson 		}
94502ac6454SAndrew Thompson 		return;
94602ac6454SAndrew Thompson 	}
94702ac6454SAndrew Thompson }
94802ac6454SAndrew Thompson 
94902ac6454SAndrew Thompson static uint8_t
95002ac6454SAndrew Thompson ural_plcp_signal(int rate)
95102ac6454SAndrew Thompson {
95202ac6454SAndrew Thompson 	switch (rate) {
95302ac6454SAndrew Thompson 	/* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
95402ac6454SAndrew Thompson 	case 12:	return 0xb;
95502ac6454SAndrew Thompson 	case 18:	return 0xf;
95602ac6454SAndrew Thompson 	case 24:	return 0xa;
95702ac6454SAndrew Thompson 	case 36:	return 0xe;
95802ac6454SAndrew Thompson 	case 48:	return 0x9;
95902ac6454SAndrew Thompson 	case 72:	return 0xd;
96002ac6454SAndrew Thompson 	case 96:	return 0x8;
96102ac6454SAndrew Thompson 	case 108:	return 0xc;
96202ac6454SAndrew Thompson 
96302ac6454SAndrew Thompson 	/* CCK rates (NB: not IEEE std, device-specific) */
96402ac6454SAndrew Thompson 	case 2:		return 0x0;
96502ac6454SAndrew Thompson 	case 4:		return 0x1;
96602ac6454SAndrew Thompson 	case 11:	return 0x2;
96702ac6454SAndrew Thompson 	case 22:	return 0x3;
96802ac6454SAndrew Thompson 	}
96902ac6454SAndrew Thompson 	return 0xff;		/* XXX unsupported/unknown rate */
97002ac6454SAndrew Thompson }
97102ac6454SAndrew Thompson 
97202ac6454SAndrew Thompson static void
97302ac6454SAndrew Thompson ural_setup_tx_desc(struct ural_softc *sc, struct ural_tx_desc *desc,
97402ac6454SAndrew Thompson     uint32_t flags, int len, int rate)
97502ac6454SAndrew Thompson {
9767a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
97702ac6454SAndrew Thompson 	uint16_t plcp_length;
97802ac6454SAndrew Thompson 	int remainder;
97902ac6454SAndrew Thompson 
98002ac6454SAndrew Thompson 	desc->flags = htole32(flags);
98102ac6454SAndrew Thompson 	desc->flags |= htole32(RAL_TX_NEWSEQ);
98202ac6454SAndrew Thompson 	desc->flags |= htole32(len << 16);
98302ac6454SAndrew Thompson 
98402ac6454SAndrew Thompson 	desc->wme = htole16(RAL_AIFSN(2) | RAL_LOGCWMIN(3) | RAL_LOGCWMAX(5));
98502ac6454SAndrew Thompson 	desc->wme |= htole16(RAL_IVOFFSET(sizeof (struct ieee80211_frame)));
98602ac6454SAndrew Thompson 
98702ac6454SAndrew Thompson 	/* setup PLCP fields */
98802ac6454SAndrew Thompson 	desc->plcp_signal  = ural_plcp_signal(rate);
98902ac6454SAndrew Thompson 	desc->plcp_service = 4;
99002ac6454SAndrew Thompson 
99102ac6454SAndrew Thompson 	len += IEEE80211_CRC_LEN;
99226d39e2cSSam Leffler 	if (ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM) {
99302ac6454SAndrew Thompson 		desc->flags |= htole32(RAL_TX_OFDM);
99402ac6454SAndrew Thompson 
99502ac6454SAndrew Thompson 		plcp_length = len & 0xfff;
99602ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 6;
99702ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0x3f;
99802ac6454SAndrew Thompson 	} else {
999b8e3094cSHans Petter Selasky 		if (rate == 0)
1000b8e3094cSHans Petter Selasky 			rate = 2;	/* avoid division by zero */
1001057b4402SPedro F. Giffuni 		plcp_length = howmany(16 * len, rate);
100202ac6454SAndrew Thompson 		if (rate == 22) {
100302ac6454SAndrew Thompson 			remainder = (16 * len) % 22;
100402ac6454SAndrew Thompson 			if (remainder != 0 && remainder < 7)
100502ac6454SAndrew Thompson 				desc->plcp_service |= RAL_PLCP_LENGEXT;
100602ac6454SAndrew Thompson 		}
100702ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 8;
100802ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0xff;
100902ac6454SAndrew Thompson 
101002ac6454SAndrew Thompson 		if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
101102ac6454SAndrew Thompson 			desc->plcp_signal |= 0x08;
101202ac6454SAndrew Thompson 	}
101302ac6454SAndrew Thompson 
101402ac6454SAndrew Thompson 	desc->iv = 0;
101502ac6454SAndrew Thompson 	desc->eiv = 0;
101602ac6454SAndrew Thompson }
101702ac6454SAndrew Thompson 
101802ac6454SAndrew Thompson #define RAL_TX_TIMEOUT	5000
101902ac6454SAndrew Thompson 
102002ac6454SAndrew Thompson static int
102102ac6454SAndrew Thompson ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
102202ac6454SAndrew Thompson {
102302ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
102402ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
102502ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
102602ac6454SAndrew Thompson 	struct ural_tx_data *data;
102702ac6454SAndrew Thompson 
102802ac6454SAndrew Thompson 	if (sc->tx_nfree == 0) {
102902ac6454SAndrew Thompson 		m_freem(m0);
103002ac6454SAndrew Thompson 		ieee80211_free_node(ni);
1031bb571462SHans Petter Selasky 		return (EIO);
1032bb571462SHans Petter Selasky 	}
1033bb571462SHans Petter Selasky 	if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
1034bb571462SHans Petter Selasky 		m_freem(m0);
1035bb571462SHans Petter Selasky 		ieee80211_free_node(ni);
1036bb571462SHans Petter Selasky 		return (ENXIO);
103702ac6454SAndrew Thompson 	}
103802ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
103902ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
104002ac6454SAndrew Thompson 	sc->tx_nfree--;
104102ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
104202ac6454SAndrew Thompson 
104302ac6454SAndrew Thompson 	data->m = m0;
104402ac6454SAndrew Thompson 	data->ni = ni;
104502ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
104602ac6454SAndrew Thompson 
104702ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc,
104802ac6454SAndrew Thompson 	    RAL_TX_IFS_NEWBACKOFF | RAL_TX_TIMESTAMP, m0->m_pkthdr.len,
104902ac6454SAndrew Thompson 	    tp->mgmtrate);
105002ac6454SAndrew Thompson 
105102ac6454SAndrew Thompson 	DPRINTFN(10, "sending beacon frame len=%u rate=%u\n",
105202ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
105302ac6454SAndrew Thompson 
105402ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1055a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
105602ac6454SAndrew Thompson 
105702ac6454SAndrew Thompson 	return (0);
105802ac6454SAndrew Thompson }
105902ac6454SAndrew Thompson 
106002ac6454SAndrew Thompson static int
106102ac6454SAndrew Thompson ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
106202ac6454SAndrew Thompson {
1063f6313575SAndriy Voskoboinyk 	const struct ieee80211_txparam *tp = ni->ni_txparms;
106402ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
106502ac6454SAndrew Thompson 	struct ural_tx_data *data;
106602ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
106702ac6454SAndrew Thompson 	struct ieee80211_key *k;
106802ac6454SAndrew Thompson 	uint32_t flags;
106902ac6454SAndrew Thompson 	uint16_t dur;
107002ac6454SAndrew Thompson 
107102ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
107202ac6454SAndrew Thompson 
107302ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
107402ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
107502ac6454SAndrew Thompson 	sc->tx_nfree--;
107602ac6454SAndrew Thompson 
107702ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
10785945b5f5SKevin Lo 	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
107902ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
108002ac6454SAndrew Thompson 		if (k == NULL) {
108102ac6454SAndrew Thompson 			m_freem(m0);
108202ac6454SAndrew Thompson 			return ENOBUFS;
108302ac6454SAndrew Thompson 		}
108402ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
108502ac6454SAndrew Thompson 	}
108602ac6454SAndrew Thompson 
108702ac6454SAndrew Thompson 	data->m = m0;
108802ac6454SAndrew Thompson 	data->ni = ni;
108902ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
109002ac6454SAndrew Thompson 
109102ac6454SAndrew Thompson 	flags = 0;
109202ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
109302ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
109402ac6454SAndrew Thompson 
109526d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, tp->mgmtrate,
109602ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
10978cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
109802ac6454SAndrew Thompson 
109902ac6454SAndrew Thompson 		/* tell hardware to add timestamp for probe responses */
1100c249cc38SAdrian Chadd 		if (IEEE80211_IS_MGMT_PROBE_RESP(wh))
110102ac6454SAndrew Thompson 			flags |= RAL_TX_TIMESTAMP;
110202ac6454SAndrew Thompson 	}
110302ac6454SAndrew Thompson 
110402ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, tp->mgmtrate);
110502ac6454SAndrew Thompson 
110602ac6454SAndrew Thompson 	DPRINTFN(10, "sending mgt frame len=%u rate=%u\n",
110702ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
110802ac6454SAndrew Thompson 
110902ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1110a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
111102ac6454SAndrew Thompson 
111202ac6454SAndrew Thompson 	return 0;
111302ac6454SAndrew Thompson }
111402ac6454SAndrew Thompson 
111502ac6454SAndrew Thompson static int
111602ac6454SAndrew Thompson ural_sendprot(struct ural_softc *sc,
111702ac6454SAndrew Thompson     const struct mbuf *m, struct ieee80211_node *ni, int prot, int rate)
111802ac6454SAndrew Thompson {
111902ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
112002ac6454SAndrew Thompson 	struct ural_tx_data *data;
112102ac6454SAndrew Thompson 	struct mbuf *mprot;
1122d1b67106SAndriy Voskoboinyk 	int protrate, flags;
112302ac6454SAndrew Thompson 
1124d1b67106SAndriy Voskoboinyk 	mprot = ieee80211_alloc_prot(ni, m, rate, prot);
112502ac6454SAndrew Thompson 	if (mprot == NULL) {
1126d1b67106SAndriy Voskoboinyk 		if_inc_counter(ni->ni_vap->iv_ifp, IFCOUNTER_OERRORS, 1);
1127d1b67106SAndriy Voskoboinyk 		device_printf(sc->sc_dev,
1128d1b67106SAndriy Voskoboinyk 		    "could not allocate mbuf for protection mode %d\n", prot);
112902ac6454SAndrew Thompson 		return ENOBUFS;
113002ac6454SAndrew Thompson 	}
1131d1b67106SAndriy Voskoboinyk 
1132d1b67106SAndriy Voskoboinyk 	protrate = ieee80211_ctl_rate(ic->ic_rt, rate);
1133d1b67106SAndriy Voskoboinyk 	flags = RAL_TX_RETRY(7);
1134d1b67106SAndriy Voskoboinyk 	if (prot == IEEE80211_PROT_RTSCTS)
1135d1b67106SAndriy Voskoboinyk 		flags |= RAL_TX_ACK;
1136d1b67106SAndriy Voskoboinyk 
113702ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
113802ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
113902ac6454SAndrew Thompson 	sc->tx_nfree--;
114002ac6454SAndrew Thompson 
114102ac6454SAndrew Thompson 	data->m = mprot;
114202ac6454SAndrew Thompson 	data->ni = ieee80211_ref_node(ni);
114302ac6454SAndrew Thompson 	data->rate = protrate;
114402ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, mprot->m_pkthdr.len, protrate);
114502ac6454SAndrew Thompson 
114602ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1147a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
114802ac6454SAndrew Thompson 
114902ac6454SAndrew Thompson 	return 0;
115002ac6454SAndrew Thompson }
115102ac6454SAndrew Thompson 
115202ac6454SAndrew Thompson static int
115302ac6454SAndrew Thompson ural_tx_raw(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
115402ac6454SAndrew Thompson     const struct ieee80211_bpf_params *params)
115502ac6454SAndrew Thompson {
1156515db61dSSam Leffler 	struct ieee80211com *ic = ni->ni_ic;
115702ac6454SAndrew Thompson 	struct ural_tx_data *data;
115802ac6454SAndrew Thompson 	uint32_t flags;
115902ac6454SAndrew Thompson 	int error;
116002ac6454SAndrew Thompson 	int rate;
116102ac6454SAndrew Thompson 
116202ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
116302ac6454SAndrew Thompson 	KASSERT(params != NULL, ("no raw xmit params"));
116402ac6454SAndrew Thompson 
1165515db61dSSam Leffler 	rate = params->ibp_rate0;
1166515db61dSSam Leffler 	if (!ieee80211_isratevalid(ic->ic_rt, rate)) {
116702ac6454SAndrew Thompson 		m_freem(m0);
116802ac6454SAndrew Thompson 		return EINVAL;
116902ac6454SAndrew Thompson 	}
117002ac6454SAndrew Thompson 	flags = 0;
117102ac6454SAndrew Thompson 	if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
117202ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
117302ac6454SAndrew Thompson 	if (params->ibp_flags & (IEEE80211_BPF_RTS|IEEE80211_BPF_CTS)) {
117402ac6454SAndrew Thompson 		error = ural_sendprot(sc, m0, ni,
117502ac6454SAndrew Thompson 		    params->ibp_flags & IEEE80211_BPF_RTS ?
117602ac6454SAndrew Thompson 			 IEEE80211_PROT_RTSCTS : IEEE80211_PROT_CTSONLY,
117702ac6454SAndrew Thompson 		    rate);
117896ca458fSAndrew Thompson 		if (error || sc->tx_nfree == 0) {
117902ac6454SAndrew Thompson 			m_freem(m0);
118096ca458fSAndrew Thompson 			return ENOBUFS;
118102ac6454SAndrew Thompson 		}
118202ac6454SAndrew Thompson 		flags |= RAL_TX_IFS_SIFS;
118302ac6454SAndrew Thompson 	}
118402ac6454SAndrew Thompson 
118596ca458fSAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
118696ca458fSAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
118796ca458fSAndrew Thompson 	sc->tx_nfree--;
118896ca458fSAndrew Thompson 
118902ac6454SAndrew Thompson 	data->m = m0;
119002ac6454SAndrew Thompson 	data->ni = ni;
119102ac6454SAndrew Thompson 	data->rate = rate;
119202ac6454SAndrew Thompson 
119302ac6454SAndrew Thompson 	/* XXX need to setup descriptor ourself */
119402ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
119502ac6454SAndrew Thompson 
119602ac6454SAndrew Thompson 	DPRINTFN(10, "sending raw frame len=%u rate=%u\n",
119702ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
119802ac6454SAndrew Thompson 
119902ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1200a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
120102ac6454SAndrew Thompson 
120202ac6454SAndrew Thompson 	return 0;
120302ac6454SAndrew Thompson }
120402ac6454SAndrew Thompson 
120502ac6454SAndrew Thompson static int
120602ac6454SAndrew Thompson ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
120702ac6454SAndrew Thompson {
120802ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
120902ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
121002ac6454SAndrew Thompson 	struct ural_tx_data *data;
121102ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
1212f6313575SAndriy Voskoboinyk 	const struct ieee80211_txparam *tp = ni->ni_txparms;
121302ac6454SAndrew Thompson 	struct ieee80211_key *k;
121402ac6454SAndrew Thompson 	uint32_t flags = 0;
121502ac6454SAndrew Thompson 	uint16_t dur;
121602ac6454SAndrew Thompson 	int error, rate;
121702ac6454SAndrew Thompson 
121802ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
121902ac6454SAndrew Thompson 
122002ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
122102ac6454SAndrew Thompson 
1222f6313575SAndriy Voskoboinyk 	if (m0->m_flags & M_EAPOL)
1223f6313575SAndriy Voskoboinyk 		rate = tp->mgmtrate;
1224f6313575SAndriy Voskoboinyk 	else if (IEEE80211_IS_MULTICAST(wh->i_addr1))
122502ac6454SAndrew Thompson 		rate = tp->mcastrate;
122602ac6454SAndrew Thompson 	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
122702ac6454SAndrew Thompson 		rate = tp->ucastrate;
1228f6930becSAndriy Voskoboinyk 	else {
1229f6930becSAndriy Voskoboinyk 		(void) ieee80211_ratectl_rate(ni, NULL, 0);
1230*70674500SAdrian Chadd 		rate = ieee80211_node_get_txrate_dot11rate(ni);
1231f6930becSAndriy Voskoboinyk 	}
123202ac6454SAndrew Thompson 
12335945b5f5SKevin Lo 	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
123402ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
123502ac6454SAndrew Thompson 		if (k == NULL) {
123602ac6454SAndrew Thompson 			m_freem(m0);
123702ac6454SAndrew Thompson 			return ENOBUFS;
123802ac6454SAndrew Thompson 		}
123902ac6454SAndrew Thompson 		/* packet header may have moved, reset our local pointer */
124002ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
124102ac6454SAndrew Thompson 	}
124202ac6454SAndrew Thompson 
124302ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
124402ac6454SAndrew Thompson 		int prot = IEEE80211_PROT_NONE;
124502ac6454SAndrew Thompson 		if (m0->m_pkthdr.len + IEEE80211_CRC_LEN > vap->iv_rtsthreshold)
124602ac6454SAndrew Thompson 			prot = IEEE80211_PROT_RTSCTS;
124702ac6454SAndrew Thompson 		else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
124826d39e2cSSam Leffler 		    ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM)
124902ac6454SAndrew Thompson 			prot = ic->ic_protmode;
125002ac6454SAndrew Thompson 		if (prot != IEEE80211_PROT_NONE) {
125102ac6454SAndrew Thompson 			error = ural_sendprot(sc, m0, ni, prot, rate);
125296ca458fSAndrew Thompson 			if (error || sc->tx_nfree == 0) {
125302ac6454SAndrew Thompson 				m_freem(m0);
125496ca458fSAndrew Thompson 				return ENOBUFS;
125502ac6454SAndrew Thompson 			}
125602ac6454SAndrew Thompson 			flags |= RAL_TX_IFS_SIFS;
125702ac6454SAndrew Thompson 		}
125802ac6454SAndrew Thompson 	}
125902ac6454SAndrew Thompson 
126002ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
126102ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
126202ac6454SAndrew Thompson 	sc->tx_nfree--;
126302ac6454SAndrew Thompson 
126402ac6454SAndrew Thompson 	data->m = m0;
126502ac6454SAndrew Thompson 	data->ni = ni;
126602ac6454SAndrew Thompson 	data->rate = rate;
126702ac6454SAndrew Thompson 
126802ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
126902ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
127002ac6454SAndrew Thompson 		flags |= RAL_TX_RETRY(7);
127102ac6454SAndrew Thompson 
127226d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, rate,
127302ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
12748cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
127502ac6454SAndrew Thompson 	}
127602ac6454SAndrew Thompson 
127702ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
127802ac6454SAndrew Thompson 
127902ac6454SAndrew Thompson 	DPRINTFN(10, "sending data frame len=%u rate=%u\n",
128002ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
128102ac6454SAndrew Thompson 
128202ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1283a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
128402ac6454SAndrew Thompson 
128502ac6454SAndrew Thompson 	return 0;
128602ac6454SAndrew Thompson }
128702ac6454SAndrew Thompson 
12887a79cebfSGleb Smirnoff static int
12897a79cebfSGleb Smirnoff ural_transmit(struct ieee80211com *ic, struct mbuf *m)
129079d2c5e8SGleb Smirnoff {
12917a79cebfSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
12927a79cebfSGleb Smirnoff 	int error;
12937a79cebfSGleb Smirnoff 
12947a79cebfSGleb Smirnoff 	RAL_LOCK(sc);
12957a79cebfSGleb Smirnoff 	if (!sc->sc_running) {
12967a79cebfSGleb Smirnoff 		RAL_UNLOCK(sc);
12977a79cebfSGleb Smirnoff 		return (ENXIO);
12987a79cebfSGleb Smirnoff 	}
12997a79cebfSGleb Smirnoff 	error = mbufq_enqueue(&sc->sc_snd, m);
13007a79cebfSGleb Smirnoff 	if (error) {
13017a79cebfSGleb Smirnoff 		RAL_UNLOCK(sc);
13027a79cebfSGleb Smirnoff 		return (error);
13037a79cebfSGleb Smirnoff 	}
13047a79cebfSGleb Smirnoff 	ural_start(sc);
13057a79cebfSGleb Smirnoff 	RAL_UNLOCK(sc);
13067a79cebfSGleb Smirnoff 
13077a79cebfSGleb Smirnoff 	return (0);
13087a79cebfSGleb Smirnoff }
13097a79cebfSGleb Smirnoff 
13107a79cebfSGleb Smirnoff static void
13117a79cebfSGleb Smirnoff ural_start(struct ural_softc *sc)
13127a79cebfSGleb Smirnoff {
131302ac6454SAndrew Thompson 	struct ieee80211_node *ni;
131402ac6454SAndrew Thompson 	struct mbuf *m;
131502ac6454SAndrew Thompson 
13167a79cebfSGleb Smirnoff 	RAL_LOCK_ASSERT(sc, MA_OWNED);
13177a79cebfSGleb Smirnoff 
13187a79cebfSGleb Smirnoff 	if (sc->sc_running == 0)
131902ac6454SAndrew Thompson 		return;
13207a79cebfSGleb Smirnoff 
13217a79cebfSGleb Smirnoff 	while (sc->tx_nfree >= RAL_TX_MINFREE &&
13227a79cebfSGleb Smirnoff 	    (m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
132302ac6454SAndrew Thompson 		ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
132402ac6454SAndrew Thompson 		if (ural_tx_data(sc, m, ni) != 0) {
13257a79cebfSGleb Smirnoff 			if_inc_counter(ni->ni_vap->iv_ifp,
13267a79cebfSGleb Smirnoff 			     IFCOUNTER_OERRORS, 1);
132702ac6454SAndrew Thompson 			ieee80211_free_node(ni);
132802ac6454SAndrew Thompson 			break;
132902ac6454SAndrew Thompson 		}
133002ac6454SAndrew Thompson 	}
133102ac6454SAndrew Thompson }
133202ac6454SAndrew Thompson 
13337a79cebfSGleb Smirnoff static void
13347a79cebfSGleb Smirnoff ural_parent(struct ieee80211com *ic)
133502ac6454SAndrew Thompson {
13367a79cebfSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
1337645e4d17SHans Petter Selasky 	int startall = 0;
1338645e4d17SHans Petter Selasky 
1339645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
13407a79cebfSGleb Smirnoff 	if (sc->sc_detached) {
1341645e4d17SHans Petter Selasky 		RAL_UNLOCK(sc);
13427a79cebfSGleb Smirnoff 		return;
13437a79cebfSGleb Smirnoff 	}
13447a79cebfSGleb Smirnoff 	if (ic->ic_nrunning > 0) {
13457a79cebfSGleb Smirnoff 		if (sc->sc_running == 0) {
13467a79cebfSGleb Smirnoff 			ural_init(sc);
134702ac6454SAndrew Thompson 			startall = 1;
134802ac6454SAndrew Thompson 		} else
13495efea30fSAndrew Thompson 			ural_setpromisc(sc);
13507a79cebfSGleb Smirnoff 	} else if (sc->sc_running)
13515efea30fSAndrew Thompson 		ural_stop(sc);
135202ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
135302ac6454SAndrew Thompson 	if (startall)
135402ac6454SAndrew Thompson 		ieee80211_start_all(ic);
135502ac6454SAndrew Thompson }
135602ac6454SAndrew Thompson 
135702ac6454SAndrew Thompson static void
135802ac6454SAndrew Thompson ural_set_testmode(struct ural_softc *sc)
135902ac6454SAndrew Thompson {
1360760bc48eSAndrew Thompson 	struct usb_device_request req;
1361e0a69b51SAndrew Thompson 	usb_error_t error;
136202ac6454SAndrew Thompson 
136302ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
136402ac6454SAndrew Thompson 	req.bRequest = RAL_VENDOR_REQUEST;
136502ac6454SAndrew Thompson 	USETW(req.wValue, 4);
136602ac6454SAndrew Thompson 	USETW(req.wIndex, 1);
136702ac6454SAndrew Thompson 	USETW(req.wLength, 0);
136802ac6454SAndrew Thompson 
136902ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
137002ac6454SAndrew Thompson 	if (error != 0) {
137102ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not set test mode: %s\n",
1372a593f6b8SAndrew Thompson 		    usbd_errstr(error));
137302ac6454SAndrew Thompson 	}
137402ac6454SAndrew Thompson }
137502ac6454SAndrew Thompson 
137602ac6454SAndrew Thompson static void
137702ac6454SAndrew Thompson ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)
137802ac6454SAndrew Thompson {
1379760bc48eSAndrew Thompson 	struct usb_device_request req;
1380e0a69b51SAndrew Thompson 	usb_error_t error;
138102ac6454SAndrew Thompson 
138202ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
138302ac6454SAndrew Thompson 	req.bRequest = RAL_READ_EEPROM;
138402ac6454SAndrew Thompson 	USETW(req.wValue, 0);
138502ac6454SAndrew Thompson 	USETW(req.wIndex, addr);
138602ac6454SAndrew Thompson 	USETW(req.wLength, len);
138702ac6454SAndrew Thompson 
138802ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
138902ac6454SAndrew Thompson 	if (error != 0) {
139002ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1391a593f6b8SAndrew Thompson 		    usbd_errstr(error));
139202ac6454SAndrew Thompson 	}
139302ac6454SAndrew Thompson }
139402ac6454SAndrew Thompson 
139502ac6454SAndrew Thompson static uint16_t
139602ac6454SAndrew Thompson ural_read(struct ural_softc *sc, uint16_t reg)
139702ac6454SAndrew Thompson {
1398760bc48eSAndrew Thompson 	struct usb_device_request req;
1399e0a69b51SAndrew Thompson 	usb_error_t error;
140002ac6454SAndrew Thompson 	uint16_t val;
140102ac6454SAndrew Thompson 
140202ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
140302ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MAC;
140402ac6454SAndrew Thompson 	USETW(req.wValue, 0);
140502ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
140602ac6454SAndrew Thompson 	USETW(req.wLength, sizeof (uint16_t));
140702ac6454SAndrew Thompson 
140802ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, &val);
140902ac6454SAndrew Thompson 	if (error != 0) {
141002ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1411a593f6b8SAndrew Thompson 		    usbd_errstr(error));
141202ac6454SAndrew Thompson 		return 0;
141302ac6454SAndrew Thompson 	}
141402ac6454SAndrew Thompson 
141502ac6454SAndrew Thompson 	return le16toh(val);
141602ac6454SAndrew Thompson }
141702ac6454SAndrew Thompson 
141802ac6454SAndrew Thompson static void
141902ac6454SAndrew Thompson ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
142002ac6454SAndrew Thompson {
1421760bc48eSAndrew Thompson 	struct usb_device_request req;
1422e0a69b51SAndrew Thompson 	usb_error_t error;
142302ac6454SAndrew Thompson 
142402ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
142502ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MULTI_MAC;
142602ac6454SAndrew Thompson 	USETW(req.wValue, 0);
142702ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
142802ac6454SAndrew Thompson 	USETW(req.wLength, len);
142902ac6454SAndrew Thompson 
143002ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
143102ac6454SAndrew Thompson 	if (error != 0) {
143202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1433a593f6b8SAndrew Thompson 		    usbd_errstr(error));
143402ac6454SAndrew Thompson 	}
143502ac6454SAndrew Thompson }
143602ac6454SAndrew Thompson 
143702ac6454SAndrew Thompson static void
143802ac6454SAndrew Thompson ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)
143902ac6454SAndrew Thompson {
1440760bc48eSAndrew Thompson 	struct usb_device_request req;
1441e0a69b51SAndrew Thompson 	usb_error_t error;
144202ac6454SAndrew Thompson 
144302ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
144402ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MAC;
144502ac6454SAndrew Thompson 	USETW(req.wValue, val);
144602ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
144702ac6454SAndrew Thompson 	USETW(req.wLength, 0);
144802ac6454SAndrew Thompson 
144902ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
145002ac6454SAndrew Thompson 	if (error != 0) {
145102ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1452a593f6b8SAndrew Thompson 		    usbd_errstr(error));
145302ac6454SAndrew Thompson 	}
145402ac6454SAndrew Thompson }
145502ac6454SAndrew Thompson 
145602ac6454SAndrew Thompson static void
145702ac6454SAndrew Thompson ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
145802ac6454SAndrew Thompson {
1459760bc48eSAndrew Thompson 	struct usb_device_request req;
1460e0a69b51SAndrew Thompson 	usb_error_t error;
146102ac6454SAndrew Thompson 
146202ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
146302ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MULTI_MAC;
146402ac6454SAndrew Thompson 	USETW(req.wValue, 0);
146502ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
146602ac6454SAndrew Thompson 	USETW(req.wLength, len);
146702ac6454SAndrew Thompson 
146802ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
146902ac6454SAndrew Thompson 	if (error != 0) {
147002ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1471a593f6b8SAndrew Thompson 		    usbd_errstr(error));
147202ac6454SAndrew Thompson 	}
147302ac6454SAndrew Thompson }
147402ac6454SAndrew Thompson 
147502ac6454SAndrew Thompson static void
147602ac6454SAndrew Thompson ural_bbp_write(struct ural_softc *sc, uint8_t reg, uint8_t val)
147702ac6454SAndrew Thompson {
147802ac6454SAndrew Thompson 	uint16_t tmp;
147902ac6454SAndrew Thompson 	int ntries;
148002ac6454SAndrew Thompson 
148102ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
148202ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
148302ac6454SAndrew Thompson 			break;
148402ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
148502ac6454SAndrew Thompson 			break;
148602ac6454SAndrew Thompson 	}
148702ac6454SAndrew Thompson 	if (ntries == 100) {
148802ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to BBP\n");
148902ac6454SAndrew Thompson 		return;
149002ac6454SAndrew Thompson 	}
149102ac6454SAndrew Thompson 
149202ac6454SAndrew Thompson 	tmp = reg << 8 | val;
149302ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, tmp);
149402ac6454SAndrew Thompson }
149502ac6454SAndrew Thompson 
149602ac6454SAndrew Thompson static uint8_t
149702ac6454SAndrew Thompson ural_bbp_read(struct ural_softc *sc, uint8_t reg)
149802ac6454SAndrew Thompson {
149902ac6454SAndrew Thompson 	uint16_t val;
150002ac6454SAndrew Thompson 	int ntries;
150102ac6454SAndrew Thompson 
150202ac6454SAndrew Thompson 	val = RAL_BBP_WRITE | reg << 8;
150302ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, val);
150402ac6454SAndrew Thompson 
150502ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
150602ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
150702ac6454SAndrew Thompson 			break;
150802ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
150902ac6454SAndrew Thompson 			break;
151002ac6454SAndrew Thompson 	}
151102ac6454SAndrew Thompson 	if (ntries == 100) {
151202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read BBP\n");
151302ac6454SAndrew Thompson 		return 0;
151402ac6454SAndrew Thompson 	}
151502ac6454SAndrew Thompson 
151602ac6454SAndrew Thompson 	return ural_read(sc, RAL_PHY_CSR7) & 0xff;
151702ac6454SAndrew Thompson }
151802ac6454SAndrew Thompson 
151902ac6454SAndrew Thompson static void
152002ac6454SAndrew Thompson ural_rf_write(struct ural_softc *sc, uint8_t reg, uint32_t val)
152102ac6454SAndrew Thompson {
152202ac6454SAndrew Thompson 	uint32_t tmp;
152302ac6454SAndrew Thompson 	int ntries;
152402ac6454SAndrew Thompson 
152502ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
152602ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR10) & RAL_RF_LOBUSY))
152702ac6454SAndrew Thompson 			break;
152802ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
152902ac6454SAndrew Thompson 			break;
153002ac6454SAndrew Thompson 	}
153102ac6454SAndrew Thompson 	if (ntries == 100) {
153202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to RF\n");
153302ac6454SAndrew Thompson 		return;
153402ac6454SAndrew Thompson 	}
153502ac6454SAndrew Thompson 
153602ac6454SAndrew Thompson 	tmp = RAL_RF_BUSY | RAL_RF_20BIT | (val & 0xfffff) << 2 | (reg & 0x3);
153702ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR9,  tmp & 0xffff);
153802ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR10, tmp >> 16);
153902ac6454SAndrew Thompson 
154002ac6454SAndrew Thompson 	/* remember last written value in sc */
154102ac6454SAndrew Thompson 	sc->rf_regs[reg] = val;
154202ac6454SAndrew Thompson 
154302ac6454SAndrew Thompson 	DPRINTFN(15, "RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff);
154402ac6454SAndrew Thompson }
154502ac6454SAndrew Thompson 
154602ac6454SAndrew Thompson static void
154702ac6454SAndrew Thompson ural_scan_start(struct ieee80211com *ic)
154802ac6454SAndrew Thompson {
1549d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
155002ac6454SAndrew Thompson 
155102ac6454SAndrew Thompson 	RAL_LOCK(sc);
15525efea30fSAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
15537a79cebfSGleb Smirnoff 	ural_set_bssid(sc, ieee80211broadcastaddr);
155402ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
155502ac6454SAndrew Thompson }
155602ac6454SAndrew Thompson 
155702ac6454SAndrew Thompson static void
155802ac6454SAndrew Thompson ural_scan_end(struct ieee80211com *ic)
155902ac6454SAndrew Thompson {
1560d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
156102ac6454SAndrew Thompson 
156202ac6454SAndrew Thompson 	RAL_LOCK(sc);
15635efea30fSAndrew Thompson 	ural_enable_tsf_sync(sc);
1564ae132f11SAndriy Voskoboinyk 	ural_set_bssid(sc, sc->sc_bssid);
156502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
156602ac6454SAndrew Thompson 
156702ac6454SAndrew Thompson }
156802ac6454SAndrew Thompson 
156902ac6454SAndrew Thompson static void
157083829b48SAndriy Voskoboinyk ural_getradiocaps(struct ieee80211com *ic,
157183829b48SAndriy Voskoboinyk     int maxchans, int *nchans, struct ieee80211_channel chans[])
157283829b48SAndriy Voskoboinyk {
157383829b48SAndriy Voskoboinyk 	struct ural_softc *sc = ic->ic_softc;
157483829b48SAndriy Voskoboinyk 	uint8_t bands[IEEE80211_MODE_BYTES];
157583829b48SAndriy Voskoboinyk 
157683829b48SAndriy Voskoboinyk 	memset(bands, 0, sizeof(bands));
157783829b48SAndriy Voskoboinyk 	setbit(bands, IEEE80211_MODE_11B);
157883829b48SAndriy Voskoboinyk 	setbit(bands, IEEE80211_MODE_11G);
1579b84b3638SAndriy Voskoboinyk 	ieee80211_add_channels_default_2ghz(chans, maxchans, nchans, bands, 0);
158083829b48SAndriy Voskoboinyk 
158183829b48SAndriy Voskoboinyk 	if (sc->rf_rev == RAL_RF_5222) {
158283829b48SAndriy Voskoboinyk 		setbit(bands, IEEE80211_MODE_11A);
158383829b48SAndriy Voskoboinyk 		ieee80211_add_channel_list_5ghz(chans, maxchans, nchans,
158483829b48SAndriy Voskoboinyk 		    ural_chan_5ghz, nitems(ural_chan_5ghz), bands, 0);
158583829b48SAndriy Voskoboinyk 	}
158683829b48SAndriy Voskoboinyk }
158783829b48SAndriy Voskoboinyk 
158883829b48SAndriy Voskoboinyk static void
158902ac6454SAndrew Thompson ural_set_channel(struct ieee80211com *ic)
159002ac6454SAndrew Thompson {
1591d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
159202ac6454SAndrew Thompson 
159302ac6454SAndrew Thompson 	RAL_LOCK(sc);
15945efea30fSAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
159502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
159602ac6454SAndrew Thompson }
159702ac6454SAndrew Thompson 
159802ac6454SAndrew Thompson static void
159902ac6454SAndrew Thompson ural_set_chan(struct ural_softc *sc, struct ieee80211_channel *c)
160002ac6454SAndrew Thompson {
16017a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
160202ac6454SAndrew Thompson 	uint8_t power, tmp;
160302ac6454SAndrew Thompson 	int i, chan;
160402ac6454SAndrew Thompson 
160502ac6454SAndrew Thompson 	chan = ieee80211_chan2ieee(ic, c);
160602ac6454SAndrew Thompson 	if (chan == 0 || chan == IEEE80211_CHAN_ANY)
160702ac6454SAndrew Thompson 		return;
160802ac6454SAndrew Thompson 
160902ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_2GHZ(c))
161002ac6454SAndrew Thompson 		power = min(sc->txpow[chan - 1], 31);
161102ac6454SAndrew Thompson 	else
161202ac6454SAndrew Thompson 		power = 31;
161302ac6454SAndrew Thompson 
161402ac6454SAndrew Thompson 	/* adjust txpower using ifconfig settings */
161502ac6454SAndrew Thompson 	power -= (100 - ic->ic_txpowlimit) / 8;
161602ac6454SAndrew Thompson 
161702ac6454SAndrew Thompson 	DPRINTFN(2, "setting channel to %u, txpower to %u\n", chan, power);
161802ac6454SAndrew Thompson 
161902ac6454SAndrew Thompson 	switch (sc->rf_rev) {
162002ac6454SAndrew Thompson 	case RAL_RF_2522:
162102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x00814);
162202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2522_r2[chan - 1]);
162302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
162402ac6454SAndrew Thompson 		break;
162502ac6454SAndrew Thompson 
162602ac6454SAndrew Thompson 	case RAL_RF_2523:
162702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
162802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2523_r2[chan - 1]);
162902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
163002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
163102ac6454SAndrew Thompson 		break;
163202ac6454SAndrew Thompson 
163302ac6454SAndrew Thompson 	case RAL_RF_2524:
163402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x0c808);
163502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2524_r2[chan - 1]);
163602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
163702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
163802ac6454SAndrew Thompson 		break;
163902ac6454SAndrew Thompson 
164002ac6454SAndrew Thompson 	case RAL_RF_2525:
164102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
164202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_hi_r2[chan - 1]);
164302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
164402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
164502ac6454SAndrew Thompson 
164602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
164702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_r2[chan - 1]);
164802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
164902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
165002ac6454SAndrew Thompson 		break;
165102ac6454SAndrew Thompson 
165202ac6454SAndrew Thompson 	case RAL_RF_2525E:
165302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
165402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525e_r2[chan - 1]);
165502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
165602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
165702ac6454SAndrew Thompson 		break;
165802ac6454SAndrew Thompson 
165902ac6454SAndrew Thompson 	case RAL_RF_2526:
166002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_hi_r2[chan - 1]);
166102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
166202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
166302ac6454SAndrew Thompson 
166402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_r2[chan - 1]);
166502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
166602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
166702ac6454SAndrew Thompson 		break;
166802ac6454SAndrew Thompson 
166902ac6454SAndrew Thompson 	/* dual-band RF */
167002ac6454SAndrew Thompson 	case RAL_RF_5222:
167102ac6454SAndrew Thompson 		for (i = 0; ural_rf5222[i].chan != chan; i++);
167202ac6454SAndrew Thompson 
167302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, ural_rf5222[i].r1);
167402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf5222[i].r2);
167502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
167602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, ural_rf5222[i].r4);
167702ac6454SAndrew Thompson 		break;
167802ac6454SAndrew Thompson 	}
167902ac6454SAndrew Thompson 
168002ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR &&
168102ac6454SAndrew Thompson 	    (ic->ic_flags & IEEE80211_F_SCAN) == 0) {
168202ac6454SAndrew Thompson 		/* set Japan filter bit for channel 14 */
168302ac6454SAndrew Thompson 		tmp = ural_bbp_read(sc, 70);
168402ac6454SAndrew Thompson 
168502ac6454SAndrew Thompson 		tmp &= ~RAL_JAPAN_FILTER;
168602ac6454SAndrew Thompson 		if (chan == 14)
168702ac6454SAndrew Thompson 			tmp |= RAL_JAPAN_FILTER;
168802ac6454SAndrew Thompson 
168902ac6454SAndrew Thompson 		ural_bbp_write(sc, 70, tmp);
169002ac6454SAndrew Thompson 
169102ac6454SAndrew Thompson 		/* clear CRC errors */
169202ac6454SAndrew Thompson 		ural_read(sc, RAL_STA_CSR0);
169302ac6454SAndrew Thompson 
169402ac6454SAndrew Thompson 		ural_pause(sc, hz / 100);
169502ac6454SAndrew Thompson 		ural_disable_rf_tune(sc);
169602ac6454SAndrew Thompson 	}
169702ac6454SAndrew Thompson 
169802ac6454SAndrew Thompson 	/* XXX doesn't belong here */
169902ac6454SAndrew Thompson 	/* update basic rate set */
170002ac6454SAndrew Thompson 	ural_set_basicrates(sc, c);
170177ddf3d3SAndrew Thompson 
170277ddf3d3SAndrew Thompson 	/* give the hardware some time to do the switchover */
170377ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 100);
170402ac6454SAndrew Thompson }
170502ac6454SAndrew Thompson 
170602ac6454SAndrew Thompson /*
170702ac6454SAndrew Thompson  * Disable RF auto-tuning.
170802ac6454SAndrew Thompson  */
170902ac6454SAndrew Thompson static void
171002ac6454SAndrew Thompson ural_disable_rf_tune(struct ural_softc *sc)
171102ac6454SAndrew Thompson {
171202ac6454SAndrew Thompson 	uint32_t tmp;
171302ac6454SAndrew Thompson 
171402ac6454SAndrew Thompson 	if (sc->rf_rev != RAL_RF_2523) {
171502ac6454SAndrew Thompson 		tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
171602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, tmp);
171702ac6454SAndrew Thompson 	}
171802ac6454SAndrew Thompson 
171902ac6454SAndrew Thompson 	tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
172002ac6454SAndrew Thompson 	ural_rf_write(sc, RAL_RF3, tmp);
172102ac6454SAndrew Thompson 
172202ac6454SAndrew Thompson 	DPRINTFN(2, "disabling RF autotune\n");
172302ac6454SAndrew Thompson }
172402ac6454SAndrew Thompson 
172502ac6454SAndrew Thompson /*
172602ac6454SAndrew Thompson  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
172702ac6454SAndrew Thompson  * synchronization.
172802ac6454SAndrew Thompson  */
172902ac6454SAndrew Thompson static void
173002ac6454SAndrew Thompson ural_enable_tsf_sync(struct ural_softc *sc)
173102ac6454SAndrew Thompson {
17327a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
173302ac6454SAndrew Thompson 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
173402ac6454SAndrew Thompson 	uint16_t logcwmin, preload, tmp;
173502ac6454SAndrew Thompson 
173602ac6454SAndrew Thompson 	/* first, disable TSF synchronization */
173702ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
173802ac6454SAndrew Thompson 
173902ac6454SAndrew Thompson 	tmp = (16 * vap->iv_bss->ni_intval) << 4;
174002ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR18, tmp);
174102ac6454SAndrew Thompson 
174202ac6454SAndrew Thompson 	logcwmin = (ic->ic_opmode == IEEE80211_M_IBSS) ? 2 : 0;
174302ac6454SAndrew Thompson 	preload = (ic->ic_opmode == IEEE80211_M_IBSS) ? 320 : 6;
174402ac6454SAndrew Thompson 	tmp = logcwmin << 12 | preload;
174502ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR20, tmp);
174602ac6454SAndrew Thompson 
174702ac6454SAndrew Thompson 	/* finally, enable TSF synchronization */
174802ac6454SAndrew Thompson 	tmp = RAL_ENABLE_TSF | RAL_ENABLE_TBCN;
174902ac6454SAndrew Thompson 	if (ic->ic_opmode == IEEE80211_M_STA)
175002ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(1);
175102ac6454SAndrew Thompson 	else
175202ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(2) | RAL_ENABLE_BEACON_GENERATOR;
175302ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, tmp);
175402ac6454SAndrew Thompson 
175502ac6454SAndrew Thompson 	DPRINTF("enabling TSF synchronization\n");
175602ac6454SAndrew Thompson }
175702ac6454SAndrew Thompson 
17585463c4a4SSam Leffler static void
17595463c4a4SSam Leffler ural_enable_tsf(struct ural_softc *sc)
17605463c4a4SSam Leffler {
17615463c4a4SSam Leffler 	/* first, disable TSF synchronization */
17625463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, 0);
17635463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, RAL_ENABLE_TSF | RAL_ENABLE_TSF_SYNC(2));
17645463c4a4SSam Leffler }
17655463c4a4SSam Leffler 
176602ac6454SAndrew Thompson #define RAL_RXTX_TURNAROUND	5	/* us */
176702ac6454SAndrew Thompson static void
17687a79cebfSGleb Smirnoff ural_update_slot(struct ural_softc *sc)
176902ac6454SAndrew Thompson {
17707a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
177102ac6454SAndrew Thompson 	uint16_t slottime, sifs, eifs;
177202ac6454SAndrew Thompson 
1773bdfff33fSAndriy Voskoboinyk 	slottime = IEEE80211_GET_SLOTTIME(ic);
177402ac6454SAndrew Thompson 
177502ac6454SAndrew Thompson 	/*
177602ac6454SAndrew Thompson 	 * These settings may sound a bit inconsistent but this is what the
177702ac6454SAndrew Thompson 	 * reference driver does.
177802ac6454SAndrew Thompson 	 */
177902ac6454SAndrew Thompson 	if (ic->ic_curmode == IEEE80211_MODE_11B) {
178002ac6454SAndrew Thompson 		sifs = 16 - RAL_RXTX_TURNAROUND;
178102ac6454SAndrew Thompson 		eifs = 364;
178202ac6454SAndrew Thompson 	} else {
178302ac6454SAndrew Thompson 		sifs = 10 - RAL_RXTX_TURNAROUND;
178402ac6454SAndrew Thompson 		eifs = 64;
178502ac6454SAndrew Thompson 	}
178602ac6454SAndrew Thompson 
178702ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR10, slottime);
178802ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR11, sifs);
178902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR12, eifs);
179002ac6454SAndrew Thompson }
179102ac6454SAndrew Thompson 
179202ac6454SAndrew Thompson static void
179302ac6454SAndrew Thompson ural_set_txpreamble(struct ural_softc *sc)
179402ac6454SAndrew Thompson {
17957a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
179602ac6454SAndrew Thompson 	uint16_t tmp;
179702ac6454SAndrew Thompson 
179802ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR10);
179902ac6454SAndrew Thompson 
180002ac6454SAndrew Thompson 	tmp &= ~RAL_SHORT_PREAMBLE;
180102ac6454SAndrew Thompson 	if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
180202ac6454SAndrew Thompson 		tmp |= RAL_SHORT_PREAMBLE;
180302ac6454SAndrew Thompson 
180402ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR10, tmp);
180502ac6454SAndrew Thompson }
180602ac6454SAndrew Thompson 
180702ac6454SAndrew Thompson static void
180802ac6454SAndrew Thompson ural_set_basicrates(struct ural_softc *sc, const struct ieee80211_channel *c)
180902ac6454SAndrew Thompson {
181002ac6454SAndrew Thompson 	/* XXX wrong, take from rate set */
181102ac6454SAndrew Thompson 	/* update basic rate set */
181202ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_5GHZ(c)) {
181302ac6454SAndrew Thompson 		/* 11a basic rates: 6, 12, 24Mbps */
181402ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x150);
181502ac6454SAndrew Thompson 	} else if (IEEE80211_IS_CHAN_ANYG(c)) {
181602ac6454SAndrew Thompson 		/* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
181702ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x15f);
181802ac6454SAndrew Thompson 	} else {
181902ac6454SAndrew Thompson 		/* 11b basic rates: 1, 2Mbps */
182002ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x3);
182102ac6454SAndrew Thompson 	}
182202ac6454SAndrew Thompson }
182302ac6454SAndrew Thompson 
182402ac6454SAndrew Thompson static void
182502ac6454SAndrew Thompson ural_set_bssid(struct ural_softc *sc, const uint8_t *bssid)
182602ac6454SAndrew Thompson {
182702ac6454SAndrew Thompson 	uint16_t tmp;
182802ac6454SAndrew Thompson 
182902ac6454SAndrew Thompson 	tmp = bssid[0] | bssid[1] << 8;
183002ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR5, tmp);
183102ac6454SAndrew Thompson 
183202ac6454SAndrew Thompson 	tmp = bssid[2] | bssid[3] << 8;
183302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR6, tmp);
183402ac6454SAndrew Thompson 
183502ac6454SAndrew Thompson 	tmp = bssid[4] | bssid[5] << 8;
183602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR7, tmp);
183702ac6454SAndrew Thompson 
183802ac6454SAndrew Thompson 	DPRINTF("setting BSSID to %6D\n", bssid, ":");
183902ac6454SAndrew Thompson }
184002ac6454SAndrew Thompson 
184102ac6454SAndrew Thompson static void
18427a79cebfSGleb Smirnoff ural_set_macaddr(struct ural_softc *sc, const uint8_t *addr)
184302ac6454SAndrew Thompson {
184402ac6454SAndrew Thompson 	uint16_t tmp;
184502ac6454SAndrew Thompson 
184602ac6454SAndrew Thompson 	tmp = addr[0] | addr[1] << 8;
184702ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR2, tmp);
184802ac6454SAndrew Thompson 
184902ac6454SAndrew Thompson 	tmp = addr[2] | addr[3] << 8;
185002ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR3, tmp);
185102ac6454SAndrew Thompson 
185202ac6454SAndrew Thompson 	tmp = addr[4] | addr[5] << 8;
185302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR4, tmp);
185402ac6454SAndrew Thompson 
185502ac6454SAndrew Thompson 	DPRINTF("setting MAC address to %6D\n", addr, ":");
185602ac6454SAndrew Thompson }
185702ac6454SAndrew Thompson 
185802ac6454SAndrew Thompson static void
18595efea30fSAndrew Thompson ural_setpromisc(struct ural_softc *sc)
186002ac6454SAndrew Thompson {
186102ac6454SAndrew Thompson 	uint32_t tmp;
186202ac6454SAndrew Thompson 
186302ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR2);
186402ac6454SAndrew Thompson 
186502ac6454SAndrew Thompson 	tmp &= ~RAL_DROP_NOT_TO_ME;
18667a79cebfSGleb Smirnoff 	if (sc->sc_ic.ic_promisc == 0)
186702ac6454SAndrew Thompson 		tmp |= RAL_DROP_NOT_TO_ME;
186802ac6454SAndrew Thompson 
186902ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
187002ac6454SAndrew Thompson 
18717a79cebfSGleb Smirnoff 	DPRINTF("%s promiscuous mode\n", sc->sc_ic.ic_promisc ?
187202ac6454SAndrew Thompson 	    "entering" : "leaving");
187302ac6454SAndrew Thompson }
187402ac6454SAndrew Thompson 
187577ddf3d3SAndrew Thompson static void
1876272f6adeSGleb Smirnoff ural_update_promisc(struct ieee80211com *ic)
187777ddf3d3SAndrew Thompson {
1878272f6adeSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
187977ddf3d3SAndrew Thompson 
188077ddf3d3SAndrew Thompson 	RAL_LOCK(sc);
18817a79cebfSGleb Smirnoff 	if (sc->sc_running)
18825efea30fSAndrew Thompson 		ural_setpromisc(sc);
188377ddf3d3SAndrew Thompson 	RAL_UNLOCK(sc);
188477ddf3d3SAndrew Thompson }
188577ddf3d3SAndrew Thompson 
188602ac6454SAndrew Thompson static const char *
188702ac6454SAndrew Thompson ural_get_rf(int rev)
188802ac6454SAndrew Thompson {
188902ac6454SAndrew Thompson 	switch (rev) {
189002ac6454SAndrew Thompson 	case RAL_RF_2522:	return "RT2522";
189102ac6454SAndrew Thompson 	case RAL_RF_2523:	return "RT2523";
189202ac6454SAndrew Thompson 	case RAL_RF_2524:	return "RT2524";
189302ac6454SAndrew Thompson 	case RAL_RF_2525:	return "RT2525";
189402ac6454SAndrew Thompson 	case RAL_RF_2525E:	return "RT2525e";
189502ac6454SAndrew Thompson 	case RAL_RF_2526:	return "RT2526";
189602ac6454SAndrew Thompson 	case RAL_RF_5222:	return "RT5222";
189702ac6454SAndrew Thompson 	default:		return "unknown";
189802ac6454SAndrew Thompson 	}
189902ac6454SAndrew Thompson }
190002ac6454SAndrew Thompson 
190102ac6454SAndrew Thompson static void
190202ac6454SAndrew Thompson ural_read_eeprom(struct ural_softc *sc)
190302ac6454SAndrew Thompson {
19047a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
190502ac6454SAndrew Thompson 	uint16_t val;
190602ac6454SAndrew Thompson 
190702ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_CONFIG0, &val, 2);
190802ac6454SAndrew Thompson 	val = le16toh(val);
190902ac6454SAndrew Thompson 	sc->rf_rev =   (val >> 11) & 0x7;
191002ac6454SAndrew Thompson 	sc->hw_radio = (val >> 10) & 0x1;
191102ac6454SAndrew Thompson 	sc->led_mode = (val >> 6)  & 0x7;
191202ac6454SAndrew Thompson 	sc->rx_ant =   (val >> 4)  & 0x3;
191302ac6454SAndrew Thompson 	sc->tx_ant =   (val >> 2)  & 0x3;
191402ac6454SAndrew Thompson 	sc->nb_ant =   val & 0x3;
191502ac6454SAndrew Thompson 
191602ac6454SAndrew Thompson 	/* read MAC address */
19177a79cebfSGleb Smirnoff 	ural_eeprom_read(sc, RAL_EEPROM_ADDRESS, ic->ic_macaddr, 6);
191802ac6454SAndrew Thompson 
191902ac6454SAndrew Thompson 	/* read default values for BBP registers */
192002ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_BBP_BASE, sc->bbp_prom, 2 * 16);
192102ac6454SAndrew Thompson 
192202ac6454SAndrew Thompson 	/* read Tx power for all b/g channels */
192302ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_TXPOWER, sc->txpow, 14);
192402ac6454SAndrew Thompson }
192502ac6454SAndrew Thompson 
192602ac6454SAndrew Thompson static int
192702ac6454SAndrew Thompson ural_bbp_init(struct ural_softc *sc)
192802ac6454SAndrew Thompson {
192902ac6454SAndrew Thompson 	int i, ntries;
193002ac6454SAndrew Thompson 
193102ac6454SAndrew Thompson 	/* wait for BBP to be ready */
193202ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
193302ac6454SAndrew Thompson 		if (ural_bbp_read(sc, RAL_BBP_VERSION) != 0)
193402ac6454SAndrew Thompson 			break;
193502ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
193602ac6454SAndrew Thompson 			break;
193702ac6454SAndrew Thompson 	}
193802ac6454SAndrew Thompson 	if (ntries == 100) {
193902ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "timeout waiting for BBP\n");
194002ac6454SAndrew Thompson 		return EIO;
194102ac6454SAndrew Thompson 	}
194202ac6454SAndrew Thompson 
194302ac6454SAndrew Thompson 	/* initialize BBP registers to default values */
194482e8c646SAdrian Chadd 	for (i = 0; i < nitems(ural_def_bbp); i++)
194502ac6454SAndrew Thompson 		ural_bbp_write(sc, ural_def_bbp[i].reg, ural_def_bbp[i].val);
194602ac6454SAndrew Thompson 
194702ac6454SAndrew Thompson #if 0
194802ac6454SAndrew Thompson 	/* initialize BBP registers to values stored in EEPROM */
194902ac6454SAndrew Thompson 	for (i = 0; i < 16; i++) {
195002ac6454SAndrew Thompson 		if (sc->bbp_prom[i].reg == 0xff)
195102ac6454SAndrew Thompson 			continue;
195202ac6454SAndrew Thompson 		ural_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
195302ac6454SAndrew Thompson 	}
195402ac6454SAndrew Thompson #endif
195502ac6454SAndrew Thompson 
195602ac6454SAndrew Thompson 	return 0;
195702ac6454SAndrew Thompson }
195802ac6454SAndrew Thompson 
195902ac6454SAndrew Thompson static void
196002ac6454SAndrew Thompson ural_set_txantenna(struct ural_softc *sc, int antenna)
196102ac6454SAndrew Thompson {
196202ac6454SAndrew Thompson 	uint16_t tmp;
196302ac6454SAndrew Thompson 	uint8_t tx;
196402ac6454SAndrew Thompson 
196502ac6454SAndrew Thompson 	tx = ural_bbp_read(sc, RAL_BBP_TX) & ~RAL_BBP_ANTMASK;
196602ac6454SAndrew Thompson 	if (antenna == 1)
196702ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTA;
196802ac6454SAndrew Thompson 	else if (antenna == 2)
196902ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTB;
197002ac6454SAndrew Thompson 	else
197102ac6454SAndrew Thompson 		tx |= RAL_BBP_DIVERSITY;
197202ac6454SAndrew Thompson 
197302ac6454SAndrew Thompson 	/* need to force I/Q flip for RF 2525e, 2526 and 5222 */
197402ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526 ||
197502ac6454SAndrew Thompson 	    sc->rf_rev == RAL_RF_5222)
197602ac6454SAndrew Thompson 		tx |= RAL_BBP_FLIPIQ;
197702ac6454SAndrew Thompson 
197802ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_TX, tx);
197902ac6454SAndrew Thompson 
198002ac6454SAndrew Thompson 	/* update values in PHY_CSR5 and PHY_CSR6 */
198102ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR5) & ~0x7;
198202ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR5, tmp | (tx & 0x7));
198302ac6454SAndrew Thompson 
198402ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR6) & ~0x7;
198502ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR6, tmp | (tx & 0x7));
198602ac6454SAndrew Thompson }
198702ac6454SAndrew Thompson 
198802ac6454SAndrew Thompson static void
198902ac6454SAndrew Thompson ural_set_rxantenna(struct ural_softc *sc, int antenna)
199002ac6454SAndrew Thompson {
199102ac6454SAndrew Thompson 	uint8_t rx;
199202ac6454SAndrew Thompson 
199302ac6454SAndrew Thompson 	rx = ural_bbp_read(sc, RAL_BBP_RX) & ~RAL_BBP_ANTMASK;
199402ac6454SAndrew Thompson 	if (antenna == 1)
199502ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTA;
199602ac6454SAndrew Thompson 	else if (antenna == 2)
199702ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTB;
199802ac6454SAndrew Thompson 	else
199902ac6454SAndrew Thompson 		rx |= RAL_BBP_DIVERSITY;
200002ac6454SAndrew Thompson 
200102ac6454SAndrew Thompson 	/* need to force no I/Q flip for RF 2525e and 2526 */
200202ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526)
200302ac6454SAndrew Thompson 		rx &= ~RAL_BBP_FLIPIQ;
200402ac6454SAndrew Thompson 
200502ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_RX, rx);
200602ac6454SAndrew Thompson }
200702ac6454SAndrew Thompson 
200802ac6454SAndrew Thompson static void
20097a79cebfSGleb Smirnoff ural_init(struct ural_softc *sc)
201002ac6454SAndrew Thompson {
20117a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
20127a79cebfSGleb Smirnoff 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
201302ac6454SAndrew Thompson 	uint16_t tmp;
201402ac6454SAndrew Thompson 	int i, ntries;
201502ac6454SAndrew Thompson 
201602ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
201702ac6454SAndrew Thompson 
201802ac6454SAndrew Thompson 	ural_set_testmode(sc);
201902ac6454SAndrew Thompson 	ural_write(sc, 0x308, 0x00f0);	/* XXX magic */
202002ac6454SAndrew Thompson 
20215efea30fSAndrew Thompson 	ural_stop(sc);
202202ac6454SAndrew Thompson 
202302ac6454SAndrew Thompson 	/* initialize MAC registers to default values */
202482e8c646SAdrian Chadd 	for (i = 0; i < nitems(ural_def_mac); i++)
202502ac6454SAndrew Thompson 		ural_write(sc, ural_def_mac[i].reg, ural_def_mac[i].val);
202602ac6454SAndrew Thompson 
202702ac6454SAndrew Thompson 	/* wait for BBP and RF to wake up (this can take a long time!) */
202802ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
202902ac6454SAndrew Thompson 		tmp = ural_read(sc, RAL_MAC_CSR17);
203002ac6454SAndrew Thompson 		if ((tmp & (RAL_BBP_AWAKE | RAL_RF_AWAKE)) ==
203102ac6454SAndrew Thompson 		    (RAL_BBP_AWAKE | RAL_RF_AWAKE))
203202ac6454SAndrew Thompson 			break;
203302ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
203402ac6454SAndrew Thompson 			break;
203502ac6454SAndrew Thompson 	}
203602ac6454SAndrew Thompson 	if (ntries == 100) {
203702ac6454SAndrew Thompson 		device_printf(sc->sc_dev,
203802ac6454SAndrew Thompson 		    "timeout waiting for BBP/RF to wakeup\n");
203902ac6454SAndrew Thompson 		goto fail;
204002ac6454SAndrew Thompson 	}
204102ac6454SAndrew Thompson 
204202ac6454SAndrew Thompson 	/* we're ready! */
204302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_HOST_READY);
204402ac6454SAndrew Thompson 
204502ac6454SAndrew Thompson 	/* set basic rate set (will be updated later) */
204602ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR11, 0x15f);
204702ac6454SAndrew Thompson 
204802ac6454SAndrew Thompson 	if (ural_bbp_init(sc) != 0)
204902ac6454SAndrew Thompson 		goto fail;
205002ac6454SAndrew Thompson 
205102ac6454SAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
205202ac6454SAndrew Thompson 
205302ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
205402ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
205502ac6454SAndrew Thompson 
205602ac6454SAndrew Thompson 	ural_set_txantenna(sc, sc->tx_ant);
205702ac6454SAndrew Thompson 	ural_set_rxantenna(sc, sc->rx_ant);
205802ac6454SAndrew Thompson 
20597a79cebfSGleb Smirnoff 	ural_set_macaddr(sc, vap ? vap->iv_myaddr : ic->ic_macaddr);
206002ac6454SAndrew Thompson 
206102ac6454SAndrew Thompson 	/*
206202ac6454SAndrew Thompson 	 * Allocate Tx and Rx xfer queues.
206302ac6454SAndrew Thompson 	 */
206402ac6454SAndrew Thompson 	ural_setup_tx_list(sc);
206502ac6454SAndrew Thompson 
206602ac6454SAndrew Thompson 	/* kick Rx */
206702ac6454SAndrew Thompson 	tmp = RAL_DROP_PHY | RAL_DROP_CRC;
206802ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR) {
206902ac6454SAndrew Thompson 		tmp |= RAL_DROP_CTL | RAL_DROP_BAD_VERSION;
207002ac6454SAndrew Thompson 		if (ic->ic_opmode != IEEE80211_M_HOSTAP)
207102ac6454SAndrew Thompson 			tmp |= RAL_DROP_TODS;
20727a79cebfSGleb Smirnoff 		if (ic->ic_promisc == 0)
207302ac6454SAndrew Thompson 			tmp |= RAL_DROP_NOT_TO_ME;
207402ac6454SAndrew Thompson 	}
207502ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
207602ac6454SAndrew Thompson 
20777a79cebfSGleb Smirnoff 	sc->sc_running = 1;
2078ed6d949aSAndrew Thompson 	usbd_xfer_set_stall(sc->sc_xfer[URAL_BULK_WR]);
2079a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_RD]);
208002ac6454SAndrew Thompson 	return;
208102ac6454SAndrew Thompson 
20825efea30fSAndrew Thompson fail:	ural_stop(sc);
208302ac6454SAndrew Thompson }
208402ac6454SAndrew Thompson 
208502ac6454SAndrew Thompson static void
20865efea30fSAndrew Thompson ural_stop(struct ural_softc *sc)
208702ac6454SAndrew Thompson {
208802ac6454SAndrew Thompson 
208902ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
209002ac6454SAndrew Thompson 
20917a79cebfSGleb Smirnoff 	sc->sc_running = 0;
209202ac6454SAndrew Thompson 
209302ac6454SAndrew Thompson 	/*
209402ac6454SAndrew Thompson 	 * Drain all the transfers, if not already drained:
209502ac6454SAndrew Thompson 	 */
209602ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
2097a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_WR]);
2098a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_RD]);
209902ac6454SAndrew Thompson 	RAL_LOCK(sc);
210002ac6454SAndrew Thompson 
210102ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
210202ac6454SAndrew Thompson 
210302ac6454SAndrew Thompson 	/* disable Rx */
210402ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, RAL_DISABLE_RX);
210502ac6454SAndrew Thompson 	/* reset ASIC and BBP (but won't reset MAC registers!) */
210602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_RESET_ASIC | RAL_RESET_BBP);
210702ac6454SAndrew Thompson 	/* wait a little */
210802ac6454SAndrew Thompson 	ural_pause(sc, hz / 10);
210902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, 0);
211077ddf3d3SAndrew Thompson 	/* wait a little */
211177ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 10);
211202ac6454SAndrew Thompson }
211302ac6454SAndrew Thompson 
211402ac6454SAndrew Thompson static int
211502ac6454SAndrew Thompson ural_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
211602ac6454SAndrew Thompson 	const struct ieee80211_bpf_params *params)
211702ac6454SAndrew Thompson {
211802ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
2119d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
212002ac6454SAndrew Thompson 
212102ac6454SAndrew Thompson 	RAL_LOCK(sc);
212202ac6454SAndrew Thompson 	/* prevent management frames from being sent if we're not ready */
21237a79cebfSGleb Smirnoff 	if (!sc->sc_running) {
212402ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
212502ac6454SAndrew Thompson 		m_freem(m);
212602ac6454SAndrew Thompson 		return ENETDOWN;
212702ac6454SAndrew Thompson 	}
212896ca458fSAndrew Thompson 	if (sc->tx_nfree < RAL_TX_MINFREE) {
212902ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
213002ac6454SAndrew Thompson 		m_freem(m);
213102ac6454SAndrew Thompson 		return EIO;
213202ac6454SAndrew Thompson 	}
213302ac6454SAndrew Thompson 
213402ac6454SAndrew Thompson 	if (params == NULL) {
213502ac6454SAndrew Thompson 		/*
213602ac6454SAndrew Thompson 		 * Legacy path; interpret frame contents to decide
213702ac6454SAndrew Thompson 		 * precisely how to send the frame.
213802ac6454SAndrew Thompson 		 */
213902ac6454SAndrew Thompson 		if (ural_tx_mgt(sc, m, ni) != 0)
214002ac6454SAndrew Thompson 			goto bad;
214102ac6454SAndrew Thompson 	} else {
214202ac6454SAndrew Thompson 		/*
214302ac6454SAndrew Thompson 		 * Caller supplied explicit parameters to use in
214402ac6454SAndrew Thompson 		 * sending the frame.
214502ac6454SAndrew Thompson 		 */
214602ac6454SAndrew Thompson 		if (ural_tx_raw(sc, m, ni, params) != 0)
214702ac6454SAndrew Thompson 			goto bad;
214802ac6454SAndrew Thompson 	}
214902ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
215002ac6454SAndrew Thompson 	return 0;
215102ac6454SAndrew Thompson bad:
215202ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
215302ac6454SAndrew Thompson 	return EIO;		/* XXX */
215402ac6454SAndrew Thompson }
215502ac6454SAndrew Thompson 
215602ac6454SAndrew Thompson static void
2157b6108616SRui Paulo ural_ratectl_start(struct ural_softc *sc, struct ieee80211_node *ni)
215802ac6454SAndrew Thompson {
215902ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
216002ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
216102ac6454SAndrew Thompson 
216202ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
216302ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
216402ac6454SAndrew Thompson 
2165b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
216602ac6454SAndrew Thompson }
216702ac6454SAndrew Thompson 
216802ac6454SAndrew Thompson static void
2169b6108616SRui Paulo ural_ratectl_timeout(void *arg)
217002ac6454SAndrew Thompson {
217102ac6454SAndrew Thompson 	struct ural_vap *uvp = arg;
21725efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
21735efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
217402ac6454SAndrew Thompson 
2175b6108616SRui Paulo 	ieee80211_runtask(ic, &uvp->ratectl_task);
217602ac6454SAndrew Thompson }
217702ac6454SAndrew Thompson 
217802ac6454SAndrew Thompson static void
2179b6108616SRui Paulo ural_ratectl_task(void *arg, int pending)
218002ac6454SAndrew Thompson {
21815efea30fSAndrew Thompson 	struct ural_vap *uvp = arg;
21825efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
2183f6930becSAndriy Voskoboinyk 	struct ural_softc *sc = vap->iv_ic->ic_softc;
2184f6930becSAndriy Voskoboinyk 	struct ieee80211_ratectl_tx_stats *txs = &sc->sc_txs;
2185f6930becSAndriy Voskoboinyk 	int fail;
218602ac6454SAndrew Thompson 
21875efea30fSAndrew Thompson 	RAL_LOCK(sc);
218802ac6454SAndrew Thompson 	/* read and clear statistic registers (STA_CSR0 to STA_CSR10) */
218902ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof(sc->sta));
219002ac6454SAndrew Thompson 
2191f6930becSAndriy Voskoboinyk 	txs->flags = IEEE80211_RATECTL_TX_STATS_RETRIES;
2192f6930becSAndriy Voskoboinyk 	txs->nsuccess = sc->sta[7] +	/* TX ok w/o retry */
219302ac6454SAndrew Thompson 			sc->sta[8];	/* TX ok w/ retry */
219402ac6454SAndrew Thompson 	fail = sc->sta[9];		/* TX retry-fail count */
2195f6930becSAndriy Voskoboinyk 	txs->nframes = txs->nsuccess + fail;
2196f6930becSAndriy Voskoboinyk 	/* XXX fail * maxretry */
2197f6930becSAndriy Voskoboinyk 	txs->nretries = sc->sta[8] + fail;
219802ac6454SAndrew Thompson 
2199f6930becSAndriy Voskoboinyk 	ieee80211_ratectl_tx_update(vap, txs);
220002ac6454SAndrew Thompson 
22017a79cebfSGleb Smirnoff 	/* count TX retry-fail as Tx errors */
2202f6930becSAndriy Voskoboinyk 	if_inc_counter(vap->iv_ifp, IFCOUNTER_OERRORS, fail);
220302ac6454SAndrew Thompson 
2204b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
22055efea30fSAndrew Thompson 	RAL_UNLOCK(sc);
220602ac6454SAndrew Thompson }
220702ac6454SAndrew Thompson 
220802ac6454SAndrew Thompson static int
220902ac6454SAndrew Thompson ural_pause(struct ural_softc *sc, int timeout)
221002ac6454SAndrew Thompson {
221102ac6454SAndrew Thompson 
2212a593f6b8SAndrew Thompson 	usb_pause_mtx(&sc->sc_mtx, timeout);
221302ac6454SAndrew Thompson 	return (0);
221402ac6454SAndrew Thompson }
2215