sys/dev/ral/rt2560.c

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