xref: /freebsd/sys/dev/usb/wlan/if_ural.c (revision 79d2c5e8574c155e3e247a52eddeda3521c7d46b)
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 *);
152*79d2c5e8SGleb Smirnoff static int		ural_transmit(struct ieee80211com *, struct mbuf *);
153*79d2c5e8SGleb Smirnoff static void		ural_start(struct ural_softc *);
154*79d2c5e8SGleb 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 *);
175*79d2c5e8SGleb 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 *);
180*79d2c5e8SGleb 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);
188*79d2c5e8SGleb 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);
425*79d2c5e8SGleb 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);
435*79d2c5e8SGleb 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 
482*79d2c5e8SGleb 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;
488*79d2c5e8SGleb Smirnoff 	ic->ic_parent = ural_parent;
489*79d2c5e8SGleb 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);
513*79d2c5e8SGleb 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 
528*79d2c5e8SGleb Smirnoff 	if (ic->ic_softc == sc)
52902ac6454SAndrew Thompson 		ieee80211_ifdetach(ic);
530*79d2c5e8SGleb 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 {
563*79d2c5e8SGleb Smirnoff 	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;
56902ac6454SAndrew Thompson 	uvp = (struct ural_vap *) malloc(sizeof(struct ural_vap),
57002ac6454SAndrew Thompson 	    M_80211_VAP, M_NOWAIT | M_ZERO);
57102ac6454SAndrew Thompson 	if (uvp == NULL)
57202ac6454SAndrew Thompson 		return NULL;
57302ac6454SAndrew Thompson 	vap = &uvp->vap;
57402ac6454SAndrew Thompson 	/* enable s/w bmiss handling for sta mode */
575bb2f69e8SHans Petter Selasky 
576bb2f69e8SHans Petter Selasky 	if (ieee80211_vap_setup(ic, vap, name, unit, opmode,
577*79d2c5e8SGleb Smirnoff 	    flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) {
578bb2f69e8SHans Petter Selasky 		/* out of memory */
579bb2f69e8SHans Petter Selasky 		free(uvp, M_80211_VAP);
580bb2f69e8SHans Petter Selasky 		return (NULL);
581bb2f69e8SHans Petter Selasky 	}
58202ac6454SAndrew Thompson 
58302ac6454SAndrew Thompson 	/* override state transition machine */
58402ac6454SAndrew Thompson 	uvp->newstate = vap->iv_newstate;
58502ac6454SAndrew Thompson 	vap->iv_newstate = ural_newstate;
58602ac6454SAndrew Thompson 
587b6108616SRui Paulo 	usb_callout_init_mtx(&uvp->ratectl_ch, &sc->sc_mtx, 0);
588b6108616SRui Paulo 	TASK_INIT(&uvp->ratectl_task, 0, ural_ratectl_task, uvp);
589b6108616SRui Paulo 	ieee80211_ratectl_init(vap);
590b6108616SRui Paulo 	ieee80211_ratectl_setinterval(vap, 1000 /* 1 sec */);
59102ac6454SAndrew Thompson 
59202ac6454SAndrew Thompson 	/* complete setup */
593*79d2c5e8SGleb Smirnoff 	ieee80211_vap_attach(vap, ieee80211_media_change,
594*79d2c5e8SGleb Smirnoff 	    ieee80211_media_status, mac);
59502ac6454SAndrew Thompson 	ic->ic_opmode = opmode;
59602ac6454SAndrew Thompson 	return vap;
59702ac6454SAndrew Thompson }
59802ac6454SAndrew Thompson 
59902ac6454SAndrew Thompson static void
60002ac6454SAndrew Thompson ural_vap_delete(struct ieee80211vap *vap)
60102ac6454SAndrew Thompson {
60202ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6035efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
60402ac6454SAndrew Thompson 
605b6108616SRui Paulo 	usb_callout_drain(&uvp->ratectl_ch);
606b6108616SRui Paulo 	ieee80211_draintask(ic, &uvp->ratectl_task);
607b6108616SRui Paulo 	ieee80211_ratectl_deinit(vap);
60802ac6454SAndrew Thompson 	ieee80211_vap_detach(vap);
60902ac6454SAndrew Thompson 	free(uvp, M_80211_VAP);
61002ac6454SAndrew Thompson }
61102ac6454SAndrew Thompson 
61202ac6454SAndrew Thompson static void
61302ac6454SAndrew Thompson ural_tx_free(struct ural_tx_data *data, int txerr)
61402ac6454SAndrew Thompson {
61502ac6454SAndrew Thompson 	struct ural_softc *sc = data->sc;
61602ac6454SAndrew Thompson 
61702ac6454SAndrew Thompson 	if (data->m != NULL) {
618*79d2c5e8SGleb Smirnoff 		ieee80211_tx_complete(data->ni, data->m, txerr);
61902ac6454SAndrew Thompson 		data->m = NULL;
62002ac6454SAndrew Thompson 		data->ni = NULL;
62102ac6454SAndrew Thompson 	}
62202ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
62302ac6454SAndrew Thompson 	sc->tx_nfree++;
62402ac6454SAndrew Thompson }
62502ac6454SAndrew Thompson 
62602ac6454SAndrew Thompson static void
62702ac6454SAndrew Thompson ural_setup_tx_list(struct ural_softc *sc)
62802ac6454SAndrew Thompson {
62902ac6454SAndrew Thompson 	struct ural_tx_data *data;
63002ac6454SAndrew Thompson 	int i;
63102ac6454SAndrew Thompson 
63202ac6454SAndrew Thompson 	sc->tx_nfree = 0;
63302ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
63402ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
63502ac6454SAndrew Thompson 
63602ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
63702ac6454SAndrew Thompson 		data = &sc->tx_data[i];
63802ac6454SAndrew Thompson 
63902ac6454SAndrew Thompson 		data->sc = sc;
64002ac6454SAndrew Thompson 		STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
64102ac6454SAndrew Thompson 		sc->tx_nfree++;
64202ac6454SAndrew Thompson 	}
64302ac6454SAndrew Thompson }
64402ac6454SAndrew Thompson 
64502ac6454SAndrew Thompson static void
64602ac6454SAndrew Thompson ural_unsetup_tx_list(struct ural_softc *sc)
64702ac6454SAndrew Thompson {
64802ac6454SAndrew Thompson 	struct ural_tx_data *data;
64902ac6454SAndrew Thompson 	int i;
65002ac6454SAndrew Thompson 
65102ac6454SAndrew Thompson 	/* make sure any subsequent use of the queues will fail */
65202ac6454SAndrew Thompson 	sc->tx_nfree = 0;
65302ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_q);
65402ac6454SAndrew Thompson 	STAILQ_INIT(&sc->tx_free);
65502ac6454SAndrew Thompson 
65602ac6454SAndrew Thompson 	/* free up all node references and mbufs */
65702ac6454SAndrew Thompson 	for (i = 0; i < RAL_TX_LIST_COUNT; i++) {
65802ac6454SAndrew Thompson 		data = &sc->tx_data[i];
65902ac6454SAndrew Thompson 
66002ac6454SAndrew Thompson 		if (data->m != NULL) {
66102ac6454SAndrew Thompson 			m_freem(data->m);
66202ac6454SAndrew Thompson 			data->m = NULL;
66302ac6454SAndrew Thompson 		}
66402ac6454SAndrew Thompson 		if (data->ni != NULL) {
66502ac6454SAndrew Thompson 			ieee80211_free_node(data->ni);
66602ac6454SAndrew Thompson 			data->ni = NULL;
66702ac6454SAndrew Thompson 		}
66802ac6454SAndrew Thompson 	}
66902ac6454SAndrew Thompson }
67002ac6454SAndrew Thompson 
6715efea30fSAndrew Thompson static int
6725efea30fSAndrew Thompson ural_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg)
67302ac6454SAndrew Thompson {
67402ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
6755efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
676*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
67702ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
67802ac6454SAndrew Thompson 	struct ieee80211_node *ni;
67902ac6454SAndrew Thompson 	struct mbuf *m;
68002ac6454SAndrew Thompson 
6815efea30fSAndrew Thompson 	DPRINTF("%s -> %s\n",
6825efea30fSAndrew Thompson 		ieee80211_state_name[vap->iv_state],
6835efea30fSAndrew Thompson 		ieee80211_state_name[nstate]);
68402ac6454SAndrew Thompson 
6855efea30fSAndrew Thompson 	IEEE80211_UNLOCK(ic);
6865efea30fSAndrew Thompson 	RAL_LOCK(sc);
687b6108616SRui Paulo 	usb_callout_stop(&uvp->ratectl_ch);
6885efea30fSAndrew Thompson 
6895efea30fSAndrew Thompson 	switch (nstate) {
69002ac6454SAndrew Thompson 	case IEEE80211_S_INIT:
6915efea30fSAndrew Thompson 		if (vap->iv_state == IEEE80211_S_RUN) {
69202ac6454SAndrew Thompson 			/* abort TSF synchronization */
69302ac6454SAndrew Thompson 			ural_write(sc, RAL_TXRX_CSR19, 0);
69402ac6454SAndrew Thompson 
69502ac6454SAndrew Thompson 			/* force tx led to stop blinking */
69602ac6454SAndrew Thompson 			ural_write(sc, RAL_MAC_CSR20, 0);
69702ac6454SAndrew Thompson 		}
69802ac6454SAndrew Thompson 		break;
69902ac6454SAndrew Thompson 
70002ac6454SAndrew Thompson 	case IEEE80211_S_RUN:
7018d8bdb01SAndrew Thompson 		ni = ieee80211_ref_node(vap->iv_bss);
70202ac6454SAndrew Thompson 
70302ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR) {
704bb571462SHans Petter Selasky 			if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
705bb571462SHans Petter Selasky 				RAL_UNLOCK(sc);
706bb571462SHans Petter Selasky 				IEEE80211_LOCK(ic);
707bb571462SHans Petter Selasky 				ieee80211_free_node(ni);
708bb571462SHans Petter Selasky 				return (-1);
709bb571462SHans Petter Selasky 			}
710*79d2c5e8SGleb Smirnoff 			ural_update_slot(sc);
71102ac6454SAndrew Thompson 			ural_set_txpreamble(sc);
71202ac6454SAndrew Thompson 			ural_set_basicrates(sc, ic->ic_bsschan);
713*79d2c5e8SGleb Smirnoff 			IEEE80211_ADDR_COPY(ic->ic_macaddr, ni->ni_bssid);
714*79d2c5e8SGleb Smirnoff 			ural_set_bssid(sc, ic->ic_macaddr);
71502ac6454SAndrew Thompson 		}
71602ac6454SAndrew Thompson 
71702ac6454SAndrew Thompson 		if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
71802ac6454SAndrew Thompson 		    vap->iv_opmode == IEEE80211_M_IBSS) {
71902ac6454SAndrew Thompson 			m = ieee80211_beacon_alloc(ni, &uvp->bo);
72002ac6454SAndrew Thompson 			if (m == NULL) {
72102ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
72202ac6454SAndrew Thompson 				    "could not allocate beacon\n");
7235efea30fSAndrew Thompson 				RAL_UNLOCK(sc);
7245efea30fSAndrew Thompson 				IEEE80211_LOCK(ic);
7258d8bdb01SAndrew Thompson 				ieee80211_free_node(ni);
7265efea30fSAndrew Thompson 				return (-1);
72702ac6454SAndrew Thompson 			}
7286fca0210SAndrew Thompson 			ieee80211_ref_node(ni);
72902ac6454SAndrew Thompson 			if (ural_tx_bcn(sc, m, ni) != 0) {
73002ac6454SAndrew Thompson 				device_printf(sc->sc_dev,
73102ac6454SAndrew Thompson 				    "could not send beacon\n");
7325efea30fSAndrew Thompson 				RAL_UNLOCK(sc);
7335efea30fSAndrew Thompson 				IEEE80211_LOCK(ic);
7348d8bdb01SAndrew Thompson 				ieee80211_free_node(ni);
7355efea30fSAndrew Thompson 				return (-1);
73602ac6454SAndrew Thompson 			}
73702ac6454SAndrew Thompson 		}
73802ac6454SAndrew Thompson 
73902ac6454SAndrew Thompson 		/* make tx led blink on tx (controlled by ASIC) */
74002ac6454SAndrew Thompson 		ural_write(sc, RAL_MAC_CSR20, 1);
74102ac6454SAndrew Thompson 
74202ac6454SAndrew Thompson 		if (vap->iv_opmode != IEEE80211_M_MONITOR)
74302ac6454SAndrew Thompson 			ural_enable_tsf_sync(sc);
7445463c4a4SSam Leffler 		else
7455463c4a4SSam Leffler 			ural_enable_tsf(sc);
74602ac6454SAndrew Thompson 
74702ac6454SAndrew Thompson 		/* enable automatic rate adaptation */
7485463c4a4SSam Leffler 		/* XXX should use ic_bsschan but not valid until after newstate call below */
7495463c4a4SSam Leffler 		tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
75002ac6454SAndrew Thompson 		if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
751b6108616SRui Paulo 			ural_ratectl_start(sc, ni);
7528d8bdb01SAndrew Thompson 		ieee80211_free_node(ni);
75302ac6454SAndrew Thompson 		break;
75402ac6454SAndrew Thompson 
75502ac6454SAndrew Thompson 	default:
75602ac6454SAndrew Thompson 		break;
75702ac6454SAndrew Thompson 	}
75802ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
75902ac6454SAndrew Thompson 	IEEE80211_LOCK(ic);
7605efea30fSAndrew Thompson 	return (uvp->newstate(vap, nstate, arg));
76102ac6454SAndrew Thompson }
76202ac6454SAndrew Thompson 
76302ac6454SAndrew Thompson 
76402ac6454SAndrew Thompson static void
765ed6d949aSAndrew Thompson ural_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
76602ac6454SAndrew Thompson {
767ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
7685463c4a4SSam Leffler 	struct ieee80211vap *vap;
76902ac6454SAndrew Thompson 	struct ural_tx_data *data;
77002ac6454SAndrew Thompson 	struct mbuf *m;
771ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
772ed6d949aSAndrew Thompson 	int len;
773ed6d949aSAndrew Thompson 
774ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
77502ac6454SAndrew Thompson 
77602ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
77702ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
778ed6d949aSAndrew Thompson 		DPRINTFN(11, "transfer complete, %d bytes\n", len);
77902ac6454SAndrew Thompson 
78002ac6454SAndrew Thompson 		/* free resources */
781ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
78202ac6454SAndrew Thompson 		ural_tx_free(data, 0);
783ed6d949aSAndrew Thompson 		usbd_xfer_set_priv(xfer, NULL);
78402ac6454SAndrew Thompson 
78502ac6454SAndrew Thompson 		/* FALLTHROUGH */
78602ac6454SAndrew Thompson 	case USB_ST_SETUP:
78702ac6454SAndrew Thompson tr_setup:
78802ac6454SAndrew Thompson 		data = STAILQ_FIRST(&sc->tx_q);
78902ac6454SAndrew Thompson 		if (data) {
79002ac6454SAndrew Thompson 			STAILQ_REMOVE_HEAD(&sc->tx_q, next);
79102ac6454SAndrew Thompson 			m = data->m;
79202ac6454SAndrew Thompson 
7936d917491SHans Petter Selasky 			if (m->m_pkthdr.len > (int)(RAL_FRAME_SIZE + RAL_TX_DESC_SIZE)) {
79402ac6454SAndrew Thompson 				DPRINTFN(0, "data overflow, %u bytes\n",
79502ac6454SAndrew Thompson 				    m->m_pkthdr.len);
79602ac6454SAndrew Thompson 				m->m_pkthdr.len = (RAL_FRAME_SIZE + RAL_TX_DESC_SIZE);
79702ac6454SAndrew Thompson 			}
798ed6d949aSAndrew Thompson 			pc = usbd_xfer_get_frame(xfer, 0);
799ed6d949aSAndrew Thompson 			usbd_copy_in(pc, 0, &data->desc, RAL_TX_DESC_SIZE);
800ed6d949aSAndrew Thompson 			usbd_m_copy_in(pc, RAL_TX_DESC_SIZE, m, 0,
80102ac6454SAndrew Thompson 			    m->m_pkthdr.len);
80202ac6454SAndrew Thompson 
8035463c4a4SSam Leffler 			vap = data->ni->ni_vap;
8045463c4a4SSam Leffler 			if (ieee80211_radiotap_active_vap(vap)) {
80502ac6454SAndrew Thompson 				struct ural_tx_radiotap_header *tap = &sc->sc_txtap;
80602ac6454SAndrew Thompson 
80702ac6454SAndrew Thompson 				tap->wt_flags = 0;
80802ac6454SAndrew Thompson 				tap->wt_rate = data->rate;
80902ac6454SAndrew Thompson 				tap->wt_antenna = sc->tx_ant;
81002ac6454SAndrew Thompson 
8115463c4a4SSam Leffler 				ieee80211_radiotap_tx(vap, m);
81202ac6454SAndrew Thompson 			}
81302ac6454SAndrew Thompson 
81402ac6454SAndrew Thompson 			/* xfer length needs to be a multiple of two! */
81502ac6454SAndrew Thompson 			len = (RAL_TX_DESC_SIZE + m->m_pkthdr.len + 1) & ~1;
81602ac6454SAndrew Thompson 			if ((len % 64) == 0)
81702ac6454SAndrew Thompson 				len += 2;
81802ac6454SAndrew Thompson 
81902ac6454SAndrew Thompson 			DPRINTFN(11, "sending frame len=%u xferlen=%u\n",
82002ac6454SAndrew Thompson 			    m->m_pkthdr.len, len);
82102ac6454SAndrew Thompson 
822ed6d949aSAndrew Thompson 			usbd_xfer_set_frame_len(xfer, 0, len);
823ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, data);
82402ac6454SAndrew Thompson 
825a593f6b8SAndrew Thompson 			usbd_transfer_submit(xfer);
82602ac6454SAndrew Thompson 		}
827*79d2c5e8SGleb Smirnoff 		ural_start(sc);
82802ac6454SAndrew Thompson 		break;
82902ac6454SAndrew Thompson 
83002ac6454SAndrew Thompson 	default:			/* Error */
83102ac6454SAndrew Thompson 		DPRINTFN(11, "transfer error, %s\n",
832ed6d949aSAndrew Thompson 		    usbd_errstr(error));
83302ac6454SAndrew Thompson 
834ed6d949aSAndrew Thompson 		data = usbd_xfer_get_priv(xfer);
83502ac6454SAndrew Thompson 		if (data != NULL) {
836ed6d949aSAndrew Thompson 			ural_tx_free(data, error);
837ed6d949aSAndrew Thompson 			usbd_xfer_set_priv(xfer, NULL);
83802ac6454SAndrew Thompson 		}
83902ac6454SAndrew Thompson 
840ed6d949aSAndrew Thompson 		if (error == USB_ERR_STALLED) {
84102ac6454SAndrew Thompson 			/* try to clear stall first */
842ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
84302ac6454SAndrew Thompson 			goto tr_setup;
84402ac6454SAndrew Thompson 		}
845ed6d949aSAndrew Thompson 		if (error == USB_ERR_TIMEOUT)
84602ac6454SAndrew Thompson 			device_printf(sc->sc_dev, "device timeout\n");
84702ac6454SAndrew Thompson 		break;
84802ac6454SAndrew Thompson 	}
84902ac6454SAndrew Thompson }
85002ac6454SAndrew Thompson 
85102ac6454SAndrew Thompson static void
852ed6d949aSAndrew Thompson ural_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
85302ac6454SAndrew Thompson {
854ed6d949aSAndrew Thompson 	struct ural_softc *sc = usbd_xfer_softc(xfer);
855*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
85602ac6454SAndrew Thompson 	struct ieee80211_node *ni;
85702ac6454SAndrew Thompson 	struct mbuf *m = NULL;
858ed6d949aSAndrew Thompson 	struct usb_page_cache *pc;
85902ac6454SAndrew Thompson 	uint32_t flags;
8605463c4a4SSam Leffler 	int8_t rssi = 0, nf = 0;
861ed6d949aSAndrew Thompson 	int len;
862ed6d949aSAndrew Thompson 
863ed6d949aSAndrew Thompson 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
86402ac6454SAndrew Thompson 
86502ac6454SAndrew Thompson 	switch (USB_GET_STATE(xfer)) {
86602ac6454SAndrew Thompson 	case USB_ST_TRANSFERRED:
86702ac6454SAndrew Thompson 
868ed6d949aSAndrew Thompson 		DPRINTFN(15, "rx done, actlen=%d\n", len);
86902ac6454SAndrew Thompson 
8706d917491SHans Petter Selasky 		if (len < (int)(RAL_RX_DESC_SIZE + IEEE80211_MIN_LEN)) {
87102ac6454SAndrew Thompson 			DPRINTF("%s: xfer too short %d\n",
87202ac6454SAndrew Thompson 			    device_get_nameunit(sc->sc_dev), len);
873*79d2c5e8SGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
87402ac6454SAndrew Thompson 			goto tr_setup;
87502ac6454SAndrew Thompson 		}
87602ac6454SAndrew Thompson 
87702ac6454SAndrew Thompson 		len -= RAL_RX_DESC_SIZE;
87802ac6454SAndrew Thompson 		/* rx descriptor is located at the end */
879ed6d949aSAndrew Thompson 		pc = usbd_xfer_get_frame(xfer, 0);
880ed6d949aSAndrew Thompson 		usbd_copy_out(pc, len, &sc->sc_rx_desc, RAL_RX_DESC_SIZE);
88102ac6454SAndrew Thompson 
88202ac6454SAndrew Thompson 		rssi = URAL_RSSI(sc->sc_rx_desc.rssi);
8835463c4a4SSam Leffler 		nf = RAL_NOISE_FLOOR;
88402ac6454SAndrew Thompson 		flags = le32toh(sc->sc_rx_desc.flags);
88502ac6454SAndrew Thompson 		if (flags & (RAL_RX_PHY_ERROR | RAL_RX_CRC_ERROR)) {
88602ac6454SAndrew Thompson 			/*
88702ac6454SAndrew Thompson 		         * This should not happen since we did not
88802ac6454SAndrew Thompson 		         * request to receive those frames when we
88902ac6454SAndrew Thompson 		         * filled RAL_TXRX_CSR2:
89002ac6454SAndrew Thompson 		         */
89102ac6454SAndrew Thompson 			DPRINTFN(5, "PHY or CRC error\n");
892*79d2c5e8SGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
89302ac6454SAndrew Thompson 			goto tr_setup;
89402ac6454SAndrew Thompson 		}
89502ac6454SAndrew Thompson 
896c6499eccSGleb Smirnoff 		m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
89702ac6454SAndrew Thompson 		if (m == NULL) {
89802ac6454SAndrew Thompson 			DPRINTF("could not allocate mbuf\n");
899*79d2c5e8SGleb Smirnoff 			counter_u64_add(ic->ic_ierrors, 1);
90002ac6454SAndrew Thompson 			goto tr_setup;
90102ac6454SAndrew Thompson 		}
902ed6d949aSAndrew Thompson 		usbd_copy_out(pc, 0, mtod(m, uint8_t *), len);
90302ac6454SAndrew Thompson 
90402ac6454SAndrew Thompson 		/* finalize mbuf */
90502ac6454SAndrew Thompson 		m->m_pkthdr.len = m->m_len = (flags >> 16) & 0xfff;
90602ac6454SAndrew Thompson 
9075463c4a4SSam Leffler 		if (ieee80211_radiotap_active(ic)) {
90802ac6454SAndrew Thompson 			struct ural_rx_radiotap_header *tap = &sc->sc_rxtap;
90902ac6454SAndrew Thompson 
9105463c4a4SSam Leffler 			/* XXX set once */
9115463c4a4SSam Leffler 			tap->wr_flags = 0;
91202ac6454SAndrew Thompson 			tap->wr_rate = ieee80211_plcp2rate(sc->sc_rx_desc.rate,
91302ac6454SAndrew Thompson 			    (flags & RAL_RX_OFDM) ?
91402ac6454SAndrew Thompson 			    IEEE80211_T_OFDM : IEEE80211_T_CCK);
91502ac6454SAndrew Thompson 			tap->wr_antenna = sc->rx_ant;
9165463c4a4SSam Leffler 			tap->wr_antsignal = nf + rssi;
9175463c4a4SSam Leffler 			tap->wr_antnoise = nf;
91802ac6454SAndrew Thompson 		}
91902ac6454SAndrew Thompson 		/* Strip trailing 802.11 MAC FCS. */
92002ac6454SAndrew Thompson 		m_adj(m, -IEEE80211_CRC_LEN);
92102ac6454SAndrew Thompson 
92202ac6454SAndrew Thompson 		/* FALLTHROUGH */
92302ac6454SAndrew Thompson 	case USB_ST_SETUP:
92402ac6454SAndrew Thompson tr_setup:
925ed6d949aSAndrew Thompson 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
926a593f6b8SAndrew Thompson 		usbd_transfer_submit(xfer);
92702ac6454SAndrew Thompson 
92802ac6454SAndrew Thompson 		/*
92902ac6454SAndrew Thompson 		 * At the end of a USB callback it is always safe to unlock
93002ac6454SAndrew Thompson 		 * the private mutex of a device! That is why we do the
93102ac6454SAndrew Thompson 		 * "ieee80211_input" here, and not some lines up!
93202ac6454SAndrew Thompson 		 */
93302ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
934941da6d3SWeongyo Jeong 		if (m) {
93502ac6454SAndrew Thompson 			ni = ieee80211_find_rxnode(ic,
93602ac6454SAndrew Thompson 			    mtod(m, struct ieee80211_frame_min *));
93702ac6454SAndrew Thompson 			if (ni != NULL) {
9385463c4a4SSam Leffler 				(void) ieee80211_input(ni, m, rssi, nf);
93902ac6454SAndrew Thompson 				ieee80211_free_node(ni);
94002ac6454SAndrew Thompson 			} else
9415463c4a4SSam Leffler 				(void) ieee80211_input_all(ic, m, rssi, nf);
94202ac6454SAndrew Thompson 		}
943941da6d3SWeongyo Jeong 		RAL_LOCK(sc);
944*79d2c5e8SGleb Smirnoff 		ural_start(sc);
94502ac6454SAndrew Thompson 		return;
94602ac6454SAndrew Thompson 
94702ac6454SAndrew Thompson 	default:			/* Error */
948ed6d949aSAndrew Thompson 		if (error != USB_ERR_CANCELLED) {
94902ac6454SAndrew Thompson 			/* try to clear stall first */
950ed6d949aSAndrew Thompson 			usbd_xfer_set_stall(xfer);
95102ac6454SAndrew Thompson 			goto tr_setup;
95202ac6454SAndrew Thompson 		}
95302ac6454SAndrew Thompson 		return;
95402ac6454SAndrew Thompson 	}
95502ac6454SAndrew Thompson }
95602ac6454SAndrew Thompson 
95702ac6454SAndrew Thompson static uint8_t
95802ac6454SAndrew Thompson ural_plcp_signal(int rate)
95902ac6454SAndrew Thompson {
96002ac6454SAndrew Thompson 	switch (rate) {
96102ac6454SAndrew Thompson 	/* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
96202ac6454SAndrew Thompson 	case 12:	return 0xb;
96302ac6454SAndrew Thompson 	case 18:	return 0xf;
96402ac6454SAndrew Thompson 	case 24:	return 0xa;
96502ac6454SAndrew Thompson 	case 36:	return 0xe;
96602ac6454SAndrew Thompson 	case 48:	return 0x9;
96702ac6454SAndrew Thompson 	case 72:	return 0xd;
96802ac6454SAndrew Thompson 	case 96:	return 0x8;
96902ac6454SAndrew Thompson 	case 108:	return 0xc;
97002ac6454SAndrew Thompson 
97102ac6454SAndrew Thompson 	/* CCK rates (NB: not IEEE std, device-specific) */
97202ac6454SAndrew Thompson 	case 2:		return 0x0;
97302ac6454SAndrew Thompson 	case 4:		return 0x1;
97402ac6454SAndrew Thompson 	case 11:	return 0x2;
97502ac6454SAndrew Thompson 	case 22:	return 0x3;
97602ac6454SAndrew Thompson 	}
97702ac6454SAndrew Thompson 	return 0xff;		/* XXX unsupported/unknown rate */
97802ac6454SAndrew Thompson }
97902ac6454SAndrew Thompson 
98002ac6454SAndrew Thompson static void
98102ac6454SAndrew Thompson ural_setup_tx_desc(struct ural_softc *sc, struct ural_tx_desc *desc,
98202ac6454SAndrew Thompson     uint32_t flags, int len, int rate)
98302ac6454SAndrew Thompson {
984*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
98502ac6454SAndrew Thompson 	uint16_t plcp_length;
98602ac6454SAndrew Thompson 	int remainder;
98702ac6454SAndrew Thompson 
98802ac6454SAndrew Thompson 	desc->flags = htole32(flags);
98902ac6454SAndrew Thompson 	desc->flags |= htole32(RAL_TX_NEWSEQ);
99002ac6454SAndrew Thompson 	desc->flags |= htole32(len << 16);
99102ac6454SAndrew Thompson 
99202ac6454SAndrew Thompson 	desc->wme = htole16(RAL_AIFSN(2) | RAL_LOGCWMIN(3) | RAL_LOGCWMAX(5));
99302ac6454SAndrew Thompson 	desc->wme |= htole16(RAL_IVOFFSET(sizeof (struct ieee80211_frame)));
99402ac6454SAndrew Thompson 
99502ac6454SAndrew Thompson 	/* setup PLCP fields */
99602ac6454SAndrew Thompson 	desc->plcp_signal  = ural_plcp_signal(rate);
99702ac6454SAndrew Thompson 	desc->plcp_service = 4;
99802ac6454SAndrew Thompson 
99902ac6454SAndrew Thompson 	len += IEEE80211_CRC_LEN;
100026d39e2cSSam Leffler 	if (ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM) {
100102ac6454SAndrew Thompson 		desc->flags |= htole32(RAL_TX_OFDM);
100202ac6454SAndrew Thompson 
100302ac6454SAndrew Thompson 		plcp_length = len & 0xfff;
100402ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 6;
100502ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0x3f;
100602ac6454SAndrew Thompson 	} else {
1007b8e3094cSHans Petter Selasky 		if (rate == 0)
1008b8e3094cSHans Petter Selasky 			rate = 2;	/* avoid division by zero */
100902ac6454SAndrew Thompson 		plcp_length = (16 * len + rate - 1) / rate;
101002ac6454SAndrew Thompson 		if (rate == 22) {
101102ac6454SAndrew Thompson 			remainder = (16 * len) % 22;
101202ac6454SAndrew Thompson 			if (remainder != 0 && remainder < 7)
101302ac6454SAndrew Thompson 				desc->plcp_service |= RAL_PLCP_LENGEXT;
101402ac6454SAndrew Thompson 		}
101502ac6454SAndrew Thompson 		desc->plcp_length_hi = plcp_length >> 8;
101602ac6454SAndrew Thompson 		desc->plcp_length_lo = plcp_length & 0xff;
101702ac6454SAndrew Thompson 
101802ac6454SAndrew Thompson 		if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
101902ac6454SAndrew Thompson 			desc->plcp_signal |= 0x08;
102002ac6454SAndrew Thompson 	}
102102ac6454SAndrew Thompson 
102202ac6454SAndrew Thompson 	desc->iv = 0;
102302ac6454SAndrew Thompson 	desc->eiv = 0;
102402ac6454SAndrew Thompson }
102502ac6454SAndrew Thompson 
102602ac6454SAndrew Thompson #define RAL_TX_TIMEOUT	5000
102702ac6454SAndrew Thompson 
102802ac6454SAndrew Thompson static int
102902ac6454SAndrew Thompson ural_tx_bcn(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
103002ac6454SAndrew Thompson {
103102ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
103202ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
103302ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
103402ac6454SAndrew Thompson 	struct ural_tx_data *data;
103502ac6454SAndrew Thompson 
103602ac6454SAndrew Thompson 	if (sc->tx_nfree == 0) {
103702ac6454SAndrew Thompson 		m_freem(m0);
103802ac6454SAndrew Thompson 		ieee80211_free_node(ni);
1039bb571462SHans Petter Selasky 		return (EIO);
1040bb571462SHans Petter Selasky 	}
1041bb571462SHans Petter Selasky 	if (ic->ic_bsschan == IEEE80211_CHAN_ANYC) {
1042bb571462SHans Petter Selasky 		m_freem(m0);
1043bb571462SHans Petter Selasky 		ieee80211_free_node(ni);
1044bb571462SHans Petter Selasky 		return (ENXIO);
104502ac6454SAndrew Thompson 	}
104602ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
104702ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
104802ac6454SAndrew Thompson 	sc->tx_nfree--;
104902ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
105002ac6454SAndrew Thompson 
105102ac6454SAndrew Thompson 	data->m = m0;
105202ac6454SAndrew Thompson 	data->ni = ni;
105302ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
105402ac6454SAndrew Thompson 
105502ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc,
105602ac6454SAndrew Thompson 	    RAL_TX_IFS_NEWBACKOFF | RAL_TX_TIMESTAMP, m0->m_pkthdr.len,
105702ac6454SAndrew Thompson 	    tp->mgmtrate);
105802ac6454SAndrew Thompson 
105902ac6454SAndrew Thompson 	DPRINTFN(10, "sending beacon frame len=%u rate=%u\n",
106002ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
106102ac6454SAndrew Thompson 
106202ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1063a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
106402ac6454SAndrew Thompson 
106502ac6454SAndrew Thompson 	return (0);
106602ac6454SAndrew Thompson }
106702ac6454SAndrew Thompson 
106802ac6454SAndrew Thompson static int
106902ac6454SAndrew Thompson ural_tx_mgt(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
107002ac6454SAndrew Thompson {
107102ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
107202ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
107302ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
107402ac6454SAndrew Thompson 	struct ural_tx_data *data;
107502ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
107602ac6454SAndrew Thompson 	struct ieee80211_key *k;
107702ac6454SAndrew Thompson 	uint32_t flags;
107802ac6454SAndrew Thompson 	uint16_t dur;
107902ac6454SAndrew Thompson 
108002ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
108102ac6454SAndrew Thompson 
108202ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
108302ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
108402ac6454SAndrew Thompson 	sc->tx_nfree--;
108502ac6454SAndrew Thompson 
108602ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
108702ac6454SAndrew Thompson 
108802ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
10895945b5f5SKevin Lo 	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
109002ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
109102ac6454SAndrew Thompson 		if (k == NULL) {
109202ac6454SAndrew Thompson 			m_freem(m0);
109302ac6454SAndrew Thompson 			return ENOBUFS;
109402ac6454SAndrew Thompson 		}
109502ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
109602ac6454SAndrew Thompson 	}
109702ac6454SAndrew Thompson 
109802ac6454SAndrew Thompson 	data->m = m0;
109902ac6454SAndrew Thompson 	data->ni = ni;
110002ac6454SAndrew Thompson 	data->rate = tp->mgmtrate;
110102ac6454SAndrew Thompson 
110202ac6454SAndrew Thompson 	flags = 0;
110302ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
110402ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
110502ac6454SAndrew Thompson 
110626d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, tp->mgmtrate,
110702ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
11088cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
110902ac6454SAndrew Thompson 
111002ac6454SAndrew Thompson 		/* tell hardware to add timestamp for probe responses */
111102ac6454SAndrew Thompson 		if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
111202ac6454SAndrew Thompson 		    IEEE80211_FC0_TYPE_MGT &&
111302ac6454SAndrew Thompson 		    (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
111402ac6454SAndrew Thompson 		    IEEE80211_FC0_SUBTYPE_PROBE_RESP)
111502ac6454SAndrew Thompson 			flags |= RAL_TX_TIMESTAMP;
111602ac6454SAndrew Thompson 	}
111702ac6454SAndrew Thompson 
111802ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, tp->mgmtrate);
111902ac6454SAndrew Thompson 
112002ac6454SAndrew Thompson 	DPRINTFN(10, "sending mgt frame len=%u rate=%u\n",
112102ac6454SAndrew Thompson 	    m0->m_pkthdr.len, tp->mgmtrate);
112202ac6454SAndrew Thompson 
112302ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1124a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
112502ac6454SAndrew Thompson 
112602ac6454SAndrew Thompson 	return 0;
112702ac6454SAndrew Thompson }
112802ac6454SAndrew Thompson 
112902ac6454SAndrew Thompson static int
113002ac6454SAndrew Thompson ural_sendprot(struct ural_softc *sc,
113102ac6454SAndrew Thompson     const struct mbuf *m, struct ieee80211_node *ni, int prot, int rate)
113202ac6454SAndrew Thompson {
113302ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
113402ac6454SAndrew Thompson 	const struct ieee80211_frame *wh;
113502ac6454SAndrew Thompson 	struct ural_tx_data *data;
113602ac6454SAndrew Thompson 	struct mbuf *mprot;
113702ac6454SAndrew Thompson 	int protrate, ackrate, pktlen, flags, isshort;
113802ac6454SAndrew Thompson 	uint16_t dur;
113902ac6454SAndrew Thompson 
114002ac6454SAndrew Thompson 	KASSERT(prot == IEEE80211_PROT_RTSCTS || prot == IEEE80211_PROT_CTSONLY,
114102ac6454SAndrew Thompson 	    ("protection %d", prot));
114202ac6454SAndrew Thompson 
114302ac6454SAndrew Thompson 	wh = mtod(m, const struct ieee80211_frame *);
114402ac6454SAndrew Thompson 	pktlen = m->m_pkthdr.len + IEEE80211_CRC_LEN;
114502ac6454SAndrew Thompson 
114626d39e2cSSam Leffler 	protrate = ieee80211_ctl_rate(ic->ic_rt, rate);
114726d39e2cSSam Leffler 	ackrate = ieee80211_ack_rate(ic->ic_rt, rate);
114802ac6454SAndrew Thompson 
114902ac6454SAndrew Thompson 	isshort = (ic->ic_flags & IEEE80211_F_SHPREAMBLE) != 0;
11500f817de7SJung-uk Kim 	dur = ieee80211_compute_duration(ic->ic_rt, pktlen, rate, isshort)
115126d39e2cSSam Leffler 	    + ieee80211_ack_duration(ic->ic_rt, rate, isshort);
115202ac6454SAndrew Thompson 	flags = RAL_TX_RETRY(7);
115302ac6454SAndrew Thompson 	if (prot == IEEE80211_PROT_RTSCTS) {
115402ac6454SAndrew Thompson 		/* NB: CTS is the same size as an ACK */
115526d39e2cSSam Leffler 		dur += ieee80211_ack_duration(ic->ic_rt, rate, isshort);
115602ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
115702ac6454SAndrew Thompson 		mprot = ieee80211_alloc_rts(ic, wh->i_addr1, wh->i_addr2, dur);
115802ac6454SAndrew Thompson 	} else {
115902ac6454SAndrew Thompson 		mprot = ieee80211_alloc_cts(ic, ni->ni_vap->iv_myaddr, dur);
116002ac6454SAndrew Thompson 	}
116102ac6454SAndrew Thompson 	if (mprot == NULL) {
116202ac6454SAndrew Thompson 		/* XXX stat + msg */
116302ac6454SAndrew Thompson 		return ENOBUFS;
116402ac6454SAndrew Thompson 	}
116502ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
116602ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
116702ac6454SAndrew Thompson 	sc->tx_nfree--;
116802ac6454SAndrew Thompson 
116902ac6454SAndrew Thompson 	data->m = mprot;
117002ac6454SAndrew Thompson 	data->ni = ieee80211_ref_node(ni);
117102ac6454SAndrew Thompson 	data->rate = protrate;
117202ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, mprot->m_pkthdr.len, protrate);
117302ac6454SAndrew Thompson 
117402ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1175a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
117602ac6454SAndrew Thompson 
117702ac6454SAndrew Thompson 	return 0;
117802ac6454SAndrew Thompson }
117902ac6454SAndrew Thompson 
118002ac6454SAndrew Thompson static int
118102ac6454SAndrew Thompson ural_tx_raw(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni,
118202ac6454SAndrew Thompson     const struct ieee80211_bpf_params *params)
118302ac6454SAndrew Thompson {
1184515db61dSSam Leffler 	struct ieee80211com *ic = ni->ni_ic;
118502ac6454SAndrew Thompson 	struct ural_tx_data *data;
118602ac6454SAndrew Thompson 	uint32_t flags;
118702ac6454SAndrew Thompson 	int error;
118802ac6454SAndrew Thompson 	int rate;
118902ac6454SAndrew Thompson 
119002ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
119102ac6454SAndrew Thompson 	KASSERT(params != NULL, ("no raw xmit params"));
119202ac6454SAndrew Thompson 
1193515db61dSSam Leffler 	rate = params->ibp_rate0;
1194515db61dSSam Leffler 	if (!ieee80211_isratevalid(ic->ic_rt, rate)) {
119502ac6454SAndrew Thompson 		m_freem(m0);
119602ac6454SAndrew Thompson 		return EINVAL;
119702ac6454SAndrew Thompson 	}
119802ac6454SAndrew Thompson 	flags = 0;
119902ac6454SAndrew Thompson 	if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
120002ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
120102ac6454SAndrew Thompson 	if (params->ibp_flags & (IEEE80211_BPF_RTS|IEEE80211_BPF_CTS)) {
120202ac6454SAndrew Thompson 		error = ural_sendprot(sc, m0, ni,
120302ac6454SAndrew Thompson 		    params->ibp_flags & IEEE80211_BPF_RTS ?
120402ac6454SAndrew Thompson 			 IEEE80211_PROT_RTSCTS : IEEE80211_PROT_CTSONLY,
120502ac6454SAndrew Thompson 		    rate);
120696ca458fSAndrew Thompson 		if (error || sc->tx_nfree == 0) {
120702ac6454SAndrew Thompson 			m_freem(m0);
120896ca458fSAndrew Thompson 			return ENOBUFS;
120902ac6454SAndrew Thompson 		}
121002ac6454SAndrew Thompson 		flags |= RAL_TX_IFS_SIFS;
121102ac6454SAndrew Thompson 	}
121202ac6454SAndrew Thompson 
121396ca458fSAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
121496ca458fSAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
121596ca458fSAndrew Thompson 	sc->tx_nfree--;
121696ca458fSAndrew Thompson 
121702ac6454SAndrew Thompson 	data->m = m0;
121802ac6454SAndrew Thompson 	data->ni = ni;
121902ac6454SAndrew Thompson 	data->rate = rate;
122002ac6454SAndrew Thompson 
122102ac6454SAndrew Thompson 	/* XXX need to setup descriptor ourself */
122202ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
122302ac6454SAndrew Thompson 
122402ac6454SAndrew Thompson 	DPRINTFN(10, "sending raw frame len=%u rate=%u\n",
122502ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
122602ac6454SAndrew Thompson 
122702ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1228a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
122902ac6454SAndrew Thompson 
123002ac6454SAndrew Thompson 	return 0;
123102ac6454SAndrew Thompson }
123202ac6454SAndrew Thompson 
123302ac6454SAndrew Thompson static int
123402ac6454SAndrew Thompson ural_tx_data(struct ural_softc *sc, struct mbuf *m0, struct ieee80211_node *ni)
123502ac6454SAndrew Thompson {
123602ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
123702ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
123802ac6454SAndrew Thompson 	struct ural_tx_data *data;
123902ac6454SAndrew Thompson 	struct ieee80211_frame *wh;
124002ac6454SAndrew Thompson 	const struct ieee80211_txparam *tp;
124102ac6454SAndrew Thompson 	struct ieee80211_key *k;
124202ac6454SAndrew Thompson 	uint32_t flags = 0;
124302ac6454SAndrew Thompson 	uint16_t dur;
124402ac6454SAndrew Thompson 	int error, rate;
124502ac6454SAndrew Thompson 
124602ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
124702ac6454SAndrew Thompson 
124802ac6454SAndrew Thompson 	wh = mtod(m0, struct ieee80211_frame *);
124902ac6454SAndrew Thompson 
125002ac6454SAndrew Thompson 	tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)];
125102ac6454SAndrew Thompson 	if (IEEE80211_IS_MULTICAST(wh->i_addr1))
125202ac6454SAndrew Thompson 		rate = tp->mcastrate;
125302ac6454SAndrew Thompson 	else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
125402ac6454SAndrew Thompson 		rate = tp->ucastrate;
125502ac6454SAndrew Thompson 	else
125602ac6454SAndrew Thompson 		rate = ni->ni_txrate;
125702ac6454SAndrew Thompson 
12585945b5f5SKevin Lo 	if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
125902ac6454SAndrew Thompson 		k = ieee80211_crypto_encap(ni, m0);
126002ac6454SAndrew Thompson 		if (k == NULL) {
126102ac6454SAndrew Thompson 			m_freem(m0);
126202ac6454SAndrew Thompson 			return ENOBUFS;
126302ac6454SAndrew Thompson 		}
126402ac6454SAndrew Thompson 		/* packet header may have moved, reset our local pointer */
126502ac6454SAndrew Thompson 		wh = mtod(m0, struct ieee80211_frame *);
126602ac6454SAndrew Thompson 	}
126702ac6454SAndrew Thompson 
126802ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
126902ac6454SAndrew Thompson 		int prot = IEEE80211_PROT_NONE;
127002ac6454SAndrew Thompson 		if (m0->m_pkthdr.len + IEEE80211_CRC_LEN > vap->iv_rtsthreshold)
127102ac6454SAndrew Thompson 			prot = IEEE80211_PROT_RTSCTS;
127202ac6454SAndrew Thompson 		else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
127326d39e2cSSam Leffler 		    ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM)
127402ac6454SAndrew Thompson 			prot = ic->ic_protmode;
127502ac6454SAndrew Thompson 		if (prot != IEEE80211_PROT_NONE) {
127602ac6454SAndrew Thompson 			error = ural_sendprot(sc, m0, ni, prot, rate);
127796ca458fSAndrew Thompson 			if (error || sc->tx_nfree == 0) {
127802ac6454SAndrew Thompson 				m_freem(m0);
127996ca458fSAndrew Thompson 				return ENOBUFS;
128002ac6454SAndrew Thompson 			}
128102ac6454SAndrew Thompson 			flags |= RAL_TX_IFS_SIFS;
128202ac6454SAndrew Thompson 		}
128302ac6454SAndrew Thompson 	}
128402ac6454SAndrew Thompson 
128502ac6454SAndrew Thompson 	data = STAILQ_FIRST(&sc->tx_free);
128602ac6454SAndrew Thompson 	STAILQ_REMOVE_HEAD(&sc->tx_free, next);
128702ac6454SAndrew Thompson 	sc->tx_nfree--;
128802ac6454SAndrew Thompson 
128902ac6454SAndrew Thompson 	data->m = m0;
129002ac6454SAndrew Thompson 	data->ni = ni;
129102ac6454SAndrew Thompson 	data->rate = rate;
129202ac6454SAndrew Thompson 
129302ac6454SAndrew Thompson 	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
129402ac6454SAndrew Thompson 		flags |= RAL_TX_ACK;
129502ac6454SAndrew Thompson 		flags |= RAL_TX_RETRY(7);
129602ac6454SAndrew Thompson 
129726d39e2cSSam Leffler 		dur = ieee80211_ack_duration(ic->ic_rt, rate,
129802ac6454SAndrew Thompson 		    ic->ic_flags & IEEE80211_F_SHPREAMBLE);
12998cfe5440SHans Petter Selasky 		USETW(wh->i_dur, dur);
130002ac6454SAndrew Thompson 	}
130102ac6454SAndrew Thompson 
130202ac6454SAndrew Thompson 	ural_setup_tx_desc(sc, &data->desc, flags, m0->m_pkthdr.len, rate);
130302ac6454SAndrew Thompson 
130402ac6454SAndrew Thompson 	DPRINTFN(10, "sending data frame len=%u rate=%u\n",
130502ac6454SAndrew Thompson 	    m0->m_pkthdr.len, rate);
130602ac6454SAndrew Thompson 
130702ac6454SAndrew Thompson 	STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1308a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_WR]);
130902ac6454SAndrew Thompson 
131002ac6454SAndrew Thompson 	return 0;
131102ac6454SAndrew Thompson }
131202ac6454SAndrew Thompson 
1313*79d2c5e8SGleb Smirnoff static int
1314*79d2c5e8SGleb Smirnoff ural_transmit(struct ieee80211com *ic, struct mbuf *m)
131502ac6454SAndrew Thompson {
1316*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
1317*79d2c5e8SGleb Smirnoff 	int error;
1318*79d2c5e8SGleb Smirnoff 
1319*79d2c5e8SGleb Smirnoff 	RAL_LOCK(sc);
1320*79d2c5e8SGleb Smirnoff 	if (!sc->sc_running) {
1321*79d2c5e8SGleb Smirnoff 		RAL_UNLOCK(sc);
1322*79d2c5e8SGleb Smirnoff 		return (ENXIO);
1323*79d2c5e8SGleb Smirnoff 	}
1324*79d2c5e8SGleb Smirnoff 	error = mbufq_enqueue(&sc->sc_snd, m);
1325*79d2c5e8SGleb Smirnoff 	if (error) {
1326*79d2c5e8SGleb Smirnoff 		RAL_UNLOCK(sc);
1327*79d2c5e8SGleb Smirnoff 		return (error);
1328*79d2c5e8SGleb Smirnoff 	}
1329*79d2c5e8SGleb Smirnoff 	ural_start(sc);
1330*79d2c5e8SGleb Smirnoff 	RAL_UNLOCK(sc);
1331*79d2c5e8SGleb Smirnoff 
1332*79d2c5e8SGleb Smirnoff 	return (0);
1333*79d2c5e8SGleb Smirnoff }
1334*79d2c5e8SGleb Smirnoff 
1335*79d2c5e8SGleb Smirnoff static void
1336*79d2c5e8SGleb Smirnoff ural_start(struct ural_softc *sc)
1337*79d2c5e8SGleb Smirnoff {
133802ac6454SAndrew Thompson 	struct ieee80211_node *ni;
133902ac6454SAndrew Thompson 	struct mbuf *m;
134002ac6454SAndrew Thompson 
1341*79d2c5e8SGleb Smirnoff 	RAL_LOCK_ASSERT(sc, MA_OWNED);
1342*79d2c5e8SGleb Smirnoff 
1343*79d2c5e8SGleb Smirnoff 	if (sc->sc_running == 0)
134402ac6454SAndrew Thompson 		return;
1345*79d2c5e8SGleb Smirnoff 
1346*79d2c5e8SGleb Smirnoff 	while (sc->tx_nfree >= RAL_TX_MINFREE &&
1347*79d2c5e8SGleb Smirnoff 	    (m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
134802ac6454SAndrew Thompson 		ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
134902ac6454SAndrew Thompson 		if (ural_tx_data(sc, m, ni) != 0) {
1350*79d2c5e8SGleb Smirnoff 			if_inc_counter(ni->ni_vap->iv_ifp,
1351*79d2c5e8SGleb Smirnoff 			     IFCOUNTER_OERRORS, 1);
135202ac6454SAndrew Thompson 			ieee80211_free_node(ni);
135302ac6454SAndrew Thompson 			break;
135402ac6454SAndrew Thompson 		}
135502ac6454SAndrew Thompson 	}
135602ac6454SAndrew Thompson }
135702ac6454SAndrew Thompson 
1358*79d2c5e8SGleb Smirnoff static void
1359*79d2c5e8SGleb Smirnoff ural_parent(struct ieee80211com *ic)
136002ac6454SAndrew Thompson {
1361*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
1362645e4d17SHans Petter Selasky 	int startall = 0;
1363645e4d17SHans Petter Selasky 
1364645e4d17SHans Petter Selasky 	RAL_LOCK(sc);
1365*79d2c5e8SGleb Smirnoff 	if (sc->sc_detached) {
1366645e4d17SHans Petter Selasky 		RAL_UNLOCK(sc);
1367*79d2c5e8SGleb Smirnoff 		return;
1368*79d2c5e8SGleb Smirnoff 	}
1369*79d2c5e8SGleb Smirnoff 	if (ic->ic_nrunning > 0) {
1370*79d2c5e8SGleb Smirnoff 		if (sc->sc_running == 0) {
1371*79d2c5e8SGleb Smirnoff 			ural_init(sc);
137202ac6454SAndrew Thompson 			startall = 1;
137302ac6454SAndrew Thompson 		} else
13745efea30fSAndrew Thompson 			ural_setpromisc(sc);
1375*79d2c5e8SGleb Smirnoff 	} else if (sc->sc_running)
13765efea30fSAndrew Thompson 		ural_stop(sc);
137702ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
137802ac6454SAndrew Thompson 	if (startall)
137902ac6454SAndrew Thompson 		ieee80211_start_all(ic);
138002ac6454SAndrew Thompson }
138102ac6454SAndrew Thompson 
138202ac6454SAndrew Thompson static void
138302ac6454SAndrew Thompson ural_set_testmode(struct ural_softc *sc)
138402ac6454SAndrew Thompson {
1385760bc48eSAndrew Thompson 	struct usb_device_request req;
1386e0a69b51SAndrew Thompson 	usb_error_t error;
138702ac6454SAndrew Thompson 
138802ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
138902ac6454SAndrew Thompson 	req.bRequest = RAL_VENDOR_REQUEST;
139002ac6454SAndrew Thompson 	USETW(req.wValue, 4);
139102ac6454SAndrew Thompson 	USETW(req.wIndex, 1);
139202ac6454SAndrew Thompson 	USETW(req.wLength, 0);
139302ac6454SAndrew Thompson 
139402ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
139502ac6454SAndrew Thompson 	if (error != 0) {
139602ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not set test mode: %s\n",
1397a593f6b8SAndrew Thompson 		    usbd_errstr(error));
139802ac6454SAndrew Thompson 	}
139902ac6454SAndrew Thompson }
140002ac6454SAndrew Thompson 
140102ac6454SAndrew Thompson static void
140202ac6454SAndrew Thompson ural_eeprom_read(struct ural_softc *sc, uint16_t addr, void *buf, int len)
140302ac6454SAndrew Thompson {
1404760bc48eSAndrew Thompson 	struct usb_device_request req;
1405e0a69b51SAndrew Thompson 	usb_error_t error;
140602ac6454SAndrew Thompson 
140702ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
140802ac6454SAndrew Thompson 	req.bRequest = RAL_READ_EEPROM;
140902ac6454SAndrew Thompson 	USETW(req.wValue, 0);
141002ac6454SAndrew Thompson 	USETW(req.wIndex, addr);
141102ac6454SAndrew Thompson 	USETW(req.wLength, len);
141202ac6454SAndrew Thompson 
141302ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
141402ac6454SAndrew Thompson 	if (error != 0) {
141502ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1416a593f6b8SAndrew Thompson 		    usbd_errstr(error));
141702ac6454SAndrew Thompson 	}
141802ac6454SAndrew Thompson }
141902ac6454SAndrew Thompson 
142002ac6454SAndrew Thompson static uint16_t
142102ac6454SAndrew Thompson ural_read(struct ural_softc *sc, uint16_t reg)
142202ac6454SAndrew Thompson {
1423760bc48eSAndrew Thompson 	struct usb_device_request req;
1424e0a69b51SAndrew Thompson 	usb_error_t error;
142502ac6454SAndrew Thompson 	uint16_t val;
142602ac6454SAndrew Thompson 
142702ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
142802ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MAC;
142902ac6454SAndrew Thompson 	USETW(req.wValue, 0);
143002ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
143102ac6454SAndrew Thompson 	USETW(req.wLength, sizeof (uint16_t));
143202ac6454SAndrew Thompson 
143302ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, &val);
143402ac6454SAndrew Thompson 	if (error != 0) {
143502ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1436a593f6b8SAndrew Thompson 		    usbd_errstr(error));
143702ac6454SAndrew Thompson 		return 0;
143802ac6454SAndrew Thompson 	}
143902ac6454SAndrew Thompson 
144002ac6454SAndrew Thompson 	return le16toh(val);
144102ac6454SAndrew Thompson }
144202ac6454SAndrew Thompson 
144302ac6454SAndrew Thompson static void
144402ac6454SAndrew Thompson ural_read_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
144502ac6454SAndrew Thompson {
1446760bc48eSAndrew Thompson 	struct usb_device_request req;
1447e0a69b51SAndrew Thompson 	usb_error_t error;
144802ac6454SAndrew Thompson 
144902ac6454SAndrew Thompson 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
145002ac6454SAndrew Thompson 	req.bRequest = RAL_READ_MULTI_MAC;
145102ac6454SAndrew Thompson 	USETW(req.wValue, 0);
145202ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
145302ac6454SAndrew Thompson 	USETW(req.wLength, len);
145402ac6454SAndrew Thompson 
145502ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
145602ac6454SAndrew Thompson 	if (error != 0) {
145702ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read MAC register: %s\n",
1458a593f6b8SAndrew Thompson 		    usbd_errstr(error));
145902ac6454SAndrew Thompson 	}
146002ac6454SAndrew Thompson }
146102ac6454SAndrew Thompson 
146202ac6454SAndrew Thompson static void
146302ac6454SAndrew Thompson ural_write(struct ural_softc *sc, uint16_t reg, uint16_t val)
146402ac6454SAndrew Thompson {
1465760bc48eSAndrew Thompson 	struct usb_device_request req;
1466e0a69b51SAndrew Thompson 	usb_error_t error;
146702ac6454SAndrew Thompson 
146802ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
146902ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MAC;
147002ac6454SAndrew Thompson 	USETW(req.wValue, val);
147102ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
147202ac6454SAndrew Thompson 	USETW(req.wLength, 0);
147302ac6454SAndrew Thompson 
147402ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, NULL);
147502ac6454SAndrew Thompson 	if (error != 0) {
147602ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1477a593f6b8SAndrew Thompson 		    usbd_errstr(error));
147802ac6454SAndrew Thompson 	}
147902ac6454SAndrew Thompson }
148002ac6454SAndrew Thompson 
148102ac6454SAndrew Thompson static void
148202ac6454SAndrew Thompson ural_write_multi(struct ural_softc *sc, uint16_t reg, void *buf, int len)
148302ac6454SAndrew Thompson {
1484760bc48eSAndrew Thompson 	struct usb_device_request req;
1485e0a69b51SAndrew Thompson 	usb_error_t error;
148602ac6454SAndrew Thompson 
148702ac6454SAndrew Thompson 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
148802ac6454SAndrew Thompson 	req.bRequest = RAL_WRITE_MULTI_MAC;
148902ac6454SAndrew Thompson 	USETW(req.wValue, 0);
149002ac6454SAndrew Thompson 	USETW(req.wIndex, reg);
149102ac6454SAndrew Thompson 	USETW(req.wLength, len);
149202ac6454SAndrew Thompson 
149302ac6454SAndrew Thompson 	error = ural_do_request(sc, &req, buf);
149402ac6454SAndrew Thompson 	if (error != 0) {
149502ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write MAC register: %s\n",
1496a593f6b8SAndrew Thompson 		    usbd_errstr(error));
149702ac6454SAndrew Thompson 	}
149802ac6454SAndrew Thompson }
149902ac6454SAndrew Thompson 
150002ac6454SAndrew Thompson static void
150102ac6454SAndrew Thompson ural_bbp_write(struct ural_softc *sc, uint8_t reg, uint8_t val)
150202ac6454SAndrew Thompson {
150302ac6454SAndrew Thompson 	uint16_t tmp;
150402ac6454SAndrew Thompson 	int ntries;
150502ac6454SAndrew Thompson 
150602ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
150702ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
150802ac6454SAndrew Thompson 			break;
150902ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
151002ac6454SAndrew Thompson 			break;
151102ac6454SAndrew Thompson 	}
151202ac6454SAndrew Thompson 	if (ntries == 100) {
151302ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to BBP\n");
151402ac6454SAndrew Thompson 		return;
151502ac6454SAndrew Thompson 	}
151602ac6454SAndrew Thompson 
151702ac6454SAndrew Thompson 	tmp = reg << 8 | val;
151802ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, tmp);
151902ac6454SAndrew Thompson }
152002ac6454SAndrew Thompson 
152102ac6454SAndrew Thompson static uint8_t
152202ac6454SAndrew Thompson ural_bbp_read(struct ural_softc *sc, uint8_t reg)
152302ac6454SAndrew Thompson {
152402ac6454SAndrew Thompson 	uint16_t val;
152502ac6454SAndrew Thompson 	int ntries;
152602ac6454SAndrew Thompson 
152702ac6454SAndrew Thompson 	val = RAL_BBP_WRITE | reg << 8;
152802ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR7, val);
152902ac6454SAndrew Thompson 
153002ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
153102ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR8) & RAL_BBP_BUSY))
153202ac6454SAndrew Thompson 			break;
153302ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
153402ac6454SAndrew Thompson 			break;
153502ac6454SAndrew Thompson 	}
153602ac6454SAndrew Thompson 	if (ntries == 100) {
153702ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not read BBP\n");
153802ac6454SAndrew Thompson 		return 0;
153902ac6454SAndrew Thompson 	}
154002ac6454SAndrew Thompson 
154102ac6454SAndrew Thompson 	return ural_read(sc, RAL_PHY_CSR7) & 0xff;
154202ac6454SAndrew Thompson }
154302ac6454SAndrew Thompson 
154402ac6454SAndrew Thompson static void
154502ac6454SAndrew Thompson ural_rf_write(struct ural_softc *sc, uint8_t reg, uint32_t val)
154602ac6454SAndrew Thompson {
154702ac6454SAndrew Thompson 	uint32_t tmp;
154802ac6454SAndrew Thompson 	int ntries;
154902ac6454SAndrew Thompson 
155002ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
155102ac6454SAndrew Thompson 		if (!(ural_read(sc, RAL_PHY_CSR10) & RAL_RF_LOBUSY))
155202ac6454SAndrew Thompson 			break;
155302ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
155402ac6454SAndrew Thompson 			break;
155502ac6454SAndrew Thompson 	}
155602ac6454SAndrew Thompson 	if (ntries == 100) {
155702ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "could not write to RF\n");
155802ac6454SAndrew Thompson 		return;
155902ac6454SAndrew Thompson 	}
156002ac6454SAndrew Thompson 
156102ac6454SAndrew Thompson 	tmp = RAL_RF_BUSY | RAL_RF_20BIT | (val & 0xfffff) << 2 | (reg & 0x3);
156202ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR9,  tmp & 0xffff);
156302ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR10, tmp >> 16);
156402ac6454SAndrew Thompson 
156502ac6454SAndrew Thompson 	/* remember last written value in sc */
156602ac6454SAndrew Thompson 	sc->rf_regs[reg] = val;
156702ac6454SAndrew Thompson 
156802ac6454SAndrew Thompson 	DPRINTFN(15, "RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff);
156902ac6454SAndrew Thompson }
157002ac6454SAndrew Thompson 
157102ac6454SAndrew Thompson static void
157202ac6454SAndrew Thompson ural_scan_start(struct ieee80211com *ic)
157302ac6454SAndrew Thompson {
1574*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
157502ac6454SAndrew Thompson 
157602ac6454SAndrew Thompson 	RAL_LOCK(sc);
15775efea30fSAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
1578*79d2c5e8SGleb Smirnoff 	ural_set_bssid(sc, ieee80211broadcastaddr);
157902ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
158002ac6454SAndrew Thompson }
158102ac6454SAndrew Thompson 
158202ac6454SAndrew Thompson static void
158302ac6454SAndrew Thompson ural_scan_end(struct ieee80211com *ic)
158402ac6454SAndrew Thompson {
1585*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
158602ac6454SAndrew Thompson 
158702ac6454SAndrew Thompson 	RAL_LOCK(sc);
15885efea30fSAndrew Thompson 	ural_enable_tsf_sync(sc);
1589*79d2c5e8SGleb Smirnoff 	ural_set_bssid(sc, ic->ic_macaddr);
159002ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
159102ac6454SAndrew Thompson 
159202ac6454SAndrew Thompson }
159302ac6454SAndrew Thompson 
159402ac6454SAndrew Thompson static void
159502ac6454SAndrew Thompson ural_set_channel(struct ieee80211com *ic)
159602ac6454SAndrew Thompson {
1597*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
159802ac6454SAndrew Thompson 
159902ac6454SAndrew Thompson 	RAL_LOCK(sc);
16005efea30fSAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
160102ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
160202ac6454SAndrew Thompson }
160302ac6454SAndrew Thompson 
160402ac6454SAndrew Thompson static void
160502ac6454SAndrew Thompson ural_set_chan(struct ural_softc *sc, struct ieee80211_channel *c)
160602ac6454SAndrew Thompson {
1607*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
160802ac6454SAndrew Thompson 	uint8_t power, tmp;
160902ac6454SAndrew Thompson 	int i, chan;
161002ac6454SAndrew Thompson 
161102ac6454SAndrew Thompson 	chan = ieee80211_chan2ieee(ic, c);
161202ac6454SAndrew Thompson 	if (chan == 0 || chan == IEEE80211_CHAN_ANY)
161302ac6454SAndrew Thompson 		return;
161402ac6454SAndrew Thompson 
161502ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_2GHZ(c))
161602ac6454SAndrew Thompson 		power = min(sc->txpow[chan - 1], 31);
161702ac6454SAndrew Thompson 	else
161802ac6454SAndrew Thompson 		power = 31;
161902ac6454SAndrew Thompson 
162002ac6454SAndrew Thompson 	/* adjust txpower using ifconfig settings */
162102ac6454SAndrew Thompson 	power -= (100 - ic->ic_txpowlimit) / 8;
162202ac6454SAndrew Thompson 
162302ac6454SAndrew Thompson 	DPRINTFN(2, "setting channel to %u, txpower to %u\n", chan, power);
162402ac6454SAndrew Thompson 
162502ac6454SAndrew Thompson 	switch (sc->rf_rev) {
162602ac6454SAndrew Thompson 	case RAL_RF_2522:
162702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x00814);
162802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2522_r2[chan - 1]);
162902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
163002ac6454SAndrew Thompson 		break;
163102ac6454SAndrew Thompson 
163202ac6454SAndrew Thompson 	case RAL_RF_2523:
163302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
163402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2523_r2[chan - 1]);
163502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
163602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
163702ac6454SAndrew Thompson 		break;
163802ac6454SAndrew Thompson 
163902ac6454SAndrew Thompson 	case RAL_RF_2524:
164002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x0c808);
164102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2524_r2[chan - 1]);
164202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
164302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
164402ac6454SAndrew Thompson 		break;
164502ac6454SAndrew Thompson 
164602ac6454SAndrew Thompson 	case RAL_RF_2525:
164702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
164802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_hi_r2[chan - 1]);
164902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
165002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
165102ac6454SAndrew Thompson 
165202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
165302ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525_r2[chan - 1]);
165402ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
165502ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
165602ac6454SAndrew Thompson 		break;
165702ac6454SAndrew Thompson 
165802ac6454SAndrew Thompson 	case RAL_RF_2525E:
165902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08808);
166002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2525e_r2[chan - 1]);
166102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
166202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
166302ac6454SAndrew Thompson 		break;
166402ac6454SAndrew Thompson 
166502ac6454SAndrew Thompson 	case RAL_RF_2526:
166602ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_hi_r2[chan - 1]);
166702ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
166802ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, 0x08804);
166902ac6454SAndrew Thompson 
167002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf2526_r2[chan - 1]);
167102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
167202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
167302ac6454SAndrew Thompson 		break;
167402ac6454SAndrew Thompson 
167502ac6454SAndrew Thompson 	/* dual-band RF */
167602ac6454SAndrew Thompson 	case RAL_RF_5222:
167702ac6454SAndrew Thompson 		for (i = 0; ural_rf5222[i].chan != chan; i++);
167802ac6454SAndrew Thompson 
167902ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, ural_rf5222[i].r1);
168002ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF2, ural_rf5222[i].r2);
168102ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
168202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF4, ural_rf5222[i].r4);
168302ac6454SAndrew Thompson 		break;
168402ac6454SAndrew Thompson 	}
168502ac6454SAndrew Thompson 
168602ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR &&
168702ac6454SAndrew Thompson 	    (ic->ic_flags & IEEE80211_F_SCAN) == 0) {
168802ac6454SAndrew Thompson 		/* set Japan filter bit for channel 14 */
168902ac6454SAndrew Thompson 		tmp = ural_bbp_read(sc, 70);
169002ac6454SAndrew Thompson 
169102ac6454SAndrew Thompson 		tmp &= ~RAL_JAPAN_FILTER;
169202ac6454SAndrew Thompson 		if (chan == 14)
169302ac6454SAndrew Thompson 			tmp |= RAL_JAPAN_FILTER;
169402ac6454SAndrew Thompson 
169502ac6454SAndrew Thompson 		ural_bbp_write(sc, 70, tmp);
169602ac6454SAndrew Thompson 
169702ac6454SAndrew Thompson 		/* clear CRC errors */
169802ac6454SAndrew Thompson 		ural_read(sc, RAL_STA_CSR0);
169902ac6454SAndrew Thompson 
170002ac6454SAndrew Thompson 		ural_pause(sc, hz / 100);
170102ac6454SAndrew Thompson 		ural_disable_rf_tune(sc);
170202ac6454SAndrew Thompson 	}
170302ac6454SAndrew Thompson 
170402ac6454SAndrew Thompson 	/* XXX doesn't belong here */
170502ac6454SAndrew Thompson 	/* update basic rate set */
170602ac6454SAndrew Thompson 	ural_set_basicrates(sc, c);
170777ddf3d3SAndrew Thompson 
170877ddf3d3SAndrew Thompson 	/* give the hardware some time to do the switchover */
170977ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 100);
171002ac6454SAndrew Thompson }
171102ac6454SAndrew Thompson 
171202ac6454SAndrew Thompson /*
171302ac6454SAndrew Thompson  * Disable RF auto-tuning.
171402ac6454SAndrew Thompson  */
171502ac6454SAndrew Thompson static void
171602ac6454SAndrew Thompson ural_disable_rf_tune(struct ural_softc *sc)
171702ac6454SAndrew Thompson {
171802ac6454SAndrew Thompson 	uint32_t tmp;
171902ac6454SAndrew Thompson 
172002ac6454SAndrew Thompson 	if (sc->rf_rev != RAL_RF_2523) {
172102ac6454SAndrew Thompson 		tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
172202ac6454SAndrew Thompson 		ural_rf_write(sc, RAL_RF1, tmp);
172302ac6454SAndrew Thompson 	}
172402ac6454SAndrew Thompson 
172502ac6454SAndrew Thompson 	tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
172602ac6454SAndrew Thompson 	ural_rf_write(sc, RAL_RF3, tmp);
172702ac6454SAndrew Thompson 
172802ac6454SAndrew Thompson 	DPRINTFN(2, "disabling RF autotune\n");
172902ac6454SAndrew Thompson }
173002ac6454SAndrew Thompson 
173102ac6454SAndrew Thompson /*
173202ac6454SAndrew Thompson  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
173302ac6454SAndrew Thompson  * synchronization.
173402ac6454SAndrew Thompson  */
173502ac6454SAndrew Thompson static void
173602ac6454SAndrew Thompson ural_enable_tsf_sync(struct ural_softc *sc)
173702ac6454SAndrew Thompson {
1738*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
173902ac6454SAndrew Thompson 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
174002ac6454SAndrew Thompson 	uint16_t logcwmin, preload, tmp;
174102ac6454SAndrew Thompson 
174202ac6454SAndrew Thompson 	/* first, disable TSF synchronization */
174302ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, 0);
174402ac6454SAndrew Thompson 
174502ac6454SAndrew Thompson 	tmp = (16 * vap->iv_bss->ni_intval) << 4;
174602ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR18, tmp);
174702ac6454SAndrew Thompson 
174802ac6454SAndrew Thompson 	logcwmin = (ic->ic_opmode == IEEE80211_M_IBSS) ? 2 : 0;
174902ac6454SAndrew Thompson 	preload = (ic->ic_opmode == IEEE80211_M_IBSS) ? 320 : 6;
175002ac6454SAndrew Thompson 	tmp = logcwmin << 12 | preload;
175102ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR20, tmp);
175202ac6454SAndrew Thompson 
175302ac6454SAndrew Thompson 	/* finally, enable TSF synchronization */
175402ac6454SAndrew Thompson 	tmp = RAL_ENABLE_TSF | RAL_ENABLE_TBCN;
175502ac6454SAndrew Thompson 	if (ic->ic_opmode == IEEE80211_M_STA)
175602ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(1);
175702ac6454SAndrew Thompson 	else
175802ac6454SAndrew Thompson 		tmp |= RAL_ENABLE_TSF_SYNC(2) | RAL_ENABLE_BEACON_GENERATOR;
175902ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR19, tmp);
176002ac6454SAndrew Thompson 
176102ac6454SAndrew Thompson 	DPRINTF("enabling TSF synchronization\n");
176202ac6454SAndrew Thompson }
176302ac6454SAndrew Thompson 
17645463c4a4SSam Leffler static void
17655463c4a4SSam Leffler ural_enable_tsf(struct ural_softc *sc)
17665463c4a4SSam Leffler {
17675463c4a4SSam Leffler 	/* first, disable TSF synchronization */
17685463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, 0);
17695463c4a4SSam Leffler 	ural_write(sc, RAL_TXRX_CSR19, RAL_ENABLE_TSF | RAL_ENABLE_TSF_SYNC(2));
17705463c4a4SSam Leffler }
17715463c4a4SSam Leffler 
177202ac6454SAndrew Thompson #define RAL_RXTX_TURNAROUND	5	/* us */
177302ac6454SAndrew Thompson static void
1774*79d2c5e8SGleb Smirnoff ural_update_slot(struct ural_softc *sc)
177502ac6454SAndrew Thompson {
1776*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
177702ac6454SAndrew Thompson 	uint16_t slottime, sifs, eifs;
177802ac6454SAndrew Thompson 
177902ac6454SAndrew Thompson 	slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
178002ac6454SAndrew Thompson 
178102ac6454SAndrew Thompson 	/*
178202ac6454SAndrew Thompson 	 * These settings may sound a bit inconsistent but this is what the
178302ac6454SAndrew Thompson 	 * reference driver does.
178402ac6454SAndrew Thompson 	 */
178502ac6454SAndrew Thompson 	if (ic->ic_curmode == IEEE80211_MODE_11B) {
178602ac6454SAndrew Thompson 		sifs = 16 - RAL_RXTX_TURNAROUND;
178702ac6454SAndrew Thompson 		eifs = 364;
178802ac6454SAndrew Thompson 	} else {
178902ac6454SAndrew Thompson 		sifs = 10 - RAL_RXTX_TURNAROUND;
179002ac6454SAndrew Thompson 		eifs = 64;
179102ac6454SAndrew Thompson 	}
179202ac6454SAndrew Thompson 
179302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR10, slottime);
179402ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR11, sifs);
179502ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR12, eifs);
179602ac6454SAndrew Thompson }
179702ac6454SAndrew Thompson 
179802ac6454SAndrew Thompson static void
179902ac6454SAndrew Thompson ural_set_txpreamble(struct ural_softc *sc)
180002ac6454SAndrew Thompson {
1801*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
180202ac6454SAndrew Thompson 	uint16_t tmp;
180302ac6454SAndrew Thompson 
180402ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR10);
180502ac6454SAndrew Thompson 
180602ac6454SAndrew Thompson 	tmp &= ~RAL_SHORT_PREAMBLE;
180702ac6454SAndrew Thompson 	if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
180802ac6454SAndrew Thompson 		tmp |= RAL_SHORT_PREAMBLE;
180902ac6454SAndrew Thompson 
181002ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR10, tmp);
181102ac6454SAndrew Thompson }
181202ac6454SAndrew Thompson 
181302ac6454SAndrew Thompson static void
181402ac6454SAndrew Thompson ural_set_basicrates(struct ural_softc *sc, const struct ieee80211_channel *c)
181502ac6454SAndrew Thompson {
181602ac6454SAndrew Thompson 	/* XXX wrong, take from rate set */
181702ac6454SAndrew Thompson 	/* update basic rate set */
181802ac6454SAndrew Thompson 	if (IEEE80211_IS_CHAN_5GHZ(c)) {
181902ac6454SAndrew Thompson 		/* 11a basic rates: 6, 12, 24Mbps */
182002ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x150);
182102ac6454SAndrew Thompson 	} else if (IEEE80211_IS_CHAN_ANYG(c)) {
182202ac6454SAndrew Thompson 		/* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
182302ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x15f);
182402ac6454SAndrew Thompson 	} else {
182502ac6454SAndrew Thompson 		/* 11b basic rates: 1, 2Mbps */
182602ac6454SAndrew Thompson 		ural_write(sc, RAL_TXRX_CSR11, 0x3);
182702ac6454SAndrew Thompson 	}
182802ac6454SAndrew Thompson }
182902ac6454SAndrew Thompson 
183002ac6454SAndrew Thompson static void
183102ac6454SAndrew Thompson ural_set_bssid(struct ural_softc *sc, const uint8_t *bssid)
183202ac6454SAndrew Thompson {
183302ac6454SAndrew Thompson 	uint16_t tmp;
183402ac6454SAndrew Thompson 
183502ac6454SAndrew Thompson 	tmp = bssid[0] | bssid[1] << 8;
183602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR5, tmp);
183702ac6454SAndrew Thompson 
183802ac6454SAndrew Thompson 	tmp = bssid[2] | bssid[3] << 8;
183902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR6, tmp);
184002ac6454SAndrew Thompson 
184102ac6454SAndrew Thompson 	tmp = bssid[4] | bssid[5] << 8;
184202ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR7, tmp);
184302ac6454SAndrew Thompson 
184402ac6454SAndrew Thompson 	DPRINTF("setting BSSID to %6D\n", bssid, ":");
184502ac6454SAndrew Thompson }
184602ac6454SAndrew Thompson 
184702ac6454SAndrew Thompson static void
1848*79d2c5e8SGleb Smirnoff ural_set_macaddr(struct ural_softc *sc, const uint8_t *addr)
184902ac6454SAndrew Thompson {
185002ac6454SAndrew Thompson 	uint16_t tmp;
185102ac6454SAndrew Thompson 
185202ac6454SAndrew Thompson 	tmp = addr[0] | addr[1] << 8;
185302ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR2, tmp);
185402ac6454SAndrew Thompson 
185502ac6454SAndrew Thompson 	tmp = addr[2] | addr[3] << 8;
185602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR3, tmp);
185702ac6454SAndrew Thompson 
185802ac6454SAndrew Thompson 	tmp = addr[4] | addr[5] << 8;
185902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR4, tmp);
186002ac6454SAndrew Thompson 
186102ac6454SAndrew Thompson 	DPRINTF("setting MAC address to %6D\n", addr, ":");
186202ac6454SAndrew Thompson }
186302ac6454SAndrew Thompson 
186402ac6454SAndrew Thompson static void
18655efea30fSAndrew Thompson ural_setpromisc(struct ural_softc *sc)
186602ac6454SAndrew Thompson {
186702ac6454SAndrew Thompson 	uint32_t tmp;
186802ac6454SAndrew Thompson 
186902ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_TXRX_CSR2);
187002ac6454SAndrew Thompson 
187102ac6454SAndrew Thompson 	tmp &= ~RAL_DROP_NOT_TO_ME;
1872*79d2c5e8SGleb Smirnoff 	if (sc->sc_ic.ic_promisc == 0)
187302ac6454SAndrew Thompson 		tmp |= RAL_DROP_NOT_TO_ME;
187402ac6454SAndrew Thompson 
187502ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
187602ac6454SAndrew Thompson 
1877*79d2c5e8SGleb Smirnoff 	DPRINTF("%s promiscuous mode\n", sc->sc_ic.ic_promisc ?
187802ac6454SAndrew Thompson 	    "entering" : "leaving");
187902ac6454SAndrew Thompson }
188002ac6454SAndrew Thompson 
188177ddf3d3SAndrew Thompson static void
1882272f6adeSGleb Smirnoff ural_update_promisc(struct ieee80211com *ic)
188377ddf3d3SAndrew Thompson {
1884272f6adeSGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
188577ddf3d3SAndrew Thompson 
188677ddf3d3SAndrew Thompson 	RAL_LOCK(sc);
1887*79d2c5e8SGleb Smirnoff 	if (sc->sc_running)
18885efea30fSAndrew Thompson 		ural_setpromisc(sc);
188977ddf3d3SAndrew Thompson 	RAL_UNLOCK(sc);
189077ddf3d3SAndrew Thompson }
189177ddf3d3SAndrew Thompson 
189202ac6454SAndrew Thompson static const char *
189302ac6454SAndrew Thompson ural_get_rf(int rev)
189402ac6454SAndrew Thompson {
189502ac6454SAndrew Thompson 	switch (rev) {
189602ac6454SAndrew Thompson 	case RAL_RF_2522:	return "RT2522";
189702ac6454SAndrew Thompson 	case RAL_RF_2523:	return "RT2523";
189802ac6454SAndrew Thompson 	case RAL_RF_2524:	return "RT2524";
189902ac6454SAndrew Thompson 	case RAL_RF_2525:	return "RT2525";
190002ac6454SAndrew Thompson 	case RAL_RF_2525E:	return "RT2525e";
190102ac6454SAndrew Thompson 	case RAL_RF_2526:	return "RT2526";
190202ac6454SAndrew Thompson 	case RAL_RF_5222:	return "RT5222";
190302ac6454SAndrew Thompson 	default:		return "unknown";
190402ac6454SAndrew Thompson 	}
190502ac6454SAndrew Thompson }
190602ac6454SAndrew Thompson 
190702ac6454SAndrew Thompson static void
190802ac6454SAndrew Thompson ural_read_eeprom(struct ural_softc *sc)
190902ac6454SAndrew Thompson {
1910*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
191102ac6454SAndrew Thompson 	uint16_t val;
191202ac6454SAndrew Thompson 
191302ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_CONFIG0, &val, 2);
191402ac6454SAndrew Thompson 	val = le16toh(val);
191502ac6454SAndrew Thompson 	sc->rf_rev =   (val >> 11) & 0x7;
191602ac6454SAndrew Thompson 	sc->hw_radio = (val >> 10) & 0x1;
191702ac6454SAndrew Thompson 	sc->led_mode = (val >> 6)  & 0x7;
191802ac6454SAndrew Thompson 	sc->rx_ant =   (val >> 4)  & 0x3;
191902ac6454SAndrew Thompson 	sc->tx_ant =   (val >> 2)  & 0x3;
192002ac6454SAndrew Thompson 	sc->nb_ant =   val & 0x3;
192102ac6454SAndrew Thompson 
192202ac6454SAndrew Thompson 	/* read MAC address */
1923*79d2c5e8SGleb Smirnoff 	ural_eeprom_read(sc, RAL_EEPROM_ADDRESS, ic->ic_macaddr, 6);
192402ac6454SAndrew Thompson 
192502ac6454SAndrew Thompson 	/* read default values for BBP registers */
192602ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_BBP_BASE, sc->bbp_prom, 2 * 16);
192702ac6454SAndrew Thompson 
192802ac6454SAndrew Thompson 	/* read Tx power for all b/g channels */
192902ac6454SAndrew Thompson 	ural_eeprom_read(sc, RAL_EEPROM_TXPOWER, sc->txpow, 14);
193002ac6454SAndrew Thompson }
193102ac6454SAndrew Thompson 
193202ac6454SAndrew Thompson static int
193302ac6454SAndrew Thompson ural_bbp_init(struct ural_softc *sc)
193402ac6454SAndrew Thompson {
19356d917491SHans Petter Selasky #define N(a)	((int)(sizeof (a) / sizeof ((a)[0])))
193602ac6454SAndrew Thompson 	int i, ntries;
193702ac6454SAndrew Thompson 
193802ac6454SAndrew Thompson 	/* wait for BBP to be ready */
193902ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
194002ac6454SAndrew Thompson 		if (ural_bbp_read(sc, RAL_BBP_VERSION) != 0)
194102ac6454SAndrew Thompson 			break;
194202ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
194302ac6454SAndrew Thompson 			break;
194402ac6454SAndrew Thompson 	}
194502ac6454SAndrew Thompson 	if (ntries == 100) {
194602ac6454SAndrew Thompson 		device_printf(sc->sc_dev, "timeout waiting for BBP\n");
194702ac6454SAndrew Thompson 		return EIO;
194802ac6454SAndrew Thompson 	}
194902ac6454SAndrew Thompson 
195002ac6454SAndrew Thompson 	/* initialize BBP registers to default values */
195102ac6454SAndrew Thompson 	for (i = 0; i < N(ural_def_bbp); i++)
195202ac6454SAndrew Thompson 		ural_bbp_write(sc, ural_def_bbp[i].reg, ural_def_bbp[i].val);
195302ac6454SAndrew Thompson 
195402ac6454SAndrew Thompson #if 0
195502ac6454SAndrew Thompson 	/* initialize BBP registers to values stored in EEPROM */
195602ac6454SAndrew Thompson 	for (i = 0; i < 16; i++) {
195702ac6454SAndrew Thompson 		if (sc->bbp_prom[i].reg == 0xff)
195802ac6454SAndrew Thompson 			continue;
195902ac6454SAndrew Thompson 		ural_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
196002ac6454SAndrew Thompson 	}
196102ac6454SAndrew Thompson #endif
196202ac6454SAndrew Thompson 
196302ac6454SAndrew Thompson 	return 0;
196402ac6454SAndrew Thompson #undef N
196502ac6454SAndrew Thompson }
196602ac6454SAndrew Thompson 
196702ac6454SAndrew Thompson static void
196802ac6454SAndrew Thompson ural_set_txantenna(struct ural_softc *sc, int antenna)
196902ac6454SAndrew Thompson {
197002ac6454SAndrew Thompson 	uint16_t tmp;
197102ac6454SAndrew Thompson 	uint8_t tx;
197202ac6454SAndrew Thompson 
197302ac6454SAndrew Thompson 	tx = ural_bbp_read(sc, RAL_BBP_TX) & ~RAL_BBP_ANTMASK;
197402ac6454SAndrew Thompson 	if (antenna == 1)
197502ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTA;
197602ac6454SAndrew Thompson 	else if (antenna == 2)
197702ac6454SAndrew Thompson 		tx |= RAL_BBP_ANTB;
197802ac6454SAndrew Thompson 	else
197902ac6454SAndrew Thompson 		tx |= RAL_BBP_DIVERSITY;
198002ac6454SAndrew Thompson 
198102ac6454SAndrew Thompson 	/* need to force I/Q flip for RF 2525e, 2526 and 5222 */
198202ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526 ||
198302ac6454SAndrew Thompson 	    sc->rf_rev == RAL_RF_5222)
198402ac6454SAndrew Thompson 		tx |= RAL_BBP_FLIPIQ;
198502ac6454SAndrew Thompson 
198602ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_TX, tx);
198702ac6454SAndrew Thompson 
198802ac6454SAndrew Thompson 	/* update values in PHY_CSR5 and PHY_CSR6 */
198902ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR5) & ~0x7;
199002ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR5, tmp | (tx & 0x7));
199102ac6454SAndrew Thompson 
199202ac6454SAndrew Thompson 	tmp = ural_read(sc, RAL_PHY_CSR6) & ~0x7;
199302ac6454SAndrew Thompson 	ural_write(sc, RAL_PHY_CSR6, tmp | (tx & 0x7));
199402ac6454SAndrew Thompson }
199502ac6454SAndrew Thompson 
199602ac6454SAndrew Thompson static void
199702ac6454SAndrew Thompson ural_set_rxantenna(struct ural_softc *sc, int antenna)
199802ac6454SAndrew Thompson {
199902ac6454SAndrew Thompson 	uint8_t rx;
200002ac6454SAndrew Thompson 
200102ac6454SAndrew Thompson 	rx = ural_bbp_read(sc, RAL_BBP_RX) & ~RAL_BBP_ANTMASK;
200202ac6454SAndrew Thompson 	if (antenna == 1)
200302ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTA;
200402ac6454SAndrew Thompson 	else if (antenna == 2)
200502ac6454SAndrew Thompson 		rx |= RAL_BBP_ANTB;
200602ac6454SAndrew Thompson 	else
200702ac6454SAndrew Thompson 		rx |= RAL_BBP_DIVERSITY;
200802ac6454SAndrew Thompson 
200902ac6454SAndrew Thompson 	/* need to force no I/Q flip for RF 2525e and 2526 */
201002ac6454SAndrew Thompson 	if (sc->rf_rev == RAL_RF_2525E || sc->rf_rev == RAL_RF_2526)
201102ac6454SAndrew Thompson 		rx &= ~RAL_BBP_FLIPIQ;
201202ac6454SAndrew Thompson 
201302ac6454SAndrew Thompson 	ural_bbp_write(sc, RAL_BBP_RX, rx);
201402ac6454SAndrew Thompson }
201502ac6454SAndrew Thompson 
201602ac6454SAndrew Thompson static void
2017*79d2c5e8SGleb Smirnoff ural_init(struct ural_softc *sc)
201802ac6454SAndrew Thompson {
20196d917491SHans Petter Selasky #define N(a)	((int)(sizeof (a) / sizeof ((a)[0])))
2020*79d2c5e8SGleb Smirnoff 	struct ieee80211com *ic = &sc->sc_ic;
2021*79d2c5e8SGleb Smirnoff 	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
202202ac6454SAndrew Thompson 	uint16_t tmp;
202302ac6454SAndrew Thompson 	int i, ntries;
202402ac6454SAndrew Thompson 
202502ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
202602ac6454SAndrew Thompson 
202702ac6454SAndrew Thompson 	ural_set_testmode(sc);
202802ac6454SAndrew Thompson 	ural_write(sc, 0x308, 0x00f0);	/* XXX magic */
202902ac6454SAndrew Thompson 
20305efea30fSAndrew Thompson 	ural_stop(sc);
203102ac6454SAndrew Thompson 
203202ac6454SAndrew Thompson 	/* initialize MAC registers to default values */
203302ac6454SAndrew Thompson 	for (i = 0; i < N(ural_def_mac); i++)
203402ac6454SAndrew Thompson 		ural_write(sc, ural_def_mac[i].reg, ural_def_mac[i].val);
203502ac6454SAndrew Thompson 
203602ac6454SAndrew Thompson 	/* wait for BBP and RF to wake up (this can take a long time!) */
203702ac6454SAndrew Thompson 	for (ntries = 0; ntries < 100; ntries++) {
203802ac6454SAndrew Thompson 		tmp = ural_read(sc, RAL_MAC_CSR17);
203902ac6454SAndrew Thompson 		if ((tmp & (RAL_BBP_AWAKE | RAL_RF_AWAKE)) ==
204002ac6454SAndrew Thompson 		    (RAL_BBP_AWAKE | RAL_RF_AWAKE))
204102ac6454SAndrew Thompson 			break;
204202ac6454SAndrew Thompson 		if (ural_pause(sc, hz / 100))
204302ac6454SAndrew Thompson 			break;
204402ac6454SAndrew Thompson 	}
204502ac6454SAndrew Thompson 	if (ntries == 100) {
204602ac6454SAndrew Thompson 		device_printf(sc->sc_dev,
204702ac6454SAndrew Thompson 		    "timeout waiting for BBP/RF to wakeup\n");
204802ac6454SAndrew Thompson 		goto fail;
204902ac6454SAndrew Thompson 	}
205002ac6454SAndrew Thompson 
205102ac6454SAndrew Thompson 	/* we're ready! */
205202ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_HOST_READY);
205302ac6454SAndrew Thompson 
205402ac6454SAndrew Thompson 	/* set basic rate set (will be updated later) */
205502ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR11, 0x15f);
205602ac6454SAndrew Thompson 
205702ac6454SAndrew Thompson 	if (ural_bbp_init(sc) != 0)
205802ac6454SAndrew Thompson 		goto fail;
205902ac6454SAndrew Thompson 
206002ac6454SAndrew Thompson 	ural_set_chan(sc, ic->ic_curchan);
206102ac6454SAndrew Thompson 
206202ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
206302ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
206402ac6454SAndrew Thompson 
206502ac6454SAndrew Thompson 	ural_set_txantenna(sc, sc->tx_ant);
206602ac6454SAndrew Thompson 	ural_set_rxantenna(sc, sc->rx_ant);
206702ac6454SAndrew Thompson 
2068*79d2c5e8SGleb Smirnoff 	ural_set_macaddr(sc, vap ? vap->iv_myaddr : ic->ic_macaddr);
206902ac6454SAndrew Thompson 
207002ac6454SAndrew Thompson 	/*
207102ac6454SAndrew Thompson 	 * Allocate Tx and Rx xfer queues.
207202ac6454SAndrew Thompson 	 */
207302ac6454SAndrew Thompson 	ural_setup_tx_list(sc);
207402ac6454SAndrew Thompson 
207502ac6454SAndrew Thompson 	/* kick Rx */
207602ac6454SAndrew Thompson 	tmp = RAL_DROP_PHY | RAL_DROP_CRC;
207702ac6454SAndrew Thompson 	if (ic->ic_opmode != IEEE80211_M_MONITOR) {
207802ac6454SAndrew Thompson 		tmp |= RAL_DROP_CTL | RAL_DROP_BAD_VERSION;
207902ac6454SAndrew Thompson 		if (ic->ic_opmode != IEEE80211_M_HOSTAP)
208002ac6454SAndrew Thompson 			tmp |= RAL_DROP_TODS;
2081*79d2c5e8SGleb Smirnoff 		if (ic->ic_promisc == 0)
208202ac6454SAndrew Thompson 			tmp |= RAL_DROP_NOT_TO_ME;
208302ac6454SAndrew Thompson 	}
208402ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, tmp);
208502ac6454SAndrew Thompson 
2086*79d2c5e8SGleb Smirnoff 	sc->sc_running = 1;
2087ed6d949aSAndrew Thompson 	usbd_xfer_set_stall(sc->sc_xfer[URAL_BULK_WR]);
2088a593f6b8SAndrew Thompson 	usbd_transfer_start(sc->sc_xfer[URAL_BULK_RD]);
208902ac6454SAndrew Thompson 	return;
209002ac6454SAndrew Thompson 
20915efea30fSAndrew Thompson fail:	ural_stop(sc);
209202ac6454SAndrew Thompson #undef N
209302ac6454SAndrew Thompson }
209402ac6454SAndrew Thompson 
209502ac6454SAndrew Thompson static void
20965efea30fSAndrew Thompson ural_stop(struct ural_softc *sc)
209702ac6454SAndrew Thompson {
209802ac6454SAndrew Thompson 
209902ac6454SAndrew Thompson 	RAL_LOCK_ASSERT(sc, MA_OWNED);
210002ac6454SAndrew Thompson 
2101*79d2c5e8SGleb Smirnoff 	sc->sc_running = 0;
210202ac6454SAndrew Thompson 
210302ac6454SAndrew Thompson 	/*
210402ac6454SAndrew Thompson 	 * Drain all the transfers, if not already drained:
210502ac6454SAndrew Thompson 	 */
210602ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
2107a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_WR]);
2108a593f6b8SAndrew Thompson 	usbd_transfer_drain(sc->sc_xfer[URAL_BULK_RD]);
210902ac6454SAndrew Thompson 	RAL_LOCK(sc);
211002ac6454SAndrew Thompson 
211102ac6454SAndrew Thompson 	ural_unsetup_tx_list(sc);
211202ac6454SAndrew Thompson 
211302ac6454SAndrew Thompson 	/* disable Rx */
211402ac6454SAndrew Thompson 	ural_write(sc, RAL_TXRX_CSR2, RAL_DISABLE_RX);
211502ac6454SAndrew Thompson 	/* reset ASIC and BBP (but won't reset MAC registers!) */
211602ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, RAL_RESET_ASIC | RAL_RESET_BBP);
211702ac6454SAndrew Thompson 	/* wait a little */
211802ac6454SAndrew Thompson 	ural_pause(sc, hz / 10);
211902ac6454SAndrew Thompson 	ural_write(sc, RAL_MAC_CSR1, 0);
212077ddf3d3SAndrew Thompson 	/* wait a little */
212177ddf3d3SAndrew Thompson 	ural_pause(sc, hz / 10);
212202ac6454SAndrew Thompson }
212302ac6454SAndrew Thompson 
212402ac6454SAndrew Thompson static int
212502ac6454SAndrew Thompson ural_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
212602ac6454SAndrew Thompson 	const struct ieee80211_bpf_params *params)
212702ac6454SAndrew Thompson {
212802ac6454SAndrew Thompson 	struct ieee80211com *ic = ni->ni_ic;
2129*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
213002ac6454SAndrew Thompson 
213102ac6454SAndrew Thompson 	RAL_LOCK(sc);
213202ac6454SAndrew Thompson 	/* prevent management frames from being sent if we're not ready */
2133*79d2c5e8SGleb Smirnoff 	if (!sc->sc_running) {
213402ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
213502ac6454SAndrew Thompson 		m_freem(m);
213602ac6454SAndrew Thompson 		ieee80211_free_node(ni);
213702ac6454SAndrew Thompson 		return ENETDOWN;
213802ac6454SAndrew Thompson 	}
213996ca458fSAndrew Thompson 	if (sc->tx_nfree < RAL_TX_MINFREE) {
214002ac6454SAndrew Thompson 		RAL_UNLOCK(sc);
214102ac6454SAndrew Thompson 		m_freem(m);
214202ac6454SAndrew Thompson 		ieee80211_free_node(ni);
214302ac6454SAndrew Thompson 		return EIO;
214402ac6454SAndrew Thompson 	}
214502ac6454SAndrew Thompson 
214602ac6454SAndrew Thompson 	if (params == NULL) {
214702ac6454SAndrew Thompson 		/*
214802ac6454SAndrew Thompson 		 * Legacy path; interpret frame contents to decide
214902ac6454SAndrew Thompson 		 * precisely how to send the frame.
215002ac6454SAndrew Thompson 		 */
215102ac6454SAndrew Thompson 		if (ural_tx_mgt(sc, m, ni) != 0)
215202ac6454SAndrew Thompson 			goto bad;
215302ac6454SAndrew Thompson 	} else {
215402ac6454SAndrew Thompson 		/*
215502ac6454SAndrew Thompson 		 * Caller supplied explicit parameters to use in
215602ac6454SAndrew Thompson 		 * sending the frame.
215702ac6454SAndrew Thompson 		 */
215802ac6454SAndrew Thompson 		if (ural_tx_raw(sc, m, ni, params) != 0)
215902ac6454SAndrew Thompson 			goto bad;
216002ac6454SAndrew Thompson 	}
216102ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
216202ac6454SAndrew Thompson 	return 0;
216302ac6454SAndrew Thompson bad:
216402ac6454SAndrew Thompson 	RAL_UNLOCK(sc);
216502ac6454SAndrew Thompson 	ieee80211_free_node(ni);
216602ac6454SAndrew Thompson 	return EIO;		/* XXX */
216702ac6454SAndrew Thompson }
216802ac6454SAndrew Thompson 
216902ac6454SAndrew Thompson static void
2170b6108616SRui Paulo ural_ratectl_start(struct ural_softc *sc, struct ieee80211_node *ni)
217102ac6454SAndrew Thompson {
217202ac6454SAndrew Thompson 	struct ieee80211vap *vap = ni->ni_vap;
217302ac6454SAndrew Thompson 	struct ural_vap *uvp = URAL_VAP(vap);
217402ac6454SAndrew Thompson 
217502ac6454SAndrew Thompson 	/* clear statistic registers (STA_CSR0 to STA_CSR10) */
217602ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof sc->sta);
217702ac6454SAndrew Thompson 
2178b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
217902ac6454SAndrew Thompson }
218002ac6454SAndrew Thompson 
218102ac6454SAndrew Thompson static void
2182b6108616SRui Paulo ural_ratectl_timeout(void *arg)
218302ac6454SAndrew Thompson {
218402ac6454SAndrew Thompson 	struct ural_vap *uvp = arg;
21855efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
21865efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
218702ac6454SAndrew Thompson 
2188b6108616SRui Paulo 	ieee80211_runtask(ic, &uvp->ratectl_task);
218902ac6454SAndrew Thompson }
219002ac6454SAndrew Thompson 
219102ac6454SAndrew Thompson static void
2192b6108616SRui Paulo ural_ratectl_task(void *arg, int pending)
219302ac6454SAndrew Thompson {
21945efea30fSAndrew Thompson 	struct ural_vap *uvp = arg;
21955efea30fSAndrew Thompson 	struct ieee80211vap *vap = &uvp->vap;
21965efea30fSAndrew Thompson 	struct ieee80211com *ic = vap->iv_ic;
2197*79d2c5e8SGleb Smirnoff 	struct ural_softc *sc = ic->ic_softc;
21988d8bdb01SAndrew Thompson 	struct ieee80211_node *ni;
219902ac6454SAndrew Thompson 	int ok, fail;
2200b6108616SRui Paulo 	int sum, retrycnt;
220102ac6454SAndrew Thompson 
22028d8bdb01SAndrew Thompson 	ni = ieee80211_ref_node(vap->iv_bss);
22035efea30fSAndrew Thompson 	RAL_LOCK(sc);
220402ac6454SAndrew Thompson 	/* read and clear statistic registers (STA_CSR0 to STA_CSR10) */
220502ac6454SAndrew Thompson 	ural_read_multi(sc, RAL_STA_CSR0, sc->sta, sizeof(sc->sta));
220602ac6454SAndrew Thompson 
220702ac6454SAndrew Thompson 	ok = sc->sta[7] +		/* TX ok w/o retry */
220802ac6454SAndrew Thompson 	     sc->sta[8];		/* TX ok w/ retry */
220902ac6454SAndrew Thompson 	fail = sc->sta[9];		/* TX retry-fail count */
2210b6108616SRui Paulo 	sum = ok+fail;
2211b6108616SRui Paulo 	retrycnt = sc->sta[8] + fail;
221202ac6454SAndrew Thompson 
2213b6108616SRui Paulo 	ieee80211_ratectl_tx_update(vap, ni, &sum, &ok, &retrycnt);
2214b6108616SRui Paulo 	(void) ieee80211_ratectl_rate(ni, NULL, 0);
221502ac6454SAndrew Thompson 
2216*79d2c5e8SGleb Smirnoff 	/* count TX retry-fail as Tx errors */
2217*79d2c5e8SGleb Smirnoff 	if_inc_counter(ni->ni_vap->iv_ifp, IFCOUNTER_OERRORS, fail);
221802ac6454SAndrew Thompson 
2219b6108616SRui Paulo 	usb_callout_reset(&uvp->ratectl_ch, hz, ural_ratectl_timeout, uvp);
22205efea30fSAndrew Thompson 	RAL_UNLOCK(sc);
22218d8bdb01SAndrew Thompson 	ieee80211_free_node(ni);
222202ac6454SAndrew Thompson }
222302ac6454SAndrew Thompson 
222402ac6454SAndrew Thompson static int
222502ac6454SAndrew Thompson ural_pause(struct ural_softc *sc, int timeout)
222602ac6454SAndrew Thompson {
222702ac6454SAndrew Thompson 
2228a593f6b8SAndrew Thompson 	usb_pause_mtx(&sc->sc_mtx, timeout);
222902ac6454SAndrew Thompson 	return (0);
223002ac6454SAndrew Thompson }
2231