xref: /freebsd/sys/dev/usb/wlan/if_ural.c (revision 97ad4604d7903a1feb18dcbad15015e73d97c74b)
102ac6454SAndrew Thompson /*	$FreeBSD$	*/
202ac6454SAndrew Thompson 
302ac6454SAndrew Thompson /*-
402ac6454SAndrew Thompson  * Copyright (c) 2005, 2006
502ac6454SAndrew Thompson  *	Damien Bergamini <damien.bergamini@free.fr>
602ac6454SAndrew Thompson  *
702ac6454SAndrew Thompson  * Copyright (c) 2006, 2008
85d38a4d4SEd Schouten  *	Hans Petter Selasky <hselasky@FreeBSD.org>
902ac6454SAndrew Thompson  *
1002ac6454SAndrew Thompson  * Permission to use, copy, modify, and distribute this software for any
1102ac6454SAndrew Thompson  * purpose with or without fee is hereby granted, provided that the above
1202ac6454SAndrew Thompson  * copyright notice and this permission notice appear in all copies.
1302ac6454SAndrew Thompson  *
1402ac6454SAndrew Thompson  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
1502ac6454SAndrew Thompson  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
1602ac6454SAndrew Thompson  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
1702ac6454SAndrew Thompson  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
1802ac6454SAndrew Thompson  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
1902ac6454SAndrew Thompson  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
2002ac6454SAndrew Thompson  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
2102ac6454SAndrew Thompson  */
2202ac6454SAndrew Thompson 
2302ac6454SAndrew Thompson #include <sys/cdefs.h>
2402ac6454SAndrew Thompson __FBSDID("$FreeBSD$");
2502ac6454SAndrew Thompson 
2602ac6454SAndrew Thompson /*-
2702ac6454SAndrew Thompson  * Ralink Technology RT2500USB chipset driver
2802ac6454SAndrew Thompson  * http://www.ralinktech.com/
2902ac6454SAndrew Thompson  */
3002ac6454SAndrew Thompson 
315efea30fSAndrew Thompson #include <sys/param.h>
325efea30fSAndrew Thompson #include <sys/sockio.h>
335efea30fSAndrew Thompson #include <sys/sysctl.h>
345efea30fSAndrew Thompson #include <sys/lock.h>
355efea30fSAndrew Thompson #include <sys/mutex.h>
365efea30fSAndrew Thompson #include <sys/mbuf.h>
375efea30fSAndrew Thompson #include <sys/kernel.h>
385efea30fSAndrew Thompson #include <sys/socket.h>
395efea30fSAndrew Thompson #include <sys/systm.h>
405efea30fSAndrew Thompson #include <sys/malloc.h>
415efea30fSAndrew Thompson #include <sys/module.h>
425efea30fSAndrew Thompson #include <sys/bus.h>
435efea30fSAndrew Thompson #include <sys/endian.h>
445efea30fSAndrew Thompson #include <sys/kdb.h>
455efea30fSAndrew Thompson 
465efea30fSAndrew Thompson #include <machine/bus.h>
475efea30fSAndrew Thompson #include <machine/resource.h>
485efea30fSAndrew Thompson #include <sys/rman.h>
495efea30fSAndrew Thompson 
505efea30fSAndrew Thompson #include <net/bpf.h>
515efea30fSAndrew Thompson #include <net/if.h>
5276039bc8SGleb Smirnoff #include <net/if_var.h>
535efea30fSAndrew Thompson #include <net/if_arp.h>
545efea30fSAndrew Thompson #include <net/ethernet.h>
555efea30fSAndrew Thompson #include <net/if_dl.h>
565efea30fSAndrew Thompson #include <net/if_media.h>
575efea30fSAndrew Thompson #include <net/if_types.h>
585efea30fSAndrew Thompson 
595efea30fSAndrew Thompson #ifdef INET
605efea30fSAndrew Thompson #include <netinet/in.h>
615efea30fSAndrew Thompson #include <netinet/in_systm.h>
625efea30fSAndrew Thompson #include <netinet/in_var.h>
635efea30fSAndrew Thompson #include <netinet/if_ether.h>
645efea30fSAndrew Thompson #include <netinet/ip.h>
655efea30fSAndrew Thompson #endif
665efea30fSAndrew Thompson 
675efea30fSAndrew Thompson #include <net80211/ieee80211_var.h>
685efea30fSAndrew Thompson #include <net80211/ieee80211_regdomain.h>
695efea30fSAndrew Thompson #include <net80211/ieee80211_radiotap.h>
70b6108616SRui Paulo #include <net80211/ieee80211_ratectl.h>
7102ac6454SAndrew Thompson 
725efea30fSAndrew Thompson #include <dev/usb/usb.h>
73ed6d949aSAndrew Thompson #include <dev/usb/usbdi.h>
745efea30fSAndrew Thompson #include "usbdevs.h"
7502ac6454SAndrew Thompson 
76ed6d949aSAndrew Thompson #define	USB_DEBUG_VAR ural_debug
77ed6d949aSAndrew Thompson #include <dev/usb/usb_debug.h>
785efea30fSAndrew Thompson 
7902ac6454SAndrew Thompson #include <dev/usb/wlan/if_uralreg.h>
8002ac6454SAndrew Thompson #include <dev/usb/wlan/if_uralvar.h>
8102ac6454SAndrew Thompson 
82b850ecc1SAndrew Thompson #ifdef USB_DEBUG
8302ac6454SAndrew Thompson static int ural_debug = 0;
8402ac6454SAndrew Thompson 
856472ac3dSEd Schouten static SYSCTL_NODE(_hw_usb, OID_AUTO, ural, CTLFLAG_RW, 0, "USB ural");
86ece4b0bdSHans Petter Selasky SYSCTL_INT(_hw_usb_ural, OID_AUTO, debug, CTLFLAG_RWTUN, &ural_debug, 0,
8702ac6454SAndrew Thompson     "Debug level");
8802ac6454SAndrew Thompson #endif
8902ac6454SAndrew Thompson 
9002ac6454SAndrew Thompson #define URAL_RSSI(rssi)					\
9102ac6454SAndrew Thompson 	((rssi) > (RAL_NOISE_FLOOR + RAL_RSSI_CORR) ?	\
9202ac6454SAndrew Thompson 	 ((rssi) - (RAL_NOISE_FLOOR + RAL_RSSI_CORR)) : 0)
9302ac6454SAndrew Thompson 
9402ac6454SAndrew Thompson /* various supported device vendors/products */
95f1a16106SHans Petter Selasky static const STRUCT_USB_HOST_ID ural_devs[] = {
969e6b5313SAndrew Thompson #define	URAL_DEV(v,p)  { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) }
979e6b5313SAndrew Thompson 	URAL_DEV(ASUS, WL167G),
989e6b5313SAndrew Thompson 	URAL_DEV(ASUS, RT2570),
999e6b5313SAndrew Thompson 	URAL_DEV(BELKIN, F5D7050),
1009e6b5313SAndrew Thompson 	URAL_DEV(BELKIN, F5D7051),
1019e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, HU200TS),
1029e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, WUSB54G),
1039e6b5313SAndrew Thompson 	URAL_DEV(CISCOLINKSYS, WUSB54GP),
1049e6b5313SAndrew Thompson 	URAL_DEV(CONCEPTRONIC2, C54RU),
1059e6b5313SAndrew Thompson 	URAL_DEV(DLINK, DWLG122),
1069e6b5313SAndrew Thompson 	URAL_DEV(GIGABYTE, GN54G),
1079e6b5313SAndrew Thompson 	URAL_DEV(GIGABYTE, GNWBKG),
1089e6b5313SAndrew Thompson 	URAL_DEV(GUILLEMOT, HWGUSB254),
1099e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54),
1109e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54AI),
1119e6b5313SAndrew Thompson 	URAL_DEV(MELCO, KG54YB),
1129e6b5313SAndrew Thompson 	URAL_DEV(MELCO, NINWIFI),
1139e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570),
1149e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570_2),
1159e6b5313SAndrew Thompson 	URAL_DEV(MSI, RT2570_3),
1169e6b5313SAndrew Thompson 	URAL_DEV(NOVATECH, NV902),
1179e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570),
1189e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570_2),
1199e6b5313SAndrew Thompson 	URAL_DEV(RALINK, RT2570_3),
1209e6b5313SAndrew Thompson 	URAL_DEV(SIEMENS2, WL54G),
1219e6b5313SAndrew Thompson 	URAL_DEV(SMC, 2862WG),
1229e6b5313SAndrew Thompson 	URAL_DEV(SPHAIRON, UB801R),
1239e6b5313SAndrew Thompson 	URAL_DEV(SURECOM, RT2570),
1249e6b5313SAndrew Thompson 	URAL_DEV(VTECH, RT2570),
1259e6b5313SAndrew Thompson 	URAL_DEV(ZINWELL, RT2570),
1269e6b5313SAndrew Thompson #undef URAL_DEV
12702ac6454SAndrew Thompson };
12802ac6454SAndrew Thompson 
129e0a69b51SAndrew Thompson static usb_callback_t ural_bulk_read_callback;
130e0a69b51SAndrew Thompson static usb_callback_t ural_bulk_write_callback;
13102ac6454SAndrew Thompson 
132e0a69b51SAndrew Thompson static usb_error_t	ural_do_request(struct ural_softc *sc,
133760bc48eSAndrew Thompson 			    struct usb_device_request *req, void *data);
13402ac6454SAndrew Thompson static struct ieee80211vap *ural_vap_create(struct ieee80211com *,
135fcd9500fSBernhard Schmidt 			    const char [IFNAMSIZ], int, enum ieee80211_opmode,
136fcd9500fSBernhard Schmidt 			    int, const uint8_t [IEEE80211_ADDR_LEN],
137fcd9500fSBernhard Schmidt 			    const uint8_t [IEEE80211_ADDR_LEN]);
13802ac6454SAndrew Thompson static void		ural_vap_delete(struct ieee80211vap *);
13902ac6454SAndrew Thompson static void		ural_tx_free(struct ural_tx_data *, int);
14002ac6454SAndrew Thompson static void		ural_setup_tx_list(struct ural_softc *);
14102ac6454SAndrew Thompson static void		ural_unsetup_tx_list(struct ural_softc *);
14202ac6454SAndrew Thompson static int		ural_newstate(struct ieee80211vap *,
14302ac6454SAndrew Thompson 			    enum ieee80211_state, int);
14402ac6454SAndrew Thompson static void		ural_setup_tx_desc(struct ural_softc *,
14502ac6454SAndrew Thompson 			    struct ural_tx_desc *, uint32_t, int, int);
14602ac6454SAndrew Thompson static int		ural_tx_bcn(struct ural_softc *, struct mbuf *,
14702ac6454SAndrew Thompson 			    struct ieee80211_node *);
14802ac6454SAndrew Thompson static int		ural_tx_mgt(struct ural_softc *, struct mbuf *,
14902ac6454SAndrew Thompson 			    struct ieee80211_node *);
15002ac6454SAndrew Thompson static int		ural_tx_data(struct ural_softc *, struct mbuf *,
15102ac6454SAndrew Thompson 			    struct ieee80211_node *);
1527a79cebfSGleb Smirnoff static int		ural_transmit(struct ieee80211com *, struct mbuf *);
1537a79cebfSGleb Smirnoff static void		ural_start(struct ural_softc *);
1547a79cebfSGleb Smirnoff static void		ural_parent(struct ieee80211com *);
15502ac6454SAndrew Thompson static void		ural_set_testmode(struct ural_softc *);
15602ac6454SAndrew Thompson static void		ural_eeprom_read(struct ural_softc *, uint16_t, void *,
15702ac6454SAndrew Thompson 			    int);
15802ac6454SAndrew Thompson static uint16_t		ural_read(struct ural_softc *, uint16_t);
15902ac6454SAndrew Thompson static void		ural_read_multi(struct ural_softc *, uint16_t, void *,
16002ac6454SAndrew Thompson 			    int);
16102ac6454SAndrew Thompson static void		ural_write(struct ural_softc *, uint16_t, uint16_t);
16202ac6454SAndrew Thompson static void		ural_write_multi(struct ural_softc *, uint16_t, void *,
16302ac6454SAndrew Thompson 			    int) __unused;
16402ac6454SAndrew Thompson static void		ural_bbp_write(struct ural_softc *, uint8_t, uint8_t);
16502ac6454SAndrew Thompson static uint8_t		ural_bbp_read(struct ural_softc *, uint8_t);
16602ac6454SAndrew Thompson static void		ural_rf_write(struct ural_softc *, uint8_t, uint32_t);
16702ac6454SAndrew Thompson static void		ural_scan_start(struct ieee80211com *);
16802ac6454SAndrew Thompson static void		ural_scan_end(struct ieee80211com *);
16902ac6454SAndrew Thompson static void		ural_set_channel(struct ieee80211com *);
17002ac6454SAndrew Thompson static void		ural_set_chan(struct ural_softc *,
17102ac6454SAndrew Thompson 			    struct ieee80211_channel *);
17202ac6454SAndrew Thompson static void		ural_disable_rf_tune(struct ural_softc *);
17302ac6454SAndrew Thompson static void		ural_enable_tsf_sync(struct ural_softc *);
1745463c4a4SSam Leffler static void 		ural_enable_tsf(struct ural_softc *);
1757a79cebfSGleb Smirnoff static void		ural_update_slot(struct ural_softc *);
17602ac6454SAndrew Thompson static void		ural_set_txpreamble(struct ural_softc *);
17702ac6454SAndrew Thompson static void		ural_set_basicrates(struct ural_softc *,
17802ac6454SAndrew Thompson 			    const struct ieee80211_channel *);
17902ac6454SAndrew Thompson static void		ural_set_bssid(struct ural_softc *, const uint8_t *);
1807a79cebfSGleb Smirnoff static void		ural_set_macaddr(struct ural_softc *, const uint8_t *);
181272f6adeSGleb Smirnoff static void		ural_update_promisc(struct ieee80211com *);
1825efea30fSAndrew Thompson static void		ural_setpromisc(struct ural_softc *);
18302ac6454SAndrew Thompson static const char	*ural_get_rf(int);
18402ac6454SAndrew Thompson static void		ural_read_eeprom(struct ural_softc *);
18502ac6454SAndrew Thompson static int		ural_bbp_init(struct ural_softc *);
18602ac6454SAndrew Thompson static void		ural_set_txantenna(struct ural_softc *, int);
18702ac6454SAndrew Thompson static void		ural_set_rxantenna(struct ural_softc *, int);
1887a79cebfSGleb Smirnoff static void		ural_init(struct ural_softc *);
1895efea30fSAndrew Thompson static void		ural_stop(struct ural_softc *);
19002ac6454SAndrew Thompson static int		ural_raw_xmit(struct ieee80211_node *, struct mbuf *,
19102ac6454SAndrew Thompson 			    const struct ieee80211_bpf_params *);
192b6108616SRui Paulo static void		ural_ratectl_start(struct ural_softc *,
19302ac6454SAndrew Thompson 			    struct ieee80211_node *);
194b6108616SRui Paulo static void		ural_ratectl_timeout(void *);
195b6108616SRui Paulo static void		ural_ratectl_task(void *, int);
19602ac6454SAndrew Thompson static int		ural_pause(struct ural_softc *sc, int timeout);
19702ac6454SAndrew Thompson 
19802ac6454SAndrew Thompson /*
19902ac6454SAndrew Thompson  * Default values for MAC registers; values taken from the reference driver.
20002ac6454SAndrew Thompson  */
20102ac6454SAndrew Thompson static const struct {
20202ac6454SAndrew Thompson 	uint16_t	reg;
20302ac6454SAndrew Thompson 	uint16_t	val;
20402ac6454SAndrew Thompson } ural_def_mac[] = {
20502ac6454SAndrew Thompson 	{ RAL_TXRX_CSR5,  0x8c8d },
20602ac6454SAndrew Thompson 	{ RAL_TXRX_CSR6,  0x8b8a },
20702ac6454SAndrew Thompson 	{ RAL_TXRX_CSR7,  0x8687 },
20802ac6454SAndrew Thompson 	{ RAL_TXRX_CSR8,  0x0085 },
20902ac6454SAndrew Thompson 	{ RAL_MAC_CSR13,  0x1111 },
21002ac6454SAndrew Thompson 	{ RAL_MAC_CSR14,  0x1e11 },
21102ac6454SAndrew Thompson 	{ RAL_TXRX_CSR21, 0xe78f },
21202ac6454SAndrew Thompson 	{ RAL_MAC_CSR9,   0xff1d },
21302ac6454SAndrew Thompson 	{ RAL_MAC_CSR11,  0x0002 },
21402ac6454SAndrew Thompson 	{ RAL_MAC_CSR22,  0x0053 },
21502ac6454SAndrew Thompson 	{ RAL_MAC_CSR15,  0x0000 },
21602ac6454SAndrew Thompson 	{ RAL_MAC_CSR8,   RAL_FRAME_SIZE },
21702ac6454SAndrew Thompson 	{ RAL_TXRX_CSR19, 0x0000 },
21802ac6454SAndrew Thompson 	{ RAL_TXRX_CSR18, 0x005a },
21902ac6454SAndrew Thompson 	{ RAL_PHY_CSR2,   0x0000 },
22002ac6454SAndrew Thompson 	{ RAL_TXRX_CSR0,  0x1ec0 },
22102ac6454SAndrew Thompson 	{ RAL_PHY_CSR4,   0x000f }
22202ac6454SAndrew Thompson };
22302ac6454SAndrew Thompson 
22402ac6454SAndrew Thompson /*
22502ac6454SAndrew Thompson  * Default values for BBP registers; values taken from the reference driver.
22602ac6454SAndrew Thompson  */
22702ac6454SAndrew Thompson static const struct {
22802ac6454SAndrew Thompson 	uint8_t	reg;
22902ac6454SAndrew Thompson 	uint8_t	val;
23002ac6454SAndrew Thompson } ural_def_bbp[] = {
23102ac6454SAndrew Thompson 	{  3, 0x02 },
23202ac6454SAndrew Thompson 	{  4, 0x19 },
23302ac6454SAndrew Thompson 	{ 14, 0x1c },
23402ac6454SAndrew Thompson 	{ 15, 0x30 },
23502ac6454SAndrew Thompson 	{ 16, 0xac },
23602ac6454SAndrew Thompson 	{ 17, 0x48 },
23702ac6454SAndrew Thompson 	{ 18, 0x18 },
23802ac6454SAndrew Thompson 	{ 19, 0xff },
23902ac6454SAndrew Thompson 	{ 20, 0x1e },
24002ac6454SAndrew Thompson 	{ 21, 0x08 },
24102ac6454SAndrew Thompson 	{ 22, 0x08 },
24202ac6454SAndrew Thompson 	{ 23, 0x08 },
24302ac6454SAndrew Thompson 	{ 24, 0x80 },
24402ac6454SAndrew Thompson 	{ 25, 0x50 },
24502ac6454SAndrew Thompson 	{ 26, 0x08 },
24602ac6454SAndrew Thompson 	{ 27, 0x23 },
24702ac6454SAndrew Thompson 	{ 30, 0x10 },
24802ac6454SAndrew Thompson 	{ 31, 0x2b },
24902ac6454SAndrew Thompson 	{ 32, 0xb9 },
25002ac6454SAndrew Thompson 	{ 34, 0x12 },
25102ac6454SAndrew Thompson 	{ 35, 0x50 },
25202ac6454SAndrew Thompson 	{ 39, 0xc4 },
25302ac6454SAndrew Thompson 	{ 40, 0x02 },
25402ac6454SAndrew Thompson 	{ 41, 0x60 },
25502ac6454SAndrew Thompson 	{ 53, 0x10 },
25602ac6454SAndrew Thompson 	{ 54, 0x18 },
25702ac6454SAndrew Thompson 	{ 56, 0x08 },
25802ac6454SAndrew Thompson 	{ 57, 0x10 },
25902ac6454SAndrew Thompson 	{ 58, 0x08 },
26002ac6454SAndrew Thompson 	{ 61, 0x60 },
26102ac6454SAndrew Thompson 	{ 62, 0x10 },
26202ac6454SAndrew Thompson 	{ 75, 0xff }
26302ac6454SAndrew Thompson };
26402ac6454SAndrew Thompson 
26502ac6454SAndrew Thompson /*
26602ac6454SAndrew Thompson  * Default values for RF register R2 indexed by channel numbers.
26702ac6454SAndrew Thompson  */
26802ac6454SAndrew Thompson static const uint32_t ural_rf2522_r2[] = {
26902ac6454SAndrew Thompson 	0x307f6, 0x307fb, 0x30800, 0x30805, 0x3080a, 0x3080f, 0x30814,
27002ac6454SAndrew Thompson 	0x30819, 0x3081e, 0x30823, 0x30828, 0x3082d, 0x30832, 0x3083e
27102ac6454SAndrew Thompson };
27202ac6454SAndrew Thompson 
27302ac6454SAndrew Thompson static const uint32_t ural_rf2523_r2[] = {
27402ac6454SAndrew Thompson 	0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
27502ac6454SAndrew Thompson 	0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
27602ac6454SAndrew Thompson };
27702ac6454SAndrew Thompson 
27802ac6454SAndrew Thompson static const uint32_t ural_rf2524_r2[] = {
27902ac6454SAndrew Thompson 	0x00327, 0x00328, 0x00329, 0x0032a, 0x0032b, 0x0032c, 0x0032d,
28002ac6454SAndrew Thompson 	0x0032e, 0x0032f, 0x00340, 0x00341, 0x00342, 0x00343, 0x00346
28102ac6454SAndrew Thompson };
28202ac6454SAndrew Thompson 
28302ac6454SAndrew Thompson static const uint32_t ural_rf2525_r2[] = {
28402ac6454SAndrew Thompson 	0x20327, 0x20328, 0x20329, 0x2032a, 0x2032b, 0x2032c, 0x2032d,
28502ac6454SAndrew Thompson 	0x2032e, 0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20346
28602ac6454SAndrew Thompson };
28702ac6454SAndrew Thompson 
28802ac6454SAndrew Thompson static const uint32_t ural_rf2525_hi_r2[] = {
28902ac6454SAndrew Thompson 	0x2032f, 0x20340, 0x20341, 0x20342, 0x20343, 0x20344, 0x20345,
29002ac6454SAndrew Thompson 	0x20346, 0x20347, 0x20348, 0x20349, 0x2034a, 0x2034b, 0x2034e
29102ac6454SAndrew Thompson };
29202ac6454SAndrew Thompson 
29302ac6454SAndrew Thompson static const uint32_t ural_rf2525e_r2[] = {
29402ac6454SAndrew Thompson 	0x2044d, 0x2044e, 0x2044f, 0x20460, 0x20461, 0x20462, 0x20463,
29502ac6454SAndrew Thompson 	0x20464, 0x20465, 0x20466, 0x20467, 0x20468, 0x20469, 0x2046b
29602ac6454SAndrew Thompson };
29702ac6454SAndrew Thompson 
29802ac6454SAndrew Thompson static const uint32_t ural_rf2526_hi_r2[] = {
29902ac6454SAndrew Thompson 	0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d, 0x0022d,
30002ac6454SAndrew Thompson 	0x0022e, 0x0022e, 0x0022f, 0x0022d, 0x00240, 0x00240, 0x00241
30102ac6454SAndrew Thompson };
30202ac6454SAndrew Thompson 
30302ac6454SAndrew Thompson static const uint32_t ural_rf2526_r2[] = {
30402ac6454SAndrew Thompson 	0x00226, 0x00227, 0x00227, 0x00228, 0x00228, 0x00229, 0x00229,
30502ac6454SAndrew Thompson 	0x0022a, 0x0022a, 0x0022b, 0x0022b, 0x0022c, 0x0022c, 0x0022d
30602ac6454SAndrew Thompson };
30702ac6454SAndrew Thompson 
30802ac6454SAndrew Thompson /*
30902ac6454SAndrew Thompson  * For dual-band RF, RF registers R1 and R4 also depend on channel number;
31002ac6454SAndrew Thompson  * values taken from the reference driver.
31102ac6454SAndrew Thompson  */
31202ac6454SAndrew Thompson static const struct {
31302ac6454SAndrew Thompson 	uint8_t		chan;
31402ac6454SAndrew Thompson 	uint32_t	r1;
31502ac6454SAndrew Thompson 	uint32_t	r2;
31602ac6454SAndrew Thompson 	uint32_t	r4;
31702ac6454SAndrew Thompson } ural_rf5222[] = {
31802ac6454SAndrew Thompson 	{   1, 0x08808, 0x0044d, 0x00282 },
31902ac6454SAndrew Thompson 	{   2, 0x08808, 0x0044e, 0x00282 },
32002ac6454SAndrew Thompson 	{   3, 0x08808, 0x0044f, 0x00282 },
32102ac6454SAndrew Thompson 	{   4, 0x08808, 0x00460, 0x00282 },
32202ac6454SAndrew Thompson 	{   5, 0x08808, 0x00461, 0x00282 },
32302ac6454SAndrew Thompson 	{   6, 0x08808, 0x00462, 0x00282 },
32402ac6454SAndrew Thompson 	{   7, 0x08808, 0x00463, 0x00282 },
32502ac6454SAndrew Thompson 	{   8, 0x08808, 0x00464, 0x00282 },
32602ac6454SAndrew Thompson 	{   9, 0x08808, 0x00465, 0x00282 },
32702ac6454SAndrew Thompson 	{  10, 0x08808, 0x00466, 0x00282 },
32802ac6454SAndrew Thompson 	{  11, 0x08808, 0x00467, 0x00282 },
32902ac6454SAndrew Thompson 	{  12, 0x08808, 0x00468, 0x00282 },
33002ac6454SAndrew Thompson 	{  13, 0x08808, 0x00469, 0x00282 },
33102ac6454SAndrew Thompson 	{  14, 0x08808, 0x0046b, 0x00286 },
33202ac6454SAndrew Thompson 
33302ac6454SAndrew Thompson 	{  36, 0x08804, 0x06225, 0x00287 },
33402ac6454SAndrew Thompson 	{  40, 0x08804, 0x06226, 0x00287 },
33502ac6454SAndrew Thompson 	{  44, 0x08804, 0x06227, 0x00287 },
33602ac6454SAndrew Thompson 	{  48, 0x08804, 0x06228, 0x00287 },
33702ac6454SAndrew Thompson 	{  52, 0x08804, 0x06229, 0x00287 },
33802ac6454SAndrew Thompson 	{  56, 0x08804, 0x0622a, 0x00287 },
33902ac6454SAndrew Thompson 	{  60, 0x08804, 0x0622b, 0x00287 },
34002ac6454SAndrew Thompson 	{  64, 0x08804, 0x0622c, 0x00287 },
34102ac6454SAndrew Thompson 
34202ac6454SAndrew Thompson 	{ 100, 0x08804, 0x02200, 0x00283 },
34302ac6454SAndrew Thompson 	{ 104, 0x08804, 0x02201, 0x00283 },
34402ac6454SAndrew Thompson 	{ 108, 0x08804, 0x02202, 0x00283 },
34502ac6454SAndrew Thompson 	{ 112, 0x08804, 0x02203, 0x00283 },
34602ac6454SAndrew Thompson 	{ 116, 0x08804, 0x02204, 0x00283 },
34702ac6454SAndrew Thompson 	{ 120, 0x08804, 0x02205, 0x00283 },
34802ac6454SAndrew Thompson 	{ 124, 0x08804, 0x02206, 0x00283 },
34902ac6454SAndrew Thompson 	{ 128, 0x08804, 0x02207, 0x00283 },
35002ac6454SAndrew Thompson 	{ 132, 0x08804, 0x02208, 0x00283 },
35102ac6454SAndrew Thompson 	{ 136, 0x08804, 0x02209, 0x00283 },
35202ac6454SAndrew Thompson 	{ 140, 0x08804, 0x0220a, 0x00283 },
35302ac6454SAndrew Thompson 
35402ac6454SAndrew Thompson 	{ 149, 0x08808, 0x02429, 0x00281 },
35502ac6454SAndrew Thompson 	{ 153, 0x08808, 0x0242b, 0x00281 },
35602ac6454SAndrew Thompson 	{ 157, 0x08808, 0x0242d, 0x00281 },
35702ac6454SAndrew Thompson 	{ 161, 0x08808, 0x0242f, 0x00281 }
35802ac6454SAndrew Thompson };
35902ac6454SAndrew Thompson 
360760bc48eSAndrew Thompson static const struct usb_config ural_config[URAL_N_TRANSFER] = {
36102ac6454SAndrew Thompson 	[URAL_BULK_WR] = {
36202ac6454SAndrew Thompson 		.type = UE_BULK,
36302ac6454SAndrew Thompson 		.endpoint = UE_ADDR_ANY,
36402ac6454SAndrew Thompson 		.direction = UE_DIR_OUT,
3654eae601eSAndrew Thompson 		.bufsize = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE + 4),
3664eae601eSAndrew Thompson 		.flags = {.pipe_bof = 1,.force_short_xfer = 1,},
3674eae601eSAndrew Thompson 		.callback = ural_bulk_write_callback,
3684eae601eSAndrew Thompson 		.timeout = 5000,	/* ms */
36902ac6454SAndrew Thompson 	},
37002ac6454SAndrew Thompson 	[URAL_BULK_RD] = {
37102ac6454SAndrew Thompson 		.type = UE_BULK,
37202ac6454SAndrew Thompson 		.endpoint = UE_ADDR_ANY,
37302ac6454SAndrew Thompson 		.direction = UE_DIR_IN,
3744eae601eSAndrew Thompson 		.bufsize = (RAL_FRAME_SIZE + RAL_RX_DESC_SIZE),
3754eae601eSAndrew Thompson 		.flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
3764eae601eSAndrew Thompson 		.callback = ural_bulk_read_callback,
37702ac6454SAndrew Thompson 	},
37802ac6454SAndrew Thompson };
37902ac6454SAndrew Thompson 
38002ac6454SAndrew Thompson static device_probe_t ural_match;
38102ac6454SAndrew Thompson static device_attach_t ural_attach;
38202ac6454SAndrew Thompson static device_detach_t ural_detach;
38302ac6454SAndrew Thompson 
38402ac6454SAndrew Thompson static device_method_t ural_methods[] = {
38502ac6454SAndrew Thompson 	/* Device interface */
38602ac6454SAndrew Thompson 	DEVMETHOD(device_probe,		ural_match),
38702ac6454SAndrew Thompson 	DEVMETHOD(device_attach,	ural_attach),
38802ac6454SAndrew Thompson 	DEVMETHOD(device_detach,	ural_detach),
389645e4d17SHans Petter Selasky 	DEVMETHOD_END
39002ac6454SAndrew Thompson };
39102ac6454SAndrew Thompson 
39202ac6454SAndrew Thompson static driver_t ural_driver = {
39302ac6454SAndrew Thompson 	.name = "ural",
39402ac6454SAndrew Thompson 	.methods = ural_methods,
39502ac6454SAndrew Thompson 	.size = sizeof(struct ural_softc),
39602ac6454SAndrew Thompson };
39702ac6454SAndrew Thompson 
39802ac6454SAndrew Thompson static devclass_t ural_devclass;
39902ac6454SAndrew Thompson 
4009aef556dSAndrew Thompson DRIVER_MODULE(ural, uhub, ural_driver, ural_devclass, NULL, 0);
40102ac6454SAndrew Thompson MODULE_DEPEND(ural, usb, 1, 1, 1);
40202ac6454SAndrew Thompson MODULE_DEPEND(ural, wlan, 1, 1, 1);
403910cb8feSAndrew Thompson MODULE_VERSION(ural, 1);
40402ac6454SAndrew Thompson 
40502ac6454SAndrew Thompson static int
40602ac6454SAndrew Thompson ural_match(device_t self)
40702ac6454SAndrew Thompson {
408760bc48eSAndrew Thompson 	struct usb_attach_arg *uaa = device_get_ivars(self);
40902ac6454SAndrew Thompson 
410f29a0724SAndrew Thompson 	if (uaa->usb_mode != USB_MODE_HOST)
41102ac6454SAndrew Thompson 		return (ENXIO);
41202ac6454SAndrew Thompson 	if (uaa->info.bConfigIndex != 0)
41302ac6454SAndrew Thompson 		return (ENXIO);
41402ac6454SAndrew Thompson 	if (uaa->info.bIfaceIndex != RAL_IFACE_INDEX)
41502ac6454SAndrew Thompson 		return (ENXIO);
41602ac6454SAndrew Thompson 
417a593f6b8SAndrew Thompson 	return (usbd_lookup_id_by_uaa(ural_devs, sizeof(ural_devs), uaa));
41802ac6454SAndrew Thompson }
41902ac6454SAndrew Thompson 
42002ac6454SAndrew Thompson static int
42102ac6454SAndrew Thompson ural_attach(device_t self)
42202ac6454SAndrew Thompson {
423760bc48eSAndrew Thompson 	struct usb_attach_arg *uaa = device_get_ivars(self);
42402ac6454SAndrew Thompson 	struct ural_softc *sc = device_get_softc(self);
4257a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
4265efea30fSAndrew Thompson 	uint8_t iface_index, bands;
42702ac6454SAndrew Thompson 	int error;
42802ac6454SAndrew Thompson 
429a593f6b8SAndrew Thompson 	device_set_usb_desc(self);
43002ac6454SAndrew Thompson 	sc->sc_udev = uaa->device;
43102ac6454SAndrew Thompson 	sc->sc_dev = self;
43202ac6454SAndrew Thompson 
43302ac6454SAndrew Thompson 	mtx_init(&sc->sc_mtx, device_get_nameunit(self),
43402ac6454SAndrew Thompson 	    MTX_NETWORK_LOCK, MTX_DEF);
4357a79cebfSGleb Smirnoff 	mbufq_init(&sc->sc_snd, ifqmaxlen);
43602ac6454SAndrew Thompson 
43702ac6454SAndrew Thompson 	iface_index = RAL_IFACE_INDEX;
438a593f6b8SAndrew Thompson 	error = usbd_transfer_setup(uaa->device,
43902ac6454SAndrew Thompson 	    &iface_index, sc->sc_xfer, ural_config,
44002ac6454SAndrew Thompson 	    URAL_N_TRANSFER, sc, &sc->sc_mtx);
44102ac6454SAndrew Thompson 	if (error) {
44202ac6454SAndrew Thompson 		device_printf(self, "could not allocate USB transfers, "
443a593f6b8SAndrew Thompson 		    "err=%s\n", usbd_errstr(error));
44402ac6454SAndrew Thompson 		goto detach;
44502ac6454SAndrew Thompson 	}
44602ac6454SAndrew Thompson 
44702ac6454SAndrew Thompson 	RAL_LOCK(sc);
44802ac6454SAndrew Thompson 	/* retrieve RT2570 rev. no */
44902ac6454SAndrew Thompson 	sc->asic_rev = ural_read(sc, RAL_MAC_CSR0);
45002ac6454SAndrew Thompson 
45102ac6454SAndrew Thompson 	/* retrieve MAC address and various other things from EEPROM */
45202ac6454SAndrew Thompson 	ural_read_eeprom(sc);
45302ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
45402ac6454SAndrew Thompson 
4555efea30fSAndrew Thompson 	device_printf(self, "MAC/BBP RT2570 (rev 0x%02x), RF %s\n",
45602ac6454SAndrew Thompson 	    sc->asic_rev, ural_get_rf(sc->rf_rev));
45702ac6454SAndrew Thompson 
45859686fe9SGleb Smirnoff 	ic->ic_softc = sc;
459c8550c02SGleb Smirnoff 	ic->ic_name = device_get_nameunit(self);
46002ac6454SAndrew Thompson 	ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
46102ac6454SAndrew Thompson 
46202ac6454SAndrew Thompson 	/* set device capabilities */
46302ac6454SAndrew Thompson 	ic->ic_caps =
46402ac6454SAndrew Thompson 	      IEEE80211_C_STA		/* station mode supported */
46502ac6454SAndrew Thompson 	    | IEEE80211_C_IBSS		/* IBSS mode supported */
46602ac6454SAndrew Thompson 	    | IEEE80211_C_MONITOR	/* monitor mode supported */
46702ac6454SAndrew Thompson 	    | IEEE80211_C_HOSTAP	/* HostAp mode supported */
46802ac6454SAndrew Thompson 	    | IEEE80211_C_TXPMGT	/* tx power management */
46902ac6454SAndrew Thompson 	    | IEEE80211_C_SHPREAMBLE	/* short preamble supported */
47002ac6454SAndrew Thompson 	    | IEEE80211_C_SHSLOT	/* short slot time supported */
47102ac6454SAndrew Thompson 	    | IEEE80211_C_BGSCAN	/* bg scanning supported */
47202ac6454SAndrew Thompson 	    | IEEE80211_C_WPA		/* 802.11i */
47302ac6454SAndrew Thompson 	    ;
47402ac6454SAndrew Thompson 
47502ac6454SAndrew Thompson 	bands = 0;
47602ac6454SAndrew Thompson 	setbit(&bands, IEEE80211_MODE_11B);
47702ac6454SAndrew Thompson 	setbit(&bands, IEEE80211_MODE_11G);
47802ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_5222)
47902ac6454SAndrew Thompson 		setbit(&bands, IEEE80211_MODE_11A);
48002ac6454SAndrew Thompson 	ieee80211_init_channels(ic, NULL, &bands);
48102ac6454SAndrew Thompson 
4827a79cebfSGleb Smirnoff 	ieee80211_ifattach(ic);
48377ddf3d3SAndrew Thompson 	ic->ic_update_promisc = ural_update_promisc;
48402ac6454SAndrew Thompson 	ic->ic_raw_xmit = ural_raw_xmit;
48502ac6454SAndrew Thompson 	ic->ic_scan_start = ural_scan_start;
48602ac6454SAndrew Thompson 	ic->ic_scan_end = ural_scan_end;
48702ac6454SAndrew Thompson 	ic->ic_set_channel = ural_set_channel;
4887a79cebfSGleb Smirnoff 	ic->ic_parent = ural_parent;
4897a79cebfSGleb Smirnoff 	ic->ic_transmit = ural_transmit;
49002ac6454SAndrew Thompson 	ic->ic_vap_create = ural_vap_create;
49102ac6454SAndrew Thompson 	ic->ic_vap_delete = ural_vap_delete;
49202ac6454SAndrew Thompson 
4935463c4a4SSam Leffler 	ieee80211_radiotap_attach(ic,
4945463c4a4SSam Leffler 	    &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
4955463c4a4SSam Leffler 		RAL_TX_RADIOTAP_PRESENT,
4965463c4a4SSam Leffler 	    &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
4975463c4a4SSam Leffler 		RAL_RX_RADIOTAP_PRESENT);
49802ac6454SAndrew Thompson 
49902ac6454SAndrew Thompson 	if (bootverbose)
50002ac6454SAndrew Thompson 		ieee80211_announce(ic);
50102ac6454SAndrew Thompson 
5025efea30fSAndrew Thompson 	return (0);
5035efea30fSAndrew Thompson 
5045efea30fSAndrew Thompson detach:
5055efea30fSAndrew Thompson 	ural_detach(self);
5065efea30fSAndrew Thompson 	return (ENXIO);			/* failure */
50702ac6454SAndrew Thompson }
50802ac6454SAndrew Thompson 
50902ac6454SAndrew Thompson static int
51002ac6454SAndrew Thompson ural_detach(device_t self)
51102ac6454SAndrew Thompson {
51202ac6454SAndrew Thompson 	struct ural_softc *sc = device_get_softc(self);
5137a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
51402ac6454SAndrew Thompson 
515645e4d17SHans Petter Selasky 	/* prevent further ioctls */
516645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
517645e4d17SHans Petter Selasky 	sc->sc_detached = 1;
518645e4d17SHans Petter Selasky 	RAL_UNLOCK(sc);
519645e4d17SHans Petter Selasky 
52002ac6454SAndrew Thompson 	/* stop all USB transfers */
521a593f6b8SAndrew Thompson 	usbd_transfer_unsetup(sc->sc_xfer, URAL_N_TRANSFER);
52202ac6454SAndrew Thompson 
52302ac6454SAndrew Thompson 	/* free TX list, if any */
52402ac6454SAndrew Thompson 	RAL_LOCK(sc);
52502ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
52602ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
52702ac6454SAndrew Thompson 
5287a79cebfSGleb Smirnoff 	if (ic->ic_softc == sc)
52902ac6454SAndrew Thompson 		ieee80211_ifdetach(ic);
5307a79cebfSGleb Smirnoff 	mbufq_drain(&sc->sc_snd);
53102ac6454SAndrew Thompson 	mtx_destroy(&sc->sc_mtx);
53202ac6454SAndrew Thompson 
53302ac6454SAndrew Thompson 	return (0);
53402ac6454SAndrew Thompson }
53502ac6454SAndrew Thompson 
536e0a69b51SAndrew Thompson static usb_error_t
53777ddf3d3SAndrew Thompson ural_do_request(struct ural_softc *sc,
538760bc48eSAndrew Thompson     struct usb_device_request *req, void *data)
53977ddf3d3SAndrew Thompson {
540e0a69b51SAndrew Thompson 	usb_error_t err;
54177ddf3d3SAndrew Thompson 	int ntries = 10;
54277ddf3d3SAndrew Thompson 
54377ddf3d3SAndrew Thompson 	while (ntries--) {
544a593f6b8SAndrew Thompson 		err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
54577ddf3d3SAndrew Thompson 		    req, data, 0, NULL, 250 /* ms */);
54677ddf3d3SAndrew Thompson 		if (err == 0)
54777ddf3d3SAndrew Thompson 			break;
54877ddf3d3SAndrew Thompson 
54977ddf3d3SAndrew Thompson 		DPRINTFN(1, "Control request failed, %s (retrying)\n",
550a593f6b8SAndrew Thompson 		    usbd_errstr(err));
55177ddf3d3SAndrew Thompson 		if (ural_pause(sc, hz / 100))
55277ddf3d3SAndrew Thompson 			break;
55377ddf3d3SAndrew Thompson 	}
55477ddf3d3SAndrew Thompson 	return (err);
55577ddf3d3SAndrew Thompson }
55677ddf3d3SAndrew Thompson 
55702ac6454SAndrew Thompson static struct ieee80211vap *
558fcd9500fSBernhard Schmidt ural_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit,
559fcd9500fSBernhard Schmidt     enum ieee80211_opmode opmode, int flags,
56002ac6454SAndrew Thompson     const uint8_t bssid[IEEE80211_ADDR_LEN],
56102ac6454SAndrew Thompson     const uint8_t mac[IEEE80211_ADDR_LEN])
56202ac6454SAndrew Thompson {
563d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
56402ac6454SAndrew Thompson 	struct ural_vap *uvp;
56502ac6454SAndrew Thompson 	struct ieee80211vap *vap;
56602ac6454SAndrew Thompson 
56702ac6454SAndrew Thompson 	if (!TAILQ_EMPTY(&ic->ic_vaps))		/* only one at a time */
56802ac6454SAndrew Thompson 		return NULL;
569*97ad4604SKevin Lo 	uvp = malloc(sizeof(struct ural_vap), M_80211_VAP, M_WAITOK | M_ZERO);
57002ac6454SAndrew Thompson 	vap = &uvp->vap;
57102ac6454SAndrew Thompson 	/* enable s/w bmiss handling for sta mode */
572bb2f69e8SHans Petter Selasky 
573bb2f69e8SHans Petter Selasky 	if (ieee80211_vap_setup(ic, vap, name, unit, opmode,
5747a79cebfSGleb Smirnoff 	    flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) {
575bb2f69e8SHans Petter Selasky 		/* out of memory */
576bb2f69e8SHans Petter Selasky 		free(uvp, M_80211_VAP);
577bb2f69e8SHans Petter Selasky 		return (NULL);
578bb2f69e8SHans Petter Selasky 	}
57902ac6454SAndrew Thompson 
58002ac6454SAndrew Thompson 	/* override state transition machine */
58102ac6454SAndrew Thompson 	uvp->newstate = vap->iv_newstate;
58202ac6454SAndrew Thompson 	vap->iv_newstate = ural_newstate;
58302ac6454SAndrew Thompson 
584b6108616SRui Paulo 	usb_callout_init_mtx(&uvp->ratectl_ch, &sc->sc_mtx, 0);
585b6108616SRui Paulo 	TASK_INIT(&uvp->ratectl_task, 0, ural_ratectl_task, uvp);
586b6108616SRui Paulo 	ieee80211_ratectl_init(vap);
587b6108616SRui Paulo 	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
58802ac6454SAndrew Thompson 
58902ac6454SAndrew Thompson 	/* complete setup */
5907a79cebfSGleb Smirnoff 	ieee80211_vap_attach(vap, ieee80211_media_change,
5917a79cebfSGleb Smirnoff 	    ieee80211_media_status, mac);
59202ac6454SAndrew Thompson 	ic->ic_opmode = opmode;
59302ac6454SAndrew Thompson 	return vap;
59402ac6454SAndrew Thompson }
59502ac6454SAndrew Thompson 
59602ac6454SAndrew Thompson static void
59702ac6454SAndrew Thompson ural_vap_delete(struct ieee80211vap *vap)
59802ac6454SAndrew Thompson {
59902ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6005efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
60102ac6454SAndrew Thompson 
602b6108616SRui Paulo 	usb_callout_drain(&uvp->ratectl_ch);
603b6108616SRui Paulo 	ieee80211_draintask(ic, &uvp->ratectl_task);
604b6108616SRui Paulo 	ieee80211_ratectl_deinit(vap);
60502ac6454SAndrew Thompson 	ieee80211_vap_detach(vap);
60602ac6454SAndrew Thompson 	free(uvp, M_80211_VAP);
60702ac6454SAndrew Thompson }
60802ac6454SAndrew Thompson 
60902ac6454SAndrew Thompson static void
61002ac6454SAndrew Thompson ural_tx_free(struct ural_tx_data *data, int txerr)
61102ac6454SAndrew Thompson {
61202ac6454SAndrew Thompson 	struct ural_softc *sc = data->sc;
61302ac6454SAndrew Thompson 
61402ac6454SAndrew Thompson 	if (data->m != NULL) {
6157a79cebfSGleb Smirnoff 		ieee80211_tx_complete(data->ni, data->m, txerr);
61602ac6454SAndrew Thompson 		data->m = NULL;
61702ac6454SAndrew Thompson 		data->ni = NULL;
61802ac6454SAndrew Thompson 	}
61902ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
62002ac6454SAndrew Thompson 	sc->tx_nfree++;
62102ac6454SAndrew Thompson }
62202ac6454SAndrew Thompson 
62302ac6454SAndrew Thompson static void
62402ac6454SAndrew Thompson ural_setup_tx_list(struct ural_softc *sc)
62502ac6454SAndrew Thompson {
62602ac6454SAndrew Thompson 	struct ural_tx_data *data;
62702ac6454SAndrew Thompson 	int i;
62802ac6454SAndrew Thompson 
62902ac6454SAndrew Thompson 	sc->tx_nfree = 0;
63002ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
63102ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
63202ac6454SAndrew Thompson 
63302ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
63402ac6454SAndrew Thompson 		data = &sc->tx_data[i];
63502ac6454SAndrew Thompson 
63602ac6454SAndrew Thompson 		data->sc = sc;
63702ac6454SAndrew Thompson 		STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
63802ac6454SAndrew Thompson 		sc->tx_nfree++;
63902ac6454SAndrew Thompson 	}
64002ac6454SAndrew Thompson }
64102ac6454SAndrew Thompson 
64202ac6454SAndrew Thompson static void
64302ac6454SAndrew Thompson ural_unsetup_tx_list(struct ural_softc *sc)
64402ac6454SAndrew Thompson {
64502ac6454SAndrew Thompson 	struct ural_tx_data *data;
64602ac6454SAndrew Thompson 	int i;
64702ac6454SAndrew Thompson 
64802ac6454SAndrew Thompson 	/* make sure any subsequent use of the queues will fail */
64902ac6454SAndrew Thompson 	sc->tx_nfree = 0;
65002ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
65102ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
65202ac6454SAndrew Thompson 
65302ac6454SAndrew Thompson 	/* free up all node references and mbufs */
65402ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
65502ac6454SAndrew Thompson 		data = &sc->tx_data[i];
65602ac6454SAndrew Thompson 
65702ac6454SAndrew Thompson 		if (data->m != NULL) {
65802ac6454SAndrew Thompson 			m_freem(data->m);
65902ac6454SAndrew Thompson 			data->m = NULL;
66002ac6454SAndrew Thompson 		}
66102ac6454SAndrew Thompson 		if (data->ni != NULL) {
66202ac6454SAndrew Thompson 			ieee80211_free_node(data->ni);
66302ac6454SAndrew Thompson 			data->ni = NULL;
66402ac6454SAndrew Thompson 		}
66502ac6454SAndrew Thompson 	}
66602ac6454SAndrew Thompson }
66702ac6454SAndrew Thompson 
6685efea30fSAndrew Thompson static int
6695efea30fSAndrew Thompson ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
67002ac6454SAndrew Thompson {
67102ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6725efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
673d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
67402ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
67502ac6454SAndrew Thompson 	struct ieee80211_node *ni;
67602ac6454SAndrew Thompson 	struct mbuf *m;
67702ac6454SAndrew Thompson 
6785efea30fSAndrew Thompson 	DPRINTF("%s -> %s\n",
6795efea30fSAndrew Thompson 		ieee80211_state_name[vap->iv_state],
6805efea30fSAndrew Thompson 		ieee80211_state_name[nstate]);
68102ac6454SAndrew Thompson 
6825efea30fSAndrew Thompson 	IEEE80211_UNLOCK(ic);
6835efea30fSAndrew Thompson 	RAL_LOCK(sc);
684b6108616SRui Paulo 	usb_callout_stop(&uvp->ratectl_ch);
6855efea30fSAndrew Thompson 
6865efea30fSAndrew Thompson 	switch (nstate) {
68702ac6454SAndrew Thompson 	case IEEE80211_S_INIT:
6885efea30fSAndrew Thompson 		if (vap->iv_state == IEEE80211_S_RUN) {
68902ac6454SAndrew Thompson 			/* abort TSF synchronization */
69002ac6454SAndrew Thompson 			ural_write(sc, RAL_TXRX_CSR19, 0);
69102ac6454SAndrew Thompson 
69202ac6454SAndrew Thompson 			/* force tx led to stop blinking */
69302ac6454SAndrew Thompson 			ural_write(sc, RAL_MAC_CSR20, 0);
69402ac6454SAndrew Thompson 		}
69502ac6454SAndrew Thompson 		break;
69602ac6454SAndrew Thompson 
69702ac6454SAndrew Thompson 	case IEEE80211_S_RUN:
6988d8bdb01SAndrew Thompson 		ni = ieee80211_ref_node(vap->iv_bss);
69902ac6454SAndrew Thompson 
70002ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR) {
701bb571462SHans Petter Selasky 			if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
702bb571462SHans Petter Selasky 				RAL_UNLOCK(sc);
703bb571462SHans Petter Selasky 				IEEE80211_LOCK(ic);
704bb571462SHans Petter Selasky 				ieee80211_free_node(ni);
705bb571462SHans Petter Selasky 				return (-1);
706bb571462SHans Petter Selasky 			}
7077a79cebfSGleb Smirnoff 			ural_update_slot(sc);
70802ac6454SAndrew Thompson 			ural_set_txpreamble(sc);
70902ac6454SAndrew Thompson 			ural_set_basicrates(sc, ic->ic_bsschan);
7107a79cebfSGleb Smirnoff 			IEEE80211_ADDR_COPY(ic->ic_macaddr, ni->ni_bssid);
7117a79cebfSGleb Smirnoff 			ural_set_bssid(sc, ic->ic_macaddr);
71202ac6454SAndrew Thompson 		}
71302ac6454SAndrew Thompson 
71402ac6454SAndrew Thompson 		if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
71502ac6454SAndrew Thompson 		    vap->iv_opmode == IEEE80211_M_IBSS) {
71602ac6454SAndrew Thompson 			m = ieee80211_beacon_alloc(ni, &uvp->bo);
71702ac6454SAndrew Thompson 			if (m == NULL) {
71802ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
71902ac6454SAndrew Thompson 				    "could not allocate beacon\n");
7205efea30fSAndrew Thompson 				RAL_UNLOCK(sc);
7215efea30fSAndrew Thompson 				IEEE80211_LOCK(ic);
7228d8bdb01SAndrew Thompson 				ieee80211_free_node(ni);
7235efea30fSAndrew Thompson 				return (-1);
72402ac6454SAndrew Thompson 			}
7256fca0210SAndrew Thompson 			ieee80211_ref_node(ni);
72602ac6454SAndrew Thompson 			if (ural_tx_bcn(sc, m, ni) != 0) {
72702ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
72802ac6454SAndrew Thompson 				    "could not send beacon\n");
7295efea30fSAndrew Thompson 				RAL_UNLOCK(sc);
7305efea30fSAndrew Thompson 				IEEE80211_LOCK(ic);
7318d8bdb01SAndrew Thompson 				ieee80211_free_node(ni);
7325efea30fSAndrew Thompson 				return (-1);
73302ac6454SAndrew Thompson 			}
73402ac6454SAndrew Thompson 		}
73502ac6454SAndrew Thompson 
73602ac6454SAndrew Thompson 		/* make tx led blink on tx (controlled by ASIC) */
73702ac6454SAndrew Thompson 		ural_write(sc, RAL_MAC_CSR20, 1);
73802ac6454SAndrew Thompson 
73902ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR)
74002ac6454SAndrew Thompson 			ural_enable_tsf_sync(sc);
7415463c4a4SSam Leffler 		else
7425463c4a4SSam Leffler 			ural_enable_tsf(sc);
74302ac6454SAndrew Thompson 
74402ac6454SAndrew Thompson 		/* enable automatic rate adaptation */
7455463c4a4SSam Leffler 		/* XXX should use ic_bsschan but not valid until after newstate call below */
7465463c4a4SSam Leffler 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
74702ac6454SAndrew Thompson 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
748b6108616SRui Paulo 			ural_ratectl_start(sc, ni);
7498d8bdb01SAndrew Thompson 		ieee80211_free_node(ni);
75002ac6454SAndrew Thompson 		break;
75102ac6454SAndrew Thompson 
75202ac6454SAndrew Thompson 	default:
75302ac6454SAndrew Thompson 		break;
75402ac6454SAndrew Thompson 	}
75502ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
75602ac6454SAndrew Thompson 	IEEE80211_LOCK(ic);
7575efea30fSAndrew Thompson 	return (uvp->newstate(vap, nstate, arg));
75802ac6454SAndrew Thompson }
75902ac6454SAndrew Thompson 
76002ac6454SAndrew Thompson 
76102ac6454SAndrew Thompson static void
762ed6d949aSAndrew Thompson ural_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
76302ac6454SAndrew Thompson {
764ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
7655463c4a4SSam Leffler 	struct ieee80211vap *vap;
76602ac6454SAndrew Thompson 	struct ural_tx_data *data;
76702ac6454SAndrew Thompson 	struct mbuf *m;
768ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
769ed6d949aSAndrew Thompson 	int len;
770ed6d949aSAndrew Thompson 
771ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
77202ac6454SAndrew Thompson 
77302ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
77402ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
775ed6d949aSAndrew Thompson 		DPRINTFN(11, "transfer complete, %d bytes\n", len);
77602ac6454SAndrew Thompson 
77702ac6454SAndrew Thompson 		/* free resources */
778ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
77902ac6454SAndrew Thompson 		ural_tx_free(data, 0);
780ed6d949aSAndrew Thompson 		usbd_xfer_set_priv(xfer, NULL);
78102ac6454SAndrew Thompson 
78202ac6454SAndrew Thompson 		/* FALLTHROUGH */
78302ac6454SAndrew Thompson 	case USB_ST_SETUP:
78402ac6454SAndrew Thompson tr_setup:
78502ac6454SAndrew Thompson 		data = STAILQ_FIRST(&sc->tx_q);
78602ac6454SAndrew Thompson 		if (data) {
78702ac6454SAndrew Thompson 			STAILQ_REMOVE_HEAD(&sc->tx_q, next);
78802ac6454SAndrew Thompson 			m = data->m;
78902ac6454SAndrew Thompson 
7906d917491SHans Petter Selasky 			if (m->m_pkthdr.len > (int)(RAL_FRAME_SIZE + RAL_TX_DESC_SIZE)) {
79102ac6454SAndrew Thompson 				DPRINTFN(0, "data overflow, %u bytes\n",
79202ac6454SAndrew Thompson 				    m->m_pkthdr.len);
79302ac6454SAndrew Thompson 				m->m_pkthdr.len = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE);
79402ac6454SAndrew Thompson 			}
795ed6d949aSAndrew Thompson 			pc = usbd_xfer_get_frame(xfer, 0);
796ed6d949aSAndrew Thompson 			usbd_copy_in(pc, 0, &data->desc, RAL_TX_DESC_SIZE);
797ed6d949aSAndrew Thompson 			usbd_m_copy_in(pc, RAL_TX_DESC_SIZE, m, 0,
79802ac6454SAndrew Thompson 			    m->m_pkthdr.len);
79902ac6454SAndrew Thompson 
8005463c4a4SSam Leffler 			vap = data->ni->ni_vap;
8015463c4a4SSam Leffler 			if (ieee80211_radiotap_active_vap(vap)) {
80202ac6454SAndrew Thompson 				struct ural_tx_radiotap_header *tap = &sc->sc_txtap;
80302ac6454SAndrew Thompson 
80402ac6454SAndrew Thompson 				tap->wt_flags = 0;
80502ac6454SAndrew Thompson 				tap->wt_rate = data->rate;
80602ac6454SAndrew Thompson 				tap->wt_antenna = sc->tx_ant;
80702ac6454SAndrew Thompson 
8085463c4a4SSam Leffler 				ieee80211_radiotap_tx(vap, m);
80902ac6454SAndrew Thompson 			}
81002ac6454SAndrew Thompson 
81102ac6454SAndrew Thompson 			/* xfer length needs to be a multiple of two! */
81202ac6454SAndrew Thompson 			len = (RAL_TX_DESC_SIZE + m->m_pkthdr.len + 1) & ~1;
81302ac6454SAndrew Thompson 			if ((len % 64) == 0)
81402ac6454SAndrew Thompson 				len += 2;
81502ac6454SAndrew Thompson 
81602ac6454SAndrew Thompson 			DPRINTFN(11, "sending frame len=%u xferlen=%u\n",
81702ac6454SAndrew Thompson 			    m->m_pkthdr.len, len);
81802ac6454SAndrew Thompson 
819ed6d949aSAndrew Thompson 			usbd_xfer_set_frame_len(xfer, 0, len);
820ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, data);
82102ac6454SAndrew Thompson 
822a593f6b8SAndrew Thompson 			usbd_transfer_submit(xfer);
82302ac6454SAndrew Thompson 		}
8247a79cebfSGleb Smirnoff 		ural_start(sc);
82502ac6454SAndrew Thompson 		break;
82602ac6454SAndrew Thompson 
82702ac6454SAndrew Thompson 	default:			/* Error */
82802ac6454SAndrew Thompson 		DPRINTFN(11, "transfer error, %s\n",
829ed6d949aSAndrew Thompson 		    usbd_errstr(error));
83002ac6454SAndrew Thompson 
831ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
83202ac6454SAndrew Thompson 		if (data != NULL) {
833ed6d949aSAndrew Thompson 			ural_tx_free(data, error);
834ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, NULL);
83502ac6454SAndrew Thompson 		}
83602ac6454SAndrew Thompson 
837ed6d949aSAndrew Thompson 		if (error == USB_ERR_STALLED) {
83802ac6454SAndrew Thompson 			/* try to clear stall first */
839ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
84002ac6454SAndrew Thompson 			goto tr_setup;
84102ac6454SAndrew Thompson 		}
842ed6d949aSAndrew Thompson 		if (error == USB_ERR_TIMEOUT)
84302ac6454SAndrew Thompson 			device_printf(sc->sc_dev, "device timeout\n");
84402ac6454SAndrew Thompson 		break;
84502ac6454SAndrew Thompson 	}
84602ac6454SAndrew Thompson }
84702ac6454SAndrew Thompson 
84802ac6454SAndrew Thompson static void
849ed6d949aSAndrew Thompson ural_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
85002ac6454SAndrew Thompson {
851ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
8527a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
85302ac6454SAndrew Thompson 	struct ieee80211_node *ni;
85402ac6454SAndrew Thompson 	struct mbuf *m = NULL;
855ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
85602ac6454SAndrew Thompson 	uint32_t flags;
8575463c4a4SSam Leffler 	int8_t rssi = 0, nf = 0;
858ed6d949aSAndrew Thompson 	int len;
859ed6d949aSAndrew Thompson 
860ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
86102ac6454SAndrew Thompson 
86202ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
86302ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
86402ac6454SAndrew Thompson 
865ed6d949aSAndrew Thompson 		DPRINTFN(15, "rx done, actlen=%d\n", len);
86602ac6454SAndrew Thompson 
8676d917491SHans Petter Selasky 		if (len < (int)(RAL_RX_DESC_SIZE + IEEE80211_MIN_LEN)) {
86802ac6454SAndrew Thompson 			DPRINTF("%s: xfer too short %d\n",
86902ac6454SAndrew Thompson 			    device_get_nameunit(sc->sc_dev), len);
8707a79cebfSGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
87102ac6454SAndrew Thompson 			goto tr_setup;
87202ac6454SAndrew Thompson 		}
87302ac6454SAndrew Thompson 
87402ac6454SAndrew Thompson 		len -= RAL_RX_DESC_SIZE;
87502ac6454SAndrew Thompson 		/* rx descriptor is located at the end */
876ed6d949aSAndrew Thompson 		pc = usbd_xfer_get_frame(xfer, 0);
877ed6d949aSAndrew Thompson 		usbd_copy_out(pc, len, &sc->sc_rx_desc, RAL_RX_DESC_SIZE);
87802ac6454SAndrew Thompson 
87902ac6454SAndrew Thompson 		rssi = URAL_RSSI(sc->sc_rx_desc.rssi);
8805463c4a4SSam Leffler 		nf = RAL_NOISE_FLOOR;
88102ac6454SAndrew Thompson 		flags = le32toh(sc->sc_rx_desc.flags);
88202ac6454SAndrew Thompson 		if (flags & (RAL_RX_PHY_ERROR | RAL_RX_CRC_ERROR)) {
88302ac6454SAndrew Thompson 			/*
88402ac6454SAndrew Thompson 		         * This should not happen since we did not
88502ac6454SAndrew Thompson 		         * request to receive those frames when we
88602ac6454SAndrew Thompson 		         * filled RAL_TXRX_CSR2:
88702ac6454SAndrew Thompson 		         */
88802ac6454SAndrew Thompson 			DPRINTFN(5, "PHY or CRC error\n");
8897a79cebfSGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
89002ac6454SAndrew Thompson 			goto tr_setup;
89102ac6454SAndrew Thompson 		}
89202ac6454SAndrew Thompson 
893c6499eccSGleb Smirnoff 		m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
89402ac6454SAndrew Thompson 		if (m == NULL) {
89502ac6454SAndrew Thompson 			DPRINTF("could not allocate mbuf\n");
8967a79cebfSGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
89702ac6454SAndrew Thompson 			goto tr_setup;
89802ac6454SAndrew Thompson 		}
899ed6d949aSAndrew Thompson 		usbd_copy_out(pc, 0, mtod(m, uint8_t *), len);
90002ac6454SAndrew Thompson 
90102ac6454SAndrew Thompson 		/* finalize mbuf */
90202ac6454SAndrew Thompson 		m->m_pkthdr.len = m->m_len = (flags >> 16) & 0xfff;
90302ac6454SAndrew Thompson 
9045463c4a4SSam Leffler 		if (ieee80211_radiotap_active(ic)) {
90502ac6454SAndrew Thompson 			struct ural_rx_radiotap_header *tap = &sc->sc_rxtap;
90602ac6454SAndrew Thompson 
9075463c4a4SSam Leffler 			/* XXX set once */
9085463c4a4SSam Leffler 			tap->wr_flags = 0;
90902ac6454SAndrew Thompson 			tap->wr_rate = ieee80211_plcp2rate(sc->sc_rx_desc.rate,
91002ac6454SAndrew Thompson 			    (flags & RAL_RX_OFDM) ?
91102ac6454SAndrew Thompson 			    IEEE80211_T_OFDM : IEEE80211_T_CCK);
91202ac6454SAndrew Thompson 			tap->wr_antenna = sc->rx_ant;
9135463c4a4SSam Leffler 			tap->wr_antsignal = nf + rssi;
9145463c4a4SSam Leffler 			tap->wr_antnoise = nf;
91502ac6454SAndrew Thompson 		}
91602ac6454SAndrew Thompson 		/* Strip trailing 802.11 MAC FCS. */
91702ac6454SAndrew Thompson 		m_adj(m, -IEEE80211_CRC_LEN);
91802ac6454SAndrew Thompson 
91902ac6454SAndrew Thompson 		/* FALLTHROUGH */
92002ac6454SAndrew Thompson 	case USB_ST_SETUP:
92102ac6454SAndrew Thompson tr_setup:
922ed6d949aSAndrew Thompson 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
923a593f6b8SAndrew Thompson 		usbd_transfer_submit(xfer);
92402ac6454SAndrew Thompson 
92502ac6454SAndrew Thompson 		/*
92602ac6454SAndrew Thompson 		 * At the end of a USB callback it is always safe to unlock
92702ac6454SAndrew Thompson 		 * the private mutex of a device! That is why we do the
92802ac6454SAndrew Thompson 		 * "ieee80211_input" here, and not some lines up!
92902ac6454SAndrew Thompson 		 */
93002ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
931941da6d3SWeongyo Jeong 		if (m) {
93202ac6454SAndrew Thompson 			ni = ieee80211_find_rxnode(ic,
93302ac6454SAndrew Thompson 			    mtod(m, struct ieee80211_frame_min *));
93402ac6454SAndrew Thompson 			if (ni != NULL) {
9355463c4a4SSam Leffler 				(void) ieee80211_input(ni, m, rssi, nf);
93602ac6454SAndrew Thompson 				ieee80211_free_node(ni);
93702ac6454SAndrew Thompson 			} else
9385463c4a4SSam Leffler 				(void) ieee80211_input_all(ic, m, rssi, nf);
93902ac6454SAndrew Thompson 		}
940941da6d3SWeongyo Jeong 		RAL_LOCK(sc);
9417a79cebfSGleb Smirnoff 		ural_start(sc);
94202ac6454SAndrew Thompson 		return;
94302ac6454SAndrew Thompson 
94402ac6454SAndrew Thompson 	default:			/* Error */
945ed6d949aSAndrew Thompson 		if (error != USB_ERR_CANCELLED) {
94602ac6454SAndrew Thompson 			/* try to clear stall first */
947ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
94802ac6454SAndrew Thompson 			goto tr_setup;
94902ac6454SAndrew Thompson 		}
95002ac6454SAndrew Thompson 		return;
95102ac6454SAndrew Thompson 	}
95202ac6454SAndrew Thompson }
95302ac6454SAndrew Thompson 
95402ac6454SAndrew Thompson static uint8_t
95502ac6454SAndrew Thompson ural_plcp_signal(int rate)
95602ac6454SAndrew Thompson {
95702ac6454SAndrew Thompson 	switch (rate) {
95802ac6454SAndrew Thompson 	/* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
95902ac6454SAndrew Thompson 	case 12:	return 0xb;
96002ac6454SAndrew Thompson 	case 18:	return 0xf;
96102ac6454SAndrew Thompson 	case 24:	return 0xa;
96202ac6454SAndrew Thompson 	case 36:	return 0xe;
96302ac6454SAndrew Thompson 	case 48:	return 0x9;
96402ac6454SAndrew Thompson 	case 72:	return 0xd;
96502ac6454SAndrew Thompson 	case 96:	return 0x8;
96602ac6454SAndrew Thompson 	case 108:	return 0xc;
96702ac6454SAndrew Thompson 
96802ac6454SAndrew Thompson 	/* CCK rates (NB: not IEEE std, device-specific) */
96902ac6454SAndrew Thompson 	case 2:		return 0x0;
97002ac6454SAndrew Thompson 	case 4:		return 0x1;
97102ac6454SAndrew Thompson 	case 11:	return 0x2;
97202ac6454SAndrew Thompson 	case 22:	return 0x3;
97302ac6454SAndrew Thompson 	}
97402ac6454SAndrew Thompson 	return 0xff;		/* XXX unsupported/unknown rate */
97502ac6454SAndrew Thompson }
97602ac6454SAndrew Thompson 
97702ac6454SAndrew Thompson static void
97802ac6454SAndrew Thompson ural_setup_tx_desc(struct ural_softc *sc, struct ural_tx_desc *desc,
97902ac6454SAndrew Thompson     uint32_t flags, int len, int rate)
98002ac6454SAndrew Thompson {
9817a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
98202ac6454SAndrew Thompson 	uint16_t plcp_length;
98302ac6454SAndrew Thompson 	int remainder;
98402ac6454SAndrew Thompson 
98502ac6454SAndrew Thompson 	desc->flags = htole32(flags);
98602ac6454SAndrew Thompson 	desc->flags |= htole32(RAL_TX_NEWSEQ);
98702ac6454SAndrew Thompson 	desc->flags |= htole32(len << 16);
98802ac6454SAndrew Thompson 
98902ac6454SAndrew Thompson 	desc->wme = htole16(RAL_AIFSN(2) | RAL_LOGCWMIN(3) | RAL_LOGCWMAX(5));
99002ac6454SAndrew Thompson 	desc->wme |= htole16(RAL_IVOFFSET(sizeof (struct ieee80211_frame)));
99102ac6454SAndrew Thompson 
99202ac6454SAndrew Thompson 	/* setup PLCP fields */
99302ac6454SAndrew Thompson 	desc->plcp_signal  = ural_plcp_signal(rate);
99402ac6454SAndrew Thompson 	desc->plcp_service = 4;
99502ac6454SAndrew Thompson 
99602ac6454SAndrew Thompson 	len += IEEE80211_CRC_LEN;
99726d39e2cSSam Leffler 	if (ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM) {
99802ac6454SAndrew Thompson 		desc->flags |= htole32(RAL_TX_OFDM);
99902ac6454SAndrew Thompson 
100002ac6454SAndrew Thompson 		plcp_length = len & 0xfff;
100102ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 6;
100202ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0x3f;
100302ac6454SAndrew Thompson 	} else {
1004b8e3094cSHans Petter Selasky 		if (rate == 0)
1005b8e3094cSHans Petter Selasky 			rate = 2;	/* avoid division by zero */
100602ac6454SAndrew Thompson 		plcp_length = (16 * len + rate - 1) / rate;
100702ac6454SAndrew Thompson 		if (rate == 22) {
100802ac6454SAndrew Thompson 			remainder = (16 * len) % 22;
100902ac6454SAndrew Thompson 			if (remainder != 0 && remainder < 7)
101002ac6454SAndrew Thompson 				desc->plcp_service |= RAL_PLCP_LENGEXT;
101102ac6454SAndrew Thompson 		}
101202ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 8;
101302ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0xff;
101402ac6454SAndrew Thompson 
101502ac6454SAndrew Thompson 		if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
101602ac6454SAndrew Thompson 			desc->plcp_signal |= 0x08;
101702ac6454SAndrew Thompson 	}
101802ac6454SAndrew Thompson 
101902ac6454SAndrew Thompson 	desc->iv = 0;
102002ac6454SAndrew Thompson 	desc->eiv = 0;
102102ac6454SAndrew Thompson }
102202ac6454SAndrew Thompson 
102302ac6454SAndrew Thompson #define RAL_TX_TIMEOUT	5000
102402ac6454SAndrew Thompson 
102502ac6454SAndrew Thompson static int
102602ac6454SAndrew Thompson ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
102702ac6454SAndrew Thompson {
102802ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
102902ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
103002ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
103102ac6454SAndrew Thompson 	struct ural_tx_data *data;
103202ac6454SAndrew Thompson 
103302ac6454SAndrew Thompson 	if (sc->tx_nfree == 0) {
103402ac6454SAndrew Thompson 		m_freem(m0);
103502ac6454SAndrew Thompson 		ieee80211_free_node(ni);
1036bb571462SHans Petter Selasky 		return (EIO);
1037bb571462SHans Petter Selasky 	}
1038bb571462SHans Petter Selasky 	if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
1039bb571462SHans Petter Selasky 		m_freem(m0);
1040bb571462SHans Petter Selasky 		ieee80211_free_node(ni);
1041bb571462SHans Petter Selasky 		return (ENXIO);
104202ac6454SAndrew Thompson 	}
104302ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
104402ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
104502ac6454SAndrew Thompson 	sc->tx_nfree--;
104602ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
104702ac6454SAndrew Thompson 
104802ac6454SAndrew Thompson 	data->m = m0;
104902ac6454SAndrew Thompson 	data->ni = ni;
105002ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
105102ac6454SAndrew Thompson 
105202ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc,
105302ac6454SAndrew Thompson 	    RAL_TX_IFS_NEWBACKOFF | RAL_TX_TIMESTAMP, m0->m_pkthdr.len,
105402ac6454SAndrew Thompson 	    tp->mgmtrate);
105502ac6454SAndrew Thompson 
105602ac6454SAndrew Thompson 	DPRINTFN(10, "sending beacon frame len=%u rate=%u\n",
105702ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
105802ac6454SAndrew Thompson 
105902ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1060a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
106102ac6454SAndrew Thompson 
106202ac6454SAndrew Thompson 	return (0);
106302ac6454SAndrew Thompson }
106402ac6454SAndrew Thompson 
106502ac6454SAndrew Thompson static int
106602ac6454SAndrew Thompson ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
106702ac6454SAndrew Thompson {
106802ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
106902ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
107002ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
107102ac6454SAndrew Thompson 	struct ural_tx_data *data;
107202ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
107302ac6454SAndrew Thompson 	struct ieee80211_key *k;
107402ac6454SAndrew Thompson 	uint32_t flags;
107502ac6454SAndrew Thompson 	uint16_t dur;
107602ac6454SAndrew Thompson 
107702ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
107802ac6454SAndrew Thompson 
107902ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
108002ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
108102ac6454SAndrew Thompson 	sc->tx_nfree--;
108202ac6454SAndrew Thompson 
108302ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
108402ac6454SAndrew Thompson 
108502ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
10865945b5f5SKevin Lo 	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
108702ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
108802ac6454SAndrew Thompson 		if (k == NULL) {
108902ac6454SAndrew Thompson 			m_freem(m0);
109002ac6454SAndrew Thompson 			return ENOBUFS;
109102ac6454SAndrew Thompson 		}
109202ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
109302ac6454SAndrew Thompson 	}
109402ac6454SAndrew Thompson 
109502ac6454SAndrew Thompson 	data->m = m0;
109602ac6454SAndrew Thompson 	data->ni = ni;
109702ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
109802ac6454SAndrew Thompson 
109902ac6454SAndrew Thompson 	flags = 0;
110002ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
110102ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
110202ac6454SAndrew Thompson 
110326d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, tp->mgmtrate,
110402ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
11058cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
110602ac6454SAndrew Thompson 
110702ac6454SAndrew Thompson 		/* tell hardware to add timestamp for probe responses */
110802ac6454SAndrew Thompson 		if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
110902ac6454SAndrew Thompson 		    IEEE80211_FC0_TYPE_MGT &&
111002ac6454SAndrew Thompson 		    (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
111102ac6454SAndrew Thompson 		    IEEE80211_FC0_SUBTYPE_PROBE_RESP)
111202ac6454SAndrew Thompson 			flags |= RAL_TX_TIMESTAMP;
111302ac6454SAndrew Thompson 	}
111402ac6454SAndrew Thompson 
111502ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, tp->mgmtrate);
111602ac6454SAndrew Thompson 
111702ac6454SAndrew Thompson 	DPRINTFN(10, "sending mgt frame len=%u rate=%u\n",
111802ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
111902ac6454SAndrew Thompson 
112002ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1121a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
112202ac6454SAndrew Thompson 
112302ac6454SAndrew Thompson 	return 0;
112402ac6454SAndrew Thompson }
112502ac6454SAndrew Thompson 
112602ac6454SAndrew Thompson static int
112702ac6454SAndrew Thompson ural_sendprot(struct ural_softc *sc,
112802ac6454SAndrew Thompson     const struct mbuf *m, struct ieee80211_node *ni, int prot, int rate)
112902ac6454SAndrew Thompson {
113002ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
113102ac6454SAndrew Thompson 	const struct ieee80211_frame *wh;
113202ac6454SAndrew Thompson 	struct ural_tx_data *data;
113302ac6454SAndrew Thompson 	struct mbuf *mprot;
113402ac6454SAndrew Thompson 	int protrate, ackrate, pktlen, flags, isshort;
113502ac6454SAndrew Thompson 	uint16_t dur;
113602ac6454SAndrew Thompson 
113702ac6454SAndrew Thompson 	KASSERT(prot == IEEE80211_PROT_RTSCTS || prot == IEEE80211_PROT_CTSONLY,
113802ac6454SAndrew Thompson 	    ("protection %d", prot));
113902ac6454SAndrew Thompson 
114002ac6454SAndrew Thompson 	wh = mtod(m, const struct ieee80211_frame *);
114102ac6454SAndrew Thompson 	pktlen = m->m_pkthdr.len + IEEE80211_CRC_LEN;
114202ac6454SAndrew Thompson 
114326d39e2cSSam Leffler 	protrate = ieee80211_ctl_rate(ic->ic_rt, rate);
114426d39e2cSSam Leffler 	ackrate = ieee80211_ack_rate(ic->ic_rt, rate);
114502ac6454SAndrew Thompson 
114602ac6454SAndrew Thompson 	isshort = (ic->ic_flags & IEEE80211_F_SHPREAMBLE) != 0;
11470f817de7SJung-uk Kim 	dur = ieee80211_compute_duration(ic->ic_rt, pktlen, rate, isshort)
114826d39e2cSSam Leffler 	    + ieee80211_ack_duration(ic->ic_rt, rate, isshort);
114902ac6454SAndrew Thompson 	flags = RAL_TX_RETRY(7);
115002ac6454SAndrew Thompson 	if (prot == IEEE80211_PROT_RTSCTS) {
115102ac6454SAndrew Thompson 		/* NB: CTS is the same size as an ACK */
115226d39e2cSSam Leffler 		dur += ieee80211_ack_duration(ic->ic_rt, rate, isshort);
115302ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
115402ac6454SAndrew Thompson 		mprot = ieee80211_alloc_rts(ic, wh->i_addr1, wh->i_addr2, dur);
115502ac6454SAndrew Thompson 	} else {
115602ac6454SAndrew Thompson 		mprot = ieee80211_alloc_cts(ic, ni->ni_vap->iv_myaddr, dur);
115702ac6454SAndrew Thompson 	}
115802ac6454SAndrew Thompson 	if (mprot == NULL) {
115902ac6454SAndrew Thompson 		/* XXX stat + msg */
116002ac6454SAndrew Thompson 		return ENOBUFS;
116102ac6454SAndrew Thompson 	}
116202ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
116302ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
116402ac6454SAndrew Thompson 	sc->tx_nfree--;
116502ac6454SAndrew Thompson 
116602ac6454SAndrew Thompson 	data->m = mprot;
116702ac6454SAndrew Thompson 	data->ni = ieee80211_ref_node(ni);
116802ac6454SAndrew Thompson 	data->rate = protrate;
116902ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, mprot->m_pkthdr.len, protrate);
117002ac6454SAndrew Thompson 
117102ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1172a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
117302ac6454SAndrew Thompson 
117402ac6454SAndrew Thompson 	return 0;
117502ac6454SAndrew Thompson }
117602ac6454SAndrew Thompson 
117702ac6454SAndrew Thompson static int
117802ac6454SAndrew Thompson ural_tx_raw(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
117902ac6454SAndrew Thompson     const struct ieee80211_bpf_params *params)
118002ac6454SAndrew Thompson {
1181515db61dSSam Leffler 	struct ieee80211com *ic = ni->ni_ic;
118202ac6454SAndrew Thompson 	struct ural_tx_data *data;
118302ac6454SAndrew Thompson 	uint32_t flags;
118402ac6454SAndrew Thompson 	int error;
118502ac6454SAndrew Thompson 	int rate;
118602ac6454SAndrew Thompson 
118702ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
118802ac6454SAndrew Thompson 	KASSERT(params != NULL, ("no raw xmit params"));
118902ac6454SAndrew Thompson 
1190515db61dSSam Leffler 	rate = params->ibp_rate0;
1191515db61dSSam Leffler 	if (!ieee80211_isratevalid(ic->ic_rt, rate)) {
119202ac6454SAndrew Thompson 		m_freem(m0);
119302ac6454SAndrew Thompson 		return EINVAL;
119402ac6454SAndrew Thompson 	}
119502ac6454SAndrew Thompson 	flags = 0;
119602ac6454SAndrew Thompson 	if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
119702ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
119802ac6454SAndrew Thompson 	if (params->ibp_flags & (IEEE80211_BPF_RTS|IEEE80211_BPF_CTS)) {
119902ac6454SAndrew Thompson 		error = ural_sendprot(sc, m0, ni,
120002ac6454SAndrew Thompson 		    params->ibp_flags & IEEE80211_BPF_RTS ?
120102ac6454SAndrew Thompson 			 IEEE80211_PROT_RTSCTS : IEEE80211_PROT_CTSONLY,
120202ac6454SAndrew Thompson 		    rate);
120396ca458fSAndrew Thompson 		if (error || sc->tx_nfree == 0) {
120402ac6454SAndrew Thompson 			m_freem(m0);
120596ca458fSAndrew Thompson 			return ENOBUFS;
120602ac6454SAndrew Thompson 		}
120702ac6454SAndrew Thompson 		flags |= RAL_TX_IFS_SIFS;
120802ac6454SAndrew Thompson 	}
120902ac6454SAndrew Thompson 
121096ca458fSAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
121196ca458fSAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
121296ca458fSAndrew Thompson 	sc->tx_nfree--;
121396ca458fSAndrew Thompson 
121402ac6454SAndrew Thompson 	data->m = m0;
121502ac6454SAndrew Thompson 	data->ni = ni;
121602ac6454SAndrew Thompson 	data->rate = rate;
121702ac6454SAndrew Thompson 
121802ac6454SAndrew Thompson 	/* XXX need to setup descriptor ourself */
121902ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
122002ac6454SAndrew Thompson 
122102ac6454SAndrew Thompson 	DPRINTFN(10, "sending raw frame len=%u rate=%u\n",
122202ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
122302ac6454SAndrew Thompson 
122402ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1225a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
122602ac6454SAndrew Thompson 
122702ac6454SAndrew Thompson 	return 0;
122802ac6454SAndrew Thompson }
122902ac6454SAndrew Thompson 
123002ac6454SAndrew Thompson static int
123102ac6454SAndrew Thompson ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
123202ac6454SAndrew Thompson {
123302ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
123402ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
123502ac6454SAndrew Thompson 	struct ural_tx_data *data;
123602ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
123702ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
123802ac6454SAndrew Thompson 	struct ieee80211_key *k;
123902ac6454SAndrew Thompson 	uint32_t flags = 0;
124002ac6454SAndrew Thompson 	uint16_t dur;
124102ac6454SAndrew Thompson 	int error, rate;
124202ac6454SAndrew Thompson 
124302ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
124402ac6454SAndrew Thompson 
124502ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
124602ac6454SAndrew Thompson 
124702ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)];
124802ac6454SAndrew Thompson 	if (IEEE80211_IS_MULTICAST(wh->i_addr1))
124902ac6454SAndrew Thompson 		rate = tp->mcastrate;
125002ac6454SAndrew Thompson 	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
125102ac6454SAndrew Thompson 		rate = tp->ucastrate;
125202ac6454SAndrew Thompson 	else
125302ac6454SAndrew Thompson 		rate = ni->ni_txrate;
125402ac6454SAndrew Thompson 
12555945b5f5SKevin Lo 	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
125602ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
125702ac6454SAndrew Thompson 		if (k == NULL) {
125802ac6454SAndrew Thompson 			m_freem(m0);
125902ac6454SAndrew Thompson 			return ENOBUFS;
126002ac6454SAndrew Thompson 		}
126102ac6454SAndrew Thompson 		/* packet header may have moved, reset our local pointer */
126202ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
126302ac6454SAndrew Thompson 	}
126402ac6454SAndrew Thompson 
126502ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
126602ac6454SAndrew Thompson 		int prot = IEEE80211_PROT_NONE;
126702ac6454SAndrew Thompson 		if (m0->m_pkthdr.len + IEEE80211_CRC_LEN > vap->iv_rtsthreshold)
126802ac6454SAndrew Thompson 			prot = IEEE80211_PROT_RTSCTS;
126902ac6454SAndrew Thompson 		else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
127026d39e2cSSam Leffler 		    ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM)
127102ac6454SAndrew Thompson 			prot = ic->ic_protmode;
127202ac6454SAndrew Thompson 		if (prot != IEEE80211_PROT_NONE) {
127302ac6454SAndrew Thompson 			error = ural_sendprot(sc, m0, ni, prot, rate);
127496ca458fSAndrew Thompson 			if (error || sc->tx_nfree == 0) {
127502ac6454SAndrew Thompson 				m_freem(m0);
127696ca458fSAndrew Thompson 				return ENOBUFS;
127702ac6454SAndrew Thompson 			}
127802ac6454SAndrew Thompson 			flags |= RAL_TX_IFS_SIFS;
127902ac6454SAndrew Thompson 		}
128002ac6454SAndrew Thompson 	}
128102ac6454SAndrew Thompson 
128202ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
128302ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
128402ac6454SAndrew Thompson 	sc->tx_nfree--;
128502ac6454SAndrew Thompson 
128602ac6454SAndrew Thompson 	data->m = m0;
128702ac6454SAndrew Thompson 	data->ni = ni;
128802ac6454SAndrew Thompson 	data->rate = rate;
128902ac6454SAndrew Thompson 
129002ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
129102ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
129202ac6454SAndrew Thompson 		flags |= RAL_TX_RETRY(7);
129302ac6454SAndrew Thompson 
129426d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, rate,
129502ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
12968cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
129702ac6454SAndrew Thompson 	}
129802ac6454SAndrew Thompson 
129902ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
130002ac6454SAndrew Thompson 
130102ac6454SAndrew Thompson 	DPRINTFN(10, "sending data frame len=%u rate=%u\n",
130202ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
130302ac6454SAndrew Thompson 
130402ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1305a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
130602ac6454SAndrew Thompson 
130702ac6454SAndrew Thompson 	return 0;
130802ac6454SAndrew Thompson }
130902ac6454SAndrew Thompson 
13107a79cebfSGleb Smirnoff static int
13117a79cebfSGleb Smirnoff ural_transmit(struct ieee80211com *ic, struct mbuf *m)
131279d2c5e8SGleb Smirnoff {
13137a79cebfSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
13147a79cebfSGleb Smirnoff 	int error;
13157a79cebfSGleb Smirnoff 
13167a79cebfSGleb Smirnoff 	RAL_LOCK(sc);
13177a79cebfSGleb Smirnoff 	if (!sc->sc_running) {
13187a79cebfSGleb Smirnoff 		RAL_UNLOCK(sc);
13197a79cebfSGleb Smirnoff 		return (ENXIO);
13207a79cebfSGleb Smirnoff 	}
13217a79cebfSGleb Smirnoff 	error = mbufq_enqueue(&sc->sc_snd, m);
13227a79cebfSGleb Smirnoff 	if (error) {
13237a79cebfSGleb Smirnoff 		RAL_UNLOCK(sc);
13247a79cebfSGleb Smirnoff 		return (error);
13257a79cebfSGleb Smirnoff 	}
13267a79cebfSGleb Smirnoff 	ural_start(sc);
13277a79cebfSGleb Smirnoff 	RAL_UNLOCK(sc);
13287a79cebfSGleb Smirnoff 
13297a79cebfSGleb Smirnoff 	return (0);
13307a79cebfSGleb Smirnoff }
13317a79cebfSGleb Smirnoff 
13327a79cebfSGleb Smirnoff static void
13337a79cebfSGleb Smirnoff ural_start(struct ural_softc *sc)
13347a79cebfSGleb Smirnoff {
133502ac6454SAndrew Thompson 	struct ieee80211_node *ni;
133602ac6454SAndrew Thompson 	struct mbuf *m;
133702ac6454SAndrew Thompson 
13387a79cebfSGleb Smirnoff 	RAL_LOCK_ASSERT(sc, MA_OWNED);
13397a79cebfSGleb Smirnoff 
13407a79cebfSGleb Smirnoff 	if (sc->sc_running == 0)
134102ac6454SAndrew Thompson 		return;
13427a79cebfSGleb Smirnoff 
13437a79cebfSGleb Smirnoff 	while (sc->tx_nfree >= RAL_TX_MINFREE &&
13447a79cebfSGleb Smirnoff 	    (m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
134502ac6454SAndrew Thompson 		ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
134602ac6454SAndrew Thompson 		if (ural_tx_data(sc, m, ni) != 0) {
13477a79cebfSGleb Smirnoff 			if_inc_counter(ni->ni_vap->iv_ifp,
13487a79cebfSGleb Smirnoff 			     IFCOUNTER_OERRORS, 1);
134902ac6454SAndrew Thompson 			ieee80211_free_node(ni);
135002ac6454SAndrew Thompson 			break;
135102ac6454SAndrew Thompson 		}
135202ac6454SAndrew Thompson 	}
135302ac6454SAndrew Thompson }
135402ac6454SAndrew Thompson 
13557a79cebfSGleb Smirnoff static void
13567a79cebfSGleb Smirnoff ural_parent(struct ieee80211com *ic)
135702ac6454SAndrew Thompson {
13587a79cebfSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
1359645e4d17SHans Petter Selasky 	int startall = 0;
1360645e4d17SHans Petter Selasky 
1361645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
13627a79cebfSGleb Smirnoff 	if (sc->sc_detached) {
1363645e4d17SHans Petter Selasky 		RAL_UNLOCK(sc);
13647a79cebfSGleb Smirnoff 		return;
13657a79cebfSGleb Smirnoff 	}
13667a79cebfSGleb Smirnoff 	if (ic->ic_nrunning > 0) {
13677a79cebfSGleb Smirnoff 		if (sc->sc_running == 0) {
13687a79cebfSGleb Smirnoff 			ural_init(sc);
136902ac6454SAndrew Thompson 			startall = 1;
137002ac6454SAndrew Thompson 		} else
13715efea30fSAndrew Thompson 			ural_setpromisc(sc);
13727a79cebfSGleb Smirnoff 	} else if (sc->sc_running)
13735efea30fSAndrew Thompson 		ural_stop(sc);
137402ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
137502ac6454SAndrew Thompson 	if (startall)
137602ac6454SAndrew Thompson 		ieee80211_start_all(ic);
137702ac6454SAndrew Thompson }
137802ac6454SAndrew Thompson 
137902ac6454SAndrew Thompson static void
138002ac6454SAndrew Thompson ural_set_testmode(struct ural_softc *sc)
138102ac6454SAndrew Thompson {
1382760bc48eSAndrew Thompson 	struct usb_device_request req;
1383e0a69b51SAndrew Thompson 	usb_error_t error;
138402ac6454SAndrew Thompson 
138502ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
138602ac6454SAndrew Thompson 	req.bRequest = RAL_VENDOR_REQUEST;
138702ac6454SAndrew Thompson 	USETW(req.wValue, 4);
138802ac6454SAndrew Thompson 	USETW(req.wIndex, 1);
138902ac6454SAndrew Thompson 	USETW(req.wLength, 0);
139002ac6454SAndrew Thompson 
139102ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
139202ac6454SAndrew Thompson 	if (error != 0) {
139302ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not set test mode: %s\n",
1394a593f6b8SAndrew Thompson 		    usbd_errstr(error));
139502ac6454SAndrew Thompson 	}
139602ac6454SAndrew Thompson }
139702ac6454SAndrew Thompson 
139802ac6454SAndrew Thompson static void
139902ac6454SAndrew Thompson ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)
140002ac6454SAndrew Thompson {
1401760bc48eSAndrew Thompson 	struct usb_device_request req;
1402e0a69b51SAndrew Thompson 	usb_error_t error;
140302ac6454SAndrew Thompson 
140402ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
140502ac6454SAndrew Thompson 	req.bRequest = RAL_READ_EEPROM;
140602ac6454SAndrew Thompson 	USETW(req.wValue, 0);
140702ac6454SAndrew Thompson 	USETW(req.wIndex, addr);
140802ac6454SAndrew Thompson 	USETW(req.wLength, len);
140902ac6454SAndrew Thompson 
141002ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
141102ac6454SAndrew Thompson 	if (error != 0) {
141202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1413a593f6b8SAndrew Thompson 		    usbd_errstr(error));
141402ac6454SAndrew Thompson 	}
141502ac6454SAndrew Thompson }
141602ac6454SAndrew Thompson 
141702ac6454SAndrew Thompson static uint16_t
141802ac6454SAndrew Thompson ural_read(struct ural_softc *sc, uint16_t reg)
141902ac6454SAndrew Thompson {
1420760bc48eSAndrew Thompson 	struct usb_device_request req;
1421e0a69b51SAndrew Thompson 	usb_error_t error;
142202ac6454SAndrew Thompson 	uint16_t val;
142302ac6454SAndrew Thompson 
142402ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
142502ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MAC;
142602ac6454SAndrew Thompson 	USETW(req.wValue, 0);
142702ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
142802ac6454SAndrew Thompson 	USETW(req.wLength, sizeof (uint16_t));
142902ac6454SAndrew Thompson 
143002ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, &val);
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 		return 0;
143502ac6454SAndrew Thompson 	}
143602ac6454SAndrew Thompson 
143702ac6454SAndrew Thompson 	return le16toh(val);
143802ac6454SAndrew Thompson }
143902ac6454SAndrew Thompson 
144002ac6454SAndrew Thompson static void
144102ac6454SAndrew Thompson ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
144202ac6454SAndrew Thompson {
1443760bc48eSAndrew Thompson 	struct usb_device_request req;
1444e0a69b51SAndrew Thompson 	usb_error_t error;
144502ac6454SAndrew Thompson 
144602ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
144702ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MULTI_MAC;
144802ac6454SAndrew Thompson 	USETW(req.wValue, 0);
144902ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
145002ac6454SAndrew Thompson 	USETW(req.wLength, len);
145102ac6454SAndrew Thompson 
145202ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
145302ac6454SAndrew Thompson 	if (error != 0) {
145402ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1455a593f6b8SAndrew Thompson 		    usbd_errstr(error));
145602ac6454SAndrew Thompson 	}
145702ac6454SAndrew Thompson }
145802ac6454SAndrew Thompson 
145902ac6454SAndrew Thompson static void
146002ac6454SAndrew Thompson ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)
146102ac6454SAndrew Thompson {
1462760bc48eSAndrew Thompson 	struct usb_device_request req;
1463e0a69b51SAndrew Thompson 	usb_error_t error;
146402ac6454SAndrew Thompson 
146502ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
146602ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MAC;
146702ac6454SAndrew Thompson 	USETW(req.wValue, val);
146802ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
146902ac6454SAndrew Thompson 	USETW(req.wLength, 0);
147002ac6454SAndrew Thompson 
147102ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
147202ac6454SAndrew Thompson 	if (error != 0) {
147302ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1474a593f6b8SAndrew Thompson 		    usbd_errstr(error));
147502ac6454SAndrew Thompson 	}
147602ac6454SAndrew Thompson }
147702ac6454SAndrew Thompson 
147802ac6454SAndrew Thompson static void
147902ac6454SAndrew Thompson ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
148002ac6454SAndrew Thompson {
1481760bc48eSAndrew Thompson 	struct usb_device_request req;
1482e0a69b51SAndrew Thompson 	usb_error_t error;
148302ac6454SAndrew Thompson 
148402ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
148502ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MULTI_MAC;
148602ac6454SAndrew Thompson 	USETW(req.wValue, 0);
148702ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
148802ac6454SAndrew Thompson 	USETW(req.wLength, len);
148902ac6454SAndrew Thompson 
149002ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
149102ac6454SAndrew Thompson 	if (error != 0) {
149202ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1493a593f6b8SAndrew Thompson 		    usbd_errstr(error));
149402ac6454SAndrew Thompson 	}
149502ac6454SAndrew Thompson }
149602ac6454SAndrew Thompson 
149702ac6454SAndrew Thompson static void
149802ac6454SAndrew Thompson ural_bbp_write(struct ural_softc *sc, uint8_t reg, uint8_t val)
149902ac6454SAndrew Thompson {
150002ac6454SAndrew Thompson 	uint16_t tmp;
150102ac6454SAndrew Thompson 	int ntries;
150202ac6454SAndrew Thompson 
150302ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
150402ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
150502ac6454SAndrew Thompson 			break;
150602ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
150702ac6454SAndrew Thompson 			break;
150802ac6454SAndrew Thompson 	}
150902ac6454SAndrew Thompson 	if (ntries == 100) {
151002ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to BBP\n");
151102ac6454SAndrew Thompson 		return;
151202ac6454SAndrew Thompson 	}
151302ac6454SAndrew Thompson 
151402ac6454SAndrew Thompson 	tmp = reg << 8 | val;
151502ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, tmp);
151602ac6454SAndrew Thompson }
151702ac6454SAndrew Thompson 
151802ac6454SAndrew Thompson static uint8_t
151902ac6454SAndrew Thompson ural_bbp_read(struct ural_softc *sc, uint8_t reg)
152002ac6454SAndrew Thompson {
152102ac6454SAndrew Thompson 	uint16_t val;
152202ac6454SAndrew Thompson 	int ntries;
152302ac6454SAndrew Thompson 
152402ac6454SAndrew Thompson 	val = RAL_BBP_WRITE | reg << 8;
152502ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, val);
152602ac6454SAndrew Thompson 
152702ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
152802ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
152902ac6454SAndrew Thompson 			break;
153002ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
153102ac6454SAndrew Thompson 			break;
153202ac6454SAndrew Thompson 	}
153302ac6454SAndrew Thompson 	if (ntries == 100) {
153402ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read BBP\n");
153502ac6454SAndrew Thompson 		return 0;
153602ac6454SAndrew Thompson 	}
153702ac6454SAndrew Thompson 
153802ac6454SAndrew Thompson 	return ural_read(sc, RAL_PHY_CSR7) & 0xff;
153902ac6454SAndrew Thompson }
154002ac6454SAndrew Thompson 
154102ac6454SAndrew Thompson static void
154202ac6454SAndrew Thompson ural_rf_write(struct ural_softc *sc, uint8_t reg, uint32_t val)
154302ac6454SAndrew Thompson {
154402ac6454SAndrew Thompson 	uint32_t tmp;
154502ac6454SAndrew Thompson 	int ntries;
154602ac6454SAndrew Thompson 
154702ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
154802ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR10) & RAL_RF_LOBUSY))
154902ac6454SAndrew Thompson 			break;
155002ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
155102ac6454SAndrew Thompson 			break;
155202ac6454SAndrew Thompson 	}
155302ac6454SAndrew Thompson 	if (ntries == 100) {
155402ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to RF\n");
155502ac6454SAndrew Thompson 		return;
155602ac6454SAndrew Thompson 	}
155702ac6454SAndrew Thompson 
155802ac6454SAndrew Thompson 	tmp = RAL_RF_BUSY | RAL_RF_20BIT | (val & 0xfffff) << 2 | (reg & 0x3);
155902ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR9,  tmp & 0xffff);
156002ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR10, tmp >> 16);
156102ac6454SAndrew Thompson 
156202ac6454SAndrew Thompson 	/* remember last written value in sc */
156302ac6454SAndrew Thompson 	sc->rf_regs[reg] = val;
156402ac6454SAndrew Thompson 
156502ac6454SAndrew Thompson 	DPRINTFN(15, "RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff);
156602ac6454SAndrew Thompson }
156702ac6454SAndrew Thompson 
156802ac6454SAndrew Thompson static void
156902ac6454SAndrew Thompson ural_scan_start(struct ieee80211com *ic)
157002ac6454SAndrew Thompson {
1571d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
157202ac6454SAndrew Thompson 
157302ac6454SAndrew Thompson 	RAL_LOCK(sc);
15745efea30fSAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
15757a79cebfSGleb Smirnoff 	ural_set_bssid(sc, ieee80211broadcastaddr);
157602ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
157702ac6454SAndrew Thompson }
157802ac6454SAndrew Thompson 
157902ac6454SAndrew Thompson static void
158002ac6454SAndrew Thompson ural_scan_end(struct ieee80211com *ic)
158102ac6454SAndrew Thompson {
1582d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
158302ac6454SAndrew Thompson 
158402ac6454SAndrew Thompson 	RAL_LOCK(sc);
15855efea30fSAndrew Thompson 	ural_enable_tsf_sync(sc);
15867a79cebfSGleb Smirnoff 	ural_set_bssid(sc, ic->ic_macaddr);
158702ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
158802ac6454SAndrew Thompson 
158902ac6454SAndrew Thompson }
159002ac6454SAndrew Thompson 
159102ac6454SAndrew Thompson static void
159202ac6454SAndrew Thompson ural_set_channel(struct ieee80211com *ic)
159302ac6454SAndrew Thompson {
1594d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
159502ac6454SAndrew Thompson 
159602ac6454SAndrew Thompson 	RAL_LOCK(sc);
15975efea30fSAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
159802ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
159902ac6454SAndrew Thompson }
160002ac6454SAndrew Thompson 
160102ac6454SAndrew Thompson static void
160202ac6454SAndrew Thompson ural_set_chan(struct ural_softc *sc, struct ieee80211_channel *c)
160302ac6454SAndrew Thompson {
16047a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
160502ac6454SAndrew Thompson 	uint8_t power, tmp;
160602ac6454SAndrew Thompson 	int i, chan;
160702ac6454SAndrew Thompson 
160802ac6454SAndrew Thompson 	chan = ieee80211_chan2ieee(ic, c);
160902ac6454SAndrew Thompson 	if (chan == 0 || chan == IEEE80211_CHAN_ANY)
161002ac6454SAndrew Thompson 		return;
161102ac6454SAndrew Thompson 
161202ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_2GHZ(c))
161302ac6454SAndrew Thompson 		power = min(sc->txpow[chan - 1], 31);
161402ac6454SAndrew Thompson 	else
161502ac6454SAndrew Thompson 		power = 31;
161602ac6454SAndrew Thompson 
161702ac6454SAndrew Thompson 	/* adjust txpower using ifconfig settings */
161802ac6454SAndrew Thompson 	power -= (100 - ic->ic_txpowlimit) / 8;
161902ac6454SAndrew Thompson 
162002ac6454SAndrew Thompson 	DPRINTFN(2, "setting channel to %u, txpower to %u\n", chan, power);
162102ac6454SAndrew Thompson 
162202ac6454SAndrew Thompson 	switch (sc->rf_rev) {
162302ac6454SAndrew Thompson 	case RAL_RF_2522:
162402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x00814);
162502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2522_r2[chan - 1]);
162602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
162702ac6454SAndrew Thompson 		break;
162802ac6454SAndrew Thompson 
162902ac6454SAndrew Thompson 	case RAL_RF_2523:
163002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
163102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2523_r2[chan - 1]);
163202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
163302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
163402ac6454SAndrew Thompson 		break;
163502ac6454SAndrew Thompson 
163602ac6454SAndrew Thompson 	case RAL_RF_2524:
163702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x0c808);
163802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2524_r2[chan - 1]);
163902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
164002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
164102ac6454SAndrew Thompson 		break;
164202ac6454SAndrew Thompson 
164302ac6454SAndrew Thompson 	case RAL_RF_2525:
164402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
164502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_hi_r2[chan - 1]);
164602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
164702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
164802ac6454SAndrew Thompson 
164902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
165002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_r2[chan - 1]);
165102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
165202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
165302ac6454SAndrew Thompson 		break;
165402ac6454SAndrew Thompson 
165502ac6454SAndrew Thompson 	case RAL_RF_2525E:
165602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
165702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525e_r2[chan - 1]);
165802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
165902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
166002ac6454SAndrew Thompson 		break;
166102ac6454SAndrew Thompson 
166202ac6454SAndrew Thompson 	case RAL_RF_2526:
166302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_hi_r2[chan - 1]);
166402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
166502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
166602ac6454SAndrew Thompson 
166702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_r2[chan - 1]);
166802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
166902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
167002ac6454SAndrew Thompson 		break;
167102ac6454SAndrew Thompson 
167202ac6454SAndrew Thompson 	/* dual-band RF */
167302ac6454SAndrew Thompson 	case RAL_RF_5222:
167402ac6454SAndrew Thompson 		for (i = 0; ural_rf5222[i].chan != chan; i++);
167502ac6454SAndrew Thompson 
167602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, ural_rf5222[i].r1);
167702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf5222[i].r2);
167802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
167902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, ural_rf5222[i].r4);
168002ac6454SAndrew Thompson 		break;
168102ac6454SAndrew Thompson 	}
168202ac6454SAndrew Thompson 
168302ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR &&
168402ac6454SAndrew Thompson 	    (ic->ic_flags & IEEE80211_F_SCAN) == 0) {
168502ac6454SAndrew Thompson 		/* set Japan filter bit for channel 14 */
168602ac6454SAndrew Thompson 		tmp = ural_bbp_read(sc, 70);
168702ac6454SAndrew Thompson 
168802ac6454SAndrew Thompson 		tmp &= ~RAL_JAPAN_FILTER;
168902ac6454SAndrew Thompson 		if (chan == 14)
169002ac6454SAndrew Thompson 			tmp |= RAL_JAPAN_FILTER;
169102ac6454SAndrew Thompson 
169202ac6454SAndrew Thompson 		ural_bbp_write(sc, 70, tmp);
169302ac6454SAndrew Thompson 
169402ac6454SAndrew Thompson 		/* clear CRC errors */
169502ac6454SAndrew Thompson 		ural_read(sc, RAL_STA_CSR0);
169602ac6454SAndrew Thompson 
169702ac6454SAndrew Thompson 		ural_pause(sc, hz / 100);
169802ac6454SAndrew Thompson 		ural_disable_rf_tune(sc);
169902ac6454SAndrew Thompson 	}
170002ac6454SAndrew Thompson 
170102ac6454SAndrew Thompson 	/* XXX doesn't belong here */
170202ac6454SAndrew Thompson 	/* update basic rate set */
170302ac6454SAndrew Thompson 	ural_set_basicrates(sc, c);
170477ddf3d3SAndrew Thompson 
170577ddf3d3SAndrew Thompson 	/* give the hardware some time to do the switchover */
170677ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 100);
170702ac6454SAndrew Thompson }
170802ac6454SAndrew Thompson 
170902ac6454SAndrew Thompson /*
171002ac6454SAndrew Thompson  * Disable RF auto-tuning.
171102ac6454SAndrew Thompson  */
171202ac6454SAndrew Thompson static void
171302ac6454SAndrew Thompson ural_disable_rf_tune(struct ural_softc *sc)
171402ac6454SAndrew Thompson {
171502ac6454SAndrew Thompson 	uint32_t tmp;
171602ac6454SAndrew Thompson 
171702ac6454SAndrew Thompson 	if (sc->rf_rev != RAL_RF_2523) {
171802ac6454SAndrew Thompson 		tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
171902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, tmp);
172002ac6454SAndrew Thompson 	}
172102ac6454SAndrew Thompson 
172202ac6454SAndrew Thompson 	tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
172302ac6454SAndrew Thompson 	ural_rf_write(sc, RAL_RF3, tmp);
172402ac6454SAndrew Thompson 
172502ac6454SAndrew Thompson 	DPRINTFN(2, "disabling RF autotune\n");
172602ac6454SAndrew Thompson }
172702ac6454SAndrew Thompson 
172802ac6454SAndrew Thompson /*
172902ac6454SAndrew Thompson  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
173002ac6454SAndrew Thompson  * synchronization.
173102ac6454SAndrew Thompson  */
173202ac6454SAndrew Thompson static void
173302ac6454SAndrew Thompson ural_enable_tsf_sync(struct ural_softc *sc)
173402ac6454SAndrew Thompson {
17357a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
173602ac6454SAndrew Thompson 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
173702ac6454SAndrew Thompson 	uint16_t logcwmin, preload, tmp;
173802ac6454SAndrew Thompson 
173902ac6454SAndrew Thompson 	/* first, disable TSF synchronization */
174002ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
174102ac6454SAndrew Thompson 
174202ac6454SAndrew Thompson 	tmp = (16 * vap->iv_bss->ni_intval) << 4;
174302ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR18, tmp);
174402ac6454SAndrew Thompson 
174502ac6454SAndrew Thompson 	logcwmin = (ic->ic_opmode == IEEE80211_M_IBSS) ? 2 : 0;
174602ac6454SAndrew Thompson 	preload = (ic->ic_opmode == IEEE80211_M_IBSS) ? 320 : 6;
174702ac6454SAndrew Thompson 	tmp = logcwmin << 12 | preload;
174802ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR20, tmp);
174902ac6454SAndrew Thompson 
175002ac6454SAndrew Thompson 	/* finally, enable TSF synchronization */
175102ac6454SAndrew Thompson 	tmp = RAL_ENABLE_TSF | RAL_ENABLE_TBCN;
175202ac6454SAndrew Thompson 	if (ic->ic_opmode == IEEE80211_M_STA)
175302ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(1);
175402ac6454SAndrew Thompson 	else
175502ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(2) | RAL_ENABLE_BEACON_GENERATOR;
175602ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, tmp);
175702ac6454SAndrew Thompson 
175802ac6454SAndrew Thompson 	DPRINTF("enabling TSF synchronization\n");
175902ac6454SAndrew Thompson }
176002ac6454SAndrew Thompson 
17615463c4a4SSam Leffler static void
17625463c4a4SSam Leffler ural_enable_tsf(struct ural_softc *sc)
17635463c4a4SSam Leffler {
17645463c4a4SSam Leffler 	/* first, disable TSF synchronization */
17655463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, 0);
17665463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, RAL_ENABLE_TSF | RAL_ENABLE_TSF_SYNC(2));
17675463c4a4SSam Leffler }
17685463c4a4SSam Leffler 
176902ac6454SAndrew Thompson #define RAL_RXTX_TURNAROUND	5	/* us */
177002ac6454SAndrew Thompson static void
17717a79cebfSGleb Smirnoff ural_update_slot(struct ural_softc *sc)
177202ac6454SAndrew Thompson {
17737a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
177402ac6454SAndrew Thompson 	uint16_t slottime, sifs, eifs;
177502ac6454SAndrew Thompson 
177602ac6454SAndrew Thompson 	slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
177702ac6454SAndrew Thompson 
177802ac6454SAndrew Thompson 	/*
177902ac6454SAndrew Thompson 	 * These settings may sound a bit inconsistent but this is what the
178002ac6454SAndrew Thompson 	 * reference driver does.
178102ac6454SAndrew Thompson 	 */
178202ac6454SAndrew Thompson 	if (ic->ic_curmode == IEEE80211_MODE_11B) {
178302ac6454SAndrew Thompson 		sifs = 16 - RAL_RXTX_TURNAROUND;
178402ac6454SAndrew Thompson 		eifs = 364;
178502ac6454SAndrew Thompson 	} else {
178602ac6454SAndrew Thompson 		sifs = 10 - RAL_RXTX_TURNAROUND;
178702ac6454SAndrew Thompson 		eifs = 64;
178802ac6454SAndrew Thompson 	}
178902ac6454SAndrew Thompson 
179002ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR10, slottime);
179102ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR11, sifs);
179202ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR12, eifs);
179302ac6454SAndrew Thompson }
179402ac6454SAndrew Thompson 
179502ac6454SAndrew Thompson static void
179602ac6454SAndrew Thompson ural_set_txpreamble(struct ural_softc *sc)
179702ac6454SAndrew Thompson {
17987a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
179902ac6454SAndrew Thompson 	uint16_t tmp;
180002ac6454SAndrew Thompson 
180102ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR10);
180202ac6454SAndrew Thompson 
180302ac6454SAndrew Thompson 	tmp &= ~RAL_SHORT_PREAMBLE;
180402ac6454SAndrew Thompson 	if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
180502ac6454SAndrew Thompson 		tmp |= RAL_SHORT_PREAMBLE;
180602ac6454SAndrew Thompson 
180702ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR10, tmp);
180802ac6454SAndrew Thompson }
180902ac6454SAndrew Thompson 
181002ac6454SAndrew Thompson static void
181102ac6454SAndrew Thompson ural_set_basicrates(struct ural_softc *sc, const struct ieee80211_channel *c)
181202ac6454SAndrew Thompson {
181302ac6454SAndrew Thompson 	/* XXX wrong, take from rate set */
181402ac6454SAndrew Thompson 	/* update basic rate set */
181502ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_5GHZ(c)) {
181602ac6454SAndrew Thompson 		/* 11a basic rates: 6, 12, 24Mbps */
181702ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x150);
181802ac6454SAndrew Thompson 	} else if (IEEE80211_IS_CHAN_ANYG(c)) {
181902ac6454SAndrew Thompson 		/* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
182002ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x15f);
182102ac6454SAndrew Thompson 	} else {
182202ac6454SAndrew Thompson 		/* 11b basic rates: 1, 2Mbps */
182302ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x3);
182402ac6454SAndrew Thompson 	}
182502ac6454SAndrew Thompson }
182602ac6454SAndrew Thompson 
182702ac6454SAndrew Thompson static void
182802ac6454SAndrew Thompson ural_set_bssid(struct ural_softc *sc, const uint8_t *bssid)
182902ac6454SAndrew Thompson {
183002ac6454SAndrew Thompson 	uint16_t tmp;
183102ac6454SAndrew Thompson 
183202ac6454SAndrew Thompson 	tmp = bssid[0] | bssid[1] << 8;
183302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR5, tmp);
183402ac6454SAndrew Thompson 
183502ac6454SAndrew Thompson 	tmp = bssid[2] | bssid[3] << 8;
183602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR6, tmp);
183702ac6454SAndrew Thompson 
183802ac6454SAndrew Thompson 	tmp = bssid[4] | bssid[5] << 8;
183902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR7, tmp);
184002ac6454SAndrew Thompson 
184102ac6454SAndrew Thompson 	DPRINTF("setting BSSID to %6D\n", bssid, ":");
184202ac6454SAndrew Thompson }
184302ac6454SAndrew Thompson 
184402ac6454SAndrew Thompson static void
18457a79cebfSGleb Smirnoff ural_set_macaddr(struct ural_softc *sc, const uint8_t *addr)
184602ac6454SAndrew Thompson {
184702ac6454SAndrew Thompson 	uint16_t tmp;
184802ac6454SAndrew Thompson 
184902ac6454SAndrew Thompson 	tmp = addr[0] | addr[1] << 8;
185002ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR2, tmp);
185102ac6454SAndrew Thompson 
185202ac6454SAndrew Thompson 	tmp = addr[2] | addr[3] << 8;
185302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR3, tmp);
185402ac6454SAndrew Thompson 
185502ac6454SAndrew Thompson 	tmp = addr[4] | addr[5] << 8;
185602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR4, tmp);
185702ac6454SAndrew Thompson 
185802ac6454SAndrew Thompson 	DPRINTF("setting MAC address to %6D\n", addr, ":");
185902ac6454SAndrew Thompson }
186002ac6454SAndrew Thompson 
186102ac6454SAndrew Thompson static void
18625efea30fSAndrew Thompson ural_setpromisc(struct ural_softc *sc)
186302ac6454SAndrew Thompson {
186402ac6454SAndrew Thompson 	uint32_t tmp;
186502ac6454SAndrew Thompson 
186602ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR2);
186702ac6454SAndrew Thompson 
186802ac6454SAndrew Thompson 	tmp &= ~RAL_DROP_NOT_TO_ME;
18697a79cebfSGleb Smirnoff 	if (sc->sc_ic.ic_promisc == 0)
187002ac6454SAndrew Thompson 		tmp |= RAL_DROP_NOT_TO_ME;
187102ac6454SAndrew Thompson 
187202ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
187302ac6454SAndrew Thompson 
18747a79cebfSGleb Smirnoff 	DPRINTF("%s promiscuous mode\n", sc->sc_ic.ic_promisc ?
187502ac6454SAndrew Thompson 	    "entering" : "leaving");
187602ac6454SAndrew Thompson }
187702ac6454SAndrew Thompson 
187877ddf3d3SAndrew Thompson static void
1879272f6adeSGleb Smirnoff ural_update_promisc(struct ieee80211com *ic)
188077ddf3d3SAndrew Thompson {
1881272f6adeSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
188277ddf3d3SAndrew Thompson 
188377ddf3d3SAndrew Thompson 	RAL_LOCK(sc);
18847a79cebfSGleb Smirnoff 	if (sc->sc_running)
18855efea30fSAndrew Thompson 		ural_setpromisc(sc);
188677ddf3d3SAndrew Thompson 	RAL_UNLOCK(sc);
188777ddf3d3SAndrew Thompson }
188877ddf3d3SAndrew Thompson 
188902ac6454SAndrew Thompson static const char *
189002ac6454SAndrew Thompson ural_get_rf(int rev)
189102ac6454SAndrew Thompson {
189202ac6454SAndrew Thompson 	switch (rev) {
189302ac6454SAndrew Thompson 	case RAL_RF_2522:	return "RT2522";
189402ac6454SAndrew Thompson 	case RAL_RF_2523:	return "RT2523";
189502ac6454SAndrew Thompson 	case RAL_RF_2524:	return "RT2524";
189602ac6454SAndrew Thompson 	case RAL_RF_2525:	return "RT2525";
189702ac6454SAndrew Thompson 	case RAL_RF_2525E:	return "RT2525e";
189802ac6454SAndrew Thompson 	case RAL_RF_2526:	return "RT2526";
189902ac6454SAndrew Thompson 	case RAL_RF_5222:	return "RT5222";
190002ac6454SAndrew Thompson 	default:		return "unknown";
190102ac6454SAndrew Thompson 	}
190202ac6454SAndrew Thompson }
190302ac6454SAndrew Thompson 
190402ac6454SAndrew Thompson static void
190502ac6454SAndrew Thompson ural_read_eeprom(struct ural_softc *sc)
190602ac6454SAndrew Thompson {
19077a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
190802ac6454SAndrew Thompson 	uint16_t val;
190902ac6454SAndrew Thompson 
191002ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_CONFIG0, &val, 2);
191102ac6454SAndrew Thompson 	val = le16toh(val);
191202ac6454SAndrew Thompson 	sc->rf_rev =   (val >> 11) & 0x7;
191302ac6454SAndrew Thompson 	sc->hw_radio = (val >> 10) & 0x1;
191402ac6454SAndrew Thompson 	sc->led_mode = (val >> 6)  & 0x7;
191502ac6454SAndrew Thompson 	sc->rx_ant =   (val >> 4)  & 0x3;
191602ac6454SAndrew Thompson 	sc->tx_ant =   (val >> 2)  & 0x3;
191702ac6454SAndrew Thompson 	sc->nb_ant =   val & 0x3;
191802ac6454SAndrew Thompson 
191902ac6454SAndrew Thompson 	/* read MAC address */
19207a79cebfSGleb Smirnoff 	ural_eeprom_read(sc, RAL_EEPROM_ADDRESS, ic->ic_macaddr, 6);
192102ac6454SAndrew Thompson 
192202ac6454SAndrew Thompson 	/* read default values for BBP registers */
192302ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_BBP_BASE, sc->bbp_prom, 2 * 16);
192402ac6454SAndrew Thompson 
192502ac6454SAndrew Thompson 	/* read Tx power for all b/g channels */
192602ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_TXPOWER, sc->txpow, 14);
192702ac6454SAndrew Thompson }
192802ac6454SAndrew Thompson 
192902ac6454SAndrew Thompson static int
193002ac6454SAndrew Thompson ural_bbp_init(struct ural_softc *sc)
193102ac6454SAndrew Thompson {
19326d917491SHans Petter Selasky #define N(a)	((int)(sizeof (a) / sizeof ((a)[0])))
193302ac6454SAndrew Thompson 	int i, ntries;
193402ac6454SAndrew Thompson 
193502ac6454SAndrew Thompson 	/* wait for BBP to be ready */
193602ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
193702ac6454SAndrew Thompson 		if (ural_bbp_read(sc, RAL_BBP_VERSION) != 0)
193802ac6454SAndrew Thompson 			break;
193902ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
194002ac6454SAndrew Thompson 			break;
194102ac6454SAndrew Thompson 	}
194202ac6454SAndrew Thompson 	if (ntries == 100) {
194302ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "timeout waiting for BBP\n");
194402ac6454SAndrew Thompson 		return EIO;
194502ac6454SAndrew Thompson 	}
194602ac6454SAndrew Thompson 
194702ac6454SAndrew Thompson 	/* initialize BBP registers to default values */
194802ac6454SAndrew Thompson 	for (i = 0; i < N(ural_def_bbp); i++)
194902ac6454SAndrew Thompson 		ural_bbp_write(sc, ural_def_bbp[i].reg, ural_def_bbp[i].val);
195002ac6454SAndrew Thompson 
195102ac6454SAndrew Thompson #if 0
195202ac6454SAndrew Thompson 	/* initialize BBP registers to values stored in EEPROM */
195302ac6454SAndrew Thompson 	for (i = 0; i < 16; i++) {
195402ac6454SAndrew Thompson 		if (sc->bbp_prom[i].reg == 0xff)
195502ac6454SAndrew Thompson 			continue;
195602ac6454SAndrew Thompson 		ural_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
195702ac6454SAndrew Thompson 	}
195802ac6454SAndrew Thompson #endif
195902ac6454SAndrew Thompson 
196002ac6454SAndrew Thompson 	return 0;
196102ac6454SAndrew Thompson #undef N
196202ac6454SAndrew Thompson }
196302ac6454SAndrew Thompson 
196402ac6454SAndrew Thompson static void
196502ac6454SAndrew Thompson ural_set_txantenna(struct ural_softc *sc, int antenna)
196602ac6454SAndrew Thompson {
196702ac6454SAndrew Thompson 	uint16_t tmp;
196802ac6454SAndrew Thompson 	uint8_t tx;
196902ac6454SAndrew Thompson 
197002ac6454SAndrew Thompson 	tx = ural_bbp_read(sc, RAL_BBP_TX) & ~RAL_BBP_ANTMASK;
197102ac6454SAndrew Thompson 	if (antenna == 1)
197202ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTA;
197302ac6454SAndrew Thompson 	else if (antenna == 2)
197402ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTB;
197502ac6454SAndrew Thompson 	else
197602ac6454SAndrew Thompson 		tx |= RAL_BBP_DIVERSITY;
197702ac6454SAndrew Thompson 
197802ac6454SAndrew Thompson 	/* need to force I/Q flip for RF 2525e, 2526 and 5222 */
197902ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526 ||
198002ac6454SAndrew Thompson 	    sc->rf_rev == RAL_RF_5222)
198102ac6454SAndrew Thompson 		tx |= RAL_BBP_FLIPIQ;
198202ac6454SAndrew Thompson 
198302ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_TX, tx);
198402ac6454SAndrew Thompson 
198502ac6454SAndrew Thompson 	/* update values in PHY_CSR5 and PHY_CSR6 */
198602ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR5) & ~0x7;
198702ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR5, tmp | (tx & 0x7));
198802ac6454SAndrew Thompson 
198902ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR6) & ~0x7;
199002ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR6, tmp | (tx & 0x7));
199102ac6454SAndrew Thompson }
199202ac6454SAndrew Thompson 
199302ac6454SAndrew Thompson static void
199402ac6454SAndrew Thompson ural_set_rxantenna(struct ural_softc *sc, int antenna)
199502ac6454SAndrew Thompson {
199602ac6454SAndrew Thompson 	uint8_t rx;
199702ac6454SAndrew Thompson 
199802ac6454SAndrew Thompson 	rx = ural_bbp_read(sc, RAL_BBP_RX) & ~RAL_BBP_ANTMASK;
199902ac6454SAndrew Thompson 	if (antenna == 1)
200002ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTA;
200102ac6454SAndrew Thompson 	else if (antenna == 2)
200202ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTB;
200302ac6454SAndrew Thompson 	else
200402ac6454SAndrew Thompson 		rx |= RAL_BBP_DIVERSITY;
200502ac6454SAndrew Thompson 
200602ac6454SAndrew Thompson 	/* need to force no I/Q flip for RF 2525e and 2526 */
200702ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526)
200802ac6454SAndrew Thompson 		rx &= ~RAL_BBP_FLIPIQ;
200902ac6454SAndrew Thompson 
201002ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_RX, rx);
201102ac6454SAndrew Thompson }
201202ac6454SAndrew Thompson 
201302ac6454SAndrew Thompson static void
20147a79cebfSGleb Smirnoff ural_init(struct ural_softc *sc)
201502ac6454SAndrew Thompson {
20166d917491SHans Petter Selasky #define N(a)	((int)(sizeof (a) / sizeof ((a)[0])))
20177a79cebfSGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
20187a79cebfSGleb Smirnoff 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
201902ac6454SAndrew Thompson 	uint16_t tmp;
202002ac6454SAndrew Thompson 	int i, ntries;
202102ac6454SAndrew Thompson 
202202ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
202302ac6454SAndrew Thompson 
202402ac6454SAndrew Thompson 	ural_set_testmode(sc);
202502ac6454SAndrew Thompson 	ural_write(sc, 0x308, 0x00f0);	/* XXX magic */
202602ac6454SAndrew Thompson 
20275efea30fSAndrew Thompson 	ural_stop(sc);
202802ac6454SAndrew Thompson 
202902ac6454SAndrew Thompson 	/* initialize MAC registers to default values */
203002ac6454SAndrew Thompson 	for (i = 0; i < N(ural_def_mac); i++)
203102ac6454SAndrew Thompson 		ural_write(sc, ural_def_mac[i].reg, ural_def_mac[i].val);
203202ac6454SAndrew Thompson 
203302ac6454SAndrew Thompson 	/* wait for BBP and RF to wake up (this can take a long time!) */
203402ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
203502ac6454SAndrew Thompson 		tmp = ural_read(sc, RAL_MAC_CSR17);
203602ac6454SAndrew Thompson 		if ((tmp & (RAL_BBP_AWAKE | RAL_RF_AWAKE)) ==
203702ac6454SAndrew Thompson 		    (RAL_BBP_AWAKE | RAL_RF_AWAKE))
203802ac6454SAndrew Thompson 			break;
203902ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
204002ac6454SAndrew Thompson 			break;
204102ac6454SAndrew Thompson 	}
204202ac6454SAndrew Thompson 	if (ntries == 100) {
204302ac6454SAndrew Thompson 		device_printf(sc->sc_dev,
204402ac6454SAndrew Thompson 		    "timeout waiting for BBP/RF to wakeup\n");
204502ac6454SAndrew Thompson 		goto fail;
204602ac6454SAndrew Thompson 	}
204702ac6454SAndrew Thompson 
204802ac6454SAndrew Thompson 	/* we're ready! */
204902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_HOST_READY);
205002ac6454SAndrew Thompson 
205102ac6454SAndrew Thompson 	/* set basic rate set (will be updated later) */
205202ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR11, 0x15f);
205302ac6454SAndrew Thompson 
205402ac6454SAndrew Thompson 	if (ural_bbp_init(sc) != 0)
205502ac6454SAndrew Thompson 		goto fail;
205602ac6454SAndrew Thompson 
205702ac6454SAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
205802ac6454SAndrew Thompson 
205902ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
206002ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
206102ac6454SAndrew Thompson 
206202ac6454SAndrew Thompson 	ural_set_txantenna(sc, sc->tx_ant);
206302ac6454SAndrew Thompson 	ural_set_rxantenna(sc, sc->rx_ant);
206402ac6454SAndrew Thompson 
20657a79cebfSGleb Smirnoff 	ural_set_macaddr(sc, vap ? vap->iv_myaddr : ic->ic_macaddr);
206602ac6454SAndrew Thompson 
206702ac6454SAndrew Thompson 	/*
206802ac6454SAndrew Thompson 	 * Allocate Tx and Rx xfer queues.
206902ac6454SAndrew Thompson 	 */
207002ac6454SAndrew Thompson 	ural_setup_tx_list(sc);
207102ac6454SAndrew Thompson 
207202ac6454SAndrew Thompson 	/* kick Rx */
207302ac6454SAndrew Thompson 	tmp = RAL_DROP_PHY | RAL_DROP_CRC;
207402ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR) {
207502ac6454SAndrew Thompson 		tmp |= RAL_DROP_CTL | RAL_DROP_BAD_VERSION;
207602ac6454SAndrew Thompson 		if (ic->ic_opmode != IEEE80211_M_HOSTAP)
207702ac6454SAndrew Thompson 			tmp |= RAL_DROP_TODS;
20787a79cebfSGleb Smirnoff 		if (ic->ic_promisc == 0)
207902ac6454SAndrew Thompson 			tmp |= RAL_DROP_NOT_TO_ME;
208002ac6454SAndrew Thompson 	}
208102ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
208202ac6454SAndrew Thompson 
20837a79cebfSGleb Smirnoff 	sc->sc_running = 1;
2084ed6d949aSAndrew Thompson 	usbd_xfer_set_stall(sc->sc_xfer[URAL_BULK_WR]);
2085a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_RD]);
208602ac6454SAndrew Thompson 	return;
208702ac6454SAndrew Thompson 
20885efea30fSAndrew Thompson fail:	ural_stop(sc);
208902ac6454SAndrew Thompson #undef N
209002ac6454SAndrew Thompson }
209102ac6454SAndrew Thompson 
209202ac6454SAndrew Thompson static void
20935efea30fSAndrew Thompson ural_stop(struct ural_softc *sc)
209402ac6454SAndrew Thompson {
209502ac6454SAndrew Thompson 
209602ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
209702ac6454SAndrew Thompson 
20987a79cebfSGleb Smirnoff 	sc->sc_running = 0;
209902ac6454SAndrew Thompson 
210002ac6454SAndrew Thompson 	/*
210102ac6454SAndrew Thompson 	 * Drain all the transfers, if not already drained:
210202ac6454SAndrew Thompson 	 */
210302ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
2104a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_WR]);
2105a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_RD]);
210602ac6454SAndrew Thompson 	RAL_LOCK(sc);
210702ac6454SAndrew Thompson 
210802ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
210902ac6454SAndrew Thompson 
211002ac6454SAndrew Thompson 	/* disable Rx */
211102ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, RAL_DISABLE_RX);
211202ac6454SAndrew Thompson 	/* reset ASIC and BBP (but won't reset MAC registers!) */
211302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_RESET_ASIC | RAL_RESET_BBP);
211402ac6454SAndrew Thompson 	/* wait a little */
211502ac6454SAndrew Thompson 	ural_pause(sc, hz / 10);
211602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, 0);
211777ddf3d3SAndrew Thompson 	/* wait a little */
211877ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 10);
211902ac6454SAndrew Thompson }
212002ac6454SAndrew Thompson 
212102ac6454SAndrew Thompson static int
212202ac6454SAndrew Thompson ural_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
212302ac6454SAndrew Thompson 	const struct ieee80211_bpf_params *params)
212402ac6454SAndrew Thompson {
212502ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
2126d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
212702ac6454SAndrew Thompson 
212802ac6454SAndrew Thompson 	RAL_LOCK(sc);
212902ac6454SAndrew Thompson 	/* prevent management frames from being sent if we're not ready */
21307a79cebfSGleb Smirnoff 	if (!sc->sc_running) {
213102ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
213202ac6454SAndrew Thompson 		m_freem(m);
213302ac6454SAndrew Thompson 		ieee80211_free_node(ni);
213402ac6454SAndrew Thompson 		return ENETDOWN;
213502ac6454SAndrew Thompson 	}
213696ca458fSAndrew Thompson 	if (sc->tx_nfree < RAL_TX_MINFREE) {
213702ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
213802ac6454SAndrew Thompson 		m_freem(m);
213902ac6454SAndrew Thompson 		ieee80211_free_node(ni);
214002ac6454SAndrew Thompson 		return EIO;
214102ac6454SAndrew Thompson 	}
214202ac6454SAndrew Thompson 
214302ac6454SAndrew Thompson 	if (params == NULL) {
214402ac6454SAndrew Thompson 		/*
214502ac6454SAndrew Thompson 		 * Legacy path; interpret frame contents to decide
214602ac6454SAndrew Thompson 		 * precisely how to send the frame.
214702ac6454SAndrew Thompson 		 */
214802ac6454SAndrew Thompson 		if (ural_tx_mgt(sc, m, ni) != 0)
214902ac6454SAndrew Thompson 			goto bad;
215002ac6454SAndrew Thompson 	} else {
215102ac6454SAndrew Thompson 		/*
215202ac6454SAndrew Thompson 		 * Caller supplied explicit parameters to use in
215302ac6454SAndrew Thompson 		 * sending the frame.
215402ac6454SAndrew Thompson 		 */
215502ac6454SAndrew Thompson 		if (ural_tx_raw(sc, m, ni, params) != 0)
215602ac6454SAndrew Thompson 			goto bad;
215702ac6454SAndrew Thompson 	}
215802ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
215902ac6454SAndrew Thompson 	return 0;
216002ac6454SAndrew Thompson bad:
216102ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
216202ac6454SAndrew Thompson 	ieee80211_free_node(ni);
216302ac6454SAndrew Thompson 	return EIO;		/* XXX */
216402ac6454SAndrew Thompson }
216502ac6454SAndrew Thompson 
216602ac6454SAndrew Thompson static void
2167b6108616SRui Paulo ural_ratectl_start(struct ural_softc *sc, struct ieee80211_node *ni)
216802ac6454SAndrew Thompson {
216902ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
217002ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
217102ac6454SAndrew Thompson 
217202ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
217302ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
217402ac6454SAndrew Thompson 
2175b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
217602ac6454SAndrew Thompson }
217702ac6454SAndrew Thompson 
217802ac6454SAndrew Thompson static void
2179b6108616SRui Paulo ural_ratectl_timeout(void *arg)
218002ac6454SAndrew Thompson {
218102ac6454SAndrew Thompson 	struct ural_vap *uvp = arg;
21825efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
21835efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
218402ac6454SAndrew Thompson 
2185b6108616SRui Paulo 	ieee80211_runtask(ic, &uvp->ratectl_task);
218602ac6454SAndrew Thompson }
218702ac6454SAndrew Thompson 
218802ac6454SAndrew Thompson static void
2189b6108616SRui Paulo ural_ratectl_task(void *arg, int pending)
219002ac6454SAndrew Thompson {
21915efea30fSAndrew Thompson 	struct ural_vap *uvp = arg;
21925efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
21935efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
2194d3fdd08cSAdrian Chadd 	struct ural_softc *sc = ic->ic_softc;
21958d8bdb01SAndrew Thompson 	struct ieee80211_node *ni;
219602ac6454SAndrew Thompson 	int ok, fail;
2197b6108616SRui Paulo 	int sum, retrycnt;
219802ac6454SAndrew Thompson 
21998d8bdb01SAndrew Thompson 	ni = ieee80211_ref_node(vap->iv_bss);
22005efea30fSAndrew Thompson 	RAL_LOCK(sc);
220102ac6454SAndrew Thompson 	/* read and clear statistic registers (STA_CSR0 to STA_CSR10) */
220202ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof(sc->sta));
220302ac6454SAndrew Thompson 
220402ac6454SAndrew Thompson 	ok = sc->sta[7] +		/* TX ok w/o retry */
220502ac6454SAndrew Thompson 	     sc->sta[8];		/* TX ok w/ retry */
220602ac6454SAndrew Thompson 	fail = sc->sta[9];		/* TX retry-fail count */
2207b6108616SRui Paulo 	sum = ok+fail;
2208b6108616SRui Paulo 	retrycnt = sc->sta[8] + fail;
220902ac6454SAndrew Thompson 
2210b6108616SRui Paulo 	ieee80211_ratectl_tx_update(vap, ni, &sum, &ok, &retrycnt);
2211b6108616SRui Paulo 	(void) ieee80211_ratectl_rate(ni, NULL, 0);
221202ac6454SAndrew Thompson 
22137a79cebfSGleb Smirnoff 	/* count TX retry-fail as Tx errors */
22147a79cebfSGleb Smirnoff 	if_inc_counter(ni->ni_vap->iv_ifp, IFCOUNTER_OERRORS, fail);
221502ac6454SAndrew Thompson 
2216b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
22175efea30fSAndrew Thompson 	RAL_UNLOCK(sc);
22188d8bdb01SAndrew Thompson 	ieee80211_free_node(ni);
221902ac6454SAndrew Thompson }
222002ac6454SAndrew Thompson 
222102ac6454SAndrew Thompson static int
222202ac6454SAndrew Thompson ural_pause(struct ural_softc *sc, int timeout)
222302ac6454SAndrew Thompson {
222402ac6454SAndrew Thompson 
2225a593f6b8SAndrew Thompson 	usb_pause_mtx(&sc->sc_mtx, timeout);
222602ac6454SAndrew Thompson 	return (0);
222702ac6454SAndrew Thompson }
2228