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