3 * Copyright (c) 2009-2010 Alexander Egorenkov <egorenar@gmail.com>
4 * Copyright (c) 2009 Damien Bergamini <damien.bergamini@free.fr>
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.
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.
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"
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
41 #define RT2860_MAX_AGG_SIZE 3840
43 #define RT2860_TX_DATA_SEG0_SIZE \
44 (sizeof(struct rt2860_txwi) + sizeof(struct ieee80211_qosframe_addr4))
46 #define RT2860_NOISE_FLOOR -95
48 #define RT2860_AID2WCID(aid) ((aid) & 0xff)
50 #define RT2860_ACK_SIZE 14
52 #define IEEE80211_HAS_ADDR4(wh) \
53 (((wh)->i_fc[1] & IEEE80211_FC1_DIR_MASK) == IEEE80211_FC1_DIR_DSTODS)
55 #define RT2860_MS(_v, _f) (((_v) & _f) >> _f##_S)
56 #define RT2860_SM(_v, _f) (((_v) << _f##_S) & _f)
58 #define RT2860_TX_WATCHDOG_TIMEOUT 5
61 * Data structures and types
64 struct rt2860_pci_ident
72 * Static function prototypes
75 static int rt2860_probe(device_t dev
);
77 static int rt2860_attach(device_t dev
);
79 static int rt2860_detach(device_t dev
);
81 static int rt2860_shutdown(device_t dev
);
83 static int rt2860_suspend(device_t dev
);
85 static int rt2860_resume(device_t dev
);
87 static void rt2860_init_channels(struct rt2860_softc
*sc
);
89 static void rt2860_init_channels_ht40(struct rt2860_softc
*sc
);
91 static void rt2860_init_locked(void *priv
);
93 static void rt2860_init(void *priv
);
95 static int rt2860_init_bbp(struct rt2860_softc
*sc
);
97 static void rt2860_stop_locked(void *priv
);
99 static void rt2860_stop(void *priv
);
101 static void rt2860_start(struct ifnet
*ifp
);
103 static int rt2860_ioctl(struct ifnet
*ifp
, u_long cmd
, caddr_t data
);
105 static struct ieee80211vap
*rt2860_vap_create(struct ieee80211com
*ic
,
106 const char name
[IFNAMSIZ
], int unit
, int opmode
, int flags
,
107 const uint8_t bssid
[IEEE80211_ADDR_LEN
],
108 const uint8_t mac
[IEEE80211_ADDR_LEN
]);
110 static void rt2860_vap_delete(struct ieee80211vap
*vap
);
112 static int rt2860_vap_reset(struct ieee80211vap
*vap
, u_long cmd
);
114 static int rt2860_vap_newstate(struct ieee80211vap
*vap
,
115 enum ieee80211_state nstate
, int arg
);
117 static void rt2860_vap_key_update_begin(struct ieee80211vap
*vap
);
119 static void rt2860_vap_key_update_end(struct ieee80211vap
*vap
);
121 static int rt2860_vap_key_set(struct ieee80211vap
*vap
,
122 const struct ieee80211_key
*k
, const uint8_t mac
[IEEE80211_ADDR_LEN
]);
124 static int rt2860_vap_key_delete(struct ieee80211vap
*vap
,
125 const struct ieee80211_key
*k
);
127 static void rt2860_vap_update_beacon(struct ieee80211vap
*vap
, int what
);
129 static int rt2860_media_change(struct ifnet
*ifp
);
131 static struct ieee80211_node
*rt2860_node_alloc(struct ieee80211vap
*vap
,
132 const uint8_t mac
[IEEE80211_ADDR_LEN
]);
134 static int rt2860_setregdomain(struct ieee80211com
*ic
,
135 struct ieee80211_regdomain
*reg
,
136 int nchans
, struct ieee80211_channel chans
[]);
138 static void rt2860_getradiocaps(struct ieee80211com
*ic
,
139 int maxchans
, int *nchans
, struct ieee80211_channel chans
[]);
141 static void rt2860_scan_start(struct ieee80211com
*ic
);
143 static void rt2860_scan_end(struct ieee80211com
*ic
);
145 static void rt2860_set_channel(struct ieee80211com
*ic
);
147 static void rt2860_newassoc(struct ieee80211_node
*ni
, int isnew
);
149 static void rt2860_updateslot(struct ifnet
*ifp
);
151 static void rt2860_update_promisc(struct ifnet
*ifp
);
153 static void rt2860_update_mcast(struct ifnet
*ifp
);
155 static int rt2860_wme_update(struct ieee80211com
*ic
);
157 static int rt2860_raw_xmit(struct ieee80211_node
*ni
, struct mbuf
*m
,
158 const struct ieee80211_bpf_params
*params
);
160 static int rt2860_recv_action(struct ieee80211_node
*ni
,
161 const struct ieee80211_frame
*wh
,
162 const uint8_t *frm
, const uint8_t *efrm
);
164 static int rt2860_send_action(struct ieee80211_node
*ni
,
165 int cat
, int act
, void *sa
);
167 static void rt2860_amrr_update_iter_func(void *arg
, struct ieee80211_node
*ni
);
169 static void rt2860_periodic(void *arg
);
171 static void rt2860_tx_watchdog(void *arg
);
173 static void rt2860_asic_set_bssid(struct rt2860_softc
*sc
,
174 const uint8_t *bssid
);
176 static void rt2860_asic_set_macaddr(struct rt2860_softc
*sc
,
177 const uint8_t *addr
);
179 static void rt2860_asic_enable_tsf_sync(struct rt2860_softc
*sc
);
181 static void rt2860_asic_disable_tsf_sync(struct rt2860_softc
*sc
);
183 static void rt2860_asic_enable_mrr(struct rt2860_softc
*sc
);
185 static void rt2860_asic_set_txpreamble(struct rt2860_softc
*sc
);
187 static void rt2860_asic_set_basicrates(struct rt2860_softc
*sc
);
189 static void rt2860_asic_update_rtsthreshold(struct rt2860_softc
*sc
);
191 static void rt2860_asic_update_txpower(struct rt2860_softc
*sc
);
193 static void rt2860_asic_update_promisc(struct rt2860_softc
*sc
);
195 static void rt2860_asic_updateprot(struct rt2860_softc
*sc
);
197 static void rt2860_asic_updateslot(struct rt2860_softc
*sc
);
199 static void rt2860_asic_wme_update(struct rt2860_softc
*sc
);
201 static int rt2860_asic_update_beacon(struct rt2860_softc
*sc
,
202 struct ieee80211vap
*vap
);
204 static void rt2860_asic_clear_keytables(struct rt2860_softc
*sc
);
206 static uint8_t rt2860_rxrate(struct rt2860_rxwi
*rxwi
);
208 static uint8_t rt2860_maxrssi_rxpath(struct rt2860_softc
*sc
,
209 const struct rt2860_rxwi
*rxwi
);
211 static int8_t rt2860_rssi2dbm(struct rt2860_softc
*sc
,
212 uint8_t rssi
, uint8_t rxpath
);
214 static uint8_t rt2860_rate2mcs(uint8_t rate
);
216 static int rt2860_tx_mgmt(struct rt2860_softc
*sc
,
217 struct mbuf
*m
, struct ieee80211_node
*ni
, int qid
);
219 static int rt2860_tx_data(struct rt2860_softc
*sc
,
220 struct mbuf
*m
, struct ieee80211_node
*ni
, int qid
);
222 static int rt2860_tx_raw(struct rt2860_softc
*sc
,
223 struct mbuf
*m
, struct ieee80211_node
*ni
,
224 const struct ieee80211_bpf_params
*params
);
226 static void rt2860_intr(void *arg
);
228 static void rt2860_tx_coherent_intr(struct rt2860_softc
*sc
);
230 static void rt2860_rx_coherent_intr(struct rt2860_softc
*sc
);
232 static void rt2860_txrx_coherent_intr(struct rt2860_softc
*sc
);
234 static void rt2860_fifo_sta_full_intr(struct rt2860_softc
*sc
);
236 static void rt2860_rx_intr(struct rt2860_softc
*sc
);
238 static void rt2860_rx_delay_intr(struct rt2860_softc
*sc
);
240 static void rt2860_tx_intr(struct rt2860_softc
*sc
, int qid
);
242 static void rt2860_tx_delay_intr(struct rt2860_softc
*sc
);
244 static void rt2860_pre_tbtt_intr(struct rt2860_softc
*sc
);
246 static void rt2860_tbtt_intr(struct rt2860_softc
*sc
);
248 static void rt2860_mcu_cmd_intr(struct rt2860_softc
*sc
);
250 static void rt2860_auto_wakeup_intr(struct rt2860_softc
*sc
);
252 static void rt2860_gp_timer_intr(struct rt2860_softc
*sc
);
254 static void rt2860_rx_done_task(void *context
, int pending
);
256 static void rt2860_tx_done_task(void *context
, int pending
);
258 static void rt2860_fifo_sta_full_task(void *context
, int pending
);
260 static void rt2860_periodic_task(void *context
, int pending
);
262 static int rt2860_rx_eof(struct rt2860_softc
*sc
, int limit
);
264 static void rt2860_tx_eof(struct rt2860_softc
*sc
,
265 struct rt2860_softc_tx_ring
*ring
);
267 static void rt2860_update_stats(struct rt2860_softc
*sc
);
269 static void rt2860_watchdog(struct rt2860_softc
*sc
);
271 static void rt2860_drain_fifo_stats(struct rt2860_softc
*sc
);
273 static void rt2860_update_raw_counters(struct rt2860_softc
*sc
);
275 static void rt2860_intr_enable(struct rt2860_softc
*sc
, uint32_t intr_mask
);
277 static void rt2860_intr_disable(struct rt2860_softc
*sc
, uint32_t intr_mask
);
279 static int rt2860_txrx_enable(struct rt2860_softc
*sc
);
281 static int rt2860_alloc_rx_ring(struct rt2860_softc
*sc
,
282 struct rt2860_softc_rx_ring
*ring
);
284 static void rt2860_reset_rx_ring(struct rt2860_softc
*sc
,
285 struct rt2860_softc_rx_ring
*ring
);
287 static void rt2860_free_rx_ring(struct rt2860_softc
*sc
,
288 struct rt2860_softc_rx_ring
*ring
);
290 static int rt2860_alloc_tx_ring(struct rt2860_softc
*sc
,
291 struct rt2860_softc_tx_ring
*ring
, int qid
);
293 static void rt2860_reset_tx_ring(struct rt2860_softc
*sc
,
294 struct rt2860_softc_tx_ring
*ring
);
296 static void rt2860_free_tx_ring(struct rt2860_softc
*sc
,
297 struct rt2860_softc_tx_ring
*ring
);
299 static void rt2860_dma_map_addr(void *arg
, bus_dma_segment_t
*segs
,
300 int nseg
, int error
);
302 static void rt2860_sysctl_attach(struct rt2860_softc
*sc
);
308 static const struct rt2860_pci_ident rt2860_pci_ids
[] =
310 { PCI_VENDOR_RALINK
, PCI_PRODUCT_RALINK_RT2860_PCI
, "Ralink RT2860 PCI" },
311 { PCI_VENDOR_RALINK
, PCI_PRODUCT_RALINK_RT2860_PCIe
, "Ralink RT2860 PCIe" },
312 { PCI_VENDOR_RALINK
, PCI_PRODUCT_RALINK_RT2760_PCI
, "Ralink RT2760 PCI" },
313 { PCI_VENDOR_RALINK
, PCI_PRODUCT_RALINK_RT2790_PCIe
, "Ralink RT2790 PCIe" },
323 { RT2860_REG_PBF_BCN_OFFSET0
, 0xf8f0e8e0 },
324 { RT2860_REG_PBF_BCN_OFFSET1
, 0x6f77d0c8 },
325 { RT2860_REG_LEGACY_BASIC_RATE
, 0x0000013f },
326 { RT2860_REG_HT_BASIC_RATE
, 0x00008003 },
327 { RT2860_REG_SYS_CTRL
, 0x00000000 },
328 { RT2860_REG_RX_FILTER_CFG
, 0x00017f97 },
329 { RT2860_REG_BKOFF_SLOT_CFG
, 0x00000209 },
330 { RT2860_REG_TX_SW_CFG0
, 0x00000000 },
331 { RT2860_REG_TX_SW_CFG1
, 0x00080606 },
332 { RT2860_REG_TX_LINK_CFG
, 0x00001020 },
333 { RT2860_REG_TX_TIMEOUT_CFG
, 0x000a2090 },
334 { RT2860_REG_MAX_LEN_CFG
, (1 << 12) | RT2860_MAX_AGG_SIZE
},
335 { RT2860_REG_LED_CFG
, 0x7f031e46 },
336 { RT2860_REG_PBF_MAX_PCNT
, 0x1f3fbf9f },
337 { RT2860_REG_TX_RTY_CFG
, 0x47d01f0f },
338 { RT2860_REG_AUTO_RSP_CFG
, 0x00000013 },
339 { RT2860_REG_TX_CCK_PROT_CFG
, 0x05740003 },
340 { RT2860_REG_TX_OFDM_PROT_CFG
, 0x05740003 },
341 { RT2860_REG_TX_MM40_PROT_CFG
, 0x03f44084 },
342 { RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, 0x00000030 },
343 { RT2860_REG_TX_GF20_PROT_CFG
, 0x01744004 },
344 { RT2860_REG_TX_GF40_PROT_CFG
, 0x03f44084 },
345 { RT2860_REG_TX_MM20_PROT_CFG
, 0x01744004 },
346 { RT2860_REG_TX_MM40_PROT_CFG
, 0x03f54084 },
347 { RT2860_REG_TX_TXOP_CTRL_CFG
, 0x0000583f },
348 { RT2860_REG_TX_RTS_CFG
, 0x00092b20 },
349 { RT2860_REG_TX_EXP_ACK_TIME
, 0x002400ca },
350 { RT2860_REG_HCCAPSMP_TXOP_HLDR_ET
, 0x00000002 },
351 { RT2860_REG_XIFS_TIME_CFG
, 0x33a41010 },
352 { RT2860_REG_PWR_PIN_CFG
, 0x00000003 },
353 { RT2860_REG_SCHDMA_WMM_AIFSN_CFG
, 0x00002273 },
354 { RT2860_REG_SCHDMA_WMM_CWMIN_CFG
, 0x00002344 },
355 { RT2860_REG_SCHDMA_WMM_CWMAX_CFG
, 0x000034aa },
358 #define RT2860_DEF_MAC_SIZE (sizeof(rt2860_def_mac) / sizeof(rt2860_def_mac[0]))
383 #define RT2860_DEF_BBP_SIZE (sizeof(rt2860_def_bbp) / sizeof(rt2860_def_bbp[0]))
388 static int rt2860_probe(device_t dev
)
390 const struct rt2860_pci_ident
*ident
;
392 for (ident
= rt2860_pci_ids
; ident
->name
!= NULL
; ident
++)
394 if (pci_get_vendor(dev
) == ident
->vendor
&&
395 pci_get_device(dev
) == ident
->device
)
397 device_set_desc(dev
, ident
->name
);
408 static int rt2860_attach(device_t dev
)
410 struct rt2860_softc
*sc
;
412 struct ieee80211com
*ic
;
413 int error
, ntries
, i
;
415 sc
= device_get_softc(dev
);
417 if (pci_get_powerstate(dev
) != PCI_POWERSTATE_D0
)
419 printf("%s: chip is in D%d power mode, setting to D0\n",
420 device_get_nameunit(dev
), pci_get_powerstate(dev
));
421 pci_set_powerstate(dev
, PCI_POWERSTATE_D0
);
424 /* enable bus-mastering */
426 pci_enable_busmaster(dev
);
430 mtx_init(&sc
->lock
, device_get_nameunit(dev
),
431 MTX_NETWORK_LOCK
, MTX_DEF
| MTX_RECURSE
);
433 sc
->mem_rid
= PCIR_BAR(0);
434 sc
->mem
= bus_alloc_resource_any(dev
, SYS_RES_MEMORY
,
435 &sc
->mem_rid
, RF_ACTIVE
);
438 printf("%s: could not allocate memory resource\n",
439 device_get_nameunit(dev
));
444 sc
->bst
= rman_get_bustag(sc
->mem
);
445 sc
->bsh
= rman_get_bushandle(sc
->mem
);
448 sc
->irq
= bus_alloc_resource_any(dev
, SYS_RES_IRQ
,
449 &sc
->irq_rid
, RF_ACTIVE
| RF_SHAREABLE
);
452 printf("%s: could not allocate interrupt resource\n",
453 device_get_nameunit(dev
));
461 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev
),
462 SYSCTL_CHILDREN(device_get_sysctl_tree(dev
)), OID_AUTO
,
463 "debug", CTLFLAG_RW
, &sc
->debug
, 0, "rt2860 debug level");
466 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
468 device_get_nameunit(sc
->dev
));
470 /* wait for NIC to initialize */
472 for (ntries
= 0; ntries
< 100; ntries
++)
474 sc
->mac_rev
= rt2860_io_mac_read(sc
, RT2860_REG_MAC_CSR0
);
475 if (sc
->mac_rev
!= 0x00000000 && sc
->mac_rev
!= 0xffffffff)
483 printf("%s: timeout waiting for NIC to initialize\n",
484 device_get_nameunit(dev
));
489 rt2860_read_eeprom(sc
);
491 printf("%s: MAC/BBP RT2860 (rev 0x%08x), RF %s\n",
492 device_get_nameunit(sc
->dev
), sc
->mac_rev
,
493 rt2860_rf_name(sc
->rf_rev
));
495 /* allocate Tx and Rx rings */
497 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
499 error
= rt2860_alloc_tx_ring(sc
, &sc
->tx_ring
[i
], i
);
502 printf("%s: could not allocate Tx ring #%d\n",
503 device_get_nameunit(sc
->dev
), i
);
508 sc
->tx_ring_mgtqid
= 5;
510 error
= rt2860_alloc_rx_ring(sc
, &sc
->rx_ring
);
513 printf("%s: could not allocate Rx ring\n",
514 device_get_nameunit(sc
->dev
));
518 callout_init(&sc
->periodic_ch
, 0);
519 callout_init_mtx(&sc
->tx_watchdog_ch
, &sc
->lock
, 0);
521 ifp
= sc
->ifp
= if_alloc(IFT_IEEE80211
);
524 printf("%s: could not if_alloc()\n",
525 device_get_nameunit(sc
->dev
));
532 if_initname(ifp
, "rt2860", device_get_unit(sc
->dev
));
534 ifp
->if_flags
= IFF_BROADCAST
| IFF_SIMPLEX
| IFF_MULTICAST
;
536 ifp
->if_init
= rt2860_init
;
537 ifp
->if_ioctl
= rt2860_ioctl
;
538 ifp
->if_start
= rt2860_start
;
540 IFQ_SET_MAXLEN(&ifp
->if_snd
, IFQ_MAXLEN
);
541 ifp
->if_snd
.ifq_drv_maxlen
= IFQ_MAXLEN
;
542 IFQ_SET_READY(&ifp
->if_snd
);
548 ic
->ic_phytype
= IEEE80211_T_HT
;
549 ic
->ic_opmode
= IEEE80211_M_STA
;
551 ic
->ic_caps
= IEEE80211_C_MONITOR
|
558 /* IEEE80211_C_BGSCAN | */
560 IEEE80211_C_SHPREAMBLE
|
567 ic
->ic_cryptocaps
|= IEEE80211_CRYPTO_WEP
|
568 IEEE80211_CRYPTO_TKIP
|
569 IEEE80211_CRYPTO_TKIPMIC
|
570 IEEE80211_CRYPTO_AES_CCM
;
572 ic
->ic_htcaps
= IEEE80211_HTC_HT
|
573 IEEE80211_HTC_AMSDU
| /* A-MSDU Tx */
574 IEEE80211_HTCAP_MAXAMSDU_3839
| /* max. A-MSDU Rx length */
575 IEEE80211_HTCAP_CHWIDTH40
| /* HT 40MHz channel width */
576 IEEE80211_HTCAP_GREENFIELD
| /* HT greenfield */
577 IEEE80211_HTCAP_SHORTGI20
| /* HT 20MHz short GI */
578 IEEE80211_HTCAP_SHORTGI40
| /* HT 40MHz short GI */
579 IEEE80211_HTCAP_DSSSCCK40
; /* HT 40MHz DSSS/CCK modulation */
581 /* spatial streams */
583 if (sc
->nrxpath
== 2)
584 ic
->ic_htcaps
|= IEEE80211_HTCAP_RXSTBC_2STREAM
;
585 else if (sc
->nrxpath
== 3)
586 ic
->ic_htcaps
|= IEEE80211_HTCAP_RXSTBC_3STREAM
;
588 ic
->ic_htcaps
|= IEEE80211_HTCAP_RXSTBC_1STREAM
;
591 ic
->ic_htcaps
|= IEEE80211_HTCAP_TXSTBC
;
595 if (sc
->mac_rev
!= 0x28600100)
596 ic
->ic_htcaps
|= IEEE80211_HTCAP_DELBA
;
602 rt2860_init_channels(sc
);
604 rt2860_init_channels_ht40(sc
);
606 ieee80211_ifattach(ic
, sc
->mac_addr
);
608 ic
->ic_vap_create
= rt2860_vap_create
;
609 ic
->ic_vap_delete
= rt2860_vap_delete
;
611 ic
->ic_node_alloc
= rt2860_node_alloc
;
612 ic
->ic_setregdomain
= rt2860_setregdomain
;
613 ic
->ic_getradiocaps
= rt2860_getradiocaps
;
614 ic
->ic_scan_start
= rt2860_scan_start
;
615 ic
->ic_scan_end
= rt2860_scan_end
;
616 ic
->ic_set_channel
= rt2860_set_channel
;
617 ic
->ic_newassoc
= rt2860_newassoc
;
618 ic
->ic_updateslot
= rt2860_updateslot
;
619 ic
->ic_update_promisc
= rt2860_update_promisc
;
620 ic
->ic_update_mcast
= rt2860_update_mcast
;
621 ic
->ic_wme
.wme_update
= rt2860_wme_update
;
622 ic
->ic_raw_xmit
= rt2860_raw_xmit
;
624 sc
->recv_action
= ic
->ic_recv_action
;
625 ic
->ic_recv_action
= rt2860_recv_action
;
627 sc
->send_action
= ic
->ic_send_action
;
628 ic
->ic_send_action
= rt2860_send_action
;
630 /* hardware requires padding between 802.11 frame header and body */
632 ic
->ic_flags
|= IEEE80211_F_DATAPAD
| IEEE80211_F_DOTH
;
634 ic
->ic_flags_ext
|= IEEE80211_FEXT_SWBMISS
;
636 ieee80211_radiotap_attach(ic
,
637 &sc
->txtap
.ihdr
, sizeof(sc
->txtap
),
638 RT2860_SOFTC_TX_RADIOTAP_PRESENT
,
639 &sc
->rxtap
.ihdr
, sizeof(sc
->rxtap
),
640 RT2860_SOFTC_RX_RADIOTAP_PRESENT
);
642 /* init task queue */
644 TASK_INIT(&sc
->rx_done_task
, 0, rt2860_rx_done_task
, sc
);
645 TASK_INIT(&sc
->tx_done_task
, 0, rt2860_tx_done_task
, sc
);
646 TASK_INIT(&sc
->fifo_sta_full_task
, 0, rt2860_fifo_sta_full_task
, sc
);
647 TASK_INIT(&sc
->periodic_task
, 0, rt2860_periodic_task
, sc
);
649 sc
->rx_process_limit
= 100;
651 sc
->taskqueue
= taskqueue_create("rt2860_taskq", M_NOWAIT
,
652 taskqueue_thread_enqueue
, &sc
->taskqueue
);
654 taskqueue_start_threads(&sc
->taskqueue
, 1, PI_NET
, "%s taskq",
655 device_get_nameunit(sc
->dev
));
657 rt2860_sysctl_attach(sc
);
660 ieee80211_announce(ic
);
662 /* set up interrupt */
664 error
= bus_setup_intr(dev
, sc
->irq
, INTR_TYPE_NET
| INTR_MPSAFE
,
665 NULL
, rt2860_intr
, sc
, &sc
->irqh
);
668 printf("%s: could not set up interrupt\n",
669 device_get_nameunit(dev
));
677 /* free Tx and Rx rings */
679 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
680 rt2860_free_tx_ring(sc
, &sc
->tx_ring
[i
]);
682 rt2860_free_rx_ring(sc
, &sc
->rx_ring
);
684 mtx_destroy(&sc
->lock
);
687 bus_release_resource(dev
, SYS_RES_MEMORY
, sc
->mem_rid
, sc
->mem
);
690 bus_release_resource(dev
, SYS_RES_IRQ
, sc
->irq_rid
, sc
->irq
);
698 static int rt2860_detach(device_t dev
)
700 struct rt2860_softc
*sc
;
702 struct ieee80211com
*ic
;
705 sc
= device_get_softc(dev
);
709 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
711 device_get_nameunit(sc
->dev
));
713 RT2860_SOFTC_LOCK(sc
);
715 ifp
->if_drv_flags
&= ~(IFF_DRV_RUNNING
| IFF_DRV_OACTIVE
);
717 callout_stop(&sc
->periodic_ch
);
718 callout_stop(&sc
->tx_watchdog_ch
);
720 taskqueue_drain(sc
->taskqueue
, &sc
->rx_done_task
);
721 taskqueue_drain(sc
->taskqueue
, &sc
->tx_done_task
);
722 taskqueue_drain(sc
->taskqueue
, &sc
->fifo_sta_full_task
);
723 taskqueue_drain(sc
->taskqueue
, &sc
->periodic_task
);
725 /* free Tx and Rx rings */
727 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
728 rt2860_free_tx_ring(sc
, &sc
->tx_ring
[i
]);
730 rt2860_free_rx_ring(sc
, &sc
->rx_ring
);
732 RT2860_SOFTC_UNLOCK(sc
);
734 ieee80211_ifdetach(ic
);
738 taskqueue_free(sc
->taskqueue
);
740 mtx_destroy(&sc
->lock
);
742 bus_generic_detach(dev
);
744 bus_teardown_intr(dev
, sc
->irq
, sc
->irqh
);
746 bus_release_resource(dev
, SYS_RES_IRQ
, sc
->irq_rid
, sc
->irq
);
748 bus_release_resource(dev
, SYS_RES_MEMORY
, sc
->mem_rid
, sc
->mem
);
756 static int rt2860_shutdown(device_t dev
)
758 struct rt2860_softc
*sc
;
760 sc
= device_get_softc(dev
);
762 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
763 "%s: shutting down\n",
764 device_get_nameunit(sc
->dev
));
768 sc
->flags
&= ~RT2860_SOFTC_FLAGS_UCODE_LOADED
;
776 static int rt2860_suspend(device_t dev
)
778 struct rt2860_softc
*sc
;
780 sc
= device_get_softc(dev
);
782 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
784 device_get_nameunit(sc
->dev
));
788 sc
->flags
&= ~RT2860_SOFTC_FLAGS_UCODE_LOADED
;
796 static int rt2860_resume(device_t dev
)
798 struct rt2860_softc
*sc
;
801 sc
= device_get_softc(dev
);
804 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
806 device_get_nameunit(sc
->dev
));
808 if (ifp
->if_flags
& IFF_UP
)
815 * rt2860_init_channels
817 static void rt2860_init_channels(struct rt2860_softc
*sc
)
820 struct ieee80211com
*ic
;
821 struct ieee80211_channel
*c
;
827 /* set supported channels for 2GHz band */
829 for (i
= 1; i
<= 14; i
++)
831 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
832 flags
= IEEE80211_CHAN_B
;
834 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
838 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
839 flags
= IEEE80211_CHAN_B
| IEEE80211_CHAN_HT20
;
841 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
845 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
846 flags
= IEEE80211_CHAN_G
;
848 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
852 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
853 flags
= IEEE80211_CHAN_G
| IEEE80211_CHAN_HT20
;
855 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
860 /* set supported channels for 5GHz band */
862 if (sc
->rf_rev
== RT2860_EEPROM_RF_2850
||
863 sc
->rf_rev
== RT2860_EEPROM_RF_2750
)
865 for (i
= 36; i
<= 64; i
+= 4)
867 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
868 flags
= IEEE80211_CHAN_A
;
870 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
874 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
875 flags
= IEEE80211_CHAN_A
| IEEE80211_CHAN_HT20
;
877 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
882 for (i
= 100; i
<= 140; i
+= 4)
884 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
885 flags
= IEEE80211_CHAN_A
;
887 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
891 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
892 flags
= IEEE80211_CHAN_A
| IEEE80211_CHAN_HT20
;
894 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
899 for (i
= 149; i
<= 165; i
+= 4)
901 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
902 flags
= IEEE80211_CHAN_A
;
904 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
908 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
909 flags
= IEEE80211_CHAN_A
| IEEE80211_CHAN_HT20
;
911 c
->ic_freq
= ieee80211_ieee2mhz(i
, flags
);
919 * rt2860_init_channels_ht40
921 static void rt2860_init_channels_ht40(struct rt2860_softc
*sc
)
924 struct ieee80211com
*ic
;
925 struct ieee80211_channel
*c
, *cent
, *ext
;
931 /* set supported channels for 2GHz band */
933 for (i
= 1; i
<= 14; i
++)
935 flags
= IEEE80211_CHAN_G
| IEEE80211_CHAN_HT40
;
937 /* find the center channel */
939 cent
= ieee80211_find_channel_byieee(ic
, i
,
940 flags
& ~IEEE80211_CHAN_HT
);
943 printf("%s: skip channel %d, could not find center channel\n",
944 device_get_nameunit(sc
->dev
), i
);
948 /* find the extension channel */
950 ext
= ieee80211_find_channel(ic
, cent
->ic_freq
+ 20,
951 flags
& ~IEEE80211_CHAN_HT
);
954 printf("%s: skip channel %d, could not find extension channel\n",
955 device_get_nameunit(sc
->dev
), i
);
959 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
962 c
->ic_extieee
= ext
->ic_ieee
;
963 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
964 c
->ic_flags
|= IEEE80211_CHAN_HT40U
;
966 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
969 c
->ic_extieee
= cent
->ic_ieee
;
970 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
971 c
->ic_flags
|= IEEE80211_CHAN_HT40D
;
974 /* set supported channels for 5GHz band */
976 if (sc
->rf_rev
== RT2860_EEPROM_RF_2850
||
977 sc
->rf_rev
== RT2860_EEPROM_RF_2750
)
979 for (i
= 36; i
<= 64; i
+= 4)
981 flags
= IEEE80211_CHAN_A
| IEEE80211_CHAN_HT40
;
983 /* find the center channel */
985 cent
= ieee80211_find_channel_byieee(ic
, i
,
986 flags
& ~IEEE80211_CHAN_HT
);
989 printf("%s: skip channel %d, could not find center channel\n",
990 device_get_nameunit(sc
->dev
), i
);
994 /* find the extension channel */
996 ext
= ieee80211_find_channel(ic
, cent
->ic_freq
+ 20,
997 flags
& ~IEEE80211_CHAN_HT
);
1000 printf("%s: skip channel %d, could not find extension channel\n",
1001 device_get_nameunit(sc
->dev
), i
);
1005 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
1008 c
->ic_extieee
= ext
->ic_ieee
;
1009 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
1010 c
->ic_flags
|= IEEE80211_CHAN_HT40U
;
1012 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
1015 c
->ic_extieee
= cent
->ic_ieee
;
1016 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
1017 c
->ic_flags
|= IEEE80211_CHAN_HT40D
;
1020 for (i
= 100; i
<= 140; i
+= 4)
1022 flags
= IEEE80211_CHAN_A
| IEEE80211_CHAN_HT40
;
1024 /* find the center channel */
1026 cent
= ieee80211_find_channel_byieee(ic
, i
,
1027 flags
& ~IEEE80211_CHAN_HT
);
1030 printf("%s: skip channel %d, could not find center channel\n",
1031 device_get_nameunit(sc
->dev
), i
);
1035 /* find the extension channel */
1037 ext
= ieee80211_find_channel(ic
, cent
->ic_freq
+ 20,
1038 flags
& ~IEEE80211_CHAN_HT
);
1041 printf("%s: skip channel %d, could not find extension channel\n",
1042 device_get_nameunit(sc
->dev
), i
);
1046 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
1049 c
->ic_extieee
= ext
->ic_ieee
;
1050 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
1051 c
->ic_flags
|= IEEE80211_CHAN_HT40U
;
1053 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
1056 c
->ic_extieee
= cent
->ic_ieee
;
1057 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
1058 c
->ic_flags
|= IEEE80211_CHAN_HT40D
;
1061 for (i
= 149; i
<= 165; i
+= 4)
1063 flags
= IEEE80211_CHAN_A
| IEEE80211_CHAN_HT40
;
1065 /* find the center channel */
1067 cent
= ieee80211_find_channel_byieee(ic
, i
,
1068 flags
& ~IEEE80211_CHAN_HT
);
1071 printf("%s: skip channel %d, could not find center channel\n",
1072 device_get_nameunit(sc
->dev
), i
);
1076 /* find the extension channel */
1078 ext
= ieee80211_find_channel(ic
, cent
->ic_freq
+ 20,
1079 flags
& ~IEEE80211_CHAN_HT
);
1082 printf("%s: skip channel %d, could not find extension channel\n",
1083 device_get_nameunit(sc
->dev
), i
);
1087 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
1090 c
->ic_extieee
= ext
->ic_ieee
;
1091 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
1092 c
->ic_flags
|= IEEE80211_CHAN_HT40U
;
1094 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
1097 c
->ic_extieee
= cent
->ic_ieee
;
1098 c
->ic_flags
&= ~IEEE80211_CHAN_HT
;
1099 c
->ic_flags
|= IEEE80211_CHAN_HT40D
;
1105 * rt2860_init_locked
1107 static void rt2860_init_locked(void *priv
)
1109 struct rt2860_softc
*sc
;
1111 struct ieee80211com
*ic
;
1112 int error
, i
, ntries
;
1113 uint32_t tmp
, stacnt
[6];
1119 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
1120 "%s: initializing\n",
1121 device_get_nameunit(sc
->dev
));
1123 RT2860_SOFTC_ASSERT_LOCKED(sc
);
1125 if (!(sc
->flags
& RT2860_SOFTC_FLAGS_UCODE_LOADED
))
1127 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
1128 "%s: loading 8051 microcode\n",
1129 device_get_nameunit(sc
->dev
));
1131 error
= rt2860_io_mcu_load_ucode(sc
, rt2860_ucode
, sizeof(rt2860_ucode
));
1134 printf("%s: could not load 8051 microcode\n",
1135 device_get_nameunit(sc
->dev
));
1139 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
1140 "%s: 8051 microcode was successfully loaded\n",
1141 device_get_nameunit(sc
->dev
));
1143 sc
->flags
|= RT2860_SOFTC_FLAGS_UCODE_LOADED
;
1146 rt2860_io_mac_write(sc
, RT2860_REG_PWR_PIN_CFG
, 0x2);
1148 /* disable DMA engine */
1150 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
1153 tmp
|= RT2860_REG_TX_WB_DDONE
;
1155 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
1157 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_RST_IDX
, 0xffffffff);
1159 /* PBF hardware reset */
1161 rt2860_io_mac_write(sc
, RT2860_REG_PBF_SYS_CTRL
, 0xe1f);
1162 rt2860_io_mac_write(sc
, RT2860_REG_PBF_SYS_CTRL
, 0xe00);
1164 /* wait while DMA engine is busy */
1166 for (ntries
= 0; ntries
< 100; ntries
++)
1168 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
1169 if (!(tmp
& (RT2860_REG_TX_DMA_BUSY
| RT2860_REG_RX_DMA_BUSY
)))
1177 printf("%s: timeout waiting for DMA engine\n",
1178 device_get_nameunit(sc
->dev
));
1183 tmp
|= RT2860_REG_TX_WB_DDONE
;
1185 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
1187 /* reset Rx and Tx rings */
1189 tmp
= RT2860_REG_RST_IDX_RX
|
1190 RT2860_REG_RST_IDX_TX_MGMT
|
1191 RT2860_REG_RST_IDX_TX_HCCA
|
1192 RT2860_REG_RST_IDX_TX_AC3
|
1193 RT2860_REG_RST_IDX_TX_AC2
|
1194 RT2860_REG_RST_IDX_TX_AC1
|
1195 RT2860_REG_RST_IDX_TX_AC0
;
1197 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_RST_IDX
, tmp
);
1199 /* PBF hardware reset */
1201 rt2860_io_mac_write(sc
, RT2860_REG_PBF_SYS_CTRL
, 0xe1f);
1202 rt2860_io_mac_write(sc
, RT2860_REG_PBF_SYS_CTRL
, 0xe00);
1204 rt2860_io_mac_write(sc
, RT2860_REG_PWR_PIN_CFG
, 0x3);
1206 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
,
1207 RT2860_REG_MAC_SRST
| RT2860_REG_BBP_HRST
);
1208 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
, 0);
1210 /* init Tx power per rate */
1212 for (i
= 0; i
< RT2860_SOFTC_TXPOW_RATE_COUNT
; i
++)
1214 if (sc
->txpow_rate_20mhz
[i
] == 0xffffffff)
1217 rt2860_io_mac_write(sc
, RT2860_REG_TX_PWR_CFG(i
),
1218 sc
->txpow_rate_20mhz
[i
]);
1221 for (i
= 0; i
< RT2860_DEF_MAC_SIZE
; i
++)
1222 rt2860_io_mac_write(sc
, rt2860_def_mac
[i
].reg
,
1223 rt2860_def_mac
[i
].val
);
1225 /* wait while MAC is busy */
1227 for (ntries
= 0; ntries
< 100; ntries
++)
1229 if (!(rt2860_io_mac_read(sc
, RT2860_REG_STATUS_CFG
) &
1230 (RT2860_REG_STATUS_TX_BUSY
| RT2860_REG_STATUS_RX_BUSY
)))
1238 printf("%s: timeout waiting for MAC\n",
1239 device_get_nameunit(sc
->dev
));
1243 /* clear Host to MCU mailbox */
1245 rt2860_io_mac_write(sc
, RT2860_REG_H2M_MAILBOX_BBP_AGENT
, 0);
1246 rt2860_io_mac_write(sc
, RT2860_REG_H2M_MAILBOX
, 0);
1248 rt2860_io_mcu_cmd(sc
, RT2860_IO_MCU_CMD_BOOT
,
1249 RT2860_REG_H2M_TOKEN_NO_INTR
, 0);
1253 error
= rt2860_init_bbp(sc
);
1257 /* set up maximum buffer sizes */
1259 tmp
= (1 << 12) | RT2860_MAX_AGG_SIZE
;
1261 rt2860_io_mac_write(sc
, RT2860_REG_MAX_LEN_CFG
, tmp
);
1263 if (sc
->mac_rev
== 0x28720200)
1265 /* set max. PSDU length from 16K to 32K bytes */
1267 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_MAX_LEN_CFG
);
1272 rt2860_io_mac_write(sc
, RT2860_REG_MAX_LEN_CFG
, tmp
);
1275 if (sc
->mac_rev
>= 0x28720200 && sc
->mac_rev
< 0x30700200)
1277 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_MAX_LEN_CFG
);
1282 rt2860_io_mac_write(sc
, RT2860_REG_MAX_LEN_CFG
, tmp
);
1285 /* set mac address */
1287 rt2860_asic_set_macaddr(sc
, IF_LLADDR(ifp
));
1289 /* clear statistic registers */
1291 rt2860_io_mac_read_multi(sc
, RT2860_REG_RX_STA_CNT0
,
1292 stacnt
, sizeof(stacnt
));
1294 /* set RTS threshold */
1296 rt2860_asic_update_rtsthreshold(sc
);
1300 rt2860_asic_update_txpower(sc
);
1302 /* set up protection mode */
1304 rt2860_asic_updateprot(sc
);
1306 /* clear key tables */
1308 rt2860_asic_clear_keytables(sc
);
1310 taskqueue_unblock(sc
->taskqueue
);
1312 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
1314 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
1315 rt2860_reset_tx_ring(sc
, &sc
->tx_ring
[i
]);
1317 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
1319 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_BASE_PTR(i
),
1320 sc
->tx_ring
[i
].desc_phys_addr
);
1321 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_MAX_CNT(i
),
1322 RT2860_SOFTC_TX_RING_DESC_COUNT
);
1323 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_CTX_IDX(i
), 0);
1328 rt2860_reset_rx_ring(sc
, &sc
->rx_ring
);
1330 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_BASE_PTR
,
1331 sc
->rx_ring
.desc_phys_addr
);
1332 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_MAX_CNT
,
1333 RT2860_SOFTC_RX_RING_DATA_COUNT
);
1334 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_CALC_IDX
,
1335 RT2860_SOFTC_RX_RING_DATA_COUNT
- 1);
1337 /* wait while DMA engine is busy */
1339 for (ntries
= 0; ntries
< 100; ntries
++)
1341 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
1342 if (!(tmp
& (RT2860_REG_TX_DMA_BUSY
| RT2860_REG_RX_DMA_BUSY
)))
1350 printf("%s: timeout waiting for DMA engine\n",
1351 device_get_nameunit(sc
->dev
));
1356 tmp
|= RT2860_REG_TX_WB_DDONE
;
1358 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
1360 /* disable interrupts mitigation */
1362 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_DELAY_INT_CFG
, 0);
1364 /* send LEDs operating mode to microcontroller */
1366 rt2860_io_mcu_cmd(sc
, RT2860_IO_MCU_CMD_LED1
,
1367 RT2860_REG_H2M_TOKEN_NO_INTR
, sc
->led_off
[0]);
1368 rt2860_io_mcu_cmd(sc
, RT2860_IO_MCU_CMD_LED2
,
1369 RT2860_REG_H2M_TOKEN_NO_INTR
, sc
->led_off
[1]);
1370 rt2860_io_mcu_cmd(sc
, RT2860_IO_MCU_CMD_LED3
,
1371 RT2860_REG_H2M_TOKEN_NO_INTR
, sc
->led_off
[2]);
1373 /* turn radio LED on */
1375 rt2860_led_cmd(sc
, RT2860_LED_CMD_RADIO_ON
);
1377 /* write vendor-specific BBP values (from EEPROM) */
1379 for (i
= 0; i
< RT2860_SOFTC_BBP_EEPROM_COUNT
; i
++)
1381 if (sc
->bbp_eeprom
[i
].reg
== 0x00 ||
1382 sc
->bbp_eeprom
[i
].reg
== 0xff)
1385 rt2860_io_bbp_write(sc
, sc
->bbp_eeprom
[i
].reg
,
1386 sc
->bbp_eeprom
[i
].val
);
1390 tmp = rt2860_io_mac_read(sc, RT2860_REG_SCHDMA_GPIO_CTRL_CFG);
1393 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_SLEEP,
1394 RT2860_REG_H2M_TOKEN_RADIOOFF, 0x02ff);
1395 rt2860_io_mcu_cmd_check(sc, RT2860_REG_H2M_TOKEN_RADIOOFF);
1397 rt2860_io_mcu_cmd(sc, RT2860_IO_MCU_CMD_WAKEUP,
1398 RT2860_REG_H2M_TOKEN_WAKEUP, 0);
1399 rt2860_io_mcu_cmd_check(sc, RT2860_REG_H2M_TOKEN_WAKEUP);
1403 /* disable non-existing Rx chains */
1405 tmp
= rt2860_io_bbp_read(sc
, 3);
1407 tmp
&= ~((1 << 4) | (1 << 3));
1409 if (sc
->nrxpath
== 3)
1411 else if (sc
->nrxpath
== 2)
1414 rt2860_io_bbp_write(sc
, 3, tmp
);
1416 /* disable non-existing Tx chains */
1418 tmp
= rt2860_io_bbp_read(sc
, 1);
1420 if (sc
->ntxpath
== 1)
1421 tmp
&= ~((1 << 4) | (1 << 3));
1423 rt2860_io_bbp_write(sc
, 1, tmp
);
1425 /* set current channel */
1427 rt2860_rf_set_chan(sc
, ic
->ic_curchan
);
1429 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_TXOP0_CFG
, 0);
1430 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_TXOP1_CFG
,
1433 if ((sc
->mac_rev
& 0xffff) != 0x0101)
1434 rt2860_io_mac_write(sc
, RT2860_REG_TX_TXOP_CTRL_CFG
, 0x583f);
1436 /* clear pending interrupts */
1438 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_INT_STATUS
, 0xffffffff);
1440 /* enable interrupts */
1442 tmp
= RT2860_REG_INT_TX_COHERENT
|
1443 RT2860_REG_INT_RX_COHERENT
|
1444 RT2860_REG_INT_GP_TIMER
|
1445 RT2860_REG_INT_AUTO_WAKEUP
|
1446 RT2860_REG_INT_FIFO_STA_FULL
|
1448 RT2860_REG_INT_PRE_TBTT |
1449 RT2860_REG_INT_TBTT |
1451 RT2860_REG_INT_TXRX_COHERENT
|
1452 RT2860_REG_INT_MCU_CMD
|
1453 RT2860_REG_INT_TX_MGMT_DONE
|
1454 RT2860_REG_INT_TX_HCCA_DONE
|
1455 RT2860_REG_INT_TX_AC3_DONE
|
1456 RT2860_REG_INT_TX_AC2_DONE
|
1457 RT2860_REG_INT_TX_AC1_DONE
|
1458 RT2860_REG_INT_TX_AC0_DONE
|
1459 RT2860_REG_INT_RX_DONE
;
1461 sc
->intr_enable_mask
= tmp
;
1463 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_INT_MASK
, tmp
);
1465 if (rt2860_txrx_enable(sc
) != 0)
1468 /* clear garbage interrupts */
1470 tmp
= rt2860_io_mac_read(sc
, 0x1300);
1472 ifp
->if_drv_flags
&= ~IFF_DRV_OACTIVE
;
1473 ifp
->if_drv_flags
|= IFF_DRV_RUNNING
;
1475 sc
->periodic_round
= 0;
1477 callout_reset(&sc
->periodic_ch
, hz
/ 10, rt2860_periodic
, sc
);
1483 rt2860_stop_locked(sc
);
1489 static void rt2860_init(void *priv
)
1491 struct rt2860_softc
*sc
;
1495 RT2860_SOFTC_LOCK(sc
);
1497 rt2860_init_locked(sc
);
1499 RT2860_SOFTC_UNLOCK(sc
);
1505 static int rt2860_init_bbp(struct rt2860_softc
*sc
)
1510 for (ntries
= 0; ntries
< 20; ntries
++)
1512 tmp
= rt2860_io_bbp_read(sc
, 0);
1513 if (tmp
!= 0x00 && tmp
!= 0xff)
1517 if (tmp
== 0x00 || tmp
== 0xff)
1519 printf("%s: timeout waiting for BBP to wakeup\n",
1520 device_get_nameunit(sc
->dev
));
1524 for (i
= 0; i
< RT2860_DEF_BBP_SIZE
; i
++)
1525 rt2860_io_bbp_write(sc
, rt2860_def_bbp
[i
].reg
,
1526 rt2860_def_bbp
[i
].val
);
1528 if ((sc
->mac_rev
& 0xffff) != 0x0101)
1529 rt2860_io_bbp_write(sc
, 84, 0x19);
1531 if (sc
->mac_rev
== 0x28600100)
1533 rt2860_io_bbp_write(sc
, 69, 0x16);
1534 rt2860_io_bbp_write(sc
, 73, 0x12);
1541 * rt2860_stop_locked
1543 static void rt2860_stop_locked(void *priv
)
1545 struct rt2860_softc
*sc
;
1547 struct ieee80211com
*ic
;
1554 RT2860_DPRINTF(sc
, RT2860_DEBUG_ANY
,
1556 device_get_nameunit(sc
->dev
));
1558 RT2860_SOFTC_ASSERT_LOCKED(sc
);
1562 if (ifp
->if_drv_flags
& IFF_DRV_RUNNING
)
1563 rt2860_led_cmd(sc
, RT2860_LED_CMD_RADIO_OFF
);
1565 ifp
->if_drv_flags
&= ~(IFF_DRV_RUNNING
| IFF_DRV_OACTIVE
);
1567 callout_stop(&sc
->periodic_ch
);
1568 callout_stop(&sc
->tx_watchdog_ch
);
1570 RT2860_SOFTC_UNLOCK(sc
);
1572 taskqueue_block(sc
->taskqueue
);
1574 taskqueue_drain(sc
->taskqueue
, &sc
->rx_done_task
);
1575 taskqueue_drain(sc
->taskqueue
, &sc
->tx_done_task
);
1576 taskqueue_drain(sc
->taskqueue
, &sc
->fifo_sta_full_task
);
1577 taskqueue_drain(sc
->taskqueue
, &sc
->periodic_task
);
1579 RT2860_SOFTC_LOCK(sc
);
1581 /* clear key tables */
1583 rt2860_asic_clear_keytables(sc
);
1585 /* disable interrupts */
1587 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_INT_MASK
, 0);
1591 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SYS_CTRL
);
1593 tmp
&= ~(RT2860_REG_RX_ENABLE
| RT2860_REG_TX_ENABLE
);
1595 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
, tmp
);
1599 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
,
1600 RT2860_REG_MAC_SRST
| RT2860_REG_BBP_HRST
);
1601 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
, 0);
1607 static void rt2860_stop(void *priv
)
1609 struct rt2860_softc
*sc
;
1613 RT2860_SOFTC_LOCK(sc
);
1615 rt2860_stop_locked(sc
);
1617 RT2860_SOFTC_UNLOCK(sc
);
1623 static void rt2860_start(struct ifnet
*ifp
)
1625 struct rt2860_softc
*sc
;
1626 struct ieee80211_node
*ni
;
1632 RT2860_SOFTC_LOCK(sc
);
1634 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
1636 RT2860_SOFTC_UNLOCK(sc
);
1642 IF_POLL(&ifp
->if_snd
, m
);
1646 IFQ_DRV_DEQUEUE(&ifp
->if_snd
, m
);
1648 ni
= (struct ieee80211_node
*) m
->m_pkthdr
.rcvif
;
1650 qid
= M_WME_GETAC(m
);
1652 if (sc
->tx_ring
[qid
].data_queued
>= RT2860_SOFTC_TX_RING_DATA_COUNT
)
1654 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
1655 "%s: if_start: Tx ring with qid=%d is full\n",
1656 device_get_nameunit(sc
->dev
), qid
);
1659 ieee80211_free_node(ni
);
1660 ifp
->if_drv_flags
|= IFF_DRV_OACTIVE
;
1665 if (rt2860_tx_data(sc
, m
, ni
, qid
) != 0)
1667 ieee80211_free_node(ni
);
1672 rt2860_drain_fifo_stats(sc
);
1674 sc
->tx_timer
= RT2860_TX_WATCHDOG_TIMEOUT
;
1676 callout_reset(&sc
->tx_watchdog_ch
, hz
, rt2860_tx_watchdog
, sc
);
1679 RT2860_SOFTC_UNLOCK(sc
);
1685 static int rt2860_ioctl(struct ifnet
*ifp
, u_long cmd
, caddr_t data
)
1687 struct rt2860_softc
*sc
;
1688 struct ieee80211com
*ic
;
1690 int error
, startall
;
1694 ifr
= (struct ifreq
*) data
;
1703 RT2860_SOFTC_LOCK(sc
);
1705 if (ifp
->if_flags
& IFF_UP
)
1707 if (ifp
->if_drv_flags
& IFF_DRV_RUNNING
)
1709 if ((ifp
->if_flags
^ sc
->if_flags
) & IFF_PROMISC
)
1710 rt2860_asic_update_promisc(sc
);
1714 rt2860_init_locked(sc
);
1720 if (ifp
->if_drv_flags
& IFF_DRV_RUNNING
)
1721 rt2860_stop_locked(sc
);
1724 sc
->if_flags
= ifp
->if_flags
;
1726 RT2860_SOFTC_UNLOCK(sc
);
1729 ieee80211_start_all(ic
);
1734 error
= ifmedia_ioctl(ifp
, ifr
, &ic
->ic_media
, cmd
);
1738 error
= ether_ioctl(ifp
, cmd
, data
);
1752 static struct ieee80211vap
*rt2860_vap_create(struct ieee80211com
*ic
,
1753 const char name
[IFNAMSIZ
], int unit
, int opmode
, int flags
,
1754 const uint8_t bssid
[IEEE80211_ADDR_LEN
],
1755 const uint8_t mac
[IEEE80211_ADDR_LEN
])
1757 struct rt2860_softc
*sc
;
1759 struct rt2860_softc_vap
*rvap
;
1760 struct ieee80211vap
*vap
;
1765 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
1766 "%s: VAP create: opmode=%s\n",
1767 device_get_nameunit(sc
->dev
),
1768 ieee80211_opmode_name
[opmode
]);
1772 case IEEE80211_M_MONITOR
:
1773 case IEEE80211_M_IBSS
:
1774 case IEEE80211_M_STA
:
1775 case IEEE80211_M_AHDEMO
:
1776 case IEEE80211_M_HOSTAP
:
1777 case IEEE80211_M_MBSS
:
1778 if (!TAILQ_EMPTY(&ic
->ic_vaps
))
1780 if_printf(ifp
, "only 1 VAP supported\n");
1784 if (opmode
== IEEE80211_M_STA
)
1785 flags
|= IEEE80211_CLONE_NOBEACONS
;
1788 case IEEE80211_M_WDS
:
1789 if (TAILQ_EMPTY(&ic
->ic_vaps
) || ic
->ic_opmode
!= IEEE80211_M_HOSTAP
)
1791 if_printf(ifp
, "WDS only supported in AP mode\n");
1795 flags
&= ~IEEE80211_CLONE_BSSID
;
1799 if_printf(ifp
, "unknown opmode %d\n", opmode
);
1803 rvap
= (struct rt2860_softc_vap
*) malloc(sizeof(struct rt2860_softc_vap
),
1804 M_80211_VAP
, M_NOWAIT
| M_ZERO
);
1810 ieee80211_vap_setup(ic
, vap
, name
, unit
, opmode
, flags
, bssid
, mac
);
1812 rvap
->newstate
= vap
->iv_newstate
;
1813 vap
->iv_newstate
= rt2860_vap_newstate
;
1815 vap
->iv_reset
= rt2860_vap_reset
;
1816 vap
->iv_key_update_begin
= rt2860_vap_key_update_begin
;
1817 vap
->iv_key_update_end
= rt2860_vap_key_update_end
;
1818 vap
->iv_key_set
= rt2860_vap_key_set
;
1819 vap
->iv_key_delete
= rt2860_vap_key_delete
;
1820 vap
->iv_update_beacon
= rt2860_vap_update_beacon
;
1822 rt2860_amrr_init(&rvap
->amrr
, vap
,
1823 RT2860_AMRR_MIN_SUCCESS_THRESHOLD
,
1824 RT2860_AMRR_MAX_SUCCESS_THRESHOLD
,
1827 ieee80211_vap_attach(vap
, rt2860_media_change
, ieee80211_media_status
);
1829 ic
->ic_opmode
= opmode
;
1837 static void rt2860_vap_delete(struct ieee80211vap
*vap
)
1839 struct rt2860_softc
*sc
;
1840 struct ieee80211com
*ic
;
1842 struct rt2860_softc_vap
*rvap
;
1847 rvap
= (struct rt2860_softc_vap
*) vap
;
1849 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
1850 "%s: VAP delete: opmode=%s\n",
1851 device_get_nameunit(sc
->dev
),
1852 ieee80211_opmode_name
[vap
->iv_opmode
]);
1854 rt2860_amrr_cleanup(&rvap
->amrr
);
1856 ieee80211_vap_detach(vap
);
1858 free(rvap
, M_80211_VAP
);
1864 static int rt2860_vap_reset(struct ieee80211vap
*vap
, u_long cmd
)
1866 struct rt2860_softc
*sc
;
1867 struct ieee80211com
*ic
;
1869 struct rt2860_softc_vap
*rvap
;
1875 rvap
= (struct rt2860_softc_vap
*) vap
;
1877 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
1878 "%s: VAP reset: cmd=%lu\n",
1879 device_get_nameunit(sc
->dev
), cmd
);
1885 case IEEE80211_IOC_RTSTHRESHOLD
:
1886 rt2860_asic_update_rtsthreshold(sc
);
1889 case IEEE80211_IOC_PROTMODE
:
1890 case IEEE80211_IOC_HTPROTMODE
:
1891 rt2860_asic_updateprot(sc
);
1894 case IEEE80211_IOC_TXPOWER
:
1895 rt2860_asic_update_txpower(sc
);
1898 case IEEE80211_IOC_SHORTGI
:
1899 case IEEE80211_IOC_AMPDU_DENSITY
:
1911 * rt2860_vap_newstate
1913 static int rt2860_vap_newstate(struct ieee80211vap
*vap
,
1914 enum ieee80211_state nstate
, int arg
)
1916 struct rt2860_softc
*sc
;
1917 struct ieee80211com
*ic
;
1919 struct rt2860_softc_vap
*rvap
;
1920 struct ieee80211_node
*ni
;
1921 enum ieee80211_state ostate
;
1927 rvap
= (struct rt2860_softc_vap
*) vap
;
1929 ostate
= vap
->iv_state
;
1931 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
1932 "%s: VAP newstate: %s -> %s\n",
1933 device_get_nameunit(sc
->dev
),
1934 ieee80211_state_name
[ostate
], ieee80211_state_name
[nstate
]);
1936 error
= rvap
->newstate(vap
, nstate
, arg
);
1940 IEEE80211_UNLOCK(ic
);
1942 RT2860_SOFTC_LOCK(sc
);
1944 /* turn link LED off */
1946 if (nstate
!= IEEE80211_S_RUN
)
1947 rt2860_led_cmd(sc
, RT2860_LED_CMD_RADIO_OFF
);
1951 case IEEE80211_S_INIT
:
1952 rt2860_asic_disable_tsf_sync(sc
);
1955 case IEEE80211_S_RUN
:
1958 rt2860_rf_set_chan(sc
, ni
->ni_chan
);
1960 if (vap
->iv_opmode
!= IEEE80211_M_MONITOR
)
1962 rt2860_asic_enable_mrr(sc
);
1963 rt2860_asic_set_txpreamble(sc
);
1964 rt2860_asic_set_basicrates(sc
);
1965 rt2860_asic_set_bssid(sc
, ni
->ni_bssid
);
1968 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
||
1969 vap
->iv_opmode
== IEEE80211_M_IBSS
||
1970 vap
->iv_opmode
== IEEE80211_M_MBSS
)
1972 error
= rt2860_asic_update_beacon(sc
, vap
);
1977 if (vap
->iv_opmode
!= IEEE80211_M_MONITOR
)
1978 rt2860_asic_enable_tsf_sync(sc
);
1980 /* turn link LED on */
1982 if (ic
->ic_opmode
!= IEEE80211_M_MONITOR
)
1984 rt2860_led_cmd(sc
, RT2860_LED_CMD_RADIO_ON
|
1985 (IEEE80211_IS_CHAN_2GHZ(ni
->ni_chan
) ?
1986 RT2860_LED_CMD_LINK_2GHZ
: RT2860_LED_CMD_LINK_5GHZ
));
1994 RT2860_SOFTC_UNLOCK(sc
);
2002 * rt2860_vap_key_update_begin
2004 static void rt2860_vap_key_update_begin(struct ieee80211vap
*vap
)
2006 struct rt2860_softc
*sc
;
2007 struct ieee80211com
*ic
;
2014 RT2860_DPRINTF(sc
, RT2860_DEBUG_KEY
,
2015 "%s: VAP key update begin\n",
2016 device_get_nameunit(sc
->dev
));
2018 taskqueue_block(sc
->taskqueue
);
2020 IF_LOCK(&ifp
->if_snd
);
2024 * rt2860_vap_key_update_end
2026 static void rt2860_vap_key_update_end(struct ieee80211vap
*vap
)
2028 struct rt2860_softc
*sc
;
2029 struct ieee80211com
*ic
;
2036 RT2860_DPRINTF(sc
, RT2860_DEBUG_KEY
,
2037 "%s: VAP key update end\n",
2038 device_get_nameunit(sc
->dev
));
2040 IF_UNLOCK(&ifp
->if_snd
);
2042 taskqueue_unblock(sc
->taskqueue
);
2046 * rt2860_vap_key_set
2048 static int rt2860_vap_key_set(struct ieee80211vap
*vap
,
2049 const struct ieee80211_key
*k
, const uint8_t mac
[IEEE80211_ADDR_LEN
])
2051 struct rt2860_softc
*sc
;
2052 struct ieee80211com
*ic
;
2054 struct ieee80211_node
*ni
;
2055 uint16_t associd
, key_base
, keymode_base
;
2056 uint8_t mode
, vapid
, wcid
, iv
[8];
2059 if (k
->wk_cipher
->ic_cipher
!= IEEE80211_CIPHER_WEP
&&
2060 k
->wk_cipher
->ic_cipher
!= IEEE80211_CIPHER_TKIP
&&
2061 k
->wk_cipher
->ic_cipher
!= IEEE80211_CIPHER_AES_CCM
)
2068 if (vap
->iv_opmode
!= IEEE80211_M_HOSTAP
)
2071 ni
= ieee80211_find_vap_node(&ic
->ic_sta
, vap
, mac
);
2073 associd
= (ni
!= NULL
) ? ni
->ni_associd
: 0;
2075 if ((vap
->iv_opmode
== IEEE80211_M_HOSTAP
) && (ni
!= NULL
))
2076 ieee80211_free_node(ni
);
2078 switch (k
->wk_cipher
->ic_cipher
)
2080 case IEEE80211_CIPHER_WEP
:
2081 if(k
->wk_keylen
< 8)
2082 mode
= RT2860_REG_CIPHER_MODE_WEP40
;
2084 mode
= RT2860_REG_CIPHER_MODE_WEP104
;
2087 case IEEE80211_CIPHER_TKIP
:
2088 mode
= RT2860_REG_CIPHER_MODE_TKIP
;
2091 case IEEE80211_CIPHER_AES_CCM
:
2092 mode
= RT2860_REG_CIPHER_MODE_AES_CCMP
;
2099 RT2860_DPRINTF(sc
, RT2860_DEBUG_KEY
,
2100 "%s: VAP key set: keyix=%d, keylen=%d, associd=0x%04x, mode=%d, group=%d\n",
2101 device_get_nameunit(sc
->dev
), k
->wk_keyix
, k
->wk_keylen
, associd
, mode
,
2102 (k
->wk_flags
& IEEE80211_KEY_GROUP
) ? 1 : 0);
2104 if (!(k
->wk_flags
& IEEE80211_KEY_GROUP
))
2106 /* install pairwise key */
2109 wcid
= RT2860_AID2WCID(associd
);
2110 key_base
= RT2860_REG_PKEY(wcid
);
2112 if (k
->wk_cipher
->ic_cipher
== IEEE80211_CIPHER_WEP
)
2116 iv
[3] = (k
->wk_keyix
<< 6);
2120 if (k
->wk_cipher
->ic_cipher
== IEEE80211_CIPHER_TKIP
)
2122 iv
[0] = (k
->wk_keytsc
>> 8);
2123 iv
[1] = ((iv
[0] | 0x20) & 0x7f);
2124 iv
[2] = k
->wk_keytsc
;
2130 iv
[0] = k
->wk_keytsc
;
2131 iv
[1] = k
->wk_keytsc
>> 8;
2135 iv
[3] = ((k
->wk_keyix
<< 6) | IEEE80211_WEP_EXTIV
);
2136 iv
[4] = (k
->wk_keytsc
>> 16);
2137 iv
[5] = (k
->wk_keytsc
>> 24);
2138 iv
[6] = (k
->wk_keytsc
>> 32);
2139 iv
[7] = (k
->wk_keytsc
>> 40);
2141 RT2860_DPRINTF(sc
, RT2860_DEBUG_KEY
,
2142 "%s: VAP key set: iv=%02x %02x %02x %02x %02x %02x %02x %02x\n",
2143 device_get_nameunit(sc
->dev
),
2144 iv
[0], iv
[1], iv
[2], iv
[3], iv
[4], iv
[5], iv
[6], iv
[7]);
2147 rt2860_io_mac_write_multi(sc
, RT2860_REG_IVEIV(wcid
), iv
, 8);
2149 if (k
->wk_cipher
->ic_cipher
== IEEE80211_CIPHER_TKIP
)
2151 rt2860_io_mac_write_multi(sc
, key_base
, k
->wk_key
, 16);
2153 if (vap
->iv_opmode
!= IEEE80211_M_HOSTAP
)
2155 rt2860_io_mac_write_multi(sc
, key_base
+ 16, &k
->wk_key
[16], 8);
2156 rt2860_io_mac_write_multi(sc
, key_base
+ 24, &k
->wk_key
[24], 8);
2160 rt2860_io_mac_write_multi(sc
, key_base
+ 16, &k
->wk_key
[24], 8);
2161 rt2860_io_mac_write_multi(sc
, key_base
+ 24, &k
->wk_key
[16], 8);
2166 rt2860_io_mac_write_multi(sc
, key_base
, k
->wk_key
, k
->wk_keylen
);
2169 tmp
= ((vapid
& RT2860_REG_VAP_MASK
) << RT2860_REG_VAP_SHIFT
) |
2170 (mode
<< RT2860_REG_CIPHER_MODE_SHIFT
) | RT2860_REG_PKEY_ENABLE
;
2172 rt2860_io_mac_write(sc
, RT2860_REG_WCID_ATTR(wcid
), tmp
);
2175 if ((k
->wk_flags
& IEEE80211_KEY_GROUP
) ||
2176 (k
->wk_cipher
->ic_cipher
== IEEE80211_CIPHER_WEP
))
2178 /* install group key */
2181 key_base
= RT2860_REG_SKEY(vapid
, k
->wk_keyix
);
2182 keymode_base
= RT2860_REG_SKEY_MODE(vapid
);
2184 if (k
->wk_cipher
->ic_cipher
== IEEE80211_CIPHER_TKIP
)
2186 rt2860_io_mac_write_multi(sc
, key_base
, k
->wk_key
, 16);
2188 if (vap
->iv_opmode
!= IEEE80211_M_HOSTAP
)
2190 rt2860_io_mac_write_multi(sc
, key_base
+ 16, &k
->wk_key
[16], 8);
2191 rt2860_io_mac_write_multi(sc
, key_base
+ 24, &k
->wk_key
[24], 8);
2195 rt2860_io_mac_write_multi(sc
, key_base
+ 16, &k
->wk_key
[24], 8);
2196 rt2860_io_mac_write_multi(sc
, key_base
+ 24, &k
->wk_key
[16], 8);
2201 rt2860_io_mac_write_multi(sc
, key_base
, k
->wk_key
, k
->wk_keylen
);
2204 tmp
= rt2860_io_mac_read(sc
, keymode_base
);
2206 tmp
&= ~(0xf << (k
->wk_keyix
* 4 + 16 * (vapid
% 2)));
2207 tmp
|= (mode
<< (k
->wk_keyix
* 4 + 16 * (vapid
% 2)));
2209 rt2860_io_mac_write(sc
, keymode_base
, tmp
);
2216 * rt2860_vap_key_delete
2218 static int rt2860_vap_key_delete(struct ieee80211vap
*vap
,
2219 const struct ieee80211_key
*k
)
2221 struct rt2860_softc
*sc
;
2222 struct ieee80211com
*ic
;
2224 struct ieee80211_node
*ni
;
2226 uint8_t vapid
, wcid
;
2233 associd
= (ni
!= NULL
) ? ni
->ni_associd
: 0;
2235 RT2860_DPRINTF(sc
, RT2860_DEBUG_KEY
,
2236 "%s: VAP key delete: keyix=%d, keylen=%d, associd=0x%04x, group=%d\n",
2237 device_get_nameunit(sc
->dev
), k
->wk_keyix
, k
->wk_keylen
, associd
,
2238 (k
->wk_flags
& IEEE80211_KEY_GROUP
) ? 1 : 0);
2240 if (!(k
->wk_flags
& IEEE80211_KEY_GROUP
))
2242 /* remove pairwise key */
2244 wcid
= RT2860_AID2WCID(associd
);
2246 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_WCID_ATTR(wcid
));
2249 tmp
|= (RT2860_REG_CIPHER_MODE_NONE
<< RT2860_REG_CIPHER_MODE_SHIFT
);
2251 rt2860_io_mac_write(sc
, RT2860_REG_WCID_ATTR(wcid
), tmp
);
2255 /* remove group key */
2259 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SKEY_MODE(vapid
));
2261 tmp
&= ~(0xf << (k
->wk_keyix
* 4 + 16 * (vapid
% 2)));
2262 tmp
|= (RT2860_REG_CIPHER_MODE_NONE
<< (k
->wk_keyix
* 4 + 16 * (vapid
% 2)));
2264 rt2860_io_mac_write(sc
, RT2860_REG_SKEY_MODE(vapid
), tmp
);
2271 * rt2860_vap_update_beacon
2273 static void rt2860_vap_update_beacon(struct ieee80211vap
*vap
, int what
)
2275 struct rt2860_softc
*sc
;
2276 struct ieee80211com
*ic
;
2283 RT2860_DPRINTF(sc
, RT2860_DEBUG_BEACON
,
2284 "%s: VAP update beacon\n",
2285 device_get_nameunit(sc
->dev
));
2287 rt2860_asic_update_beacon(sc
, vap
);
2291 * rt2860_media_change
2293 static int rt2860_media_change(struct ifnet
*ifp
)
2297 error
= ieee80211_media_change(ifp
);
2299 return (error
== ENETRESET
? 0 : error
);
2305 static struct ieee80211_node
*rt2860_node_alloc(struct ieee80211vap
*vap
,
2306 const uint8_t mac
[IEEE80211_ADDR_LEN
])
2308 return malloc(sizeof(struct rt2860_softc_node
),
2309 M_80211_NODE
, M_NOWAIT
| M_ZERO
);
2313 * rt2860_setregdomain
2315 static int rt2860_setregdomain(struct ieee80211com
*ic
,
2316 struct ieee80211_regdomain
*reg
,
2317 int nchans
, struct ieee80211_channel chans
[])
2319 struct rt2860_softc
*sc
;
2325 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
2326 "%s: set regulatory domain: country=%d, country code string=%c%c, location=%c\n",
2327 device_get_nameunit(sc
->dev
),
2328 reg
->country
, reg
->isocc
[0], reg
->isocc
[1], reg
->location
);
2334 * rt2860_getradiocaps
2336 static void rt2860_getradiocaps(struct ieee80211com
*ic
,
2337 int maxchans
, int *nchans
, struct ieee80211_channel chans
[])
2339 *nchans
= (ic
->ic_nchans
>= maxchans
) ? maxchans
: ic
->ic_nchans
;
2341 memcpy(chans
, ic
->ic_channels
, (*nchans
) * sizeof(struct ieee80211_channel
));
2347 static void rt2860_scan_start(struct ieee80211com
*ic
)
2349 struct rt2860_softc
*sc
;
2355 rt2860_asic_disable_tsf_sync(sc
);
2361 static void rt2860_scan_end(struct ieee80211com
*ic
)
2363 struct rt2860_softc
*sc
;
2369 rt2860_asic_enable_tsf_sync(sc
);
2373 * rt2860_set_channel
2375 static void rt2860_set_channel(struct ieee80211com
*ic
)
2377 struct rt2860_softc
*sc
;
2383 RT2860_DPRINTF(sc
, RT2860_DEBUG_CHAN
,
2384 "%s: set channel: channel=%u, HT%s%s\n",
2385 device_get_nameunit(sc
->dev
),
2386 ieee80211_chan2ieee(ic
, ic
->ic_curchan
),
2387 !IEEE80211_IS_CHAN_HT(ic
->ic_curchan
) ? " disabled" :
2388 IEEE80211_IS_CHAN_HT20(ic
->ic_curchan
) ? "20":
2389 IEEE80211_IS_CHAN_HT40U(ic
->ic_curchan
) ? "40U" : "40D",
2390 (ic
->ic_flags
& IEEE80211_F_SCAN
) ? ", scanning" : "");
2392 RT2860_SOFTC_LOCK(sc
);
2394 rt2860_rf_set_chan(sc
, ic
->ic_curchan
);
2396 RT2860_SOFTC_UNLOCK(sc
);
2402 static void rt2860_newassoc(struct ieee80211_node
*ni
, int isnew
)
2404 struct rt2860_softc
*sc
;
2405 struct ieee80211com
*ic
;
2407 struct ieee80211vap
*vap
;
2408 struct rt2860_softc_vap
*rvap
;
2416 rvap
= (struct rt2860_softc_vap
*) vap
;
2418 associd
= (ni
!= NULL
) ? ni
->ni_associd
: 0;
2419 wcid
= RT2860_AID2WCID(associd
);
2421 RT2860_DPRINTF(sc
, RT2860_DEBUG_NODE
,
2422 "%s: new association: wcid=0x%02x, "
2423 "mac addr=%s, QoS %s, ERP %s, HT %s\n",
2424 device_get_nameunit(sc
->dev
), wcid
,
2425 ether_sprintf(ni
->ni_macaddr
),
2426 (ni
->ni_flags
& IEEE80211_NODE_QOS
) ? "enabled" : "disabled",
2427 (ni
->ni_flags
& IEEE80211_NODE_ERP
) ? "enabled" : "disabled",
2428 (ni
->ni_flags
& IEEE80211_NODE_HT
) ? "enabled" : "disabled");
2430 rt2860_io_mac_write_multi(sc
, RT2860_REG_WCID(wcid
),
2431 ni
->ni_macaddr
, IEEE80211_ADDR_LEN
);
2433 rt2860_amrr_node_init(&rvap
->amrr
, &sc
->amrr_node
[wcid
], ni
);
2435 RT2860_DPRINTF(sc
, RT2860_DEBUG_RATE
,
2436 "%s: initial%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2437 device_get_nameunit(sc
->dev
),
2438 (ni
->ni_flags
& IEEE80211_NODE_HT
) ? " HT" : "",
2439 ni
->ni_associd
, ni
->ni_txrate
,
2440 (ni
->ni_flags
& IEEE80211_NODE_HT
) ?
2441 (ni
->ni_htrates
.rs_rates
[ni
->ni_htrates
.rs_nrates
- 1] | IEEE80211_RATE_MCS
) :
2442 (ni
->ni_rates
.rs_rates
[ni
->ni_rates
.rs_nrates
- 1] & IEEE80211_RATE_VAL
));
2444 rt2860_asic_updateprot(sc
);
2445 rt2860_asic_updateslot(sc
);
2446 rt2860_asic_set_txpreamble(sc
);
2452 static void rt2860_updateslot(struct ifnet
*ifp
)
2454 struct rt2860_softc
*sc
;
2458 rt2860_asic_updateslot(sc
);
2462 * rt2860_update_promisc
2464 static void rt2860_update_promisc(struct ifnet
*ifp
)
2466 struct rt2860_softc
*sc
;
2470 rt2860_asic_update_promisc(sc
);
2474 * rt2860_update_mcast
2476 static void rt2860_update_mcast(struct ifnet
*ifp
)
2478 struct rt2860_softc
*sc
;
2486 static int rt2860_wme_update(struct ieee80211com
*ic
)
2488 struct rt2860_softc
*sc
;
2494 rt2860_asic_wme_update(sc
);
2502 static int rt2860_raw_xmit(struct ieee80211_node
*ni
, struct mbuf
*m
,
2503 const struct ieee80211_bpf_params
*params
)
2505 struct rt2860_softc
*sc
;
2506 struct ieee80211com
*ic
;
2513 RT2860_SOFTC_LOCK(sc
);
2515 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
2517 RT2860_SOFTC_UNLOCK(sc
);
2519 ieee80211_free_node(ni
);
2523 if (sc
->tx_ring
[sc
->tx_ring_mgtqid
].data_queued
>= RT2860_SOFTC_TX_RING_DATA_COUNT
)
2525 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
2526 "%s: raw xmit: Tx ring with qid=%d is full\n",
2527 device_get_nameunit(sc
->dev
), sc
->tx_ring_mgtqid
);
2529 ifp
->if_drv_flags
|= IFF_DRV_OACTIVE
;
2530 RT2860_SOFTC_UNLOCK(sc
);
2532 ieee80211_free_node(ni
);
2536 if (rt2860_tx_mgmt(sc
, m
, ni
, sc
->tx_ring_mgtqid
) != 0)
2539 RT2860_SOFTC_UNLOCK(sc
);
2540 ieee80211_free_node(ni
);
2544 sc
->tx_timer
= RT2860_TX_WATCHDOG_TIMEOUT
;
2546 RT2860_SOFTC_UNLOCK(sc
);
2552 * rt2860_recv_action
2554 static int rt2860_recv_action(struct ieee80211_node
*ni
,
2555 const struct ieee80211_frame
*wh
,
2556 const uint8_t *frm
, const uint8_t *efrm
)
2558 struct rt2860_softc
*sc
;
2559 struct ieee80211com
*ic
;
2561 const struct ieee80211_action
*ia
;
2562 uint16_t associd
, baparamset
;
2571 ia
= (const struct ieee80211_action
*) frm
;
2573 ret
= sc
->recv_action(ni
, wh
, frm
, efrm
);
2575 if (ia
->ia_category
!= IEEE80211_ACTION_CAT_BA
)
2578 associd
= (ni
!= NULL
) ? ni
->ni_associd
: 0;
2579 wcid
= RT2860_AID2WCID(associd
);
2581 switch (ia
->ia_action
)
2583 /* IEEE80211_ACTION_BA_ADDBA_REQUEST */
2584 case IEEE80211_ACTION_BA_ADDBA_REQUEST
:
2585 baparamset
= LE_READ_2(frm
+ 3);
2586 tid
= RT2860_MS(baparamset
, IEEE80211_BAPS_TID
);
2588 RT2860_DPRINTF(sc
, RT2860_DEBUG_BA
,
2589 "%s: adding A-MPDU Rx block ACK: associd=0x%04x, tid=%d\n",
2590 device_get_nameunit(sc
->dev
), associd
, tid
);
2592 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_WCID(wcid
) + 4);
2594 tmp
|= (0x10000 << tid
);
2596 rt2860_io_mac_write(sc
, RT2860_REG_WCID(wcid
) + 4, tmp
);
2599 /* IEEE80211_ACTION_BA_DELBA */
2600 case IEEE80211_ACTION_BA_DELBA
:
2601 baparamset
= LE_READ_2(frm
+ 2);
2602 tid
= RT2860_MS(baparamset
, IEEE80211_BAPS_TID
);
2604 RT2860_DPRINTF(sc
, RT2860_DEBUG_BA
,
2605 "%s: deleting A-MPDU Rx block ACK: associd=0x%04x, tid=%d\n",
2606 device_get_nameunit(sc
->dev
), associd
, tid
);
2608 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_WCID(wcid
) + 4);
2610 tmp
&= ~(0x10000 << tid
);
2612 rt2860_io_mac_write(sc
, RT2860_REG_WCID(wcid
) + 4, tmp
);
2620 * rt2860_send_action
2622 static int rt2860_send_action(struct ieee80211_node
*ni
,
2623 int cat
, int act
, void *sa
)
2625 struct rt2860_softc
*sc
;
2626 struct ieee80211com
*ic
;
2628 uint16_t associd
, *args
, baparamset
;
2637 ret
= sc
->send_action(ni
, cat
, act
, sa
);
2639 if (cat
!= IEEE80211_ACTION_CAT_BA
)
2642 associd
= (ni
!= NULL
) ? ni
->ni_associd
: 0;
2643 wcid
= RT2860_AID2WCID(associd
);
2648 /* IEEE80211_ACTION_BA_DELBA */
2649 case IEEE80211_ACTION_BA_DELBA
:
2650 baparamset
= RT2860_SM(args
[0], IEEE80211_DELBAPS_TID
) | args
[1];
2652 if (RT2860_MS(baparamset
, IEEE80211_DELBAPS_INIT
) == IEEE80211_DELBAPS_INIT
)
2655 tid
= RT2860_MS(baparamset
, IEEE80211_DELBAPS_TID
);
2657 RT2860_DPRINTF(sc
, RT2860_DEBUG_BA
,
2658 "%s: deleting A-MPDU Rx block ACK: associd=0x%04x, tid=%d\n",
2659 device_get_nameunit(sc
->dev
), associd
, tid
);
2661 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_WCID(wcid
) + 4);
2663 tmp
&= ~(0x10000 << tid
);
2665 rt2860_io_mac_write(sc
, RT2860_REG_WCID(wcid
) + 4, tmp
);
2673 * rt2860_amrr_update_iter_func
2675 static void rt2860_amrr_update_iter_func(void *arg
, struct ieee80211_node
*ni
)
2677 struct rt2860_softc
*sc
;
2678 struct ieee80211com
*ic
;
2680 struct ieee80211vap
*vap
;
2681 struct rt2860_softc_vap
*rvap
;
2688 rvap
= (struct rt2860_softc_vap
*) vap
;
2690 /* only associated stations */
2692 if ((ni
->ni_vap
== vap
) && (ni
->ni_associd
!= 0))
2694 wcid
= RT2860_AID2WCID(ni
->ni_associd
);
2696 rt2860_amrr_choose(ni
, &sc
->amrr_node
[wcid
]);
2698 RT2860_DPRINTF(sc
, RT2860_DEBUG_RATE
,
2699 "%s:%s node Tx rate: associd=0x%04x, rate=0x%02x, max rate=0x%02x\n",
2700 device_get_nameunit(sc
->dev
),
2701 (ni
->ni_flags
& IEEE80211_NODE_HT
) ? " HT" : "",
2702 ni
->ni_associd
, ni
->ni_txrate
,
2703 (ni
->ni_flags
& IEEE80211_NODE_HT
) ?
2704 (ni
->ni_htrates
.rs_rates
[ni
->ni_htrates
.rs_nrates
- 1] | IEEE80211_RATE_MCS
) :
2705 (ni
->ni_rates
.rs_rates
[ni
->ni_rates
.rs_nrates
- 1] & IEEE80211_RATE_VAL
));
2712 static void rt2860_periodic(void *arg
)
2714 struct rt2860_softc
*sc
;
2718 RT2860_DPRINTF(sc
, RT2860_DEBUG_PERIODIC
,
2720 device_get_nameunit(sc
->dev
));
2722 taskqueue_enqueue(sc
->taskqueue
, &sc
->periodic_task
);
2726 * rt2860_tx_watchdog
2728 static void rt2860_tx_watchdog(void *arg
)
2730 struct rt2860_softc
*sc
;
2736 if (sc
->tx_timer
== 0)
2739 if (--sc
->tx_timer
== 0)
2741 printf("%s: Tx watchdog timeout: resetting\n",
2742 device_get_nameunit(sc
->dev
));
2744 rt2860_stop_locked(sc
);
2745 rt2860_init_locked(sc
);
2749 sc
->tx_watchdog_timeouts
++;
2752 callout_reset(&sc
->tx_watchdog_ch
, hz
, rt2860_tx_watchdog
, sc
);
2756 * rt2860_asic_set_bssid
2758 static void rt2860_asic_set_bssid(struct rt2860_softc
*sc
,
2759 const uint8_t *bssid
)
2763 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
2764 "%s: set bssid: bssid=%s\n",
2765 device_get_nameunit(sc
->dev
),
2766 ether_sprintf(bssid
));
2768 tmp
= bssid
[0] | (bssid
[1]) << 8 | (bssid
[2] << 16) | (bssid
[3] << 24);
2770 rt2860_io_mac_write(sc
, RT2860_REG_BSSID_DW0
, tmp
);
2772 tmp
= bssid
[4] | (bssid
[5] << 8);
2774 rt2860_io_mac_write(sc
, RT2860_REG_BSSID_DW1
, tmp
);
2778 * rt2860_asic_set_macaddr
2780 static void rt2860_asic_set_macaddr(struct rt2860_softc
*sc
,
2781 const uint8_t *addr
)
2785 tmp
= addr
[0] | (addr
[1] << 8) | (addr
[2] << 16) | (addr
[3] << 24);
2787 rt2860_io_mac_write(sc
, RT2860_REG_ADDR_DW0
, tmp
);
2789 tmp
= addr
[4] | (addr
[5] << 8);
2791 rt2860_io_mac_write(sc
, RT2860_REG_ADDR_DW1
, tmp
);
2795 * rt2860_asic_enable_tsf_sync
2797 static void rt2860_asic_enable_tsf_sync(struct rt2860_softc
*sc
)
2800 struct ieee80211com
*ic
;
2801 struct ieee80211vap
*vap
;
2806 vap
= TAILQ_FIRST(&ic
->ic_vaps
);
2808 RT2860_DPRINTF(sc
, RT2860_DEBUG_BEACON
,
2809 "%s: enabling TSF\n",
2810 device_get_nameunit(sc
->dev
));
2812 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_BCN_TIME_CFG
);
2815 tmp
|= vap
->iv_bss
->ni_intval
* 16;
2816 tmp
|= (RT2860_REG_TSF_TIMER_ENABLE
| RT2860_REG_TBTT_TIMER_ENABLE
);
2818 if (vap
->iv_opmode
== IEEE80211_M_STA
)
2820 tmp
|= (RT2860_REG_TSF_SYNC_MODE_STA
<< RT2860_REG_TSF_SYNC_MODE_SHIFT
);
2822 else if (vap
->iv_opmode
== IEEE80211_M_IBSS
)
2824 tmp
|= RT2860_REG_BCN_TX_ENABLE
;
2825 tmp
|= (RT2860_REG_TSF_SYNC_MODE_IBSS
<< RT2860_REG_TSF_SYNC_MODE_SHIFT
);
2827 else if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
)
2829 tmp
|= RT2860_REG_BCN_TX_ENABLE
;
2830 tmp
|= (RT2860_REG_TSF_SYNC_MODE_HOSTAP
<< RT2860_REG_TSF_SYNC_MODE_SHIFT
);
2833 rt2860_io_mac_write(sc
, RT2860_REG_BCN_TIME_CFG
, tmp
);
2837 * rt2860_asic_disable_tsf_sync
2839 static void rt2860_asic_disable_tsf_sync(struct rt2860_softc
*sc
)
2843 RT2860_DPRINTF(sc
, RT2860_DEBUG_BEACON
,
2844 "%s: disabling TSF\n",
2845 device_get_nameunit(sc
->dev
));
2847 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_BCN_TIME_CFG
);
2849 tmp
&= ~(RT2860_REG_BCN_TX_ENABLE
|
2850 RT2860_REG_TSF_TIMER_ENABLE
|
2851 RT2860_REG_TBTT_TIMER_ENABLE
);
2853 tmp
&= ~(RT2860_REG_TSF_SYNC_MODE_MASK
<< RT2860_REG_TSF_SYNC_MODE_SHIFT
);
2854 tmp
|= (RT2860_REG_TSF_SYNC_MODE_DISABLE
<< RT2860_REG_TSF_SYNC_MODE_SHIFT
);
2856 rt2860_io_mac_write(sc
, RT2860_REG_BCN_TIME_CFG
, tmp
);
2860 * rt2860_asic_enable_mrr
2862 static void rt2860_asic_enable_mrr(struct rt2860_softc
*sc
)
2864 #define CCK(mcs) (mcs)
2865 #define OFDM(mcs) ((1 << 3) | (mcs))
2866 #define HT(mcs) (mcs)
2868 rt2860_io_mac_write(sc
, RT2860_REG_TX_LG_FBK_CFG0
,
2869 (OFDM(6) << 28) | /* 54 -> 48 */
2870 (OFDM(5) << 24) | /* 48 -> 36 */
2871 (OFDM(4) << 20) | /* 36 -> 24 */
2872 (OFDM(3) << 16) | /* 24 -> 18 */
2873 (OFDM(2) << 12) | /* 18 -> 12 */
2874 (OFDM(1) << 8) | /* 12 -> 9 */
2875 (OFDM(0) << 4) | /* 9 -> 6 */
2876 OFDM(0)); /* 6 -> 6 */
2878 rt2860_io_mac_write(sc
, RT2860_REG_TX_LG_FBK_CFG1
,
2879 (CCK(2) << 12) | /* 11 -> 5.5 */
2880 (CCK(1) << 8) | /* 5.5 -> 2 */
2881 (CCK(0) << 4) | /* 2 -> 1 */
2882 CCK(0)); /* 1 -> 1 */
2884 rt2860_io_mac_write(sc
, RT2860_REG_TX_HT_FBK_CFG0
,
2894 rt2860_io_mac_write(sc
, RT2860_REG_TX_HT_FBK_CFG1
,
2910 * rt2860_asic_set_txpreamble
2912 static void rt2860_asic_set_txpreamble(struct rt2860_softc
*sc
)
2915 struct ieee80211com
*ic
;
2921 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
2922 "%s: %s short Tx preamble\n",
2923 device_get_nameunit(sc
->dev
),
2924 (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
) ? "enabling" : "disabling");
2926 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_AUTO_RSP_CFG
);
2928 tmp
&= ~RT2860_REG_CCK_SHORT_ENABLE
;
2930 if (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
)
2931 tmp
|= RT2860_REG_CCK_SHORT_ENABLE
;
2933 rt2860_io_mac_write(sc
, RT2860_REG_AUTO_RSP_CFG
, tmp
);
2937 * rt2860_asic_set_basicrates
2939 static void rt2860_asic_set_basicrates(struct rt2860_softc
*sc
)
2942 struct ieee80211com
*ic
;
2947 if (ic
->ic_curmode
== IEEE80211_MODE_11B
)
2948 rt2860_io_mac_write(sc
, RT2860_REG_LEGACY_BASIC_RATE
, 0x3);
2949 else if (ic
->ic_curmode
== IEEE80211_MODE_11A
)
2950 rt2860_io_mac_write(sc
, RT2860_REG_LEGACY_BASIC_RATE
, 0x150);
2952 rt2860_io_mac_write(sc
, RT2860_REG_LEGACY_BASIC_RATE
, 0x15f);
2956 * rt2860_asic_update_rtsthreshold
2958 static void rt2860_asic_update_rtsthreshold(struct rt2860_softc
*sc
)
2961 struct ieee80211com
*ic
;
2962 struct ieee80211vap
*vap
;
2968 vap
= TAILQ_FIRST(&ic
->ic_vaps
);
2970 RT2860_DPRINTF(sc
, RT2860_DEBUG_PROT
,
2971 "%s: updating RTS threshold: %d\n",
2972 device_get_nameunit(sc
->dev
), vap
->iv_rtsthreshold
);
2974 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_TX_RTS_CFG
);
2976 tmp
&= ~(RT2860_REG_TX_RTS_THRESHOLD_MASK
<< RT2860_REG_TX_RTS_THRESHOLD_SHIFT
);
2978 threshold
= (vap
->iv_rtsthreshold
< IEEE80211_RTS_MAX
) ?
2979 vap
->iv_rtsthreshold
: 0x1000;
2981 tmp
|= ((threshold
& RT2860_REG_TX_RTS_THRESHOLD_MASK
) <<
2982 RT2860_REG_TX_RTS_THRESHOLD_SHIFT
);
2984 rt2860_io_mac_write(sc
, RT2860_REG_TX_RTS_CFG
, tmp
);
2988 * rt2860_asic_update_txpower
2990 static void rt2860_asic_update_txpower(struct rt2860_softc
*sc
)
2993 struct ieee80211com
*ic
;
2994 uint32_t *txpow_rate
;
3003 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
3004 "%s: updating Tx power: %d\n",
3005 device_get_nameunit(sc
->dev
), ic
->ic_txpowlimit
);
3007 if (!IEEE80211_IS_CHAN_HT40(ic
->ic_curchan
))
3009 txpow_rate
= sc
->txpow_rate_20mhz
;
3013 if (IEEE80211_IS_CHAN_2GHZ(ic
->ic_curchan
))
3014 txpow_rate
= sc
->txpow_rate_40mhz_2ghz
;
3016 txpow_rate
= sc
->txpow_rate_40mhz_5ghz
;
3021 val
= rt2860_io_bbp_read(sc
, 1);
3024 if (ic
->ic_txpowlimit
> 90)
3028 else if (ic
->ic_txpowlimit
> 60)
3032 else if (ic
->ic_txpowlimit
> 30)
3036 else if (ic
->ic_txpowlimit
> 15)
3040 else if (ic
->ic_txpowlimit
> 9)
3050 rt2860_io_bbp_write(sc
, 1, val
);
3052 for (i
= 0; i
< RT2860_SOFTC_TXPOW_RATE_COUNT
; i
++)
3054 if (txpow_rate
[i
] == 0xffffffff)
3057 tmp
= rt2860_read_eeprom_txpow_rate_add_delta(txpow_rate
[i
], delta
);
3059 rt2860_io_mac_write(sc
, RT2860_REG_TX_PWR_CFG(i
), tmp
);
3064 * rt2860_asic_update_promisc
3066 static void rt2860_asic_update_promisc(struct rt2860_softc
*sc
)
3073 printf("%s: %s promiscuous mode\n",
3074 device_get_nameunit(sc
->dev
),
3075 (ifp
->if_flags
& IFF_PROMISC
) ? "entering" : "leaving");
3077 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_RX_FILTER_CFG
);
3079 tmp
&= ~RT2860_REG_RX_FILTER_DROP_UC_NOME
;
3081 if (!(ifp
->if_flags
& IFF_PROMISC
))
3082 tmp
|= RT2860_REG_RX_FILTER_DROP_UC_NOME
;
3084 rt2860_io_mac_write(sc
, RT2860_REG_RX_FILTER_CFG
, tmp
);
3088 * rt2860_asic_updateprot
3090 static void rt2860_asic_updateprot(struct rt2860_softc
*sc
)
3093 struct ieee80211com
*ic
;
3094 struct ieee80211vap
*vap
;
3095 uint32_t cck_prot
, ofdm_prot
, mm20_prot
, mm40_prot
, gf20_prot
, gf40_prot
;
3100 vap
= TAILQ_FIRST(&ic
->ic_vaps
);
3102 /* CCK frame protection */
3104 cck_prot
= RT2860_REG_RTSTH_ENABLE
| RT2860_REG_PROT_NAV_SHORT
|
3105 RT2860_REG_TXOP_ALLOW_ALL
| RT2860_REG_PROT_CTRL_NONE
;
3107 /* set up protection frame phy mode and rate (MCS code) */
3109 if (ic
->ic_curmode
== IEEE80211_MODE_11A
)
3110 cck_prot
|= (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3111 (0 << RT2860_REG_PROT_MCS_SHIFT
);
3113 cck_prot
|= ((RT2860_REG_PROT_PHYMODE_CCK
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3114 (3 << RT2860_REG_PROT_MCS_SHIFT
));
3116 rt2860_io_mac_write(sc
, RT2860_REG_TX_CCK_PROT_CFG
, cck_prot
);
3118 /* OFDM frame protection */
3120 ofdm_prot
= RT2860_REG_RTSTH_ENABLE
| RT2860_REG_PROT_NAV_SHORT
|
3121 RT2860_REG_TXOP_ALLOW_ALL
;
3123 if (ic
->ic_flags
& IEEE80211_F_USEPROT
)
3125 RT2860_DPRINTF(sc
, RT2860_DEBUG_PROT
,
3126 "%s: updating protection mode: b/g protection mode=%s\n",
3127 device_get_nameunit(sc
->dev
),
3128 (ic
->ic_protmode
== IEEE80211_PROT_RTSCTS
) ? "RTS/CTS" :
3129 ((ic
->ic_protmode
== IEEE80211_PROT_CTSONLY
) ? "CTS-to-self" : "none"));
3131 if (ic
->ic_protmode
== IEEE80211_PROT_RTSCTS
)
3132 ofdm_prot
|= RT2860_REG_PROT_CTRL_RTS_CTS
;
3133 else if (ic
->ic_protmode
== IEEE80211_PROT_CTSONLY
)
3134 ofdm_prot
|= RT2860_REG_PROT_CTRL_CTS
;
3136 ofdm_prot
|= RT2860_REG_PROT_CTRL_NONE
;
3140 RT2860_DPRINTF(sc
, RT2860_DEBUG_PROT
,
3141 "%s: updating protection mode: b/g protection mode=%s\n",
3142 device_get_nameunit(sc
->dev
), "none");
3144 ofdm_prot
|= RT2860_REG_PROT_CTRL_NONE
;
3147 rt2860_io_mac_write(sc
, RT2860_REG_TX_OFDM_PROT_CFG
, ofdm_prot
);
3149 /* HT frame protection */
3151 if ((vap
->iv_opmode
== IEEE80211_M_STA
) && (vap
->iv_state
== IEEE80211_S_RUN
))
3152 htopmode
= vap
->iv_bss
->ni_htopmode
;
3154 htopmode
= ic
->ic_curhtprotmode
;
3156 RT2860_DPRINTF(sc
, RT2860_DEBUG_PROT
,
3157 "%s: updating protection mode: HT operation mode=0x%02x, protection mode=%s\n",
3158 device_get_nameunit(sc
->dev
),
3159 htopmode
& IEEE80211_HTINFO_OPMODE
,
3160 (ic
->ic_htprotmode
== IEEE80211_PROT_RTSCTS
) ? "RTS/CTS" :
3161 ((ic
->ic_htprotmode
== IEEE80211_PROT_CTSONLY
) ? "CTS-to-self" : "none"));
3163 switch (htopmode
& IEEE80211_HTINFO_OPMODE
)
3165 /* IEEE80211_HTINFO_OPMODE_HT20PR */
3166 case IEEE80211_HTINFO_OPMODE_HT20PR
:
3167 mm20_prot
= RT2860_REG_PROT_NAV_SHORT
| RT2860_REG_PROT_CTRL_NONE
|
3168 RT2860_REG_TXOP_ALLOW_CCK
| RT2860_REG_TXOP_ALLOW_OFDM
|
3169 RT2860_REG_TXOP_ALLOW_MM20
| RT2860_REG_TXOP_ALLOW_GF20
|
3170 (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3171 (4 << RT2860_REG_PROT_MCS_SHIFT
);
3173 gf20_prot
= mm20_prot
;
3175 mm40_prot
= RT2860_REG_PROT_NAV_SHORT
| RT2860_REG_TXOP_ALLOW_ALL
|
3176 (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3177 (0x84 << RT2860_REG_PROT_MCS_SHIFT
);
3179 if (ic
->ic_htprotmode
== IEEE80211_PROT_RTSCTS
)
3180 mm40_prot
|= RT2860_REG_PROT_CTRL_RTS_CTS
;
3181 else if (ic
->ic_htprotmode
== IEEE80211_PROT_CTSONLY
)
3182 mm40_prot
|= RT2860_REG_PROT_CTRL_CTS
;
3184 mm40_prot
|= RT2860_REG_PROT_CTRL_NONE
;
3186 gf40_prot
= mm40_prot
;
3189 /* IEEE80211_HTINFO_OPMODE_MIXED */
3190 case IEEE80211_HTINFO_OPMODE_MIXED
:
3191 mm20_prot
= RT2860_REG_PROT_NAV_SHORT
|
3192 RT2860_REG_TXOP_ALLOW_CCK
| RT2860_REG_TXOP_ALLOW_OFDM
|
3193 RT2860_REG_TXOP_ALLOW_MM20
| RT2860_REG_TXOP_ALLOW_GF20
;
3195 if (ic
->ic_flags
& IEEE80211_F_USEPROT
)
3196 mm20_prot
|= (RT2860_REG_PROT_PHYMODE_CCK
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3197 (3 << RT2860_REG_PROT_MCS_SHIFT
);
3199 mm20_prot
|= (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3200 (4 << RT2860_REG_PROT_MCS_SHIFT
);
3202 if (ic
->ic_htprotmode
== IEEE80211_PROT_RTSCTS
)
3203 mm20_prot
|= RT2860_REG_PROT_CTRL_RTS_CTS
;
3204 else if (ic
->ic_htprotmode
== IEEE80211_PROT_CTSONLY
)
3205 mm20_prot
|= RT2860_REG_PROT_CTRL_CTS
;
3207 mm20_prot
|= RT2860_REG_PROT_CTRL_NONE
;
3209 gf20_prot
= mm20_prot
;
3211 mm40_prot
= RT2860_REG_PROT_NAV_SHORT
| RT2860_REG_TXOP_ALLOW_ALL
;
3213 if (ic
->ic_flags
& IEEE80211_F_USEPROT
)
3214 mm40_prot
|= (RT2860_REG_PROT_PHYMODE_CCK
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3215 (3 << RT2860_REG_PROT_MCS_SHIFT
);
3217 mm40_prot
|= (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3218 (0x84 << RT2860_REG_PROT_MCS_SHIFT
);
3220 if (ic
->ic_htprotmode
== IEEE80211_PROT_RTSCTS
)
3221 mm40_prot
|= RT2860_REG_PROT_CTRL_RTS_CTS
;
3222 else if (ic
->ic_htprotmode
== IEEE80211_PROT_CTSONLY
)
3223 mm40_prot
|= RT2860_REG_PROT_CTRL_CTS
;
3225 mm40_prot
|= RT2860_REG_PROT_CTRL_NONE
;
3227 gf40_prot
= mm40_prot
;
3231 * IEEE80211_HTINFO_OPMODE_PURE
3232 * IEEE80211_HTINFO_OPMODE_PROTOPT
3234 case IEEE80211_HTINFO_OPMODE_PURE
:
3235 case IEEE80211_HTINFO_OPMODE_PROTOPT
:
3237 mm20_prot
= RT2860_REG_PROT_NAV_SHORT
| RT2860_REG_PROT_CTRL_NONE
|
3238 RT2860_REG_TXOP_ALLOW_CCK
| RT2860_REG_TXOP_ALLOW_OFDM
|
3239 RT2860_REG_TXOP_ALLOW_MM20
| RT2860_REG_TXOP_ALLOW_GF20
|
3240 (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3241 (4 << RT2860_REG_PROT_MCS_SHIFT
);
3243 gf20_prot
= mm20_prot
;
3245 mm40_prot
= RT2860_REG_PROT_NAV_SHORT
| RT2860_REG_PROT_CTRL_NONE
|
3246 RT2860_REG_TXOP_ALLOW_ALL
|
3247 (RT2860_REG_PROT_PHYMODE_OFDM
<< RT2860_REG_PROT_PHYMODE_SHIFT
) |
3248 (0x84 << RT2860_REG_PROT_MCS_SHIFT
);
3250 gf40_prot
= mm40_prot
;
3254 rt2860_io_mac_write(sc
, RT2860_REG_TX_MM20_PROT_CFG
, mm20_prot
);
3255 rt2860_io_mac_write(sc
, RT2860_REG_TX_MM40_PROT_CFG
, mm40_prot
);
3256 rt2860_io_mac_write(sc
, RT2860_REG_TX_GF20_PROT_CFG
, gf20_prot
);
3257 rt2860_io_mac_write(sc
, RT2860_REG_TX_GF40_PROT_CFG
, gf40_prot
);
3261 * rt2860_asic_updateslot
3263 static void rt2860_asic_updateslot(struct rt2860_softc
*sc
)
3266 struct ieee80211com
*ic
;
3272 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATE
,
3273 "%s: %s short slot time\n",
3274 device_get_nameunit(sc
->dev
),
3275 (ic
->ic_flags
& IEEE80211_F_SHSLOT
) ? "enabling" : "disabling");
3277 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_BKOFF_SLOT_CFG
);
3280 tmp
|= (ic
->ic_flags
& IEEE80211_F_SHSLOT
) ? 9 : 20;
3282 rt2860_io_mac_write(sc
, RT2860_REG_BKOFF_SLOT_CFG
, tmp
);
3286 * rt2860_asic_wme_update
3288 static void rt2860_asic_wme_update(struct rt2860_softc
*sc
)
3291 struct ieee80211com
*ic
;
3292 struct ieee80211_wme_state
*wme
;
3293 const struct wmeParams
*wmep
;
3299 wmep
= wme
->wme_chanParams
.cap_wmeParams
;
3301 RT2860_DPRINTF(sc
, RT2860_DEBUG_WME
,
3302 "%s: wme update: WME_AC_VO=%d/%d/%d/%d, WME_AC_VI=%d/%d/%d/%d, "
3303 "WME_AC_BK=%d/%d/%d/%d, WME_AC_BE=%d/%d/%d/%d\n",
3304 device_get_nameunit(sc
->dev
),
3305 wmep
[WME_AC_VO
].wmep_aifsn
,
3306 wmep
[WME_AC_VO
].wmep_logcwmin
, wmep
[WME_AC_VO
].wmep_logcwmax
,
3307 wmep
[WME_AC_VO
].wmep_txopLimit
,
3308 wmep
[WME_AC_VI
].wmep_aifsn
,
3309 wmep
[WME_AC_VI
].wmep_logcwmin
, wmep
[WME_AC_VI
].wmep_logcwmax
,
3310 wmep
[WME_AC_VI
].wmep_txopLimit
,
3311 wmep
[WME_AC_BK
].wmep_aifsn
,
3312 wmep
[WME_AC_BK
].wmep_logcwmin
, wmep
[WME_AC_BK
].wmep_logcwmax
,
3313 wmep
[WME_AC_BK
].wmep_txopLimit
,
3314 wmep
[WME_AC_BE
].wmep_aifsn
,
3315 wmep
[WME_AC_BE
].wmep_logcwmin
, wmep
[WME_AC_BE
].wmep_logcwmax
,
3316 wmep
[WME_AC_BE
].wmep_txopLimit
);
3318 for (i
= 0; i
< WME_NUM_AC
; i
++)
3319 rt2860_io_mac_write(sc
, RT2860_REG_TX_EDCA_AC_CFG(i
),
3320 (wmep
[i
].wmep_logcwmax
<< 16) | (wmep
[i
].wmep_logcwmin
<< 12) |
3321 (wmep
[i
].wmep_aifsn
<< 8) | wmep
[i
].wmep_txopLimit
);
3323 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_AIFSN_CFG
,
3324 (wmep
[WME_AC_VO
].wmep_aifsn
<< 12) | (wmep
[WME_AC_VI
].wmep_aifsn
<< 8) |
3325 (wmep
[WME_AC_BK
].wmep_aifsn
<< 4) | wmep
[WME_AC_BE
].wmep_aifsn
);
3327 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_CWMIN_CFG
,
3328 (wmep
[WME_AC_VO
].wmep_logcwmin
<< 12) | (wmep
[WME_AC_VI
].wmep_logcwmin
<< 8) |
3329 (wmep
[WME_AC_BK
].wmep_logcwmin
<< 4) | wmep
[WME_AC_BE
].wmep_logcwmin
);
3331 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_CWMAX_CFG
,
3332 (wmep
[WME_AC_VO
].wmep_logcwmax
<< 12) | (wmep
[WME_AC_VI
].wmep_logcwmax
<< 8) |
3333 (wmep
[WME_AC_BK
].wmep_logcwmax
<< 4) | wmep
[WME_AC_BE
].wmep_logcwmax
);
3335 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_TXOP0_CFG
,
3336 (wmep
[WME_AC_BK
].wmep_txopLimit
<< 16) | wmep
[WME_AC_BE
].wmep_txopLimit
);
3338 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WMM_TXOP1_CFG
,
3339 (wmep
[WME_AC_VO
].wmep_txopLimit
<< 16) | wmep
[WME_AC_VI
].wmep_txopLimit
);
3343 * rt2860_asic_update_beacon
3345 static int rt2860_asic_update_beacon(struct rt2860_softc
*sc
,
3346 struct ieee80211vap
*vap
)
3349 struct ieee80211com
*ic
;
3350 struct rt2860_softc_vap
*rvap
;
3351 const struct ieee80211_txparam
*tp
;
3353 struct rt2860_txwi txwi
;
3359 rvap
= (struct rt2860_softc_vap
*) vap
;
3360 tp
= &vap
->iv_txparms
[ieee80211_chan2mode(ic
->ic_bsschan
)];
3362 m
= ieee80211_beacon_alloc(vap
->iv_bss
, &rvap
->beacon_offsets
);
3366 rate
= tp
->mgmtrate
;
3367 mcs
= rt2860_rate2mcs(rate
);
3369 memset(&txwi
, 0, sizeof(struct rt2860_txwi
));
3372 txwi
.pid_mpdu_len
= ((htole16(m
->m_pkthdr
.len
) & RT2860_TXWI_MPDU_LEN_MASK
) <<
3373 RT2860_TXWI_MPDU_LEN_SHIFT
);
3374 txwi
.txop
= (RT2860_TXWI_TXOP_HT
<< RT2860_TXWI_TXOP_SHIFT
);
3375 txwi
.mpdu_density_flags
|=
3376 (RT2860_TXWI_FLAGS_TS
<< RT2860_TXWI_FLAGS_SHIFT
);
3377 txwi
.bawin_size_xflags
|=
3378 (RT2860_TXWI_XFLAGS_NSEQ
<< RT2860_TXWI_XFLAGS_SHIFT
);
3380 if (ieee80211_rate2phytype(ic
->ic_rt
, rate
) != IEEE80211_T_OFDM
)
3382 txwi
.phymode_ifs_stbc_shortgi
=
3383 (RT2860_TXWI_PHYMODE_CCK
<< RT2860_TXWI_PHYMODE_SHIFT
);
3385 if (rate
!= 2 && (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
))
3386 mcs
|= RT2860_TXWI_MCS_SHOTPRE
;
3390 txwi
.phymode_ifs_stbc_shortgi
=
3391 (RT2860_TXWI_PHYMODE_OFDM
<< RT2860_TXWI_PHYMODE_SHIFT
);
3394 txwi
.bw_mcs
= (RT2860_TXWI_BW_20
<< RT2860_TXWI_BW_SHIFT
) |
3395 ((mcs
& RT2860_TXWI_MCS_MASK
) << RT2860_TXWI_MCS_SHIFT
);
3397 /* disable temporarily TSF sync */
3399 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_BCN_TIME_CFG
);
3401 tmp
&= ~(RT2860_REG_BCN_TX_ENABLE
|
3402 RT2860_REG_TSF_TIMER_ENABLE
|
3403 RT2860_REG_TBTT_TIMER_ENABLE
);
3405 rt2860_io_mac_write(sc
, RT2860_REG_BCN_TIME_CFG
, tmp
);
3407 /* write Tx wireless info and beacon frame to on-chip memory */
3409 rt2860_io_mac_write_multi(sc
, RT2860_REG_BEACON_BASE(0),
3410 &txwi
, sizeof(struct rt2860_txwi
));
3412 rt2860_io_mac_write_multi(sc
, RT2860_REG_BEACON_BASE(0) + sizeof(struct rt2860_txwi
),
3413 mtod(m
, uint8_t *), m
->m_pkthdr
.len
);
3415 /* enable again TSF sync */
3417 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_BCN_TIME_CFG
);
3419 tmp
|= (RT2860_REG_BCN_TX_ENABLE
|
3420 RT2860_REG_TSF_TIMER_ENABLE
|
3421 RT2860_REG_TBTT_TIMER_ENABLE
);
3423 rt2860_io_mac_write(sc
, RT2860_REG_BCN_TIME_CFG
, tmp
);
3431 * rt2860_asic_clear_keytables
3433 static void rt2860_asic_clear_keytables(struct rt2860_softc
*sc
)
3435 /* clear Rx WCID search table (entries = 256, entry size = 8) */
3437 rt2860_io_mac_set_region_4(sc
, RT2860_REG_WCID(0), 0, 2 * 256);
3439 /* clear WCID attribute table (entries = 256, entry size = 4) */
3441 rt2860_io_mac_set_region_4(sc
, RT2860_REG_WCID_ATTR(0), 0, 256);
3443 /* clear IV/EIV table (entries = 256, entry size = 8) */
3445 rt2860_io_mac_set_region_4(sc
, RT2860_REG_IVEIV(0), 0, 2 * 256);
3447 /* clear pairwise key table (entries = 256, entry size = 32) */
3449 rt2860_io_mac_set_region_4(sc
, RT2860_REG_PKEY(0), 0, 8 * 256);
3451 /* clear shared key table (entries = 32, entry size = 32) */
3453 rt2860_io_mac_set_region_4(sc
, RT2860_REG_SKEY(0, 0), 0, 8 * 32);
3455 /* clear shared key mode (entries = 32, entry size = 2) */
3457 rt2860_io_mac_set_region_4(sc
, RT2860_REG_SKEY_MODE(0), 0, 16);
3463 static uint8_t rt2860_rxrate(struct rt2860_rxwi
*rxwi
)
3465 uint8_t mcs
, phymode
;
3468 mcs
= (rxwi
->bw_mcs
>> RT2860_RXWI_MCS_SHIFT
) & RT2860_RXWI_MCS_MASK
;
3469 phymode
= (rxwi
->phymode_stbc_shortgi
>> RT2860_RXWI_PHYMODE_SHIFT
) &
3470 RT2860_RXWI_PHYMODE_MASK
;
3476 case RT2860_RXWI_PHYMODE_CCK
:
3477 switch (mcs
& ~RT2860_RXWI_MCS_SHOTPRE
)
3479 case 0: rate
= 2; break; /* 1 Mbps */
3480 case 1: rate
= 4; break; /* 2 MBps */
3481 case 2: rate
= 11; break; /* 5.5 Mbps */
3482 case 3: rate
= 22; break; /* 11 Mbps */
3486 case RT2860_RXWI_PHYMODE_OFDM
:
3489 case 0: rate
= 12; break; /* 6 Mbps */
3490 case 1: rate
= 18; break; /* 9 Mbps */
3491 case 2: rate
= 24; break; /* 12 Mbps */
3492 case 3: rate
= 36; break; /* 18 Mbps */
3493 case 4: rate
= 48; break; /* 24 Mbps */
3494 case 5: rate
= 72; break; /* 36 Mbps */
3495 case 6: rate
= 96; break; /* 48 Mbps */
3496 case 7: rate
= 108; break; /* 54 Mbps */
3500 case RT2860_RXWI_PHYMODE_HT_MIXED
:
3501 case RT2860_RXWI_PHYMODE_HT_GF
:
3509 * rt2860_maxrssi_rxpath
3511 static uint8_t rt2860_maxrssi_rxpath(struct rt2860_softc
*sc
,
3512 const struct rt2860_rxwi
*rxwi
)
3518 if (sc
->nrxpath
> 1)
3519 if (rxwi
->rssi
[1] > rxwi
->rssi
[rxpath
])
3522 if (sc
->nrxpath
> 2)
3523 if (rxwi
->rssi
[2] > rxwi
->rssi
[rxpath
])
3532 static int8_t rt2860_rssi2dbm(struct rt2860_softc
*sc
,
3533 uint8_t rssi
, uint8_t rxpath
)
3536 struct ieee80211com
*ic
;
3537 struct ieee80211_channel
*c
;
3543 chan
= ieee80211_chan2ieee(ic
, c
);
3545 if (IEEE80211_IS_CHAN_5GHZ(c
))
3547 delta
= sc
->rssi_off_5ghz
[rxpath
];
3550 delta
-= sc
->lna_gain
[1];
3551 else if (chan
<= 128)
3552 delta
-= sc
->lna_gain
[2];
3554 delta
-= sc
->lna_gain
[3];
3558 delta
= sc
->rssi_off_2ghz
[rxpath
] - sc
->lna_gain
[0];
3561 return (-12 - delta
- rssi
);
3567 static uint8_t rt2860_rate2mcs(uint8_t rate
)
3594 static int rt2860_tx_mgmt(struct rt2860_softc
*sc
,
3595 struct mbuf
*m
, struct ieee80211_node
*ni
, int qid
)
3598 struct ieee80211com
*ic
;
3599 struct ieee80211vap
*vap
;
3600 const struct ieee80211_txparam
*tp
;
3601 struct rt2860_softc_node
*rni
;
3602 struct rt2860_softc_tx_ring
*ring
;
3603 struct rt2860_softc_tx_data
*data
;
3604 struct rt2860_txdesc
*desc
;
3605 struct rt2860_txwi
*txwi
;
3606 struct ieee80211_frame
*wh
;
3607 struct rt2860_softc_tx_radiotap_header
*tap
;
3608 bus_dma_segment_t dma_seg
[RT2860_SOFTC_MAX_SCATTER
];
3609 u_int hdrsize
, hdrspace
;
3610 uint8_t rate
, stbc
, shortgi
, mcs
, pid
, qsel
;
3611 uint16_t len
, dmalen
, mpdu_len
, dur
;
3612 int error
, ndmasegs
, ndescs
, i
, j
;
3614 KASSERT(qid
>= 0 && qid
< RT2860_SOFTC_TX_RING_COUNT
,
3615 ("%s: Tx MGMT: invalid qid=%d\n",
3616 device_get_nameunit(sc
->dev
), qid
));
3621 rni
= (struct rt2860_softc_node
*) ni
;
3622 tp
= &vap
->iv_txparms
[ieee80211_chan2mode(ic
->ic_curchan
)];
3624 ring
= &sc
->tx_ring
[qid
];
3625 desc
= &ring
->desc
[ring
->desc_cur
];
3626 data
= &ring
->data
[ring
->data_cur
];
3627 txwi
= (struct rt2860_txwi
*) (ring
->seg0
+ ring
->data_cur
* RT2860_TX_DATA_SEG0_SIZE
);
3629 wh
= mtod(m
, struct ieee80211_frame
*);
3631 rate
= tp
->mgmtrate
& IEEE80211_RATE_VAL
;
3633 /* fill Tx wireless info */
3635 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
3638 mcs
= rt2860_rate2mcs(rate
);
3642 /* calculate MPDU length without padding */
3644 hdrsize
= ieee80211_hdrsize(wh
);
3645 hdrspace
= ieee80211_hdrspace(ic
, wh
);
3646 mpdu_len
= m
->m_pkthdr
.len
- hdrspace
+ hdrsize
;
3648 memset(txwi
, 0, sizeof(struct rt2860_txwi
));
3650 /* management frames do not need encryption */
3654 txwi
->pid_mpdu_len
= ((htole16(pid
) & RT2860_TXWI_PID_MASK
) <<
3655 RT2860_TXWI_PID_SHIFT
) | ((htole16(mpdu_len
) & RT2860_TXWI_MPDU_LEN_MASK
) <<
3656 RT2860_TXWI_MPDU_LEN_SHIFT
);
3658 stbc
= (ni
->ni_htcap
& IEEE80211_HTCAP_RXSTBC
) ? 1 : 0;
3660 shortgi
= (vap
->iv_flags_ht
& (IEEE80211_FHT_SHORTGI20
| IEEE80211_FHT_SHORTGI40
)) &&
3661 (ni
->ni_flags
& IEEE80211_NODE_HT
);
3663 txwi
->phymode_ifs_stbc_shortgi
|=
3664 ((stbc
& RT2860_TXWI_STBC_MASK
) << RT2860_TXWI_STBC_SHIFT
) |
3665 ((shortgi
& RT2860_TXWI_SHORTGI_MASK
) << RT2860_TXWI_SHORTGI_SHIFT
);
3667 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
3669 txwi
->phymode_ifs_stbc_shortgi
|=
3670 (RT2860_TXWI_PHYMODE_HT_MIXED
<< RT2860_TXWI_PHYMODE_SHIFT
);
3674 if (ieee80211_rate2phytype(ic
->ic_rt
, rate
) != IEEE80211_T_OFDM
)
3676 txwi
->phymode_ifs_stbc_shortgi
|=
3677 (RT2860_TXWI_PHYMODE_CCK
<< RT2860_TXWI_PHYMODE_SHIFT
);
3679 if (rate
!= 2 && (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
))
3680 mcs
|= RT2860_TXWI_MCS_SHOTPRE
;
3684 txwi
->phymode_ifs_stbc_shortgi
|=
3685 (RT2860_TXWI_PHYMODE_OFDM
<< RT2860_TXWI_PHYMODE_SHIFT
);
3689 txwi
->bw_mcs
= (RT2860_TXWI_BW_20
<< RT2860_TXWI_BW_SHIFT
) |
3690 ((mcs
& RT2860_TXWI_MCS_MASK
) << RT2860_TXWI_MCS_SHIFT
);
3692 txwi
->txop
= (RT2860_TXWI_TXOP_BACKOFF
<< RT2860_TXWI_TXOP_SHIFT
);
3694 /* skip ACKs for multicast frames and probe responses */
3696 if (!IEEE80211_IS_MULTICAST(wh
->i_addr1
) &&
3697 ((wh
->i_fc
[0] & (IEEE80211_FC0_TYPE_MASK
| IEEE80211_FC0_SUBTYPE_MASK
)) !=
3698 (IEEE80211_FC0_TYPE_MGT
| IEEE80211_FC0_SUBTYPE_PROBE_RESP
)))
3700 txwi
->bawin_size_xflags
|=
3701 (RT2860_TXWI_XFLAGS_ACK
<< RT2860_TXWI_XFLAGS_SHIFT
);
3703 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
3705 /* preamble + plcp + signal extension */
3711 dur
= ieee80211_ack_duration(ic
->ic_rt
, rate
,
3712 ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
);
3715 *(uint16_t *) wh
->i_dur
= htole16(dur
);
3718 /* ask MAC to insert timestamp into probe responses */
3720 if ((wh
->i_fc
[0] & (IEEE80211_FC0_TYPE_MASK
| IEEE80211_FC0_SUBTYPE_MASK
)) ==
3721 (IEEE80211_FC0_TYPE_MGT
| IEEE80211_FC0_SUBTYPE_PROBE_RESP
))
3722 txwi
->mpdu_density_flags
|=
3723 (RT2860_TXWI_FLAGS_TS
<< RT2860_TXWI_FLAGS_SHIFT
);
3725 if (ieee80211_radiotap_active_vap(vap
))
3729 tap
->flags
= IEEE80211_RADIOTAP_F_DATAPAD
;
3730 tap
->chan_flags
= htole32(ic
->ic_curchan
->ic_flags
);
3731 tap
->chan_freq
= htole16(ic
->ic_curchan
->ic_freq
);
3732 tap
->chan_ieee
= ic
->ic_curchan
->ic_ieee
;
3733 tap
->chan_maxpow
= 0;
3735 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
3736 tap
->rate
= mcs
| IEEE80211_RATE_MCS
;
3740 if (mcs
& RT2860_TXWI_MCS_SHOTPRE
)
3741 tap
->flags
|= IEEE80211_RADIOTAP_F_SHORTPRE
;
3744 tap
->flags
|= IEEE80211_RADIOTAP_F_SHORTGI
;
3746 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
)
3747 tap
->flags
|= IEEE80211_RADIOTAP_F_WEP
;
3749 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
)
3751 wh
->i_fc
[1] &= ~IEEE80211_FC1_WEP
;
3753 ieee80211_radiotap_tx(vap
, m
);
3755 wh
->i_fc
[1] |= IEEE80211_FC1_WEP
;
3759 ieee80211_radiotap_tx(vap
, m
);
3763 /* copy and trim 802.11 header */
3765 m_copydata(m
, 0, hdrsize
, (caddr_t
) (txwi
+ 1));
3768 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
, m
,
3769 dma_seg
, &ndmasegs
, 0);
3772 /* too many fragments, linearize */
3774 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
3775 "%s: could not load mbuf DMA map, trying to linearize mbuf\n",
3776 device_get_nameunit(sc
->dev
));
3778 m
= m_defrag(m
, M_DONTWAIT
);
3782 sc
->tx_defrag_packets
++;
3784 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
, m
,
3785 dma_seg
, &ndmasegs
, 0);
3788 printf("%s: could not load mbuf DMA map: error=%d\n",
3789 device_get_nameunit(sc
->dev
), error
);
3795 /* determine how many Tx descs are required */
3797 ndescs
= 1 + ndmasegs
/ 2;
3798 if ((ring
->desc_queued
+ ndescs
) > (RT2860_SOFTC_TX_RING_DESC_COUNT
- 2))
3800 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
3801 "%s: there are not enough Tx descs\n",
3802 device_get_nameunit(sc
->dev
));
3804 sc
->no_tx_desc_avail
++;
3806 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
3814 /* set up Tx descs */
3816 /* first segment is Tx wireless info and 802.11 header */
3818 len
= sizeof(struct rt2860_txwi
) + hdrsize
;
3820 /* align end on a 4-bytes boundary */
3822 dmalen
= (len
+ 3) & ~ 3;
3824 memset((caddr_t
) txwi
+ len
, 0, dmalen
- len
);
3826 qsel
= RT2860_TXDESC_QSEL_EDCA
;
3828 desc
->sdp0
= htole32(ring
->seg0_phys_addr
+ ring
->data_cur
* RT2860_TX_DATA_SEG0_SIZE
);
3829 desc
->sdl0
= htole16(dmalen
);
3830 desc
->qsel_flags
= (qsel
<< RT2860_TXDESC_QSEL_SHIFT
);
3832 /* set up payload segments */
3834 for (i
= ndmasegs
, j
= 0; i
>= 2; i
-= 2)
3836 desc
->sdp1
= htole32(dma_seg
[j
].ds_addr
);
3837 desc
->sdl1
= htole16(dma_seg
[j
].ds_len
);
3839 ring
->desc_queued
++;
3840 ring
->desc_cur
= (ring
->desc_cur
+ 1) % RT2860_SOFTC_TX_RING_DESC_COUNT
;
3844 desc
= &ring
->desc
[ring
->desc_cur
];
3846 desc
->sdp0
= htole32(dma_seg
[j
].ds_addr
);
3847 desc
->sdl0
= htole16(dma_seg
[j
].ds_len
);
3848 desc
->qsel_flags
= (qsel
<< RT2860_TXDESC_QSEL_SHIFT
);
3853 /* finalize last payload segment */
3857 desc
->sdp1
= htole32(dma_seg
[j
].ds_addr
);
3858 desc
->sdl1
= htole16(dma_seg
[j
].ds_len
| RT2860_TXDESC_SDL1_LASTSEG
);
3862 desc
->sdl0
|= htole16(RT2860_TXDESC_SDL0_LASTSEG
);
3866 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
3867 "%s: sending MGMT frame: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
3868 "stbc=%d, shortgi=%d, mcs=%d, DMA len=%d, ndmasegs=%d, DMA ds_len=%d/%d/%d/%d/%d\n",
3869 device_get_nameunit(sc
->dev
),
3870 qid
, hdrsize
, hdrspace
, m
->m_pkthdr
.len
+ hdrsize
,
3871 stbc
, shortgi
, mcs
, dmalen
, ndmasegs
,
3872 dma_seg
[0].ds_len
, dma_seg
[1].ds_len
, dma_seg
[2].ds_len
, dma_seg
[3].ds_len
, dma_seg
[4].ds_len
);
3874 bus_dmamap_sync(ring
->seg0_dma_tag
, ring
->seg0_dma_map
,
3875 BUS_DMASYNC_PREWRITE
);
3876 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
3877 BUS_DMASYNC_PREWRITE
);
3878 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
3879 BUS_DMASYNC_PREWRITE
);
3881 ring
->desc_queued
++;
3882 ring
->desc_cur
= (ring
->desc_cur
+ 1) % RT2860_SOFTC_TX_RING_DESC_COUNT
;
3884 ring
->data_queued
++;
3885 ring
->data_cur
= (ring
->data_cur
+ 1) % RT2860_SOFTC_TX_RING_DATA_COUNT
;
3889 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_CTX_IDX(qid
), ring
->desc_cur
);
3897 static int rt2860_tx_data(struct rt2860_softc
*sc
,
3898 struct mbuf
*m
, struct ieee80211_node
*ni
, int qid
)
3901 struct ieee80211com
*ic
;
3902 struct ieee80211vap
*vap
;
3903 const struct ieee80211_txparam
*tp
;
3904 struct rt2860_softc_node
*rni
;
3905 struct rt2860_softc_tx_ring
*ring
;
3906 struct rt2860_softc_tx_data
*data
;
3907 struct rt2860_txdesc
*desc
;
3908 struct rt2860_txwi
*txwi
;
3909 struct ieee80211_frame
*wh
;
3910 struct rt2860_softc_tx_radiotap_header
*tap
;
3911 bus_dma_segment_t dma_seg
[RT2860_SOFTC_MAX_SCATTER
];
3912 u_int hdrsize
, hdrspace
;
3913 uint8_t type
, rate
, bw
, stbc
, shortgi
, mcs
, pid
, wcid
, qsel
;
3914 uint16_t qos
, len
, dmalen
, mpdu_len
, dur
;
3915 int error
, hasqos
, ndmasegs
, ndescs
, i
, j
;
3917 KASSERT(qid
>= 0 && qid
< RT2860_SOFTC_TX_RING_COUNT
,
3918 ("%s: Tx data: invalid qid=%d\n",
3919 device_get_nameunit(sc
->dev
), qid
));
3924 rni
= (struct rt2860_softc_node
*) ni
;
3925 tp
= &vap
->iv_txparms
[ieee80211_chan2mode(ni
->ni_chan
)];
3927 ring
= &sc
->tx_ring
[qid
];
3928 desc
= &ring
->desc
[ring
->desc_cur
];
3929 data
= &ring
->data
[ring
->data_cur
];
3930 txwi
= (struct rt2860_txwi
*) (ring
->seg0
+ ring
->data_cur
* RT2860_TX_DATA_SEG0_SIZE
);
3932 wh
= mtod(m
, struct ieee80211_frame
*);
3934 type
= wh
->i_fc
[0] & IEEE80211_FC0_TYPE_MASK
;
3936 hasqos
= IEEE80211_QOS_HAS_SEQ(wh
);
3939 if (IEEE80211_HAS_ADDR4(wh
))
3940 qos
= le16toh(*(const uint16_t *)
3941 (((struct ieee80211_qosframe_addr4
*) wh
)->i_qos
));
3943 qos
= le16toh(*(const uint16_t *)
3944 (((struct ieee80211_qosframe
*) wh
)->i_qos
));
3951 if (IEEE80211_IS_MULTICAST(wh
->i_addr1
))
3952 rate
= tp
->mcastrate
;
3953 else if (m
->m_flags
& M_EAPOL
)
3954 rate
= tp
->mgmtrate
;
3955 else if (tp
->ucastrate
!= IEEE80211_FIXED_RATE_NONE
)
3956 rate
= tp
->ucastrate
;
3958 rate
= ni
->ni_txrate
;
3960 rate
&= IEEE80211_RATE_VAL
;
3962 /* fill Tx wireless info */
3964 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
3967 mcs
= rt2860_rate2mcs(rate
);
3971 wcid
= (type
== IEEE80211_FC0_TYPE_DATA
) ?
3972 RT2860_AID2WCID(ni
->ni_associd
) : 0xff;
3974 /* calculate MPDU length without padding */
3976 hdrsize
= ieee80211_hdrsize(wh
);
3977 hdrspace
= ieee80211_hdrspace(ic
, wh
);
3978 mpdu_len
= m
->m_pkthdr
.len
- hdrspace
+ hdrsize
;
3980 memset(txwi
, 0, sizeof(struct rt2860_txwi
));
3984 txwi
->pid_mpdu_len
= ((htole16(pid
) & RT2860_TXWI_PID_MASK
) <<
3985 RT2860_TXWI_PID_SHIFT
) | ((htole16(mpdu_len
) & RT2860_TXWI_MPDU_LEN_MASK
) <<
3986 RT2860_TXWI_MPDU_LEN_SHIFT
);
3988 stbc
= (ni
->ni_htcap
& IEEE80211_HTCAP_RXSTBC
) ? 1 : 0;
3990 shortgi
= (vap
->iv_flags_ht
& (IEEE80211_FHT_SHORTGI20
| IEEE80211_FHT_SHORTGI40
)) &&
3991 (ni
->ni_flags
& IEEE80211_NODE_HT
);
3993 txwi
->phymode_ifs_stbc_shortgi
|=
3994 ((stbc
& RT2860_TXWI_STBC_MASK
) << RT2860_TXWI_STBC_SHIFT
) |
3995 ((shortgi
& RT2860_TXWI_SHORTGI_MASK
) << RT2860_TXWI_SHORTGI_SHIFT
);
3997 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
3999 txwi
->phymode_ifs_stbc_shortgi
|=
4000 (RT2860_TXWI_PHYMODE_HT_MIXED
<< RT2860_TXWI_PHYMODE_SHIFT
);
4004 if (ieee80211_rate2phytype(ic
->ic_rt
, rate
) != IEEE80211_T_OFDM
)
4006 txwi
->phymode_ifs_stbc_shortgi
|=
4007 (RT2860_TXWI_PHYMODE_CCK
<< RT2860_TXWI_PHYMODE_SHIFT
);
4009 if (rate
!= 2 && (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
))
4010 mcs
|= RT2860_TXWI_MCS_SHOTPRE
;
4014 txwi
->phymode_ifs_stbc_shortgi
|=
4015 (RT2860_TXWI_PHYMODE_OFDM
<< RT2860_TXWI_PHYMODE_SHIFT
);
4019 if ((ni
->ni_flags
& IEEE80211_NODE_HT
) &&
4020 (ni
->ni_htcap
& IEEE80211_HTCAP_CHWIDTH40
))
4021 bw
= RT2860_TXWI_BW_40
;
4023 bw
= RT2860_TXWI_BW_20
;
4025 txwi
->bw_mcs
= ((bw
& RT2860_TXWI_BW_MASK
) << RT2860_TXWI_BW_SHIFT
) |
4026 ((mcs
& RT2860_TXWI_MCS_MASK
) << RT2860_TXWI_MCS_SHIFT
);
4028 txwi
->txop
= (RT2860_TXWI_TXOP_HT
<< RT2860_TXWI_TXOP_SHIFT
);
4030 if (!IEEE80211_IS_MULTICAST(wh
->i_addr1
) &&
4031 (!hasqos
|| (qos
& IEEE80211_QOS_ACKPOLICY
) != IEEE80211_QOS_ACKPOLICY_NOACK
))
4033 txwi
->bawin_size_xflags
|=
4034 (RT2860_TXWI_XFLAGS_ACK
<< RT2860_TXWI_XFLAGS_SHIFT
);
4036 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
4038 /* preamble + plcp + signal extension */
4044 dur
= ieee80211_ack_duration(ic
->ic_rt
, rate
,
4045 ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
);
4048 *(uint16_t *) wh
->i_dur
= htole16(dur
);
4051 /* ask MAC to insert timestamp into probe responses */
4053 if ((wh
->i_fc
[0] & (IEEE80211_FC0_TYPE_MASK
| IEEE80211_FC0_SUBTYPE_MASK
)) ==
4054 (IEEE80211_FC0_TYPE_MGT
| IEEE80211_FC0_SUBTYPE_PROBE_RESP
))
4055 txwi
->mpdu_density_flags
|=
4056 (RT2860_TXWI_FLAGS_TS
<< RT2860_TXWI_FLAGS_SHIFT
);
4058 if (ieee80211_radiotap_active_vap(vap
))
4062 tap
->flags
= IEEE80211_RADIOTAP_F_DATAPAD
;
4063 tap
->chan_flags
= htole32(ic
->ic_curchan
->ic_flags
);
4064 tap
->chan_freq
= htole16(ic
->ic_curchan
->ic_freq
);
4065 tap
->chan_ieee
= ic
->ic_curchan
->ic_ieee
;
4066 tap
->chan_maxpow
= 0;
4068 if (ni
->ni_flags
& IEEE80211_NODE_HT
)
4069 tap
->rate
= mcs
| IEEE80211_RATE_MCS
;
4073 if (mcs
& RT2860_TXWI_MCS_SHOTPRE
)
4074 tap
->flags
|= IEEE80211_RADIOTAP_F_SHORTPRE
;
4077 tap
->flags
|= IEEE80211_RADIOTAP_F_SHORTGI
;
4079 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
)
4080 tap
->flags
|= IEEE80211_RADIOTAP_F_WEP
;
4082 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
)
4084 wh
->i_fc
[1] &= ~IEEE80211_FC1_WEP
;
4086 ieee80211_radiotap_tx(vap
, m
);
4088 wh
->i_fc
[1] |= IEEE80211_FC1_WEP
;
4092 ieee80211_radiotap_tx(vap
, m
);
4096 /* copy and trim 802.11 header */
4098 m_copydata(m
, 0, hdrsize
, (caddr_t
) (txwi
+ 1));
4101 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
, m
,
4102 dma_seg
, &ndmasegs
, 0);
4105 /* too many fragments, linearize */
4107 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
4108 "%s: could not load mbuf DMA map, trying to linearize mbuf\n",
4109 device_get_nameunit(sc
->dev
));
4111 m
= m_defrag(m
, M_DONTWAIT
);
4115 sc
->tx_defrag_packets
++;
4117 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
, m
,
4118 dma_seg
, &ndmasegs
, 0);
4121 printf("%s: could not load mbuf DMA map: error=%d\n",
4122 device_get_nameunit(sc
->dev
), error
);
4128 /* determine how many Tx descs are required */
4130 ndescs
= 1 + ndmasegs
/ 2;
4131 if ((ring
->desc_queued
+ ndescs
) > (RT2860_SOFTC_TX_RING_DESC_COUNT
- 2))
4133 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
4134 "%s: there are not enough Tx descs\n",
4135 device_get_nameunit(sc
->dev
));
4137 sc
->no_tx_desc_avail
++;
4139 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
4147 /* set up Tx descs */
4149 /* first segment is Tx wireless info and 802.11 header */
4151 len
= sizeof(struct rt2860_txwi
) + hdrsize
;
4153 /* align end on a 4-bytes boundary */
4155 dmalen
= (len
+ 3) & ~ 3;
4157 memset((caddr_t
) txwi
+ len
, 0, dmalen
- len
);
4159 qsel
= RT2860_TXDESC_QSEL_EDCA
;
4161 desc
->sdp0
= htole32(ring
->seg0_phys_addr
+ ring
->data_cur
* RT2860_TX_DATA_SEG0_SIZE
);
4162 desc
->sdl0
= htole16(dmalen
);
4163 desc
->qsel_flags
= (qsel
<< RT2860_TXDESC_QSEL_SHIFT
);
4165 /* set up payload segments */
4167 for (i
= ndmasegs
, j
= 0; i
>= 2; i
-= 2)
4169 desc
->sdp1
= htole32(dma_seg
[j
].ds_addr
);
4170 desc
->sdl1
= htole16(dma_seg
[j
].ds_len
);
4172 ring
->desc_queued
++;
4173 ring
->desc_cur
= (ring
->desc_cur
+ 1) % RT2860_SOFTC_TX_RING_DESC_COUNT
;
4177 desc
= &ring
->desc
[ring
->desc_cur
];
4179 desc
->sdp0
= htole32(dma_seg
[j
].ds_addr
);
4180 desc
->sdl0
= htole16(dma_seg
[j
].ds_len
);
4181 desc
->qsel_flags
= (qsel
<< RT2860_TXDESC_QSEL_SHIFT
);
4186 /* finalize last payload segment */
4190 desc
->sdp1
= htole32(dma_seg
[j
].ds_addr
);
4191 desc
->sdl1
= htole16(dma_seg
[j
].ds_len
| RT2860_TXDESC_SDL1_LASTSEG
);
4195 desc
->sdl0
|= htole16(RT2860_TXDESC_SDL0_LASTSEG
);
4199 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
4200 "%s: sending data: qid=%d, hdrsize=%d, hdrspace=%d, len=%d, "
4201 "bw=%d, stbc=%d, shortgi=%d, mcs=%d, wcid=0x%02x, DMA len=%d, ndmasegs=%d, DMA ds_len=%d/%d/%d/%d/%d\n",
4202 device_get_nameunit(sc
->dev
),
4203 qid
, hdrsize
, hdrspace
, m
->m_pkthdr
.len
+ hdrsize
,
4204 bw
, stbc
, shortgi
, mcs
, wcid
, dmalen
, ndmasegs
,
4205 dma_seg
[0].ds_len
, dma_seg
[1].ds_len
, dma_seg
[2].ds_len
, dma_seg
[3].ds_len
, dma_seg
[4].ds_len
);
4207 bus_dmamap_sync(ring
->seg0_dma_tag
, ring
->seg0_dma_map
,
4208 BUS_DMASYNC_PREWRITE
);
4209 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
4210 BUS_DMASYNC_PREWRITE
);
4211 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
4212 BUS_DMASYNC_PREWRITE
);
4214 ring
->desc_queued
++;
4215 ring
->desc_cur
= (ring
->desc_cur
+ 1) % RT2860_SOFTC_TX_RING_DESC_COUNT
;
4217 ring
->data_queued
++;
4218 ring
->data_cur
= (ring
->data_cur
+ 1) % RT2860_SOFTC_TX_RING_DATA_COUNT
;
4222 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_CTX_IDX(qid
), ring
->desc_cur
);
4230 static int rt2860_tx_raw(struct rt2860_softc
*sc
,
4231 struct mbuf
*m
, struct ieee80211_node
*ni
,
4232 const struct ieee80211_bpf_params
*params
)
4234 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
4236 device_get_nameunit(sc
->dev
));
4244 static void rt2860_intr(void *arg
)
4246 struct rt2860_softc
*sc
;
4253 /* acknowledge interrupts */
4255 status
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_INT_STATUS
);
4256 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_INT_STATUS
, status
);
4258 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4259 "%s: interrupt: status = 0x%08x\n",
4260 device_get_nameunit(sc
->dev
), status
);
4262 if (status
== 0xffffffff || /* device likely went away */
4263 status
== 0) /* not for us */
4268 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
4271 if (status
& RT2860_REG_INT_TX_COHERENT
)
4272 rt2860_tx_coherent_intr(sc
);
4274 if (status
& RT2860_REG_INT_RX_COHERENT
)
4275 rt2860_rx_coherent_intr(sc
);
4277 if (status
& RT2860_REG_INT_TXRX_COHERENT
)
4278 rt2860_txrx_coherent_intr(sc
);
4280 if (status
& RT2860_REG_INT_FIFO_STA_FULL
)
4281 rt2860_fifo_sta_full_intr(sc
);
4283 if (status
& RT2860_REG_INT_TX_MGMT_DONE
)
4284 rt2860_tx_intr(sc
, 5);
4286 if (status
& RT2860_REG_INT_RX_DONE
)
4289 if (status
& RT2860_REG_INT_RX_DELAY_DONE
)
4290 rt2860_rx_delay_intr(sc
);
4292 if (status
& RT2860_REG_INT_TX_HCCA_DONE
)
4293 rt2860_tx_intr(sc
, 4);
4295 if (status
& RT2860_REG_INT_TX_AC3_DONE
)
4296 rt2860_tx_intr(sc
, 3);
4298 if (status
& RT2860_REG_INT_TX_AC2_DONE
)
4299 rt2860_tx_intr(sc
, 2);
4301 if (status
& RT2860_REG_INT_TX_AC1_DONE
)
4302 rt2860_tx_intr(sc
, 1);
4304 if (status
& RT2860_REG_INT_TX_AC0_DONE
)
4305 rt2860_tx_intr(sc
, 0);
4307 if (status
& RT2860_REG_INT_TX_DELAY_DONE
)
4308 rt2860_tx_delay_intr(sc
);
4310 if (status
& RT2860_REG_INT_PRE_TBTT
)
4311 rt2860_pre_tbtt_intr(sc
);
4313 if (status
& RT2860_REG_INT_TBTT
)
4314 rt2860_tbtt_intr(sc
);
4316 if (status
& RT2860_REG_INT_MCU_CMD
)
4317 rt2860_mcu_cmd_intr(sc
);
4319 if (status
& RT2860_REG_INT_AUTO_WAKEUP
)
4320 rt2860_auto_wakeup_intr(sc
);
4322 if (status
& RT2860_REG_INT_GP_TIMER
)
4323 rt2860_gp_timer_intr(sc
);
4327 * rt2860_tx_coherent_intr
4329 static void rt2860_tx_coherent_intr(struct rt2860_softc
*sc
)
4334 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4335 "%s: Tx coherent interrupt\n",
4336 device_get_nameunit(sc
->dev
));
4338 sc
->tx_coherent_interrupts
++;
4340 /* restart DMA engine */
4342 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
4344 tmp
&= ~(RT2860_REG_TX_WB_DDONE
|
4345 RT2860_REG_RX_DMA_ENABLE
|
4346 RT2860_REG_TX_DMA_ENABLE
);
4348 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
4350 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
4352 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
4353 rt2860_reset_tx_ring(sc
, &sc
->tx_ring
[i
]);
4355 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
4357 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_BASE_PTR(i
),
4358 sc
->tx_ring
[i
].desc_phys_addr
);
4359 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_MAX_CNT(i
),
4360 RT2860_SOFTC_TX_RING_DESC_COUNT
);
4361 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_CTX_IDX(i
), 0);
4366 rt2860_reset_rx_ring(sc
, &sc
->rx_ring
);
4368 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_BASE_PTR
,
4369 sc
->rx_ring
.desc_phys_addr
);
4370 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_MAX_CNT
,
4371 RT2860_SOFTC_RX_RING_DATA_COUNT
);
4372 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_CALC_IDX
,
4373 RT2860_SOFTC_RX_RING_DATA_COUNT
- 1);
4375 rt2860_txrx_enable(sc
);
4379 * rt2860_rx_coherent_intr
4381 static void rt2860_rx_coherent_intr(struct rt2860_softc
*sc
)
4386 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4387 "%s: Rx coherent interrupt\n",
4388 device_get_nameunit(sc
->dev
));
4390 sc
->rx_coherent_interrupts
++;
4392 /* restart DMA engine */
4394 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
4396 tmp
&= ~(RT2860_REG_TX_WB_DDONE
|
4397 RT2860_REG_RX_DMA_ENABLE
|
4398 RT2860_REG_TX_DMA_ENABLE
);
4400 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
4402 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
4404 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
4405 rt2860_reset_tx_ring(sc
, &sc
->tx_ring
[i
]);
4407 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
4409 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_BASE_PTR(i
),
4410 sc
->tx_ring
[i
].desc_phys_addr
);
4411 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_MAX_CNT(i
),
4412 RT2860_SOFTC_TX_RING_DESC_COUNT
);
4413 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_CTX_IDX(i
), 0);
4418 rt2860_reset_rx_ring(sc
, &sc
->rx_ring
);
4420 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_BASE_PTR
,
4421 sc
->rx_ring
.desc_phys_addr
);
4422 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_MAX_CNT
,
4423 RT2860_SOFTC_RX_RING_DATA_COUNT
);
4424 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_CALC_IDX
,
4425 RT2860_SOFTC_RX_RING_DATA_COUNT
- 1);
4427 rt2860_txrx_enable(sc
);
4431 * rt2860_txrx_coherent_intr
4433 static void rt2860_txrx_coherent_intr(struct rt2860_softc
*sc
)
4438 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4439 "%s: Tx/Rx coherent interrupt\n",
4440 device_get_nameunit(sc
->dev
));
4442 sc
->txrx_coherent_interrupts
++;
4444 /* restart DMA engine */
4446 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
4448 tmp
&= ~(RT2860_REG_TX_WB_DDONE
|
4449 RT2860_REG_RX_DMA_ENABLE
|
4450 RT2860_REG_TX_DMA_ENABLE
);
4452 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
4454 /* init Tx rings (4 EDCAs + HCCA + MGMT) */
4456 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
4457 rt2860_reset_tx_ring(sc
, &sc
->tx_ring
[i
]);
4459 for (i
= 0; i
< RT2860_SOFTC_TX_RING_COUNT
; i
++)
4461 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_BASE_PTR(i
),
4462 sc
->tx_ring
[i
].desc_phys_addr
);
4463 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_MAX_CNT(i
),
4464 RT2860_SOFTC_TX_RING_DESC_COUNT
);
4465 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_TX_CTX_IDX(i
), 0);
4470 rt2860_reset_rx_ring(sc
, &sc
->rx_ring
);
4472 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_BASE_PTR
,
4473 sc
->rx_ring
.desc_phys_addr
);
4474 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_MAX_CNT
,
4475 RT2860_SOFTC_RX_RING_DATA_COUNT
);
4476 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_CALC_IDX
,
4477 RT2860_SOFTC_RX_RING_DATA_COUNT
- 1);
4479 rt2860_txrx_enable(sc
);
4483 * rt2860_fifo_sta_full_intr
4485 static void rt2860_fifo_sta_full_intr(struct rt2860_softc
*sc
)
4487 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4488 "%s: FIFO statistic full interrupt\n",
4489 device_get_nameunit(sc
->dev
));
4491 sc
->fifo_sta_full_interrupts
++;
4493 RT2860_SOFTC_LOCK(sc
);
4495 if (!(sc
->intr_disable_mask
& RT2860_REG_INT_FIFO_STA_FULL
))
4497 rt2860_intr_disable(sc
, RT2860_REG_INT_FIFO_STA_FULL
);
4499 taskqueue_enqueue(sc
->taskqueue
, &sc
->fifo_sta_full_task
);
4502 sc
->intr_pending_mask
|= RT2860_REG_INT_FIFO_STA_FULL
;
4504 RT2860_SOFTC_UNLOCK(sc
);
4510 static void rt2860_rx_intr(struct rt2860_softc
*sc
)
4512 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4513 "%s: Rx interrupt\n",
4514 device_get_nameunit(sc
->dev
));
4516 sc
->rx_interrupts
++;
4518 RT2860_SOFTC_LOCK(sc
);
4520 if (!(sc
->intr_disable_mask
& RT2860_REG_INT_RX_DONE
))
4522 rt2860_intr_disable(sc
, RT2860_REG_INT_RX_DONE
);
4524 taskqueue_enqueue(sc
->taskqueue
, &sc
->rx_done_task
);
4527 sc
->intr_pending_mask
|= RT2860_REG_INT_RX_DONE
;
4529 RT2860_SOFTC_UNLOCK(sc
);
4533 * rt2860_rx_delay_intr
4535 static void rt2860_rx_delay_intr(struct rt2860_softc
*sc
)
4537 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4538 "%s: Rx delay interrupt\n",
4539 device_get_nameunit(sc
->dev
));
4541 sc
->rx_delay_interrupts
++;
4547 static void rt2860_tx_intr(struct rt2860_softc
*sc
, int qid
)
4549 KASSERT(qid
>= 0 && qid
< RT2860_SOFTC_TX_RING_COUNT
,
4550 ("%s: Tx interrupt: invalid qid=%d\n",
4551 device_get_nameunit(sc
->dev
), qid
));
4553 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4554 "%s: Tx interrupt: qid=%d\n",
4555 device_get_nameunit(sc
->dev
), qid
);
4557 sc
->tx_interrupts
[qid
]++;
4559 RT2860_SOFTC_LOCK(sc
);
4561 if (!(sc
->intr_disable_mask
& (RT2860_REG_INT_TX_AC0_DONE
<< qid
)))
4563 rt2860_intr_disable(sc
, (RT2860_REG_INT_TX_AC0_DONE
<< qid
));
4565 taskqueue_enqueue(sc
->taskqueue
, &sc
->tx_done_task
);
4568 sc
->intr_pending_mask
|= (RT2860_REG_INT_TX_AC0_DONE
<< qid
);
4570 RT2860_SOFTC_UNLOCK(sc
);
4574 * rt2860_tx_delay_intr
4576 static void rt2860_tx_delay_intr(struct rt2860_softc
*sc
)
4578 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4579 "%s: Tx delay interrupt\n",
4580 device_get_nameunit(sc
->dev
));
4582 sc
->tx_delay_interrupts
++;
4586 * rt2860_pre_tbtt_intr
4588 static void rt2860_pre_tbtt_intr(struct rt2860_softc
*sc
)
4590 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4591 "%s: Pre-TBTT interrupt\n",
4592 device_get_nameunit(sc
->dev
));
4594 sc
->pre_tbtt_interrupts
++;
4600 static void rt2860_tbtt_intr(struct rt2860_softc
*sc
)
4602 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4603 "%s: TBTT interrupt\n",
4604 device_get_nameunit(sc
->dev
));
4606 sc
->tbtt_interrupts
++;
4610 * rt2860_mcu_cmd_intr
4612 static void rt2860_mcu_cmd_intr(struct rt2860_softc
*sc
)
4614 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4615 "%s: MCU command interrupt\n",
4616 device_get_nameunit(sc
->dev
));
4618 sc
->mcu_cmd_interrupts
++;
4622 * rt2860_auto_wakeup_intr
4624 static void rt2860_auto_wakeup_intr(struct rt2860_softc
*sc
)
4626 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4627 "%s: auto wakeup interrupt\n",
4628 device_get_nameunit(sc
->dev
));
4630 sc
->auto_wakeup_interrupts
++;
4634 * rt2860_gp_timer_intr
4636 static void rt2860_gp_timer_intr(struct rt2860_softc
*sc
)
4638 RT2860_DPRINTF(sc
, RT2860_DEBUG_INTR
,
4639 "%s: GP timer interrupt\n",
4640 device_get_nameunit(sc
->dev
));
4642 sc
->gp_timer_interrupts
++;
4646 * rt2860_rx_done_task
4648 static void rt2860_rx_done_task(void *context
, int pending
)
4650 struct rt2860_softc
*sc
;
4657 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
4658 "%s: Rx done task\n",
4659 device_get_nameunit(sc
->dev
));
4661 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
4664 sc
->intr_pending_mask
&= ~RT2860_REG_INT_RX_DONE
;
4666 again
= rt2860_rx_eof(sc
, sc
->rx_process_limit
);
4668 RT2860_SOFTC_LOCK(sc
);
4670 if ((sc
->intr_pending_mask
& RT2860_REG_INT_RX_DONE
) || again
)
4672 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
4673 "%s: Rx done task: scheduling again\n",
4674 device_get_nameunit(sc
->dev
));
4676 taskqueue_enqueue(sc
->taskqueue
, &sc
->rx_done_task
);
4680 rt2860_intr_enable(sc
, RT2860_REG_INT_RX_DONE
);
4683 RT2860_SOFTC_UNLOCK(sc
);
4687 * rt2860_tx_done_task
4689 static void rt2860_tx_done_task(void *context
, int pending
)
4691 struct rt2860_softc
*sc
;
4699 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
4700 "%s: Tx done task\n",
4701 device_get_nameunit(sc
->dev
));
4703 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
4706 intr_mask
= (RT2860_REG_INT_TX_MGMT_DONE
|
4707 RT2860_REG_INT_TX_HCCA_DONE
|
4708 RT2860_REG_INT_TX_AC3_DONE
|
4709 RT2860_REG_INT_TX_AC2_DONE
|
4710 RT2860_REG_INT_TX_AC1_DONE
|
4711 RT2860_REG_INT_TX_AC0_DONE
);
4713 sc
->intr_pending_mask
&= ~intr_mask
;
4715 for (i
= RT2860_SOFTC_TX_RING_COUNT
- 1; i
>= 0; i
--)
4716 rt2860_tx_eof(sc
, &sc
->tx_ring
[i
]);
4720 ifp
->if_drv_flags
&= ~IFF_DRV_OACTIVE
;
4722 RT2860_SOFTC_LOCK(sc
);
4724 rt2860_intr_enable(sc
, ~sc
->intr_pending_mask
&
4725 (sc
->intr_disable_mask
& intr_mask
));
4727 if (sc
->intr_pending_mask
& intr_mask
)
4729 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
4730 "%s: Tx done task: scheduling again\n",
4731 device_get_nameunit(sc
->dev
));
4733 taskqueue_enqueue(sc
->taskqueue
, &sc
->tx_done_task
);
4736 RT2860_SOFTC_UNLOCK(sc
);
4740 * rt2860_fifo_sta_full_task
4742 static void rt2860_fifo_sta_full_task(void *context
, int pending
)
4744 struct rt2860_softc
*sc
;
4750 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATS
,
4751 "%s: FIFO statistic full task\n",
4752 device_get_nameunit(sc
->dev
));
4754 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
4757 sc
->intr_pending_mask
&= ~RT2860_REG_INT_FIFO_STA_FULL
;
4759 rt2860_drain_fifo_stats(sc
);
4761 RT2860_SOFTC_LOCK(sc
);
4763 if (sc
->intr_pending_mask
& RT2860_REG_INT_FIFO_STA_FULL
)
4765 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATS
,
4766 "%s: FIFO statistic full task: scheduling again\n",
4767 device_get_nameunit(sc
->dev
));
4769 taskqueue_enqueue(sc
->taskqueue
, &sc
->fifo_sta_full_task
);
4773 rt2860_intr_enable(sc
, RT2860_REG_INT_FIFO_STA_FULL
);
4776 RT2860_SOFTC_UNLOCK(sc
);
4780 * rt2860_periodic_task
4782 static void rt2860_periodic_task(void *context
, int pending
)
4784 struct rt2860_softc
*sc
;
4786 struct ieee80211com
*ic
;
4787 struct ieee80211vap
*vap
;
4793 RT2860_DPRINTF(sc
, RT2860_DEBUG_PERIODIC
,
4794 "%s: periodic task: round=%lu\n",
4795 device_get_nameunit(sc
->dev
), sc
->periodic_round
);
4797 if (!(ifp
->if_drv_flags
& IFF_DRV_RUNNING
))
4800 RT2860_SOFTC_LOCK(sc
);
4802 sc
->periodic_round
++;
4804 rt2860_update_stats(sc
);
4806 if ((sc
->periodic_round
% 10) == 0)
4808 rt2860_update_raw_counters(sc
);
4810 rt2860_watchdog(sc
);
4812 vap
= TAILQ_FIRST(&ic
->ic_vaps
);
4815 if (vap
->iv_opmode
== IEEE80211_M_STA
)
4816 rt2860_amrr_update_iter_func(vap
, vap
->iv_bss
);
4818 ieee80211_iterate_nodes(&ic
->ic_sta
, rt2860_amrr_update_iter_func
, vap
);
4822 RT2860_SOFTC_UNLOCK(sc
);
4824 callout_reset(&sc
->periodic_ch
, hz
/ 10, rt2860_periodic
, sc
);
4830 static int rt2860_rx_eof(struct rt2860_softc
*sc
, int limit
)
4833 struct ieee80211com
*ic
;
4834 struct ieee80211_frame
*wh
;
4835 struct ieee80211_node
*ni
;
4836 struct rt2860_softc_rx_radiotap_header
*tap
;
4837 struct rt2860_softc_rx_ring
*ring
;
4838 struct rt2860_rxdesc
*desc
;
4839 struct rt2860_softc_rx_data
*data
;
4840 struct rt2860_rxwi
*rxwi
;
4841 struct mbuf
*m
, *mnew
;
4842 bus_dma_segment_t segs
[1];
4843 uint32_t index
, desc_flags
;
4844 uint8_t cipher_err
, rssi
, ant
, phymode
, bw
, shortgi
, mcs
;
4846 int error
, nsegs
, len
, ampdu
, amsdu
, nframes
;
4850 ring
= &sc
->rx_ring
;
4854 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
4855 BUS_DMASYNC_POSTREAD
);
4859 index
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_RX_DRX_IDX
);
4860 if (ring
->cur
== index
)
4863 desc
= &ring
->desc
[ring
->cur
];
4864 desc_flags
= le32toh(desc
->flags
);
4865 data
= &ring
->data
[ring
->cur
];
4867 if (!(desc
->sdl0
& htole16(RT2860_RXDESC_SDL0_DDONE
)))
4872 mnew
= m_getjcl(M_DONTWAIT
, MT_DATA
, M_PKTHDR
, MJUMPAGESIZE
);
4875 sc
->rx_mbuf_alloc_errors
++;
4880 mnew
->m_len
= mnew
->m_pkthdr
.len
= MJUMPAGESIZE
;
4882 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
4883 BUS_DMASYNC_POSTREAD
);
4884 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
4886 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
,
4887 mnew
, segs
, &nsegs
, BUS_DMA_NOWAIT
);
4892 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
,
4893 data
->m
, segs
, &nsegs
, BUS_DMA_NOWAIT
);
4895 panic("%s: could not load old Rx mbuf: error=%d\n",
4896 device_get_name(sc
->dev
), error
);
4898 sc
->rx_mbuf_dmamap_errors
++;
4904 KASSERT(nsegs
== 1, ("%s: too many DMA segments"));
4909 desc
->sdp0
= htole32(segs
[0].ds_addr
);
4911 /* get Rx wireless info */
4913 rxwi
= mtod(m
, struct rt2860_rxwi
*);
4914 len
= (le16toh(rxwi
->tid_size
) >> RT2860_RXWI_SIZE_SHIFT
) &
4915 RT2860_RXWI_SIZE_MASK
;
4917 /* check for L2 padding between IEEE 802.11 frame header and body */
4919 if (desc_flags
& RT2860_RXDESC_FLAGS_L2PAD
)
4921 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
4922 "%s: L2 padding: len=%d\n",
4923 device_get_nameunit(sc
->dev
), len
);
4928 m
->m_pkthdr
.rcvif
= ifp
;
4929 m
->m_data
= (caddr_t
) (rxwi
+ 1);
4930 m
->m_pkthdr
.len
= m
->m_len
= len
;
4932 /* check for crc errors */
4934 if (desc_flags
& RT2860_RXDESC_FLAGS_CRC_ERR
)
4936 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
4937 "%s: rxdesc: crc error\n",
4938 device_get_nameunit(sc
->dev
));
4942 if (!(ifp
->if_flags
& IFF_PROMISC
))
4949 wh
= (struct ieee80211_frame
*) (rxwi
+ 1);
4951 /* check for cipher errors */
4953 if (desc_flags
& RT2860_RXDESC_FLAGS_DECRYPTED
)
4955 cipher_err
= ((desc_flags
>> RT2860_RXDESC_FLAGS_CIPHER_ERR_SHIFT
) &
4956 RT2860_RXDESC_FLAGS_CIPHER_ERR_MASK
);
4957 if (cipher_err
== RT2860_RXDESC_FLAGS_CIPHER_ERR_NONE
)
4959 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
)
4960 wh
->i_fc
[1] &= ~IEEE80211_FC1_WEP
;
4962 m
->m_flags
|= M_WEP
;
4966 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
4967 "%s: rxdesc: cipher error=0x%02x\n",
4968 device_get_nameunit(sc
->dev
), cipher_err
);
4972 if (!(ifp
->if_flags
& IFF_PROMISC
))
4981 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
)
4985 if (!(ifp
->if_flags
& IFF_PROMISC
))
4993 /* check for A-MPDU */
4995 if (desc_flags
& RT2860_RXDESC_FLAGS_AMPDU
)
4997 m
->m_flags
|= M_AMPDU
;
5005 ant
= rt2860_maxrssi_rxpath(sc
, rxwi
);
5006 rssi
= rxwi
->rssi
[ant
];
5007 rssi_dbm
= rt2860_rssi2dbm(sc
, rssi
, ant
);
5008 phymode
= ((rxwi
->phymode_stbc_shortgi
>> RT2860_RXWI_PHYMODE_SHIFT
) &
5009 RT2860_RXWI_PHYMODE_MASK
);
5010 bw
= ((rxwi
->bw_mcs
>> RT2860_RXWI_BW_SHIFT
) & RT2860_RXWI_BW_MASK
);
5011 shortgi
= ((rxwi
->phymode_stbc_shortgi
>> RT2860_RXWI_SHORTGI_SHIFT
) &
5012 RT2860_RXWI_SHORTGI_MASK
);
5013 mcs
= ((rxwi
->bw_mcs
>> RT2860_RXWI_MCS_SHIFT
) & RT2860_RXWI_MCS_MASK
);
5014 amsdu
= (desc_flags
& RT2860_RXDESC_FLAGS_AMSDU
);
5016 if (ieee80211_radiotap_active(ic
))
5020 tap
->flags
= (desc_flags
& RT2860_RXDESC_FLAGS_L2PAD
) ? IEEE80211_RADIOTAP_F_DATAPAD
: 0;
5021 tap
->dbm_antsignal
= rssi_dbm
;
5022 tap
->dbm_antnoise
= RT2860_NOISE_FLOOR
;
5024 tap
->antsignal
= rssi
;
5025 tap
->chan_flags
= htole32(ic
->ic_curchan
->ic_flags
);
5026 tap
->chan_freq
= htole16(ic
->ic_curchan
->ic_freq
);
5027 tap
->chan_ieee
= ic
->ic_curchan
->ic_ieee
;
5028 tap
->chan_maxpow
= 0;
5030 if (phymode
== RT2860_TXWI_PHYMODE_HT_MIXED
|| phymode
== RT2860_TXWI_PHYMODE_HT_GF
)
5031 tap
->rate
= mcs
| IEEE80211_RATE_MCS
;
5033 tap
->rate
= rt2860_rxrate(rxwi
);
5035 if (rxwi
->bw_mcs
& RT2860_RXWI_MCS_SHOTPRE
)
5036 tap
->flags
|= IEEE80211_RADIOTAP_F_SHORTPRE
;
5039 tap
->flags
|= IEEE80211_RADIOTAP_F_SHORTGI
;
5042 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
5043 "%s: received frame: len=%d, phymode=%d, bw=%d, shortgi=%d, mcs=%d, "
5044 "ant=%d, rssi=%d/%d/%d, snr=%d/%d, wcid=0x%02x, ampdu=%d, amsdu=%d\n",
5045 device_get_nameunit(sc
->dev
),
5046 len
, phymode
, bw
, shortgi
, mcs
,
5047 ant
, rxwi
->rssi
[0], rxwi
->rssi
[1], rxwi
->rssi
[2],
5048 rxwi
->snr
[0], rxwi
->snr
[1],
5049 rxwi
->wcid
, ampdu
, amsdu
);
5051 ni
= ieee80211_find_rxnode(ic
, (struct ieee80211_frame_min
*) wh
);
5054 ieee80211_input(ni
, m
, rssi_dbm
- RT2860_NOISE_FLOOR
, RT2860_NOISE_FLOOR
);
5055 ieee80211_free_node(ni
);
5059 ieee80211_input_all(ic
, m
, rssi_dbm
- RT2860_NOISE_FLOOR
, RT2860_NOISE_FLOOR
);
5064 desc
->sdl0
&= ~htole16(RT2860_RXDESC_SDL0_DDONE
);
5066 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5067 BUS_DMASYNC_PREREAD
| BUS_DMASYNC_PREWRITE
);
5069 ring
->cur
= (ring
->cur
+ 1) % RT2860_SOFTC_RX_RING_DATA_COUNT
;
5075 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_CALC_IDX
,
5076 RT2860_SOFTC_RX_RING_DATA_COUNT
- 1);
5078 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_RX_CALC_IDX
,
5081 RT2860_DPRINTF(sc
, RT2860_DEBUG_RX
,
5082 "%s: Rx eof: nframes=%d\n",
5083 device_get_nameunit(sc
->dev
), nframes
);
5085 sc
->rx_packets
+= nframes
;
5087 return (limit
== 0);
5093 static void rt2860_tx_eof(struct rt2860_softc
*sc
,
5094 struct rt2860_softc_tx_ring
*ring
)
5097 struct rt2860_txdesc
*desc
;
5098 struct rt2860_softc_tx_data
*data
;
5100 int ndescs
, nframes
;
5107 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5108 BUS_DMASYNC_POSTREAD
);
5112 index
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_TX_DTX_IDX(ring
->qid
));
5113 if (ring
->desc_next
== index
)
5118 rt2860_drain_fifo_stats(sc
);
5120 desc
= &ring
->desc
[ring
->desc_next
];
5122 if (desc
->sdl0
& htole16(RT2860_TXDESC_SDL0_LASTSEG
) ||
5123 desc
->sdl1
& htole16(RT2860_TXDESC_SDL1_LASTSEG
))
5127 data
= &ring
->data
[ring
->data_next
];
5129 if (data
->m
->m_flags
& M_TXCB
)
5130 ieee80211_process_callback(data
->ni
, data
->m
, 0);
5132 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
5133 BUS_DMASYNC_POSTWRITE
);
5134 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
5138 ieee80211_free_node(data
->ni
);
5145 ring
->data_queued
--;
5146 ring
->data_next
= (ring
->data_next
+ 1) % RT2860_SOFTC_TX_RING_DATA_COUNT
;
5149 desc
->sdl0
&= ~htole16(RT2860_TXDESC_SDL0_DDONE
);
5151 ring
->desc_queued
--;
5152 ring
->desc_next
= (ring
->desc_next
+ 1) % RT2860_SOFTC_TX_RING_DESC_COUNT
;
5155 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5156 BUS_DMASYNC_PREREAD
| BUS_DMASYNC_PREWRITE
);
5158 RT2860_DPRINTF(sc
, RT2860_DEBUG_TX
,
5159 "%s: Tx eof: qid=%d, ndescs=%d, nframes=%d\n",
5160 device_get_nameunit(sc
->dev
), ring
->qid
, ndescs
, nframes
);
5164 * rt2860_update_stats
5166 static void rt2860_update_stats(struct rt2860_softc
*sc
)
5169 struct ieee80211com
*ic
;
5170 struct ieee80211vap
*vap
;
5171 struct ieee80211_node
*ni
;
5175 int txcnt
, retrycnt
, failcnt
;
5180 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATS
,
5181 "%s: update statistic\n",
5182 device_get_nameunit(sc
->dev
));
5184 rt2860_drain_fifo_stats(sc
);
5186 if (ic
->ic_opmode
== IEEE80211_M_STA
)
5188 vap
= TAILQ_FIRST(&ic
->ic_vaps
);
5191 associd
= (ni
!= NULL
) ? ni
->ni_associd
: 0;
5192 wcid
= RT2860_AID2WCID(associd
);
5194 /* read and clear Tx statistic registers */
5196 rt2860_io_mac_read_multi(sc
, RT2860_REG_TX_STA_CNT0
,
5197 stacnt
, sizeof(stacnt
));
5199 txcnt
= le32toh(stacnt
[1]) & 0xffff;
5200 retrycnt
= le32toh(stacnt
[1]) >> 16;
5201 failcnt
= le32toh(stacnt
[0]) & 0xffff;
5203 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATS
,
5204 "%s: update statistic: associd=0x%04x, txcnt=%d, retrycnt=%d, failcnt=%d\n",
5205 device_get_nameunit(sc
->dev
),
5206 associd
, txcnt
, retrycnt
, failcnt
);
5208 ifp
->if_oerrors
+= failcnt
;
5210 rt2860_amrr_tx_update(&sc
->amrr_node
[wcid
],
5211 txcnt
+ retrycnt
+ failcnt
, txcnt
+ retrycnt
, retrycnt
+ failcnt
);
5218 static void rt2860_watchdog(struct rt2860_softc
*sc
)
5223 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_PBF_TXRXQ_PCNT
);
5225 RT2860_DPRINTF(sc
, RT2860_DEBUG_WATCHDOG
,
5226 "%s: watchdog: TXRXQ_PCNT=0x%08x\n",
5227 device_get_nameunit(sc
->dev
), tmp
);
5229 if (((tmp
>> RT2860_REG_TX0Q_PCNT_SHIFT
) & RT2860_REG_TX0Q_PCNT_MASK
) != 0)
5231 sc
->tx_queue_not_empty
[0]++;
5233 rt2860_io_mac_write(sc
, RT2860_REG_PBF_CFG
, 0xf40012);
5235 for (ntries
= 0; ntries
< 10; ntries
++)
5237 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_PBF_TXRXQ_PCNT
);
5238 if (((tmp
>> RT2860_REG_TX0Q_PCNT_SHIFT
) & RT2860_REG_TX0Q_PCNT_MASK
) == 0)
5244 rt2860_io_mac_write(sc
, RT2860_REG_PBF_CFG
, 0xf40006);
5247 if (((tmp
>> RT2860_REG_TX1Q_PCNT_SHIFT
) & RT2860_REG_TX1Q_PCNT_MASK
) != 0)
5249 sc
->tx_queue_not_empty
[1]++;
5251 rt2860_io_mac_write(sc
, RT2860_REG_PBF_CFG
, 0xf4000a);
5253 for (ntries
= 0; ntries
< 10; ntries
++)
5255 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_PBF_TXRXQ_PCNT
);
5256 if (((tmp
>> RT2860_REG_TX1Q_PCNT_SHIFT
) & RT2860_REG_TX1Q_PCNT_MASK
) == 0)
5262 rt2860_io_mac_write(sc
, RT2860_REG_PBF_CFG
, 0xf40006);
5267 * rt2860_drain_fifo_stats
5269 static void rt2860_drain_fifo_stats(struct rt2860_softc
*sc
)
5273 uint8_t wcid
, mcs
, pid
;
5278 /* drain Tx status FIFO (maxsize = 16) */
5280 while ((stats
= rt2860_io_mac_read(sc
, RT2860_REG_TX_STA_FIFO
)) &
5281 RT2860_REG_TX_STA_FIFO_VALID
)
5283 wcid
= (stats
>> RT2860_REG_TX_STA_FIFO_WCID_SHIFT
) &
5284 RT2860_REG_TX_STA_FIFO_WCID_MASK
;
5286 /* if no ACK was requested, no feedback is available */
5288 if (!(stats
& RT2860_REG_TX_STA_FIFO_ACK_REQ
) || wcid
== 0xff)
5291 /* update AMRR statistic */
5293 ok
= (stats
& RT2860_REG_TX_STA_FIFO_TX_OK
) ? 1 : 0;
5294 mcs
= (stats
>> RT2860_REG_TX_STA_FIFO_MCS_SHIFT
) &
5295 RT2860_REG_TX_STA_FIFO_MCS_MASK
;
5296 pid
= (stats
>> RT2860_REG_TX_STA_FIFO_PID_SHIFT
) &
5297 RT2860_REG_TX_STA_FIFO_PID_MASK
;
5298 retrycnt
= pid
- mcs
;
5300 RT2860_DPRINTF(sc
, RT2860_DEBUG_STATS
,
5301 "%s: FIFO statistic: wcid=0x%02x, ok=%d, mcs=0x%02x, pid=0x%02x, retrycnt=%d\n",
5302 device_get_nameunit(sc
->dev
),
5303 wcid
, ok
, mcs
, pid
, retrycnt
);
5305 rt2860_amrr_tx_complete(&sc
->amrr_node
[wcid
], ok
, retrycnt
);
5313 * rt2860_update_raw_counters
5315 static void rt2860_update_raw_counters(struct rt2860_softc
*sc
)
5319 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_RX_STA_CNT0
);
5321 sc
->rx_crc_errors
+= tmp
& 0xffff;
5322 sc
->rx_phy_errors
+= tmp
>> 16;
5324 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_RX_STA_CNT1
);
5326 sc
->rx_false_ccas
+= tmp
& 0xffff;
5327 sc
->rx_plcp_errors
+= tmp
>> 16;
5329 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_RX_STA_CNT2
);
5331 sc
->rx_dup_packets
+= tmp
& 0xffff;
5332 sc
->rx_fifo_overflows
+= tmp
>> 16;
5336 * rt2860_intr_enable
5338 static void rt2860_intr_enable(struct rt2860_softc
*sc
, uint32_t intr_mask
)
5342 sc
->intr_disable_mask
&= ~intr_mask
;
5344 tmp
= sc
->intr_enable_mask
& ~sc
->intr_disable_mask
;
5346 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_INT_MASK
, tmp
);
5350 * rt2860_intr_disable
5352 static void rt2860_intr_disable(struct rt2860_softc
*sc
, uint32_t intr_mask
)
5356 sc
->intr_disable_mask
|= intr_mask
;
5358 tmp
= sc
->intr_enable_mask
& ~sc
->intr_disable_mask
;
5360 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_INT_MASK
, tmp
);
5364 * rt2860_txrx_enable
5366 static int rt2860_txrx_enable(struct rt2860_softc
*sc
)
5368 struct ieee80211com
*ic
;
5376 /* enable Tx/Rx DMA engine */
5378 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
, RT2860_REG_TX_ENABLE
);
5380 for (ntries
= 0; ntries
< 200; ntries
++)
5382 tmp
= rt2860_io_mac_read(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
);
5383 if (!(tmp
& (RT2860_REG_TX_DMA_BUSY
| RT2860_REG_RX_DMA_BUSY
)))
5391 printf("%s: timeout waiting for DMA engine\n",
5392 device_get_nameunit(sc
->dev
));
5398 tmp
|= RT2860_REG_TX_WB_DDONE
|
5399 RT2860_REG_RX_DMA_ENABLE
|
5400 RT2860_REG_TX_DMA_ENABLE
|
5401 (RT2860_REG_WPDMA_BT_SIZE64
<< RT2860_REG_WPDMA_BT_SIZE_SHIFT
);
5403 rt2860_io_mac_write(sc
, RT2860_REG_SCHDMA_WPDMA_GLO_CFG
, tmp
);
5407 tmp
= RT2860_REG_RX_FILTER_DROP_CRC_ERR
|
5408 RT2860_REG_RX_FILTER_DROP_PHY_ERR
;
5410 if (ic
->ic_opmode
!= IEEE80211_M_MONITOR
)
5412 tmp
|= RT2860_REG_RX_FILTER_DROP_DUPL
|
5413 RT2860_REG_RX_FILTER_DROP_CTS
|
5414 RT2860_REG_RX_FILTER_DROP_BA
|
5415 RT2860_REG_RX_FILTER_DROP_ACK
|
5416 RT2860_REG_RX_FILTER_DROP_VER_ERR
|
5417 RT2860_REG_RX_FILTER_DROP_CTRL_RSV
|
5418 RT2860_REG_RX_FILTER_DROP_CFACK
|
5419 RT2860_REG_RX_FILTER_DROP_CFEND
;
5421 if (ic
->ic_opmode
== IEEE80211_M_STA
)
5422 tmp
|= RT2860_REG_RX_FILTER_DROP_RTS
|
5423 RT2860_REG_RX_FILTER_DROP_PSPOLL
;
5425 if (!(ifp
->if_flags
& IFF_PROMISC
))
5426 tmp
|= RT2860_REG_RX_FILTER_DROP_UC_NOME
;
5429 rt2860_io_mac_write(sc
, RT2860_REG_RX_FILTER_CFG
, tmp
);
5431 rt2860_io_mac_write(sc
, RT2860_REG_SYS_CTRL
,
5432 RT2860_REG_RX_ENABLE
| RT2860_REG_TX_ENABLE
);
5438 * rt2860_alloc_rx_ring
5440 static int rt2860_alloc_rx_ring(struct rt2860_softc
*sc
,
5441 struct rt2860_softc_rx_ring
*ring
)
5443 struct rt2860_rxdesc
*desc
;
5444 struct rt2860_softc_rx_data
*data
;
5445 bus_dma_segment_t segs
[1];
5446 int i
, nsegs
, error
;
5448 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->dev
), 4, 0,
5449 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
5450 RT2860_SOFTC_RX_RING_DATA_COUNT
* sizeof(struct rt2860_rxdesc
), 1,
5451 RT2860_SOFTC_RX_RING_DATA_COUNT
* sizeof(struct rt2860_rxdesc
),
5452 0, NULL
, NULL
, &ring
->desc_dma_tag
);
5455 printf("%s: could not create Rx desc DMA tag\n",
5456 device_get_nameunit(sc
->dev
));
5460 error
= bus_dmamem_alloc(ring
->desc_dma_tag
, (void **) &ring
->desc
,
5461 BUS_DMA_NOWAIT
| BUS_DMA_ZERO
, &ring
->desc_dma_map
);
5464 printf("%s: could not allocate Rx desc DMA memory\n",
5465 device_get_nameunit(sc
->dev
));
5469 error
= bus_dmamap_load(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5471 RT2860_SOFTC_RX_RING_DATA_COUNT
* sizeof(struct rt2860_rxdesc
),
5472 rt2860_dma_map_addr
, &ring
->desc_phys_addr
, 0);
5475 printf("%s: could not load Rx desc DMA map\n",
5476 device_get_nameunit(sc
->dev
));
5480 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->dev
), 4, 0,
5481 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
5482 MJUMPAGESIZE
, 1, MJUMPAGESIZE
, 0, NULL
, NULL
,
5483 &ring
->data_dma_tag
);
5486 printf("%s: could not create Rx data DMA tag\n",
5487 device_get_nameunit(sc
->dev
));
5491 for (i
= 0; i
< RT2860_SOFTC_RX_RING_DATA_COUNT
; i
++)
5493 desc
= &ring
->desc
[i
];
5494 data
= &ring
->data
[i
];
5496 error
= bus_dmamap_create(ring
->data_dma_tag
, 0, &data
->dma_map
);
5499 printf("%s: could not create Rx data DMA map\n",
5500 device_get_nameunit(sc
->dev
));
5504 data
->m
= m_getjcl(M_DONTWAIT
, MT_DATA
, M_PKTHDR
, MJUMPAGESIZE
);
5505 if (data
->m
== NULL
)
5507 printf("%s: could not allocate Rx mbuf\n",
5508 device_get_nameunit(sc
->dev
));
5513 data
->m
->m_len
= data
->m
->m_pkthdr
.len
= MJUMPAGESIZE
;
5515 error
= bus_dmamap_load_mbuf_sg(ring
->data_dma_tag
, data
->dma_map
,
5516 data
->m
, segs
, &nsegs
, BUS_DMA_NOWAIT
);
5519 printf("%s: could not load Rx mbuf DMA map\n",
5520 device_get_nameunit(sc
->dev
));
5524 KASSERT(nsegs
== 1, ("%s: too many DMA segments"));
5526 desc
->sdp0
= htole32(segs
[0].ds_addr
);
5527 desc
->sdl0
= htole16(MJUMPAGESIZE
);
5530 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5531 BUS_DMASYNC_PREREAD
| BUS_DMASYNC_PREWRITE
);
5537 rt2860_free_rx_ring(sc
, ring
);
5543 * rt2860_reset_rx_ring
5545 static void rt2860_reset_rx_ring(struct rt2860_softc
*sc
,
5546 struct rt2860_softc_rx_ring
*ring
)
5548 struct rt2860_rxdesc
*desc
;
5551 for (i
= 0; i
< RT2860_SOFTC_RX_RING_DATA_COUNT
; i
++)
5553 desc
= &ring
->desc
[i
];
5555 desc
->sdl0
&= ~htole16(RT2860_RXDESC_SDL0_DDONE
);
5558 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5559 BUS_DMASYNC_PREREAD
| BUS_DMASYNC_PREWRITE
);
5565 * rt2860_free_rx_ring
5567 static void rt2860_free_rx_ring(struct rt2860_softc
*sc
,
5568 struct rt2860_softc_rx_ring
*ring
)
5570 struct rt2860_softc_rx_data
*data
;
5573 if (ring
->desc
!= NULL
)
5575 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5576 BUS_DMASYNC_POSTWRITE
);
5577 bus_dmamap_unload(ring
->desc_dma_tag
, ring
->desc_dma_map
);
5578 bus_dmamem_free(ring
->desc_dma_tag
, ring
->desc
,
5579 ring
->desc_dma_map
);
5582 if (ring
->desc_dma_tag
!= NULL
)
5583 bus_dma_tag_destroy(ring
->desc_dma_tag
);
5585 for (i
= 0; i
< RT2860_SOFTC_RX_RING_DATA_COUNT
; i
++)
5587 data
= &ring
->data
[i
];
5589 if (data
->m
!= NULL
)
5591 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
5592 BUS_DMASYNC_POSTREAD
);
5593 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
5597 if (data
->dma_map
!= NULL
)
5598 bus_dmamap_destroy(ring
->data_dma_tag
, data
->dma_map
);
5601 if (ring
->data_dma_tag
!= NULL
)
5602 bus_dma_tag_destroy(ring
->data_dma_tag
);
5606 * rt2860_alloc_tx_ring
5608 static int rt2860_alloc_tx_ring(struct rt2860_softc
*sc
,
5609 struct rt2860_softc_tx_ring
*ring
, int qid
)
5611 struct rt2860_softc_tx_data
*data
;
5614 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->dev
), 4, 0,
5615 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
5616 RT2860_SOFTC_TX_RING_DESC_COUNT
* sizeof(struct rt2860_txdesc
), 1,
5617 RT2860_SOFTC_TX_RING_DESC_COUNT
* sizeof(struct rt2860_txdesc
),
5618 0, NULL
, NULL
, &ring
->desc_dma_tag
);
5621 printf("%s: could not create Tx desc DMA tag\n",
5622 device_get_nameunit(sc
->dev
));
5626 error
= bus_dmamem_alloc(ring
->desc_dma_tag
, (void **) &ring
->desc
,
5627 BUS_DMA_NOWAIT
| BUS_DMA_ZERO
, &ring
->desc_dma_map
);
5630 printf("%s: could not allocate Tx desc DMA memory\n",
5631 device_get_nameunit(sc
->dev
));
5635 error
= bus_dmamap_load(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5637 RT2860_SOFTC_TX_RING_DESC_COUNT
* sizeof(struct rt2860_txdesc
),
5638 rt2860_dma_map_addr
, &ring
->desc_phys_addr
, 0);
5641 printf("%s: could not load Tx desc DMA map\n",
5642 device_get_nameunit(sc
->dev
));
5646 ring
->desc_queued
= 0;
5648 ring
->desc_next
= 0;
5650 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->dev
), 4, 0,
5651 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
5652 RT2860_SOFTC_TX_RING_DATA_COUNT
* RT2860_TX_DATA_SEG0_SIZE
, 1,
5653 RT2860_SOFTC_TX_RING_DATA_COUNT
* RT2860_TX_DATA_SEG0_SIZE
,
5654 0, NULL
, NULL
, &ring
->seg0_dma_tag
);
5657 printf("%s: could not create Tx seg0 DMA tag\n",
5658 device_get_nameunit(sc
->dev
));
5662 error
= bus_dmamem_alloc(ring
->seg0_dma_tag
, (void **) &ring
->seg0
,
5663 BUS_DMA_NOWAIT
| BUS_DMA_ZERO
, &ring
->seg0_dma_map
);
5666 printf("%s: could not allocate Tx seg0 DMA memory\n",
5667 device_get_nameunit(sc
->dev
));
5671 error
= bus_dmamap_load(ring
->seg0_dma_tag
, ring
->seg0_dma_map
,
5673 RT2860_SOFTC_TX_RING_DATA_COUNT
* RT2860_TX_DATA_SEG0_SIZE
,
5674 rt2860_dma_map_addr
, &ring
->seg0_phys_addr
, 0);
5677 printf("%s: could not load Tx seg0 DMA map\n",
5678 device_get_nameunit(sc
->dev
));
5682 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->dev
), 1, 0,
5683 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
5684 MJUMPAGESIZE
, RT2860_SOFTC_MAX_SCATTER
, MJUMPAGESIZE
, 0, NULL
, NULL
,
5685 &ring
->data_dma_tag
);
5688 printf("%s: could not create Tx data DMA tag\n",
5689 device_get_nameunit(sc
->dev
));
5693 for (i
= 0; i
< RT2860_SOFTC_TX_RING_DATA_COUNT
; i
++)
5695 data
= &ring
->data
[i
];
5697 error
= bus_dmamap_create(ring
->data_dma_tag
, 0, &data
->dma_map
);
5700 printf("%s: could not create Tx data DMA map\n",
5701 device_get_nameunit(sc
->dev
));
5706 ring
->data_queued
= 0;
5708 ring
->data_next
= 0;
5716 rt2860_free_tx_ring(sc
, ring
);
5722 * rt2860_reset_tx_ring
5724 static void rt2860_reset_tx_ring(struct rt2860_softc
*sc
,
5725 struct rt2860_softc_tx_ring
*ring
)
5727 struct rt2860_softc_tx_data
*data
;
5728 struct rt2860_txdesc
*desc
;
5731 for (i
= 0; i
< RT2860_SOFTC_TX_RING_DESC_COUNT
; i
++)
5733 desc
= &ring
->desc
[i
];
5739 ring
->desc_queued
= 0;
5741 ring
->desc_next
= 0;
5743 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5744 BUS_DMASYNC_PREWRITE
);
5746 bus_dmamap_sync(ring
->seg0_dma_tag
, ring
->seg0_dma_map
,
5747 BUS_DMASYNC_PREWRITE
);
5749 for (i
= 0; i
< RT2860_SOFTC_TX_RING_DATA_COUNT
; i
++)
5751 data
= &ring
->data
[i
];
5753 if (data
->m
!= NULL
)
5755 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
5756 BUS_DMASYNC_POSTWRITE
);
5757 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
5762 if (data
->ni
!= NULL
)
5764 ieee80211_free_node(data
->ni
);
5769 ring
->data_queued
= 0;
5771 ring
->data_next
= 0;
5775 * rt2860_free_tx_ring
5777 static void rt2860_free_tx_ring(struct rt2860_softc
*sc
,
5778 struct rt2860_softc_tx_ring
*ring
)
5780 struct rt2860_softc_tx_data
*data
;
5783 if (ring
->desc
!= NULL
)
5785 bus_dmamap_sync(ring
->desc_dma_tag
, ring
->desc_dma_map
,
5786 BUS_DMASYNC_POSTWRITE
);
5787 bus_dmamap_unload(ring
->desc_dma_tag
, ring
->desc_dma_map
);
5788 bus_dmamem_free(ring
->desc_dma_tag
, ring
->desc
,
5789 ring
->desc_dma_map
);
5792 if (ring
->desc_dma_tag
!= NULL
)
5793 bus_dma_tag_destroy(ring
->desc_dma_tag
);
5795 if (ring
->seg0
!= NULL
)
5797 bus_dmamap_sync(ring
->seg0_dma_tag
, ring
->seg0_dma_map
,
5798 BUS_DMASYNC_POSTWRITE
);
5799 bus_dmamap_unload(ring
->seg0_dma_tag
, ring
->seg0_dma_map
);
5800 bus_dmamem_free(ring
->seg0_dma_tag
, ring
->seg0
,
5801 ring
->seg0_dma_map
);
5804 if (ring
->seg0_dma_tag
!= NULL
)
5805 bus_dma_tag_destroy(ring
->seg0_dma_tag
);
5807 for (i
= 0; i
< RT2860_SOFTC_TX_RING_DATA_COUNT
; i
++)
5809 data
= &ring
->data
[i
];
5811 if (data
->m
!= NULL
)
5813 bus_dmamap_sync(ring
->data_dma_tag
, data
->dma_map
,
5814 BUS_DMASYNC_POSTWRITE
);
5815 bus_dmamap_unload(ring
->data_dma_tag
, data
->dma_map
);
5819 if (data
->ni
!= NULL
)
5820 ieee80211_free_node(data
->ni
);
5822 if (data
->dma_map
!= NULL
)
5823 bus_dmamap_destroy(ring
->data_dma_tag
, data
->dma_map
);
5826 if (ring
->data_dma_tag
!= NULL
)
5827 bus_dma_tag_destroy(ring
->data_dma_tag
);
5831 * rt2860_dma_map_addr
5833 static void rt2860_dma_map_addr(void *arg
, bus_dma_segment_t
*segs
,
5834 int nseg
, int error
)
5839 KASSERT(nseg
== 1, ("too many DMA segments, %d should be 1", nseg
));
5841 *(bus_addr_t
*) arg
= segs
[0].ds_addr
;
5845 * rt2860_sysctl_attach
5847 static void rt2860_sysctl_attach(struct rt2860_softc
*sc
)
5849 struct sysctl_ctx_list
*ctx
;
5850 struct sysctl_oid
*tree
;
5851 struct sysctl_oid
*stats
;
5853 ctx
= device_get_sysctl_ctx(sc
->dev
);
5854 tree
= device_get_sysctl_tree(sc
->dev
);
5856 stats
= SYSCTL_ADD_NODE(ctx
, SYSCTL_CHILDREN(tree
), OID_AUTO
,
5857 "stats", CTLFLAG_RD
, 0, "statistic");
5859 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5860 "interrupts", CTLFLAG_RD
, &sc
->interrupts
, 0,
5863 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5864 "tx_coherent_interrupts", CTLFLAG_RD
, &sc
->tx_coherent_interrupts
, 0,
5865 "Tx coherent interrupts");
5867 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5868 "rx_coherent_interrupts", CTLFLAG_RD
, &sc
->rx_coherent_interrupts
, 0,
5869 "Rx coherent interrupts");
5871 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5872 "txrx_coherent_interrupts", CTLFLAG_RD
, &sc
->txrx_coherent_interrupts
, 0,
5873 "Tx/Rx coherent interrupts");
5875 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5876 "fifo_sta_full_interrupts", CTLFLAG_RD
, &sc
->fifo_sta_full_interrupts
, 0,
5877 "FIFO statistic full interrupts");
5879 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5880 "rx_interrupts", CTLFLAG_RD
, &sc
->rx_interrupts
, 0,
5883 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5884 "rx_delay_interrupts", CTLFLAG_RD
, &sc
->rx_delay_interrupts
, 0,
5885 "Rx delay interrupts");
5887 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5888 "tx_mgmt_interrupts", CTLFLAG_RD
, &sc
->tx_interrupts
[5], 0,
5889 "Tx MGMT interrupts");
5891 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5892 "tx_hcca_interrupts", CTLFLAG_RD
, &sc
->tx_interrupts
[4], 0,
5893 "Tx HCCA interrupts");
5895 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5896 "tx_ac3_interrupts", CTLFLAG_RD
, &sc
->tx_interrupts
[3], 0,
5897 "Tx AC3 interrupts");
5899 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5900 "tx_ac2_interrupts", CTLFLAG_RD
, &sc
->tx_interrupts
[2], 0,
5901 "Tx AC2 interrupts");
5903 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5904 "tx_ac1_interrupts", CTLFLAG_RD
, &sc
->tx_interrupts
[1], 0,
5905 "Tx AC1 interrupts");
5907 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5908 "tx_ac0_interrupts", CTLFLAG_RD
, &sc
->tx_interrupts
[0], 0,
5909 "Tx AC0 interrupts");
5911 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5912 "tx_delay_interrupts", CTLFLAG_RD
, &sc
->tx_delay_interrupts
, 0,
5913 "Tx delay interrupts");
5915 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5916 "pre_tbtt_interrupts", CTLFLAG_RD
, &sc
->pre_tbtt_interrupts
, 0,
5917 "Pre-TBTT interrupts");
5919 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5920 "tbtt_interrupts", CTLFLAG_RD
, &sc
->tbtt_interrupts
, 0,
5923 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5924 "mcu_cmd_interrupts", CTLFLAG_RD
, &sc
->mcu_cmd_interrupts
, 0,
5925 "MCU command interrupts");
5927 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5928 "auto_wakeup_interrupts", CTLFLAG_RD
, &sc
->auto_wakeup_interrupts
, 0,
5929 "auto wakeup interrupts");
5931 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5932 "gp_timer_interrupts", CTLFLAG_RD
, &sc
->gp_timer_interrupts
, 0,
5933 "GP timer interrupts");
5935 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5936 "tx_mgmt_desc_queued", CTLFLAG_RD
, &sc
->tx_ring
[5].desc_queued
, 0,
5937 "Tx MGMT descriptors queued");
5939 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5940 "tx_mgmt_data_queued", CTLFLAG_RD
, &sc
->tx_ring
[5].data_queued
, 0,
5941 "Tx MGMT data queued");
5943 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5944 "tx_hcca_desc_queued", CTLFLAG_RD
, &sc
->tx_ring
[4].desc_queued
, 0,
5945 "Tx HCCA descriptors queued");
5947 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5948 "tx_hcca_data_queued", CTLFLAG_RD
, &sc
->tx_ring
[4].data_queued
, 0,
5949 "Tx HCCA data queued");
5951 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5952 "tx_ac3_desc_queued", CTLFLAG_RD
, &sc
->tx_ring
[3].desc_queued
, 0,
5953 "Tx AC3 descriptors queued");
5955 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5956 "tx_ac3_data_queued", CTLFLAG_RD
, &sc
->tx_ring
[3].data_queued
, 0,
5957 "Tx AC3 data queued");
5959 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5960 "tx_ac2_desc_queued", CTLFLAG_RD
, &sc
->tx_ring
[2].desc_queued
, 0,
5961 "Tx AC2 descriptors queued");
5963 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5964 "tx_ac2_data_queued", CTLFLAG_RD
, &sc
->tx_ring
[2].data_queued
, 0,
5965 "Tx AC2 data queued");
5967 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5968 "tx_ac1_desc_queued", CTLFLAG_RD
, &sc
->tx_ring
[1].desc_queued
, 0,
5969 "Tx AC1 descriptors queued");
5971 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5972 "tx_ac1_data_queued", CTLFLAG_RD
, &sc
->tx_ring
[1].data_queued
, 0,
5973 "Tx AC1 data queued");
5975 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5976 "tx_ac0_desc_queued", CTLFLAG_RD
, &sc
->tx_ring
[0].desc_queued
, 0,
5977 "Tx AC0 descriptors queued");
5979 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5980 "tx_ac0_data_queued", CTLFLAG_RD
, &sc
->tx_ring
[0].data_queued
, 0,
5981 "Tx AC0 data queued");
5983 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5984 "tx_watchdog_timeouts", CTLFLAG_RD
, &sc
->tx_watchdog_timeouts
, 0,
5985 "Tx watchdog timeouts");
5987 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5988 "tx_defrag_packets", CTLFLAG_RD
, &sc
->tx_defrag_packets
, 0,
5989 "Tx defragmented packets");
5991 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5992 "no_tx_desc_avail", CTLFLAG_RD
, &sc
->no_tx_desc_avail
, 0,
5993 "no Tx descriptors available");
5995 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
5996 "rx_mbuf_alloc_errors", CTLFLAG_RD
, &sc
->rx_mbuf_alloc_errors
, 0,
5997 "Rx mbuf allocation errors");
5999 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6000 "rx_mbuf_dmamap_errors", CTLFLAG_RD
, &sc
->rx_mbuf_dmamap_errors
, 0,
6001 "Rx mbuf DMA mapping errors");
6003 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6004 "tx_queue_0_not_empty", CTLFLAG_RD
, &sc
->tx_queue_not_empty
[0], 0,
6005 "Tx queue 0 not empty");
6007 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6008 "tx_queue_1_not_empty", CTLFLAG_RD
, &sc
->tx_queue_not_empty
[1], 0,
6009 "Tx queue 1 not empty");
6011 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6012 "rx_packets", CTLFLAG_RD
, &sc
->rx_packets
, 0,
6015 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6016 "rx_crc_errors", CTLFLAG_RD
, &sc
->rx_crc_errors
, 0,
6019 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6020 "rx_phy_errors", CTLFLAG_RD
, &sc
->rx_phy_errors
, 0,
6023 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6024 "rx_false_ccas", CTLFLAG_RD
, &sc
->rx_false_ccas
, 0,
6027 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6028 "rx_plcp_errors", CTLFLAG_RD
, &sc
->rx_plcp_errors
, 0,
6031 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6032 "rx_dup_packets", CTLFLAG_RD
, &sc
->rx_dup_packets
, 0,
6033 "Rx duplicate packets");
6035 SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(stats
), OID_AUTO
,
6036 "rx_fifo_overflows", CTLFLAG_RD
, &sc
->rx_fifo_overflows
, 0,
6037 "Rx FIFO overflows");
6040 static device_method_t rt2860_dev_methods
[] =
6042 DEVMETHOD(device_probe
, rt2860_probe
),
6043 DEVMETHOD(device_attach
, rt2860_attach
),
6044 DEVMETHOD(device_detach
, rt2860_detach
),
6045 DEVMETHOD(device_shutdown
, rt2860_shutdown
),
6046 DEVMETHOD(device_suspend
, rt2860_suspend
),
6047 DEVMETHOD(device_resume
, rt2860_resume
),
6051 static driver_t rt2860_driver
=
6055 sizeof(struct rt2860_softc
)
6058 static devclass_t rt2860_dev_class
;
6060 DRIVER_MODULE(rt2860
, pci
, rt2860_driver
, rt2860_dev_class
, 0, 0);
6062 MODULE_DEPEND(rt2860
, pci
, 1, 1, 1);
6063 MODULE_DEPEND(rt2860
, wlan
, 1, 1, 1);