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