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