?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Introduced Tx QID pending mask in order to improve Tx interrupt handling
[ralink_drivers/rt2870_fbsd8.git] / rt2870.c
blob85a78d2d3059dd0de15f419c33552412a448777f
1
2 /*-
3 * Copyright (c) 2009-2010 Alexander Egorenkov <egorenar@gmail.com>
4 * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #include "rt2870_softc.h"
20 #include "rt2870_reg.h"
21 #include "rt2870_eeprom.h"
22 #include "rt2870_ucode.h"
23 #include "rt2870_rxwi.h"
24 #include "rt2870_rxinfo.h"
25 #include "rt2870_txinfo.h"
26 #include "rt2870_txwi.h"
27 #include "rt2870_read_eeprom.h"
28 #include "rt2870_io.h"
29 #include "rt2870_rf.h"
30 #include "rt2870_led.h"
31 #include "rt2870_debug.h"
32
33 /*
34 * Defines and macros
35 */
36
37 #define USB_PRODUCT_LINKSYS4_WUSB600N 0x0071
38 #define USB_PRODUCT_DLINK2_DWA140 0x3c09
39 #define USB_PRODUCT_DLINK2_DWA160AREVB 0x3c11
40 #define USB_PRODUCT_ASUS_RT2770F 0x1742
41 #define USB_PRODUCT_RALINK_RT2770 0x2770
42
43 #define RT2870_USB_CONFIG_INDEX 0
44 #define RT2870_USB_IFACE_INDEX 0
45
46 #define RT2870_USB_REQ_MAC_READ_MULTI 0x07
47
48 /* packet length + Rx wireless info + Rx info */
49 #define RT2870_RX_DESC_SIZE \
50 (sizeof(uint32_t) + sizeof(struct rt2870_rxwi) + sizeof(struct rt2870_rxinfo))
51
52 /* Tx info + Tx wireless info + max padding */
53 #define RT2870_TX_DESC_SIZE \
54 (sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + 11)
55
56 #define RT2870_MAX_AGG_SIZE 3840
57
58 #define RT2870_USB_RX_BULK_BUFLEN (2048 * 12)
59
60 #define RT2870_NOISE_FLOOR -95
61
62 #define RT2870_AID2WCID(aid) ((aid) & 0xff)
63
64 #define RT2870_ACK_SIZE 14
65
66 #define IEEE80211_HAS_ADDR4(wh) \
67 (((wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS)
68
69 #define RT2870_MS(_v, _f) (((_v) & _f) >> _f##_S)
70 #define RT2870_SM(_v, _f) (((_v) << _f##_S) & _f)
71
72 #define RT2870_USB_XFER_TIMEOUT 5000
73
74 #define RT2870_TX_WATCHDOG_TIMEOUT 5
75
76 /*
77 * Data structures and types
78 */
79
80 struct rt2870_cmd_argv_keydelete
81 {
82 struct ieee80211_key key;
83 uint16_t associd;
84 };
85
86 /*
87 * Static function prototypes
88 */
89
90 static void rt2870_init_channels(struct rt2870_softc *sc);
91
92 static void rt2870_init_channels_ht40(struct rt2870_softc *sc);
93
94 static void rt2870_init_locked(void *priv);
95
96 static void rt2870_init(void *priv);
97
98 static int rt2870_init_bbp(struct rt2870_softc *sc);
99
100 static void rt2870_stop_locked(void *priv);
101
102 static void rt2870_stop(void *priv);
103
104 static void rt2870_start(struct ifnet *ifp);
105
106 static int rt2870_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
107
108 static struct ieee80211vap *rt2870_vap_create(struct ieee80211com *ic,
109 const char name[IFNAMSIZ], int unit, int opmode, int flags,
110 const uint8_t bssid[IEEE80211_ADDR_LEN],
111 const uint8_t mac[IEEE80211_ADDR_LEN]);
112
113 static void rt2870_vap_delete(struct ieee80211vap *vap);
114
115 static int rt2870_vap_reset(struct ieee80211vap *vap, u_long cmd);
116
117 static int rt2870_vap_newstate(struct ieee80211vap *vap,
118 enum ieee80211_state nstate, int arg);
119
120 static void rt2870_vap_key_update_begin(struct ieee80211vap *vap);
121
122 static void rt2870_vap_key_update_end(struct ieee80211vap *vap);
123
124 static int rt2870_vap_key_set(struct ieee80211vap *vap,
125 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN]);
126
127 static int rt2870_vap_key_delete(struct ieee80211vap *vap,
128 const struct ieee80211_key *k);
129
130 static void rt2870_vap_update_beacon(struct ieee80211vap *vap, int what);
131
132 static struct ieee80211_node *rt2870_node_alloc(struct ieee80211vap *vap,
133 const uint8_t mac[IEEE80211_ADDR_LEN]);
134
135 static int rt2870_setregdomain(struct ieee80211com *ic,
136 struct ieee80211_regdomain *reg,
137 int nchans, struct ieee80211_channel chans[]);
138
139 static void rt2870_getradiocaps(struct ieee80211com *ic,
140 int maxchans, int *nchans, struct ieee80211_channel chans[]);
141
142 static void rt2870_scan_start(struct ieee80211com *ic);
143
144 static void rt2870_scan_end(struct ieee80211com *ic);
145
146 static void rt2870_set_channel(struct ieee80211com *ic);
147
148 static void rt2870_newassoc(struct ieee80211_node *ni, int isnew);
149
150 static void rt2870_updateslot(struct ifnet *ifp);
151
152 static void rt2870_update_promisc(struct ifnet *ifp);
153
154 static void rt2870_update_mcast(struct ifnet *ifp);
155
156 static int rt2870_wme_update(struct ieee80211com *ic);
157
158 static int rt2870_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
159 const struct ieee80211_bpf_params *params);
160
161 static int rt2870_recv_action(struct ieee80211_node *ni,
162 const struct ieee80211_frame *wh,
163 const uint8_t *frm, const uint8_t *efrm);
164
165 static int rt2870_send_action(struct ieee80211_node *ni,
166 int cat, int act, void *sa);
167
168 static void rt2870_amrr_update_iter_func(void *arg, struct ieee80211_node *ni);
169
170 static void rt2870_periodic(void *arg);
171
172 static void rt2870_tx_watchdog(void *arg);
173
174 static int rt2870_do_async(struct rt2870_softc *sc,
175 void (*cb)(struct rt2870_softc *sc, void *arg),
176 void *arg, int len);
177
178 static void rt2870_updateslot_cb(struct rt2870_softc *sc, void *arg);
179
180 static void rt2870_wme_update_cb(struct rt2870_softc *sc, void *arg);
181
182 static void rt2870_vap_key_delete_cb(struct rt2870_softc *sc, void *arg);
183
184 static void rt2870_vap_update_beacon_cb(struct rt2870_softc *sc, void *arg);
185
186 static void rt2870_asic_set_bssid(struct rt2870_softc *sc,
187 const uint8_t *bssid);
188
189 static void rt2870_asic_set_macaddr(struct rt2870_softc *sc,
190 const uint8_t *addr);
191
192 static void rt2870_asic_enable_tsf_sync(struct rt2870_softc *sc);
193
194 static void rt2870_asic_disable_tsf_sync(struct rt2870_softc *sc);
195
196 static void rt2870_asic_enable_mrr(struct rt2870_softc *sc);
197
198 static void rt2870_asic_set_txpreamble(struct rt2870_softc *sc);
199
200 static void rt2870_asic_set_basicrates(struct rt2870_softc *sc);
201
202 static void rt2870_asic_update_rtsthreshold(struct rt2870_softc *sc);
203
204 static void rt2870_asic_update_txpower(struct rt2870_softc *sc);
205
206 static void rt2870_asic_update_promisc(struct rt2870_softc *sc);
207
208 static void rt2870_asic_updateprot(struct rt2870_softc *sc);
209
210 static void rt2870_asic_updateslot(struct rt2870_softc *sc);
211
212 static void rt2870_asic_wme_update(struct rt2870_softc *sc);
213
214 static int rt2870_asic_update_beacon(struct rt2870_softc *sc,
215 struct ieee80211vap *vap);
216
217 static void rt2870_asic_clear_keytables(struct rt2870_softc *sc);
218
219 static uint8_t rt2870_rxrate(struct rt2870_rxwi *rxwi);
220
221 static uint8_t rt2870_maxrssi_rxpath(struct rt2870_softc *sc,
222 const struct rt2870_rxwi *rxwi);
223
224 static int8_t rt2870_rssi2dbm(struct rt2870_softc *sc,
225 uint8_t rssi, uint8_t rxpath);
226
227 static uint8_t rt2870_rate2mcs(uint8_t rate);
228
229 static void rt2870_rx_frame(struct rt2870_softc *sc,
230 uint8_t *buf, uint32_t dmalen);
231
232 static int rt2870_tx_mgmt(struct rt2870_softc *sc,
233 struct mbuf *m, struct ieee80211_node *ni, int qid);
234
235 static int rt2870_tx_data(struct rt2870_softc *sc,
236 struct mbuf *m, struct ieee80211_node *ni, int qid);
237
238 static int rt2870_tx_raw(struct rt2870_softc *sc,
239 struct mbuf *m, struct ieee80211_node *ni,
240 const struct ieee80211_bpf_params *params);
241
242 static void rt2870_rx_intr(struct usb_xfer *xfer, usb_error_t error);
243
244 static void rt2870_tx_intr(struct usb_xfer *xfer, usb_error_t error);
245
246 static void rt2870_rx_done_task(void *context, int pending);
247
248 static void rt2870_tx_done_task(void *context, int pending);
249
250 static void rt2870_periodic_task(void *context, int pending);
251
252 static void rt2870_cmd_task(void *context, int pending);
253
254 static int rt2870_rx_eof(struct rt2870_softc *sc, int limit);
255
256 static void rt2870_tx_eof(struct rt2870_softc *sc,
257 struct rt2870_softc_tx_ring *ring);
258
259 static void rt2870_update_stats(struct rt2870_softc *sc);
260
261 static void rt2870_watchdog(struct rt2870_softc *sc);
262
263 static void rt2870_drain_fifo_stats(struct rt2870_softc *sc);
264
265 static void rt2870_update_raw_counters(struct rt2870_softc *sc);
266
267 static int rt2870_txrx_enable(struct rt2870_softc *sc);
268
269 static int rt2870_alloc_rx_ring(struct rt2870_softc *sc,
270 struct rt2870_softc_rx_ring *ring);
271
272 static void rt2870_reset_rx_ring(struct rt2870_softc *sc,
273 struct rt2870_softc_rx_ring *ring);
274
275 static void rt2870_free_rx_ring(struct rt2870_softc *sc,
276 struct rt2870_softc_rx_ring *ring);
277
278 static int rt2870_alloc_tx_ring(struct rt2870_softc *sc,
279 struct rt2870_softc_tx_ring *ring, int qid);
280
281 static void rt2870_reset_tx_ring(struct rt2870_softc *sc,
282 struct rt2870_softc_tx_ring *ring);
283
284 static void rt2870_free_tx_ring(struct rt2870_softc *sc,
285 struct rt2870_softc_tx_ring *ring);
286
287 static void rt2870_reset_cmd_ring(struct rt2870_softc *sc,
288 struct rt2870_softc_cmd_ring *ring);
289
290 static void rt2870_sysctl_attach(struct rt2870_softc *sc);
291
292 /*
293 * Static variables
294 */
295
296 static const struct usb_device_id rt2870_usb_devid[] =
297 {
298 { USB_VP(USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_WUSB600N) }, /* Linksys WUSB600N */
299 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA140) }, /* D-Link DWA-140 */
300 { USB_VP(USB_VENDOR_DLINK2, USB_PRODUCT_DLINK2_DWA160AREVB) }, /* D-Link DWA-160A Rev. B */
301 { USB_VP(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_RT2770F) }, /* Asus RT2770F */
302 { USB_VP(USB_VENDOR_RALINK, USB_PRODUCT_RALINK_RT2770) }, /* Ralink RT2770 */
303 };
304
305 static const struct usb_config rt2870_usb_config[RT2870_SOFTC_USB_XFER_COUNT] =
306 {
307 {
308 .type = UE_BULK,
309 .endpoint = 0x01,
310 .direction = UE_DIR_IN,
311 .bufsize = RT2870_USB_RX_BULK_BUFLEN,
312 .flags = { .ext_buffer = 1, .pipe_bof = 1, .short_xfer_ok = 1, },
313 .callback = rt2870_rx_intr,
314 },
315 {
316 .type = UE_BULK,
317 .endpoint = 0x01,
318 .direction = UE_DIR_OUT,
319 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
320 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
321 .callback = rt2870_tx_intr,
322 .timeout = RT2870_USB_XFER_TIMEOUT,
323 },
324 {
325 .type = UE_BULK,
326 .endpoint = 0x02,
327 .direction = UE_DIR_OUT,
328 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
329 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
330 .callback = rt2870_tx_intr,
331 .timeout = RT2870_USB_XFER_TIMEOUT,
332 },
333 {
334 .type = UE_BULK,
335 .endpoint = 0x03,
336 .direction = UE_DIR_OUT,
337 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
338 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
339 .callback = rt2870_tx_intr,
340 .timeout = RT2870_USB_XFER_TIMEOUT,
341 },
342 {
343 .type = UE_BULK,
344 .endpoint = 0x04,
345 .direction = UE_DIR_OUT,
346 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
347 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
348 .callback = rt2870_tx_intr,
349 .timeout = RT2870_USB_XFER_TIMEOUT,
350 },
351 {
352 .type = UE_BULK,
353 .endpoint = 0x05,
354 .direction = UE_DIR_OUT,
355 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
356 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
357 .callback = rt2870_tx_intr,
358 .timeout = RT2870_USB_XFER_TIMEOUT,
359 },
360 {
361 .type = UE_BULK,
362 .endpoint = 0x06,
363 .direction = UE_DIR_OUT,
364 .bufsize = (RT2870_TX_DESC_SIZE + MJUMPAGESIZE),
365 .flags = { .ext_buffer = 1, .pipe_bof = 1, .force_short_xfer = 1, },
366 .callback = rt2870_tx_intr,
367 .timeout = RT2870_USB_XFER_TIMEOUT,
368 },
369 };
370
371 static const struct
372 {
373 uint32_t reg;
374 uint32_t val;
375 } rt2870_def_mac[] =
376 {
377 { RT2870_REG_PBF_BCN_OFFSET0, 0xf8f0e8e0 },
378 { RT2870_REG_PBF_BCN_OFFSET1, 0x6f77d0c8 },
379 { RT2870_REG_LEGACY_BASIC_RATE, 0x0000013f },
380 { RT2870_REG_HT_BASIC_RATE, 0x00008003 },
381 { RT2870_REG_SYS_CTRL, 0x00000000 },
382 { RT2870_REG_RX_FILTER_CFG, 0x00017f97 },
383 { RT2870_REG_BKOFF_SLOT_CFG, 0x00000209 },
384 { RT2870_REG_TX_SW_CFG0, 0x00000000 },
385 { RT2870_REG_TX_SW_CFG1, 0x00080606 },
386 { RT2870_REG_TX_LINK_CFG, 0x00001020 },
387 { RT2870_REG_TX_TIMEOUT_CFG, 0x000a2090 },
388 { RT2870_REG_MAX_LEN_CFG, (1 << 12) | RT2870_MAX_AGG_SIZE },
389 { RT2870_REG_LED_CFG, 0x7f031e46 },
390 { RT2870_REG_PBF_MAX_PCNT, 0x1f3fbf9f },
391 { RT2870_REG_TX_RTY_CFG, 0x47d01f0f },
392 { RT2870_REG_AUTO_RSP_CFG, 0x00000013 },
393 { RT2870_REG_TX_CCK_PROT_CFG, 0x05740003 },
394 { RT2870_REG_TX_OFDM_PROT_CFG, 0x05740003 },
395 { RT2870_REG_PBF_CFG, 0x00f40006 },
396 { RT2870_REG_TX_MM40_PROT_CFG, 0x03f44084 },
397 { RT2870_REG_SCHDMA_WPDMA_GLO_CFG, 0x00000030 },
398 { RT2870_REG_TX_GF20_PROT_CFG, 0x01744004 },
399 { RT2870_REG_TX_GF40_PROT_CFG, 0x03f44084 },
400 { RT2870_REG_TX_MM20_PROT_CFG, 0x01744004 },
401 { RT2870_REG_TX_TXOP_CTRL_CFG, 0x0000583f },
402 { RT2870_REG_TX_RTS_CFG, 0x00092b20 },
403 { RT2870_REG_TX_EXP_ACK_TIME, 0x002400ca },
404 { RT2870_REG_HCCAPSMP_TXOP_HLDR_ET, 0x00000002 },
405 { RT2870_REG_XIFS_TIME_CFG, 0x33a41010 },
406 { RT2870_REG_PWR_PIN_CFG, 0x00000003 },
407 { RT2870_REG_SCHDMA_WMM_AIFSN_CFG, 0x00002273 },
408 { RT2870_REG_SCHDMA_WMM_CWMIN_CFG, 0x00002344 },
409 { RT2870_REG_SCHDMA_WMM_CWMAX_CFG, 0x000034aa },
410 };
411
412 #define RT2870_DEF_MAC_SIZE (sizeof(rt2870_def_mac) / sizeof(rt2870_def_mac[0]))
413
414 static const struct
415 {
416 uint8_t reg;
417 uint8_t val;
418 } rt2870_def_bbp[] =
419 {
420 { 65, 0x2c },
421 { 66, 0x38 },
422 { 69, 0x12 },
423 { 70, 0x0a },
424 { 73, 0x10 },
425 { 81, 0x37 },
426 { 82, 0x62 },
427 { 83, 0x6a },
428 { 84, 0x99 },
429 { 86, 0x00 },
430 { 91, 0x04 },
431 { 92, 0x00 },
432 { 103, 0x00 },
433 { 105, 0x05 },
434 { 106, 0x35 },
435 };
436
437 #define RT2870_DEF_BBP_SIZE (sizeof(rt2870_def_bbp) / sizeof(rt2870_def_bbp[0]))
438
439 SYSCTL_NODE(_hw, OID_AUTO, rt2870, CTLFLAG_RD, 0, "RT2870 driver parameters");
440
441 #ifdef RT2870_DEBUG
442 static int rt2870_debug = 0;
443 SYSCTL_INT(_hw_rt2870, OID_AUTO, debug, CTLFLAG_RW, &rt2870_debug, 0, "rt2870 debug level");
444 TUNABLE_INT("hw.rt2870.debug", &rt2870_debug);
445 #endif
446
447 /*
448 * rt2870_probe
449 */
450 static int rt2870_probe(device_t dev)
451 {
452 struct usb_attach_arg *uaa;
453
454 uaa = device_get_ivars(dev);
455
456 if (uaa->usb_mode != USB_MODE_HOST)
457 return ENXIO;
458
459 if (uaa->info.bConfigIndex != RT2870_USB_CONFIG_INDEX)
460 return ENXIO;
461
462 if (uaa->info.bIfaceIndex != RT2870_USB_IFACE_INDEX)
463 return ENXIO;
464
465 return (usbd_lookup_id_by_uaa(rt2870_usb_devid,
466 sizeof(rt2870_usb_devid), uaa));
467 }
468
469 /*
470 * rt2870_attach
471 */
472 static int rt2870_attach(device_t dev)
473 {
474 struct rt2870_softc *sc;
475 struct usb_attach_arg *uaa;
476 usb_error_t usb_error;
477 struct ieee80211com *ic;
478 struct ifnet *ifp;
479 struct usb_interface *iface;
480 struct usb_interface_descriptor *iface_desc;
481 uint8_t iface_index;
482 int error, ntries, i;
483
484 sc = device_get_softc(dev);
485 uaa = device_get_ivars(dev);
486
487 sc->dev = dev;
488 sc->usb_dev = uaa->device;
489
490 device_set_usb_desc(dev);
491
492 #ifdef RT2870_DEBUG
493 sc->debug = rt2870_debug;
494
495 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
496 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
497 "debug", CTLFLAG_RW, &sc->debug, 0, "rt2870 debug level");
498 #endif
499
500 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
501 "%s: attaching\n",
502 device_get_nameunit(sc->dev));
503
504 iface_index = RT2870_USB_IFACE_INDEX;
505
506 iface = usbd_get_iface(uaa->device, iface_index);
507 if (iface == NULL)
508 {
509 printf("%s: could not get USB interface\n",
510 device_get_nameunit(sc->dev));
511 return ENXIO;
512 }
513
514 iface_desc = usbd_get_interface_descriptor(iface);
515 if (iface_desc == NULL)
516 {
517 printf("%s: could not get USB interface descriptor\n",
518 device_get_nameunit(sc->dev));
519 return ENXIO;
520 }
521
522 sc->usb_endpoints = iface_desc->bNumEndpoints;
523 if ((sc->usb_endpoints != RT2870_SOFTC_USB_XFER_COUNT) &&
524 (sc->usb_endpoints != RT2870_SOFTC_USB_XFER_COUNT - 2))
525 {
526 printf("%s: wrong number of USB endpoints=%d\n",
527 device_get_nameunit(sc->dev), sc->usb_endpoints);
528 return ENXIO;
529 }
530
531 mtx_init(&sc->lock, device_get_nameunit(dev),
532 MTX_NETWORK_LOCK, MTX_DEF);
533
534 usb_error = usbd_transfer_setup(uaa->device, &iface_index,
535 sc->usb_xfer, rt2870_usb_config, sc->usb_endpoints,
536 sc, &sc->lock);
537 if (usb_error != 0)
538 {
539 printf("%s: could not allocate USB transfers: error=%s\n",
540 device_get_nameunit(sc->dev), usbd_errstr(usb_error));
541 error = ENXIO;
542 goto fail;
543 }
544
545 RT2870_SOFTC_LOCK(sc);
546
547 for (ntries = 0; ntries < 100; ntries++)
548 {
549 sc->mac_rev = rt2870_io_mac_read(sc, RT2870_REG_MAC_CSR0);
550 if (sc->mac_rev != 0x00000000 && sc->mac_rev != 0xffffffff)
551 break;
552
553 DELAY(10);
554 }
555
556 if (ntries == 100)
557 {
558 printf("%s: timeout waiting for NIC to initialize\n",
559 device_get_nameunit(sc->dev));
560 error = ENXIO;
561 goto fail;
562 }
563
564 rt2870_read_eeprom(sc);
565
566 RT2870_SOFTC_UNLOCK(sc);
567
568 printf("%s: MAC/BBP RT2870 (rev 0x%08x), RF %s\n",
569 device_get_nameunit(sc->dev), sc->mac_rev,
570 rt2870_rf_name(sc->rf_rev));
571
572 /* allocate Tx and Rx rings */
573
574 for (i = 0; i < sc->usb_endpoints - 1; i++)
575 {
576 error = rt2870_alloc_tx_ring(sc, &sc->tx_ring[i], i);
577 if (error != 0)
578 {
579 printf("%s: could not allocate Tx ring #%d\n",
580 device_get_nameunit(sc->dev), i);
581 goto fail;
582 }
583 }
584
585 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
586 sc->tx_ring_mgtqid = 5;
587 else
588 sc->tx_ring_mgtqid = 0;
589
590 error = rt2870_alloc_rx_ring(sc, &sc->rx_ring);
591 if (error != 0)
592 {
593 printf("%s: could not allocate Rx ring\n",
594 device_get_nameunit(sc->dev));
595 goto fail;
596 }
597
598 callout_init(&sc->periodic_ch, 0);
599 callout_init_mtx(&sc->tx_watchdog_ch, &sc->lock, 0);
600
601 ifp = sc->ifp = if_alloc(IFT_IEEE80211);
602 if (ifp == NULL)
603 {
604 printf("%s: could not if_alloc()\n",
605 device_get_nameunit(sc->dev));
606 error = ENOMEM;
607 goto fail;
608 }
609
610 ifp->if_softc = sc;
611
612 if_initname(ifp, "rt2870", device_get_unit(sc->dev));
613
614 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
615
616 ifp->if_init = rt2870_init;
617 ifp->if_ioctl = rt2870_ioctl;
618 ifp->if_start = rt2870_start;
619
620 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
621 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
622 IFQ_SET_READY(&ifp->if_snd);
623
624 ic = ifp->if_l2com;
625
626 ic->ic_ifp = ifp;
627
628 ic->ic_phytype = IEEE80211_T_HT;
629 ic->ic_opmode = IEEE80211_M_STA;
630
631 ic->ic_caps = IEEE80211_C_MONITOR |
632 IEEE80211_C_IBSS |
633 IEEE80211_C_STA |
634 IEEE80211_C_AHDEMO |
635 IEEE80211_C_HOSTAP |
636 IEEE80211_C_WDS |
637 IEEE80211_C_MBSS |
638 /* IEEE80211_C_BGSCAN | */
639 IEEE80211_C_TXPMGT |
640 IEEE80211_C_SHPREAMBLE |
641 IEEE80211_C_SHSLOT |
642 IEEE80211_C_TXFRAG |
643 IEEE80211_C_BURST |
644 IEEE80211_C_WME |
645 IEEE80211_C_WPA;
646
647 ic->ic_cryptocaps |= IEEE80211_CRYPTO_WEP |
648 IEEE80211_CRYPTO_TKIP |
649 IEEE80211_CRYPTO_TKIPMIC |
650 IEEE80211_CRYPTO_AES_CCM;
651
652 ic->ic_htcaps = IEEE80211_HTC_HT |
653 IEEE80211_HTC_AMSDU | /* A-MSDU Tx */
654 IEEE80211_HTCAP_MAXAMSDU_3839 | /* max. A-MSDU Rx length */
655 IEEE80211_HTCAP_CHWIDTH40 | /* HT 40MHz channel width */
656 IEEE80211_HTCAP_GREENFIELD | /* HT greenfield */
657 IEEE80211_HTCAP_SHORTGI20 | /* HT 20MHz short GI */
658 IEEE80211_HTCAP_SHORTGI40 | /* HT 40MHz short GI */
659 IEEE80211_HTCAP_DSSSCCK40; /* HT 40MHz DSSS/CCK modulation */
660
661 /* spatial streams */
662
663 if (sc->nrxpath == 2)
664 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_2STREAM;
665 else if (sc->nrxpath == 3)
666 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_3STREAM;
667 else
668 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_1STREAM;
669
670 if (sc->ntxpath > 1)
671 ic->ic_htcaps |= IEEE80211_HTCAP_TXSTBC;
672
673 /* delayed BA */
674
675 if (sc->mac_rev != 0x28600100)
676 ic->ic_htcaps |= IEEE80211_HTCAP_DELBA;
677
678 /* init channels */
679
680 ic->ic_nchans = 0;
681
682 rt2870_init_channels(sc);
683
684 rt2870_init_channels_ht40(sc);
685
686 ieee80211_ifattach(ic, sc->mac_addr);
687
688 ic->ic_vap_create = rt2870_vap_create;
689 ic->ic_vap_delete = rt2870_vap_delete;
690
691 ic->ic_node_alloc = rt2870_node_alloc;
692 ic->ic_setregdomain = rt2870_setregdomain;
693 ic->ic_getradiocaps = rt2870_getradiocaps;
694 ic->ic_scan_start = rt2870_scan_start;
695 ic->ic_scan_end = rt2870_scan_end;
696 ic->ic_set_channel = rt2870_set_channel;
697 ic->ic_newassoc = rt2870_newassoc;
698 ic->ic_updateslot = rt2870_updateslot;
699 ic->ic_update_promisc = rt2870_update_promisc;
700 ic->ic_update_mcast = rt2870_update_mcast;
701 ic->ic_wme.wme_update = rt2870_wme_update;
702 ic->ic_raw_xmit = rt2870_raw_xmit;
703
704 sc->recv_action = ic->ic_recv_action;
705 ic->ic_recv_action = rt2870_recv_action;
706
707 sc->send_action = ic->ic_send_action;
708 ic->ic_send_action = rt2870_send_action;
709
710 /* hardware requires padding between 802.11 frame header and body */
711
712 ic->ic_flags |= IEEE80211_F_DATAPAD | IEEE80211_F_DOTH;
713
714 ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS;
715
716 ieee80211_radiotap_attach(ic,
717 &sc->txtap.ihdr, sizeof(sc->txtap),
718 RT2870_SOFTC_TX_RADIOTAP_PRESENT,
719 &sc->rxtap.ihdr, sizeof(sc->rxtap),
720 RT2870_SOFTC_RX_RADIOTAP_PRESENT);
721
722 /* init task queue */
723
724 TASK_INIT(&sc->rx_done_task, 0, rt2870_rx_done_task, sc);
725 TASK_INIT(&sc->tx_done_task, 0, rt2870_tx_done_task, sc);
726 TASK_INIT(&sc->periodic_task, 0, rt2870_periodic_task, sc);
727 TASK_INIT(&sc->cmd_task, 0, rt2870_cmd_task, sc);
728
729 sc->rx_process_limit = 100;
730
731 sc->taskqueue = taskqueue_create("rt2870_taskq", M_NOWAIT,
732 taskqueue_thread_enqueue, &sc->taskqueue);
733
734 taskqueue_start_threads(&sc->taskqueue, 1, PI_NET, "%s taskq",
735 device_get_nameunit(sc->dev));
736
737 rt2870_sysctl_attach(sc);
738
739 if (bootverbose)
740 ieee80211_announce(ic);
741
742 return 0;
743
744 fail:
745
746 /* stop all USB transfers */
747
748 usbd_transfer_unsetup(sc->usb_xfer, sc->usb_endpoints);
749
750 /* free Tx and Rx rings */
751
752 for (i = 0; i < sc->usb_endpoints - 1; i++)
753 rt2870_free_tx_ring(sc, &sc->tx_ring[i]);
754
755 rt2870_free_rx_ring(sc, &sc->rx_ring);
756
757 mtx_destroy(&sc->lock);
758
759 return error;
760 }
761
762 /*
763 * rt2870_detach
764 */
765 static int rt2870_detach(device_t dev)
766 {
767 struct rt2870_softc *sc;
768 struct ieee80211com *ic;
769 struct ifnet *ifp;
770 int i;
771
772 if (!device_is_attached(dev))
773 return 0;
774
775 sc = device_get_softc(dev);
776 ifp = sc->ifp;
777 ic = ifp->if_l2com;
778
779 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
780 "%s: detaching\n",
781 device_get_nameunit(sc->dev));
782
783 RT2870_SOFTC_LOCK(sc);
784
785 sc->tx_timer = 0;
786
787 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
788
789 callout_stop(&sc->periodic_ch);
790 callout_stop(&sc->tx_watchdog_ch);
791
792 RT2870_SOFTC_UNLOCK(sc);
793
794 taskqueue_block(sc->taskqueue);
795
796 taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
797 taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
798 taskqueue_drain(sc->taskqueue, &sc->periodic_task);
799 taskqueue_drain(sc->taskqueue, &sc->cmd_task);
800
801 /* stop all USB transfers */
802
803 usbd_transfer_unsetup(sc->usb_xfer, sc->usb_endpoints);
804
805 RT2870_SOFTC_LOCK(sc);
806
807 /* free Tx and Rx rings */
808
809 for (i = 0; i < sc->usb_endpoints - 1; i++)
810 rt2870_free_tx_ring(sc, &sc->tx_ring[i]);
811
812 rt2870_free_rx_ring(sc, &sc->rx_ring);
813
814 RT2870_SOFTC_UNLOCK(sc);
815
816 ieee80211_ifdetach(ic);
817
818 if_free(ifp);
819
820 taskqueue_free(sc->taskqueue);
821
822 mtx_destroy(&sc->lock);
823
824 return 0;
825 }
826
827 /*
828 * rt2870_init_channels
829 */
830 static void rt2870_init_channels(struct rt2870_softc *sc)
831 {
832 struct ifnet *ifp;
833 struct ieee80211com *ic;
834 struct ieee80211_channel *c;
835 int i, flags;
836
837 ifp = sc->ifp;
838 ic = ifp->if_l2com;
839
840 /* set supported channels for 2GHz band */
841
842 for (i = 1; i <= 14; i++)
843 {
844 c = &ic->ic_channels[ic->ic_nchans++];
845 flags = IEEE80211_CHAN_B;
846
847 c->ic_freq = ieee80211_ieee2mhz(i, flags);
848 c->ic_ieee = i;
849 c->ic_flags = flags;
850
851 c = &ic->ic_channels[ic->ic_nchans++];
852 flags = IEEE80211_CHAN_B | IEEE80211_CHAN_HT20;
853
854 c->ic_freq = ieee80211_ieee2mhz(i, flags);
855 c->ic_ieee = i;
856 c->ic_flags = flags;
857
858 c = &ic->ic_channels[ic->ic_nchans++];
859 flags = IEEE80211_CHAN_G;
860
861 c->ic_freq = ieee80211_ieee2mhz(i, flags);
862 c->ic_ieee = i;
863 c->ic_flags = flags;
864
865 c = &ic->ic_channels[ic->ic_nchans++];
866 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT20;
867
868 c->ic_freq = ieee80211_ieee2mhz(i, flags);
869 c->ic_ieee = i;
870 c->ic_flags = flags;
871 }
872
873 /* set supported channels for 5GHz band */
874
875 if (sc->rf_rev == RT2870_EEPROM_RF_2850 ||
876 sc->rf_rev == RT2870_EEPROM_RF_2750)
877 {
878 for (i = 36; i <= 64; i += 4)
879 {
880 c = &ic->ic_channels[ic->ic_nchans++];
881 flags = IEEE80211_CHAN_A;
882
883 c->ic_freq = ieee80211_ieee2mhz(i, flags);
884 c->ic_ieee = i;
885 c->ic_flags = flags;
886
887 c = &ic->ic_channels[ic->ic_nchans++];
888 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
889
890 c->ic_freq = ieee80211_ieee2mhz(i, flags);
891 c->ic_ieee = i;
892 c->ic_flags = flags;
893 }
894
895 for (i = 100; i <= 140; i += 4)
896 {
897 c = &ic->ic_channels[ic->ic_nchans++];
898 flags = IEEE80211_CHAN_A;
899
900 c->ic_freq = ieee80211_ieee2mhz(i, flags);
901 c->ic_ieee = i;
902 c->ic_flags = flags;
903
904 c = &ic->ic_channels[ic->ic_nchans++];
905 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
906
907 c->ic_freq = ieee80211_ieee2mhz(i, flags);
908 c->ic_ieee = i;
909 c->ic_flags = flags;
910 }
911
912 for (i = 149; i <= 165; i += 4)
913 {
914 c = &ic->ic_channels[ic->ic_nchans++];
915 flags = IEEE80211_CHAN_A;
916
917 c->ic_freq = ieee80211_ieee2mhz(i, flags);
918 c->ic_ieee = i;
919 c->ic_flags = flags;
920
921 c = &ic->ic_channels[ic->ic_nchans++];
922 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
923
924 c->ic_freq = ieee80211_ieee2mhz(i, flags);
925 c->ic_ieee = i;
926 c->ic_flags = flags;
927 }
928 }
929 }
930
931 /*
932 * rt2870_init_channels_ht40
933 */
934 static void rt2870_init_channels_ht40(struct rt2870_softc *sc)
935 {
936 struct ifnet *ifp;
937 struct ieee80211com *ic;
938 struct ieee80211_channel *c, *cent, *ext;
939 int i, flags;
940
941 ifp = sc->ifp;
942 ic = ifp->if_l2com;
943
944 /* set supported channels for 2GHz band */
945
946 for (i = 1; i <= 14; i++)
947 {
948 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40;
949
950 /* find the center channel */
951
952 cent = ieee80211_find_channel_byieee(ic, i,
953 flags & ~IEEE80211_CHAN_HT);
954 if (cent == NULL)
955 {
956 printf("%s: skip channel %d, could not find center channel\n",
957 device_get_nameunit(sc->dev), i);
958 continue;
959 }
960
961 /* find the extension channel */
962
963 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
964 flags & ~IEEE80211_CHAN_HT);
965 if (ext == NULL)
966 {
967 printf("%s: skip channel %d, could not find extension channel\n",
968 device_get_nameunit(sc->dev), i);
969 continue;
970 }
971
972 c = &ic->ic_channels[ic->ic_nchans++];
973
974 *c = *cent;
975 c->ic_extieee = ext->ic_ieee;
976 c->ic_flags &= ~IEEE80211_CHAN_HT;
977 c->ic_flags |= IEEE80211_CHAN_HT40U;
978
979 c = &ic->ic_channels[ic->ic_nchans++];
980
981 *c = *ext;
982 c->ic_extieee = cent->ic_ieee;
983 c->ic_flags &= ~IEEE80211_CHAN_HT;
984 c->ic_flags |= IEEE80211_CHAN_HT40D;
985 }
986
987 /* set supported channels for 5GHz band */
988
989 if (sc->rf_rev == RT2870_EEPROM_RF_2850 ||
990 sc->rf_rev == RT2870_EEPROM_RF_2750)
991 {
992 for (i = 36; i <= 64; i += 4)
993 {
994 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
995
996 /* find the center channel */
997
998 cent = ieee80211_find_channel_byieee(ic, i,
999 flags & ~IEEE80211_CHAN_HT);
1000 if (cent == NULL)
1001 {
1002 printf("%s: skip channel %d, could not find center channel\n",
1003 device_get_nameunit(sc->dev), i);
1004 continue;
1005 }
1006
1007 /* find the extension channel */
1008
1009 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1010 flags & ~IEEE80211_CHAN_HT);
1011 if (ext == NULL)
1012 {
1013 printf("%s: skip channel %d, could not find extension channel\n",
1014 device_get_nameunit(sc->dev), i);
1015 continue;
1016 }
1017
1018 c = &ic->ic_channels[ic->ic_nchans++];
1019
1020 *c = *cent;
1021 c->ic_extieee = ext->ic_ieee;
1022 c->ic_flags &= ~IEEE80211_CHAN_HT;
1023 c->ic_flags |= IEEE80211_CHAN_HT40U;
1024
1025 c = &ic->ic_channels[ic->ic_nchans++];
1026
1027 *c = *ext;
1028 c->ic_extieee = cent->ic_ieee;
1029 c->ic_flags &= ~IEEE80211_CHAN_HT;
1030 c->ic_flags |= IEEE80211_CHAN_HT40D;
1031 }
1032
1033 for (i = 100; i <= 140; i += 4)
1034 {
1035 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1036
1037 /* find the center channel */
1038
1039 cent = ieee80211_find_channel_byieee(ic, i,
1040 flags & ~IEEE80211_CHAN_HT);
1041 if (cent == NULL)
1042 {
1043 printf("%s: skip channel %d, could not find center channel\n",
1044 device_get_nameunit(sc->dev), i);
1045 continue;
1046 }
1047
1048 /* find the extension channel */
1049
1050 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1051 flags & ~IEEE80211_CHAN_HT);
1052 if (ext == NULL)
1053 {
1054 printf("%s: skip channel %d, could not find extension channel\n",
1055 device_get_nameunit(sc->dev), i);
1056 continue;
1057 }
1058
1059 c = &ic->ic_channels[ic->ic_nchans++];
1060
1061 *c = *cent;
1062 c->ic_extieee = ext->ic_ieee;
1063 c->ic_flags &= ~IEEE80211_CHAN_HT;
1064 c->ic_flags |= IEEE80211_CHAN_HT40U;
1065
1066 c = &ic->ic_channels[ic->ic_nchans++];
1067
1068 *c = *ext;
1069 c->ic_extieee = cent->ic_ieee;
1070 c->ic_flags &= ~IEEE80211_CHAN_HT;
1071 c->ic_flags |= IEEE80211_CHAN_HT40D;
1072 }
1073
1074 for (i = 149; i <= 165; i += 4)
1075 {
1076 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1077
1078 /* find the center channel */
1079
1080 cent = ieee80211_find_channel_byieee(ic, i,
1081 flags & ~IEEE80211_CHAN_HT);
1082 if (cent == NULL)
1083 {
1084 printf("%s: skip channel %d, could not find center channel\n",
1085 device_get_nameunit(sc->dev), i);
1086 continue;
1087 }
1088
1089 /* find the extension channel */
1090
1091 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1092 flags & ~IEEE80211_CHAN_HT);
1093 if (ext == NULL)
1094 {
1095 printf("%s: skip channel %d, could not find extension channel\n",
1096 device_get_nameunit(sc->dev), i);
1097 continue;
1098 }
1099
1100 c = &ic->ic_channels[ic->ic_nchans++];
1101
1102 *c = *cent;
1103 c->ic_extieee = ext->ic_ieee;
1104 c->ic_flags &= ~IEEE80211_CHAN_HT;
1105 c->ic_flags |= IEEE80211_CHAN_HT40U;
1106
1107 c = &ic->ic_channels[ic->ic_nchans++];
1108
1109 *c = *ext;
1110 c->ic_extieee = cent->ic_ieee;
1111 c->ic_flags &= ~IEEE80211_CHAN_HT;
1112 c->ic_flags |= IEEE80211_CHAN_HT40D;
1113 }
1114 }
1115 }
1116
1117 /*
1118 * rt2870_init_locked
1119 */
1120 static void rt2870_init_locked(void *priv)
1121 {
1122 struct rt2870_softc *sc;
1123 struct ifnet *ifp;
1124 struct ieee80211com *ic;
1125 int ntries, error, i;
1126 uint32_t tmp, stacnt[6];
1127
1128 sc = priv;
1129 ifp = sc->ifp;
1130 ic = ifp->if_l2com;
1131
1132 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1133 "%s: initializing\n",
1134 device_get_nameunit(sc->dev));
1135
1136 RT2870_SOFTC_ASSERT_LOCKED(sc);
1137
1138 if (!(sc->flags & RT2870_SOFTC_FLAGS_UCODE_LOADED))
1139 {
1140 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1141 "%s: loading 8051 microcode\n",
1142 device_get_nameunit(sc->dev));
1143
1144 error = rt2870_io_mcu_load_ucode(sc, rt2870_ucode, sizeof(rt2870_ucode));
1145 if (error != 0)
1146 {
1147 printf("%s: could not load 8051 microcode\n",
1148 device_get_nameunit(sc->dev));
1149 goto fail;
1150 }
1151
1152 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1153 "%s: 8051 microcode was successfully loaded\n",
1154 device_get_nameunit(sc->dev));
1155
1156 sc->flags |= RT2870_SOFTC_FLAGS_UCODE_LOADED;
1157 }
1158
1159 /* wait while DMA engine is busy */
1160
1161 for (ntries = 0; ntries < 100; ntries++)
1162 {
1163 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG);
1164 if (!(tmp & (RT2870_REG_TX_DMA_BUSY | RT2870_REG_RX_DMA_BUSY)))
1165 break;
1166
1167 DELAY(1000);
1168 }
1169
1170 if (ntries == 100)
1171 {
1172 printf("%s: timeout waiting for DMA engine\n",
1173 device_get_nameunit(sc->dev));
1174 goto fail;
1175 }
1176
1177 tmp &= 0xff0;
1178 tmp |= RT2870_REG_TX_WB_DDONE;
1179
1180 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
1181
1182 /* PBF hardware reset */
1183
1184 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_SYS_CTRL);
1185
1186 tmp &= ~(1 << 13);
1187
1188 rt2870_io_mac_write(sc, RT2870_REG_PBF_SYS_CTRL, tmp);
1189
1190 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
1191 RT2870_REG_MAC_SRST | RT2870_REG_BBP_HRST);
1192
1193 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, 0);
1194
1195 rt2870_io_mcu_reset(sc);
1196
1197 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, 0);
1198
1199 /* init Tx power per rate */
1200
1201 for (i = 0; i < RT2870_SOFTC_TXPOW_RATE_COUNT; i++)
1202 {
1203 if (sc->txpow_rate_20mhz[i] == 0xffffffff)
1204 continue;
1205
1206 rt2870_io_mac_write(sc, RT2870_REG_TX_PWR_CFG(i),
1207 sc->txpow_rate_20mhz[i]);
1208 }
1209
1210 for (i = 0; i < RT2870_DEF_MAC_SIZE; i++)
1211 rt2870_io_mac_write(sc, rt2870_def_mac[i].reg,
1212 rt2870_def_mac[i].val);
1213
1214 /* wait while MAC is busy */
1215
1216 for (ntries = 0; ntries < 100; ntries++)
1217 {
1218 if (!(rt2870_io_mac_read(sc, RT2870_REG_STATUS_CFG) &
1219 (RT2870_REG_STATUS_TX_BUSY | RT2870_REG_STATUS_RX_BUSY)))
1220 break;
1221
1222 DELAY(1000);
1223 }
1224
1225 if (ntries == 100)
1226 {
1227 printf("%s: timeout waiting for MAC\n",
1228 device_get_nameunit(sc->dev));
1229 goto fail;
1230 }
1231
1232 /* clear Host to MCU mailbox */
1233
1234 rt2870_io_mac_write(sc, RT2870_REG_H2M_MAILBOX_BBP_AGENT, 0);
1235 rt2870_io_mac_write(sc, RT2870_REG_H2M_MAILBOX, 0);
1236
1237 DELAY(1000);
1238
1239 error = rt2870_init_bbp(sc);
1240 if (error != 0)
1241 goto fail;
1242
1243 /* set up maximum buffer sizes */
1244
1245 tmp = (1 << 12) | RT2870_MAX_AGG_SIZE;
1246
1247 rt2870_io_mac_write(sc, RT2870_REG_MAX_LEN_CFG, tmp);
1248
1249 if (sc->mac_rev == 0x28720200)
1250 {
1251 /* set max. PSDU length from 16K to 32K bytes */
1252
1253 tmp = rt2870_io_mac_read(sc, RT2870_REG_MAX_LEN_CFG);
1254
1255 tmp &= ~(3 << 12);
1256 tmp |= (2 << 12);
1257
1258 rt2870_io_mac_write(sc, RT2870_REG_MAX_LEN_CFG, tmp);
1259 }
1260
1261 if (sc->mac_rev >= 0x28720200 && sc->mac_rev < 0x30700200)
1262 {
1263 tmp = rt2870_io_mac_read(sc, RT2870_REG_MAX_LEN_CFG);
1264
1265 tmp &= 0xfff;
1266 tmp |= 0x2000;
1267
1268 rt2870_io_mac_write(sc, RT2870_REG_MAX_LEN_CFG, tmp);
1269 }
1270
1271 /* set mac address */
1272
1273 rt2870_asic_set_macaddr(sc, IF_LLADDR(ifp));
1274
1275 /* clear statistic registers */
1276
1277 rt2870_io_mac_read_multi(sc, RT2870_REG_RX_STA_CNT0,
1278 stacnt, sizeof(stacnt));
1279
1280 /* send LEDs operating mode to microcontroller */
1281
1282 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_LED1,
1283 RT2870_REG_H2M_TOKEN_NO_INTR, sc->led_off[0]);
1284 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_LED2,
1285 RT2870_REG_H2M_TOKEN_NO_INTR, sc->led_off[1]);
1286 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_LED3,
1287 RT2870_REG_H2M_TOKEN_NO_INTR, sc->led_off[2]);
1288
1289 /* write vendor-specific BBP values (from EEPROM) */
1290
1291 for (i = 0; i < RT2870_SOFTC_BBP_EEPROM_COUNT; i++)
1292 {
1293 if (sc->bbp_eeprom[i].reg == 0x00 ||
1294 sc->bbp_eeprom[i].reg == 0xff)
1295 continue;
1296
1297 rt2870_io_bbp_write(sc, sc->bbp_eeprom[i].reg,
1298 sc->bbp_eeprom[i].val);
1299 }
1300
1301 /* disable non-existing Rx chains */
1302
1303 tmp = rt2870_io_bbp_read(sc, 3);
1304
1305 tmp &= ~((1 << 4) | (1 << 3));
1306
1307 if (sc->nrxpath == 3)
1308 tmp |= (1 << 4);
1309 else if (sc->nrxpath == 2)
1310 tmp |= (1 << 3);
1311
1312 rt2870_io_bbp_write(sc, 3, tmp);
1313
1314 /* disable non-existing Tx chains */
1315
1316 tmp = rt2870_io_bbp_read(sc, 1);
1317
1318 tmp &= ~((1 << 4) | (1 << 3));
1319
1320 if (sc->ntxpath == 2)
1321 tmp |= (1 << 4);
1322
1323 rt2870_io_bbp_write(sc, 1, tmp);
1324
1325 /* set current channel */
1326
1327 rt2870_rf_set_chan(sc, ic->ic_curchan);
1328
1329 /* turn radio LED on */
1330
1331 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_ON);
1332
1333 rt2870_io_mcu_cmd(sc, RT2870_IO_MCU_CMD_BOOT,
1334 RT2870_REG_H2M_TOKEN_NO_INTR, 0);
1335
1336 /* set RTS threshold */
1337
1338 rt2870_asic_update_rtsthreshold(sc);
1339
1340 /* set Tx power */
1341
1342 rt2870_asic_update_txpower(sc);
1343
1344 /* set up protection mode */
1345
1346 rt2870_asic_updateprot(sc);
1347
1348 /* clear key tables */
1349
1350 rt2870_asic_clear_keytables(sc);
1351
1352 if (rt2870_txrx_enable(sc) != 0)
1353 goto fail;
1354
1355 /* clear garbage interrupts */
1356
1357 tmp = rt2870_io_mac_read(sc, 0x1300);
1358
1359 taskqueue_unblock(sc->taskqueue);
1360
1361 /* init Tx and Rx rings */
1362
1363 for(i = 0; i < sc->usb_endpoints - 1; i++)
1364 rt2870_reset_tx_ring(sc, &sc->tx_ring[i]);
1365
1366 rt2870_reset_rx_ring(sc, &sc->rx_ring);
1367
1368 rt2870_reset_cmd_ring(sc, &sc->cmd_ring);
1369
1370 for(i = 0; i < sc->usb_endpoints - 1; i++)
1371 {
1372 usbd_xfer_set_priv(sc->usb_xfer[i + 1], &sc->tx_ring[i]);
1373 usbd_xfer_set_stall(sc->usb_xfer[i + 1]);
1374 }
1375
1376 /* start up the receive pipe */
1377
1378 for(i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
1379 usbd_transfer_start(sc->usb_xfer[0]);
1380
1381 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1382 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1383
1384 sc->periodic_round = 0;
1385
1386 callout_reset(&sc->periodic_ch, hz / 10, rt2870_periodic, sc);
1387
1388 return;
1389
1390 fail:
1391
1392 rt2870_stop_locked(sc);
1393 }
1394
1395 /*
1396 * rt2870_init
1397 */
1398 static void rt2870_init(void *priv)
1399 {
1400 struct rt2870_softc *sc;
1401
1402 sc = priv;
1403
1404 RT2870_SOFTC_LOCK(sc);
1405
1406 rt2870_init_locked(sc);
1407
1408 RT2870_SOFTC_UNLOCK(sc);
1409 }
1410
1411 /*
1412 * rt2870_init_bbp
1413 */
1414 static int rt2870_init_bbp(struct rt2870_softc *sc)
1415 {
1416 int ntries, i;
1417 uint8_t tmp;
1418
1419 for (ntries = 0; ntries < 20; ntries++)
1420 {
1421 tmp = rt2870_io_bbp_read(sc, 0);
1422 if (tmp != 0x00 && tmp != 0xff)
1423 break;
1424 }
1425
1426 if (tmp == 0x00 || tmp == 0xff)
1427 {
1428 printf("%s: timeout waiting for BBP to wakeup\n",
1429 device_get_nameunit(sc->dev));
1430 return ETIMEDOUT;
1431 }
1432
1433 for (i = 0; i < RT2870_DEF_BBP_SIZE; i++)
1434 rt2870_io_bbp_write(sc, rt2870_def_bbp[i].reg,
1435 rt2870_def_bbp[i].val);
1436
1437 if ((sc->mac_rev & 0xffff) != 0x0101)
1438 rt2870_io_bbp_write(sc, 84, 0x19);
1439
1440 if (sc->mac_rev == 0x28600100)
1441 {
1442 rt2870_io_bbp_write(sc, 69, 0x16);
1443 rt2870_io_bbp_write(sc, 73, 0x12);
1444 }
1445
1446 return 0;
1447 }
1448
1449 /*
1450 * rt2870_stop_locked
1451 */
1452 static void rt2870_stop_locked(void *priv)
1453 {
1454 struct rt2870_softc *sc;
1455 struct ifnet *ifp;
1456 struct ieee80211com *ic;
1457 uint32_t tmp;
1458 int i;
1459
1460 sc = priv;
1461 ifp = sc->ifp;
1462 ic = ifp->if_l2com;
1463
1464 RT2870_DPRINTF(sc, RT2870_DEBUG_ANY,
1465 "%s: stopping\n",
1466 device_get_nameunit(sc->dev));
1467
1468 RT2870_SOFTC_ASSERT_LOCKED(sc);
1469
1470 sc->tx_timer = 0;
1471
1472 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1473 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_OFF);
1474
1475 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1476
1477 callout_stop(&sc->periodic_ch);
1478 callout_stop(&sc->tx_watchdog_ch);
1479
1480 RT2870_SOFTC_UNLOCK(sc);
1481
1482 taskqueue_block(sc->taskqueue);
1483
1484 taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
1485 taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
1486 taskqueue_drain(sc->taskqueue, &sc->periodic_task);
1487 taskqueue_drain(sc->taskqueue, &sc->cmd_task);
1488
1489 RT2870_SOFTC_LOCK(sc);
1490
1491 /* clear key tables */
1492
1493 rt2870_asic_clear_keytables(sc);
1494
1495 /* disable Tx/Rx */
1496
1497 tmp = rt2870_io_mac_read(sc, RT2870_REG_SYS_CTRL);
1498
1499 tmp &= ~(RT2870_REG_RX_ENABLE | RT2870_REG_TX_ENABLE);
1500
1501 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, tmp);
1502
1503 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, 0);
1504
1505 /* reset adapter */
1506
1507 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
1508 RT2870_REG_MAC_SRST | RT2870_REG_BBP_HRST);
1509 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, 0);
1510
1511 /* abort any pending transfers */
1512
1513 for (i = 0; i < sc->usb_endpoints; i++)
1514 usbd_transfer_stop(sc->usb_xfer[i]);
1515 }
1516
1517 /*
1518 * rt2870_stop
1519 */
1520 static void rt2870_stop(void *priv)
1521 {
1522 struct rt2870_softc *sc;
1523
1524 sc = priv;
1525
1526 RT2870_SOFTC_LOCK(sc);
1527
1528 rt2870_stop_locked(sc);
1529
1530 RT2870_SOFTC_UNLOCK(sc);
1531 }
1532
1533 /*
1534 * rt2870_start
1535 */
1536 static void rt2870_start(struct ifnet *ifp)
1537 {
1538 struct rt2870_softc *sc;
1539 struct ieee80211_node *ni;
1540 struct mbuf *m;
1541 int qid;
1542
1543 sc = ifp->if_softc;
1544
1545 RT2870_SOFTC_LOCK(sc);
1546
1547 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1548 {
1549 RT2870_SOFTC_UNLOCK(sc);
1550 return;
1551 }
1552
1553 for (;;)
1554 {
1555 IF_POLL(&ifp->if_snd, m);
1556 if (m == NULL)
1557 break;
1558
1559 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1560
1561 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1562
1563 qid = M_WME_GETAC(m);
1564
1565 if (sc->tx_ring[qid].queued >= RT2870_SOFTC_TX_RING_DATA_COUNT)
1566 {
1567 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
1568 "%s: if_start: Tx ring with qid=%d is full\n",
1569 device_get_nameunit(sc->dev), qid);
1570
1571 m_freem(m);
1572 ieee80211_free_node(ni);
1573 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1574 ifp->if_oerrors++;
1575 break;
1576 }
1577
1578 if (rt2870_tx_data(sc, m, ni, qid) != 0)
1579 {
1580 ieee80211_free_node(ni);
1581 ifp->if_oerrors++;
1582 break;
1583 }
1584
1585 sc->tx_timer = RT2870_TX_WATCHDOG_TIMEOUT;
1586
1587 callout_reset(&sc->tx_watchdog_ch, hz, rt2870_tx_watchdog, sc);
1588 }
1589
1590 RT2870_SOFTC_UNLOCK(sc);
1591 }
1592
1593 /*
1594 * rt2870_ioctl
1595 */
1596 static int rt2870_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1597 {
1598 struct rt2870_softc *sc;
1599 struct ieee80211com *ic;
1600 struct ifreq *ifr;
1601 int error, startall;
1602
1603 sc = ifp->if_softc;
1604 ic = ifp->if_l2com;
1605 ifr = (struct ifreq *) data;
1606
1607 error = 0;
1608
1609 switch (cmd)
1610 {
1611 case SIOCSIFFLAGS:
1612 startall = 0;
1613
1614 RT2870_SOFTC_LOCK(sc);
1615
1616 if (ifp->if_flags & IFF_UP)
1617 {
1618 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1619 {
1620 if ((ifp->if_flags ^ sc->if_flags) & IFF_PROMISC)
1621 rt2870_asic_update_promisc(sc);
1622 }
1623 else
1624 {
1625 rt2870_init_locked(sc);
1626 startall = 1;
1627 }
1628 }
1629 else
1630 {
1631 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1632 rt2870_stop_locked(sc);
1633 }
1634
1635 sc->if_flags = ifp->if_flags;
1636
1637 RT2870_SOFTC_UNLOCK(sc);
1638
1639 if (startall)
1640 ieee80211_start_all(ic);
1641 break;
1642
1643 case SIOCGIFMEDIA:
1644 case SIOCSIFMEDIA:
1645 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd);
1646 break;
1647
1648 case SIOCGIFADDR:
1649 error = ether_ioctl(ifp, cmd, data);
1650 break;
1651
1652 default:
1653 error = EINVAL;
1654 break;
1655 }
1656
1657 return error;
1658 }
1659
1660 /*
1661 * rt2870_vap_create
1662 */
1663 static struct ieee80211vap *rt2870_vap_create(struct ieee80211com *ic,
1664 const char name[IFNAMSIZ], int unit, int opmode, int flags,
1665 const uint8_t bssid[IEEE80211_ADDR_LEN],
1666 const uint8_t mac[IEEE80211_ADDR_LEN])
1667 {
1668 struct rt2870_softc *sc;
1669 struct ifnet *ifp;
1670 struct rt2870_softc_vap *rvap;
1671 struct ieee80211vap *vap;
1672
1673 ifp = ic->ic_ifp;
1674 sc = ifp->if_softc;
1675
1676 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1677 "%s: VAP create: opmode=%s\n",
1678 device_get_nameunit(sc->dev),
1679 ieee80211_opmode_name[opmode]);
1680
1681 switch (opmode)
1682 {
1683 case IEEE80211_M_MONITOR:
1684 case IEEE80211_M_IBSS:
1685 case IEEE80211_M_STA:
1686 case IEEE80211_M_AHDEMO:
1687 case IEEE80211_M_HOSTAP:
1688 case IEEE80211_M_MBSS:
1689 if (!TAILQ_EMPTY(&ic->ic_vaps))
1690 {
1691 if_printf(ifp, "only 1 VAP supported\n");
1692 return NULL;
1693 }
1694
1695 if (opmode == IEEE80211_M_STA)
1696 flags |= IEEE80211_CLONE_NOBEACONS;
1697 break;
1698
1699 case IEEE80211_M_WDS:
1700 if (TAILQ_EMPTY(&ic->ic_vaps) || ic->ic_opmode != IEEE80211_M_HOSTAP)
1701 {
1702 if_printf(ifp, "WDS only supported in AP mode\n");
1703 return NULL;
1704 }
1705
1706 flags &= ~IEEE80211_CLONE_BSSID;
1707 break;
1708
1709 default:
1710 if_printf(ifp, "unknown opmode %d\n", opmode);
1711 return NULL;
1712 }
1713
1714 rvap = (struct rt2870_softc_vap *) malloc(sizeof(struct rt2870_softc_vap),
1715 M_80211_VAP, M_NOWAIT | M_ZERO);
1716 if (rvap == NULL)
1717 return NULL;
1718
1719 vap = &rvap->vap;
1720
1721 ieee80211_vap_setup(ic, vap, name, unit, opmode, flags, bssid, mac);
1722
1723 rvap->newstate = vap->iv_newstate;
1724 vap->iv_newstate = rt2870_vap_newstate;
1725
1726 vap->iv_reset = rt2870_vap_reset;
1727 vap->iv_key_update_begin = rt2870_vap_key_update_begin;
1728 vap->iv_key_update_end = rt2870_vap_key_update_end;
1729 vap->iv_key_set = rt2870_vap_key_set;
1730 vap->iv_key_delete = rt2870_vap_key_delete;
1731 vap->iv_update_beacon = rt2870_vap_update_beacon;
1732
1733 rt2870_amrr_init(&rvap->amrr, vap,
1734 RT2870_AMRR_MIN_SUCCESS_THRESHOLD,
1735 RT2870_AMRR_MAX_SUCCESS_THRESHOLD,
1736 500);
1737
1738 ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status);
1739
1740 ic->ic_opmode = opmode;
1741
1742 return vap;
1743 }
1744
1745 /*
1746 * rt2870_vap_delete
1747 */
1748 static void rt2870_vap_delete(struct ieee80211vap *vap)
1749 {
1750 struct rt2870_softc *sc;
1751 struct ieee80211com *ic;
1752 struct ifnet *ifp;
1753 struct rt2870_softc_vap *rvap;
1754
1755 ic = vap->iv_ic;
1756 ifp = ic->ic_ifp;
1757 sc = ifp->if_softc;
1758 rvap = (struct rt2870_softc_vap *) vap;
1759
1760 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1761 "%s: VAP delete: opmode=%s\n",
1762 device_get_nameunit(sc->dev),
1763 ieee80211_opmode_name[vap->iv_opmode]);
1764
1765 rt2870_amrr_cleanup(&rvap->amrr);
1766
1767 ieee80211_vap_detach(vap);
1768
1769 free(rvap, M_80211_VAP);
1770 }
1771
1772 /*
1773 * rt2870_reset_vap
1774 */
1775 static int rt2870_vap_reset(struct ieee80211vap *vap, u_long cmd)
1776 {
1777 struct rt2870_softc *sc;
1778 struct ieee80211com *ic;
1779 struct ifnet *ifp;
1780 struct rt2870_softc_vap *rvap;
1781 int error;
1782
1783 ic = vap->iv_ic;
1784 ifp = ic->ic_ifp;
1785 sc = ifp->if_softc;
1786 rvap = (struct rt2870_softc_vap *) vap;
1787
1788 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1789 "%s: VAP reset: cmd=%lu\n",
1790 device_get_nameunit(sc->dev), cmd);
1791
1792 error = 0;
1793
1794 RT2870_SOFTC_LOCK(sc);
1795
1796 switch (cmd)
1797 {
1798 case IEEE80211_IOC_RTSTHRESHOLD:
1799 rt2870_asic_update_rtsthreshold(sc);
1800 break;
1801
1802 case IEEE80211_IOC_PROTMODE:
1803 case IEEE80211_IOC_HTPROTMODE:
1804 rt2870_asic_updateprot(sc);
1805 break;
1806
1807 case IEEE80211_IOC_TXPOWER:
1808 rt2870_asic_update_txpower(sc);
1809 break;
1810
1811 case IEEE80211_IOC_SHORTGI:
1812 case IEEE80211_IOC_AMPDU_DENSITY:
1813 break;
1814
1815 default:
1816 error = ENETRESET;
1817 break;
1818 }
1819
1820 RT2870_SOFTC_UNLOCK(sc);
1821
1822 return error;
1823 }
1824
1825 /*
1826 * rt2870_vap_newstate
1827 */
1828 static int rt2870_vap_newstate(struct ieee80211vap *vap,
1829 enum ieee80211_state nstate, int arg)
1830 {
1831 struct rt2870_softc *sc;
1832 struct ieee80211com *ic;
1833 struct ifnet *ifp;
1834 struct rt2870_softc_vap *rvap;
1835 struct ieee80211_node *ni;
1836 int error;
1837
1838 ic = vap->iv_ic;
1839 ifp = ic->ic_ifp;
1840 sc = ifp->if_softc;
1841 rvap = (struct rt2870_softc_vap *) vap;
1842
1843 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
1844 "%s: VAP newstate: %s -> %s\n",
1845 device_get_nameunit(sc->dev),
1846 ieee80211_state_name[vap->iv_state], ieee80211_state_name[nstate]);
1847
1848 error = rvap->newstate(vap, nstate, arg);
1849 if (error != 0)
1850 return error;
1851
1852 IEEE80211_UNLOCK(ic);
1853
1854 RT2870_SOFTC_LOCK(sc);
1855
1856 /* turn link LED off */
1857
1858 if (nstate != IEEE80211_S_RUN)
1859 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_OFF);
1860
1861 switch (nstate)
1862 {
1863 case IEEE80211_S_INIT:
1864 rt2870_asic_disable_tsf_sync(sc);
1865 break;
1866
1867 case IEEE80211_S_RUN:
1868 ni = vap->iv_bss;
1869
1870 rt2870_rf_set_chan(sc, ni->ni_chan);
1871
1872 if (vap->iv_opmode != IEEE80211_M_MONITOR)
1873 {
1874 rt2870_asic_enable_mrr(sc);
1875 rt2870_asic_set_txpreamble(sc);
1876 rt2870_asic_set_basicrates(sc);
1877 rt2870_asic_update_txpower(sc);
1878 rt2870_asic_set_bssid(sc, ni->ni_bssid);
1879 }
1880
1881 if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
1882 vap->iv_opmode == IEEE80211_M_IBSS ||
1883 vap->iv_opmode == IEEE80211_M_MBSS)
1884 {
1885 error = rt2870_asic_update_beacon(sc, vap);
1886 if (error != 0)
1887 break;
1888 }
1889
1890 if (vap->iv_opmode != IEEE80211_M_MONITOR)
1891 rt2870_asic_enable_tsf_sync(sc);
1892
1893 /* turn link LED on */
1894
1895 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1896 {
1897 rt2870_led_cmd(sc, RT2870_LED_CMD_RADIO_ON |
1898 (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan) ?
1899 RT2870_LED_CMD_LINK_2GHZ : RT2870_LED_CMD_LINK_5GHZ));
1900 }
1901 break;
1902
1903 default:
1904 break;
1905 }
1906
1907 RT2870_SOFTC_UNLOCK(sc);
1908
1909 IEEE80211_LOCK(ic);
1910
1911 return error;
1912 }
1913
1914 /*
1915 * rt2870_vap_key_update_begin
1916 */
1917 static void rt2870_vap_key_update_begin(struct ieee80211vap *vap)
1918 {
1919 struct rt2870_softc *sc;
1920 struct ieee80211com *ic;
1921 struct ifnet *ifp;
1922
1923 ic = vap->iv_ic;
1924 ifp = ic->ic_ifp;
1925 sc = ifp->if_softc;
1926
1927 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
1928 "%s: VAP key update begin\n",
1929 device_get_nameunit(sc->dev));
1930
1931 taskqueue_block(sc->taskqueue);
1932
1933 IF_LOCK(&ifp->if_snd);
1934 }
1935
1936 /*
1937 * rt2870_vap_key_update_end
1938 */
1939 static void rt2870_vap_key_update_end(struct ieee80211vap *vap)
1940 {
1941 struct rt2870_softc *sc;
1942 struct ieee80211com *ic;
1943 struct ifnet *ifp;
1944
1945 ic = vap->iv_ic;
1946 ifp = ic->ic_ifp;
1947 sc = ifp->if_softc;
1948
1949 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
1950 "%s: VAP key update end\n",
1951 device_get_nameunit(sc->dev));
1952
1953 IF_UNLOCK(&ifp->if_snd);
1954
1955 taskqueue_unblock(sc->taskqueue);
1956 }
1957
1958 /*
1959 * rt2870_vap_key_set
1960 */
1961 static int rt2870_vap_key_set(struct ieee80211vap *vap,
1962 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN])
1963 {
1964 struct rt2870_softc *sc;
1965 struct ieee80211com *ic;
1966 struct ifnet *ifp;
1967 struct ieee80211_node *ni;
1968 uint16_t associd, key_base, keymode_base;
1969 uint8_t mode, vapid, wcid, iv[8];
1970 uint32_t tmp;
1971
1972 if (k->wk_cipher->ic_cipher != IEEE80211_CIPHER_WEP &&
1973 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_TKIP &&
1974 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_AES_CCM)
1975 return EINVAL;
1976
1977 ic = vap->iv_ic;
1978 ifp = ic->ic_ifp;
1979 sc = ifp->if_softc;
1980
1981 if (vap->iv_opmode != IEEE80211_M_HOSTAP)
1982 ni = vap->iv_bss;
1983 else
1984 ni = ieee80211_find_vap_node(&ic->ic_sta, vap, mac);
1985
1986 associd = (ni != NULL) ? ni->ni_associd : 0;
1987
1988 if ((vap->iv_opmode == IEEE80211_M_HOSTAP) && (ni != NULL))
1989 ieee80211_free_node(ni);
1990
1991 switch (k->wk_cipher->ic_cipher)
1992 {
1993 case IEEE80211_CIPHER_WEP:
1994 if(k->wk_keylen < 8)
1995 mode = RT2870_REG_CIPHER_MODE_WEP40;
1996 else
1997 mode = RT2870_REG_CIPHER_MODE_WEP104;
1998 break;
1999
2000 case IEEE80211_CIPHER_TKIP:
2001 mode = RT2870_REG_CIPHER_MODE_TKIP;
2002 break;
2003
2004 case IEEE80211_CIPHER_AES_CCM:
2005 mode = RT2870_REG_CIPHER_MODE_AES_CCMP;
2006 break;
2007
2008 default:
2009 return EINVAL;
2010 }
2011
2012 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
2013 "%s: VAP key set: keyix=%d, keylen=%d, associd=0x%04x, mode=%d, group=%d\n",
2014 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, associd, mode,
2015 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
2016
2017 RT2870_SOFTC_LOCK(sc);
2018
2019 if (!(k->wk_flags & IEEE80211_KEY_GROUP))
2020 {
2021 /* install pairwise key */
2022
2023 vapid = 0;
2024 wcid = RT2870_AID2WCID(associd);
2025 key_base = RT2870_REG_PKEY(wcid);
2026
2027 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)
2028 {
2029 memset(iv, 0, 8);
2030
2031 iv[3] = (k->wk_keyix << 6);
2032 }
2033 else
2034 {
2035 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2036 {
2037 iv[0] = (k->wk_keytsc >> 8);
2038 iv[1] = ((iv[0] | 0x20) & 0x7f);
2039 iv[2] = k->wk_keytsc;
2040 }
2041 else
2042 {
2043 /* AES CCMP */
2044
2045 iv[0] = k->wk_keytsc;
2046 iv[1] = k->wk_keytsc >> 8;
2047 iv[2] = 0;
2048 }
2049
2050 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV);
2051 iv[4] = (k->wk_keytsc >> 16);
2052 iv[5] = (k->wk_keytsc >> 24);
2053 iv[6] = (k->wk_keytsc >> 32);
2054 iv[7] = (k->wk_keytsc >> 40);
2055
2056 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
2057 "%s: set key: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
2058 device_get_nameunit(sc->dev),
2059 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
2060 }
2061
2062 rt2870_io_mac_write_multi(sc, RT2870_REG_IVEIV(wcid), iv, 8);
2063
2064 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2065 {
2066 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, 16);
2067
2068 if (vap->iv_opmode != IEEE80211_M_HOSTAP)
2069 {
2070 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
2071 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
2072 }
2073 else
2074 {
2075 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
2076 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
2077 }
2078 }
2079 else
2080 {
2081 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
2082 }
2083
2084 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
2085 (mode << RT2870_REG_CIPHER_MODE_SHIFT) | RT2870_REG_PKEY_ENABLE;
2086
2087 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
2088 }
2089
2090 if ((k->wk_flags & IEEE80211_KEY_GROUP) ||
2091 (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP))
2092 {
2093 /* install group key */
2094
2095 vapid = 0;
2096 key_base = RT2870_REG_SKEY(vapid, k->wk_keyix);
2097 keymode_base = RT2870_REG_SKEY_MODE(vapid);
2098
2099 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2100 {
2101 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, 16);
2102
2103 if (vap->iv_opmode != IEEE80211_M_HOSTAP)
2104 {
2105 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
2106 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
2107 }
2108 else
2109 {
2110 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
2111 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
2112 }
2113 }
2114 else
2115 {
2116 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
2117 }
2118
2119 tmp = rt2870_io_mac_read(sc, keymode_base);
2120
2121 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2122 tmp |= (mode << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2123
2124 rt2870_io_mac_write(sc, keymode_base, tmp);
2125 }
2126
2127 RT2870_SOFTC_UNLOCK(sc);
2128
2129 return 1;
2130 }
2131
2132 /*
2133 * rt2870_vap_key_delete
2134 */
2135 static int rt2870_vap_key_delete(struct ieee80211vap *vap,
2136 const struct ieee80211_key *k)
2137 {
2138 struct rt2870_softc *sc;
2139 struct ieee80211com *ic;
2140 struct ifnet *ifp;
2141 struct ieee80211_node *ni;
2142 struct rt2870_cmd_argv_keydelete cmd_argv;
2143 uint16_t associd;
2144
2145 ic = vap->iv_ic;
2146 ifp = ic->ic_ifp;
2147 sc = ifp->if_softc;
2148 ni = vap->iv_bss;
2149 associd = (ni != NULL) ? ni->ni_associd : 0;
2150
2151 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
2152 "%s: VAP key delete: keyix=%d, keylen=%d, associd=0x%04x, group=%d\n",
2153 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, associd,
2154 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
2155
2156 memcpy(&cmd_argv.key, k, sizeof(struct ieee80211_key));
2157 cmd_argv.associd = associd;
2158
2159 rt2870_do_async(sc, rt2870_vap_key_delete_cb,
2160 &cmd_argv, sizeof(struct rt2870_cmd_argv_keydelete));
2161
2162 return 1;
2163 }
2164
2165 /*
2166 * rt2870_vap_update_beacon
2167 */
2168 static void rt2870_vap_update_beacon(struct ieee80211vap *vap, int what)
2169 {
2170 struct rt2870_softc *sc;
2171 struct ieee80211com *ic;
2172 struct ifnet *ifp;
2173
2174 ic = vap->iv_ic;
2175 ifp = ic->ic_ifp;
2176 sc = ifp->if_softc;
2177
2178 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
2179 "%s: VAP update beacon\n",
2180 device_get_nameunit(sc->dev));
2181
2182 rt2870_do_async(sc, rt2870_vap_update_beacon_cb, NULL, 0);
2183 }
2184
2185 /*
2186 * rt2870_node_alloc
2187 */
2188 static struct ieee80211_node *rt2870_node_alloc(struct ieee80211vap *vap,
2189 const uint8_t mac[IEEE80211_ADDR_LEN])
2190 {
2191 return malloc(sizeof(struct rt2870_softc_node),
2192 M_80211_NODE, M_NOWAIT | M_ZERO);
2193 }
2194
2195 /*
2196 * rt2870_setregdomain
2197 */
2198 static int rt2870_setregdomain(struct ieee80211com *ic,
2199 struct ieee80211_regdomain *reg,
2200 int nchans, struct ieee80211_channel chans[])
2201 {
2202 struct rt2870_softc *sc;
2203 struct ifnet *ifp;
2204
2205 ifp = ic->ic_ifp;
2206 sc = ifp->if_softc;
2207
2208 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
2209 "%s: set regulatory domain: country=%d, country code string=%c%c, location=%c\n",
2210 device_get_nameunit(sc->dev),
2211 reg->country, reg->isocc[0], reg->isocc[1], reg->location);
2212
2213 return 0;
2214 }
2215
2216 /*
2217 * rt2870_getradiocaps
2218 */
2219 static void rt2870_getradiocaps(struct ieee80211com *ic,
2220 int maxchans, int *nchans, struct ieee80211_channel chans[])
2221 {
2222 *nchans = (ic->ic_nchans >= maxchans) ? maxchans : ic->ic_nchans;
2223
2224 memcpy(chans, ic->ic_channels, (*nchans) * sizeof(struct ieee80211_channel));
2225 }
2226
2227 /*
2228 * rt2870_scan_start
2229 */
2230 static void rt2870_scan_start(struct ieee80211com *ic)
2231 {
2232 struct rt2870_softc *sc;
2233 struct ifnet *ifp;
2234
2235 ifp = ic->ic_ifp;
2236 sc = ifp->if_softc;
2237
2238 RT2870_SOFTC_LOCK(sc);
2239
2240 rt2870_asic_disable_tsf_sync(sc);
2241
2242 RT2870_SOFTC_UNLOCK(sc);
2243 }
2244
2245 /*
2246 * rt2870_scan_end
2247 */
2248 static void rt2870_scan_end(struct ieee80211com *ic)
2249 {
2250 struct rt2870_softc *sc;
2251 struct ifnet *ifp;
2252
2253 ifp = ic->ic_ifp;
2254 sc = ifp->if_softc;
2255
2256 RT2870_SOFTC_LOCK(sc);
2257
2258 rt2870_asic_enable_tsf_sync(sc);
2259
2260 RT2870_SOFTC_UNLOCK(sc);
2261 }
2262
2263 /*
2264 * rt2870_set_channel
2265 */
2266 static void rt2870_set_channel(struct ieee80211com *ic)
2267 {
2268 struct rt2870_softc *sc;
2269 struct ifnet *ifp;
2270
2271 ifp = ic->ic_ifp;
2272 sc = ifp->if_softc;
2273
2274 RT2870_DPRINTF(sc, RT2870_DEBUG_CHAN,
2275 "%s: set channel: channel=%u, HT%s%s\n",
2276 device_get_nameunit(sc->dev),
2277 ieee80211_chan2ieee(ic, ic->ic_curchan),
2278 !IEEE80211_IS_CHAN_HT(ic->ic_curchan) ? " disabled" :
2279 IEEE80211_IS_CHAN_HT20(ic->ic_curchan) ? "20":
2280 IEEE80211_IS_CHAN_HT40U(ic->ic_curchan) ? "40U" : "40D",
2281 (ic->ic_flags & IEEE80211_F_SCAN) ? ", scanning" : "");
2282
2283 RT2870_SOFTC_LOCK(sc);
2284
2285 rt2870_rf_set_chan(sc, ic->ic_curchan);
2286
2287 RT2870_SOFTC_UNLOCK(sc);
2288 }
2289
2290 /*
2291 * rt2870_newassoc
2292 */
2293 static void rt2870_newassoc(struct ieee80211_node *ni, int isnew)
2294 {
2295 struct rt2870_softc *sc;
2296 struct ieee80211com *ic;
2297 struct ifnet *ifp;
2298 struct ieee80211vap *vap;
2299 struct rt2870_softc_vap *rvap;
2300 uint16_t associd;
2301 uint8_t wcid;
2302
2303 vap = ni->ni_vap;
2304 ic = vap->iv_ic;
2305 ifp = ic->ic_ifp;
2306 sc = ifp->if_softc;
2307 rvap = (struct rt2870_softc_vap *) vap;
2308
2309 associd = (ni != NULL) ? ni->ni_associd : 0;
2310 wcid = RT2870_AID2WCID(associd);
2311
2312 RT2870_DPRINTF(sc, RT2870_DEBUG_NODE,
2313 "%s: new association: wcid=0x%02x, "
2314 "mac addr=%s, QoS %s, ERP %s, HT %s\n",
2315 device_get_nameunit(sc->dev), wcid,
2316 ether_sprintf(ni->ni_macaddr),
2317 (ni->ni_flags & IEEE80211_NODE_QOS) ? "enabled" : "disabled",
2318 (ni->ni_flags & IEEE80211_NODE_ERP) ? "enabled" : "disabled",
2319 (ni->ni_flags & IEEE80211_NODE_HT) ? "enabled" : "disabled");
2320
2321 RT2870_SOFTC_LOCK(sc);
2322
2323 rt2870_io_mac_write_multi(sc, RT2870_REG_WCID(wcid),
2324 ni->ni_macaddr, IEEE80211_ADDR_LEN);
2325
2326 rt2870_amrr_node_init(&rvap->amrr, &sc->amrr_node[wcid], ni);
2327
2328 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2329 "%s: initial%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2330 device_get_nameunit(sc->dev),
2331 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2332 ni->ni_associd, ni->ni_txrate,
2333 (ni->ni_flags & IEEE80211_NODE_HT) ?
2334 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2335 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2336
2337 rt2870_asic_updateprot(sc);
2338 rt2870_asic_updateslot(sc);
2339 rt2870_asic_set_txpreamble(sc);
2340
2341 RT2870_SOFTC_UNLOCK(sc);
2342 }
2343
2344 /*
2345 * rt2870_updateslot
2346 */
2347 static void rt2870_updateslot(struct ifnet *ifp)
2348 {
2349 struct rt2870_softc *sc;
2350
2351 sc = ifp->if_softc;
2352
2353 rt2870_do_async(sc, rt2870_updateslot_cb, NULL, 0);
2354 }
2355
2356 /*
2357 * rt2870_update_promisc
2358 */
2359 static void rt2870_update_promisc(struct ifnet *ifp)
2360 {
2361 struct rt2870_softc *sc;
2362
2363 sc = ifp->if_softc;
2364
2365 RT2870_SOFTC_LOCK(sc);
2366
2367 rt2870_asic_update_promisc(sc);
2368
2369 RT2870_SOFTC_UNLOCK(sc);
2370 }
2371
2372 /*
2373 * rt2870_update_mcast
2374 */
2375 static void rt2870_update_mcast(struct ifnet *ifp)
2376 {
2377 struct rt2870_softc *sc;
2378
2379 sc = ifp->if_softc;
2380 }
2381
2382 /*
2383 * rt2870_wme_update
2384 */
2385 static int rt2870_wme_update(struct ieee80211com *ic)
2386 {
2387 struct rt2870_softc *sc;
2388 struct ifnet *ifp;
2389
2390 ifp = ic->ic_ifp;
2391 sc = ifp->if_softc;
2392
2393 rt2870_do_async(sc, rt2870_wme_update_cb, NULL, 0);
2394
2395 return 0;
2396 }
2397
2398 /*
2399 * rt2870_raw_xmit
2400 */
2401 static int rt2870_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
2402 const struct ieee80211_bpf_params *params)
2403 {
2404 struct rt2870_softc *sc;
2405 struct ieee80211com *ic;
2406 struct ifnet *ifp;
2407
2408 ic = ni->ni_ic;
2409 ifp = ic->ic_ifp;
2410 sc = ifp->if_softc;
2411
2412 RT2870_SOFTC_LOCK(sc);
2413
2414 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2415 {
2416 RT2870_SOFTC_UNLOCK(sc);
2417 m_freem(m);
2418 ieee80211_free_node(ni);
2419 return ENETDOWN;
2420 }
2421
2422 if (sc->tx_ring[sc->tx_ring_mgtqid].queued >= RT2870_SOFTC_TX_RING_DATA_COUNT)
2423 {
2424 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
2425 "%s: raw xmit: Tx ring with qid=%d is full\n",
2426 device_get_nameunit(sc->dev), sc->tx_ring_mgtqid);
2427
2428 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
2429 RT2870_SOFTC_UNLOCK(sc);
2430 m_freem(m);
2431 ieee80211_free_node(ni);
2432 return ENOBUFS;
2433 }
2434
2435 if (rt2870_tx_mgmt(sc, m, ni, sc->tx_ring_mgtqid) != 0)
2436 {
2437 ifp->if_oerrors++;
2438 RT2870_SOFTC_UNLOCK(sc);
2439 ieee80211_free_node(ni);
2440 return EIO;
2441 }
2442
2443 sc->tx_timer = RT2870_TX_WATCHDOG_TIMEOUT;
2444
2445 RT2870_SOFTC_UNLOCK(sc);
2446
2447 return 0;
2448 }
2449
2450 /*
2451 * rt2870_recv_action
2452 */
2453 static int rt2870_recv_action(struct ieee80211_node *ni,
2454 const struct ieee80211_frame *wh,
2455 const uint8_t *frm, const uint8_t *efrm)
2456 {
2457 struct rt2870_softc *sc;
2458 struct ieee80211com *ic;
2459 struct ifnet *ifp;
2460 const struct ieee80211_action *ia;
2461 uint16_t associd, baparamset;
2462 uint8_t wcid;
2463 int ret, tid, bufsize;
2464 uint32_t tmp;
2465
2466 ic = ni->ni_ic;
2467 ifp = ic->ic_ifp;
2468 sc = ifp->if_softc;
2469
2470 ia = (const struct ieee80211_action *) frm;
2471
2472 ret = sc->recv_action(ni, wh, frm, efrm);
2473
2474 if (ia->ia_category != IEEE80211_ACTION_CAT_BA)
2475 return ret;
2476
2477 associd = (ni != NULL) ? ni->ni_associd : 0;
2478 wcid = RT2870_AID2WCID(associd);
2479
2480 switch (ia->ia_action)
2481 {
2482 /* IEEE80211_ACTION_BA_ADDBA_REQUEST */
2483 case IEEE80211_ACTION_BA_ADDBA_REQUEST:
2484 baparamset = LE_READ_2(frm + 3);
2485 tid = RT2870_MS(baparamset, IEEE80211_BAPS_TID);
2486 bufsize = RT2870_MS(baparamset, IEEE80211_BAPS_BUFSIZ);
2487
2488 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2489 "%s: adding A-MPDU Rx block ACK: associd=0x%04x, tid=%d, bufsize=%d\n",
2490 device_get_nameunit(sc->dev), associd, tid, bufsize);
2491
2492 RT2870_SOFTC_LOCK(sc);
2493
2494 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID(wcid) + 4);
2495
2496 tmp |= (0x10000 << tid);
2497
2498 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, tmp);
2499
2500 RT2870_SOFTC_UNLOCK(sc);
2501 break;
2502
2503 /* IEEE80211_ACTION_BA_DELBA */
2504 case IEEE80211_ACTION_BA_DELBA:
2505 baparamset = LE_READ_2(frm + 2);
2506 tid = RT2870_MS(baparamset, IEEE80211_BAPS_TID);
2507
2508 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2509 "%s: deleting A-MPDU Rx block ACK: associd=0x%04x, tid=%d\n",
2510 device_get_nameunit(sc->dev), associd, tid);
2511
2512 RT2870_SOFTC_LOCK(sc);
2513
2514 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID(wcid) + 4);
2515
2516 tmp &= ~(0x10000 << tid);
2517
2518 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, tmp);
2519
2520 RT2870_SOFTC_UNLOCK(sc);
2521 break;
2522 }
2523
2524 return ret;
2525 }
2526
2527 /*
2528 * rt2870_send_action
2529 */
2530 static int rt2870_send_action(struct ieee80211_node *ni,
2531 int cat, int act, void *sa)
2532 {
2533 struct rt2870_softc *sc;
2534 struct ieee80211com *ic;
2535 struct ifnet *ifp;
2536 uint16_t associd, *args, baparamset;
2537 uint8_t wcid;
2538 int ret, tid;
2539 uint32_t tmp;
2540
2541 ic = ni->ni_ic;
2542 ifp = ic->ic_ifp;
2543 sc = ifp->if_softc;
2544
2545 ret = sc->send_action(ni, cat, act, sa);
2546
2547 if (cat != IEEE80211_ACTION_CAT_BA)
2548 return ret;
2549
2550 associd = (ni != NULL) ? ni->ni_associd : 0;
2551 wcid = RT2870_AID2WCID(associd);
2552 args = sa;
2553
2554 switch (act)
2555 {
2556 /* IEEE80211_ACTION_BA_DELBA */
2557 case IEEE80211_ACTION_BA_DELBA:
2558 baparamset = RT2870_SM(args[0], IEEE80211_DELBAPS_TID) | args[1];
2559
2560 if (RT2870_MS(baparamset, IEEE80211_DELBAPS_INIT) == IEEE80211_DELBAPS_INIT)
2561 break;
2562
2563 tid = RT2870_MS(baparamset, IEEE80211_DELBAPS_TID);
2564
2565 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2566 "%s: deleting A-MPDU Rx block ACK: associd=0x%04x, tid=%d\n",
2567 device_get_nameunit(sc->dev), associd, tid);
2568
2569 RT2870_SOFTC_LOCK(sc);
2570
2571 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID(wcid) + 4);
2572
2573 tmp &= ~(0x10000 << tid);
2574
2575 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, tmp);
2576
2577 RT2870_SOFTC_UNLOCK(sc);
2578 break;
2579 }
2580
2581 return ret;
2582 }
2583
2584 /*
2585 * rt2870_amrr_update_iter_func
2586 */
2587 static void rt2870_amrr_update_iter_func(void *arg, struct ieee80211_node *ni)
2588 {
2589 struct rt2870_softc *sc;
2590 struct ieee80211com *ic;
2591 struct ifnet *ifp;
2592 struct ieee80211vap *vap;
2593 struct rt2870_softc_vap *rvap;
2594 uint8_t wcid;
2595
2596 vap = arg;
2597 ic = vap->iv_ic;
2598 ifp = ic->ic_ifp;
2599 sc = ifp->if_softc;
2600 rvap = (struct rt2870_softc_vap *) vap;
2601
2602 /* only associated stations */
2603
2604 if ((ni->ni_vap == vap) && (ni->ni_associd != 0))
2605 {
2606 wcid = RT2870_AID2WCID(ni->ni_associd);
2607
2608 rt2870_amrr_choose(ni, &sc->amrr_node[wcid]);
2609
2610 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2611 "%s:%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2612 device_get_nameunit(sc->dev),
2613 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2614 ni->ni_associd, ni->ni_txrate,
2615 (ni->ni_flags & IEEE80211_NODE_HT) ?
2616 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2617 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2618 }
2619 }
2620
2621 /*
2622 * rt2870_periodic
2623 */
2624 static void rt2870_periodic(void *arg)
2625 {
2626 struct rt2870_softc *sc;
2627 struct ifnet *ifp;
2628
2629 sc = arg;
2630 ifp = sc->ifp;
2631
2632 RT2870_DPRINTF(sc, RT2870_DEBUG_PERIODIC,
2633 "%s: periodic\n",
2634 device_get_nameunit(sc->dev));
2635
2636 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2637 return;
2638
2639 taskqueue_enqueue(sc->taskqueue, &sc->periodic_task);
2640 }
2641
2642 /*
2643 * rt2870_tx_watchdog
2644 */
2645 static void rt2870_tx_watchdog(void *arg)
2646 {
2647 struct rt2870_softc *sc;
2648 struct ifnet *ifp;
2649
2650 sc = arg;
2651 ifp = sc->ifp;
2652
2653 if (sc->tx_timer == 0)
2654 return;
2655
2656 if (--sc->tx_timer == 0)
2657 {
2658 printf("%s: Tx watchdog timeout: resetting\n",
2659 device_get_nameunit(sc->dev));
2660
2661 rt2870_stop_locked(sc);
2662 rt2870_init_locked(sc);
2663
2664 ifp->if_oerrors++;
2665
2666 sc->tx_watchdog_timeouts++;
2667 }
2668
2669 callout_reset(&sc->tx_watchdog_ch, hz, rt2870_tx_watchdog, sc);
2670 }
2671
2672 /*
2673 * rt2870_do_async
2674 */
2675 static int rt2870_do_async(struct rt2870_softc *sc,
2676 void (*cb)(struct rt2870_softc *sc, void *arg),
2677 void *arg, int len)
2678 {
2679 struct ifnet *ifp;
2680 struct rt2870_softc_cmd_ring *ring;
2681 struct rt2870_softc_cmd *cmd;
2682 int run_cmd_task;
2683
2684 ifp = sc->ifp;
2685 ring = &sc->cmd_ring;
2686
2687 RT2870_SOFTC_LOCK(sc);
2688
2689 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2690 {
2691 RT2870_SOFTC_UNLOCK(sc);
2692 return -1;
2693 }
2694
2695 if (ring->queued >= RT2870_SOFTC_CMD_RING_CMD_COUNT)
2696 {
2697 RT2870_SOFTC_UNLOCK(sc);
2698 return -1;
2699 }
2700
2701 cmd = STAILQ_FIRST(&ring->inactive);
2702 STAILQ_REMOVE_HEAD(&ring->inactive, next);
2703
2704 cmd->cb = cb;
2705
2706 if(arg != NULL)
2707 memcpy(cmd->data, arg, len);
2708
2709 STAILQ_INSERT_TAIL(&ring->active, cmd, next);
2710 ring->queued++;
2711
2712 run_cmd_task = (ring->queued == 1);
2713
2714 RT2870_SOFTC_UNLOCK(sc);
2715
2716 if (run_cmd_task)
2717 taskqueue_enqueue(sc->taskqueue, &sc->cmd_task);
2718
2719 return 0;
2720 }
2721
2722 /*
2723 * rt2870_updateslot_cb
2724 */
2725 static void rt2870_updateslot_cb(struct rt2870_softc *sc, void *arg)
2726 {
2727 RT2870_SOFTC_LOCK(sc);
2728
2729 rt2870_asic_updateslot(sc);
2730
2731 RT2870_SOFTC_UNLOCK(sc);
2732 }
2733
2734 /*
2735 * rt2870_wme_update_cb
2736 */
2737 static void rt2870_wme_update_cb(struct rt2870_softc *sc, void *arg)
2738 {
2739 RT2870_SOFTC_LOCK(sc);
2740
2741 rt2870_asic_wme_update(sc);
2742
2743 RT2870_SOFTC_UNLOCK(sc);
2744 }
2745
2746 /*
2747 * rt2870_vap_key_delete_cb
2748 */
2749 static void rt2870_vap_key_delete_cb(struct rt2870_softc *sc, void *arg)
2750 {
2751 struct ieee80211_key *k;
2752 struct rt2870_cmd_argv_keydelete *cmd_argv;
2753 uint16_t associd;
2754 uint8_t vapid, wcid;
2755 uint32_t tmp;
2756
2757 cmd_argv = arg;
2758 k = &cmd_argv->key;
2759 associd = cmd_argv->associd;
2760
2761 RT2870_SOFTC_LOCK(sc);
2762
2763 if (!(k->wk_flags & IEEE80211_KEY_GROUP))
2764 {
2765 /* remove pairwise key */
2766
2767 wcid = RT2870_AID2WCID(associd);
2768
2769 tmp = rt2870_io_mac_read(sc, RT2870_REG_WCID_ATTR(wcid));
2770
2771 tmp &= ~0xf;
2772 tmp |= (RT2870_REG_CIPHER_MODE_NONE << RT2870_REG_CIPHER_MODE_SHIFT);
2773
2774 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
2775 }
2776 else
2777 {
2778 /* remove group key */
2779
2780 vapid = 0;
2781
2782 tmp = rt2870_io_mac_read(sc, RT2870_REG_SKEY_MODE(vapid));
2783
2784 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2785 tmp |= (RT2870_REG_CIPHER_MODE_NONE << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2786
2787 rt2870_io_mac_write(sc, RT2870_REG_SKEY_MODE(vapid), tmp);
2788 }
2789
2790 RT2870_SOFTC_UNLOCK(sc);
2791 }
2792
2793 /*
2794 * rt2870_vap_update_beacon_cb
2795 */
2796 static void rt2870_vap_update_beacon_cb(struct rt2870_softc *sc, void *arg)
2797 {
2798 struct ifnet *ifp;
2799 struct ieee80211com *ic;
2800 struct ieee80211vap *vap;
2801
2802 ifp = sc->ifp;
2803 ic = ifp->if_l2com;
2804 vap = TAILQ_FIRST(&ic->ic_vaps);
2805
2806 if (vap == NULL)
2807 return;
2808
2809 RT2870_SOFTC_LOCK(sc);
2810
2811 rt2870_asic_update_beacon(sc, vap);
2812
2813 RT2870_SOFTC_UNLOCK(sc);
2814 }
2815
2816 /*
2817 * rt2870_asic_set_bssid
2818 */
2819 static void rt2870_asic_set_bssid(struct rt2870_softc *sc,
2820 const uint8_t *bssid)
2821 {
2822 uint32_t tmp;
2823
2824 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
2825 "%s: set bssid: bssid=%s\n",
2826 device_get_nameunit(sc->dev),
2827 ether_sprintf(bssid));
2828
2829 tmp = bssid[0] | (bssid[1]) << 8 | (bssid[2] << 16) | (bssid[3] << 24);
2830
2831 rt2870_io_mac_write(sc, RT2870_REG_BSSID_DW0, tmp);
2832
2833 tmp = bssid[4] | (bssid[5] << 8);
2834
2835 rt2870_io_mac_write(sc, RT2870_REG_BSSID_DW1, tmp);
2836 }
2837
2838 /*
2839 * rt2870_asic_set_macaddr
2840 */
2841 static void rt2870_asic_set_macaddr(struct rt2870_softc *sc,
2842 const uint8_t *addr)
2843 {
2844 uint32_t tmp;
2845
2846 tmp = addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24);
2847
2848 rt2870_io_mac_write(sc, RT2870_REG_ADDR_DW0, tmp);
2849
2850 tmp = addr[4] | (addr[5] << 8);
2851
2852 rt2870_io_mac_write(sc, RT2870_REG_ADDR_DW1, tmp);
2853 }
2854
2855 /*
2856 * rt2870_asic_enable_tsf_sync
2857 */
2858 static void rt2870_asic_enable_tsf_sync(struct rt2870_softc *sc)
2859 {
2860 struct ifnet *ifp;
2861 struct ieee80211com *ic;
2862 struct ieee80211vap *vap;
2863 uint32_t tmp;
2864
2865 ifp = sc->ifp;
2866 ic = ifp->if_l2com;
2867 vap = TAILQ_FIRST(&ic->ic_vaps);
2868
2869 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
2870 "%s: enabling TSF\n",
2871 device_get_nameunit(sc->dev));
2872
2873 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
2874
2875 tmp &= ~0x1fffff;
2876 tmp |= vap->iv_bss->ni_intval * 16;
2877 tmp |= (RT2870_REG_TSF_TIMER_ENABLE | RT2870_REG_TBTT_TIMER_ENABLE);
2878
2879 if (vap->iv_opmode == IEEE80211_M_STA)
2880 {
2881 tmp |= (RT2870_REG_TSF_SYNC_MODE_STA << RT2870_REG_TSF_SYNC_MODE_SHIFT);
2882 }
2883 else if (vap->iv_opmode == IEEE80211_M_IBSS)
2884 {
2885 tmp |= RT2870_REG_BCN_TX_ENABLE;
2886 tmp |= (RT2870_REG_TSF_SYNC_MODE_IBSS << RT2870_REG_TSF_SYNC_MODE_SHIFT);
2887 }
2888 else if (vap->iv_opmode == IEEE80211_M_HOSTAP)
2889 {
2890 tmp |= RT2870_REG_BCN_TX_ENABLE;
2891 tmp |= (RT2870_REG_TSF_SYNC_MODE_HOSTAP << RT2870_REG_TSF_SYNC_MODE_SHIFT);
2892 }
2893
2894 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
2895 }
2896
2897 /*
2898 * rt2870_asic_disable_tsf_sync
2899 */
2900 static void rt2870_asic_disable_tsf_sync(struct rt2870_softc *sc)
2901 {
2902 uint32_t tmp;
2903
2904 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
2905 "%s: disabling TSF\n",
2906 device_get_nameunit(sc->dev));
2907
2908 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
2909
2910 tmp &= ~(RT2870_REG_BCN_TX_ENABLE |
2911 RT2870_REG_TSF_TIMER_ENABLE |
2912 RT2870_REG_TBTT_TIMER_ENABLE);
2913
2914 tmp &= ~(RT2870_REG_TSF_SYNC_MODE_MASK << RT2870_REG_TSF_SYNC_MODE_SHIFT);
2915 tmp |= (RT2870_REG_TSF_SYNC_MODE_DISABLE << RT2870_REG_TSF_SYNC_MODE_SHIFT);
2916
2917 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
2918 }
2919
2920 /*
2921 * rt2870_asic_enable_mrr
2922 */
2923 static void rt2870_asic_enable_mrr(struct rt2870_softc *sc)
2924 {
2925 #define CCK(mcs) (mcs)
2926 #define OFDM(mcs) ((1 << 3) | (mcs))
2927 #define HT(mcs) (mcs)
2928
2929 rt2870_io_mac_write(sc, RT2870_REG_TX_LG_FBK_CFG0,
2930 (OFDM(6) << 28) | /* 54 -> 48 */
2931 (OFDM(5) << 24) | /* 48 -> 36 */
2932 (OFDM(4) << 20) | /* 36 -> 24 */
2933 (OFDM(3) << 16) | /* 24 -> 18 */
2934 (OFDM(2) << 12) | /* 18 -> 12 */
2935 (OFDM(1) << 8) | /* 12 -> 9 */
2936 (OFDM(0) << 4) | /* 9 -> 6 */
2937 OFDM(0)); /* 6 -> 6 */
2938
2939 rt2870_io_mac_write(sc, RT2870_REG_TX_LG_FBK_CFG1,
2940 (CCK(2) << 12) | /* 11 -> 5.5 */
2941 (CCK(1) << 8) | /* 5.5 -> 2 */
2942 (CCK(0) << 4) | /* 2 -> 1 */
2943 CCK(0)); /* 1 -> 1 */
2944
2945 rt2870_io_mac_write(sc, RT2870_REG_TX_HT_FBK_CFG0,
2946 (HT(6) << 28) |
2947 (HT(5) << 24) |
2948 (HT(4) << 20) |
2949 (HT(3) << 16) |
2950 (HT(2) << 12) |
2951 (HT(1) << 8) |
2952 (HT(0) << 4) |
2953 HT(0));
2954
2955 rt2870_io_mac_write(sc, RT2870_REG_TX_HT_FBK_CFG1,
2956 (HT(14) << 28) |
2957 (HT(13) << 24) |
2958 (HT(12) << 20) |
2959 (HT(11) << 16) |
2960 (HT(10) << 12) |
2961 (HT(9) << 8) |
2962 (HT(8) << 4) |
2963 HT(8));
2964
2965 #undef HT
2966 #undef OFDM
2967 #undef CCK
2968 }
2969
2970 /*
2971 * rt2870_asic_set_txpreamble
2972 */
2973 static void rt2870_asic_set_txpreamble(struct rt2870_softc *sc)
2974 {
2975 struct ifnet *ifp;
2976 struct ieee80211com *ic;
2977 uint32_t tmp;
2978
2979 ifp = sc->ifp;
2980 ic = ifp->if_l2com;
2981
2982 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
2983 "%s: %s short Tx preamble\n",
2984 device_get_nameunit(sc->dev),
2985 (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "enabling" : "disabling");
2986
2987 tmp = rt2870_io_mac_read(sc, RT2870_REG_AUTO_RSP_CFG);
2988
2989 tmp &= ~RT2870_REG_CCK_SHORT_ENABLE;
2990
2991 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
2992 tmp |= RT2870_REG_CCK_SHORT_ENABLE;
2993
2994 rt2870_io_mac_write(sc, RT2870_REG_AUTO_RSP_CFG, tmp);
2995 }
2996
2997 /*
2998 * rt2870_asic_set_basicrates
2999 */
3000 static void rt2870_asic_set_basicrates(struct rt2870_softc *sc)
3001 {
3002 struct ifnet *ifp;
3003 struct ieee80211com *ic;
3004
3005 ifp = sc->ifp;
3006 ic = ifp->if_l2com;
3007
3008 if (ic->ic_curmode == IEEE80211_MODE_11B)
3009 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x3);
3010 else if (ic->ic_curmode == IEEE80211_MODE_11A)
3011 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x150);
3012 else
3013 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x15f);
3014 }
3015
3016 /*
3017 * rt2870_asic_update_rtsthreshold
3018 */
3019 static void rt2870_asic_update_rtsthreshold(struct rt2870_softc *sc)
3020 {
3021 struct ifnet *ifp;
3022 struct ieee80211com *ic;
3023 struct ieee80211vap *vap;
3024 uint32_t tmp;
3025 uint16_t threshold;
3026
3027 ifp = sc->ifp;
3028 ic = ifp->if_l2com;
3029 vap = TAILQ_FIRST(&ic->ic_vaps);
3030
3031 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3032 "%s: updating RTS threshold: %d\n",
3033 device_get_nameunit(sc->dev), vap->iv_rtsthreshold);
3034
3035 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_RTS_CFG);
3036
3037 tmp &= ~(RT2870_REG_TX_RTS_THRESHOLD_MASK << RT2870_REG_TX_RTS_THRESHOLD_SHIFT);
3038
3039 threshold = (vap->iv_rtsthreshold < IEEE80211_RTS_MAX) ?
3040 vap->iv_rtsthreshold : 0x1000;
3041
3042 tmp |= ((threshold & RT2870_REG_TX_RTS_THRESHOLD_MASK) <<
3043 RT2870_REG_TX_RTS_THRESHOLD_SHIFT);
3044
3045 rt2870_io_mac_write(sc, RT2870_REG_TX_RTS_CFG, tmp);
3046 }
3047
3048 /*
3049 * rt2870_asic_update_txpower
3050 */
3051 static void rt2870_asic_update_txpower(struct rt2870_softc *sc)
3052 {
3053 struct ifnet *ifp;
3054 struct ieee80211com *ic;
3055 uint32_t *txpow_rate;
3056 int8_t delta;
3057 uint8_t val;
3058 uint32_t tmp;
3059 int i;
3060
3061 ifp = sc->ifp;
3062 ic = ifp->if_l2com;
3063
3064 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3065 "%s: updating Tx power: %d\n",
3066 device_get_nameunit(sc->dev), ic->ic_txpowlimit);
3067
3068 if (!IEEE80211_IS_CHAN_HT40(ic->ic_curchan))
3069 {
3070 txpow_rate = sc->txpow_rate_20mhz;
3071 }
3072 else
3073 {
3074 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
3075 txpow_rate = sc->txpow_rate_40mhz_2ghz;
3076 else
3077 txpow_rate = sc->txpow_rate_40mhz_5ghz;
3078 }
3079
3080 delta = 0;
3081
3082 val = rt2870_io_bbp_read(sc, 1);
3083 val &= 0xfc;
3084
3085 if (ic->ic_txpowlimit > 90)
3086 {
3087 /* do nothing */
3088 }
3089 else if (ic->ic_txpowlimit > 60)
3090 {
3091 delta -= 1;
3092 }
3093 else if (ic->ic_txpowlimit > 30)
3094 {
3095 delta -= 3;
3096 }
3097 else if (ic->ic_txpowlimit > 15)
3098 {
3099 val |= 0x1;
3100 }
3101 else if (ic->ic_txpowlimit > 9)
3102 {
3103 val |= 0x1;
3104 delta -= 3;
3105 }
3106 else
3107 {
3108 val |= 0x2;
3109 }
3110
3111 rt2870_io_bbp_write(sc, 1, val);
3112
3113 for (i = 0; i < RT2870_SOFTC_TXPOW_RATE_COUNT; i++)
3114 {
3115 if (txpow_rate[i] == 0xffffffff)
3116 continue;
3117
3118 tmp = rt2870_read_eeprom_txpow_rate_add_delta(txpow_rate[i], delta);
3119
3120 rt2870_io_mac_write(sc, RT2870_REG_TX_PWR_CFG(i), tmp);
3121 }
3122 }
3123
3124 /*
3125 * rt2870_asic_update_promisc
3126 */
3127 static void rt2870_asic_update_promisc(struct rt2870_softc *sc)
3128 {
3129 struct ifnet *ifp;
3130 uint32_t tmp;
3131
3132 ifp = sc->ifp;
3133
3134 printf("%s: %s promiscuous mode\n",
3135 device_get_nameunit(sc->dev),
3136 (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
3137
3138 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_FILTER_CFG);
3139
3140 tmp &= ~RT2870_REG_RX_FILTER_DROP_UC_NOME;
3141
3142 if (!(ifp->if_flags & IFF_PROMISC))
3143 tmp |= RT2870_REG_RX_FILTER_DROP_UC_NOME;
3144
3145 rt2870_io_mac_write(sc, RT2870_REG_RX_FILTER_CFG, tmp);
3146 }
3147
3148 /*
3149 * rt2870_asic_updateprot
3150 */
3151 static void rt2870_asic_updateprot(struct rt2870_softc *sc)
3152 {
3153 struct ifnet *ifp;
3154 struct ieee80211com *ic;
3155 struct ieee80211vap *vap;
3156 uint32_t cck_prot, ofdm_prot, mm20_prot, mm40_prot, gf20_prot, gf40_prot;
3157 uint8_t htopmode;
3158
3159 ifp = sc->ifp;
3160 ic = ifp->if_l2com;
3161 vap = TAILQ_FIRST(&ic->ic_vaps);
3162
3163 /* CCK frame protection */
3164
3165 cck_prot = RT2870_REG_RTSTH_ENABLE | RT2870_REG_PROT_NAV_SHORT |
3166 RT2870_REG_TXOP_ALLOW_ALL | RT2870_REG_PROT_CTRL_NONE;
3167
3168 /* set up protection frame phy mode and rate (MCS code) */
3169
3170 if (ic->ic_curmode == IEEE80211_MODE_11A)
3171 cck_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3172 (0 << RT2870_REG_PROT_MCS_SHIFT);
3173 else
3174 cck_prot |= ((RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3175 (3 << RT2870_REG_PROT_MCS_SHIFT));
3176
3177 rt2870_io_mac_write(sc, RT2870_REG_TX_CCK_PROT_CFG, cck_prot);
3178
3179 /* OFDM frame protection */
3180
3181 ofdm_prot = RT2870_REG_RTSTH_ENABLE | RT2870_REG_PROT_NAV_SHORT |
3182 RT2870_REG_TXOP_ALLOW_ALL;
3183
3184 if (ic->ic_flags & IEEE80211_F_USEPROT)
3185 {
3186 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3187 "%s: updating protection mode: b/g protection mode=%s\n",
3188 device_get_nameunit(sc->dev),
3189 (ic->ic_protmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3190 ((ic->ic_protmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3191
3192 if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
3193 ofdm_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3194 else if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
3195 ofdm_prot |= RT2870_REG_PROT_CTRL_CTS;
3196 else
3197 ofdm_prot |= RT2870_REG_PROT_CTRL_NONE;
3198 }
3199 else
3200 {
3201 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3202 "%s: updating protection mode: b/g protection mode=%s\n",
3203 device_get_nameunit(sc->dev), "none");
3204
3205 ofdm_prot |= RT2870_REG_PROT_CTRL_NONE;
3206 }
3207
3208 rt2870_io_mac_write(sc, RT2870_REG_TX_OFDM_PROT_CFG, ofdm_prot);
3209
3210 /* HT frame protection */
3211
3212 if ((vap->iv_opmode == IEEE80211_M_STA) && (vap->iv_state == IEEE80211_S_RUN))
3213 htopmode = vap->iv_bss->ni_htopmode;
3214 else
3215 htopmode = ic->ic_curhtprotmode;
3216
3217 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3218 "%s: updating protection mode: HT operation mode=0x%02x, protection mode=%s\n",
3219 device_get_nameunit(sc->dev),
3220 htopmode & IEEE80211_HTINFO_OPMODE,
3221 (ic->ic_htprotmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3222 ((ic->ic_htprotmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3223
3224 switch (htopmode & IEEE80211_HTINFO_OPMODE)
3225 {
3226 /* IEEE80211_HTINFO_OPMODE_HT20PR */
3227 case IEEE80211_HTINFO_OPMODE_HT20PR:
3228 mm20_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3229 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3230 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20 |
3231 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3232 (4 << RT2870_REG_PROT_MCS_SHIFT);
3233
3234 gf20_prot = mm20_prot;
3235
3236 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3237 RT2870_REG_TXOP_ALLOW_ALL |
3238 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3239 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3240
3241 if (ic->ic_htprotmode == IEEE80211_PROT_RTSCTS)
3242 mm40_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3243 else if (ic->ic_htprotmode == IEEE80211_PROT_CTSONLY)
3244 mm40_prot |= RT2870_REG_PROT_CTRL_CTS;
3245 else
3246 mm40_prot |= RT2870_REG_PROT_CTRL_NONE;
3247
3248 gf40_prot = mm40_prot;
3249 break;
3250
3251 /* IEEE80211_HTINFO_OPMODE_MIXED */
3252 case IEEE80211_HTINFO_OPMODE_MIXED:
3253 mm20_prot = RT2870_REG_PROT_NAV_SHORT |
3254 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3255 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20;
3256
3257 if (ic->ic_flags & IEEE80211_F_USEPROT)
3258 mm20_prot |= (RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3259 (3 << RT2870_REG_PROT_MCS_SHIFT);
3260 else
3261 mm20_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3262 (4 << RT2870_REG_PROT_MCS_SHIFT);
3263
3264 if (ic->ic_htprotmode == IEEE80211_PROT_RTSCTS)
3265 mm20_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3266 else if (ic->ic_htprotmode == IEEE80211_PROT_CTSONLY)
3267 mm20_prot |= RT2870_REG_PROT_CTRL_CTS;
3268 else
3269 mm20_prot |= RT2870_REG_PROT_CTRL_NONE;
3270
3271 gf20_prot = mm20_prot;
3272
3273 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_TXOP_ALLOW_ALL;
3274
3275 if (ic->ic_flags & IEEE80211_F_USEPROT)
3276 mm40_prot |= (RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3277 (3 << RT2870_REG_PROT_MCS_SHIFT);
3278 else
3279 mm40_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3280 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3281
3282 if (ic->ic_htprotmode == IEEE80211_PROT_RTSCTS)
3283 mm40_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3284 else if (ic->ic_htprotmode == IEEE80211_PROT_CTSONLY)
3285 mm40_prot |= RT2870_REG_PROT_CTRL_CTS;
3286 else
3287 mm40_prot |= RT2870_REG_PROT_CTRL_NONE;
3288
3289 gf40_prot = mm40_prot;
3290 break;
3291
3292 /*
3293 * IEEE80211_HTINFO_OPMODE_PURE
3294 * IEEE80211_HTINFO_OPMODE_PROTOPT
3295 */
3296 case IEEE80211_HTINFO_OPMODE_PURE:
3297 case IEEE80211_HTINFO_OPMODE_PROTOPT:
3298 default:
3299 mm20_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3300 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3301 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20 |
3302 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3303 (4 << RT2870_REG_PROT_MCS_SHIFT);
3304
3305 gf20_prot = mm20_prot;
3306
3307 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3308 RT2870_REG_TXOP_ALLOW_ALL |
3309 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3310 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3311
3312 gf40_prot = mm40_prot;
3313 break;
3314 }
3315
3316 rt2870_io_mac_write(sc, RT2870_REG_TX_MM20_PROT_CFG, mm20_prot);
3317 rt2870_io_mac_write(sc, RT2870_REG_TX_MM40_PROT_CFG, mm40_prot);
3318 rt2870_io_mac_write(sc, RT2870_REG_TX_GF20_PROT_CFG, gf20_prot);
3319 rt2870_io_mac_write(sc, RT2870_REG_TX_GF40_PROT_CFG, gf40_prot);
3320 }
3321
3322 /*
3323 * rt2870_asic_updateslot
3324 */
3325 static void rt2870_asic_updateslot(struct rt2870_softc *sc)
3326 {
3327 struct ifnet *ifp;
3328 struct ieee80211com *ic;
3329 uint32_t tmp;
3330
3331 ifp = sc->ifp;
3332 ic = ifp->if_l2com;
3333
3334 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3335 "%s: %s short slot time\n",
3336 device_get_nameunit(sc->dev),
3337 (ic->ic_flags & IEEE80211_F_SHSLOT) ? "enabling" : "disabling");
3338
3339 tmp = rt2870_io_mac_read(sc, RT2870_REG_BKOFF_SLOT_CFG);
3340
3341 tmp &= ~0xff;
3342 tmp |= (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
3343
3344 rt2870_io_mac_write(sc, RT2870_REG_BKOFF_SLOT_CFG, tmp);
3345 }
3346
3347 /*
3348 * rt2870_asic_wme_update
3349 */
3350 static void rt2870_asic_wme_update(struct rt2870_softc *sc)
3351 {
3352 struct ifnet *ifp;
3353 struct ieee80211com *ic;
3354 struct ieee80211_wme_state *wme;
3355 const struct wmeParams *wmep;
3356 int i;
3357
3358 ifp = sc->ifp;
3359 ic = ifp->if_l2com;
3360 wme = &ic->ic_wme;
3361 wmep = wme->wme_chanParams.cap_wmeParams;
3362
3363 RT2870_DPRINTF(sc, RT2870_DEBUG_WME,
3364 "%s: wme update: WME_AC_VO=%d/%d/%d/%d, WME_AC_VI=%d/%d/%d/%d, "
3365 "WME_AC_BK=%d/%d/%d/%d, WME_AC_BE=%d/%d/%d/%d\n",
3366 device_get_nameunit(sc->dev),
3367 wmep[WME_AC_VO].wmep_aifsn,
3368 wmep[WME_AC_VO].wmep_logcwmin, wmep[WME_AC_VO].wmep_logcwmax,
3369 wmep[WME_AC_VO].wmep_txopLimit,
3370 wmep[WME_AC_VI].wmep_aifsn,
3371 wmep[WME_AC_VI].wmep_logcwmin, wmep[WME_AC_VI].wmep_logcwmax,
3372 wmep[WME_AC_VI].wmep_txopLimit,
3373 wmep[WME_AC_BK].wmep_aifsn,
3374 wmep[WME_AC_BK].wmep_logcwmin, wmep[WME_AC_BK].wmep_logcwmax,
3375 wmep[WME_AC_BK].wmep_txopLimit,
3376 wmep[WME_AC_BE].wmep_aifsn,
3377 wmep[WME_AC_BE].wmep_logcwmin, wmep[WME_AC_BE].wmep_logcwmax,
3378 wmep[WME_AC_BE].wmep_txopLimit);
3379
3380 for (i = 0; i < WME_NUM_AC; i++)
3381 rt2870_io_mac_write(sc, RT2870_REG_TX_EDCA_AC_CFG(i),
3382 (wmep[i].wmep_logcwmax << 16) | (wmep[i].wmep_logcwmin << 12) |
3383 (wmep[i].wmep_aifsn << 8) | wmep[i].wmep_txopLimit);
3384
3385 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_AIFSN_CFG,
3386 (wmep[WME_AC_VO].wmep_aifsn << 12) | (wmep[WME_AC_VI].wmep_aifsn << 8) |
3387 (wmep[WME_AC_BK].wmep_aifsn << 4) | wmep[WME_AC_BE].wmep_aifsn);
3388
3389 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_CWMIN_CFG,
3390 (wmep[WME_AC_VO].wmep_logcwmin << 12) | (wmep[WME_AC_VI].wmep_logcwmin << 8) |
3391 (wmep[WME_AC_BK].wmep_logcwmin << 4) | wmep[WME_AC_BE].wmep_logcwmin);
3392
3393 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_CWMAX_CFG,
3394 (wmep[WME_AC_VO].wmep_logcwmax << 12) | (wmep[WME_AC_VI].wmep_logcwmax << 8) |
3395 (wmep[WME_AC_BK].wmep_logcwmax << 4) | wmep[WME_AC_BE].wmep_logcwmax);
3396
3397 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP0_CFG,
3398 (wmep[WME_AC_BK].wmep_txopLimit << 16) | wmep[WME_AC_BE].wmep_txopLimit);
3399
3400 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP1_CFG,
3401 (wmep[WME_AC_VO].wmep_txopLimit << 16) | wmep[WME_AC_VI].wmep_txopLimit);
3402 }
3403
3404 /*
3405 * rt2870_asic_update_beacon
3406 */
3407 static int rt2870_asic_update_beacon(struct rt2870_softc *sc,
3408 struct ieee80211vap *vap)
3409 {
3410 struct ifnet *ifp;
3411 struct ieee80211com *ic;
3412 struct rt2870_softc_vap *rvap;
3413 const struct ieee80211_txparam *tp;
3414 struct mbuf *m;
3415 struct rt2870_txwi txwi;
3416 uint8_t rate, mcs;
3417 uint32_t tmp;
3418
3419 ifp = sc->ifp;
3420 ic = ifp->if_l2com;
3421 rvap = (struct rt2870_softc_vap *) vap;
3422 tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
3423
3424 m = ieee80211_beacon_alloc(vap->iv_bss, &rvap->beacon_offsets);
3425 if (m == NULL)
3426 return ENOMEM;
3427
3428 rate = tp->mgmtrate;
3429 mcs = rt2870_rate2mcs(rate);
3430
3431 memset(&txwi, 0, sizeof(struct rt2870_txwi));
3432
3433 txwi.wcid = 0xff;
3434 txwi.pid_mpdu_len = ((htole16(m->m_pkthdr.len) & RT2870_TXWI_MPDU_LEN_MASK) <<
3435 RT2870_TXWI_MPDU_LEN_SHIFT);
3436 txwi.txop = (RT2870_TXWI_TXOP_HT << RT2870_TXWI_TXOP_SHIFT);
3437 txwi.mpdu_density_flags |=
3438 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
3439 txwi.bawin_size_xflags |=
3440 (RT2870_TXWI_XFLAGS_NSEQ << RT2870_TXWI_XFLAGS_SHIFT);
3441
3442 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
3443 {
3444 txwi.phymode_ifs_stbc_shortgi =
3445 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
3446
3447 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
3448 mcs |= RT2870_TXWI_MCS_SHOTPRE;
3449 }
3450 else
3451 {
3452 txwi.phymode_ifs_stbc_shortgi =
3453 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
3454 }
3455
3456 txwi.bw_mcs = (RT2870_TXWI_BW_20 << RT2870_TXWI_BW_SHIFT) |
3457 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
3458
3459 /* disable temporarily TSF sync */
3460
3461 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3462
3463 tmp &= ~(RT2870_REG_BCN_TX_ENABLE |
3464 RT2870_REG_TSF_TIMER_ENABLE |
3465 RT2870_REG_TBTT_TIMER_ENABLE);
3466
3467 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3468
3469 /* write Tx wireless info and beacon frame to on-chip memory */
3470
3471 rt2870_io_mac_write_multi(sc, RT2870_REG_BEACON_BASE(0),
3472 &txwi, sizeof(struct rt2870_txwi));
3473
3474 rt2870_io_mac_write_multi(sc, RT2870_REG_BEACON_BASE(0) + sizeof(struct rt2870_txwi),
3475 mtod(m, uint8_t *), m->m_pkthdr.len);
3476
3477 /* enable again TSF sync */
3478
3479 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3480
3481 tmp |= (RT2870_REG_BCN_TX_ENABLE |
3482 RT2870_REG_TSF_TIMER_ENABLE |
3483 RT2870_REG_TBTT_TIMER_ENABLE);
3484
3485 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3486
3487 m_freem(m);
3488
3489 return 0;
3490 }
3491
3492 /*
3493 * rt2870_asic_clear_keytables
3494 */
3495 static void rt2870_asic_clear_keytables(struct rt2870_softc *sc)
3496 {
3497 int i;
3498
3499 /* clear Rx WCID search table (entries = 256, entry size = 8) */
3500
3501 for (i = 0; i < 256; i++)
3502 {
3503 rt2870_io_mac_write(sc, RT2870_REG_WCID(i), 0xffffffff);
3504 rt2870_io_mac_write(sc, RT2870_REG_WCID(i) + 4, 0x0000ffff);
3505 }
3506
3507 /* clear WCID attribute table (entries = 256, entry size = 4) */
3508
3509 rt2870_io_mac_set_region_4(sc, RT2870_REG_WCID_ATTR(0), 0, 256);
3510
3511 /* clear IV/EIV table (entries = 256, entry size = 8) */
3512
3513 rt2870_io_mac_set_region_4(sc, RT2870_REG_IVEIV(0), 0, 2 * 256);
3514
3515 /* clear pairwise key table (entries = 256, entry size = 32) */
3516
3517 rt2870_io_mac_set_region_4(sc, RT2870_REG_PKEY(0), 0, 8 * 256);
3518
3519 /* clear shared key table (entries = 32, entry size = 32) */
3520
3521 rt2870_io_mac_set_region_4(sc, RT2870_REG_SKEY(0, 0), 0, 8 * 32);
3522
3523 /* clear shared key mode (entries = 32, entry size = 2) */
3524
3525 rt2870_io_mac_set_region_4(sc, RT2870_REG_SKEY_MODE(0), 0, 16);
3526 }
3527
3528 /*
3529 * rt2870_rxrate
3530 */
3531 static uint8_t rt2870_rxrate(struct rt2870_rxwi *rxwi)
3532 {
3533 uint8_t mcs, phymode;
3534 uint8_t rate;
3535
3536 mcs = (rxwi->bw_mcs >> RT2870_RXWI_MCS_SHIFT) & RT2870_RXWI_MCS_MASK;
3537 phymode = (rxwi->phymode_stbc_shortgi >> RT2870_RXWI_PHYMODE_SHIFT) &
3538 RT2870_RXWI_PHYMODE_MASK;
3539
3540 rate = 2;
3541
3542 switch (phymode)
3543 {
3544 case RT2870_RXWI_PHYMODE_CCK:
3545 switch (mcs & ~RT2870_RXWI_MCS_SHOTPRE)
3546 {
3547 case 0: rate = 2; break; /* 1 Mbps */
3548 case 1: rate = 4; break; /* 2 MBps */
3549 case 2: rate = 11; break; /* 5.5 Mbps */
3550 case 3: rate = 22; break; /* 11 Mbps */
3551 }
3552 break;
3553
3554 case RT2870_RXWI_PHYMODE_OFDM:
3555 switch (mcs)
3556 {
3557 case 0: rate = 12; break; /* 6 Mbps */
3558 case 1: rate = 18; break; /* 9 Mbps */
3559 case 2: rate = 24; break; /* 12 Mbps */
3560 case 3: rate = 36; break; /* 18 Mbps */
3561 case 4: rate = 48; break; /* 24 Mbps */
3562 case 5: rate = 72; break; /* 36 Mbps */
3563 case 6: rate = 96; break; /* 48 Mbps */
3564 case 7: rate = 108; break; /* 54 Mbps */
3565 }
3566 break;
3567
3568 case RT2870_RXWI_PHYMODE_HT_MIXED:
3569 case RT2870_RXWI_PHYMODE_HT_GF:
3570 break;
3571 }
3572
3573 return rate;
3574 }
3575
3576 /*
3577 * rt2870_maxrssi_rxpath
3578 */
3579 static uint8_t rt2870_maxrssi_rxpath(struct rt2870_softc *sc,
3580 const struct rt2870_rxwi *rxwi)
3581 {
3582 uint8_t rxpath;
3583
3584 rxpath = 0;
3585
3586 if (sc->nrxpath > 1)
3587 if (rxwi->rssi[1] > rxwi->rssi[rxpath])
3588 rxpath = 1;
3589
3590 if (sc->nrxpath > 2)
3591 if (rxwi->rssi[2] > rxwi->rssi[rxpath])
3592 rxpath = 2;
3593
3594 return rxpath;
3595 }
3596
3597 /*
3598 * rt2870_rssi2dbm
3599 */
3600 static int8_t rt2870_rssi2dbm(struct rt2870_softc *sc,
3601 uint8_t rssi, uint8_t rxpath)
3602 {
3603 struct ifnet *ifp;
3604 struct ieee80211com *ic;
3605 struct ieee80211_channel *c;
3606 int chan;
3607 int8_t rssi_off, lna_gain;
3608
3609 if (rssi == 0)
3610 return -99;
3611
3612 ifp = sc->ifp;
3613 ic = ifp->if_l2com;
3614 c = ic->ic_curchan;
3615 chan = ieee80211_chan2ieee(ic, c);
3616
3617 if (IEEE80211_IS_CHAN_5GHZ(c))
3618 {
3619 rssi_off = sc->rssi_off_5ghz[rxpath];
3620
3621 if (chan <= 64)
3622 lna_gain = sc->lna_gain[1];
3623 else if (chan <= 128)
3624 lna_gain = sc->lna_gain[2];
3625 else
3626 lna_gain = sc->lna_gain[3];
3627 }
3628 else
3629 {
3630 rssi_off = sc->rssi_off_2ghz[rxpath];
3631 lna_gain = sc->lna_gain[0];
3632 }
3633
3634 return (-12 - rssi_off - lna_gain - rssi);
3635 }
3636
3637 /*
3638 * rt2870_rate2mcs
3639 */
3640 static uint8_t rt2870_rate2mcs(uint8_t rate)
3641 {
3642 switch (rate)
3643 {
3644 /* CCK rates */
3645 case 2: return 0;
3646 case 4: return 1;
3647 case 11: return 2;
3648 case 22: return 3;
3649
3650 /* OFDM rates */
3651 case 12: return 0;
3652 case 18: return 1;
3653 case 24: return 2;
3654 case 36: return 3;
3655 case 48: return 4;
3656 case 72: return 5;
3657 case 96: return 6;
3658 case 108: return 7;
3659 }
3660
3661 return 0;
3662 }
3663
3664 /*
3665 * rt2870_rx_frame
3666 */
3667 static void rt2870_rx_frame(struct rt2870_softc *sc,
3668 uint8_t *buf, uint32_t dmalen)
3669 {
3670 struct ifnet *ifp;
3671 struct ieee80211com *ic;
3672 struct ieee80211_frame *wh;
3673 struct ieee80211_node *ni;
3674 struct rt2870_softc_rx_radiotap_header *tap;
3675 struct rt2870_rxwi *rxwi;
3676 struct rt2870_rxinfo *rxinfo;
3677 struct mbuf *m;
3678 uint32_t rxinfo_flags;
3679 uint8_t cipher_err, rssi, ant, phymode, bw, shortgi, mcs;
3680 int8_t rssi_dbm;
3681 int len, ampdu, amsdu;
3682
3683 ifp = sc->ifp;
3684 ic = ifp->if_l2com;
3685
3686 /* get Rx wireless info */
3687
3688 rxwi = (struct rt2870_rxwi *) buf;
3689 len = (le16toh(rxwi->tid_size) >> RT2870_RXWI_SIZE_SHIFT) &
3690 RT2870_RXWI_SIZE_MASK;
3691
3692 if (len > dmalen)
3693 {
3694 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3695 "%s: bad rxwi len: DMA len=%d, rxwi len=%d\n",
3696 device_get_nameunit(sc->dev), dmalen, len);
3697 return;
3698 }
3699
3700 /* get Rx info */
3701
3702 rxinfo = (struct rt2870_rxinfo *) ((caddr_t) rxwi + dmalen);
3703 rxinfo_flags = le32toh(rxinfo->flags);
3704
3705 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3706 "%s: Rx frame: DMA len=%d, len=%d, rxinfo flags=0x%08x\n",
3707 device_get_nameunit(sc->dev), dmalen, len, rxinfo_flags);
3708
3709 /* check for crc errors */
3710
3711 if (rxinfo_flags & RT2870_RXINFO_FLAGS_CRC_ERR)
3712 {
3713 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3714 "%s: rxinfo: crc error\n",
3715 device_get_nameunit(sc->dev));
3716
3717 ifp->if_ierrors++;
3718
3719 if (!(ifp->if_flags & IFF_PROMISC))
3720 return;
3721 }
3722
3723 wh = (struct ieee80211_frame *) (rxwi + 1);
3724
3725 /* check for L2 padding between IEEE 802.11 frame header and body */
3726
3727 if (rxinfo_flags & RT2870_RXINFO_FLAGS_L2PAD)
3728 {
3729 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3730 "%s: L2 padding: DMA len=%d, len=%d\n",
3731 device_get_nameunit(sc->dev), dmalen, len);
3732
3733 len += 2;
3734 }
3735
3736 m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
3737 if (m == NULL)
3738 {
3739 sc->rx_mbuf_alloc_errors++;
3740 ifp->if_ierrors++;
3741 return;
3742 }
3743
3744 m->m_pkthdr.rcvif = ifp;
3745 m->m_pkthdr.len = m->m_len = len;
3746
3747 m_copyback(m, 0, len, (caddr_t) wh);
3748
3749 wh = mtod(m, struct ieee80211_frame *);
3750
3751 /* check for cipher errors */
3752
3753 if (rxinfo_flags & RT2870_RXINFO_FLAGS_DECRYPTED)
3754 {
3755 cipher_err = ((rxinfo_flags >> RT2870_RXINFO_FLAGS_CIPHER_ERR_SHIFT) &
3756 RT2870_RXINFO_FLAGS_CIPHER_ERR_MASK);
3757 if (cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_NONE)
3758 {
3759 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3760 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
3761
3762 m->m_flags |= M_WEP;
3763 }
3764 else
3765 {
3766 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3767 "%s: rxinfo: cipher error=0x%02x\n",
3768 device_get_nameunit(sc->dev), cipher_err);
3769
3770 ifp->if_ierrors++;
3771
3772 if (!(ifp->if_flags & IFF_PROMISC))
3773 {
3774 m_free(m);
3775 return;
3776 }
3777 }
3778 }
3779 else
3780 {
3781 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3782 {
3783 ifp->if_ierrors++;
3784
3785 if (!(ifp->if_flags & IFF_PROMISC))
3786 {
3787 m_free(m);
3788 return;
3789 }
3790 }
3791 }
3792
3793 /* check for A-MPDU */
3794
3795 if (rxinfo_flags & RT2870_RXINFO_FLAGS_AMPDU)
3796 {
3797 m->m_flags |= M_AMPDU;
3798 ampdu = 1;
3799 }
3800 else
3801 {
3802 ampdu = 0;
3803 }
3804
3805 ant = rt2870_maxrssi_rxpath(sc, rxwi);
3806 rssi = rxwi->rssi[ant];
3807 rssi_dbm = rt2870_rssi2dbm(sc, rssi, ant);
3808 phymode = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_PHYMODE_SHIFT) &
3809 RT2870_RXWI_PHYMODE_MASK);
3810 bw = ((rxwi->bw_mcs >> RT2870_RXWI_BW_SHIFT) & RT2870_RXWI_BW_MASK);
3811 shortgi = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_SHORTGI_SHIFT) &
3812 RT2870_RXWI_SHORTGI_MASK);
3813 mcs = ((rxwi->bw_mcs >> RT2870_RXWI_MCS_SHIFT) & RT2870_RXWI_MCS_MASK);
3814 amsdu = (rxinfo_flags & RT2870_RXINFO_FLAGS_AMSDU);
3815
3816 if (ieee80211_radiotap_active(ic))
3817 {
3818 tap = &sc->rxtap;
3819
3820 tap->flags = (rxinfo_flags & RT2870_RXINFO_FLAGS_L2PAD) ? IEEE80211_RADIOTAP_F_DATAPAD : 0;
3821 tap->dbm_antsignal = rssi_dbm;
3822 tap->dbm_antnoise = RT2870_NOISE_FLOOR;
3823 tap->antenna = ant;
3824 tap->antsignal = rssi;
3825 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
3826 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
3827 tap->chan_ieee = ic->ic_curchan->ic_ieee;
3828 tap->chan_maxpow = 0;
3829
3830 if (phymode == RT2870_RXWI_PHYMODE_CCK || phymode == RT2870_RXWI_PHYMODE_OFDM)
3831 tap->rate = rt2870_rxrate(rxwi);
3832 else
3833 tap->rate = mcs | IEEE80211_RATE_MCS;
3834
3835 if (rxwi->bw_mcs & RT2870_RXWI_MCS_SHOTPRE)
3836 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
3837
3838 if (shortgi)
3839 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
3840 }
3841
3842 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
3843 "%s: received frame: len=%d, phymode=%d, bw=%d, shortgi=%d, mcs=%d, "
3844 "ant=%d, rssi=%d/%d/%d, snr=%d/%d, wcid=0x%02x, ampdu=%d, amsdu=%d\n",
3845 device_get_nameunit(sc->dev),
3846 len, phymode, bw, shortgi, mcs,
3847 ant, rxwi->rssi[0], rxwi->rssi[1], rxwi->rssi[2],
3848 rxwi->snr[0], rxwi->snr[1],
3849 rxwi->wcid, ampdu, amsdu);
3850
3851 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *) wh);
3852 if (ni != NULL)
3853 {
3854 ieee80211_input(ni, m, rssi_dbm - RT2870_NOISE_FLOOR, RT2870_NOISE_FLOOR);
3855 ieee80211_free_node(ni);
3856 }
3857 else
3858 {
3859 ieee80211_input_all(ic, m, rssi_dbm - RT2870_NOISE_FLOOR, RT2870_NOISE_FLOOR);
3860 }
3861 }
3862
3863 /*
3864 * rt2870_tx_mgmt
3865 */
3866 static int rt2870_tx_mgmt(struct rt2870_softc *sc,
3867 struct mbuf *m, struct ieee80211_node *ni, int qid)
3868 {
3869 struct ifnet *ifp;
3870 struct ieee80211com *ic;
3871 struct ieee80211vap *vap;
3872 const struct ieee80211_txparam *tp;
3873 struct rt2870_softc_node *rni;
3874 struct rt2870_softc_tx_ring *ring;
3875 struct rt2870_softc_tx_data *data;
3876 struct rt2870_txinfo *txinfo;
3877 struct rt2870_txwi *txwi;
3878 struct ieee80211_frame *wh;
3879 struct rt2870_softc_tx_radiotap_header *tap;
3880 u_int hdrsize, hdrspace;
3881 uint8_t rate, stbc, shortgi, mcs, pid;
3882 uint16_t len, dmalen, mpdu_len, dur;
3883
3884 KASSERT(qid >= 0 && qid < (sc->usb_endpoints - 1),
3885 ("%s: Tx MGMT: invalid qid=%d\n",
3886 device_get_nameunit(sc->dev), qid));
3887
3888 ifp = sc->ifp;
3889 ic = ifp->if_l2com;
3890 vap = ni->ni_vap;
3891 rni = (struct rt2870_softc_node *) ni;
3892 tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
3893
3894 ring = &sc->tx_ring[qid];
3895 data = STAILQ_FIRST(&ring->inactive);
3896 STAILQ_REMOVE_HEAD(&ring->inactive, next);
3897 txinfo = (struct rt2870_txinfo *) data->buf;
3898 txwi = (struct rt2870_txwi *) (txinfo + 1);
3899
3900 wh = mtod(m, struct ieee80211_frame *);
3901
3902 rate = tp->mgmtrate & IEEE80211_RATE_VAL;
3903
3904 len = sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + m->m_pkthdr.len;
3905
3906 /* align end on a 4-bytes boundary */
3907
3908 dmalen = (len + 3) & ~3;
3909
3910 /* fill Tx info */
3911
3912 memset(txinfo, 0, sizeof(struct rt2870_txinfo));
3913
3914 txinfo->len = htole16(dmalen - sizeof(struct rt2870_txinfo));
3915
3916 txinfo->qsel_flags = (RT2870_TXINFO_QSEL_EDCA << RT2870_TXINFO_QSEL_SHIFT);
3917
3918 dmalen += 4;
3919
3920 memset((caddr_t) txinfo + len, 0, dmalen - len);
3921
3922 /* fill Tx wireless info */
3923
3924 if (ni->ni_flags & IEEE80211_NODE_HT)
3925 mcs = rate;
3926 else
3927 mcs = rt2870_rate2mcs(rate);
3928
3929 pid = mcs;
3930
3931 /* calculate MPDU length without padding */
3932
3933 hdrsize = ieee80211_hdrsize(wh);
3934 hdrspace = ieee80211_hdrspace(ic, wh);
3935 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
3936
3937 memset(txwi, 0, sizeof(struct rt2870_txwi));
3938
3939 /* management frames do not need encryption */
3940
3941 txwi->wcid = 0xff;
3942
3943 txwi->pid_mpdu_len = ((htole16(pid) & RT2870_TXWI_PID_MASK) <<
3944 RT2870_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2870_TXWI_MPDU_LEN_MASK) <<
3945 RT2870_TXWI_MPDU_LEN_SHIFT);
3946
3947 stbc = (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC) ? 1 : 0;
3948
3949 shortgi = (vap->iv_flags_ht & (IEEE80211_FHT_SHORTGI20 | IEEE80211_FHT_SHORTGI40)) &&
3950 (ni->ni_flags & IEEE80211_NODE_HT);
3951
3952 txwi->phymode_ifs_stbc_shortgi |=
3953 ((stbc & RT2870_TXWI_STBC_MASK) << RT2870_TXWI_STBC_SHIFT) |
3954 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
3955
3956 txwi->phymode_ifs_stbc_shortgi |=
3957 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
3958
3959 if (ni->ni_flags & IEEE80211_NODE_HT)
3960 {
3961 txwi->phymode_ifs_stbc_shortgi |=
3962 (RT2870_TXWI_PHYMODE_HT_MIXED << RT2870_TXWI_PHYMODE_SHIFT);
3963 }
3964 else
3965 {
3966 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
3967 {
3968 txwi->phymode_ifs_stbc_shortgi |=
3969 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
3970
3971 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
3972 mcs |= RT2870_TXWI_MCS_SHOTPRE;
3973 }
3974 else
3975 {
3976 txwi->phymode_ifs_stbc_shortgi |=
3977 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
3978 }
3979 }
3980
3981 txwi->bw_mcs = (RT2870_TXWI_BW_20 << RT2870_TXWI_BW_SHIFT) |
3982 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
3983
3984 txwi->txop = (RT2870_TXWI_TXOP_BACKOFF << RT2870_TXWI_TXOP_SHIFT);
3985
3986 /* skip ACKs for multicast frames and probe responses */
3987
3988 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
3989 ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) !=
3990 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP)))
3991 {
3992 txwi->bawin_size_xflags |=
3993 (RT2870_TXWI_XFLAGS_ACK << RT2870_TXWI_XFLAGS_SHIFT);
3994
3995 if (ni->ni_flags & IEEE80211_NODE_HT)
3996 {
3997 /* preamble + plcp + signal extension */
3998
3999 dur = 16 + 4 + 6;
4000 }
4001 else
4002 {
4003 dur = ieee80211_ack_duration(ic->ic_rt, rate,
4004 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
4005 }
4006
4007 *(uint16_t *) wh->i_dur = htole16(dur);
4008 }
4009
4010 /* ask MAC to insert timestamp into probe responses */
4011
4012 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
4013 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
4014 txwi->mpdu_density_flags |=
4015 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4016
4017 if (ieee80211_radiotap_active_vap(vap))
4018 {
4019 tap = &sc->txtap;
4020
4021 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
4022 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4023 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4024 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4025 tap->chan_maxpow = 0;
4026
4027 if (ni->ni_flags & IEEE80211_NODE_HT)
4028 tap->rate = mcs | IEEE80211_RATE_MCS;
4029 else
4030 tap->rate = rate;
4031
4032 if (mcs & RT2870_TXWI_MCS_SHOTPRE)
4033 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4034
4035 if (shortgi)
4036 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4037
4038 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4039 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4040
4041 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4042 {
4043 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4044
4045 ieee80211_radiotap_tx(vap, m);
4046
4047 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4048 }
4049 else
4050 {
4051 ieee80211_radiotap_tx(vap, m);
4052 }
4053 }
4054
4055 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t) (txwi + 1));
4056
4057 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4058 "%s: sending MGMT frame: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4059 "stbc=%d, shortgi=%d, mcs=%d, DMA len=%d\n",
4060 device_get_nameunit(sc->dev),
4061 qid, hdrsize, hdrspace, m->m_pkthdr.len, stbc, shortgi, mcs, dmalen);
4062
4063 data->len = dmalen;
4064 data->m = m;
4065 data->ni = ni;
4066
4067 STAILQ_INSERT_TAIL(&ring->pending, data, next);
4068 ring->queued++;
4069
4070 usbd_transfer_start(sc->usb_xfer[1 + qid]);
4071
4072 return 0;
4073 }
4074
4075 /*
4076 * rt2870_tx_data
4077 */
4078 static int rt2870_tx_data(struct rt2870_softc *sc,
4079 struct mbuf *m, struct ieee80211_node *ni, int qid)
4080 {
4081 struct ifnet *ifp;
4082 struct ieee80211com *ic;
4083 struct ieee80211vap *vap;
4084 const struct ieee80211_txparam *tp;
4085 struct rt2870_softc_node *rni;
4086 struct rt2870_softc_tx_ring *ring;
4087 struct rt2870_softc_tx_data *data;
4088 struct rt2870_txinfo *txinfo;
4089 struct rt2870_txwi *txwi;
4090 struct ieee80211_frame *wh;
4091 struct rt2870_softc_tx_radiotap_header *tap;
4092 u_int hdrsize, hdrspace;
4093 uint8_t type, rate, bw, stbc, shortgi, mcs, pid, wcid;
4094 uint16_t qos, len, dmalen, mpdu_len, dur;
4095 int hasqos;
4096
4097 KASSERT(qid >= 0 && qid < (sc->usb_endpoints - 1),
4098 ("%s: Tx data: invalid qid=%d\n",
4099 device_get_nameunit(sc->dev), qid));
4100
4101 ifp = sc->ifp;
4102 ic = ifp->if_l2com;
4103 vap = ni->ni_vap;
4104 rni = (struct rt2870_softc_node *) ni;
4105 tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)];
4106
4107 ring = &sc->tx_ring[qid];
4108 data = STAILQ_FIRST(&ring->inactive);
4109 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4110 txinfo = (struct rt2870_txinfo *) data->buf;
4111 txwi = (struct rt2870_txwi *) (txinfo + 1);
4112
4113 wh = mtod(m, struct ieee80211_frame *);
4114
4115 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
4116
4117 hasqos = IEEE80211_QOS_HAS_SEQ(wh);
4118 if (hasqos)
4119 {
4120 if (IEEE80211_HAS_ADDR4(wh))
4121 qos = le16toh(*(const uint16_t *)
4122 (((struct ieee80211_qosframe_addr4 *) wh)->i_qos));
4123 else
4124 qos = le16toh(*(const uint16_t *)
4125 (((struct ieee80211_qosframe *) wh)->i_qos));
4126 }
4127 else
4128 {
4129 qos = 0;
4130 }
4131
4132 if (IEEE80211_IS_MULTICAST(wh->i_addr1))
4133 rate = tp->mcastrate;
4134 else if (m->m_flags & M_EAPOL)
4135 rate = tp->mgmtrate;
4136 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
4137 rate = tp->ucastrate;
4138 else
4139 rate = ni->ni_txrate;
4140
4141 rate &= IEEE80211_RATE_VAL;
4142
4143 len = sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + m->m_pkthdr.len;
4144
4145 /* align end on a 4-bytes boundary */
4146
4147 dmalen = (len + 3) & ~3;
4148
4149 /* fill Tx info */
4150
4151 memset(txinfo, 0, sizeof(struct rt2870_txinfo));
4152
4153 txinfo->len = htole16(dmalen - sizeof(struct rt2870_txinfo));
4154
4155 txinfo->qsel_flags = (RT2870_TXINFO_QSEL_EDCA << RT2870_TXINFO_QSEL_SHIFT);
4156
4157 dmalen += 4;
4158
4159 memset((caddr_t) txinfo + len, 0, dmalen - len);
4160
4161 /* fill Tx wireless info */
4162
4163 if (ni->ni_flags & IEEE80211_NODE_HT)
4164 mcs = rate;
4165 else
4166 mcs = rt2870_rate2mcs(rate);
4167
4168 pid = mcs;
4169
4170 wcid = (type == IEEE80211_FC0_TYPE_DATA) ?
4171 RT2870_AID2WCID(ni->ni_associd) : 0xff;
4172
4173 /* calculate MPDU length without padding */
4174
4175 hdrsize = ieee80211_hdrsize(wh);
4176 hdrspace = ieee80211_hdrspace(ic, wh);
4177 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
4178
4179 memset(txwi, 0, sizeof(struct rt2870_txwi));
4180
4181 txwi->wcid = wcid;
4182
4183 txwi->pid_mpdu_len = ((htole16(pid) & RT2870_TXWI_PID_MASK) <<
4184 RT2870_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2870_TXWI_MPDU_LEN_MASK) <<
4185 RT2870_TXWI_MPDU_LEN_SHIFT);
4186
4187 stbc = (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC) ? 1 : 0;
4188
4189 shortgi = (vap->iv_flags_ht & (IEEE80211_FHT_SHORTGI20 | IEEE80211_FHT_SHORTGI40)) &&
4190 (ni->ni_flags & IEEE80211_NODE_HT);
4191
4192 txwi->phymode_ifs_stbc_shortgi |=
4193 ((stbc & RT2870_TXWI_STBC_MASK) << RT2870_TXWI_STBC_SHIFT) |
4194 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4195
4196 if (ni->ni_flags & IEEE80211_NODE_HT)
4197 {
4198 txwi->phymode_ifs_stbc_shortgi |=
4199 (RT2870_TXWI_PHYMODE_HT_MIXED << RT2870_TXWI_PHYMODE_SHIFT);
4200 }
4201 else
4202 {
4203 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
4204 {
4205 txwi->phymode_ifs_stbc_shortgi |=
4206 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
4207
4208 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
4209 mcs |= RT2870_TXWI_MCS_SHOTPRE;
4210 }
4211 else
4212 {
4213 txwi->phymode_ifs_stbc_shortgi |=
4214 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
4215 }
4216 }
4217
4218 if ((ni->ni_flags & IEEE80211_NODE_HT) &&
4219 (ni->ni_htcap & IEEE80211_HTCAP_CHWIDTH40))
4220 bw = RT2870_TXWI_BW_40;
4221 else
4222 bw = RT2870_TXWI_BW_20;
4223
4224 txwi->bw_mcs = ((bw & RT2870_TXWI_BW_MASK) << RT2870_TXWI_BW_SHIFT) |
4225 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
4226
4227 txwi->txop = (RT2870_TXWI_TXOP_HT << RT2870_TXWI_TXOP_SHIFT);
4228
4229 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
4230 (!hasqos || (qos & IEEE80211_QOS_ACKPOLICY) != IEEE80211_QOS_ACKPOLICY_NOACK))
4231 {
4232 txwi->bawin_size_xflags |=
4233 (RT2870_TXWI_XFLAGS_ACK << RT2870_TXWI_XFLAGS_SHIFT);
4234
4235 if (ni->ni_flags & IEEE80211_NODE_HT)
4236 {
4237 /* preamble + plcp + signal extension */
4238
4239 dur = 16 + 4 + 6;
4240 }
4241 else
4242 {
4243 dur = ieee80211_ack_duration(ic->ic_rt, rate,
4244 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
4245 }
4246
4247 *(uint16_t *) wh->i_dur = htole16(dur);
4248 }
4249
4250 /* ask MAC to insert timestamp into probe responses */
4251
4252 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
4253 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
4254 txwi->mpdu_density_flags |=
4255 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4256
4257 if (ieee80211_radiotap_active_vap(vap))
4258 {
4259 tap = &sc->txtap;
4260
4261 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
4262 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4263 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4264 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4265 tap->chan_maxpow = 0;
4266
4267 if (ni->ni_flags & IEEE80211_NODE_HT)
4268 tap->rate = mcs | IEEE80211_RATE_MCS;
4269 else
4270 tap->rate = rate;
4271
4272 if (mcs & RT2870_TXWI_MCS_SHOTPRE)
4273 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4274
4275 if (shortgi)
4276 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4277
4278 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4279 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4280
4281 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4282 {
4283 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4284
4285 ieee80211_radiotap_tx(vap, m);
4286
4287 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4288 }
4289 else
4290 {
4291 ieee80211_radiotap_tx(vap, m);
4292 }
4293 }
4294
4295 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t) (txwi + 1));
4296
4297 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4298 "%s: sending data: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4299 "bw=%d, stbc=%d, shortgi=%d, mcs=%d, wcid=0x%02x, DMA len=%d\n",
4300 device_get_nameunit(sc->dev),
4301 qid, hdrsize, hdrspace, m->m_pkthdr.len,
4302 bw, stbc, shortgi, mcs, wcid, dmalen);
4303
4304 data->len = dmalen;
4305 data->m = m;
4306 data->ni = ni;
4307
4308 STAILQ_INSERT_TAIL(&ring->pending, data, next);
4309 ring->queued++;
4310
4311 usbd_transfer_start(sc->usb_xfer[1 + qid]);
4312
4313 return 0;
4314 }
4315
4316 /*
4317 * rt2870_tx_raw
4318 */
4319 static int rt2870_tx_raw(struct rt2870_softc *sc,
4320 struct mbuf *m, struct ieee80211_node *ni,
4321 const struct ieee80211_bpf_params *params)
4322 {
4323 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4324 "%s: Tx raw\n",
4325 device_get_nameunit(sc->dev));
4326
4327 return 0;
4328 }
4329
4330 /*
4331 * rt2870_rx_intr
4332 */
4333 static void rt2870_rx_intr(struct usb_xfer *xfer, usb_error_t error)
4334 {
4335 struct rt2870_softc *sc;
4336 struct ifnet *ifp;
4337 struct rt2870_softc_rx_ring *ring;
4338 struct rt2870_softc_rx_data *data;
4339 int len;
4340
4341 sc = usbd_xfer_softc(xfer);
4342 ifp = sc->ifp;
4343 ring = &sc->rx_ring;
4344
4345 RT2870_DPRINTF(sc, RT2870_DEBUG_INTR,
4346 "%s: Rx interrupt: state=%d, error=%s\n",
4347 device_get_nameunit(sc->dev),
4348 USB_GET_STATE(xfer), usbd_errstr(error));
4349
4350 switch (USB_GET_STATE(xfer))
4351 {
4352 case USB_ST_TRANSFERRED:
4353 sc->interrupts++;
4354 sc->rx_interrupts++;
4355
4356 data = STAILQ_FIRST(&ring->active);
4357 if (data == NULL)
4358 goto setup;
4359
4360 STAILQ_REMOVE_HEAD(&ring->active, next);
4361
4362 usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
4363
4364 data->len = len;
4365
4366 STAILQ_INSERT_TAIL(&ring->done, data, next);
4367
4368 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
4369
4370 /* FALLTHROUGH */
4371
4372 setup:
4373
4374 case USB_ST_SETUP:
4375 data = STAILQ_FIRST(&ring->inactive);
4376 if (data == NULL)
4377 break;
4378
4379 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4380
4381 STAILQ_INSERT_TAIL(&ring->active, data, next);
4382
4383 usbd_xfer_set_frame_data(xfer, 0, data->buf, usbd_xfer_max_len(xfer));
4384 usbd_transfer_submit(xfer);
4385 break;
4386
4387 default:
4388 sc->interrupts++;
4389 sc->rx_interrupts++;
4390
4391 data = STAILQ_FIRST(&ring->active);
4392 if (data != NULL)
4393 {
4394 STAILQ_REMOVE_HEAD(&ring->active, next);
4395 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4396 }
4397
4398 if (error != USB_ERR_CANCELLED)
4399 {
4400 ifp->if_ierrors++;
4401
4402 usbd_xfer_set_stall(xfer);
4403
4404 goto setup;
4405 }
4406 break;
4407 }
4408 }
4409
4410 /*
4411 * rt2870_tx_intr
4412 */
4413 static void rt2870_tx_intr(struct usb_xfer *xfer, usb_error_t error)
4414 {
4415 struct rt2870_softc *sc;
4416 struct ifnet *ifp;
4417 struct rt2870_softc_tx_ring *ring;
4418 struct rt2870_softc_tx_data *data;
4419
4420 sc = usbd_xfer_softc(xfer);
4421 ifp = sc->ifp;
4422 ring = usbd_xfer_get_priv(xfer);
4423
4424 usbd_xfer_status(xfer, NULL, NULL, NULL, NULL);
4425
4426 RT2870_DPRINTF(sc, RT2870_DEBUG_INTR,
4427 "%s: Tx interrupt: state=%d, error=%s\n",
4428 device_get_nameunit(sc->dev),
4429 USB_GET_STATE(xfer), usbd_errstr(error));
4430
4431 switch (USB_GET_STATE(xfer))
4432 {
4433 case USB_ST_TRANSFERRED:
4434 sc->interrupts++;
4435 sc->tx_interrupts[ring->qid]++;
4436
4437 data = STAILQ_FIRST(&ring->active);
4438 if (data == NULL)
4439 goto setup;
4440
4441 STAILQ_REMOVE_HEAD(&ring->active, next);
4442
4443 STAILQ_INSERT_TAIL(&ring->done, data, next);
4444
4445 sc->tx_qid_pending_mask |= (1 << ring->qid);
4446
4447 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
4448
4449 /* FALLTHROUGH */
4450
4451 setup:
4452
4453 case USB_ST_SETUP:
4454 data = STAILQ_FIRST(&ring->pending);
4455 if (data == NULL)
4456 break;
4457
4458 STAILQ_REMOVE_HEAD(&ring->pending, next);
4459 STAILQ_INSERT_TAIL(&ring->active, data, next);
4460
4461 usbd_xfer_set_frame_data(xfer, 0, data->buf, data->len);
4462 usbd_transfer_submit(xfer);
4463
4464 RT2870_SOFTC_UNLOCK(sc);
4465
4466 rt2870_start(ifp);
4467
4468 RT2870_SOFTC_LOCK(sc);
4469 break;
4470
4471 default:
4472 sc->interrupts++;
4473 sc->tx_interrupts[ring->qid]++;
4474
4475 data = STAILQ_FIRST(&ring->active);
4476 if (data != NULL)
4477 {
4478 STAILQ_REMOVE_HEAD(&ring->active, next);
4479
4480 printf("%s: could not transmit buffer: qid=%d, error=%s\n",
4481 device_get_nameunit(sc->dev), ring->qid, usbd_errstr(error));
4482
4483 if (data->m != NULL)
4484 {
4485 m_freem(data->m);
4486 data->m = NULL;
4487 }
4488
4489 if (data->ni != NULL)
4490 {
4491 ieee80211_free_node(data->ni);
4492 data->ni = NULL;
4493 }
4494
4495 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4496
4497 ring->queued--;
4498 }
4499
4500 if (error != USB_ERR_CANCELLED)
4501 {
4502 ifp->if_oerrors++;
4503 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4504
4505 usbd_xfer_set_stall(xfer);
4506
4507 goto setup;
4508 }
4509 break;
4510 }
4511 }
4512
4513 /*
4514 * rt2870_rx_done_task
4515 */
4516 static void rt2870_rx_done_task(void *context, int pending)
4517 {
4518 struct rt2870_softc *sc;
4519 struct ifnet *ifp;
4520
4521 sc = context;
4522 ifp = sc->ifp;
4523
4524 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4525 "%s: Rx done task\n",
4526 device_get_nameunit(sc->dev));
4527
4528 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4529 return;
4530
4531 if (rt2870_rx_eof(sc, sc->rx_process_limit) != 0)
4532 {
4533 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4534 "%s: Rx done task: scheduling again\n",
4535 device_get_nameunit(sc->dev));
4536
4537 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
4538 }
4539 }
4540
4541 /*
4542 * rt2870_tx_done_task
4543 */
4544 static void rt2870_tx_done_task(void *context, int pending)
4545 {
4546 struct rt2870_softc *sc;
4547 struct ifnet *ifp;
4548 int i;
4549
4550 sc = context;
4551 ifp = sc->ifp;
4552
4553 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4554 "%s: Tx done task\n",
4555 device_get_nameunit(sc->dev));
4556
4557 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4558 return;
4559
4560 for (i = sc->usb_endpoints - 2; i >= 0; i--)
4561 {
4562 if (sc->tx_qid_pending_mask & (1 << i))
4563 {
4564 sc->tx_qid_pending_mask &= ~(1 << i);
4565
4566 rt2870_tx_eof(sc, &sc->tx_ring[i]);
4567 }
4568 }
4569
4570 if (sc->tx_qid_pending_mask != 0)
4571 {
4572 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4573 "%s: Tx done task: scheduling again\n",
4574 device_get_nameunit(sc->dev));
4575
4576 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
4577 }
4578
4579 sc->tx_timer = 0;
4580
4581 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4582 }
4583
4584 /*
4585 * rt2870_periodic_task
4586 */
4587 static void rt2870_periodic_task(void *context, int pending)
4588 {
4589 struct rt2870_softc *sc;
4590 struct ifnet *ifp;
4591 struct ieee80211com *ic;
4592 struct ieee80211vap *vap;
4593
4594 sc = context;
4595 ifp = sc->ifp;
4596 ic = ifp->if_l2com;
4597
4598 RT2870_DPRINTF(sc, RT2870_DEBUG_PERIODIC,
4599 "%s: periodic task: round=%lu\n",
4600 device_get_nameunit(sc->dev), sc->periodic_round);
4601
4602 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4603 return;
4604
4605 RT2870_SOFTC_LOCK(sc);
4606
4607 sc->periodic_round++;
4608
4609 rt2870_update_stats(sc);
4610
4611 if ((sc->periodic_round % 10) == 0)
4612 {
4613 rt2870_update_raw_counters(sc);
4614
4615 rt2870_watchdog(sc);
4616
4617 vap = TAILQ_FIRST(&ic->ic_vaps);
4618 if (vap != NULL)
4619 {
4620 if (vap->iv_opmode == IEEE80211_M_STA)
4621 rt2870_amrr_update_iter_func(vap, vap->iv_bss);
4622 else
4623 ieee80211_iterate_nodes(&ic->ic_sta, rt2870_amrr_update_iter_func, vap);
4624 }
4625 }
4626
4627 RT2870_SOFTC_UNLOCK(sc);
4628
4629 callout_reset(&sc->periodic_ch, hz / 10, rt2870_periodic, sc);
4630 }
4631
4632 /*
4633 * rt2870_cmd_task
4634 */
4635 static void rt2870_cmd_task(void *context, int pending)
4636 {
4637 struct rt2870_softc *sc;
4638 struct rt2870_softc_cmd_ring *ring;
4639 struct rt2870_softc_cmd *cmd;
4640
4641 sc = context;
4642 ring = &sc->cmd_ring;
4643
4644 while (1)
4645 {
4646 RT2870_SOFTC_LOCK(sc);
4647
4648 cmd = STAILQ_FIRST(&ring->active);
4649 if (cmd == NULL)
4650 {
4651 RT2870_SOFTC_UNLOCK(sc);
4652 break;
4653 }
4654
4655 STAILQ_REMOVE_HEAD(&ring->active, next);
4656
4657 RT2870_SOFTC_UNLOCK(sc);
4658
4659 cmd->cb(sc, cmd->data);
4660
4661 RT2870_SOFTC_LOCK(sc);
4662
4663 STAILQ_INSERT_TAIL(&ring->inactive, cmd, next);
4664 ring->queued--;
4665
4666 RT2870_SOFTC_UNLOCK(sc);
4667 }
4668 }
4669
4670 /*
4671 * rt2870_rx_eof
4672 */
4673 static int rt2870_rx_eof(struct rt2870_softc *sc, int limit)
4674 {
4675 struct ifnet *ifp;
4676 struct rt2870_softc_rx_ring *ring;
4677 struct rt2870_softc_rx_data *data;
4678 uint32_t dmalen;
4679 uint8_t *buf;
4680 int nframes, len;
4681
4682 ifp = sc->ifp;
4683 ring = &sc->rx_ring;
4684
4685 nframes = 0;
4686
4687 while (limit != 0)
4688 {
4689 RT2870_SOFTC_LOCK(sc);
4690
4691 data = STAILQ_FIRST(&ring->done);
4692 if (data == NULL)
4693 {
4694 RT2870_SOFTC_UNLOCK(sc);
4695 break;
4696 }
4697
4698 STAILQ_REMOVE_HEAD(&ring->done, next);
4699
4700 RT2870_SOFTC_UNLOCK(sc);
4701
4702 buf = data->buf;
4703 len = data->len;
4704
4705 if (len < RT2870_RX_DESC_SIZE)
4706 {
4707 ifp->if_ierrors++;
4708 goto skip;
4709 }
4710
4711 while (len > (sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)))
4712 {
4713 dmalen = (le32toh(*(uint32_t *) buf) & 0xffff);
4714
4715 if (dmalen == 0 || (dmalen & 3) != 0)
4716 {
4717 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4718 "%s: bad DMA len=%u\n",
4719 device_get_nameunit(sc->dev), dmalen);
4720 goto skip;
4721 }
4722
4723 if ((dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)) > len)
4724 {
4725 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4726 "%s: bad DMA len: DMA len=%u, USB len=%d\n",
4727 device_get_nameunit(sc->dev),
4728 (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)), len);
4729 goto skip;
4730 }
4731
4732 nframes++;
4733
4734 rt2870_rx_frame(sc, buf + sizeof(uint32_t), dmalen);
4735
4736 buf += (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo));
4737 len -= (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo));
4738 }
4739
4740 skip:
4741
4742 RT2870_SOFTC_LOCK(sc);
4743
4744 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4745
4746 usbd_transfer_start(sc->usb_xfer[0]);
4747
4748 RT2870_SOFTC_UNLOCK(sc);
4749
4750 limit--;
4751 }
4752
4753 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4754 "%s: Rx eof: nframes=%d\n",
4755 device_get_nameunit(sc->dev), nframes);
4756
4757 sc->rx_packets += nframes;
4758
4759 return (limit == 0);
4760 }
4761
4762 /*
4763 * rt2870_tx_eof
4764 */
4765 static void rt2870_tx_eof(struct rt2870_softc *sc,
4766 struct rt2870_softc_tx_ring *ring)
4767 {
4768 struct ifnet *ifp;
4769 struct rt2870_softc_tx_data *data;
4770 int nframes;
4771
4772 ifp = sc->ifp;
4773
4774 nframes = 0;
4775
4776 while (1)
4777 {
4778 RT2870_SOFTC_LOCK(sc);
4779
4780 data = STAILQ_FIRST(&ring->done);
4781 if (data == NULL)
4782 {
4783 RT2870_SOFTC_UNLOCK(sc);
4784 break;
4785 }
4786
4787 STAILQ_REMOVE_HEAD(&ring->done, next);
4788
4789 RT2870_SOFTC_UNLOCK(sc);
4790
4791 nframes++;
4792
4793 if (data->m->m_flags & M_TXCB)
4794 ieee80211_process_callback(data->ni, data->m, 0);
4795
4796 m_freem(data->m);
4797
4798 ieee80211_free_node(data->ni);
4799
4800 data->m = NULL;
4801 data->ni = NULL;
4802
4803 RT2870_SOFTC_LOCK(sc);
4804
4805 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
4806
4807 ring->queued--;
4808 ifp->if_opackets++;
4809
4810 RT2870_SOFTC_UNLOCK(sc);
4811 }
4812
4813 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4814 "%s: Tx eof: qid=%d, nframes=%d\n",
4815 device_get_nameunit(sc->dev), ring->qid, nframes);
4816 }
4817
4818 /*
4819 * rt2870_update_stats
4820 */
4821 static void rt2870_update_stats(struct rt2870_softc *sc)
4822 {
4823 struct ifnet *ifp;
4824 struct ieee80211com *ic;
4825 struct ieee80211vap *vap;
4826 struct ieee80211_node *ni;
4827 uint16_t associd;
4828 uint8_t wcid;
4829 uint32_t stacnt[3];
4830 int txcnt, retrycnt, failcnt;
4831
4832 ifp = sc->ifp;
4833 ic = ifp->if_l2com;
4834
4835 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
4836 "%s: update statistic\n",
4837 device_get_nameunit(sc->dev));
4838
4839 rt2870_drain_fifo_stats(sc);
4840
4841 if (ic->ic_opmode == IEEE80211_M_STA)
4842 {
4843 vap = TAILQ_FIRST(&ic->ic_vaps);
4844 ni = vap->iv_bss;
4845
4846 associd = (ni != NULL) ? ni->ni_associd : 0;
4847 wcid = RT2870_AID2WCID(associd);
4848
4849 /* read and clear Tx statistic registers */
4850
4851 rt2870_io_mac_read_multi(sc, RT2870_REG_TX_STA_CNT0,
4852 stacnt, sizeof(stacnt));
4853
4854 txcnt = le32toh(stacnt[1]) & 0xffff;
4855 retrycnt = le32toh(stacnt[1]) >> 16;
4856 failcnt = le32toh(stacnt[0]) & 0xffff;
4857
4858 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
4859 "%s: update statistic: associd=0x%04x, txcnt=%d, retrycnt=%d, failcnt=%d\n",
4860 device_get_nameunit(sc->dev),
4861 associd, txcnt, retrycnt, failcnt);
4862
4863 ifp->if_oerrors += failcnt;
4864
4865 rt2870_amrr_tx_update(&sc->amrr_node[wcid],
4866 txcnt + retrycnt + failcnt, txcnt + retrycnt, retrycnt + failcnt);
4867 }
4868 }
4869
4870 /*
4871 * rt2870_watchdog
4872 */
4873 static void rt2870_watchdog(struct rt2870_softc *sc)
4874 {
4875 uint32_t tmp;
4876 int ntries;
4877
4878 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
4879
4880 RT2870_DPRINTF(sc, RT2870_DEBUG_WATCHDOG,
4881 "%s: watchdog: TXRXQ_PCNT=0x%08x\n",
4882 device_get_nameunit(sc->dev), tmp);
4883
4884 if (((tmp >> RT2870_REG_TX0Q_PCNT_SHIFT) & RT2870_REG_TX0Q_PCNT_MASK) != 0)
4885 {
4886 sc->tx_queue_not_empty[0]++;
4887
4888 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40012);
4889
4890 for (ntries = 0; ntries < 10; ntries++)
4891 {
4892 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
4893 if (((tmp >> RT2870_REG_TX0Q_PCNT_SHIFT) & RT2870_REG_TX0Q_PCNT_MASK) == 0)
4894 break;
4895
4896 DELAY(1);
4897 }
4898
4899 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40006);
4900 }
4901
4902 if (((tmp >> RT2870_REG_TX1Q_PCNT_SHIFT) & RT2870_REG_TX1Q_PCNT_MASK) != 0)
4903 {
4904 sc->tx_queue_not_empty[1]++;
4905
4906 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf4000a);
4907
4908 for (ntries = 0; ntries < 10; ntries++)
4909 {
4910 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
4911 if (((tmp >> RT2870_REG_TX1Q_PCNT_SHIFT) & RT2870_REG_TX1Q_PCNT_MASK) == 0)
4912 break;
4913
4914 DELAY(1);
4915 }
4916
4917 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40006);
4918 }
4919 }
4920
4921 /*
4922 * rt2870_drain_fifo_stats
4923 */
4924 static void rt2870_drain_fifo_stats(struct rt2870_softc *sc)
4925 {
4926 struct ifnet *ifp;
4927 uint32_t stats;
4928 uint8_t wcid, mcs, pid;
4929 int ok, retrycnt;
4930
4931 ifp = sc->ifp;
4932
4933 /* drain Tx status FIFO (maxsize = 16) */
4934
4935 while ((stats = rt2870_io_mac_read(sc, RT2870_REG_TX_STA_FIFO)) &
4936 RT2870_REG_TX_STA_FIFO_VALID)
4937 {
4938 wcid = (stats >> RT2870_REG_TX_STA_FIFO_WCID_SHIFT) &
4939 RT2870_REG_TX_STA_FIFO_WCID_MASK;
4940
4941 /* if no ACK was requested, no feedback is available */
4942
4943 if (!(stats & RT2870_REG_TX_STA_FIFO_ACK_REQ) || wcid == 0xff)
4944 continue;
4945
4946 /* update AMRR statistic */
4947
4948 ok = (stats & RT2870_REG_TX_STA_FIFO_TX_OK) ? 1 : 0;
4949 mcs = (stats >> RT2870_REG_TX_STA_FIFO_MCS_SHIFT) &
4950 RT2870_REG_TX_STA_FIFO_MCS_MASK;
4951 pid = (stats >> RT2870_REG_TX_STA_FIFO_PID_SHIFT) &
4952 RT2870_REG_TX_STA_FIFO_PID_MASK;
4953 retrycnt = pid - mcs;
4954
4955 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
4956 "%s: FIFO statistic: wcid=0x%02x, ok=%d, mcs=0x%02x, pid=0x%02x, retrycnt=%d\n",
4957 device_get_nameunit(sc->dev),
4958 wcid, ok, mcs, pid, retrycnt);
4959
4960 rt2870_amrr_tx_complete(&sc->amrr_node[wcid], ok, retrycnt);
4961
4962 if (!ok)
4963 ifp->if_oerrors++;
4964 }
4965 }
4966
4967 /*
4968 * rt2870_update_raw_counters
4969 */
4970 static void rt2870_update_raw_counters(struct rt2870_softc *sc)
4971 {
4972 uint32_t tmp;
4973
4974 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT0);
4975
4976 sc->rx_crc_errors += tmp & 0xffff;
4977 sc->rx_phy_errors += tmp >> 16;
4978
4979 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT1);
4980
4981 sc->rx_false_ccas += tmp & 0xffff;
4982 sc->rx_plcp_errors += tmp >> 16;
4983
4984 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT2);
4985
4986 sc->rx_dup_packets += tmp & 0xffff;
4987 sc->rx_fifo_overflows += tmp >> 16;
4988 }
4989
4990 /*
4991 * rt2870_txrx_enable
4992 */
4993 static int rt2870_txrx_enable(struct rt2870_softc *sc)
4994 {
4995 struct ieee80211com *ic;
4996 struct ifnet *ifp;
4997 uint32_t tmp;
4998 int ntries;
4999
5000 ifp = sc->ifp;
5001 ic = ifp->if_l2com;
5002
5003 /* enable Tx/Rx DMA engine */
5004
5005 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_USB_CYC_CFG);
5006
5007 tmp &= 0xffffff00;
5008 tmp |= 0x1e;
5009
5010 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_CYC_CFG, tmp);
5011
5012 if ((sc->mac_rev & 0xffff) != 0x0101)
5013 rt2870_io_mac_write(sc, RT2870_REG_TX_TXOP_CTRL_CFG, 0x583f);
5014
5015 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, RT2870_REG_TX_ENABLE);
5016
5017 for (ntries = 0; ntries < 200; ntries++)
5018 {
5019 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG);
5020 if (!(tmp & (RT2870_REG_TX_DMA_BUSY | RT2870_REG_RX_DMA_BUSY)))
5021 break;
5022
5023 DELAY(1000);
5024 }
5025
5026 if (ntries == 200)
5027 {
5028 printf("%s: timeout waiting for DMA engine\n",
5029 device_get_nameunit(sc->dev));
5030 return -1;
5031 }
5032
5033 DELAY(50);
5034
5035 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP0_CFG, 0);
5036 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP1_CFG,
5037 (48 << 16) | 96);
5038
5039 tmp |= RT2870_REG_TX_WB_DDONE |
5040 RT2870_REG_RX_DMA_ENABLE |
5041 RT2870_REG_TX_DMA_ENABLE;
5042
5043 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
5044
5045 tmp = RT2870_REG_USB_DMA_TX_ENABLE |
5046 RT2870_REG_USB_DMA_RX_ENABLE |
5047 RT2870_REG_USB_DMA_RX_AGG_ENABLE |
5048 /* Rx agg limit in unit of 1024 byte */
5049 ((RT2870_USB_RX_BULK_BUFLEN / 1024 - 3) << RT2870_REG_USB_DMA_RX_AGG_LIMIT_SHIFT) |
5050 /* Rx agg timeout in unit of 33ns */
5051 0x80;
5052
5053 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, tmp);
5054
5055 /* set Rx filter */
5056
5057 tmp = RT2870_REG_RX_FILTER_DROP_CRC_ERR |
5058 RT2870_REG_RX_FILTER_DROP_PHY_ERR;
5059
5060 if (ic->ic_opmode != IEEE80211_M_MONITOR)
5061 {
5062 tmp |= RT2870_REG_RX_FILTER_DROP_DUPL |
5063 RT2870_REG_RX_FILTER_DROP_CTS |
5064 RT2870_REG_RX_FILTER_DROP_BA |
5065 RT2870_REG_RX_FILTER_DROP_ACK |
5066 RT2870_REG_RX_FILTER_DROP_VER_ERR |
5067 RT2870_REG_RX_FILTER_DROP_CTRL_RSV |
5068 RT2870_REG_RX_FILTER_DROP_CFACK |
5069 RT2870_REG_RX_FILTER_DROP_CFEND;
5070
5071 if (ic->ic_opmode == IEEE80211_M_STA)
5072 tmp |= RT2870_REG_RX_FILTER_DROP_RTS |
5073 RT2870_REG_RX_FILTER_DROP_PSPOLL;
5074
5075 if (!(ifp->if_flags & IFF_PROMISC))
5076 tmp |= RT2870_REG_RX_FILTER_DROP_UC_NOME;
5077 }
5078
5079 rt2870_io_mac_write(sc, RT2870_REG_RX_FILTER_CFG, tmp);
5080
5081 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
5082 RT2870_REG_RX_ENABLE | RT2870_REG_TX_ENABLE);
5083
5084 return 0;
5085 }
5086
5087 /*
5088 * rt2870_alloc_rx_ring
5089 */
5090 static int rt2870_alloc_rx_ring(struct rt2870_softc *sc,
5091 struct rt2870_softc_rx_ring *ring)
5092 {
5093 struct rt2870_softc_rx_data *data;
5094 int i, error;
5095
5096 STAILQ_INIT(&ring->inactive);
5097 STAILQ_INIT(&ring->active);
5098 STAILQ_INIT(&ring->done);
5099
5100 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5101 {
5102 data = &ring->data[i];
5103
5104 data->buf = malloc(RT2870_USB_RX_BULK_BUFLEN, M_USBDEV, M_NOWAIT);
5105 if (data->buf == NULL)
5106 {
5107 printf("%s: could not allocate Rx buffer\n",
5108 device_get_nameunit(sc->dev));
5109 error = ENOMEM;
5110 goto fail;
5111 }
5112
5113 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5114 }
5115
5116 return 0;
5117
5118 fail:
5119
5120 rt2870_free_rx_ring(sc, ring);
5121
5122 return error;
5123 }
5124
5125 /*
5126 * rt2870_reset_rx_ring
5127 */
5128 static void rt2870_reset_rx_ring(struct rt2870_softc *sc,
5129 struct rt2870_softc_rx_ring *ring)
5130 {
5131 struct rt2870_softc_rx_data *data;
5132 int i;
5133
5134 STAILQ_INIT(&ring->inactive);
5135 STAILQ_INIT(&ring->active);
5136 STAILQ_INIT(&ring->done);
5137
5138 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5139 {
5140 data = &ring->data[i];
5141
5142 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5143 }
5144 }
5145
5146 /*
5147 * rt2870_free_rx_ring
5148 */
5149 static void rt2870_free_rx_ring(struct rt2870_softc *sc,
5150 struct rt2870_softc_rx_ring *ring)
5151 {
5152 struct rt2870_softc_rx_data *data;
5153 int i;
5154
5155 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5156 {
5157 data = &ring->data[i];
5158
5159 if (data->buf != NULL)
5160 {
5161 free(data->buf, M_USBDEV);
5162 data->buf = NULL;
5163 }
5164 }
5165 }
5166
5167 /*
5168 * rt2870_alloc_tx_ring
5169 */
5170 static int rt2870_alloc_tx_ring(struct rt2870_softc *sc,
5171 struct rt2870_softc_tx_ring *ring, int qid)
5172 {
5173 struct rt2870_softc_tx_data *data;
5174 int i, error;
5175
5176 STAILQ_INIT(&ring->inactive);
5177 STAILQ_INIT(&ring->pending);
5178 STAILQ_INIT(&ring->active);
5179 STAILQ_INIT(&ring->done);
5180
5181 ring->queued = 0;
5182 ring->qid = qid;
5183
5184 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
5185 {
5186 data = &ring->data[i];
5187
5188 data->buf = malloc(RT2870_TX_DESC_SIZE + MJUMPAGESIZE, M_USBDEV, M_NOWAIT);
5189 if (data->buf == NULL)
5190 {
5191 printf("%s: could not allocate Tx buffer\n",
5192 device_get_nameunit(sc->dev));
5193 error = ENOMEM;
5194 goto fail;
5195 }
5196
5197 memset(data->buf, 0, RT2870_TX_DESC_SIZE);
5198
5199 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5200 }
5201
5202 return 0;
5203
5204 fail:
5205
5206 rt2870_free_tx_ring(sc, ring);
5207
5208 return error;
5209 }
5210
5211 /*
5212 * rt2870_reset_tx_ring
5213 */
5214 static void rt2870_reset_tx_ring(struct rt2870_softc *sc,
5215 struct rt2870_softc_tx_ring *ring)
5216 {
5217 struct rt2870_softc_tx_data *data;
5218 int i;
5219
5220 STAILQ_INIT(&ring->inactive);
5221 STAILQ_INIT(&ring->pending);
5222 STAILQ_INIT(&ring->active);
5223 STAILQ_INIT(&ring->done);
5224
5225 ring->queued = 0;
5226
5227 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
5228 {
5229 data = &ring->data[i];
5230
5231 if (data->m != NULL)
5232 {
5233 m_free(data->m);
5234 data->m = NULL;
5235 }
5236
5237 if (data->ni != NULL)
5238 {
5239 ieee80211_free_node(data->ni);
5240 data->ni = NULL;
5241 }
5242
5243 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5244 }
5245 }
5246
5247 /*
5248 * rt2870_free_tx_ring
5249 */
5250 static void rt2870_free_tx_ring(struct rt2870_softc *sc,
5251 struct rt2870_softc_tx_ring *ring)
5252 {
5253 struct rt2870_softc_tx_data *data;
5254 int i;
5255
5256 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
5257 {
5258 data = &ring->data[i];
5259
5260 if (data->buf != NULL)
5261 {
5262 free(data->buf, M_USBDEV);
5263 data->buf = NULL;
5264 }
5265
5266 if (data->m != NULL)
5267 {
5268 m_free(data->m);
5269 data->m = NULL;
5270 }
5271
5272 if (data->ni != NULL)
5273 {
5274 ieee80211_free_node(data->ni);
5275 data->ni = NULL;
5276 }
5277 }
5278 }
5279
5280 /*
5281 * rt2870_reset_cmd_ring
5282 */
5283 static void rt2870_reset_cmd_ring(struct rt2870_softc *sc,
5284 struct rt2870_softc_cmd_ring *ring)
5285 {
5286 struct rt2870_softc_cmd *cmd;
5287 int i;
5288
5289 STAILQ_INIT(&ring->inactive);
5290 STAILQ_INIT(&ring->active);
5291
5292 ring->queued = 0;
5293
5294 for (i = 0; i < RT2870_SOFTC_CMD_RING_CMD_COUNT; i++)
5295 {
5296 cmd = &ring->cmd[i];
5297
5298 STAILQ_INSERT_TAIL(&ring->inactive, cmd, next);
5299 }
5300 }
5301
5302 /*
5303 * rt2870_sysctl_attach
5304 */
5305 static void rt2870_sysctl_attach(struct rt2870_softc *sc)
5306 {
5307 struct sysctl_ctx_list *ctx;
5308 struct sysctl_oid *tree;
5309 struct sysctl_oid *stats;
5310
5311 ctx = device_get_sysctl_ctx(sc->dev);
5312 tree = device_get_sysctl_tree(sc->dev);
5313
5314 stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
5315 "stats", CTLFLAG_RD, 0, "statistic");
5316
5317 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5318 "interrupts", CTLFLAG_RD, &sc->interrupts, 0,
5319 "all interrupts");
5320
5321 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5322 "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0,
5323 "Rx interrupts");
5324
5325 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
5326 {
5327 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5328 "tx_mgmt_interrupts", CTLFLAG_RD, &sc->tx_interrupts[5], 0,
5329 "Tx MGMT interrupts");
5330
5331 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5332 "tx_hcca_interrupts", CTLFLAG_RD, &sc->tx_interrupts[4], 0,
5333 "Tx HCCA interrupts");
5334 }
5335
5336 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5337 "tx_ac3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0,
5338 "Tx AC3 interrupts");
5339
5340 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5341 "tx_ac2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0,
5342 "Tx AC2 interrupts");
5343
5344 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5345 "tx_ac1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0,
5346 "Tx AC1 interrupts");
5347
5348 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5349 "tx_ac0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0,
5350 "Tx AC0 interrupts");
5351
5352 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
5353 {
5354 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5355 "tx_mgmt_data_queued", CTLFLAG_RD, &sc->tx_ring[5].queued, 0,
5356 "Tx MGMT data queued");
5357
5358 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5359 "tx_hcca_data_queued", CTLFLAG_RD, &sc->tx_ring[4].queued, 0,
5360 "Tx HCCA data queued");
5361 }
5362
5363 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5364 "tx_ac3_data_queued", CTLFLAG_RD, &sc->tx_ring[3].queued, 0,
5365 "Tx AC3 data queued");
5366
5367 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5368 "tx_ac2_data_queued", CTLFLAG_RD, &sc->tx_ring[2].queued, 0,
5369 "Tx AC2 data queued");
5370
5371 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5372 "tx_ac1_data_queued", CTLFLAG_RD, &sc->tx_ring[1].queued, 0,
5373 "Tx AC1 data queued");
5374
5375 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5376 "tx_ac0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].queued, 0,
5377 "Tx AC0 data queued");
5378
5379 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5380 "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts, 0,
5381 "Tx watchdog timeouts");
5382
5383 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5384 "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors, 0,
5385 "Rx mbuf allocation errors");
5386
5387 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5388 "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0], 0,
5389 "Tx queue 0 not empty");
5390
5391 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5392 "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1], 0,
5393 "Tx queue 1 not empty");
5394
5395 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5396 "rx_packets", CTLFLAG_RD, &sc->rx_packets, 0,
5397 "Rx packets");
5398
5399 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5400 "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_errors, 0,
5401 "Rx CRC errors");
5402
5403 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5404 "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_errors, 0,
5405 "Rx PHY errors");
5406
5407 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5408 "rx_false_ccas", CTLFLAG_RD, &sc->rx_false_ccas, 0,
5409 "Rx false CCAs");
5410
5411 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5412 "rx_plcp_errors", CTLFLAG_RD, &sc->rx_plcp_errors, 0,
5413 "Rx PLCP errors");
5414
5415 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5416 "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0,
5417 "Rx duplicate packets");
5418
5419 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5420 "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0,
5421 "Rx FIFO overflows");
5422 }
5423
5424 static device_method_t rt2870_dev_methods[] =
5425 {
5426 DEVMETHOD(device_probe, rt2870_probe),
5427 DEVMETHOD(device_attach, rt2870_attach),
5428 DEVMETHOD(device_detach, rt2870_detach),
5429 { 0, 0 }
5430 };
5431
5432 static driver_t rt2870_driver =
5433 {
5434 "rt2870",
5435 rt2870_dev_methods,
5436 sizeof(struct rt2870_softc),
5437 };
5438
5439 static devclass_t rt2870_dev_class;
5440
5441 DRIVER_MODULE(rt2870, uhub, rt2870_driver, rt2870_dev_class,
5442 NULL, 0);
5443
5444 MODULE_DEPEND(rt2870, usb, 1, 1, 1);
5445 MODULE_DEPEND(rt2870, wlan, 1, 1, 1);
FreeBSD 8 device driver for Ralink rt2870