Annotation of sys/dev/ic/rt2560.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: rt2560.c,v 1.32 2007/03/08 21:58:27 deraadt Exp $ */
2:
3: /*-
4: * Copyright (c) 2005, 2006
5: * Damien Bergamini <damien.bergamini@free.fr>
6: *
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.
10: *
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.
18: */
19:
20: /*-
21: * Ralink Technology RT2560 chipset driver
22: * http://www.ralinktech.com/
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: /* retrieve RT2560 rev. no */
187: sc->asic_rev = RAL_READ(sc, RT2560_CSR0);
188:
189: /* retrieve MAC address */
190: rt2560_get_macaddr(sc, ic->ic_myaddr);
191: printf(", address %s\n", ether_sprintf(ic->ic_myaddr));
192:
193: /* retrieve RF rev. no and various other things from EEPROM */
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: * Allocate Tx and Rx rings.
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; /* not only, but not used */
234: ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
235: ic->ic_state = IEEE80211_S_INIT;
236:
237: /* set device capabilities */
238: ic->ic_caps =
239: IEEE80211_C_IBSS | /* IBSS mode supported */
240: IEEE80211_C_MONITOR | /* monitor mode supported */
241: IEEE80211_C_HOSTAP | /* HostAp mode supported */
242: IEEE80211_C_TXPMGT | /* tx power management */
243: IEEE80211_C_SHPREAMBLE | /* short preamble supported */
244: IEEE80211_C_SHSLOT | /* short slot time supported */
245: IEEE80211_C_WEP; /* s/w WEP */
246:
247: /* set supported .11b and .11g rates */
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: /* set supported .11b and .11g channels (1 through 14) */
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: /* override state transition machine */
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: * Make sure the interface is shutdown during reboot.
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); /* free all nodes */
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: * The node has already been freed at that point so don't call
434: * ieee80211_release_node() here.
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: * The node has already been freed at that point so
477: * don't call ieee80211_release_node() here.
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: * Pre-allocate Rx buffers and populate Rx ring.
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: * This function is called periodically (every 200ms) during scanning to
673: * switch from one channel to another.
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: * This function is called for each neighbor node.
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: /* set rate to some reasonable initial value */
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: /* abort TSF synchronization */
750: RAL_WRITE(sc, RT2560_CSR14, 0);
751:
752: /* turn association led off */
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: /* turn assocation led on */
798: rt2560_update_led(sc, 1, 0);
799:
800: if (ic->ic_opmode == IEEE80211_M_STA) {
801: /* fake a join to init the tx rate */
802: rt2560_newassoc(ic, ni, 1);
803: }
804:
805: if (ic->ic_opmode != IEEE80211_M_MONITOR) {
806: /* start automatic rate control timer */
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: * Read 16 bits at address 'addr' from the serial EEPROM (either 93C46 or
820: * 93C66).
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: /* clock C once before the first command */
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: /* write start bit (1) */
837: RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D);
838: RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D | RT2560_C);
839:
840: /* write READ opcode (10) */
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: /* write address (A5-A0 or A7-A0) */
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: /* read data Q15-Q0 */
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: /* clear Chip Select and clock C */
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: * Some frames were processed by the hardware cipher engine and are ready for
878: * transmission.
879: */
880: void
881: rt2560_encryption_intr(struct rt2560_softc *sc)
882: {
883: int hw;
884:
885: /* retrieve last descriptor index processed by cipher engine */
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: /* for TKIP, swap eiv field to fix a bug in ASIC */
902: if ((letoh32(desc->flags) & RT2560_TX_CIPHER_MASK) ==
903: RT2560_TX_CIPHER_TKIP)
904: desc->eiv = swap32(desc->eiv);
905:
906: /* mark the frame ready for transmission */
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: /* kick Tx */
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: /* descriptor is no longer valid */
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: /* descriptor is no longer valid */
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: * Some frames were processed by the hardware cipher engine and are ready for
1071: * transmission to the IEEE802.11 layer.
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: /* retrieve last decriptor index processed by cipher engine */
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: * Try to allocate a new mbuf for this ring element and load it
1114: * before processing the current mbuf. If the ring element
1115: * cannot be loaded, drop the received packet and reuse the old
1116: * mbuf. In the unlikely case that the old mbuf can't be
1117: * reloaded either, explicitly panic.
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: /* try to reload the old mbuf */
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: /* very unlikely that it will fail... */
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: * New mbuf successfully loaded, update Rx ring and continue
1155: * processing.
1156: */
1157: m = data->m;
1158: data->m = mnew;
1159: desc->physaddr = htole32(data->map->dm_segs->ds_addr);
1160:
1161: /* finalize mbuf */
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: /* get timestamp (low and high 32 bits) */
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: /* send the frame to the 802.11 layer */
1199: ieee80211_input(ifp, m, ni, desc->rssi, 0);
1200:
1201: /* node is no longer needed */
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: * In HostAP mode, ieee80211_input() will enqueue packets in if_snd
1218: * without calling if_start().
1219: */
1220: if (!IFQ_IS_EMPTY(&ifp->if_snd) && !(ifp->if_flags & IFF_OACTIVE))
1221: rt2560_start(ifp);
1222: }
1223:
1224: /*
1225: * Some frames were received. Pass them to the hardware cipher engine before
1226: * sending them to the 802.11 layer.
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: * This should not happen since we did not request
1249: * to receive those frames when we filled RXCSR0.
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: /* mark the frame for decryption */
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: /* kick decrypt */
1274: RAL_WRITE(sc, RT2560_SECCSR0, RT2560_KICK_DECRYPT);
1275: }
1276:
1277: /*
1278: * This function is called in HostAP or IBSS modes when it's time to send a
1279: * new beacon (every ni_intval milliseconds).
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: /* update ERP Information Element */
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; /* not for us */
1331:
1332: /* disable interrupts */
1333: RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
1334:
1335: /* acknowledge interrupts */
1336: RAL_WRITE(sc, RT2560_CSR7, r);
1337:
1338: /* don't re-enable interrupts if we're shutting down */
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: /* re-enable interrupts */
1364: RAL_WRITE(sc, RT2560_CSR8, RT2560_INTR_MASK);
1365:
1366: return 1;
1367: }
1368:
1369: /* quickly determine if a given rate is CCK or OFDM */
1370: #define RAL_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
1371:
1372: #define RAL_ACK_SIZE 14 /* 10 + 4(FCS) */
1373: #define RAL_CTS_SIZE 14 /* 10 + 4(FCS) */
1374:
1375: #define RAL_SIFS 10 /* us */
1376:
1377: #define RT2560_RXTX_TURNAROUND 10 /* us */
1378:
1379: /*
1380: * This function is only used by the Rx radiotap code. It returns the rate at
1381: * which a given frame was received.
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: /* reverse function of rt2560_plcp_signal */
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; /* should not get there */
1410: }
1411: #endif
1412:
1413: /*
1414: * Return the expected ack rate for a frame transmitted at rate `rate'.
1415: */
1416: int
1417: rt2560_ack_rate(struct ieee80211com *ic, int rate)
1418: {
1419: switch (rate) {
1420: /* CCK rates */
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: /* OFDM rates */
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: /* default to 1Mbps */
1443: return 2;
1444: }
1445:
1446: /*
1447: * Compute the duration (in us) needed to transmit `len' bytes at rate `rate'.
1448: * The function automatically determines the operating mode depending on the
1449: * given rate. `flags' indicates whether short preamble is in use or not.
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: /* IEEE Std 802.11g-2003, pp. 44 */
1458: txtime = (8 + 4 * len + 3 + rate - 1) / rate;
1459: txtime = 16 + 4 + 4 * txtime + 6;
1460: } else {
1461: /* IEEE Std 802.11b-1999, pp. 28 */
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: /* CCK rates (returned values are device-dependent) */
1476: case 2: return 0x0;
1477: case 4: return 0x1;
1478: case 11: return 0x2;
1479: case 22: return 0x3;
1480:
1481: /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
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: /* unsupported rates (should not get there) */
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: /* setup PLCP fields */
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: * Store pointer to ERP Information Element so that we can update it
1577: * dynamically when the slot time changes.
1578: * XXX: this is ugly since it depends on how net80211 builds beacon
1579: * frames but ieee80211_beacon_alloc() don't store offsets for us.
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: /* packet header may have moved, reset our local pointer */
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: /* tell hardware to set timestamp for probe responses */
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: /* kick prio */
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: /* packet header may have moved, reset our local pointer */
1716: wh = mtod(m0, struct ieee80211_frame *);
1717: }
1718:
1719: /* compute actual packet length (including CRC and crypto overhead) */
1720: pktlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN;
1721:
1722: /* pickup a rate */
1723: if (IEEE80211_IS_MULTICAST(wh->i_addr1) ||
1724: ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
1725: IEEE80211_FC0_TYPE_MGT)) {
1726: /* mgmt/multicast frames are sent at the lowest avail. rate */
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; /* XXX should not happen */
1735: rate &= IEEE80211_RATE_VAL;
1736:
1737: /*
1738: * Packet Bursting: backoff after ppb=8 frames to give other STAs a
1739: * chance to contend for the wireless medium.
1740: */
1741: if (ic->ic_opmode == IEEE80211_M_STA && (ni->ni_txseq & 7))
1742: flags |= RT2560_TX_IFS_SIFS;
1743:
1744: /* check if RTS/CTS or CTS-to-self protection must be used */
1745: if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1746: /* multicast frames are not sent at OFDM rates in 802.11b/g */
1747: if (pktlen > ic->ic_rtsthreshold) {
1748: needrts = 1; /* RTS/CTS based on frame length */
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; /* CTS-to-self */
1753: else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
1754: needrts = 1; /* RTS/CTS */
1755: }
1756: }
1757: if (needrts || needcts) {
1758: struct mbuf *mprot;
1759: int protrate, ackrate;
1760: uint16_t dur;
1761:
1762: protrate = 2; /* XXX */
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: /* avoid multiple free() of the same node for each fragment */
1797: data->ni = ieee80211_ref_node(ni);
1798:
1799: /* XXX may want to pass the protection frame to BPF */
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: /* too many fragments, linearize */
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: /* packet header have moved, reset our local pointer */
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: /* kick encrypt */
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: * net80211 may still try to send management frames even if the
1929: * IFF_RUNNING flag is not set...
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: /* FALLTHROUGH */
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: * This allows for fast channel switching in monitor mode
2053: * (used by kismet). In IBSS mode, we must explicitly reset
2054: * the interface to generate a new beacon frame.
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: /* remember last written value in sc */
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: /* set Japan filter bit for channel 14 */
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); /* RF needs a 1ms delay here */
2235: rt2560_disable_rf_tune(sc);
2236:
2237: /* clear CRC errors */
2238: RAL_READ(sc, RT2560_CNT0);
2239: }
2240: }
2241:
2242: /*
2243: * Disable RF auto-tuning.
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: * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
2263: * synchronization.
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: /* first, disable TSF synchronization */
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: /* finally, enable TSF synchronization */
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: /* no short preamble for 1Mbps */
2303: RAL_WRITE(sc, RT2560_PLCP1MCSR, 0x00700400);
2304:
2305: if (!(ic->ic_flags & IEEE80211_F_SHPREAMBLE)) {
2306: /* values taken from the reference driver */
2307: RAL_WRITE(sc, RT2560_PLCP2MCSR, 0x00380401);
2308: RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x00150402);
2309: RAL_WRITE(sc, RT2560_PLCP11MCSR, 0x000b8403);
2310: } else {
2311: /* same values as above or'ed 0x8 */
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: * In HostAP mode, we defer setting of new slot time until
2329: * updated ERP Information Element has propagated to all
2330: * associated STAs.
2331: */
2332: sc->sc_flags |= RT2560_UPDATE_SLOT;
2333: } else
2334: rt2560_set_slottime(sc);
2335: }
2336:
2337: /*
2338: * IEEE 802.11a (and possibly 802.11g) use short slot time. Refer to
2339: * IEEE Std 802.11-1999 pp. 85 to know how these values are computed.
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: /* define the MAC slot boundaries */
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: /* update basic rate set */
2376: if (ic->ic_curmode == IEEE80211_MODE_11B) {
2377: /* 11b basic rates: 1, 2Mbps */
2378: RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x3);
2379: } else {
2380: /* 11b/g basic rates: 1, 2, 5.5, 11Mbps */
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: /* set ON period to 70ms and OFF period to 30ms */
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: /* need to force I/Q flip for RF 2525e, 2526 and 5222 */
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: /* update values for CCK and OFDM in BBPCSR1 */
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: /* need to force no I/Q flip for RF 2525e and 2526 */
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: /* read default values for BBP registers */
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: /* read Tx power for all b/g channels */
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: /* wait for BBP to be ready */
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: /* initialize BBP registers to default values */
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: /* initialize BBP registers to values stored in EEPROM */
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: /* for CardBus, power on the socket */
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: /* setup tx rings */
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: /* rings _must_ be initialized in this _exact_ order! */
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: /* setup rx ring */
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: /* initialize MAC registers to default values */
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: /* set basic rate set (will be updated later) */
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: /* set default BSS channel */
2648: ic->ic_bss->ni_chan = ic->ic_ibss_chan;
2649: rt2560_set_chan(sc, ic->ic_bss->ni_chan);
2650:
2651: /* kick Rx */
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: /* clear old FCS and Rx FIFO errors */
2663: RAL_READ(sc, RT2560_CNT0);
2664: RAL_READ(sc, RT2560_CNT4);
2665:
2666: /* clear any pending interrupts */
2667: RAL_WRITE(sc, RT2560_CSR7, 0xffffffff);
2668:
2669: /* enable interrupts */
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); /* free all nodes */
2695:
2696: /* abort Tx */
2697: RAL_WRITE(sc, RT2560_TXCSR0, RT2560_ABORT_TX);
2698:
2699: /* disable Rx */
2700: RAL_WRITE(sc, RT2560_RXCSR0, RT2560_DISABLE_RX);
2701:
2702: /* reset ASIC (and thus, BBP) */
2703: RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
2704: RAL_WRITE(sc, RT2560_CSR1, 0);
2705:
2706: /* disable interrupts */
2707: RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
2708:
2709: /* clear any pending interrupt */
2710: RAL_WRITE(sc, RT2560_CSR7, 0xffffffff);
2711:
2712: /* reset Tx and Rx rings */
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: /* for CardBus, power down the socket */
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: };
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to rt2560.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic