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