?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clear WCID entry when node is cleaned up
[ralink_drivers/rt2860_fbsd72.git] / rt2860.c
blob69b8b480db2de912cf2c07403893af89fa437582
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 "rt2860_softc.h"
20 #include "rt2860_reg.h"
21 #include "rt2860_eeprom.h"
22 #include "rt2860_ucode.h"
23 #include "rt2860_txwi.h"
24 #include "rt2860_rxwi.h"
25 #include "rt2860_io.h"
26 #include "rt2860_read_eeprom.h"
27 #include "rt2860_led.h"
28 #include "rt2860_rf.h"
29 #include "rt2860_debug.h"
30
31 /*
32 * Defines and macros
33 */
34
35 #define PCI_VENDOR_RALINK 0x1814
36 #define PCI_PRODUCT_RALINK_RT2860_PCI 0x0601
37 #define PCI_PRODUCT_RALINK_RT2860_PCIe 0x0681
38 #define PCI_PRODUCT_RALINK_RT2760_PCI 0x0701
39 #define PCI_PRODUCT_RALINK_RT2790_PCIe 0x0781
40
41 #define RT2860_MAX_AGG_SIZE 3840
42
43 #define RT2860_TX_DATA_SEG0_SIZE \
44 (sizeof(struct rt2860_txwi) + sizeof(struct ieee80211_qosframe_addr4))
45
46 #define RT2860_NOISE_FLOOR -95
47
48 #define RT2860_AID2WCID(aid) ((aid) & 0xff)
49
50 #define RT2860_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
51
52 #define RT2860_ACK_SIZE 14
53
54 #define IEEE80211_HAS_ADDR4(wh) \
55 (((wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS)
56
57 #define RT2860_MS(_v, _f) (((_v) & _f) >> _f##_S)
58 #define RT2860_SM(_v, _f) (((_v) << _f##_S) & _f)
59
60 #define RT2860_TX_WATCHDOG_TIMEOUT 5
61
62 #define RT2860_WCID_RESERVED 0xff
63 #define RT2860_WCID_MCAST 0xf7
64
65 /*
66 * Data structures and types
67 */
68
69 struct rt2860_pci_ident
70 {
71 uint16_t vendor;
72 uint16_t device;
73 const char *name;
74 };
75
76 /*
77 * Static function prototypes
78 */
79
80 static int rt2860_probe(device_t dev);
81
82 static int rt2860_attach(device_t dev);
83
84 static int rt2860_detach(device_t dev);
85
86 static int rt2860_shutdown(device_t dev);
87
88 static int rt2860_suspend(device_t dev);
89
90 static int rt2860_resume(device_t dev);
91
92 static void rt2860_init_channels(struct rt2860_softc *sc);
93
94 static void rt2860_init_channels_ht40(struct rt2860_softc *sc);
95
96 static void rt2860_init_locked(void *priv);
97
98 static void rt2860_init(void *priv);
99
100 static int rt2860_init_bbp(struct rt2860_softc *sc);
101
102 static void rt2860_stop_locked(void *priv);
103
104 static void rt2860_stop(void *priv);
105
106 static void rt2860_start(struct ifnet *ifp);
107
108 static int rt2860_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
109
110 static int rt2860_reset(struct ifnet *ifp);
111
112 static int rt2860_newstate(struct ieee80211com *ic,
113 enum ieee80211_state nstate, int arg);
114
115 static void rt2860_scan_start(struct ieee80211com *ic);
116
117 static void rt2860_scan_end(struct ieee80211com *ic);
118
119 static void rt2860_set_channel(struct ieee80211com *ic);
120
121 static void rt2860_newassoc(struct ieee80211_node *ni, int isnew);
122
123 static void rt2860_updateslot(struct ifnet *ifp);
124
125 static int rt2860_wme_update(struct ieee80211com *ic);
126
127 static void rt2860_update_beacon(struct ieee80211com *ic, int what);
128
129 static void rt2860_key_update_begin(struct ieee80211com *ic);
130
131 static void rt2860_key_update_end(struct ieee80211com *ic);
132
133 static int rt2860_key_set(struct ieee80211com *ic,
134 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN]);
135
136 static int rt2860_key_delete(struct ieee80211com *ic,
137 const struct ieee80211_key *k);
138
139 static int rt2860_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
140 const struct ieee80211_bpf_params *params);
141
142 static int rt2860_media_change(struct ifnet *ifp);
143
144 static struct ieee80211_node *rt2860_node_alloc(struct ieee80211_node_table *nt);
145
146 static void rt2860_node_cleanup(struct ieee80211_node *ni);
147
148 static void rt2860_recv_action(struct ieee80211_node *ni,
149 const uint8_t *frm, const uint8_t *efrm);
150
151 static int rt2860_send_action(struct ieee80211_node *ni,
152 int category, int action, uint16_t args[4]);
153
154 static void rt2860_amrr_update_iter_func(void *arg, struct ieee80211_node *ni);
155
156 static void rt2860_periodic(void *arg);
157
158 static void rt2860_tx_watchdog(void *arg);
159
160 static int rt2860_staid_alloc(struct rt2860_softc *sc, int aid);
161
162 static void rt2860_staid_delete(struct rt2860_softc *sc, int staid);
163
164 static void rt2860_asic_set_bssid(struct rt2860_softc *sc,
165 const uint8_t *bssid);
166
167 static void rt2860_asic_set_macaddr(struct rt2860_softc *sc,
168 const uint8_t *addr);
169
170 static void rt2860_asic_enable_tsf_sync(struct rt2860_softc *sc);
171
172 static void rt2860_asic_disable_tsf_sync(struct rt2860_softc *sc);
173
174 static void rt2860_asic_enable_mrr(struct rt2860_softc *sc);
175
176 static void rt2860_asic_set_txpreamble(struct rt2860_softc *sc);
177
178 static void rt2860_asic_set_basicrates(struct rt2860_softc *sc);
179
180 static void rt2860_asic_update_rtsthreshold(struct rt2860_softc *sc);
181
182 static void rt2860_asic_update_txpower(struct rt2860_softc *sc);
183
184 static void rt2860_asic_update_promisc(struct rt2860_softc *sc);
185
186 static void rt2860_asic_updateprot(struct rt2860_softc *sc);
187
188 static void rt2860_asic_updateslot(struct rt2860_softc *sc);
189
190 static void rt2860_asic_wme_update(struct rt2860_softc *sc);
191
192 static void rt2860_asic_update_beacon(struct rt2860_softc *sc);
193
194 static void rt2860_asic_clear_keytables(struct rt2860_softc *sc);
195
196 static int rt2860_beacon_alloc(struct rt2860_softc *sc);
197
198 static uint8_t rt2860_rxrate(struct rt2860_rxwi *rxwi);
199
200 static uint8_t rt2860_maxrssi_rxpath(struct rt2860_softc *sc,
201 const struct rt2860_rxwi *rxwi);
202
203 static int8_t rt2860_rssi2dbm(struct rt2860_softc *sc,
204 uint8_t rssi, uint8_t rxpath);
205
206 static uint8_t rt2860_rate2mcs(uint8_t rate);
207
208 static int rt2860_ackrate(struct ieee80211com *ic, int rate);
209
210 static uint16_t rt2860_txtime(int len, int rate, uint32_t flags);
211
212 static int rt2860_tx_frame(struct rt2860_softc *sc,
213 struct mbuf *m, struct ieee80211_node *ni, int qid);
214
215 static int rt2860_tx_raw(struct rt2860_softc *sc,
216 struct mbuf *m, struct ieee80211_node *ni,
217 const struct ieee80211_bpf_params *params);
218
219 static void rt2860_intr(void *arg);
220
221 static void rt2860_tx_coherent_intr(struct rt2860_softc *sc);
222
223 static void rt2860_rx_coherent_intr(struct rt2860_softc *sc);
224
225 static void rt2860_txrx_coherent_intr(struct rt2860_softc *sc);
226
227 static void rt2860_fifo_sta_full_intr(struct rt2860_softc *sc);
228
229 static void rt2860_rx_intr(struct rt2860_softc *sc);
230
231 static void rt2860_rx_delay_intr(struct rt2860_softc *sc);
232
233 static void rt2860_tx_intr(struct rt2860_softc *sc, int qid);
234
235 static void rt2860_tx_delay_intr(struct rt2860_softc *sc);
236
237 static void rt2860_pre_tbtt_intr(struct rt2860_softc *sc);
238
239 static void rt2860_tbtt_intr(struct rt2860_softc *sc);
240
241 static void rt2860_mcu_cmd_intr(struct rt2860_softc *sc);
242
243 static void rt2860_auto_wakeup_intr(struct rt2860_softc *sc);
244
245 static void rt2860_gp_timer_intr(struct rt2860_softc *sc);
246
247 static void rt2860_rx_done_task(void *context, int pending);
248
249 static void rt2860_tx_done_task(void *context, int pending);
250
251 static void rt2860_fifo_sta_full_task(void *context, int pending);
252
253 static void rt2860_periodic_task(void *context, int pending);
254
255 static int rt2860_rx_eof(struct rt2860_softc *sc, int limit);
256
257 static void rt2860_tx_eof(struct rt2860_softc *sc,
258 struct rt2860_softc_tx_ring *ring);
259
260 static void rt2860_update_stats(struct rt2860_softc *sc);
261
262 static void rt2860_bbp_tuning(struct rt2860_softc *sc);
263
264 static void rt2860_watchdog(struct rt2860_softc *sc);
265
266 static void rt2860_drain_fifo_stats(struct rt2860_softc *sc);
267
268 static void rt2860_update_raw_counters(struct rt2860_softc *sc);
269
270 static void rt2860_intr_enable(struct rt2860_softc *sc, uint32_t intr_mask);
271
272 static void rt2860_intr_disable(struct rt2860_softc *sc, uint32_t intr_mask);
273
274 static int rt2860_txrx_enable(struct rt2860_softc *sc);
275
276 static int rt2860_alloc_rx_ring(struct rt2860_softc *sc,
277 struct rt2860_softc_rx_ring *ring);
278
279 static void rt2860_reset_rx_ring(struct rt2860_softc *sc,
280 struct rt2860_softc_rx_ring *ring);
281
282 static void rt2860_free_rx_ring(struct rt2860_softc *sc,
283 struct rt2860_softc_rx_ring *ring);
284
285 static int rt2860_alloc_tx_ring(struct rt2860_softc *sc,
286 struct rt2860_softc_tx_ring *ring, int qid);
287
288 static void rt2860_reset_tx_ring(struct rt2860_softc *sc,
289 struct rt2860_softc_tx_ring *ring);
290
291 static void rt2860_free_tx_ring(struct rt2860_softc *sc,
292 struct rt2860_softc_tx_ring *ring);
293
294 static void rt2860_dma_map_addr(void *arg, bus_dma_segment_t *segs,
295 int nseg, int error);
296
297 static void rt2860_sysctl_attach(struct rt2860_softc *sc);
298
299 /*
300 * Static variables
301 */
302
303 static const struct rt2860_pci_ident rt2860_pci_ids[] =
304 {
305 { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2860_PCI, "Ralink RT2860 PCI" },
306 { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2860_PCIe, "Ralink RT2860 PCIe" },
307 { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2760_PCI, "Ralink RT2760 PCI" },
308 { PCI_VENDOR_RALINK, PCI_PRODUCT_RALINK_RT2790_PCIe, "Ralink RT2790 PCIe" },
309 { 0, 0, NULL }
310 };
311
312 static const struct
313 {
314 uint32_t reg;
315 uint32_t val;
316 } rt2860_def_mac[] =
317 {
318 { RT2860_REG_PBF_BCN_OFFSET0, 0xf8f0e8e0 },
319 { RT2860_REG_PBF_BCN_OFFSET1, 0x6f77d0c8 },
320 { RT2860_REG_LEGACY_BASIC_RATE, 0x0000013f },
321 { RT2860_REG_HT_BASIC_RATE, 0x00008003 },
322 { RT2860_REG_SYS_CTRL, 0x00000000 },
323 { RT2860_REG_RX_FILTER_CFG, 0x00017f97 },
324 { RT2860_REG_BKOFF_SLOT_CFG, 0x00000209 },
325 { RT2860_REG_TX_SW_CFG0, 0x00000000 },
326 { RT2860_REG_TX_SW_CFG1, 0x00080606 },
327 { RT2860_REG_TX_LINK_CFG, 0x00001020 },
328 { RT2860_REG_TX_TIMEOUT_CFG, 0x000a2090 },
329 { RT2860_REG_MAX_LEN_CFG, (1 << 12) | RT2860_MAX_AGG_SIZE },
330 { RT2860_REG_LED_CFG, 0x7f031e46 },
331 { RT2860_REG_PBF_MAX_PCNT, 0x1f3fbf9f },
332 { RT2860_REG_TX_RTY_CFG, 0x47d01f0f },
333 { RT2860_REG_AUTO_RSP_CFG, 0x00000013 },
334 { RT2860_REG_TX_CCK_PROT_CFG, 0x05740003 },
335 { RT2860_REG_TX_OFDM_PROT_CFG, 0x05740003 },
336 { RT2860_REG_TX_GF20_PROT_CFG, 0x01744004 },
337 { RT2860_REG_TX_GF40_PROT_CFG, 0x03f44084 },
338 { RT2860_REG_TX_MM20_PROT_CFG, 0x01744004 },
339 { RT2860_REG_TX_MM40_PROT_CFG, 0x03f54084 },
340 { RT2860_REG_TX_TXOP_CTRL_CFG, 0x0000583f },
341 { RT2860_REG_TX_RTS_CFG, 0x00092b20 },
342 { RT2860_REG_TX_EXP_ACK_TIME, 0x002400ca },
343 { RT2860_REG_HCCAPSMP_TXOP_HLDR_ET, 0x00000002 },
344 { RT2860_REG_XIFS_TIME_CFG, 0x33a41010 },
345 { RT2860_REG_PWR_PIN_CFG, 0x00000003 },
346 { RT2860_REG_SCHDMA_WMM_AIFSN_CFG, 0x00002273 },
347 { RT2860_REG_SCHDMA_WMM_CWMIN_CFG, 0x00002344 },
348 { RT2860_REG_SCHDMA_WMM_CWMAX_CFG, 0x000034aa },
349 };
350
351 #define RT2860_DEF_MAC_SIZE (sizeof(rt2860_def_mac) / sizeof(rt2860_def_mac[0]))
352
353 static const struct
354 {
355 uint8_t reg;
356 uint8_t val;
357 } rt2860_def_bbp[] =
358 {
359 { 65, 0x2c },
360 { 66, 0x38 },
361 { 69, 0x12 },
362 { 70, 0x0a },
363 { 73, 0x10 },
364 { 81, 0x37 },
365 { 82, 0x62 },
366 { 83, 0x6a },
367 { 84, 0x99 },
368 { 86, 0x00 },
369 { 91, 0x04 },
370 { 92, 0x00 },
371 { 103, 0x00 },
372 { 105, 0x05 },
373 { 106, 0x35 },
374 };
375
376 #define RT2860_DEF_BBP_SIZE (sizeof(rt2860_def_bbp) / sizeof(rt2860_def_bbp[0]))
377
378 SYSCTL_NODE(_hw, OID_AUTO, rt2860, CTLFLAG_RD, 0, "RT2860 driver parameters");
379
380 static int rt2860_tx_stbc = 0;
381 SYSCTL_INT(_hw_rt2860, OID_AUTO, tx_stbc, CTLFLAG_RW, &rt2860_tx_stbc, 0, "rt2860 Tx STBC");
382 TUNABLE_INT("hw.rt2860.tx_stbc", &rt2860_tx_stbc);
383
384 #ifdef RT2860_DEBUG
385 static int rt2860_debug = 0;
386 SYSCTL_INT(_hw_rt2860, OID_AUTO, debug, CTLFLAG_RW, &rt2860_debug, 0, "rt2860 debug level");
387 TUNABLE_INT("hw.rt2860.debug", &rt2860_debug);
388 #endif
389
390 /*
391 * rt2860_probe
392 */
393 static int rt2860_probe(device_t dev)
394 {
395 const struct rt2860_pci_ident *ident;
396
397 for (ident = rt2860_pci_ids; ident->name != NULL; ident++)
398 {
399 if (pci_get_vendor(dev) == ident->vendor &&
400 pci_get_device(dev) == ident->device)
401 {
402 device_set_desc(dev, ident->name);
403 return 0;
404 }
405 }
406
407 return ENXIO;
408 }
409
410 /*
411 * rt2860_attach
412 */
413 static int rt2860_attach(device_t dev)
414 {
415 struct rt2860_softc *sc;
416 struct ifnet *ifp;
417 struct ieee80211com *ic;
418 int error, ntries, i;
419
420 sc = device_get_softc(dev);
421
422 if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0)
423 {
424 printf("%s: chip is in D%d power mode, setting to D0\n",
425 device_get_nameunit(dev), pci_get_powerstate(dev));
426 pci_set_powerstate(dev, PCI_POWERSTATE_D0);
427 }
428
429 /* enable bus-mastering */
430
431 pci_enable_busmaster(dev);
432
433 sc->dev = dev;
434
435 mtx_init(&sc->lock, device_get_nameunit(dev),
436 MTX_NETWORK_LOCK, MTX_DEF | MTX_RECURSE);
437
438 sc->mem_rid = PCIR_BAR(0);
439 sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
440 &sc->mem_rid, RF_ACTIVE);
441 if (sc->mem == NULL)
442 {
443 printf("%s: could not allocate memory resource\n",
444 device_get_nameunit(dev));
445 error = ENXIO;
446 goto fail;
447 }
448
449 sc->bst = rman_get_bustag(sc->mem);
450 sc->bsh = rman_get_bushandle(sc->mem);
451
452 sc->irq_rid = 0;
453 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
454 &sc->irq_rid, RF_ACTIVE | RF_SHAREABLE);
455 if (sc->irq == NULL)
456 {
457 printf("%s: could not allocate interrupt resource\n",
458 device_get_nameunit(dev));
459 error = ENXIO;
460 goto fail;
461 }
462
463 sc->tx_stbc = rt2860_tx_stbc;
464
465 #ifdef RT2860_DEBUG
466 sc->debug = rt2860_debug;
467
468 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
469 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
470 "debug", CTLFLAG_RW, &sc->debug, 0, "rt2860 debug level");
471 #endif
472
473 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
474 "%s: attaching\n",
475 device_get_nameunit(sc->dev));
476
477 /* wait for NIC to initialize */
478
479 for (ntries = 0; ntries < 100; ntries++)
480 {
481 sc->mac_rev = rt2860_io_mac_read(sc, RT2860_REG_MAC_CSR0);
482 if (sc->mac_rev != 0x00000000 && sc->mac_rev != 0xffffffff)
483 break;
484
485 DELAY(10);
486 }
487
488 if (ntries == 100)
489 {
490 printf("%s: timeout waiting for NIC to initialize\n",
491 device_get_nameunit(dev));
492 error = EIO;
493 goto fail;
494 }
495
496 rt2860_read_eeprom(sc);
497
498 printf("%s: MAC/BBP RT2860 (rev 0x%08x), RF %s\n",
499 device_get_nameunit(sc->dev), sc->mac_rev,
500 rt2860_rf_name(sc->rf_rev));
501
502 /* clear key tables */
503
504 rt2860_asic_clear_keytables(sc);
505
506 /* allocate Tx and Rx rings */
507
508 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
509 {
510 error = rt2860_alloc_tx_ring(sc, &sc->tx_ring[i], i);
511 if (error != 0)
512 {
513 printf("%s: could not allocate Tx ring #%d\n",
514 device_get_nameunit(sc->dev), i);
515 goto fail;
516 }
517 }
518
519 sc->tx_ring_mgtqid = 5;
520
521 error = rt2860_alloc_rx_ring(sc, &sc->rx_ring);
522 if (error != 0)
523 {
524 printf("%s: could not allocate Rx ring\n",
525 device_get_nameunit(sc->dev));
526 goto fail;
527 }
528
529 callout_init(&sc->periodic_ch, 0);
530 callout_init_mtx(&sc->tx_watchdog_ch, &sc->lock, 0);
531
532 ifp = sc->ifp = if_alloc(IFT_ETHER);
533 if (ifp == NULL)
534 {
535 printf("%s: could not if_alloc()\n",
536 device_get_nameunit(sc->dev));
537 error = ENOMEM;
538 goto fail;
539 }
540
541 ifp->if_softc = sc;
542
543 if_initname(ifp, "rt2860", device_get_unit(sc->dev));
544
545 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
546
547 ifp->if_init = rt2860_init;
548 ifp->if_ioctl = rt2860_ioctl;
549 ifp->if_start = rt2860_start;
550
551 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
552 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
553 IFQ_SET_READY(&ifp->if_snd);
554
555 ic = &sc->ic;
556
557 ic->ic_ifp = ifp;
558
559 ic->ic_phytype = IEEE80211_T_HT;
560 ic->ic_opmode = IEEE80211_M_STA;
561 ic->ic_state = IEEE80211_S_INIT;
562
563 ic->ic_caps = IEEE80211_C_MONITOR |
564 IEEE80211_C_IBSS |
565 IEEE80211_C_AHDEMO |
566 IEEE80211_C_HOSTAP |
567 IEEE80211_C_WDS |
568 IEEE80211_C_BGSCAN |
569 IEEE80211_C_TXPMGT |
570 IEEE80211_C_SHPREAMBLE |
571 IEEE80211_C_SHSLOT |
572 IEEE80211_C_TXFRAG |
573 IEEE80211_C_BURST |
574 IEEE80211_C_WME |
575 IEEE80211_C_WEP |
576 IEEE80211_C_TKIP |
577 IEEE80211_C_AES_CCM |
578 IEEE80211_C_WPA;
579
580 ic->ic_htcaps = IEEE80211_HTC_HT |
581 IEEE80211_HTC_AMSDU | /* A-MSDU Tx */
582 IEEE80211_HTC_AMPDU | /* A-MPDU Tx */
583 IEEE80211_HTCAP_MAXAMSDU_3839 | /* max. A-MSDU Rx length */
584 IEEE80211_HTCAP_CHWIDTH40 | /* HT 40MHz channel width */
585 IEEE80211_HTCAP_GREENFIELD | /* HT greenfield */
586 IEEE80211_HTCAP_SHORTGI20 | /* HT 20MHz short GI */
587 IEEE80211_HTCAP_SHORTGI40 | /* HT 40MHz short GI */
588 IEEE80211_HTCAP_SMPS_OFF; /* MIMO power save disabled */
589
590 /* spatial streams */
591
592 if (sc->nrxpath == 2)
593 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_2STREAM;
594 else if (sc->nrxpath == 3)
595 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_3STREAM;
596 else
597 ic->ic_htcaps |= IEEE80211_HTCAP_RXSTBC_1STREAM;
598
599 if (sc->ntxpath > 1)
600 ic->ic_htcaps |= IEEE80211_HTCAP_TXSTBC;
601
602 /* delayed BA */
603
604 if (sc->mac_rev != 0x28600100)
605 ic->ic_htcaps |= IEEE80211_HTCAP_DELBA;
606
607 /* init channels */
608
609 ic->ic_nchans = 0;
610 ic->ic_regdomain = 0;
611 ic->ic_countrycode = CTRY_DEFAULT;
612 ic->ic_location = 0;
613
614 rt2860_init_channels(sc);
615
616 rt2860_init_channels_ht40(sc);
617
618 IEEE80211_ADDR_COPY(ic->ic_myaddr, sc->mac_addr);
619
620 ieee80211_ifattach(ic);
621
622 sc->newstate = ic->ic_newstate;
623 ic->ic_newstate = rt2860_newstate;
624
625 ic->ic_reset = rt2860_reset;
626 ic->ic_node_alloc = rt2860_node_alloc;
627
628 sc->node_cleanup = ic->ic_node_cleanup;
629 ic->ic_node_cleanup = rt2860_node_cleanup;
630
631 ic->ic_scan_start = rt2860_scan_start;
632 ic->ic_scan_end = rt2860_scan_end;
633 ic->ic_set_channel = rt2860_set_channel;
634 ic->ic_newassoc = rt2860_newassoc;
635 ic->ic_updateslot = rt2860_updateslot;
636 ic->ic_wme.wme_update = rt2860_wme_update;
637 ic->ic_update_beacon = rt2860_update_beacon;
638 ic->ic_crypto.cs_key_update_begin = rt2860_key_update_begin;
639 ic->ic_crypto.cs_key_update_end = rt2860_key_update_end;
640 ic->ic_crypto.cs_key_set = rt2860_key_set;
641 ic->ic_crypto.cs_key_delete = rt2860_key_delete;
642 ic->ic_raw_xmit = rt2860_raw_xmit;
643
644 sc->recv_action = ic->ic_recv_action;
645 ic->ic_recv_action = rt2860_recv_action;
646
647 sc->send_action = ic->ic_send_action;
648 ic->ic_send_action = rt2860_send_action;
649
650 /* override Rx A-MPDU factor */
651
652 ic->ic_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_32K;
653 ic->ic_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_NA;
654 ic->ic_ampdu_limit = ic->ic_ampdu_rxmax;
655
656 /* hardware requires padding between 802.11 frame header and body */
657
658 ic->ic_flags |= IEEE80211_F_WME | IEEE80211_F_DATAPAD | IEEE80211_F_DOTH;
659
660 ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS;
661
662 ic->ic_max_aid = RT2860_SOFTC_STAID_COUNT;
663
664 ieee80211_media_init(ic, rt2860_media_change, ieee80211_media_status);
665
666 rt2860_amrr_init(&sc->amrr, ic,
667 sc->ntxpath,
668 RT2860_AMRR_MIN_SUCCESS_THRESHOLD,
669 RT2860_AMRR_MAX_SUCCESS_THRESHOLD,
670 500);
671
672 bpfattach2(ifp, DLT_IEEE802_11_RADIO,
673 sizeof(struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN,
674 &sc->drvbpf);
675
676 sc->rxtap_len = sizeof(sc->rxtapu);
677 sc->rxtap.ihdr.it_len = htole16(sc->rxtap_len);
678 sc->rxtap.ihdr.it_present = htole32(RT2860_SOFTC_RX_RADIOTAP_PRESENT);
679
680 sc->txtap_len = sizeof(sc->txtapu);
681 sc->txtap.ihdr.it_len = htole16(sc->txtap_len);
682 sc->txtap.ihdr.it_present = htole32(RT2860_SOFTC_TX_RADIOTAP_PRESENT);
683
684 /* init task queue */
685
686 TASK_INIT(&sc->rx_done_task, 0, rt2860_rx_done_task, sc);
687 TASK_INIT(&sc->tx_done_task, 0, rt2860_tx_done_task, sc);
688 TASK_INIT(&sc->fifo_sta_full_task, 0, rt2860_fifo_sta_full_task, sc);
689 TASK_INIT(&sc->periodic_task, 0, rt2860_periodic_task, sc);
690
691 sc->rx_process_limit = 100;
692
693 sc->taskqueue = taskqueue_create("rt2860_taskq", M_NOWAIT,
694 taskqueue_thread_enqueue, &sc->taskqueue);
695
696 taskqueue_start_threads(&sc->taskqueue, 1, PI_NET, "%s taskq",
697 device_get_nameunit(sc->dev));
698
699 rt2860_sysctl_attach(sc);
700
701 if (bootverbose)
702 ieee80211_announce(ic);
703
704 /* set up interrupt */
705
706 error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE,
707 NULL, rt2860_intr, sc, &sc->irqh);
708 if (error != 0)
709 {
710 printf("%s: could not set up interrupt\n",
711 device_get_nameunit(dev));
712 goto fail;
713 }
714
715 return 0;
716
717 fail:
718
719 /* free Tx and Rx rings */
720
721 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
722 rt2860_free_tx_ring(sc, &sc->tx_ring[i]);
723
724 rt2860_free_rx_ring(sc, &sc->rx_ring);
725
726 mtx_destroy(&sc->lock);
727
728 if (sc->mem != NULL)
729 bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem);
730
731 if (sc->irq != NULL)
732 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq);
733
734 return error;
735 }
736
737 /*
738 * rt2860_detach
739 */
740 static int rt2860_detach(device_t dev)
741 {
742 struct rt2860_softc *sc;
743 struct ieee80211com *ic;
744 struct ifnet *ifp;
745 int i;
746
747 sc = device_get_softc(dev);
748 ic = &sc->ic;
749 ifp = ic->ic_ifp;
750
751 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
752 "%s: detaching\n",
753 device_get_nameunit(sc->dev));
754
755 RT2860_SOFTC_LOCK(sc);
756
757 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
758
759 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
760
761 callout_stop(&sc->periodic_ch);
762 callout_stop(&sc->tx_watchdog_ch);
763
764 taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
765 taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
766 taskqueue_drain(sc->taskqueue, &sc->fifo_sta_full_task);
767 taskqueue_drain(sc->taskqueue, &sc->periodic_task);
768
769 /* free Tx and Rx rings */
770
771 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
772 rt2860_free_tx_ring(sc, &sc->tx_ring[i]);
773
774 rt2860_free_rx_ring(sc, &sc->rx_ring);
775
776 RT2860_SOFTC_UNLOCK(sc);
777
778 bpfdetach(ifp);
779
780 ieee80211_ifdetach(ic);
781
782 if_free(ifp);
783
784 taskqueue_free(sc->taskqueue);
785
786 mtx_destroy(&sc->lock);
787
788 bus_generic_detach(dev);
789
790 bus_teardown_intr(dev, sc->irq, sc->irqh);
791
792 bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq);
793
794 bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem);
795
796 return 0;
797 }
798
799 /*
800 * rt2860_shutdown
801 */
802 static int rt2860_shutdown(device_t dev)
803 {
804 struct rt2860_softc *sc;
805
806 sc = device_get_softc(dev);
807
808 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
809 "%s: shutting down\n",
810 device_get_nameunit(sc->dev));
811
812 rt2860_stop(sc);
813
814 sc->flags &= ~RT2860_SOFTC_FLAGS_UCODE_LOADED;
815
816 return 0;
817 }
818
819 /*
820 * rt2860_suspend
821 */
822 static int rt2860_suspend(device_t dev)
823 {
824 struct rt2860_softc *sc;
825
826 sc = device_get_softc(dev);
827
828 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
829 "%s: suspending\n",
830 device_get_nameunit(sc->dev));
831
832 rt2860_stop(sc);
833
834 sc->flags &= ~RT2860_SOFTC_FLAGS_UCODE_LOADED;
835
836 return 0;
837 }
838
839 /*
840 * rt2860_resume
841 */
842 static int rt2860_resume(device_t dev)
843 {
844 struct rt2860_softc *sc;
845 struct ifnet *ifp;
846
847 sc = device_get_softc(dev);
848 ifp = sc->ifp;
849
850 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
851 "%s: resuming\n",
852 device_get_nameunit(sc->dev));
853
854 if (ifp->if_flags & IFF_UP)
855 rt2860_init(sc);
856
857 return 0;
858 }
859
860 /*
861 * rt2860_init_channels
862 */
863 static void rt2860_init_channels(struct rt2860_softc *sc)
864 {
865 struct ieee80211com *ic;
866 struct ieee80211_channel *c;
867 int i, flags;
868
869 ic = &sc->ic;
870
871 /* set supported channels for 2GHz band */
872
873 for (i = 1; i <= 14; i++)
874 {
875 c = &ic->ic_channels[ic->ic_nchans++];
876 flags = IEEE80211_CHAN_B;
877
878 c->ic_freq = ieee80211_ieee2mhz(i, flags);
879 c->ic_ieee = i;
880 c->ic_flags = flags;
881
882 c = &ic->ic_channels[ic->ic_nchans++];
883 flags = IEEE80211_CHAN_B | IEEE80211_CHAN_HT20;
884
885 c->ic_freq = ieee80211_ieee2mhz(i, flags);
886 c->ic_ieee = i;
887 c->ic_flags = flags;
888
889 c = &ic->ic_channels[ic->ic_nchans++];
890 flags = IEEE80211_CHAN_G;
891
892 c->ic_freq = ieee80211_ieee2mhz(i, flags);
893 c->ic_ieee = i;
894 c->ic_flags = flags;
895
896 c = &ic->ic_channels[ic->ic_nchans++];
897 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT20;
898
899 c->ic_freq = ieee80211_ieee2mhz(i, flags);
900 c->ic_ieee = i;
901 c->ic_flags = flags;
902 }
903
904 /* set supported channels for 5GHz band */
905
906 if (sc->rf_rev == RT2860_EEPROM_RF_2850 ||
907 sc->rf_rev == RT2860_EEPROM_RF_2750)
908 {
909 for (i = 36; i <= 64; i += 4)
910 {
911 c = &ic->ic_channels[ic->ic_nchans++];
912 flags = IEEE80211_CHAN_A;
913
914 c->ic_freq = ieee80211_ieee2mhz(i, flags);
915 c->ic_ieee = i;
916 c->ic_flags = flags;
917
918 c = &ic->ic_channels[ic->ic_nchans++];
919 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
920
921 c->ic_freq = ieee80211_ieee2mhz(i, flags);
922 c->ic_ieee = i;
923 c->ic_flags = flags;
924 }
925
926 for (i = 100; i <= 140; i += 4)
927 {
928 c = &ic->ic_channels[ic->ic_nchans++];
929 flags = IEEE80211_CHAN_A;
930
931 c->ic_freq = ieee80211_ieee2mhz(i, flags);
932 c->ic_ieee = i;
933 c->ic_flags = flags;
934
935 c = &ic->ic_channels[ic->ic_nchans++];
936 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
937
938 c->ic_freq = ieee80211_ieee2mhz(i, flags);
939 c->ic_ieee = i;
940 c->ic_flags = flags;
941 }
942
943 for (i = 149; i <= 165; i += 4)
944 {
945 c = &ic->ic_channels[ic->ic_nchans++];
946 flags = IEEE80211_CHAN_A;
947
948 c->ic_freq = ieee80211_ieee2mhz(i, flags);
949 c->ic_ieee = i;
950 c->ic_flags = flags;
951
952 c = &ic->ic_channels[ic->ic_nchans++];
953 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT20;
954
955 c->ic_freq = ieee80211_ieee2mhz(i, flags);
956 c->ic_ieee = i;
957 c->ic_flags = flags;
958 }
959 }
960 }
961
962 /*
963 * rt2860_init_channels_ht40
964 */
965 static void rt2860_init_channels_ht40(struct rt2860_softc *sc)
966 {
967 struct ieee80211com *ic;
968 struct ieee80211_channel *c, *cent, *ext;
969 int i, flags;
970
971 ic = &sc->ic;
972
973 /* set supported channels for 2GHz band */
974
975 for (i = 1; i <= 14; i++)
976 {
977 flags = IEEE80211_CHAN_G | IEEE80211_CHAN_HT40;
978
979 /* find the center channel */
980
981 cent = ieee80211_find_channel_byieee(ic, i,
982 flags & ~IEEE80211_CHAN_HT);
983 if (cent == NULL)
984 {
985 printf("%s: skip channel %d, could not find center channel\n",
986 device_get_nameunit(sc->dev), i);
987 continue;
988 }
989
990 /* find the extension channel */
991
992 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
993 flags & ~IEEE80211_CHAN_HT);
994 if (ext == NULL)
995 {
996 printf("%s: skip channel %d, could not find extension channel\n",
997 device_get_nameunit(sc->dev), i);
998 continue;
999 }
1000
1001 c = &ic->ic_channels[ic->ic_nchans++];
1002
1003 *c = *cent;
1004 c->ic_extieee = ext->ic_ieee;
1005 c->ic_flags &= ~IEEE80211_CHAN_HT;
1006 c->ic_flags |= IEEE80211_CHAN_HT40U;
1007
1008 c = &ic->ic_channels[ic->ic_nchans++];
1009
1010 *c = *ext;
1011 c->ic_extieee = cent->ic_ieee;
1012 c->ic_flags &= ~IEEE80211_CHAN_HT;
1013 c->ic_flags |= IEEE80211_CHAN_HT40D;
1014 }
1015
1016 /* set supported channels for 5GHz band */
1017
1018 if (sc->rf_rev == RT2860_EEPROM_RF_2850 ||
1019 sc->rf_rev == RT2860_EEPROM_RF_2750)
1020 {
1021 for (i = 36; i <= 64; i += 4)
1022 {
1023 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1024
1025 /* find the center channel */
1026
1027 cent = ieee80211_find_channel_byieee(ic, i,
1028 flags & ~IEEE80211_CHAN_HT);
1029 if (cent == NULL)
1030 {
1031 printf("%s: skip channel %d, could not find center channel\n",
1032 device_get_nameunit(sc->dev), i);
1033 continue;
1034 }
1035
1036 /* find the extension channel */
1037
1038 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1039 flags & ~IEEE80211_CHAN_HT);
1040 if (ext == NULL)
1041 {
1042 printf("%s: skip channel %d, could not find extension channel\n",
1043 device_get_nameunit(sc->dev), i);
1044 continue;
1045 }
1046
1047 c = &ic->ic_channels[ic->ic_nchans++];
1048
1049 *c = *cent;
1050 c->ic_extieee = ext->ic_ieee;
1051 c->ic_flags &= ~IEEE80211_CHAN_HT;
1052 c->ic_flags |= IEEE80211_CHAN_HT40U;
1053
1054 c = &ic->ic_channels[ic->ic_nchans++];
1055
1056 *c = *ext;
1057 c->ic_extieee = cent->ic_ieee;
1058 c->ic_flags &= ~IEEE80211_CHAN_HT;
1059 c->ic_flags |= IEEE80211_CHAN_HT40D;
1060 }
1061
1062 for (i = 100; i <= 140; i += 4)
1063 {
1064 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1065
1066 /* find the center channel */
1067
1068 cent = ieee80211_find_channel_byieee(ic, i,
1069 flags & ~IEEE80211_CHAN_HT);
1070 if (cent == NULL)
1071 {
1072 printf("%s: skip channel %d, could not find center channel\n",
1073 device_get_nameunit(sc->dev), i);
1074 continue;
1075 }
1076
1077 /* find the extension channel */
1078
1079 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1080 flags & ~IEEE80211_CHAN_HT);
1081 if (ext == NULL)
1082 {
1083 printf("%s: skip channel %d, could not find extension channel\n",
1084 device_get_nameunit(sc->dev), i);
1085 continue;
1086 }
1087
1088 c = &ic->ic_channels[ic->ic_nchans++];
1089
1090 *c = *cent;
1091 c->ic_extieee = ext->ic_ieee;
1092 c->ic_flags &= ~IEEE80211_CHAN_HT;
1093 c->ic_flags |= IEEE80211_CHAN_HT40U;
1094
1095 c = &ic->ic_channels[ic->ic_nchans++];
1096
1097 *c = *ext;
1098 c->ic_extieee = cent->ic_ieee;
1099 c->ic_flags &= ~IEEE80211_CHAN_HT;
1100 c->ic_flags |= IEEE80211_CHAN_HT40D;
1101 }
1102
1103 for (i = 149; i <= 165; i += 4)
1104 {
1105 flags = IEEE80211_CHAN_A | IEEE80211_CHAN_HT40;
1106
1107 /* find the center channel */
1108
1109 cent = ieee80211_find_channel_byieee(ic, i,
1110 flags & ~IEEE80211_CHAN_HT);
1111 if (cent == NULL)
1112 {
1113 printf("%s: skip channel %d, could not find center channel\n",
1114 device_get_nameunit(sc->dev), i);
1115 continue;
1116 }
1117
1118 /* find the extension channel */
1119
1120 ext = ieee80211_find_channel(ic, cent->ic_freq + 20,
1121 flags & ~IEEE80211_CHAN_HT);
1122 if (ext == NULL)
1123 {
1124 printf("%s: skip channel %d, could not find extension channel\n",
1125 device_get_nameunit(sc->dev), i);
1126 continue;
1127 }
1128
1129 c = &ic->ic_channels[ic->ic_nchans++];
1130
1131 *c = *cent;
1132 c->ic_extieee = ext->ic_ieee;
1133 c->ic_flags &= ~IEEE80211_CHAN_HT;
1134 c->ic_flags |= IEEE80211_CHAN_HT40U;
1135
1136 c = &ic->ic_channels[ic->ic_nchans++];
1137
1138 *c = *ext;
1139 c->ic_extieee = cent->ic_ieee;
1140 c->ic_flags &= ~IEEE80211_CHAN_HT;
1141 c->ic_flags |= IEEE80211_CHAN_HT40D;
1142 }
1143 }
1144 }
1145
1146 /*
1147 * rt2860_init_locked
1148 */
1149 static void rt2860_init_locked(void *priv)
1150 {
1151 struct rt2860_softc *sc;
1152 struct ieee80211com *ic;
1153 struct ifnet *ifp;
1154 int error, i, ntries;
1155 uint32_t tmp, stacnt[6];
1156
1157 sc = priv;
1158 ic = &sc->ic;
1159 ifp = ic->ic_ifp;
1160
1161 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
1162 "%s: initializing\n",
1163 device_get_nameunit(sc->dev));
1164
1165 RT2860_SOFTC_ASSERT_LOCKED(sc);
1166
1167 if (!(sc->flags & RT2860_SOFTC_FLAGS_UCODE_LOADED))
1168 {
1169 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
1170 "%s: loading 8051 microcode\n",
1171 device_get_nameunit(sc->dev));
1172
1173 error = rt2860_io_mcu_load_ucode(sc, rt2860_ucode, sizeof(rt2860_ucode));
1174 if (error != 0)
1175 {
1176 printf("%s: could not load 8051 microcode\n",
1177 device_get_nameunit(sc->dev));
1178 goto fail;
1179 }
1180
1181 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
1182 "%s: 8051 microcode was successfully loaded\n",
1183 device_get_nameunit(sc->dev));
1184
1185 sc->flags |= RT2860_SOFTC_FLAGS_UCODE_LOADED;
1186 }
1187
1188 rt2860_io_mac_write(sc, RT2860_REG_PWR_PIN_CFG, 0x2);
1189
1190 /* disable DMA engine */
1191
1192 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
1193
1194 tmp &= 0xff0;
1195 tmp |= RT2860_REG_TX_WB_DDONE;
1196
1197 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
1198
1199 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_RST_IDX, 0xffffffff);
1200
1201 /* PBF hardware reset */
1202
1203 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe1f);
1204 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe00);
1205
1206 /* wait while DMA engine is busy */
1207
1208 for (ntries = 0; ntries < 100; ntries++)
1209 {
1210 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
1211 if (!(tmp & (RT2860_REG_TX_DMA_BUSY | RT2860_REG_RX_DMA_BUSY)))
1212 break;
1213
1214 DELAY(1000);
1215 }
1216
1217 if (ntries == 100)
1218 {
1219 printf("%s: timeout waiting for DMA engine\n",
1220 device_get_nameunit(sc->dev));
1221 goto fail;
1222 }
1223
1224 tmp &= 0xff0;
1225 tmp |= RT2860_REG_TX_WB_DDONE;
1226
1227 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
1228
1229 /* reset Rx and Tx rings */
1230
1231 tmp = RT2860_REG_RST_IDX_RX |
1232 RT2860_REG_RST_IDX_TX_MGMT |
1233 RT2860_REG_RST_IDX_TX_HCCA |
1234 RT2860_REG_RST_IDX_TX_AC3 |
1235 RT2860_REG_RST_IDX_TX_AC2 |
1236 RT2860_REG_RST_IDX_TX_AC1 |
1237 RT2860_REG_RST_IDX_TX_AC0;
1238
1239 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_RST_IDX, tmp);
1240
1241 /* PBF hardware reset */
1242
1243 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe1f);
1244 rt2860_io_mac_write(sc, RT2860_REG_PBF_SYS_CTRL, 0xe00);
1245
1246 rt2860_io_mac_write(sc, RT2860_REG_PWR_PIN_CFG, 0x3);
1247
1248 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL,
1249 RT2860_REG_MAC_SRST | RT2860_REG_BBP_HRST);
1250 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 0);
1251
1252 /* init Tx power per rate */
1253
1254 for (i = 0; i < RT2860_SOFTC_TXPOW_RATE_COUNT; i++)
1255 {
1256 if (sc->txpow_rate_20mhz[i] == 0xffffffff)
1257 continue;
1258
1259 rt2860_io_mac_write(sc, RT2860_REG_TX_PWR_CFG(i),
1260 sc->txpow_rate_20mhz[i]);
1261 }
1262
1263 for (i = 0; i < RT2860_DEF_MAC_SIZE; i++)
1264 rt2860_io_mac_write(sc, rt2860_def_mac[i].reg,
1265 rt2860_def_mac[i].val);
1266
1267 /* wait while MAC is busy */
1268
1269 for (ntries = 0; ntries < 100; ntries++)
1270 {
1271 if (!(rt2860_io_mac_read(sc, RT2860_REG_STATUS_CFG) &
1272 (RT2860_REG_STATUS_TX_BUSY | RT2860_REG_STATUS_RX_BUSY)))
1273 break;
1274
1275 DELAY(1000);
1276 }
1277
1278 if (ntries == 100)
1279 {
1280 printf("%s: timeout waiting for MAC\n",
1281 device_get_nameunit(sc->dev));
1282 goto fail;
1283 }
1284
1285 /* clear Host to MCU mailbox */
1286
1287 rt2860_io_mac_write(sc, RT2860_REG_H2M_MAILBOX_BBP_AGENT, 0);
1288 rt2860_io_mac_write(sc, RT2860_REG_H2M_MAILBOX, 0);
1289
1290 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_BOOT,
1291 RT2860_REG_H2M_TOKEN_NO_INTR, 0);
1292
1293 DELAY(1000);
1294
1295 error = rt2860_init_bbp(sc);
1296 if (error != 0)
1297 goto fail;
1298
1299 /* set up maximum buffer sizes */
1300
1301 tmp = (1 << 12) | RT2860_MAX_AGG_SIZE;
1302
1303 rt2860_io_mac_write(sc, RT2860_REG_MAX_LEN_CFG, tmp);
1304
1305 /* set mac address */
1306
1307 IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
1308
1309 rt2860_asic_set_macaddr(sc, ic->ic_myaddr);
1310
1311 /* clear statistic registers */
1312
1313 rt2860_io_mac_read_multi(sc, RT2860_REG_RX_STA_CNT0,
1314 stacnt, sizeof(stacnt));
1315
1316 /* set RTS threshold */
1317
1318 rt2860_asic_update_rtsthreshold(sc);
1319
1320 /* set Tx power */
1321
1322 rt2860_asic_update_txpower(sc);
1323
1324 /* set up protection mode */
1325
1326 sc->tx_ampdu_sessions = 0;
1327
1328 rt2860_asic_updateprot(sc);
1329
1330 /* clear beacon frame space (entries = 8, entry size = 512) */
1331
1332 rt2860_io_mac_set_region_4(sc, RT2860_REG_BEACON_BASE(0), 0, 1024);
1333
1334 taskqueue_unblock(sc->taskqueue);
1335
1336 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
1337
1338 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
1339 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]);
1340
1341 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
1342 {
1343 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i),
1344 sc->tx_ring[i].desc_phys_addr);
1345 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i),
1346 RT2860_SOFTC_TX_RING_DESC_COUNT);
1347 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0);
1348 }
1349
1350 /* init Rx ring */
1351
1352 rt2860_reset_rx_ring(sc, &sc->rx_ring);
1353
1354 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR,
1355 sc->rx_ring.desc_phys_addr);
1356 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT,
1357 RT2860_SOFTC_RX_RING_DATA_COUNT);
1358 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX,
1359 RT2860_SOFTC_RX_RING_DATA_COUNT - 1);
1360
1361 /* wait while DMA engine is busy */
1362
1363 for (ntries = 0; ntries < 100; ntries++)
1364 {
1365 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
1366 if (!(tmp & (RT2860_REG_TX_DMA_BUSY | RT2860_REG_RX_DMA_BUSY)))
1367 break;
1368
1369 DELAY(1000);
1370 }
1371
1372 if (ntries == 100)
1373 {
1374 printf("%s: timeout waiting for DMA engine\n",
1375 device_get_nameunit(sc->dev));
1376 goto fail;
1377 }
1378
1379 tmp &= 0xff0;
1380 tmp |= RT2860_REG_TX_WB_DDONE;
1381
1382 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
1383
1384 /* disable interrupts mitigation */
1385
1386 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_DELAY_INT_CFG, 0);
1387
1388 /* send LEDs operating mode to microcontroller */
1389
1390 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_LED1,
1391 RT2860_REG_H2M_TOKEN_NO_INTR, sc->led_off[0]);
1392 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_LED2,
1393 RT2860_REG_H2M_TOKEN_NO_INTR, sc->led_off[1]);
1394 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_LED3,
1395 RT2860_REG_H2M_TOKEN_NO_INTR, sc->led_off[2]);
1396
1397 /* turn radio LED on */
1398
1399 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_ON);
1400
1401 /* write vendor-specific BBP values (from EEPROM) */
1402
1403 for (i = 0; i < RT2860_SOFTC_BBP_EEPROM_COUNT; i++)
1404 {
1405 if (sc->bbp_eeprom[i].reg == 0x00 ||
1406 sc->bbp_eeprom[i].reg == 0xff)
1407 continue;
1408
1409 rt2860_io_bbp_write(sc, sc->bbp_eeprom[i].reg,
1410 sc->bbp_eeprom[i].val);
1411 }
1412
1413 /*
1414 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_GPIO_CTRL_CFG);
1415 if (tmp & (1 << 2))
1416 {
1417 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_SLEEP,
1418 RT2860_REG_H2M_TOKEN_RADIOOFF, 0x02ff);
1419 rt2860_io_mcu_cmd_check(sc, RT2860_REG_H2M_TOKEN_RADIOOFF);
1420
1421 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_WAKEUP,
1422 RT2860_REG_H2M_TOKEN_WAKEUP, 0);
1423 rt2860_io_mcu_cmd_check(sc, RT2860_REG_H2M_TOKEN_WAKEUP);
1424 }
1425 */
1426
1427 /* disable non-existing Rx chains */
1428
1429 tmp = rt2860_io_bbp_read(sc, 3);
1430
1431 tmp &= ~((1 << 4) | (1 << 3));
1432
1433 if (sc->nrxpath == 3)
1434 tmp |= (1 << 4);
1435 else if (sc->nrxpath == 2)
1436 tmp |= (1 << 3);
1437
1438 rt2860_io_bbp_write(sc, 3, tmp);
1439
1440 /* disable non-existing Tx chains */
1441
1442 tmp = rt2860_io_bbp_read(sc, 1);
1443
1444 tmp &= ~((1 << 4) | (1 << 3));
1445
1446 if (sc->ntxpath == 2)
1447 tmp |= (1 << 4);
1448
1449 rt2860_io_bbp_write(sc, 1, tmp);
1450
1451 /* set current channel */
1452
1453 rt2860_rf_set_chan(sc, ic->ic_curchan);
1454
1455 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP0_CFG, 0);
1456 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP1_CFG,
1457 (48 << 16) | 96);
1458
1459 if ((sc->mac_rev & 0xffff) != 0x0101)
1460 rt2860_io_mac_write(sc, RT2860_REG_TX_TXOP_CTRL_CFG, 0x583f);
1461
1462 /* clear pending interrupts */
1463
1464 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_STATUS, 0xffffffff);
1465
1466 /* enable interrupts */
1467
1468 tmp = RT2860_REG_INT_TX_COHERENT |
1469 RT2860_REG_INT_RX_COHERENT |
1470 RT2860_REG_INT_GP_TIMER |
1471 RT2860_REG_INT_AUTO_WAKEUP |
1472 RT2860_REG_INT_FIFO_STA_FULL |
1473 /*
1474 RT2860_REG_INT_PRE_TBTT |
1475 RT2860_REG_INT_TBTT |
1476 */
1477 RT2860_REG_INT_TXRX_COHERENT |
1478 RT2860_REG_INT_MCU_CMD |
1479 RT2860_REG_INT_TX_MGMT_DONE |
1480 RT2860_REG_INT_TX_HCCA_DONE |
1481 RT2860_REG_INT_TX_AC3_DONE |
1482 RT2860_REG_INT_TX_AC2_DONE |
1483 RT2860_REG_INT_TX_AC1_DONE |
1484 RT2860_REG_INT_TX_AC0_DONE |
1485 RT2860_REG_INT_RX_DONE;
1486
1487 sc->intr_enable_mask = tmp;
1488
1489 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, tmp);
1490
1491 if (rt2860_txrx_enable(sc) != 0)
1492 goto fail;
1493
1494 /* clear garbage interrupts */
1495
1496 tmp = rt2860_io_mac_read(sc, 0x1300);
1497
1498 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
1499 ifp->if_drv_flags |= IFF_DRV_RUNNING;
1500
1501 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1502 {
1503 if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
1504 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
1505 }
1506 else
1507 {
1508 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
1509 }
1510
1511 sc->periodic_round = 0;
1512
1513 callout_reset(&sc->periodic_ch, hz / 10, rt2860_periodic, sc);
1514
1515 return;
1516
1517 fail:
1518
1519 rt2860_stop_locked(sc);
1520 }
1521
1522 /*
1523 * rt2860_init
1524 */
1525 static void rt2860_init(void *priv)
1526 {
1527 struct rt2860_softc *sc;
1528
1529 sc = priv;
1530
1531 RT2860_SOFTC_LOCK(sc);
1532
1533 rt2860_init_locked(sc);
1534
1535 RT2860_SOFTC_UNLOCK(sc);
1536 }
1537
1538 /*
1539 * rt2860_init_bbp
1540 */
1541 static int rt2860_init_bbp(struct rt2860_softc *sc)
1542 {
1543 int ntries, i;
1544 uint8_t tmp;
1545
1546 for (ntries = 0; ntries < 20; ntries++)
1547 {
1548 tmp = rt2860_io_bbp_read(sc, 0);
1549 if (tmp != 0x00 && tmp != 0xff)
1550 break;
1551 }
1552
1553 if (tmp == 0x00 || tmp == 0xff)
1554 {
1555 printf("%s: timeout waiting for BBP to wakeup\n",
1556 device_get_nameunit(sc->dev));
1557 return ETIMEDOUT;
1558 }
1559
1560 for (i = 0; i < RT2860_DEF_BBP_SIZE; i++)
1561 rt2860_io_bbp_write(sc, rt2860_def_bbp[i].reg,
1562 rt2860_def_bbp[i].val);
1563
1564 if ((sc->mac_rev & 0xffff) != 0x0101)
1565 rt2860_io_bbp_write(sc, 84, 0x19);
1566
1567 return 0;
1568 }
1569
1570 /*
1571 * rt2860_stop_locked
1572 */
1573 static void rt2860_stop_locked(void *priv)
1574 {
1575 struct rt2860_softc *sc;
1576 struct ieee80211com *ic;
1577 struct ifnet *ifp;
1578 uint32_t tmp;
1579
1580 sc = priv;
1581 ic = &sc->ic;
1582 ifp = ic->ic_ifp;
1583
1584 RT2860_DPRINTF(sc, RT2860_DEBUG_ANY,
1585 "%s: stopping\n",
1586 device_get_nameunit(sc->dev));
1587
1588 RT2860_SOFTC_ASSERT_LOCKED(sc);
1589
1590 sc->tx_timer = 0;
1591
1592 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1593 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_OFF);
1594
1595 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
1596
1597 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
1598
1599 callout_stop(&sc->periodic_ch);
1600 callout_stop(&sc->tx_watchdog_ch);
1601
1602 RT2860_SOFTC_UNLOCK(sc);
1603
1604 taskqueue_block(sc->taskqueue);
1605
1606 taskqueue_drain(sc->taskqueue, &sc->rx_done_task);
1607 taskqueue_drain(sc->taskqueue, &sc->tx_done_task);
1608 taskqueue_drain(sc->taskqueue, &sc->fifo_sta_full_task);
1609 taskqueue_drain(sc->taskqueue, &sc->periodic_task);
1610
1611 RT2860_SOFTC_LOCK(sc);
1612
1613 /* clear key tables */
1614
1615 rt2860_asic_clear_keytables(sc);
1616
1617 /* disable interrupts */
1618
1619 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, 0);
1620
1621 /* disable Tx/Rx */
1622
1623 tmp = rt2860_io_mac_read(sc, RT2860_REG_SYS_CTRL);
1624
1625 tmp &= ~(RT2860_REG_RX_ENABLE | RT2860_REG_TX_ENABLE);
1626
1627 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, tmp);
1628
1629 /* reset adapter */
1630
1631 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL,
1632 RT2860_REG_MAC_SRST | RT2860_REG_BBP_HRST);
1633 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, 0);
1634
1635 if (sc->beacon_mbuf != NULL)
1636 {
1637 m_free(sc->beacon_mbuf);
1638 sc->beacon_mbuf = NULL;
1639 }
1640 }
1641
1642 /*
1643 * rt2860_stop
1644 */
1645 static void rt2860_stop(void *priv)
1646 {
1647 struct rt2860_softc *sc;
1648
1649 sc = priv;
1650
1651 RT2860_SOFTC_LOCK(sc);
1652
1653 rt2860_stop_locked(sc);
1654
1655 RT2860_SOFTC_UNLOCK(sc);
1656 }
1657
1658 /*
1659 * rt2860_start
1660 */
1661 static void rt2860_start(struct ifnet *ifp)
1662 {
1663 struct rt2860_softc *sc;
1664 struct ieee80211com *ic;
1665 struct ieee80211_node *ni;
1666 struct ether_header *eh;
1667 struct mbuf *m;
1668 int qid;
1669
1670 sc = ifp->if_softc;
1671 ic = &sc->ic;
1672
1673 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
1674 return;
1675
1676 for (;;)
1677 {
1678 IF_POLL(&ic->ic_mgtq, m);
1679 if (m != NULL)
1680 {
1681 RT2860_SOFTC_TX_RING_LOCK(&sc->tx_ring[sc->tx_ring_mgtqid]);
1682
1683 if (sc->tx_ring[sc->tx_ring_mgtqid].data_queued >= RT2860_SOFTC_TX_RING_DATA_COUNT)
1684 {
1685 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]);
1686
1687 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
1688 "%s: if_start: Tx ring with qid=%d is full\n",
1689 device_get_nameunit(sc->dev), sc->tx_ring_mgtqid);
1690
1691 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1692
1693 sc->tx_data_queue_full[sc->tx_ring_mgtqid]++;
1694
1695 break;
1696 }
1697
1698 IF_DEQUEUE(&ic->ic_mgtq, m);
1699 if (m == NULL)
1700 {
1701 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]);
1702 break;
1703 }
1704
1705 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1706
1707 m->m_pkthdr.rcvif = NULL;
1708
1709 if (bpf_peers_present(ic->ic_rawbpf))
1710 bpf_mtap(ic->ic_rawbpf, m);
1711
1712 if (rt2860_tx_frame(sc, m, ni, sc->tx_ring_mgtqid) != 0)
1713 {
1714 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]);
1715 break;
1716 }
1717
1718 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[sc->tx_ring_mgtqid]);
1719
1720 rt2860_drain_fifo_stats(sc);
1721 }
1722 else
1723 {
1724 if (ic->ic_state != IEEE80211_S_RUN)
1725 break;
1726
1727 IFQ_DRV_DEQUEUE(&ifp->if_snd, m);
1728 if (m == NULL)
1729 break;
1730
1731 if (ic->ic_flags & IEEE80211_F_SCAN)
1732 ieee80211_cancel_scan(ic);
1733
1734 if (m->m_len < sizeof(struct ether_header) &&
1735 !(m = m_pullup(m, sizeof (struct ether_header))))
1736 continue;
1737
1738 eh = mtod(m, struct ether_header *);
1739
1740 ni = ieee80211_find_txnode(ic, eh->ether_dhost);
1741 if (ni == NULL)
1742 {
1743 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
1744 "%s: if_start: could not find Tx node\n",
1745 device_get_nameunit(sc->dev));
1746
1747 m_freem(m);
1748
1749 continue;
1750 }
1751
1752 ieee80211_classify(ic, m, ni);
1753
1754 qid = M_WME_GETAC(m);
1755
1756 RT2860_SOFTC_TX_RING_LOCK(&sc->tx_ring[qid]);
1757
1758 if (sc->tx_ring[qid].data_queued >= RT2860_SOFTC_TX_RING_DATA_COUNT)
1759 {
1760 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1761
1762 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
1763 "%s: if_start: Tx ring with qid=%d is full\n",
1764 device_get_nameunit(sc->dev), qid);
1765
1766 m_freem(m);
1767 ieee80211_free_node(ni);
1768
1769 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
1770 ifp->if_oerrors++;
1771
1772 sc->tx_data_queue_full[qid]++;
1773
1774 break;
1775 }
1776
1777 BPF_MTAP(ifp, m);
1778
1779 m = ieee80211_encap(ic, m, ni);
1780 if (m == NULL)
1781 {
1782 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1783
1784 ieee80211_free_node(ni);
1785
1786 ifp->if_oerrors++;
1787
1788 continue;
1789 }
1790
1791 if (bpf_peers_present(ic->ic_rawbpf))
1792 bpf_mtap(ic->ic_rawbpf, m);
1793
1794 if (rt2860_tx_frame(sc, m, ni, qid) != 0)
1795 {
1796 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1797
1798 ieee80211_free_node(ni);
1799
1800 ifp->if_oerrors++;
1801
1802 break;
1803 }
1804
1805 RT2860_SOFTC_TX_RING_UNLOCK(&sc->tx_ring[qid]);
1806
1807 rt2860_drain_fifo_stats(sc);
1808 }
1809
1810 sc->tx_timer = RT2860_TX_WATCHDOG_TIMEOUT;
1811
1812 ic->ic_lastdata = ticks;
1813
1814 callout_reset(&sc->tx_watchdog_ch, hz, rt2860_tx_watchdog, sc);
1815 }
1816 }
1817
1818 /*
1819 * rt2860_ioctl
1820 */
1821 static int rt2860_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1822 {
1823 struct rt2860_softc *sc;
1824 struct ieee80211com *ic;
1825 int error;
1826
1827 sc = ifp->if_softc;
1828 ic = &sc->ic;
1829
1830 error = 0;
1831
1832 switch (cmd)
1833 {
1834 case SIOCSIFFLAGS:
1835 RT2860_SOFTC_LOCK(sc);
1836
1837 if (ifp->if_flags & IFF_UP)
1838 {
1839 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1840 {
1841 if ((ifp->if_flags ^ sc->if_flags) & IFF_PROMISC)
1842 rt2860_asic_update_promisc(sc);
1843 }
1844 else
1845 {
1846 rt2860_init_locked(sc);
1847 }
1848 }
1849 else
1850 {
1851 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
1852 rt2860_stop_locked(sc);
1853 }
1854
1855 sc->if_flags = ifp->if_flags;
1856
1857 RT2860_SOFTC_UNLOCK(sc);
1858 break;
1859
1860 default:
1861 error = ieee80211_ioctl(ic, cmd, data);
1862 }
1863
1864 if (error == ENETRESET)
1865 {
1866 RT2860_SOFTC_LOCK(sc);
1867
1868 if ((ifp->if_flags & IFF_UP) &&
1869 (ifp->if_drv_flags & IFF_DRV_RUNNING) &&
1870 (ic->ic_roaming != IEEE80211_ROAMING_MANUAL))
1871 {
1872 rt2860_stop_locked(sc);
1873 rt2860_init_locked(sc);
1874 }
1875
1876 RT2860_SOFTC_UNLOCK(sc);
1877
1878 error = 0;
1879 }
1880
1881 return error;
1882 }
1883
1884 /*
1885 * rt2860_reset
1886 */
1887 static int rt2860_reset(struct ifnet *ifp)
1888 {
1889 struct rt2860_softc *sc;
1890 struct ieee80211com *ic;
1891
1892 sc = ifp->if_softc;
1893 ic = &sc->ic;
1894
1895 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1896 return ENETRESET;
1897
1898 rt2860_rf_set_chan(sc, ic->ic_curchan);
1899
1900 return 0;
1901 }
1902
1903 /*
1904 * rt2860_newstate
1905 */
1906 static int rt2860_newstate(struct ieee80211com *ic,
1907 enum ieee80211_state nstate, int arg)
1908 {
1909 struct rt2860_softc *sc;
1910 struct ifnet *ifp;
1911 struct ieee80211_node *ni;
1912 int error;
1913
1914 ifp = ic->ic_ifp;
1915 sc = ifp->if_softc;
1916
1917 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE,
1918 "%s: newstate: %s -> %s\n",
1919 device_get_nameunit(sc->dev),
1920 ieee80211_state_name[ic->ic_state], ieee80211_state_name[nstate]);
1921
1922 error = sc->newstate(ic, nstate, arg);
1923 if (error != 0)
1924 return error;
1925
1926 RT2860_SOFTC_LOCK(sc);
1927
1928 /* turn link LED off */
1929
1930 if (nstate != IEEE80211_S_RUN)
1931 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_OFF);
1932
1933 switch (nstate)
1934 {
1935 case IEEE80211_S_INIT:
1936 rt2860_asic_disable_tsf_sync(sc);
1937 break;
1938
1939 case IEEE80211_S_RUN:
1940 ni = ic->ic_bss;
1941
1942 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1943 rt2860_rf_set_chan(sc, ni->ni_chan);
1944
1945 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1946 {
1947 rt2860_asic_enable_mrr(sc);
1948 rt2860_asic_set_txpreamble(sc);
1949 rt2860_asic_set_basicrates(sc);
1950 rt2860_asic_update_txpower(sc);
1951 rt2860_asic_set_bssid(sc, ni->ni_bssid);
1952 }
1953
1954 if (ic->ic_opmode == IEEE80211_M_STA)
1955 rt2860_newassoc(ni, 1);
1956
1957 if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
1958 ic->ic_opmode == IEEE80211_M_IBSS)
1959 {
1960 error = rt2860_beacon_alloc(sc);
1961 if (error != 0)
1962 break;
1963
1964 rt2860_asic_update_beacon(sc);
1965 }
1966
1967 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1968 rt2860_asic_enable_tsf_sync(sc);
1969
1970 /* turn link LED on */
1971
1972 if (ic->ic_opmode != IEEE80211_M_MONITOR)
1973 {
1974 rt2860_led_cmd(sc, RT2860_LED_CMD_RADIO_ON |
1975 (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan) ?
1976 RT2860_LED_CMD_LINK_2GHZ : RT2860_LED_CMD_LINK_5GHZ));
1977 }
1978 break;
1979
1980 case IEEE80211_S_SLEEP:
1981 break;
1982
1983 default:
1984 break;
1985 }
1986
1987 RT2860_SOFTC_UNLOCK(sc);
1988
1989 return error;
1990 }
1991
1992 /*
1993 * rt2860_scan_start
1994 */
1995 static void rt2860_scan_start(struct ieee80211com *ic)
1996 {
1997 struct rt2860_softc *sc;
1998 struct ifnet *ifp;
1999
2000 ifp = ic->ic_ifp;
2001 sc = ifp->if_softc;
2002
2003 rt2860_asic_disable_tsf_sync(sc);
2004 }
2005
2006 /*
2007 * rt2860_scan_end
2008 */
2009 static void rt2860_scan_end(struct ieee80211com *ic)
2010 {
2011 struct rt2860_softc *sc;
2012 struct ifnet *ifp;
2013
2014 ifp = ic->ic_ifp;
2015 sc = ifp->if_softc;
2016
2017 rt2860_asic_enable_tsf_sync(sc);
2018 }
2019
2020 /*
2021 * rt2860_set_channel
2022 */
2023 static void rt2860_set_channel(struct ieee80211com *ic)
2024 {
2025 struct rt2860_softc *sc;
2026 struct ifnet *ifp;
2027
2028 ifp = ic->ic_ifp;
2029 sc = ifp->if_softc;
2030
2031 RT2860_DPRINTF(sc, RT2860_DEBUG_CHAN,
2032 "%s: set channel: channel=%u, HT%s%s\n",
2033 device_get_nameunit(sc->dev),
2034 ieee80211_chan2ieee(ic, ic->ic_curchan),
2035 !IEEE80211_IS_CHAN_HT(ic->ic_curchan) ? " disabled" :
2036 IEEE80211_IS_CHAN_HT20(ic->ic_curchan) ? "20":
2037 IEEE80211_IS_CHAN_HT40U(ic->ic_curchan) ? "40U" : "40D",
2038 (ic->ic_flags & IEEE80211_F_SCAN) ? ", scanning" : "");
2039
2040 RT2860_SOFTC_LOCK(sc);
2041
2042 rt2860_rf_set_chan(sc, ic->ic_curchan);
2043
2044 RT2860_SOFTC_UNLOCK(sc);
2045 }
2046
2047 /*
2048 * rt2860_newassoc
2049 */
2050 static void rt2860_newassoc(struct ieee80211_node *ni, int isnew)
2051 {
2052 struct rt2860_softc *sc;
2053 struct ieee80211com *ic;
2054 struct ifnet *ifp;
2055 struct rt2860_softc_node *rni;
2056 uint16_t aid;
2057 uint8_t wcid;
2058
2059 ic = ni->ni_ic;
2060 ifp = ic->ic_ifp;
2061 sc = ifp->if_softc;
2062 rni = (struct rt2860_softc_node *) ni;
2063
2064 if (isnew)
2065 {
2066 aid = IEEE80211_AID(ni->ni_associd);
2067 rni->staid = rt2860_staid_alloc(sc, aid);
2068 wcid = rni->staid;
2069
2070 rt2860_io_mac_write_multi(sc, RT2860_REG_WCID(wcid),
2071 ni->ni_macaddr, IEEE80211_ADDR_LEN);
2072
2073 rt2860_amrr_node_init(&sc->amrr, &sc->amrr_node[wcid], ni);
2074
2075 RT2860_DPRINTF(sc, RT2860_DEBUG_RATE,
2076 "%s: initial%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2077 device_get_nameunit(sc->dev),
2078 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2079 ni->ni_associd,
2080 (ni->ni_flags & IEEE80211_NODE_HT) ?
2081 (ni->ni_htrates.rs_rates[ni->ni_txrate] | IEEE80211_RATE_MCS) :
2082 (ni->ni_rates.rs_rates[ni->ni_txrate] & IEEE80211_RATE_VAL),
2083 (ni->ni_flags & IEEE80211_NODE_HT) ?
2084 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2085 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2086
2087 rt2860_asic_updateprot(sc);
2088 rt2860_asic_updateslot(sc);
2089 rt2860_asic_set_txpreamble(sc);
2090 }
2091
2092 RT2860_DPRINTF(sc, RT2860_DEBUG_NODE,
2093 "%s: new association: isnew=%d, macaddr=%s, associd=0x%04x, staid=0x%02x, QoS %s, ERP %s, HT %s\n",
2094 device_get_nameunit(sc->dev), isnew, ether_sprintf(ni->ni_macaddr),
2095 ni->ni_associd, rni->staid,
2096 (ni->ni_flags & IEEE80211_NODE_QOS) ? "enabled" : "disabled",
2097 (ni->ni_flags & IEEE80211_NODE_ERP) ? "enabled" : "disabled",
2098 (ni->ni_flags & IEEE80211_NODE_HT) ? "enabled" : "disabled");
2099
2100 }
2101
2102 /*
2103 * rt2860_updateslot
2104 */
2105 static void rt2860_updateslot(struct ifnet *ifp)
2106 {
2107 struct rt2860_softc *sc;
2108
2109 sc = ifp->if_softc;
2110
2111 rt2860_asic_updateslot(sc);
2112 }
2113
2114 /*
2115 * rt2860_wme_update
2116 */
2117 static int rt2860_wme_update(struct ieee80211com *ic)
2118 {
2119 struct rt2860_softc *sc;
2120 struct ifnet *ifp;
2121
2122 ifp = ic->ic_ifp;
2123 sc = ifp->if_softc;
2124
2125 rt2860_asic_wme_update(sc);
2126
2127 return 0;
2128 }
2129
2130 /*
2131 * rt2860_update_beacon
2132 */
2133 static void rt2860_update_beacon(struct ieee80211com *ic, int what)
2134 {
2135 struct rt2860_softc *sc;
2136 struct ifnet *ifp;
2137 struct mbuf *m;
2138 struct ieee80211_beacon_offsets *bo;
2139
2140 ifp = ic->ic_ifp;
2141 sc = ifp->if_softc;
2142 m = sc->beacon_mbuf;
2143 bo = &sc->beacon_offsets;
2144
2145 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON,
2146 "%s: update beacon: what=%d\n",
2147 device_get_nameunit(sc->dev), what);
2148
2149 setbit(bo->bo_flags, what);
2150
2151 ieee80211_beacon_update(ic->ic_bss, bo, m, 0);
2152
2153 rt2860_asic_update_beacon(sc);
2154 }
2155
2156 /*
2157 * rt2860_key_update_begin
2158 */
2159 static void rt2860_key_update_begin(struct ieee80211com *ic)
2160 {
2161 struct rt2860_softc *sc;
2162 struct ifnet *ifp;
2163
2164 ifp = ic->ic_ifp;
2165 sc = ifp->if_softc;
2166
2167 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY,
2168 "%s: key update begin\n",
2169 device_get_nameunit(sc->dev));
2170
2171 taskqueue_block(sc->taskqueue);
2172
2173 IF_LOCK(&ifp->if_snd);
2174 }
2175
2176 /*
2177 * rt2860_key_update_end
2178 */
2179 static void rt2860_key_update_end(struct ieee80211com *ic)
2180 {
2181 struct rt2860_softc *sc;
2182 struct ifnet *ifp;
2183
2184 ifp = ic->ic_ifp;
2185 sc = ifp->if_softc;
2186
2187 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY,
2188 "%s: key update end\n",
2189 device_get_nameunit(sc->dev));
2190
2191 IF_UNLOCK(&ifp->if_snd);
2192
2193 taskqueue_unblock(sc->taskqueue);
2194 }
2195
2196 /*
2197 * rt2860_key_set
2198 */
2199 static int rt2860_key_set(struct ieee80211com *ic,
2200 const struct ieee80211_key *k, const uint8_t mac[IEEE80211_ADDR_LEN])
2201 {
2202 struct rt2860_softc *sc;
2203 struct ifnet *ifp;
2204 struct ieee80211_node *ni;
2205 struct rt2860_softc_node *rni;
2206 uint16_t key_base, keymode_base;
2207 uint8_t mode, vapid, wcid, iv[8];
2208 uint32_t tmp;
2209
2210 if (k->wk_cipher->ic_cipher != IEEE80211_CIPHER_WEP &&
2211 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_TKIP &&
2212 k->wk_cipher->ic_cipher != IEEE80211_CIPHER_AES_CCM)
2213 return 0;
2214
2215 ifp = ic->ic_ifp;
2216 sc = ifp->if_softc;
2217
2218 switch (k->wk_cipher->ic_cipher)
2219 {
2220 case IEEE80211_CIPHER_WEP:
2221 if(k->wk_keylen < 8)
2222 mode = RT2860_REG_CIPHER_MODE_WEP40;
2223 else
2224 mode = RT2860_REG_CIPHER_MODE_WEP104;
2225 break;
2226
2227 case IEEE80211_CIPHER_TKIP:
2228 mode = RT2860_REG_CIPHER_MODE_TKIP;
2229 break;
2230
2231 case IEEE80211_CIPHER_AES_CCM:
2232 mode = RT2860_REG_CIPHER_MODE_AES_CCMP;
2233 break;
2234
2235 default:
2236 return 0;
2237 }
2238
2239 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY,
2240 "%s: set key: keyix=%d, keylen=%d, macaddr=%s, mode=%d, group=%d\n",
2241 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen, ether_sprintf(mac),
2242 mode, (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
2243
2244 if (!(k->wk_flags & IEEE80211_KEY_GROUP))
2245 {
2246 /* install pairwise key */
2247
2248 ni = ieee80211_find_node(&ic->ic_sta, mac);
2249 rni = (struct rt2860_softc_node *) ni;
2250
2251 vapid = 0;
2252 wcid = rni->staid;
2253 key_base = RT2860_REG_PKEY(wcid);
2254
2255 ieee80211_free_node(ni);
2256
2257 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)
2258 {
2259 memset(iv, 0, 8);
2260
2261 iv[3] = (k->wk_keyix << 6);
2262 }
2263 else
2264 {
2265 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2266 {
2267 iv[0] = (k->wk_keytsc >> 8);
2268 iv[1] = ((iv[0] | 0x20) & 0x7f);
2269 iv[2] = k->wk_keytsc;
2270 }
2271 else
2272 {
2273 /* AES CCMP */
2274
2275 iv[0] = k->wk_keytsc;
2276 iv[1] = k->wk_keytsc >> 8;
2277 iv[2] = 0;
2278 }
2279
2280 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV);
2281 iv[4] = (k->wk_keytsc >> 16);
2282 iv[5] = (k->wk_keytsc >> 24);
2283 iv[6] = (k->wk_keytsc >> 32);
2284 iv[7] = (k->wk_keytsc >> 40);
2285
2286 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY,
2287 "%s: set key: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
2288 device_get_nameunit(sc->dev),
2289 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
2290 }
2291
2292 rt2860_io_mac_write_multi(sc, RT2860_REG_IVEIV(wcid), iv, 8);
2293
2294 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2295 {
2296 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, 16);
2297
2298 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2299 {
2300 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
2301 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
2302 }
2303 else
2304 {
2305 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
2306 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
2307 }
2308 }
2309 else
2310 {
2311 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
2312 }
2313
2314 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) |
2315 (mode << RT2860_REG_CIPHER_MODE_SHIFT) | RT2860_REG_PKEY_ENABLE;
2316
2317 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp);
2318 }
2319
2320 if ((k->wk_flags & IEEE80211_KEY_GROUP) ||
2321 (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP))
2322 {
2323 /* install group key */
2324
2325 vapid = 0;
2326 wcid = RT2860_WCID_MCAST;
2327 key_base = RT2860_REG_SKEY(vapid, k->wk_keyix);
2328 keymode_base = RT2860_REG_SKEY_MODE(vapid);
2329
2330 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2331 {
2332 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, 16);
2333
2334 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2335 {
2336 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[16], 8);
2337 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[24], 8);
2338 }
2339 else
2340 {
2341 rt2860_io_mac_write_multi(sc, key_base + 16, &k->wk_key[24], 8);
2342 rt2860_io_mac_write_multi(sc, key_base + 24, &k->wk_key[16], 8);
2343 }
2344 }
2345 else
2346 {
2347 rt2860_io_mac_write_multi(sc, key_base, k->wk_key, k->wk_keylen);
2348 }
2349
2350 tmp = rt2860_io_mac_read(sc, keymode_base);
2351
2352 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2353 tmp |= (mode << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2354
2355 rt2860_io_mac_write(sc, keymode_base, tmp);
2356
2357 if (ic->ic_opmode == IEEE80211_M_HOSTAP)
2358 {
2359 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_WEP)
2360 {
2361 memset(iv, 0, 8);
2362
2363 iv[3] = (k->wk_keyix << 6);
2364 }
2365 else
2366 {
2367 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP)
2368 {
2369 iv[0] = (k->wk_keytsc >> 8);
2370 iv[1] = ((iv[0] | 0x20) & 0x7f);
2371 iv[2] = k->wk_keytsc;
2372 }
2373 else
2374 {
2375 /* AES CCMP */
2376
2377 iv[0] = k->wk_keytsc;
2378 iv[1] = k->wk_keytsc >> 8;
2379 iv[2] = 0;
2380 }
2381
2382 iv[3] = ((k->wk_keyix << 6) | IEEE80211_WEP_EXTIV);
2383 iv[4] = (k->wk_keytsc >> 16);
2384 iv[5] = (k->wk_keytsc >> 24);
2385 iv[6] = (k->wk_keytsc >> 32);
2386 iv[7] = (k->wk_keytsc >> 40);
2387
2388 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY,
2389 "%s: set key: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
2390 device_get_nameunit(sc->dev),
2391 iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
2392 }
2393
2394 rt2860_io_mac_write_multi(sc, RT2860_REG_IVEIV(wcid), iv, 8);
2395
2396 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) |
2397 (mode << RT2860_REG_CIPHER_MODE_SHIFT);
2398
2399 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp);
2400 }
2401 }
2402
2403 return 1;
2404 }
2405
2406 /*
2407 * rt2860_key_delete
2408 */
2409 static int rt2860_key_delete(struct ieee80211com *ic,
2410 const struct ieee80211_key *k)
2411 {
2412 struct rt2860_softc *sc;
2413 uint8_t vapid, wcid;
2414 uint32_t tmp;
2415
2416 sc = ic->ic_ifp->if_softc;
2417
2418 RT2860_DPRINTF(sc, RT2860_DEBUG_KEY,
2419 "%s: delete key: keyix=%d, keylen=%d, group=%d\n",
2420 device_get_nameunit(sc->dev), k->wk_keyix, k->wk_keylen,
2421 (k->wk_flags & IEEE80211_KEY_GROUP) ? 1 : 0);
2422
2423 if (k->wk_flags & IEEE80211_KEY_GROUP)
2424 {
2425 /* remove group key */
2426
2427 vapid = 0;
2428 wcid = RT2860_WCID_MCAST;
2429
2430 tmp = rt2860_io_mac_read(sc, RT2860_REG_SKEY_MODE(vapid));
2431
2432 tmp &= ~(0xf << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2433 tmp |= (RT2860_REG_CIPHER_MODE_NONE << (k->wk_keyix * 4 + 16 * (vapid % 2)));
2434
2435 rt2860_io_mac_write(sc, RT2860_REG_SKEY_MODE(vapid), tmp);
2436
2437 if (ic->ic_opmode == IEEE80211_M_HOSTAP)
2438 {
2439 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) |
2440 (RT2860_REG_CIPHER_MODE_NONE << RT2860_REG_CIPHER_MODE_SHIFT) | RT2860_REG_PKEY_ENABLE;
2441
2442 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp);
2443 }
2444 }
2445
2446 return 1;
2447 }
2448
2449 /*
2450 * rt2860_raw_xmit
2451 */
2452 static int rt2860_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
2453 const struct ieee80211_bpf_params *params)
2454 {
2455 return 0;
2456 }
2457
2458 /*
2459 * rt2860_media_change
2460 */
2461 static int rt2860_media_change(struct ifnet *ifp)
2462 {
2463 struct rt2860_softc *sc;
2464 int error;
2465
2466 sc = ifp->if_softc;
2467
2468 error = ieee80211_media_change(ifp);
2469 if (error != ENETRESET)
2470 return error;
2471
2472 RT2860_SOFTC_LOCK(sc);
2473
2474 if ((ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING))
2475 {
2476 rt2860_stop_locked(sc);
2477 rt2860_init_locked(sc);
2478 }
2479
2480 RT2860_SOFTC_UNLOCK(sc);
2481
2482 return 0;
2483 }
2484
2485 /*
2486 * rt2860_node_alloc
2487 */
2488 static struct ieee80211_node *rt2860_node_alloc(struct ieee80211_node_table *nt)
2489 {
2490 return malloc(sizeof(struct rt2860_softc_node),
2491 M_80211_NODE, M_NOWAIT | M_ZERO);
2492 }
2493
2494 /*
2495 * rt2860_node_cleanup
2496 */
2497 static void rt2860_node_cleanup(struct ieee80211_node *ni)
2498 {
2499 struct rt2860_softc *sc;
2500 struct ieee80211com *ic;
2501 struct ifnet *ifp;
2502 struct rt2860_softc_node *rni;
2503 uint8_t vapid, wcid;
2504 uint32_t tmp;
2505
2506 ic = ni->ni_ic;
2507 ifp = ic->ic_ifp;
2508 sc = ifp->if_softc;
2509 rni = (struct rt2860_softc_node *) ni;
2510
2511 RT2860_DPRINTF(sc, RT2860_DEBUG_NODE,
2512 "%s: node cleanup: macaddr=%s, associd=0x%04x, staid=0x%02x\n",
2513 device_get_nameunit(sc->dev), ether_sprintf(ni->ni_macaddr),
2514 ni->ni_associd, rni->staid);
2515
2516 if (rni->staid != 0)
2517 {
2518 vapid = 0;
2519 wcid = rni->staid;
2520
2521 tmp = ((vapid & RT2860_REG_VAP_MASK) << RT2860_REG_VAP_SHIFT) |
2522 (RT2860_REG_CIPHER_MODE_NONE << RT2860_REG_CIPHER_MODE_SHIFT) | RT2860_REG_PKEY_ENABLE;
2523
2524 rt2860_io_mac_write(sc, RT2860_REG_WCID_ATTR(wcid), tmp);
2525
2526 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid), 0xffffffff);
2527 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, 0x0000ffff);
2528
2529 rt2860_staid_delete(sc, rni->staid);
2530
2531 rni->staid = 0;
2532 }
2533
2534 sc->node_cleanup(ni);
2535 }
2536
2537 /*
2538 * rt2860_recv_action
2539 */
2540 static void rt2860_recv_action(struct ieee80211_node *ni,
2541 const uint8_t *frm, const uint8_t *efrm)
2542 {
2543 struct rt2860_softc *sc;
2544 struct ieee80211com *ic;
2545 struct ifnet *ifp;
2546 struct rt2860_softc_node *rni;
2547 const struct ieee80211_action *ia;
2548 struct ieee80211_tx_ampdu *tx_ampdu;
2549 uint16_t status, baparamset;
2550 uint8_t wcid;
2551 int tid, bufsize, ac;
2552 uint32_t tmp;
2553
2554 ic = ni->ni_ic;
2555 ifp = ic->ic_ifp;
2556 sc = ifp->if_softc;
2557 rni = (struct rt2860_softc_node *) ni;
2558
2559 ia = (const struct ieee80211_action *) frm;
2560
2561 sc->recv_action(ni, frm, efrm);
2562
2563 if (ia->ia_category != IEEE80211_ACTION_CAT_BA)
2564 return;
2565
2566 switch (ia->ia_action)
2567 {
2568 /* IEEE80211_ACTION_BA_ADDBA_RESPONSE */
2569 case IEEE80211_ACTION_BA_ADDBA_RESPONSE:
2570 status = LE_READ_2(frm + 3);
2571 baparamset = LE_READ_2(frm + 4);
2572 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID);
2573 bufsize = RT2860_MS(baparamset, IEEE80211_BAPS_BUFSIZ);
2574 ac = TID_TO_WME_AC(tid);
2575 tx_ampdu = &ni->ni_tx_ampdu[ac];
2576
2577 RT2860_DPRINTF(sc, RT2860_DEBUG_BA,
2578 "%s: received ADDBA response: associd=0x%04x, staid=0x%02x, status=%d, tid=%d, bufsize=%d\n",
2579 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, status, tid, bufsize);
2580
2581 if (sc->mac_rev >= 0x28720200)
2582 {
2583 if (tx_ampdu->txa_wnd > 13)
2584 tx_ampdu->txa_wnd = 13;
2585 }
2586 else
2587 {
2588 if (tx_ampdu->txa_wnd > 7)
2589 tx_ampdu->txa_wnd = 7;
2590 }
2591
2592 if (status == IEEE80211_STATUS_SUCCESS)
2593 {
2594 sc->tx_ampdu_sessions++;
2595
2596 rt2860_asic_updateprot(sc);
2597 }
2598 break;
2599
2600 /* IEEE80211_ACTION_BA_DELBA */
2601 case IEEE80211_ACTION_BA_DELBA:
2602 baparamset = LE_READ_2(frm + 2);
2603 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID);
2604 wcid = rni->staid;
2605
2606 RT2860_DPRINTF(sc, RT2860_DEBUG_BA,
2607 "%s: received DELBA request: associd=0x%04x, staid=0x%02x, tid=%d\n",
2608 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid);
2609
2610 tmp = rt2860_io_mac_read(sc, RT2860_REG_WCID(wcid) + 4);
2611
2612 tmp &= ~(0x10000 << tid);
2613
2614 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, tmp);
2615 break;
2616 }
2617 }
2618
2619 /*
2620 * rt2860_send_action
2621 */
2622 static int rt2860_send_action(struct ieee80211_node *ni,
2623 int category, int action, uint16_t args[4])
2624 {
2625 struct rt2860_softc *sc;
2626 struct ieee80211com *ic;
2627 struct ifnet *ifp;
2628 struct rt2860_softc_node *rni;
2629 uint16_t status, baparamset;
2630 uint8_t wcid;
2631 int ret, tid, bufsize;
2632 uint32_t tmp;
2633
2634 ic = ni->ni_ic;
2635 ifp = ic->ic_ifp;
2636 sc = ifp->if_softc;
2637 rni = (struct rt2860_softc_node *) ni;
2638
2639 ret = sc->send_action(ni, category, action, args);
2640
2641 if (category != IEEE80211_ACTION_CAT_BA)
2642 return ret;
2643
2644 wcid = rni->staid;
2645
2646 switch (action)
2647 {
2648 /* IEEE80211_ACTION_BA_ADDBA_RESPONSE */
2649 case IEEE80211_ACTION_BA_ADDBA_RESPONSE:
2650 status = args[1];
2651 baparamset = args[2];
2652 tid = RT2860_MS(baparamset, IEEE80211_BAPS_TID);
2653 bufsize = RT2860_MS(baparamset, IEEE80211_BAPS_BUFSIZ);
2654
2655 RT2860_DPRINTF(sc, RT2860_DEBUG_BA,
2656 "%s: sending ADDBA response: associd=0x%04x, staid=0x%02x, status=%d, tid=%d, bufsize=%d\n",
2657 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, status, tid, bufsize);
2658
2659 if (status == IEEE80211_STATUS_SUCCESS)
2660 {
2661 tmp = rt2860_io_mac_read(sc, RT2860_REG_WCID(wcid) + 4);
2662
2663 tmp |= (0x10000 << tid);
2664
2665 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, tmp);
2666 }
2667 break;
2668
2669 /* IEEE80211_ACTION_BA_DELBA */
2670 case IEEE80211_ACTION_BA_DELBA:
2671 baparamset = RT2860_SM(args[0], IEEE80211_DELBAPS_TID) | args[1];
2672
2673 tid = RT2860_MS(baparamset, IEEE80211_DELBAPS_TID);
2674
2675 RT2860_DPRINTF(sc, RT2860_DEBUG_BA,
2676 "%s: sending DELBA request: associd=0x%04x, staid=0x%02x, tid=%d\n",
2677 device_get_nameunit(sc->dev), ni->ni_associd, rni->staid, tid);
2678
2679 if (RT2860_MS(baparamset, IEEE80211_DELBAPS_INIT) != IEEE80211_DELBAPS_INIT)
2680 {
2681 tmp = rt2860_io_mac_read(sc, RT2860_REG_WCID(wcid) + 4);
2682
2683 tmp &= ~(0x10000 << tid);
2684
2685 rt2860_io_mac_write(sc, RT2860_REG_WCID(wcid) + 4, tmp);
2686 }
2687 else
2688 {
2689 sc->tx_ampdu_sessions--;
2690
2691 rt2860_asic_updateprot(sc);
2692 }
2693 break;
2694 }
2695
2696 return ret;
2697 }
2698
2699 /*
2700 * rt2860_amrr_update_iter_func
2701 */
2702 static void rt2860_amrr_update_iter_func(void *arg, struct ieee80211_node *ni)
2703 {
2704 struct rt2860_softc *sc;
2705 struct ieee80211com *ic;
2706 struct rt2860_softc_node *rni;
2707 uint8_t wcid;
2708
2709 sc = arg;
2710 ic = &sc->ic;
2711 rni = (struct rt2860_softc_node *) ni;
2712
2713 /* only associated stations */
2714
2715 if (rni->staid != 0)
2716 {
2717 wcid = rni->staid;
2718
2719 RT2860_DPRINTF(sc, RT2860_DEBUG_RATE,
2720 "%s: AMRR node: staid=0x%02x, txcnt=%d, success=%d, retrycnt=%d\n",
2721 device_get_nameunit(sc->dev),
2722 rni->staid, sc->amrr_node[wcid].txcnt, sc->amrr_node[wcid].success, sc->amrr_node[wcid].retrycnt);
2723
2724 rt2860_amrr_choose(ni, &sc->amrr_node[wcid]);
2725
2726 RT2860_DPRINTF(sc, RT2860_DEBUG_RATE,
2727 "%s:%s node Tx rate: associd=0x%04x, staid=0x%02x, rate=0x%02x, max rate=0x%02x\n",
2728 device_get_nameunit(sc->dev),
2729 (ni->ni_flags & IEEE80211_NODE_HT) ? " HT" : "",
2730 ni->ni_associd, rni->staid,
2731 (ni->ni_flags & IEEE80211_NODE_HT) ?
2732 (ni->ni_htrates.rs_rates[ni->ni_txrate] | IEEE80211_RATE_MCS) :
2733 (ni->ni_rates.rs_rates[ni->ni_txrate] & IEEE80211_RATE_VAL),
2734 (ni->ni_flags & IEEE80211_NODE_HT) ?
2735 (ni->ni_htrates.rs_rates[ni->ni_htrates.rs_nrates - 1] | IEEE80211_RATE_MCS) :
2736 (ni->ni_rates.rs_rates[ni->ni_rates.rs_nrates - 1] & IEEE80211_RATE_VAL));
2737 }
2738 }
2739
2740 /*
2741 * rt2860_periodic
2742 */
2743 static void rt2860_periodic(void *arg)
2744 {
2745 struct rt2860_softc *sc;
2746
2747 sc = arg;
2748
2749 RT2860_DPRINTF(sc, RT2860_DEBUG_PERIODIC,
2750 "%s: periodic\n",
2751 device_get_nameunit(sc->dev));
2752
2753 taskqueue_enqueue(sc->taskqueue, &sc->periodic_task);
2754 }
2755
2756 /*
2757 * rt2860_tx_watchdog
2758 */
2759 static void rt2860_tx_watchdog(void *arg)
2760 {
2761 struct rt2860_softc *sc;
2762 struct ifnet *ifp;
2763
2764 sc = arg;
2765 ifp = sc->ifp;
2766
2767 if (sc->tx_timer == 0)
2768 return;
2769
2770 if (--sc->tx_timer == 0)
2771 {
2772 printf("%s: Tx watchdog timeout: resetting\n",
2773 device_get_nameunit(sc->dev));
2774
2775 rt2860_stop_locked(sc);
2776 rt2860_init_locked(sc);
2777
2778 ifp->if_oerrors++;
2779
2780 sc->tx_watchdog_timeouts++;
2781 }
2782
2783 callout_reset(&sc->tx_watchdog_ch, hz, rt2860_tx_watchdog, sc);
2784 }
2785
2786 /*
2787 * rt2860_staid_alloc
2788 */
2789 static int rt2860_staid_alloc(struct rt2860_softc *sc, int aid)
2790 {
2791 int staid;
2792
2793 if ((aid > 0 && aid < RT2860_SOFTC_STAID_COUNT) && isclr(sc->staid_mask, aid))
2794 {
2795 staid = aid;
2796 }
2797 else
2798 {
2799 for (staid = 1; staid < RT2860_SOFTC_STAID_COUNT; staid++)
2800 {
2801 if (isclr(sc->staid_mask, staid))
2802 break;
2803 }
2804 }
2805
2806 setbit(sc->staid_mask, staid);
2807
2808 return staid;
2809 }
2810
2811 /*
2812 * rt2860_staid_delete
2813 */
2814 static void rt2860_staid_delete(struct rt2860_softc *sc, int staid)
2815 {
2816 clrbit(sc->staid_mask, staid);
2817 }
2818
2819 /*
2820 * rt2860_asic_set_bssid
2821 */
2822 static void rt2860_asic_set_bssid(struct rt2860_softc *sc,
2823 const uint8_t *bssid)
2824 {
2825 uint32_t tmp;
2826
2827 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE,
2828 "%s: set bssid: bssid=%s\n",
2829 device_get_nameunit(sc->dev), ether_sprintf(bssid));
2830
2831 tmp = bssid[0] | (bssid[1]) << 8 | (bssid[2] << 16) | (bssid[3] << 24);
2832
2833 rt2860_io_mac_write(sc, RT2860_REG_BSSID_DW0, tmp);
2834
2835 tmp = bssid[4] | (bssid[5] << 8);
2836
2837 rt2860_io_mac_write(sc, RT2860_REG_BSSID_DW1, tmp);
2838 }
2839
2840 /*
2841 * rt2860_asic_set_macaddr
2842 */
2843 static void rt2860_asic_set_macaddr(struct rt2860_softc *sc,
2844 const uint8_t *addr)
2845 {
2846 uint32_t tmp;
2847
2848 tmp = addr[0] | (addr[1] << 8) | (addr[2] << 16) | (addr[3] << 24);
2849
2850 rt2860_io_mac_write(sc, RT2860_REG_ADDR_DW0, tmp);
2851
2852 tmp = addr[4] | (addr[5] << 8);
2853
2854 rt2860_io_mac_write(sc, RT2860_REG_ADDR_DW1, tmp);
2855 }
2856
2857 /*
2858 * rt2860_asic_enable_tsf_sync
2859 */
2860 static void rt2860_asic_enable_tsf_sync(struct rt2860_softc *sc)
2861 {
2862 struct ieee80211com *ic;
2863 uint32_t tmp;
2864
2865 ic = &sc->ic;
2866
2867 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON,
2868 "%s: enabling TSF\n",
2869 device_get_nameunit(sc->dev));
2870
2871 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG);
2872
2873 tmp &= ~0x1fffff;
2874 tmp |= ic->ic_bss->ni_intval * 16;
2875 tmp |= (RT2860_REG_TSF_TIMER_ENABLE | RT2860_REG_TBTT_TIMER_ENABLE);
2876
2877 if (ic->ic_opmode == IEEE80211_M_STA)
2878 {
2879 tmp |= (RT2860_REG_TSF_SYNC_MODE_STA << RT2860_REG_TSF_SYNC_MODE_SHIFT);
2880 }
2881 else if (ic->ic_opmode == IEEE80211_M_IBSS)
2882 {
2883 tmp |= RT2860_REG_BCN_TX_ENABLE;
2884 tmp |= (RT2860_REG_TSF_SYNC_MODE_IBSS << RT2860_REG_TSF_SYNC_MODE_SHIFT);
2885 }
2886 else if (ic->ic_opmode == IEEE80211_M_HOSTAP)
2887 {
2888 tmp |= RT2860_REG_BCN_TX_ENABLE;
2889 tmp |= (RT2860_REG_TSF_SYNC_MODE_HOSTAP << RT2860_REG_TSF_SYNC_MODE_SHIFT);
2890 }
2891
2892 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp);
2893 }
2894
2895 /*
2896 * rt2860_asic_disable_tsf_sync
2897 */
2898 static void rt2860_asic_disable_tsf_sync(struct rt2860_softc *sc)
2899 {
2900 uint32_t tmp;
2901
2902 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON,
2903 "%s: disabling TSF\n",
2904 device_get_nameunit(sc->dev));
2905
2906 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG);
2907
2908 tmp &= ~(RT2860_REG_BCN_TX_ENABLE |
2909 RT2860_REG_TSF_TIMER_ENABLE |
2910 RT2860_REG_TBTT_TIMER_ENABLE);
2911
2912 tmp &= ~(RT2860_REG_TSF_SYNC_MODE_MASK << RT2860_REG_TSF_SYNC_MODE_SHIFT);
2913 tmp |= (RT2860_REG_TSF_SYNC_MODE_DISABLE << RT2860_REG_TSF_SYNC_MODE_SHIFT);
2914
2915 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp);
2916 }
2917
2918 /*
2919 * rt2860_asic_enable_mrr
2920 */
2921 static void rt2860_asic_enable_mrr(struct rt2860_softc *sc)
2922 {
2923 #define CCK(mcs) (mcs)
2924 #define OFDM(mcs) ((1 << 3) | (mcs))
2925 #define HT(mcs) (mcs)
2926
2927 rt2860_io_mac_write(sc, RT2860_REG_TX_LG_FBK_CFG0,
2928 (OFDM(6) << 28) | /* 54 -> 48 */
2929 (OFDM(5) << 24) | /* 48 -> 36 */
2930 (OFDM(4) << 20) | /* 36 -> 24 */
2931 (OFDM(3) << 16) | /* 24 -> 18 */
2932 (OFDM(2) << 12) | /* 18 -> 12 */
2933 (OFDM(1) << 8) | /* 12 -> 9 */
2934 (OFDM(0) << 4) | /* 9 -> 6 */
2935 OFDM(0)); /* 6 -> 6 */
2936
2937 rt2860_io_mac_write(sc, RT2860_REG_TX_LG_FBK_CFG1,
2938 (CCK(2) << 12) | /* 11 -> 5.5 */
2939 (CCK(1) << 8) | /* 5.5 -> 2 */
2940 (CCK(0) << 4) | /* 2 -> 1 */
2941 CCK(0)); /* 1 -> 1 */
2942
2943 rt2860_io_mac_write(sc, RT2860_REG_TX_HT_FBK_CFG0,
2944 (HT(6) << 28) |
2945 (HT(5) << 24) |
2946 (HT(4) << 20) |
2947 (HT(3) << 16) |
2948 (HT(2) << 12) |
2949 (HT(1) << 8) |
2950 (HT(0) << 4) |
2951 HT(0));
2952
2953 rt2860_io_mac_write(sc, RT2860_REG_TX_HT_FBK_CFG1,
2954 (HT(14) << 28) |
2955 (HT(13) << 24) |
2956 (HT(12) << 20) |
2957 (HT(11) << 16) |
2958 (HT(10) << 12) |
2959 (HT(9) << 8) |
2960 (HT(8) << 4) |
2961 HT(7));
2962
2963 #undef HT
2964 #undef OFDM
2965 #undef CCK
2966 }
2967
2968 /*
2969 * rt2860_asic_set_txpreamble
2970 */
2971 static void rt2860_asic_set_txpreamble(struct rt2860_softc *sc)
2972 {
2973 struct ieee80211com *ic;
2974 uint32_t tmp;
2975
2976 ic = &sc->ic;
2977
2978 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE,
2979 "%s: %s short Tx preamble\n",
2980 device_get_nameunit(sc->dev),
2981 (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "enabling" : "disabling");
2982
2983 tmp = rt2860_io_mac_read(sc, RT2860_REG_AUTO_RSP_CFG);
2984
2985 tmp &= ~RT2860_REG_CCK_SHORT_ENABLE;
2986
2987 if (sc->ic.ic_flags & IEEE80211_F_SHPREAMBLE)
2988 tmp |= RT2860_REG_CCK_SHORT_ENABLE;
2989
2990 rt2860_io_mac_write(sc, RT2860_REG_AUTO_RSP_CFG, tmp);
2991 }
2992
2993 /*
2994 * rt2860_asic_set_basicrates
2995 */
2996 static void rt2860_asic_set_basicrates(struct rt2860_softc *sc)
2997 {
2998 struct ieee80211com *ic;
2999
3000 ic = &sc->ic;
3001
3002 if (ic->ic_curmode == IEEE80211_MODE_11B)
3003 rt2860_io_mac_write(sc, RT2860_REG_LEGACY_BASIC_RATE, 0x3);
3004 else if (ic->ic_curmode == IEEE80211_MODE_11A)
3005 rt2860_io_mac_write(sc, RT2860_REG_LEGACY_BASIC_RATE, 0x150);
3006 else
3007 rt2860_io_mac_write(sc, RT2860_REG_LEGACY_BASIC_RATE, 0x15f);
3008 }
3009
3010 /*
3011 * rt2860_asic_update_rtsthreshold
3012 */
3013 static void rt2860_asic_update_rtsthreshold(struct rt2860_softc *sc)
3014 {
3015 struct ieee80211com *ic;
3016 uint32_t tmp;
3017 uint16_t threshold;
3018
3019 ic = &sc->ic;
3020
3021 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT,
3022 "%s: updating RTS threshold: %d\n",
3023 device_get_nameunit(sc->dev), ic->ic_rtsthreshold);
3024
3025 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_RTS_CFG);
3026
3027 tmp &= ~(RT2860_REG_TX_RTS_THRESHOLD_MASK << RT2860_REG_TX_RTS_THRESHOLD_SHIFT);
3028
3029 if (ic->ic_flags_ext & IEEE80211_FEXT_AMSDU_TX)
3030 threshold = 0x1000;
3031 else
3032 threshold = ic->ic_rtsthreshold;
3033
3034
3035 tmp |= ((threshold & RT2860_REG_TX_RTS_THRESHOLD_MASK) <<
3036 RT2860_REG_TX_RTS_THRESHOLD_SHIFT);
3037
3038 rt2860_io_mac_write(sc, RT2860_REG_TX_RTS_CFG, tmp);
3039 }
3040
3041 /*
3042 * rt2860_asic_update_txpower
3043 */
3044 static void rt2860_asic_update_txpower(struct rt2860_softc *sc)
3045 {
3046 struct ieee80211com *ic;
3047 uint32_t *txpow_rate;
3048 int8_t delta;
3049 uint8_t val;
3050 uint32_t tmp;
3051 int i;
3052
3053 ic = &sc->ic;
3054
3055 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE,
3056 "%s: updating Tx power: %d\n",
3057 device_get_nameunit(sc->dev), ic->ic_txpowlimit);
3058
3059 if (!IEEE80211_IS_CHAN_HT40(ic->ic_curchan))
3060 {
3061 txpow_rate = sc->txpow_rate_20mhz;
3062 }
3063 else
3064 {
3065 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan))
3066 txpow_rate = sc->txpow_rate_40mhz_2ghz;
3067 else
3068 txpow_rate = sc->txpow_rate_40mhz_5ghz;
3069 }
3070
3071 delta = 0;
3072
3073 val = rt2860_io_bbp_read(sc, 1);
3074 val &= 0xfc;
3075
3076 if (ic->ic_txpowlimit > 90)
3077 {
3078 /* do nothing */
3079 }
3080 else if (ic->ic_txpowlimit > 60)
3081 {
3082 delta -= 1;
3083 }
3084 else if (ic->ic_txpowlimit > 30)
3085 {
3086 delta -= 3;
3087 }
3088 else if (ic->ic_txpowlimit > 15)
3089 {
3090 val |= 0x1;
3091 }
3092 else if (ic->ic_txpowlimit > 9)
3093 {
3094 val |= 0x1;
3095 delta -= 3;
3096 }
3097 else
3098 {
3099 val |= 0x2;
3100 }
3101
3102 rt2860_io_bbp_write(sc, 1, val);
3103
3104 for (i = 0; i < RT2860_SOFTC_TXPOW_RATE_COUNT; i++)
3105 {
3106 if (txpow_rate[i] == 0xffffffff)
3107 continue;
3108
3109 tmp = rt2860_read_eeprom_txpow_rate_add_delta(txpow_rate[i], delta);
3110
3111 rt2860_io_mac_write(sc, RT2860_REG_TX_PWR_CFG(i), tmp);
3112 }
3113 }
3114
3115 /*
3116 * rt2860_asic_update_promisc
3117 */
3118 static void rt2860_asic_update_promisc(struct rt2860_softc *sc)
3119 {
3120 struct ifnet *ifp;
3121 uint32_t tmp;
3122
3123 ifp = sc->ic.ic_ifp;
3124
3125 printf("%s: %s promiscuous mode\n",
3126 device_get_nameunit(sc->dev),
3127 (ifp->if_flags & IFF_PROMISC) ? "entering" : "leaving");
3128
3129 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_FILTER_CFG);
3130
3131 tmp &= ~RT2860_REG_RX_FILTER_DROP_UC_NOME;
3132
3133 if (!(ifp->if_flags & IFF_PROMISC))
3134 tmp |= RT2860_REG_RX_FILTER_DROP_UC_NOME;
3135
3136 rt2860_io_mac_write(sc, RT2860_REG_RX_FILTER_CFG, tmp);
3137 }
3138
3139 /*
3140 * rt2860_asic_updateprot
3141 */
3142 static void rt2860_asic_updateprot(struct rt2860_softc *sc)
3143 {
3144 struct ieee80211com *ic;
3145 uint32_t cck_prot, ofdm_prot, mm20_prot, mm40_prot, gf20_prot, gf40_prot;
3146 uint8_t htopmode;
3147 enum ieee80211_protmode htprotmode;
3148
3149 ic = &sc->ic;
3150
3151 /* CCK frame protection */
3152
3153 cck_prot = RT2860_REG_RTSTH_ENABLE | RT2860_REG_PROT_NAV_SHORT |
3154 RT2860_REG_TXOP_ALLOW_ALL | RT2860_REG_PROT_CTRL_NONE;
3155
3156 /* set up protection frame phy mode and rate (MCS code) */
3157
3158 if (ic->ic_curmode == IEEE80211_MODE_11A)
3159 cck_prot |= (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3160 (0 << RT2860_REG_PROT_MCS_SHIFT);
3161 else
3162 cck_prot |= ((RT2860_REG_PROT_PHYMODE_CCK << RT2860_REG_PROT_PHYMODE_SHIFT) |
3163 (3 << RT2860_REG_PROT_MCS_SHIFT));
3164
3165 rt2860_io_mac_write(sc, RT2860_REG_TX_CCK_PROT_CFG, cck_prot);
3166
3167 /* OFDM frame protection */
3168
3169 ofdm_prot = RT2860_REG_RTSTH_ENABLE | RT2860_REG_PROT_NAV_SHORT |
3170 RT2860_REG_TXOP_ALLOW_ALL;
3171
3172 if (ic->ic_flags & IEEE80211_F_USEPROT)
3173 {
3174 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT,
3175 "%s: updating protection mode: b/g protection mode=%s\n",
3176 device_get_nameunit(sc->dev),
3177 (ic->ic_protmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3178 ((ic->ic_protmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3179
3180 if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
3181 ofdm_prot |= RT2860_REG_PROT_CTRL_RTS_CTS;
3182 else if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
3183 ofdm_prot |= RT2860_REG_PROT_CTRL_CTS;
3184 else
3185 ofdm_prot |= RT2860_REG_PROT_CTRL_NONE;
3186 }
3187 else
3188 {
3189 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT,
3190 "%s: updating protection mode: b/g protection mode=%s\n",
3191 device_get_nameunit(sc->dev), "none");
3192
3193 ofdm_prot |= RT2860_REG_PROT_CTRL_NONE;
3194 }
3195
3196 rt2860_io_mac_write(sc, RT2860_REG_TX_OFDM_PROT_CFG, ofdm_prot);
3197
3198 /* HT frame protection */
3199
3200 if ((ic->ic_opmode == IEEE80211_M_STA) && (ic->ic_state == IEEE80211_S_RUN))
3201 htopmode = ic->ic_bss->ni_htopmode;
3202 else
3203 htopmode = ic->ic_curhtprotmode;
3204
3205 htprotmode = ic->ic_htprotmode;
3206
3207 /* force HT mixed mode and RTS/CTS protection if A-MPDU Tx aggregation is enabled */
3208
3209 if (sc->tx_ampdu_sessions > 0)
3210 {
3211 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT,
3212 "%s: updating protection mode: forcing HT mixed mode and RTS/CTS protection\n",
3213 device_get_nameunit(sc->dev));
3214
3215 htopmode = IEEE80211_HTINFO_OPMODE_MIXED;
3216 htprotmode = IEEE80211_PROT_RTSCTS;
3217 }
3218
3219 RT2860_DPRINTF(sc, RT2860_DEBUG_PROT,
3220 "%s: updating protection mode: HT operation mode=0x%02x, protection mode=%s\n",
3221 device_get_nameunit(sc->dev),
3222 htopmode & IEEE80211_HTINFO_OPMODE,
3223 (htprotmode == IEEE80211_PROT_RTSCTS) ? "RTS/CTS" :
3224 ((htprotmode == IEEE80211_PROT_CTSONLY) ? "CTS-to-self" : "none"));
3225
3226 switch (htopmode & IEEE80211_HTINFO_OPMODE)
3227 {
3228 /* IEEE80211_HTINFO_OPMODE_HT20PR */
3229 case IEEE80211_HTINFO_OPMODE_HT20PR:
3230 mm20_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_PROT_CTRL_NONE |
3231 RT2860_REG_TXOP_ALLOW_CCK | RT2860_REG_TXOP_ALLOW_OFDM |
3232 RT2860_REG_TXOP_ALLOW_MM20 | RT2860_REG_TXOP_ALLOW_GF20 |
3233 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3234 (4 << RT2860_REG_PROT_MCS_SHIFT);
3235
3236 gf20_prot = mm20_prot;
3237
3238 mm40_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_TXOP_ALLOW_ALL |
3239 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3240 (0x84 << RT2860_REG_PROT_MCS_SHIFT);
3241
3242 if (htprotmode == IEEE80211_PROT_RTSCTS)
3243 mm40_prot |= RT2860_REG_PROT_CTRL_RTS_CTS;
3244 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3245 mm40_prot |= RT2860_REG_PROT_CTRL_CTS;
3246 else
3247 mm40_prot |= RT2860_REG_PROT_CTRL_NONE;
3248
3249 gf40_prot = mm40_prot;
3250 break;
3251
3252 /* IEEE80211_HTINFO_OPMODE_MIXED */
3253 case IEEE80211_HTINFO_OPMODE_MIXED:
3254 mm20_prot = RT2860_REG_PROT_NAV_SHORT |
3255 RT2860_REG_TXOP_ALLOW_CCK | RT2860_REG_TXOP_ALLOW_OFDM |
3256 RT2860_REG_TXOP_ALLOW_MM20 | RT2860_REG_TXOP_ALLOW_GF20;
3257
3258 if (ic->ic_flags & IEEE80211_F_USEPROT)
3259 mm20_prot |= (RT2860_REG_PROT_PHYMODE_CCK << RT2860_REG_PROT_PHYMODE_SHIFT) |
3260 (3 << RT2860_REG_PROT_MCS_SHIFT);
3261 else
3262 mm20_prot |= (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3263 (4 << RT2860_REG_PROT_MCS_SHIFT);
3264
3265 if (htprotmode == IEEE80211_PROT_RTSCTS)
3266 mm20_prot |= RT2860_REG_PROT_CTRL_RTS_CTS;
3267 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3268 mm20_prot |= RT2860_REG_PROT_CTRL_CTS;
3269 else
3270 mm20_prot |= RT2860_REG_PROT_CTRL_NONE;
3271
3272 gf20_prot = mm20_prot;
3273
3274 mm40_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_TXOP_ALLOW_ALL;
3275
3276 if (ic->ic_flags & IEEE80211_F_USEPROT)
3277 mm40_prot |= (RT2860_REG_PROT_PHYMODE_CCK << RT2860_REG_PROT_PHYMODE_SHIFT) |
3278 (3 << RT2860_REG_PROT_MCS_SHIFT);
3279 else
3280 mm40_prot |= (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3281 (0x84 << RT2860_REG_PROT_MCS_SHIFT);
3282
3283 if (htprotmode == IEEE80211_PROT_RTSCTS)
3284 mm40_prot |= RT2860_REG_PROT_CTRL_RTS_CTS;
3285 else if (htprotmode == IEEE80211_PROT_CTSONLY)
3286 mm40_prot |= RT2860_REG_PROT_CTRL_CTS;
3287 else
3288 mm40_prot |= RT2860_REG_PROT_CTRL_NONE;
3289
3290 gf40_prot = mm40_prot;
3291 break;
3292
3293 /*
3294 * IEEE80211_HTINFO_OPMODE_PURE
3295 * IEEE80211_HTINFO_OPMODE_PROTOPT
3296 */
3297 case IEEE80211_HTINFO_OPMODE_PURE:
3298 case IEEE80211_HTINFO_OPMODE_PROTOPT:
3299 default:
3300 mm20_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_PROT_CTRL_NONE |
3301 RT2860_REG_TXOP_ALLOW_CCK | RT2860_REG_TXOP_ALLOW_OFDM |
3302 RT2860_REG_TXOP_ALLOW_MM20 | RT2860_REG_TXOP_ALLOW_GF20 |
3303 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3304 (4 << RT2860_REG_PROT_MCS_SHIFT);
3305
3306 gf20_prot = mm20_prot;
3307
3308 mm40_prot = RT2860_REG_PROT_NAV_SHORT | RT2860_REG_PROT_CTRL_NONE |
3309 RT2860_REG_TXOP_ALLOW_ALL |
3310 (RT2860_REG_PROT_PHYMODE_OFDM << RT2860_REG_PROT_PHYMODE_SHIFT) |
3311 (0x84 << RT2860_REG_PROT_MCS_SHIFT);
3312
3313 gf40_prot = mm40_prot;
3314 break;
3315 }
3316
3317 rt2860_io_mac_write(sc, RT2860_REG_TX_MM20_PROT_CFG, mm20_prot);
3318 rt2860_io_mac_write(sc, RT2860_REG_TX_MM40_PROT_CFG, mm40_prot);
3319 rt2860_io_mac_write(sc, RT2860_REG_TX_GF20_PROT_CFG, gf20_prot);
3320 rt2860_io_mac_write(sc, RT2860_REG_TX_GF40_PROT_CFG, gf40_prot);
3321 }
3322
3323 /*
3324 * rt2860_asic_updateslot
3325 */
3326 static void rt2860_asic_updateslot(struct rt2860_softc *sc)
3327 {
3328 struct ieee80211com *ic;
3329 uint32_t tmp;
3330
3331 ic = &sc->ic;
3332
3333 RT2860_DPRINTF(sc, RT2860_DEBUG_STATE,
3334 "%s: %s short slot time\n",
3335 device_get_nameunit(sc->dev),
3336 (ic->ic_flags & (IEEE80211_F_SHSLOT | IEEE80211_F_BURST)) ? "enabling" : "disabling");
3337
3338 tmp = rt2860_io_mac_read(sc, RT2860_REG_BKOFF_SLOT_CFG);
3339
3340 tmp &= ~0xff;
3341 tmp |= (ic->ic_flags & (IEEE80211_F_SHSLOT |IEEE80211_F_BURST)) ? 9 : 20;
3342
3343 rt2860_io_mac_write(sc, RT2860_REG_BKOFF_SLOT_CFG, tmp);
3344 }
3345
3346 /*
3347 * rt2860_asic_wme_update
3348 */
3349 static void rt2860_asic_wme_update(struct rt2860_softc *sc)
3350 {
3351 struct ieee80211com *ic;
3352 struct ieee80211_wme_state *wme;
3353 const struct wmeParams *wmep;
3354 int i;
3355
3356 ic = &sc->ic;
3357 wme = &ic->ic_wme;
3358 wmep = wme->wme_chanParams.cap_wmeParams;
3359
3360 RT2860_DPRINTF(sc, RT2860_DEBUG_WME,
3361 "%s: wme update: WME_AC_VO=%d/%d/%d/%d, WME_AC_VI=%d/%d/%d/%d, "
3362 "WME_AC_BK=%d/%d/%d/%d, WME_AC_BE=%d/%d/%d/%d\n",
3363 device_get_nameunit(sc->dev),
3364 wmep[WME_AC_VO].wmep_aifsn,
3365 wmep[WME_AC_VO].wmep_logcwmin, wmep[WME_AC_VO].wmep_logcwmax,
3366 wmep[WME_AC_VO].wmep_txopLimit,
3367 wmep[WME_AC_VI].wmep_aifsn,
3368 wmep[WME_AC_VI].wmep_logcwmin, wmep[WME_AC_VI].wmep_logcwmax,
3369 wmep[WME_AC_VI].wmep_txopLimit,
3370 wmep[WME_AC_BK].wmep_aifsn,
3371 wmep[WME_AC_BK].wmep_logcwmin, wmep[WME_AC_BK].wmep_logcwmax,
3372 wmep[WME_AC_BK].wmep_txopLimit,
3373 wmep[WME_AC_BE].wmep_aifsn,
3374 wmep[WME_AC_BE].wmep_logcwmin, wmep[WME_AC_BE].wmep_logcwmax,
3375 wmep[WME_AC_BE].wmep_txopLimit);
3376
3377 for (i = 0; i < WME_NUM_AC; i++)
3378 rt2860_io_mac_write(sc, RT2860_REG_TX_EDCA_AC_CFG(i),
3379 (wmep[i].wmep_logcwmax << 16) | (wmep[i].wmep_logcwmin << 12) |
3380 (wmep[i].wmep_aifsn << 8) | wmep[i].wmep_txopLimit);
3381
3382 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_AIFSN_CFG,
3383 (wmep[WME_AC_VO].wmep_aifsn << 12) | (wmep[WME_AC_VI].wmep_aifsn << 8) |
3384 (wmep[WME_AC_BK].wmep_aifsn << 4) | wmep[WME_AC_BE].wmep_aifsn);
3385
3386 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_CWMIN_CFG,
3387 (wmep[WME_AC_VO].wmep_logcwmin << 12) | (wmep[WME_AC_VI].wmep_logcwmin << 8) |
3388 (wmep[WME_AC_BK].wmep_logcwmin << 4) | wmep[WME_AC_BE].wmep_logcwmin);
3389
3390 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_CWMAX_CFG,
3391 (wmep[WME_AC_VO].wmep_logcwmax << 12) | (wmep[WME_AC_VI].wmep_logcwmax << 8) |
3392 (wmep[WME_AC_BK].wmep_logcwmax << 4) | wmep[WME_AC_BE].wmep_logcwmax);
3393
3394 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP0_CFG,
3395 (wmep[WME_AC_BK].wmep_txopLimit << 16) | wmep[WME_AC_BE].wmep_txopLimit);
3396
3397 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WMM_TXOP1_CFG,
3398 (wmep[WME_AC_VO].wmep_txopLimit << 16) | wmep[WME_AC_VI].wmep_txopLimit);
3399 }
3400
3401 /*
3402 * rt2860_asic_update_beacon
3403 */
3404 static void rt2860_asic_update_beacon(struct rt2860_softc *sc)
3405 {
3406 struct ieee80211com *ic;
3407 struct mbuf *m;
3408 struct rt2860_txwi *txwi;
3409 uint32_t tmp;
3410
3411 ic = &sc->ic;
3412
3413 m = sc->beacon_mbuf;
3414 txwi = &sc->beacon_txwi;
3415
3416 /* disable temporarily TSF sync */
3417
3418 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG);
3419
3420 tmp &= ~(RT2860_REG_BCN_TX_ENABLE |
3421 RT2860_REG_TSF_TIMER_ENABLE |
3422 RT2860_REG_TBTT_TIMER_ENABLE);
3423
3424 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp);
3425
3426 /* write Tx wireless info and beacon frame to on-chip memory */
3427
3428 rt2860_io_mac_write_multi(sc, RT2860_REG_BEACON_BASE(0),
3429 txwi, sizeof(struct rt2860_txwi));
3430
3431 rt2860_io_mac_write_multi(sc, RT2860_REG_BEACON_BASE(0) + sizeof(struct rt2860_txwi),
3432 mtod(m, uint8_t *), m->m_pkthdr.len);
3433
3434 /* enable again TSF sync */
3435
3436 tmp = rt2860_io_mac_read(sc, RT2860_REG_BCN_TIME_CFG);
3437
3438 tmp |= (RT2860_REG_BCN_TX_ENABLE |
3439 RT2860_REG_TSF_TIMER_ENABLE |
3440 RT2860_REG_TBTT_TIMER_ENABLE);
3441
3442 rt2860_io_mac_write(sc, RT2860_REG_BCN_TIME_CFG, tmp);
3443 }
3444
3445 /*
3446 * rt2860_asic_clear_keytables
3447 */
3448 static void rt2860_asic_clear_keytables(struct rt2860_softc *sc)
3449 {
3450 int i;
3451
3452 /* clear Rx WCID search table (entries = 256, entry size = 8) */
3453
3454 for (i = 0; i < 256; i++)
3455 {
3456 rt2860_io_mac_write(sc, RT2860_REG_WCID(i), 0xffffffff);
3457 rt2860_io_mac_write(sc, RT2860_REG_WCID(i) + 4, 0x0000ffff);
3458 }
3459
3460 /* clear WCID attribute table (entries = 256, entry size = 4) */
3461
3462 rt2860_io_mac_set_region_4(sc, RT2860_REG_WCID_ATTR(0), 0, 256);
3463
3464 /* clear IV/EIV table (entries = 256, entry size = 8) */
3465
3466 rt2860_io_mac_set_region_4(sc, RT2860_REG_IVEIV(0), 0, 2 * 256);
3467
3468 /* clear pairwise key table (entries = 64, entry size = 32) */
3469
3470 rt2860_io_mac_set_region_4(sc, RT2860_REG_PKEY(0), 0, 8 * 64);
3471
3472 /* clear shared key table (entries = 32, entry size = 32) */
3473
3474 rt2860_io_mac_set_region_4(sc, RT2860_REG_SKEY(0, 0), 0, 8 * 32);
3475
3476 /* clear shared key mode (entries = 32, entry size = 2) */
3477
3478 rt2860_io_mac_set_region_4(sc, RT2860_REG_SKEY_MODE(0), 0, 16);
3479 }
3480
3481 /*
3482 * rt2860_beacon_alloc
3483 */
3484 static int rt2860_beacon_alloc(struct rt2860_softc *sc)
3485 {
3486 struct ieee80211com *ic;
3487 struct mbuf *m;
3488 struct rt2860_txwi txwi;
3489 uint8_t rate, mcs;
3490
3491 ic = &sc->ic;
3492
3493 m = ieee80211_beacon_alloc(ic->ic_bss, &sc->beacon_offsets);
3494 if (m == NULL)
3495 return ENOMEM;
3496
3497 rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
3498 mcs = rt2860_rate2mcs(rate);
3499
3500 RT2860_DPRINTF(sc, RT2860_DEBUG_BEACON,
3501 "%s: beacon allocate: mcs=0x%02x\n",
3502 device_get_nameunit(sc->dev), mcs);
3503
3504 memset(&txwi, 0, sizeof(struct rt2860_txwi));
3505
3506 txwi.wcid = RT2860_WCID_RESERVED;
3507 txwi.pid_mpdu_len = ((htole16(m->m_pkthdr.len) & RT2860_TXWI_MPDU_LEN_MASK) <<
3508 RT2860_TXWI_MPDU_LEN_SHIFT);
3509 txwi.txop = (RT2860_TXWI_TXOP_HT << RT2860_TXWI_TXOP_SHIFT);
3510 txwi.mpdu_density_flags |=
3511 (RT2860_TXWI_FLAGS_TS << RT2860_TXWI_FLAGS_SHIFT);
3512 txwi.bawin_size_xflags |=
3513 (RT2860_TXWI_XFLAGS_NSEQ << RT2860_TXWI_XFLAGS_SHIFT);
3514
3515 if (rate == 2)
3516 {
3517 txwi.phymode_ifs_stbc_shortgi =
3518 (RT2860_TXWI_PHYMODE_CCK << RT2860_TXWI_PHYMODE_SHIFT);
3519
3520 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
3521 mcs |= RT2860_TXWI_MCS_SHOTPRE;
3522 }
3523 else
3524 {
3525 txwi.phymode_ifs_stbc_shortgi =
3526 (RT2860_TXWI_PHYMODE_OFDM << RT2860_TXWI_PHYMODE_SHIFT);
3527 }
3528
3529 txwi.bw_mcs = (RT2860_TXWI_BW_20 << RT2860_TXWI_BW_SHIFT) |
3530 ((mcs & RT2860_TXWI_MCS_MASK) << RT2860_TXWI_MCS_SHIFT);
3531
3532 if (sc->beacon_mbuf != NULL)
3533 {
3534 m_free(sc->beacon_mbuf);
3535 sc->beacon_mbuf = NULL;
3536 }
3537
3538 sc->beacon_mbuf = m;
3539 sc->beacon_txwi = txwi;
3540
3541 return 0;
3542 }
3543
3544 /*
3545 * rt2860_rxrate
3546 */
3547 static uint8_t rt2860_rxrate(struct rt2860_rxwi *rxwi)
3548 {
3549 uint8_t mcs, phymode;
3550 uint8_t rate;
3551
3552 mcs = (rxwi->bw_mcs >> RT2860_RXWI_MCS_SHIFT) & RT2860_RXWI_MCS_MASK;
3553 phymode = (rxwi->phymode_stbc_shortgi >> RT2860_RXWI_PHYMODE_SHIFT) &
3554 RT2860_RXWI_PHYMODE_MASK;
3555
3556 rate = 2;
3557
3558 switch (phymode)
3559 {
3560 case RT2860_RXWI_PHYMODE_CCK:
3561 switch (mcs & ~RT2860_RXWI_MCS_SHOTPRE)
3562 {
3563 case 0: rate = 2; break; /* 1 Mbps */
3564 case 1: rate = 4; break; /* 2 MBps */
3565 case 2: rate = 11; break; /* 5.5 Mbps */
3566 case 3: rate = 22; break; /* 11 Mbps */
3567 }
3568 break;
3569
3570 case RT2860_RXWI_PHYMODE_OFDM:
3571 switch (mcs)
3572 {
3573 case 0: rate = 12; break; /* 6 Mbps */
3574 case 1: rate = 18; break; /* 9 Mbps */
3575 case 2: rate = 24; break; /* 12 Mbps */
3576 case 3: rate = 36; break; /* 18 Mbps */
3577 case 4: rate = 48; break; /* 24 Mbps */
3578 case 5: rate = 72; break; /* 36 Mbps */
3579 case 6: rate = 96; break; /* 48 Mbps */
3580 case 7: rate = 108; break; /* 54 Mbps */
3581 }
3582 break;
3583
3584 case RT2860_RXWI_PHYMODE_HT_MIXED:
3585 case RT2860_RXWI_PHYMODE_HT_GF:
3586 break;
3587 }
3588
3589 return rate;
3590 }
3591
3592 /*
3593 * rt2860_maxrssi_rxpath
3594 */
3595 static uint8_t rt2860_maxrssi_rxpath(struct rt2860_softc *sc,
3596 const struct rt2860_rxwi *rxwi)
3597 {
3598 uint8_t rxpath;
3599
3600 rxpath = 0;
3601
3602 if (sc->nrxpath > 1)
3603 if (rxwi->rssi[1] > rxwi->rssi[rxpath])
3604 rxpath = 1;
3605
3606 if (sc->nrxpath > 2)
3607 if (rxwi->rssi[2] > rxwi->rssi[rxpath])
3608 rxpath = 2;
3609
3610 return rxpath;
3611 }
3612
3613 /*
3614 * rt2860_rssi2dbm
3615 */
3616 static int8_t rt2860_rssi2dbm(struct rt2860_softc *sc,
3617 uint8_t rssi, uint8_t rxpath)
3618 {
3619 struct ieee80211com *ic;
3620 struct ieee80211_channel *c;
3621 int chan;
3622 int8_t rssi_off, lna_gain;
3623
3624 if (rssi == 0)
3625 return -99;
3626
3627 ic = &sc->ic;
3628 c = ic->ic_curchan;
3629 chan = ieee80211_chan2ieee(ic, c);
3630
3631 if (IEEE80211_IS_CHAN_5GHZ(c))
3632 {
3633 rssi_off = sc->rssi_off_5ghz[rxpath];
3634
3635 if (chan <= 64)
3636 lna_gain = sc->lna_gain[1];
3637 else if (chan <= 128)
3638 lna_gain = sc->lna_gain[2];
3639 else
3640 lna_gain = sc->lna_gain[3];
3641 }
3642 else
3643 {
3644 rssi_off = sc->rssi_off_2ghz[rxpath];
3645 lna_gain = sc->lna_gain[0];
3646 }
3647
3648 return (-12 - rssi_off - lna_gain - rssi);
3649 }
3650
3651 /*
3652 * rt2860_rate2mcs
3653 */
3654 static uint8_t rt2860_rate2mcs(uint8_t rate)
3655 {
3656 switch (rate)
3657 {
3658 /* CCK rates */
3659 case 2: return 0;
3660 case 4: return 1;
3661 case 11: return 2;
3662 case 22: return 3;
3663
3664 /* OFDM rates */
3665 case 12: return 0;
3666 case 18: return 1;
3667 case 24: return 2;
3668 case 36: return 3;
3669 case 48: return 4;
3670 case 72: return 5;
3671 case 96: return 6;
3672 case 108: return 7;
3673 }
3674
3675 return 0;
3676 }
3677
3678 /*
3679 * rt2860_ackrate
3680 */
3681 static int rt2860_ackrate(struct ieee80211com *ic, int rate)
3682 {
3683 switch (rate)
3684 {
3685 /* CCK rates */
3686
3687 case 2:
3688 return 2;
3689
3690 case 4:
3691 case 11:
3692 case 22:
3693 return (ic->ic_curmode == IEEE80211_MODE_11B) ? 4 : rate;
3694
3695 /* OFDM rates */
3696
3697 case 12:
3698 case 18:
3699 return 12;
3700
3701 case 24:
3702 case 36:
3703 return 24;
3704
3705 case 48:
3706 case 72:
3707 case 96:
3708 case 108:
3709 return 48;
3710 }
3711
3712 /* default to 1Mbps */
3713 return 2;
3714 }
3715
3716 /*
3717 * rt2860_txtime
3718 */
3719 static uint16_t rt2860_txtime(int len, int rate, uint32_t flags)
3720 {
3721 uint16_t txtime;
3722
3723 if (RT2860_RATE_IS_OFDM(rate))
3724 {
3725 txtime = (8 + 4 * len + 3 + rate - 1) / rate;
3726 txtime = 16 + 4 + 4 * txtime + 6;
3727 }
3728 else
3729 {
3730 txtime = (16 * len + rate - 1) / rate;
3731
3732 if (rate != 2 && (flags & IEEE80211_F_SHPREAMBLE))
3733 txtime += 72 + 24;
3734 else
3735 txtime += 144 + 48;
3736 }
3737
3738 return txtime;
3739 }
3740
3741 /*
3742 * rt2860_tx_frame
3743 */
3744 static int rt2860_tx_frame(struct rt2860_softc *sc,
3745 struct mbuf *m, struct ieee80211_node *ni, int qid)
3746 {
3747 struct ieee80211com *ic;
3748 struct rt2860_softc_node *rni;
3749 struct rt2860_softc_tx_ring *ring;
3750 struct rt2860_softc_tx_data *data;
3751 struct rt2860_txdesc *desc;
3752 struct rt2860_txwi *txwi;
3753 struct ieee80211_frame *wh;
3754 struct ieee80211_tx_ampdu *tx_ampdu;
3755 struct rt2860_softc_tx_radiotap_header *tap;
3756 bus_dma_segment_t dma_seg[RT2860_SOFTC_MAX_SCATTER];
3757 u_int hdrsize, hdrspace;
3758 uint8_t type, rate, bw, stbc, shortgi, mcs, pid, wcid, mpdu_density, bawin_size, qsel;
3759 uint16_t qos, len, dmalen, mpdu_len, dur;
3760 int error, hasqos, ac, ampdu, mimops, ackrate, ndmasegs, ndescs, i, j;
3761
3762 KASSERT(qid >= 0 && qid < RT2860_SOFTC_TX_RING_COUNT,
3763 ("%s: Tx frame: invalid qid=%d\n",
3764 device_get_nameunit(sc->dev), qid));
3765
3766 RT2860_SOFTC_TX_RING_ASSERT_LOCKED(&sc->tx_ring[qid]);
3767
3768 ic = &sc->ic;
3769 rni = (struct rt2860_softc_node *) ni;
3770
3771 ring = &sc->tx_ring[qid];
3772 desc = &ring->desc[ring->desc_cur];
3773 data = &ring->data[ring->data_cur];
3774 txwi = (struct rt2860_txwi *) (ring->seg0 + ring->data_cur * RT2860_TX_DATA_SEG0_SIZE);
3775
3776 wh = mtod(m, struct ieee80211_frame *);
3777
3778 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
3779
3780 hasqos = IEEE80211_QOS_HAS_SEQ(wh);
3781 if (hasqos)
3782 {
3783 if (IEEE80211_HAS_ADDR4(wh))
3784 qos = le16toh(*(const uint16_t *)
3785 (((struct ieee80211_qosframe_addr4 *) wh)->i_qos));
3786 else
3787 qos = le16toh(*(const uint16_t *)
3788 (((struct ieee80211_qosframe *) wh)->i_qos));
3789 }
3790 else
3791 {
3792 qos = 0;
3793 }
3794
3795 if (ni->ni_flags & IEEE80211_NODE_HT)
3796 {
3797 if (IEEE80211_IS_MULTICAST(wh->i_addr1) || type != IEEE80211_FC0_TYPE_DATA)
3798 rate = 0;
3799 else if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE)
3800 rate = ic->ic_fixed_rate;
3801 else
3802 rate = ni->ni_htrates.rs_rates[ni->ni_txrate];
3803 }
3804 else
3805 {
3806 if (IEEE80211_IS_MULTICAST(wh->i_addr1) || type != IEEE80211_FC0_TYPE_DATA)
3807 rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
3808 else if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE)
3809 rate = ic->ic_fixed_rate;
3810 else
3811 rate = ni->ni_rates.rs_rates[ni->ni_txrate];
3812 }
3813
3814 rate &= IEEE80211_RATE_VAL;
3815
3816 /* fill Tx wireless info */
3817
3818 if (ni->ni_flags & IEEE80211_NODE_HT)
3819 mcs = rate;
3820 else
3821 mcs = rt2860_rate2mcs(rate);
3822
3823 /* management frames do not need encryption */
3824
3825 if (type == IEEE80211_FC0_TYPE_DATA)
3826 wcid = !IEEE80211_IS_MULTICAST(wh->i_addr1) ? rni->staid : RT2860_WCID_MCAST;
3827 else
3828 wcid = RT2860_WCID_RESERVED;
3829
3830 /* calculate MPDU length without padding */
3831
3832 hdrsize = ieee80211_hdrsize(wh);
3833 hdrspace = ieee80211_hdrspace(ic, wh);
3834 mpdu_len = m->m_pkthdr.len - hdrspace + hdrsize;
3835
3836 memset(txwi, 0, sizeof(struct rt2860_txwi));
3837
3838 txwi->wcid = wcid;
3839
3840 /* MIMO power save */
3841
3842 if ((ni->ni_flags & IEEE80211_NODE_HT) &&
3843 ((ni->ni_htcap & IEEE80211_HTCAP_SMPS) != IEEE80211_HTCAP_SMPS_OFF))
3844 {
3845 if (mcs > 7)
3846 {
3847 if ((ni->ni_htcap & IEEE80211_HTCAP_SMPS) == IEEE80211_HTCAP_SMPS_DYNAMIC)
3848 {
3849 /* dynamic MIMO power save */
3850
3851 txwi->mpdu_density_flags |=
3852 (RT2860_TXWI_FLAGS_MIMOPS << RT2860_TXWI_FLAGS_SHIFT);
3853 }
3854 else
3855 {
3856 /* static MIMO power save */
3857
3858 mcs = 7;
3859 }
3860 }
3861
3862 mimops = 1;
3863 }
3864 else
3865 {
3866 mimops = 0;
3867 }
3868
3869 pid = mcs;
3870
3871 txwi->pid_mpdu_len = ((htole16(pid) & RT2860_TXWI_PID_MASK) <<
3872 RT2860_TXWI_PID_SHIFT) | ((htole16(mpdu_len) & RT2860_TXWI_MPDU_LEN_MASK) <<
3873 RT2860_TXWI_MPDU_LEN_SHIFT);
3874
3875 stbc = sc->tx_stbc && (ic->ic_htcaps & IEEE80211_HTCAP_TXSTBC) &&
3876 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC);
3877
3878 shortgi = ((ic->ic_flags_ext & IEEE80211_FEXT_SHORTGI20) &&
3879 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20) &&
3880 (ni->ni_chw == 20)) ||
3881 ((ic->ic_flags_ext & IEEE80211_FEXT_SHORTGI40) &&
3882 (ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40) &&
3883 (ni->ni_chw == 40));
3884
3885 txwi->phymode_ifs_stbc_shortgi |=
3886 ((stbc & RT2860_TXWI_STBC_MASK) << RT2860_TXWI_STBC_SHIFT) |
3887 ((shortgi & RT2860_TXWI_SHORTGI_MASK) << RT2860_TXWI_SHORTGI_SHIFT);
3888
3889 if (ni->ni_flags & IEEE80211_NODE_HT)
3890 {
3891 txwi->phymode_ifs_stbc_shortgi |=
3892 (RT2860_TXWI_PHYMODE_HT_MIXED << RT2860_TXWI_PHYMODE_SHIFT);
3893 }
3894 else
3895 {
3896 if (!RT2860_RATE_IS_OFDM(rate))
3897 {
3898 txwi->phymode_ifs_stbc_shortgi |=
3899 (RT2860_TXWI_PHYMODE_CCK << RT2860_TXWI_PHYMODE_SHIFT);
3900
3901 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
3902 mcs |= RT2860_TXWI_MCS_SHOTPRE;
3903 }
3904 else
3905 {
3906 txwi->phymode_ifs_stbc_shortgi |=
3907 (RT2860_TXWI_PHYMODE_OFDM << RT2860_TXWI_PHYMODE_SHIFT);
3908 }
3909 }
3910
3911 if ((ni->ni_flags & IEEE80211_NODE_HT) && (ni->ni_chw == 40))
3912 bw = RT2860_TXWI_BW_40;
3913 else
3914 bw = RT2860_TXWI_BW_20;
3915
3916 txwi->bw_mcs = ((bw & RT2860_TXWI_BW_MASK) << RT2860_TXWI_BW_SHIFT) |
3917 ((mcs & RT2860_TXWI_MCS_MASK) << RT2860_TXWI_MCS_SHIFT);
3918
3919 if (type != IEEE80211_FC0_TYPE_DATA)
3920 txwi->txop = (RT2860_TXWI_TXOP_BACKOFF << RT2860_TXWI_TXOP_SHIFT);
3921 else
3922 txwi->txop = (RT2860_TXWI_TXOP_HT << RT2860_TXWI_TXOP_SHIFT);
3923
3924 /* skip ACKs for multicast frames */
3925
3926 if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
3927 (!hasqos || (qos & IEEE80211_QOS_ACKPOLICY) != IEEE80211_QOS_ACKPOLICY_NOACK))
3928 {
3929 txwi->bawin_size_xflags |=
3930 (RT2860_TXWI_XFLAGS_ACK << RT2860_TXWI_XFLAGS_SHIFT);
3931
3932 if (ni->ni_flags & IEEE80211_NODE_HT)
3933 {
3934 /* preamble + plcp + signal extension + SIFS */
3935
3936 dur = 16 + 4 + 6 + 10;
3937 }
3938 else
3939 {
3940 ackrate = rt2860_ackrate(ic, rate);
3941
3942 dur = rt2860_txtime(RT2860_ACK_SIZE, ackrate, ic->ic_flags) +
3943 sc->sifs;
3944 }
3945
3946 *(uint16_t *) wh->i_dur = htole16(dur);
3947 }
3948
3949 /* check for A-MPDU */
3950
3951 if ((qos & IEEE80211_QOS_ACKPOLICY) == IEEE80211_QOS_ACKPOLICY_BA)
3952 {
3953 ac = M_WME_GETAC(m);
3954 tx_ampdu = &ni->ni_tx_ampdu[ac];
3955
3956 mpdu_density = RT2860_MS(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY);
3957 bawin_size = tx_ampdu->txa_wnd;
3958
3959 txwi->mpdu_density_flags |=
3960 ((mpdu_density & RT2860_TXWI_MPDU_DENSITY_MASK) << RT2860_TXWI_MPDU_DENSITY_SHIFT) |
3961 (RT2860_TXWI_FLAGS_AMPDU << RT2860_TXWI_FLAGS_SHIFT);
3962
3963 txwi->bawin_size_xflags |=
3964 ((bawin_size & RT2860_TXWI_BAWIN_SIZE_MASK) << RT2860_TXWI_BAWIN_SIZE_SHIFT);
3965
3966 if (IEEE80211_HAS_ADDR4(wh))
3967 ((struct ieee80211_qosframe_addr4 *) wh)->i_qos[0] &= ~IEEE80211_QOS_ACKPOLICY;
3968 else
3969 ((struct ieee80211_qosframe *) wh)->i_qos[0] &= ~IEEE80211_QOS_ACKPOLICY;
3970
3971 ampdu = 1;
3972 }
3973 else
3974 {
3975 ampdu = 0;
3976 }
3977
3978 /* ask MAC to insert timestamp into probe responses */
3979
3980 if ((wh->i_fc[0] & (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
3981 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
3982 txwi->mpdu_density_flags |=
3983 (RT2860_TXWI_FLAGS_TS << RT2860_TXWI_FLAGS_SHIFT);
3984
3985 if (bpf_peers_present(sc->drvbpf))
3986 {
3987 tap = &sc->txtap;
3988
3989 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
3990 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
3991 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
3992 tap->chan_ieee = ic->ic_curchan->ic_ieee;
3993 tap->chan_maxpow = 0;
3994
3995 if (ni->ni_flags & IEEE80211_NODE_HT)
3996 tap->rate = mcs | IEEE80211_RATE_MCS;
3997 else
3998 tap->rate = rate;
3999
4000 if (mcs & RT2860_TXWI_MCS_SHOTPRE)
4001 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
4002
4003 if (shortgi)
4004 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
4005
4006 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4007 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
4008
4009 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4010 {
4011 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4012
4013 bpf_mtap2(sc->drvbpf, tap, sc->txtap_len, m);
4014
4015 wh->i_fc[1] |= IEEE80211_FC1_WEP;
4016 }
4017 else
4018 {
4019 bpf_mtap2(sc->drvbpf, tap, sc->txtap_len, m);
4020 }
4021 }
4022
4023 /* copy and trim 802.11 header */
4024
4025 m_copydata(m, 0, hdrsize, (caddr_t) (txwi + 1));
4026 m_adj(m, hdrspace);
4027
4028 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m,
4029 dma_seg, &ndmasegs, 0);
4030 if (error != 0)
4031 {
4032 /* too many fragments, linearize */
4033
4034 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
4035 "%s: could not load mbuf DMA map, trying to linearize mbuf\n",
4036 device_get_nameunit(sc->dev));
4037
4038 m = m_defrag(m, M_DONTWAIT);
4039 if (m == NULL)
4040 return ENOMEM;
4041
4042 sc->tx_defrag_packets++;
4043
4044 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map, m,
4045 dma_seg, &ndmasegs, 0);
4046 if (error != 0)
4047 {
4048 printf("%s: could not load mbuf DMA map: error=%d\n",
4049 device_get_nameunit(sc->dev), error);
4050 m_freem(m);
4051 return error;
4052 }
4053 }
4054
4055 if (m->m_pkthdr.len == 0)
4056 ndmasegs = 0;
4057
4058 /* determine how many Tx descs are required */
4059
4060 ndescs = 1 + ndmasegs / 2;
4061 if ((ring->desc_queued + ndescs) > (RT2860_SOFTC_TX_RING_DESC_COUNT - 2))
4062 {
4063 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
4064 "%s: there are not enough Tx descs\n",
4065 device_get_nameunit(sc->dev));
4066
4067 sc->no_tx_desc_avail++;
4068
4069 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
4070 m_freem(m);
4071 return EFBIG;
4072 }
4073
4074 data->m = m;
4075 data->ni = ni;
4076
4077 /* set up Tx descs */
4078
4079 /* first segment is Tx wireless info and 802.11 header */
4080
4081 len = sizeof(struct rt2860_txwi) + hdrsize;
4082
4083 /* align end on a 4-bytes boundary */
4084
4085 dmalen = (len + 3) & ~ 3;
4086
4087 memset((caddr_t) txwi + len, 0, dmalen - len);
4088
4089 qsel = RT2860_TXDESC_QSEL_EDCA;
4090
4091 desc->sdp0 = htole32(ring->seg0_phys_addr + ring->data_cur * RT2860_TX_DATA_SEG0_SIZE);
4092 desc->sdl0 = htole16(dmalen);
4093 desc->qsel_flags = (qsel << RT2860_TXDESC_QSEL_SHIFT);
4094
4095 /* set up payload segments */
4096
4097 for (i = ndmasegs, j = 0; i >= 2; i -= 2)
4098 {
4099 desc->sdp1 = htole32(dma_seg[j].ds_addr);
4100 desc->sdl1 = htole16(dma_seg[j].ds_len);
4101
4102 ring->desc_queued++;
4103 ring->desc_cur = (ring->desc_cur + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT;
4104
4105 j++;
4106
4107 desc = &ring->desc[ring->desc_cur];
4108
4109 desc->sdp0 = htole32(dma_seg[j].ds_addr);
4110 desc->sdl0 = htole16(dma_seg[j].ds_len);
4111 desc->qsel_flags = (qsel << RT2860_TXDESC_QSEL_SHIFT);
4112
4113 j++;
4114 }
4115
4116 /* finalize last payload segment */
4117
4118 if (i > 0)
4119 {
4120 desc->sdp1 = htole32(dma_seg[j].ds_addr);
4121 desc->sdl1 = htole16(dma_seg[j].ds_len | RT2860_TXDESC_SDL1_LASTSEG);
4122 }
4123 else
4124 {
4125 desc->sdl0 |= htole16(RT2860_TXDESC_SDL0_LASTSEG);
4126 desc->sdl1 = 0;
4127 }
4128
4129 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
4130 "%s: sending frame: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4131 "bw=%d, stbc=%d, shortgi=%d, mcs=%d, wcid=0x%02x, ampdu=%d, mimops=%d, DMA len=%d, ndmasegs=%d, DMA ds_len=%d/%d/%d/%d/%d\n",
4132 device_get_nameunit(sc->dev),
4133 qid, hdrsize, hdrspace, m->m_pkthdr.len + hdrsize,
4134 bw, stbc, shortgi, mcs, wcid, ampdu, mimops, dmalen, ndmasegs,
4135 dma_seg[0].ds_len, dma_seg[1].ds_len, dma_seg[2].ds_len, dma_seg[3].ds_len, dma_seg[4].ds_len);
4136
4137 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map,
4138 BUS_DMASYNC_PREWRITE);
4139 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
4140 BUS_DMASYNC_PREWRITE);
4141 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
4142 BUS_DMASYNC_PREWRITE);
4143
4144 ring->desc_queued++;
4145 ring->desc_cur = (ring->desc_cur + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT;
4146
4147 ring->data_queued++;
4148 ring->data_cur = (ring->data_cur + 1) % RT2860_SOFTC_TX_RING_DATA_COUNT;
4149
4150 /* kick Tx */
4151
4152 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(qid), ring->desc_cur);
4153
4154 return 0;
4155 }
4156
4157 /*
4158 * rt2860_tx_raw
4159 */
4160 static int rt2860_tx_raw(struct rt2860_softc *sc,
4161 struct mbuf *m, struct ieee80211_node *ni,
4162 const struct ieee80211_bpf_params *params)
4163 {
4164 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
4165 "%s: Tx raw\n",
4166 device_get_nameunit(sc->dev));
4167
4168 return 0;
4169 }
4170
4171 /*
4172 * rt2860_intr
4173 */
4174 static void rt2860_intr(void *arg)
4175 {
4176 struct rt2860_softc *sc;
4177 struct ifnet *ifp;
4178 uint32_t status;
4179
4180 sc = arg;
4181 ifp = sc->ifp;
4182
4183 /* acknowledge interrupts */
4184
4185 status = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_INT_STATUS);
4186 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_STATUS, status);
4187
4188 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4189 "%s: interrupt: status = 0x%08x\n",
4190 device_get_nameunit(sc->dev), status);
4191
4192 if (status == 0xffffffff || /* device likely went away */
4193 status == 0) /* not for us */
4194 return;
4195
4196 sc->interrupts++;
4197
4198 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4199 return;
4200
4201 if (status & RT2860_REG_INT_TX_COHERENT)
4202 rt2860_tx_coherent_intr(sc);
4203
4204 if (status & RT2860_REG_INT_RX_COHERENT)
4205 rt2860_rx_coherent_intr(sc);
4206
4207 if (status & RT2860_REG_INT_TXRX_COHERENT)
4208 rt2860_txrx_coherent_intr(sc);
4209
4210 if (status & RT2860_REG_INT_FIFO_STA_FULL)
4211 rt2860_fifo_sta_full_intr(sc);
4212
4213 if (status & RT2860_REG_INT_TX_MGMT_DONE)
4214 rt2860_tx_intr(sc, 5);
4215
4216 if (status & RT2860_REG_INT_RX_DONE)
4217 rt2860_rx_intr(sc);
4218
4219 if (status & RT2860_REG_INT_RX_DELAY_DONE)
4220 rt2860_rx_delay_intr(sc);
4221
4222 if (status & RT2860_REG_INT_TX_HCCA_DONE)
4223 rt2860_tx_intr(sc, 4);
4224
4225 if (status & RT2860_REG_INT_TX_AC3_DONE)
4226 rt2860_tx_intr(sc, 3);
4227
4228 if (status & RT2860_REG_INT_TX_AC2_DONE)
4229 rt2860_tx_intr(sc, 2);
4230
4231 if (status & RT2860_REG_INT_TX_AC1_DONE)
4232 rt2860_tx_intr(sc, 1);
4233
4234 if (status & RT2860_REG_INT_TX_AC0_DONE)
4235 rt2860_tx_intr(sc, 0);
4236
4237 if (status & RT2860_REG_INT_TX_DELAY_DONE)
4238 rt2860_tx_delay_intr(sc);
4239
4240 if (status & RT2860_REG_INT_PRE_TBTT)
4241 rt2860_pre_tbtt_intr(sc);
4242
4243 if (status & RT2860_REG_INT_TBTT)
4244 rt2860_tbtt_intr(sc);
4245
4246 if (status & RT2860_REG_INT_MCU_CMD)
4247 rt2860_mcu_cmd_intr(sc);
4248
4249 if (status & RT2860_REG_INT_AUTO_WAKEUP)
4250 rt2860_auto_wakeup_intr(sc);
4251
4252 if (status & RT2860_REG_INT_GP_TIMER)
4253 rt2860_gp_timer_intr(sc);
4254 }
4255
4256 /*
4257 * rt2860_tx_coherent_intr
4258 */
4259 static void rt2860_tx_coherent_intr(struct rt2860_softc *sc)
4260 {
4261 uint32_t tmp;
4262 int i;
4263
4264 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4265 "%s: Tx coherent interrupt\n",
4266 device_get_nameunit(sc->dev));
4267
4268 sc->tx_coherent_interrupts++;
4269
4270 /* restart DMA engine */
4271
4272 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
4273
4274 tmp &= ~(RT2860_REG_TX_WB_DDONE |
4275 RT2860_REG_RX_DMA_ENABLE |
4276 RT2860_REG_TX_DMA_ENABLE);
4277
4278 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
4279
4280 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
4281
4282 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
4283 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]);
4284
4285 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
4286 {
4287 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i),
4288 sc->tx_ring[i].desc_phys_addr);
4289 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i),
4290 RT2860_SOFTC_TX_RING_DESC_COUNT);
4291 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0);
4292 }
4293
4294 /* init Rx ring */
4295
4296 rt2860_reset_rx_ring(sc, &sc->rx_ring);
4297
4298 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR,
4299 sc->rx_ring.desc_phys_addr);
4300 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT,
4301 RT2860_SOFTC_RX_RING_DATA_COUNT);
4302 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX,
4303 RT2860_SOFTC_RX_RING_DATA_COUNT - 1);
4304
4305 rt2860_txrx_enable(sc);
4306 }
4307
4308 /*
4309 * rt2860_rx_coherent_intr
4310 */
4311 static void rt2860_rx_coherent_intr(struct rt2860_softc *sc)
4312 {
4313 uint32_t tmp;
4314 int i;
4315
4316 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4317 "%s: Rx coherent interrupt\n",
4318 device_get_nameunit(sc->dev));
4319
4320 sc->rx_coherent_interrupts++;
4321
4322 /* restart DMA engine */
4323
4324 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
4325
4326 tmp &= ~(RT2860_REG_TX_WB_DDONE |
4327 RT2860_REG_RX_DMA_ENABLE |
4328 RT2860_REG_TX_DMA_ENABLE);
4329
4330 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
4331
4332 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
4333
4334 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
4335 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]);
4336
4337 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
4338 {
4339 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i),
4340 sc->tx_ring[i].desc_phys_addr);
4341 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i),
4342 RT2860_SOFTC_TX_RING_DESC_COUNT);
4343 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0);
4344 }
4345
4346 /* init Rx ring */
4347
4348 rt2860_reset_rx_ring(sc, &sc->rx_ring);
4349
4350 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR,
4351 sc->rx_ring.desc_phys_addr);
4352 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT,
4353 RT2860_SOFTC_RX_RING_DATA_COUNT);
4354 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX,
4355 RT2860_SOFTC_RX_RING_DATA_COUNT - 1);
4356
4357 rt2860_txrx_enable(sc);
4358 }
4359
4360 /*
4361 * rt2860_txrx_coherent_intr
4362 */
4363 static void rt2860_txrx_coherent_intr(struct rt2860_softc *sc)
4364 {
4365 uint32_t tmp;
4366 int i;
4367
4368 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4369 "%s: Tx/Rx coherent interrupt\n",
4370 device_get_nameunit(sc->dev));
4371
4372 sc->txrx_coherent_interrupts++;
4373
4374 /* restart DMA engine */
4375
4376 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
4377
4378 tmp &= ~(RT2860_REG_TX_WB_DDONE |
4379 RT2860_REG_RX_DMA_ENABLE |
4380 RT2860_REG_TX_DMA_ENABLE);
4381
4382 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
4383
4384 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
4385
4386 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
4387 rt2860_reset_tx_ring(sc, &sc->tx_ring[i]);
4388
4389 for (i = 0; i < RT2860_SOFTC_TX_RING_COUNT; i++)
4390 {
4391 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_BASE_PTR(i),
4392 sc->tx_ring[i].desc_phys_addr);
4393 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_MAX_CNT(i),
4394 RT2860_SOFTC_TX_RING_DESC_COUNT);
4395 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_TX_CTX_IDX(i), 0);
4396 }
4397
4398 /* init Rx ring */
4399
4400 rt2860_reset_rx_ring(sc, &sc->rx_ring);
4401
4402 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_BASE_PTR,
4403 sc->rx_ring.desc_phys_addr);
4404 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_MAX_CNT,
4405 RT2860_SOFTC_RX_RING_DATA_COUNT);
4406 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX,
4407 RT2860_SOFTC_RX_RING_DATA_COUNT - 1);
4408
4409 rt2860_txrx_enable(sc);
4410 }
4411
4412 /*
4413 * rt2860_fifo_sta_full_intr
4414 */
4415 static void rt2860_fifo_sta_full_intr(struct rt2860_softc *sc)
4416 {
4417 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4418 "%s: FIFO statistic full interrupt\n",
4419 device_get_nameunit(sc->dev));
4420
4421 sc->fifo_sta_full_interrupts++;
4422
4423 RT2860_SOFTC_LOCK(sc);
4424
4425 if (!(sc->intr_disable_mask & RT2860_REG_INT_FIFO_STA_FULL))
4426 {
4427 rt2860_intr_disable(sc, RT2860_REG_INT_FIFO_STA_FULL);
4428
4429 taskqueue_enqueue(sc->taskqueue, &sc->fifo_sta_full_task);
4430 }
4431
4432 sc->intr_pending_mask |= RT2860_REG_INT_FIFO_STA_FULL;
4433
4434 RT2860_SOFTC_UNLOCK(sc);
4435 }
4436
4437 /*
4438 * rt2860_rx_intr
4439 */
4440 static void rt2860_rx_intr(struct rt2860_softc *sc)
4441 {
4442 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4443 "%s: Rx interrupt\n",
4444 device_get_nameunit(sc->dev));
4445
4446 sc->rx_interrupts++;
4447
4448 RT2860_SOFTC_LOCK(sc);
4449
4450 if (!(sc->intr_disable_mask & RT2860_REG_INT_RX_DONE))
4451 {
4452 rt2860_intr_disable(sc, RT2860_REG_INT_RX_DONE);
4453
4454 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
4455 }
4456
4457 sc->intr_pending_mask |= RT2860_REG_INT_RX_DONE;
4458
4459 RT2860_SOFTC_UNLOCK(sc);
4460 }
4461
4462 /*
4463 * rt2860_rx_delay_intr
4464 */
4465 static void rt2860_rx_delay_intr(struct rt2860_softc *sc)
4466 {
4467 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4468 "%s: Rx delay interrupt\n",
4469 device_get_nameunit(sc->dev));
4470
4471 sc->rx_delay_interrupts++;
4472 }
4473
4474 /*
4475 * rt2860_tx_intr
4476 */
4477 static void rt2860_tx_intr(struct rt2860_softc *sc, int qid)
4478 {
4479 KASSERT(qid >= 0 && qid < RT2860_SOFTC_TX_RING_COUNT,
4480 ("%s: Tx interrupt: invalid qid=%d\n",
4481 device_get_nameunit(sc->dev), qid));
4482
4483 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4484 "%s: Tx interrupt: qid=%d\n",
4485 device_get_nameunit(sc->dev), qid);
4486
4487 sc->tx_interrupts[qid]++;
4488
4489 RT2860_SOFTC_LOCK(sc);
4490
4491 if (!(sc->intr_disable_mask & (RT2860_REG_INT_TX_AC0_DONE << qid)))
4492 {
4493 rt2860_intr_disable(sc, (RT2860_REG_INT_TX_AC0_DONE << qid));
4494
4495 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
4496 }
4497
4498 sc->intr_pending_mask |= (RT2860_REG_INT_TX_AC0_DONE << qid);
4499
4500 RT2860_SOFTC_UNLOCK(sc);
4501 }
4502
4503 /*
4504 * rt2860_tx_delay_intr
4505 */
4506 static void rt2860_tx_delay_intr(struct rt2860_softc *sc)
4507 {
4508 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4509 "%s: Tx delay interrupt\n",
4510 device_get_nameunit(sc->dev));
4511
4512 sc->tx_delay_interrupts++;
4513 }
4514
4515 /*
4516 * rt2860_pre_tbtt_intr
4517 */
4518 static void rt2860_pre_tbtt_intr(struct rt2860_softc *sc)
4519 {
4520 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4521 "%s: Pre-TBTT interrupt\n",
4522 device_get_nameunit(sc->dev));
4523
4524 sc->pre_tbtt_interrupts++;
4525 }
4526
4527 /*
4528 * rt2860_tbtt_intr
4529 */
4530 static void rt2860_tbtt_intr(struct rt2860_softc *sc)
4531 {
4532 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4533 "%s: TBTT interrupt\n",
4534 device_get_nameunit(sc->dev));
4535
4536 sc->tbtt_interrupts++;
4537 }
4538
4539 /*
4540 * rt2860_mcu_cmd_intr
4541 */
4542 static void rt2860_mcu_cmd_intr(struct rt2860_softc *sc)
4543 {
4544 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4545 "%s: MCU command interrupt\n",
4546 device_get_nameunit(sc->dev));
4547
4548 sc->mcu_cmd_interrupts++;
4549 }
4550
4551 /*
4552 * rt2860_auto_wakeup_intr
4553 */
4554 static void rt2860_auto_wakeup_intr(struct rt2860_softc *sc)
4555 {
4556 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4557 "%s: auto wakeup interrupt\n",
4558 device_get_nameunit(sc->dev));
4559
4560 sc->auto_wakeup_interrupts++;
4561 }
4562
4563 /*
4564 * rt2860_gp_timer_intr
4565 */
4566 static void rt2860_gp_timer_intr(struct rt2860_softc *sc)
4567 {
4568 RT2860_DPRINTF(sc, RT2860_DEBUG_INTR,
4569 "%s: GP timer interrupt\n",
4570 device_get_nameunit(sc->dev));
4571
4572 sc->gp_timer_interrupts++;
4573 }
4574
4575 /*
4576 * rt2860_rx_done_task
4577 */
4578 static void rt2860_rx_done_task(void *context, int pending)
4579 {
4580 struct rt2860_softc *sc;
4581 struct ifnet *ifp;
4582 int again;
4583
4584 sc = context;
4585 ifp = sc->ifp;
4586
4587 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
4588 "%s: Rx done task\n",
4589 device_get_nameunit(sc->dev));
4590
4591 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4592 return;
4593
4594 sc->intr_pending_mask &= ~RT2860_REG_INT_RX_DONE;
4595
4596 again = rt2860_rx_eof(sc, sc->rx_process_limit);
4597
4598 RT2860_SOFTC_LOCK(sc);
4599
4600 if ((sc->intr_pending_mask & RT2860_REG_INT_RX_DONE) || again)
4601 {
4602 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
4603 "%s: Rx done task: scheduling again\n",
4604 device_get_nameunit(sc->dev));
4605
4606 taskqueue_enqueue(sc->taskqueue, &sc->rx_done_task);
4607 }
4608 else
4609 {
4610 rt2860_intr_enable(sc, RT2860_REG_INT_RX_DONE);
4611 }
4612
4613 RT2860_SOFTC_UNLOCK(sc);
4614 }
4615
4616 /*
4617 * rt2860_tx_done_task
4618 */
4619 static void rt2860_tx_done_task(void *context, int pending)
4620 {
4621 struct rt2860_softc *sc;
4622 struct ifnet *ifp;
4623 struct ieee80211com *ic;
4624 uint32_t intr_mask;
4625 int i;
4626
4627 sc = context;
4628 ifp = sc->ifp;
4629 ic = &sc->ic;
4630
4631 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
4632 "%s: Tx done task\n",
4633 device_get_nameunit(sc->dev));
4634
4635 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4636 return;
4637
4638 for (i = RT2860_SOFTC_TX_RING_COUNT - 1; i >= 0; i--)
4639 {
4640 if (sc->intr_pending_mask & (RT2860_REG_INT_TX_AC0_DONE << i))
4641 {
4642 sc->intr_pending_mask &= ~(RT2860_REG_INT_TX_AC0_DONE << i);
4643
4644 rt2860_tx_eof(sc, &sc->tx_ring[i]);
4645 }
4646 }
4647
4648 sc->tx_timer = 0;
4649
4650 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
4651
4652 intr_mask = (RT2860_REG_INT_TX_MGMT_DONE |
4653 RT2860_REG_INT_TX_HCCA_DONE |
4654 RT2860_REG_INT_TX_AC3_DONE |
4655 RT2860_REG_INT_TX_AC2_DONE |
4656 RT2860_REG_INT_TX_AC1_DONE |
4657 RT2860_REG_INT_TX_AC0_DONE);
4658
4659 RT2860_SOFTC_LOCK(sc);
4660
4661 rt2860_intr_enable(sc, ~sc->intr_pending_mask &
4662 (sc->intr_disable_mask & intr_mask));
4663
4664 if (sc->intr_pending_mask & intr_mask)
4665 {
4666 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
4667 "%s: Tx done task: scheduling again\n",
4668 device_get_nameunit(sc->dev));
4669
4670 taskqueue_enqueue(sc->taskqueue, &sc->tx_done_task);
4671 }
4672
4673 RT2860_SOFTC_UNLOCK(sc);
4674
4675 if (!IFQ_IS_EMPTY(&ic->ic_mgtq) || !IFQ_IS_EMPTY(&ifp->if_snd))
4676 rt2860_start(ifp);
4677 }
4678
4679 /*
4680 * rt2860_fifo_sta_full_task
4681 */
4682 static void rt2860_fifo_sta_full_task(void *context, int pending)
4683 {
4684 struct rt2860_softc *sc;
4685 struct ifnet *ifp;
4686 struct ieee80211com *ic;
4687
4688 sc = context;
4689 ifp = sc->ifp;
4690 ic = &sc->ic;
4691
4692 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS,
4693 "%s: FIFO statistic full task\n",
4694 device_get_nameunit(sc->dev));
4695
4696 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4697 return;
4698
4699 sc->intr_pending_mask &= ~RT2860_REG_INT_FIFO_STA_FULL;
4700
4701 rt2860_drain_fifo_stats(sc);
4702
4703 RT2860_SOFTC_LOCK(sc);
4704
4705 if (sc->intr_pending_mask & RT2860_REG_INT_FIFO_STA_FULL)
4706 {
4707 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS,
4708 "%s: FIFO statistic full task: scheduling again\n",
4709 device_get_nameunit(sc->dev));
4710
4711 taskqueue_enqueue(sc->taskqueue, &sc->fifo_sta_full_task);
4712 }
4713 else
4714 {
4715 rt2860_intr_enable(sc, RT2860_REG_INT_FIFO_STA_FULL);
4716 }
4717
4718 RT2860_SOFTC_UNLOCK(sc);
4719
4720 if (!IFQ_IS_EMPTY(&ic->ic_mgtq) || !IFQ_IS_EMPTY(&ifp->if_snd))
4721 rt2860_start(ifp);
4722 }
4723
4724 /*
4725 * rt2860_periodic_task
4726 */
4727 static void rt2860_periodic_task(void *context, int pending)
4728 {
4729 struct rt2860_softc *sc;
4730 struct ifnet *ifp;
4731 struct ieee80211com *ic;
4732
4733 sc = context;
4734 ifp = sc->ifp;
4735 ic = &sc->ic;
4736
4737 RT2860_DPRINTF(sc, RT2860_DEBUG_PERIODIC,
4738 "%s: periodic task: round=%lu\n",
4739 device_get_nameunit(sc->dev), sc->periodic_round);
4740
4741 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))
4742 return;
4743
4744 RT2860_SOFTC_LOCK(sc);
4745
4746 sc->periodic_round++;
4747
4748 rt2860_update_stats(sc);
4749
4750 if ((sc->periodic_round % 10) == 0)
4751 {
4752 rt2860_bbp_tuning(sc);
4753
4754 rt2860_update_raw_counters(sc);
4755
4756 rt2860_watchdog(sc);
4757
4758 if (ic->ic_opmode != IEEE80211_M_MONITOR && ic->ic_state == IEEE80211_S_RUN)
4759 {
4760 if (ic->ic_opmode == IEEE80211_M_STA)
4761 rt2860_amrr_update_iter_func(sc, ic->ic_bss);
4762 else
4763 ieee80211_iterate_nodes(&ic->ic_sta, rt2860_amrr_update_iter_func, sc);
4764 }
4765 }
4766
4767 RT2860_SOFTC_UNLOCK(sc);
4768
4769 callout_reset(&sc->periodic_ch, hz / 10, rt2860_periodic, sc);
4770 }
4771
4772 /*
4773 * rt2860_rx_eof
4774 */
4775 static int rt2860_rx_eof(struct rt2860_softc *sc, int limit)
4776 {
4777 struct ieee80211com *ic;
4778 struct ifnet *ifp;
4779 struct ieee80211_frame *wh;
4780 struct ieee80211_node *ni;
4781 struct rt2860_softc_node *rni;
4782 struct rt2860_softc_rx_radiotap_header *tap;
4783 struct rt2860_softc_rx_ring *ring;
4784 struct rt2860_rxdesc *desc;
4785 struct rt2860_softc_rx_data *data;
4786 struct rt2860_rxwi *rxwi;
4787 struct mbuf *m, *mnew;
4788 bus_dma_segment_t segs[1];
4789 bus_dmamap_t dma_map;
4790 uint32_t index, desc_flags;
4791 uint8_t cipher_err, rssi, ant, phymode, bw, shortgi, mcs, keyidx;
4792 int8_t rssi_dbm;
4793 int error, nsegs, len, ampdu, amsdu, nframes, i;
4794
4795 ic = &sc->ic;
4796 ifp = sc->ifp;
4797 ring = &sc->rx_ring;
4798
4799 nframes = 0;
4800
4801 while (limit != 0)
4802 {
4803 index = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_RX_DRX_IDX);
4804 if (ring->cur == index)
4805 break;
4806
4807 desc = &ring->desc[ring->cur];
4808 desc_flags = le32toh(desc->flags);
4809 data = &ring->data[ring->cur];
4810
4811 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
4812 BUS_DMASYNC_POSTREAD);
4813
4814 if (!(desc->sdl0 & htole16(RT2860_RXDESC_SDL0_DDONE)))
4815 break;
4816
4817 nframes++;
4818
4819 mnew = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
4820 if (mnew == NULL)
4821 {
4822 sc->rx_mbuf_alloc_errors++;
4823 ifp->if_ierrors++;
4824 goto skip;
4825 }
4826
4827 mnew->m_len = mnew->m_pkthdr.len = MJUMPAGESIZE;
4828
4829 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, ring->spare_dma_map,
4830 mnew, segs, &nsegs, BUS_DMA_NOWAIT);
4831 if (error != 0)
4832 {
4833 m_freem(mnew);
4834
4835 sc->rx_mbuf_dmamap_errors++;
4836 ifp->if_ierrors++;
4837
4838 goto skip;
4839 }
4840
4841 KASSERT(nsegs == 1, ("%s: too many DMA segments",
4842 device_get_name(sc->dev)));
4843
4844 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
4845 BUS_DMASYNC_POSTREAD);
4846 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
4847
4848 dma_map = data->dma_map;
4849 data->dma_map = ring->spare_dma_map;
4850 ring->spare_dma_map = dma_map;
4851
4852 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
4853 BUS_DMASYNC_PREREAD);
4854
4855 m = data->m;
4856
4857 data->m = mnew;
4858 desc->sdp0 = htole32(segs[0].ds_addr);
4859
4860 /* get Rx wireless info */
4861
4862 rxwi = mtod(m, struct rt2860_rxwi *);
4863 len = (le16toh(rxwi->tid_size) >> RT2860_RXWI_SIZE_SHIFT) &
4864 RT2860_RXWI_SIZE_MASK;
4865
4866 /* check for L2 padding between IEEE 802.11 frame header and body */
4867
4868 if (desc_flags & RT2860_RXDESC_FLAGS_L2PAD)
4869 {
4870 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
4871 "%s: L2 padding: len=%d\n",
4872 device_get_nameunit(sc->dev), len);
4873
4874 len += 2;
4875 }
4876
4877 m->m_pkthdr.rcvif = ifp;
4878 m->m_data = (caddr_t) (rxwi + 1);
4879 m->m_pkthdr.len = m->m_len = len;
4880
4881 /* check for crc errors */
4882
4883 if (desc_flags & RT2860_RXDESC_FLAGS_CRC_ERR)
4884 {
4885 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
4886 "%s: rxdesc: crc error\n",
4887 device_get_nameunit(sc->dev));
4888
4889 ifp->if_ierrors++;
4890
4891 if (!(ifp->if_flags & IFF_PROMISC))
4892 {
4893 m_freem(m);
4894 goto skip;
4895 }
4896 }
4897
4898 wh = (struct ieee80211_frame *) (rxwi + 1);
4899
4900 /* check for cipher errors */
4901
4902 if (desc_flags & RT2860_RXDESC_FLAGS_DECRYPTED)
4903 {
4904 cipher_err = ((desc_flags >> RT2860_RXDESC_FLAGS_CIPHER_ERR_SHIFT) &
4905 RT2860_RXDESC_FLAGS_CIPHER_ERR_MASK);
4906 if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_NONE)
4907 {
4908 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4909 wh->i_fc[1] &= ~IEEE80211_FC1_WEP;
4910
4911 m->m_flags |= M_WEP;
4912
4913 sc->rx_cipher_no_errors++;
4914 }
4915 else
4916 {
4917 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
4918 "%s: rxdesc: cipher error=0x%02x\n",
4919 device_get_nameunit(sc->dev), cipher_err);
4920
4921 if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_ICV)
4922 sc->rx_cipher_icv_errors++;
4923 else if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_MIC)
4924 sc->rx_cipher_mic_errors++;
4925 else if (cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_INVALID_KEY)
4926 sc->rx_cipher_invalid_key_errors++;
4927
4928 if ((cipher_err == RT2860_RXDESC_FLAGS_CIPHER_ERR_MIC) &&
4929 (desc_flags & RT2860_RXDESC_FLAGS_MYBSS))
4930 {
4931 keyidx = (rxwi->udf_bssidx_keyidx >> RT2860_RXWI_KEYIDX_SHIFT) &
4932 RT2860_RXWI_KEYIDX_MASK;
4933
4934 ieee80211_notify_michael_failure(ic, wh, keyidx);
4935 }
4936
4937 ifp->if_ierrors++;
4938
4939 if (!(ifp->if_flags & IFF_PROMISC))
4940 {
4941 m_free(m);
4942 goto skip;
4943 }
4944 }
4945 }
4946 else
4947 {
4948 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
4949 {
4950 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
4951 "%s: rxdesc: not decrypted but protected flag set\n",
4952 device_get_nameunit(sc->dev));
4953
4954 ifp->if_ierrors++;
4955
4956 if (!(ifp->if_flags & IFF_PROMISC))
4957 {
4958 m_free(m);
4959 goto skip;
4960 }
4961 }
4962 }
4963
4964 /* check for A-MPDU */
4965
4966 if (desc_flags & RT2860_RXDESC_FLAGS_AMPDU)
4967 {
4968 m->m_flags |= M_AMPDU;
4969
4970 sc->rx_ampdu++;
4971
4972 ampdu = 1;
4973 }
4974 else
4975 {
4976 ampdu = 0;
4977 }
4978
4979 /* check for A-MSDU */
4980
4981 if (desc_flags & RT2860_RXDESC_FLAGS_AMSDU)
4982 {
4983 sc->rx_amsdu++;
4984
4985 amsdu = 1;
4986 }
4987 else
4988 {
4989 amsdu = 0;
4990 }
4991
4992 ant = rt2860_maxrssi_rxpath(sc, rxwi);
4993 rssi = rxwi->rssi[ant];
4994 rssi_dbm = rt2860_rssi2dbm(sc, rssi, ant);
4995 phymode = ((rxwi->phymode_stbc_shortgi >> RT2860_RXWI_PHYMODE_SHIFT) &
4996 RT2860_RXWI_PHYMODE_MASK);
4997 bw = ((rxwi->bw_mcs >> RT2860_RXWI_BW_SHIFT) & RT2860_RXWI_BW_MASK);
4998 shortgi = ((rxwi->phymode_stbc_shortgi >> RT2860_RXWI_SHORTGI_SHIFT) &
4999 RT2860_RXWI_SHORTGI_MASK);
5000 mcs = ((rxwi->bw_mcs >> RT2860_RXWI_MCS_SHIFT) & RT2860_RXWI_MCS_MASK);
5001
5002 if (bpf_peers_present(sc->drvbpf))
5003 {
5004 tap = &sc->rxtap;
5005
5006 tap->flags = IEEE80211_RADIOTAP_F_DATAPAD;
5007 tap->dbm_antsignal = rssi_dbm;
5008 tap->dbm_antnoise = RT2860_NOISE_FLOOR;
5009 tap->antenna = ant;
5010 tap->antsignal = rssi;
5011 tap->chan_flags = htole32(ic->ic_curchan->ic_flags);
5012 tap->chan_freq = htole16(ic->ic_curchan->ic_freq);
5013 tap->chan_ieee = ic->ic_curchan->ic_ieee;
5014 tap->chan_maxpow = 0;
5015
5016 if (phymode == RT2860_TXWI_PHYMODE_HT_MIXED || phymode == RT2860_TXWI_PHYMODE_HT_GF)
5017 tap->rate = mcs | IEEE80211_RATE_MCS;
5018 else
5019 tap->rate = rt2860_rxrate(rxwi);
5020
5021 if (desc_flags & RT2860_RXDESC_FLAGS_CRC_ERR)
5022 tap->flags |= IEEE80211_RADIOTAP_F_BADFCS;
5023
5024 if (desc_flags & RT2860_RXDESC_FLAGS_FRAG)
5025 tap->flags |= IEEE80211_RADIOTAP_F_FRAG;
5026
5027 if (rxwi->bw_mcs & RT2860_RXWI_MCS_SHOTPRE)
5028 tap->flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
5029
5030 if ((desc_flags & RT2860_RXDESC_FLAGS_DECRYPTED) ||
5031 (wh->i_fc[1] & IEEE80211_FC1_WEP))
5032 tap->flags |= IEEE80211_RADIOTAP_F_WEP;
5033
5034 if (shortgi)
5035 tap->flags |= IEEE80211_RADIOTAP_F_SHORTGI;
5036
5037 bpf_mtap2(sc->drvbpf, tap, sc->rxtap_len, m);
5038 }
5039
5040 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
5041 "%s: received frame: len=%d, phymode=%d, bw=%d, shortgi=%d, mcs=%d, "
5042 "ant=%d, rssi=%d/%d/%d, snr=%d/%d, wcid=0x%02x, ampdu=%d, amsdu=%d\n",
5043 device_get_nameunit(sc->dev),
5044 len, phymode, bw, shortgi, mcs,
5045 ant, rxwi->rssi[0], rxwi->rssi[1], rxwi->rssi[2],
5046 rxwi->snr[0], rxwi->snr[1],
5047 rxwi->wcid, ampdu, amsdu);
5048
5049 ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *) wh);
5050
5051 if (ni != NULL)
5052 {
5053 rni = (struct rt2860_softc_node *) ni;
5054
5055 for (i = 0; i < RT2860_SOFTC_RSSI_COUNT; i++)
5056 {
5057 rni->last_rssi[i] = rxwi->rssi[i];
5058 rni->last_rssi_dbm[i] = rt2860_rssi2dbm(sc, rxwi->rssi[i], i);
5059 }
5060 }
5061
5062 ieee80211_input(ic, m, ni, rssi_dbm, RT2860_NOISE_FLOOR, 0);
5063
5064 ieee80211_free_node(ni);
5065
5066 skip:
5067
5068 desc->sdl0 &= ~htole16(RT2860_RXDESC_SDL0_DDONE);
5069
5070 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5071 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
5072
5073 ring->cur = (ring->cur + 1) % RT2860_SOFTC_RX_RING_DATA_COUNT;
5074
5075 limit--;
5076 }
5077
5078 if (ring->cur == 0)
5079 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX,
5080 RT2860_SOFTC_RX_RING_DATA_COUNT - 1);
5081 else
5082 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_RX_CALC_IDX,
5083 ring->cur - 1);
5084
5085 RT2860_DPRINTF(sc, RT2860_DEBUG_RX,
5086 "%s: Rx eof: nframes=%d\n",
5087 device_get_nameunit(sc->dev), nframes);
5088
5089 sc->rx_packets += nframes;
5090
5091 return (limit == 0);
5092 }
5093
5094 /*
5095 * rt2860_tx_eof
5096 */
5097 static void rt2860_tx_eof(struct rt2860_softc *sc,
5098 struct rt2860_softc_tx_ring *ring)
5099 {
5100 struct ifnet *ifp;
5101 struct rt2860_txdesc *desc;
5102 struct rt2860_softc_tx_data *data;
5103 uint32_t index;
5104 int ndescs, nframes;
5105
5106 ifp = sc->ifp;
5107
5108 ndescs = 0;
5109 nframes = 0;
5110
5111 for (;;)
5112 {
5113 index = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_TX_DTX_IDX(ring->qid));
5114 if (ring->desc_next == index)
5115 break;
5116
5117 ndescs++;
5118
5119 rt2860_drain_fifo_stats(sc);
5120
5121 desc = &ring->desc[ring->desc_next];
5122
5123 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5124 BUS_DMASYNC_POSTREAD);
5125
5126 if (desc->sdl0 & htole16(RT2860_TXDESC_SDL0_LASTSEG) ||
5127 desc->sdl1 & htole16(RT2860_TXDESC_SDL1_LASTSEG))
5128 {
5129 nframes++;
5130
5131 data = &ring->data[ring->data_next];
5132
5133 if (data->m->m_flags & M_TXCB)
5134 ieee80211_process_callback(data->ni, data->m, 0);
5135
5136 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
5137 BUS_DMASYNC_POSTWRITE);
5138 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
5139
5140 m_freem(data->m);
5141
5142 ieee80211_free_node(data->ni);
5143
5144 data->m = NULL;
5145 data->ni = NULL;
5146
5147 ifp->if_opackets++;
5148
5149 RT2860_SOFTC_TX_RING_LOCK(ring);
5150
5151 ring->data_queued--;
5152 ring->data_next = (ring->data_next + 1) % RT2860_SOFTC_TX_RING_DATA_COUNT;
5153
5154 RT2860_SOFTC_TX_RING_UNLOCK(ring);
5155 }
5156
5157 desc->sdl0 &= ~htole16(RT2860_TXDESC_SDL0_DDONE);
5158
5159 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5160 BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
5161
5162 RT2860_SOFTC_TX_RING_LOCK(ring);
5163
5164 ring->desc_queued--;
5165 ring->desc_next = (ring->desc_next + 1) % RT2860_SOFTC_TX_RING_DESC_COUNT;
5166
5167 RT2860_SOFTC_TX_RING_UNLOCK(ring);
5168 }
5169
5170 RT2860_DPRINTF(sc, RT2860_DEBUG_TX,
5171 "%s: Tx eof: qid=%d, ndescs=%d, nframes=%d\n",
5172 device_get_nameunit(sc->dev), ring->qid, ndescs, nframes);
5173 }
5174
5175 /*
5176 * rt2860_update_stats
5177 */
5178 static void rt2860_update_stats(struct rt2860_softc *sc)
5179 {
5180 struct ifnet *ifp;
5181 uint32_t stacnt[3];
5182 int beacons, noretryok, retryok, failed, underflows, zerolen;
5183
5184 ifp = sc->ifp;
5185
5186 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS,
5187 "%s: update statistic\n",
5188 device_get_nameunit(sc->dev));
5189
5190 rt2860_drain_fifo_stats(sc);
5191
5192 /* read and clear Tx statistic registers */
5193
5194 rt2860_io_mac_read_multi(sc, RT2860_REG_TX_STA_CNT0,
5195 stacnt, sizeof(stacnt));
5196
5197 stacnt[0] = le32toh(stacnt[0]);
5198 stacnt[1] = le32toh(stacnt[1]);
5199 stacnt[2] = le32toh(stacnt[2]);
5200
5201 beacons = stacnt[0] >> 16;
5202 noretryok = stacnt[1] & 0xffff;
5203 retryok = stacnt[1] >> 16;
5204 failed = stacnt[0] & 0xffff;
5205 underflows = stacnt[2] >> 16;
5206 zerolen = stacnt[2] & 0xffff;
5207
5208 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS,
5209 "%s: update statistic: beacons=%d, noretryok=%d, retryok=%d, failed=%d, underflows=%d, zerolen=%d\n",
5210 device_get_nameunit(sc->dev),
5211 beacons, noretryok, retryok, failed, underflows, zerolen);
5212
5213 ifp->if_oerrors += failed;
5214
5215 sc->tx_beacons += beacons;
5216 sc->tx_noretryok += noretryok;
5217 sc->tx_retryok += retryok;
5218 sc->tx_failed += failed;
5219 sc->tx_underflows += underflows;
5220 sc->tx_zerolen += zerolen;
5221 }
5222
5223 /*
5224 * rt2860_bbp_tuning
5225 */
5226 static void rt2860_bbp_tuning(struct rt2860_softc *sc)
5227 {
5228 struct ieee80211com *ic;
5229 struct ieee80211_node *ni;
5230 int chan, group;
5231 int8_t rssi, old, new;
5232
5233 /* RT2860C does not support BBP tuning */
5234
5235 if (sc->mac_rev == 0x28600100)
5236 return;
5237
5238 ic = &sc->ic;
5239
5240 if ((ic->ic_flags & IEEE80211_F_SCAN) ||
5241 ic->ic_opmode != IEEE80211_M_STA || ic->ic_state != IEEE80211_S_RUN)
5242 return;
5243
5244 ni = ic->ic_bss;
5245
5246 chan = ieee80211_chan2ieee(ic, ni->ni_chan);
5247
5248 if (chan <= 14)
5249 group = 0;
5250 else if (chan <= 64)
5251 group = 1;
5252 else if (chan <= 128)
5253 group = 2;
5254 else
5255 group = 3;
5256
5257 rssi = ieee80211_getrssi(ic);
5258
5259 if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan))
5260 {
5261 new = 0x2e + sc->lna_gain[group];
5262 }
5263 else
5264 {
5265 if (!IEEE80211_IS_CHAN_HT40(ni->ni_chan))
5266 new = 0x32 + sc->lna_gain[group] * 5 / 3;
5267 else
5268 new = 0x3a + sc->lna_gain[group] * 5 / 3;
5269 }
5270
5271 /* Tune if absolute average RSSI is greater than -80 */
5272
5273 if (rssi > -80)
5274 new += 0x10;
5275
5276 old = rt2860_io_bbp_read(sc, 66);
5277
5278 if (old != new)
5279 rt2860_io_bbp_write(sc, 66, new);
5280 }
5281
5282 /*
5283 * rt2860_watchdog
5284 */
5285 static void rt2860_watchdog(struct rt2860_softc *sc)
5286 {
5287 uint32_t tmp;
5288 int ntries;
5289
5290 tmp = rt2860_io_mac_read(sc, RT2860_REG_PBF_TXRXQ_PCNT);
5291
5292 RT2860_DPRINTF(sc, RT2860_DEBUG_WATCHDOG,
5293 "%s: watchdog: TXRXQ_PCNT=0x%08x\n",
5294 device_get_nameunit(sc->dev), tmp);
5295
5296 if (((tmp >> RT2860_REG_TX0Q_PCNT_SHIFT) & RT2860_REG_TX0Q_PCNT_MASK) != 0)
5297 {
5298 sc->tx_queue_not_empty[0]++;
5299
5300 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf40012);
5301
5302 for (ntries = 0; ntries < 10; ntries++)
5303 {
5304 tmp = rt2860_io_mac_read(sc, RT2860_REG_PBF_TXRXQ_PCNT);
5305 if (((tmp >> RT2860_REG_TX0Q_PCNT_SHIFT) & RT2860_REG_TX0Q_PCNT_MASK) == 0)
5306 break;
5307
5308 DELAY(1);
5309 }
5310
5311 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf40006);
5312 }
5313
5314 if (((tmp >> RT2860_REG_TX1Q_PCNT_SHIFT) & RT2860_REG_TX1Q_PCNT_MASK) != 0)
5315 {
5316 sc->tx_queue_not_empty[1]++;
5317
5318 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf4000a);
5319
5320 for (ntries = 0; ntries < 10; ntries++)
5321 {
5322 tmp = rt2860_io_mac_read(sc, RT2860_REG_PBF_TXRXQ_PCNT);
5323 if (((tmp >> RT2860_REG_TX1Q_PCNT_SHIFT) & RT2860_REG_TX1Q_PCNT_MASK) == 0)
5324 break;
5325
5326 DELAY(1);
5327 }
5328
5329 rt2860_io_mac_write(sc, RT2860_REG_PBF_CFG, 0xf40006);
5330 }
5331 }
5332
5333 /*
5334 * rt2860_drain_fifo_stats
5335 */
5336 static void rt2860_drain_fifo_stats(struct rt2860_softc *sc)
5337 {
5338 struct ifnet *ifp;
5339 uint32_t stats;
5340 uint8_t wcid, mcs, pid;
5341 int ok, agg, retrycnt;
5342
5343 ifp = sc->ic.ic_ifp;
5344
5345 /* drain Tx status FIFO (maxsize = 16) */
5346
5347 while ((stats = rt2860_io_mac_read(sc, RT2860_REG_TX_STA_FIFO)) &
5348 RT2860_REG_TX_STA_FIFO_VALID)
5349 {
5350 wcid = (stats >> RT2860_REG_TX_STA_FIFO_WCID_SHIFT) &
5351 RT2860_REG_TX_STA_FIFO_WCID_MASK;
5352
5353 /* if no ACK was requested, no feedback is available */
5354
5355 if (!(stats & RT2860_REG_TX_STA_FIFO_ACK_REQ) || wcid == RT2860_WCID_RESERVED)
5356 continue;
5357
5358 /* update AMRR statistic */
5359
5360 ok = (stats & RT2860_REG_TX_STA_FIFO_TX_OK) ? 1 : 0;
5361 agg = (stats & RT2860_REG_TX_STA_FIFO_AGG) ? 1 : 0;
5362 mcs = (stats >> RT2860_REG_TX_STA_FIFO_MCS_SHIFT) &
5363 RT2860_REG_TX_STA_FIFO_MCS_MASK;
5364 pid = (stats >> RT2860_REG_TX_STA_FIFO_PID_SHIFT) &
5365 RT2860_REG_TX_STA_FIFO_PID_MASK;
5366 retrycnt = pid - mcs;
5367
5368 RT2860_DPRINTF(sc, RT2860_DEBUG_STATS,
5369 "%s: FIFO statistic: wcid=0x%02x, ok=%d, agg=%d, mcs=0x%02x, pid=0x%02x, retrycnt=%d\n",
5370 device_get_nameunit(sc->dev),
5371 wcid, ok, agg, mcs, pid, retrycnt);
5372
5373 rt2860_amrr_tx_complete(&sc->amrr_node[wcid], ok, retrycnt);
5374
5375 if (!ok)
5376 ifp->if_oerrors++;
5377 }
5378 }
5379
5380 /*
5381 * rt2860_update_raw_counters
5382 */
5383 static void rt2860_update_raw_counters(struct rt2860_softc *sc)
5384 {
5385 uint32_t tmp;
5386
5387 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT);
5388
5389 sc->tx_nonagg += tmp & 0xffff;
5390 sc->tx_agg += tmp >> 16;
5391
5392 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT0);
5393
5394 sc->tx_ampdu += (tmp & 0xffff) / 1 + (tmp >> 16) / 2;
5395
5396 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT1);
5397
5398 sc->tx_ampdu += (tmp & 0xffff) / 3 + (tmp >> 16) / 4;
5399
5400 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT2);
5401
5402 sc->tx_ampdu += (tmp & 0xffff) / 5 + (tmp >> 16) / 6;
5403
5404 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT3);
5405
5406 sc->tx_ampdu += (tmp & 0xffff) / 7 + (tmp >> 16) / 8;
5407
5408 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT4);
5409
5410 sc->tx_ampdu += (tmp & 0xffff) / 9 + (tmp >> 16) / 10;
5411
5412 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT5);
5413
5414 sc->tx_ampdu += (tmp & 0xffff) / 11 + (tmp >> 16) / 12;
5415
5416 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT6);
5417
5418 sc->tx_ampdu += (tmp & 0xffff) / 13 + (tmp >> 16) / 14;
5419
5420 tmp = rt2860_io_mac_read(sc, RT2860_REG_TX_AGG_CNT7);
5421
5422 sc->tx_ampdu += (tmp & 0xffff) / 15 + (tmp >> 16) / 16;
5423
5424 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_STA_CNT0);
5425
5426 sc->rx_crc_errors += tmp & 0xffff;
5427 sc->rx_phy_errors += tmp >> 16;
5428
5429 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_STA_CNT1);
5430
5431 sc->rx_false_ccas += tmp & 0xffff;
5432 sc->rx_plcp_errors += tmp >> 16;
5433
5434 tmp = rt2860_io_mac_read(sc, RT2860_REG_RX_STA_CNT2);
5435
5436 sc->rx_dup_packets += tmp & 0xffff;
5437 sc->rx_fifo_overflows += tmp >> 16;
5438
5439 tmp = rt2860_io_mac_read(sc, RT2860_REG_TXRX_MPDU_DEN_CNT);
5440
5441 sc->tx_mpdu_zero_density += tmp & 0xffff;
5442 sc->rx_mpdu_zero_density += tmp >> 16;
5443 }
5444
5445 /*
5446 * rt2860_intr_enable
5447 */
5448 static void rt2860_intr_enable(struct rt2860_softc *sc, uint32_t intr_mask)
5449 {
5450 uint32_t tmp;
5451
5452 sc->intr_disable_mask &= ~intr_mask;
5453
5454 tmp = sc->intr_enable_mask & ~sc->intr_disable_mask;
5455
5456 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, tmp);
5457 }
5458
5459 /*
5460 * rt2860_intr_disable
5461 */
5462 static void rt2860_intr_disable(struct rt2860_softc *sc, uint32_t intr_mask)
5463 {
5464 uint32_t tmp;
5465
5466 sc->intr_disable_mask |= intr_mask;
5467
5468 tmp = sc->intr_enable_mask & ~sc->intr_disable_mask;
5469
5470 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_INT_MASK, tmp);
5471 }
5472
5473 /*
5474 * rt2860_txrx_enable
5475 */
5476 static int rt2860_txrx_enable(struct rt2860_softc *sc)
5477 {
5478 struct ieee80211com *ic;
5479 struct ifnet *ifp;
5480 uint32_t tmp;
5481 int ntries;
5482
5483 ic = &sc->ic;
5484 ifp = ic->ic_ifp;
5485
5486 /* enable Tx/Rx DMA engine */
5487
5488 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL, RT2860_REG_TX_ENABLE);
5489
5490 for (ntries = 0; ntries < 200; ntries++)
5491 {
5492 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG);
5493 if (!(tmp & (RT2860_REG_TX_DMA_BUSY | RT2860_REG_RX_DMA_BUSY)))
5494 break;
5495
5496 DELAY(1000);
5497 }
5498
5499 if (ntries == 200)
5500 {
5501 printf("%s: timeout waiting for DMA engine\n",
5502 device_get_nameunit(sc->dev));
5503 return -1;
5504 }
5505
5506 DELAY(50);
5507
5508 tmp |= RT2860_REG_TX_WB_DDONE |
5509 RT2860_REG_RX_DMA_ENABLE |
5510 RT2860_REG_TX_DMA_ENABLE |
5511 (RT2860_REG_WPDMA_BT_SIZE64 << RT2860_REG_WPDMA_BT_SIZE_SHIFT);
5512
5513 rt2860_io_mac_write(sc, RT2860_REG_SCHDMA_WPDMA_GLO_CFG, tmp);
5514
5515 /* set Rx filter */
5516
5517 tmp = RT2860_REG_RX_FILTER_DROP_CRC_ERR |
5518 RT2860_REG_RX_FILTER_DROP_PHY_ERR;
5519
5520 if (ic->ic_opmode != IEEE80211_M_MONITOR)
5521 {
5522 tmp |= RT2860_REG_RX_FILTER_DROP_DUPL |
5523 RT2860_REG_RX_FILTER_DROP_CTS |
5524 RT2860_REG_RX_FILTER_DROP_BA |
5525 RT2860_REG_RX_FILTER_DROP_ACK |
5526 RT2860_REG_RX_FILTER_DROP_VER_ERR |
5527 RT2860_REG_RX_FILTER_DROP_CTRL_RSV |
5528 RT2860_REG_RX_FILTER_DROP_CFACK |
5529 RT2860_REG_RX_FILTER_DROP_CFEND;
5530
5531 if (ic->ic_opmode == IEEE80211_M_STA)
5532 tmp |= RT2860_REG_RX_FILTER_DROP_RTS |
5533 RT2860_REG_RX_FILTER_DROP_PSPOLL;
5534
5535 if (!(ifp->if_flags & IFF_PROMISC))
5536 tmp |= RT2860_REG_RX_FILTER_DROP_UC_NOME;
5537 }
5538
5539 rt2860_io_mac_write(sc, RT2860_REG_RX_FILTER_CFG, tmp);
5540
5541 rt2860_io_mac_write(sc, RT2860_REG_SYS_CTRL,
5542 RT2860_REG_RX_ENABLE | RT2860_REG_TX_ENABLE);
5543
5544 return 0;
5545 }
5546
5547 /*
5548 * rt2860_alloc_rx_ring
5549 */
5550 static int rt2860_alloc_rx_ring(struct rt2860_softc *sc,
5551 struct rt2860_softc_rx_ring *ring)
5552 {
5553 struct rt2860_rxdesc *desc;
5554 struct rt2860_softc_rx_data *data;
5555 bus_dma_segment_t segs[1];
5556 int i, nsegs, error;
5557
5558 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
5559 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
5560 RT2860_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt2860_rxdesc), 1,
5561 RT2860_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt2860_rxdesc),
5562 0, NULL, NULL, &ring->desc_dma_tag);
5563 if (error != 0)
5564 {
5565 printf("%s: could not create Rx desc DMA tag\n",
5566 device_get_nameunit(sc->dev));
5567 goto fail;
5568 }
5569
5570 error = bus_dmamem_alloc(ring->desc_dma_tag, (void **) &ring->desc,
5571 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_dma_map);
5572 if (error != 0)
5573 {
5574 printf("%s: could not allocate Rx desc DMA memory\n",
5575 device_get_nameunit(sc->dev));
5576 goto fail;
5577 }
5578
5579 error = bus_dmamap_load(ring->desc_dma_tag, ring->desc_dma_map,
5580 ring->desc,
5581 RT2860_SOFTC_RX_RING_DATA_COUNT * sizeof(struct rt2860_rxdesc),
5582 rt2860_dma_map_addr, &ring->desc_phys_addr, 0);
5583 if (error != 0)
5584 {
5585 printf("%s: could not load Rx desc DMA map\n",
5586 device_get_nameunit(sc->dev));
5587 goto fail;
5588 }
5589
5590 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
5591 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
5592 MJUMPAGESIZE, 1, MJUMPAGESIZE, 0, NULL, NULL,
5593 &ring->data_dma_tag);
5594 if (error != 0)
5595 {
5596 printf("%s: could not create Rx data DMA tag\n",
5597 device_get_nameunit(sc->dev));
5598 goto fail;
5599 }
5600
5601 for (i = 0; i < RT2860_SOFTC_RX_RING_DATA_COUNT; i++)
5602 {
5603 desc = &ring->desc[i];
5604 data = &ring->data[i];
5605
5606 error = bus_dmamap_create(ring->data_dma_tag, 0, &data->dma_map);
5607 if (error != 0)
5608 {
5609 printf("%s: could not create Rx data DMA map\n",
5610 device_get_nameunit(sc->dev));
5611 goto fail;
5612 }
5613
5614 data->m = m_getjcl(M_DONTWAIT, MT_DATA, M_PKTHDR, MJUMPAGESIZE);
5615 if (data->m == NULL)
5616 {
5617 printf("%s: could not allocate Rx mbuf\n",
5618 device_get_nameunit(sc->dev));
5619 error = ENOMEM;
5620 goto fail;
5621 }
5622
5623 data->m->m_len = data->m->m_pkthdr.len = MJUMPAGESIZE;
5624
5625 error = bus_dmamap_load_mbuf_sg(ring->data_dma_tag, data->dma_map,
5626 data->m, segs, &nsegs, BUS_DMA_NOWAIT);
5627 if (error != 0)
5628 {
5629 printf("%s: could not load Rx mbuf DMA map\n",
5630 device_get_nameunit(sc->dev));
5631 goto fail;
5632 }
5633
5634 KASSERT(nsegs == 1, ("%s: too many DMA segments",
5635 device_get_name(sc->dev)));
5636
5637 desc->sdp0 = htole32(segs[0].ds_addr);
5638 desc->sdl0 = htole16(MJUMPAGESIZE);
5639 }
5640
5641 error = bus_dmamap_create(ring->data_dma_tag, 0, &ring->spare_dma_map);
5642 if (error != 0)
5643 {
5644 printf("%s: could not create Rx spare DMA map\n",
5645 device_get_nameunit(sc->dev));
5646 goto fail;
5647 }
5648
5649 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5650 BUS_DMASYNC_PREWRITE);
5651
5652 return 0;
5653
5654 fail:
5655
5656 rt2860_free_rx_ring(sc, ring);
5657
5658 return error;
5659 }
5660
5661 /*
5662 * rt2860_reset_rx_ring
5663 */
5664 static void rt2860_reset_rx_ring(struct rt2860_softc *sc,
5665 struct rt2860_softc_rx_ring *ring)
5666 {
5667 struct rt2860_rxdesc *desc;
5668 int i;
5669
5670 for (i = 0; i < RT2860_SOFTC_RX_RING_DATA_COUNT; i++)
5671 {
5672 desc = &ring->desc[i];
5673
5674 desc->sdl0 &= ~htole16(RT2860_RXDESC_SDL0_DDONE);
5675 }
5676
5677 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5678 BUS_DMASYNC_PREWRITE);
5679
5680 ring->cur = 0;
5681 }
5682
5683 /*
5684 * rt2860_free_rx_ring
5685 */
5686 static void rt2860_free_rx_ring(struct rt2860_softc *sc,
5687 struct rt2860_softc_rx_ring *ring)
5688 {
5689 struct rt2860_softc_rx_data *data;
5690 int i;
5691
5692 if (ring->desc != NULL)
5693 {
5694 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5695 BUS_DMASYNC_POSTWRITE);
5696 bus_dmamap_unload(ring->desc_dma_tag, ring->desc_dma_map);
5697 bus_dmamem_free(ring->desc_dma_tag, ring->desc,
5698 ring->desc_dma_map);
5699 }
5700
5701 if (ring->desc_dma_tag != NULL)
5702 bus_dma_tag_destroy(ring->desc_dma_tag);
5703
5704 for (i = 0; i < RT2860_SOFTC_RX_RING_DATA_COUNT; i++)
5705 {
5706 data = &ring->data[i];
5707
5708 if (data->m != NULL)
5709 {
5710 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
5711 BUS_DMASYNC_POSTREAD);
5712 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
5713 m_freem(data->m);
5714 }
5715
5716 if (data->dma_map != NULL)
5717 bus_dmamap_destroy(ring->data_dma_tag, data->dma_map);
5718 }
5719
5720 if (ring->spare_dma_map != NULL)
5721 bus_dmamap_destroy(ring->data_dma_tag, ring->spare_dma_map);
5722
5723 if (ring->data_dma_tag != NULL)
5724 bus_dma_tag_destroy(ring->data_dma_tag);
5725 }
5726
5727 /*
5728 * rt2860_alloc_tx_ring
5729 */
5730 static int rt2860_alloc_tx_ring(struct rt2860_softc *sc,
5731 struct rt2860_softc_tx_ring *ring, int qid)
5732 {
5733 struct rt2860_softc_tx_data *data;
5734 int error, i;
5735
5736 mtx_init(&ring->lock, device_get_nameunit(sc->dev), NULL, MTX_DEF);
5737
5738 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
5739 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
5740 RT2860_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt2860_txdesc), 1,
5741 RT2860_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt2860_txdesc),
5742 0, NULL, NULL, &ring->desc_dma_tag);
5743 if (error != 0)
5744 {
5745 printf("%s: could not create Tx desc DMA tag\n",
5746 device_get_nameunit(sc->dev));
5747 goto fail;
5748 }
5749
5750 error = bus_dmamem_alloc(ring->desc_dma_tag, (void **) &ring->desc,
5751 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_dma_map);
5752 if (error != 0)
5753 {
5754 printf("%s: could not allocate Tx desc DMA memory\n",
5755 device_get_nameunit(sc->dev));
5756 goto fail;
5757 }
5758
5759 error = bus_dmamap_load(ring->desc_dma_tag, ring->desc_dma_map,
5760 ring->desc,
5761 RT2860_SOFTC_TX_RING_DESC_COUNT * sizeof(struct rt2860_txdesc),
5762 rt2860_dma_map_addr, &ring->desc_phys_addr, 0);
5763 if (error != 0)
5764 {
5765 printf("%s: could not load Tx desc DMA map\n",
5766 device_get_nameunit(sc->dev));
5767 goto fail;
5768 }
5769
5770 ring->desc_queued = 0;
5771 ring->desc_cur = 0;
5772 ring->desc_next = 0;
5773
5774 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
5775 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
5776 RT2860_SOFTC_TX_RING_DATA_COUNT * RT2860_TX_DATA_SEG0_SIZE, 1,
5777 RT2860_SOFTC_TX_RING_DATA_COUNT * RT2860_TX_DATA_SEG0_SIZE,
5778 0, NULL, NULL, &ring->seg0_dma_tag);
5779 if (error != 0)
5780 {
5781 printf("%s: could not create Tx seg0 DMA tag\n",
5782 device_get_nameunit(sc->dev));
5783 goto fail;
5784 }
5785
5786 error = bus_dmamem_alloc(ring->seg0_dma_tag, (void **) &ring->seg0,
5787 BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->seg0_dma_map);
5788 if (error != 0)
5789 {
5790 printf("%s: could not allocate Tx seg0 DMA memory\n",
5791 device_get_nameunit(sc->dev));
5792 goto fail;
5793 }
5794
5795 error = bus_dmamap_load(ring->seg0_dma_tag, ring->seg0_dma_map,
5796 ring->seg0,
5797 RT2860_SOFTC_TX_RING_DATA_COUNT * RT2860_TX_DATA_SEG0_SIZE,
5798 rt2860_dma_map_addr, &ring->seg0_phys_addr, 0);
5799 if (error != 0)
5800 {
5801 printf("%s: could not load Tx seg0 DMA map\n",
5802 device_get_nameunit(sc->dev));
5803 goto fail;
5804 }
5805
5806 error = bus_dma_tag_create(bus_get_dma_tag(sc->dev), PAGE_SIZE, 0,
5807 BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
5808 MJUMPAGESIZE, RT2860_SOFTC_MAX_SCATTER, MJUMPAGESIZE, 0, NULL, NULL,
5809 &ring->data_dma_tag);
5810 if (error != 0)
5811 {
5812 printf("%s: could not create Tx data DMA tag\n",
5813 device_get_nameunit(sc->dev));
5814 goto fail;
5815 }
5816
5817 for (i = 0; i < RT2860_SOFTC_TX_RING_DATA_COUNT; i++)
5818 {
5819 data = &ring->data[i];
5820
5821 error = bus_dmamap_create(ring->data_dma_tag, 0, &data->dma_map);
5822 if (error != 0)
5823 {
5824 printf("%s: could not create Tx data DMA map\n",
5825 device_get_nameunit(sc->dev));
5826 goto fail;
5827 }
5828 }
5829
5830 ring->data_queued = 0;
5831 ring->data_cur = 0;
5832 ring->data_next = 0;
5833
5834 ring->qid = qid;
5835
5836 return 0;
5837
5838 fail:
5839
5840 rt2860_free_tx_ring(sc, ring);
5841
5842 return error;
5843 }
5844
5845 /*
5846 * rt2860_reset_tx_ring
5847 */
5848 static void rt2860_reset_tx_ring(struct rt2860_softc *sc,
5849 struct rt2860_softc_tx_ring *ring)
5850 {
5851 struct rt2860_softc_tx_data *data;
5852 struct rt2860_txdesc *desc;
5853 int i;
5854
5855 for (i = 0; i < RT2860_SOFTC_TX_RING_DESC_COUNT; i++)
5856 {
5857 desc = &ring->desc[i];
5858
5859 desc->sdl0 = 0;
5860 desc->sdl1 = 0;
5861 }
5862
5863 ring->desc_queued = 0;
5864 ring->desc_cur = 0;
5865 ring->desc_next = 0;
5866
5867 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5868 BUS_DMASYNC_PREWRITE);
5869
5870 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map,
5871 BUS_DMASYNC_PREWRITE);
5872
5873 for (i = 0; i < RT2860_SOFTC_TX_RING_DATA_COUNT; i++)
5874 {
5875 data = &ring->data[i];
5876
5877 if (data->m != NULL)
5878 {
5879 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
5880 BUS_DMASYNC_POSTWRITE);
5881 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
5882 m_freem(data->m);
5883 data->m = NULL;
5884 }
5885
5886 if (data->ni != NULL)
5887 {
5888 ieee80211_free_node(data->ni);
5889 data->ni = NULL;
5890 }
5891 }
5892
5893 ring->data_queued = 0;
5894 ring->data_cur = 0;
5895 ring->data_next = 0;
5896 }
5897
5898 /*
5899 * rt2860_free_tx_ring
5900 */
5901 static void rt2860_free_tx_ring(struct rt2860_softc *sc,
5902 struct rt2860_softc_tx_ring *ring)
5903 {
5904 struct rt2860_softc_tx_data *data;
5905 int i;
5906
5907 if (ring->desc != NULL)
5908 {
5909 bus_dmamap_sync(ring->desc_dma_tag, ring->desc_dma_map,
5910 BUS_DMASYNC_POSTWRITE);
5911 bus_dmamap_unload(ring->desc_dma_tag, ring->desc_dma_map);
5912 bus_dmamem_free(ring->desc_dma_tag, ring->desc,
5913 ring->desc_dma_map);
5914 }
5915
5916 if (ring->desc_dma_tag != NULL)
5917 bus_dma_tag_destroy(ring->desc_dma_tag);
5918
5919 if (ring->seg0 != NULL)
5920 {
5921 bus_dmamap_sync(ring->seg0_dma_tag, ring->seg0_dma_map,
5922 BUS_DMASYNC_POSTWRITE);
5923 bus_dmamap_unload(ring->seg0_dma_tag, ring->seg0_dma_map);
5924 bus_dmamem_free(ring->seg0_dma_tag, ring->seg0,
5925 ring->seg0_dma_map);
5926 }
5927
5928 if (ring->seg0_dma_tag != NULL)
5929 bus_dma_tag_destroy(ring->seg0_dma_tag);
5930
5931 for (i = 0; i < RT2860_SOFTC_TX_RING_DATA_COUNT; i++)
5932 {
5933 data = &ring->data[i];
5934
5935 if (data->m != NULL)
5936 {
5937 bus_dmamap_sync(ring->data_dma_tag, data->dma_map,
5938 BUS_DMASYNC_POSTWRITE);
5939 bus_dmamap_unload(ring->data_dma_tag, data->dma_map);
5940 m_freem(data->m);
5941 }
5942
5943 if (data->ni != NULL)
5944 ieee80211_free_node(data->ni);
5945
5946 if (data->dma_map != NULL)
5947 bus_dmamap_destroy(ring->data_dma_tag, data->dma_map);
5948 }
5949
5950 if (ring->data_dma_tag != NULL)
5951 bus_dma_tag_destroy(ring->data_dma_tag);
5952
5953 mtx_destroy(&ring->lock);
5954 }
5955
5956 /*
5957 * rt2860_dma_map_addr
5958 */
5959 static void rt2860_dma_map_addr(void *arg, bus_dma_segment_t *segs,
5960 int nseg, int error)
5961 {
5962 if (error != 0)
5963 return;
5964
5965 KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
5966
5967 *(bus_addr_t *) arg = segs[0].ds_addr;
5968 }
5969
5970 /*
5971 * rt2860_sysctl_attach
5972 */
5973 static void rt2860_sysctl_attach(struct rt2860_softc *sc)
5974 {
5975 struct sysctl_ctx_list *ctx;
5976 struct sysctl_oid *tree;
5977 struct sysctl_oid *stats;
5978
5979 ctx = device_get_sysctl_ctx(sc->dev);
5980 tree = device_get_sysctl_tree(sc->dev);
5981
5982 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
5983 "tx_stbc", CTLFLAG_RW, &sc->tx_stbc, 0,
5984 "Tx STBC");
5985
5986 /* statistic counters */
5987
5988 stats = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
5989 "stats", CTLFLAG_RD, 0, "statistic");
5990
5991 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5992 "interrupts", CTLFLAG_RD, &sc->interrupts, 0,
5993 "all interrupts");
5994
5995 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
5996 "tx_coherent_interrupts", CTLFLAG_RD, &sc->tx_coherent_interrupts, 0,
5997 "Tx coherent interrupts");
5998
5999 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6000 "rx_coherent_interrupts", CTLFLAG_RD, &sc->rx_coherent_interrupts, 0,
6001 "Rx coherent interrupts");
6002
6003 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6004 "txrx_coherent_interrupts", CTLFLAG_RD, &sc->txrx_coherent_interrupts, 0,
6005 "Tx/Rx coherent interrupts");
6006
6007 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6008 "fifo_sta_full_interrupts", CTLFLAG_RD, &sc->fifo_sta_full_interrupts, 0,
6009 "FIFO statistic full interrupts");
6010
6011 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6012 "rx_interrupts", CTLFLAG_RD, &sc->rx_interrupts, 0,
6013 "Rx interrupts");
6014
6015 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6016 "rx_delay_interrupts", CTLFLAG_RD, &sc->rx_delay_interrupts, 0,
6017 "Rx delay interrupts");
6018
6019 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6020 "tx_mgmt_interrupts", CTLFLAG_RD, &sc->tx_interrupts[5], 0,
6021 "Tx MGMT interrupts");
6022
6023 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6024 "tx_hcca_interrupts", CTLFLAG_RD, &sc->tx_interrupts[4], 0,
6025 "Tx HCCA interrupts");
6026
6027 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6028 "tx_ac3_interrupts", CTLFLAG_RD, &sc->tx_interrupts[3], 0,
6029 "Tx AC3 interrupts");
6030
6031 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6032 "tx_ac2_interrupts", CTLFLAG_RD, &sc->tx_interrupts[2], 0,
6033 "Tx AC2 interrupts");
6034
6035 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6036 "tx_ac1_interrupts", CTLFLAG_RD, &sc->tx_interrupts[1], 0,
6037 "Tx AC1 interrupts");
6038
6039 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6040 "tx_ac0_interrupts", CTLFLAG_RD, &sc->tx_interrupts[0], 0,
6041 "Tx AC0 interrupts");
6042
6043 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6044 "tx_delay_interrupts", CTLFLAG_RD, &sc->tx_delay_interrupts, 0,
6045 "Tx delay interrupts");
6046
6047 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6048 "pre_tbtt_interrupts", CTLFLAG_RD, &sc->pre_tbtt_interrupts, 0,
6049 "Pre-TBTT interrupts");
6050
6051 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6052 "tbtt_interrupts", CTLFLAG_RD, &sc->tbtt_interrupts, 0,
6053 "TBTT interrupts");
6054
6055 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6056 "mcu_cmd_interrupts", CTLFLAG_RD, &sc->mcu_cmd_interrupts, 0,
6057 "MCU command interrupts");
6058
6059 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6060 "auto_wakeup_interrupts", CTLFLAG_RD, &sc->auto_wakeup_interrupts, 0,
6061 "auto wakeup interrupts");
6062
6063 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6064 "gp_timer_interrupts", CTLFLAG_RD, &sc->gp_timer_interrupts, 0,
6065 "GP timer interrupts");
6066
6067 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6068 "tx_mgmt_desc_queued", CTLFLAG_RD, &sc->tx_ring[5].desc_queued, 0,
6069 "Tx MGMT descriptors queued");
6070
6071 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6072 "tx_mgmt_data_queued", CTLFLAG_RD, &sc->tx_ring[5].data_queued, 0,
6073 "Tx MGMT data queued");
6074
6075 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6076 "tx_hcca_desc_queued", CTLFLAG_RD, &sc->tx_ring[4].desc_queued, 0,
6077 "Tx HCCA descriptors queued");
6078
6079 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6080 "tx_hcca_data_queued", CTLFLAG_RD, &sc->tx_ring[4].data_queued, 0,
6081 "Tx HCCA data queued");
6082
6083 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6084 "tx_ac3_desc_queued", CTLFLAG_RD, &sc->tx_ring[3].desc_queued, 0,
6085 "Tx AC3 descriptors queued");
6086
6087 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6088 "tx_ac3_data_queued", CTLFLAG_RD, &sc->tx_ring[3].data_queued, 0,
6089 "Tx AC3 data queued");
6090
6091 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6092 "tx_ac2_desc_queued", CTLFLAG_RD, &sc->tx_ring[2].desc_queued, 0,
6093 "Tx AC2 descriptors queued");
6094
6095 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6096 "tx_ac2_data_queued", CTLFLAG_RD, &sc->tx_ring[2].data_queued, 0,
6097 "Tx AC2 data queued");
6098
6099 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6100 "tx_ac1_desc_queued", CTLFLAG_RD, &sc->tx_ring[1].desc_queued, 0,
6101 "Tx AC1 descriptors queued");
6102
6103 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6104 "tx_ac1_data_queued", CTLFLAG_RD, &sc->tx_ring[1].data_queued, 0,
6105 "Tx AC1 data queued");
6106
6107 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6108 "tx_ac0_desc_queued", CTLFLAG_RD, &sc->tx_ring[0].desc_queued, 0,
6109 "Tx AC0 descriptors queued");
6110
6111 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6112 "tx_ac0_data_queued", CTLFLAG_RD, &sc->tx_ring[0].data_queued, 0,
6113 "Tx AC0 data queued");
6114
6115 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6116 "tx_mgmt_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[5], 0,
6117 "Tx MGMT data queue full");
6118
6119 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6120 "tx_hcca_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[4], 0,
6121 "Tx HCCA data queue full");
6122
6123 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6124 "tx_ac3_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[3], 0,
6125 "Tx AC3 data queue full");
6126
6127 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6128 "tx_ac2_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[2], 0,
6129 "Tx AC2 data queue full");
6130
6131 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6132 "tx_ac1_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[1], 0,
6133 "Tx AC1 data queue full");
6134
6135 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6136 "tx_ac0_data_queue_full", CTLFLAG_RD, &sc->tx_data_queue_full[0], 0,
6137 "Tx AC0 data queue full");
6138
6139 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6140 "tx_watchdog_timeouts", CTLFLAG_RD, &sc->tx_watchdog_timeouts, 0,
6141 "Tx watchdog timeouts");
6142
6143 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6144 "tx_defrag_packets", CTLFLAG_RD, &sc->tx_defrag_packets, 0,
6145 "Tx defragmented packets");
6146
6147 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6148 "no_tx_desc_avail", CTLFLAG_RD, &sc->no_tx_desc_avail, 0,
6149 "no Tx descriptors available");
6150
6151 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6152 "rx_mbuf_alloc_errors", CTLFLAG_RD, &sc->rx_mbuf_alloc_errors, 0,
6153 "Rx mbuf allocation errors");
6154
6155 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6156 "rx_mbuf_dmamap_errors", CTLFLAG_RD, &sc->rx_mbuf_dmamap_errors, 0,
6157 "Rx mbuf DMA mapping errors");
6158
6159 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6160 "tx_queue_0_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[0], 0,
6161 "Tx queue 0 not empty");
6162
6163 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6164 "tx_queue_1_not_empty", CTLFLAG_RD, &sc->tx_queue_not_empty[1], 0,
6165 "Tx queue 1 not empty");
6166
6167 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6168 "tx_beacons", CTLFLAG_RD, &sc->tx_beacons, 0,
6169 "Tx beacons");
6170
6171 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6172 "tx_noretryok", CTLFLAG_RD, &sc->tx_noretryok, 0,
6173 "Tx successfull without retries");
6174
6175 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6176 "tx_retryok", CTLFLAG_RD, &sc->tx_retryok, 0,
6177 "Tx successfull with retries");
6178
6179 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6180 "tx_failed", CTLFLAG_RD, &sc->tx_failed, 0,
6181 "Tx failed");
6182
6183 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6184 "tx_underflows", CTLFLAG_RD, &sc->tx_underflows, 0,
6185 "Tx underflows");
6186
6187 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6188 "tx_zerolen", CTLFLAG_RD, &sc->tx_zerolen, 0,
6189 "Tx zero length");
6190
6191 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6192 "tx_nonagg", CTLFLAG_RD, &sc->tx_nonagg, 0,
6193 "Tx non-aggregated");
6194
6195 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6196 "tx_agg", CTLFLAG_RD, &sc->tx_agg, 0,
6197 "Tx aggregated");
6198
6199 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6200 "tx_ampdu", CTLFLAG_RD, &sc->tx_ampdu, 0,
6201 "Tx A-MPDU");
6202
6203 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6204 "tx_mpdu_zero_density", CTLFLAG_RD, &sc->tx_mpdu_zero_density, 0,
6205 "Tx MPDU with zero density");
6206
6207 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6208 "tx_ampdu_sessions", CTLFLAG_RD, &sc->tx_ampdu_sessions, 0,
6209 "Tx A-MPDU sessions");
6210
6211 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6212 "rx_packets", CTLFLAG_RD, &sc->rx_packets, 0,
6213 "Rx packets");
6214
6215 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6216 "rx_ampdu", CTLFLAG_RD, &sc->rx_ampdu, 0,
6217 "Rx A-MPDU");
6218
6219 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6220 "rx_mpdu_zero_density", CTLFLAG_RD, &sc->rx_mpdu_zero_density, 0,
6221 "Rx MPDU with zero density");
6222
6223 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6224 "rx_amsdu", CTLFLAG_RD, &sc->rx_amsdu, 0,
6225 "Rx A-MSDU");
6226
6227 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6228 "rx_crc_errors", CTLFLAG_RD, &sc->rx_crc_errors, 0,
6229 "Rx CRC errors");
6230
6231 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6232 "rx_phy_errors", CTLFLAG_RD, &sc->rx_phy_errors, 0,
6233 "Rx PHY errors");
6234
6235 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6236 "rx_false_ccas", CTLFLAG_RD, &sc->rx_false_ccas, 0,
6237 "Rx false CCAs");
6238
6239 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6240 "rx_plcp_errors", CTLFLAG_RD, &sc->rx_plcp_errors, 0,
6241 "Rx PLCP errors");
6242
6243 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6244 "rx_dup_packets", CTLFLAG_RD, &sc->rx_dup_packets, 0,
6245 "Rx duplicate packets");
6246
6247 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6248 "rx_fifo_overflows", CTLFLAG_RD, &sc->rx_fifo_overflows, 0,
6249 "Rx FIFO overflows");
6250
6251 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6252 "rx_cipher_no_errors", CTLFLAG_RD, &sc->rx_cipher_no_errors, 0,
6253 "Rx cipher no errors");
6254
6255 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6256 "rx_cipher_icv_errors", CTLFLAG_RD, &sc->rx_cipher_icv_errors, 0,
6257 "Rx cipher ICV errors");
6258
6259 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6260 "rx_cipher_mic_errors", CTLFLAG_RD, &sc->rx_cipher_mic_errors, 0,
6261 "Rx cipher MIC errors");
6262
6263 SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(stats), OID_AUTO,
6264 "rx_cipher_invalid_key_errors", CTLFLAG_RD, &sc->rx_cipher_invalid_key_errors, 0,
6265 "Rx cipher invalid key errors");
6266 }
6267
6268 static device_method_t rt2860_dev_methods[] =
6269 {
6270 DEVMETHOD(device_probe, rt2860_probe),
6271 DEVMETHOD(device_attach, rt2860_attach),
6272 DEVMETHOD(device_detach, rt2860_detach),
6273 DEVMETHOD(device_shutdown, rt2860_shutdown),
6274 DEVMETHOD(device_suspend, rt2860_suspend),
6275 DEVMETHOD(device_resume, rt2860_resume),
6276 { 0, 0 }
6277 };
6278
6279 static driver_t rt2860_driver =
6280 {
6281 "rt2860",
6282 rt2860_dev_methods,
6283 sizeof(struct rt2860_softc)
6284 };
6285
6286 static devclass_t rt2860_dev_class;
6287
6288 DRIVER_MODULE(rt2860, pci, rt2860_driver, rt2860_dev_class, 0, 0);
6289
6290 MODULE_DEPEND(rt2860, pci, 1, 1, 1);
6291 MODULE_DEPEND(rt2860, wlan, 1, 1, 1);
FreeBSD 7.2 device driver for Ralink rt2860