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