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