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