4 * Copyright (c) 2005, 2006
5 * Damien Bergamini <damien.bergamini@free.fr>
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 #include <sys/cdefs.h>
21 __FBSDID("$FreeBSD$");
24 * Ralink Technology RT2560 chipset driver
25 * http://www.ralinktech.com/
28 #include <sys/param.h>
29 #include <sys/sysctl.h>
30 #include <sys/sockio.h>
32 #include <sys/kernel.h>
33 #include <sys/socket.h>
34 #include <sys/systm.h>
35 #include <sys/malloc.h>
37 #include <sys/mutex.h>
38 #include <sys/module.h>
40 #include <sys/endian.h>
42 #if defined(__DragonFly__)
45 #include <machine/bus.h>
46 #include <machine/resource.h>
52 #include <net/if_var.h>
53 #include <net/if_arp.h>
54 #include <net/ethernet.h>
55 #include <net/if_dl.h>
56 #include <net/if_media.h>
57 #include <net/if_types.h>
59 #include <netproto/802_11/ieee80211_var.h>
60 #include <netproto/802_11/ieee80211_radiotap.h>
61 #include <netproto/802_11/ieee80211_regdomain.h>
62 #include <netproto/802_11/ieee80211_ratectl.h>
64 #include <netinet/in.h>
65 #include <netinet/in_systm.h>
66 #include <netinet/in_var.h>
67 #include <netinet/ip.h>
68 #include <netinet/if_ether.h>
70 #include <dev/netif/ral/rt2560reg.h>
71 #include <dev/netif/ral/rt2560var.h>
73 #define RT2560_RSSI(sc, rssi) \
74 ((rssi) > (RT2560_NOISE_FLOOR + (sc)->rssi_corr) ? \
75 ((rssi) - RT2560_NOISE_FLOOR - (sc)->rssi_corr) : 0)
79 #define DPRINTF(sc, fmt, ...) do { \
80 if (sc->sc_debug > 0) \
81 kprintf(fmt, __VA_ARGS__); \
83 #define DPRINTFN(sc, n, fmt, ...) do { \
84 if (sc->sc_debug >= (n)) \
85 kprintf(fmt, __VA_ARGS__); \
88 #define DPRINTF(sc, fmt, ...)
89 #define DPRINTFN(sc, n, fmt, ...)
92 static struct ieee80211vap
*rt2560_vap_create(struct ieee80211com
*,
93 const char [IFNAMSIZ
], int, enum ieee80211_opmode
,
94 int, const uint8_t [IEEE80211_ADDR_LEN
],
95 const uint8_t [IEEE80211_ADDR_LEN
]);
96 static void rt2560_vap_delete(struct ieee80211vap
*);
97 static void rt2560_dma_map_addr(void *, bus_dma_segment_t
*, int,
99 static int rt2560_alloc_tx_ring(struct rt2560_softc
*,
100 struct rt2560_tx_ring
*, int);
101 static void rt2560_reset_tx_ring(struct rt2560_softc
*,
102 struct rt2560_tx_ring
*);
103 static void rt2560_free_tx_ring(struct rt2560_softc
*,
104 struct rt2560_tx_ring
*);
105 static int rt2560_alloc_rx_ring(struct rt2560_softc
*,
106 struct rt2560_rx_ring
*, int);
107 static void rt2560_reset_rx_ring(struct rt2560_softc
*,
108 struct rt2560_rx_ring
*);
109 static void rt2560_free_rx_ring(struct rt2560_softc
*,
110 struct rt2560_rx_ring
*);
111 static int rt2560_newstate(struct ieee80211vap
*,
112 enum ieee80211_state
, int);
113 static uint16_t rt2560_eeprom_read(struct rt2560_softc
*, uint8_t);
114 static void rt2560_encryption_intr(struct rt2560_softc
*);
115 static void rt2560_tx_intr(struct rt2560_softc
*);
116 static void rt2560_prio_intr(struct rt2560_softc
*);
117 static void rt2560_decryption_intr(struct rt2560_softc
*);
118 static void rt2560_rx_intr(struct rt2560_softc
*);
119 static void rt2560_beacon_update(struct ieee80211vap
*, int item
);
120 static void rt2560_beacon_expire(struct rt2560_softc
*);
121 static void rt2560_wakeup_expire(struct rt2560_softc
*);
122 static void rt2560_scan_start(struct ieee80211com
*);
123 static void rt2560_scan_end(struct ieee80211com
*);
124 static void rt2560_set_channel(struct ieee80211com
*);
125 static void rt2560_setup_tx_desc(struct rt2560_softc
*,
126 struct rt2560_tx_desc
*, uint32_t, int, int, int,
128 static int rt2560_tx_bcn(struct rt2560_softc
*, struct mbuf
*,
129 struct ieee80211_node
*);
130 static int rt2560_tx_mgt(struct rt2560_softc
*, struct mbuf
*,
131 struct ieee80211_node
*);
132 static int rt2560_tx_data(struct rt2560_softc
*, struct mbuf
*,
133 struct ieee80211_node
*);
134 static int rt2560_transmit(struct ieee80211com
*, struct mbuf
*);
135 static void rt2560_start(struct rt2560_softc
*);
136 static void rt2560_watchdog(void *);
137 static void rt2560_parent(struct ieee80211com
*);
138 static void rt2560_bbp_write(struct rt2560_softc
*, uint8_t,
140 static uint8_t rt2560_bbp_read(struct rt2560_softc
*, uint8_t);
141 static void rt2560_rf_write(struct rt2560_softc
*, uint8_t,
143 static void rt2560_set_chan(struct rt2560_softc
*,
144 struct ieee80211_channel
*);
146 static void rt2560_disable_rf_tune(struct rt2560_softc
*);
148 static void rt2560_enable_tsf_sync(struct rt2560_softc
*);
149 static void rt2560_enable_tsf(struct rt2560_softc
*);
150 static void rt2560_update_plcp(struct rt2560_softc
*);
151 static void rt2560_update_slot(struct ieee80211com
*);
152 static void rt2560_set_basicrates(struct rt2560_softc
*,
153 const struct ieee80211_rateset
*);
154 static void rt2560_update_led(struct rt2560_softc
*, int, int);
155 static void rt2560_set_bssid(struct rt2560_softc
*, const uint8_t *);
156 static void rt2560_set_macaddr(struct rt2560_softc
*,
158 static void rt2560_get_macaddr(struct rt2560_softc
*, uint8_t *);
159 static void rt2560_update_promisc(struct ieee80211com
*);
160 static const char *rt2560_get_rf(int);
161 static void rt2560_read_config(struct rt2560_softc
*);
162 static int rt2560_bbp_init(struct rt2560_softc
*);
163 static void rt2560_set_txantenna(struct rt2560_softc
*, int);
164 static void rt2560_set_rxantenna(struct rt2560_softc
*, int);
165 static void rt2560_init_locked(struct rt2560_softc
*);
166 static void rt2560_init(void *);
167 static void rt2560_stop_locked(struct rt2560_softc
*);
168 static int rt2560_raw_xmit(struct ieee80211_node
*, struct mbuf
*,
169 const struct ieee80211_bpf_params
*);
171 static const struct {
174 } rt2560_def_mac
[] = {
178 static const struct {
181 } rt2560_def_bbp
[] = {
185 static const uint32_t rt2560_rf2522_r2
[] = RT2560_RF2522_R2
;
186 static const uint32_t rt2560_rf2523_r2
[] = RT2560_RF2523_R2
;
187 static const uint32_t rt2560_rf2524_r2
[] = RT2560_RF2524_R2
;
188 static const uint32_t rt2560_rf2525_r2
[] = RT2560_RF2525_R2
;
189 static const uint32_t rt2560_rf2525_hi_r2
[] = RT2560_RF2525_HI_R2
;
190 static const uint32_t rt2560_rf2525e_r2
[] = RT2560_RF2525E_R2
;
191 static const uint32_t rt2560_rf2526_r2
[] = RT2560_RF2526_R2
;
192 static const uint32_t rt2560_rf2526_hi_r2
[] = RT2560_RF2526_HI_R2
;
194 static const struct {
197 } rt2560_rf5222
[] = {
202 rt2560_attach(device_t dev
, int id
)
204 struct rt2560_softc
*sc
= device_get_softc(dev
);
205 struct ieee80211com
*ic
= &sc
->sc_ic
;
206 uint8_t bands
[IEEE80211_MODE_BYTES
];
211 #if defined(__DragonFly__)
212 lockinit(&sc
->sc_mtx
, device_get_nameunit(dev
), 0, LK_CANRECURSE
);
214 mtx_init(&sc
->sc_mtx
, device_get_nameunit(dev
), MTX_NETWORK_LOCK
,
215 MTX_DEF
| MTX_RECURSE
);
218 callout_init_mtx(&sc
->watchdog_ch
, &sc
->sc_mtx
, 0);
219 mbufq_init(&sc
->sc_snd
, ifqmaxlen
);
221 /* retrieve RT2560 rev. no */
222 sc
->asic_rev
= RAL_READ(sc
, RT2560_CSR0
);
224 /* retrieve RF rev. no and various other things from EEPROM */
225 rt2560_read_config(sc
);
227 device_printf(dev
, "MAC/BBP RT2560 (rev 0x%02x), RF %s\n",
228 sc
->asic_rev
, rt2560_get_rf(sc
->rf_rev
));
231 * Allocate Tx and Rx rings.
233 error
= rt2560_alloc_tx_ring(sc
, &sc
->txq
, RT2560_TX_RING_COUNT
);
235 device_printf(sc
->sc_dev
, "could not allocate Tx ring\n");
239 error
= rt2560_alloc_tx_ring(sc
, &sc
->atimq
, RT2560_ATIM_RING_COUNT
);
241 device_printf(sc
->sc_dev
, "could not allocate ATIM ring\n");
245 error
= rt2560_alloc_tx_ring(sc
, &sc
->prioq
, RT2560_PRIO_RING_COUNT
);
247 device_printf(sc
->sc_dev
, "could not allocate Prio ring\n");
251 error
= rt2560_alloc_tx_ring(sc
, &sc
->bcnq
, RT2560_BEACON_RING_COUNT
);
253 device_printf(sc
->sc_dev
, "could not allocate Beacon ring\n");
257 error
= rt2560_alloc_rx_ring(sc
, &sc
->rxq
, RT2560_RX_RING_COUNT
);
259 device_printf(sc
->sc_dev
, "could not allocate Rx ring\n");
263 /* retrieve MAC address */
264 rt2560_get_macaddr(sc
, ic
->ic_macaddr
);
267 ic
->ic_name
= device_get_nameunit(dev
);
268 ic
->ic_opmode
= IEEE80211_M_STA
;
269 ic
->ic_phytype
= IEEE80211_T_OFDM
; /* not only, but not used */
271 /* set device capabilities */
273 IEEE80211_C_STA
/* station mode */
274 | IEEE80211_C_IBSS
/* ibss, nee adhoc, mode */
275 | IEEE80211_C_HOSTAP
/* hostap mode */
276 | IEEE80211_C_MONITOR
/* monitor mode */
277 | IEEE80211_C_AHDEMO
/* adhoc demo mode */
278 | IEEE80211_C_WDS
/* 4-address traffic works */
279 | IEEE80211_C_MBSS
/* mesh point link mode */
280 | IEEE80211_C_SHPREAMBLE
/* short preamble supported */
281 | IEEE80211_C_SHSLOT
/* short slot time supported */
282 | IEEE80211_C_WPA
/* capable of WPA1+WPA2 */
283 | IEEE80211_C_BGSCAN
/* capable of bg scanning */
285 | IEEE80211_C_TXFRAG
/* handle tx frags */
289 memset(bands
, 0, sizeof(bands
));
290 setbit(bands
, IEEE80211_MODE_11B
);
291 setbit(bands
, IEEE80211_MODE_11G
);
292 if (sc
->rf_rev
== RT2560_RF_5222
)
293 setbit(bands
, IEEE80211_MODE_11A
);
294 ieee80211_init_channels(ic
, NULL
, bands
);
296 ieee80211_ifattach(ic
);
297 ic
->ic_raw_xmit
= rt2560_raw_xmit
;
298 ic
->ic_updateslot
= rt2560_update_slot
;
299 ic
->ic_update_promisc
= rt2560_update_promisc
;
300 ic
->ic_scan_start
= rt2560_scan_start
;
301 ic
->ic_scan_end
= rt2560_scan_end
;
302 ic
->ic_set_channel
= rt2560_set_channel
;
304 ic
->ic_vap_create
= rt2560_vap_create
;
305 ic
->ic_vap_delete
= rt2560_vap_delete
;
306 ic
->ic_parent
= rt2560_parent
;
307 ic
->ic_transmit
= rt2560_transmit
;
309 ieee80211_radiotap_attach(ic
,
310 &sc
->sc_txtap
.wt_ihdr
, sizeof(sc
->sc_txtap
),
311 RT2560_TX_RADIOTAP_PRESENT
,
312 &sc
->sc_rxtap
.wr_ihdr
, sizeof(sc
->sc_rxtap
),
313 RT2560_RX_RADIOTAP_PRESENT
);
316 * Add a few sysctl knobs.
319 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev
),
320 SYSCTL_CHILDREN(device_get_sysctl_tree(dev
)), OID_AUTO
,
321 "debug", CTLFLAG_RW
, &sc
->sc_debug
, 0, "debug msgs");
323 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev
),
324 SYSCTL_CHILDREN(device_get_sysctl_tree(dev
)), OID_AUTO
,
325 "txantenna", CTLFLAG_RW
, &sc
->tx_ant
, 0, "tx antenna (0=auto)");
327 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev
),
328 SYSCTL_CHILDREN(device_get_sysctl_tree(dev
)), OID_AUTO
,
329 "rxantenna", CTLFLAG_RW
, &sc
->rx_ant
, 0, "rx antenna (0=auto)");
332 ieee80211_announce(ic
);
336 fail5
: rt2560_free_tx_ring(sc
, &sc
->bcnq
);
337 fail4
: rt2560_free_tx_ring(sc
, &sc
->prioq
);
338 fail3
: rt2560_free_tx_ring(sc
, &sc
->atimq
);
339 fail2
: rt2560_free_tx_ring(sc
, &sc
->txq
);
340 #if defined(__DragonFly__)
341 fail1
: lockuninit(&sc
->sc_mtx
);
343 fail1
: mtx_destroy(&sc
->sc_mtx
);
350 rt2560_detach(void *xsc
)
352 struct rt2560_softc
*sc
= xsc
;
353 struct ieee80211com
*ic
= &sc
->sc_ic
;
357 ieee80211_ifdetach(ic
);
358 mbufq_drain(&sc
->sc_snd
);
360 rt2560_free_tx_ring(sc
, &sc
->txq
);
361 rt2560_free_tx_ring(sc
, &sc
->atimq
);
362 rt2560_free_tx_ring(sc
, &sc
->prioq
);
363 rt2560_free_tx_ring(sc
, &sc
->bcnq
);
364 rt2560_free_rx_ring(sc
, &sc
->rxq
);
366 #if defined(__DragonFly__)
367 lockuninit(&sc
->sc_mtx
);
369 mtx_destroy(&sc
->sc_mtx
);
375 static struct ieee80211vap
*
376 rt2560_vap_create(struct ieee80211com
*ic
, const char name
[IFNAMSIZ
], int unit
,
377 enum ieee80211_opmode opmode
, int flags
,
378 const uint8_t bssid
[IEEE80211_ADDR_LEN
],
379 const uint8_t mac
[IEEE80211_ADDR_LEN
])
381 struct rt2560_softc
*sc
= ic
->ic_softc
;
382 struct rt2560_vap
*rvp
;
383 struct ieee80211vap
*vap
;
386 case IEEE80211_M_STA
:
387 case IEEE80211_M_IBSS
:
388 case IEEE80211_M_AHDEMO
:
389 case IEEE80211_M_MONITOR
:
390 case IEEE80211_M_HOSTAP
:
391 case IEEE80211_M_MBSS
:
393 if (!TAILQ_EMPTY(&ic
->ic_vaps
)) {
394 device_printf(sc
->sc_dev
, "only 1 vap supported\n");
397 if (opmode
== IEEE80211_M_STA
)
398 flags
|= IEEE80211_CLONE_NOBEACONS
;
400 case IEEE80211_M_WDS
:
401 if (TAILQ_EMPTY(&ic
->ic_vaps
) ||
402 ic
->ic_opmode
!= IEEE80211_M_HOSTAP
) {
403 device_printf(sc
->sc_dev
,
404 "wds only supported in ap mode\n");
408 * Silently remove any request for a unique
409 * bssid; WDS vap's always share the local
412 flags
&= ~IEEE80211_CLONE_BSSID
;
415 device_printf(sc
->sc_dev
, "unknown opmode %d\n", opmode
);
418 rvp
= kmalloc(sizeof(struct rt2560_vap
), M_80211_VAP
,
421 ieee80211_vap_setup(ic
, vap
, name
, unit
, opmode
, flags
, bssid
);
423 /* override state transition machine */
424 rvp
->ral_newstate
= vap
->iv_newstate
;
425 vap
->iv_newstate
= rt2560_newstate
;
426 vap
->iv_update_beacon
= rt2560_beacon_update
;
428 ieee80211_ratectl_init(vap
);
430 ieee80211_vap_attach(vap
, ieee80211_media_change
,
431 ieee80211_media_status
, mac
);
432 if (TAILQ_FIRST(&ic
->ic_vaps
) == vap
)
433 ic
->ic_opmode
= opmode
;
438 rt2560_vap_delete(struct ieee80211vap
*vap
)
440 struct rt2560_vap
*rvp
= RT2560_VAP(vap
);
442 ieee80211_ratectl_deinit(vap
);
443 ieee80211_vap_detach(vap
);
444 kfree(rvp
, M_80211_VAP
);
448 rt2560_resume(void *xsc
)
450 struct rt2560_softc
*sc
= xsc
;
452 if (sc
->sc_ic
.ic_nrunning
> 0)
457 rt2560_dma_map_addr(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
462 KASSERT(nseg
== 1, ("too many DMA segments, %d should be 1", nseg
));
464 *(bus_addr_t
*)arg
= segs
[0].ds_addr
;
468 rt2560_alloc_tx_ring(struct rt2560_softc
*sc
, struct rt2560_tx_ring
*ring
,
475 ring
->cur
= ring
->next
= 0;
476 ring
->cur_encrypt
= ring
->next_encrypt
= 0;
478 #if defined(__DragonFly__)
479 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 4, 0,
480 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
481 count
* RT2560_TX_DESC_SIZE
, 1, count
* RT2560_TX_DESC_SIZE
,
482 0, &ring
->desc_dmat
);
484 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 4, 0,
485 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
486 count
* RT2560_TX_DESC_SIZE
, 1, count
* RT2560_TX_DESC_SIZE
,
487 0, NULL
, NULL
, &ring
->desc_dmat
);
490 device_printf(sc
->sc_dev
, "could not create desc DMA tag\n");
494 error
= bus_dmamem_alloc(ring
->desc_dmat
, (void **)&ring
->desc
,
495 BUS_DMA_NOWAIT
| BUS_DMA_ZERO
, &ring
->desc_map
);
497 device_printf(sc
->sc_dev
, "could not allocate DMA memory\n");
501 error
= bus_dmamap_load(ring
->desc_dmat
, ring
->desc_map
, ring
->desc
,
502 count
* RT2560_TX_DESC_SIZE
, rt2560_dma_map_addr
, &ring
->physaddr
,
505 device_printf(sc
->sc_dev
, "could not load desc DMA map\n");
509 ring
->data
= kmalloc(count
* sizeof (struct rt2560_tx_data
), M_DEVBUF
,
511 if (ring
->data
== NULL
) {
512 device_printf(sc
->sc_dev
, "could not allocate soft data\n");
517 #if defined(__DragonFly__)
518 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 4, 0,
519 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
520 MCLBYTES
, RT2560_MAX_SCATTER
, MCLBYTES
, 0,
523 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 1, 0,
524 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
525 MCLBYTES
, RT2560_MAX_SCATTER
, MCLBYTES
, 0, NULL
, NULL
,
529 device_printf(sc
->sc_dev
, "could not create data DMA tag\n");
533 for (i
= 0; i
< count
; i
++) {
534 error
= bus_dmamap_create(ring
->data_dmat
, 0,
537 device_printf(sc
->sc_dev
, "could not create DMA map\n");
544 fail
: rt2560_free_tx_ring(sc
, ring
);
549 rt2560_reset_tx_ring(struct rt2560_softc
*sc
, struct rt2560_tx_ring
*ring
)
551 struct rt2560_tx_desc
*desc
;
552 struct rt2560_tx_data
*data
;
555 for (i
= 0; i
< ring
->count
; i
++) {
556 desc
= &ring
->desc
[i
];
557 data
= &ring
->data
[i
];
559 if (data
->m
!= NULL
) {
560 bus_dmamap_sync(ring
->data_dmat
, data
->map
,
561 BUS_DMASYNC_POSTWRITE
);
562 bus_dmamap_unload(ring
->data_dmat
, data
->map
);
567 if (data
->ni
!= NULL
) {
568 ieee80211_free_node(data
->ni
);
575 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
, BUS_DMASYNC_PREWRITE
);
578 ring
->cur
= ring
->next
= 0;
579 ring
->cur_encrypt
= ring
->next_encrypt
= 0;
583 rt2560_free_tx_ring(struct rt2560_softc
*sc
, struct rt2560_tx_ring
*ring
)
585 struct rt2560_tx_data
*data
;
588 if (ring
->desc
!= NULL
) {
589 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
,
590 BUS_DMASYNC_POSTWRITE
);
591 bus_dmamap_unload(ring
->desc_dmat
, ring
->desc_map
);
592 bus_dmamem_free(ring
->desc_dmat
, ring
->desc
, ring
->desc_map
);
595 if (ring
->desc_dmat
!= NULL
)
596 bus_dma_tag_destroy(ring
->desc_dmat
);
598 if (ring
->data
!= NULL
) {
599 for (i
= 0; i
< ring
->count
; i
++) {
600 data
= &ring
->data
[i
];
602 if (data
->m
!= NULL
) {
603 bus_dmamap_sync(ring
->data_dmat
, data
->map
,
604 BUS_DMASYNC_POSTWRITE
);
605 bus_dmamap_unload(ring
->data_dmat
, data
->map
);
609 if (data
->ni
!= NULL
)
610 ieee80211_free_node(data
->ni
);
612 if (data
->map
!= NULL
)
613 bus_dmamap_destroy(ring
->data_dmat
, data
->map
);
616 kfree(ring
->data
, M_DEVBUF
);
619 if (ring
->data_dmat
!= NULL
)
620 bus_dma_tag_destroy(ring
->data_dmat
);
624 rt2560_alloc_rx_ring(struct rt2560_softc
*sc
, struct rt2560_rx_ring
*ring
,
627 struct rt2560_rx_desc
*desc
;
628 struct rt2560_rx_data
*data
;
633 ring
->cur
= ring
->next
= 0;
634 ring
->cur_decrypt
= 0;
636 #if defined(__DragonFly__)
637 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 4, 0,
638 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
639 count
* RT2560_RX_DESC_SIZE
, 1, count
* RT2560_RX_DESC_SIZE
,
640 0, &ring
->desc_dmat
);
642 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 4, 0,
643 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
,
644 count
* RT2560_RX_DESC_SIZE
, 1, count
* RT2560_RX_DESC_SIZE
,
645 0, NULL
, NULL
, &ring
->desc_dmat
);
648 device_printf(sc
->sc_dev
, "could not create desc DMA tag\n");
652 error
= bus_dmamem_alloc(ring
->desc_dmat
, (void **)&ring
->desc
,
653 BUS_DMA_NOWAIT
| BUS_DMA_ZERO
, &ring
->desc_map
);
655 device_printf(sc
->sc_dev
, "could not allocate DMA memory\n");
659 error
= bus_dmamap_load(ring
->desc_dmat
, ring
->desc_map
, ring
->desc
,
660 count
* RT2560_RX_DESC_SIZE
, rt2560_dma_map_addr
, &ring
->physaddr
,
663 device_printf(sc
->sc_dev
, "could not load desc DMA map\n");
667 ring
->data
= kmalloc(count
* sizeof (struct rt2560_rx_data
), M_DEVBUF
,
669 if (ring
->data
== NULL
) {
670 device_printf(sc
->sc_dev
, "could not allocate soft data\n");
676 * Pre-allocate Rx buffers and populate Rx ring.
678 #if defined(__DragonFly__)
679 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 4, 0,
680 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
, MCLBYTES
,
681 1, MCLBYTES
, 0, &ring
->data_dmat
);
683 error
= bus_dma_tag_create(bus_get_dma_tag(sc
->sc_dev
), 1, 0,
684 BUS_SPACE_MAXADDR_32BIT
, BUS_SPACE_MAXADDR
, NULL
, NULL
, MCLBYTES
,
685 1, MCLBYTES
, 0, NULL
, NULL
, &ring
->data_dmat
);
688 device_printf(sc
->sc_dev
, "could not create data DMA tag\n");
692 for (i
= 0; i
< count
; i
++) {
693 desc
= &sc
->rxq
.desc
[i
];
694 data
= &sc
->rxq
.data
[i
];
696 error
= bus_dmamap_create(ring
->data_dmat
, 0, &data
->map
);
698 device_printf(sc
->sc_dev
, "could not create DMA map\n");
702 data
->m
= m_getcl(M_NOWAIT
, MT_DATA
, M_PKTHDR
);
703 if (data
->m
== NULL
) {
704 device_printf(sc
->sc_dev
,
705 "could not allocate rx mbuf\n");
710 error
= bus_dmamap_load(ring
->data_dmat
, data
->map
,
711 mtod(data
->m
, void *), MCLBYTES
, rt2560_dma_map_addr
,
714 device_printf(sc
->sc_dev
,
715 "could not load rx buf DMA map");
719 desc
->flags
= htole32(RT2560_RX_BUSY
);
720 desc
->physaddr
= htole32(physaddr
);
723 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
, BUS_DMASYNC_PREWRITE
);
727 fail
: rt2560_free_rx_ring(sc
, ring
);
732 rt2560_reset_rx_ring(struct rt2560_softc
*sc
, struct rt2560_rx_ring
*ring
)
736 for (i
= 0; i
< ring
->count
; i
++) {
737 ring
->desc
[i
].flags
= htole32(RT2560_RX_BUSY
);
738 ring
->data
[i
].drop
= 0;
741 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
, BUS_DMASYNC_PREWRITE
);
743 ring
->cur
= ring
->next
= 0;
744 ring
->cur_decrypt
= 0;
748 rt2560_free_rx_ring(struct rt2560_softc
*sc
, struct rt2560_rx_ring
*ring
)
750 struct rt2560_rx_data
*data
;
753 if (ring
->desc
!= NULL
) {
754 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
,
755 BUS_DMASYNC_POSTWRITE
);
756 bus_dmamap_unload(ring
->desc_dmat
, ring
->desc_map
);
757 bus_dmamem_free(ring
->desc_dmat
, ring
->desc
, ring
->desc_map
);
760 if (ring
->desc_dmat
!= NULL
)
761 bus_dma_tag_destroy(ring
->desc_dmat
);
763 if (ring
->data
!= NULL
) {
764 for (i
= 0; i
< ring
->count
; i
++) {
765 data
= &ring
->data
[i
];
767 if (data
->m
!= NULL
) {
768 bus_dmamap_sync(ring
->data_dmat
, data
->map
,
769 BUS_DMASYNC_POSTREAD
);
770 bus_dmamap_unload(ring
->data_dmat
, data
->map
);
774 if (data
->map
!= NULL
)
775 bus_dmamap_destroy(ring
->data_dmat
, data
->map
);
778 kfree(ring
->data
, M_DEVBUF
);
781 if (ring
->data_dmat
!= NULL
)
782 bus_dma_tag_destroy(ring
->data_dmat
);
786 rt2560_newstate(struct ieee80211vap
*vap
, enum ieee80211_state nstate
, int arg
)
788 struct rt2560_vap
*rvp
= RT2560_VAP(vap
);
789 struct rt2560_softc
*sc
= vap
->iv_ic
->ic_softc
;
792 if (nstate
== IEEE80211_S_INIT
&& vap
->iv_state
== IEEE80211_S_RUN
) {
793 /* abort TSF synchronization */
794 RAL_WRITE(sc
, RT2560_CSR14
, 0);
796 /* turn association led off */
797 rt2560_update_led(sc
, 0, 0);
800 error
= rvp
->ral_newstate(vap
, nstate
, arg
);
802 if (error
== 0 && nstate
== IEEE80211_S_RUN
) {
803 struct ieee80211_node
*ni
= vap
->iv_bss
;
806 if (vap
->iv_opmode
!= IEEE80211_M_MONITOR
) {
807 rt2560_update_plcp(sc
);
808 rt2560_set_basicrates(sc
, &ni
->ni_rates
);
809 rt2560_set_bssid(sc
, ni
->ni_bssid
);
812 if (vap
->iv_opmode
== IEEE80211_M_HOSTAP
||
813 vap
->iv_opmode
== IEEE80211_M_IBSS
||
814 vap
->iv_opmode
== IEEE80211_M_MBSS
) {
815 m
= ieee80211_beacon_alloc(ni
);
817 device_printf(sc
->sc_dev
,
818 "could not allocate beacon\n");
821 ieee80211_ref_node(ni
);
822 error
= rt2560_tx_bcn(sc
, m
, ni
);
827 /* turn association led on */
828 rt2560_update_led(sc
, 1, 0);
830 if (vap
->iv_opmode
!= IEEE80211_M_MONITOR
)
831 rt2560_enable_tsf_sync(sc
);
833 rt2560_enable_tsf(sc
);
839 * Read 16 bits at address 'addr' from the serial EEPROM (either 93C46 or
843 rt2560_eeprom_read(struct rt2560_softc
*sc
, uint8_t addr
)
849 /* clock C once before the first command */
850 RT2560_EEPROM_CTL(sc
, 0);
852 RT2560_EEPROM_CTL(sc
, RT2560_S
);
853 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_C
);
854 RT2560_EEPROM_CTL(sc
, RT2560_S
);
856 /* write start bit (1) */
857 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_D
);
858 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_D
| RT2560_C
);
860 /* write READ opcode (10) */
861 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_D
);
862 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_D
| RT2560_C
);
863 RT2560_EEPROM_CTL(sc
, RT2560_S
);
864 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_C
);
866 /* write address (A5-A0 or A7-A0) */
867 n
= (RAL_READ(sc
, RT2560_CSR21
) & RT2560_93C46
) ? 5 : 7;
868 for (; n
>= 0; n
--) {
869 RT2560_EEPROM_CTL(sc
, RT2560_S
|
870 (((addr
>> n
) & 1) << RT2560_SHIFT_D
));
871 RT2560_EEPROM_CTL(sc
, RT2560_S
|
872 (((addr
>> n
) & 1) << RT2560_SHIFT_D
) | RT2560_C
);
875 RT2560_EEPROM_CTL(sc
, RT2560_S
);
877 /* read data Q15-Q0 */
879 for (n
= 15; n
>= 0; n
--) {
880 RT2560_EEPROM_CTL(sc
, RT2560_S
| RT2560_C
);
881 tmp
= RAL_READ(sc
, RT2560_CSR21
);
882 val
|= ((tmp
& RT2560_Q
) >> RT2560_SHIFT_Q
) << n
;
883 RT2560_EEPROM_CTL(sc
, RT2560_S
);
886 RT2560_EEPROM_CTL(sc
, 0);
888 /* clear Chip Select and clock C */
889 RT2560_EEPROM_CTL(sc
, RT2560_S
);
890 RT2560_EEPROM_CTL(sc
, 0);
891 RT2560_EEPROM_CTL(sc
, RT2560_C
);
897 * Some frames were processed by the hardware cipher engine and are ready for
901 rt2560_encryption_intr(struct rt2560_softc
*sc
)
903 struct rt2560_tx_desc
*desc
;
906 /* retrieve last descriptor index processed by cipher engine */
907 hw
= RAL_READ(sc
, RT2560_SECCSR1
) - sc
->txq
.physaddr
;
908 hw
/= RT2560_TX_DESC_SIZE
;
910 bus_dmamap_sync(sc
->txq
.desc_dmat
, sc
->txq
.desc_map
,
911 BUS_DMASYNC_POSTREAD
);
913 while (sc
->txq
.next_encrypt
!= hw
) {
914 if (sc
->txq
.next_encrypt
== sc
->txq
.cur_encrypt
) {
915 kprintf("hw encrypt %d, cur_encrypt %d\n", hw
,
916 sc
->txq
.cur_encrypt
);
920 desc
= &sc
->txq
.desc
[sc
->txq
.next_encrypt
];
922 if ((le32toh(desc
->flags
) & RT2560_TX_BUSY
) ||
923 (le32toh(desc
->flags
) & RT2560_TX_CIPHER_BUSY
))
926 /* for TKIP, swap eiv field to fix a bug in ASIC */
927 if ((le32toh(desc
->flags
) & RT2560_TX_CIPHER_MASK
) ==
928 RT2560_TX_CIPHER_TKIP
)
929 desc
->eiv
= bswap32(desc
->eiv
);
931 /* mark the frame ready for transmission */
932 desc
->flags
|= htole32(RT2560_TX_VALID
);
933 desc
->flags
|= htole32(RT2560_TX_BUSY
);
935 DPRINTFN(sc
, 15, "encryption done idx=%u\n",
936 sc
->txq
.next_encrypt
);
938 sc
->txq
.next_encrypt
=
939 (sc
->txq
.next_encrypt
+ 1) % RT2560_TX_RING_COUNT
;
942 bus_dmamap_sync(sc
->txq
.desc_dmat
, sc
->txq
.desc_map
,
943 BUS_DMASYNC_PREWRITE
);
946 RAL_WRITE(sc
, RT2560_TXCSR0
, RT2560_KICK_TX
);
950 rt2560_tx_intr(struct rt2560_softc
*sc
)
952 struct rt2560_tx_desc
*desc
;
953 struct rt2560_tx_data
*data
;
955 struct ieee80211vap
*vap
;
956 struct ieee80211_node
*ni
;
958 int retrycnt
, status
;
960 bus_dmamap_sync(sc
->txq
.desc_dmat
, sc
->txq
.desc_map
,
961 BUS_DMASYNC_POSTREAD
);
964 desc
= &sc
->txq
.desc
[sc
->txq
.next
];
965 data
= &sc
->txq
.data
[sc
->txq
.next
];
967 flags
= le32toh(desc
->flags
);
968 if ((flags
& RT2560_TX_BUSY
) ||
969 (flags
& RT2560_TX_CIPHER_BUSY
) ||
970 !(flags
& RT2560_TX_VALID
))
977 switch (flags
& RT2560_TX_RESULT_MASK
) {
978 case RT2560_TX_SUCCESS
:
981 DPRINTFN(sc
, 10, "%s\n", "data frame sent successfully");
982 if (data
->rix
!= IEEE80211_FIXED_RATE_NONE
)
983 ieee80211_ratectl_tx_complete(vap
, ni
,
984 IEEE80211_RATECTL_TX_SUCCESS
,
989 case RT2560_TX_SUCCESS_RETRY
:
990 retrycnt
= RT2560_TX_RETRYCNT(flags
);
992 DPRINTFN(sc
, 9, "data frame sent after %u retries\n",
994 if (data
->rix
!= IEEE80211_FIXED_RATE_NONE
)
995 ieee80211_ratectl_tx_complete(vap
, ni
,
996 IEEE80211_RATECTL_TX_SUCCESS
,
1001 case RT2560_TX_FAIL_RETRY
:
1002 retrycnt
= RT2560_TX_RETRYCNT(flags
);
1004 DPRINTFN(sc
, 9, "data frame failed after %d retries\n",
1006 if (data
->rix
!= IEEE80211_FIXED_RATE_NONE
)
1007 ieee80211_ratectl_tx_complete(vap
, ni
,
1008 IEEE80211_RATECTL_TX_FAILURE
,
1013 case RT2560_TX_FAIL_INVALID
:
1014 case RT2560_TX_FAIL_OTHER
:
1016 device_printf(sc
->sc_dev
, "sending data frame failed "
1021 bus_dmamap_sync(sc
->txq
.data_dmat
, data
->map
,
1022 BUS_DMASYNC_POSTWRITE
);
1023 bus_dmamap_unload(sc
->txq
.data_dmat
, data
->map
);
1025 ieee80211_tx_complete(ni
, m
, status
);
1029 /* descriptor is no longer valid */
1030 desc
->flags
&= ~htole32(RT2560_TX_VALID
);
1032 DPRINTFN(sc
, 15, "tx done idx=%u\n", sc
->txq
.next
);
1035 sc
->txq
.next
= (sc
->txq
.next
+ 1) % RT2560_TX_RING_COUNT
;
1038 bus_dmamap_sync(sc
->txq
.desc_dmat
, sc
->txq
.desc_map
,
1039 BUS_DMASYNC_PREWRITE
);
1041 if (sc
->prioq
.queued
== 0 && sc
->txq
.queued
== 0)
1042 sc
->sc_tx_timer
= 0;
1044 if (sc
->txq
.queued
< RT2560_TX_RING_COUNT
- 1)
1049 rt2560_prio_intr(struct rt2560_softc
*sc
)
1051 struct rt2560_tx_desc
*desc
;
1052 struct rt2560_tx_data
*data
;
1053 struct ieee80211_node
*ni
;
1057 bus_dmamap_sync(sc
->prioq
.desc_dmat
, sc
->prioq
.desc_map
,
1058 BUS_DMASYNC_POSTREAD
);
1061 desc
= &sc
->prioq
.desc
[sc
->prioq
.next
];
1062 data
= &sc
->prioq
.data
[sc
->prioq
.next
];
1064 flags
= le32toh(desc
->flags
);
1065 if ((flags
& RT2560_TX_BUSY
) || (flags
& RT2560_TX_VALID
) == 0)
1068 switch (flags
& RT2560_TX_RESULT_MASK
) {
1069 case RT2560_TX_SUCCESS
:
1070 DPRINTFN(sc
, 10, "%s\n", "mgt frame sent successfully");
1073 case RT2560_TX_SUCCESS_RETRY
:
1074 DPRINTFN(sc
, 9, "mgt frame sent after %u retries\n",
1075 (flags
>> 5) & 0x7);
1078 case RT2560_TX_FAIL_RETRY
:
1079 DPRINTFN(sc
, 9, "%s\n",
1080 "sending mgt frame failed (too much retries)");
1083 case RT2560_TX_FAIL_INVALID
:
1084 case RT2560_TX_FAIL_OTHER
:
1086 device_printf(sc
->sc_dev
, "sending mgt frame failed "
1091 bus_dmamap_sync(sc
->prioq
.data_dmat
, data
->map
,
1092 BUS_DMASYNC_POSTWRITE
);
1093 bus_dmamap_unload(sc
->prioq
.data_dmat
, data
->map
);
1100 /* descriptor is no longer valid */
1101 desc
->flags
&= ~htole32(RT2560_TX_VALID
);
1103 DPRINTFN(sc
, 15, "prio done idx=%u\n", sc
->prioq
.next
);
1106 sc
->prioq
.next
= (sc
->prioq
.next
+ 1) % RT2560_PRIO_RING_COUNT
;
1108 if (m
->m_flags
& M_TXCB
)
1109 ieee80211_process_callback(ni
, m
,
1110 (flags
& RT2560_TX_RESULT_MASK
) &~
1111 (RT2560_TX_SUCCESS
| RT2560_TX_SUCCESS_RETRY
));
1113 ieee80211_free_node(ni
);
1116 bus_dmamap_sync(sc
->prioq
.desc_dmat
, sc
->prioq
.desc_map
,
1117 BUS_DMASYNC_PREWRITE
);
1119 if (sc
->prioq
.queued
== 0 && sc
->txq
.queued
== 0)
1120 sc
->sc_tx_timer
= 0;
1122 if (sc
->prioq
.queued
< RT2560_PRIO_RING_COUNT
)
1127 * Some frames were processed by the hardware cipher engine and are ready for
1128 * handoff to the IEEE802.11 layer.
1131 rt2560_decryption_intr(struct rt2560_softc
*sc
)
1133 struct ieee80211com
*ic
= &sc
->sc_ic
;
1134 struct rt2560_rx_desc
*desc
;
1135 struct rt2560_rx_data
*data
;
1136 bus_addr_t physaddr
;
1137 struct ieee80211_frame
*wh
;
1138 struct ieee80211_node
*ni
;
1139 struct mbuf
*mnew
, *m
;
1143 /* retrieve last descriptor index processed by cipher engine */
1144 hw
= RAL_READ(sc
, RT2560_SECCSR0
) - sc
->rxq
.physaddr
;
1145 hw
/= RT2560_RX_DESC_SIZE
;
1147 bus_dmamap_sync(sc
->rxq
.desc_dmat
, sc
->rxq
.desc_map
,
1148 BUS_DMASYNC_POSTREAD
);
1150 for (; sc
->rxq
.cur_decrypt
!= hw
;) {
1151 desc
= &sc
->rxq
.desc
[sc
->rxq
.cur_decrypt
];
1152 data
= &sc
->rxq
.data
[sc
->rxq
.cur_decrypt
];
1154 if ((le32toh(desc
->flags
) & RT2560_RX_BUSY
) ||
1155 (le32toh(desc
->flags
) & RT2560_RX_CIPHER_BUSY
))
1159 #if defined(__DragonFly__)
1160 /* not implemeted */
1162 counter_u64_add(ic
->ic_ierrors
, 1);
1167 if ((le32toh(desc
->flags
) & RT2560_RX_CIPHER_MASK
) != 0 &&
1168 (le32toh(desc
->flags
) & RT2560_RX_ICV_ERROR
)) {
1169 #if defined(__DragonFly__)
1170 /* not implemeted */
1172 counter_u64_add(ic
->ic_ierrors
, 1);
1178 * Try to allocate a new mbuf for this ring element and load it
1179 * before processing the current mbuf. If the ring element
1180 * cannot be loaded, drop the received packet and reuse the old
1181 * mbuf. In the unlikely case that the old mbuf can't be
1182 * reloaded either, explicitly panic.
1184 mnew
= m_getcl(M_NOWAIT
, MT_DATA
, M_PKTHDR
);
1186 #if defined(__DragonFly__)
1187 /* not implemeted */
1189 counter_u64_add(ic
->ic_ierrors
, 1);
1194 bus_dmamap_sync(sc
->rxq
.data_dmat
, data
->map
,
1195 BUS_DMASYNC_POSTREAD
);
1196 bus_dmamap_unload(sc
->rxq
.data_dmat
, data
->map
);
1198 error
= bus_dmamap_load(sc
->rxq
.data_dmat
, data
->map
,
1199 mtod(mnew
, void *), MCLBYTES
, rt2560_dma_map_addr
,
1204 /* try to reload the old mbuf */
1205 error
= bus_dmamap_load(sc
->rxq
.data_dmat
, data
->map
,
1206 mtod(data
->m
, void *), MCLBYTES
,
1207 rt2560_dma_map_addr
, &physaddr
, 0);
1209 /* very unlikely that it will fail... */
1210 panic("%s: could not load old rx mbuf",
1211 device_get_name(sc
->sc_dev
));
1213 #if defined(__DragonFly__)
1214 /* not implemeted */
1216 counter_u64_add(ic
->ic_ierrors
, 1);
1222 * New mbuf successfully loaded, update Rx ring and continue
1227 desc
->physaddr
= htole32(physaddr
);
1230 m
->m_pkthdr
.len
= m
->m_len
=
1231 (le32toh(desc
->flags
) >> 16) & 0xfff;
1233 rssi
= RT2560_RSSI(sc
, desc
->rssi
);
1234 nf
= RT2560_NOISE_FLOOR
;
1235 if (ieee80211_radiotap_active(ic
)) {
1236 struct rt2560_rx_radiotap_header
*tap
= &sc
->sc_rxtap
;
1237 uint32_t tsf_lo
, tsf_hi
;
1239 /* get timestamp (low and high 32 bits) */
1240 tsf_hi
= RAL_READ(sc
, RT2560_CSR17
);
1241 tsf_lo
= RAL_READ(sc
, RT2560_CSR16
);
1244 htole64(((uint64_t)tsf_hi
<< 32) | tsf_lo
);
1246 tap
->wr_rate
= ieee80211_plcp2rate(desc
->rate
,
1247 (desc
->flags
& htole32(RT2560_RX_OFDM
)) ?
1248 IEEE80211_T_OFDM
: IEEE80211_T_CCK
);
1249 tap
->wr_antenna
= sc
->rx_ant
;
1250 tap
->wr_antsignal
= nf
+ rssi
;
1251 tap
->wr_antnoise
= nf
;
1254 sc
->sc_flags
|= RT2560_F_INPUT_RUNNING
;
1256 wh
= mtod(m
, struct ieee80211_frame
*);
1257 ni
= ieee80211_find_rxnode(ic
,
1258 (struct ieee80211_frame_min
*)wh
);
1260 (void) ieee80211_input(ni
, m
, rssi
, nf
);
1261 ieee80211_free_node(ni
);
1263 (void) ieee80211_input_all(ic
, m
, rssi
, nf
);
1266 sc
->sc_flags
&= ~RT2560_F_INPUT_RUNNING
;
1267 skip
: desc
->flags
= htole32(RT2560_RX_BUSY
);
1269 DPRINTFN(sc
, 15, "decryption done idx=%u\n", sc
->rxq
.cur_decrypt
);
1271 sc
->rxq
.cur_decrypt
=
1272 (sc
->rxq
.cur_decrypt
+ 1) % RT2560_RX_RING_COUNT
;
1275 bus_dmamap_sync(sc
->rxq
.desc_dmat
, sc
->rxq
.desc_map
,
1276 BUS_DMASYNC_PREWRITE
);
1280 * Some frames were received. Pass them to the hardware cipher engine before
1281 * sending them to the 802.11 layer.
1284 rt2560_rx_intr(struct rt2560_softc
*sc
)
1286 struct rt2560_rx_desc
*desc
;
1287 struct rt2560_rx_data
*data
;
1289 bus_dmamap_sync(sc
->rxq
.desc_dmat
, sc
->rxq
.desc_map
,
1290 BUS_DMASYNC_POSTREAD
);
1293 desc
= &sc
->rxq
.desc
[sc
->rxq
.cur
];
1294 data
= &sc
->rxq
.data
[sc
->rxq
.cur
];
1296 if ((le32toh(desc
->flags
) & RT2560_RX_BUSY
) ||
1297 (le32toh(desc
->flags
) & RT2560_RX_CIPHER_BUSY
))
1302 if ((le32toh(desc
->flags
) & RT2560_RX_PHY_ERROR
) ||
1303 (le32toh(desc
->flags
) & RT2560_RX_CRC_ERROR
)) {
1305 * This should not happen since we did not request
1306 * to receive those frames when we filled RXCSR0.
1308 DPRINTFN(sc
, 5, "PHY or CRC error flags 0x%08x\n",
1309 le32toh(desc
->flags
));
1313 if (((le32toh(desc
->flags
) >> 16) & 0xfff) > MCLBYTES
) {
1314 DPRINTFN(sc
, 5, "%s\n", "bad length");
1318 /* mark the frame for decryption */
1319 desc
->flags
|= htole32(RT2560_RX_CIPHER_BUSY
);
1321 DPRINTFN(sc
, 15, "rx done idx=%u\n", sc
->rxq
.cur
);
1323 sc
->rxq
.cur
= (sc
->rxq
.cur
+ 1) % RT2560_RX_RING_COUNT
;
1326 bus_dmamap_sync(sc
->rxq
.desc_dmat
, sc
->rxq
.desc_map
,
1327 BUS_DMASYNC_PREWRITE
);
1330 RAL_WRITE(sc
, RT2560_SECCSR0
, RT2560_KICK_DECRYPT
);
1334 rt2560_beacon_update(struct ieee80211vap
*vap
, int item
)
1336 struct ieee80211_beacon_offsets
*bo
= &vap
->iv_bcn_off
;
1338 setbit(bo
->bo_flags
, item
);
1342 * This function is called periodically in IBSS mode when a new beacon must be
1346 rt2560_beacon_expire(struct rt2560_softc
*sc
)
1348 struct ieee80211com
*ic
= &sc
->sc_ic
;
1349 struct rt2560_tx_data
*data
;
1351 if (ic
->ic_opmode
!= IEEE80211_M_IBSS
&&
1352 ic
->ic_opmode
!= IEEE80211_M_HOSTAP
&&
1353 ic
->ic_opmode
!= IEEE80211_M_MBSS
)
1356 data
= &sc
->bcnq
.data
[sc
->bcnq
.next
];
1358 * Don't send beacon if bsschan isn't set
1360 if (data
->ni
== NULL
)
1363 bus_dmamap_sync(sc
->bcnq
.data_dmat
, data
->map
, BUS_DMASYNC_POSTWRITE
);
1364 bus_dmamap_unload(sc
->bcnq
.data_dmat
, data
->map
);
1366 /* XXX 1 =>'s mcast frames which means all PS sta's will wakeup! */
1367 ieee80211_beacon_update(data
->ni
, data
->m
, 1);
1369 rt2560_tx_bcn(sc
, data
->m
, data
->ni
);
1371 DPRINTFN(sc
, 15, "%s", "beacon expired\n");
1373 sc
->bcnq
.next
= (sc
->bcnq
.next
+ 1) % RT2560_BEACON_RING_COUNT
;
1378 rt2560_wakeup_expire(struct rt2560_softc
*sc
)
1380 DPRINTFN(sc
, 2, "%s", "wakeup expired\n");
1384 rt2560_intr(void *arg
)
1386 struct rt2560_softc
*sc
= arg
;
1391 /* disable interrupts */
1392 RAL_WRITE(sc
, RT2560_CSR8
, 0xffffffff);
1394 /* don't re-enable interrupts if we're shutting down */
1395 if (!(sc
->sc_flags
& RT2560_F_RUNNING
)) {
1400 r
= RAL_READ(sc
, RT2560_CSR7
);
1401 RAL_WRITE(sc
, RT2560_CSR7
, r
);
1403 if (r
& RT2560_BEACON_EXPIRE
)
1404 rt2560_beacon_expire(sc
);
1406 if (r
& RT2560_WAKEUP_EXPIRE
)
1407 rt2560_wakeup_expire(sc
);
1409 if (r
& RT2560_ENCRYPTION_DONE
)
1410 rt2560_encryption_intr(sc
);
1412 if (r
& RT2560_TX_DONE
)
1415 if (r
& RT2560_PRIO_DONE
)
1416 rt2560_prio_intr(sc
);
1418 if (r
& RT2560_DECRYPTION_DONE
)
1419 rt2560_decryption_intr(sc
);
1421 if (r
& RT2560_RX_DONE
) {
1423 rt2560_encryption_intr(sc
);
1426 /* re-enable interrupts */
1427 RAL_WRITE(sc
, RT2560_CSR8
, RT2560_INTR_MASK
);
1432 #define RAL_SIFS 10 /* us */
1434 #define RT2560_TXRX_TURNAROUND 10 /* us */
1437 rt2560_plcp_signal(int rate
)
1440 /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
1441 case 12: return 0xb;
1442 case 18: return 0xf;
1443 case 24: return 0xa;
1444 case 36: return 0xe;
1445 case 48: return 0x9;
1446 case 72: return 0xd;
1447 case 96: return 0x8;
1448 case 108: return 0xc;
1450 /* CCK rates (NB: not IEEE std, device-specific) */
1453 case 11: return 0x2;
1454 case 22: return 0x3;
1456 return 0xff; /* XXX unsupported/unknown rate */
1460 rt2560_setup_tx_desc(struct rt2560_softc
*sc
, struct rt2560_tx_desc
*desc
,
1461 uint32_t flags
, int len
, int rate
, int encrypt
, bus_addr_t physaddr
)
1463 struct ieee80211com
*ic
= &sc
->sc_ic
;
1464 uint16_t plcp_length
;
1467 desc
->flags
= htole32(flags
);
1468 desc
->flags
|= htole32(len
<< 16);
1470 desc
->physaddr
= htole32(physaddr
);
1471 desc
->wme
= htole16(
1473 RT2560_LOGCWMIN(3) |
1474 RT2560_LOGCWMAX(8));
1476 /* setup PLCP fields */
1477 desc
->plcp_signal
= rt2560_plcp_signal(rate
);
1478 desc
->plcp_service
= 4;
1480 len
+= IEEE80211_CRC_LEN
;
1481 if (ieee80211_rate2phytype(ic
->ic_rt
, rate
) == IEEE80211_T_OFDM
) {
1482 desc
->flags
|= htole32(RT2560_TX_OFDM
);
1484 plcp_length
= len
& 0xfff;
1485 desc
->plcp_length_hi
= plcp_length
>> 6;
1486 desc
->plcp_length_lo
= plcp_length
& 0x3f;
1488 plcp_length
= howmany(16 * len
, rate
);
1490 remainder
= (16 * len
) % 22;
1491 if (remainder
!= 0 && remainder
< 7)
1492 desc
->plcp_service
|= RT2560_PLCP_LENGEXT
;
1494 desc
->plcp_length_hi
= plcp_length
>> 8;
1495 desc
->plcp_length_lo
= plcp_length
& 0xff;
1497 if (rate
!= 2 && (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
))
1498 desc
->plcp_signal
|= 0x08;
1502 desc
->flags
|= htole32(RT2560_TX_VALID
);
1503 desc
->flags
|= encrypt
? htole32(RT2560_TX_CIPHER_BUSY
)
1504 : htole32(RT2560_TX_BUSY
);
1508 rt2560_tx_bcn(struct rt2560_softc
*sc
, struct mbuf
*m0
,
1509 struct ieee80211_node
*ni
)
1511 struct ieee80211vap
*vap
= ni
->ni_vap
;
1512 struct rt2560_tx_desc
*desc
;
1513 struct rt2560_tx_data
*data
;
1514 bus_dma_segment_t segs
[RT2560_MAX_SCATTER
];
1515 int nsegs
, rate
, error
;
1517 desc
= &sc
->bcnq
.desc
[sc
->bcnq
.cur
];
1518 data
= &sc
->bcnq
.data
[sc
->bcnq
.cur
];
1520 /* XXX maybe a separate beacon rate? */
1521 rate
= vap
->iv_txparms
[ieee80211_chan2mode(ni
->ni_chan
)].mgmtrate
;
1523 #if defined(__DragonFly__)
1524 error
= bus_dmamap_load_mbuf_segment(sc
->bcnq
.data_dmat
, data
->map
, m0
,
1525 segs
, 1, &nsegs
, BUS_DMA_NOWAIT
);
1527 error
= bus_dmamap_load_mbuf_sg(sc
->bcnq
.data_dmat
, data
->map
, m0
,
1528 segs
, &nsegs
, BUS_DMA_NOWAIT
);
1531 device_printf(sc
->sc_dev
, "could not map mbuf (error %d)\n",
1537 if (ieee80211_radiotap_active_vap(vap
)) {
1538 struct rt2560_tx_radiotap_header
*tap
= &sc
->sc_txtap
;
1541 tap
->wt_rate
= rate
;
1542 tap
->wt_antenna
= sc
->tx_ant
;
1544 ieee80211_radiotap_tx(vap
, m0
);
1550 rt2560_setup_tx_desc(sc
, desc
, RT2560_TX_IFS_NEWBACKOFF
|
1551 RT2560_TX_TIMESTAMP
, m0
->m_pkthdr
.len
, rate
, 0, segs
->ds_addr
);
1553 DPRINTFN(sc
, 10, "sending beacon frame len=%u idx=%u rate=%u\n",
1554 m0
->m_pkthdr
.len
, sc
->bcnq
.cur
, rate
);
1556 bus_dmamap_sync(sc
->bcnq
.data_dmat
, data
->map
, BUS_DMASYNC_PREWRITE
);
1557 bus_dmamap_sync(sc
->bcnq
.desc_dmat
, sc
->bcnq
.desc_map
,
1558 BUS_DMASYNC_PREWRITE
);
1560 sc
->bcnq
.cur
= (sc
->bcnq
.cur
+ 1) % RT2560_BEACON_RING_COUNT
;
1566 rt2560_tx_mgt(struct rt2560_softc
*sc
, struct mbuf
*m0
,
1567 struct ieee80211_node
*ni
)
1569 struct ieee80211vap
*vap
= ni
->ni_vap
;
1570 struct ieee80211com
*ic
= ni
->ni_ic
;
1571 struct rt2560_tx_desc
*desc
;
1572 struct rt2560_tx_data
*data
;
1573 struct ieee80211_frame
*wh
;
1574 struct ieee80211_key
*k
;
1575 bus_dma_segment_t segs
[RT2560_MAX_SCATTER
];
1578 int nsegs
, rate
, error
;
1580 desc
= &sc
->prioq
.desc
[sc
->prioq
.cur
];
1581 data
= &sc
->prioq
.data
[sc
->prioq
.cur
];
1583 rate
= vap
->iv_txparms
[ieee80211_chan2mode(ic
->ic_curchan
)].mgmtrate
;
1585 wh
= mtod(m0
, struct ieee80211_frame
*);
1587 if (wh
->i_fc
[1] & IEEE80211_FC1_PROTECTED
) {
1588 k
= ieee80211_crypto_encap(ni
, m0
);
1595 #if defined(__DragonFly__)
1596 error
= bus_dmamap_load_mbuf_segment(sc
->prioq
.data_dmat
, data
->map
, m0
,
1597 segs
, 1, &nsegs
, BUS_DMA_NOWAIT
);
1599 error
= bus_dmamap_load_mbuf_sg(sc
->prioq
.data_dmat
, data
->map
, m0
,
1603 device_printf(sc
->sc_dev
, "could not map mbuf (error %d)\n",
1609 if (ieee80211_radiotap_active_vap(vap
)) {
1610 struct rt2560_tx_radiotap_header
*tap
= &sc
->sc_txtap
;
1613 tap
->wt_rate
= rate
;
1614 tap
->wt_antenna
= sc
->tx_ant
;
1616 ieee80211_radiotap_tx(vap
, m0
);
1621 /* management frames are not taken into account for amrr */
1622 data
->rix
= IEEE80211_FIXED_RATE_NONE
;
1624 wh
= mtod(m0
, struct ieee80211_frame
*);
1626 if (!IEEE80211_IS_MULTICAST(wh
->i_addr1
)) {
1627 flags
|= RT2560_TX_ACK
;
1629 dur
= ieee80211_ack_duration(ic
->ic_rt
,
1630 rate
, ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
);
1631 *(uint16_t *)wh
->i_dur
= htole16(dur
);
1633 /* tell hardware to add timestamp for probe responses */
1634 if ((wh
->i_fc
[0] & IEEE80211_FC0_TYPE_MASK
) ==
1635 IEEE80211_FC0_TYPE_MGT
&&
1636 (wh
->i_fc
[0] & IEEE80211_FC0_SUBTYPE_MASK
) ==
1637 IEEE80211_FC0_SUBTYPE_PROBE_RESP
)
1638 flags
|= RT2560_TX_TIMESTAMP
;
1641 rt2560_setup_tx_desc(sc
, desc
, flags
, m0
->m_pkthdr
.len
, rate
, 0,
1644 bus_dmamap_sync(sc
->prioq
.data_dmat
, data
->map
, BUS_DMASYNC_PREWRITE
);
1645 bus_dmamap_sync(sc
->prioq
.desc_dmat
, sc
->prioq
.desc_map
,
1646 BUS_DMASYNC_PREWRITE
);
1648 DPRINTFN(sc
, 10, "sending mgt frame len=%u idx=%u rate=%u\n",
1649 m0
->m_pkthdr
.len
, sc
->prioq
.cur
, rate
);
1653 sc
->prioq
.cur
= (sc
->prioq
.cur
+ 1) % RT2560_PRIO_RING_COUNT
;
1654 RAL_WRITE(sc
, RT2560_TXCSR0
, RT2560_KICK_PRIO
);
1660 rt2560_sendprot(struct rt2560_softc
*sc
,
1661 const struct mbuf
*m
, struct ieee80211_node
*ni
, int prot
, int rate
)
1663 struct ieee80211com
*ic
= ni
->ni_ic
;
1664 const struct ieee80211_frame
*wh
;
1665 struct rt2560_tx_desc
*desc
;
1666 struct rt2560_tx_data
*data
;
1668 int protrate
, ackrate
, pktlen
, flags
, isshort
, error
;
1670 bus_dma_segment_t segs
[RT2560_MAX_SCATTER
];
1673 KASSERT(prot
== IEEE80211_PROT_RTSCTS
|| prot
== IEEE80211_PROT_CTSONLY
,
1674 ("protection %d", prot
));
1676 wh
= mtod(m
, const struct ieee80211_frame
*);
1677 pktlen
= m
->m_pkthdr
.len
+ IEEE80211_CRC_LEN
;
1679 protrate
= ieee80211_ctl_rate(ic
->ic_rt
, rate
);
1680 ackrate
= ieee80211_ack_rate(ic
->ic_rt
, rate
);
1682 isshort
= (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
) != 0;
1683 dur
= ieee80211_compute_duration(ic
->ic_rt
, pktlen
, rate
, isshort
)
1684 + ieee80211_ack_duration(ic
->ic_rt
, rate
, isshort
);
1685 flags
= RT2560_TX_MORE_FRAG
;
1686 if (prot
== IEEE80211_PROT_RTSCTS
) {
1687 /* NB: CTS is the same size as an ACK */
1688 dur
+= ieee80211_ack_duration(ic
->ic_rt
, rate
, isshort
);
1689 flags
|= RT2560_TX_ACK
;
1690 mprot
= ieee80211_alloc_rts(ic
, wh
->i_addr1
, wh
->i_addr2
, dur
);
1692 mprot
= ieee80211_alloc_cts(ic
, ni
->ni_vap
->iv_myaddr
, dur
);
1694 if (mprot
== NULL
) {
1695 /* XXX stat + msg */
1699 desc
= &sc
->txq
.desc
[sc
->txq
.cur_encrypt
];
1700 data
= &sc
->txq
.data
[sc
->txq
.cur_encrypt
];
1702 #if defined(__DragonFly__)
1703 error
= bus_dmamap_load_mbuf_segment(sc
->txq
.data_dmat
, data
->map
,
1704 mprot
, segs
, 1, &nsegs
, BUS_DMA_NOWAIT
);
1706 error
= bus_dmamap_load_mbuf_sg(sc
->txq
.data_dmat
, data
->map
,
1707 mprot
, segs
, &nsegs
, 0);
1710 device_printf(sc
->sc_dev
,
1711 "could not map mbuf (error %d)\n", error
);
1717 data
->ni
= ieee80211_ref_node(ni
);
1718 /* ctl frames are not taken into account for amrr */
1719 data
->rix
= IEEE80211_FIXED_RATE_NONE
;
1721 rt2560_setup_tx_desc(sc
, desc
, flags
, mprot
->m_pkthdr
.len
, protrate
, 1,
1724 bus_dmamap_sync(sc
->txq
.data_dmat
, data
->map
,
1725 BUS_DMASYNC_PREWRITE
);
1728 sc
->txq
.cur_encrypt
= (sc
->txq
.cur_encrypt
+ 1) % RT2560_TX_RING_COUNT
;
1734 rt2560_tx_raw(struct rt2560_softc
*sc
, struct mbuf
*m0
,
1735 struct ieee80211_node
*ni
, const struct ieee80211_bpf_params
*params
)
1737 struct ieee80211vap
*vap
= ni
->ni_vap
;
1738 struct ieee80211com
*ic
= ni
->ni_ic
;
1739 struct rt2560_tx_desc
*desc
;
1740 struct rt2560_tx_data
*data
;
1741 bus_dma_segment_t segs
[RT2560_MAX_SCATTER
];
1743 int nsegs
, rate
, error
;
1745 desc
= &sc
->prioq
.desc
[sc
->prioq
.cur
];
1746 data
= &sc
->prioq
.data
[sc
->prioq
.cur
];
1748 rate
= params
->ibp_rate0
;
1749 if (!ieee80211_isratevalid(ic
->ic_rt
, rate
)) {
1750 /* XXX fall back to mcast/mgmt rate? */
1756 if ((params
->ibp_flags
& IEEE80211_BPF_NOACK
) == 0)
1757 flags
|= RT2560_TX_ACK
;
1758 if (params
->ibp_flags
& (IEEE80211_BPF_RTS
|IEEE80211_BPF_CTS
)) {
1759 error
= rt2560_sendprot(sc
, m0
, ni
,
1760 params
->ibp_flags
& IEEE80211_BPF_RTS
?
1761 IEEE80211_PROT_RTSCTS
: IEEE80211_PROT_CTSONLY
,
1767 flags
|= RT2560_TX_LONG_RETRY
| RT2560_TX_IFS_SIFS
;
1770 #if defined(__DragonFly__)
1771 error
= bus_dmamap_load_mbuf_segment(sc
->prioq
.data_dmat
, data
->map
, m0
,
1772 segs
, 1, &nsegs
, BUS_DMA_NOWAIT
);
1774 error
= bus_dmamap_load_mbuf_sg(sc
->prioq
.data_dmat
, data
->map
, m0
,
1778 device_printf(sc
->sc_dev
, "could not map mbuf (error %d)\n",
1784 if (ieee80211_radiotap_active_vap(vap
)) {
1785 struct rt2560_tx_radiotap_header
*tap
= &sc
->sc_txtap
;
1788 tap
->wt_rate
= rate
;
1789 tap
->wt_antenna
= sc
->tx_ant
;
1791 ieee80211_radiotap_tx(ni
->ni_vap
, m0
);
1797 /* XXX need to setup descriptor ourself */
1798 rt2560_setup_tx_desc(sc
, desc
, flags
, m0
->m_pkthdr
.len
,
1799 rate
, (params
->ibp_flags
& IEEE80211_BPF_CRYPTO
) != 0,
1802 bus_dmamap_sync(sc
->prioq
.data_dmat
, data
->map
, BUS_DMASYNC_PREWRITE
);
1803 bus_dmamap_sync(sc
->prioq
.desc_dmat
, sc
->prioq
.desc_map
,
1804 BUS_DMASYNC_PREWRITE
);
1806 DPRINTFN(sc
, 10, "sending raw frame len=%u idx=%u rate=%u\n",
1807 m0
->m_pkthdr
.len
, sc
->prioq
.cur
, rate
);
1811 sc
->prioq
.cur
= (sc
->prioq
.cur
+ 1) % RT2560_PRIO_RING_COUNT
;
1812 RAL_WRITE(sc
, RT2560_TXCSR0
, RT2560_KICK_PRIO
);
1818 rt2560_tx_data(struct rt2560_softc
*sc
, struct mbuf
*m0
,
1819 struct ieee80211_node
*ni
)
1821 struct ieee80211vap
*vap
= ni
->ni_vap
;
1822 struct ieee80211com
*ic
= ni
->ni_ic
;
1823 struct rt2560_tx_desc
*desc
;
1824 struct rt2560_tx_data
*data
;
1825 struct ieee80211_frame
*wh
;
1826 const struct ieee80211_txparam
*tp
;
1827 struct ieee80211_key
*k
;
1829 bus_dma_segment_t segs
[RT2560_MAX_SCATTER
];
1832 int nsegs
, rate
, error
;
1834 wh
= mtod(m0
, struct ieee80211_frame
*);
1836 tp
= &vap
->iv_txparms
[ieee80211_chan2mode(ni
->ni_chan
)];
1837 if (IEEE80211_IS_MULTICAST(wh
->i_addr1
)) {
1838 rate
= tp
->mcastrate
;
1839 } else if (m0
->m_flags
& M_EAPOL
) {
1840 rate
= tp
->mgmtrate
;
1841 } else if (tp
->ucastrate
!= IEEE80211_FIXED_RATE_NONE
) {
1842 rate
= tp
->ucastrate
;
1844 (void) ieee80211_ratectl_rate(ni
, NULL
, 0);
1845 rate
= ni
->ni_txrate
;
1848 if (wh
->i_fc
[1] & IEEE80211_FC1_PROTECTED
) {
1849 k
= ieee80211_crypto_encap(ni
, m0
);
1855 /* packet header may have moved, reset our local pointer */
1856 wh
= mtod(m0
, struct ieee80211_frame
*);
1860 if (!IEEE80211_IS_MULTICAST(wh
->i_addr1
)) {
1861 int prot
= IEEE80211_PROT_NONE
;
1862 if (m0
->m_pkthdr
.len
+ IEEE80211_CRC_LEN
> vap
->iv_rtsthreshold
)
1863 prot
= IEEE80211_PROT_RTSCTS
;
1864 else if ((ic
->ic_flags
& IEEE80211_F_USEPROT
) &&
1865 ieee80211_rate2phytype(ic
->ic_rt
, rate
) == IEEE80211_T_OFDM
)
1866 prot
= ic
->ic_protmode
;
1867 if (prot
!= IEEE80211_PROT_NONE
) {
1868 error
= rt2560_sendprot(sc
, m0
, ni
, prot
, rate
);
1873 flags
|= RT2560_TX_LONG_RETRY
| RT2560_TX_IFS_SIFS
;
1877 data
= &sc
->txq
.data
[sc
->txq
.cur_encrypt
];
1878 desc
= &sc
->txq
.desc
[sc
->txq
.cur_encrypt
];
1880 #if defined(__DragonFly__)
1881 error
= bus_dmamap_load_mbuf_segment(sc
->txq
.data_dmat
, data
->map
, m0
,
1882 segs
, 1, &nsegs
, BUS_DMA_NOWAIT
);
1884 error
= bus_dmamap_load_mbuf_sg(sc
->txq
.data_dmat
, data
->map
, m0
,
1887 if (error
!= 0 && error
!= EFBIG
) {
1888 device_printf(sc
->sc_dev
, "could not map mbuf (error %d)\n",
1894 mnew
= m_defrag(m0
, M_NOWAIT
);
1896 device_printf(sc
->sc_dev
,
1897 "could not defragment mbuf\n");
1903 #if defined(__DragonFly__)
1904 error
= bus_dmamap_load_mbuf_segment(sc
->txq
.data_dmat
,
1906 m0
, segs
, 1, &nsegs
, BUS_DMA_NOWAIT
);
1908 error
= bus_dmamap_load_mbuf_sg(sc
->txq
.data_dmat
, data
->map
,
1909 m0
, segs
, &nsegs
, 0);
1912 device_printf(sc
->sc_dev
,
1913 "could not map mbuf (error %d)\n", error
);
1918 /* packet header may have moved, reset our local pointer */
1919 wh
= mtod(m0
, struct ieee80211_frame
*);
1922 if (ieee80211_radiotap_active_vap(vap
)) {
1923 struct rt2560_tx_radiotap_header
*tap
= &sc
->sc_txtap
;
1926 tap
->wt_rate
= rate
;
1927 tap
->wt_antenna
= sc
->tx_ant
;
1929 ieee80211_radiotap_tx(vap
, m0
);
1935 /* remember link conditions for rate adaptation algorithm */
1936 if (tp
->ucastrate
== IEEE80211_FIXED_RATE_NONE
) {
1937 data
->rix
= ni
->ni_txrate
;
1938 /* XXX probably need last rssi value and not avg */
1939 data
->rssi
= ic
->ic_node_getrssi(ni
);
1941 data
->rix
= IEEE80211_FIXED_RATE_NONE
;
1943 if (!IEEE80211_IS_MULTICAST(wh
->i_addr1
)) {
1944 flags
|= RT2560_TX_ACK
;
1946 dur
= ieee80211_ack_duration(ic
->ic_rt
,
1947 rate
, ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
);
1948 *(uint16_t *)wh
->i_dur
= htole16(dur
);
1951 rt2560_setup_tx_desc(sc
, desc
, flags
, m0
->m_pkthdr
.len
, rate
, 1,
1954 bus_dmamap_sync(sc
->txq
.data_dmat
, data
->map
, BUS_DMASYNC_PREWRITE
);
1955 bus_dmamap_sync(sc
->txq
.desc_dmat
, sc
->txq
.desc_map
,
1956 BUS_DMASYNC_PREWRITE
);
1958 DPRINTFN(sc
, 10, "sending data frame len=%u idx=%u rate=%u\n",
1959 m0
->m_pkthdr
.len
, sc
->txq
.cur_encrypt
, rate
);
1963 sc
->txq
.cur_encrypt
= (sc
->txq
.cur_encrypt
+ 1) % RT2560_TX_RING_COUNT
;
1964 RAL_WRITE(sc
, RT2560_SECCSR1
, RT2560_KICK_ENCRYPT
);
1970 rt2560_transmit(struct ieee80211com
*ic
, struct mbuf
*m
)
1972 struct rt2560_softc
*sc
= ic
->ic_softc
;
1976 if ((sc
->sc_flags
& RT2560_F_RUNNING
) == 0) {
1980 error
= mbufq_enqueue(&sc
->sc_snd
, m
);
1992 rt2560_start(struct rt2560_softc
*sc
)
1994 struct ieee80211_node
*ni
;
1997 RAL_LOCK_ASSERT(sc
);
1999 while (sc
->txq
.queued
< RT2560_TX_RING_COUNT
- 1 &&
2000 (m
= mbufq_dequeue(&sc
->sc_snd
)) != NULL
) {
2001 ni
= (struct ieee80211_node
*) m
->m_pkthdr
.rcvif
;
2002 if (rt2560_tx_data(sc
, m
, ni
) != 0) {
2003 if_inc_counter(ni
->ni_vap
->iv_ifp
,
2004 IFCOUNTER_OERRORS
, 1);
2005 ieee80211_free_node(ni
);
2008 sc
->sc_tx_timer
= 5;
2013 rt2560_watchdog(void *arg
)
2015 struct rt2560_softc
*sc
= arg
;
2017 RAL_LOCK_ASSERT(sc
);
2019 KASSERT(sc
->sc_flags
& RT2560_F_RUNNING
, ("not running"));
2021 if (sc
->sc_invalid
) /* card ejected */
2024 rt2560_encryption_intr(sc
);
2027 if (sc
->sc_tx_timer
> 0 && --sc
->sc_tx_timer
== 0) {
2028 device_printf(sc
->sc_dev
, "device timeout\n");
2029 rt2560_init_locked(sc
);
2030 #if defined(__DragonFly__)
2031 /* not implemeted */
2033 counter_u64_add(sc
->sc_ic
.ic_oerrors
, 1);
2035 /* NB: callout is reset in rt2560_init() */
2038 callout_reset(&sc
->watchdog_ch
, hz
, rt2560_watchdog
, sc
);
2042 rt2560_parent(struct ieee80211com
*ic
)
2044 struct rt2560_softc
*sc
= ic
->ic_softc
;
2048 if (ic
->ic_nrunning
> 0) {
2049 if ((sc
->sc_flags
& RT2560_F_RUNNING
) == 0) {
2050 rt2560_init_locked(sc
);
2053 rt2560_update_promisc(ic
);
2054 } else if (sc
->sc_flags
& RT2560_F_RUNNING
)
2055 rt2560_stop_locked(sc
);
2058 ieee80211_start_all(ic
);
2062 rt2560_bbp_write(struct rt2560_softc
*sc
, uint8_t reg
, uint8_t val
)
2067 for (ntries
= 0; ntries
< 100; ntries
++) {
2068 if (!(RAL_READ(sc
, RT2560_BBPCSR
) & RT2560_BBP_BUSY
))
2072 if (ntries
== 100) {
2073 device_printf(sc
->sc_dev
, "could not write to BBP\n");
2077 tmp
= RT2560_BBP_WRITE
| RT2560_BBP_BUSY
| reg
<< 8 | val
;
2078 RAL_WRITE(sc
, RT2560_BBPCSR
, tmp
);
2080 DPRINTFN(sc
, 15, "BBP R%u <- 0x%02x\n", reg
, val
);
2084 rt2560_bbp_read(struct rt2560_softc
*sc
, uint8_t reg
)
2089 for (ntries
= 0; ntries
< 100; ntries
++) {
2090 if (!(RAL_READ(sc
, RT2560_BBPCSR
) & RT2560_BBP_BUSY
))
2094 if (ntries
== 100) {
2095 device_printf(sc
->sc_dev
, "could not read from BBP\n");
2099 val
= RT2560_BBP_BUSY
| reg
<< 8;
2100 RAL_WRITE(sc
, RT2560_BBPCSR
, val
);
2102 for (ntries
= 0; ntries
< 100; ntries
++) {
2103 val
= RAL_READ(sc
, RT2560_BBPCSR
);
2104 if (!(val
& RT2560_BBP_BUSY
))
2109 device_printf(sc
->sc_dev
, "could not read from BBP\n");
2114 rt2560_rf_write(struct rt2560_softc
*sc
, uint8_t reg
, uint32_t val
)
2119 for (ntries
= 0; ntries
< 100; ntries
++) {
2120 if (!(RAL_READ(sc
, RT2560_RFCSR
) & RT2560_RF_BUSY
))
2124 if (ntries
== 100) {
2125 device_printf(sc
->sc_dev
, "could not write to RF\n");
2129 tmp
= RT2560_RF_BUSY
| RT2560_RF_20BIT
| (val
& 0xfffff) << 2 |
2131 RAL_WRITE(sc
, RT2560_RFCSR
, tmp
);
2133 /* remember last written value in sc */
2134 sc
->rf_regs
[reg
] = val
;
2136 DPRINTFN(sc
, 15, "RF R[%u] <- 0x%05x\n", reg
& 0x3, val
& 0xfffff);
2140 rt2560_set_chan(struct rt2560_softc
*sc
, struct ieee80211_channel
*c
)
2142 struct ieee80211com
*ic
= &sc
->sc_ic
;
2146 chan
= ieee80211_chan2ieee(ic
, c
);
2147 KASSERT(chan
!= 0 && chan
!= IEEE80211_CHAN_ANY
, ("chan 0x%x", chan
));
2149 if (IEEE80211_IS_CHAN_2GHZ(c
))
2150 power
= min(sc
->txpow
[chan
- 1], 31);
2154 /* adjust txpower using ifconfig settings */
2155 power
-= (100 - ic
->ic_txpowlimit
) / 8;
2157 DPRINTFN(sc
, 2, "setting channel to %u, txpower to %u\n", chan
, power
);
2159 switch (sc
->rf_rev
) {
2160 case RT2560_RF_2522
:
2161 rt2560_rf_write(sc
, RAL_RF1
, 0x00814);
2162 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2522_r2
[chan
- 1]);
2163 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x00040);
2166 case RT2560_RF_2523
:
2167 rt2560_rf_write(sc
, RAL_RF1
, 0x08804);
2168 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2523_r2
[chan
- 1]);
2169 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x38044);
2170 rt2560_rf_write(sc
, RAL_RF4
, (chan
== 14) ? 0x00280 : 0x00286);
2173 case RT2560_RF_2524
:
2174 rt2560_rf_write(sc
, RAL_RF1
, 0x0c808);
2175 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2524_r2
[chan
- 1]);
2176 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x00040);
2177 rt2560_rf_write(sc
, RAL_RF4
, (chan
== 14) ? 0x00280 : 0x00286);
2180 case RT2560_RF_2525
:
2181 rt2560_rf_write(sc
, RAL_RF1
, 0x08808);
2182 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2525_hi_r2
[chan
- 1]);
2183 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x18044);
2184 rt2560_rf_write(sc
, RAL_RF4
, (chan
== 14) ? 0x00280 : 0x00286);
2186 rt2560_rf_write(sc
, RAL_RF1
, 0x08808);
2187 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2525_r2
[chan
- 1]);
2188 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x18044);
2189 rt2560_rf_write(sc
, RAL_RF4
, (chan
== 14) ? 0x00280 : 0x00286);
2192 case RT2560_RF_2525E
:
2193 rt2560_rf_write(sc
, RAL_RF1
, 0x08808);
2194 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2525e_r2
[chan
- 1]);
2195 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x18044);
2196 rt2560_rf_write(sc
, RAL_RF4
, (chan
== 14) ? 0x00286 : 0x00282);
2199 case RT2560_RF_2526
:
2200 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2526_hi_r2
[chan
- 1]);
2201 rt2560_rf_write(sc
, RAL_RF4
, (chan
& 1) ? 0x00386 : 0x00381);
2202 rt2560_rf_write(sc
, RAL_RF1
, 0x08804);
2204 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf2526_r2
[chan
- 1]);
2205 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x18044);
2206 rt2560_rf_write(sc
, RAL_RF4
, (chan
& 1) ? 0x00386 : 0x00381);
2210 case RT2560_RF_5222
:
2211 for (i
= 0; rt2560_rf5222
[i
].chan
!= chan
; i
++);
2213 rt2560_rf_write(sc
, RAL_RF1
, rt2560_rf5222
[i
].r1
);
2214 rt2560_rf_write(sc
, RAL_RF2
, rt2560_rf5222
[i
].r2
);
2215 rt2560_rf_write(sc
, RAL_RF3
, power
<< 7 | 0x00040);
2216 rt2560_rf_write(sc
, RAL_RF4
, rt2560_rf5222
[i
].r4
);
2219 kprintf("unknown ral rev=%d\n", sc
->rf_rev
);
2223 if ((ic
->ic_flags
& IEEE80211_F_SCAN
) == 0) {
2224 /* set Japan filter bit for channel 14 */
2225 tmp
= rt2560_bbp_read(sc
, 70);
2227 tmp
&= ~RT2560_JAPAN_FILTER
;
2229 tmp
|= RT2560_JAPAN_FILTER
;
2231 rt2560_bbp_write(sc
, 70, tmp
);
2233 /* clear CRC errors */
2234 RAL_READ(sc
, RT2560_CNT0
);
2239 rt2560_set_channel(struct ieee80211com
*ic
)
2241 struct rt2560_softc
*sc
= ic
->ic_softc
;
2244 rt2560_set_chan(sc
, ic
->ic_curchan
);
2251 * Disable RF auto-tuning.
2254 rt2560_disable_rf_tune(struct rt2560_softc
*sc
)
2258 if (sc
->rf_rev
!= RT2560_RF_2523
) {
2259 tmp
= sc
->rf_regs
[RAL_RF1
] & ~RAL_RF1_AUTOTUNE
;
2260 rt2560_rf_write(sc
, RAL_RF1
, tmp
);
2263 tmp
= sc
->rf_regs
[RAL_RF3
] & ~RAL_RF3_AUTOTUNE
;
2264 rt2560_rf_write(sc
, RAL_RF3
, tmp
);
2266 DPRINTFN(sc
, 2, "%s", "disabling RF autotune\n");
2271 * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
2275 rt2560_enable_tsf_sync(struct rt2560_softc
*sc
)
2277 struct ieee80211com
*ic
= &sc
->sc_ic
;
2278 struct ieee80211vap
*vap
= TAILQ_FIRST(&ic
->ic_vaps
);
2279 uint16_t logcwmin
, preload
;
2282 /* first, disable TSF synchronization */
2283 RAL_WRITE(sc
, RT2560_CSR14
, 0);
2285 tmp
= 16 * vap
->iv_bss
->ni_intval
;
2286 RAL_WRITE(sc
, RT2560_CSR12
, tmp
);
2288 RAL_WRITE(sc
, RT2560_CSR13
, 0);
2291 preload
= (vap
->iv_opmode
== IEEE80211_M_STA
) ? 384 : 1024;
2292 tmp
= logcwmin
<< 16 | preload
;
2293 RAL_WRITE(sc
, RT2560_BCNOCSR
, tmp
);
2295 /* finally, enable TSF synchronization */
2296 tmp
= RT2560_ENABLE_TSF
| RT2560_ENABLE_TBCN
;
2297 if (ic
->ic_opmode
== IEEE80211_M_STA
)
2298 tmp
|= RT2560_ENABLE_TSF_SYNC(1);
2300 tmp
|= RT2560_ENABLE_TSF_SYNC(2) |
2301 RT2560_ENABLE_BEACON_GENERATOR
;
2302 RAL_WRITE(sc
, RT2560_CSR14
, tmp
);
2304 DPRINTF(sc
, "%s", "enabling TSF synchronization\n");
2308 rt2560_enable_tsf(struct rt2560_softc
*sc
)
2310 RAL_WRITE(sc
, RT2560_CSR14
, 0);
2311 RAL_WRITE(sc
, RT2560_CSR14
,
2312 RT2560_ENABLE_TSF_SYNC(2) | RT2560_ENABLE_TSF
);
2316 rt2560_update_plcp(struct rt2560_softc
*sc
)
2318 struct ieee80211com
*ic
= &sc
->sc_ic
;
2320 /* no short preamble for 1Mbps */
2321 RAL_WRITE(sc
, RT2560_PLCP1MCSR
, 0x00700400);
2323 if (!(ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
)) {
2324 /* values taken from the reference driver */
2325 RAL_WRITE(sc
, RT2560_PLCP2MCSR
, 0x00380401);
2326 RAL_WRITE(sc
, RT2560_PLCP5p5MCSR
, 0x00150402);
2327 RAL_WRITE(sc
, RT2560_PLCP11MCSR
, 0x000b8403);
2329 /* same values as above or'ed 0x8 */
2330 RAL_WRITE(sc
, RT2560_PLCP2MCSR
, 0x00380409);
2331 RAL_WRITE(sc
, RT2560_PLCP5p5MCSR
, 0x0015040a);
2332 RAL_WRITE(sc
, RT2560_PLCP11MCSR
, 0x000b840b);
2335 DPRINTF(sc
, "updating PLCP for %s preamble\n",
2336 (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
) ? "short" : "long");
2340 * This function can be called by ieee80211_set_shortslottime(). Refer to
2341 * IEEE Std 802.11-1999 pp. 85 to know how these values are computed.
2344 rt2560_update_slot(struct ieee80211com
*ic
)
2346 struct rt2560_softc
*sc
= ic
->ic_softc
;
2348 uint16_t tx_sifs
, tx_pifs
, tx_difs
, eifs
;
2351 #ifndef FORCE_SLOTTIME
2352 slottime
= IEEE80211_GET_SLOTTIME(ic
);
2355 * Setting slot time according to "short slot time" capability
2356 * in beacon/probe_resp seems to cause problem to acknowledge
2357 * certain AP's data frames transimitted at CCK/DS rates: the
2358 * problematic AP keeps retransmitting data frames, probably
2359 * because MAC level acks are not received by hardware.
2360 * So we cheat a little bit here by claiming we are capable of
2361 * "short slot time" but setting hardware slot time to the normal
2362 * slot time. ral(4) does not seem to have trouble to receive
2363 * frames transmitted using short slot time even if hardware
2364 * slot time is set to normal slot time. If we didn't use this
2365 * trick, we would have to claim that short slot time is not
2366 * supported; this would give relative poor RX performance
2367 * (-1Mb~-2Mb lower) and the _whole_ BSS would stop using short
2370 slottime
= IEEE80211_DUR_SLOT
;
2373 /* update the MAC slot boundaries */
2374 tx_sifs
= RAL_SIFS
- RT2560_TXRX_TURNAROUND
;
2375 tx_pifs
= tx_sifs
+ slottime
;
2376 tx_difs
= IEEE80211_DUR_DIFS(tx_sifs
, slottime
);
2377 eifs
= (ic
->ic_curmode
== IEEE80211_MODE_11B
) ? 364 : 60;
2379 tmp
= RAL_READ(sc
, RT2560_CSR11
);
2380 tmp
= (tmp
& ~0x1f00) | slottime
<< 8;
2381 RAL_WRITE(sc
, RT2560_CSR11
, tmp
);
2383 tmp
= tx_pifs
<< 16 | tx_sifs
;
2384 RAL_WRITE(sc
, RT2560_CSR18
, tmp
);
2386 tmp
= eifs
<< 16 | tx_difs
;
2387 RAL_WRITE(sc
, RT2560_CSR19
, tmp
);
2389 DPRINTF(sc
, "setting slottime to %uus\n", slottime
);
2393 rt2560_set_basicrates(struct rt2560_softc
*sc
,
2394 const struct ieee80211_rateset
*rs
)
2396 struct ieee80211com
*ic
= &sc
->sc_ic
;
2401 for (i
= 0; i
< rs
->rs_nrates
; i
++) {
2402 rate
= rs
->rs_rates
[i
];
2404 if (!(rate
& IEEE80211_RATE_BASIC
))
2407 mask
|= 1 << ieee80211_legacy_rate_lookup(ic
->ic_rt
,
2408 IEEE80211_RV(rate
));
2411 RAL_WRITE(sc
, RT2560_ARSP_PLCP_1
, mask
);
2413 DPRINTF(sc
, "Setting basic rate mask to 0x%x\n", mask
);
2417 rt2560_update_led(struct rt2560_softc
*sc
, int led1
, int led2
)
2421 /* set ON period to 70ms and OFF period to 30ms */
2422 tmp
= led1
<< 16 | led2
<< 17 | 70 << 8 | 30;
2423 RAL_WRITE(sc
, RT2560_LEDCSR
, tmp
);
2427 rt2560_set_bssid(struct rt2560_softc
*sc
, const uint8_t *bssid
)
2431 tmp
= bssid
[0] | bssid
[1] << 8 | bssid
[2] << 16 | bssid
[3] << 24;
2432 RAL_WRITE(sc
, RT2560_CSR5
, tmp
);
2434 tmp
= bssid
[4] | bssid
[5] << 8;
2435 RAL_WRITE(sc
, RT2560_CSR6
, tmp
);
2437 #if defined(__DragonFly__)
2438 DPRINTF(sc
, "setting BSSID to %s\n", ether_sprintf(bssid
));
2440 DPRINTF(sc
, "setting BSSID to %6D\n", bssid
, ":");
2445 rt2560_set_macaddr(struct rt2560_softc
*sc
, const uint8_t *addr
)
2449 tmp
= addr
[0] | addr
[1] << 8 | addr
[2] << 16 | addr
[3] << 24;
2450 RAL_WRITE(sc
, RT2560_CSR3
, tmp
);
2452 tmp
= addr
[4] | addr
[5] << 8;
2453 RAL_WRITE(sc
, RT2560_CSR4
, tmp
);
2455 #if defined(__DragonFly__)
2456 DPRINTF(sc
, "setting MAC address to %s\n", ether_sprintf(addr
));
2458 DPRINTF(sc
, "setting MAC address to %6D\n", addr
, ":");
2463 rt2560_get_macaddr(struct rt2560_softc
*sc
, uint8_t *addr
)
2467 tmp
= RAL_READ(sc
, RT2560_CSR3
);
2468 addr
[0] = tmp
& 0xff;
2469 addr
[1] = (tmp
>> 8) & 0xff;
2470 addr
[2] = (tmp
>> 16) & 0xff;
2471 addr
[3] = (tmp
>> 24);
2473 tmp
= RAL_READ(sc
, RT2560_CSR4
);
2474 addr
[4] = tmp
& 0xff;
2475 addr
[5] = (tmp
>> 8) & 0xff;
2479 rt2560_update_promisc(struct ieee80211com
*ic
)
2481 struct rt2560_softc
*sc
= ic
->ic_softc
;
2484 tmp
= RAL_READ(sc
, RT2560_RXCSR0
);
2486 tmp
&= ~RT2560_DROP_NOT_TO_ME
;
2487 if (ic
->ic_promisc
== 0)
2488 tmp
|= RT2560_DROP_NOT_TO_ME
;
2490 RAL_WRITE(sc
, RT2560_RXCSR0
, tmp
);
2492 DPRINTF(sc
, "%s promiscuous mode\n",
2493 (ic
->ic_promisc
> 0) ? "entering" : "leaving");
2497 rt2560_get_rf(int rev
)
2500 case RT2560_RF_2522
: return "RT2522";
2501 case RT2560_RF_2523
: return "RT2523";
2502 case RT2560_RF_2524
: return "RT2524";
2503 case RT2560_RF_2525
: return "RT2525";
2504 case RT2560_RF_2525E
: return "RT2525e";
2505 case RT2560_RF_2526
: return "RT2526";
2506 case RT2560_RF_5222
: return "RT5222";
2507 default: return "unknown";
2512 rt2560_read_config(struct rt2560_softc
*sc
)
2517 val
= rt2560_eeprom_read(sc
, RT2560_EEPROM_CONFIG0
);
2518 sc
->rf_rev
= (val
>> 11) & 0x7;
2519 sc
->hw_radio
= (val
>> 10) & 0x1;
2520 sc
->led_mode
= (val
>> 6) & 0x7;
2521 sc
->rx_ant
= (val
>> 4) & 0x3;
2522 sc
->tx_ant
= (val
>> 2) & 0x3;
2523 sc
->nb_ant
= val
& 0x3;
2525 /* read default values for BBP registers */
2526 for (i
= 0; i
< 16; i
++) {
2527 val
= rt2560_eeprom_read(sc
, RT2560_EEPROM_BBP_BASE
+ i
);
2528 if (val
== 0 || val
== 0xffff)
2531 sc
->bbp_prom
[i
].reg
= val
>> 8;
2532 sc
->bbp_prom
[i
].val
= val
& 0xff;
2535 /* read Tx power for all b/g channels */
2536 for (i
= 0; i
< 14 / 2; i
++) {
2537 val
= rt2560_eeprom_read(sc
, RT2560_EEPROM_TXPOWER
+ i
);
2538 sc
->txpow
[i
* 2] = val
& 0xff;
2539 sc
->txpow
[i
* 2 + 1] = val
>> 8;
2541 for (i
= 0; i
< 14; ++i
) {
2542 if (sc
->txpow
[i
] > 31)
2546 val
= rt2560_eeprom_read(sc
, RT2560_EEPROM_CALIBRATE
);
2547 if ((val
& 0xff) == 0xff)
2548 sc
->rssi_corr
= RT2560_DEFAULT_RSSI_CORR
;
2550 sc
->rssi_corr
= val
& 0xff;
2551 DPRINTF(sc
, "rssi correction %d, calibrate 0x%02x\n",
2552 sc
->rssi_corr
, val
);
2557 rt2560_scan_start(struct ieee80211com
*ic
)
2559 struct rt2560_softc
*sc
= ic
->ic_softc
;
2561 /* abort TSF synchronization */
2562 RAL_WRITE(sc
, RT2560_CSR14
, 0);
2563 rt2560_set_bssid(sc
, ieee80211broadcastaddr
);
2567 rt2560_scan_end(struct ieee80211com
*ic
)
2569 struct rt2560_softc
*sc
= ic
->ic_softc
;
2570 struct ieee80211vap
*vap
= ic
->ic_scan
->ss_vap
;
2572 rt2560_enable_tsf_sync(sc
);
2573 /* XXX keep local copy */
2574 rt2560_set_bssid(sc
, vap
->iv_bss
->ni_bssid
);
2578 rt2560_bbp_init(struct rt2560_softc
*sc
)
2582 /* wait for BBP to be ready */
2583 for (ntries
= 0; ntries
< 100; ntries
++) {
2584 if (rt2560_bbp_read(sc
, RT2560_BBP_VERSION
) != 0)
2588 if (ntries
== 100) {
2589 device_printf(sc
->sc_dev
, "timeout waiting for BBP\n");
2593 /* initialize BBP registers to default values */
2594 for (i
= 0; i
< nitems(rt2560_def_bbp
); i
++) {
2595 rt2560_bbp_write(sc
, rt2560_def_bbp
[i
].reg
,
2596 rt2560_def_bbp
[i
].val
);
2599 /* initialize BBP registers to values stored in EEPROM */
2600 for (i
= 0; i
< 16; i
++) {
2601 if (sc
->bbp_prom
[i
].reg
== 0 && sc
->bbp_prom
[i
].val
== 0)
2603 rt2560_bbp_write(sc
, sc
->bbp_prom
[i
].reg
, sc
->bbp_prom
[i
].val
);
2605 rt2560_bbp_write(sc
, 17, 0x48); /* XXX restore bbp17 */
2611 rt2560_set_txantenna(struct rt2560_softc
*sc
, int antenna
)
2616 tx
= rt2560_bbp_read(sc
, RT2560_BBP_TX
) & ~RT2560_BBP_ANTMASK
;
2618 tx
|= RT2560_BBP_ANTA
;
2619 else if (antenna
== 2)
2620 tx
|= RT2560_BBP_ANTB
;
2622 tx
|= RT2560_BBP_DIVERSITY
;
2624 /* need to force I/Q flip for RF 2525e, 2526 and 5222 */
2625 if (sc
->rf_rev
== RT2560_RF_2525E
|| sc
->rf_rev
== RT2560_RF_2526
||
2626 sc
->rf_rev
== RT2560_RF_5222
)
2627 tx
|= RT2560_BBP_FLIPIQ
;
2629 rt2560_bbp_write(sc
, RT2560_BBP_TX
, tx
);
2631 /* update values for CCK and OFDM in BBPCSR1 */
2632 tmp
= RAL_READ(sc
, RT2560_BBPCSR1
) & ~0x00070007;
2633 tmp
|= (tx
& 0x7) << 16 | (tx
& 0x7);
2634 RAL_WRITE(sc
, RT2560_BBPCSR1
, tmp
);
2638 rt2560_set_rxantenna(struct rt2560_softc
*sc
, int antenna
)
2642 rx
= rt2560_bbp_read(sc
, RT2560_BBP_RX
) & ~RT2560_BBP_ANTMASK
;
2644 rx
|= RT2560_BBP_ANTA
;
2645 else if (antenna
== 2)
2646 rx
|= RT2560_BBP_ANTB
;
2648 rx
|= RT2560_BBP_DIVERSITY
;
2650 /* need to force no I/Q flip for RF 2525e and 2526 */
2651 if (sc
->rf_rev
== RT2560_RF_2525E
|| sc
->rf_rev
== RT2560_RF_2526
)
2652 rx
&= ~RT2560_BBP_FLIPIQ
;
2654 rt2560_bbp_write(sc
, RT2560_BBP_RX
, rx
);
2658 rt2560_init_locked(struct rt2560_softc
*sc
)
2660 struct ieee80211com
*ic
= &sc
->sc_ic
;
2661 struct ieee80211vap
*vap
= TAILQ_FIRST(&ic
->ic_vaps
);
2665 RAL_LOCK_ASSERT(sc
);
2667 rt2560_stop_locked(sc
);
2669 /* setup tx rings */
2670 tmp
= RT2560_PRIO_RING_COUNT
<< 24 |
2671 RT2560_ATIM_RING_COUNT
<< 16 |
2672 RT2560_TX_RING_COUNT
<< 8 |
2673 RT2560_TX_DESC_SIZE
;
2675 /* rings must be initialized in this exact order */
2676 RAL_WRITE(sc
, RT2560_TXCSR2
, tmp
);
2677 RAL_WRITE(sc
, RT2560_TXCSR3
, sc
->txq
.physaddr
);
2678 RAL_WRITE(sc
, RT2560_TXCSR5
, sc
->prioq
.physaddr
);
2679 RAL_WRITE(sc
, RT2560_TXCSR4
, sc
->atimq
.physaddr
);
2680 RAL_WRITE(sc
, RT2560_TXCSR6
, sc
->bcnq
.physaddr
);
2683 tmp
= RT2560_RX_RING_COUNT
<< 8 | RT2560_RX_DESC_SIZE
;
2685 RAL_WRITE(sc
, RT2560_RXCSR1
, tmp
);
2686 RAL_WRITE(sc
, RT2560_RXCSR2
, sc
->rxq
.physaddr
);
2688 /* initialize MAC registers to default values */
2689 for (i
= 0; i
< nitems(rt2560_def_mac
); i
++)
2690 RAL_WRITE(sc
, rt2560_def_mac
[i
].reg
, rt2560_def_mac
[i
].val
);
2692 rt2560_set_macaddr(sc
, vap
? vap
->iv_myaddr
: ic
->ic_macaddr
);
2694 /* set basic rate set (will be updated later) */
2695 RAL_WRITE(sc
, RT2560_ARSP_PLCP_1
, 0x153);
2697 rt2560_update_slot(ic
);
2698 rt2560_update_plcp(sc
);
2699 rt2560_update_led(sc
, 0, 0);
2701 RAL_WRITE(sc
, RT2560_CSR1
, RT2560_RESET_ASIC
);
2702 RAL_WRITE(sc
, RT2560_CSR1
, RT2560_HOST_READY
);
2704 if (rt2560_bbp_init(sc
) != 0) {
2705 rt2560_stop_locked(sc
);
2709 rt2560_set_txantenna(sc
, sc
->tx_ant
);
2710 rt2560_set_rxantenna(sc
, sc
->rx_ant
);
2712 /* set default BSS channel */
2713 rt2560_set_chan(sc
, ic
->ic_curchan
);
2716 tmp
= RT2560_DROP_PHY_ERROR
| RT2560_DROP_CRC_ERROR
;
2717 if (ic
->ic_opmode
!= IEEE80211_M_MONITOR
) {
2718 tmp
|= RT2560_DROP_CTL
| RT2560_DROP_VERSION_ERROR
;
2719 if (ic
->ic_opmode
!= IEEE80211_M_HOSTAP
&&
2720 ic
->ic_opmode
!= IEEE80211_M_MBSS
)
2721 tmp
|= RT2560_DROP_TODS
;
2722 if (ic
->ic_promisc
== 0)
2723 tmp
|= RT2560_DROP_NOT_TO_ME
;
2725 RAL_WRITE(sc
, RT2560_RXCSR0
, tmp
);
2727 /* clear old FCS and Rx FIFO errors */
2728 RAL_READ(sc
, RT2560_CNT0
);
2729 RAL_READ(sc
, RT2560_CNT4
);
2731 /* clear any pending interrupts */
2732 RAL_WRITE(sc
, RT2560_CSR7
, 0xffffffff);
2734 /* enable interrupts */
2735 RAL_WRITE(sc
, RT2560_CSR8
, RT2560_INTR_MASK
);
2737 sc
->sc_flags
|= RT2560_F_RUNNING
;
2739 callout_reset(&sc
->watchdog_ch
, hz
, rt2560_watchdog
, sc
);
2743 rt2560_init(void *priv
)
2745 struct rt2560_softc
*sc
= priv
;
2746 struct ieee80211com
*ic
= &sc
->sc_ic
;
2749 rt2560_init_locked(sc
);
2752 if (sc
->sc_flags
& RT2560_F_RUNNING
)
2753 ieee80211_start_all(ic
); /* start all vap's */
2757 rt2560_stop_locked(struct rt2560_softc
*sc
)
2759 volatile int *flags
= &sc
->sc_flags
;
2761 RAL_LOCK_ASSERT(sc
);
2763 #if defined(__DragonFly__)
2764 while (*flags
& RT2560_F_INPUT_RUNNING
)
2765 lksleep(sc
, &sc
->sc_mtx
, 0, "ralrunning", hz
/10);
2767 while (*flags
& RT2560_F_INPUT_RUNNING
)
2768 msleep(sc
, &sc
->sc_mtx
, 0, "ralrunning", hz
/10);
2771 callout_stop(&sc
->watchdog_ch
);
2772 sc
->sc_tx_timer
= 0;
2774 if (sc
->sc_flags
& RT2560_F_RUNNING
) {
2775 sc
->sc_flags
&= ~RT2560_F_RUNNING
;
2778 RAL_WRITE(sc
, RT2560_TXCSR0
, RT2560_ABORT_TX
);
2781 RAL_WRITE(sc
, RT2560_RXCSR0
, RT2560_DISABLE_RX
);
2783 /* reset ASIC (imply reset BBP) */
2784 RAL_WRITE(sc
, RT2560_CSR1
, RT2560_RESET_ASIC
);
2785 RAL_WRITE(sc
, RT2560_CSR1
, 0);
2787 /* disable interrupts */
2788 RAL_WRITE(sc
, RT2560_CSR8
, 0xffffffff);
2790 /* reset Tx and Rx rings */
2791 rt2560_reset_tx_ring(sc
, &sc
->txq
);
2792 rt2560_reset_tx_ring(sc
, &sc
->atimq
);
2793 rt2560_reset_tx_ring(sc
, &sc
->prioq
);
2794 rt2560_reset_tx_ring(sc
, &sc
->bcnq
);
2795 rt2560_reset_rx_ring(sc
, &sc
->rxq
);
2800 rt2560_stop(void *arg
)
2802 struct rt2560_softc
*sc
= arg
;
2805 rt2560_stop_locked(sc
);
2810 rt2560_raw_xmit(struct ieee80211_node
*ni
, struct mbuf
*m
,
2811 const struct ieee80211_bpf_params
*params
)
2813 struct ieee80211com
*ic
= ni
->ni_ic
;
2814 struct rt2560_softc
*sc
= ic
->ic_softc
;
2818 /* prevent management frames from being sent if we're not ready */
2819 if (!(sc
->sc_flags
& RT2560_F_RUNNING
)) {
2824 if (sc
->prioq
.queued
>= RT2560_PRIO_RING_COUNT
) {
2827 return ENOBUFS
; /* XXX */
2830 if (params
== NULL
) {
2832 * Legacy path; interpret frame contents to decide
2833 * precisely how to send the frame.
2835 if (rt2560_tx_mgt(sc
, m
, ni
) != 0)
2839 * Caller supplied explicit parameters to use in
2840 * sending the frame.
2842 if (rt2560_tx_raw(sc
, m
, ni
, params
))
2845 sc
->sc_tx_timer
= 5;
2852 return EIO
; /* XXX */