sys/dev/netif/ral/rt2661.c

   1 /*
   2  * Copyright (c) 2006
   3  *      Damien Bergamini <damien.bergamini@free.fr>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  *
  17  * $FreeBSD: src/sys/dev/ral/rt2661.c,v 1.4 2006/03/21 21:15:43 damien Exp $
  18  * $DragonFly: src/sys/dev/netif/ral/rt2661.c,v 1.3 2006/09/05 00:55:40 dillon Exp $
  19  */
  20
  21 /*
  22  * Ralink Technology RT2561, RT2561S and RT2661 chipset driver
  23  * http://www.ralinktech.com/
  24  */
  25
  26 #include <sys/param.h>
  27 #include <sys/sysctl.h>
  28 #include <sys/sockio.h>
  29 #include <sys/mbuf.h>
  30 #include <sys/kernel.h>
  31 #include <sys/socket.h>
  32 #include <sys/systm.h>
  33 #include <sys/malloc.h>
  34 #include <sys/module.h>
  35 #include <sys/bus.h>
  36 #include <sys/endian.h>
  37
  38 #include <machine/bus.h>
  39 #include <machine/resource.h>
  40 #include <machine/clock.h>
  41 #include <sys/rman.h>
  42
  43 #include <net/bpf.h>
  44 #include <net/if.h>
  45 #include <net/if_arp.h>
  46 #include <net/ethernet.h>
  47 #include <net/if_dl.h>
  48 #include <net/if_media.h>
  49 #include <net/if_types.h>
  50 #include <net/ifq_var.h>
  51
  52 #include <netproto/802_11/ieee80211_var.h>
  53 #include <netproto/802_11/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/netif/ral/if_ralrate.h>
  62 #include <dev/netif/ral/rt2661reg.h>
  63 #include <dev/netif/ral/rt2661var.h>
  64 #include <dev/netif/ral/rt2661_ucode.h>
  65
  66 #ifdef RAL_DEBUG
  67 #define DPRINTF(x)      do { if (ral_debug > 0) printf x; } while (0)
  68 #define DPRINTFN(n, x)  do { if (ral_debug >= (n)) printf x; } while (0)
  69 int ral_debug = 0;
  70 SYSCTL_INT(_debug, OID_AUTO, ral, CTLFLAG_RW, &ral_debug, 0, "ral debug level");
  71 #else
  72 #define DPRINTF(x)
  73 #define DPRINTFN(n, x)
  74 #endif
  75
  76 static void             rt2661_dma_map_addr(void *, bus_dma_segment_t *, int,
  77                             int);
  78 static void             rt2661_dma_map_mbuf(void *, bus_dma_segment_t *, int,
  79                                             bus_size_t, int);
  80 static int              rt2661_alloc_tx_ring(struct rt2661_softc *,
  81                             struct rt2661_tx_ring *, int);
  82 static void             rt2661_reset_tx_ring(struct rt2661_softc *,
  83                             struct rt2661_tx_ring *);
  84 static void             rt2661_free_tx_ring(struct rt2661_softc *,
  85                             struct rt2661_tx_ring *);
  86 static int              rt2661_alloc_rx_ring(struct rt2661_softc *,
  87                             struct rt2661_rx_ring *, int);
  88 static void             rt2661_reset_rx_ring(struct rt2661_softc *,
  89                             struct rt2661_rx_ring *);
  90 static void             rt2661_free_rx_ring(struct rt2661_softc *,
  91                             struct rt2661_rx_ring *);
  92 static struct           ieee80211_node *rt2661_node_alloc(
  93                             struct ieee80211_node_table *);
  94 static int              rt2661_media_change(struct ifnet *);
  95 static void             rt2661_next_scan(void *);
  96 static int              rt2661_newstate(struct ieee80211com *,
  97                             enum ieee80211_state, int);
  98 static uint16_t         rt2661_eeprom_read(struct rt2661_softc *, uint8_t);
  99 static void             rt2661_rx_intr(struct rt2661_softc *);
 100 static void             rt2661_tx_intr(struct rt2661_softc *);
 101 static void             rt2661_tx_dma_intr(struct rt2661_softc *,
 102                             struct rt2661_tx_ring *);
 103 static void             rt2661_mcu_beacon_expire(struct rt2661_softc *);
 104 static void             rt2661_mcu_wakeup(struct rt2661_softc *);
 105 static void             rt2661_mcu_cmd_intr(struct rt2661_softc *);
 106 static int              rt2661_ack_rate(struct ieee80211com *, int);
 107 static uint16_t         rt2661_txtime(int, int, uint32_t);
 108 static uint8_t          rt2661_rxrate(struct rt2661_rx_desc *);
 109 static uint8_t          rt2661_plcp_signal(int);
 110 static void             rt2661_setup_tx_desc(struct rt2661_softc *,
 111                             struct rt2661_tx_desc *, uint32_t, uint16_t, int,
 112                             int, const bus_dma_segment_t *, int, int);
 113 static struct mbuf *    rt2661_get_rts(struct rt2661_softc *,
 114                             struct ieee80211_frame *, uint16_t);
 115 static int              rt2661_tx_data(struct rt2661_softc *, struct mbuf *,
 116                             struct ieee80211_node *, int);
 117 static int              rt2661_tx_mgt(struct rt2661_softc *, struct mbuf *,
 118                             struct ieee80211_node *);
 119 static void             rt2661_start(struct ifnet *);
 120 static void             rt2661_watchdog(struct ifnet *);
 121 static int              rt2661_reset(struct ifnet *);
 122 static int              rt2661_ioctl(struct ifnet *, u_long, caddr_t,
 123                                      struct ucred *);
 124 static void             rt2661_bbp_write(struct rt2661_softc *, uint8_t,
 125                             uint8_t);
 126 static uint8_t          rt2661_bbp_read(struct rt2661_softc *, uint8_t);
 127 static void             rt2661_rf_write(struct rt2661_softc *, uint8_t,
 128                             uint32_t);
 129 static int              rt2661_tx_cmd(struct rt2661_softc *, uint8_t,
 130                             uint16_t);
 131 static void             rt2661_select_antenna(struct rt2661_softc *);
 132 static void             rt2661_enable_mrr(struct rt2661_softc *);
 133 static void             rt2661_set_txpreamble(struct rt2661_softc *);
 134 static void             rt2661_set_basicrates(struct rt2661_softc *,
 135                             const struct ieee80211_rateset *);
 136 static void             rt2661_select_band(struct rt2661_softc *,
 137                             struct ieee80211_channel *);
 138 static void             rt2661_set_chan(struct rt2661_softc *,
 139                             struct ieee80211_channel *);
 140 static void             rt2661_set_bssid(struct rt2661_softc *,
 141                             const uint8_t *);
 142 static void             rt2661_set_macaddr(struct rt2661_softc *,
 143                            const uint8_t *);
 144 static void             rt2661_update_promisc(struct rt2661_softc *);
 145 static int              rt2661_wme_update(struct ieee80211com *) __unused;
 146 static void             rt2661_update_slot(struct ifnet *);
 147 static const char       *rt2661_get_rf(int);
 148 static void             rt2661_read_eeprom(struct rt2661_softc *);
 149 static int              rt2661_bbp_init(struct rt2661_softc *);
 150 static void             rt2661_init(void *);
 151 static void             rt2661_stop(void *);
 152 static void             rt2661_intr(void *);
 153 static int              rt2661_load_microcode(struct rt2661_softc *,
 154                             const uint8_t *, int);
 155 #ifdef notyet
 156 static void             rt2661_rx_tune(struct rt2661_softc *);
 157 static void             rt2661_radar_start(struct rt2661_softc *);
 158 static int              rt2661_radar_stop(struct rt2661_softc *);
 159 #endif
 160 static int              rt2661_prepare_beacon(struct rt2661_softc *);
 161 static void             rt2661_enable_tsf_sync(struct rt2661_softc *);
 162 static int              rt2661_get_rssi(struct rt2661_softc *, uint8_t);
 163
 164 /*
 165  * Supported rates for 802.11a/b/g modes (in 500Kbps unit).
 166  */
 167 static const struct ieee80211_rateset rt2661_rateset_11a =
 168         { 8, { 12, 18, 24, 36, 48, 72, 96, 108 } };
 169
 170 static const struct ieee80211_rateset rt2661_rateset_11b =
 171         { 4, { 2, 4, 11, 22 } };
 172
 173 static const struct ieee80211_rateset rt2661_rateset_11g =
 174         { 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } };
 175
 176 static const struct {
 177         uint32_t        reg;
 178         uint32_t        val;
 179 } rt2661_def_mac[] = {
 180         RT2661_DEF_MAC
 181 };
 182
 183 static const struct {
 184         uint8_t reg;
 185         uint8_t val;
 186 } rt2661_def_bbp[] = {
 187         RT2661_DEF_BBP
 188 };
 189
 190 static const struct rfprog {
 191         uint8_t         chan;
 192         uint32_t        r1, r2, r3, r4;
 193 }  rt2661_rf5225_1[] = {
 194         RT2661_RF5225_1
 195 }, rt2661_rf5225_2[] = {
 196         RT2661_RF5225_2
 197 };
 198
 199 struct rt2661_dmamap {
 200         bus_dma_segment_t       segs[RT2661_MAX_SCATTER];
 201         int                     nseg;
 202 };
 203
 204 int
 205 rt2661_attach(device_t dev, int id)
 206 {
 207         struct rt2661_softc *sc = device_get_softc(dev);
 208         struct ieee80211com *ic = &sc->sc_ic;
 209         struct ifnet *ifp = &ic->ic_if;
 210         uint32_t val;
 211         const uint8_t *ucode = NULL;
 212         int error, i, ac, ntries, size = 0;
 213
 214         callout_init(&sc->scan_ch);
 215         callout_init(&sc->rssadapt_ch);
 216
 217         sc->sc_irq_rid = 0;
 218         sc->sc_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->sc_irq_rid,
 219                                             RF_ACTIVE | RF_SHAREABLE);
 220         if (sc->sc_irq == NULL) {
 221                 device_printf(dev, "could not allocate interrupt resource\n");
 222                 return ENXIO;
 223         }
 224
 225         /* wait for NIC to initialize */
 226         for (ntries = 0; ntries < 1000; ntries++) {
 227                 if ((val = RAL_READ(sc, RT2661_MAC_CSR0)) != 0)
 228                         break;
 229                 DELAY(1000);
 230         }
 231         if (ntries == 1000) {
 232                 device_printf(sc->sc_dev,
 233                     "timeout waiting for NIC to initialize\n");
 234                 error = EIO;
 235                 goto fail;
 236         }
 237
 238         /* retrieve RF rev. no and various other things from EEPROM */
 239         rt2661_read_eeprom(sc);
 240
 241         device_printf(dev, "MAC/BBP RT%X, RF %s\n", val,
 242             rt2661_get_rf(sc->rf_rev));
 243
 244         /*
 245          * Load 8051 microcode into NIC.
 246          */
 247         switch (id) {
 248         case 0x0301:
 249                 ucode = rt2561s_ucode;
 250                 size = sizeof rt2561s_ucode;
 251                 break;
 252         case 0x0302:
 253                 ucode = rt2561_ucode;
 254                 size = sizeof rt2561_ucode;
 255                 break;
 256         case 0x0401:
 257                 ucode = rt2661_ucode;
 258                 size = sizeof rt2661_ucode;
 259                 break;
 260         }
 261
 262         error = rt2661_load_microcode(sc, ucode, size);
 263         if (error != 0) {
 264                 device_printf(sc->sc_dev, "could not load 8051 microcode\n");
 265                 goto fail;
 266         }
 267
 268         /*
 269          * Allocate Tx and Rx rings.
 270          */
 271         for (ac = 0; ac < 4; ac++) {
 272                 error = rt2661_alloc_tx_ring(sc, &sc->txq[ac],
 273                     RT2661_TX_RING_COUNT);
 274                 if (error != 0) {
 275                         device_printf(sc->sc_dev,
 276                             "could not allocate Tx ring %d\n", ac);
 277                         goto fail;
 278                 }
 279         }
 280
 281         error = rt2661_alloc_tx_ring(sc, &sc->mgtq, RT2661_MGT_RING_COUNT);
 282         if (error != 0) {
 283                 device_printf(sc->sc_dev, "could not allocate Mgt ring\n");
 284                 goto fail;
 285         }
 286
 287         error = rt2661_alloc_rx_ring(sc, &sc->rxq, RT2661_RX_RING_COUNT);
 288         if (error != 0) {
 289                 device_printf(sc->sc_dev, "could not allocate Rx ring\n");
 290                 goto fail;
 291         }
 292
 293         sysctl_ctx_init(&sc->sysctl_ctx);
 294         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 295                                           SYSCTL_STATIC_CHILDREN(_hw),
 296                                           OID_AUTO,
 297                                           device_get_nameunit(dev),
 298                                           CTLFLAG_RD, 0, "");
 299         if (sc->sysctl_tree == NULL) {
 300                 device_printf(dev, "could not add sysctl node\n");
 301                 error = ENXIO;
 302                 goto fail;
 303         }
 304
 305         ifp->if_softc = sc;
 306         if_initname(ifp, device_get_name(dev), device_get_unit(dev));
 307         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 308         ifp->if_init = rt2661_init;
 309         ifp->if_ioctl = rt2661_ioctl;
 310         ifp->if_start = rt2661_start;
 311         ifp->if_watchdog = rt2661_watchdog;
 312         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 313         ifq_set_ready(&ifp->if_snd);
 314
 315         ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
 316         ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */
 317         ic->ic_state = IEEE80211_S_INIT;
 318
 319         /* set device capabilities */
 320         ic->ic_caps =
 321             IEEE80211_C_IBSS |          /* IBSS mode supported */
 322             IEEE80211_C_MONITOR |       /* monitor mode supported */
 323             IEEE80211_C_HOSTAP |        /* HostAp mode supported */
 324             IEEE80211_C_TXPMGT |        /* tx power management */
 325             IEEE80211_C_SHPREAMBLE |    /* short preamble supported */
 326             IEEE80211_C_SHSLOT |        /* short slot time supported */
 327 #ifdef notyet
 328             IEEE80211_C_WME |           /* 802.11e */
 329 #endif
 330             IEEE80211_C_WEP |           /* WEP */
 331             IEEE80211_C_WPA;            /* 802.11i */
 332
 333         if (sc->rf_rev == RT2661_RF_5225 || sc->rf_rev == RT2661_RF_5325) {
 334                 /* set supported .11a rates */
 335                 ic->ic_sup_rates[IEEE80211_MODE_11A] = rt2661_rateset_11a;
 336
 337                 /* set supported .11a channels */
 338                 for (i = 36; i <= 64; i += 4) {
 339                         ic->ic_channels[i].ic_freq =
 340                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
 341                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
 342                 }
 343                 for (i = 100; i <= 140; i += 4) {
 344                         ic->ic_channels[i].ic_freq =
 345                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
 346                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
 347                 }
 348                 for (i = 149; i <= 165; i += 4) {
 349                         ic->ic_channels[i].ic_freq =
 350                             ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ);
 351                         ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A;
 352                 }
 353         }
 354
 355         /* set supported .11b and .11g rates */
 356         ic->ic_sup_rates[IEEE80211_MODE_11B] = rt2661_rateset_11b;
 357         ic->ic_sup_rates[IEEE80211_MODE_11G] = rt2661_rateset_11g;
 358
 359         /* set supported .11b and .11g channels (1 through 14) */
 360         for (i = 1; i <= 14; i++) {
 361                 ic->ic_channels[i].ic_freq =
 362                     ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
 363                 ic->ic_channels[i].ic_flags =
 364                     IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
 365                     IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
 366         }
 367
 368         ieee80211_ifattach(ic);
 369         ic->ic_node_alloc = rt2661_node_alloc;
 370 /*      ic->ic_wme.wme_update = rt2661_wme_update;*/
 371         ic->ic_updateslot = rt2661_update_slot;
 372         ic->ic_reset = rt2661_reset;
 373         /* enable s/w bmiss handling in sta mode */
 374         ic->ic_flags_ext |= IEEE80211_FEXT_SWBMISS;
 375
 376         /* override state transition machine */
 377         sc->sc_newstate = ic->ic_newstate;
 378         ic->ic_newstate = rt2661_newstate;
 379         ieee80211_media_init(ic, rt2661_media_change, ieee80211_media_status);
 380
 381         bpfattach_dlt(ifp, DLT_IEEE802_11_RADIO,
 382             sizeof (struct ieee80211_frame) + 64, &sc->sc_drvbpf);
 383
 384         sc->sc_rxtap_len = sizeof sc->sc_rxtapu;
 385         sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
 386         sc->sc_rxtap.wr_ihdr.it_present = htole32(RT2661_RX_RADIOTAP_PRESENT);
 387
 388         sc->sc_txtap_len = sizeof sc->sc_txtapu;
 389         sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
 390         sc->sc_txtap.wt_ihdr.it_present = htole32(RT2661_TX_RADIOTAP_PRESENT);
 391
 392         /*
 393          * Add a few sysctl knobs.
 394          */
 395         sc->dwelltime = 200;
 396
 397         SYSCTL_ADD_INT(&sc->sysctl_ctx,
 398             SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "dwell",
 399             CTLFLAG_RW, &sc->dwelltime, 0,
 400             "channel dwell time (ms) for AP/station scanning");
 401
 402         error = bus_setup_intr(dev, sc->sc_irq, INTR_MPSAFE, rt2661_intr,
 403                                sc, &sc->sc_ih, ifp->if_serializer);
 404         if (error != 0) {
 405                 device_printf(dev, "could not set up interrupt\n");
 406                 bpfdetach(ifp);
 407                 ieee80211_ifdetach(ic);
 408                 goto fail;
 409         }
 410
 411         if (bootverbose)
 412                 ieee80211_announce(ic);
 413         return 0;
 414 fail:
 415         rt2661_detach(sc);
 416         return error;
 417 }
 418
 419 int
 420 rt2661_detach(void *xsc)
 421 {
 422         struct rt2661_softc *sc = xsc;
 423         struct ieee80211com *ic = &sc->sc_ic;
 424         struct ifnet *ifp = &ic->ic_if;
 425
 426         if (device_is_attached(sc->sc_dev)) {
 427                 lwkt_serialize_enter(ifp->if_serializer);
 428
 429                 callout_stop(&sc->scan_ch);
 430                 callout_stop(&sc->rssadapt_ch);
 431                 rt2661_stop(sc);
 432                 bus_teardown_intr(sc->sc_dev, sc->sc_irq, sc->sc_ih);
 433
 434                 lwkt_serialize_exit(ifp->if_serializer);
 435
 436                 bpfdetach(ifp);
 437                 ieee80211_ifdetach(ic);
 438         }
 439
 440         rt2661_free_tx_ring(sc, &sc->txq[0]);
 441         rt2661_free_tx_ring(sc, &sc->txq[1]);
 442         rt2661_free_tx_ring(sc, &sc->txq[2]);
 443         rt2661_free_tx_ring(sc, &sc->txq[3]);
 444         rt2661_free_tx_ring(sc, &sc->mgtq);
 445         rt2661_free_rx_ring(sc, &sc->rxq);
 446
 447         if (sc->sc_irq != NULL) {
 448                 bus_release_resource(sc->sc_dev, SYS_RES_IRQ, sc->sc_irq_rid,
 449                                      sc->sc_irq);
 450         }
 451
 452         if (sc->sysctl_tree != NULL)
 453                 sysctl_ctx_free(&sc->sysctl_ctx);
 454
 455         return 0;
 456 }
 457
 458 void
 459 rt2661_shutdown(void *xsc)
 460 {
 461         struct rt2661_softc *sc = xsc;
 462         struct ifnet *ifp = &sc->sc_ic.ic_if;
 463
 464         lwkt_serialize_enter(ifp->if_serializer);
 465         rt2661_stop(sc);
 466         lwkt_serialize_exit(ifp->if_serializer);
 467 }
 468
 469 void
 470 rt2661_suspend(void *xsc)
 471 {
 472         struct rt2661_softc *sc = xsc;
 473         struct ifnet *ifp = &sc->sc_ic.ic_if;
 474
 475         lwkt_serialize_enter(ifp->if_serializer);
 476         rt2661_stop(sc);
 477         lwkt_serialize_exit(ifp->if_serializer);
 478 }
 479
 480 void
 481 rt2661_resume(void *xsc)
 482 {
 483         struct rt2661_softc *sc = xsc;
 484         struct ifnet *ifp = sc->sc_ic.ic_ifp;
 485
 486         lwkt_serialize_enter(ifp->if_serializer);
 487         if (ifp->if_flags & IFF_UP) {
 488                 ifp->if_init(ifp->if_softc);
 489                 if (ifp->if_flags & IFF_RUNNING)
 490                         ifp->if_start(ifp);
 491         }
 492         lwkt_serialize_exit(ifp->if_serializer);
 493 }
 494
 495 static void
 496 rt2661_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 497 {
 498         if (error != 0)
 499                 return;
 500
 501         KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg));
 502
 503         *(bus_addr_t *)arg = segs[0].ds_addr;
 504 }
 505
 506 static int
 507 rt2661_alloc_tx_ring(struct rt2661_softc *sc, struct rt2661_tx_ring *ring,
 508     int count)
 509 {
 510         int i, error;
 511
 512         ring->count = count;
 513         ring->queued = 0;
 514         ring->cur = ring->next = ring->stat = 0;
 515
 516         error = bus_dma_tag_create(NULL, 4, 0, BUS_SPACE_MAXADDR_32BIT,
 517             BUS_SPACE_MAXADDR, NULL, NULL, count * RT2661_TX_DESC_SIZE, 1,
 518             count * RT2661_TX_DESC_SIZE, 0, &ring->desc_dmat);
 519         if (error != 0) {
 520                 device_printf(sc->sc_dev, "could not create desc DMA tag\n");
 521                 goto fail;
 522         }
 523
 524         error = bus_dmamem_alloc(ring->desc_dmat, (void **)&ring->desc,
 525             BUS_DMA_WAITOK | BUS_DMA_ZERO, &ring->desc_map);
 526         if (error != 0) {
 527                 device_printf(sc->sc_dev, "could not allocate DMA memory\n");
 528                 goto fail;
 529         }
 530
 531         error = bus_dmamap_load(ring->desc_dmat, ring->desc_map, ring->desc,
 532             count * RT2661_TX_DESC_SIZE, rt2661_dma_map_addr, &ring->physaddr,
 533             0);
 534         if (error != 0) {
 535                 device_printf(sc->sc_dev, "could not load desc DMA map\n");
 536
 537                 bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map);
 538                 ring->desc = NULL;
 539                 goto fail;
 540         }
 541
 542         ring->data = kmalloc(count * sizeof (struct rt2661_tx_data), M_DEVBUF,
 543             M_WAITOK | M_ZERO);
 544
 545         error = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT,
 546             BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES * RT2661_MAX_SCATTER,
 547             RT2661_MAX_SCATTER, MCLBYTES, 0, &ring->data_dmat);
 548         if (error != 0) {
 549                 device_printf(sc->sc_dev, "could not create data DMA tag\n");
 550                 goto fail;
 551         }
 552
 553         for (i = 0; i < count; i++) {
 554                 error = bus_dmamap_create(ring->data_dmat, 0,
 555                     &ring->data[i].map);
 556                 if (error != 0) {
 557                         device_printf(sc->sc_dev, "could not create DMA map\n");
 558                         goto fail;
 559                 }
 560         }
 561         return 0;
 562
 563 fail:   rt2661_free_tx_ring(sc, ring);
 564         return error;
 565 }
 566
 567 static void
 568 rt2661_reset_tx_ring(struct rt2661_softc *sc, struct rt2661_tx_ring *ring)
 569 {
 570         struct rt2661_tx_desc *desc;
 571         struct rt2661_tx_data *data;
 572         int i;
 573
 574         for (i = 0; i < ring->count; i++) {
 575                 desc = &ring->desc[i];
 576                 data = &ring->data[i];
 577
 578                 if (data->m != NULL) {
 579                         bus_dmamap_sync(ring->data_dmat, data->map,
 580                             BUS_DMASYNC_POSTWRITE);
 581                         bus_dmamap_unload(ring->data_dmat, data->map);
 582                         m_freem(data->m);
 583                         data->m = NULL;
 584                 }
 585
 586                 if (data->ni != NULL) {
 587                         ieee80211_free_node(data->ni);
 588                         data->ni = NULL;
 589                 }
 590
 591                 desc->flags = 0;
 592         }
 593
 594         bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_PREWRITE);
 595
 596         ring->queued = 0;
 597         ring->cur = ring->next = ring->stat = 0;
 598 }
 599
 600 static void
 601 rt2661_free_tx_ring(struct rt2661_softc *sc, struct rt2661_tx_ring *ring)
 602 {
 603         struct rt2661_tx_data *data;
 604         int i;
 605
 606         if (ring->desc != NULL) {
 607                 bus_dmamap_sync(ring->desc_dmat, ring->desc_map,
 608                     BUS_DMASYNC_POSTWRITE);
 609                 bus_dmamap_unload(ring->desc_dmat, ring->desc_map);
 610                 bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map);
 611                 ring->desc = NULL;
 612         }
 613
 614         if (ring->desc_dmat != NULL) {
 615                 bus_dma_tag_destroy(ring->desc_dmat);
 616                 ring->desc_dmat = NULL;
 617         }
 618
 619         if (ring->data != NULL) {
 620                 for (i = 0; i < ring->count; i++) {
 621                         data = &ring->data[i];
 622
 623                         if (data->m != NULL) {
 624                                 bus_dmamap_sync(ring->data_dmat, data->map,
 625                                     BUS_DMASYNC_POSTWRITE);
 626                                 bus_dmamap_unload(ring->data_dmat, data->map);
 627                                 m_freem(data->m);
 628                                 data->m = NULL;
 629                         }
 630
 631                         if (data->ni != NULL) {
 632                                 ieee80211_free_node(data->ni);
 633                                 data->ni = NULL;
 634                         }
 635
 636                         if (data->map != NULL) {
 637                                 bus_dmamap_destroy(ring->data_dmat, data->map);
 638                                 data->map = NULL;
 639                         }
 640                 }
 641
 642                 kfree(ring->data, M_DEVBUF);
 643                 ring->data = NULL;
 644         }
 645
 646         if (ring->data_dmat != NULL) {
 647                 bus_dma_tag_destroy(ring->data_dmat);
 648                 ring->data_dmat = NULL;
 649         }
 650 }
 651
 652 static int
 653 rt2661_alloc_rx_ring(struct rt2661_softc *sc, struct rt2661_rx_ring *ring,
 654     int count)
 655 {
 656         struct rt2661_rx_desc *desc;
 657         struct rt2661_rx_data *data;
 658         bus_addr_t physaddr;
 659         int i, error;
 660
 661         ring->count = count;
 662         ring->cur = ring->next = 0;
 663
 664         error = bus_dma_tag_create(NULL, 4, 0, BUS_SPACE_MAXADDR_32BIT,
 665             BUS_SPACE_MAXADDR, NULL, NULL, count * RT2661_RX_DESC_SIZE, 1,
 666             count * RT2661_RX_DESC_SIZE, 0, &ring->desc_dmat);
 667         if (error != 0) {
 668                 device_printf(sc->sc_dev, "could not create desc DMA tag\n");
 669                 goto fail;
 670         }
 671
 672         error = bus_dmamem_alloc(ring->desc_dmat, (void **)&ring->desc,
 673             BUS_DMA_WAITOK | BUS_DMA_ZERO, &ring->desc_map);
 674         if (error != 0) {
 675                 device_printf(sc->sc_dev, "could not allocate DMA memory\n");
 676                 goto fail;
 677         }
 678
 679         error = bus_dmamap_load(ring->desc_dmat, ring->desc_map, ring->desc,
 680             count * RT2661_RX_DESC_SIZE, rt2661_dma_map_addr, &ring->physaddr,
 681             0);
 682         if (error != 0) {
 683                 device_printf(sc->sc_dev, "could not load desc DMA map\n");
 684
 685                 bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map);
 686                 ring->desc = NULL;
 687                 goto fail;
 688         }
 689
 690         ring->data = kmalloc(count * sizeof (struct rt2661_rx_data), M_DEVBUF,
 691             M_WAITOK | M_ZERO);
 692
 693         /*
 694          * Pre-allocate Rx buffers and populate Rx ring.
 695          */
 696         error = bus_dma_tag_create(NULL, 1, 0, BUS_SPACE_MAXADDR_32BIT,
 697             BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1, MCLBYTES, 0,
 698             &ring->data_dmat);
 699         if (error != 0) {
 700                 device_printf(sc->sc_dev, "could not create data DMA tag\n");
 701                 goto fail;
 702         }
 703
 704         for (i = 0; i < count; i++) {
 705                 desc = &sc->rxq.desc[i];
 706                 data = &sc->rxq.data[i];
 707
 708                 error = bus_dmamap_create(ring->data_dmat, 0, &data->map);
 709                 if (error != 0) {
 710                         device_printf(sc->sc_dev, "could not create DMA map\n");
 711                         goto fail;
 712                 }
 713
 714                 data->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 715                 if (data->m == NULL) {
 716                         device_printf(sc->sc_dev,
 717                             "could not allocate rx mbuf\n");
 718                         error = ENOMEM;
 719                         goto fail;
 720                 }
 721
 722                 error = bus_dmamap_load(ring->data_dmat, data->map,
 723                     mtod(data->m, void *), MCLBYTES, rt2661_dma_map_addr,
 724                     &physaddr, 0);
 725                 if (error != 0) {
 726                         device_printf(sc->sc_dev,
 727                             "could not load rx buf DMA map");
 728
 729                         m_freem(data->m);
 730                         data->m = NULL;
 731                         goto fail;
 732                 }
 733
 734                 desc->flags = htole32(RT2661_RX_BUSY);
 735                 desc->physaddr = htole32(physaddr);
 736         }
 737
 738         bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_PREWRITE);
 739
 740         return 0;
 741
 742 fail:   rt2661_free_rx_ring(sc, ring);
 743         return error;
 744 }
 745
 746 static void
 747 rt2661_reset_rx_ring(struct rt2661_softc *sc, struct rt2661_rx_ring *ring)
 748 {
 749         int i;
 750
 751         for (i = 0; i < ring->count; i++)
 752                 ring->desc[i].flags = htole32(RT2661_RX_BUSY);
 753
 754         bus_dmamap_sync(ring->desc_dmat, ring->desc_map, BUS_DMASYNC_PREWRITE);
 755
 756         ring->cur = ring->next = 0;
 757 }
 758
 759 static void
 760 rt2661_free_rx_ring(struct rt2661_softc *sc, struct rt2661_rx_ring *ring)
 761 {
 762         struct rt2661_rx_data *data;
 763         int i;
 764
 765         if (ring->desc != NULL) {
 766                 bus_dmamap_sync(ring->desc_dmat, ring->desc_map,
 767                     BUS_DMASYNC_POSTWRITE);
 768                 bus_dmamap_unload(ring->desc_dmat, ring->desc_map);
 769                 bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map);
 770                 ring->desc = NULL;
 771         }
 772
 773         if (ring->desc_dmat != NULL) {
 774                 bus_dma_tag_destroy(ring->desc_dmat);
 775                 ring->desc_dmat = NULL;
 776         }
 777
 778         if (ring->data != NULL) {
 779                 for (i = 0; i < ring->count; i++) {
 780                         data = &ring->data[i];
 781
 782                         if (data->m != NULL) {
 783                                 bus_dmamap_sync(ring->data_dmat, data->map,
 784                                     BUS_DMASYNC_POSTREAD);
 785                                 bus_dmamap_unload(ring->data_dmat, data->map);
 786                                 m_freem(data->m);
 787                                 data->m = NULL;
 788                         }
 789
 790                         if (data->map != NULL) {
 791                                 bus_dmamap_destroy(ring->data_dmat, data->map);
 792                                 data->map = NULL;
 793                         }
 794                 }
 795
 796                 kfree(ring->data, M_DEVBUF);
 797                 ring->data = NULL;
 798         }
 799
 800         if (ring->data_dmat != NULL) {
 801                 bus_dma_tag_destroy(ring->data_dmat);
 802                 ring->data_dmat = NULL;
 803         }
 804 }
 805
 806 static struct ieee80211_node *
 807 rt2661_node_alloc(struct ieee80211_node_table *nt)
 808 {
 809         struct rt2661_node *rn;
 810
 811         rn = kmalloc(sizeof (struct rt2661_node), M_80211_NODE,
 812             M_NOWAIT | M_ZERO);
 813
 814         return (rn != NULL) ? &rn->ni : NULL;
 815 }
 816
 817 static int
 818 rt2661_media_change(struct ifnet *ifp)
 819 {
 820         struct rt2661_softc *sc = ifp->if_softc;
 821         int error;
 822
 823         error = ieee80211_media_change(ifp);
 824         if (error != ENETRESET)
 825                 return error;
 826
 827         if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
 828                 rt2661_init(sc);
 829         return 0;
 830 }
 831
 832 /*
 833  * This function is called periodically (every 200ms) during scanning to
 834  * switch from one channel to another.
 835  */
 836 static void
 837 rt2661_next_scan(void *arg)
 838 {
 839         struct rt2661_softc *sc = arg;
 840         struct ieee80211com *ic = &sc->sc_ic;
 841         struct ifnet *ifp = &ic->ic_if;
 842
 843         lwkt_serialize_enter(ifp->if_serializer);
 844         if (ic->ic_state == IEEE80211_S_SCAN)
 845                 ieee80211_next_scan(ic);
 846         lwkt_serialize_exit(ifp->if_serializer);
 847 }
 848
 849 /*
 850  * This function is called for each node present in the node station table.
 851  */
 852 static void
 853 rt2661_iter_func(void *arg, struct ieee80211_node *ni)
 854 {
 855         struct rt2661_node *rn = (struct rt2661_node *)ni;
 856
 857         ral_rssadapt_updatestats(&rn->rssadapt);
 858 }
 859
 860 /*
 861  * This function is called periodically (every 100ms) in RUN state to update
 862  * the rate adaptation statistics.
 863  */
 864 static void
 865 rt2661_update_rssadapt(void *arg)
 866 {
 867         struct rt2661_softc *sc = arg;
 868         struct ieee80211com *ic = &sc->sc_ic;
 869         struct ifnet *ifp = &ic->ic_if;
 870
 871         lwkt_serialize_enter(ifp->if_serializer);
 872
 873         ieee80211_iterate_nodes(&ic->ic_sta, rt2661_iter_func, arg);
 874         callout_reset(&sc->rssadapt_ch, hz / 10, rt2661_update_rssadapt, sc);
 875
 876         lwkt_serialize_exit(ifp->if_serializer);
 877 }
 878
 879 static int
 880 rt2661_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
 881 {
 882         struct rt2661_softc *sc = ic->ic_ifp->if_softc;
 883         enum ieee80211_state ostate;
 884         struct ieee80211_node *ni;
 885         uint32_t tmp;
 886         int error = 0;
 887
 888         ostate = ic->ic_state;
 889         callout_stop(&sc->scan_ch);
 890
 891         switch (nstate) {
 892         case IEEE80211_S_INIT:
 893                 callout_stop(&sc->rssadapt_ch);
 894
 895                 if (ostate == IEEE80211_S_RUN) {
 896                         /* abort TSF synchronization */
 897                         tmp = RAL_READ(sc, RT2661_TXRX_CSR9);
 898                         RAL_WRITE(sc, RT2661_TXRX_CSR9, tmp & ~0x00ffffff);
 899                 }
 900                 break;
 901
 902         case IEEE80211_S_SCAN:
 903                 rt2661_set_chan(sc, ic->ic_curchan);
 904                 callout_reset(&sc->scan_ch, (sc->dwelltime * hz) / 1000,
 905                     rt2661_next_scan, sc);
 906                 break;
 907
 908         case IEEE80211_S_AUTH:
 909         case IEEE80211_S_ASSOC:
 910                 rt2661_set_chan(sc, ic->ic_curchan);
 911                 break;
 912
 913         case IEEE80211_S_RUN:
 914                 rt2661_set_chan(sc, ic->ic_curchan);
 915
 916                 ni = ic->ic_bss;
 917
 918                 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
 919                         rt2661_enable_mrr(sc);
 920                         rt2661_set_txpreamble(sc);
 921                         rt2661_set_basicrates(sc, &ni->ni_rates);
 922                         rt2661_set_bssid(sc, ni->ni_bssid);
 923                 }
 924
 925                 if (ic->ic_opmode == IEEE80211_M_HOSTAP ||
 926                     ic->ic_opmode == IEEE80211_M_IBSS) {
 927                         if ((error = rt2661_prepare_beacon(sc)) != 0)
 928                                 break;
 929                 }
 930
 931                 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
 932                         callout_reset(&sc->rssadapt_ch, hz / 10,
 933                             rt2661_update_rssadapt, sc);
 934                         rt2661_enable_tsf_sync(sc);
 935                 }
 936                 break;
 937         }
 938
 939         return (error != 0) ? error : sc->sc_newstate(ic, nstate, arg);
 940 }
 941
 942 /*
 943  * Read 16 bits at address 'addr' from the serial EEPROM (either 93C46 or
 944  * 93C66).
 945  */
 946 static uint16_t
 947 rt2661_eeprom_read(struct rt2661_softc *sc, uint8_t addr)
 948 {
 949         uint32_t tmp;
 950         uint16_t val;
 951         int n;
 952
 953         /* clock C once before the first command */
 954         RT2661_EEPROM_CTL(sc, 0);
 955
 956         RT2661_EEPROM_CTL(sc, RT2661_S);
 957         RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_C);
 958         RT2661_EEPROM_CTL(sc, RT2661_S);
 959
 960         /* write start bit (1) */
 961         RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_D);
 962         RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_D | RT2661_C);
 963
 964         /* write READ opcode (10) */
 965         RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_D);
 966         RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_D | RT2661_C);
 967         RT2661_EEPROM_CTL(sc, RT2661_S);
 968         RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_C);
 969
 970         /* write address (A5-A0 or A7-A0) */
 971         n = (RAL_READ(sc, RT2661_E2PROM_CSR) & RT2661_93C46) ? 5 : 7;
 972         for (; n >= 0; n--) {
 973                 RT2661_EEPROM_CTL(sc, RT2661_S |
 974                     (((addr >> n) & 1) << RT2661_SHIFT_D));
 975                 RT2661_EEPROM_CTL(sc, RT2661_S |
 976                     (((addr >> n) & 1) << RT2661_SHIFT_D) | RT2661_C);
 977         }
 978
 979         RT2661_EEPROM_CTL(sc, RT2661_S);
 980
 981         /* read data Q15-Q0 */
 982         val = 0;
 983         for (n = 15; n >= 0; n--) {
 984                 RT2661_EEPROM_CTL(sc, RT2661_S | RT2661_C);
 985                 tmp = RAL_READ(sc, RT2661_E2PROM_CSR);
 986                 val |= ((tmp & RT2661_Q) >> RT2661_SHIFT_Q) << n;
 987                 RT2661_EEPROM_CTL(sc, RT2661_S);
 988         }
 989
 990         RT2661_EEPROM_CTL(sc, 0);
 991
 992         /* clear Chip Select and clock C */
 993         RT2661_EEPROM_CTL(sc, RT2661_S);
 994         RT2661_EEPROM_CTL(sc, 0);
 995         RT2661_EEPROM_CTL(sc, RT2661_C);
 996
 997         return val;
 998 }
 999
1000 static void
1001 rt2661_tx_intr(struct rt2661_softc *sc)
1002 {
1003         struct ieee80211com *ic = &sc->sc_ic;
1004         struct ifnet *ifp = ic->ic_ifp;
1005         struct rt2661_tx_ring *txq;
1006         struct rt2661_tx_data *data;
1007         struct rt2661_node *rn;
1008         uint32_t val;
1009         int qid, retrycnt;
1010
1011         for (;;) {
1012                 val = RAL_READ(sc, RT2661_STA_CSR4);
1013                 if (!(val & RT2661_TX_STAT_VALID))
1014                         break;
1015
1016                 /* retrieve the queue in which this frame was sent */
1017                 qid = RT2661_TX_QID(val);
1018                 txq = (qid <= 3) ? &sc->txq[qid] : &sc->mgtq;
1019
1020                 /* retrieve rate control algorithm context */
1021                 data = &txq->data[txq->stat];
1022                 rn = (struct rt2661_node *)data->ni;
1023
1024                 switch (RT2661_TX_RESULT(val)) {
1025                 case RT2661_TX_SUCCESS:
1026                         retrycnt = RT2661_TX_RETRYCNT(val);
1027
1028                         DPRINTFN(10, ("data frame sent successfully after "
1029                             "%d retries\n", retrycnt));
1030                         if (retrycnt == 0 && data->id.id_node != NULL) {
1031                                 ral_rssadapt_raise_rate(ic, &rn->rssadapt,
1032                                     &data->id);
1033                         }
1034                         ifp->if_opackets++;
1035                         break;
1036
1037                 case RT2661_TX_RETRY_FAIL:
1038                         DPRINTFN(9, ("sending data frame failed (too much "
1039                             "retries)\n"));
1040                         if (data->id.id_node != NULL) {
1041                                 ral_rssadapt_lower_rate(ic, data->ni,
1042                                     &rn->rssadapt, &data->id);
1043                         }
1044                         ifp->if_oerrors++;
1045                         break;
1046
1047                 default:
1048                         /* other failure */
1049                         device_printf(sc->sc_dev,
1050                             "sending data frame failed 0x%08x\n", val);
1051                         ifp->if_oerrors++;
1052                 }
1053
1054                 ieee80211_free_node(data->ni);
1055                 data->ni = NULL;
1056
1057                 DPRINTFN(15, ("tx done q=%d idx=%u\n", qid, txq->stat));
1058
1059                 txq->queued--;
1060                 if (++txq->stat >= txq->count)  /* faster than % count */
1061                         txq->stat = 0;
1062         }
1063
1064         sc->sc_tx_timer = 0;
1065         ifp->if_flags &= ~IFF_OACTIVE;
1066         rt2661_start(ifp);
1067 }
1068
1069 static void
1070 rt2661_tx_dma_intr(struct rt2661_softc *sc, struct rt2661_tx_ring *txq)
1071 {
1072         struct rt2661_tx_desc *desc;
1073         struct rt2661_tx_data *data;
1074
1075         bus_dmamap_sync(txq->desc_dmat, txq->desc_map, BUS_DMASYNC_POSTREAD);
1076
1077         for (;;) {
1078                 desc = &txq->desc[txq->next];
1079                 data = &txq->data[txq->next];
1080
1081                 if ((le32toh(desc->flags) & RT2661_TX_BUSY) ||
1082                     !(le32toh(desc->flags) & RT2661_TX_VALID))
1083                         break;
1084
1085                 bus_dmamap_sync(txq->data_dmat, data->map,
1086                     BUS_DMASYNC_POSTWRITE);
1087                 bus_dmamap_unload(txq->data_dmat, data->map);
1088                 m_freem(data->m);
1089                 data->m = NULL;
1090                 /* node reference is released in rt2661_tx_intr() */
1091
1092                 /* descriptor is no longer valid */
1093                 desc->flags &= ~htole32(RT2661_TX_VALID);
1094
1095                 DPRINTFN(15, ("tx dma done q=%p idx=%u\n", txq, txq->next));
1096
1097                 if (++txq->next >= txq->count)  /* faster than % count */
1098                         txq->next = 0;
1099         }
1100
1101         bus_dmamap_sync(txq->desc_dmat, txq->desc_map, BUS_DMASYNC_PREWRITE);
1102 }
1103
1104 static void
1105 rt2661_rx_intr(struct rt2661_softc *sc)
1106 {
1107         struct ieee80211com *ic = &sc->sc_ic;
1108         struct ifnet *ifp = ic->ic_ifp;
1109         struct rt2661_rx_desc *desc;
1110         struct rt2661_rx_data *data;
1111         bus_addr_t physaddr;
1112         struct ieee80211_frame *wh;
1113         struct ieee80211_node *ni;
1114         struct rt2661_node *rn;
1115         struct mbuf *mnew, *m;
1116         int error;
1117
1118         bus_dmamap_sync(sc->rxq.desc_dmat, sc->rxq.desc_map,
1119             BUS_DMASYNC_POSTREAD);
1120
1121         for (;;) {
1122                 desc = &sc->rxq.desc[sc->rxq.cur];
1123                 data = &sc->rxq.data[sc->rxq.cur];
1124
1125                 if (le32toh(desc->flags) & RT2661_RX_BUSY)
1126                         break;
1127
1128                 if ((le32toh(desc->flags) & RT2661_RX_PHY_ERROR) ||
1129                     (le32toh(desc->flags) & RT2661_RX_CRC_ERROR)) {
1130                         /*
1131                          * This should not happen since we did not request
1132                          * to receive those frames when we filled TXRX_CSR0.
1133                          */
1134                         DPRINTFN(5, ("PHY or CRC error flags 0x%08x\n",
1135                             le32toh(desc->flags)));
1136                         ifp->if_ierrors++;
1137                         goto skip;
1138                 }
1139
1140                 if ((le32toh(desc->flags) & RT2661_RX_CIPHER_MASK) != 0) {
1141                         ifp->if_ierrors++;
1142                         goto skip;
1143                 }
1144
1145                 /*
1146                  * Try to allocate a new mbuf for this ring element and load it
1147                  * before processing the current mbuf. If the ring element
1148                  * cannot be loaded, drop the received packet and reuse the old
1149                  * mbuf. In the unlikely case that the old mbuf can't be
1150                  * reloaded either, explicitly panic.
1151                  */
1152                 mnew = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
1153                 if (mnew == NULL) {
1154                         ifp->if_ierrors++;
1155                         goto skip;
1156                 }
1157
1158                 bus_dmamap_sync(sc->rxq.data_dmat, data->map,
1159                     BUS_DMASYNC_POSTREAD);
1160                 bus_dmamap_unload(sc->rxq.data_dmat, data->map);
1161
1162                 error = bus_dmamap_load(sc->rxq.data_dmat, data->map,
1163                     mtod(mnew, void *), MCLBYTES, rt2661_dma_map_addr,
1164                     &physaddr, 0);
1165                 if (error != 0) {
1166                         m_freem(mnew);
1167
1168                         /* try to reload the old mbuf */
1169                         error = bus_dmamap_load(sc->rxq.data_dmat, data->map,
1170                             mtod(data->m, void *), MCLBYTES,
1171                             rt2661_dma_map_addr, &physaddr, 0);
1172                         if (error != 0) {
1173                                 /* very unlikely that it will fail... */
1174                                 panic("%s: could not load old rx mbuf",
1175                                     device_get_name(sc->sc_dev));
1176                         }
1177                         ifp->if_ierrors++;
1178                         goto skip;
1179                 }
1180
1181                 /*
1182                  * New mbuf successfully loaded, update Rx ring and continue
1183                  * processing.
1184                  */
1185                 m = data->m;
1186                 data->m = mnew;
1187                 desc->physaddr = htole32(physaddr);
1188
1189                 /* finalize mbuf */
1190                 m->m_pkthdr.rcvif = ifp;
1191                 m->m_pkthdr.len = m->m_len =
1192                     (le32toh(desc->flags) >> 16) & 0xfff;
1193
1194                 if (sc->sc_drvbpf != NULL) {
1195                         struct rt2661_rx_radiotap_header *tap = &sc->sc_rxtap;
1196                         uint32_t tsf_lo, tsf_hi;
1197
1198                         /* get timestamp (low and high 32 bits) */
1199                         tsf_hi = RAL_READ(sc, RT2661_TXRX_CSR13);
1200                         tsf_lo = RAL_READ(sc, RT2661_TXRX_CSR12);
1201
1202                         tap->wr_tsf =
1203                             htole64(((uint64_t)tsf_hi << 32) | tsf_lo);
1204                         tap->wr_flags = 0;
1205                         tap->wr_rate = rt2661_rxrate(desc);
1206                         tap->wr_chan_freq = htole16(ic->ic_curchan->ic_freq);
1207                         tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags);
1208                         tap->wr_antsignal = desc->rssi;
1209
1210                         bpf_ptap(sc->sc_drvbpf, m, tap, sc->sc_rxtap_len);
1211                 }
1212
1213                 wh = mtod(m, struct ieee80211_frame *);
1214                 ni = ieee80211_find_rxnode(ic,
1215                     (struct ieee80211_frame_min *)wh);
1216
1217                 /* send the frame to the 802.11 layer */
1218                 ieee80211_input(ic, m, ni, desc->rssi, 0);
1219
1220                 /* give rssi to the rate adatation algorithm */
1221                 rn = (struct rt2661_node *)ni;
1222                 ral_rssadapt_input(ic, ni, &rn->rssadapt,
1223                     rt2661_get_rssi(sc, desc->rssi));
1224
1225                 /* node is no longer needed */
1226                 ieee80211_free_node(ni);
1227
1228 skip:           desc->flags |= htole32(RT2661_RX_BUSY);
1229
1230                 DPRINTFN(15, ("rx intr idx=%u\n", sc->rxq.cur));
1231
1232                 sc->rxq.cur = (sc->rxq.cur + 1) % RT2661_RX_RING_COUNT;
1233         }
1234
1235         bus_dmamap_sync(sc->rxq.desc_dmat, sc->rxq.desc_map,
1236             BUS_DMASYNC_PREWRITE);
1237 }
1238
1239 /* ARGSUSED */
1240 static void
1241 rt2661_mcu_beacon_expire(struct rt2661_softc *sc)
1242 {
1243         /* do nothing */
1244 }
1245
1246 static void
1247 rt2661_mcu_wakeup(struct rt2661_softc *sc)
1248 {
1249         RAL_WRITE(sc, RT2661_MAC_CSR11, 5 << 16);
1250
1251         RAL_WRITE(sc, RT2661_SOFT_RESET_CSR, 0x7);
1252         RAL_WRITE(sc, RT2661_IO_CNTL_CSR, 0x18);
1253         RAL_WRITE(sc, RT2661_PCI_USEC_CSR, 0x20);
1254
1255         /* send wakeup command to MCU */
1256         rt2661_tx_cmd(sc, RT2661_MCU_CMD_WAKEUP, 0);
1257 }
1258
1259 static void
1260 rt2661_mcu_cmd_intr(struct rt2661_softc *sc)
1261 {
1262         RAL_READ(sc, RT2661_M2H_CMD_DONE_CSR);
1263         RAL_WRITE(sc, RT2661_M2H_CMD_DONE_CSR, 0xffffffff);
1264 }
1265
1266 static void
1267 rt2661_intr(void *arg)
1268 {
1269         struct rt2661_softc *sc = arg;
1270         struct ifnet *ifp = &sc->sc_ic.ic_if;
1271         uint32_t r1, r2;
1272
1273         /* disable MAC and MCU interrupts */
1274         RAL_WRITE(sc, RT2661_INT_MASK_CSR, 0xffffff7f);
1275         RAL_WRITE(sc, RT2661_MCU_INT_MASK_CSR, 0xffffffff);
1276
1277         /* don't re-enable interrupts if we're shutting down */
1278         if (!(ifp->if_flags & IFF_RUNNING))
1279                 return;
1280
1281         r1 = RAL_READ(sc, RT2661_INT_SOURCE_CSR);
1282         RAL_WRITE(sc, RT2661_INT_SOURCE_CSR, r1);
1283
1284         r2 = RAL_READ(sc, RT2661_MCU_INT_SOURCE_CSR);
1285         RAL_WRITE(sc, RT2661_MCU_INT_SOURCE_CSR, r2);
1286
1287         if (r1 & RT2661_MGT_DONE)
1288                 rt2661_tx_dma_intr(sc, &sc->mgtq);
1289
1290         if (r1 & RT2661_RX_DONE)
1291                 rt2661_rx_intr(sc);
1292
1293         if (r1 & RT2661_TX0_DMA_DONE)
1294                 rt2661_tx_dma_intr(sc, &sc->txq[0]);
1295
1296         if (r1 & RT2661_TX1_DMA_DONE)
1297                 rt2661_tx_dma_intr(sc, &sc->txq[1]);
1298
1299         if (r1 & RT2661_TX2_DMA_DONE)
1300                 rt2661_tx_dma_intr(sc, &sc->txq[2]);
1301
1302         if (r1 & RT2661_TX3_DMA_DONE)
1303                 rt2661_tx_dma_intr(sc, &sc->txq[3]);
1304
1305         if (r1 & RT2661_TX_DONE)
1306                 rt2661_tx_intr(sc);
1307
1308         if (r2 & RT2661_MCU_CMD_DONE)
1309                 rt2661_mcu_cmd_intr(sc);
1310
1311         if (r2 & RT2661_MCU_BEACON_EXPIRE)
1312                 rt2661_mcu_beacon_expire(sc);
1313
1314         if (r2 & RT2661_MCU_WAKEUP)
1315                 rt2661_mcu_wakeup(sc);
1316
1317         /* re-enable MAC and MCU interrupts */
1318         RAL_WRITE(sc, RT2661_INT_MASK_CSR, 0x0000ff10);
1319         RAL_WRITE(sc, RT2661_MCU_INT_MASK_CSR, 0);
1320 }
1321
1322 /* quickly determine if a given rate is CCK or OFDM */
1323 #define RAL_RATE_IS_OFDM(rate) ((rate) >= 12 && (rate) != 22)
1324
1325 #define RAL_ACK_SIZE    14      /* 10 + 4(FCS) */
1326 #define RAL_CTS_SIZE    14      /* 10 + 4(FCS) */
1327
1328 #define RAL_SIFS        10      /* us */
1329
1330 /*
1331  * This function is only used by the Rx radiotap code. It returns the rate at
1332  * which a given frame was received.
1333  */
1334 static uint8_t
1335 rt2661_rxrate(struct rt2661_rx_desc *desc)
1336 {
1337         if (le32toh(desc->flags) & RT2661_RX_OFDM) {
1338                 /* reverse function of rt2661_plcp_signal */
1339                 switch (desc->rate & 0xf) {
1340                 case 0xb:       return 12;
1341                 case 0xf:       return 18;
1342                 case 0xa:       return 24;
1343                 case 0xe:       return 36;
1344                 case 0x9:       return 48;
1345                 case 0xd:       return 72;
1346                 case 0x8:       return 96;
1347                 case 0xc:       return 108;
1348                 }
1349         } else {
1350                 if (desc->rate == 10)
1351                         return 2;
1352                 if (desc->rate == 20)
1353                         return 4;
1354                 if (desc->rate == 55)
1355                         return 11;
1356                 if (desc->rate == 110)
1357                         return 22;
1358         }
1359         return 2;       /* should not get there */
1360 }
1361
1362 /*
1363  * Return the expected ack rate for a frame transmitted at rate `rate'.
1364  * XXX: this should depend on the destination node basic rate set.
1365  */
1366 static int
1367 rt2661_ack_rate(struct ieee80211com *ic, int rate)
1368 {
1369         switch (rate) {
1370         /* CCK rates */
1371         case 2:
1372                 return 2;
1373         case 4:
1374         case 11:
1375         case 22:
1376                 return (ic->ic_curmode == IEEE80211_MODE_11B) ? 4 : rate;
1377
1378         /* OFDM rates */
1379         case 12:
1380         case 18:
1381                 return 12;
1382         case 24:
1383         case 36:
1384                 return 24;
1385         case 48:
1386         case 72:
1387         case 96:
1388         case 108:
1389                 return 48;
1390         }
1391
1392         /* default to 1Mbps */
1393         return 2;
1394 }
1395
1396 /*
1397  * Compute the duration (in us) needed to transmit `len' bytes at rate `rate'.
1398  * The function automatically determines the operating mode depending on the
1399  * given rate. `flags' indicates whether short preamble is in use or not.
1400  */
1401 static uint16_t
1402 rt2661_txtime(int len, int rate, uint32_t flags)
1403 {
1404         uint16_t txtime;
1405
1406         if (RAL_RATE_IS_OFDM(rate)) {
1407                 /* IEEE Std 802.11a-1999, pp. 37 */
1408                 txtime = (8 + 4 * len + 3 + rate - 1) / rate;
1409                 txtime = 16 + 4 + 4 * txtime + 6;
1410         } else {
1411                 /* IEEE Std 802.11b-1999, pp. 28 */
1412                 txtime = (16 * len + rate - 1) / rate;
1413                 if (rate != 2 && (flags & IEEE80211_F_SHPREAMBLE))
1414                         txtime +=  72 + 24;
1415                 else
1416                         txtime += 144 + 48;
1417         }
1418
1419         return txtime;
1420 }
1421
1422 static uint8_t
1423 rt2661_plcp_signal(int rate)
1424 {
1425         switch (rate) {
1426         /* CCK rates (returned values are device-dependent) */
1427         case 2:         return 0x0;
1428         case 4:         return 0x1;
1429         case 11:        return 0x2;
1430         case 22:        return 0x3;
1431
1432         /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
1433         case 12:        return 0xb;
1434         case 18:        return 0xf;
1435         case 24:        return 0xa;
1436         case 36:        return 0xe;
1437         case 48:        return 0x9;
1438         case 72:        return 0xd;
1439         case 96:        return 0x8;
1440         case 108:       return 0xc;
1441
1442         /* unsupported rates (should not get there) */
1443         default:        return 0xff;
1444         }
1445 }
1446
1447 static void
1448 rt2661_setup_tx_desc(struct rt2661_softc *sc, struct rt2661_tx_desc *desc,
1449     uint32_t flags, uint16_t xflags, int len, int rate,
1450     const bus_dma_segment_t *segs, int nsegs, int ac)
1451 {
1452         struct ieee80211com *ic = &sc->sc_ic;
1453         uint16_t plcp_length;
1454         int i, remainder;
1455
1456         desc->flags = htole32(flags);
1457         desc->flags |= htole32(len << 16);
1458         desc->flags |= htole32(RT2661_TX_BUSY | RT2661_TX_VALID);
1459
1460         desc->xflags = htole16(xflags);
1461         desc->xflags |= htole16(nsegs << 13);
1462
1463         desc->wme = htole16(
1464             RT2661_QID(ac) |
1465             RT2661_AIFSN(2) |
1466             RT2661_LOGCWMIN(4) |
1467             RT2661_LOGCWMAX(10));
1468
1469         /*
1470          * Remember in which queue this frame was sent. This field is driver
1471          * private data only. It will be made available by the NIC in STA_CSR4
1472          * on Tx interrupts.
1473          */
1474         desc->qid = ac;
1475
1476         /* setup PLCP fields */
1477         desc->plcp_signal  = rt2661_plcp_signal(rate);
1478         desc->plcp_service = 4;
1479
1480         len += IEEE80211_CRC_LEN;
1481         if (RAL_RATE_IS_OFDM(rate)) {
1482                 desc->flags |= htole32(RT2661_TX_OFDM);
1483
1484                 plcp_length = len & 0xfff;
1485                 desc->plcp_length_hi = plcp_length >> 6;
1486                 desc->plcp_length_lo = plcp_length & 0x3f;
1487         } else {
1488                 plcp_length = (16 * len + rate - 1) / rate;
1489                 if (rate == 22) {
1490                         remainder = (16 * len) % 22;
1491                         if (remainder != 0 && remainder < 7)
1492                                 desc->plcp_service |= RT2661_PLCP_LENGEXT;
1493                 }
1494                 desc->plcp_length_hi = plcp_length >> 8;
1495                 desc->plcp_length_lo = plcp_length & 0xff;
1496
1497                 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
1498                         desc->plcp_signal |= 0x08;
1499         }
1500
1501         /* RT2x61 supports scatter with up to 5 segments */
1502         for (i = 0; i < nsegs; i++) {
1503                 desc->addr[i] = htole32(segs[i].ds_addr);
1504                 desc->len [i] = htole16(segs[i].ds_len);
1505         }
1506 }
1507
1508 static int
1509 rt2661_tx_mgt(struct rt2661_softc *sc, struct mbuf *m0,
1510     struct ieee80211_node *ni)
1511 {
1512         struct ieee80211com *ic = &sc->sc_ic;
1513         struct rt2661_tx_desc *desc;
1514         struct rt2661_tx_data *data;
1515         struct ieee80211_frame *wh;
1516         struct rt2661_dmamap map;
1517         uint16_t dur;
1518         uint32_t flags = 0;     /* XXX HWSEQ */
1519         int rate, error;
1520
1521         desc = &sc->mgtq.desc[sc->mgtq.cur];
1522         data = &sc->mgtq.data[sc->mgtq.cur];
1523
1524         /* send mgt frames at the lowest available rate */
1525         rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
1526
1527         error = bus_dmamap_load_mbuf(sc->mgtq.data_dmat, data->map, m0,
1528                                      rt2661_dma_map_mbuf, &map, 0);
1529         if (error != 0) {
1530                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
1531                     error);
1532                 m_freem(m0);
1533                 return error;
1534         }
1535
1536         if (sc->sc_drvbpf != NULL) {
1537                 struct rt2661_tx_radiotap_header *tap = &sc->sc_txtap;
1538
1539                 tap->wt_flags = 0;
1540                 tap->wt_rate = rate;
1541                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
1542                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
1543
1544                 bpf_ptap(sc->sc_drvbpf, m0, tap, sc->sc_txtap_len);
1545         }
1546
1547         data->m = m0;
1548         data->ni = ni;
1549
1550         wh = mtod(m0, struct ieee80211_frame *);
1551
1552         if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1553                 flags |= RT2661_TX_NEED_ACK;
1554
1555                 dur = rt2661_txtime(RAL_ACK_SIZE, rate, ic->ic_flags) +
1556                     RAL_SIFS;
1557                 *(uint16_t *)wh->i_dur = htole16(dur);
1558
1559                 /* tell hardware to add timestamp in probe responses */
1560                 if ((wh->i_fc[0] &
1561                     (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
1562                     (IEEE80211_FC0_TYPE_MGT | IEEE80211_FC0_SUBTYPE_PROBE_RESP))
1563                         flags |= RT2661_TX_TIMESTAMP;
1564         }
1565
1566         rt2661_setup_tx_desc(sc, desc, flags, 0 /* XXX HWSEQ */,
1567             m0->m_pkthdr.len, rate, map.segs, map.nseg, RT2661_QID_MGT);
1568
1569         bus_dmamap_sync(sc->mgtq.data_dmat, data->map, BUS_DMASYNC_PREWRITE);
1570         bus_dmamap_sync(sc->mgtq.desc_dmat, sc->mgtq.desc_map,
1571             BUS_DMASYNC_PREWRITE);
1572
1573         DPRINTFN(10, ("sending mgt frame len=%u idx=%u rate=%u\n",
1574             m0->m_pkthdr.len, sc->mgtq.cur, rate));
1575
1576         /* kick mgt */
1577         sc->mgtq.queued++;
1578         sc->mgtq.cur = (sc->mgtq.cur + 1) % RT2661_MGT_RING_COUNT;
1579         RAL_WRITE(sc, RT2661_TX_CNTL_CSR, RT2661_KICK_MGT);
1580
1581         return 0;
1582 }
1583
1584 /*
1585  * Build a RTS control frame.
1586  */
1587 static struct mbuf *
1588 rt2661_get_rts(struct rt2661_softc *sc, struct ieee80211_frame *wh,
1589     uint16_t dur)
1590 {
1591         struct ieee80211_frame_rts *rts;
1592         struct mbuf *m;
1593
1594         MGETHDR(m, MB_DONTWAIT, MT_DATA);
1595         if (m == NULL) {
1596                 sc->sc_ic.ic_stats.is_tx_nobuf++;
1597                 device_printf(sc->sc_dev, "could not allocate RTS frame\n");
1598                 return NULL;
1599         }
1600
1601         rts = mtod(m, struct ieee80211_frame_rts *);
1602
1603         rts->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_CTL |
1604             IEEE80211_FC0_SUBTYPE_RTS;
1605         rts->i_fc[1] = IEEE80211_FC1_DIR_NODS;
1606         *(uint16_t *)rts->i_dur = htole16(dur);
1607         IEEE80211_ADDR_COPY(rts->i_ra, wh->i_addr1);
1608         IEEE80211_ADDR_COPY(rts->i_ta, wh->i_addr2);
1609
1610         m->m_pkthdr.len = m->m_len = sizeof (struct ieee80211_frame_rts);
1611
1612         return m;
1613 }
1614
1615 static int
1616 rt2661_tx_data(struct rt2661_softc *sc, struct mbuf *m0,
1617     struct ieee80211_node *ni, int ac)
1618 {
1619         struct ieee80211com *ic = &sc->sc_ic;
1620         struct rt2661_tx_ring *txq = &sc->txq[ac];
1621         struct rt2661_tx_desc *desc;
1622         struct rt2661_tx_data *data;
1623         struct rt2661_node *rn;
1624         struct ieee80211_rateset *rs;
1625         struct ieee80211_frame *wh;
1626         struct ieee80211_key *k;
1627         const struct chanAccParams *cap;
1628         struct mbuf *mnew;
1629         struct rt2661_dmamap map;
1630         uint16_t dur;
1631         uint32_t flags = 0;
1632         int error, rate, noack = 0;
1633
1634         wh = mtod(m0, struct ieee80211_frame *);
1635
1636         if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) {
1637                 rs = &ic->ic_sup_rates[ic->ic_curmode];
1638                 rate = rs->rs_rates[ic->ic_fixed_rate];
1639         } else {
1640                 rs = &ni->ni_rates;
1641                 rn = (struct rt2661_node *)ni;
1642                 ni->ni_txrate = ral_rssadapt_choose(&rn->rssadapt, rs,
1643                     wh, m0->m_pkthdr.len, NULL, 0);
1644                 rate = rs->rs_rates[ni->ni_txrate];
1645         }
1646         rate &= IEEE80211_RATE_VAL;
1647
1648         if (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_QOS) {
1649                 cap = &ic->ic_wme.wme_chanParams;
1650                 noack = cap->cap_wmeParams[ac].wmep_noackPolicy;
1651         }
1652
1653         if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
1654                 k = ieee80211_crypto_encap(ic, ni, m0);
1655                 if (k == NULL) {
1656                         m_freem(m0);
1657                         return ENOBUFS;
1658                 }
1659
1660                 /* packet header may have moved, reset our local pointer */
1661                 wh = mtod(m0, struct ieee80211_frame *);
1662         }
1663
1664         /*
1665          * IEEE Std 802.11-1999, pp 82: "A STA shall use an RTS/CTS exchange
1666          * for directed frames only when the length of the MPDU is greater
1667          * than the length threshold indicated by [...]" ic_rtsthreshold.
1668          */
1669         if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
1670             m0->m_pkthdr.len > ic->ic_rtsthreshold) {
1671                 struct mbuf *m;
1672                 uint16_t dur;
1673                 int rtsrate, ackrate;
1674
1675                 rtsrate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
1676                 ackrate = rt2661_ack_rate(ic, rate);
1677
1678                 dur = rt2661_txtime(m0->m_pkthdr.len + 4, rate, ic->ic_flags) +
1679                       rt2661_txtime(RAL_CTS_SIZE, rtsrate, ic->ic_flags) +
1680                       /* XXX: noack (QoS)? */
1681                       rt2661_txtime(RAL_ACK_SIZE, ackrate, ic->ic_flags) +
1682                       3 * RAL_SIFS;
1683
1684                 m = rt2661_get_rts(sc, wh, dur);
1685
1686                 desc = &txq->desc[txq->cur];
1687                 data = &txq->data[txq->cur];
1688
1689                 error = bus_dmamap_load_mbuf(txq->data_dmat, data->map, m,
1690                                              rt2661_dma_map_mbuf, &map, 0);
1691                 if (error != 0) {
1692                         device_printf(sc->sc_dev,
1693                             "could not map mbuf (error %d)\n", error);
1694                         m_freem(m);
1695                         m_freem(m0);
1696                         return error;
1697                 }
1698
1699                 /* avoid multiple free() of the same node for each fragment */
1700                 ieee80211_ref_node(ni);
1701
1702                 data->m = m;
1703                 data->ni = ni;
1704
1705                 /* RTS frames are not taken into account for rssadapt */
1706                 data->id.id_node = NULL;
1707
1708                 rt2661_setup_tx_desc(sc, desc, RT2661_TX_NEED_ACK |
1709                                      RT2661_TX_MORE_FRAG, 0, m->m_pkthdr.len,
1710                                      rtsrate, map.segs, map.nseg, ac);
1711
1712                 bus_dmamap_sync(txq->data_dmat, data->map,
1713                     BUS_DMASYNC_PREWRITE);
1714
1715                 txq->queued++;
1716                 txq->cur = (txq->cur + 1) % RT2661_TX_RING_COUNT;
1717
1718                 /*
1719                  * IEEE Std 802.11-1999: when an RTS/CTS exchange is used, the
1720                  * asynchronous data frame shall be transmitted after the CTS
1721                  * frame and a SIFS period.
1722                  */
1723                 flags |= RT2661_TX_LONG_RETRY | RT2661_TX_IFS;
1724         }
1725
1726         data = &txq->data[txq->cur];
1727         desc = &txq->desc[txq->cur];
1728
1729         error = bus_dmamap_load_mbuf(txq->data_dmat, data->map, m0,
1730                                      rt2661_dma_map_mbuf, &map, 0);
1731         if (error != 0 && error != EFBIG) {
1732                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
1733                     error);
1734                 m_freem(m0);
1735                 return error;
1736         }
1737         if (error != 0) {
1738                 mnew = m_defrag(m0, MB_DONTWAIT);
1739                 if (mnew == NULL) {
1740                         device_printf(sc->sc_dev,
1741                             "could not defragment mbuf\n");
1742                         m_freem(m0);
1743                         return ENOBUFS;
1744                 }
1745                 m0 = mnew;
1746
1747                 error = bus_dmamap_load_mbuf(txq->data_dmat, data->map, m0,
1748                                              rt2661_dma_map_mbuf, &map, 0);
1749                 if (error != 0) {
1750                         device_printf(sc->sc_dev,
1751                             "could not map mbuf (error %d)\n", error);
1752                         m_freem(m0);
1753                         return error;
1754                 }
1755
1756                 /* packet header have moved, reset our local pointer */
1757                 wh = mtod(m0, struct ieee80211_frame *);
1758         }
1759
1760         if (sc->sc_drvbpf != NULL) {
1761                 struct rt2661_tx_radiotap_header *tap = &sc->sc_txtap;
1762
1763                 tap->wt_flags = 0;
1764                 tap->wt_rate = rate;
1765                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
1766                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
1767
1768                 bpf_ptap(sc->sc_drvbpf, m0, tap, sc->sc_txtap_len);
1769         }
1770
1771         data->m = m0;
1772         data->ni = ni;
1773
1774         /* remember link conditions for rate adaptation algorithm */
1775         if (ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) {
1776                 data->id.id_len = m0->m_pkthdr.len;
1777                 data->id.id_rateidx = ni->ni_txrate;
1778                 data->id.id_node = ni;
1779                 data->id.id_rssi = ni->ni_rssi;
1780         } else
1781                 data->id.id_node = NULL;
1782
1783         if (!noack && !IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1784                 flags |= RT2661_TX_NEED_ACK;
1785
1786                 dur = rt2661_txtime(RAL_ACK_SIZE, rt2661_ack_rate(ic, rate),
1787                     ic->ic_flags) + RAL_SIFS;
1788                 *(uint16_t *)wh->i_dur = htole16(dur);
1789         }
1790
1791         rt2661_setup_tx_desc(sc, desc, flags, 0, m0->m_pkthdr.len, rate,
1792                              map.segs, map.nseg, ac);
1793
1794         bus_dmamap_sync(txq->data_dmat, data->map, BUS_DMASYNC_PREWRITE);
1795         bus_dmamap_sync(txq->desc_dmat, txq->desc_map, BUS_DMASYNC_PREWRITE);
1796
1797         DPRINTFN(10, ("sending data frame len=%u idx=%u rate=%u\n",
1798             m0->m_pkthdr.len, txq->cur, rate));
1799
1800         /* kick Tx */
1801         txq->queued++;
1802         txq->cur = (txq->cur + 1) % RT2661_TX_RING_COUNT;
1803         RAL_WRITE(sc, RT2661_TX_CNTL_CSR, 1 << ac);
1804
1805         return 0;
1806 }
1807
1808 static void
1809 rt2661_start(struct ifnet *ifp)
1810 {
1811         struct rt2661_softc *sc = ifp->if_softc;
1812         struct ieee80211com *ic = &sc->sc_ic;
1813         struct mbuf *m0;
1814         struct ether_header *eh;
1815         struct ieee80211_node *ni;
1816         int ac;
1817
1818         /* prevent management frames from being sent if we're not ready */
1819         if (!(ifp->if_flags & IFF_RUNNING))
1820                 return;
1821
1822         for (;;) {
1823                 IF_POLL(&ic->ic_mgtq, m0);
1824                 if (m0 != NULL) {
1825                         if (sc->mgtq.queued >= RT2661_MGT_RING_COUNT) {
1826                                 ifp->if_flags |= IFF_OACTIVE;
1827                                 break;
1828                         }
1829                         IF_DEQUEUE(&ic->ic_mgtq, m0);
1830
1831                         ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
1832                         m0->m_pkthdr.rcvif = NULL;
1833
1834                         if (ic->ic_rawbpf != NULL)
1835                                 bpf_mtap(ic->ic_rawbpf, m0);
1836
1837                         if (rt2661_tx_mgt(sc, m0, ni) != 0)
1838                                 break;
1839
1840                 } else {
1841                         if (ic->ic_state != IEEE80211_S_RUN)
1842                                 break;
1843
1844                         m0 = ifq_dequeue(&ifp->if_snd, NULL);
1845                         if (m0 == NULL)
1846                                 break;
1847
1848                         if (m0->m_len < sizeof (struct ether_header) &&
1849                             !(m0 = m_pullup(m0, sizeof (struct ether_header))))
1850                                 continue;
1851
1852                         eh = mtod(m0, struct ether_header *);
1853                         ni = ieee80211_find_txnode(ic, eh->ether_dhost);
1854                         if (ni == NULL) {
1855                                 m_freem(m0);
1856                                 ifp->if_oerrors++;
1857                                 continue;
1858                         }
1859
1860                         /* classify mbuf so we can find which tx ring to use */
1861                         if (ieee80211_classify(ic, m0, ni) != 0) {
1862                                 m_freem(m0);
1863                                 ieee80211_free_node(ni);
1864                                 ifp->if_oerrors++;
1865                                 continue;
1866                         }
1867
1868                         /* no QoS encapsulation for EAPOL frames */
1869                         ac = (eh->ether_type != htons(ETHERTYPE_PAE)) ?
1870                             M_WME_GETAC(m0) : WME_AC_BE;
1871
1872                         if (sc->txq[ac].queued >= RT2661_TX_RING_COUNT - 1) {
1873                                 /* there is no place left in this ring */
1874                                 ifp->if_flags |= IFF_OACTIVE;
1875                                 m_freem(m0);
1876                                 ieee80211_free_node(ni);
1877                                 break;
1878                         }
1879
1880                         BPF_MTAP(ifp, m0);
1881
1882                         m0 = ieee80211_encap(ic, m0, ni);
1883                         if (m0 == NULL) {
1884                                 ieee80211_free_node(ni);
1885                                 ifp->if_oerrors++;
1886                                 continue;
1887                         }
1888
1889                         if (ic->ic_rawbpf != NULL)
1890                                 bpf_mtap(ic->ic_rawbpf, m0);
1891
1892                         if (rt2661_tx_data(sc, m0, ni, ac) != 0) {
1893                                 ieee80211_free_node(ni);
1894                                 ifp->if_oerrors++;
1895                                 break;
1896                         }
1897                 }
1898
1899                 sc->sc_tx_timer = 5;
1900                 ifp->if_timer = 1;
1901         }
1902 }
1903
1904 static void
1905 rt2661_watchdog(struct ifnet *ifp)
1906 {
1907         struct rt2661_softc *sc = ifp->if_softc;
1908         struct ieee80211com *ic = &sc->sc_ic;
1909
1910         ifp->if_timer = 0;
1911
1912         if (sc->sc_tx_timer > 0) {
1913                 if (--sc->sc_tx_timer == 0) {
1914                         device_printf(sc->sc_dev, "device timeout\n");
1915                         rt2661_init(sc);
1916                         ifp->if_oerrors++;
1917                         return;
1918                 }
1919                 ifp->if_timer = 1;
1920         }
1921
1922         ieee80211_watchdog(ic);
1923 }
1924
1925 /*
1926  * This function allows for fast channel switching in monitor mode (used by
1927  * net-mgmt/kismet). In IBSS mode, we must explicitly reset the interface to
1928  * generate a new beacon frame.
1929  */
1930 static int
1931 rt2661_reset(struct ifnet *ifp)
1932 {
1933         struct rt2661_softc *sc = ifp->if_softc;
1934         struct ieee80211com *ic = &sc->sc_ic;
1935
1936         if (ic->ic_opmode != IEEE80211_M_MONITOR)
1937                 return ENETRESET;
1938
1939         rt2661_set_chan(sc, ic->ic_curchan);
1940
1941         return 0;
1942 }
1943
1944 static int
1945 rt2661_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
1946 {
1947         struct rt2661_softc *sc = ifp->if_softc;
1948         struct ieee80211com *ic = &sc->sc_ic;
1949         int error = 0;
1950
1951         switch (cmd) {
1952         case SIOCSIFFLAGS:
1953                 if (ifp->if_flags & IFF_UP) {
1954                         if (ifp->if_flags & IFF_RUNNING)
1955                                 rt2661_update_promisc(sc);
1956                         else
1957                                 rt2661_init(sc);
1958                 } else {
1959                         if (ifp->if_flags & IFF_RUNNING)
1960                                 rt2661_stop(sc);
1961                 }
1962                 break;
1963
1964         default:
1965                 error = ieee80211_ioctl(ic, cmd, data, cr);
1966         }
1967
1968         if (error == ENETRESET) {
1969                 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
1970                     (IFF_UP | IFF_RUNNING) &&
1971                     (ic->ic_roaming != IEEE80211_ROAMING_MANUAL))
1972                         rt2661_init(sc);
1973                 error = 0;
1974         }
1975         return error;
1976 }
1977
1978 static void
1979 rt2661_bbp_write(struct rt2661_softc *sc, uint8_t reg, uint8_t val)
1980 {
1981         uint32_t tmp;
1982         int ntries;
1983
1984         for (ntries = 0; ntries < 100; ntries++) {
1985                 if (!(RAL_READ(sc, RT2661_PHY_CSR3) & RT2661_BBP_BUSY))
1986                         break;
1987                 DELAY(1);
1988         }
1989         if (ntries == 100) {
1990                 device_printf(sc->sc_dev, "could not write to BBP\n");
1991                 return;
1992         }
1993
1994         tmp = RT2661_BBP_BUSY | (reg & 0x7f) << 8 | val;
1995         RAL_WRITE(sc, RT2661_PHY_CSR3, tmp);
1996
1997         DPRINTFN(15, ("BBP R%u <- 0x%02x\n", reg, val));
1998 }
1999
2000 static uint8_t
2001 rt2661_bbp_read(struct rt2661_softc *sc, uint8_t reg)
2002 {
2003         uint32_t val;
2004         int ntries;
2005
2006         for (ntries = 0; ntries < 100; ntries++) {
2007                 if (!(RAL_READ(sc, RT2661_PHY_CSR3) & RT2661_BBP_BUSY))
2008                         break;
2009                 DELAY(1);
2010         }
2011         if (ntries == 100) {
2012                 device_printf(sc->sc_dev, "could not read from BBP\n");
2013                 return 0;
2014         }
2015
2016         val = RT2661_BBP_BUSY | RT2661_BBP_READ | reg << 8;
2017         RAL_WRITE(sc, RT2661_PHY_CSR3, val);
2018
2019         for (ntries = 0; ntries < 100; ntries++) {
2020                 val = RAL_READ(sc, RT2661_PHY_CSR3);
2021                 if (!(val & RT2661_BBP_BUSY))
2022                         return val & 0xff;
2023                 DELAY(1);
2024         }
2025
2026         device_printf(sc->sc_dev, "could not read from BBP\n");
2027         return 0;
2028 }
2029
2030 static void
2031 rt2661_rf_write(struct rt2661_softc *sc, uint8_t reg, uint32_t val)
2032 {
2033         uint32_t tmp;
2034         int ntries;
2035
2036         for (ntries = 0; ntries < 100; ntries++) {
2037                 if (!(RAL_READ(sc, RT2661_PHY_CSR4) & RT2661_RF_BUSY))
2038                         break;
2039                 DELAY(1);
2040         }
2041         if (ntries == 100) {
2042                 device_printf(sc->sc_dev, "could not write to RF\n");
2043                 return;
2044         }
2045
2046         tmp = RT2661_RF_BUSY | RT2661_RF_21BIT | (val & 0x1fffff) << 2 |
2047             (reg & 3);
2048         RAL_WRITE(sc, RT2661_PHY_CSR4, tmp);
2049
2050         /* remember last written value in sc */
2051         sc->rf_regs[reg] = val;
2052
2053         DPRINTFN(15, ("RF R[%u] <- 0x%05x\n", reg & 3, val & 0x1fffff));
2054 }
2055
2056 static int
2057 rt2661_tx_cmd(struct rt2661_softc *sc, uint8_t cmd, uint16_t arg)
2058 {
2059         if (RAL_READ(sc, RT2661_H2M_MAILBOX_CSR) & RT2661_H2M_BUSY)
2060                 return EIO;     /* there is already a command pending */
2061
2062         RAL_WRITE(sc, RT2661_H2M_MAILBOX_CSR,
2063             RT2661_H2M_BUSY | RT2661_TOKEN_NO_INTR << 16 | arg);
2064
2065         RAL_WRITE(sc, RT2661_HOST_CMD_CSR, RT2661_KICK_CMD | cmd);
2066
2067         return 0;
2068 }
2069
2070 static void
2071 rt2661_select_antenna(struct rt2661_softc *sc)
2072 {
2073         uint8_t bbp4, bbp77;
2074         uint32_t tmp;
2075
2076         bbp4  = rt2661_bbp_read(sc,  4);
2077         bbp77 = rt2661_bbp_read(sc, 77);
2078
2079         /* TBD */
2080
2081         /* make sure Rx is disabled before switching antenna */
2082         tmp = RAL_READ(sc, RT2661_TXRX_CSR0);
2083         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp | RT2661_DISABLE_RX);
2084
2085         rt2661_bbp_write(sc,  4, bbp4);
2086         rt2661_bbp_write(sc, 77, bbp77);
2087
2088         /* restore Rx filter */
2089         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp);
2090 }
2091
2092 /*
2093  * Enable multi-rate retries for frames sent at OFDM rates.
2094  * In 802.11b/g mode, allow fallback to CCK rates.
2095  */
2096 static void
2097 rt2661_enable_mrr(struct rt2661_softc *sc)
2098 {
2099         struct ieee80211com *ic = &sc->sc_ic;
2100         uint32_t tmp;
2101
2102         tmp = RAL_READ(sc, RT2661_TXRX_CSR4);
2103
2104         tmp &= ~RT2661_MRR_CCK_FALLBACK;
2105         if (!IEEE80211_IS_CHAN_5GHZ(ic->ic_bss->ni_chan))
2106                 tmp |= RT2661_MRR_CCK_FALLBACK;
2107         tmp |= RT2661_MRR_ENABLED;
2108
2109         RAL_WRITE(sc, RT2661_TXRX_CSR4, tmp);
2110 }
2111
2112 static void
2113 rt2661_set_txpreamble(struct rt2661_softc *sc)
2114 {
2115         uint32_t tmp;
2116
2117         tmp = RAL_READ(sc, RT2661_TXRX_CSR4);
2118
2119         tmp &= ~RT2661_SHORT_PREAMBLE;
2120         if (sc->sc_ic.ic_flags & IEEE80211_F_SHPREAMBLE)
2121                 tmp |= RT2661_SHORT_PREAMBLE;
2122
2123         RAL_WRITE(sc, RT2661_TXRX_CSR4, tmp);
2124 }
2125
2126 static void
2127 rt2661_set_basicrates(struct rt2661_softc *sc,
2128     const struct ieee80211_rateset *rs)
2129 {
2130 #define RV(r)   ((r) & IEEE80211_RATE_VAL)
2131         uint32_t mask = 0;
2132         uint8_t rate;
2133         int i, j;
2134
2135         for (i = 0; i < rs->rs_nrates; i++) {
2136                 rate = rs->rs_rates[i];
2137
2138                 if (!(rate & IEEE80211_RATE_BASIC))
2139                         continue;
2140
2141                 /*
2142                  * Find h/w rate index.  We know it exists because the rate
2143                  * set has already been negotiated.
2144                  */
2145                 for (j = 0; rt2661_rateset_11g.rs_rates[j] != RV(rate); j++);
2146
2147                 mask |= 1 << j;
2148         }
2149
2150         RAL_WRITE(sc, RT2661_TXRX_CSR5, mask);
2151
2152         DPRINTF(("Setting basic rate mask to 0x%x\n", mask));
2153 #undef RV
2154 }
2155
2156 /*
2157  * Reprogram MAC/BBP to switch to a new band.  Values taken from the reference
2158  * driver.
2159  */
2160 static void
2161 rt2661_select_band(struct rt2661_softc *sc, struct ieee80211_channel *c)
2162 {
2163         uint8_t bbp17, bbp35, bbp96, bbp97, bbp98, bbp104;
2164         uint32_t tmp;
2165
2166         /* update all BBP registers that depend on the band */
2167         bbp17 = 0x20; bbp96 = 0x48; bbp104 = 0x2c;
2168         bbp35 = 0x50; bbp97 = 0x48; bbp98  = 0x48;
2169         if (IEEE80211_IS_CHAN_5GHZ(c)) {
2170                 bbp17 += 0x08; bbp96 += 0x10; bbp104 += 0x0c;
2171                 bbp35 += 0x10; bbp97 += 0x10; bbp98  += 0x10;
2172         }
2173         if ((IEEE80211_IS_CHAN_2GHZ(c) && sc->ext_2ghz_lna) ||
2174             (IEEE80211_IS_CHAN_5GHZ(c) && sc->ext_5ghz_lna)) {
2175                 bbp17 += 0x10; bbp96 += 0x10; bbp104 += 0x10;
2176         }
2177
2178         rt2661_bbp_write(sc,  17, bbp17);
2179         rt2661_bbp_write(sc,  96, bbp96);
2180         rt2661_bbp_write(sc, 104, bbp104);
2181
2182         if ((IEEE80211_IS_CHAN_2GHZ(c) && sc->ext_2ghz_lna) ||
2183             (IEEE80211_IS_CHAN_5GHZ(c) && sc->ext_5ghz_lna)) {
2184                 rt2661_bbp_write(sc, 75, 0x80);
2185                 rt2661_bbp_write(sc, 86, 0x80);
2186                 rt2661_bbp_write(sc, 88, 0x80);
2187         }
2188
2189         rt2661_bbp_write(sc, 35, bbp35);
2190         rt2661_bbp_write(sc, 97, bbp97);
2191         rt2661_bbp_write(sc, 98, bbp98);
2192
2193         tmp = RAL_READ(sc, RT2661_PHY_CSR0);
2194         tmp &= ~(RT2661_PA_PE_2GHZ | RT2661_PA_PE_5GHZ);
2195         if (IEEE80211_IS_CHAN_2GHZ(c))
2196                 tmp |= RT2661_PA_PE_2GHZ;
2197         else
2198                 tmp |= RT2661_PA_PE_5GHZ;
2199         RAL_WRITE(sc, RT2661_PHY_CSR0, tmp);
2200 }
2201
2202 static void
2203 rt2661_set_chan(struct rt2661_softc *sc, struct ieee80211_channel *c)
2204 {
2205         struct ieee80211com *ic = &sc->sc_ic;
2206         const struct rfprog *rfprog;
2207         uint8_t bbp3, bbp94 = RT2661_BBPR94_DEFAULT;
2208         int8_t power;
2209         u_int i, chan;
2210
2211         chan = ieee80211_chan2ieee(ic, c);
2212         if (chan == 0 || chan == IEEE80211_CHAN_ANY)
2213                 return;
2214
2215         /* select the appropriate RF settings based on what EEPROM says */
2216         rfprog = (sc->rfprog == 0) ? rt2661_rf5225_1 : rt2661_rf5225_2;
2217
2218         /* find the settings for this channel (we know it exists) */
2219         for (i = 0; rfprog[i].chan != chan; i++);
2220
2221         power = sc->txpow[i];
2222         if (power < 0) {
2223                 bbp94 += power;
2224                 power = 0;
2225         } else if (power > 31) {
2226                 bbp94 += power - 31;
2227                 power = 31;
2228         }
2229
2230         /*
2231          * If we are switching from the 2GHz band to the 5GHz band or
2232          * vice-versa, BBP registers need to be reprogrammed.
2233          */
2234         if (c->ic_flags != sc->sc_curchan->ic_flags) {
2235                 rt2661_select_band(sc, c);
2236                 rt2661_select_antenna(sc);
2237         }
2238         sc->sc_curchan = c;
2239
2240         rt2661_rf_write(sc, RAL_RF1, rfprog[i].r1);
2241         rt2661_rf_write(sc, RAL_RF2, rfprog[i].r2);
2242         rt2661_rf_write(sc, RAL_RF3, rfprog[i].r3 | power << 7);
2243         rt2661_rf_write(sc, RAL_RF4, rfprog[i].r4 | sc->rffreq << 10);
2244
2245         DELAY(200);
2246
2247         rt2661_rf_write(sc, RAL_RF1, rfprog[i].r1);
2248         rt2661_rf_write(sc, RAL_RF2, rfprog[i].r2);
2249         rt2661_rf_write(sc, RAL_RF3, rfprog[i].r3 | power << 7 | 1);
2250         rt2661_rf_write(sc, RAL_RF4, rfprog[i].r4 | sc->rffreq << 10);
2251
2252         DELAY(200);
2253
2254         rt2661_rf_write(sc, RAL_RF1, rfprog[i].r1);
2255         rt2661_rf_write(sc, RAL_RF2, rfprog[i].r2);
2256         rt2661_rf_write(sc, RAL_RF3, rfprog[i].r3 | power << 7);
2257         rt2661_rf_write(sc, RAL_RF4, rfprog[i].r4 | sc->rffreq << 10);
2258
2259         /* enable smart mode for MIMO-capable RFs */
2260         bbp3 = rt2661_bbp_read(sc, 3);
2261
2262         bbp3 &= ~RT2661_SMART_MODE;
2263         if (sc->rf_rev == RT2661_RF_5325 || sc->rf_rev == RT2661_RF_2529)
2264                 bbp3 |= RT2661_SMART_MODE;
2265
2266         rt2661_bbp_write(sc, 3, bbp3);
2267
2268         if (bbp94 != RT2661_BBPR94_DEFAULT)
2269                 rt2661_bbp_write(sc, 94, bbp94);
2270
2271         /* 5GHz radio needs a 1ms delay here */
2272         if (IEEE80211_IS_CHAN_5GHZ(c))
2273                 DELAY(1000);
2274 }
2275
2276 static void
2277 rt2661_set_bssid(struct rt2661_softc *sc, const uint8_t *bssid)
2278 {
2279         uint32_t tmp;
2280
2281         tmp = bssid[0] | bssid[1] << 8 | bssid[2] << 16 | bssid[3] << 24;
2282         RAL_WRITE(sc, RT2661_MAC_CSR4, tmp);
2283
2284         tmp = bssid[4] | bssid[5] << 8 | RT2661_ONE_BSSID << 16;
2285         RAL_WRITE(sc, RT2661_MAC_CSR5, tmp);
2286 }
2287
2288 static void
2289 rt2661_set_macaddr(struct rt2661_softc *sc, const uint8_t *addr)
2290 {
2291         uint32_t tmp;
2292
2293         tmp = addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24;
2294         RAL_WRITE(sc, RT2661_MAC_CSR2, tmp);
2295
2296         tmp = addr[4] | addr[5] << 8;
2297         RAL_WRITE(sc, RT2661_MAC_CSR3, tmp);
2298 }
2299
2300 static void
2301 rt2661_update_promisc(struct rt2661_softc *sc)
2302 {
2303         struct ifnet *ifp = sc->sc_ic.ic_ifp;
2304         uint32_t tmp;
2305
2306         tmp = RAL_READ(sc, RT2661_TXRX_CSR0);
2307
2308         tmp &= ~RT2661_DROP_NOT_TO_ME;
2309         if (!(ifp->if_flags & IFF_PROMISC))
2310                 tmp |= RT2661_DROP_NOT_TO_ME;
2311
2312         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp);
2313
2314         DPRINTF(("%s promiscuous mode\n", (ifp->if_flags & IFF_PROMISC) ?
2315             "entering" : "leaving"));
2316 }
2317
2318 /*
2319  * Update QoS (802.11e) settings for each h/w Tx ring.
2320  */
2321 static int
2322 rt2661_wme_update(struct ieee80211com *ic)
2323 {
2324         struct rt2661_softc *sc = ic->ic_ifp->if_softc;
2325         const struct wmeParams *wmep;
2326
2327         wmep = ic->ic_wme.wme_chanParams.cap_wmeParams;
2328
2329         /* XXX: not sure about shifts. */
2330         /* XXX: the reference driver plays with AC_VI settings too. */
2331
2332         /* update TxOp */
2333         RAL_WRITE(sc, RT2661_AC_TXOP_CSR0,
2334             wmep[WME_AC_BE].wmep_txopLimit << 16 |
2335             wmep[WME_AC_BK].wmep_txopLimit);
2336         RAL_WRITE(sc, RT2661_AC_TXOP_CSR1,
2337             wmep[WME_AC_VI].wmep_txopLimit << 16 |
2338             wmep[WME_AC_VO].wmep_txopLimit);
2339
2340         /* update CWmin */
2341         RAL_WRITE(sc, RT2661_CWMIN_CSR,
2342             wmep[WME_AC_BE].wmep_logcwmin << 12 |
2343             wmep[WME_AC_BK].wmep_logcwmin <<  8 |
2344             wmep[WME_AC_VI].wmep_logcwmin <<  4 |
2345             wmep[WME_AC_VO].wmep_logcwmin);
2346
2347         /* update CWmax */
2348         RAL_WRITE(sc, RT2661_CWMAX_CSR,
2349             wmep[WME_AC_BE].wmep_logcwmax << 12 |
2350             wmep[WME_AC_BK].wmep_logcwmax <<  8 |
2351             wmep[WME_AC_VI].wmep_logcwmax <<  4 |
2352             wmep[WME_AC_VO].wmep_logcwmax);
2353
2354         /* update Aifsn */
2355         RAL_WRITE(sc, RT2661_AIFSN_CSR,
2356             wmep[WME_AC_BE].wmep_aifsn << 12 |
2357             wmep[WME_AC_BK].wmep_aifsn <<  8 |
2358             wmep[WME_AC_VI].wmep_aifsn <<  4 |
2359             wmep[WME_AC_VO].wmep_aifsn);
2360
2361         return 0;
2362 }
2363
2364 static void
2365 rt2661_update_slot(struct ifnet *ifp)
2366 {
2367         struct rt2661_softc *sc = ifp->if_softc;
2368         struct ieee80211com *ic = &sc->sc_ic;
2369         uint8_t slottime;
2370         uint32_t tmp;
2371
2372         slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
2373
2374         tmp = RAL_READ(sc, RT2661_MAC_CSR9);
2375         tmp = (tmp & ~0xff) | slottime;
2376         RAL_WRITE(sc, RT2661_MAC_CSR9, tmp);
2377 }
2378
2379 static const char *
2380 rt2661_get_rf(int rev)
2381 {
2382         switch (rev) {
2383         case RT2661_RF_5225:    return "RT5225";
2384         case RT2661_RF_5325:    return "RT5325 (MIMO XR)";
2385         case RT2661_RF_2527:    return "RT2527";
2386         case RT2661_RF_2529:    return "RT2529 (MIMO XR)";
2387         default:                return "unknown";
2388         }
2389 }
2390
2391 static void
2392 rt2661_read_eeprom(struct rt2661_softc *sc)
2393 {
2394         struct ieee80211com *ic = &sc->sc_ic;
2395         uint16_t val;
2396         int i;
2397
2398         /* read MAC address */
2399         val = rt2661_eeprom_read(sc, RT2661_EEPROM_MAC01);
2400         ic->ic_myaddr[0] = val & 0xff;
2401         ic->ic_myaddr[1] = val >> 8;
2402
2403         val = rt2661_eeprom_read(sc, RT2661_EEPROM_MAC23);
2404         ic->ic_myaddr[2] = val & 0xff;
2405         ic->ic_myaddr[3] = val >> 8;
2406
2407         val = rt2661_eeprom_read(sc, RT2661_EEPROM_MAC45);
2408         ic->ic_myaddr[4] = val & 0xff;
2409         ic->ic_myaddr[5] = val >> 8;
2410
2411         val = rt2661_eeprom_read(sc, RT2661_EEPROM_ANTENNA);
2412         /* XXX: test if different from 0xffff? */
2413         sc->rf_rev   = (val >> 11) & 0x1f;
2414         sc->hw_radio = (val >> 10) & 0x1;
2415         sc->rx_ant   = (val >> 4)  & 0x3;
2416         sc->tx_ant   = (val >> 2)  & 0x3;
2417         sc->nb_ant   = val & 0x3;
2418
2419         DPRINTF(("RF revision=%d\n", sc->rf_rev));
2420
2421         val = rt2661_eeprom_read(sc, RT2661_EEPROM_CONFIG2);
2422         sc->ext_5ghz_lna = (val >> 6) & 0x1;
2423         sc->ext_2ghz_lna = (val >> 4) & 0x1;
2424
2425         DPRINTF(("External 2GHz LNA=%d\nExternal 5GHz LNA=%d\n",
2426             sc->ext_2ghz_lna, sc->ext_5ghz_lna));
2427
2428         val = rt2661_eeprom_read(sc, RT2661_EEPROM_RSSI_2GHZ_OFFSET);
2429         if ((val & 0xff) != 0xff)
2430                 sc->rssi_2ghz_corr = (int8_t)(val & 0xff);      /* signed */
2431
2432         val = rt2661_eeprom_read(sc, RT2661_EEPROM_RSSI_5GHZ_OFFSET);
2433         if ((val & 0xff) != 0xff)
2434                 sc->rssi_5ghz_corr = (int8_t)(val & 0xff);      /* signed */
2435
2436         /* adjust RSSI correction for external low-noise amplifier */
2437         if (sc->ext_2ghz_lna)
2438                 sc->rssi_2ghz_corr -= 14;
2439         if (sc->ext_5ghz_lna)
2440                 sc->rssi_5ghz_corr -= 14;
2441
2442         DPRINTF(("RSSI 2GHz corr=%d\nRSSI 5GHz corr=%d\n",
2443             sc->rssi_2ghz_corr, sc->rssi_5ghz_corr));
2444
2445         val = rt2661_eeprom_read(sc, RT2661_EEPROM_FREQ_OFFSET);
2446         if ((val >> 8) != 0xff)
2447                 sc->rfprog = (val >> 8) & 0x3;
2448         if ((val & 0xff) != 0xff)
2449                 sc->rffreq = val & 0xff;
2450
2451         DPRINTF(("RF prog=%d\nRF freq=%d\n", sc->rfprog, sc->rffreq));
2452
2453         /* read Tx power for all a/b/g channels */
2454         for (i = 0; i < 19; i++) {
2455                 val = rt2661_eeprom_read(sc, RT2661_EEPROM_TXPOWER + i);
2456                 sc->txpow[i * 2] = (int8_t)(val >> 8);          /* signed */
2457                 DPRINTF(("Channel=%d Tx power=%d\n",
2458                     rt2661_rf5225_1[i * 2].chan, sc->txpow[i * 2]));
2459                 sc->txpow[i * 2 + 1] = (int8_t)(val & 0xff);    /* signed */
2460                 DPRINTF(("Channel=%d Tx power=%d\n",
2461                     rt2661_rf5225_1[i * 2 + 1].chan, sc->txpow[i * 2 + 1]));
2462         }
2463
2464         /* read vendor-specific BBP values */
2465         for (i = 0; i < 16; i++) {
2466                 val = rt2661_eeprom_read(sc, RT2661_EEPROM_BBP_BASE + i);
2467                 if (val == 0 || val == 0xffff)
2468                         continue;       /* skip invalid entries */
2469                 sc->bbp_prom[i].reg = val >> 8;
2470                 sc->bbp_prom[i].val = val & 0xff;
2471                 DPRINTF(("BBP R%d=%02x\n", sc->bbp_prom[i].reg,
2472                     sc->bbp_prom[i].val));
2473         }
2474 }
2475
2476 static int
2477 rt2661_bbp_init(struct rt2661_softc *sc)
2478 {
2479 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
2480         int i, ntries;
2481         uint8_t val;
2482
2483         /* wait for BBP to be ready */
2484         for (ntries = 0; ntries < 100; ntries++) {
2485                 val = rt2661_bbp_read(sc, 0);
2486                 if (val != 0 && val != 0xff)
2487                         break;
2488                 DELAY(100);
2489         }
2490         if (ntries == 100) {
2491                 device_printf(sc->sc_dev, "timeout waiting for BBP\n");
2492                 return EIO;
2493         }
2494
2495         /* initialize BBP registers to default values */
2496         for (i = 0; i < N(rt2661_def_bbp); i++) {
2497                 rt2661_bbp_write(sc, rt2661_def_bbp[i].reg,
2498                     rt2661_def_bbp[i].val);
2499         }
2500
2501         /* write vendor-specific BBP values (from EEPROM) */
2502         for (i = 0; i < 16; i++) {
2503                 if (sc->bbp_prom[i].reg == 0)
2504                         continue;
2505                 rt2661_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
2506         }
2507
2508         return 0;
2509 #undef N
2510 }
2511
2512 static void
2513 rt2661_init(void *priv)
2514 {
2515 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
2516         struct rt2661_softc *sc = priv;
2517         struct ieee80211com *ic = &sc->sc_ic;
2518         struct ifnet *ifp = ic->ic_ifp;
2519         uint32_t tmp, sta[3];
2520         int i, ntries;
2521
2522         rt2661_stop(sc);
2523
2524         /* initialize Tx rings */
2525         RAL_WRITE(sc, RT2661_AC1_BASE_CSR, sc->txq[1].physaddr);
2526         RAL_WRITE(sc, RT2661_AC0_BASE_CSR, sc->txq[0].physaddr);
2527         RAL_WRITE(sc, RT2661_AC2_BASE_CSR, sc->txq[2].physaddr);
2528         RAL_WRITE(sc, RT2661_AC3_BASE_CSR, sc->txq[3].physaddr);
2529
2530         /* initialize Mgt ring */
2531         RAL_WRITE(sc, RT2661_MGT_BASE_CSR, sc->mgtq.physaddr);
2532
2533         /* initialize Rx ring */
2534         RAL_WRITE(sc, RT2661_RX_BASE_CSR, sc->rxq.physaddr);
2535
2536         /* initialize Tx rings sizes */
2537         RAL_WRITE(sc, RT2661_TX_RING_CSR0,
2538             RT2661_TX_RING_COUNT << 24 |
2539             RT2661_TX_RING_COUNT << 16 |
2540             RT2661_TX_RING_COUNT <<  8 |
2541             RT2661_TX_RING_COUNT);
2542
2543         RAL_WRITE(sc, RT2661_TX_RING_CSR1,
2544             RT2661_TX_DESC_WSIZE << 16 |
2545             RT2661_TX_RING_COUNT <<  8 |        /* XXX: HCCA ring unused */
2546             RT2661_MGT_RING_COUNT);
2547
2548         /* initialize Rx rings */
2549         RAL_WRITE(sc, RT2661_RX_RING_CSR,
2550             RT2661_RX_DESC_BACK  << 16 |
2551             RT2661_RX_DESC_WSIZE <<  8 |
2552             RT2661_RX_RING_COUNT);
2553
2554         /* XXX: some magic here */
2555         RAL_WRITE(sc, RT2661_TX_DMA_DST_CSR, 0xaa);
2556
2557         /* load base addresses of all 5 Tx rings (4 data + 1 mgt) */
2558         RAL_WRITE(sc, RT2661_LOAD_TX_RING_CSR, 0x1f);
2559
2560         /* load base address of Rx ring */
2561         RAL_WRITE(sc, RT2661_RX_CNTL_CSR, 2);
2562
2563         /* initialize MAC registers to default values */
2564         for (i = 0; i < N(rt2661_def_mac); i++)
2565                 RAL_WRITE(sc, rt2661_def_mac[i].reg, rt2661_def_mac[i].val);
2566
2567         IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
2568         rt2661_set_macaddr(sc, ic->ic_myaddr);
2569
2570         /* set host ready */
2571         RAL_WRITE(sc, RT2661_MAC_CSR1, 3);
2572         RAL_WRITE(sc, RT2661_MAC_CSR1, 0);
2573
2574         /* wait for BBP/RF to wakeup */
2575         for (ntries = 0; ntries < 1000; ntries++) {
2576                 if (RAL_READ(sc, RT2661_MAC_CSR12) & 8)
2577                         break;
2578                 DELAY(1000);
2579         }
2580         if (ntries == 1000) {
2581                 printf("timeout waiting for BBP/RF to wakeup\n");
2582                 rt2661_stop(sc);
2583                 return;
2584         }
2585
2586         if (rt2661_bbp_init(sc) != 0) {
2587                 rt2661_stop(sc);
2588                 return;
2589         }
2590
2591         /* select default channel */
2592         sc->sc_curchan = ic->ic_curchan;
2593         rt2661_select_band(sc, sc->sc_curchan);
2594         rt2661_select_antenna(sc);
2595         rt2661_set_chan(sc, sc->sc_curchan);
2596
2597         /* update Rx filter */
2598         tmp = RAL_READ(sc, RT2661_TXRX_CSR0) & 0xffff;
2599
2600         tmp |= RT2661_DROP_PHY_ERROR | RT2661_DROP_CRC_ERROR;
2601         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2602                 tmp |= RT2661_DROP_CTL | RT2661_DROP_VER_ERROR |
2603                        RT2661_DROP_ACKCTS;
2604                 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2605                         tmp |= RT2661_DROP_TODS;
2606                 if (!(ifp->if_flags & IFF_PROMISC))
2607                         tmp |= RT2661_DROP_NOT_TO_ME;
2608         }
2609
2610         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp);
2611
2612         /* clear STA registers */
2613         RAL_READ_REGION_4(sc, RT2661_STA_CSR0, sta, N(sta));
2614
2615         /* initialize ASIC */
2616         RAL_WRITE(sc, RT2661_MAC_CSR1, 4);
2617
2618         /* clear any pending interrupt */
2619         RAL_WRITE(sc, RT2661_INT_SOURCE_CSR, 0xffffffff);
2620
2621         /* enable interrupts */
2622         RAL_WRITE(sc, RT2661_INT_MASK_CSR, 0x0000ff10);
2623         RAL_WRITE(sc, RT2661_MCU_INT_MASK_CSR, 0);
2624
2625         /* kick Rx */
2626         RAL_WRITE(sc, RT2661_RX_CNTL_CSR, 1);
2627
2628         ifp->if_flags &= ~IFF_OACTIVE;
2629         ifp->if_flags |= IFF_RUNNING;
2630
2631         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2632                 if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
2633                         ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
2634         } else
2635                 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
2636 #undef N
2637 }
2638
2639 void
2640 rt2661_stop(void *priv)
2641 {
2642         struct rt2661_softc *sc = priv;
2643         struct ieee80211com *ic = &sc->sc_ic;
2644         struct ifnet *ifp = ic->ic_ifp;
2645         uint32_t tmp;
2646
2647         sc->sc_tx_timer = 0;
2648         ifp->if_timer = 0;
2649         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2650
2651         ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
2652
2653         /* abort Tx (for all 5 Tx rings) */
2654         RAL_WRITE(sc, RT2661_TX_CNTL_CSR, 0x1f << 16);
2655
2656         /* disable Rx (value remains after reset!) */
2657         tmp = RAL_READ(sc, RT2661_TXRX_CSR0);
2658         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp | RT2661_DISABLE_RX);
2659
2660         /* reset ASIC */
2661         RAL_WRITE(sc, RT2661_MAC_CSR1, 3);
2662         RAL_WRITE(sc, RT2661_MAC_CSR1, 0);
2663
2664         /* disable interrupts */
2665         RAL_WRITE(sc, RT2661_INT_MASK_CSR, 0xffffffff);
2666         RAL_WRITE(sc, RT2661_MCU_INT_MASK_CSR, 0xffffffff);
2667
2668         /* clear any pending interrupt */
2669         RAL_WRITE(sc, RT2661_INT_SOURCE_CSR, 0xffffffff);
2670         RAL_WRITE(sc, RT2661_MCU_INT_SOURCE_CSR, 0xffffffff);
2671
2672         /* reset Tx and Rx rings */
2673         rt2661_reset_tx_ring(sc, &sc->txq[0]);
2674         rt2661_reset_tx_ring(sc, &sc->txq[1]);
2675         rt2661_reset_tx_ring(sc, &sc->txq[2]);
2676         rt2661_reset_tx_ring(sc, &sc->txq[3]);
2677         rt2661_reset_tx_ring(sc, &sc->mgtq);
2678         rt2661_reset_rx_ring(sc, &sc->rxq);
2679 }
2680
2681 static int
2682 rt2661_load_microcode(struct rt2661_softc *sc, const uint8_t *ucode, int size)
2683 {
2684         int ntries;
2685
2686         /* reset 8051 */
2687         RAL_WRITE(sc, RT2661_MCU_CNTL_CSR, RT2661_MCU_RESET);
2688
2689         /* cancel any pending Host to MCU command */
2690         RAL_WRITE(sc, RT2661_H2M_MAILBOX_CSR, 0);
2691         RAL_WRITE(sc, RT2661_M2H_CMD_DONE_CSR, 0xffffffff);
2692         RAL_WRITE(sc, RT2661_HOST_CMD_CSR, 0);
2693
2694         /* write 8051's microcode */
2695         RAL_WRITE(sc, RT2661_MCU_CNTL_CSR, RT2661_MCU_RESET | RT2661_MCU_SEL);
2696         RAL_WRITE_REGION_1(sc, RT2661_MCU_CODE_BASE, ucode, size);
2697         RAL_WRITE(sc, RT2661_MCU_CNTL_CSR, RT2661_MCU_RESET);
2698
2699         /* kick 8051's ass */
2700         RAL_WRITE(sc, RT2661_MCU_CNTL_CSR, 0);
2701
2702         /* wait for 8051 to initialize */
2703         for (ntries = 0; ntries < 500; ntries++) {
2704                 if (RAL_READ(sc, RT2661_MCU_CNTL_CSR) & RT2661_MCU_READY)
2705                         break;
2706                 DELAY(100);
2707         }
2708         if (ntries == 500) {
2709                 printf("timeout waiting for MCU to initialize\n");
2710                 return EIO;
2711         }
2712         return 0;
2713 }
2714
2715 #ifdef notyet
2716 /*
2717  * Dynamically tune Rx sensitivity (BBP register 17) based on average RSSI and
2718  * false CCA count.  This function is called periodically (every seconds) when
2719  * in the RUN state.  Values taken from the reference driver.
2720  */
2721 static void
2722 rt2661_rx_tune(struct rt2661_softc *sc)
2723 {
2724         uint8_t bbp17;
2725         uint16_t cca;
2726         int lo, hi, dbm;
2727
2728         /*
2729          * Tuning range depends on operating band and on the presence of an
2730          * external low-noise amplifier.
2731          */
2732         lo = 0x20;
2733         if (IEEE80211_IS_CHAN_5GHZ(sc->sc_curchan))
2734                 lo += 0x08;
2735         if ((IEEE80211_IS_CHAN_2GHZ(sc->sc_curchan) && sc->ext_2ghz_lna) ||
2736             (IEEE80211_IS_CHAN_5GHZ(sc->sc_curchan) && sc->ext_5ghz_lna))
2737                 lo += 0x10;
2738         hi = lo + 0x20;
2739
2740         /* retrieve false CCA count since last call (clear on read) */
2741         cca = RAL_READ(sc, RT2661_STA_CSR1) & 0xffff;
2742
2743         if (dbm >= -35) {
2744                 bbp17 = 0x60;
2745         } else if (dbm >= -58) {
2746                 bbp17 = hi;
2747         } else if (dbm >= -66) {
2748                 bbp17 = lo + 0x10;
2749         } else if (dbm >= -74) {
2750                 bbp17 = lo + 0x08;
2751         } else {
2752                 /* RSSI < -74dBm, tune using false CCA count */
2753
2754                 bbp17 = sc->bbp17; /* current value */
2755
2756                 hi -= 2 * (-74 - dbm);
2757                 if (hi < lo)
2758                         hi = lo;
2759
2760                 if (bbp17 > hi) {
2761                         bbp17 = hi;
2762
2763                 } else if (cca > 512) {
2764                         if (++bbp17 > hi)
2765                                 bbp17 = hi;
2766                 } else if (cca < 100) {
2767                         if (--bbp17 < lo)
2768                                 bbp17 = lo;
2769                 }
2770         }
2771
2772         if (bbp17 != sc->bbp17) {
2773                 rt2661_bbp_write(sc, 17, bbp17);
2774                 sc->bbp17 = bbp17;
2775         }
2776 }
2777
2778 /*
2779  * Enter/Leave radar detection mode.
2780  * This is for 802.11h additional regulatory domains.
2781  */
2782 static void
2783 rt2661_radar_start(struct rt2661_softc *sc)
2784 {
2785         uint32_t tmp;
2786
2787         /* disable Rx */
2788         tmp = RAL_READ(sc, RT2661_TXRX_CSR0);
2789         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp | RT2661_DISABLE_RX);
2790
2791         rt2661_bbp_write(sc, 82, 0x20);
2792         rt2661_bbp_write(sc, 83, 0x00);
2793         rt2661_bbp_write(sc, 84, 0x40);
2794
2795         /* save current BBP registers values */
2796         sc->bbp18 = rt2661_bbp_read(sc, 18);
2797         sc->bbp21 = rt2661_bbp_read(sc, 21);
2798         sc->bbp22 = rt2661_bbp_read(sc, 22);
2799         sc->bbp16 = rt2661_bbp_read(sc, 16);
2800         sc->bbp17 = rt2661_bbp_read(sc, 17);
2801         sc->bbp64 = rt2661_bbp_read(sc, 64);
2802
2803         rt2661_bbp_write(sc, 18, 0xff);
2804         rt2661_bbp_write(sc, 21, 0x3f);
2805         rt2661_bbp_write(sc, 22, 0x3f);
2806         rt2661_bbp_write(sc, 16, 0xbd);
2807         rt2661_bbp_write(sc, 17, sc->ext_5ghz_lna ? 0x44 : 0x34);
2808         rt2661_bbp_write(sc, 64, 0x21);
2809
2810         /* restore Rx filter */
2811         RAL_WRITE(sc, RT2661_TXRX_CSR0, tmp);
2812 }
2813
2814 static int
2815 rt2661_radar_stop(struct rt2661_softc *sc)
2816 {
2817         uint8_t bbp66;
2818
2819         /* read radar detection result */
2820         bbp66 = rt2661_bbp_read(sc, 66);
2821
2822         /* restore BBP registers values */
2823         rt2661_bbp_write(sc, 16, sc->bbp16);
2824         rt2661_bbp_write(sc, 17, sc->bbp17);
2825         rt2661_bbp_write(sc, 18, sc->bbp18);
2826         rt2661_bbp_write(sc, 21, sc->bbp21);
2827         rt2661_bbp_write(sc, 22, sc->bbp22);
2828         rt2661_bbp_write(sc, 64, sc->bbp64);
2829
2830         return bbp66 == 1;
2831 }
2832 #endif
2833
2834 static int
2835 rt2661_prepare_beacon(struct rt2661_softc *sc)
2836 {
2837         struct ieee80211com *ic = &sc->sc_ic;
2838         struct ieee80211_beacon_offsets bo;
2839         struct rt2661_tx_desc desc;
2840         struct mbuf *m0;
2841         int rate;
2842
2843         m0 = ieee80211_beacon_alloc(ic, ic->ic_bss, &bo);
2844         if (m0 == NULL) {
2845                 device_printf(sc->sc_dev, "could not allocate beacon frame\n");
2846                 return ENOBUFS;
2847         }
2848
2849         /* send beacons at the lowest available rate */
2850         rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_bss->ni_chan) ? 12 : 2;
2851
2852         rt2661_setup_tx_desc(sc, &desc, RT2661_TX_TIMESTAMP, RT2661_TX_HWSEQ,
2853             m0->m_pkthdr.len, rate, NULL, 0, RT2661_QID_MGT);
2854
2855         /* copy the first 24 bytes of Tx descriptor into NIC memory */
2856         RAL_WRITE_REGION_1(sc, RT2661_HW_BEACON_BASE0, (uint8_t *)&desc, 24);
2857
2858         /* copy beacon header and payload into NIC memory */
2859         RAL_WRITE_REGION_1(sc, RT2661_HW_BEACON_BASE0 + 24,
2860             mtod(m0, uint8_t *), m0->m_pkthdr.len);
2861
2862         m_freem(m0);
2863         return 0;
2864 }
2865
2866 /*
2867  * Enable TSF synchronization and tell h/w to start sending beacons for IBSS
2868  * and HostAP operating modes.
2869  */
2870 static void
2871 rt2661_enable_tsf_sync(struct rt2661_softc *sc)
2872 {
2873         struct ieee80211com *ic = &sc->sc_ic;
2874         uint32_t tmp;
2875
2876         if (ic->ic_opmode != IEEE80211_M_STA) {
2877                 /*
2878                  * Change default 16ms TBTT adjustment to 8ms.
2879                  * Must be done before enabling beacon generation.
2880                  */
2881                 RAL_WRITE(sc, RT2661_TXRX_CSR10, 1 << 12 | 8);
2882         }
2883
2884         tmp = RAL_READ(sc, RT2661_TXRX_CSR9) & 0xff000000;
2885
2886         /* set beacon interval (in 1/16ms unit) */
2887         tmp |= ic->ic_bss->ni_intval * 16;
2888
2889         tmp |= RT2661_TSF_TICKING | RT2661_ENABLE_TBTT;
2890         if (ic->ic_opmode == IEEE80211_M_STA)
2891                 tmp |= RT2661_TSF_MODE(1);
2892         else
2893                 tmp |= RT2661_TSF_MODE(2) | RT2661_GENERATE_BEACON;
2894
2895         RAL_WRITE(sc, RT2661_TXRX_CSR9, tmp);
2896 }
2897
2898 /*
2899  * Retrieve the "Received Signal Strength Indicator" from the raw values
2900  * contained in Rx descriptors.  The computation depends on which band the
2901  * frame was received.  Correction values taken from the reference driver.
2902  */
2903 static int
2904 rt2661_get_rssi(struct rt2661_softc *sc, uint8_t raw)
2905 {
2906         int lna, agc, rssi;
2907
2908         lna = (raw >> 5) & 0x3;
2909         agc = raw & 0x1f;
2910
2911         rssi = 2 * agc;
2912
2913         if (IEEE80211_IS_CHAN_2GHZ(sc->sc_curchan)) {
2914                 rssi += sc->rssi_2ghz_corr;
2915
2916                 if (lna == 1)
2917                         rssi -= 64;
2918                 else if (lna == 2)
2919                         rssi -= 74;
2920                 else if (lna == 3)
2921                         rssi -= 90;
2922         } else {
2923                 rssi += sc->rssi_5ghz_corr;
2924
2925                 if (lna == 1)
2926                         rssi -= 64;
2927                 else if (lna == 2)
2928                         rssi -= 86;
2929                 else if (lna == 3)
2930                         rssi -= 100;
2931         }
2932         return rssi;
2933 }
2934
2935 static void
2936 rt2661_dma_map_mbuf(void *arg, bus_dma_segment_t *seg, int nseg,
2937                     bus_size_t map_size __unused, int error)
2938 {
2939         struct rt2661_dmamap *map = arg;
2940
2941         if (error)
2942                 return;
2943
2944         KASSERT(nseg <= RT2661_MAX_SCATTER, ("too many DMA segments"));
2945
2946         bcopy(seg, map->segs, nseg * sizeof(bus_dma_segment_t));
2947         map->nseg = nseg;
2948 }