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