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