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