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