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