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