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