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