?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Hook ic_addba_response and ic_addba_stop functions in order to be able to count activ...
[ralink_drivers/rt2870_fbsd8.git] / rt2870.c
blob1fe87f8f1dfb25d9b19aa239293e218828bf0de6
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 int tid, bufsize;
2717
2718 ic = ni->ni_ic;
2719 ifp = ic->ic_ifp;
2720 sc = ifp->if_softc;
2721 rni = (struct rt2870_softc_node *) ni;
2722
2723 tid = RT2870_MS(baparamset, IEEE80211_BAPS_TID);
2724 bufsize = RT2870_MS(baparamset, IEEE80211_BAPS_BUFSIZ);
2725
2726 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2727 "%s: received ADDBA response: associd=0x%04x, staid=0x%02x, status=%d, tid=%d, bufsize=%d\n",
2728 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, status, tid, bufsize);
2729
2730 if (status == IEEE80211_STATUS_SUCCESS)
2731 {
2732 if (sc->mac_rev >= 0x28720200)
2733 {
2734 if (bufsize > 13)
2735 bufsize = 13;
2736 }
2737 else
2738 {
2739 if (bufsize > 7)
2740 bufsize = 7;
2741 }
2742
2743 baparamset &= ~IEEE80211_BAPS_BUFSIZ;
2744 baparamset = RT2870_SM(bufsize, IEEE80211_BAPS_BUFSIZ);
2745
2746 if (!(tap->txa_flags & IEEE80211_AGGR_RUNNING))
2747 {
2748 sc->tx_ampdu_sessions++;
2749
2750 RT2870_SOFTC_LOCK(sc);
2751
2752 rt2870_asic_updateprot(sc);
2753
2754 RT2870_SOFTC_UNLOCK(sc);
2755 }
2756 }
2757
2758 return sc->addba_response(ni, tap, status, baparamset, batimeout);
2759 }
2760
2761 /*
2762 * rt2870_addba_stop
2763 */
2764 static void rt2870_addba_stop(struct ieee80211_node *ni,
2765 struct ieee80211_tx_ampdu *tap)
2766 {
2767 struct rt2870_softc *sc;
2768 struct ieee80211com *ic;
2769 struct ifnet *ifp;
2770 struct rt2870_softc_node *rni;
2771 int tid;
2772
2773 ic = ni->ni_ic;
2774 ifp = ic->ic_ifp;
2775 sc = ifp->if_softc;
2776 rni = (struct rt2870_softc_node *) ni;
2777
2778 tid = WME_AC_TO_TID(tap->txa_ac);
2779
2780 RT2870_DPRINTF(sc, RT2870_DEBUG_BA,
2781 "%s: stopping A-MPDU Tx: associd=0x%04x, staid=0x%02x, tid=%d\n",
2782 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid);
2783
2784 sc->tx_ampdu_sessions--;
2785
2786 RT2870_SOFTC_LOCK(sc);
2787
2788 rt2870_asic_updateprot(sc);
2789
2790 RT2870_SOFTC_UNLOCK(sc);
2791
2792 sc->addba_stop(ni, tap);
2793 }
2794
2795 /*
2796 * rt2870_amrr_update_iter_func
2797 */
2798 static void rt2870_amrr_update_iter_func(void *arg, struct ieee80211_node *ni)
2799 {
2800 struct rt2870_softc *sc;
2801 struct ieee80211com *ic;
2802 struct ifnet *ifp;
2803 struct ieee80211vap *vap;
2804 struct rt2870_softc_vap *rvap;
2805 struct rt2870_softc_node *rni;
2806 uint8_t wcid;
2807
2808 vap = arg;
2809 ic = vap->iv_ic;
2810 ifp = ic->ic_ifp;
2811 sc = ifp->if_softc;
2812 rvap = (struct rt2870_softc_vap *) vap;
2813 rni = (struct rt2870_softc_node *) ni;
2814
2815 /* only associated stations */
2816
2817 if ((ni->ni_vap == vap) && (rni->staid != 0))
2818 {
2819 wcid = rni->staid;
2820
2821 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2822 "%s: AMRR node: staid=0x%02x, txcnt=%d, success=%d, retrycnt=%d\n",
2823 device_get_nameunit(sc->dev),
2824 rni->staid, sc->amrr_node[wcid].txcnt, sc->amrr_node[wcid].success, sc->amrr_node[wcid].retrycnt);
2825
2826 rt2870_amrr_choose(ni, &sc->amrr_node[wcid]);
2827
2828 RT2870_DPRINTF(sc, RT2870_DEBUG_RATE,
2829 "%s:%s node Tx rate: associd=0x%04x, staid=0x%02x, rate=0x%02x, max rate=0x%02x\n",
2830 device_get_nameunit(sc->dev),
2831 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2832 ni->ni_associd, rni->staid, ni->ni_txrate,
2833 (ni->ni_flags & IEEE80211_NODE_HT) ?
2834 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2835 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2836 }
2837 }
2838
2839 /*
2840 * rt2870_periodic
2841 */
2842 static void rt2870_periodic(void *arg)
2843 {
2844 struct rt2870_softc *sc;
2845 struct ifnet *ifp;
2846
2847 sc = arg;
2848 ifp = sc->ifp;
2849
2850 RT2870_DPRINTF(sc, RT2870_DEBUG_PERIODIC,
2851 "%s: periodic\n",
2852 device_get_nameunit(sc->dev));
2853
2854 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
2855 return;
2856
2857 taskqueue_enqueue(sc->taskqueue, &sc->periodic_task);
2858 }
2859
2860 /*
2861 * rt2870_tx_watchdog
2862 */
2863 static void rt2870_tx_watchdog(void *arg)
2864 {
2865 struct rt2870_softc *sc;
2866 struct ifnet *ifp;
2867
2868 sc = arg;
2869 ifp = sc->ifp;
2870
2871 if (sc->tx_timer == 0)
2872 return;
2873
2874 if (--sc->tx_timer == 0)
2875 {
2876 printf("%s: Tx watchdog timeout: resetting\n",
2877 device_get_nameunit(sc->dev));
2878
2879 rt2870_stop_locked(sc);
2880 rt2870_init_locked(sc);
2881
2882 ifp->if_oerrors++;
2883
2884 sc->tx_watchdog_timeouts++;
2885 }
2886
2887 callout_reset(&sc->tx_watchdog_ch, hz, rt2870_tx_watchdog, sc);
2888 }
2889
2890 /*
2891 * rt2870_staid_alloc
2892 */
2893 static int rt2870_staid_alloc(struct rt2870_softc *sc, int aid)
2894 {
2895 int staid;
2896
2897 if ((aid > 0 && aid < RT2870_SOFTC_STAID_COUNT) && isclr(sc->staid_mask, aid))
2898 {
2899 staid = aid;
2900 }
2901 else
2902 {
2903 for (staid = 1; staid < RT2870_SOFTC_STAID_COUNT; staid++)
2904 {
2905 if (isclr(sc->staid_mask, staid))
2906 break;
2907 }
2908 }
2909
2910 setbit(sc->staid_mask, staid);
2911
2912 return staid;
2913 }
2914
2915 /*
2916 * rt2870_staid_delete
2917 */
2918 static void rt2870_staid_delete(struct rt2870_softc *sc, int staid)
2919 {
2920 clrbit(sc->staid_mask, staid);
2921 }
2922
2923
2924 /*
2925 * rt2870_do_async
2926 */
2927 static int rt2870_do_async(struct rt2870_softc *sc,
2928 void (*cb)(struct rt2870_softc *sc, void *arg),
2929 void *arg, int len)
2930 {
2931 struct ifnet *ifp;
2932 struct rt2870_softc_cmd_ring *ring;
2933 struct rt2870_softc_cmd *cmd;
2934 int run_cmd_task;
2935
2936 ifp = sc->ifp;
2937 ring = &sc->cmd_ring;
2938
2939 RT2870_SOFTC_LOCK(sc);
2940
2941 if (ring->queued >= RT2870_SOFTC_CMD_RING_CMD_COUNT)
2942 {
2943 RT2870_SOFTC_UNLOCK(sc);
2944 return -1;
2945 }
2946
2947 cmd = STAILQ_FIRST(&ring->inactive);
2948 STAILQ_REMOVE_HEAD(&ring->inactive, next);
2949
2950 cmd->cb = cb;
2951
2952 if(arg != NULL)
2953 memcpy(cmd->data, arg, len);
2954
2955 STAILQ_INSERT_TAIL(&ring->active, cmd, next);
2956 ring->queued++;
2957
2958 run_cmd_task = (ring->queued == 1);
2959
2960 RT2870_SOFTC_UNLOCK(sc);
2961
2962 if (run_cmd_task)
2963 taskqueue_enqueue(sc->taskqueue, &sc->cmd_task);
2964
2965 return 0;
2966 }
2967
2968 /*
2969 * rt2870_node_cleanup_cb
2970 */
2971 static void rt2870_node_cleanup_cb(struct rt2870_softc *sc, void *arg)
2972 {
2973 struct ifnet *ifp;
2974 struct ieee80211com *ic;
2975 struct rt2870_cmd_argv_nodecleanup *cmd_argv;
2976 uint8_t staid, vapid, wcid;
2977 uint32_t tmp;
2978
2979 ifp = sc->ifp;
2980 ic = ifp->if_l2com;
2981 cmd_argv = arg;
2982 staid = cmd_argv->staid;
2983
2984 vapid = 0;
2985 wcid = staid;
2986
2987 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
2988 (RT2870_REG_CIPHER_MODE_NONE << RT2870_REG_CIPHER_MODE_SHIFT) | RT2870_REG_PKEY_ENABLE;
2989
2990 RT2870_SOFTC_LOCK(sc);
2991
2992 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
2993
2994 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid), 0xffffffff);
2995 rt2870_io_mac_write(sc, RT2870_REG_WCID(wcid) + 4, 0x0000ffff);
2996
2997 rt2870_staid_delete(sc, staid);
2998
2999 RT2870_SOFTC_UNLOCK(sc);
3000 }
3001
3002 /*
3003 * rt2870_updateslot_cb
3004 */
3005 static void rt2870_updateslot_cb(struct rt2870_softc *sc, void *arg)
3006 {
3007 RT2870_SOFTC_LOCK(sc);
3008
3009 rt2870_asic_updateslot(sc);
3010
3011 RT2870_SOFTC_UNLOCK(sc);
3012 }
3013
3014 /*
3015 * rt2870_wme_update_cb
3016 */
3017 static void rt2870_wme_update_cb(struct rt2870_softc *sc, void *arg)
3018 {
3019 RT2870_SOFTC_LOCK(sc);
3020
3021 rt2870_asic_wme_update(sc);
3022
3023 RT2870_SOFTC_UNLOCK(sc);
3024 }
3025
3026 /*
3027 * rt2870_vap_key_set_cb
3028 */
3029 static void rt2870_vap_key_set_cb(struct rt2870_softc *sc, void *arg)
3030 {
3031 struct ieee80211com *ic;
3032 struct ifnet *ifp;
3033 struct ieee80211_key *k;
3034 enum ieee80211_opmode opmode;
3035 struct rt2870_cmd_argv_keyset *cmd_argv;
3036 uint16_t key_base, keymode_base;
3037 uint8_t mode, vapid, wcid, iv[8];
3038 uint32_t tmp;
3039
3040 ifp = sc->ifp;
3041 ic = ifp->if_l2com;
3042 cmd_argv = arg;
3043 k = &cmd_argv->key;
3044 opmode = cmd_argv->opmode;
3045
3046 switch (k->wk_cipher->ic_cipher)
3047 {
3048 case IEEE80211_CIPHER_WEP:
3049 if(k->wk_keylen < 8)
3050 mode = RT2870_REG_CIPHER_MODE_WEP40;
3051 else
3052 mode = RT2870_REG_CIPHER_MODE_WEP104;
3053 break;
3054
3055 case IEEE80211_CIPHER_TKIP:
3056 mode = RT2870_REG_CIPHER_MODE_TKIP;
3057 break;
3058
3059 case IEEE80211_CIPHER_AES_CCM:
3060 mode = RT2870_REG_CIPHER_MODE_AES_CCMP;
3061 break;
3062
3063 default:
3064 return;
3065 }
3066
3067 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
3068 "%s: VAP key set: keyix=%d, keylen=%d, macaddr=%s, mode=%d, group=%d\n",
3069 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, ether_sprintf(k->wk_macaddr),
3070 mode, (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
3071
3072 RT2870_SOFTC_LOCK(sc);
3073
3074 if (!(k->wk_flags & IEEE80211_KEY_GROUP))
3075 {
3076 /* install pairwise key */
3077
3078 vapid = 0;
3079 wcid = cmd_argv->staid;
3080 key_base = RT2870_REG_PKEY(wcid);
3081
3082 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)
3083 {
3084 memset(iv, 0, 8);
3085
3086 iv[3] = (k->wk_keyix << 6);
3087 }
3088 else
3089 {
3090 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
3091 {
3092 iv[0] = (k->wk_keytsc >> 8);
3093 iv[1] = ((iv[0] | 0x20) & 0x7f);
3094 iv[2] = k->wk_keytsc;
3095 }
3096 else
3097 {
3098 /* AES CCMP */
3099
3100 iv[0] = k->wk_keytsc;
3101 iv[1] = k->wk_keytsc >> 8;
3102 iv[2] = 0;
3103 }
3104
3105 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV);
3106 iv[4] = (k->wk_keytsc >> 16);
3107 iv[5] = (k->wk_keytsc >> 24);
3108 iv[6] = (k->wk_keytsc >> 32);
3109 iv[7] = (k->wk_keytsc >> 40);
3110
3111 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
3112 "%s: VAP key set: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
3113 device_get_nameunit(sc->dev),
3114 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
3115 }
3116
3117 rt2870_io_mac_write_multi(sc, RT2870_REG_IVEIV(wcid), iv, 8);
3118
3119 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
3120 {
3121 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, 16);
3122
3123 if (opmode != IEEE80211_M_HOSTAP)
3124 {
3125 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
3126 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
3127 }
3128 else
3129 {
3130 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
3131 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
3132 }
3133 }
3134 else
3135 {
3136 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
3137 }
3138
3139 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
3140 (mode << RT2870_REG_CIPHER_MODE_SHIFT) | RT2870_REG_PKEY_ENABLE;
3141
3142 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
3143 }
3144
3145 if ((k->wk_flags & IEEE80211_KEY_GROUP) ||
3146 (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP))
3147 {
3148 /* install group key */
3149
3150 vapid = 0;
3151 wcid = RT2870_WCID_MCAST;
3152 key_base = RT2870_REG_SKEY(vapid, k->wk_keyix);
3153 keymode_base = RT2870_REG_SKEY_MODE(vapid);
3154
3155 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
3156 {
3157 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, 16);
3158
3159 if (opmode != IEEE80211_M_HOSTAP)
3160 {
3161 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
3162 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
3163 }
3164 else
3165 {
3166 rt2870_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
3167 rt2870_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
3168 }
3169 }
3170 else
3171 {
3172 rt2870_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
3173 }
3174
3175 tmp = rt2870_io_mac_read(sc, keymode_base);
3176
3177 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
3178 tmp |= (mode << (k->wk_keyix * 4 + 16 * (vapid % 2)));
3179
3180 rt2870_io_mac_write(sc, keymode_base, tmp);
3181
3182 if (opmode == IEEE80211_M_HOSTAP)
3183 {
3184 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)
3185 {
3186 memset(iv, 0, 8);
3187
3188 iv[3] = (k->wk_keyix << 6);
3189 }
3190 else
3191 {
3192 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
3193 {
3194 iv[0] = (k->wk_keytsc >> 8);
3195 iv[1] = ((iv[0] | 0x20) & 0x7f);
3196 iv[2] = k->wk_keytsc;
3197 }
3198 else
3199 {
3200 /* AES CCMP */
3201
3202 iv[0] = k->wk_keytsc;
3203 iv[1] = k->wk_keytsc >> 8;
3204 iv[2] = 0;
3205 }
3206
3207 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV);
3208 iv[4] = (k->wk_keytsc >> 16);
3209 iv[5] = (k->wk_keytsc >> 24);
3210 iv[6] = (k->wk_keytsc >> 32);
3211 iv[7] = (k->wk_keytsc >> 40);
3212
3213 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
3214 "%s: VAP key set: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
3215 device_get_nameunit(sc->dev),
3216 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
3217 }
3218
3219 rt2870_io_mac_write_multi(sc, RT2870_REG_IVEIV(wcid), iv, 8);
3220
3221 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
3222 (mode << RT2870_REG_CIPHER_MODE_SHIFT);
3223
3224 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
3225 }
3226 }
3227
3228 RT2870_SOFTC_UNLOCK(sc);
3229 }
3230
3231 /*
3232 * rt2870_vap_key_delete_cb
3233 */
3234 static void rt2870_vap_key_delete_cb(struct rt2870_softc *sc, void *arg)
3235 {
3236 struct ieee80211com *ic;
3237 struct ifnet *ifp;
3238 struct ieee80211_key *k;
3239 enum ieee80211_opmode opmode;
3240 struct rt2870_cmd_argv_keydelete *cmd_argv;
3241 uint8_t vapid, wcid;
3242 uint32_t tmp;
3243
3244 ifp = sc->ifp;
3245 ic = ifp->if_l2com;
3246 cmd_argv = arg;
3247 k = &cmd_argv->key;
3248 opmode = cmd_argv->opmode;
3249
3250 RT2870_DPRINTF(sc, RT2870_DEBUG_KEY,
3251 "%s: VAP key delete: keyix=%d, keylen=%d, macaddr=%s, group=%d\n",
3252 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, ether_sprintf(k->wk_macaddr),
3253 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
3254
3255 RT2870_SOFTC_LOCK(sc);
3256
3257 if (k->wk_flags & IEEE80211_KEY_GROUP)
3258 {
3259 /* remove group key */
3260
3261 vapid = 0;
3262 wcid = RT2870_WCID_MCAST;
3263
3264 tmp = rt2870_io_mac_read(sc, RT2870_REG_SKEY_MODE(vapid));
3265
3266 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
3267 tmp |= (RT2870_REG_CIPHER_MODE_NONE << (k->wk_keyix * 4 + 16 * (vapid % 2)));
3268
3269 rt2870_io_mac_write(sc, RT2870_REG_SKEY_MODE(vapid), tmp);
3270
3271 if (opmode == IEEE80211_M_HOSTAP)
3272 {
3273 tmp = ((vapid & RT2870_REG_VAP_MASK) << RT2870_REG_VAP_SHIFT) |
3274 (RT2870_REG_CIPHER_MODE_NONE << RT2870_REG_CIPHER_MODE_SHIFT);
3275
3276 rt2870_io_mac_write(sc, RT2870_REG_WCID_ATTR(wcid), tmp);
3277 }
3278 }
3279
3280 RT2870_SOFTC_UNLOCK(sc);
3281 }
3282
3283 /*
3284 * rt2870_vap_update_beacon_cb
3285 */
3286 static void rt2870_vap_update_beacon_cb(struct rt2870_softc *sc, void *arg)
3287 {
3288 struct ifnet *ifp;
3289 struct ieee80211com *ic;
3290 struct ieee80211vap *vap;
3291
3292 ifp = sc->ifp;
3293 ic = ifp->if_l2com;
3294 vap = TAILQ_FIRST(&ic->ic_vaps);
3295
3296 if (vap == NULL)
3297 return;
3298
3299 RT2870_SOFTC_LOCK(sc);
3300
3301 rt2870_asic_update_beacon(sc, vap);
3302
3303 RT2870_SOFTC_UNLOCK(sc);
3304 }
3305
3306 /*
3307 * rt2870_asic_set_bssid
3308 */
3309 static void rt2870_asic_set_bssid(struct rt2870_softc *sc,
3310 const uint8_t *bssid)
3311 {
3312 uint32_t tmp;
3313
3314 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3315 "%s: set bssid: bssid=%s\n",
3316 device_get_nameunit(sc->dev),
3317 ether_sprintf(bssid));
3318
3319 tmp = bssid[0] | (bssid[1]) << 8 | (bssid[2] << 16) | (bssid[3] << 24);
3320
3321 rt2870_io_mac_write(sc, RT2870_REG_BSSID_DW0, tmp);
3322
3323 tmp = bssid[4] | (bssid[5] << 8);
3324
3325 rt2870_io_mac_write(sc, RT2870_REG_BSSID_DW1, tmp);
3326 }
3327
3328 /*
3329 * rt2870_asic_set_macaddr
3330 */
3331 static void rt2870_asic_set_macaddr(struct rt2870_softc *sc,
3332 const uint8_t *addr)
3333 {
3334 uint32_t tmp;
3335
3336 tmp = addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24);
3337
3338 rt2870_io_mac_write(sc, RT2870_REG_ADDR_DW0, tmp);
3339
3340 tmp = addr[4] | (addr[5] << 8);
3341
3342 rt2870_io_mac_write(sc, RT2870_REG_ADDR_DW1, tmp);
3343 }
3344
3345 /*
3346 * rt2870_asic_enable_tsf_sync
3347 */
3348 static void rt2870_asic_enable_tsf_sync(struct rt2870_softc *sc)
3349 {
3350 struct ifnet *ifp;
3351 struct ieee80211com *ic;
3352 struct ieee80211vap *vap;
3353 uint32_t tmp;
3354
3355 ifp = sc->ifp;
3356 ic = ifp->if_l2com;
3357 vap = TAILQ_FIRST(&ic->ic_vaps);
3358
3359 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
3360 "%s: enabling TSF\n",
3361 device_get_nameunit(sc->dev));
3362
3363 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3364
3365 tmp &= ~0x1fffff;
3366 tmp |= vap->iv_bss->ni_intval * 16;
3367 tmp |= (RT2870_REG_TSF_TIMER_ENABLE | RT2870_REG_TBTT_TIMER_ENABLE);
3368
3369 if (vap->iv_opmode == IEEE80211_M_STA)
3370 {
3371 tmp |= (RT2870_REG_TSF_SYNC_MODE_STA << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3372 }
3373 else if (vap->iv_opmode == IEEE80211_M_IBSS)
3374 {
3375 tmp |= RT2870_REG_BCN_TX_ENABLE;
3376 tmp |= (RT2870_REG_TSF_SYNC_MODE_IBSS << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3377 }
3378 else if (vap->iv_opmode == IEEE80211_M_HOSTAP)
3379 {
3380 tmp |= RT2870_REG_BCN_TX_ENABLE;
3381 tmp |= (RT2870_REG_TSF_SYNC_MODE_HOSTAP << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3382 }
3383
3384 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3385 }
3386
3387 /*
3388 * rt2870_asic_disable_tsf_sync
3389 */
3390 static void rt2870_asic_disable_tsf_sync(struct rt2870_softc *sc)
3391 {
3392 uint32_t tmp;
3393
3394 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
3395 "%s: disabling TSF\n",
3396 device_get_nameunit(sc->dev));
3397
3398 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3399
3400 tmp &= ~(RT2870_REG_BCN_TX_ENABLE |
3401 RT2870_REG_TSF_TIMER_ENABLE |
3402 RT2870_REG_TBTT_TIMER_ENABLE);
3403
3404 tmp &= ~(RT2870_REG_TSF_SYNC_MODE_MASK << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3405 tmp |= (RT2870_REG_TSF_SYNC_MODE_DISABLE << RT2870_REG_TSF_SYNC_MODE_SHIFT);
3406
3407 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3408 }
3409
3410 /*
3411 * rt2870_asic_enable_mrr
3412 */
3413 static void rt2870_asic_enable_mrr(struct rt2870_softc *sc)
3414 {
3415 #define CCK(mcs) (mcs)
3416 #define OFDM(mcs) ((1 << 3) | (mcs))
3417 #define HT(mcs) (mcs)
3418
3419 rt2870_io_mac_write(sc, RT2870_REG_TX_LG_FBK_CFG0,
3420 (OFDM(6) << 28) | /* 54 -> 48 */
3421 (OFDM(5) << 24) | /* 48 -> 36 */
3422 (OFDM(4) << 20) | /* 36 -> 24 */
3423 (OFDM(3) << 16) | /* 24 -> 18 */
3424 (OFDM(2) << 12) | /* 18 -> 12 */
3425 (OFDM(1) << 8) | /* 12 -> 9 */
3426 (OFDM(0) << 4) | /* 9 -> 6 */
3427 OFDM(0)); /* 6 -> 6 */
3428
3429 rt2870_io_mac_write(sc, RT2870_REG_TX_LG_FBK_CFG1,
3430 (CCK(2) << 12) | /* 11 -> 5.5 */
3431 (CCK(1) << 8) | /* 5.5 -> 2 */
3432 (CCK(0) << 4) | /* 2 -> 1 */
3433 CCK(0)); /* 1 -> 1 */
3434
3435 rt2870_io_mac_write(sc, RT2870_REG_TX_HT_FBK_CFG0,
3436 (HT(6) << 28) |
3437 (HT(5) << 24) |
3438 (HT(4) << 20) |
3439 (HT(3) << 16) |
3440 (HT(2) << 12) |
3441 (HT(1) << 8) |
3442 (HT(0) << 4) |
3443 HT(0));
3444
3445 rt2870_io_mac_write(sc, RT2870_REG_TX_HT_FBK_CFG1,
3446 (HT(14) << 28) |
3447 (HT(13) << 24) |
3448 (HT(12) << 20) |
3449 (HT(11) << 16) |
3450 (HT(10) << 12) |
3451 (HT(9) << 8) |
3452 (HT(8) << 4) |
3453 HT(7));
3454
3455 #undef HT
3456 #undef OFDM
3457 #undef CCK
3458 }
3459
3460 /*
3461 * rt2870_asic_set_txpreamble
3462 */
3463 static void rt2870_asic_set_txpreamble(struct rt2870_softc *sc)
3464 {
3465 struct ifnet *ifp;
3466 struct ieee80211com *ic;
3467 uint32_t tmp;
3468
3469 ifp = sc->ifp;
3470 ic = ifp->if_l2com;
3471
3472 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3473 "%s: %s short Tx preamble\n",
3474 device_get_nameunit(sc->dev),
3475 (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "enabling" : "disabling");
3476
3477 tmp = rt2870_io_mac_read(sc, RT2870_REG_AUTO_RSP_CFG);
3478
3479 tmp &= ~RT2870_REG_CCK_SHORT_ENABLE;
3480
3481 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
3482 tmp |= RT2870_REG_CCK_SHORT_ENABLE;
3483
3484 rt2870_io_mac_write(sc, RT2870_REG_AUTO_RSP_CFG, tmp);
3485 }
3486
3487 /*
3488 * rt2870_asic_set_basicrates
3489 */
3490 static void rt2870_asic_set_basicrates(struct rt2870_softc *sc)
3491 {
3492 struct ifnet *ifp;
3493 struct ieee80211com *ic;
3494
3495 ifp = sc->ifp;
3496 ic = ifp->if_l2com;
3497
3498 if (ic->ic_curmode == IEEE80211_MODE_11B)
3499 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x3);
3500 else if (ic->ic_curmode == IEEE80211_MODE_11A)
3501 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x150);
3502 else
3503 rt2870_io_mac_write(sc, RT2870_REG_LEGACY_BASIC_RATE, 0x15f);
3504 }
3505
3506 /*
3507 * rt2870_asic_update_rtsthreshold
3508 */
3509 static void rt2870_asic_update_rtsthreshold(struct rt2870_softc *sc)
3510 {
3511 struct ifnet *ifp;
3512 struct ieee80211com *ic;
3513 struct ieee80211vap *vap;
3514 uint32_t tmp;
3515 uint16_t threshold;
3516
3517 ifp = sc->ifp;
3518 ic = ifp->if_l2com;
3519 vap = TAILQ_FIRST(&ic->ic_vaps);
3520
3521 if (vap == NULL)
3522 threshold = IEEE80211_RTS_MAX;
3523 else if (vap->iv_flags_ht & IEEE80211_FHT_AMSDU_TX)
3524 threshold = 0x1000;
3525 else
3526 threshold = vap->iv_rtsthreshold;
3527
3528 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3529 "%s: updating RTS threshold: %d\n",
3530 device_get_nameunit(sc->dev), threshold);
3531
3532 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_RTS_CFG);
3533
3534 tmp &= ~(RT2870_REG_TX_RTS_THRESHOLD_MASK << RT2870_REG_TX_RTS_THRESHOLD_SHIFT);
3535
3536 tmp |= ((threshold & RT2870_REG_TX_RTS_THRESHOLD_MASK) <<
3537 RT2870_REG_TX_RTS_THRESHOLD_SHIFT);
3538
3539 rt2870_io_mac_write(sc, RT2870_REG_TX_RTS_CFG, tmp);
3540 }
3541
3542 /*
3543 * rt2870_asic_update_txpower
3544 */
3545 static void rt2870_asic_update_txpower(struct rt2870_softc *sc)
3546 {
3547 struct ifnet *ifp;
3548 struct ieee80211com *ic;
3549 uint32_t *txpow_rate;
3550 int8_t delta;
3551 uint8_t val;
3552 uint32_t tmp;
3553 int i;
3554
3555 ifp = sc->ifp;
3556 ic = ifp->if_l2com;
3557
3558 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3559 "%s: updating Tx power: %d\n",
3560 device_get_nameunit(sc->dev), ic->ic_txpowlimit);
3561
3562 if (!IEEE80211_IS_CHAN_HT40(ic->ic_curchan))
3563 {
3564 txpow_rate = sc->txpow_rate_20mhz;
3565 }
3566 else
3567 {
3568 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
3569 txpow_rate = sc->txpow_rate_40mhz_2ghz;
3570 else
3571 txpow_rate = sc->txpow_rate_40mhz_5ghz;
3572 }
3573
3574 delta = 0;
3575
3576 val = rt2870_io_bbp_read(sc, 1);
3577 val &= 0xfc;
3578
3579 if (ic->ic_txpowlimit > 90)
3580 {
3581 /* do nothing */
3582 }
3583 else if (ic->ic_txpowlimit > 60)
3584 {
3585 delta -= 1;
3586 }
3587 else if (ic->ic_txpowlimit > 30)
3588 {
3589 delta -= 3;
3590 }
3591 else if (ic->ic_txpowlimit > 15)
3592 {
3593 val |= 0x1;
3594 }
3595 else if (ic->ic_txpowlimit > 9)
3596 {
3597 val |= 0x1;
3598 delta -= 3;
3599 }
3600 else
3601 {
3602 val |= 0x2;
3603 }
3604
3605 rt2870_io_bbp_write(sc, 1, val);
3606
3607 for (i = 0; i < RT2870_SOFTC_TXPOW_RATE_COUNT; i++)
3608 {
3609 if (txpow_rate[i] == 0xffffffff)
3610 continue;
3611
3612 tmp = rt2870_read_eeprom_txpow_rate_add_delta(txpow_rate[i], delta);
3613
3614 rt2870_io_mac_write(sc, RT2870_REG_TX_PWR_CFG(i), tmp);
3615 }
3616 }
3617
3618 /*
3619 * rt2870_asic_update_promisc
3620 */
3621 static void rt2870_asic_update_promisc(struct rt2870_softc *sc)
3622 {
3623 struct ifnet *ifp;
3624 uint32_t tmp;
3625
3626 ifp = sc->ifp;
3627
3628 printf("%s: %s promiscuous mode\n",
3629 device_get_nameunit(sc->dev),
3630 (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
3631
3632 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_FILTER_CFG);
3633
3634 tmp &= ~RT2870_REG_RX_FILTER_DROP_UC_NOME;
3635
3636 if (!(ifp->if_flags & IFF_PROMISC))
3637 tmp |= RT2870_REG_RX_FILTER_DROP_UC_NOME;
3638
3639 rt2870_io_mac_write(sc, RT2870_REG_RX_FILTER_CFG, tmp);
3640 }
3641
3642 /*
3643 * rt2870_asic_updateprot
3644 */
3645 static void rt2870_asic_updateprot(struct rt2870_softc *sc)
3646 {
3647 struct ifnet *ifp;
3648 struct ieee80211com *ic;
3649 struct ieee80211vap *vap;
3650 uint32_t cck_prot, ofdm_prot, mm20_prot, mm40_prot, gf20_prot, gf40_prot;
3651 uint8_t htopmode;
3652 enum ieee80211_protmode htprotmode;
3653
3654 ifp = sc->ifp;
3655 ic = ifp->if_l2com;
3656 vap = TAILQ_FIRST(&ic->ic_vaps);
3657
3658 /* CCK frame protection */
3659
3660 cck_prot = RT2870_REG_RTSTH_ENABLE | RT2870_REG_PROT_NAV_SHORT |
3661 RT2870_REG_TXOP_ALLOW_ALL | RT2870_REG_PROT_CTRL_NONE;
3662
3663 /* set up protection frame phy mode and rate (MCS code) */
3664
3665 if (ic->ic_curmode == IEEE80211_MODE_11A)
3666 cck_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3667 (0 << RT2870_REG_PROT_MCS_SHIFT);
3668 else
3669 cck_prot |= ((RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3670 (3 << RT2870_REG_PROT_MCS_SHIFT));
3671
3672 rt2870_io_mac_write(sc, RT2870_REG_TX_CCK_PROT_CFG, cck_prot);
3673
3674 /* OFDM frame protection */
3675
3676 ofdm_prot = RT2870_REG_RTSTH_ENABLE | RT2870_REG_PROT_NAV_SHORT |
3677 RT2870_REG_TXOP_ALLOW_ALL;
3678
3679 if (ic->ic_flags & IEEE80211_F_USEPROT)
3680 {
3681 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3682 "%s: updating protection mode: b/g protection mode=%s\n",
3683 device_get_nameunit(sc->dev),
3684 (ic->ic_protmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3685 ((ic->ic_protmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3686
3687 if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
3688 ofdm_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3689 else if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
3690 ofdm_prot |= RT2870_REG_PROT_CTRL_CTS;
3691 else
3692 ofdm_prot |= RT2870_REG_PROT_CTRL_NONE;
3693 }
3694 else
3695 {
3696 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3697 "%s: updating protection mode: b/g protection mode=%s\n",
3698 device_get_nameunit(sc->dev), "none");
3699
3700 ofdm_prot |= RT2870_REG_PROT_CTRL_NONE;
3701 }
3702
3703 rt2870_io_mac_write(sc, RT2870_REG_TX_OFDM_PROT_CFG, ofdm_prot);
3704
3705 /* HT frame protection */
3706
3707 if ((vap != NULL) && (vap->iv_opmode == IEEE80211_M_STA) && (vap->iv_state == IEEE80211_S_RUN))
3708 htopmode = vap->iv_bss->ni_htopmode;
3709 else
3710 htopmode = ic->ic_curhtprotmode;
3711
3712 htprotmode = ic->ic_htprotmode;
3713
3714 /* force HT mixed mode and RTS/CTS protection if A-MPDU Tx aggregation is enabled */
3715
3716 if (sc->tx_ampdu_sessions > 0)
3717 {
3718 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3719 "%s: updating protection mode: forcing HT mixed mode and RTS/CTS protection\n",
3720 device_get_nameunit(sc->dev));
3721
3722 htopmode = IEEE80211_HTINFO_OPMODE_MIXED;
3723 htprotmode = IEEE80211_PROT_RTSCTS;
3724 }
3725
3726 RT2870_DPRINTF(sc, RT2870_DEBUG_PROT,
3727 "%s: updating protection mode: HT operation mode=0x%02x, protection mode=%s\n",
3728 device_get_nameunit(sc->dev),
3729 htopmode & IEEE80211_HTINFO_OPMODE,
3730 (htprotmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3731 ((htprotmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3732
3733 switch (htopmode & IEEE80211_HTINFO_OPMODE)
3734 {
3735 /* IEEE80211_HTINFO_OPMODE_HT20PR */
3736 case IEEE80211_HTINFO_OPMODE_HT20PR:
3737 mm20_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3738 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3739 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20 |
3740 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3741 (4 << RT2870_REG_PROT_MCS_SHIFT);
3742
3743 gf20_prot = mm20_prot;
3744
3745 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3746 RT2870_REG_TXOP_ALLOW_ALL |
3747 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3748 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3749
3750 if (htprotmode == IEEE80211_PROT_RTSCTS)
3751 mm40_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3752 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3753 mm40_prot |= RT2870_REG_PROT_CTRL_CTS;
3754 else
3755 mm40_prot |= RT2870_REG_PROT_CTRL_NONE;
3756
3757 gf40_prot = mm40_prot;
3758 break;
3759
3760 /* IEEE80211_HTINFO_OPMODE_MIXED */
3761 case IEEE80211_HTINFO_OPMODE_MIXED:
3762 mm20_prot = RT2870_REG_PROT_NAV_SHORT |
3763 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3764 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20;
3765
3766 if (ic->ic_flags & IEEE80211_F_USEPROT)
3767 mm20_prot |= (RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3768 (3 << RT2870_REG_PROT_MCS_SHIFT);
3769 else
3770 mm20_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3771 (4 << RT2870_REG_PROT_MCS_SHIFT);
3772
3773 if (htprotmode == IEEE80211_PROT_RTSCTS)
3774 mm20_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3775 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3776 mm20_prot |= RT2870_REG_PROT_CTRL_CTS;
3777 else
3778 mm20_prot |= RT2870_REG_PROT_CTRL_NONE;
3779
3780 gf20_prot = mm20_prot;
3781
3782 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_TXOP_ALLOW_ALL;
3783
3784 if (ic->ic_flags & IEEE80211_F_USEPROT)
3785 mm40_prot |= (RT2870_REG_PROT_PHYMODE_CCK << RT2870_REG_PROT_PHYMODE_SHIFT) |
3786 (3 << RT2870_REG_PROT_MCS_SHIFT);
3787 else
3788 mm40_prot |= (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3789 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3790
3791 if (htprotmode == IEEE80211_PROT_RTSCTS)
3792 mm40_prot |= RT2870_REG_PROT_CTRL_RTS_CTS;
3793 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3794 mm40_prot |= RT2870_REG_PROT_CTRL_CTS;
3795 else
3796 mm40_prot |= RT2870_REG_PROT_CTRL_NONE;
3797
3798 gf40_prot = mm40_prot;
3799 break;
3800
3801 /*
3802 * IEEE80211_HTINFO_OPMODE_PURE
3803 * IEEE80211_HTINFO_OPMODE_PROTOPT
3804 */
3805 case IEEE80211_HTINFO_OPMODE_PURE:
3806 case IEEE80211_HTINFO_OPMODE_PROTOPT:
3807 default:
3808 mm20_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3809 RT2870_REG_TXOP_ALLOW_CCK | RT2870_REG_TXOP_ALLOW_OFDM |
3810 RT2870_REG_TXOP_ALLOW_MM20 | RT2870_REG_TXOP_ALLOW_GF20 |
3811 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3812 (4 << RT2870_REG_PROT_MCS_SHIFT);
3813
3814 gf20_prot = mm20_prot;
3815
3816 mm40_prot = RT2870_REG_PROT_NAV_SHORT | RT2870_REG_PROT_CTRL_NONE |
3817 RT2870_REG_TXOP_ALLOW_ALL |
3818 (RT2870_REG_PROT_PHYMODE_OFDM << RT2870_REG_PROT_PHYMODE_SHIFT) |
3819 (0x84 << RT2870_REG_PROT_MCS_SHIFT);
3820
3821 gf40_prot = mm40_prot;
3822 break;
3823 }
3824
3825 rt2870_io_mac_write(sc, RT2870_REG_TX_MM20_PROT_CFG, mm20_prot);
3826 rt2870_io_mac_write(sc, RT2870_REG_TX_MM40_PROT_CFG, mm40_prot);
3827 rt2870_io_mac_write(sc, RT2870_REG_TX_GF20_PROT_CFG, gf20_prot);
3828 rt2870_io_mac_write(sc, RT2870_REG_TX_GF40_PROT_CFG, gf40_prot);
3829 }
3830
3831 /*
3832 * rt2870_asic_updateslot
3833 */
3834 static void rt2870_asic_updateslot(struct rt2870_softc *sc)
3835 {
3836 struct ifnet *ifp;
3837 struct ieee80211com *ic;
3838 struct ieee80211vap *vap;
3839 uint32_t tmp;
3840
3841 ifp = sc->ifp;
3842 ic = ifp->if_l2com;
3843 vap = TAILQ_FIRST(&ic->ic_vaps);
3844
3845 RT2870_DPRINTF(sc, RT2870_DEBUG_STATE,
3846 "%s: %s short slot time\n",
3847 device_get_nameunit(sc->dev),
3848 ((ic->ic_flags & IEEE80211_F_SHSLOT) ||
3849 ((vap != NULL) && (vap->iv_flags & IEEE80211_F_BURST))) ? "enabling" : "disabling");
3850
3851 tmp = rt2870_io_mac_read(sc, RT2870_REG_BKOFF_SLOT_CFG);
3852
3853 tmp &= ~0xff;
3854
3855 if ((ic->ic_flags & IEEE80211_F_SHSLOT) ||
3856 ((vap != NULL) && (vap->iv_flags & IEEE80211_F_BURST)))
3857 tmp |= IEEE80211_DUR_SHSLOT;
3858 else
3859 tmp |= IEEE80211_DUR_SLOT;
3860
3861 rt2870_io_mac_write(sc, RT2870_REG_BKOFF_SLOT_CFG, tmp);
3862 }
3863
3864 /*
3865 * rt2870_asic_wme_update
3866 */
3867 static void rt2870_asic_wme_update(struct rt2870_softc *sc)
3868 {
3869 struct ifnet *ifp;
3870 struct ieee80211com *ic;
3871 struct ieee80211_wme_state *wme;
3872 const struct wmeParams *wmep;
3873 int i;
3874
3875 ifp = sc->ifp;
3876 ic = ifp->if_l2com;
3877 wme = &ic->ic_wme;
3878 wmep = wme->wme_chanParams.cap_wmeParams;
3879
3880 RT2870_DPRINTF(sc, RT2870_DEBUG_WME,
3881 "%s: wme update: WME_AC_VO=%d/%d/%d/%d, WME_AC_VI=%d/%d/%d/%d, "
3882 "WME_AC_BK=%d/%d/%d/%d, WME_AC_BE=%d/%d/%d/%d\n",
3883 device_get_nameunit(sc->dev),
3884 wmep[WME_AC_VO].wmep_aifsn,
3885 wmep[WME_AC_VO].wmep_logcwmin, wmep[WME_AC_VO].wmep_logcwmax,
3886 wmep[WME_AC_VO].wmep_txopLimit,
3887 wmep[WME_AC_VI].wmep_aifsn,
3888 wmep[WME_AC_VI].wmep_logcwmin, wmep[WME_AC_VI].wmep_logcwmax,
3889 wmep[WME_AC_VI].wmep_txopLimit,
3890 wmep[WME_AC_BK].wmep_aifsn,
3891 wmep[WME_AC_BK].wmep_logcwmin, wmep[WME_AC_BK].wmep_logcwmax,
3892 wmep[WME_AC_BK].wmep_txopLimit,
3893 wmep[WME_AC_BE].wmep_aifsn,
3894 wmep[WME_AC_BE].wmep_logcwmin, wmep[WME_AC_BE].wmep_logcwmax,
3895 wmep[WME_AC_BE].wmep_txopLimit);
3896
3897 for (i = 0; i < WME_NUM_AC; i++)
3898 rt2870_io_mac_write(sc, RT2870_REG_TX_EDCA_AC_CFG(i),
3899 (wmep[i].wmep_logcwmax << 16) | (wmep[i].wmep_logcwmin << 12) |
3900 (wmep[i].wmep_aifsn << 8) | wmep[i].wmep_txopLimit);
3901
3902 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_AIFSN_CFG,
3903 (wmep[WME_AC_VO].wmep_aifsn << 12) | (wmep[WME_AC_VI].wmep_aifsn << 8) |
3904 (wmep[WME_AC_BK].wmep_aifsn << 4) | wmep[WME_AC_BE].wmep_aifsn);
3905
3906 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_CWMIN_CFG,
3907 (wmep[WME_AC_VO].wmep_logcwmin << 12) | (wmep[WME_AC_VI].wmep_logcwmin << 8) |
3908 (wmep[WME_AC_BK].wmep_logcwmin << 4) | wmep[WME_AC_BE].wmep_logcwmin);
3909
3910 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_CWMAX_CFG,
3911 (wmep[WME_AC_VO].wmep_logcwmax << 12) | (wmep[WME_AC_VI].wmep_logcwmax << 8) |
3912 (wmep[WME_AC_BK].wmep_logcwmax << 4) | wmep[WME_AC_BE].wmep_logcwmax);
3913
3914 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP0_CFG,
3915 (wmep[WME_AC_BK].wmep_txopLimit << 16) | wmep[WME_AC_BE].wmep_txopLimit);
3916
3917 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP1_CFG,
3918 (wmep[WME_AC_VO].wmep_txopLimit << 16) | wmep[WME_AC_VI].wmep_txopLimit);
3919 }
3920
3921 /*
3922 * rt2870_asic_update_beacon
3923 */
3924 static void rt2870_asic_update_beacon(struct rt2870_softc *sc,
3925 struct ieee80211vap *vap)
3926 {
3927 struct rt2870_softc_vap *rvap;
3928 struct mbuf *m;
3929 struct rt2870_txwi *txwi;
3930 uint32_t tmp;
3931
3932 rvap = (struct rt2870_softc_vap *) vap;
3933
3934 m = rvap->beacon_mbuf;
3935 txwi = &rvap->beacon_txwi;
3936
3937 /* disable temporarily TSF sync */
3938
3939 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3940
3941 tmp &= ~(RT2870_REG_BCN_TX_ENABLE |
3942 RT2870_REG_TSF_TIMER_ENABLE |
3943 RT2870_REG_TBTT_TIMER_ENABLE);
3944
3945 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3946
3947 /* write Tx wireless info and beacon frame to on-chip memory */
3948
3949 rt2870_io_mac_write_multi(sc, RT2870_REG_BEACON_BASE(0),
3950 txwi, sizeof(struct rt2870_txwi));
3951
3952 rt2870_io_mac_write_multi(sc, RT2870_REG_BEACON_BASE(0) + sizeof(struct rt2870_txwi),
3953 mtod(m, uint8_t *), m->m_pkthdr.len);
3954
3955 /* enable again TSF sync */
3956
3957 tmp = rt2870_io_mac_read(sc, RT2870_REG_BCN_TIME_CFG);
3958
3959 tmp |= (RT2870_REG_BCN_TX_ENABLE |
3960 RT2870_REG_TSF_TIMER_ENABLE |
3961 RT2870_REG_TBTT_TIMER_ENABLE);
3962
3963 rt2870_io_mac_write(sc, RT2870_REG_BCN_TIME_CFG, tmp);
3964 }
3965
3966 /*
3967 * rt2870_asic_clear_keytables
3968 */
3969 static void rt2870_asic_clear_keytables(struct rt2870_softc *sc)
3970 {
3971 int i;
3972
3973 /* clear Rx WCID search table (entries = 256, entry size = 8) */
3974
3975 for (i = 0; i < 256; i++)
3976 {
3977 rt2870_io_mac_write(sc, RT2870_REG_WCID(i), 0xffffffff);
3978 rt2870_io_mac_write(sc, RT2870_REG_WCID(i) + 4, 0x0000ffff);
3979 }
3980
3981 /* clear WCID attribute table (entries = 256, entry size = 4) */
3982
3983 rt2870_io_mac_set_region_4(sc, RT2870_REG_WCID_ATTR(0), 0, 256);
3984
3985 /* clear IV/EIV table (entries = 256, entry size = 8) */
3986
3987 rt2870_io_mac_set_region_4(sc, RT2870_REG_IVEIV(0), 0, 2 * 256);
3988
3989 /* clear pairwise key table (entries = 256, entry size = 32) */
3990
3991 rt2870_io_mac_set_region_4(sc, RT2870_REG_PKEY(0), 0, 8 * 256);
3992
3993 /* clear shared key table (entries = 32, entry size = 32) */
3994
3995 rt2870_io_mac_set_region_4(sc, RT2870_REG_SKEY(0, 0), 0, 8 * 32);
3996
3997 /* clear shared key mode (entries = 32, entry size = 2) */
3998
3999 rt2870_io_mac_set_region_4(sc, RT2870_REG_SKEY_MODE(0), 0, 16);
4000 }
4001
4002 /*
4003 * rt2870_beacon_alloc
4004 */
4005 static int rt2870_beacon_alloc(struct rt2870_softc *sc,
4006 struct ieee80211vap *vap)
4007 {
4008 struct ieee80211com *ic;
4009 struct rt2870_softc_vap *rvap;
4010 struct mbuf *m;
4011 struct rt2870_txwi txwi;
4012 uint8_t rate, mcs;
4013
4014 ic = vap->iv_ic;
4015 rvap = (struct rt2870_softc_vap *) vap;
4016
4017 m = ieee80211_beacon_alloc(vap->iv_bss, &rvap->beacon_offsets);
4018 if (m == NULL)
4019 return ENOMEM;
4020
4021 rate = IEEE80211_IS_CHAN_5GHZ(vap->iv_bss->ni_chan) ? 12 : 2;
4022 mcs = rt2870_rate2mcs(rate);
4023
4024 RT2870_DPRINTF(sc, RT2870_DEBUG_BEACON,
4025 "%s: beacon allocate: mcs=0x%02x\n",
4026 device_get_nameunit(sc->dev), mcs);
4027
4028 memset(&txwi, 0, sizeof(struct rt2870_txwi));
4029
4030 txwi.wcid = RT2870_WCID_RESERVED;
4031 txwi.pid_mpdu_len = ((htole16(m->m_pkthdr.len) & RT2870_TXWI_MPDU_LEN_MASK) <<
4032 RT2870_TXWI_MPDU_LEN_SHIFT);
4033 txwi.txop = (RT2870_TXWI_TXOP_HT << RT2870_TXWI_TXOP_SHIFT);
4034 txwi.mpdu_density_flags |=
4035 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4036 txwi.bawin_size_xflags |=
4037 (RT2870_TXWI_XFLAGS_NSEQ << RT2870_TXWI_XFLAGS_SHIFT);
4038
4039 if (rate == 2)
4040 {
4041 txwi.phymode_ifs_stbc_shortgi =
4042 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
4043
4044 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
4045 mcs |= RT2870_TXWI_MCS_SHOTPRE;
4046 }
4047 else
4048 {
4049 txwi.phymode_ifs_stbc_shortgi =
4050 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
4051 }
4052
4053 txwi.bw_mcs = (RT2870_TXWI_BW_20 << RT2870_TXWI_BW_SHIFT) |
4054 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
4055
4056 if (rvap->beacon_mbuf != NULL)
4057 {
4058 m_free(rvap->beacon_mbuf);
4059 rvap->beacon_mbuf = NULL;
4060 }
4061
4062 rvap->beacon_mbuf = m;
4063 rvap->beacon_txwi = txwi;
4064
4065 return 0;
4066 }
4067
4068 /*
4069 * rt2870_rxrate
4070 */
4071 static uint8_t rt2870_rxrate(struct rt2870_rxwi *rxwi)
4072 {
4073 uint8_t mcs, phymode;
4074 uint8_t rate;
4075
4076 mcs = (rxwi->bw_mcs >> RT2870_RXWI_MCS_SHIFT) & RT2870_RXWI_MCS_MASK;
4077 phymode = (rxwi->phymode_stbc_shortgi >> RT2870_RXWI_PHYMODE_SHIFT) &
4078 RT2870_RXWI_PHYMODE_MASK;
4079
4080 rate = 2;
4081
4082 switch (phymode)
4083 {
4084 case RT2870_RXWI_PHYMODE_CCK:
4085 switch (mcs & ~RT2870_RXWI_MCS_SHOTPRE)
4086 {
4087 case 0: rate = 2; break; /* 1 Mbps */
4088 case 1: rate = 4; break; /* 2 MBps */
4089 case 2: rate = 11; break; /* 5.5 Mbps */
4090 case 3: rate = 22; break; /* 11 Mbps */
4091 }
4092 break;
4093
4094 case RT2870_RXWI_PHYMODE_OFDM:
4095 switch (mcs)
4096 {
4097 case 0: rate = 12; break; /* 6 Mbps */
4098 case 1: rate = 18; break; /* 9 Mbps */
4099 case 2: rate = 24; break; /* 12 Mbps */
4100 case 3: rate = 36; break; /* 18 Mbps */
4101 case 4: rate = 48; break; /* 24 Mbps */
4102 case 5: rate = 72; break; /* 36 Mbps */
4103 case 6: rate = 96; break; /* 48 Mbps */
4104 case 7: rate = 108; break; /* 54 Mbps */
4105 }
4106 break;
4107
4108 case RT2870_RXWI_PHYMODE_HT_MIXED:
4109 case RT2870_RXWI_PHYMODE_HT_GF:
4110 break;
4111 }
4112
4113 return rate;
4114 }
4115
4116 /*
4117 * rt2870_maxrssi_rxpath
4118 */
4119 static uint8_t rt2870_maxrssi_rxpath(struct rt2870_softc *sc,
4120 const struct rt2870_rxwi *rxwi)
4121 {
4122 uint8_t rxpath;
4123
4124 rxpath = 0;
4125
4126 if (sc->nrxpath > 1)
4127 if (rxwi->rssi[1] > rxwi->rssi[rxpath])
4128 rxpath = 1;
4129
4130 if (sc->nrxpath > 2)
4131 if (rxwi->rssi[2] > rxwi->rssi[rxpath])
4132 rxpath = 2;
4133
4134 return rxpath;
4135 }
4136
4137 /*
4138 * rt2870_rssi2dbm
4139 */
4140 static int8_t rt2870_rssi2dbm(struct rt2870_softc *sc,
4141 uint8_t rssi, uint8_t rxpath)
4142 {
4143 struct ifnet *ifp;
4144 struct ieee80211com *ic;
4145 struct ieee80211_channel *c;
4146 int chan;
4147 int8_t rssi_off, lna_gain;
4148
4149 if (rssi == 0)
4150 return -99;
4151
4152 ifp = sc->ifp;
4153 ic = ifp->if_l2com;
4154 c = ic->ic_curchan;
4155 chan = ieee80211_chan2ieee(ic, c);
4156
4157 if (IEEE80211_IS_CHAN_5GHZ(c))
4158 {
4159 rssi_off = sc->rssi_off_5ghz[rxpath];
4160
4161 if (chan <= 64)
4162 lna_gain = sc->lna_gain[1];
4163 else if (chan <= 128)
4164 lna_gain = sc->lna_gain[2];
4165 else
4166 lna_gain = sc->lna_gain[3];
4167 }
4168 else
4169 {
4170 rssi_off = sc->rssi_off_2ghz[rxpath];
4171 lna_gain = sc->lna_gain[0];
4172 }
4173
4174 return (-12 - rssi_off - lna_gain - rssi);
4175 }
4176
4177 /*
4178 * rt2870_rate2mcs
4179 */
4180 static uint8_t rt2870_rate2mcs(uint8_t rate)
4181 {
4182 switch (rate)
4183 {
4184 /* CCK rates */
4185 case 2: return 0;
4186 case 4: return 1;
4187 case 11: return 2;
4188 case 22: return 3;
4189
4190 /* OFDM rates */
4191 case 12: return 0;
4192 case 18: return 1;
4193 case 24: return 2;
4194 case 36: return 3;
4195 case 48: return 4;
4196 case 72: return 5;
4197 case 96: return 6;
4198 case 108: return 7;
4199 }
4200
4201 return 0;
4202 }
4203
4204 /*
4205 * rt2870_rx_frame
4206 */
4207 static void rt2870_rx_frame(struct rt2870_softc *sc,
4208 uint8_t *buf, uint32_t dmalen)
4209 {
4210 struct ifnet *ifp;
4211 struct ieee80211com *ic;
4212 struct ieee80211_frame *wh;
4213 struct ieee80211_node *ni;
4214 struct rt2870_softc_node *rni;
4215 struct rt2870_softc_rx_radiotap_header *tap;
4216 struct rt2870_rxwi *rxwi;
4217 struct rt2870_rxinfo *rxinfo;
4218 struct mbuf *m;
4219 uint32_t rxinfo_flags;
4220 uint8_t cipher_err, rssi, ant, phymode, bw, shortgi, stbc, mcs, keyidx, tid, frag;
4221 uint16_t seq;
4222 int8_t rssi_dbm;
4223 int len, ampdu, amsdu, rssi_dbm_rel, i;
4224
4225 ifp = sc->ifp;
4226 ic = ifp->if_l2com;
4227
4228 /* get Rx wireless info */
4229
4230 rxwi = (struct rt2870_rxwi *) buf;
4231 len = (le16toh(rxwi->tid_size) >> RT2870_RXWI_SIZE_SHIFT) &
4232 RT2870_RXWI_SIZE_MASK;
4233
4234 if (len > dmalen)
4235 {
4236 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4237 "%s: bad rxwi len: DMA len=%d, rxwi len=%d\n",
4238 device_get_nameunit(sc->dev), dmalen, len);
4239 return;
4240 }
4241
4242 /* get Rx info */
4243
4244 rxinfo = (struct rt2870_rxinfo *) ((caddr_t) rxwi + dmalen);
4245 rxinfo_flags = le32toh(rxinfo->flags);
4246
4247 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4248 "%s: Rx frame: DMA len=%d, len=%d, rxinfo flags=0x%08x\n",
4249 device_get_nameunit(sc->dev), dmalen, len, rxinfo_flags);
4250
4251 /* check for crc errors */
4252
4253 if (rxinfo_flags & RT2870_RXINFO_FLAGS_CRC_ERR)
4254 {
4255 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4256 "%s: rxinfo: crc error\n",
4257 device_get_nameunit(sc->dev));
4258
4259 ifp->if_ierrors++;
4260
4261 if (!(ifp->if_flags & IFF_PROMISC))
4262 return;
4263 }
4264
4265 wh = (struct ieee80211_frame *) (rxwi + 1);
4266
4267 /* check for L2 padding between IEEE 802.11 frame header and body */
4268
4269 if (rxinfo_flags & RT2870_RXINFO_FLAGS_L2PAD)
4270 {
4271 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4272 "%s: L2 padding: DMA len=%d, len=%d\n",
4273 device_get_nameunit(sc->dev), dmalen, len);
4274
4275 len += 2;
4276 }
4277
4278 m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
4279 if (m == NULL)
4280 {
4281 sc->rx_mbuf_alloc_errors++;
4282 ifp->if_ierrors++;
4283 return;
4284 }
4285
4286 m->m_pkthdr.rcvif = ifp;
4287 m->m_pkthdr.len = m->m_len = len;
4288
4289 m_copyback(m, 0, len, (caddr_t) wh);
4290
4291 wh = mtod(m, struct ieee80211_frame *);
4292
4293 /* check for cipher errors */
4294
4295 if (rxinfo_flags & RT2870_RXINFO_FLAGS_DECRYPTED)
4296 {
4297 cipher_err = ((rxinfo_flags >> RT2870_RXINFO_FLAGS_CIPHER_ERR_SHIFT) &
4298 RT2870_RXINFO_FLAGS_CIPHER_ERR_MASK);
4299 if (cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_NONE)
4300 {
4301 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4302 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4303
4304 m->m_flags |= M_WEP;
4305
4306 sc->rx_cipher_no_errors++;
4307 }
4308 else
4309 {
4310 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4311 "%s: rxinfo: cipher error=0x%02x\n",
4312 device_get_nameunit(sc->dev), cipher_err);
4313
4314 if (cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_ICV)
4315 sc->rx_cipher_icv_errors++;
4316 else if (cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_MIC)
4317 sc->rx_cipher_mic_errors++;
4318 else if (cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_INVALID_KEY)
4319 sc->rx_cipher_invalid_key_errors++;
4320
4321 if ((cipher_err == RT2870_RXINFO_FLAGS_CIPHER_ERR_MIC) &&
4322 (rxinfo_flags & RT2870_RXINFO_FLAGS_MYBSS))
4323 {
4324 ni = ieee80211_find_rxnode(ic, (const struct ieee80211_frame_min *) wh);
4325 if (ni != NULL)
4326 {
4327 keyidx = (rxwi->udf_bssidx_keyidx >> RT2870_RXWI_KEYIDX_SHIFT) &
4328 RT2870_RXWI_KEYIDX_MASK;
4329
4330 ieee80211_notify_michael_failure(ni->ni_vap, wh, keyidx);
4331
4332 ieee80211_free_node(ni);
4333 }
4334 }
4335
4336 ifp->if_ierrors++;
4337
4338 if (!(ifp->if_flags & IFF_PROMISC))
4339 {
4340 m_free(m);
4341 return;
4342 }
4343 }
4344 }
4345 else
4346 {
4347 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4348 {
4349 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4350 "%s: rxinfo: not decrypted but protected flag set\n",
4351 device_get_nameunit(sc->dev));
4352
4353 ifp->if_ierrors++;
4354
4355 if (!(ifp->if_flags & IFF_PROMISC))
4356 {
4357 m_free(m);
4358 return;
4359 }
4360 }
4361 }
4362
4363 /* check for A-MPDU */
4364
4365 if (rxinfo_flags & RT2870_RXINFO_FLAGS_BA)
4366 {
4367 m->m_flags |= M_AMPDU;
4368
4369 sc->rx_ampdu++;
4370
4371 ampdu = 1;
4372 }
4373 else
4374 {
4375 ampdu = 0;
4376 }
4377
4378 /* check for A-MSDU */
4379
4380 if (rxinfo_flags & RT2870_RXINFO_FLAGS_AMSDU)
4381 {
4382 sc->rx_amsdu++;
4383
4384 amsdu = 1;
4385 }
4386 else
4387 {
4388 amsdu = 0;
4389 }
4390
4391 ant = rt2870_maxrssi_rxpath(sc, rxwi);
4392 rssi = rxwi->rssi[ant];
4393 rssi_dbm = rt2870_rssi2dbm(sc, rssi, ant);
4394 phymode = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_PHYMODE_SHIFT) &
4395 RT2870_RXWI_PHYMODE_MASK);
4396 bw = ((rxwi->bw_mcs >> RT2870_RXWI_BW_SHIFT) & RT2870_RXWI_BW_MASK);
4397 shortgi = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_SHORTGI_SHIFT) &
4398 RT2870_RXWI_SHORTGI_MASK);
4399 stbc = ((rxwi->phymode_stbc_shortgi >> RT2870_RXWI_STBC_SHIFT) &
4400 RT2870_RXWI_STBC_MASK);
4401 mcs = ((rxwi->bw_mcs >> RT2870_RXWI_MCS_SHIFT) & RT2870_RXWI_MCS_MASK);
4402 tid = ((rxwi->tid_size >> RT2870_RXWI_TID_SHIFT) & RT2870_RXWI_TID_MASK);
4403 seq = ((rxwi->seq_frag >> RT2870_RXWI_SEQ_SHIFT) & RT2870_RXWI_SEQ_MASK);
4404 frag = ((rxwi->seq_frag >> RT2870_RXWI_FRAG_SHIFT) & RT2870_RXWI_FRAG_MASK);
4405
4406 if (ieee80211_radiotap_active(ic))
4407 {
4408 tap = &sc->rxtap;
4409
4410 tap->flags = (rxinfo_flags & RT2870_RXINFO_FLAGS_L2PAD) ? IEEE80211_RADIOTAP_F_DATAPAD : 0;
4411 tap->dbm_antsignal = rssi_dbm;
4412 tap->dbm_antnoise = RT2870_NOISE_FLOOR;
4413 tap->antenna = ant;
4414 tap->antsignal = rssi;
4415 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4416 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4417 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4418 tap->chan_maxpow = 0;
4419
4420 if (phymode == RT2870_RXWI_PHYMODE_CCK || phymode == RT2870_RXWI_PHYMODE_OFDM)
4421 tap->rate = rt2870_rxrate(rxwi);
4422 else
4423 tap->rate = mcs | IEEE80211_RATE_MCS;
4424
4425 if (rxinfo_flags & RT2870_RXINFO_FLAGS_CRC_ERR)
4426 tap->flags |= IEEE80211_RADIOTAP_F_BADFCS;
4427
4428 if (rxinfo_flags & RT2870_RXINFO_FLAGS_FRAG)
4429 tap->flags |= IEEE80211_RADIOTAP_F_FRAG;
4430
4431 if (rxwi->bw_mcs & RT2870_RXWI_MCS_SHOTPRE)
4432 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4433
4434 if ((rxinfo_flags & RT2870_RXINFO_FLAGS_DECRYPTED) ||
4435 (wh->i_fc[1] & IEEE80211_FC1_WEP))
4436 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4437
4438 if (shortgi)
4439 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4440 }
4441
4442 /*
4443 * net80211 assumes that RSSI data are in the range [-127..127] and
4444 * in .5 dBm units relative to the current noise floor
4445 */
4446
4447 rssi_dbm_rel = (rssi_dbm - RT2870_NOISE_FLOOR) * 2;
4448 if (rssi_dbm_rel > 127)
4449 rssi_dbm_rel = 127;
4450
4451 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
4452 "%s: received frame: len=%d, phymode=%d, bw=%d, shortgi=%d, stbc=0x%02x, mcs=%d, "
4453 "ant=%d, rssi=%d/%d/%d, snr=%d/%d, wcid=0x%02x, ampdu=%d, amsdu=%d, tid=%d, seq=%d, frag=%d, "
4454 "rssi_dbm=%d, rssi_dbm_rel=%d\n",
4455 device_get_nameunit(sc->dev),
4456 len, phymode, bw, shortgi, stbc, mcs,
4457 ant, rxwi->rssi[0], rxwi->rssi[1], rxwi->rssi[2],
4458 rxwi->snr[0], rxwi->snr[1],
4459 rxwi->wcid, ampdu, amsdu, tid, seq, frag, rssi_dbm, rssi_dbm_rel);
4460
4461 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *) wh);
4462 if (ni != NULL)
4463 {
4464 rni = (struct rt2870_softc_node *) ni;
4465
4466 for (i = 0; i < RT2870_SOFTC_RSSI_COUNT; i++)
4467 {
4468 rni->last_rssi[i] = rxwi->rssi[i];
4469 rni->last_rssi_dbm[i] = rt2870_rssi2dbm(sc, rxwi->rssi[i], i);
4470 }
4471
4472 ieee80211_input(ni, m, rssi_dbm_rel, RT2870_NOISE_FLOOR);
4473 ieee80211_free_node(ni);
4474 }
4475 else
4476 {
4477 ieee80211_input_all(ic, m, rssi_dbm_rel, RT2870_NOISE_FLOOR);
4478 }
4479 }
4480
4481 /*
4482 * rt2870_tx_mgmt
4483 */
4484 static int rt2870_tx_mgmt(struct rt2870_softc *sc,
4485 struct mbuf *m, struct ieee80211_node *ni, int qid)
4486 {
4487 struct ifnet *ifp;
4488 struct ieee80211com *ic;
4489 struct ieee80211vap *vap;
4490 const struct ieee80211_txparam *tp;
4491 struct rt2870_softc_node *rni;
4492 struct rt2870_softc_tx_ring *ring;
4493 struct rt2870_softc_tx_data *data;
4494 struct rt2870_txinfo *txinfo;
4495 struct rt2870_txwi *txwi;
4496 struct ieee80211_frame *wh;
4497 struct rt2870_softc_tx_radiotap_header *tap;
4498 u_int hdrsize, hdrspace;
4499 uint8_t rate, stbc, shortgi, mcs, pid;
4500 uint16_t len, dmalen, mpdu_len, dur;
4501 int mimops;
4502
4503 KASSERT(qid >= 0 && qid < (sc->usb_endpoints - 1),
4504 ("%s: Tx MGMT: invalid qid=%d\n",
4505 device_get_nameunit(sc->dev), qid));
4506
4507 ifp = sc->ifp;
4508 ic = ifp->if_l2com;
4509 vap = ni->ni_vap;
4510 rni = (struct rt2870_softc_node *) ni;
4511 tp = ni->ni_txparms;
4512
4513 ring = &sc->tx_ring[qid];
4514 data = STAILQ_FIRST(&ring->inactive);
4515 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4516 txinfo = (struct rt2870_txinfo *) data->buf;
4517 txwi = (struct rt2870_txwi *) (txinfo + 1);
4518
4519 wh = mtod(m, struct ieee80211_frame *);
4520
4521 rate = tp->mgmtrate & IEEE80211_RATE_VAL;
4522
4523 len = sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + m->m_pkthdr.len;
4524
4525 /* align end on a 4-bytes boundary */
4526
4527 dmalen = (len + 3) & ~3;
4528
4529 /* fill Tx info */
4530
4531 memset(txinfo, 0, sizeof(struct rt2870_txinfo));
4532
4533 txinfo->len = htole16(dmalen - sizeof(struct rt2870_txinfo));
4534
4535 txinfo->qsel_flags = (RT2870_TXINFO_QSEL_EDCA << RT2870_TXINFO_QSEL_SHIFT);
4536
4537 dmalen += 4;
4538
4539 memset((caddr_t) txinfo + len, 0, dmalen - len);
4540
4541 /* fill Tx wireless info */
4542
4543 if (ni->ni_flags & IEEE80211_NODE_HT)
4544 mcs = rate;
4545 else
4546 mcs = rt2870_rate2mcs(rate);
4547
4548 /* calculate MPDU length without padding */
4549
4550 hdrsize = ieee80211_hdrsize(wh);
4551 hdrspace = ieee80211_hdrspace(ic, wh);
4552 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
4553
4554 memset(txwi, 0, sizeof(struct rt2870_txwi));
4555
4556 /* management frames do not need encryption */
4557
4558 txwi->wcid = 0xff;
4559
4560 /* MIMO power save */
4561
4562 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_flags & IEEE80211_NODE_MIMO_PS))
4563 {
4564 if (mcs > 7)
4565 {
4566 if (ni->ni_flags & IEEE80211_NODE_MIMO_RTS)
4567 {
4568 /* dynamic MIMO power save */
4569
4570 txwi->mpdu_density_flags |=
4571 (RT2870_TXWI_FLAGS_MIMOPS << RT2870_TXWI_FLAGS_SHIFT);
4572 }
4573 else
4574 {
4575 /* static MIMO power save */
4576
4577 mcs = 7;
4578 }
4579 }
4580
4581 mimops = 1;
4582 }
4583 else
4584 {
4585 mimops = 0;
4586 }
4587
4588 pid = (mcs < 0xf) ? (mcs + 1) : mcs;
4589
4590 txwi->pid_mpdu_len = ((htole16(pid) & RT2870_TXWI_PID_MASK) <<
4591 RT2870_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2870_TXWI_MPDU_LEN_MASK) <<
4592 RT2870_TXWI_MPDU_LEN_SHIFT);
4593
4594 stbc = sc->tx_stbc && (mcs <= 7) && (vap->iv_htcaps & IEEE80211_HTCAP_TXSTBC) &&
4595 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC);
4596
4597 shortgi = ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20) && (ni->ni_flags & IEEE80211_NODE_SGI20) && (ni->ni_chw == 20)) ||
4598 ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI40) && (ni->ni_flags & IEEE80211_NODE_SGI40) && (ni->ni_chw == 40));
4599
4600 txwi->phymode_ifs_stbc_shortgi |=
4601 ((stbc & RT2870_TXWI_STBC_MASK) << RT2870_TXWI_STBC_SHIFT) |
4602 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4603
4604 txwi->phymode_ifs_stbc_shortgi |=
4605 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4606
4607 if (ni->ni_flags & IEEE80211_NODE_HT)
4608 {
4609 txwi->phymode_ifs_stbc_shortgi |=
4610 (RT2870_TXWI_PHYMODE_HT_MIXED << RT2870_TXWI_PHYMODE_SHIFT);
4611 }
4612 else
4613 {
4614 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
4615 {
4616 txwi->phymode_ifs_stbc_shortgi |=
4617 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
4618
4619 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
4620 mcs |= RT2870_TXWI_MCS_SHOTPRE;
4621 }
4622 else
4623 {
4624 txwi->phymode_ifs_stbc_shortgi |=
4625 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
4626 }
4627 }
4628
4629 txwi->bw_mcs = (RT2870_TXWI_BW_20 << RT2870_TXWI_BW_SHIFT) |
4630 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
4631
4632 txwi->txop = (RT2870_TXWI_TXOP_BACKOFF << RT2870_TXWI_TXOP_SHIFT);
4633
4634 /* skip ACKs for multicast frames */
4635
4636 if (!IEEE80211_IS_MULTICAST(wh->i_addr1))
4637 {
4638 txwi->bawin_size_xflags |=
4639 (RT2870_TXWI_XFLAGS_ACK << RT2870_TXWI_XFLAGS_SHIFT);
4640
4641 if (ni->ni_flags & IEEE80211_NODE_HT)
4642 {
4643 /* preamble + plcp + signal extension + SIFS */
4644
4645 dur = 16 + 4 + 6 + 10;
4646 }
4647 else
4648 {
4649 dur = ieee80211_ack_duration(ic->ic_rt, rate,
4650 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
4651 }
4652
4653 *(uint16_t *) wh->i_dur = htole16(dur);
4654 }
4655
4656 /* ask MAC to insert timestamp into probe responses */
4657
4658 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
4659 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
4660 txwi->mpdu_density_flags |=
4661 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4662
4663 if (ieee80211_radiotap_active_vap(vap))
4664 {
4665 tap = &sc->txtap;
4666
4667 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
4668 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4669 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4670 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4671 tap->chan_maxpow = 0;
4672
4673 if (ni->ni_flags & IEEE80211_NODE_HT)
4674 tap->rate = mcs | IEEE80211_RATE_MCS;
4675 else
4676 tap->rate = rate;
4677
4678 if (mcs & RT2870_TXWI_MCS_SHOTPRE)
4679 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4680
4681 if (shortgi)
4682 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4683
4684 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4685 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4686
4687 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4688 {
4689 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4690
4691 ieee80211_radiotap_tx(vap, m);
4692
4693 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4694 }
4695 else
4696 {
4697 ieee80211_radiotap_tx(vap, m);
4698 }
4699 }
4700
4701 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t) (txwi + 1));
4702
4703 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
4704 "%s: sending MGMT frame: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4705 "stbc=%d, shortgi=%d, mcs=%d, mimops=%d, DMA len=%d\n",
4706 device_get_nameunit(sc->dev),
4707 qid, hdrsize, hdrspace, m->m_pkthdr.len, stbc, shortgi, mcs, mimops, dmalen);
4708
4709 data->len = dmalen;
4710 data->m = m;
4711 data->ni = ni;
4712
4713 STAILQ_INSERT_TAIL(&ring->pending, data, next);
4714 ring->queued++;
4715
4716 usbd_transfer_start(sc->usb_xfer[1 + qid]);
4717
4718 return 0;
4719 }
4720
4721 /*
4722 * rt2870_tx_data
4723 */
4724 static int rt2870_tx_data(struct rt2870_softc *sc,
4725 struct mbuf *m, struct ieee80211_node *ni, int qid)
4726 {
4727 struct ifnet *ifp;
4728 struct ieee80211com *ic;
4729 struct ieee80211vap *vap;
4730 const struct ieee80211_txparam *tp;
4731 struct rt2870_softc_node *rni;
4732 struct rt2870_softc_tx_ring *ring;
4733 struct rt2870_softc_tx_data *data;
4734 struct rt2870_txinfo *txinfo;
4735 struct rt2870_txwi *txwi;
4736 struct ieee80211_frame *wh;
4737 struct ieee80211_tx_ampdu *tx_ampdu;
4738 ieee80211_seq seqno;
4739 struct rt2870_softc_tx_radiotap_header *tap;
4740 u_int hdrsize, hdrspace;
4741 uint8_t type, rate, bw, stbc, shortgi, mcs, pid, wcid, mpdu_density, bawin_size;
4742 uint16_t qos, len, dmalen, mpdu_len, dur;
4743 int hasqos, ac, tid, ampdu, mimops;
4744
4745 KASSERT(qid >= 0 && qid < (sc->usb_endpoints - 1),
4746 ("%s: Tx data: invalid qid=%d\n",
4747 device_get_nameunit(sc->dev), qid));
4748
4749 ifp = sc->ifp;
4750 ic = ifp->if_l2com;
4751 vap = ni->ni_vap;
4752 rni = (struct rt2870_softc_node *) ni;
4753 tp = ni->ni_txparms;
4754
4755 ring = &sc->tx_ring[qid];
4756 data = STAILQ_FIRST(&ring->inactive);
4757 STAILQ_REMOVE_HEAD(&ring->inactive, next);
4758 txinfo = (struct rt2870_txinfo *) data->buf;
4759 txwi = (struct rt2870_txwi *) (txinfo + 1);
4760
4761 wh = mtod(m, struct ieee80211_frame *);
4762
4763 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
4764
4765 hasqos = IEEE80211_QOS_HAS_SEQ(wh);
4766 if (hasqos)
4767 {
4768 if (IEEE80211_HAS_ADDR4(wh))
4769 qos = le16toh(*(const uint16_t *)
4770 (((struct ieee80211_qosframe_addr4 *) wh)->i_qos));
4771 else
4772 qos = le16toh(*(const uint16_t *)
4773 (((struct ieee80211_qosframe *) wh)->i_qos));
4774 }
4775 else
4776 {
4777 qos = 0;
4778 }
4779
4780 if (IEEE80211_IS_MULTICAST(wh->i_addr1))
4781 rate = tp->mcastrate;
4782 else if (m->m_flags & M_EAPOL)
4783 rate = tp->mgmtrate;
4784 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
4785 rate = tp->ucastrate;
4786 else
4787 rate = ni->ni_txrate;
4788
4789 rate &= IEEE80211_RATE_VAL;
4790
4791 len = sizeof(struct rt2870_txinfo) + sizeof(struct rt2870_txwi) + m->m_pkthdr.len;
4792
4793 /* align end on a 4-bytes boundary */
4794
4795 dmalen = (len + 3) & ~3;
4796
4797 /* fill Tx info */
4798
4799 memset(txinfo, 0, sizeof(struct rt2870_txinfo));
4800
4801 txinfo->len = htole16(dmalen - sizeof(struct rt2870_txinfo));
4802
4803 txinfo->qsel_flags = (RT2870_TXINFO_QSEL_EDCA << RT2870_TXINFO_QSEL_SHIFT);
4804
4805 dmalen += 4;
4806
4807 memset((caddr_t) txinfo + len, 0, dmalen - len);
4808
4809 /* fill Tx wireless info */
4810
4811 if (ni->ni_flags & IEEE80211_NODE_HT)
4812 mcs = rate;
4813 else
4814 mcs = rt2870_rate2mcs(rate);
4815
4816 if (type == IEEE80211_FC0_TYPE_DATA)
4817 wcid = !IEEE80211_IS_MULTICAST(wh->i_addr1) ? rni->staid : RT2870_WCID_MCAST;
4818 else
4819 wcid = RT2870_WCID_RESERVED;
4820
4821 /* calculate MPDU length without padding */
4822
4823 hdrsize = ieee80211_hdrsize(wh);
4824 hdrspace = ieee80211_hdrspace(ic, wh);
4825 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
4826
4827 memset(txwi, 0, sizeof(struct rt2870_txwi));
4828
4829 txwi->wcid = wcid;
4830
4831 /* MIMO power save */
4832
4833 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_flags & IEEE80211_NODE_MIMO_PS))
4834 {
4835 if (mcs > 7)
4836 {
4837 if (ni->ni_flags & IEEE80211_NODE_MIMO_RTS)
4838 {
4839 /* dynamic MIMO power save */
4840
4841 txwi->mpdu_density_flags |=
4842 (RT2870_TXWI_FLAGS_MIMOPS << RT2870_TXWI_FLAGS_SHIFT);
4843 }
4844 else
4845 {
4846 /* static MIMO power save */
4847
4848 mcs = 7;
4849 }
4850 }
4851
4852 mimops = 1;
4853 }
4854 else
4855 {
4856 mimops = 0;
4857 }
4858
4859 pid = (mcs < 0xf) ? (mcs + 1) : mcs;
4860
4861 txwi->pid_mpdu_len = ((htole16(pid) & RT2870_TXWI_PID_MASK) <<
4862 RT2870_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2870_TXWI_MPDU_LEN_MASK) <<
4863 RT2870_TXWI_MPDU_LEN_SHIFT);
4864
4865 stbc = sc->tx_stbc && (mcs <= 7) && (vap->iv_htcaps & IEEE80211_HTCAP_TXSTBC) &&
4866 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC);
4867
4868 shortgi = ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20) && (ni->ni_flags & IEEE80211_NODE_SGI20) && (ni->ni_chw == 20)) ||
4869 ((vap->iv_flags_ht & IEEE80211_FHT_SHORTGI40) && (ni->ni_flags & IEEE80211_NODE_SGI40) && (ni->ni_chw == 40));
4870
4871 txwi->phymode_ifs_stbc_shortgi |=
4872 ((stbc & RT2870_TXWI_STBC_MASK) << RT2870_TXWI_STBC_SHIFT) |
4873 ((shortgi & RT2870_TXWI_SHORTGI_MASK) << RT2870_TXWI_SHORTGI_SHIFT);
4874
4875 if (ni->ni_flags & IEEE80211_NODE_HT)
4876 {
4877 txwi->phymode_ifs_stbc_shortgi |=
4878 (RT2870_TXWI_PHYMODE_HT_MIXED << RT2870_TXWI_PHYMODE_SHIFT);
4879 }
4880 else
4881 {
4882 if (ieee80211_rate2phytype(ic->ic_rt, rate) != IEEE80211_T_OFDM)
4883 {
4884 txwi->phymode_ifs_stbc_shortgi |=
4885 (RT2870_TXWI_PHYMODE_CCK << RT2870_TXWI_PHYMODE_SHIFT);
4886
4887 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
4888 mcs |= RT2870_TXWI_MCS_SHOTPRE;
4889 }
4890 else
4891 {
4892 txwi->phymode_ifs_stbc_shortgi |=
4893 (RT2870_TXWI_PHYMODE_OFDM << RT2870_TXWI_PHYMODE_SHIFT);
4894 }
4895 }
4896
4897 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_chw == 40))
4898 bw = RT2870_TXWI_BW_40;
4899 else
4900 bw = RT2870_TXWI_BW_20;
4901
4902 txwi->bw_mcs = ((bw & RT2870_TXWI_BW_MASK) << RT2870_TXWI_BW_SHIFT) |
4903 ((mcs & RT2870_TXWI_MCS_MASK) << RT2870_TXWI_MCS_SHIFT);
4904
4905 txwi->txop = (RT2870_TXWI_TXOP_HT << RT2870_TXWI_TXOP_SHIFT);
4906
4907 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
4908 (!hasqos || (qos & IEEE80211_QOS_ACKPOLICY) != IEEE80211_QOS_ACKPOLICY_NOACK))
4909 {
4910 txwi->bawin_size_xflags |=
4911 (RT2870_TXWI_XFLAGS_ACK << RT2870_TXWI_XFLAGS_SHIFT);
4912
4913 if (ni->ni_flags & IEEE80211_NODE_HT)
4914 {
4915 /* preamble + plcp + signal extension + SIFS */
4916
4917 dur = 16 + 4 + 6 + 10;
4918 }
4919 else
4920 {
4921 dur = ieee80211_ack_duration(ic->ic_rt, rate,
4922 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
4923 }
4924
4925 *(uint16_t *) wh->i_dur = htole16(dur);
4926 }
4927
4928 /* check fo A-MPDU */
4929
4930 if (m->m_flags & M_AMPDU_MPDU)
4931 {
4932 ac = M_WME_GETAC(m);
4933 tid = WME_AC_TO_TID(ac);
4934 tx_ampdu = &ni->ni_tx_ampdu[ac];
4935
4936 mpdu_density = RT2870_MS(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY);
4937 bawin_size = tx_ampdu->txa_wnd;
4938
4939 txwi->mpdu_density_flags |=
4940 ((mpdu_density & RT2870_TXWI_MPDU_DENSITY_MASK) << RT2870_TXWI_MPDU_DENSITY_SHIFT) |
4941 (RT2870_TXWI_FLAGS_AMPDU << RT2870_TXWI_FLAGS_SHIFT);
4942
4943 txwi->bawin_size_xflags |=
4944 ((bawin_size & RT2870_TXWI_BAWIN_SIZE_MASK) << RT2870_TXWI_BAWIN_SIZE_SHIFT);
4945
4946 seqno = ni->ni_txseqs[tid]++;
4947
4948 *(uint16_t *) &wh->i_seq[0] = htole16(seqno << IEEE80211_SEQ_SEQ_SHIFT);
4949
4950 ampdu = 1;
4951 }
4952 else
4953 {
4954 mpdu_density = 0;
4955 bawin_size = 0;
4956 ampdu = 0;
4957 }
4958
4959 /* ask MAC to insert timestamp into probe responses */
4960
4961 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
4962 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
4963 txwi->mpdu_density_flags |=
4964 (RT2870_TXWI_FLAGS_TS << RT2870_TXWI_FLAGS_SHIFT);
4965
4966 if (ieee80211_radiotap_active_vap(vap))
4967 {
4968 tap = &sc->txtap;
4969
4970 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
4971 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
4972 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
4973 tap->chan_ieee = ic->ic_curchan->ic_ieee;
4974 tap->chan_maxpow = 0;
4975
4976 if (ni->ni_flags & IEEE80211_NODE_HT)
4977 tap->rate = mcs | IEEE80211_RATE_MCS;
4978 else
4979 tap->rate = rate;
4980
4981 if (mcs & RT2870_TXWI_MCS_SHOTPRE)
4982 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4983
4984 if (shortgi)
4985 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4986
4987 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4988 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4989
4990 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4991 {
4992 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4993
4994 ieee80211_radiotap_tx(vap, m);
4995
4996 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4997 }
4998 else
4999 {
5000 ieee80211_radiotap_tx(vap, m);
5001 }
5002 }
5003
5004 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t) (txwi + 1));
5005
5006 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
5007 "%s: sending data: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
5008 "bw=%d, stbc=%d, shortgi=%d, mcs=%d, wcid=0x%02x, "
5009 "ampdu=%d (density=%d, winsize=%d), mimops=%d, DMA len=%d\n",
5010 device_get_nameunit(sc->dev),
5011 qid, hdrsize, hdrspace, m->m_pkthdr.len,
5012 bw, stbc, shortgi, mcs, wcid,
5013 ampdu, mpdu_density, bawin_size, mimops, dmalen);
5014
5015 data->len = dmalen;
5016 data->m = m;
5017 data->ni = ni;
5018
5019 STAILQ_INSERT_TAIL(&ring->pending, data, next);
5020 ring->queued++;
5021
5022 usbd_transfer_start(sc->usb_xfer[1 + qid]);
5023
5024 return 0;
5025 }
5026
5027 /*
5028 * rt2870_tx_raw
5029 */
5030 static int rt2870_tx_raw(struct rt2870_softc *sc,
5031 struct mbuf *m, struct ieee80211_node *ni,
5032 const struct ieee80211_bpf_params *params)
5033 {
5034 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
5035 "%s: Tx raw\n",
5036 device_get_nameunit(sc->dev));
5037
5038 return 0;
5039 }
5040
5041 /*
5042 * rt2870_rx_intr
5043 */
5044 static void rt2870_rx_intr(struct usb_xfer *xfer, usb_error_t error)
5045 {
5046 struct rt2870_softc *sc;
5047 struct ifnet *ifp;
5048 struct rt2870_softc_rx_ring *ring;
5049 struct rt2870_softc_rx_data *data;
5050 int len;
5051
5052 sc = usbd_xfer_softc(xfer);
5053 ifp = sc->ifp;
5054 ring = &sc->rx_ring;
5055
5056 RT2870_DPRINTF(sc, RT2870_DEBUG_INTR,
5057 "%s: Rx interrupt: state=%d, error=%s\n",
5058 device_get_nameunit(sc->dev),
5059 USB_GET_STATE(xfer), usbd_errstr(error));
5060
5061 switch (USB_GET_STATE(xfer))
5062 {
5063 case USB_ST_TRANSFERRED:
5064 sc->interrupts++;
5065 sc->rx_interrupts++;
5066
5067 data = STAILQ_FIRST(&ring->active);
5068 if (data == NULL)
5069 goto setup;
5070
5071 STAILQ_REMOVE_HEAD(&ring->active, next);
5072
5073 usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5074
5075 data->len = len;
5076
5077 STAILQ_INSERT_TAIL(&ring->done, data, next);
5078
5079 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
5080
5081 /* FALLTHROUGH */
5082
5083 setup:
5084
5085 case USB_ST_SETUP:
5086 data = STAILQ_FIRST(&ring->inactive);
5087 if (data == NULL)
5088 break;
5089
5090 STAILQ_REMOVE_HEAD(&ring->inactive, next);
5091
5092 STAILQ_INSERT_TAIL(&ring->active, data, next);
5093
5094 usbd_xfer_set_frame_data(xfer, 0, data->buf, usbd_xfer_max_len(xfer));
5095 usbd_transfer_submit(xfer);
5096 break;
5097
5098 default:
5099 sc->interrupts++;
5100 sc->rx_interrupts++;
5101
5102 data = STAILQ_FIRST(&ring->active);
5103 if (data != NULL)
5104 {
5105 STAILQ_REMOVE_HEAD(&ring->active, next);
5106 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5107 }
5108
5109 if (error != USB_ERR_CANCELLED)
5110 {
5111 ifp->if_ierrors++;
5112
5113 usbd_xfer_set_stall(xfer);
5114
5115 goto setup;
5116 }
5117 break;
5118 }
5119 }
5120
5121 /*
5122 * rt2870_tx_intr
5123 */
5124 static void rt2870_tx_intr(struct usb_xfer *xfer, usb_error_t error)
5125 {
5126 struct rt2870_softc *sc;
5127 struct ifnet *ifp;
5128 struct rt2870_softc_tx_ring *ring;
5129 struct rt2870_softc_tx_data *data;
5130
5131 sc = usbd_xfer_softc(xfer);
5132 ifp = sc->ifp;
5133 ring = usbd_xfer_get_priv(xfer);
5134
5135 usbd_xfer_status(xfer, NULL, NULL, NULL, NULL);
5136
5137 RT2870_DPRINTF(sc, RT2870_DEBUG_INTR,
5138 "%s: Tx interrupt: state=%d, error=%s\n",
5139 device_get_nameunit(sc->dev),
5140 USB_GET_STATE(xfer), usbd_errstr(error));
5141
5142 switch (USB_GET_STATE(xfer))
5143 {
5144 case USB_ST_TRANSFERRED:
5145 sc->interrupts++;
5146 sc->tx_interrupts[ring->qid]++;
5147
5148 data = STAILQ_FIRST(&ring->active);
5149 if (data == NULL)
5150 goto setup;
5151
5152 STAILQ_REMOVE_HEAD(&ring->active, next);
5153
5154 STAILQ_INSERT_TAIL(&ring->done, data, next);
5155
5156 sc->tx_qid_pending_mask |= (1 << ring->qid);
5157
5158 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
5159
5160 /* FALLTHROUGH */
5161
5162 setup:
5163
5164 case USB_ST_SETUP:
5165 data = STAILQ_FIRST(&ring->pending);
5166 if (data == NULL)
5167 break;
5168
5169 STAILQ_REMOVE_HEAD(&ring->pending, next);
5170 STAILQ_INSERT_TAIL(&ring->active, data, next);
5171
5172 usbd_xfer_set_frame_data(xfer, 0, data->buf, data->len);
5173 usbd_transfer_submit(xfer);
5174
5175 RT2870_SOFTC_UNLOCK(sc);
5176
5177 rt2870_start(ifp);
5178
5179 RT2870_SOFTC_LOCK(sc);
5180 break;
5181
5182 default:
5183 sc->interrupts++;
5184 sc->tx_interrupts[ring->qid]++;
5185
5186 data = STAILQ_FIRST(&ring->active);
5187 if (data != NULL)
5188 {
5189 STAILQ_REMOVE_HEAD(&ring->active, next);
5190
5191 printf("%s: could not transmit buffer: qid=%d, error=%s\n",
5192 device_get_nameunit(sc->dev), ring->qid, usbd_errstr(error));
5193
5194 if (data->m != NULL)
5195 {
5196 m_freem(data->m);
5197 data->m = NULL;
5198 }
5199
5200 if (data->ni != NULL)
5201 {
5202 ieee80211_free_node(data->ni);
5203 data->ni = NULL;
5204 }
5205
5206 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5207
5208 ring->queued--;
5209 }
5210
5211 if (error != USB_ERR_CANCELLED)
5212 {
5213 ifp->if_oerrors++;
5214 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
5215
5216 usbd_xfer_set_stall(xfer);
5217
5218 goto setup;
5219 }
5220 break;
5221 }
5222 }
5223
5224 /*
5225 * rt2870_rx_done_task
5226 */
5227 static void rt2870_rx_done_task(void *context, int pending)
5228 {
5229 struct rt2870_softc *sc;
5230 struct ifnet *ifp;
5231
5232 sc = context;
5233 ifp = sc->ifp;
5234
5235 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
5236 "%s: Rx done task\n",
5237 device_get_nameunit(sc->dev));
5238
5239 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
5240 return;
5241
5242 if (rt2870_rx_eof(sc, sc->rx_process_limit) != 0)
5243 {
5244 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
5245 "%s: Rx done task: scheduling again\n",
5246 device_get_nameunit(sc->dev));
5247
5248 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
5249 }
5250 }
5251
5252 /*
5253 * rt2870_tx_done_task
5254 */
5255 static void rt2870_tx_done_task(void *context, int pending)
5256 {
5257 struct rt2870_softc *sc;
5258 struct ifnet *ifp;
5259 int i;
5260
5261 sc = context;
5262 ifp = sc->ifp;
5263
5264 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
5265 "%s: Tx done task\n",
5266 device_get_nameunit(sc->dev));
5267
5268 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
5269 return;
5270
5271 for (i = sc->usb_endpoints - 2; i >= 0; i--)
5272 {
5273 if (sc->tx_qid_pending_mask & (1 << i))
5274 {
5275 sc->tx_qid_pending_mask &= ~(1 << i);
5276
5277 rt2870_tx_eof(sc, &sc->tx_ring[i]);
5278 }
5279 }
5280
5281 if (sc->tx_qid_pending_mask != 0)
5282 {
5283 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
5284 "%s: Tx done task: scheduling again\n",
5285 device_get_nameunit(sc->dev));
5286
5287 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
5288 }
5289
5290 sc->tx_timer = 0;
5291
5292 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
5293 }
5294
5295 /*
5296 * rt2870_periodic_task
5297 */
5298 static void rt2870_periodic_task(void *context, int pending)
5299 {
5300 struct rt2870_softc *sc;
5301 struct ifnet *ifp;
5302 struct ieee80211com *ic;
5303 struct ieee80211vap *vap;
5304
5305 sc = context;
5306 ifp = sc->ifp;
5307 ic = ifp->if_l2com;
5308 vap = TAILQ_FIRST(&ic->ic_vaps);
5309
5310 RT2870_DPRINTF(sc, RT2870_DEBUG_PERIODIC,
5311 "%s: periodic task: round=%lu\n",
5312 device_get_nameunit(sc->dev), sc->periodic_round);
5313
5314 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
5315 return;
5316
5317 RT2870_SOFTC_LOCK(sc);
5318
5319 sc->periodic_round++;
5320
5321 rt2870_update_stats(sc);
5322
5323 if ((sc->periodic_round % 10) == 0)
5324 {
5325 rt2870_bbp_tuning(sc);
5326
5327 rt2870_update_raw_counters(sc);
5328
5329 rt2870_watchdog(sc);
5330
5331 if (vap != NULL && vap->iv_opmode != IEEE80211_M_MONITOR && vap->iv_state == IEEE80211_S_RUN)
5332 {
5333 if (vap->iv_opmode == IEEE80211_M_STA)
5334 rt2870_amrr_update_iter_func(vap, vap->iv_bss);
5335 else
5336 ieee80211_iterate_nodes(&ic->ic_sta, rt2870_amrr_update_iter_func, vap);
5337 }
5338 }
5339
5340 RT2870_SOFTC_UNLOCK(sc);
5341
5342 callout_reset(&sc->periodic_ch, hz / 10, rt2870_periodic, sc);
5343 }
5344
5345 /*
5346 * rt2870_cmd_task
5347 */
5348 static void rt2870_cmd_task(void *context, int pending)
5349 {
5350 struct rt2870_softc *sc;
5351 struct rt2870_softc_cmd_ring *ring;
5352 struct rt2870_softc_cmd *cmd;
5353
5354 sc = context;
5355 ring = &sc->cmd_ring;
5356
5357 if (!(sc->flags & RT2870_SOFTC_FLAGS_VALID))
5358 return;
5359
5360 while (1)
5361 {
5362 RT2870_SOFTC_LOCK(sc);
5363
5364 cmd = STAILQ_FIRST(&ring->active);
5365 if (cmd == NULL)
5366 {
5367 RT2870_SOFTC_UNLOCK(sc);
5368 break;
5369 }
5370
5371 STAILQ_REMOVE_HEAD(&ring->active, next);
5372
5373 RT2870_SOFTC_UNLOCK(sc);
5374
5375 cmd->cb(sc, cmd->data);
5376
5377 RT2870_SOFTC_LOCK(sc);
5378
5379 STAILQ_INSERT_TAIL(&ring->inactive, cmd, next);
5380 ring->queued--;
5381
5382 RT2870_SOFTC_UNLOCK(sc);
5383 }
5384 }
5385
5386 /*
5387 * rt2870_rx_eof
5388 */
5389 static int rt2870_rx_eof(struct rt2870_softc *sc, int limit)
5390 {
5391 struct ifnet *ifp;
5392 struct rt2870_softc_rx_ring *ring;
5393 struct rt2870_softc_rx_data *data;
5394 uint32_t dmalen;
5395 uint8_t *buf;
5396 int nframes, len;
5397
5398 ifp = sc->ifp;
5399 ring = &sc->rx_ring;
5400
5401 nframes = 0;
5402
5403 while (limit != 0)
5404 {
5405 RT2870_SOFTC_LOCK(sc);
5406
5407 data = STAILQ_FIRST(&ring->done);
5408 if (data == NULL)
5409 {
5410 RT2870_SOFTC_UNLOCK(sc);
5411 break;
5412 }
5413
5414 STAILQ_REMOVE_HEAD(&ring->done, next);
5415
5416 RT2870_SOFTC_UNLOCK(sc);
5417
5418 buf = data->buf;
5419 len = data->len;
5420
5421 if (len < RT2870_RX_DESC_SIZE)
5422 {
5423 ifp->if_ierrors++;
5424 goto skip;
5425 }
5426
5427 while (len > (sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)))
5428 {
5429 dmalen = (le32toh(*(uint32_t *) buf) & 0xffff);
5430
5431 if (dmalen == 0 || (dmalen & 3) != 0)
5432 {
5433 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
5434 "%s: bad DMA len=%u\n",
5435 device_get_nameunit(sc->dev), dmalen);
5436 goto skip;
5437 }
5438
5439 if ((dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)) > len)
5440 {
5441 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
5442 "%s: bad DMA len: DMA len=%u, USB len=%d\n",
5443 device_get_nameunit(sc->dev),
5444 (unsigned int) (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo)), len);
5445 goto skip;
5446 }
5447
5448 nframes++;
5449
5450 rt2870_rx_frame(sc, buf + sizeof(uint32_t), dmalen);
5451
5452 buf += (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo));
5453 len -= (dmalen + sizeof(uint32_t) + sizeof(struct rt2870_rxinfo));
5454 }
5455
5456 skip:
5457
5458 RT2870_SOFTC_LOCK(sc);
5459
5460 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5461
5462 usbd_transfer_start(sc->usb_xfer[0]);
5463
5464 RT2870_SOFTC_UNLOCK(sc);
5465
5466 limit--;
5467 }
5468
5469 RT2870_DPRINTF(sc, RT2870_DEBUG_RX,
5470 "%s: Rx eof: nframes=%d\n",
5471 device_get_nameunit(sc->dev), nframes);
5472
5473 sc->rx_packets += nframes;
5474
5475 return (limit == 0);
5476 }
5477
5478 /*
5479 * rt2870_tx_eof
5480 */
5481 static void rt2870_tx_eof(struct rt2870_softc *sc,
5482 struct rt2870_softc_tx_ring *ring)
5483 {
5484 struct ifnet *ifp;
5485 struct rt2870_softc_tx_data *data;
5486 int nframes;
5487
5488 ifp = sc->ifp;
5489
5490 nframes = 0;
5491
5492 while (1)
5493 {
5494 RT2870_SOFTC_LOCK(sc);
5495
5496 data = STAILQ_FIRST(&ring->done);
5497 if (data == NULL)
5498 {
5499 RT2870_SOFTC_UNLOCK(sc);
5500 break;
5501 }
5502
5503 STAILQ_REMOVE_HEAD(&ring->done, next);
5504
5505 rt2870_drain_fifo_stats(sc);
5506
5507 RT2870_SOFTC_UNLOCK(sc);
5508
5509 nframes++;
5510
5511 if (data->m->m_flags & M_TXCB)
5512 ieee80211_process_callback(data->ni, data->m, 0);
5513
5514 m_freem(data->m);
5515
5516 ieee80211_free_node(data->ni);
5517
5518 data->m = NULL;
5519 data->ni = NULL;
5520
5521 RT2870_SOFTC_LOCK(sc);
5522
5523 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5524
5525 ring->queued--;
5526 ifp->if_opackets++;
5527
5528 RT2870_SOFTC_UNLOCK(sc);
5529 }
5530
5531 RT2870_DPRINTF(sc, RT2870_DEBUG_TX,
5532 "%s: Tx eof: qid=%d, nframes=%d\n",
5533 device_get_nameunit(sc->dev), ring->qid, nframes);
5534 }
5535
5536 /*
5537 * rt2870_update_stats
5538 */
5539 static void rt2870_update_stats(struct rt2870_softc *sc)
5540 {
5541 struct ifnet *ifp;
5542 struct ieee80211com *ic;
5543 uint32_t stacnt[3];
5544 int beacons, noretryok, retryok, failed, underflows, zerolen;
5545
5546 ifp = sc->ifp;
5547 ic = ifp->if_l2com;
5548
5549 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
5550 "%s: update statistic\n",
5551 device_get_nameunit(sc->dev));
5552
5553 rt2870_drain_fifo_stats(sc);
5554
5555 /* read and clear Tx statistic registers */
5556
5557 rt2870_io_mac_read_multi(sc, RT2870_REG_TX_STA_CNT0,
5558 stacnt, sizeof(stacnt));
5559
5560 stacnt[0] = le32toh(stacnt[0]);
5561 stacnt[1] = le32toh(stacnt[1]);
5562 stacnt[2] = le32toh(stacnt[2]);
5563
5564 beacons = stacnt[0] >> 16;
5565 noretryok = stacnt[1] & 0xffff;
5566 retryok = stacnt[1] >> 16;
5567 failed = stacnt[0] & 0xffff;
5568 underflows = stacnt[2] >> 16;
5569 zerolen = stacnt[2] & 0xffff;
5570
5571 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
5572 "%s: update statistic: beacons=%d, noretryok=%d, retryok=%d, failed=%d, underflows=%d, zerolen=%d\n",
5573 device_get_nameunit(sc->dev),
5574 beacons, noretryok, retryok, failed, underflows, zerolen);
5575
5576 ifp->if_oerrors += failed;
5577
5578 sc->tx_beacons += beacons;
5579 sc->tx_noretryok += noretryok;
5580 sc->tx_retryok += retryok;
5581 sc->tx_failed += failed;
5582 sc->tx_underflows += underflows;
5583 sc->tx_zerolen += zerolen;
5584 }
5585
5586 /*
5587 * rt2870_bbp_tuning
5588 */
5589 static void rt2870_bbp_tuning(struct rt2870_softc *sc)
5590 {
5591 struct ifnet *ifp;
5592 struct ieee80211com *ic;
5593 struct ieee80211vap *vap;
5594 struct ieee80211_node *ni;
5595 int chan, group;
5596 int8_t rssi, old, new;
5597
5598 /* RT2860C does not support BBP tuning */
5599
5600 if (sc->mac_rev == 0x28600100)
5601 return;
5602
5603 ifp = sc->ifp;
5604 ic = ifp->if_l2com;
5605 vap = TAILQ_FIRST(&ic->ic_vaps);
5606
5607 if ((ic->ic_flags & IEEE80211_F_SCAN) || vap == NULL ||
5608 vap->iv_opmode != IEEE80211_M_STA || vap->iv_state != IEEE80211_S_RUN)
5609 return;
5610
5611 ni = vap->iv_bss;
5612
5613 chan = ieee80211_chan2ieee(ic, ni->ni_chan);
5614
5615 if (chan <= 14)
5616 group = 0;
5617 else if (chan <= 64)
5618 group = 1;
5619 else if (chan <= 128)
5620 group = 2;
5621 else
5622 group = 3;
5623
5624 rssi = ieee80211_getrssi(vap);
5625
5626 if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan))
5627 {
5628 new = 0x2e + sc->lna_gain[group];
5629 }
5630 else
5631 {
5632 if (!IEEE80211_IS_CHAN_HT40(ni->ni_chan))
5633 new = 0x32 + sc->lna_gain[group] * 5 / 3;
5634 else
5635 new = 0x3a + sc->lna_gain[group] * 5 / 3;
5636 }
5637
5638 /* Tune if absolute average RSSI is greater than -80 */
5639
5640 if (rssi > 30)
5641 new += 0x10;
5642
5643 old = rt2870_io_bbp_read(sc, 66);
5644
5645 if (old != new)
5646 rt2870_io_bbp_write(sc, 66, new);
5647 }
5648
5649 /*
5650 * rt2870_watchdog
5651 */
5652 static void rt2870_watchdog(struct rt2870_softc *sc)
5653 {
5654 uint32_t tmp;
5655 int ntries;
5656
5657 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
5658
5659 RT2870_DPRINTF(sc, RT2870_DEBUG_WATCHDOG,
5660 "%s: watchdog: TXRXQ_PCNT=0x%08x\n",
5661 device_get_nameunit(sc->dev), tmp);
5662
5663 if (((tmp >> RT2870_REG_TX0Q_PCNT_SHIFT) & RT2870_REG_TX0Q_PCNT_MASK) != 0)
5664 {
5665 sc->tx_queue_not_empty[0]++;
5666
5667 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40012);
5668
5669 for (ntries = 0; ntries < 10; ntries++)
5670 {
5671 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
5672 if (((tmp >> RT2870_REG_TX0Q_PCNT_SHIFT) & RT2870_REG_TX0Q_PCNT_MASK) == 0)
5673 break;
5674
5675 DELAY(1);
5676 }
5677
5678 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40006);
5679 }
5680
5681 if (((tmp >> RT2870_REG_TX1Q_PCNT_SHIFT) & RT2870_REG_TX1Q_PCNT_MASK) != 0)
5682 {
5683 sc->tx_queue_not_empty[1]++;
5684
5685 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf4000a);
5686
5687 for (ntries = 0; ntries < 10; ntries++)
5688 {
5689 tmp = rt2870_io_mac_read(sc, RT2870_REG_PBF_TXRXQ_PCNT);
5690 if (((tmp >> RT2870_REG_TX1Q_PCNT_SHIFT) & RT2870_REG_TX1Q_PCNT_MASK) == 0)
5691 break;
5692
5693 DELAY(1);
5694 }
5695
5696 rt2870_io_mac_write(sc, RT2870_REG_PBF_CFG, 0xf40006);
5697 }
5698 }
5699
5700 /*
5701 * rt2870_drain_fifo_stats
5702 */
5703 static void rt2870_drain_fifo_stats(struct rt2870_softc *sc)
5704 {
5705 struct ifnet *ifp;
5706 uint32_t stats;
5707 uint8_t wcid, mcs, pid;
5708 int ok, agg, retrycnt;
5709
5710 ifp = sc->ifp;
5711
5712 /* drain Tx status FIFO (maxsize = 16) */
5713
5714 while ((sc->flags & RT2870_SOFTC_FLAGS_VALID) &&
5715 ((stats = rt2870_io_mac_read(sc, RT2870_REG_TX_STA_FIFO)) &
5716 RT2870_REG_TX_STA_FIFO_VALID))
5717 {
5718 wcid = (stats >> RT2870_REG_TX_STA_FIFO_WCID_SHIFT) &
5719 RT2870_REG_TX_STA_FIFO_WCID_MASK;
5720
5721 /* if no ACK was requested, no feedback is available */
5722
5723 if (!(stats & RT2870_REG_TX_STA_FIFO_ACK_REQ) || wcid == RT2870_WCID_RESERVED)
5724 continue;
5725
5726 /* update AMRR statistic */
5727
5728 ok = (stats & RT2870_REG_TX_STA_FIFO_TX_OK) ? 1 : 0;
5729 agg = (stats & RT2870_REG_TX_STA_FIFO_AGG) ? 1 : 0;
5730 mcs = (stats >> RT2870_REG_TX_STA_FIFO_MCS_SHIFT) &
5731 RT2870_REG_TX_STA_FIFO_MCS_MASK;
5732 pid = (stats >> RT2870_REG_TX_STA_FIFO_PID_SHIFT) &
5733 RT2870_REG_TX_STA_FIFO_PID_MASK;
5734 retrycnt = (mcs < 0xf) ? (pid - mcs - 1) : 0;
5735
5736 RT2870_DPRINTF(sc, RT2870_DEBUG_STATS,
5737 "%s: FIFO statistic: wcid=0x%02x, ok=%d, agg=%d, mcs=0x%02x, pid=0x%02x, retrycnt=%d\n",
5738 device_get_nameunit(sc->dev),
5739 wcid, ok, agg, mcs, pid, retrycnt);
5740
5741 rt2870_amrr_tx_complete(&sc->amrr_node[wcid], ok, retrycnt);
5742
5743 if (!ok)
5744 ifp->if_oerrors++;
5745 }
5746 }
5747
5748 /*
5749 * rt2870_update_raw_counters
5750 */
5751 static void rt2870_update_raw_counters(struct rt2870_softc *sc)
5752 {
5753 uint32_t tmp;
5754
5755 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT);
5756
5757 sc->tx_nonagg += tmp & 0xffff;
5758 sc->tx_agg += tmp >> 16;
5759
5760 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT0);
5761
5762 sc->tx_ampdu += (tmp & 0xffff) / 1 + (tmp >> 16) / 2;
5763
5764 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT1);
5765
5766 sc->tx_ampdu += (tmp & 0xffff) / 3 + (tmp >> 16) / 4;
5767
5768 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT2);
5769
5770 sc->tx_ampdu += (tmp & 0xffff) / 5 + (tmp >> 16) / 6;
5771
5772 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT3);
5773
5774 sc->tx_ampdu += (tmp & 0xffff) / 7 + (tmp >> 16) / 8;
5775
5776 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT4);
5777
5778 sc->tx_ampdu += (tmp & 0xffff) / 9 + (tmp >> 16) / 10;
5779
5780 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT5);
5781
5782 sc->tx_ampdu += (tmp & 0xffff) / 11 + (tmp >> 16) / 12;
5783
5784 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT6);
5785
5786 sc->tx_ampdu += (tmp & 0xffff) / 13 + (tmp >> 16) / 14;
5787
5788 tmp = rt2870_io_mac_read(sc, RT2870_REG_TX_AGG_CNT7);
5789
5790 sc->tx_ampdu += (tmp & 0xffff) / 15 + (tmp >> 16) / 16;
5791
5792 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT0);
5793
5794 sc->rx_crc_errors += tmp & 0xffff;
5795 sc->rx_phy_errors += tmp >> 16;
5796
5797 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT1);
5798
5799 sc->rx_false_ccas += tmp & 0xffff;
5800 sc->rx_plcp_errors += tmp >> 16;
5801
5802 tmp = rt2870_io_mac_read(sc, RT2870_REG_RX_STA_CNT2);
5803
5804 sc->rx_dup_packets += tmp & 0xffff;
5805 sc->rx_fifo_overflows += tmp >> 16;
5806
5807 tmp = rt2870_io_mac_read(sc, RT2870_REG_TXRX_MPDU_DEN_CNT);
5808
5809 sc->tx_mpdu_zero_density += tmp & 0xffff;
5810 sc->rx_mpdu_zero_density += tmp >> 16;
5811 }
5812
5813 /*
5814 * rt2870_txrx_enable
5815 */
5816 static int rt2870_txrx_enable(struct rt2870_softc *sc)
5817 {
5818 struct ieee80211com *ic;
5819 struct ifnet *ifp;
5820 uint32_t tmp;
5821 int ntries;
5822
5823 ifp = sc->ifp;
5824 ic = ifp->if_l2com;
5825
5826 /* enable Tx/Rx DMA engine */
5827
5828 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_USB_CYC_CFG);
5829
5830 tmp &= 0xffffff00;
5831 tmp |= 0x1e;
5832
5833 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_CYC_CFG, tmp);
5834
5835 if ((sc->mac_rev & 0xffff) != 0x0101)
5836 rt2870_io_mac_write(sc, RT2870_REG_TX_TXOP_CTRL_CFG, 0x583f);
5837
5838 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL, RT2870_REG_TX_ENABLE);
5839
5840 for (ntries = 0; ntries < 200; ntries++)
5841 {
5842 tmp = rt2870_io_mac_read(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG);
5843 if (!(tmp & (RT2870_REG_TX_DMA_BUSY | RT2870_REG_RX_DMA_BUSY)))
5844 break;
5845
5846 DELAY(1000);
5847 }
5848
5849 if (ntries == 200)
5850 {
5851 printf("%s: timeout waiting for DMA engine\n",
5852 device_get_nameunit(sc->dev));
5853 return -1;
5854 }
5855
5856 DELAY(50);
5857
5858 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP0_CFG, 0);
5859 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WMM_TXOP1_CFG,
5860 (48 << 16) | 96);
5861
5862 tmp |= RT2870_REG_TX_WB_DDONE |
5863 RT2870_REG_RX_DMA_ENABLE |
5864 RT2870_REG_TX_DMA_ENABLE;
5865
5866 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
5867
5868 tmp = RT2870_REG_USB_DMA_TX_ENABLE |
5869 RT2870_REG_USB_DMA_RX_ENABLE |
5870 RT2870_REG_USB_DMA_RX_AGG_ENABLE |
5871 /* Rx agg limit in unit of 1024 byte */
5872 ((RT2870_USB_RX_BULK_BUFLEN / 1024 - 3) << RT2870_REG_USB_DMA_RX_AGG_LIMIT_SHIFT) |
5873 /* Rx agg timeout in unit of 33ns */
5874 0x80;
5875
5876 rt2870_io_mac_write(sc, RT2870_REG_SCHDMA_USB_DMA_CFG, tmp);
5877
5878 /* set Rx filter */
5879
5880 tmp = RT2870_REG_RX_FILTER_DROP_CRC_ERR |
5881 RT2870_REG_RX_FILTER_DROP_PHY_ERR;
5882
5883 if (ic->ic_opmode != IEEE80211_M_MONITOR)
5884 {
5885 tmp |= RT2870_REG_RX_FILTER_DROP_DUPL |
5886 RT2870_REG_RX_FILTER_DROP_CTS |
5887 RT2870_REG_RX_FILTER_DROP_BA |
5888 RT2870_REG_RX_FILTER_DROP_ACK |
5889 RT2870_REG_RX_FILTER_DROP_VER_ERR |
5890 RT2870_REG_RX_FILTER_DROP_CTRL_RSV |
5891 RT2870_REG_RX_FILTER_DROP_CFACK |
5892 RT2870_REG_RX_FILTER_DROP_CFEND;
5893
5894 if (ic->ic_opmode == IEEE80211_M_STA)
5895 tmp |= RT2870_REG_RX_FILTER_DROP_RTS |
5896 RT2870_REG_RX_FILTER_DROP_PSPOLL;
5897
5898 if (!(ifp->if_flags & IFF_PROMISC))
5899 tmp |= RT2870_REG_RX_FILTER_DROP_UC_NOME;
5900 }
5901
5902 rt2870_io_mac_write(sc, RT2870_REG_RX_FILTER_CFG, tmp);
5903
5904 rt2870_io_mac_write(sc, RT2870_REG_SYS_CTRL,
5905 RT2870_REG_RX_ENABLE | RT2870_REG_TX_ENABLE);
5906
5907 return 0;
5908 }
5909
5910 /*
5911 * rt2870_alloc_rx_ring
5912 */
5913 static int rt2870_alloc_rx_ring(struct rt2870_softc *sc,
5914 struct rt2870_softc_rx_ring *ring)
5915 {
5916 struct rt2870_softc_rx_data *data;
5917 int i, error;
5918
5919 STAILQ_INIT(&ring->inactive);
5920 STAILQ_INIT(&ring->active);
5921 STAILQ_INIT(&ring->done);
5922
5923 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5924 {
5925 data = &ring->data[i];
5926
5927 data->buf = malloc(RT2870_USB_RX_BULK_BUFLEN, M_USBDEV, M_NOWAIT);
5928 if (data->buf == NULL)
5929 {
5930 printf("%s: could not allocate Rx buffer\n",
5931 device_get_nameunit(sc->dev));
5932 error = ENOMEM;
5933 goto fail;
5934 }
5935
5936 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5937 }
5938
5939 return 0;
5940
5941 fail:
5942
5943 rt2870_free_rx_ring(sc, ring);
5944
5945 return error;
5946 }
5947
5948 /*
5949 * rt2870_reset_rx_ring
5950 */
5951 static void rt2870_reset_rx_ring(struct rt2870_softc *sc,
5952 struct rt2870_softc_rx_ring *ring)
5953 {
5954 struct rt2870_softc_rx_data *data;
5955 int i;
5956
5957 STAILQ_INIT(&ring->inactive);
5958 STAILQ_INIT(&ring->active);
5959 STAILQ_INIT(&ring->done);
5960
5961 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5962 {
5963 data = &ring->data[i];
5964
5965 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
5966 }
5967 }
5968
5969 /*
5970 * rt2870_free_rx_ring
5971 */
5972 static void rt2870_free_rx_ring(struct rt2870_softc *sc,
5973 struct rt2870_softc_rx_ring *ring)
5974 {
5975 struct rt2870_softc_rx_data *data;
5976 int i;
5977
5978 for (i = 0; i < RT2870_SOFTC_RX_RING_DATA_COUNT; i++)
5979 {
5980 data = &ring->data[i];
5981
5982 if (data->buf != NULL)
5983 {
5984 free(data->buf, M_USBDEV);
5985 data->buf = NULL;
5986 }
5987 }
5988 }
5989
5990 /*
5991 * rt2870_alloc_tx_ring
5992 */
5993 static int rt2870_alloc_tx_ring(struct rt2870_softc *sc,
5994 struct rt2870_softc_tx_ring *ring, int qid)
5995 {
5996 struct rt2870_softc_tx_data *data;
5997 int i, error;
5998
5999 STAILQ_INIT(&ring->inactive);
6000 STAILQ_INIT(&ring->pending);
6001 STAILQ_INIT(&ring->active);
6002 STAILQ_INIT(&ring->done);
6003
6004 ring->queued = 0;
6005 ring->qid = qid;
6006
6007 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
6008 {
6009 data = &ring->data[i];
6010
6011 data->buf = malloc(RT2870_TX_DESC_SIZE + MJUMPAGESIZE, M_USBDEV, M_NOWAIT);
6012 if (data->buf == NULL)
6013 {
6014 printf("%s: could not allocate Tx buffer\n",
6015 device_get_nameunit(sc->dev));
6016 error = ENOMEM;
6017 goto fail;
6018 }
6019
6020 memset(data->buf, 0, RT2870_TX_DESC_SIZE);
6021
6022 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
6023 }
6024
6025 return 0;
6026
6027 fail:
6028
6029 rt2870_free_tx_ring(sc, ring);
6030
6031 return error;
6032 }
6033
6034 /*
6035 * rt2870_reset_tx_ring
6036 */
6037 static void rt2870_reset_tx_ring(struct rt2870_softc *sc,
6038 struct rt2870_softc_tx_ring *ring)
6039 {
6040 struct rt2870_softc_tx_data *data;
6041 int i;
6042
6043 STAILQ_INIT(&ring->inactive);
6044 STAILQ_INIT(&ring->pending);
6045 STAILQ_INIT(&ring->active);
6046 STAILQ_INIT(&ring->done);
6047
6048 ring->queued = 0;
6049
6050 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
6051 {
6052 data = &ring->data[i];
6053
6054 if (data->m != NULL)
6055 {
6056 m_free(data->m);
6057 data->m = NULL;
6058 }
6059
6060 if (data->ni != NULL)
6061 {
6062 ieee80211_free_node(data->ni);
6063 data->ni = NULL;
6064 }
6065
6066 STAILQ_INSERT_TAIL(&ring->inactive, data, next);
6067 }
6068 }
6069
6070 /*
6071 * rt2870_free_tx_ring
6072 */
6073 static void rt2870_free_tx_ring(struct rt2870_softc *sc,
6074 struct rt2870_softc_tx_ring *ring)
6075 {
6076 struct rt2870_softc_tx_data *data;
6077 int i;
6078
6079 for (i = 0; i < RT2870_SOFTC_TX_RING_DATA_COUNT; i++)
6080 {
6081 data = &ring->data[i];
6082
6083 if (data->buf != NULL)
6084 {
6085 free(data->buf, M_USBDEV);
6086 data->buf = NULL;
6087 }
6088
6089 if (data->m != NULL)
6090 {
6091 m_free(data->m);
6092 data->m = NULL;
6093 }
6094
6095 if (data->ni != NULL)
6096 {
6097 ieee80211_free_node(data->ni);
6098 data->ni = NULL;
6099 }
6100 }
6101 }
6102
6103 /*
6104 * rt2870_reset_cmd_ring
6105 */
6106 static void rt2870_reset_cmd_ring(struct rt2870_softc *sc,
6107 struct rt2870_softc_cmd_ring *ring)
6108 {
6109 struct rt2870_softc_cmd *cmd;
6110 int i;
6111
6112 STAILQ_INIT(&ring->inactive);
6113 STAILQ_INIT(&ring->active);
6114
6115 ring->queued = 0;
6116
6117 for (i = 0; i < RT2870_SOFTC_CMD_RING_CMD_COUNT; i++)
6118 {
6119 cmd = &ring->cmd[i];
6120
6121 STAILQ_INSERT_TAIL(&ring->inactive, cmd, next);
6122 }
6123 }
6124
6125 /*
6126 * rt2870_sysctl_attach
6127 */
6128 static void rt2870_sysctl_attach(struct rt2870_softc *sc)
6129 {
6130 struct sysctl_ctx_list *ctx;
6131 struct sysctl_oid *tree;
6132 struct sysctl_oid *stats;
6133
6134 ctx = device_get_sysctl_ctx(sc->dev);
6135 tree = device_get_sysctl_tree(sc->dev);
6136
6137 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
6138 "tx_stbc", CTLFLAG_RW, &sc->tx_stbc, 0,
6139 "Tx STBC");
6140
6141 /* statistic counters */
6142
6143 stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
6144 "stats", CTLFLAG_RD, 0, "statistic");
6145
6146 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6147 "interrupts", CTLFLAG_RD, &sc->interrupts, 0,
6148 "all interrupts");
6149
6150 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6151 "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0,
6152 "Rx interrupts");
6153
6154 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
6155 {
6156 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6157 "tx_mgmt_interrupts", CTLFLAG_RD, &sc->tx_interrupts[5], 0,
6158 "Tx MGMT interrupts");
6159
6160 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6161 "tx_hcca_interrupts", CTLFLAG_RD, &sc->tx_interrupts[4], 0,
6162 "Tx HCCA interrupts");
6163 }
6164
6165 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6166 "tx_ac3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0,
6167 "Tx AC3 interrupts");
6168
6169 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6170 "tx_ac2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0,
6171 "Tx AC2 interrupts");
6172
6173 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6174 "tx_ac1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0,
6175 "Tx AC1 interrupts");
6176
6177 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6178 "tx_ac0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0,
6179 "Tx AC0 interrupts");
6180
6181 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
6182 {
6183 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6184 "tx_mgmt_data_queued", CTLFLAG_RD, &sc->tx_ring[5].queued, 0,
6185 "Tx MGMT data queued");
6186
6187 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6188 "tx_hcca_data_queued", CTLFLAG_RD, &sc->tx_ring[4].queued, 0,
6189 "Tx HCCA data queued");
6190 }
6191
6192 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6193 "tx_ac3_data_queued", CTLFLAG_RD, &sc->tx_ring[3].queued, 0,
6194 "Tx AC3 data queued");
6195
6196 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6197 "tx_ac2_data_queued", CTLFLAG_RD, &sc->tx_ring[2].queued, 0,
6198 "Tx AC2 data queued");
6199
6200 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6201 "tx_ac1_data_queued", CTLFLAG_RD, &sc->tx_ring[1].queued, 0,
6202 "Tx AC1 data queued");
6203
6204 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6205 "tx_ac0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].queued, 0,
6206 "Tx AC0 data queued");
6207
6208 if (sc->usb_endpoints == RT2870_SOFTC_USB_XFER_COUNT)
6209 {
6210 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6211 "tx_mgmt_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[5], 0,
6212 "Tx MGMT data queue full");
6213
6214 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6215 "tx_hcca_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[4], 0,
6216 "Tx HCCA data queue full");
6217 }
6218
6219 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6220 "tx_ac3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3], 0,
6221 "Tx AC3 data queue full");
6222
6223 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6224 "tx_ac2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2], 0,
6225 "Tx AC2 data queue full");
6226
6227 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6228 "tx_ac1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1], 0,
6229 "Tx AC1 data queue full");
6230
6231 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6232 "tx_ac0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0], 0,
6233 "Tx AC0 data queue full");
6234
6235 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6236 "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts, 0,
6237 "Tx watchdog timeouts");
6238
6239 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6240 "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors, 0,
6241 "Rx mbuf allocation errors");
6242
6243 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6244 "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0], 0,
6245 "Tx queue 0 not empty");
6246
6247 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6248 "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1], 0,
6249 "Tx queue 1 not empty");
6250
6251 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6252 "tx_beacons", CTLFLAG_RD, &sc->tx_beacons, 0,
6253 "Tx beacons");
6254
6255 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6256 "tx_noretryok", CTLFLAG_RD, &sc->tx_noretryok, 0,
6257 "Tx successfull without retries");
6258
6259 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6260 "tx_retryok", CTLFLAG_RD, &sc->tx_retryok, 0,
6261 "Tx successfull with retries");
6262
6263 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6264 "tx_failed", CTLFLAG_RD, &sc->tx_failed, 0,
6265 "Tx failed");
6266
6267 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6268 "tx_underflows", CTLFLAG_RD, &sc->tx_underflows, 0,
6269 "Tx underflows");
6270
6271 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6272 "tx_zerolen", CTLFLAG_RD, &sc->tx_zerolen, 0,
6273 "Tx zero length");
6274
6275 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6276 "tx_nonagg", CTLFLAG_RD, &sc->tx_nonagg, 0,
6277 "Tx non-aggregated");
6278
6279 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6280 "tx_agg", CTLFLAG_RD, &sc->tx_agg, 0,
6281 "Tx aggregated");
6282
6283 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6284 "tx_ampdu", CTLFLAG_RD, &sc->tx_ampdu, 0,
6285 "Tx A-MPDU");
6286
6287 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6288 "tx_mpdu_zero_density", CTLFLAG_RD, &sc->tx_mpdu_zero_density, 0,
6289 "Tx MPDU with zero density");
6290
6291 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6292 "tx_ampdu_sessions", CTLFLAG_RD, &sc->tx_ampdu_sessions, 0,
6293 "Tx A-MPDU sessions");
6294
6295 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6296 "rx_packets", CTLFLAG_RD, &sc->rx_packets, 0,
6297 "Rx packets");
6298
6299 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6300 "rx_ampdu", CTLFLAG_RD, &sc->rx_ampdu, 0,
6301 "Rx A-MPDU");
6302
6303 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6304 "rx_mpdu_zero_density", CTLFLAG_RD, &sc->rx_mpdu_zero_density, 0,
6305 "Rx MPDU with zero density");
6306
6307 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6308 "rx_amsdu", CTLFLAG_RD, &sc->rx_amsdu, 0,
6309 "Rx A-MSDU");
6310
6311 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6312 "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_errors, 0,
6313 "Rx CRC errors");
6314
6315 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6316 "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_errors, 0,
6317 "Rx PHY errors");
6318
6319 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6320 "rx_false_ccas", CTLFLAG_RD, &sc->rx_false_ccas, 0,
6321 "Rx false CCAs");
6322
6323 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6324 "rx_plcp_errors", CTLFLAG_RD, &sc->rx_plcp_errors, 0,
6325 "Rx PLCP errors");
6326
6327 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6328 "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0,
6329 "Rx duplicate packets");
6330
6331 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6332 "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0,
6333 "Rx FIFO overflows");
6334
6335 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6336 "rx_cipher_no_errors", CTLFLAG_RD, &sc->rx_cipher_no_errors, 0,
6337 "Rx cipher no errors");
6338
6339 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6340 "rx_cipher_icv_errors", CTLFLAG_RD, &sc->rx_cipher_icv_errors, 0,
6341 "Rx cipher ICV errors");
6342
6343 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6344 "rx_cipher_mic_errors", CTLFLAG_RD, &sc->rx_cipher_mic_errors, 0,
6345 "Rx cipher MIC errors");
6346
6347 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6348 "rx_cipher_invalid_key_errors", CTLFLAG_RD, &sc->rx_cipher_invalid_key_errors, 0,
6349 "Rx cipher invalid key errors");
6350 }
6351
6352 static device_method_t rt2870_dev_methods[] =
6353 {
6354 DEVMETHOD(device_probe, rt2870_probe),
6355 DEVMETHOD(device_attach, rt2870_attach),
6356 DEVMETHOD(device_detach, rt2870_detach),
6357 { 0, 0 }
6358 };
6359
6360 static driver_t rt2870_driver =
6361 {
6362 "rt2870",
6363 rt2870_dev_methods,
6364 sizeof(struct rt2870_softc),
6365 };
6366
6367 static devclass_t rt2870_dev_class;
6368
6369 DRIVER_MODULE(rt2870, uhub, rt2870_driver, rt2870_dev_class,
6370 NULL, 0);
6371
6372 MODULE_DEPEND(rt2870, usb, 1, 1, 1);
6373 MODULE_DEPEND(rt2870, wlan, 1, 1, 1);
FreeBSD 8 device driver for Ralink rt2870