The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ral/rt2560.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $FreeBSD$       */
    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 #include <sys/cdefs.h>
   21 __FBSDID("$FreeBSD$");
   22 
   23 /*-
   24  * Ralink Technology RT2560 chipset driver
   25  * http://www.ralinktech.com/
   26  */
   27 
   28 #include <sys/param.h>
   29 #include <sys/sysctl.h>
   30 #include <sys/sockio.h>
   31 #include <sys/mbuf.h>
   32 #include <sys/kernel.h>
   33 #include <sys/socket.h>
   34 #include <sys/systm.h>
   35 #include <sys/malloc.h>
   36 #include <sys/module.h>
   37 #include <sys/bus.h>
   38 #include <sys/endian.h>
   39 
   40 #include <machine/bus.h>
   41 #include <machine/resource.h>
   42 #include <sys/rman.h>
   43 
   44 #include <net/bpf.h>
   45 #include <net/if.h>
   46 #include <net/if_arp.h>
   47 #include <net/ethernet.h>
   48 #include <net/if_dl.h>
   49 #include <net/if_media.h>
   50 #include <net/if_types.h>
   51 
   52 #include <net80211/ieee80211_var.h>
   53 #include <net80211/ieee80211_radiotap.h>
   54 
   55 #include <netinet/in.h>
   56 #include <netinet/in_systm.h>
   57 #include <netinet/in_var.h>
   58 #include <netinet/ip.h>
   59 #include <netinet/if_ether.h>
   60 
   61 #include <dev/ral/if_ralrate.h>
   62 #include <dev/ral/rt2560reg.h>
   63 #include <dev/ral/rt2560var.h>
   64 
   65 #ifdef RAL_DEBUG
   66 #define DPRINTF(x)      do { if (ral_debug > 0) printf x; } while (0)
   67 #define DPRINTFN(n, x)  do { if (ral_debug >= (n)) printf x; } while (0)
   68 extern int ral_debug;
   69 #else
   70 #define DPRINTF(x)
   71 #define DPRINTFN(n, x)
   72 #endif
   73 
   74 static void             rt2560_dma_map_addr(void *, bus_dma_segment_t *, int,
   75                             int);
   76 static int              rt2560_alloc_tx_ring(struct rt2560_softc *,
   77                             struct rt2560_tx_ring *, int);
   78 static void             rt2560_reset_tx_ring(struct rt2560_softc *,
   79                             struct rt2560_tx_ring *);
   80 static void             rt2560_free_tx_ring(struct rt2560_softc *,
   81                             struct rt2560_tx_ring *);
   82 static int              rt2560_alloc_rx_ring(struct rt2560_softc *,
   83                             struct rt2560_rx_ring *, int);
   84 static void             rt2560_reset_rx_ring(struct rt2560_softc *,
   85                             struct rt2560_rx_ring *);
   86 static void             rt2560_free_rx_ring(struct rt2560_softc *,
   87                             struct rt2560_rx_ring *);
   88 static struct           ieee80211_node *rt2560_node_alloc(
   89                             struct ieee80211_node_table *);
   90 static int              rt2560_media_change(struct ifnet *);
   91 static void             rt2560_next_scan(void *);
   92 static void             rt2560_iter_func(void *, struct ieee80211_node *);
   93 static void             rt2560_update_rssadapt(void *);
   94 static int              rt2560_newstate(struct ieee80211com *,
   95                             enum ieee80211_state, int);
   96 static uint16_t         rt2560_eeprom_read(struct rt2560_softc *, uint8_t);
   97 static void             rt2560_encryption_intr(struct rt2560_softc *);
   98 static void             rt2560_tx_intr(struct rt2560_softc *);
   99 static void             rt2560_prio_intr(struct rt2560_softc *);
  100 static void             rt2560_decryption_intr(struct rt2560_softc *);
  101 static void             rt2560_rx_intr(struct rt2560_softc *);
  102 static void             rt2560_beacon_expire(struct rt2560_softc *);
  103 static void             rt2560_wakeup_expire(struct rt2560_softc *);
  104 static uint8_t          rt2560_rxrate(struct rt2560_rx_desc *);
  105 static int              rt2560_ack_rate(struct ieee80211com *, int);
  106 static uint16_t         rt2560_txtime(int, int, uint32_t);
  107 static uint8_t          rt2560_plcp_signal(int);
  108 static void             rt2560_setup_tx_desc(struct rt2560_softc *,
  109                             struct rt2560_tx_desc *, uint32_t, int, int, int,
  110                             bus_addr_t);
  111 static int              rt2560_tx_bcn(struct rt2560_softc *, struct mbuf *,
  112                             struct ieee80211_node *);
  113 static int              rt2560_tx_mgt(struct rt2560_softc *, struct mbuf *,
  114                             struct ieee80211_node *);
  115 static struct           mbuf *rt2560_get_rts(struct rt2560_softc *,
  116                             struct ieee80211_frame *, uint16_t);
  117 static int              rt2560_tx_data(struct rt2560_softc *, struct mbuf *,
  118                             struct ieee80211_node *);
  119 static void             rt2560_start(struct ifnet *);
  120 static void             rt2560_watchdog(struct ifnet *);
  121 static int              rt2560_reset(struct ifnet *);
  122 static int              rt2560_ioctl(struct ifnet *, u_long, caddr_t);
  123 static void             rt2560_bbp_write(struct rt2560_softc *, uint8_t,
  124                             uint8_t);
  125 static uint8_t          rt2560_bbp_read(struct rt2560_softc *, uint8_t);
  126 static void             rt2560_rf_write(struct rt2560_softc *, uint8_t,
  127                             uint32_t);
  128 static void             rt2560_set_chan(struct rt2560_softc *,
  129                             struct ieee80211_channel *);
  130 #if 0
  131 static void             rt2560_disable_rf_tune(struct rt2560_softc *);
  132 #endif
  133 static void             rt2560_enable_tsf_sync(struct rt2560_softc *);
  134 static void             rt2560_update_plcp(struct rt2560_softc *);
  135 static void             rt2560_update_slot(struct ifnet *);
  136 static void             rt2560_set_basicrates(struct rt2560_softc *);
  137 static void             rt2560_update_led(struct rt2560_softc *, int, int);
  138 static void             rt2560_set_bssid(struct rt2560_softc *, uint8_t *);
  139 static void             rt2560_set_macaddr(struct rt2560_softc *, uint8_t *);
  140 static void             rt2560_get_macaddr(struct rt2560_softc *, uint8_t *);
  141 static void             rt2560_update_promisc(struct rt2560_softc *);
  142 static const char       *rt2560_get_rf(int);
  143 static void             rt2560_read_eeprom(struct rt2560_softc *);
  144 static int              rt2560_bbp_init(struct rt2560_softc *);
  145 static void             rt2560_set_txantenna(struct rt2560_softc *, int);
  146 static void             rt2560_set_rxantenna(struct rt2560_softc *, int);
  147 static void             rt2560_init(void *);
  148 static void             rt2560_stop(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 static const struct {
  174         uint8_t         chan;
  175         uint32_t        r1, r2, r4;
  176 } rt2560_rf5222[] = {
  177         RT2560_RF5222
  178 };
  179 
  180 int
  181 rt2560_attach(device_t dev, int id)
  182 {
  183         struct rt2560_softc *sc = device_get_softc(dev);
  184         struct ieee80211com *ic = &sc->sc_ic;
  185         struct ifnet *ifp;
  186         int error, i;
  187 
  188         sc->sc_dev = dev;
  189 
  190         mtx_init(&sc->sc_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK,
  191             MTX_DEF | MTX_RECURSE);
  192 
  193         callout_init(&sc->scan_ch, debug_mpsafenet ? CALLOUT_MPSAFE : 0);
  194         callout_init(&sc->rssadapt_ch, CALLOUT_MPSAFE);
  195 
  196         /* retrieve RT2560 rev. no */
  197         sc->asic_rev = RAL_READ(sc, RT2560_CSR0);
  198 
  199         /* retrieve MAC address */
  200         rt2560_get_macaddr(sc, ic->ic_myaddr);
  201 
  202         /* retrieve RF rev. no and various other things from EEPROM */
  203         rt2560_read_eeprom(sc);
  204 
  205         device_printf(dev, "MAC/BBP RT2560 (rev 0x%02x), RF %s\n",
  206             sc->asic_rev, rt2560_get_rf(sc->rf_rev));
  207 
  208         /*
  209          * Allocate Tx and Rx rings.
  210          */
  211         error = rt2560_alloc_tx_ring(sc, &sc->txq, RT2560_TX_RING_COUNT);
  212         if (error != 0) {
  213                 device_printf(sc->sc_dev, "could not allocate Tx ring\n");
  214                 goto fail1;
  215         }
  216 
  217         error = rt2560_alloc_tx_ring(sc, &sc->atimq, RT2560_ATIM_RING_COUNT);
  218         if (error != 0) {
  219                 device_printf(sc->sc_dev, "could not allocate ATIM ring\n");
  220                 goto fail2;
  221         }
  222 
  223         error = rt2560_alloc_tx_ring(sc, &sc->prioq, RT2560_PRIO_RING_COUNT);
  224         if (error != 0) {
  225                 device_printf(sc->sc_dev, "could not allocate Prio ring\n");
  226                 goto fail3;
  227         }
  228 
  229         error = rt2560_alloc_tx_ring(sc, &sc->bcnq, RT2560_BEACON_RING_COUNT);
  230         if (error != 0) {
  231                 device_printf(sc->sc_dev, "could not allocate Beacon ring\n");
  232                 goto fail4;
  233         }
  234 
  235         error = rt2560_alloc_rx_ring(sc, &sc->rxq, RT2560_RX_RING_COUNT);
  236         if (error != 0) {
  237                 device_printf(sc->sc_dev, "could not allocate Rx ring\n");
  238                 goto fail5;
  239         }
  240 
  241         ifp = sc->sc_ifp = if_alloc(IFT_ETHER);
  242         if (ifp == NULL) {
  243                 device_printf(sc->sc_dev, "can not if_alloc()\n");
  244                 goto fail6;
  245         }
  246 
  247         ifp->if_softc = sc;
  248         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
  249         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
  250         ifp->if_init = rt2560_init;
  251         ifp->if_ioctl = rt2560_ioctl;
  252         ifp->if_start = rt2560_start;
  253         ifp->if_watchdog = rt2560_watchdog;
  254         IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
  255         ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN;
  256         IFQ_SET_READY(&ifp->if_snd);
  257 
  258         ic->ic_ifp = ifp;
  259         ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
  260         ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
  261         ic->ic_state = IEEE80211_S_INIT;
  262 
  263         /* set device capabilities */
  264         ic->ic_caps =
  265             IEEE80211_C_IBSS |          /* IBSS mode supported */
  266             IEEE80211_C_MONITOR |       /* monitor mode supported */
  267             IEEE80211_C_HOSTAP |        /* HostAp mode supported */
  268             IEEE80211_C_TXPMGT |        /* tx power management */
  269             IEEE80211_C_SHPREAMBLE |    /* short preamble supported */
  270             IEEE80211_C_SHSLOT |        /* short slot time supported */
  271             IEEE80211_C_WPA;            /* 802.11i */
  272 
  273         if (sc->rf_rev == RT2560_RF_5222) {
  274                 /* set supported .11a channels */
  275                 for (i = 36; i <= 64; i += 4) {
  276                         ic->ic_channels[i].ic_freq =
  277                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
  278                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
  279                 }
  280                 for (i = 100; i <= 140; i += 4) {
  281                         ic->ic_channels[i].ic_freq =
  282                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
  283                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
  284                 }
  285                 for (i = 149; i <= 161; i += 4) {
  286                         ic->ic_channels[i].ic_freq =
  287                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
  288                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
  289                 }
  290         }
  291 
  292         /* set supported .11b and .11g channels (1 through 14) */
  293         for (i = 1; i <= 14; i++) {
  294                 ic->ic_channels[i].ic_freq =
  295                     ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
  296                 ic->ic_channels[i].ic_flags =
  297                     IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
  298                     IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
  299         }
  300 
  301         ieee80211_ifattach(ic);
  302         ic->ic_node_alloc = rt2560_node_alloc;
  303         ic->ic_updateslot = rt2560_update_slot;
  304         ic->ic_reset = rt2560_reset;
  305         /* enable s/w bmiss handling in sta mode */
  306         ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS;
  307 
  308         /* override state transition machine */
  309         sc->sc_newstate = ic->ic_newstate;
  310         ic->ic_newstate = rt2560_newstate;
  311         ieee80211_media_init(ic, rt2560_media_change, ieee80211_media_status);
  312 
  313         bpfattach2(ifp, DLT_IEEE802_11_RADIO,
  314             sizeof (struct ieee80211_frame) + 64, &sc->sc_drvbpf);
  315 
  316         sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
  317         sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
  318         sc->sc_rxtap.wr_ihdr.it_present = htole32(RT2560_RX_RADIOTAP_PRESENT);
  319 
  320         sc->sc_txtap_len = sizeof sc->sc_txtapu;
  321         sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
  322         sc->sc_txtap.wt_ihdr.it_present = htole32(RT2560_TX_RADIOTAP_PRESENT);
  323 
  324         /*
  325          * Add a few sysctl knobs.
  326          */
  327         sc->dwelltime = 200;
  328 
  329         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
  330             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
  331             "txantenna", CTLFLAG_RW, &sc->tx_ant, 0, "tx antenna (0=auto)");
  332 
  333         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
  334             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
  335             "rxantenna", CTLFLAG_RW, &sc->rx_ant, 0, "rx antenna (0=auto)");
  336 
  337         SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
  338             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "dwell",
  339             CTLFLAG_RW, &sc->dwelltime, 0,
  340             "channel dwell time (ms) for AP/station scanning");
  341 
  342         if (bootverbose)
  343                 ieee80211_announce(ic);
  344 
  345         return 0;
  346 
  347 fail6:  rt2560_free_rx_ring(sc, &sc->rxq);
  348 fail5:  rt2560_free_tx_ring(sc, &sc->bcnq);
  349 fail4:  rt2560_free_tx_ring(sc, &sc->prioq);
  350 fail3:  rt2560_free_tx_ring(sc, &sc->atimq);
  351 fail2:  rt2560_free_tx_ring(sc, &sc->txq);
  352 fail1:  mtx_destroy(&sc->sc_mtx);
  353 
  354         return ENXIO;
  355 }
  356 
  357 int
  358 rt2560_detach(void *xsc)
  359 {
  360         struct rt2560_softc *sc = xsc;
  361         struct ieee80211com *ic = &sc->sc_ic;
  362         struct ifnet *ifp = ic->ic_ifp;
  363 
  364         rt2560_stop(sc);
  365         callout_stop(&sc->scan_ch);
  366         callout_stop(&sc->rssadapt_ch);
  367 
  368         bpfdetach(ifp);
  369         ieee80211_ifdetach(ic);
  370 
  371         rt2560_free_tx_ring(sc, &sc->txq);
  372         rt2560_free_tx_ring(sc, &sc->atimq);
  373         rt2560_free_tx_ring(sc, &sc->prioq);
  374         rt2560_free_tx_ring(sc, &sc->bcnq);
  375         rt2560_free_rx_ring(sc, &sc->rxq);
  376 
  377         if_free(ifp);
  378 
  379         mtx_destroy(&sc->sc_mtx);
  380 
  381         return 0;
  382 }
  383 
  384 void
  385 rt2560_shutdown(void *xsc)
  386 {
  387         struct rt2560_softc *sc = xsc;
  388 
  389         rt2560_stop(sc);
  390 }
  391 
  392 void
  393 rt2560_suspend(void *xsc)
  394 {
  395         struct rt2560_softc *sc = xsc;
  396 
  397         rt2560_stop(sc);
  398 }
  399 
  400 void
  401 rt2560_resume(void *xsc)
  402 {
  403         struct rt2560_softc *sc = xsc;
  404         struct ifnet *ifp = sc->sc_ic.ic_ifp;
  405 
  406         if (ifp->if_flags & IFF_UP) {
  407                 ifp->if_init(ifp->if_softc);
  408                 if (ifp->if_drv_flags & IFF_DRV_RUNNING)
  409                         ifp->if_start(ifp);
  410         }
  411 }
  412 
  413 static void
  414 rt2560_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
  415 {
  416         if (error != 0)
  417                 return;
  418 
  419         KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
  420 
  421         *(bus_addr_t *)arg = segs[0].ds_addr;
  422 }
  423 
  424 static int
  425 rt2560_alloc_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring,
  426     int count)
  427 {
  428         int i, error;
  429 
  430         ring->count = count;
  431         ring->queued = 0;
  432         ring->cur = ring->next = 0;
  433         ring->cur_encrypt = ring->next_encrypt = 0;
  434 
  435         error = bus_dma_tag_create(NULL, 4, 0, BUS_SPACE_MAXADDR_32BIT,
  436             BUS_SPACE_MAXADDR, NULL, NULL, count * RT2560_TX_DESC_SIZE, 1,
  437             count * RT2560_TX_DESC_SIZE, 0, NULL, NULL, &ring->desc_dmat);
  438         if (error != 0) {
  439                 device_printf(sc->sc_dev, "could not create desc DMA tag\n");
  440                 goto fail;
  441         }
  442 
  443         error = bus_dmamem_alloc(ring->desc_dmat, (void **)&ring->desc,
  444             BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_map);
  445         if (error != 0) {
  446                 device_printf(sc->sc_dev, "could not allocate DMA memory\n");
  447                 goto fail;
  448         }
  449 
  450         error = bus_dmamap_load(ring->desc_dmat, ring->desc_map, ring->desc,
  451             count * RT2560_TX_DESC_SIZE, rt2560_dma_map_addr, &ring->physaddr,
  452             0);
  453         if (error != 0) {
  454                 device_printf(sc->sc_dev, "could not load desc DMA map\n");
  455                 goto fail;
  456         }
  457 
  458         ring->data = malloc(count * sizeof (struct rt2560_tx_data), M_DEVBUF,
  459             M_NOWAIT | M_ZERO);
  460         if (ring->data == NULL) {
  461                 device_printf(sc->sc_dev, "could not allocate soft data\n");
  462                 error = ENOMEM;
  463                 goto fail;
  464         }
  465 
  466         error = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT,
  467             BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, RT2560_MAX_SCATTER,
  468             MCLBYTES, 0, NULL, NULL, &ring->data_dmat);
  469         if (error != 0) {
  470                 device_printf(sc->sc_dev, "could not create data DMA tag\n");
  471                 goto fail;
  472         }
  473 
  474         for (i = 0; i < count; i++) {
  475                 error = bus_dmamap_create(ring->data_dmat, 0,
  476                     &ring->data[i].map);
  477                 if (error != 0) {
  478                         device_printf(sc->sc_dev, "could not create DMA map\n");
  479                         goto fail;
  480                 }
  481         }
  482 
  483         return 0;
  484 
  485 fail:   rt2560_free_tx_ring(sc, ring);
  486         return error;
  487 }
  488 
  489 static void
  490 rt2560_reset_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring)
  491 {
  492         struct rt2560_tx_desc *desc;
  493         struct rt2560_tx_data *data;
  494         int i;
  495 
  496         for (i = 0; i < ring->count; i++) {
  497                 desc = &ring->desc[i];
  498                 data = &ring->data[i];
  499 
  500                 if (data->m != NULL) {
  501                         bus_dmamap_sync(ring->data_dmat, data->map,
  502                             BUS_DMASYNC_POSTWRITE);
  503                         bus_dmamap_unload(ring->data_dmat, data->map);
  504                         m_freem(data->m);
  505                         data->m = NULL;
  506                 }
  507 
  508                 if (data->ni != NULL) {
  509                         ieee80211_free_node(data->ni);
  510                         data->ni = NULL;
  511                 }
  512 
  513                 desc->flags = 0;
  514         }
  515 
  516         bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_PREWRITE);
  517 
  518         ring->queued = 0;
  519         ring->cur = ring->next = 0;
  520         ring->cur_encrypt = ring->next_encrypt = 0;
  521 }
  522 
  523 static void
  524 rt2560_free_tx_ring(struct rt2560_softc *sc, struct rt2560_tx_ring *ring)
  525 {
  526         struct rt2560_tx_data *data;
  527         int i;
  528 
  529         if (ring->desc != NULL) {
  530                 bus_dmamap_sync(ring->desc_dmat, ring->desc_map,
  531                     BUS_DMASYNC_POSTWRITE);
  532                 bus_dmamap_unload(ring->desc_dmat, ring->desc_map);
  533                 bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map);
  534         }
  535 
  536         if (ring->desc_dmat != NULL)
  537                 bus_dma_tag_destroy(ring->desc_dmat);
  538 
  539         if (ring->data != NULL) {
  540                 for (i = 0; i < ring->count; i++) {
  541                         data = &ring->data[i];
  542 
  543                         if (data->m != NULL) {
  544                                 bus_dmamap_sync(ring->data_dmat, data->map,
  545                                     BUS_DMASYNC_POSTWRITE);
  546                                 bus_dmamap_unload(ring->data_dmat, data->map);
  547                                 m_freem(data->m);
  548                         }
  549 
  550                         if (data->ni != NULL)
  551                                 ieee80211_free_node(data->ni);
  552 
  553                         if (data->map != NULL)
  554                                 bus_dmamap_destroy(ring->data_dmat, data->map);
  555                 }
  556 
  557                 free(ring->data, M_DEVBUF);
  558         }
  559 
  560         if (ring->data_dmat != NULL)
  561                 bus_dma_tag_destroy(ring->data_dmat);
  562 }
  563 
  564 static int
  565 rt2560_alloc_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring,
  566     int count)
  567 {
  568         struct rt2560_rx_desc *desc;
  569         struct rt2560_rx_data *data;
  570         bus_addr_t physaddr;
  571         int i, error;
  572 
  573         ring->count = count;
  574         ring->cur = ring->next = 0;
  575         ring->cur_decrypt = 0;
  576 
  577         error = bus_dma_tag_create(NULL, 4, 0, BUS_SPACE_MAXADDR_32BIT,
  578             BUS_SPACE_MAXADDR, NULL, NULL, count * RT2560_RX_DESC_SIZE, 1,
  579             count * RT2560_RX_DESC_SIZE, 0, NULL, NULL, &ring->desc_dmat);
  580         if (error != 0) {
  581                 device_printf(sc->sc_dev, "could not create desc DMA tag\n");
  582                 goto fail;
  583         }
  584 
  585         error = bus_dmamem_alloc(ring->desc_dmat, (void **)&ring->desc,
  586             BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_map);
  587         if (error != 0) {
  588                 device_printf(sc->sc_dev, "could not allocate DMA memory\n");
  589                 goto fail;
  590         }
  591 
  592         error = bus_dmamap_load(ring->desc_dmat, ring->desc_map, ring->desc,
  593             count * RT2560_RX_DESC_SIZE, rt2560_dma_map_addr, &ring->physaddr,
  594             0);
  595         if (error != 0) {
  596                 device_printf(sc->sc_dev, "could not load desc DMA map\n");
  597                 goto fail;
  598         }
  599 
  600         ring->data = malloc(count * sizeof (struct rt2560_rx_data), M_DEVBUF,
  601             M_NOWAIT | M_ZERO);
  602         if (ring->data == NULL) {
  603                 device_printf(sc->sc_dev, "could not allocate soft data\n");
  604                 error = ENOMEM;
  605                 goto fail;
  606         }
  607 
  608         /*
  609          * Pre-allocate Rx buffers and populate Rx ring.
  610          */
  611         error = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT,
  612             BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1, MCLBYTES, 0, NULL,
  613             NULL, &ring->data_dmat);
  614         if (error != 0) {
  615                 device_printf(sc->sc_dev, "could not create data DMA tag\n");
  616                 goto fail;
  617         }
  618 
  619         for (i = 0; i < count; i++) {
  620                 desc = &sc->rxq.desc[i];
  621                 data = &sc->rxq.data[i];
  622 
  623                 error = bus_dmamap_create(ring->data_dmat, 0, &data->map);
  624                 if (error != 0) {
  625                         device_printf(sc->sc_dev, "could not create DMA map\n");
  626                         goto fail;
  627                 }
  628 
  629                 data->m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
  630                 if (data->m == NULL) {
  631                         device_printf(sc->sc_dev,
  632                             "could not allocate rx mbuf\n");
  633                         error = ENOMEM;
  634                         goto fail;
  635                 }
  636 
  637                 error = bus_dmamap_load(ring->data_dmat, data->map,
  638                     mtod(data->m, void *), MCLBYTES, rt2560_dma_map_addr,
  639                     &physaddr, 0);
  640                 if (error != 0) {
  641                         device_printf(sc->sc_dev,
  642                             "could not load rx buf DMA map");
  643                         goto fail;
  644                 }
  645 
  646                 desc->flags = htole32(RT2560_RX_BUSY);
  647                 desc->physaddr = htole32(physaddr);
  648         }
  649 
  650         bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_PREWRITE);
  651 
  652         return 0;
  653 
  654 fail:   rt2560_free_rx_ring(sc, ring);
  655         return error;
  656 }
  657 
  658 static void
  659 rt2560_reset_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring)
  660 {
  661         int i;
  662 
  663         for (i = 0; i < ring->count; i++) {
  664                 ring->desc[i].flags = htole32(RT2560_RX_BUSY);
  665                 ring->data[i].drop = 0;
  666         }
  667 
  668         bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_PREWRITE);
  669 
  670         ring->cur = ring->next = 0;
  671         ring->cur_decrypt = 0;
  672 }
  673 
  674 static void
  675 rt2560_free_rx_ring(struct rt2560_softc *sc, struct rt2560_rx_ring *ring)
  676 {
  677         struct rt2560_rx_data *data;
  678         int i;
  679 
  680         if (ring->desc != NULL) {
  681                 bus_dmamap_sync(ring->desc_dmat, ring->desc_map,
  682                     BUS_DMASYNC_POSTWRITE);
  683                 bus_dmamap_unload(ring->desc_dmat, ring->desc_map);
  684                 bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map);
  685         }
  686 
  687         if (ring->desc_dmat != NULL)
  688                 bus_dma_tag_destroy(ring->desc_dmat);
  689 
  690         if (ring->data != NULL) {
  691                 for (i = 0; i < ring->count; i++) {
  692                         data = &ring->data[i];
  693 
  694                         if (data->m != NULL) {
  695                                 bus_dmamap_sync(ring->data_dmat, data->map,
  696                                     BUS_DMASYNC_POSTREAD);
  697                                 bus_dmamap_unload(ring->data_dmat, data->map);
  698                                 m_freem(data->m);
  699                         }
  700 
  701                         if (data->map != NULL)
  702                                 bus_dmamap_destroy(ring->data_dmat, data->map);
  703                 }
  704 
  705                 free(ring->data, M_DEVBUF);
  706         }
  707 
  708         if (ring->data_dmat != NULL)
  709                 bus_dma_tag_destroy(ring->data_dmat);
  710 }
  711 
  712 static struct ieee80211_node *
  713 rt2560_node_alloc(struct ieee80211_node_table *nt)
  714 {
  715         struct rt2560_node *rn;
  716 
  717         rn = malloc(sizeof (struct rt2560_node), M_80211_NODE,
  718             M_NOWAIT | M_ZERO);
  719 
  720         return (rn != NULL) ? &rn->ni : NULL;
  721 }
  722 
  723 static int
  724 rt2560_media_change(struct ifnet *ifp)
  725 {
  726         struct rt2560_softc *sc = ifp->if_softc;
  727         int error;
  728 
  729         error = ieee80211_media_change(ifp);
  730         if (error != ENETRESET)
  731                 return error;
  732 
  733         if ((ifp->if_flags & IFF_UP) &&
  734             (ifp->if_drv_flags & IFF_DRV_RUNNING))
  735                 rt2560_init(sc);
  736 
  737         return 0;
  738 }
  739 
  740 /*
  741  * This function is called periodically (every 200ms) during scanning to
  742  * switch from one channel to another.
  743  */
  744 static void
  745 rt2560_next_scan(void *arg)
  746 {
  747         struct rt2560_softc *sc = arg;
  748         struct ieee80211com *ic = &sc->sc_ic;
  749 
  750         if (ic->ic_state == IEEE80211_S_SCAN)
  751                 ieee80211_next_scan(ic);
  752 }
  753 
  754 /*
  755  * This function is called for each node present in the node station table.
  756  */
  757 static void
  758 rt2560_iter_func(void *arg, struct ieee80211_node *ni)
  759 {
  760         struct rt2560_node *rn = (struct rt2560_node *)ni;
  761 
  762         ral_rssadapt_updatestats(&rn->rssadapt);
  763 }
  764 
  765 /*
  766  * This function is called periodically (every 100ms) in RUN state to update
  767  * the rate adaptation statistics.
  768  */
  769 static void
  770 rt2560_update_rssadapt(void *arg)
  771 {
  772         struct rt2560_softc *sc = arg;
  773         struct ieee80211com *ic = &sc->sc_ic;
  774 
  775         RAL_LOCK(sc);
  776 
  777         ieee80211_iterate_nodes(&ic->ic_sta, rt2560_iter_func, arg);
  778         callout_reset(&sc->rssadapt_ch, hz / 10, rt2560_update_rssadapt, sc);
  779 
  780         RAL_UNLOCK(sc);
  781 }
  782 
  783 static int
  784 rt2560_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
  785 {
  786         struct rt2560_softc *sc = ic->ic_ifp->if_softc;
  787         enum ieee80211_state ostate;
  788         struct ieee80211_node *ni;
  789         struct mbuf *m;
  790         int error = 0;
  791 
  792         ostate = ic->ic_state;
  793         callout_stop(&sc->scan_ch);
  794 
  795         switch (nstate) {
  796         case IEEE80211_S_INIT:
  797                 callout_stop(&sc->rssadapt_ch);
  798 
  799                 if (ostate == IEEE80211_S_RUN) {
  800                         /* abort TSF synchronization */
  801                         RAL_WRITE(sc, RT2560_CSR14, 0);
  802 
  803                         /* turn association led off */
  804                         rt2560_update_led(sc, 0, 0);
  805                 }
  806                 break;
  807 
  808         case IEEE80211_S_SCAN:
  809                 rt2560_set_chan(sc, ic->ic_curchan);
  810                 callout_reset(&sc->scan_ch, (sc->dwelltime * hz) / 1000,
  811                     rt2560_next_scan, sc);
  812                 break;
  813 
  814         case IEEE80211_S_AUTH:
  815                 rt2560_set_chan(sc, ic->ic_curchan);
  816                 break;
  817 
  818         case IEEE80211_S_ASSOC:
  819                 rt2560_set_chan(sc, ic->ic_curchan);
  820                 break;
  821 
  822         case IEEE80211_S_RUN:
  823                 rt2560_set_chan(sc, ic->ic_curchan);
  824 
  825                 ni = ic->ic_bss;
  826 
  827                 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
  828                         rt2560_update_plcp(sc);
  829                         rt2560_set_basicrates(sc);
  830                         rt2560_set_bssid(sc, ni->ni_bssid);
  831                 }
  832 
  833                 if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
  834                     ic->ic_opmode == IEEE80211_M_IBSS) {
  835                         m = ieee80211_beacon_alloc(ic, ni, &sc->sc_bo);
  836                         if (m == NULL) {
  837                                 device_printf(sc->sc_dev,
  838                                     "could not allocate beacon\n");
  839                                 error = ENOBUFS;
  840                                 break;
  841                         }
  842 
  843                         ieee80211_ref_node(ni);
  844                         error = rt2560_tx_bcn(sc, m, ni);
  845                         if (error != 0)
  846                                 break;
  847                 }
  848 
  849                 /* turn assocation led on */
  850                 rt2560_update_led(sc, 1, 0);
  851 
  852                 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
  853                         callout_reset(&sc->rssadapt_ch, hz / 10,
  854                             rt2560_update_rssadapt, sc);
  855 
  856                         rt2560_enable_tsf_sync(sc);
  857                 }
  858                 break;
  859         }
  860 
  861         return (error != 0) ? error : sc->sc_newstate(ic, nstate, arg);
  862 }
  863 
  864 /*
  865  * Read 16 bits at address 'addr' from the serial EEPROM (either 93C46 or
  866  * 93C66).
  867  */
  868 static uint16_t
  869 rt2560_eeprom_read(struct rt2560_softc *sc, uint8_t addr)
  870 {
  871         uint32_t tmp;
  872         uint16_t val;
  873         int n;
  874 
  875         /* clock C once before the first command */
  876         RT2560_EEPROM_CTL(sc, 0);
  877 
  878         RT2560_EEPROM_CTL(sc, RT2560_S);
  879         RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_C);
  880         RT2560_EEPROM_CTL(sc, RT2560_S);
  881 
  882         /* write start bit (1) */
  883         RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D);
  884         RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D | RT2560_C);
  885 
  886         /* write READ opcode (10) */
  887         RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D);
  888         RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_D | RT2560_C);
  889         RT2560_EEPROM_CTL(sc, RT2560_S);
  890         RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_C);
  891 
  892         /* write address (A5-A0 or A7-A0) */
  893         n = (RAL_READ(sc, RT2560_CSR21) & RT2560_93C46) ? 5 : 7;
  894         for (; n >= 0; n--) {
  895                 RT2560_EEPROM_CTL(sc, RT2560_S |
  896                     (((addr >> n) & 1) << RT2560_SHIFT_D));
  897                 RT2560_EEPROM_CTL(sc, RT2560_S |
  898                     (((addr >> n) & 1) << RT2560_SHIFT_D) | RT2560_C);
  899         }
  900 
  901         RT2560_EEPROM_CTL(sc, RT2560_S);
  902 
  903         /* read data Q15-Q0 */
  904         val = 0;
  905         for (n = 15; n >= 0; n--) {
  906                 RT2560_EEPROM_CTL(sc, RT2560_S | RT2560_C);
  907                 tmp = RAL_READ(sc, RT2560_CSR21);
  908                 val |= ((tmp & RT2560_Q) >> RT2560_SHIFT_Q) << n;
  909                 RT2560_EEPROM_CTL(sc, RT2560_S);
  910         }
  911 
  912         RT2560_EEPROM_CTL(sc, 0);
  913 
  914         /* clear Chip Select and clock C */
  915         RT2560_EEPROM_CTL(sc, RT2560_S);
  916         RT2560_EEPROM_CTL(sc, 0);
  917         RT2560_EEPROM_CTL(sc, RT2560_C);
  918 
  919         return val;
  920 }
  921 
  922 /*
  923  * Some frames were processed by the hardware cipher engine and are ready for
  924  * transmission.
  925  */
  926 static void
  927 rt2560_encryption_intr(struct rt2560_softc *sc)
  928 {
  929         struct rt2560_tx_desc *desc;
  930         int hw;
  931 
  932         /* retrieve last descriptor index processed by cipher engine */
  933         hw = RAL_READ(sc, RT2560_SECCSR1) - sc->txq.physaddr;
  934         hw /= RT2560_TX_DESC_SIZE;
  935 
  936         bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
  937             BUS_DMASYNC_POSTREAD);
  938 
  939         for (; sc->txq.next_encrypt != hw;) {
  940                 desc = &sc->txq.desc[sc->txq.next_encrypt];
  941 
  942                 if ((le32toh(desc->flags) & RT2560_TX_BUSY) ||
  943                     (le32toh(desc->flags) & RT2560_TX_CIPHER_BUSY))
  944                         break;
  945 
  946                 /* for TKIP, swap eiv field to fix a bug in ASIC */
  947                 if ((le32toh(desc->flags) & RT2560_TX_CIPHER_MASK) ==
  948                     RT2560_TX_CIPHER_TKIP)
  949                         desc->eiv = bswap32(desc->eiv);
  950 
  951                 /* mark the frame ready for transmission */
  952                 desc->flags |= htole32(RT2560_TX_BUSY | RT2560_TX_VALID);
  953 
  954                 DPRINTFN(15, ("encryption done idx=%u\n",
  955                     sc->txq.next_encrypt));
  956 
  957                 sc->txq.next_encrypt =
  958                     (sc->txq.next_encrypt + 1) % RT2560_TX_RING_COUNT;
  959         }
  960 
  961         bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
  962             BUS_DMASYNC_PREWRITE);
  963 
  964         /* kick Tx */
  965         RAL_WRITE(sc, RT2560_TXCSR0, RT2560_KICK_TX);
  966 }
  967 
  968 static void
  969 rt2560_tx_intr(struct rt2560_softc *sc)
  970 {
  971         struct ieee80211com *ic = &sc->sc_ic;
  972         struct ifnet *ifp = ic->ic_ifp;
  973         struct rt2560_tx_desc *desc;
  974         struct rt2560_tx_data *data;
  975         struct rt2560_node *rn;
  976 
  977         bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
  978             BUS_DMASYNC_POSTREAD);
  979 
  980         for (;;) {
  981                 desc = &sc->txq.desc[sc->txq.next];
  982                 data = &sc->txq.data[sc->txq.next];
  983 
  984                 if ((le32toh(desc->flags) & RT2560_TX_BUSY) ||
  985                     (le32toh(desc->flags) & RT2560_TX_CIPHER_BUSY) ||
  986                     !(le32toh(desc->flags) & RT2560_TX_VALID))
  987                         break;
  988 
  989                 rn = (struct rt2560_node *)data->ni;
  990 
  991                 switch (le32toh(desc->flags) & RT2560_TX_RESULT_MASK) {
  992                 case RT2560_TX_SUCCESS:
  993                         DPRINTFN(10, ("data frame sent successfully\n"));
  994                         if (data->id.id_node != NULL) {
  995                                 ral_rssadapt_raise_rate(ic, &rn->rssadapt,
  996                                     &data->id);
  997                         }
  998                         ifp->if_opackets++;
  999                         break;
 1000 
 1001                 case RT2560_TX_SUCCESS_RETRY:
 1002                         DPRINTFN(9, ("data frame sent after %u retries\n",
 1003                             (le32toh(desc->flags) >> 5) & 0x7));
 1004                         ifp->if_opackets++;
 1005                         break;
 1006 
 1007                 case RT2560_TX_FAIL_RETRY:
 1008                         DPRINTFN(9, ("sending data frame failed (too much "
 1009                             "retries)\n"));
 1010                         if (data->id.id_node != NULL) {
 1011                                 ral_rssadapt_lower_rate(ic, data->ni,
 1012                                     &rn->rssadapt, &data->id);
 1013                         }
 1014                         ifp->if_oerrors++;
 1015                         break;
 1016 
 1017                 case RT2560_TX_FAIL_INVALID:
 1018                 case RT2560_TX_FAIL_OTHER:
 1019                 default:
 1020                         device_printf(sc->sc_dev, "sending data frame failed "
 1021                             "0x%08x\n", le32toh(desc->flags));
 1022                         ifp->if_oerrors++;
 1023                 }
 1024 
 1025                 bus_dmamap_sync(sc->txq.data_dmat, data->map,
 1026                     BUS_DMASYNC_POSTWRITE);
 1027                 bus_dmamap_unload(sc->txq.data_dmat, data->map);
 1028                 m_freem(data->m);
 1029                 data->m = NULL;
 1030                 ieee80211_free_node(data->ni);
 1031                 data->ni = NULL;
 1032 
 1033                 /* descriptor is no longer valid */
 1034                 desc->flags &= ~htole32(RT2560_TX_VALID);
 1035 
 1036                 DPRINTFN(15, ("tx done idx=%u\n", sc->txq.next));
 1037 
 1038                 sc->txq.queued--;
 1039                 sc->txq.next = (sc->txq.next + 1) % RT2560_TX_RING_COUNT;
 1040         }
 1041 
 1042         bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
 1043             BUS_DMASYNC_PREWRITE);
 1044 
 1045         sc->sc_tx_timer = 0;
 1046         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 1047         rt2560_start(ifp);
 1048 }
 1049 
 1050 static void
 1051 rt2560_prio_intr(struct rt2560_softc *sc)
 1052 {
 1053         struct ieee80211com *ic = &sc->sc_ic;
 1054         struct ifnet *ifp = ic->ic_ifp;
 1055         struct rt2560_tx_desc *desc;
 1056         struct rt2560_tx_data *data;
 1057 
 1058         bus_dmamap_sync(sc->prioq.desc_dmat, sc->prioq.desc_map,
 1059             BUS_DMASYNC_POSTREAD);
 1060 
 1061         for (;;) {
 1062                 desc = &sc->prioq.desc[sc->prioq.next];
 1063                 data = &sc->prioq.data[sc->prioq.next];
 1064 
 1065                 if ((le32toh(desc->flags) & RT2560_TX_BUSY) ||
 1066                     !(le32toh(desc->flags) & RT2560_TX_VALID))
 1067                         break;
 1068 
 1069                 switch (le32toh(desc->flags) & RT2560_TX_RESULT_MASK) {
 1070                 case RT2560_TX_SUCCESS:
 1071                         DPRINTFN(10, ("mgt frame sent successfully\n"));
 1072                         break;
 1073 
 1074                 case RT2560_TX_SUCCESS_RETRY:
 1075                         DPRINTFN(9, ("mgt frame sent after %u retries\n",
 1076                             (le32toh(desc->flags) >> 5) & 0x7));
 1077                         break;
 1078 
 1079                 case RT2560_TX_FAIL_RETRY:
 1080                         DPRINTFN(9, ("sending mgt frame failed (too much "
 1081                             "retries)\n"));
 1082                         break;
 1083 
 1084                 case RT2560_TX_FAIL_INVALID:
 1085                 case RT2560_TX_FAIL_OTHER:
 1086                 default:
 1087                         device_printf(sc->sc_dev, "sending mgt frame failed "
 1088                             "0x%08x\n", le32toh(desc->flags));
 1089                 }
 1090 
 1091                 bus_dmamap_sync(sc->prioq.data_dmat, data->map,
 1092                     BUS_DMASYNC_POSTWRITE);
 1093                 bus_dmamap_unload(sc->prioq.data_dmat, data->map);
 1094                 m_freem(data->m);
 1095                 data->m = NULL;
 1096                 ieee80211_free_node(data->ni);
 1097                 data->ni = NULL;
 1098 
 1099                 /* descriptor is no longer valid */
 1100                 desc->flags &= ~htole32(RT2560_TX_VALID);
 1101 
 1102                 DPRINTFN(15, ("prio done idx=%u\n", sc->prioq.next));
 1103 
 1104                 sc->prioq.queued--;
 1105                 sc->prioq.next = (sc->prioq.next + 1) % RT2560_PRIO_RING_COUNT;
 1106         }
 1107 
 1108         bus_dmamap_sync(sc->prioq.desc_dmat, sc->prioq.desc_map,
 1109             BUS_DMASYNC_PREWRITE);
 1110 
 1111         sc->sc_tx_timer = 0;
 1112         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 1113         rt2560_start(ifp);
 1114 }
 1115 
 1116 /*
 1117  * Some frames were processed by the hardware cipher engine and are ready for
 1118  * transmission to the IEEE802.11 layer.
 1119  */
 1120 static void
 1121 rt2560_decryption_intr(struct rt2560_softc *sc)
 1122 {
 1123         struct ieee80211com *ic = &sc->sc_ic;
 1124         struct ifnet *ifp = ic->ic_ifp;
 1125         struct rt2560_rx_desc *desc;
 1126         struct rt2560_rx_data *data;
 1127         bus_addr_t physaddr;
 1128         struct ieee80211_frame *wh;
 1129         struct ieee80211_node *ni;
 1130         struct rt2560_node *rn;
 1131         struct mbuf *mnew, *m;
 1132         int hw, error;
 1133 
 1134         /* retrieve last decriptor index processed by cipher engine */
 1135         hw = RAL_READ(sc, RT2560_SECCSR0) - sc->rxq.physaddr;
 1136         hw /= RT2560_RX_DESC_SIZE;
 1137 
 1138         bus_dmamap_sync(sc->rxq.desc_dmat, sc->rxq.desc_map,
 1139             BUS_DMASYNC_POSTREAD);
 1140 
 1141         for (; sc->rxq.cur_decrypt != hw;) {
 1142                 desc = &sc->rxq.desc[sc->rxq.cur_decrypt];
 1143                 data = &sc->rxq.data[sc->rxq.cur_decrypt];
 1144 
 1145                 if ((le32toh(desc->flags) & RT2560_RX_BUSY) ||
 1146                     (le32toh(desc->flags) & RT2560_RX_CIPHER_BUSY))
 1147                         break;
 1148 
 1149                 if (data->drop) {
 1150                         ifp->if_ierrors++;
 1151                         goto skip;
 1152                 }
 1153 
 1154                 if ((le32toh(desc->flags) & RT2560_RX_CIPHER_MASK) != 0 &&
 1155                     (le32toh(desc->flags) & RT2560_RX_ICV_ERROR)) {
 1156                         ifp->if_ierrors++;
 1157                         goto skip;
 1158                 }
 1159 
 1160                 /*
 1161                  * Try to allocate a new mbuf for this ring element and load it
 1162                  * before processing the current mbuf. If the ring element
 1163                  * cannot be loaded, drop the received packet and reuse the old
 1164                  * mbuf. In the unlikely case that the old mbuf can't be
 1165                  * reloaded either, explicitly panic.
 1166                  */
 1167                 mnew = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);
 1168                 if (mnew == NULL) {
 1169                         ifp->if_ierrors++;
 1170                         goto skip;
 1171                 }
 1172 
 1173                 bus_dmamap_sync(sc->rxq.data_dmat, data->map,
 1174                     BUS_DMASYNC_POSTREAD);
 1175                 bus_dmamap_unload(sc->rxq.data_dmat, data->map);
 1176 
 1177                 error = bus_dmamap_load(sc->rxq.data_dmat, data->map,
 1178                     mtod(mnew, void *), MCLBYTES, rt2560_dma_map_addr,
 1179                     &physaddr, 0);
 1180                 if (error != 0) {
 1181                         m_freem(mnew);
 1182 
 1183                         /* try to reload the old mbuf */
 1184                         error = bus_dmamap_load(sc->rxq.data_dmat, data->map,
 1185                             mtod(data->m, void *), MCLBYTES,
 1186                             rt2560_dma_map_addr, &physaddr, 0);
 1187                         if (error != 0) {
 1188                                 /* very unlikely that it will fail... */
 1189                                 panic("%s: could not load old rx mbuf",
 1190                                     device_get_name(sc->sc_dev));
 1191                         }
 1192                         ifp->if_ierrors++;
 1193                         goto skip;
 1194                 }
 1195 
 1196                 /*
 1197                  * New mbuf successfully loaded, update Rx ring and continue
 1198                  * processing.
 1199                  */
 1200                 m = data->m;
 1201                 data->m = mnew;
 1202                 desc->physaddr = htole32(physaddr);
 1203 
 1204                 /* finalize mbuf */
 1205                 m->m_pkthdr.rcvif = ifp;
 1206                 m->m_pkthdr.len = m->m_len =
 1207                     (le32toh(desc->flags) >> 16) & 0xfff;
 1208 
 1209                 if (bpf_peers_present(sc->sc_drvbpf)) {
 1210                         struct rt2560_rx_radiotap_header *tap = &sc->sc_rxtap;
 1211                         uint32_t tsf_lo, tsf_hi;
 1212 
 1213                         /* get timestamp (low and high 32 bits) */
 1214                         tsf_hi = RAL_READ(sc, RT2560_CSR17);
 1215                         tsf_lo = RAL_READ(sc, RT2560_CSR16);
 1216 
 1217                         tap->wr_tsf =
 1218                             htole64(((uint64_t)tsf_hi << 32) | tsf_lo);
 1219                         tap->wr_flags = 0;
 1220                         tap->wr_rate = rt2560_rxrate(desc);
 1221                         tap->wr_chan_freq = htole16(ic->ic_curchan->ic_freq);
 1222                         tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags);
 1223                         tap->wr_antenna = sc->rx_ant;
 1224                         tap->wr_antsignal = desc->rssi;
 1225 
 1226                         bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_rxtap_len, m);
 1227                 }
 1228 
 1229                 wh = mtod(m, struct ieee80211_frame *);
 1230                 ni = ieee80211_find_rxnode(ic,
 1231                     (struct ieee80211_frame_min *)wh);
 1232 
 1233                 /* send the frame to the 802.11 layer */
 1234                 ieee80211_input(ic, m, ni, desc->rssi, 0);
 1235 
 1236                 /* give rssi to the rate adatation algorithm */
 1237                 rn = (struct rt2560_node *)ni;
 1238                 ral_rssadapt_input(ic, ni, &rn->rssadapt, desc->rssi);
 1239 
 1240                 /* node is no longer needed */
 1241                 ieee80211_free_node(ni);
 1242 
 1243 skip:           desc->flags = htole32(RT2560_RX_BUSY);
 1244 
 1245                 DPRINTFN(15, ("decryption done idx=%u\n", sc->rxq.cur_decrypt));
 1246 
 1247                 sc->rxq.cur_decrypt =
 1248                     (sc->rxq.cur_decrypt + 1) % RT2560_RX_RING_COUNT;
 1249         }
 1250 
 1251         bus_dmamap_sync(sc->rxq.desc_dmat, sc->rxq.desc_map,
 1252             BUS_DMASYNC_PREWRITE);
 1253 }
 1254 
 1255 /*
 1256  * Some frames were received. Pass them to the hardware cipher engine before
 1257  * sending them to the 802.11 layer.
 1258  */
 1259 static void
 1260 rt2560_rx_intr(struct rt2560_softc *sc)
 1261 {
 1262         struct rt2560_rx_desc *desc;
 1263         struct rt2560_rx_data *data;
 1264 
 1265         bus_dmamap_sync(sc->rxq.desc_dmat, sc->rxq.desc_map,
 1266             BUS_DMASYNC_POSTREAD);
 1267 
 1268         for (;;) {
 1269                 desc = &sc->rxq.desc[sc->rxq.cur];
 1270                 data = &sc->rxq.data[sc->rxq.cur];
 1271 
 1272                 if ((le32toh(desc->flags) & RT2560_RX_BUSY) ||
 1273                     (le32toh(desc->flags) & RT2560_RX_CIPHER_BUSY))
 1274                         break;
 1275 
 1276                 data->drop = 0;
 1277 
 1278                 if ((le32toh(desc->flags) & RT2560_RX_PHY_ERROR) ||
 1279                     (le32toh(desc->flags) & RT2560_RX_CRC_ERROR)) {
 1280                         /*
 1281                          * This should not happen since we did not request
 1282                          * to receive those frames when we filled RXCSR0.
 1283                          */
 1284                         DPRINTFN(5, ("PHY or CRC error flags 0x%08x\n",
 1285                             le32toh(desc->flags)));
 1286                         data->drop = 1;
 1287                 }
 1288 
 1289                 if (((le32toh(desc->flags) >> 16) & 0xfff) > MCLBYTES) {
 1290                         DPRINTFN(5, ("bad length\n"));
 1291                         data->drop = 1;
 1292                 }
 1293 
 1294                 /* mark the frame for decryption */
 1295                 desc->flags |= htole32(RT2560_RX_CIPHER_BUSY);
 1296 
 1297                 DPRINTFN(15, ("rx done idx=%u\n", sc->rxq.cur));
 1298 
 1299                 sc->rxq.cur = (sc->rxq.cur + 1) % RT2560_RX_RING_COUNT;
 1300         }
 1301 
 1302         bus_dmamap_sync(sc->rxq.desc_dmat, sc->rxq.desc_map,
 1303             BUS_DMASYNC_PREWRITE);
 1304 
 1305         /* kick decrypt */
 1306         RAL_WRITE(sc, RT2560_SECCSR0, RT2560_KICK_DECRYPT);
 1307 }
 1308 
 1309 /*
 1310  * This function is called periodically in IBSS mode when a new beacon must be
 1311  * sent out.
 1312  */
 1313 static void
 1314 rt2560_beacon_expire(struct rt2560_softc *sc)
 1315 {
 1316         struct ieee80211com *ic = &sc->sc_ic;
 1317         struct rt2560_tx_data *data;
 1318 
 1319         if (ic->ic_opmode != IEEE80211_M_IBSS &&
 1320             ic->ic_opmode != IEEE80211_M_HOSTAP)
 1321                 return;
 1322 
 1323         data = &sc->bcnq.data[sc->bcnq.next];
 1324 
 1325         bus_dmamap_sync(sc->bcnq.data_dmat, data->map, BUS_DMASYNC_POSTWRITE);
 1326         bus_dmamap_unload(sc->bcnq.data_dmat, data->map);
 1327 
 1328         ieee80211_beacon_update(ic, data->ni, &sc->sc_bo, data->m, 1);
 1329 
 1330         if (bpf_peers_present(ic->ic_rawbpf))
 1331                 bpf_mtap(ic->ic_rawbpf, data->m);
 1332 
 1333         rt2560_tx_bcn(sc, data->m, data->ni);
 1334 
 1335         DPRINTFN(15, ("beacon expired\n"));
 1336 
 1337         sc->bcnq.next = (sc->bcnq.next + 1) % RT2560_BEACON_RING_COUNT;
 1338 }
 1339 
 1340 /* ARGSUSED */
 1341 static void
 1342 rt2560_wakeup_expire(struct rt2560_softc *sc)
 1343 {
 1344         DPRINTFN(2, ("wakeup expired\n"));
 1345 }
 1346 
 1347 void
 1348 rt2560_intr(void *arg)
 1349 {
 1350         struct rt2560_softc *sc = arg;
 1351         struct ifnet *ifp = sc->sc_ifp;
 1352         uint32_t r;
 1353 
 1354         RAL_LOCK(sc);
 1355 
 1356         /* disable interrupts */
 1357         RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
 1358 
 1359         /* don't re-enable interrupts if we're shutting down */
 1360         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 1361                 RAL_UNLOCK(sc);
 1362                 return;
 1363         }
 1364 
 1365         r = RAL_READ(sc, RT2560_CSR7);
 1366         RAL_WRITE(sc, RT2560_CSR7, r);
 1367 
 1368         if (r & RT2560_BEACON_EXPIRE)
 1369                 rt2560_beacon_expire(sc);
 1370 
 1371         if (r & RT2560_WAKEUP_EXPIRE)
 1372                 rt2560_wakeup_expire(sc);
 1373 
 1374         if (r & RT2560_ENCRYPTION_DONE)
 1375                 rt2560_encryption_intr(sc);
 1376 
 1377         if (r & RT2560_TX_DONE)
 1378                 rt2560_tx_intr(sc);
 1379 
 1380         if (r & RT2560_PRIO_DONE)
 1381                 rt2560_prio_intr(sc);
 1382 
 1383         if (r & RT2560_DECRYPTION_DONE)
 1384                 rt2560_decryption_intr(sc);
 1385 
 1386         if (r & RT2560_RX_DONE)
 1387                 rt2560_rx_intr(sc);
 1388 
 1389         /* re-enable interrupts */
 1390         RAL_WRITE(sc, RT2560_CSR8, RT2560_INTR_MASK);
 1391 
 1392         RAL_UNLOCK(sc);
 1393 }
 1394 
 1395 /* quickly determine if a given rate is CCK or OFDM */
 1396 #define RAL_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
 1397 
 1398 #define RAL_ACK_SIZE    14      /* 10 + 4(FCS) */
 1399 #define RAL_CTS_SIZE    14      /* 10 + 4(FCS) */
 1400 
 1401 #define RAL_SIFS                10      /* us */
 1402 
 1403 #define RT2560_TXRX_TURNAROUND  10      /* us */
 1404 
 1405 /*
 1406  * This function is only used by the Rx radiotap code.
 1407  */
 1408 static uint8_t
 1409 rt2560_rxrate(struct rt2560_rx_desc *desc)
 1410 {
 1411         if (le32toh(desc->flags) & RT2560_RX_OFDM) {
 1412                 /* reverse function of rt2560_plcp_signal */
 1413                 switch (desc->rate) {
 1414                 case 0xb:       return 12;
 1415                 case 0xf:       return 18;
 1416                 case 0xa:       return 24;
 1417                 case 0xe:       return 36;
 1418                 case 0x9:       return 48;
 1419                 case 0xd:       return 72;
 1420                 case 0x8:       return 96;
 1421                 case 0xc:       return 108;
 1422                 }
 1423         } else {
 1424                 if (desc->rate == 10)
 1425                         return 2;
 1426                 if (desc->rate == 20)
 1427                         return 4;
 1428                 if (desc->rate == 55)
 1429                         return 11;
 1430                 if (desc->rate == 110)
 1431                         return 22;
 1432         }
 1433         return 2;       /* should not get there */
 1434 }
 1435 
 1436 /*
 1437  * Return the expected ack rate for a frame transmitted at rate `rate'.
 1438  * XXX: this should depend on the destination node basic rate set.
 1439  */
 1440 static int
 1441 rt2560_ack_rate(struct ieee80211com *ic, int rate)
 1442 {
 1443         switch (rate) {
 1444         /* CCK rates */
 1445         case 2:
 1446                 return 2;
 1447         case 4:
 1448         case 11:
 1449         case 22:
 1450                 return (ic->ic_curmode == IEEE80211_MODE_11B) ? 4 : rate;
 1451 
 1452         /* OFDM rates */
 1453         case 12:
 1454         case 18:
 1455                 return 12;
 1456         case 24:
 1457         case 36:
 1458                 return 24;
 1459         case 48:
 1460         case 72:
 1461         case 96:
 1462         case 108:
 1463                 return 48;
 1464         }
 1465 
 1466         /* default to 1Mbps */
 1467         return 2;
 1468 }
 1469 
 1470 /*
 1471  * Compute the duration (in us) needed to transmit `len' bytes at rate `rate'.
 1472  * The function automatically determines the operating mode depending on the
 1473  * given rate. `flags' indicates whether short preamble is in use or not.
 1474  */
 1475 static uint16_t
 1476 rt2560_txtime(int len, int rate, uint32_t flags)
 1477 {
 1478         uint16_t txtime;
 1479 
 1480         if (RAL_RATE_IS_OFDM(rate)) {
 1481                 /* IEEE Std 802.11a-1999, pp. 37 */
 1482                 txtime = (8 + 4 * len + 3 + rate - 1) / rate;
 1483                 txtime = 16 + 4 + 4 * txtime + 6;
 1484         } else {
 1485                 /* IEEE Std 802.11b-1999, pp. 28 */
 1486                 txtime = (16 * len + rate - 1) / rate;
 1487                 if (rate != 2 && (flags & IEEE80211_F_SHPREAMBLE))
 1488                         txtime +=  72 + 24;
 1489                 else
 1490                         txtime += 144 + 48;
 1491         }
 1492 
 1493         return txtime;
 1494 }
 1495 
 1496 static uint8_t
 1497 rt2560_plcp_signal(int rate)
 1498 {
 1499         switch (rate) {
 1500         /* CCK rates (returned values are device-dependent) */
 1501         case 2:         return 0x0;
 1502         case 4:         return 0x1;
 1503         case 11:        return 0x2;
 1504         case 22:        return 0x3;
 1505 
 1506         /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
 1507         case 12:        return 0xb;
 1508         case 18:        return 0xf;
 1509         case 24:        return 0xa;
 1510         case 36:        return 0xe;
 1511         case 48:        return 0x9;
 1512         case 72:        return 0xd;
 1513         case 96:        return 0x8;
 1514         case 108:       return 0xc;
 1515 
 1516         /* unsupported rates (should not get there) */
 1517         default:        return 0xff;
 1518         }
 1519 }
 1520 
 1521 static void
 1522 rt2560_setup_tx_desc(struct rt2560_softc *sc, struct rt2560_tx_desc *desc,
 1523     uint32_t flags, int len, int rate, int encrypt, bus_addr_t physaddr)
 1524 {
 1525         struct ieee80211com *ic = &sc->sc_ic;
 1526         uint16_t plcp_length;
 1527         int remainder;
 1528 
 1529         desc->flags = htole32(flags);
 1530         desc->flags |= htole32(len << 16);
 1531         desc->flags |= encrypt ? htole32(RT2560_TX_CIPHER_BUSY) :
 1532             htole32(RT2560_TX_BUSY | RT2560_TX_VALID);
 1533 
 1534         desc->physaddr = htole32(physaddr);
 1535         desc->wme = htole16(
 1536             RT2560_AIFSN(2) |
 1537             RT2560_LOGCWMIN(3) |
 1538             RT2560_LOGCWMAX(8));
 1539 
 1540         /* setup PLCP fields */
 1541         desc->plcp_signal  = rt2560_plcp_signal(rate);
 1542         desc->plcp_service = 4;
 1543 
 1544         len += IEEE80211_CRC_LEN;
 1545         if (RAL_RATE_IS_OFDM(rate)) {
 1546                 desc->flags |= htole32(RT2560_TX_OFDM);
 1547 
 1548                 plcp_length = len & 0xfff;
 1549                 desc->plcp_length_hi = plcp_length >> 6;
 1550                 desc->plcp_length_lo = plcp_length & 0x3f;
 1551         } else {
 1552                 plcp_length = (16 * len + rate - 1) / rate;
 1553                 if (rate == 22) {
 1554                         remainder = (16 * len) % 22;
 1555                         if (remainder != 0 && remainder < 7)
 1556                                 desc->plcp_service |= RT2560_PLCP_LENGEXT;
 1557                 }
 1558                 desc->plcp_length_hi = plcp_length >> 8;
 1559                 desc->plcp_length_lo = plcp_length & 0xff;
 1560 
 1561                 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
 1562                         desc->plcp_signal |= 0x08;
 1563         }
 1564 }
 1565 
 1566 static int
 1567 rt2560_tx_bcn(struct rt2560_softc *sc, struct mbuf *m0,
 1568     struct ieee80211_node *ni)
 1569 {
 1570         struct ieee80211com *ic = &sc->sc_ic;
 1571         struct rt2560_tx_desc *desc;
 1572         struct rt2560_tx_data *data;
 1573         bus_dma_segment_t segs[RT2560_MAX_SCATTER];
 1574         int nsegs, rate, error;
 1575 
 1576         desc = &sc->bcnq.desc[sc->bcnq.cur];
 1577         data = &sc->bcnq.data[sc->bcnq.cur];
 1578 
 1579         rate = IEEE80211_IS_CHAN_5GHZ(ni->ni_chan) ? 12 : 2;
 1580 
 1581         error = bus_dmamap_load_mbuf_sg(sc->bcnq.data_dmat, data->map, m0,
 1582             segs, &nsegs, BUS_DMA_NOWAIT);
 1583         if (error != 0) {
 1584                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
 1585                     error);
 1586                 m_freem(m0);
 1587                 return error;
 1588         }
 1589 
 1590         if (bpf_peers_present(sc->sc_drvbpf)) {
 1591                 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
 1592 
 1593                 tap->wt_flags = 0;
 1594                 tap->wt_rate = rate;
 1595                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
 1596                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
 1597                 tap->wt_antenna = sc->tx_ant;
 1598 
 1599                 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0);
 1600         }
 1601 
 1602         data->m = m0;
 1603         data->ni = ni;
 1604 
 1605         rt2560_setup_tx_desc(sc, desc, RT2560_TX_IFS_NEWBACKOFF |
 1606             RT2560_TX_TIMESTAMP, m0->m_pkthdr.len, rate, 0, segs->ds_addr);
 1607 
 1608         DPRINTFN(10, ("sending beacon frame len=%u idx=%u rate=%u\n",
 1609             m0->m_pkthdr.len, sc->bcnq.cur, rate));
 1610 
 1611         bus_dmamap_sync(sc->bcnq.data_dmat, data->map, BUS_DMASYNC_PREWRITE);
 1612         bus_dmamap_sync(sc->bcnq.desc_dmat, sc->bcnq.desc_map,
 1613             BUS_DMASYNC_PREWRITE);
 1614 
 1615         sc->bcnq.cur = (sc->bcnq.cur + 1) % RT2560_BEACON_RING_COUNT;
 1616 
 1617         return 0;
 1618 }
 1619 
 1620 static int
 1621 rt2560_tx_mgt(struct rt2560_softc *sc, struct mbuf *m0,
 1622     struct ieee80211_node *ni)
 1623 {
 1624         struct ieee80211com *ic = &sc->sc_ic;
 1625         struct rt2560_tx_desc *desc;
 1626         struct rt2560_tx_data *data;
 1627         struct ieee80211_frame *wh;
 1628         bus_dma_segment_t segs[RT2560_MAX_SCATTER];
 1629         uint16_t dur;
 1630         uint32_t flags = 0;
 1631         int nsegs, rate, error;
 1632 
 1633         desc = &sc->prioq.desc[sc->prioq.cur];
 1634         data = &sc->prioq.data[sc->prioq.cur];
 1635 
 1636         rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
 1637 
 1638         error = bus_dmamap_load_mbuf_sg(sc->prioq.data_dmat, data->map, m0,
 1639             segs, &nsegs, 0);
 1640         if (error != 0) {
 1641                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
 1642                     error);
 1643                 m_freem(m0);
 1644                 return error;
 1645         }
 1646 
 1647         if (bpf_peers_present(sc->sc_drvbpf)) {
 1648                 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
 1649 
 1650                 tap->wt_flags = 0;
 1651                 tap->wt_rate = rate;
 1652                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
 1653                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
 1654                 tap->wt_antenna = sc->tx_ant;
 1655 
 1656                 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0);
 1657         }
 1658 
 1659         data->m = m0;
 1660         data->ni = ni;
 1661 
 1662         wh = mtod(m0, struct ieee80211_frame *);
 1663 
 1664         if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
 1665                 flags |= RT2560_TX_ACK;
 1666 
 1667                 dur = rt2560_txtime(RAL_ACK_SIZE, rate, ic->ic_flags) +
 1668                       RAL_SIFS;
 1669                 *(uint16_t *)wh->i_dur = htole16(dur);
 1670 
 1671                 /* tell hardware to add timestamp for probe responses */
 1672                 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
 1673                     IEEE80211_FC0_TYPE_MGT &&
 1674                     (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
 1675                     IEEE80211_FC0_SUBTYPE_PROBE_RESP)
 1676                         flags |= RT2560_TX_TIMESTAMP;
 1677         }
 1678 
 1679         rt2560_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len, rate, 0,
 1680             segs->ds_addr);
 1681 
 1682         bus_dmamap_sync(sc->prioq.data_dmat, data->map, BUS_DMASYNC_PREWRITE);
 1683         bus_dmamap_sync(sc->prioq.desc_dmat, sc->prioq.desc_map,
 1684             BUS_DMASYNC_PREWRITE);
 1685 
 1686         DPRINTFN(10, ("sending mgt frame len=%u idx=%u rate=%u\n",
 1687             m0->m_pkthdr.len, sc->prioq.cur, rate));
 1688 
 1689         /* kick prio */
 1690         sc->prioq.queued++;
 1691         sc->prioq.cur = (sc->prioq.cur + 1) % RT2560_PRIO_RING_COUNT;
 1692         RAL_WRITE(sc, RT2560_TXCSR0, RT2560_KICK_PRIO);
 1693 
 1694         return 0;
 1695 }
 1696 
 1697 /*
 1698  * Build a RTS control frame.
 1699  */
 1700 static struct mbuf *
 1701 rt2560_get_rts(struct rt2560_softc *sc, struct ieee80211_frame *wh,
 1702     uint16_t dur)
 1703 {
 1704         struct ieee80211_frame_rts *rts;
 1705         struct mbuf *m;
 1706 
 1707         MGETHDR(m, M_DONTWAIT, MT_DATA);
 1708         if (m == NULL) {
 1709                 sc->sc_ic.ic_stats.is_tx_nobuf++;
 1710                 device_printf(sc->sc_dev, "could not allocate RTS frame\n");
 1711                 return NULL;
 1712         }
 1713 
 1714         rts = mtod(m, struct ieee80211_frame_rts *);
 1715 
 1716         rts->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_CTL |
 1717             IEEE80211_FC0_SUBTYPE_RTS;
 1718         rts->i_fc[1] = IEEE80211_FC1_DIR_NODS;
 1719         *(uint16_t *)rts->i_dur = htole16(dur);
 1720         IEEE80211_ADDR_COPY(rts->i_ra, wh->i_addr1);
 1721         IEEE80211_ADDR_COPY(rts->i_ta, wh->i_addr2);
 1722 
 1723         m->m_pkthdr.len = m->m_len = sizeof (struct ieee80211_frame_rts);
 1724 
 1725         return m;
 1726 }
 1727 
 1728 static int
 1729 rt2560_tx_data(struct rt2560_softc *sc, struct mbuf *m0,
 1730     struct ieee80211_node *ni)
 1731 {
 1732         struct ieee80211com *ic = &sc->sc_ic;
 1733         struct rt2560_tx_desc *desc;
 1734         struct rt2560_tx_data *data;
 1735         struct rt2560_node *rn;
 1736         struct ieee80211_rateset *rs;
 1737         struct ieee80211_frame *wh;
 1738         struct ieee80211_key *k;
 1739         struct mbuf *mnew;
 1740         bus_dma_segment_t segs[RT2560_MAX_SCATTER];
 1741         uint16_t dur;
 1742         uint32_t flags = 0;
 1743         int nsegs, rate, error;
 1744 
 1745         wh = mtod(m0, struct ieee80211_frame *);
 1746 
 1747         if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) {
 1748                 rs = &ic->ic_sup_rates[ic->ic_curmode];
 1749                 rate = rs->rs_rates[ic->ic_fixed_rate];
 1750         } else {
 1751                 rs = &ni->ni_rates;
 1752                 rn = (struct rt2560_node *)ni;
 1753                 ni->ni_txrate = ral_rssadapt_choose(&rn->rssadapt, rs, wh,
 1754                     m0->m_pkthdr.len, NULL, 0);
 1755                 rate = rs->rs_rates[ni->ni_txrate];
 1756         }
 1757         rate &= IEEE80211_RATE_VAL;
 1758 
 1759         if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
 1760                 k = ieee80211_crypto_encap(ic, ni, m0);
 1761                 if (k == NULL) {
 1762                         m_freem(m0);
 1763                         return ENOBUFS;
 1764                 }
 1765 
 1766                 /* packet header may have moved, reset our local pointer */
 1767                 wh = mtod(m0, struct ieee80211_frame *);
 1768         }
 1769 
 1770         /*
 1771          * IEEE Std 802.11-1999, pp 82: "A STA shall use an RTS/CTS exchange
 1772          * for directed frames only when the length of the MPDU is greater
 1773          * than the length threshold indicated by [...]" ic_rtsthreshold.
 1774          */
 1775         if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
 1776             m0->m_pkthdr.len > ic->ic_rtsthreshold) {
 1777                 struct mbuf *m;
 1778                 uint16_t dur;
 1779                 int rtsrate, ackrate;
 1780 
 1781                 rtsrate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
 1782                 ackrate = rt2560_ack_rate(ic, rate);
 1783 
 1784                 dur = rt2560_txtime(m0->m_pkthdr.len + 4, rate, ic->ic_flags) +
 1785                       rt2560_txtime(RAL_CTS_SIZE, rtsrate, ic->ic_flags) +
 1786                       rt2560_txtime(RAL_ACK_SIZE, ackrate, ic->ic_flags) +
 1787                       3 * RAL_SIFS;
 1788 
 1789                 m = rt2560_get_rts(sc, wh, dur);
 1790 
 1791                 desc = &sc->txq.desc[sc->txq.cur_encrypt];
 1792                 data = &sc->txq.data[sc->txq.cur_encrypt];
 1793 
 1794                 error = bus_dmamap_load_mbuf_sg(sc->txq.data_dmat, data->map,
 1795                     m, segs, &nsegs, 0);
 1796                 if (error != 0) {
 1797                         device_printf(sc->sc_dev,
 1798                             "could not map mbuf (error %d)\n", error);
 1799                         m_freem(m);
 1800                         m_freem(m0);
 1801                         return error;
 1802                 }
 1803 
 1804                 /* avoid multiple free() of the same node for each fragment */
 1805                 ieee80211_ref_node(ni);
 1806 
 1807                 data->m = m;
 1808                 data->ni = ni;
 1809 
 1810                 /* RTS frames are not taken into account for rssadapt */
 1811                 data->id.id_node = NULL;
 1812 
 1813                 rt2560_setup_tx_desc(sc, desc, RT2560_TX_ACK |
 1814                     RT2560_TX_MORE_FRAG, m->m_pkthdr.len, rtsrate, 1,
 1815                     segs->ds_addr);
 1816 
 1817                 bus_dmamap_sync(sc->txq.data_dmat, data->map,
 1818                     BUS_DMASYNC_PREWRITE);
 1819 
 1820                 sc->txq.queued++;
 1821                 sc->txq.cur_encrypt =
 1822                     (sc->txq.cur_encrypt + 1) % RT2560_TX_RING_COUNT;
 1823 
 1824                 /*
 1825                  * IEEE Std 802.11-1999: when an RTS/CTS exchange is used, the
 1826                  * asynchronous data frame shall be transmitted after the CTS
 1827                  * frame and a SIFS period.
 1828                  */
 1829                 flags |= RT2560_TX_LONG_RETRY | RT2560_TX_IFS_SIFS;
 1830         }
 1831 
 1832         data = &sc->txq.data[sc->txq.cur_encrypt];
 1833         desc = &sc->txq.desc[sc->txq.cur_encrypt];
 1834 
 1835         error = bus_dmamap_load_mbuf_sg(sc->txq.data_dmat, data->map, m0,
 1836             segs, &nsegs, 0);
 1837         if (error != 0 && error != EFBIG) {
 1838                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
 1839                     error);
 1840                 m_freem(m0);
 1841                 return error;
 1842         }
 1843         if (error != 0) {
 1844                 mnew = m_defrag(m0, M_DONTWAIT);
 1845                 if (mnew == NULL) {
 1846                         device_printf(sc->sc_dev,
 1847                             "could not defragment mbuf\n");
 1848                         m_freem(m0);
 1849                         return ENOBUFS;
 1850                 }
 1851                 m0 = mnew;
 1852 
 1853                 error = bus_dmamap_load_mbuf_sg(sc->txq.data_dmat, data->map,
 1854                     m0, segs, &nsegs, 0);
 1855                 if (error != 0) {
 1856                         device_printf(sc->sc_dev,
 1857                             "could not map mbuf (error %d)\n", error);
 1858                         m_freem(m0);
 1859                         return error;
 1860                 }
 1861 
 1862                 /* packet header may have moved, reset our local pointer */
 1863                 wh = mtod(m0, struct ieee80211_frame *);
 1864         }
 1865 
 1866         if (bpf_peers_present(sc->sc_drvbpf)) {
 1867                 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
 1868 
 1869                 tap->wt_flags = 0;
 1870                 tap->wt_rate = rate;
 1871                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
 1872                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
 1873                 tap->wt_antenna = sc->tx_ant;
 1874 
 1875                 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0);
 1876         }
 1877 
 1878         data->m = m0;
 1879         data->ni = ni;
 1880 
 1881         /* remember link conditions for rate adaptation algorithm */
 1882         if (ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) {
 1883                 data->id.id_len = m0->m_pkthdr.len;
 1884                 data->id.id_rateidx = ni->ni_txrate;
 1885                 data->id.id_node = ni;
 1886                 data->id.id_rssi = ni->ni_rssi;
 1887         } else
 1888                 data->id.id_node = NULL;
 1889 
 1890         if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
 1891                 flags |= RT2560_TX_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             segs->ds_addr);
 1900 
 1901         bus_dmamap_sync(sc->txq.data_dmat, data->map, BUS_DMASYNC_PREWRITE);
 1902         bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
 1903             BUS_DMASYNC_PREWRITE);
 1904 
 1905         DPRINTFN(10, ("sending data frame len=%u idx=%u rate=%u\n",
 1906             m0->m_pkthdr.len, sc->txq.cur_encrypt, rate));
 1907 
 1908         /* kick encrypt */
 1909         sc->txq.queued++;
 1910         sc->txq.cur_encrypt = (sc->txq.cur_encrypt + 1) % RT2560_TX_RING_COUNT;
 1911         RAL_WRITE(sc, RT2560_SECCSR1, RT2560_KICK_ENCRYPT);
 1912 
 1913         return 0;
 1914 }
 1915 
 1916 static void
 1917 rt2560_start(struct ifnet *ifp)
 1918 {
 1919         struct rt2560_softc *sc = ifp->if_softc;
 1920         struct ieee80211com *ic = &sc->sc_ic;
 1921         struct mbuf *m0;
 1922         struct ether_header *eh;
 1923         struct ieee80211_node *ni;
 1924 
 1925         RAL_LOCK(sc);
 1926 
 1927         /* prevent management frames from being sent if we're not ready */
 1928         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
 1929                 RAL_UNLOCK(sc);
 1930                 return;
 1931         }
 1932 
 1933         for (;;) {
 1934                 IF_POLL(&ic->ic_mgtq, m0);
 1935                 if (m0 != NULL) {
 1936                         if (sc->prioq.queued >= RT2560_PRIO_RING_COUNT) {
 1937                                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 1938                                 break;
 1939                         }
 1940                         IF_DEQUEUE(&ic->ic_mgtq, m0);
 1941 
 1942                         ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
 1943                         m0->m_pkthdr.rcvif = NULL;
 1944 
 1945                         if (bpf_peers_present(ic->ic_rawbpf))
 1946                                 bpf_mtap(ic->ic_rawbpf, m0);
 1947 
 1948                         if (rt2560_tx_mgt(sc, m0, ni) != 0)
 1949                                 break;
 1950 
 1951                 } else {
 1952                         if (ic->ic_state != IEEE80211_S_RUN)
 1953                                 break;
 1954                         IFQ_DRV_DEQUEUE(&ifp->if_snd, m0);
 1955                         if (m0 == NULL)
 1956                                 break;
 1957                         if (sc->txq.queued >= RT2560_TX_RING_COUNT - 1) {
 1958                                 IFQ_DRV_PREPEND(&ifp->if_snd, m0);
 1959                                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 1960                                 break;
 1961                         }
 1962 
 1963                         if (m0->m_len < sizeof (struct ether_header) &&
 1964                             !(m0 = m_pullup(m0, sizeof (struct ether_header))))
 1965                                 continue;
 1966 
 1967                         eh = mtod(m0, struct ether_header *);
 1968                         ni = ieee80211_find_txnode(ic, eh->ether_dhost);
 1969                         if (ni == NULL) {
 1970                                 m_freem(m0);
 1971                                 continue;
 1972                         }
 1973                         BPF_MTAP(ifp, m0);
 1974 
 1975                         m0 = ieee80211_encap(ic, m0, ni);
 1976                         if (m0 == NULL) {
 1977                                 ieee80211_free_node(ni);
 1978                                 continue;
 1979                         }
 1980 
 1981                         if (bpf_peers_present(ic->ic_rawbpf))
 1982                                 bpf_mtap(ic->ic_rawbpf, m0);
 1983 
 1984                         if (rt2560_tx_data(sc, m0, ni) != 0) {
 1985                                 ieee80211_free_node(ni);
 1986                                 ifp->if_oerrors++;
 1987                                 break;
 1988                         }
 1989                 }
 1990 
 1991                 sc->sc_tx_timer = 5;
 1992                 ifp->if_timer = 1;
 1993         }
 1994 
 1995         RAL_UNLOCK(sc);
 1996 }
 1997 
 1998 static void
 1999 rt2560_watchdog(struct ifnet *ifp)
 2000 {
 2001         struct rt2560_softc *sc = ifp->if_softc;
 2002         struct ieee80211com *ic = &sc->sc_ic;
 2003 
 2004         RAL_LOCK(sc);
 2005 
 2006         ifp->if_timer = 0;
 2007 
 2008         if (sc->sc_tx_timer > 0) {
 2009                 if (--sc->sc_tx_timer == 0) {
 2010                         device_printf(sc->sc_dev, "device timeout\n");
 2011                         rt2560_init(sc);
 2012                         ifp->if_oerrors++;
 2013                         RAL_UNLOCK(sc);
 2014                         return;
 2015                 }
 2016                 ifp->if_timer = 1;
 2017         }
 2018 
 2019         ieee80211_watchdog(ic);
 2020 
 2021         RAL_UNLOCK(sc);
 2022 }
 2023 
 2024 /*
 2025  * This function allows for fast channel switching in monitor mode (used by
 2026  * net-mgmt/kismet). In IBSS mode, we must explicitly reset the interface to
 2027  * generate a new beacon frame.
 2028  */
 2029 static int
 2030 rt2560_reset(struct ifnet *ifp)
 2031 {
 2032         struct rt2560_softc *sc = ifp->if_softc;
 2033         struct ieee80211com *ic = &sc->sc_ic;
 2034 
 2035         if (ic->ic_opmode != IEEE80211_M_MONITOR)
 2036                 return ENETRESET;
 2037 
 2038         rt2560_set_chan(sc, ic->ic_curchan);
 2039 
 2040         return 0;
 2041 }
 2042 
 2043 static int
 2044 rt2560_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 2045 {
 2046         struct rt2560_softc *sc = ifp->if_softc;
 2047         struct ieee80211com *ic = &sc->sc_ic;
 2048         int error = 0;
 2049 
 2050         RAL_LOCK(sc);
 2051 
 2052         switch (cmd) {
 2053         case SIOCSIFFLAGS:
 2054                 if (ifp->if_flags & IFF_UP) {
 2055                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 2056                                 rt2560_update_promisc(sc);
 2057                         else
 2058                                 rt2560_init(sc);
 2059                 } else {
 2060                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
 2061                                 rt2560_stop(sc);
 2062                 }
 2063                 break;
 2064 
 2065         default:
 2066                 error = ieee80211_ioctl(ic, cmd, data);
 2067         }
 2068 
 2069         if (error == ENETRESET) {
 2070                 if ((ifp->if_flags & IFF_UP) &&
 2071                     (ifp->if_drv_flags & IFF_DRV_RUNNING) &&
 2072                     (ic->ic_roaming != IEEE80211_ROAMING_MANUAL))
 2073                         rt2560_init(sc);
 2074                 error = 0;
 2075         }
 2076 
 2077         RAL_UNLOCK(sc);
 2078 
 2079         return error;
 2080 }
 2081 
 2082 static 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                 device_printf(sc->sc_dev, "could not write to BBP\n");
 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 static 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         device_printf(sc->sc_dev, "could not read from BBP\n");
 2121         return 0;
 2122 }
 2123 
 2124 static 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                 device_printf(sc->sc_dev, "could not write to RF\n");
 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 static 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 i, chan;
 2156 
 2157         chan = ieee80211_chan2ieee(ic, c);
 2158         if (chan == 0 || chan == IEEE80211_CHAN_ANY)
 2159                 return;
 2160 
 2161         if (IEEE80211_IS_CHAN_2GHZ(c))
 2162                 power = min(sc->txpow[chan - 1], 31);
 2163         else
 2164                 power = 31;
 2165 
 2166         /* adjust txpower using ifconfig settings */
 2167         power -= (100 - ic->ic_txpowlimit) / 8;
 2168 
 2169         DPRINTFN(2, ("setting channel to %u, txpower to %u\n", chan, power));
 2170 
 2171         switch (sc->rf_rev) {
 2172         case RT2560_RF_2522:
 2173                 rt2560_rf_write(sc, RAL_RF1, 0x00814);
 2174                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2522_r2[chan - 1]);
 2175                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
 2176                 break;
 2177 
 2178         case RT2560_RF_2523:
 2179                 rt2560_rf_write(sc, RAL_RF1, 0x08804);
 2180                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2523_r2[chan - 1]);
 2181                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
 2182                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
 2183                 break;
 2184 
 2185         case RT2560_RF_2524:
 2186                 rt2560_rf_write(sc, RAL_RF1, 0x0c808);
 2187                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2524_r2[chan - 1]);
 2188                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
 2189                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
 2190                 break;
 2191 
 2192         case RT2560_RF_2525:
 2193                 rt2560_rf_write(sc, RAL_RF1, 0x08808);
 2194                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2525_hi_r2[chan - 1]);
 2195                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
 2196                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
 2197 
 2198                 rt2560_rf_write(sc, RAL_RF1, 0x08808);
 2199                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2525_r2[chan - 1]);
 2200                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
 2201                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
 2202                 break;
 2203 
 2204         case RT2560_RF_2525E:
 2205                 rt2560_rf_write(sc, RAL_RF1, 0x08808);
 2206                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2525e_r2[chan - 1]);
 2207                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
 2208                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
 2209                 break;
 2210 
 2211         case RT2560_RF_2526:
 2212                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2526_hi_r2[chan - 1]);
 2213                 rt2560_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
 2214                 rt2560_rf_write(sc, RAL_RF1, 0x08804);
 2215 
 2216                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2526_r2[chan - 1]);
 2217                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
 2218                 rt2560_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
 2219                 break;
 2220 
 2221         /* dual-band RF */
 2222         case RT2560_RF_5222:
 2223                 for (i = 0; rt2560_rf5222[i].chan != chan; i++);
 2224 
 2225                 rt2560_rf_write(sc, RAL_RF1, rt2560_rf5222[i].r1);
 2226                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf5222[i].r2);
 2227                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
 2228                 rt2560_rf_write(sc, RAL_RF4, rt2560_rf5222[i].r4);
 2229                 break;
 2230         }
 2231 
 2232         if (ic->ic_state != IEEE80211_S_SCAN) {
 2233                 /* set Japan filter bit for channel 14 */
 2234                 tmp = rt2560_bbp_read(sc, 70);
 2235 
 2236                 tmp &= ~RT2560_JAPAN_FILTER;
 2237                 if (chan == 14)
 2238                         tmp |= RT2560_JAPAN_FILTER;
 2239 
 2240                 rt2560_bbp_write(sc, 70, tmp);
 2241 
 2242                 /* clear CRC errors */
 2243                 RAL_READ(sc, RT2560_CNT0);
 2244         }
 2245 }
 2246 
 2247 #if 0
 2248 /*
 2249  * Disable RF auto-tuning.
 2250  */
 2251 static void
 2252 rt2560_disable_rf_tune(struct rt2560_softc *sc)
 2253 {
 2254         uint32_t tmp;
 2255 
 2256         if (sc->rf_rev != RT2560_RF_2523) {
 2257                 tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
 2258                 rt2560_rf_write(sc, RAL_RF1, tmp);
 2259         }
 2260 
 2261         tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
 2262         rt2560_rf_write(sc, RAL_RF3, tmp);
 2263 
 2264         DPRINTFN(2, ("disabling RF autotune\n"));
 2265 }
 2266 #endif
 2267 
 2268 /*
 2269  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
 2270  * synchronization.
 2271  */
 2272 static void
 2273 rt2560_enable_tsf_sync(struct rt2560_softc *sc)
 2274 {
 2275         struct ieee80211com *ic = &sc->sc_ic;
 2276         uint16_t logcwmin, preload;
 2277         uint32_t tmp;
 2278 
 2279         /* first, disable TSF synchronization */
 2280         RAL_WRITE(sc, RT2560_CSR14, 0);
 2281 
 2282         tmp = 16 * ic->ic_bss->ni_intval;
 2283         RAL_WRITE(sc, RT2560_CSR12, tmp);
 2284 
 2285         RAL_WRITE(sc, RT2560_CSR13, 0);
 2286 
 2287         logcwmin = 5;
 2288         preload = (ic->ic_opmode == IEEE80211_M_STA) ? 384 : 1024;
 2289         tmp = logcwmin << 16 | preload;
 2290         RAL_WRITE(sc, RT2560_BCNOCSR, tmp);
 2291 
 2292         /* finally, enable TSF synchronization */
 2293         tmp = RT2560_ENABLE_TSF | RT2560_ENABLE_TBCN;
 2294         if (ic->ic_opmode == IEEE80211_M_STA)
 2295                 tmp |= RT2560_ENABLE_TSF_SYNC(1);
 2296         else
 2297                 tmp |= RT2560_ENABLE_TSF_SYNC(2) |
 2298                        RT2560_ENABLE_BEACON_GENERATOR;
 2299         RAL_WRITE(sc, RT2560_CSR14, tmp);
 2300 
 2301         DPRINTF(("enabling TSF synchronization\n"));
 2302 }
 2303 
 2304 static void
 2305 rt2560_update_plcp(struct rt2560_softc *sc)
 2306 {
 2307         struct ieee80211com *ic = &sc->sc_ic;
 2308 
 2309         /* no short preamble for 1Mbps */
 2310         RAL_WRITE(sc, RT2560_PLCP1MCSR, 0x00700400);
 2311 
 2312         if (!(ic->ic_flags & IEEE80211_F_SHPREAMBLE)) {
 2313                 /* values taken from the reference driver */
 2314                 RAL_WRITE(sc, RT2560_PLCP2MCSR,   0x00380401);
 2315                 RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x00150402);
 2316                 RAL_WRITE(sc, RT2560_PLCP11MCSR,  0x000b8403);
 2317         } else {
 2318                 /* same values as above or'ed 0x8 */
 2319                 RAL_WRITE(sc, RT2560_PLCP2MCSR,   0x00380409);
 2320                 RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x0015040a);
 2321                 RAL_WRITE(sc, RT2560_PLCP11MCSR,  0x000b840b);
 2322         }
 2323 
 2324         DPRINTF(("updating PLCP for %s preamble\n",
 2325             (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "short" : "long"));
 2326 }
 2327 
 2328 /*
 2329  * This function can be called by ieee80211_set_shortslottime(). Refer to
 2330  * IEEE Std 802.11-1999 pp. 85 to know how these values are computed.
 2331  */
 2332 static void
 2333 rt2560_update_slot(struct ifnet *ifp)
 2334 {
 2335         struct rt2560_softc *sc = ifp->if_softc;
 2336         struct ieee80211com *ic = &sc->sc_ic;
 2337         uint8_t slottime;
 2338         uint16_t tx_sifs, tx_pifs, tx_difs, eifs;
 2339         uint32_t tmp;
 2340 
 2341         slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
 2342 
 2343         /* update the MAC slot boundaries */
 2344         tx_sifs = RAL_SIFS - RT2560_TXRX_TURNAROUND;
 2345         tx_pifs = tx_sifs + slottime;
 2346         tx_difs = tx_sifs + 2 * slottime;
 2347         eifs = (ic->ic_curmode == IEEE80211_MODE_11B) ? 364 : 60;
 2348 
 2349         tmp = RAL_READ(sc, RT2560_CSR11);
 2350         tmp = (tmp & ~0x1f00) | slottime << 8;
 2351         RAL_WRITE(sc, RT2560_CSR11, tmp);
 2352 
 2353         tmp = tx_pifs << 16 | tx_sifs;
 2354         RAL_WRITE(sc, RT2560_CSR18, tmp);
 2355 
 2356         tmp = eifs << 16 | tx_difs;
 2357         RAL_WRITE(sc, RT2560_CSR19, tmp);
 2358 
 2359         DPRINTF(("setting slottime to %uus\n", slottime));
 2360 }
 2361 
 2362 static void
 2363 rt2560_set_basicrates(struct rt2560_softc *sc)
 2364 {
 2365         struct ieee80211com *ic = &sc->sc_ic;
 2366 
 2367         /* update basic rate set */
 2368         if (ic->ic_curmode == IEEE80211_MODE_11B) {
 2369                 /* 11b basic rates: 1, 2Mbps */
 2370                 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x3);
 2371         } else if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) {
 2372                 /* 11a basic rates: 6, 12, 24Mbps */
 2373                 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x150);
 2374         } else {
 2375                 /* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
 2376                 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x15f);
 2377         }
 2378 }
 2379 
 2380 static void
 2381 rt2560_update_led(struct rt2560_softc *sc, int led1, int led2)
 2382 {
 2383         uint32_t tmp;
 2384 
 2385         /* set ON period to 70ms and OFF period to 30ms */
 2386         tmp = led1 << 16 | led2 << 17 | 70 << 8 | 30;
 2387         RAL_WRITE(sc, RT2560_LEDCSR, tmp);
 2388 }
 2389 
 2390 static void
 2391 rt2560_set_bssid(struct rt2560_softc *sc, uint8_t *bssid)
 2392 {
 2393         uint32_t tmp;
 2394 
 2395         tmp = bssid[0] | bssid[1] << 8 | bssid[2] << 16 | bssid[3] << 24;
 2396         RAL_WRITE(sc, RT2560_CSR5, tmp);
 2397 
 2398         tmp = bssid[4] | bssid[5] << 8;
 2399         RAL_WRITE(sc, RT2560_CSR6, tmp);
 2400 
 2401         DPRINTF(("setting BSSID to %6D\n", bssid, ":"));
 2402 }
 2403 
 2404 static void
 2405 rt2560_set_macaddr(struct rt2560_softc *sc, uint8_t *addr)
 2406 {
 2407         uint32_t tmp;
 2408 
 2409         tmp = addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24;
 2410         RAL_WRITE(sc, RT2560_CSR3, tmp);
 2411 
 2412         tmp = addr[4] | addr[5] << 8;
 2413         RAL_WRITE(sc, RT2560_CSR4, tmp);
 2414 
 2415         DPRINTF(("setting MAC address to %6D\n", addr, ":"));
 2416 }
 2417 
 2418 static void
 2419 rt2560_get_macaddr(struct rt2560_softc *sc, uint8_t *addr)
 2420 {
 2421         uint32_t tmp;
 2422 
 2423         tmp = RAL_READ(sc, RT2560_CSR3);
 2424         addr[0] = tmp & 0xff;
 2425         addr[1] = (tmp >>  8) & 0xff;
 2426         addr[2] = (tmp >> 16) & 0xff;
 2427         addr[3] = (tmp >> 24);
 2428 
 2429         tmp = RAL_READ(sc, RT2560_CSR4);
 2430         addr[4] = tmp & 0xff;
 2431         addr[5] = (tmp >> 8) & 0xff;
 2432 }
 2433 
 2434 static void
 2435 rt2560_update_promisc(struct rt2560_softc *sc)
 2436 {
 2437         struct ifnet *ifp = sc->sc_ic.ic_ifp;
 2438         uint32_t tmp;
 2439 
 2440         tmp = RAL_READ(sc, RT2560_RXCSR0);
 2441 
 2442         tmp &= ~RT2560_DROP_NOT_TO_ME;
 2443         if (!(ifp->if_flags & IFF_PROMISC))
 2444                 tmp |= RT2560_DROP_NOT_TO_ME;
 2445 
 2446         RAL_WRITE(sc, RT2560_RXCSR0, tmp);
 2447 
 2448         DPRINTF(("%s promiscuous mode\n", (ifp->if_flags & IFF_PROMISC) ?
 2449             "entering" : "leaving"));
 2450 }
 2451 
 2452 static const char *
 2453 rt2560_get_rf(int rev)
 2454 {
 2455         switch (rev) {
 2456         case RT2560_RF_2522:    return "RT2522";
 2457         case RT2560_RF_2523:    return "RT2523";
 2458         case RT2560_RF_2524:    return "RT2524";
 2459         case RT2560_RF_2525:    return "RT2525";
 2460         case RT2560_RF_2525E:   return "RT2525e";
 2461         case RT2560_RF_2526:    return "RT2526";
 2462         case RT2560_RF_5222:    return "RT5222";
 2463         default:                return "unknown";
 2464         }
 2465 }
 2466 
 2467 static void
 2468 rt2560_read_eeprom(struct rt2560_softc *sc)
 2469 {
 2470         uint16_t val;
 2471         int i;
 2472 
 2473         val = rt2560_eeprom_read(sc, RT2560_EEPROM_CONFIG0);
 2474         sc->rf_rev =   (val >> 11) & 0x7;
 2475         sc->hw_radio = (val >> 10) & 0x1;
 2476         sc->led_mode = (val >> 6)  & 0x7;
 2477         sc->rx_ant =   (val >> 4)  & 0x3;
 2478         sc->tx_ant =   (val >> 2)  & 0x3;
 2479         sc->nb_ant =   val & 0x3;
 2480 
 2481         /* read default values for BBP registers */
 2482         for (i = 0; i < 16; i++) {
 2483                 val = rt2560_eeprom_read(sc, RT2560_EEPROM_BBP_BASE + i);
 2484                 sc->bbp_prom[i].reg = val >> 8;
 2485                 sc->bbp_prom[i].val = val & 0xff;
 2486         }
 2487 
 2488         /* read Tx power for all b/g channels */
 2489         for (i = 0; i < 14 / 2; i++) {
 2490                 val = rt2560_eeprom_read(sc, RT2560_EEPROM_TXPOWER + i);
 2491                 sc->txpow[i * 2] = val >> 8;
 2492                 sc->txpow[i * 2 + 1] = val & 0xff;
 2493         }
 2494 }
 2495 
 2496 static int
 2497 rt2560_bbp_init(struct rt2560_softc *sc)
 2498 {
 2499 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
 2500         int i, ntries;
 2501 
 2502         /* wait for BBP to be ready */
 2503         for (ntries = 0; ntries < 100; ntries++) {
 2504                 if (rt2560_bbp_read(sc, RT2560_BBP_VERSION) != 0)
 2505                         break;
 2506                 DELAY(1);
 2507         }
 2508         if (ntries == 100) {
 2509                 device_printf(sc->sc_dev, "timeout waiting for BBP\n");
 2510                 return EIO;
 2511         }
 2512 
 2513         /* initialize BBP registers to default values */
 2514         for (i = 0; i < N(rt2560_def_bbp); i++) {
 2515                 rt2560_bbp_write(sc, rt2560_def_bbp[i].reg,
 2516                     rt2560_def_bbp[i].val);
 2517         }
 2518 #if 0
 2519         /* initialize BBP registers to values stored in EEPROM */
 2520         for (i = 0; i < 16; i++) {
 2521                 if (sc->bbp_prom[i].reg == 0xff)
 2522                         continue;
 2523                 rt2560_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
 2524         }
 2525 #endif
 2526 
 2527         return 0;
 2528 #undef N
 2529 }
 2530 
 2531 static void
 2532 rt2560_set_txantenna(struct rt2560_softc *sc, int antenna)
 2533 {
 2534         uint32_t tmp;
 2535         uint8_t tx;
 2536 
 2537         tx = rt2560_bbp_read(sc, RT2560_BBP_TX) & ~RT2560_BBP_ANTMASK;
 2538         if (antenna == 1)
 2539                 tx |= RT2560_BBP_ANTA;
 2540         else if (antenna == 2)
 2541                 tx |= RT2560_BBP_ANTB;
 2542         else
 2543                 tx |= RT2560_BBP_DIVERSITY;
 2544 
 2545         /* need to force I/Q flip for RF 2525e, 2526 and 5222 */
 2546         if (sc->rf_rev == RT2560_RF_2525E || sc->rf_rev == RT2560_RF_2526 ||
 2547             sc->rf_rev == RT2560_RF_5222)
 2548                 tx |= RT2560_BBP_FLIPIQ;
 2549 
 2550         rt2560_bbp_write(sc, RT2560_BBP_TX, tx);
 2551 
 2552         /* update values for CCK and OFDM in BBPCSR1 */
 2553         tmp = RAL_READ(sc, RT2560_BBPCSR1) & ~0x00070007;
 2554         tmp |= (tx & 0x7) << 16 | (tx & 0x7);
 2555         RAL_WRITE(sc, RT2560_BBPCSR1, tmp);
 2556 }
 2557 
 2558 static void
 2559 rt2560_set_rxantenna(struct rt2560_softc *sc, int antenna)
 2560 {
 2561         uint8_t rx;
 2562 
 2563         rx = rt2560_bbp_read(sc, RT2560_BBP_RX) & ~RT2560_BBP_ANTMASK;
 2564         if (antenna == 1)
 2565                 rx |= RT2560_BBP_ANTA;
 2566         else if (antenna == 2)
 2567                 rx |= RT2560_BBP_ANTB;
 2568         else
 2569                 rx |= RT2560_BBP_DIVERSITY;
 2570 
 2571         /* need to force no I/Q flip for RF 2525e and 2526 */
 2572         if (sc->rf_rev == RT2560_RF_2525E || sc->rf_rev == RT2560_RF_2526)
 2573                 rx &= ~RT2560_BBP_FLIPIQ;
 2574 
 2575         rt2560_bbp_write(sc, RT2560_BBP_RX, rx);
 2576 }
 2577 
 2578 static void
 2579 rt2560_init(void *priv)
 2580 {
 2581 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
 2582         struct rt2560_softc *sc = priv;
 2583         struct ieee80211com *ic = &sc->sc_ic;
 2584         struct ifnet *ifp = ic->ic_ifp;
 2585         uint32_t tmp;
 2586         int i;
 2587 
 2588         RAL_LOCK(sc);
 2589 
 2590         rt2560_stop(sc);
 2591 
 2592         /* setup tx rings */
 2593         tmp = RT2560_PRIO_RING_COUNT << 24 |
 2594               RT2560_ATIM_RING_COUNT << 16 |
 2595               RT2560_TX_RING_COUNT   <<  8 |
 2596               RT2560_TX_DESC_SIZE;
 2597 
 2598         /* rings must be initialized in this exact order */
 2599         RAL_WRITE(sc, RT2560_TXCSR2, tmp);
 2600         RAL_WRITE(sc, RT2560_TXCSR3, sc->txq.physaddr);
 2601         RAL_WRITE(sc, RT2560_TXCSR5, sc->prioq.physaddr);
 2602         RAL_WRITE(sc, RT2560_TXCSR4, sc->atimq.physaddr);
 2603         RAL_WRITE(sc, RT2560_TXCSR6, sc->bcnq.physaddr);
 2604 
 2605         /* setup rx ring */
 2606         tmp = RT2560_RX_RING_COUNT << 8 | RT2560_RX_DESC_SIZE;
 2607 
 2608         RAL_WRITE(sc, RT2560_RXCSR1, tmp);
 2609         RAL_WRITE(sc, RT2560_RXCSR2, sc->rxq.physaddr);
 2610 
 2611         /* initialize MAC registers to default values */
 2612         for (i = 0; i < N(rt2560_def_mac); i++)
 2613                 RAL_WRITE(sc, rt2560_def_mac[i].reg, rt2560_def_mac[i].val);
 2614 
 2615         IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
 2616         rt2560_set_macaddr(sc, ic->ic_myaddr);
 2617 
 2618         /* set basic rate set (will be updated later) */
 2619         RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x153);
 2620 
 2621         rt2560_set_txantenna(sc, sc->tx_ant);
 2622         rt2560_set_rxantenna(sc, sc->rx_ant);
 2623         rt2560_update_slot(ifp);
 2624         rt2560_update_plcp(sc);
 2625         rt2560_update_led(sc, 0, 0);
 2626 
 2627         RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
 2628         RAL_WRITE(sc, RT2560_CSR1, RT2560_HOST_READY);
 2629 
 2630         if (rt2560_bbp_init(sc) != 0) {
 2631                 rt2560_stop(sc);
 2632                 RAL_UNLOCK(sc);
 2633                 return;
 2634         }
 2635 
 2636         /* set default BSS channel */
 2637         rt2560_set_chan(sc, ic->ic_curchan);
 2638 
 2639         /* kick Rx */
 2640         tmp = RT2560_DROP_PHY_ERROR | RT2560_DROP_CRC_ERROR;
 2641         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
 2642                 tmp |= RT2560_DROP_CTL | RT2560_DROP_VERSION_ERROR;
 2643                 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
 2644                         tmp |= RT2560_DROP_TODS;
 2645                 if (!(ifp->if_flags & IFF_PROMISC))
 2646                         tmp |= RT2560_DROP_NOT_TO_ME;
 2647         }
 2648         RAL_WRITE(sc, RT2560_RXCSR0, tmp);
 2649 
 2650         /* clear old FCS and Rx FIFO errors */
 2651         RAL_READ(sc, RT2560_CNT0);
 2652         RAL_READ(sc, RT2560_CNT4);
 2653 
 2654         /* clear any pending interrupts */
 2655         RAL_WRITE(sc, RT2560_CSR7, 0xffffffff);
 2656 
 2657         /* enable interrupts */
 2658         RAL_WRITE(sc, RT2560_CSR8, RT2560_INTR_MASK);
 2659 
 2660         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 2661         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 2662 
 2663         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
 2664                 if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
 2665                         ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
 2666         } else
 2667                 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
 2668 
 2669         RAL_UNLOCK(sc);
 2670 #undef N
 2671 }
 2672 
 2673 void
 2674 rt2560_stop(void *priv)
 2675 {
 2676         struct rt2560_softc *sc = priv;
 2677         struct ieee80211com *ic = &sc->sc_ic;
 2678         struct ifnet *ifp = ic->ic_ifp;
 2679 
 2680         sc->sc_tx_timer = 0;
 2681         ifp->if_timer = 0;
 2682         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
 2683 
 2684         ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
 2685 
 2686         /* abort Tx */
 2687         RAL_WRITE(sc, RT2560_TXCSR0, RT2560_ABORT_TX);
 2688 
 2689         /* disable Rx */
 2690         RAL_WRITE(sc, RT2560_RXCSR0, RT2560_DISABLE_RX);
 2691 
 2692         /* reset ASIC (imply reset BBP) */
 2693         RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
 2694         RAL_WRITE(sc, RT2560_CSR1, 0);
 2695 
 2696         /* disable interrupts */
 2697         RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
 2698 
 2699         /* reset Tx and Rx rings */
 2700         rt2560_reset_tx_ring(sc, &sc->txq);
 2701         rt2560_reset_tx_ring(sc, &sc->atimq);
 2702         rt2560_reset_tx_ring(sc, &sc->prioq);
 2703         rt2560_reset_tx_ring(sc, &sc->bcnq);
 2704         rt2560_reset_rx_ring(sc, &sc->rxq);
 2705 }

Cache object: d9a55e190f0a4af2acaece3a31a9c46b


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.