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                 return EINVAL;
1721
1722         error = bus_dmamap_load_mbuf_sg(sc->prioq.data_dmat, data->map, m0,
1723             segs, &nsegs, 0);
1724         if (error != 0) {
1725                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
1726                     error);
1727                 m_freem(m0);
1728                 return error;
1729         }
1730
1731         if (bpf_peers_present(sc->sc_drvbpf)) {
1732                 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
1733
1734                 tap->wt_flags = 0;
1735                 tap->wt_rate = rate;
1736                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
1737                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
1738                 tap->wt_antenna = sc->tx_ant;
1739
1740                 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0);
1741         }
1742
1743         data->m = m0;
1744         data->ni = ni;
1745
1746         flags = 0;
1747         if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
1748                 flags |= RT2560_TX_ACK;
1749
1750         /* XXX need to setup descriptor ourself */
1751         rt2560_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len,
1752             rate, (params->ibp_flags & IEEE80211_BPF_CRYPTO) != 0,
1753             segs->ds_addr);
1754
1755         bus_dmamap_sync(sc->prioq.data_dmat, data->map, BUS_DMASYNC_PREWRITE);
1756         bus_dmamap_sync(sc->prioq.desc_dmat, sc->prioq.desc_map,
1757             BUS_DMASYNC_PREWRITE);
1758
1759         DPRINTFN(10, ("sending raw frame len=%u idx=%u rate=%u\n",
1760             m0->m_pkthdr.len, sc->prioq.cur, rate));
1761
1762         /* kick prio */
1763         sc->prioq.queued++;
1764         sc->prioq.cur = (sc->prioq.cur + 1) % RT2560_PRIO_RING_COUNT;
1765         RAL_WRITE(sc, RT2560_TXCSR0, RT2560_KICK_PRIO);
1766
1767         return 0;
1768 }
1769
1770 /*
1771  * Build a RTS control frame.
1772  */
1773 static struct mbuf *
1774 rt2560_get_rts(struct rt2560_softc *sc, struct ieee80211_frame *wh,
1775     uint16_t dur)
1776 {
1777         struct ieee80211_frame_rts *rts;
1778         struct mbuf *m;
1779
1780         MGETHDR(m, M_DONTWAIT, MT_DATA);
1781         if (m == NULL) {
1782                 sc->sc_ic.ic_stats.is_tx_nobuf++;
1783                 device_printf(sc->sc_dev, "could not allocate RTS frame\n");
1784                 return NULL;
1785         }
1786
1787         rts = mtod(m, struct ieee80211_frame_rts *);
1788
1789         rts->i_fc[0] = IEEE80211_FC0_VERSION_0 | IEEE80211_FC0_TYPE_CTL |
1790             IEEE80211_FC0_SUBTYPE_RTS;
1791         rts->i_fc[1] = IEEE80211_FC1_DIR_NODS;
1792         *(uint16_t *)rts->i_dur = htole16(dur);
1793         IEEE80211_ADDR_COPY(rts->i_ra, wh->i_addr1);
1794         IEEE80211_ADDR_COPY(rts->i_ta, wh->i_addr2);
1795
1796         m->m_pkthdr.len = m->m_len = sizeof (struct ieee80211_frame_rts);
1797
1798         return m;
1799 }
1800
1801 static int
1802 rt2560_tx_data(struct rt2560_softc *sc, struct mbuf *m0,
1803     struct ieee80211_node *ni)
1804 {
1805         struct ieee80211com *ic = &sc->sc_ic;
1806         struct rt2560_tx_desc *desc;
1807         struct rt2560_tx_data *data;
1808         struct rt2560_node *rn;
1809         struct ieee80211_rateset *rs;
1810         struct ieee80211_frame *wh;
1811         struct ieee80211_key *k;
1812         struct mbuf *mnew;
1813         bus_dma_segment_t segs[RT2560_MAX_SCATTER];
1814         uint16_t dur;
1815         uint32_t flags = 0;
1816         int nsegs, rate, error;
1817
1818         wh = mtod(m0, struct ieee80211_frame *);
1819
1820         if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE) {
1821                 rs = &ic->ic_sup_rates[ic->ic_curmode];
1822                 rate = rs->rs_rates[ic->ic_fixed_rate];
1823         } else {
1824                 rs = &ni->ni_rates;
1825                 rn = (struct rt2560_node *)ni;
1826                 ni->ni_txrate = ral_rssadapt_choose(&rn->rssadapt, rs, wh,
1827                     m0->m_pkthdr.len, NULL, 0);
1828                 rate = rs->rs_rates[ni->ni_txrate];
1829         }
1830         rate &= IEEE80211_RATE_VAL;
1831
1832         if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
1833                 k = ieee80211_crypto_encap(ic, ni, m0);
1834                 if (k == NULL) {
1835                         m_freem(m0);
1836                         return ENOBUFS;
1837                 }
1838
1839                 /* packet header may have moved, reset our local pointer */
1840                 wh = mtod(m0, struct ieee80211_frame *);
1841         }
1842
1843         /*
1844          * IEEE Std 802.11-1999, pp 82: "A STA shall use an RTS/CTS exchange
1845          * for directed frames only when the length of the MPDU is greater
1846          * than the length threshold indicated by [...]" ic_rtsthreshold.
1847          */
1848         if (!IEEE80211_IS_MULTICAST(wh->i_addr1) &&
1849             m0->m_pkthdr.len > ic->ic_rtsthreshold) {
1850                 struct mbuf *m;
1851                 uint16_t dur;
1852                 int rtsrate, ackrate;
1853
1854                 rtsrate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2;
1855                 ackrate = rt2560_ack_rate(ic, rate);
1856
1857                 dur = rt2560_txtime(m0->m_pkthdr.len + 4, rate, ic->ic_flags) +
1858                       rt2560_txtime(RAL_CTS_SIZE, rtsrate, ic->ic_flags) +
1859                       rt2560_txtime(RAL_ACK_SIZE, ackrate, ic->ic_flags) +
1860                       3 * RAL_SIFS;
1861
1862                 m = rt2560_get_rts(sc, wh, dur);
1863
1864                 desc = &sc->txq.desc[sc->txq.cur_encrypt];
1865                 data = &sc->txq.data[sc->txq.cur_encrypt];
1866
1867                 error = bus_dmamap_load_mbuf_sg(sc->txq.data_dmat, data->map,
1868                     m, segs, &nsegs, 0);
1869                 if (error != 0) {
1870                         device_printf(sc->sc_dev,
1871                             "could not map mbuf (error %d)\n", error);
1872                         m_freem(m);
1873                         m_freem(m0);
1874                         return error;
1875                 }
1876
1877                 /* avoid multiple free() of the same node for each fragment */
1878                 ieee80211_ref_node(ni);
1879
1880                 data->m = m;
1881                 data->ni = ni;
1882
1883                 /* RTS frames are not taken into account for rssadapt */
1884                 data->id.id_node = NULL;
1885
1886                 rt2560_setup_tx_desc(sc, desc, RT2560_TX_ACK |
1887                     RT2560_TX_MORE_FRAG, m->m_pkthdr.len, rtsrate, 1,
1888                     segs->ds_addr);
1889
1890                 bus_dmamap_sync(sc->txq.data_dmat, data->map,
1891                     BUS_DMASYNC_PREWRITE);
1892
1893                 sc->txq.queued++;
1894                 sc->txq.cur_encrypt =
1895                     (sc->txq.cur_encrypt + 1) % RT2560_TX_RING_COUNT;
1896
1897                 /*
1898                  * IEEE Std 802.11-1999: when an RTS/CTS exchange is used, the
1899                  * asynchronous data frame shall be transmitted after the CTS
1900                  * frame and a SIFS period.
1901                  */
1902                 flags |= RT2560_TX_LONG_RETRY | RT2560_TX_IFS_SIFS;
1903         }
1904
1905         data = &sc->txq.data[sc->txq.cur_encrypt];
1906         desc = &sc->txq.desc[sc->txq.cur_encrypt];
1907
1908         error = bus_dmamap_load_mbuf_sg(sc->txq.data_dmat, data->map, m0,
1909             segs, &nsegs, 0);
1910         if (error != 0 && error != EFBIG) {
1911                 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n",
1912                     error);
1913                 m_freem(m0);
1914                 return error;
1915         }
1916         if (error != 0) {
1917                 mnew = m_defrag(m0, M_DONTWAIT);
1918                 if (mnew == NULL) {
1919                         device_printf(sc->sc_dev,
1920                             "could not defragment mbuf\n");
1921                         m_freem(m0);
1922                         return ENOBUFS;
1923                 }
1924                 m0 = mnew;
1925
1926                 error = bus_dmamap_load_mbuf_sg(sc->txq.data_dmat, data->map,
1927                     m0, segs, &nsegs, 0);
1928                 if (error != 0) {
1929                         device_printf(sc->sc_dev,
1930                             "could not map mbuf (error %d)\n", error);
1931                         m_freem(m0);
1932                         return error;
1933                 }
1934
1935                 /* packet header may have moved, reset our local pointer */
1936                 wh = mtod(m0, struct ieee80211_frame *);
1937         }
1938
1939         if (bpf_peers_present(sc->sc_drvbpf)) {
1940                 struct rt2560_tx_radiotap_header *tap = &sc->sc_txtap;
1941
1942                 tap->wt_flags = 0;
1943                 tap->wt_rate = rate;
1944                 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq);
1945                 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags);
1946                 tap->wt_antenna = sc->tx_ant;
1947
1948                 bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0);
1949         }
1950
1951         data->m = m0;
1952         data->ni = ni;
1953
1954         /* remember link conditions for rate adaptation algorithm */
1955         if (ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) {
1956                 data->id.id_len = m0->m_pkthdr.len;
1957                 data->id.id_rateidx = ni->ni_txrate;
1958                 data->id.id_node = ni;
1959                 data->id.id_rssi = ni->ni_rssi;
1960         } else
1961                 data->id.id_node = NULL;
1962
1963         if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1964                 flags |= RT2560_TX_ACK;
1965
1966                 dur = rt2560_txtime(RAL_ACK_SIZE, rt2560_ack_rate(ic, rate),
1967                     ic->ic_flags) + RAL_SIFS;
1968                 *(uint16_t *)wh->i_dur = htole16(dur);
1969         }
1970
1971         rt2560_setup_tx_desc(sc, desc, flags, m0->m_pkthdr.len, rate, 1,
1972             segs->ds_addr);
1973
1974         bus_dmamap_sync(sc->txq.data_dmat, data->map, BUS_DMASYNC_PREWRITE);
1975         bus_dmamap_sync(sc->txq.desc_dmat, sc->txq.desc_map,
1976             BUS_DMASYNC_PREWRITE);
1977
1978         DPRINTFN(10, ("sending data frame len=%u idx=%u rate=%u\n",
1979             m0->m_pkthdr.len, sc->txq.cur_encrypt, rate));
1980
1981         /* kick encrypt */
1982         sc->txq.queued++;
1983         sc->txq.cur_encrypt = (sc->txq.cur_encrypt + 1) % RT2560_TX_RING_COUNT;
1984         RAL_WRITE(sc, RT2560_SECCSR1, RT2560_KICK_ENCRYPT);
1985
1986         return 0;
1987 }
1988
1989 static void
1990 rt2560_start(struct ifnet *ifp)
1991 {
1992         struct rt2560_softc *sc = ifp->if_softc;
1993         struct ieee80211com *ic = &sc->sc_ic;
1994         struct mbuf *m0;
1995         struct ether_header *eh;
1996         struct ieee80211_node *ni;
1997
1998         RAL_LOCK(sc);
1999
2000         /* prevent management frames from being sent if we're not ready */
2001         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
2002                 RAL_UNLOCK(sc);
2003                 return;
2004         }
2005
2006         for (;;) {
2007                 IF_POLL(&ic->ic_mgtq, m0);
2008                 if (m0 != NULL) {
2009                         if (sc->prioq.queued >= RT2560_PRIO_RING_COUNT) {
2010                                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
2011                                 break;
2012                         }
2013                         IF_DEQUEUE(&ic->ic_mgtq, m0);
2014
2015                         ni = (struct ieee80211_node *)m0->m_pkthdr.rcvif;
2016                         m0->m_pkthdr.rcvif = NULL;
2017
2018                         if (bpf_peers_present(ic->ic_rawbpf))
2019                                 bpf_mtap(ic->ic_rawbpf, m0);
2020
2021                         if (rt2560_tx_mgt(sc, m0, ni) != 0)
2022                                 break;
2023
2024                 } else {
2025                         if (ic->ic_state != IEEE80211_S_RUN)
2026                                 break;
2027                         IFQ_DRV_DEQUEUE(&ifp->if_snd, m0);
2028                         if (m0 == NULL)
2029                                 break;
2030                         if (sc->txq.queued >= RT2560_TX_RING_COUNT - 1) {
2031                                 IFQ_DRV_PREPEND(&ifp->if_snd, m0);
2032                                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
2033                                 break;
2034                         }
2035
2036                         if (m0->m_len < sizeof (struct ether_header) &&
2037                             !(m0 = m_pullup(m0, sizeof (struct ether_header))))
2038                                 continue;
2039
2040                         eh = mtod(m0, struct ether_header *);
2041                         ni = ieee80211_find_txnode(ic, eh->ether_dhost);
2042                         if (ni == NULL) {
2043                                 m_freem(m0);
2044                                 continue;
2045                         }
2046                         BPF_MTAP(ifp, m0);
2047
2048                         m0 = ieee80211_encap(ic, m0, ni);
2049                         if (m0 == NULL) {
2050                                 ieee80211_free_node(ni);
2051                                 continue;
2052                         }
2053
2054                         if (bpf_peers_present(ic->ic_rawbpf))
2055                                 bpf_mtap(ic->ic_rawbpf, m0);
2056
2057                         if (rt2560_tx_data(sc, m0, ni) != 0) {
2058                                 ieee80211_free_node(ni);
2059                                 ifp->if_oerrors++;
2060                                 break;
2061                         }
2062                 }
2063
2064                 sc->sc_tx_timer = 5;
2065                 callout_reset(&sc->watchdog_ch, hz, rt2560_watchdog, sc);
2066         }
2067
2068         RAL_UNLOCK(sc);
2069 }
2070
2071 static void
2072 rt2560_watchdog(void *arg)
2073 {
2074         struct rt2560_softc *sc = arg;
2075         struct ieee80211com *ic = &sc->sc_ic;
2076
2077         if (sc->sc_tx_timer > 0) {
2078                 if (--sc->sc_tx_timer == 0) {
2079                         device_printf(sc->sc_dev, "device timeout\n");
2080                         rt2560_init(sc);
2081                         sc->sc_ifp->if_oerrors++;
2082                         return;
2083                 }
2084                 callout_reset(&sc->watchdog_ch, hz, rt2560_watchdog, sc);
2085         }
2086
2087         ieee80211_watchdog(ic);
2088 }
2089
2090 /*
2091  * This function allows for fast channel switching in monitor mode (used by
2092  * net-mgmt/kismet). In IBSS mode, we must explicitly reset the interface to
2093  * generate a new beacon frame.
2094  */
2095 static int
2096 rt2560_reset(struct ifnet *ifp)
2097 {
2098         struct rt2560_softc *sc = ifp->if_softc;
2099         struct ieee80211com *ic = &sc->sc_ic;
2100
2101         if (ic->ic_opmode != IEEE80211_M_MONITOR)
2102                 return ENETRESET;
2103
2104         rt2560_set_chan(sc, ic->ic_curchan);
2105
2106         return 0;
2107 }
2108
2109 static int
2110 rt2560_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
2111 {
2112         struct rt2560_softc *sc = ifp->if_softc;
2113         struct ieee80211com *ic = &sc->sc_ic;
2114         int error = 0;
2115
2116         RAL_LOCK(sc);
2117
2118         switch (cmd) {
2119         case SIOCSIFFLAGS:
2120                 if (ifp->if_flags & IFF_UP) {
2121                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2122                                 rt2560_update_promisc(sc);
2123                         else
2124                                 rt2560_init(sc);
2125                 } else {
2126                         if (ifp->if_drv_flags & IFF_DRV_RUNNING)
2127                                 rt2560_stop(sc);
2128                 }
2129                 break;
2130
2131         default:
2132                 error = ieee80211_ioctl(ic, cmd, data);
2133         }
2134
2135         if (error == ENETRESET) {
2136                 if ((ifp->if_flags & IFF_UP) &&
2137                     (ifp->if_drv_flags & IFF_DRV_RUNNING) &&
2138                     (ic->ic_roaming != IEEE80211_ROAMING_MANUAL))
2139                         rt2560_init(sc);
2140                 error = 0;
2141         }
2142
2143         RAL_UNLOCK(sc);
2144
2145         return error;
2146 }
2147
2148 static void
2149 rt2560_bbp_write(struct rt2560_softc *sc, uint8_t reg, uint8_t val)
2150 {
2151         uint32_t tmp;
2152         int ntries;
2153
2154         for (ntries = 0; ntries < 100; ntries++) {
2155                 if (!(RAL_READ(sc, RT2560_BBPCSR) & RT2560_BBP_BUSY))
2156                         break;
2157                 DELAY(1);
2158         }
2159         if (ntries == 100) {
2160                 device_printf(sc->sc_dev, "could not write to BBP\n");
2161                 return;
2162         }
2163
2164         tmp = RT2560_BBP_WRITE | RT2560_BBP_BUSY | reg << 8 | val;
2165         RAL_WRITE(sc, RT2560_BBPCSR, tmp);
2166
2167         DPRINTFN(15, ("BBP R%u <- 0x%02x\n", reg, val));
2168 }
2169
2170 static uint8_t
2171 rt2560_bbp_read(struct rt2560_softc *sc, uint8_t reg)
2172 {
2173         uint32_t val;
2174         int ntries;
2175
2176         val = RT2560_BBP_BUSY | reg << 8;
2177         RAL_WRITE(sc, RT2560_BBPCSR, val);
2178
2179         for (ntries = 0; ntries < 100; ntries++) {
2180                 val = RAL_READ(sc, RT2560_BBPCSR);
2181                 if (!(val & RT2560_BBP_BUSY))
2182                         return val & 0xff;
2183                 DELAY(1);
2184         }
2185
2186         device_printf(sc->sc_dev, "could not read from BBP\n");
2187         return 0;
2188 }
2189
2190 static void
2191 rt2560_rf_write(struct rt2560_softc *sc, uint8_t reg, uint32_t val)
2192 {
2193         uint32_t tmp;
2194         int ntries;
2195
2196         for (ntries = 0; ntries < 100; ntries++) {
2197                 if (!(RAL_READ(sc, RT2560_RFCSR) & RT2560_RF_BUSY))
2198                         break;
2199                 DELAY(1);
2200         }
2201         if (ntries == 100) {
2202                 device_printf(sc->sc_dev, "could not write to RF\n");
2203                 return;
2204         }
2205
2206         tmp = RT2560_RF_BUSY | RT2560_RF_20BIT | (val & 0xfffff) << 2 |
2207             (reg & 0x3);
2208         RAL_WRITE(sc, RT2560_RFCSR, tmp);
2209
2210         /* remember last written value in sc */
2211         sc->rf_regs[reg] = val;
2212
2213         DPRINTFN(15, ("RF R[%u] <- 0x%05x\n", reg & 0x3, val & 0xfffff));
2214 }
2215
2216 static void
2217 rt2560_set_chan(struct rt2560_softc *sc, struct ieee80211_channel *c)
2218 {
2219         struct ieee80211com *ic = &sc->sc_ic;
2220         uint8_t power, tmp;
2221         u_int i, chan;
2222
2223         chan = ieee80211_chan2ieee(ic, c);
2224         if (chan == 0 || chan == IEEE80211_CHAN_ANY)
2225                 return;
2226
2227         if (IEEE80211_IS_CHAN_2GHZ(c))
2228                 power = min(sc->txpow[chan - 1], 31);
2229         else
2230                 power = 31;
2231
2232         /* adjust txpower using ifconfig settings */
2233         power -= (100 - ic->ic_txpowlimit) / 8;
2234
2235         DPRINTFN(2, ("setting channel to %u, txpower to %u\n", chan, power));
2236
2237         switch (sc->rf_rev) {
2238         case RT2560_RF_2522:
2239                 rt2560_rf_write(sc, RAL_RF1, 0x00814);
2240                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2522_r2[chan - 1]);
2241                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
2242                 break;
2243
2244         case RT2560_RF_2523:
2245                 rt2560_rf_write(sc, RAL_RF1, 0x08804);
2246                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2523_r2[chan - 1]);
2247                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x38044);
2248                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
2249                 break;
2250
2251         case RT2560_RF_2524:
2252                 rt2560_rf_write(sc, RAL_RF1, 0x0c808);
2253                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2524_r2[chan - 1]);
2254                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
2255                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
2256                 break;
2257
2258         case RT2560_RF_2525:
2259                 rt2560_rf_write(sc, RAL_RF1, 0x08808);
2260                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2525_hi_r2[chan - 1]);
2261                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
2262                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
2263
2264                 rt2560_rf_write(sc, RAL_RF1, 0x08808);
2265                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2525_r2[chan - 1]);
2266                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
2267                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00280 : 0x00286);
2268                 break;
2269
2270         case RT2560_RF_2525E:
2271                 rt2560_rf_write(sc, RAL_RF1, 0x08808);
2272                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2525e_r2[chan - 1]);
2273                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
2274                 rt2560_rf_write(sc, RAL_RF4, (chan == 14) ? 0x00286 : 0x00282);
2275                 break;
2276
2277         case RT2560_RF_2526:
2278                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2526_hi_r2[chan - 1]);
2279                 rt2560_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
2280                 rt2560_rf_write(sc, RAL_RF1, 0x08804);
2281
2282                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf2526_r2[chan - 1]);
2283                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x18044);
2284                 rt2560_rf_write(sc, RAL_RF4, (chan & 1) ? 0x00386 : 0x00381);
2285                 break;
2286
2287         /* dual-band RF */
2288         case RT2560_RF_5222:
2289                 for (i = 0; rt2560_rf5222[i].chan != chan; i++);
2290
2291                 rt2560_rf_write(sc, RAL_RF1, rt2560_rf5222[i].r1);
2292                 rt2560_rf_write(sc, RAL_RF2, rt2560_rf5222[i].r2);
2293                 rt2560_rf_write(sc, RAL_RF3, power << 7 | 0x00040);
2294                 rt2560_rf_write(sc, RAL_RF4, rt2560_rf5222[i].r4);
2295                 break;
2296         }
2297
2298         if (ic->ic_state != IEEE80211_S_SCAN) {
2299                 /* set Japan filter bit for channel 14 */
2300                 tmp = rt2560_bbp_read(sc, 70);
2301
2302                 tmp &= ~RT2560_JAPAN_FILTER;
2303                 if (chan == 14)
2304                         tmp |= RT2560_JAPAN_FILTER;
2305
2306                 rt2560_bbp_write(sc, 70, tmp);
2307
2308                 /* clear CRC errors */
2309                 RAL_READ(sc, RT2560_CNT0);
2310         }
2311 }
2312
2313 #if 0
2314 /*
2315  * Disable RF auto-tuning.
2316  */
2317 static void
2318 rt2560_disable_rf_tune(struct rt2560_softc *sc)
2319 {
2320         uint32_t tmp;
2321
2322         if (sc->rf_rev != RT2560_RF_2523) {
2323                 tmp = sc->rf_regs[RAL_RF1] & ~RAL_RF1_AUTOTUNE;
2324                 rt2560_rf_write(sc, RAL_RF1, tmp);
2325         }
2326
2327         tmp = sc->rf_regs[RAL_RF3] & ~RAL_RF3_AUTOTUNE;
2328         rt2560_rf_write(sc, RAL_RF3, tmp);
2329
2330         DPRINTFN(2, ("disabling RF autotune\n"));
2331 }
2332 #endif
2333
2334 /*
2335  * Refer to IEEE Std 802.11-1999 pp. 123 for more information on TSF
2336  * synchronization.
2337  */
2338 static void
2339 rt2560_enable_tsf_sync(struct rt2560_softc *sc)
2340 {
2341         struct ieee80211com *ic = &sc->sc_ic;
2342         uint16_t logcwmin, preload;
2343         uint32_t tmp;
2344
2345         /* first, disable TSF synchronization */
2346         RAL_WRITE(sc, RT2560_CSR14, 0);
2347
2348         tmp = 16 * ic->ic_bss->ni_intval;
2349         RAL_WRITE(sc, RT2560_CSR12, tmp);
2350
2351         RAL_WRITE(sc, RT2560_CSR13, 0);
2352
2353         logcwmin = 5;
2354         preload = (ic->ic_opmode == IEEE80211_M_STA) ? 384 : 1024;
2355         tmp = logcwmin << 16 | preload;
2356         RAL_WRITE(sc, RT2560_BCNOCSR, tmp);
2357
2358         /* finally, enable TSF synchronization */
2359         tmp = RT2560_ENABLE_TSF | RT2560_ENABLE_TBCN;
2360         if (ic->ic_opmode == IEEE80211_M_STA)
2361                 tmp |= RT2560_ENABLE_TSF_SYNC(1);
2362         else
2363                 tmp |= RT2560_ENABLE_TSF_SYNC(2) |
2364                        RT2560_ENABLE_BEACON_GENERATOR;
2365         RAL_WRITE(sc, RT2560_CSR14, tmp);
2366
2367         DPRINTF(("enabling TSF synchronization\n"));
2368 }
2369
2370 static void
2371 rt2560_update_plcp(struct rt2560_softc *sc)
2372 {
2373         struct ieee80211com *ic = &sc->sc_ic;
2374
2375         /* no short preamble for 1Mbps */
2376         RAL_WRITE(sc, RT2560_PLCP1MCSR, 0x00700400);
2377
2378         if (!(ic->ic_flags & IEEE80211_F_SHPREAMBLE)) {
2379                 /* values taken from the reference driver */
2380                 RAL_WRITE(sc, RT2560_PLCP2MCSR,   0x00380401);
2381                 RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x00150402);
2382                 RAL_WRITE(sc, RT2560_PLCP11MCSR,  0x000b8403);
2383         } else {
2384                 /* same values as above or'ed 0x8 */
2385                 RAL_WRITE(sc, RT2560_PLCP2MCSR,   0x00380409);
2386                 RAL_WRITE(sc, RT2560_PLCP5p5MCSR, 0x0015040a);
2387                 RAL_WRITE(sc, RT2560_PLCP11MCSR,  0x000b840b);
2388         }
2389
2390         DPRINTF(("updating PLCP for %s preamble\n",
2391             (ic->ic_flags & IEEE80211_F_SHPREAMBLE) ? "short" : "long"));
2392 }
2393
2394 /*
2395  * This function can be called by ieee80211_set_shortslottime(). Refer to
2396  * IEEE Std 802.11-1999 pp. 85 to know how these values are computed.
2397  */
2398 static void
2399 rt2560_update_slot(struct ifnet *ifp)
2400 {
2401         struct rt2560_softc *sc = ifp->if_softc;
2402         struct ieee80211com *ic = &sc->sc_ic;
2403         uint8_t slottime;
2404         uint16_t tx_sifs, tx_pifs, tx_difs, eifs;
2405         uint32_t tmp;
2406
2407         slottime = (ic->ic_flags & IEEE80211_F_SHSLOT) ? 9 : 20;
2408
2409         /* update the MAC slot boundaries */
2410         tx_sifs = RAL_SIFS - RT2560_TXRX_TURNAROUND;
2411         tx_pifs = tx_sifs + slottime;
2412         tx_difs = tx_sifs + 2 * slottime;
2413         eifs = (ic->ic_curmode == IEEE80211_MODE_11B) ? 364 : 60;
2414
2415         tmp = RAL_READ(sc, RT2560_CSR11);
2416         tmp = (tmp & ~0x1f00) | slottime << 8;
2417         RAL_WRITE(sc, RT2560_CSR11, tmp);
2418
2419         tmp = tx_pifs << 16 | tx_sifs;
2420         RAL_WRITE(sc, RT2560_CSR18, tmp);
2421
2422         tmp = eifs << 16 | tx_difs;
2423         RAL_WRITE(sc, RT2560_CSR19, tmp);
2424
2425         DPRINTF(("setting slottime to %uus\n", slottime));
2426 }
2427
2428 static void
2429 rt2560_set_basicrates(struct rt2560_softc *sc)
2430 {
2431         struct ieee80211com *ic = &sc->sc_ic;
2432
2433         /* update basic rate set */
2434         if (ic->ic_curmode == IEEE80211_MODE_11B) {
2435                 /* 11b basic rates: 1, 2Mbps */
2436                 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x3);
2437         } else if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) {
2438                 /* 11a basic rates: 6, 12, 24Mbps */
2439                 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x150);
2440         } else {
2441                 /* 11g basic rates: 1, 2, 5.5, 11, 6, 12, 24Mbps */
2442                 RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x15f);
2443         }
2444 }
2445
2446 static void
2447 rt2560_update_led(struct rt2560_softc *sc, int led1, int led2)
2448 {
2449         uint32_t tmp;
2450
2451         /* set ON period to 70ms and OFF period to 30ms */
2452         tmp = led1 << 16 | led2 << 17 | 70 << 8 | 30;
2453         RAL_WRITE(sc, RT2560_LEDCSR, tmp);
2454 }
2455
2456 static void
2457 rt2560_set_bssid(struct rt2560_softc *sc, uint8_t *bssid)
2458 {
2459         uint32_t tmp;
2460
2461         tmp = bssid[0] | bssid[1] << 8 | bssid[2] << 16 | bssid[3] << 24;
2462         RAL_WRITE(sc, RT2560_CSR5, tmp);
2463
2464         tmp = bssid[4] | bssid[5] << 8;
2465         RAL_WRITE(sc, RT2560_CSR6, tmp);
2466
2467         DPRINTF(("setting BSSID to %6D\n", bssid, ":"));
2468 }
2469
2470 static void
2471 rt2560_set_macaddr(struct rt2560_softc *sc, uint8_t *addr)
2472 {
2473         uint32_t tmp;
2474
2475         tmp = addr[0] | addr[1] << 8 | addr[2] << 16 | addr[3] << 24;
2476         RAL_WRITE(sc, RT2560_CSR3, tmp);
2477
2478         tmp = addr[4] | addr[5] << 8;
2479         RAL_WRITE(sc, RT2560_CSR4, tmp);
2480
2481         DPRINTF(("setting MAC address to %6D\n", addr, ":"));
2482 }
2483
2484 static void
2485 rt2560_get_macaddr(struct rt2560_softc *sc, uint8_t *addr)
2486 {
2487         uint32_t tmp;
2488
2489         tmp = RAL_READ(sc, RT2560_CSR3);
2490         addr[0] = tmp & 0xff;
2491         addr[1] = (tmp >>  8) & 0xff;
2492         addr[2] = (tmp >> 16) & 0xff;
2493         addr[3] = (tmp >> 24);
2494
2495         tmp = RAL_READ(sc, RT2560_CSR4);
2496         addr[4] = tmp & 0xff;
2497         addr[5] = (tmp >> 8) & 0xff;
2498 }
2499
2500 static void
2501 rt2560_update_promisc(struct rt2560_softc *sc)
2502 {
2503         struct ifnet *ifp = sc->sc_ic.ic_ifp;
2504         uint32_t tmp;
2505
2506         tmp = RAL_READ(sc, RT2560_RXCSR0);
2507
2508         tmp &= ~RT2560_DROP_NOT_TO_ME;
2509         if (!(ifp->if_flags & IFF_PROMISC))
2510                 tmp |= RT2560_DROP_NOT_TO_ME;
2511
2512         RAL_WRITE(sc, RT2560_RXCSR0, tmp);
2513
2514         DPRINTF(("%s promiscuous mode\n", (ifp->if_flags & IFF_PROMISC) ?
2515             "entering" : "leaving"));
2516 }
2517
2518 static const char *
2519 rt2560_get_rf(int rev)
2520 {
2521         switch (rev) {
2522         case RT2560_RF_2522:    return "RT2522";
2523         case RT2560_RF_2523:    return "RT2523";
2524         case RT2560_RF_2524:    return "RT2524";
2525         case RT2560_RF_2525:    return "RT2525";
2526         case RT2560_RF_2525E:   return "RT2525e";
2527         case RT2560_RF_2526:    return "RT2526";
2528         case RT2560_RF_5222:    return "RT5222";
2529         default:                return "unknown";
2530         }
2531 }
2532
2533 static void
2534 rt2560_read_eeprom(struct rt2560_softc *sc)
2535 {
2536         uint16_t val;
2537         int i;
2538
2539         val = rt2560_eeprom_read(sc, RT2560_EEPROM_CONFIG0);
2540         sc->rf_rev =   (val >> 11) & 0x7;
2541         sc->hw_radio = (val >> 10) & 0x1;
2542         sc->led_mode = (val >> 6)  & 0x7;
2543         sc->rx_ant =   (val >> 4)  & 0x3;
2544         sc->tx_ant =   (val >> 2)  & 0x3;
2545         sc->nb_ant =   val & 0x3;
2546
2547         /* read default values for BBP registers */
2548         for (i = 0; i < 16; i++) {
2549                 val = rt2560_eeprom_read(sc, RT2560_EEPROM_BBP_BASE + i);
2550                 sc->bbp_prom[i].reg = val >> 8;
2551                 sc->bbp_prom[i].val = val & 0xff;
2552         }
2553
2554         /* read Tx power for all b/g channels */
2555         for (i = 0; i < 14 / 2; i++) {
2556                 val = rt2560_eeprom_read(sc, RT2560_EEPROM_TXPOWER + i);
2557                 sc->txpow[i * 2] = val >> 8;
2558                 sc->txpow[i * 2 + 1] = val & 0xff;
2559         }
2560 }
2561
2562 static int
2563 rt2560_bbp_init(struct rt2560_softc *sc)
2564 {
2565 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
2566         int i, ntries;
2567
2568         /* wait for BBP to be ready */
2569         for (ntries = 0; ntries < 100; ntries++) {
2570                 if (rt2560_bbp_read(sc, RT2560_BBP_VERSION) != 0)
2571                         break;
2572                 DELAY(1);
2573         }
2574         if (ntries == 100) {
2575                 device_printf(sc->sc_dev, "timeout waiting for BBP\n");
2576                 return EIO;
2577         }
2578
2579         /* initialize BBP registers to default values */
2580         for (i = 0; i < N(rt2560_def_bbp); i++) {
2581                 rt2560_bbp_write(sc, rt2560_def_bbp[i].reg,
2582                     rt2560_def_bbp[i].val);
2583         }
2584 #if 0
2585         /* initialize BBP registers to values stored in EEPROM */
2586         for (i = 0; i < 16; i++) {
2587                 if (sc->bbp_prom[i].reg == 0xff)
2588                         continue;
2589                 rt2560_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
2590         }
2591 #endif
2592
2593         return 0;
2594 #undef N
2595 }
2596
2597 static void
2598 rt2560_set_txantenna(struct rt2560_softc *sc, int antenna)
2599 {
2600         uint32_t tmp;
2601         uint8_t tx;
2602
2603         tx = rt2560_bbp_read(sc, RT2560_BBP_TX) & ~RT2560_BBP_ANTMASK;
2604         if (antenna == 1)
2605                 tx |= RT2560_BBP_ANTA;
2606         else if (antenna == 2)
2607                 tx |= RT2560_BBP_ANTB;
2608         else
2609                 tx |= RT2560_BBP_DIVERSITY;
2610
2611         /* need to force I/Q flip for RF 2525e, 2526 and 5222 */
2612         if (sc->rf_rev == RT2560_RF_2525E || sc->rf_rev == RT2560_RF_2526 ||
2613             sc->rf_rev == RT2560_RF_5222)
2614                 tx |= RT2560_BBP_FLIPIQ;
2615
2616         rt2560_bbp_write(sc, RT2560_BBP_TX, tx);
2617
2618         /* update values for CCK and OFDM in BBPCSR1 */
2619         tmp = RAL_READ(sc, RT2560_BBPCSR1) & ~0x00070007;
2620         tmp |= (tx & 0x7) << 16 | (tx & 0x7);
2621         RAL_WRITE(sc, RT2560_BBPCSR1, tmp);
2622 }
2623
2624 static void
2625 rt2560_set_rxantenna(struct rt2560_softc *sc, int antenna)
2626 {
2627         uint8_t rx;
2628
2629         rx = rt2560_bbp_read(sc, RT2560_BBP_RX) & ~RT2560_BBP_ANTMASK;
2630         if (antenna == 1)
2631                 rx |= RT2560_BBP_ANTA;
2632         else if (antenna == 2)
2633                 rx |= RT2560_BBP_ANTB;
2634         else
2635                 rx |= RT2560_BBP_DIVERSITY;
2636
2637         /* need to force no I/Q flip for RF 2525e and 2526 */
2638         if (sc->rf_rev == RT2560_RF_2525E || sc->rf_rev == RT2560_RF_2526)
2639                 rx &= ~RT2560_BBP_FLIPIQ;
2640
2641         rt2560_bbp_write(sc, RT2560_BBP_RX, rx);
2642 }
2643
2644 static void
2645 rt2560_init(void *priv)
2646 {
2647 #define N(a)    (sizeof (a) / sizeof ((a)[0]))
2648         struct rt2560_softc *sc = priv;
2649         struct ieee80211com *ic = &sc->sc_ic;
2650         struct ifnet *ifp = ic->ic_ifp;
2651         uint32_t tmp;
2652         int i;
2653
2654         RAL_LOCK(sc);
2655
2656         rt2560_stop(sc);
2657
2658         /* setup tx rings */
2659         tmp = RT2560_PRIO_RING_COUNT << 24 |
2660               RT2560_ATIM_RING_COUNT << 16 |
2661               RT2560_TX_RING_COUNT   <<  8 |
2662               RT2560_TX_DESC_SIZE;
2663
2664         /* rings must be initialized in this exact order */
2665         RAL_WRITE(sc, RT2560_TXCSR2, tmp);
2666         RAL_WRITE(sc, RT2560_TXCSR3, sc->txq.physaddr);
2667         RAL_WRITE(sc, RT2560_TXCSR5, sc->prioq.physaddr);
2668         RAL_WRITE(sc, RT2560_TXCSR4, sc->atimq.physaddr);
2669         RAL_WRITE(sc, RT2560_TXCSR6, sc->bcnq.physaddr);
2670
2671         /* setup rx ring */
2672         tmp = RT2560_RX_RING_COUNT << 8 | RT2560_RX_DESC_SIZE;
2673
2674         RAL_WRITE(sc, RT2560_RXCSR1, tmp);
2675         RAL_WRITE(sc, RT2560_RXCSR2, sc->rxq.physaddr);
2676
2677         /* initialize MAC registers to default values */
2678         for (i = 0; i < N(rt2560_def_mac); i++)
2679                 RAL_WRITE(sc, rt2560_def_mac[i].reg, rt2560_def_mac[i].val);
2680
2681         IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
2682         rt2560_set_macaddr(sc, ic->ic_myaddr);
2683
2684         /* set basic rate set (will be updated later) */
2685         RAL_WRITE(sc, RT2560_ARSP_PLCP_1, 0x153);
2686
2687         rt2560_set_txantenna(sc, sc->tx_ant);
2688         rt2560_set_rxantenna(sc, sc->rx_ant);
2689         rt2560_update_slot(ifp);
2690         rt2560_update_plcp(sc);
2691         rt2560_update_led(sc, 0, 0);
2692
2693         RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
2694         RAL_WRITE(sc, RT2560_CSR1, RT2560_HOST_READY);
2695
2696         if (rt2560_bbp_init(sc) != 0) {
2697                 rt2560_stop(sc);
2698                 RAL_UNLOCK(sc);
2699                 return;
2700         }
2701
2702         /* set default BSS channel */
2703         rt2560_set_chan(sc, ic->ic_curchan);
2704
2705         /* kick Rx */
2706         tmp = RT2560_DROP_PHY_ERROR | RT2560_DROP_CRC_ERROR;
2707         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2708                 tmp |= RT2560_DROP_CTL | RT2560_DROP_VERSION_ERROR;
2709                 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2710                         tmp |= RT2560_DROP_TODS;
2711                 if (!(ifp->if_flags & IFF_PROMISC))
2712                         tmp |= RT2560_DROP_NOT_TO_ME;
2713         }
2714         RAL_WRITE(sc, RT2560_RXCSR0, tmp);
2715
2716         /* clear old FCS and Rx FIFO errors */
2717         RAL_READ(sc, RT2560_CNT0);
2718         RAL_READ(sc, RT2560_CNT4);
2719
2720         /* clear any pending interrupts */
2721         RAL_WRITE(sc, RT2560_CSR7, 0xffffffff);
2722
2723         /* enable interrupts */
2724         RAL_WRITE(sc, RT2560_CSR8, RT2560_INTR_MASK);
2725
2726         ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
2727         ifp->if_drv_flags |= IFF_DRV_RUNNING;
2728
2729         if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2730                 if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
2731                         ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
2732         } else
2733                 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
2734
2735         RAL_UNLOCK(sc);
2736 #undef N
2737 }
2738
2739 void
2740 rt2560_stop(void *priv)
2741 {
2742         struct rt2560_softc *sc = priv;
2743         struct ieee80211com *ic = &sc->sc_ic;
2744         struct ifnet *ifp = ic->ic_ifp;
2745
2746         sc->sc_tx_timer = 0;
2747         ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE);
2748
2749         ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
2750
2751         /* abort Tx */
2752         RAL_WRITE(sc, RT2560_TXCSR0, RT2560_ABORT_TX);
2753
2754         /* disable Rx */
2755         RAL_WRITE(sc, RT2560_RXCSR0, RT2560_DISABLE_RX);
2756
2757         /* reset ASIC (imply reset BBP) */
2758         RAL_WRITE(sc, RT2560_CSR1, RT2560_RESET_ASIC);
2759         RAL_WRITE(sc, RT2560_CSR1, 0);
2760
2761         /* disable interrupts */
2762         RAL_WRITE(sc, RT2560_CSR8, 0xffffffff);
2763
2764         /* reset Tx and Rx rings */
2765         rt2560_reset_tx_ring(sc, &sc->txq);
2766         rt2560_reset_tx_ring(sc, &sc->atimq);
2767         rt2560_reset_tx_ring(sc, &sc->prioq);
2768         rt2560_reset_tx_ring(sc, &sc->bcnq);
2769         rt2560_reset_rx_ring(sc, &sc->rxq);
2770 }
2771
2772 static int
2773 rt2560_raw_xmit(struct ieee80211_node *ni, struct mbuf *m,
2774         const struct ieee80211_bpf_params *params)
2775 {
2776         struct ieee80211com *ic = ni->ni_ic;
2777         struct ifnet *ifp = ic->ic_ifp;
2778         struct rt2560_softc *sc = ifp->if_softc;
2779
2780         RAL_LOCK(sc);
2781
2782         /* prevent management frames from being sent if we're not ready */
2783         if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) {
2784                 RAL_UNLOCK(sc);
2785                 return ENETDOWN;
2786         }
2787         if (sc->prioq.queued >= RT2560_PRIO_RING_COUNT) {
2788                 ifp->if_drv_flags |= IFF_DRV_OACTIVE;
2789                 RAL_UNLOCK(sc);
2790                 return ENOBUFS;         /* XXX */
2791         }
2792
2793         if (bpf_peers_present(ic->ic_rawbpf))
2794                 bpf_mtap(ic->ic_rawbpf, m);
2795
2796         ifp->if_opackets++;
2797
2798         if (params == NULL) {
2799                 /*
2800                  * Legacy path; interpret frame contents to decide
2801                  * precisely how to send the frame.
2802                  */
2803                 if (rt2560_tx_mgt(sc, m, ni) != 0)
2804                         goto bad;
2805         } else {
2806                 /*
2807                  * Caller supplied explicit parameters to use in
2808                  * sending the frame.
2809                  */
2810                 if (rt2560_tx_raw(sc, m, ni, params))
2811                         goto bad;
2812         }
2813         sc->sc_tx_timer = 5;
2814         callout_reset(&sc->watchdog_ch, hz, rt2560_watchdog, sc);
2815
2816         RAL_UNLOCK(sc);
2817
2818         return 0;
2819 bad:
2820         ifp->if_oerrors++;
2821         ieee80211_free_node(ni);
2822         RAL_UNLOCK(sc);
2823         return EIO;             /* XXX */
2824 }