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