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