This source file includes following definitions.
- rt2560_attach
- rt2560_detach
- rt2560_alloc_tx_ring
- rt2560_reset_tx_ring
- rt2560_free_tx_ring
- rt2560_alloc_rx_ring
- rt2560_reset_rx_ring
- rt2560_free_rx_ring
- rt2560_node_alloc
- rt2560_media_change
- rt2560_next_scan
- rt2560_iter_func
- rt2560_amrr_timeout
- rt2560_newassoc
- rt2560_newstate
- rt2560_eeprom_read
- rt2560_encryption_intr
- rt2560_tx_intr
- rt2560_prio_intr
- rt2560_decryption_intr
- rt2560_rx_intr
- rt2560_beacon_expire
- rt2560_wakeup_expire
- rt2560_intr
- rt2560_rxrate
- rt2560_ack_rate
- rt2560_txtime
- rt2560_plcp_signal
- rt2560_setup_tx_desc
- rt2560_tx_bcn
- rt2560_tx_mgt
- rt2560_tx_data
- rt2560_start
- rt2560_watchdog
- rt2560_ioctl
- rt2560_bbp_write
- rt2560_bbp_read
- rt2560_rf_write
- rt2560_set_chan
- rt2560_disable_rf_tune
- rt2560_enable_tsf_sync
- rt2560_update_plcp
- rt2560_updateslot
- rt2560_set_slottime
- rt2560_set_basicrates
- rt2560_update_led
- rt2560_set_bssid
- rt2560_set_macaddr
- rt2560_get_macaddr
- rt2560_update_promisc
- rt2560_set_txantenna
- rt2560_set_rxantenna
- rt2560_get_rf
- rt2560_read_eeprom
- rt2560_bbp_init
- rt2560_init
- rt2560_stop
- rt2560_power
- rt2560_shutdown
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 #include "bpfilter.h"
26
27 #include <sys/param.h>
28 #include <sys/sockio.h>
29 #include <sys/sysctl.h>
30 #include <sys/mbuf.h>
31 #include <sys/kernel.h>
32 #include <sys/socket.h>
33 #include <sys/systm.h>
34 #include <sys/malloc.h>
35 #include <sys/timeout.h>
36 #include <sys/conf.h>
37 #include <sys/device.h>
38
39 #include <machine/bus.h>
40 #include <machine/endian.h>
41 #include <machine/intr.h>
42
43 #if NBPFILTER > 0
44 #include <net/bpf.h>
45 #endif
46 #include <net/if.h>
47 #include <net/if_arp.h>
48 #include <net/if_dl.h>
49 #include <net/if_media.h>
50 #include <net/if_types.h>
51
52 #include <netinet/in.h>
53 #include <netinet/in_systm.h>
54 #include <netinet/in_var.h>
55 #include <netinet/if_ether.h>
56 #include <netinet/ip.h>
57
58 #include <net80211/ieee80211_var.h>
59 #include <net80211/ieee80211_amrr.h>
60 #include <net80211/ieee80211_radiotap.h>
61
62 #include <dev/ic/rt2560reg.h>
63 #include <dev/ic/rt2560var.h>
64
65 #include <dev/pci/pcireg.h>
66 #include <dev/pci/pcivar.h>
67 #include <dev/pci/pcidevs.h>
68
69 #ifdef RAL_DEBUG
70 #define DPRINTF(x) do { if (rt2560_debug > 0) printf x; } while (0)
71 #define DPRINTFN(n, x) do { if (rt2560_debug >= (n)) printf x; } while (0)
72 int rt2560_debug = 1;
73 #else
74 #define DPRINTF(x)
75 #define DPRINTFN(n, x)
76 #endif
77
78 int rt2560_alloc_tx_ring(struct rt2560_softc *,
79 struct rt2560_tx_ring *, int);
80 void rt2560_reset_tx_ring(struct rt2560_softc *,
81 struct rt2560_tx_ring *);
82 void rt2560_free_tx_ring(struct rt2560_softc *,
83 struct rt2560_tx_ring *);
84 int rt2560_alloc_rx_ring(struct rt2560_softc *,
85 struct rt2560_rx_ring *, int);
86 void rt2560_reset_rx_ring(struct rt2560_softc *,
87 struct rt2560_rx_ring *);
88 void rt2560_free_rx_ring(struct rt2560_softc *,
89 struct rt2560_rx_ring *);
90 struct ieee80211_node *rt2560_node_alloc(struct ieee80211com *);
91 int rt2560_media_change(struct ifnet *);
92 void rt2560_next_scan(void *);
93 void rt2560_iter_func(void *, struct ieee80211_node *);
94 void rt2560_amrr_timeout(void *);
95 void rt2560_newassoc(struct ieee80211com *, struct ieee80211_node *,
96 int);
97 int rt2560_newstate(struct ieee80211com *, enum ieee80211_state,
98 int);
99 uint16_t rt2560_eeprom_read(struct rt2560_softc *, uint8_t);
100 void rt2560_encryption_intr(struct rt2560_softc *);
101 void rt2560_tx_intr(struct rt2560_softc *);
102 void rt2560_prio_intr(struct rt2560_softc *);
103 void rt2560_decryption_intr(struct rt2560_softc *);
104 void rt2560_rx_intr(struct rt2560_softc *);
105 void rt2560_beacon_expire(struct rt2560_softc *);
106 void rt2560_wakeup_expire(struct rt2560_softc *);
107 #if NBPFILTER > 0
108 uint8_t rt2560_rxrate(const struct rt2560_rx_desc *);
109 #endif
110 int rt2560_ack_rate(struct ieee80211com *, int);
111 uint16_t rt2560_txtime(int, int, uint32_t);
112 uint8_t rt2560_plcp_signal(int);
113 void rt2560_setup_tx_desc(struct rt2560_softc *,
114 struct rt2560_tx_desc *, uint32_t, int, int, int,
115 bus_addr_t);
116 int rt2560_tx_bcn(struct rt2560_softc *, struct mbuf *,
117 struct ieee80211_node *);
118 int rt2560_tx_mgt(struct rt2560_softc *, struct mbuf *,
119 struct ieee80211_node *);
120 int rt2560_tx_data(struct rt2560_softc *, struct mbuf *,
121 struct ieee80211_node *);
122 void rt2560_start(struct ifnet *);
123 void rt2560_watchdog(struct ifnet *);
124 int rt2560_ioctl(struct ifnet *, u_long, caddr_t);
125 void rt2560_bbp_write(struct rt2560_softc *, uint8_t, uint8_t);
126 uint8_t rt2560_bbp_read(struct rt2560_softc *, uint8_t);
127 void rt2560_rf_write(struct rt2560_softc *, uint8_t, uint32_t);
128 void rt2560_set_chan(struct rt2560_softc *,
129 struct ieee80211_channel *);
130 void rt2560_disable_rf_tune(struct rt2560_softc *);
131 void rt2560_enable_tsf_sync(struct rt2560_softc *);
132 void rt2560_update_plcp(struct rt2560_softc *);
133 void rt2560_updateslot(struct ieee80211com *);
134 void rt2560_set_slottime(struct rt2560_softc *);
135 void rt2560_set_basicrates(struct rt2560_softc *);
136 void rt2560_update_led(struct rt2560_softc *, int, int);
137 void rt2560_set_bssid(struct rt2560_softc *, uint8_t *);
138 void rt2560_set_macaddr(struct rt2560_softc *, uint8_t *);
139 void rt2560_get_macaddr(struct rt2560_softc *, uint8_t *);
140 void rt2560_update_promisc(struct rt2560_softc *);
141 void rt2560_set_txantenna(struct rt2560_softc *, int);
142 void rt2560_set_rxantenna(struct rt2560_softc *, int);
143 const char *rt2560_get_rf(int);
144 void rt2560_read_eeprom(struct rt2560_softc *);
145 int rt2560_bbp_init(struct rt2560_softc *);
146 int rt2560_init(struct ifnet *);
147 void rt2560_stop(struct ifnet *, int);
148 void rt2560_power(int, void *);
149
150 static const struct {
151 uint32_t reg;
152 uint32_t val;
153 } rt2560_def_mac[] = {
154 RT2560_DEF_MAC
155 };
156
157 static const struct {
158 uint8_t reg;
159 uint8_t val;
160 } rt2560_def_bbp[] = {
161 RT2560_DEF_BBP
162 };
163
164 static const uint32_t rt2560_rf2522_r2[] = RT2560_RF2522_R2;
165 static const uint32_t rt2560_rf2523_r2[] = RT2560_RF2523_R2;
166 static const uint32_t rt2560_rf2524_r2[] = RT2560_RF2524_R2;
167 static const uint32_t rt2560_rf2525_r2[] = RT2560_RF2525_R2;
168 static const uint32_t rt2560_rf2525_hi_r2[] = RT2560_RF2525_HI_R2;
169 static const uint32_t rt2560_rf2525e_r2[] = RT2560_RF2525E_R2;
170 static const uint32_t rt2560_rf2526_r2[] = RT2560_RF2526_R2;
171 static const uint32_t rt2560_rf2526_hi_r2[] = RT2560_RF2526_HI_R2;
172
173 int
174 rt2560_attach(void *xsc, int id)
175 {
176 struct rt2560_softc *sc = xsc;
177 struct ieee80211com *ic = &sc->sc_ic;
178 struct ifnet *ifp = &ic->ic_if;
179 int error, i;
180
181 sc->amrr.amrr_min_success_threshold = 1;
182 sc->amrr.amrr_max_success_threshold = 15;
183 timeout_set(&sc->amrr_to, rt2560_amrr_timeout, sc);
184 timeout_set(&sc->scan_to, rt2560_next_scan, sc);
185
186
187 sc->asic_rev = RAL_READ(sc, RT2560_CSR0);
188
189
190 rt2560_get_macaddr(sc, ic->ic_myaddr);
191 printf(", address %s\n", ether_sprintf(ic->ic_myaddr));
192
193
194 rt2560_read_eeprom(sc);
195
196 printf("%s: MAC/BBP RT2560 (rev 0x%02x), RF %s\n", sc->sc_dev.dv_xname,
197 sc->asic_rev, rt2560_get_rf(sc->rf_rev));
198
199
200
201
202 error = rt2560_alloc_tx_ring(sc, &sc->txq, RT2560_TX_RING_COUNT);
203 if (error != 0) {
204 printf("%s: could not allocate Tx ring\n",
205 sc->sc_dev.dv_xname);
206 goto fail1;
207 }
208 error = rt2560_alloc_tx_ring(sc, &sc->atimq, RT2560_ATIM_RING_COUNT);
209 if (error != 0) {
210 printf("%s: could not allocate ATIM ring\n",
211 sc->sc_dev.dv_xname);
212 goto fail2;
213 }
214 error = rt2560_alloc_tx_ring(sc, &sc->prioq, RT2560_PRIO_RING_COUNT);
215 if (error != 0) {
216 printf("%s: could not allocate Prio ring\n",
217 sc->sc_dev.dv_xname);
218 goto fail3;
219 }
220 error = rt2560_alloc_tx_ring(sc, &sc->bcnq, RT2560_BEACON_RING_COUNT);
221 if (error != 0) {
222 printf("%s: could not allocate Beacon ring\n",
223 sc->sc_dev.dv_xname);
224 goto fail4;
225 }
226 error = rt2560_alloc_rx_ring(sc, &sc->rxq, RT2560_RX_RING_COUNT);
227 if (error != 0) {
228 printf("%s: could not allocate Rx ring\n",
229 sc->sc_dev.dv_xname);
230 goto fail5;
231 }
232
233 ic->ic_phytype = IEEE80211_T_OFDM;
234 ic->ic_opmode = IEEE80211_M_STA;
235 ic->ic_state = IEEE80211_S_INIT;
236
237
238 ic->ic_caps =
239 IEEE80211_C_IBSS |
240 IEEE80211_C_MONITOR |
241 IEEE80211_C_HOSTAP |
242 IEEE80211_C_TXPMGT |
243 IEEE80211_C_SHPREAMBLE |
244 IEEE80211_C_SHSLOT |
245 IEEE80211_C_WEP;
246
247
248 ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
249 ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;
250
251
252 for (i = 1; i <= 14; i++) {
253 ic->ic_channels[i].ic_freq =
254 ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
255 ic->ic_channels[i].ic_flags =
256 IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
257 IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
258 }
259
260 ifp->if_softc = sc;
261 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
262 ifp->if_init = rt2560_init;
263 ifp->if_ioctl = rt2560_ioctl;
264 ifp->if_start = rt2560_start;
265 ifp->if_watchdog = rt2560_watchdog;
266 IFQ_SET_READY(&ifp->if_snd);
267 memcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
268
269 if_attach(ifp);
270 ieee80211_ifattach(ifp);
271 ic->ic_node_alloc = rt2560_node_alloc;
272 ic->ic_newassoc = rt2560_newassoc;
273 ic->ic_updateslot = rt2560_updateslot;
274
275
276 sc->sc_newstate = ic->ic_newstate;
277 ic->ic_newstate = rt2560_newstate;
278 ieee80211_media_init(ifp, rt2560_media_change, ieee80211_media_status);
279
280 #if NBPFILTER > 0
281 bpfattach(&sc->sc_drvbpf, ifp, DLT_IEEE802_11_RADIO,
282 sizeof (struct ieee80211_frame) + 64);
283
284 sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
285 sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
286 sc->sc_rxtap.wr_ihdr.it_present = htole32(RT2560_RX_RADIOTAP_PRESENT);
287
288 sc->sc_txtap_len = sizeof sc->sc_txtapu;
289 sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
290 sc->sc_txtap.wt_ihdr.it_present = htole32(RT2560_TX_RADIOTAP_PRESENT);
291 #endif
292
293
294
295
296 sc->sc_sdhook = shutdownhook_establish(rt2560_shutdown, sc);
297 if (sc->sc_sdhook == NULL) {
298 printf("%s: WARNING: unable to establish shutdown hook\n",
299 sc->sc_dev.dv_xname);
300 }
301 sc->sc_powerhook = powerhook_establish(rt2560_power, sc);
302 if (sc->sc_powerhook == NULL) {
303 printf("%s: WARNING: unable to establish power hook\n",
304 sc->sc_dev.dv_xname);
305 }
306 return 0;
307
308 fail5: rt2560_free_tx_ring(sc, &sc->bcnq);
309 fail4: rt2560_free_tx_ring(sc, &sc->prioq);
310 fail3: rt2560_free_tx_ring(sc, &sc->atimq);
311 fail2: rt2560_free_tx_ring(sc, &sc->txq);
312 fail1: return ENXIO;
313 }
314
315 int
316 rt2560_detach(void *xsc)
317 {
318 struct rt2560_softc *sc = xsc;
319 struct ifnet *ifp = &sc->sc_ic.ic_if;
320
321 timeout_del(&sc->scan_to);
322 timeout_del(&sc->amrr_to);
323
324 ieee80211_ifdetach(ifp);
325 if_detach(ifp);
326
327 if (sc->sc_powerhook != NULL)
328 powerhook_disestablish(sc->sc_powerhook);
329 if (sc->sc_sdhook != NULL)
330 shutdownhook_disestablish(sc->sc_sdhook);
331
332 rt2560_free_tx_ring(sc, &sc->txq);
333 rt2560_free_tx_ring(sc, &sc->atimq);
334 rt2560_free_tx_ring(sc, &sc->prioq);
335 rt2560_free_tx_ring(sc, &sc->bcnq);
336 rt2560_free_rx_ring(sc, &sc->rxq);
337
338 return 0;
339 }
340
341 int
342 rt2560_alloc_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring,
343 int count)
344 {
345 int i, nsegs, error;
346
347 ring->count = count;
348 ring->queued = 0;
349 ring->cur = ring->next = 0;
350 ring->cur_encrypt = ring->next_encrypt = 0;
351
352 error = bus_dmamap_create(sc->sc_dmat, count * RT2560_TX_DESC_SIZE, 1,
353 count * RT2560_TX_DESC_SIZE, 0, BUS_DMA_NOWAIT, &ring->map);
354 if (error != 0) {
355 printf("%s: could not create desc DMA map\n",
356 sc->sc_dev.dv_xname);
357 goto fail;
358 }
359
360 error = bus_dmamem_alloc(sc->sc_dmat, count * RT2560_TX_DESC_SIZE,
361 PAGE_SIZE, 0, &ring->seg, 1, &nsegs, BUS_DMA_NOWAIT);
362 if (error != 0) {
363 printf("%s: could not allocate DMA memory\n",
364 sc->sc_dev.dv_xname);
365 goto fail;
366 }
367
368 error = bus_dmamem_map(sc->sc_dmat, &ring->seg, nsegs,
369 count * RT2560_TX_DESC_SIZE, (caddr_t *)&ring->desc,
370 BUS_DMA_NOWAIT);
371 if (error != 0) {
372 printf("%s: could not map desc DMA memory\n",
373 sc->sc_dev.dv_xname);
374 goto fail;
375 }
376
377 error = bus_dmamap_load(sc->sc_dmat, ring->map, ring->desc,
378 count * RT2560_TX_DESC_SIZE, NULL, BUS_DMA_NOWAIT);
379 if (error != 0) {
380 printf("%s: could not load desc DMA map\n",
381 sc->sc_dev.dv_xname);
382 goto fail;
383 }
384
385 memset(ring->desc, 0, count * RT2560_TX_DESC_SIZE);
386 ring->physaddr = ring->map->dm_segs->ds_addr;
387
388 ring->data = malloc(count * sizeof (struct rt2560_tx_data), M_DEVBUF,
389 M_NOWAIT);
390 if (ring->data == NULL) {
391 printf("%s: could not allocate soft data\n",
392 sc->sc_dev.dv_xname);
393 error = ENOMEM;
394 goto fail;
395 }
396
397 memset(ring->data, 0, count * sizeof (struct rt2560_tx_data));
398 for (i = 0; i < count; i++) {
399 error = bus_dmamap_create(sc->sc_dmat, MCLBYTES,
400 RT2560_MAX_SCATTER, MCLBYTES, 0, BUS_DMA_NOWAIT,
401 &ring->data[i].map);
402 if (error != 0) {
403 printf("%s: could not create DMA map\n",
404 sc->sc_dev.dv_xname);
405 goto fail;
406 }
407 }
408
409 return 0;
410
411 fail: rt2560_free_tx_ring(sc, ring);
412 return error;
413 }
414
415 void
416 rt2560_reset_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring)
417 {
418 int i;
419
420 for (i = 0; i < ring->count; i++) {
421 struct rt2560_tx_desc *desc = &ring->desc[i];
422 struct rt2560_tx_data *data = &ring->data[i];
423
424 if (data->m != NULL) {
425 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
426 data->map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
427 bus_dmamap_unload(sc->sc_dmat, data->map);
428 m_freem(data->m);
429 data->m = NULL;
430 }
431
432
433
434
435
436 data->ni = NULL;
437
438 desc->flags = 0;
439 }
440
441 bus_dmamap_sync(sc->sc_dmat, ring->map, 0, ring->map->dm_mapsize,
442 BUS_DMASYNC_PREWRITE);
443
444 ring->queued = 0;
445 ring->cur = ring->next = 0;
446 ring->cur_encrypt = ring->next_encrypt = 0;
447 }
448
449 void
450 rt2560_free_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring)
451 {
452 int i;
453
454 if (ring->desc != NULL) {
455 bus_dmamap_sync(sc->sc_dmat, ring->map, 0,
456 ring->map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
457 bus_dmamap_unload(sc->sc_dmat, ring->map);
458 bus_dmamem_unmap(sc->sc_dmat, (caddr_t)ring->desc,
459 ring->count * RT2560_TX_DESC_SIZE);
460 bus_dmamem_free(sc->sc_dmat, &ring->seg, 1);
461 }
462
463 if (ring->data != NULL) {
464 for (i = 0; i < ring->count; i++) {
465 struct rt2560_tx_data *data = &ring->data[i];
466
467 if (data->m != NULL) {
468 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
469 data->map->dm_mapsize,
470 BUS_DMASYNC_POSTWRITE);
471 bus_dmamap_unload(sc->sc_dmat, data->map);
472 m_freem(data->m);
473 }
474
475
476
477
478
479 data->ni = NULL;
480
481 if (data->map != NULL)
482 bus_dmamap_destroy(sc->sc_dmat, data->map);
483 }
484 free(ring->data, M_DEVBUF);
485 }
486 }
487
488 int
489 rt2560_alloc_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring,
490 int count)
491 {
492 int i, nsegs, error;
493
494 ring->count = count;
495 ring->cur = ring->next = 0;
496 ring->cur_decrypt = 0;
497
498 error = bus_dmamap_create(sc->sc_dmat, count * RT2560_RX_DESC_SIZE, 1,
499 count * RT2560_RX_DESC_SIZE, 0, BUS_DMA_NOWAIT, &ring->map);
500 if (error != 0) {
501 printf("%s: could not create desc DMA map\n",
502 sc->sc_dev.dv_xname);
503 goto fail;
504 }
505
506 error = bus_dmamem_alloc(sc->sc_dmat, count * RT2560_RX_DESC_SIZE,
507 PAGE_SIZE, 0, &ring->seg, 1, &nsegs, BUS_DMA_NOWAIT);
508 if (error != 0) {
509 printf("%s: could not allocate DMA memory\n",
510 sc->sc_dev.dv_xname);
511 goto fail;
512 }
513
514 error = bus_dmamem_map(sc->sc_dmat, &ring->seg, nsegs,
515 count * RT2560_RX_DESC_SIZE, (caddr_t *)&ring->desc,
516 BUS_DMA_NOWAIT);
517 if (error != 0) {
518 printf("%s: could not map desc DMA memory\n",
519 sc->sc_dev.dv_xname);
520 goto fail;
521 }
522
523 error = bus_dmamap_load(sc->sc_dmat, ring->map, ring->desc,
524 count * RT2560_RX_DESC_SIZE, NULL, BUS_DMA_NOWAIT);
525 if (error != 0) {
526 printf("%s: could not load desc DMA map\n",
527 sc->sc_dev.dv_xname);
528 goto fail;
529 }
530
531 memset(ring->desc, 0, count * RT2560_RX_DESC_SIZE);
532 ring->physaddr = ring->map->dm_segs->ds_addr;
533
534 ring->data = malloc(count * sizeof (struct rt2560_rx_data), M_DEVBUF,
535 M_NOWAIT);
536 if (ring->data == NULL) {
537 printf("%s: could not allocate soft data\n",
538 sc->sc_dev.dv_xname);
539 error = ENOMEM;
540 goto fail;
541 }
542
543
544
545
546 memset(ring->data, 0, count * sizeof (struct rt2560_rx_data));
547 for (i = 0; i < count; i++) {
548 struct rt2560_rx_desc *desc = &sc->rxq.desc[i];
549 struct rt2560_rx_data *data = &sc->rxq.data[i];
550
551 error = bus_dmamap_create(sc->sc_dmat, MCLBYTES, 1, MCLBYTES,
552 0, BUS_DMA_NOWAIT, &data->map);
553 if (error != 0) {
554 printf("%s: could not create DMA map\n",
555 sc->sc_dev.dv_xname);
556 goto fail;
557 }
558
559 MGETHDR(data->m, M_DONTWAIT, MT_DATA);
560 if (data->m == NULL) {
561 printf("%s: could not allocate rx mbuf\n",
562 sc->sc_dev.dv_xname);
563 error = ENOMEM;
564 goto fail;
565 }
566 MCLGET(data->m, M_DONTWAIT);
567 if (!(data->m->m_flags & M_EXT)) {
568 printf("%s: could not allocate rx mbuf cluster\n",
569 sc->sc_dev.dv_xname);
570 error = ENOMEM;
571 goto fail;
572 }
573
574 error = bus_dmamap_load(sc->sc_dmat, data->map,
575 mtod(data->m, void *), MCLBYTES, NULL, BUS_DMA_NOWAIT);
576 if (error != 0) {
577 printf("%s: could not load rx buf DMA map",
578 sc->sc_dev.dv_xname);
579 goto fail;
580 }
581
582 desc->flags = htole32(RT2560_RX_BUSY);
583 desc->physaddr = htole32(data->map->dm_segs->ds_addr);
584 }
585
586 bus_dmamap_sync(sc->sc_dmat, ring->map, 0, ring->map->dm_mapsize,
587 BUS_DMASYNC_PREWRITE);
588
589 return 0;
590
591 fail: rt2560_free_rx_ring(sc, ring);
592 return error;
593 }
594
595 void
596 rt2560_reset_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring)
597 {
598 int i;
599
600 for (i = 0; i < ring->count; i++) {
601 ring->desc[i].flags = htole32(RT2560_RX_BUSY);
602 ring->data[i].drop = 0;
603 }
604
605 bus_dmamap_sync(sc->sc_dmat, ring->map, 0, ring->map->dm_mapsize,
606 BUS_DMASYNC_PREWRITE);
607
608 ring->cur = ring->next = 0;
609 ring->cur_decrypt = 0;
610 }
611
612 void
613 rt2560_free_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring)
614 {
615 int i;
616
617 if (ring->desc != NULL) {
618 bus_dmamap_sync(sc->sc_dmat, ring->map, 0,
619 ring->map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
620 bus_dmamap_unload(sc->sc_dmat, ring->map);
621 bus_dmamem_unmap(sc->sc_dmat, (caddr_t)ring->desc,
622 ring->count * RT2560_RX_DESC_SIZE);
623 bus_dmamem_free(sc->sc_dmat, &ring->seg, 1);
624 }
625
626 if (ring->data != NULL) {
627 for (i = 0; i < ring->count; i++) {
628 struct rt2560_rx_data *data = &ring->data[i];
629
630 if (data->m != NULL) {
631 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
632 data->map->dm_mapsize,
633 BUS_DMASYNC_POSTREAD);
634 bus_dmamap_unload(sc->sc_dmat, data->map);
635 m_freem(data->m);
636 }
637
638 if (data->map != NULL)
639 bus_dmamap_destroy(sc->sc_dmat, data->map);
640 }
641 free(ring->data, M_DEVBUF);
642 }
643 }
644
645 struct ieee80211_node *
646 rt2560_node_alloc(struct ieee80211com *ic)
647 {
648 struct rt2560_node *rn;
649
650 rn = malloc(sizeof (struct rt2560_node), M_DEVBUF, M_NOWAIT);
651 if (rn != NULL)
652 bzero(rn, sizeof (struct rt2560_node));
653 return (struct ieee80211_node *)rn;
654 }
655
656 int
657 rt2560_media_change(struct ifnet *ifp)
658 {
659 int error;
660
661 error = ieee80211_media_change(ifp);
662 if (error != ENETRESET)
663 return error;
664
665 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
666 rt2560_init(ifp);
667
668 return 0;
669 }
670
671
672
673
674
675 void
676 rt2560_next_scan(void *arg)
677 {
678 struct rt2560_softc *sc = arg;
679 struct ieee80211com *ic = &sc->sc_ic;
680 struct ifnet *ifp = &ic->ic_if;
681 int s;
682
683 s = splnet();
684 if (ic->ic_state == IEEE80211_S_SCAN)
685 ieee80211_next_scan(ifp);
686 splx(s);
687 }
688
689
690
691
692 void
693 rt2560_iter_func(void *arg, struct ieee80211_node *ni)
694 {
695 struct rt2560_softc *sc = arg;
696 struct rt2560_node *rn = (struct rt2560_node *)ni;
697
698 ieee80211_amrr_choose(&sc->amrr, ni, &rn->amn);
699 }
700
701 void
702 rt2560_amrr_timeout(void *arg)
703 {
704 struct rt2560_softc *sc = arg;
705 struct ieee80211com *ic = &sc->sc_ic;
706 int s;
707
708 s = splnet();
709 if (ic->ic_opmode == IEEE80211_M_STA)
710 rt2560_iter_func(sc, ic->ic_bss);
711 else
712 ieee80211_iterate_nodes(ic, rt2560_iter_func, sc);
713 splx(s);
714
715 timeout_add(&sc->amrr_to, hz / 2);
716 }
717
718 void
719 rt2560_newassoc(struct ieee80211com *ic, struct ieee80211_node *ni, int isnew)
720 {
721 struct rt2560_softc *sc = ic->ic_softc;
722 int i;
723
724 ieee80211_amrr_node_init(&sc->amrr, &((struct rt2560_node *)ni)->amn);
725
726
727 for (i = ni->ni_rates.rs_nrates - 1;
728 i > 0 && (ni->ni_rates.rs_rates[i] & IEEE80211_RATE_VAL) > 72;
729 i--);
730 ni->ni_txrate = i;
731 }
732
733 int
734 rt2560_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
735 {
736 struct rt2560_softc *sc = ic->ic_if.if_softc;
737 enum ieee80211_state ostate;
738 struct ieee80211_node *ni;
739 struct mbuf *m;
740 int error = 0;
741
742 ostate = ic->ic_state;
743 timeout_del(&sc->scan_to);
744 timeout_del(&sc->amrr_to);
745
746 switch (nstate) {
747 case IEEE80211_S_INIT:
748 if (ostate == IEEE80211_S_RUN) {
749
750 RAL_WRITE(sc, RT2560_CSR14, 0);
751
752
753 rt2560_update_led(sc, 0, 0);
754 }
755 break;
756
757 case IEEE80211_S_SCAN:
758 rt2560_set_chan(sc, ic->ic_bss->ni_chan);
759 timeout_add(&sc->scan_to, hz / 5);
760 break;
761
762 case IEEE80211_S_AUTH:
763 rt2560_set_chan(sc, ic->ic_bss->ni_chan);
764 break;
765
766 case IEEE80211_S_ASSOC:
767 rt2560_set_chan(sc, ic->ic_bss->ni_chan);
768 break;
769
770 case IEEE80211_S_RUN:
771 rt2560_set_chan(sc, ic->ic_bss->ni_chan);
772
773 ni = ic->ic_bss;
774
775 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
776 rt2560_update_plcp(sc);
777 rt2560_set_slottime(sc);
778 rt2560_set_basicrates(sc);
779 rt2560_set_bssid(sc, ni->ni_bssid);
780 }
781
782 if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
783 ic->ic_opmode == IEEE80211_M_IBSS) {
784 m = ieee80211_beacon_alloc(ic, ni);
785 if (m == NULL) {
786 printf("%s: could not allocate beacon\n",
787 sc->sc_dev.dv_xname);
788 error = ENOBUFS;
789 break;
790 }
791
792 error = rt2560_tx_bcn(sc, m, ni);
793 if (error != 0)
794 break;
795 }
796
797
798 rt2560_update_led(sc, 1, 0);
799
800 if (ic->ic_opmode == IEEE80211_M_STA) {
801
802 rt2560_newassoc(ic, ni, 1);
803 }
804
805 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
806
807 if (ic->ic_fixed_rate == -1)
808 timeout_add(&sc->amrr_to, hz / 2);
809
810 rt2560_enable_tsf_sync(sc);
811 }
812 break;
813 }
814
815 return (error != 0) ? error : sc->sc_newstate(ic, nstate, arg);
816 }
817
818
819
820
821
822 uint16_t
823 rt2560_eeprom_read(struct rt2560_softc *sc, uint8_t addr)
824 {
825 uint32_t tmp;
826 uint16_t val;
827 int n;
828
829
830 RT2560_EEPROM_CTL(sc, 0);
831
832 RT2560_EEPROM_CTL(sc, RT2560_S);
833 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_C);
834 RT2560_EEPROM_CTL(sc, RT2560_S);
835
836
837 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D);
838 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D | RT2560_C);
839
840
841 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D);
842 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D | RT2560_C);
843 RT2560_EEPROM_CTL(sc, RT2560_S);
844 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_C);
845
846
847 n = (RAL_READ(sc, RT2560_CSR21) & RT2560_93C46) ? 5 : 7;
848 for (; n >= 0; n--) {
849 RT2560_EEPROM_CTL(sc, RT2560_S |
850 (((addr >> n) & 1) << RT2560_SHIFT_D));
851 RT2560_EEPROM_CTL(sc, RT2560_S |
852 (((addr >> n) & 1) << RT2560_SHIFT_D) | RT2560_C);
853 }
854
855 RT2560_EEPROM_CTL(sc, RT2560_S);
856
857
858 val = 0;
859 for (n = 15; n >= 0; n--) {
860 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_C);
861 tmp = RAL_READ(sc, RT2560_CSR21);
862 val |= ((tmp & RT2560_Q) >> RT2560_SHIFT_Q) << n;
863 RT2560_EEPROM_CTL(sc, RT2560_S);
864 }
865
866 RT2560_EEPROM_CTL(sc, 0);
867
868
869 RT2560_EEPROM_CTL(sc, RT2560_S);
870 RT2560_EEPROM_CTL(sc, 0);
871 RT2560_EEPROM_CTL(sc, RT2560_C);
872
873 return val;
874 }
875
876
877
878
879
880 void
881 rt2560_encryption_intr(struct rt2560_softc *sc)
882 {
883 int hw;
884
885
886 hw = (RAL_READ(sc, RT2560_SECCSR1) - sc->txq.physaddr) /
887 RT2560_TX_DESC_SIZE;
888
889 for (; sc->txq.next_encrypt != hw;) {
890 struct rt2560_tx_desc *desc =
891 &sc->txq.desc[sc->txq.next_encrypt];
892
893 bus_dmamap_sync(sc->sc_dmat, sc->txq.map,
894 sc->txq.next_encrypt * RT2560_TX_DESC_SIZE,
895 RT2560_TX_DESC_SIZE, BUS_DMASYNC_POSTREAD);
896
897 if (letoh32(desc->flags) &
898 (RT2560_TX_BUSY | RT2560_TX_CIPHER_BUSY))
899 break;
900
901
902 if ((letoh32(desc->flags) & RT2560_TX_CIPHER_MASK) ==
903 RT2560_TX_CIPHER_TKIP)
904 desc->eiv = swap32(desc->eiv);
905
906
907 desc->flags |= htole32(RT2560_TX_BUSY | RT2560_TX_VALID);
908
909 bus_dmamap_sync(sc->sc_dmat, sc->txq.map,
910 sc->txq.next_encrypt * RT2560_TX_DESC_SIZE,
911 RT2560_TX_DESC_SIZE, BUS_DMASYNC_PREWRITE);
912
913 DPRINTFN(15, ("encryption done idx=%u\n",
914 sc->txq.next_encrypt));
915
916 sc->txq.next_encrypt =
917 (sc->txq.next_encrypt + 1) % RT2560_TX_RING_COUNT;
918 }
919
920
921 RAL_WRITE(sc, RT2560_TXCSR0, RT2560_KICK_TX);
922 }
923
924 void
925 rt2560_tx_intr(struct rt2560_softc *sc)
926 {
927 struct ieee80211com *ic = &sc->sc_ic;
928 struct ifnet *ifp = &ic->ic_if;
929
930 for (;;) {
931 struct rt2560_tx_desc *desc = &sc->txq.desc[sc->txq.next];
932 struct rt2560_tx_data *data = &sc->txq.data[sc->txq.next];
933 struct rt2560_node *rn;
934
935 bus_dmamap_sync(sc->sc_dmat, sc->txq.map,
936 sc->txq.next * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
937 BUS_DMASYNC_POSTREAD);
938
939 if ((letoh32(desc->flags) & RT2560_TX_BUSY) ||
940 (letoh32(desc->flags) & RT2560_TX_CIPHER_BUSY) ||
941 !(letoh32(desc->flags) & RT2560_TX_VALID))
942 break;
943
944 rn = (struct rt2560_node *)data->ni;
945
946 switch (letoh32(desc->flags) & RT2560_TX_RESULT_MASK) {
947 case RT2560_TX_SUCCESS:
948 DPRINTFN(10, ("data frame sent successfully\n"));
949 rn->amn.amn_txcnt++;
950 ifp->if_opackets++;
951 break;
952
953 case RT2560_TX_SUCCESS_RETRY:
954 DPRINTFN(9, ("data frame sent after %u retries\n",
955 (letoh32(desc->flags) >> 5) & 0x7));
956 rn->amn.amn_txcnt++;
957 rn->amn.amn_retrycnt++;
958 ifp->if_opackets++;
959 break;
960
961 case RT2560_TX_FAIL_RETRY:
962 DPRINTFN(9, ("sending data frame failed (too much "
963 "retries)\n"));
964 rn->amn.amn_txcnt++;
965 rn->amn.amn_retrycnt++;
966 ifp->if_oerrors++;
967 break;
968
969 case RT2560_TX_FAIL_INVALID:
970 case RT2560_TX_FAIL_OTHER:
971 default:
972 printf("%s: sending data frame failed 0x%08x\n",
973 sc->sc_dev.dv_xname, letoh32(desc->flags));
974 ifp->if_oerrors++;
975 }
976
977 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
978 data->map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
979 bus_dmamap_unload(sc->sc_dmat, data->map);
980 m_freem(data->m);
981 data->m = NULL;
982 ieee80211_release_node(ic, data->ni);
983 data->ni = NULL;
984
985
986 desc->flags &= ~htole32(RT2560_TX_VALID);
987
988 bus_dmamap_sync(sc->sc_dmat, sc->txq.map,
989 sc->txq.next * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
990 BUS_DMASYNC_PREWRITE);
991
992 DPRINTFN(15, ("tx done idx=%u\n", sc->txq.next));
993
994 sc->txq.queued--;
995 sc->txq.next = (sc->txq.next + 1) % RT2560_TX_RING_COUNT;
996 }
997
998 sc->sc_tx_timer = 0;
999 ifp->if_flags &= ~IFF_OACTIVE;
1000 rt2560_start(ifp);
1001 }
1002
1003 void
1004 rt2560_prio_intr(struct rt2560_softc *sc)
1005 {
1006 struct ieee80211com *ic = &sc->sc_ic;
1007 struct ifnet *ifp = &ic->ic_if;
1008
1009 for (;;) {
1010 struct rt2560_tx_desc *desc = &sc->prioq.desc[sc->prioq.next];
1011 struct rt2560_tx_data *data = &sc->prioq.data[sc->prioq.next];
1012
1013 bus_dmamap_sync(sc->sc_dmat, sc->prioq.map,
1014 sc->prioq.next * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
1015 BUS_DMASYNC_POSTREAD);
1016
1017 if ((letoh32(desc->flags) & RT2560_TX_BUSY) ||
1018 !(letoh32(desc->flags) & RT2560_TX_VALID))
1019 break;
1020
1021 switch (letoh32(desc->flags) & RT2560_TX_RESULT_MASK) {
1022 case RT2560_TX_SUCCESS:
1023 DPRINTFN(10, ("mgt frame sent successfully\n"));
1024 break;
1025
1026 case RT2560_TX_SUCCESS_RETRY:
1027 DPRINTFN(9, ("mgt frame sent after %u retries\n",
1028 (letoh32(desc->flags) >> 5) & 0x7));
1029 break;
1030
1031 case RT2560_TX_FAIL_RETRY:
1032 DPRINTFN(9, ("sending mgt frame failed (too much "
1033 "retries)\n"));
1034 break;
1035
1036 case RT2560_TX_FAIL_INVALID:
1037 case RT2560_TX_FAIL_OTHER:
1038 default:
1039 printf("%s: sending mgt frame failed 0x%08x\n",
1040 sc->sc_dev.dv_xname, letoh32(desc->flags));
1041 }
1042
1043 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
1044 data->map->dm_mapsize, BUS_DMASYNC_POSTWRITE);
1045 bus_dmamap_unload(sc->sc_dmat, data->map);
1046 m_freem(data->m);
1047 data->m = NULL;
1048 ieee80211_release_node(ic, data->ni);
1049 data->ni = NULL;
1050
1051
1052 desc->flags &= ~htole32(RT2560_TX_VALID);
1053
1054 bus_dmamap_sync(sc->sc_dmat, sc->prioq.map,
1055 sc->prioq.next * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
1056 BUS_DMASYNC_PREWRITE);
1057
1058 DPRINTFN(15, ("prio done idx=%u\n", sc->prioq.next));
1059
1060 sc->prioq.queued--;
1061 sc->prioq.next = (sc->prioq.next + 1) % RT2560_PRIO_RING_COUNT;
1062 }
1063
1064 sc->sc_tx_timer = 0;
1065 ifp->if_flags &= ~IFF_OACTIVE;
1066 rt2560_start(ifp);
1067 }
1068
1069
1070
1071
1072
1073 void
1074 rt2560_decryption_intr(struct rt2560_softc *sc)
1075 {
1076 struct ieee80211com *ic = &sc->sc_ic;
1077 struct ifnet *ifp = &ic->ic_if;
1078 struct ieee80211_frame *wh;
1079 struct ieee80211_node *ni;
1080 struct mbuf *mnew, *m;
1081 int hw, error;
1082
1083
1084 hw = (RAL_READ(sc, RT2560_SECCSR0) - sc->rxq.physaddr) /
1085 RT2560_RX_DESC_SIZE;
1086
1087 for (; sc->rxq.cur_decrypt != hw;) {
1088 struct rt2560_rx_desc *desc =
1089 &sc->rxq.desc[sc->rxq.cur_decrypt];
1090 struct rt2560_rx_data *data =
1091 &sc->rxq.data[sc->rxq.cur_decrypt];
1092
1093 bus_dmamap_sync(sc->sc_dmat, sc->rxq.map,
1094 sc->rxq.cur_decrypt * RT2560_TX_DESC_SIZE,
1095 RT2560_TX_DESC_SIZE, BUS_DMASYNC_POSTREAD);
1096
1097 if (letoh32(desc->flags) &
1098 (RT2560_RX_BUSY | RT2560_RX_CIPHER_BUSY))
1099 break;
1100
1101 if (data->drop) {
1102 ifp->if_ierrors++;
1103 goto skip;
1104 }
1105
1106 if ((letoh32(desc->flags) & RT2560_RX_CIPHER_MASK) != 0 &&
1107 (letoh32(desc->flags) & RT2560_RX_ICV_ERROR)) {
1108 ifp->if_ierrors++;
1109 goto skip;
1110 }
1111
1112
1113
1114
1115
1116
1117
1118
1119 MGETHDR(mnew, M_DONTWAIT, MT_DATA);
1120 if (mnew == NULL) {
1121 ifp->if_ierrors++;
1122 goto skip;
1123 }
1124 MCLGET(mnew, M_DONTWAIT);
1125 if (!(mnew->m_flags & M_EXT)) {
1126 m_freem(mnew);
1127 ifp->if_ierrors++;
1128 goto skip;
1129 }
1130
1131 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
1132 data->map->dm_mapsize, BUS_DMASYNC_POSTREAD);
1133 bus_dmamap_unload(sc->sc_dmat, data->map);
1134
1135 error = bus_dmamap_load(sc->sc_dmat, data->map,
1136 mtod(mnew, void *), MCLBYTES, NULL, BUS_DMA_NOWAIT);
1137 if (error != 0) {
1138 m_freem(mnew);
1139
1140
1141 error = bus_dmamap_load(sc->sc_dmat, data->map,
1142 mtod(data->m, void *), MCLBYTES, NULL,
1143 BUS_DMA_NOWAIT);
1144 if (error != 0) {
1145
1146 panic("%s: could not load old rx mbuf",
1147 sc->sc_dev.dv_xname);
1148 }
1149 ifp->if_ierrors++;
1150 goto skip;
1151 }
1152
1153
1154
1155
1156
1157 m = data->m;
1158 data->m = mnew;
1159 desc->physaddr = htole32(data->map->dm_segs->ds_addr);
1160
1161
1162 m->m_pkthdr.rcvif = ifp;
1163 m->m_pkthdr.len = m->m_len =
1164 (letoh32(desc->flags) >> 16) & 0xfff;
1165
1166 #if NBPFILTER > 0
1167 if (sc->sc_drvbpf != NULL) {
1168 struct mbuf mb;
1169 struct rt2560_rx_radiotap_header *tap = &sc->sc_rxtap;
1170 uint32_t tsf_lo, tsf_hi;
1171
1172
1173 tsf_hi = RAL_READ(sc, RT2560_CSR17);
1174 tsf_lo = RAL_READ(sc, RT2560_CSR16);
1175
1176 tap->wr_tsf =
1177 htole64(((uint64_t)tsf_hi << 32) | tsf_lo);
1178 tap->wr_flags = 0;
1179 tap->wr_rate = rt2560_rxrate(desc);
1180 tap->wr_chan_freq = htole16(ic->ic_ibss_chan->ic_freq);
1181 tap->wr_chan_flags =
1182 htole16(ic->ic_ibss_chan->ic_flags);
1183 tap->wr_antenna = sc->rx_ant;
1184 tap->wr_antsignal = desc->rssi;
1185
1186 mb.m_data = (caddr_t)tap;
1187 mb.m_len = sc->sc_txtap_len;
1188 mb.m_next = m;
1189 mb.m_nextpkt = NULL;
1190 mb.m_type = 0;
1191 mb.m_flags = 0;
1192 bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_IN);
1193 }
1194 #endif
1195 wh = mtod(m, struct ieee80211_frame *);
1196 ni = ieee80211_find_rxnode(ic, wh);
1197
1198
1199 ieee80211_input(ifp, m, ni, desc->rssi, 0);
1200
1201
1202 ieee80211_release_node(ic, ni);
1203
1204 skip: desc->flags = htole32(RT2560_RX_BUSY);
1205
1206 bus_dmamap_sync(sc->sc_dmat, sc->rxq.map,
1207 sc->rxq.cur_decrypt * RT2560_TX_DESC_SIZE,
1208 RT2560_TX_DESC_SIZE, BUS_DMASYNC_PREWRITE);
1209
1210 DPRINTFN(15, ("decryption done idx=%u\n", sc->rxq.cur_decrypt));
1211
1212 sc->rxq.cur_decrypt =
1213 (sc->rxq.cur_decrypt + 1) % RT2560_RX_RING_COUNT;
1214 }
1215
1216
1217
1218
1219
1220 if (!IFQ_IS_EMPTY(&ifp->if_snd) && !(ifp->if_flags & IFF_OACTIVE))
1221 rt2560_start(ifp);
1222 }
1223
1224
1225
1226
1227
1228 void
1229 rt2560_rx_intr(struct rt2560_softc *sc)
1230 {
1231 for (;;) {
1232 struct rt2560_rx_desc *desc = &sc->rxq.desc[sc->rxq.cur];
1233 struct rt2560_rx_data *data = &sc->rxq.data[sc->rxq.cur];
1234
1235 bus_dmamap_sync(sc->sc_dmat, sc->rxq.map,
1236 sc->rxq.cur * RT2560_RX_DESC_SIZE, RT2560_RX_DESC_SIZE,
1237 BUS_DMASYNC_POSTREAD);
1238
1239 if (letoh32(desc->flags) &
1240 (RT2560_RX_BUSY | RT2560_RX_CIPHER_BUSY))
1241 break;
1242
1243 data->drop = 0;
1244
1245 if (letoh32(desc->flags) &
1246 (RT2560_RX_PHY_ERROR | RT2560_RX_CRC_ERROR)) {
1247
1248
1249
1250
1251 DPRINTFN(5, ("PHY or CRC error flags 0x%08x\n",
1252 letoh32(desc->flags)));
1253 data->drop = 1;
1254 }
1255
1256 if (((letoh32(desc->flags) >> 16) & 0xfff) > MCLBYTES) {
1257 DPRINTFN(5, ("bad length\n"));
1258 data->drop = 1;
1259 }
1260
1261
1262 desc->flags |= htole32(RT2560_RX_CIPHER_BUSY);
1263
1264 bus_dmamap_sync(sc->sc_dmat, sc->rxq.map,
1265 sc->rxq.cur * RT2560_RX_DESC_SIZE, RT2560_RX_DESC_SIZE,
1266 BUS_DMASYNC_PREWRITE);
1267
1268 DPRINTFN(15, ("rx done idx=%u\n", sc->rxq.cur));
1269
1270 sc->rxq.cur = (sc->rxq.cur + 1) % RT2560_RX_RING_COUNT;
1271 }
1272
1273
1274 RAL_WRITE(sc, RT2560_SECCSR0, RT2560_KICK_DECRYPT);
1275 }
1276
1277
1278
1279
1280
1281 void
1282 rt2560_beacon_expire(struct rt2560_softc *sc)
1283 {
1284 struct ieee80211com *ic = &sc->sc_ic;
1285 struct rt2560_tx_data *data;
1286
1287 if (ic->ic_opmode != IEEE80211_M_IBSS &&
1288 ic->ic_opmode != IEEE80211_M_HOSTAP)
1289 return;
1290
1291 data = &sc->bcnq.data[sc->bcnq.next];
1292
1293 if (sc->sc_flags & RT2560_UPDATE_SLOT) {
1294 sc->sc_flags &= ~RT2560_UPDATE_SLOT;
1295 sc->sc_flags |= RT2560_SET_SLOTTIME;
1296 } else if (sc->sc_flags & RT2560_SET_SLOTTIME) {
1297 sc->sc_flags &= ~RT2560_SET_SLOTTIME;
1298 rt2560_set_slottime(sc);
1299 }
1300
1301 if (ic->ic_curmode == IEEE80211_MODE_11G) {
1302
1303 *sc->erp = ic->ic_bss->ni_erp;
1304 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
1305 data->map->dm_mapsize, BUS_DMASYNC_PREWRITE);
1306 }
1307
1308 #if defined(RT2560_DEBUG) && NBPFILTER > 0
1309 if (ic->ic_rawbpf != NULL)
1310 bpf_mtap(ic->ic_rawbpf, data->m, BPF_DIRECTION_OUT);
1311 #endif
1312
1313 DPRINTFN(15, ("beacon expired\n"));
1314 }
1315
1316 void
1317 rt2560_wakeup_expire(struct rt2560_softc *sc)
1318 {
1319 DPRINTFN(15, ("wakeup expired\n"));
1320 }
1321
1322 int
1323 rt2560_intr(void *arg)
1324 {
1325 struct rt2560_softc *sc = arg;
1326 struct ifnet *ifp = &sc->sc_ic.ic_if;
1327 uint32_t r;
1328
1329 if ((r = RAL_READ(sc, RT2560_CSR7)) == 0)
1330 return 0;
1331
1332
1333 RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
1334
1335
1336 RAL_WRITE(sc, RT2560_CSR7, r);
1337
1338
1339 if (!(ifp->if_flags & IFF_RUNNING))
1340 return 0;
1341
1342 if (r & RT2560_BEACON_EXPIRE)
1343 rt2560_beacon_expire(sc);
1344
1345 if (r & RT2560_WAKEUP_EXPIRE)
1346 rt2560_wakeup_expire(sc);
1347
1348 if (r & RT2560_ENCRYPTION_DONE)
1349 rt2560_encryption_intr(sc);
1350
1351 if (r & RT2560_TX_DONE)
1352 rt2560_tx_intr(sc);
1353
1354 if (r & RT2560_PRIO_DONE)
1355 rt2560_prio_intr(sc);
1356
1357 if (r & RT2560_DECRYPTION_DONE)
1358 rt2560_decryption_intr(sc);
1359
1360 if (r & RT2560_RX_DONE)
1361 rt2560_rx_intr(sc);
1362
1363
1364 RAL_WRITE(sc, RT2560_CSR8, RT2560_INTR_MASK);
1365
1366 return 1;
1367 }
1368
1369
1370 #define RAL_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
1371
1372 #define RAL_ACK_SIZE 14
1373 #define RAL_CTS_SIZE 14
1374
1375 #define RAL_SIFS 10
1376
1377 #define RT2560_RXTX_TURNAROUND 10
1378
1379
1380
1381
1382
1383 #if NBPFILTER > 0
1384 uint8_t
1385 rt2560_rxrate(const struct rt2560_rx_desc *desc)
1386 {
1387 if (letoh32(desc->flags) & RT2560_RX_OFDM) {
1388
1389 switch (desc->rate) {
1390 case 0xb: return 12;
1391 case 0xf: return 18;
1392 case 0xa: return 24;
1393 case 0xe: return 36;
1394 case 0x9: return 48;
1395 case 0xd: return 72;
1396 case 0x8: return 96;
1397 case 0xc: return 108;
1398 }
1399 } else {
1400 if (desc->rate == 10)
1401 return 2;
1402 if (desc->rate == 20)
1403 return 4;
1404 if (desc->rate == 55)
1405 return 11;
1406 if (desc->rate == 110)
1407 return 22;
1408 }
1409 return 2;
1410 }
1411 #endif
1412
1413
1414
1415
1416 int
1417 rt2560_ack_rate(struct ieee80211com *ic, int rate)
1418 {
1419 switch (rate) {
1420
1421 case 2:
1422 return 2;
1423 case 4:
1424 case 11:
1425 case 22:
1426 return (ic->ic_curmode == IEEE80211_MODE_11B) ? 4 : rate;
1427
1428
1429 case 12:
1430 case 18:
1431 return 12;
1432 case 24:
1433 case 36:
1434 return 24;
1435 case 48:
1436 case 72:
1437 case 96:
1438 case 108:
1439 return 48;
1440 }
1441
1442
1443 return 2;
1444 }
1445
1446
1447
1448
1449
1450
1451 uint16_t
1452 rt2560_txtime(int len, int rate, uint32_t flags)
1453 {
1454 uint16_t txtime;
1455
1456 if (RAL_RATE_IS_OFDM(rate)) {
1457
1458 txtime = (8 + 4 * len + 3 + rate - 1) / rate;
1459 txtime = 16 + 4 + 4 * txtime + 6;
1460 } else {
1461
1462 txtime = (16 * len + rate - 1) / rate;
1463 if (rate != 2 && (flags & IEEE80211_F_SHPREAMBLE))
1464 txtime += 72 + 24;
1465 else
1466 txtime += 144 + 48;
1467 }
1468 return txtime;
1469 }
1470
1471 uint8_t
1472 rt2560_plcp_signal(int rate)
1473 {
1474 switch (rate) {
1475
1476 case 2: return 0x0;
1477 case 4: return 0x1;
1478 case 11: return 0x2;
1479 case 22: return 0x3;
1480
1481
1482 case 12: return 0xb;
1483 case 18: return 0xf;
1484 case 24: return 0xa;
1485 case 36: return 0xe;
1486 case 48: return 0x9;
1487 case 72: return 0xd;
1488 case 96: return 0x8;
1489 case 108: return 0xc;
1490
1491
1492 default: return 0xff;
1493 }
1494 }
1495
1496 void
1497 rt2560_setup_tx_desc(struct rt2560_softc *sc, struct rt2560_tx_desc *desc,
1498 uint32_t flags, int len, int rate, int encrypt, bus_addr_t physaddr)
1499 {
1500 struct ieee80211com *ic = &sc->sc_ic;
1501 uint16_t plcp_length;
1502 int remainder;
1503
1504 desc->flags = htole32(flags);
1505 desc->flags |= htole32(len << 16);
1506 desc->flags |= encrypt ? htole32(RT2560_TX_CIPHER_BUSY) :
1507 htole32(RT2560_TX_BUSY | RT2560_TX_VALID);
1508
1509 desc->physaddr = htole32(physaddr);
1510 desc->wme = htole16(
1511 RT2560_AIFSN(2) |
1512 RT2560_LOGCWMIN(3) |
1513 RT2560_LOGCWMAX(8));
1514
1515
1516 desc->plcp_signal = rt2560_plcp_signal(rate);
1517 desc->plcp_service = 4;
1518
1519 len += IEEE80211_CRC_LEN;
1520 if (RAL_RATE_IS_OFDM(rate)) {
1521 desc->flags |= htole32(RT2560_TX_OFDM);
1522
1523 plcp_length = len & 0xfff;
1524 desc->plcp_length_hi = plcp_length >> 6;
1525 desc->plcp_length_lo = plcp_length & 0x3f;
1526 } else {
1527 plcp_length = (16 * len + rate - 1) / rate;
1528 if (rate == 22) {
1529 remainder = (16 * len) % 22;
1530 if (remainder != 0 && remainder < 7)
1531 desc->plcp_service |= RT2560_PLCP_LENGEXT;
1532 }
1533 desc->plcp_length_hi = plcp_length >> 8;
1534 desc->plcp_length_lo = plcp_length & 0xff;
1535
1536 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
1537 desc->plcp_signal |= 0x08;
1538 }
1539 }
1540
1541 int
1542 rt2560_tx_bcn(struct rt2560_softc *sc, struct mbuf *m0,
1543 struct ieee80211_node *ni)
1544 {
1545 struct ieee80211com *ic = &sc->sc_ic;
1546 struct rt2560_tx_desc *desc;
1547 struct rt2560_tx_data *data;
1548 int rate = 2, error;
1549
1550 desc = &sc->bcnq.desc[sc->bcnq.cur];
1551 data = &sc->bcnq.data[sc->bcnq.cur];
1552
1553 error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
1554 BUS_DMA_NOWAIT);
1555 if (error != 0) {
1556 printf("%s: could not map mbuf (error %d)\n",
1557 sc->sc_dev.dv_xname, error);
1558 m_freem(m0);
1559 return error;
1560 }
1561
1562 data->m = m0;
1563 data->ni = ni;
1564
1565 rt2560_setup_tx_desc(sc, desc, RT2560_TX_IFS_NEWBACKOFF |
1566 RT2560_TX_TIMESTAMP, m0->m_pkthdr.len, rate, 0,
1567 data->map->dm_segs->ds_addr);
1568
1569 bus_dmamap_sync(sc->sc_dmat, data->map, 0, data->map->dm_mapsize,
1570 BUS_DMASYNC_PREWRITE);
1571 bus_dmamap_sync(sc->sc_dmat, sc->bcnq.map,
1572 sc->bcnq.cur * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
1573 BUS_DMASYNC_PREWRITE);
1574
1575
1576
1577
1578
1579
1580
1581 if (ic->ic_curmode == IEEE80211_MODE_11G) {
1582 sc->erp =
1583 mtod(m0, uint8_t *) +
1584 sizeof (struct ieee80211_frame) +
1585 8 + 2 + 2 +
1586 ((ic->ic_flags & IEEE80211_F_HIDENWID) ?
1587 1 : 2 + ni->ni_esslen) +
1588 2 + min(ni->ni_rates.rs_nrates, IEEE80211_RATE_SIZE) +
1589 2 + 1 +
1590 ((ic->ic_opmode == IEEE80211_M_IBSS) ? 4 : 6) +
1591 2;
1592 }
1593
1594 return 0;
1595 }
1596
1597 int
1598 rt2560_tx_mgt(struct rt2560_softc *sc, struct mbuf *m0,
1599 struct ieee80211_node *ni)
1600 {
1601 struct ieee80211com *ic = &sc->sc_ic;
1602 struct ifnet *ifp = &ic->ic_if;
1603 struct rt2560_tx_desc *desc;
1604 struct rt2560_tx_data *data;
1605 struct ieee80211_frame *wh;
1606 uint16_t dur;
1607 uint32_t flags = 0;
1608 int rate = 2, error;
1609
1610 desc = &sc->prioq.desc[sc->prioq.cur];
1611 data = &sc->prioq.data[sc->prioq.cur];
1612
1613 wh = mtod(m0, struct ieee80211_frame *);
1614
1615 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
1616 m0 = ieee80211_wep_crypt(ifp, m0, 1);
1617 if (m0 == NULL)
1618 return ENOBUFS;
1619
1620
1621 wh = mtod(m0, struct ieee80211_frame *);
1622 }
1623
1624 error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
1625 BUS_DMA_NOWAIT);
1626 if (error != 0) {
1627 printf("%s: could not map mbuf (error %d)\n",
1628 sc->sc_dev.dv_xname, error);
1629 m_freem(m0);
1630 return error;
1631 }
1632
1633 #if NBPFILTER > 0
1634 if (sc->sc_drvbpf != NULL) {
1635 struct mbuf mb;
1636 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
1637
1638 tap->wt_flags = 0;
1639 tap->wt_rate = rate;
1640 tap->wt_chan_freq = htole16(ic->ic_ibss_chan->ic_freq);
1641 tap->wt_chan_flags = htole16(ic->ic_ibss_chan->ic_flags);
1642 tap->wt_antenna = sc->tx_ant;
1643
1644 mb.m_data = (caddr_t)tap;
1645 mb.m_len = sc->sc_txtap_len;
1646 mb.m_next = m0;
1647 mb.m_nextpkt = NULL;
1648 mb.m_type = 0;
1649 mb.m_flags = 0;
1650 bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
1651 }
1652 #endif
1653
1654 data->m = m0;
1655 data->ni = ni;
1656
1657 wh = mtod(m0, struct ieee80211_frame *);
1658
1659 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1660 flags |= RT2560_TX_NEED_ACK;
1661
1662 dur = rt2560_txtime(RAL_ACK_SIZE, rate, ic->ic_flags) +
1663 RAL_SIFS;
1664 *(uint16_t *)wh->i_dur = htole16(dur);
1665
1666
1667 if ((wh->i_fc[0] &
1668 (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
1669 (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
1670 flags |= RT2560_TX_TIMESTAMP;
1671 }
1672
1673 rt2560_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len, rate, 0,
1674 data->map->dm_segs->ds_addr);
1675
1676 bus_dmamap_sync(sc->sc_dmat, data->map, 0, data->map->dm_mapsize,
1677 BUS_DMASYNC_PREWRITE);
1678 bus_dmamap_sync(sc->sc_dmat, sc->prioq.map,
1679 sc->prioq.cur * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
1680 BUS_DMASYNC_PREWRITE);
1681
1682 DPRINTFN(10, ("sending mgt frame len=%u idx=%u rate=%u\n",
1683 m0->m_pkthdr.len, sc->prioq.cur, rate));
1684
1685
1686 sc->prioq.queued++;
1687 sc->prioq.cur = (sc->prioq.cur + 1) % RT2560_PRIO_RING_COUNT;
1688 RAL_WRITE(sc, RT2560_TXCSR0, RT2560_KICK_PRIO);
1689
1690 return 0;
1691 }
1692
1693 int
1694 rt2560_tx_data(struct rt2560_softc *sc, struct mbuf *m0,
1695 struct ieee80211_node *ni)
1696 {
1697 struct ieee80211com *ic = &sc->sc_ic;
1698 struct ifnet *ifp = &ic->ic_if;
1699 struct rt2560_tx_ring *txq = &sc->txq;
1700 struct rt2560_tx_desc *desc;
1701 struct rt2560_tx_data *data;
1702 struct ieee80211_frame *wh;
1703 struct mbuf *mnew;
1704 uint16_t dur;
1705 uint32_t flags = 0;
1706 int pktlen, rate, needcts = 0, needrts = 0, error;
1707
1708 wh = mtod(m0, struct ieee80211_frame *);
1709
1710 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
1711 m0 = ieee80211_wep_crypt(ifp, m0, 1);
1712 if (m0 == NULL)
1713 return ENOBUFS;
1714
1715
1716 wh = mtod(m0, struct ieee80211_frame *);
1717 }
1718
1719
1720 pktlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN;
1721
1722
1723 if (IEEE80211_IS_MULTICAST(wh->i_addr1) ||
1724 ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
1725 IEEE80211_FC0_TYPE_MGT)) {
1726
1727 rate = ni->ni_rates.rs_rates[0];
1728 } else if (ic->ic_fixed_rate != -1) {
1729 rate = ic->ic_sup_rates[ic->ic_curmode].
1730 rs_rates[ic->ic_fixed_rate];
1731 } else
1732 rate = ni->ni_rates.rs_rates[ni->ni_txrate];
1733 if (rate == 0)
1734 rate = 2;
1735 rate &= IEEE80211_RATE_VAL;
1736
1737
1738
1739
1740
1741 if (ic->ic_opmode == IEEE80211_M_STA && (ni->ni_txseq & 7))
1742 flags |= RT2560_TX_IFS_SIFS;
1743
1744
1745 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1746
1747 if (pktlen > ic->ic_rtsthreshold) {
1748 needrts = 1;
1749 } else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
1750 RAL_RATE_IS_OFDM(rate)) {
1751 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
1752 needcts = 1;
1753 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
1754 needrts = 1;
1755 }
1756 }
1757 if (needrts || needcts) {
1758 struct mbuf *mprot;
1759 int protrate, ackrate;
1760 uint16_t dur;
1761
1762 protrate = 2;
1763 ackrate = rt2560_ack_rate(ic, rate);
1764
1765 dur = rt2560_txtime(pktlen, rate, ic->ic_flags) +
1766 rt2560_txtime(RAL_ACK_SIZE, ackrate, ic->ic_flags) +
1767 2 * RAL_SIFS;
1768 if (needrts) {
1769 dur += rt2560_txtime(RAL_CTS_SIZE, rt2560_ack_rate(ic,
1770 protrate), ic->ic_flags) + RAL_SIFS;
1771 mprot = ieee80211_get_rts(ic, wh, dur);
1772 } else {
1773 mprot = ieee80211_get_cts_to_self(ic, dur);
1774 }
1775 if (mprot == NULL) {
1776 printf("%s: could not allocate protection frame\n",
1777 sc->sc_dev.dv_xname);
1778 m_freem(m0);
1779 return ENOBUFS;
1780 }
1781
1782 desc = &txq->desc[txq->cur_encrypt];
1783 data = &txq->data[txq->cur_encrypt];
1784
1785 error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, mprot,
1786 BUS_DMA_NOWAIT);
1787 if (error != 0) {
1788 printf("%s: could not map mbuf (error %d)\n",
1789 sc->sc_dev.dv_xname, error);
1790 m_freem(mprot);
1791 m_freem(m0);
1792 return error;
1793 }
1794
1795 data->m = mprot;
1796
1797 data->ni = ieee80211_ref_node(ni);
1798
1799
1800
1801 rt2560_setup_tx_desc(sc, desc,
1802 (needrts ? RT2560_TX_NEED_ACK : 0) | RT2560_TX_MORE_FRAG,
1803 mprot->m_pkthdr.len, protrate, 1,
1804 data->map->dm_segs->ds_addr);
1805
1806 bus_dmamap_sync(sc->sc_dmat, data->map, 0,
1807 data->map->dm_mapsize, BUS_DMASYNC_PREWRITE);
1808 bus_dmamap_sync(sc->sc_dmat, txq->map,
1809 txq->cur_encrypt * RT2560_TX_DESC_SIZE,
1810 RT2560_TX_DESC_SIZE, BUS_DMASYNC_PREWRITE);
1811
1812 txq->queued++;
1813 if (++txq->cur_encrypt >= txq->count)
1814 txq->cur_encrypt = 0;
1815
1816 flags |= RT2560_TX_LONG_RETRY | RT2560_TX_IFS_SIFS;
1817 }
1818
1819 data = &txq->data[txq->cur_encrypt];
1820 desc = &txq->desc[txq->cur_encrypt];
1821
1822 error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
1823 BUS_DMA_NOWAIT);
1824 if (error != 0 && error != EFBIG) {
1825 printf("%s: could not map mbuf (error %d)\n",
1826 sc->sc_dev.dv_xname, error);
1827 m_freem(m0);
1828 return error;
1829 }
1830 if (error != 0) {
1831
1832
1833 MGETHDR(mnew, M_DONTWAIT, MT_DATA);
1834 if (mnew == NULL) {
1835 m_freem(m0);
1836 return ENOMEM;
1837 }
1838 M_DUP_PKTHDR(mnew, m0);
1839 if (m0->m_pkthdr.len > MHLEN) {
1840 MCLGET(mnew, M_DONTWAIT);
1841 if (!(mnew->m_flags & M_EXT)) {
1842 m_freem(m0);
1843 m_freem(mnew);
1844 return ENOMEM;
1845 }
1846 }
1847
1848 m_copydata(m0, 0, m0->m_pkthdr.len, mtod(mnew, caddr_t));
1849 m_freem(m0);
1850 mnew->m_len = mnew->m_pkthdr.len;
1851 m0 = mnew;
1852
1853 error = bus_dmamap_load_mbuf(sc->sc_dmat, data->map, m0,
1854 BUS_DMA_NOWAIT);
1855 if (error != 0) {
1856 printf("%s: could not map mbuf (error %d)\n",
1857 sc->sc_dev.dv_xname, error);
1858 m_freem(m0);
1859 return error;
1860 }
1861
1862
1863 wh = mtod(m0, struct ieee80211_frame *);
1864 }
1865
1866 #if NBPFILTER > 0
1867 if (sc->sc_drvbpf != NULL) {
1868 struct mbuf mb;
1869 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
1870
1871 tap->wt_flags = 0;
1872 tap->wt_rate = rate;
1873 tap->wt_chan_freq = htole16(ic->ic_ibss_chan->ic_freq);
1874 tap->wt_chan_flags = htole16(ic->ic_ibss_chan->ic_flags);
1875 tap->wt_antenna = sc->tx_ant;
1876
1877 mb.m_data = (caddr_t)tap;
1878 mb.m_len = sc->sc_txtap_len;
1879 mb.m_next = m0;
1880 mb.m_nextpkt = NULL;
1881 mb.m_type = 0;
1882 mb.m_flags = 0;
1883 bpf_mtap(sc->sc_drvbpf, &mb, BPF_DIRECTION_OUT);
1884 }
1885 #endif
1886
1887 data->m = m0;
1888 data->ni = ni;
1889
1890 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1891 flags |= RT2560_TX_NEED_ACK;
1892
1893 dur = rt2560_txtime(RAL_ACK_SIZE, rt2560_ack_rate(ic, rate),
1894 ic->ic_flags) + RAL_SIFS;
1895 *(uint16_t *)wh->i_dur = htole16(dur);
1896 }
1897
1898 rt2560_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len, rate, 1,
1899 data->map->dm_segs->ds_addr);
1900
1901 bus_dmamap_sync(sc->sc_dmat, data->map, 0, data->map->dm_mapsize,
1902 BUS_DMASYNC_PREWRITE);
1903 bus_dmamap_sync(sc->sc_dmat, txq->map,
1904 txq->cur_encrypt * RT2560_TX_DESC_SIZE, RT2560_TX_DESC_SIZE,
1905 BUS_DMASYNC_PREWRITE);
1906
1907 DPRINTFN(10, ("sending frame len=%u idx=%u rate=%u\n",
1908 m0->m_pkthdr.len, txq->cur_encrypt, rate));
1909
1910
1911 txq->queued++;
1912 if (++txq->cur_encrypt >= txq->count)
1913 txq->cur_encrypt = 0;
1914 RAL_WRITE(sc, RT2560_SECCSR1, RT2560_KICK_ENCRYPT);
1915
1916 return 0;
1917 }
1918
1919 void
1920 rt2560_start(struct ifnet *ifp)
1921 {
1922 struct rt2560_softc *sc = ifp->if_softc;
1923 struct ieee80211com *ic = &sc->sc_ic;
1924 struct mbuf *m0;
1925 struct ieee80211_node *ni;
1926
1927
1928
1929
1930
1931 if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
1932 return;
1933
1934 for (;;) {
1935 IF_POLL(&ic->ic_mgtq, m0);
1936 if (m0 != NULL) {
1937 if (sc->prioq.queued >= RT2560_PRIO_RING_COUNT) {
1938 ifp->if_flags |= IFF_OACTIVE;
1939 break;
1940 }
1941 IF_DEQUEUE(&ic->ic_mgtq, m0);
1942
1943 ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
1944 m0->m_pkthdr.rcvif = NULL;
1945 #if NBPFILTER > 0
1946 if (ic->ic_rawbpf != NULL)
1947 bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
1948 #endif
1949 if (rt2560_tx_mgt(sc, m0, ni) != 0)
1950 break;
1951
1952 } else {
1953 if (ic->ic_state != IEEE80211_S_RUN)
1954 break;
1955 IFQ_POLL(&ifp->if_snd, m0);
1956 if (m0 == NULL)
1957 break;
1958 if (sc->txq.queued >= RT2560_TX_RING_COUNT - 1) {
1959 ifp->if_flags |= IFF_OACTIVE;
1960 break;
1961 }
1962 IFQ_DEQUEUE(&ifp->if_snd, m0);
1963 #if NBPFILTER > 0
1964 if (ifp->if_bpf != NULL)
1965 bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
1966 #endif
1967 m0 = ieee80211_encap(ifp, m0, &ni);
1968 if (m0 == NULL)
1969 continue;
1970 #if NBPFILTER > 0
1971 if (ic->ic_rawbpf != NULL)
1972 bpf_mtap(ic->ic_rawbpf, m0, BPF_DIRECTION_OUT);
1973 #endif
1974 if (rt2560_tx_data(sc, m0, ni) != 0) {
1975 if (ni != NULL)
1976 ieee80211_release_node(ic, ni);
1977 ifp->if_oerrors++;
1978 break;
1979 }
1980 }
1981
1982 sc->sc_tx_timer = 5;
1983 ifp->if_timer = 1;
1984 }
1985 }
1986
1987 void
1988 rt2560_watchdog(struct ifnet *ifp)
1989 {
1990 struct rt2560_softc *sc = ifp->if_softc;
1991
1992 ifp->if_timer = 0;
1993
1994 if (sc->sc_tx_timer > 0) {
1995 if (--sc->sc_tx_timer == 0) {
1996 printf("%s: device timeout\n", sc->sc_dev.dv_xname);
1997 rt2560_init(ifp);
1998 ifp->if_oerrors++;
1999 return;
2000 }
2001 ifp->if_timer = 1;
2002 }
2003
2004 ieee80211_watchdog(ifp);
2005 }
2006
2007 int
2008 rt2560_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2009 {
2010 struct rt2560_softc *sc = ifp->if_softc;
2011 struct ieee80211com *ic = &sc->sc_ic;
2012 struct ifaddr *ifa;
2013 struct ifreq *ifr;
2014 int s, error = 0;
2015
2016 s = splnet();
2017
2018 switch (cmd) {
2019 case SIOCSIFADDR:
2020 ifa = (struct ifaddr *)data;
2021 ifp->if_flags |= IFF_UP;
2022 #ifdef INET
2023 if (ifa->ifa_addr->sa_family == AF_INET)
2024 arp_ifinit(&ic->ic_ac, ifa);
2025 #endif
2026
2027 case SIOCSIFFLAGS:
2028 if (ifp->if_flags & IFF_UP) {
2029 if (ifp->if_flags & IFF_RUNNING)
2030 rt2560_update_promisc(sc);
2031 else
2032 rt2560_init(ifp);
2033 } else {
2034 if (ifp->if_flags & IFF_RUNNING)
2035 rt2560_stop(ifp, 1);
2036 }
2037 break;
2038
2039 case SIOCADDMULTI:
2040 case SIOCDELMULTI:
2041 ifr = (struct ifreq *)data;
2042 error = (cmd == SIOCADDMULTI) ?
2043 ether_addmulti(ifr, &ic->ic_ac) :
2044 ether_delmulti(ifr, &ic->ic_ac);
2045
2046 if (error == ENETRESET)
2047 error = 0;
2048 break;
2049
2050 case SIOCS80211CHANNEL:
2051
2052
2053
2054
2055
2056 error = ieee80211_ioctl(ifp, cmd, data);
2057 if (error == ENETRESET &&
2058 ic->ic_opmode == IEEE80211_M_MONITOR) {
2059 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
2060 (IFF_UP | IFF_RUNNING))
2061 rt2560_set_chan(sc, ic->ic_ibss_chan);
2062 error = 0;
2063 }
2064 break;
2065
2066 default:
2067 error = ieee80211_ioctl(ifp, cmd, data);
2068 }
2069
2070 if (error == ENETRESET) {
2071 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
2072 (IFF_UP | IFF_RUNNING))
2073 rt2560_init(ifp);
2074 error = 0;
2075 }
2076
2077 splx(s);
2078
2079 return error;
2080 }
2081
2082 void
2083 rt2560_bbp_write(struct rt2560_softc *sc, uint8_t reg, uint8_t val)
2084 {
2085 uint32_t tmp;
2086 int ntries;
2087
2088 for (ntries = 0; ntries < 100; ntries++) {
2089 if (!(RAL_READ(sc, RT2560_BBPCSR) & RT2560_BBP_BUSY))
2090 break;
2091 DELAY(1);
2092 }
2093 if (ntries == 100) {
2094 printf("%s: could not write to BBP\n", sc->sc_dev.dv_xname);
2095 return;
2096 }
2097
2098 tmp = RT2560_BBP_WRITE | RT2560_BBP_BUSY | reg << 8 | val;
2099 RAL_WRITE(sc, RT2560_BBPCSR, tmp);
2100
2101 DPRINTFN(15, ("BBP R%u <- 0x%02x\n", reg, val));
2102 }
2103
2104 uint8_t
2105 rt2560_bbp_read(struct rt2560_softc *sc, uint8_t reg)
2106 {
2107 uint32_t val;
2108 int ntries;
2109
2110 val = RT2560_BBP_BUSY | reg << 8;
2111 RAL_WRITE(sc, RT2560_BBPCSR, val);
2112
2113 for (ntries = 0; ntries < 100; ntries++) {
2114 val = RAL_READ(sc, RT2560_BBPCSR);
2115 if (!(val & RT2560_BBP_BUSY))
2116 return val & 0xff;
2117 DELAY(1);
2118 }
2119
2120 printf("%s: could not read from BBP\n", sc->sc_dev.dv_xname);
2121 return 0;
2122 }
2123
2124 void
2125 rt2560_rf_write(struct rt2560_softc *sc, uint8_t reg, uint32_t val)
2126 {
2127 uint32_t tmp;
2128 int ntries;
2129
2130 for (ntries = 0; ntries < 100; ntries++) {
2131 if (!(RAL_READ(sc, RT2560_RFCSR) & RT2560_RF_BUSY))
2132 break;
2133 DELAY(1);
2134 }
2135 if (ntries == 100) {
2136 printf("%s: could not write to RF\n", sc->sc_dev.dv_xname);
2137 return;
2138 }
2139
2140 tmp = RT2560_RF_BUSY | RT2560_RF_20BIT | (val & 0xfffff) << 2 |
2141 (reg & 0x3);
2142 RAL_WRITE(sc, RT2560_RFCSR, tmp);
2143
2144
2145 sc->rf_regs[reg] = val;
2146
2147 DPRINTFN(15, ("RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff));
2148 }
2149
2150 void
2151 rt2560_set_chan(struct rt2560_softc *sc, struct ieee80211_channel *c)
2152 {
2153 struct ieee80211com *ic = &sc->sc_ic;
2154 uint8_t power, tmp;
2155 u_int chan;
2156
2157 chan = ieee80211_chan2ieee(ic, c);
2158 if (chan == 0 || chan == IEEE80211_CHAN_ANY)
2159 return;
2160
2161 power = min(sc->txpow[chan - 1], 31);
2162
2163 DPRINTFN(2, ("setting channel to %u, txpower to %u\n", chan, power));
2164
2165 switch (sc->rf_rev) {
2166 case RT2560_RF_2522:
2167 rt2560_rf_write(sc, RT2560_RF1, 0x00814);
2168 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2522_r2[chan - 1]);
2169 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x00040);
2170 break;
2171
2172 case RT2560_RF_2523:
2173 rt2560_rf_write(sc, RT2560_RF1, 0x08804);
2174 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2523_r2[chan - 1]);
2175 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x38044);
2176 rt2560_rf_write(sc, RT2560_RF4,
2177 (chan == 14) ? 0x00280 : 0x00286);
2178 break;
2179
2180 case RT2560_RF_2524:
2181 rt2560_rf_write(sc, RT2560_RF1, 0x0c808);
2182 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2524_r2[chan - 1]);
2183 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x00040);
2184 rt2560_rf_write(sc, RT2560_RF4,
2185 (chan == 14) ? 0x00280 : 0x00286);
2186 break;
2187
2188 case RT2560_RF_2525:
2189 rt2560_rf_write(sc, RT2560_RF1, 0x08808);
2190 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2525_hi_r2[chan - 1]);
2191 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x18044);
2192 rt2560_rf_write(sc, RT2560_RF4,
2193 (chan == 14) ? 0x00280 : 0x00286);
2194
2195 rt2560_rf_write(sc, RT2560_RF1, 0x08808);
2196 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2525_r2[chan - 1]);
2197 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x18044);
2198 rt2560_rf_write(sc, RT2560_RF4,
2199 (chan == 14) ? 0x00280 : 0x00286);
2200 break;
2201
2202 case RT2560_RF_2525E:
2203 rt2560_rf_write(sc, RT2560_RF1, 0x08808);
2204 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2525e_r2[chan - 1]);
2205 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x18044);
2206 rt2560_rf_write(sc, RT2560_RF4,
2207 (chan == 14) ? 0x00286 : 0x00282);
2208 break;
2209
2210 case RT2560_RF_2526:
2211 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2526_hi_r2[chan - 1]);
2212 rt2560_rf_write(sc, RT2560_RF4,
2213 (chan & 1) ? 0x00386 : 0x00381);
2214 rt2560_rf_write(sc, RT2560_RF1, 0x08804);
2215
2216 rt2560_rf_write(sc, RT2560_RF2, rt2560_rf2526_r2[chan - 1]);
2217 rt2560_rf_write(sc, RT2560_RF3, power << 7 | 0x18044);
2218 rt2560_rf_write(sc, RT2560_RF4,
2219 (chan & 1) ? 0x00386 : 0x00381);
2220 break;
2221 }
2222
2223 if (ic->ic_opmode != IEEE80211_M_MONITOR &&
2224 ic->ic_state != IEEE80211_S_SCAN) {
2225
2226 tmp = rt2560_bbp_read(sc, 70);
2227
2228 tmp &= ~RT2560_JAPAN_FILTER;
2229 if (chan == 14)
2230 tmp |= RT2560_JAPAN_FILTER;
2231
2232 rt2560_bbp_write(sc, 70, tmp);
2233
2234 DELAY(1000);
2235 rt2560_disable_rf_tune(sc);
2236
2237
2238 RAL_READ(sc, RT2560_CNT0);
2239 }
2240 }
2241
2242
2243
2244
2245 void
2246 rt2560_disable_rf_tune(struct rt2560_softc *sc)
2247 {
2248 uint32_t tmp;
2249
2250 if (sc->rf_rev != RT2560_RF_2523) {
2251 tmp = sc->rf_regs[RT2560_RF1] & ~RT2560_RF1_AUTOTUNE;
2252 rt2560_rf_write(sc, RT2560_RF1, tmp);
2253 }
2254
2255 tmp = sc->rf_regs[RT2560_RF3] & ~RT2560_RF3_AUTOTUNE;
2256 rt2560_rf_write(sc, RT2560_RF3, tmp);
2257
2258 DPRINTFN(2, ("disabling RF autotune\n"));
2259 }
2260
2261
2262
2263
2264
2265 void
2266 rt2560_enable_tsf_sync(struct rt2560_softc *sc)
2267 {
2268 struct ieee80211com *ic = &sc->sc_ic;
2269 uint16_t logcwmin, preload;
2270 uint32_t tmp;
2271
2272
2273 RAL_WRITE(sc, RT2560_CSR14, 0);
2274
2275 tmp = 16 * ic->ic_bss->ni_intval;
2276 RAL_WRITE(sc, RT2560_CSR12, tmp);
2277
2278 RAL_WRITE(sc, RT2560_CSR13, 0);
2279
2280 logcwmin = 5;
2281 preload = (ic->ic_opmode == IEEE80211_M_STA) ? 384 : 1024;
2282 tmp = logcwmin << 16 | preload;
2283 RAL_WRITE(sc, RT2560_BCNOCSR, tmp);
2284
2285
2286 tmp = RT2560_ENABLE_TSF | RT2560_ENABLE_TBCN;
2287 if (ic->ic_opmode == IEEE80211_M_STA)
2288 tmp |= RT2560_ENABLE_TSF_SYNC(1);
2289 else
2290 tmp |= RT2560_ENABLE_TSF_SYNC(2) |
2291 RT2560_ENABLE_BEACON_GENERATOR;
2292 RAL_WRITE(sc, RT2560_CSR14, tmp);
2293
2294 DPRINTF(("enabling TSF synchronization\n"));
2295 }
2296
2297 void
2298 rt2560_update_plcp(struct rt2560_softc *sc)
2299 {
2300 struct ieee80211com *ic = &sc->sc_ic;
2301
2302
2303 RAL_WRITE(sc, RT2560_PLCP1MCSR, 0x00700400);
2304
2305 if (!(ic->ic_flags & IEEE80211_F_SHPREAMBLE)) {
2306
2307 RAL_WRITE(sc, RT2560_PLCP2MCSR, 0x00380401);
2308 RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x00150402);
2309 RAL_WRITE(sc, RT2560_PLCP11MCSR, 0x000b8403);
2310 } else {
2311
2312 RAL_WRITE(sc, RT2560_PLCP2MCSR, 0x00380409);
2313 RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x0015040a);
2314 RAL_WRITE(sc, RT2560_PLCP11MCSR, 0x000b840b);
2315 }
2316
2317 DPRINTF(("updating PLCP for %s preamble\n",
2318 (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "short" : "long"));
2319 }
2320
2321 void
2322 rt2560_updateslot(struct ieee80211com *ic)
2323 {
2324 struct rt2560_softc *sc = ic->ic_if.if_softc;
2325
2326 if (ic->ic_opmode == IEEE80211_M_HOSTAP) {
2327
2328
2329
2330
2331
2332 sc->sc_flags |= RT2560_UPDATE_SLOT;
2333 } else
2334 rt2560_set_slottime(sc);
2335 }
2336
2337
2338
2339
2340
2341 void
2342 rt2560_set_slottime(struct rt2560_softc *sc)
2343 {
2344 struct ieee80211com *ic = &sc->sc_ic;
2345 uint8_t slottime;
2346 uint16_t sifs, pifs, difs, eifs;
2347 uint32_t tmp;
2348
2349 slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
2350
2351
2352 sifs = RAL_SIFS - RT2560_RXTX_TURNAROUND;
2353 pifs = sifs + slottime;
2354 difs = sifs + 2 * slottime;
2355 eifs = (ic->ic_curmode == IEEE80211_MODE_11B) ? 364 : 60;
2356
2357 tmp = RAL_READ(sc, RT2560_CSR11);
2358 tmp = (tmp & ~0x1f00) | slottime << 8;
2359 RAL_WRITE(sc, RT2560_CSR11, tmp);
2360
2361 tmp = pifs << 16 | sifs;
2362 RAL_WRITE(sc, RT2560_CSR18, tmp);
2363
2364 tmp = eifs << 16 | difs;
2365 RAL_WRITE(sc, RT2560_CSR19, tmp);
2366
2367 DPRINTF(("setting slottime to %uus\n", slottime));
2368 }
2369
2370 void
2371 rt2560_set_basicrates(struct rt2560_softc *sc)
2372 {
2373 struct ieee80211com *ic = &sc->sc_ic;
2374
2375
2376 if (ic->ic_curmode == IEEE80211_MODE_11B) {
2377
2378 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x3);
2379 } else {
2380
2381 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0xf);
2382 }
2383 }
2384
2385 void
2386 rt2560_update_led(struct rt2560_softc *sc, int led1, int led2)
2387 {
2388 uint32_t tmp;
2389
2390
2391 tmp = led1 << 16 | led2 << 17 | 70 << 8 | 30;
2392 RAL_WRITE(sc, RT2560_LEDCSR, tmp);
2393 }
2394
2395 void
2396 rt2560_set_bssid(struct rt2560_softc *sc, uint8_t *bssid)
2397 {
2398 uint32_t tmp;
2399
2400 tmp = bssid[0] | bssid[1] << 8 | bssid[2] << 16 | bssid[3] << 24;
2401 RAL_WRITE(sc, RT2560_CSR5, tmp);
2402
2403 tmp = bssid[4] | bssid[5] << 8;
2404 RAL_WRITE(sc, RT2560_CSR6, tmp);
2405
2406 DPRINTF(("setting BSSID to %s\n", ether_sprintf(bssid)));
2407 }
2408
2409 void
2410 rt2560_set_macaddr(struct rt2560_softc *sc, uint8_t *addr)
2411 {
2412 uint32_t tmp;
2413
2414 tmp = addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24;
2415 RAL_WRITE(sc, RT2560_CSR3, tmp);
2416
2417 tmp = addr[4] | addr[5] << 8;
2418 RAL_WRITE(sc, RT2560_CSR4, tmp);
2419
2420 DPRINTF(("setting MAC address to %s\n", ether_sprintf(addr)));
2421 }
2422
2423 void
2424 rt2560_get_macaddr(struct rt2560_softc *sc, uint8_t *addr)
2425 {
2426 uint32_t tmp;
2427
2428 tmp = RAL_READ(sc, RT2560_CSR3);
2429 addr[0] = tmp & 0xff;
2430 addr[1] = (tmp >> 8) & 0xff;
2431 addr[2] = (tmp >> 16) & 0xff;
2432 addr[3] = (tmp >> 24);
2433
2434 tmp = RAL_READ(sc, RT2560_CSR4);
2435 addr[4] = tmp & 0xff;
2436 addr[5] = (tmp >> 8) & 0xff;
2437 }
2438
2439 void
2440 rt2560_update_promisc(struct rt2560_softc *sc)
2441 {
2442 struct ifnet *ifp = &sc->sc_ic.ic_if;
2443 uint32_t tmp;
2444
2445 tmp = RAL_READ(sc, RT2560_RXCSR0);
2446
2447 tmp &= ~RT2560_DROP_NOT_TO_ME;
2448 if (!(ifp->if_flags & IFF_PROMISC))
2449 tmp |= RT2560_DROP_NOT_TO_ME;
2450
2451 RAL_WRITE(sc, RT2560_RXCSR0, tmp);
2452
2453 DPRINTF(("%s promiscuous mode\n", (ifp->if_flags & IFF_PROMISC) ?
2454 "entering" : "leaving"));
2455 }
2456
2457 void
2458 rt2560_set_txantenna(struct rt2560_softc *sc, int antenna)
2459 {
2460 uint32_t tmp;
2461 uint8_t tx;
2462
2463 tx = rt2560_bbp_read(sc, RT2560_BBP_TX) & ~RT2560_BBP_ANTMASK;
2464 if (antenna == 1)
2465 tx |= RT2560_BBP_ANTA;
2466 else if (antenna == 2)
2467 tx |= RT2560_BBP_ANTB;
2468 else
2469 tx |= RT2560_BBP_DIVERSITY;
2470
2471
2472 if (sc->rf_rev == RT2560_RF_2525E || sc->rf_rev == RT2560_RF_2526 ||
2473 sc->rf_rev == RT2560_RF_5222)
2474 tx |= RT2560_BBP_FLIPIQ;
2475
2476 rt2560_bbp_write(sc, RT2560_BBP_TX, tx);
2477
2478
2479 tmp = RAL_READ(sc, RT2560_BBPCSR1) & ~0x00070007;
2480 tmp |= (tx & 0x7) << 16 | (tx & 0x7);
2481 RAL_WRITE(sc, RT2560_BBPCSR1, tmp);
2482 }
2483
2484 void
2485 rt2560_set_rxantenna(struct rt2560_softc *sc, int antenna)
2486 {
2487 uint8_t rx;
2488
2489 rx = rt2560_bbp_read(sc, RT2560_BBP_RX) & ~RT2560_BBP_ANTMASK;
2490 if (antenna == 1)
2491 rx |= RT2560_BBP_ANTA;
2492 else if (antenna == 2)
2493 rx |= RT2560_BBP_ANTB;
2494 else
2495 rx |= RT2560_BBP_DIVERSITY;
2496
2497
2498 if (sc->rf_rev == RT2560_RF_2525E || sc->rf_rev == RT2560_RF_2526)
2499 rx &= ~RT2560_BBP_FLIPIQ;
2500
2501 rt2560_bbp_write(sc, RT2560_BBP_RX, rx);
2502 }
2503
2504 const char *
2505 rt2560_get_rf(int rev)
2506 {
2507 switch (rev) {
2508 case RT2560_RF_2522: return "RT2522";
2509 case RT2560_RF_2523: return "RT2523";
2510 case RT2560_RF_2524: return "RT2524";
2511 case RT2560_RF_2525: return "RT2525";
2512 case RT2560_RF_2525E: return "RT2525e";
2513 case RT2560_RF_2526: return "RT2526";
2514 case RT2560_RF_5222: return "RT5222";
2515 default: return "unknown";
2516 }
2517 }
2518
2519 void
2520 rt2560_read_eeprom(struct rt2560_softc *sc)
2521 {
2522 uint16_t val;
2523 int i;
2524
2525 val = rt2560_eeprom_read(sc, RT2560_EEPROM_CONFIG0);
2526 sc->rf_rev = (val >> 11) & 0x1f;
2527 sc->hw_radio = (val >> 10) & 0x1;
2528 sc->led_mode = (val >> 6) & 0x7;
2529 sc->rx_ant = (val >> 4) & 0x3;
2530 sc->tx_ant = (val >> 2) & 0x3;
2531 sc->nb_ant = val & 0x3;
2532
2533
2534 for (i = 0; i < 16; i++) {
2535 val = rt2560_eeprom_read(sc, RT2560_EEPROM_BBP_BASE + i);
2536 sc->bbp_prom[i].reg = val >> 8;
2537 sc->bbp_prom[i].val = val & 0xff;
2538 }
2539
2540
2541 for (i = 0; i < 14 / 2; i++) {
2542 val = rt2560_eeprom_read(sc, RT2560_EEPROM_TXPOWER + i);
2543 sc->txpow[i * 2] = val >> 8;
2544 sc->txpow[i * 2 + 1] = val & 0xff;
2545 }
2546 }
2547
2548 int
2549 rt2560_bbp_init(struct rt2560_softc *sc)
2550 {
2551 #define N(a) (sizeof (a) / sizeof ((a)[0]))
2552 int i, ntries;
2553
2554
2555 for (ntries = 0; ntries < 100; ntries++) {
2556 if (rt2560_bbp_read(sc, RT2560_BBP_VERSION) != 0)
2557 break;
2558 DELAY(1);
2559 }
2560 if (ntries == 100) {
2561 printf("%s: timeout waiting for BBP\n", sc->sc_dev.dv_xname);
2562 return EIO;
2563 }
2564
2565
2566 for (i = 0; i < N(rt2560_def_bbp); i++) {
2567 rt2560_bbp_write(sc, rt2560_def_bbp[i].reg,
2568 rt2560_def_bbp[i].val);
2569 }
2570 #if 0
2571
2572 for (i = 0; i < 16; i++) {
2573 if (sc->bbp_prom[i].reg == 0xff)
2574 continue;
2575 rt2560_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
2576 }
2577 #endif
2578
2579 return 0;
2580 #undef N
2581 }
2582
2583 int
2584 rt2560_init(struct ifnet *ifp)
2585 {
2586 #define N(a) (sizeof (a) / sizeof ((a)[0]))
2587 struct rt2560_softc *sc = ifp->if_softc;
2588 struct ieee80211com *ic = &sc->sc_ic;
2589 uint32_t tmp;
2590 int i;
2591
2592
2593 if (!(sc->sc_flags & RT2560_ENABLED)) {
2594 if (sc->sc_enable != NULL && (*sc->sc_enable)(sc) != 0) {
2595 printf("%s: could not enable device\n",
2596 sc->sc_dev.dv_xname);
2597 return EIO;
2598 }
2599 sc->sc_flags |= RT2560_ENABLED;
2600 }
2601
2602 rt2560_stop(ifp, 0);
2603
2604
2605 tmp = RT2560_PRIO_RING_COUNT << 24 |
2606 RT2560_ATIM_RING_COUNT << 16 |
2607 RT2560_TX_RING_COUNT << 8 |
2608 RT2560_TX_DESC_SIZE;
2609
2610
2611 RAL_WRITE(sc, RT2560_TXCSR2, tmp);
2612 RAL_WRITE(sc, RT2560_TXCSR3, sc->txq.physaddr);
2613 RAL_WRITE(sc, RT2560_TXCSR5, sc->prioq.physaddr);
2614 RAL_WRITE(sc, RT2560_TXCSR4, sc->atimq.physaddr);
2615 RAL_WRITE(sc, RT2560_TXCSR6, sc->bcnq.physaddr);
2616
2617
2618 tmp = RT2560_RX_RING_COUNT << 8 | RT2560_RX_DESC_SIZE;
2619
2620 RAL_WRITE(sc, RT2560_RXCSR1, tmp);
2621 RAL_WRITE(sc, RT2560_RXCSR2, sc->rxq.physaddr);
2622
2623
2624 for (i = 0; i < N(rt2560_def_mac); i++)
2625 RAL_WRITE(sc, rt2560_def_mac[i].reg, rt2560_def_mac[i].val);
2626
2627 IEEE80211_ADDR_COPY(ic->ic_myaddr, LLADDR(ifp->if_sadl));
2628 rt2560_set_macaddr(sc, ic->ic_myaddr);
2629
2630
2631 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x153);
2632
2633 rt2560_set_txantenna(sc, 1);
2634 rt2560_set_rxantenna(sc, 1);
2635 rt2560_set_slottime(sc);
2636 rt2560_update_plcp(sc);
2637 rt2560_update_led(sc, 0, 0);
2638
2639 RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
2640 RAL_WRITE(sc, RT2560_CSR1, RT2560_HOST_READY);
2641
2642 if (rt2560_bbp_init(sc) != 0) {
2643 rt2560_stop(ifp, 1);
2644 return EIO;
2645 }
2646
2647
2648 ic->ic_bss->ni_chan = ic->ic_ibss_chan;
2649 rt2560_set_chan(sc, ic->ic_bss->ni_chan);
2650
2651
2652 tmp = RT2560_DROP_PHY_ERROR | RT2560_DROP_CRC_ERROR;
2653 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2654 tmp |= RT2560_DROP_CTL | RT2560_DROP_VERSION_ERROR;
2655 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2656 tmp |= RT2560_DROP_TODS;
2657 if (!(ifp->if_flags & IFF_PROMISC))
2658 tmp |= RT2560_DROP_NOT_TO_ME;
2659 }
2660 RAL_WRITE(sc, RT2560_RXCSR0, tmp);
2661
2662
2663 RAL_READ(sc, RT2560_CNT0);
2664 RAL_READ(sc, RT2560_CNT4);
2665
2666
2667 RAL_WRITE(sc, RT2560_CSR7, 0xffffffff);
2668
2669
2670 RAL_WRITE(sc, RT2560_CSR8, RT2560_INTR_MASK);
2671
2672 ifp->if_flags &= ~IFF_OACTIVE;
2673 ifp->if_flags |= IFF_RUNNING;
2674
2675 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2676 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
2677 else
2678 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
2679
2680 return 0;
2681 #undef N
2682 }
2683
2684 void
2685 rt2560_stop(struct ifnet *ifp, int disable)
2686 {
2687 struct rt2560_softc *sc = ifp->if_softc;
2688 struct ieee80211com *ic = &sc->sc_ic;
2689
2690 sc->sc_tx_timer = 0;
2691 ifp->if_timer = 0;
2692 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2693
2694 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
2695
2696
2697 RAL_WRITE(sc, RT2560_TXCSR0, RT2560_ABORT_TX);
2698
2699
2700 RAL_WRITE(sc, RT2560_RXCSR0, RT2560_DISABLE_RX);
2701
2702
2703 RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
2704 RAL_WRITE(sc, RT2560_CSR1, 0);
2705
2706
2707 RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
2708
2709
2710 RAL_WRITE(sc, RT2560_CSR7, 0xffffffff);
2711
2712
2713 rt2560_reset_tx_ring(sc, &sc->txq);
2714 rt2560_reset_tx_ring(sc, &sc->atimq);
2715 rt2560_reset_tx_ring(sc, &sc->prioq);
2716 rt2560_reset_tx_ring(sc, &sc->bcnq);
2717 rt2560_reset_rx_ring(sc, &sc->rxq);
2718
2719
2720 if (disable && sc->sc_disable != NULL) {
2721 if (sc->sc_flags & RT2560_ENABLED) {
2722 (*sc->sc_disable)(sc);
2723 sc->sc_flags &= ~RT2560_ENABLED;
2724 }
2725 }
2726 }
2727
2728 void
2729 rt2560_power(int why, void *arg)
2730 {
2731 struct rt2560_softc *sc = arg;
2732 struct ifnet *ifp = &sc->sc_ic.ic_if;
2733 int s;
2734
2735 DPRINTF(("%s: rt2560_power(%d)\n", sc->sc_dev.dv_xname, why));
2736
2737 s = splnet();
2738 switch (why) {
2739 case PWR_SUSPEND:
2740 case PWR_STANDBY:
2741 rt2560_stop(ifp, 1);
2742 if (sc->sc_power != NULL)
2743 (*sc->sc_power)(sc, why);
2744 break;
2745 case PWR_RESUME:
2746 if (ifp->if_flags & IFF_UP) {
2747 rt2560_init(ifp);
2748 if (sc->sc_power != NULL)
2749 (*sc->sc_power)(sc, why);
2750 if (ifp->if_flags & IFF_RUNNING)
2751 rt2560_start(ifp);
2752 }
2753 break;
2754 }
2755 splx(s);
2756 }
2757
2758 void
2759 rt2560_shutdown(void *arg)
2760 {
2761 struct rt2560_softc *sc = arg;
2762
2763 rt2560_stop(&sc->sc_ic.ic_if, 1);
2764 }
2765
2766 struct cfdriver ral_cd = {
2767 NULL, "ral", DV_IFNET
2768 };