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