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