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