Lines Matching refs:mac
515 struct bwn_mac *mac;
540 mac = malloc(sizeof(*mac), M_DEVBUF, M_WAITOK | M_ZERO);
541 mac->mac_sc = sc;
542 mac->mac_status = BWN_MAC_STATUS_UNINIT;
544 mac->mac_flags |= BWN_MAC_FLAG_BADFRAME_PREEMP;
546 TASK_INIT(&mac->mac_hwreset, 0, bwn_hwreset, mac);
547 TASK_INIT(&mac->mac_intrtask, 0, bwn_intrtask, mac);
548 TASK_INIT(&mac->mac_txpower, 0, bwn_txpwr, mac);
550 error = bwn_attach_core(mac);
553 bwn_led_attach(mac);
558 mac->mac_phy.analog, mac->mac_phy.type, mac->mac_phy.rev,
559 mac->mac_phy.rf_manuf, mac->mac_phy.rf_ver,
560 mac->mac_phy.rf_rev);
561 if (mac->mac_flags & BWN_MAC_FLAG_DMA)
563 mac->mac_method.dma.dmatype);
582 mac->mac_intr_spec = bwn_res_spec_legacy;
587 mac->mac_intr_spec = bwn_res_spec_msi;
588 mac->mac_msi = 1;
592 error = bus_alloc_resources(dev, mac->mac_intr_spec,
593 mac->mac_res_irq);
600 if (mac->mac_msi == 0)
601 error = bus_setup_intr(dev, mac->mac_res_irq[0],
602 INTR_TYPE_NET | INTR_MPSAFE, bwn_intr, NULL, mac,
603 &mac->mac_intrhand[0]);
606 error = bus_setup_intr(dev, mac->mac_res_irq[i],
607 INTR_TYPE_NET | INTR_MPSAFE, bwn_intr, NULL, mac,
608 &mac->mac_intrhand[i]);
617 TAILQ_INSERT_TAIL(&sc->sc_maclist, mac, mac_list);
630 free(mac, M_DEVBUF);
708 bwn_phy_detach(struct bwn_mac *mac)
711 if (mac->mac_phy.detach != NULL)
712 mac->mac_phy.detach(mac);
719 struct bwn_mac *mac = sc->sc_curmac;
729 bwn_dma_free(mac);
734 bwn_phy_detach(mac);
735 ieee80211_draintask(ic, &mac->mac_hwreset);
736 ieee80211_draintask(ic, &mac->mac_txpower);
739 taskqueue_drain(sc->sc_tq, &mac->mac_intrtask);
743 if (mac->mac_intrhand[i] != NULL) {
744 bus_teardown_intr(dev, mac->mac_res_irq[i],
745 mac->mac_intrhand[i]);
746 mac->mac_intrhand[i] = NULL;
749 bus_release_resources(dev, mac->mac_intr_spec, mac->mac_res_irq);
750 if (mac->mac_msi != 0)
753 bwn_release_firmware(mac);
851 struct bwn_mac *mac = sc->sc_curmac;
859 if ((sc->sc_flags & BWN_FLAG_RUNNING) == 0 || mac == NULL ||
860 mac->mac_status < BWN_MAC_STATUS_STARTED)
901 struct bwn_mac *mac = sc->sc_curmac;
903 int pktlen = roundup(m->m_pkthdr.len + BWN_HDRSIZE(mac), 4);
907 if (mac->mac_flags & BWN_MAC_FLAG_DMA) {
908 dr = bwn_dma_select(mac, M_WME_GETAC(m));
915 tq = bwn_pio_select(mac, M_WME_GETAC(m));
929 struct bwn_mac *mac = sc->sc_curmac;
934 if (m->m_pkthdr.len < IEEE80211_MIN_LEN || mac == NULL) {
939 error = (mac->mac_flags & BWN_MAC_FLAG_DMA) ?
940 bwn_dma_tx_start(mac, ni, &m) : bwn_pio_tx_start(mac, ni, &m);
949 bwn_pio_tx_start(struct bwn_mac *mac, struct ieee80211_node *ni,
954 struct bwn_softc *sc = mac->mac_sc;
966 tq = bwn_pio_select(mac, M_WME_GETAC(m));
972 error = bwn_set_txhdr(mac, ni, m, &txhdr, BWN_PIO_COOKIE(tq, tp));
979 tq->tq_used += roundup(m->m_pkthdr.len + BWN_HDRSIZE(mac), 4);
1000 ctl32 = bwn_pio_write_multi_4(mac, tq,
1001 (BWN_PIO_READ_4(mac, tq, BWN_PIO8_TXCTL) |
1003 (const uint8_t *)&txhdr, BWN_HDRSIZE(mac));
1005 ctl32 = bwn_pio_write_multi_4(mac, tq, ctl32,
1007 bwn_pio_write_4(mac, tq, BWN_PIO_TXCTL,
1010 ctl16 = bwn_pio_write_multi_2(mac, tq,
1011 (bwn_pio_read_2(mac, tq, BWN_PIO_TXCTL) |
1013 (const uint8_t *)&txhdr, BWN_HDRSIZE(mac));
1014 ctl16 = bwn_pio_write_mbuf_2(mac, tq, ctl16, m);
1015 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXCTL,
1023 bwn_pio_select(struct bwn_mac *mac, uint8_t prio)
1026 if ((mac->mac_flags & BWN_MAC_FLAG_WME) == 0)
1027 return (&mac->mac_method.pio.wme[WME_AC_BE]);
1031 return (&mac->mac_method.pio.wme[WME_AC_BE]);
1033 return (&mac->mac_method.pio.wme[WME_AC_BK]);
1035 return (&mac->mac_method.pio.wme[WME_AC_VI]);
1037 return (&mac->mac_method.pio.wme[WME_AC_VO]);
1044 bwn_dma_tx_start(struct bwn_mac *mac, struct ieee80211_node *ni,
1048 &(txhdr_cache[(slot / BWN_TX_SLOTS_PER_FRAME) * BWN_HDRSIZE(mac)])
1049 struct bwn_dma *dma = &mac->mac_method.dma;
1050 struct bwn_dma_ring *dr = bwn_dma_select(mac, M_WME_GETAC(*mp));
1053 struct bwn_softc *sc = mac->mac_sc;
1075 BWN_GET_TXHDRCACHE(slot), BWN_HDRSIZE(mac), bwn_dma_ring_addr,
1084 dr->setdesc(dr, desc, mt->mt_paddr, BWN_HDRSIZE(mac), 1, 0, 0);
1154 bwn_attach_core(struct bwn_mac *mac)
1156 struct bwn_softc *sc = mac->mac_sc;
1162 if (bwn_is_bus_siba(mac)) {
1194 bwn_reset_core(mac, have_bg);
1199 error = bwn_phy_getinfo(mac, have_bg);
1214 if (mac->mac_phy.type == BWN_PHYTYPE_A)
1216 else if (mac->mac_phy.type == BWN_PHYTYPE_G ||
1217 mac->mac_phy.type == BWN_PHYTYPE_N ||
1218 mac->mac_phy.type == BWN_PHYTYPE_LP)
1222 mac->mac_phy.type));
1228 if (mac->mac_phy.type != BWN_PHYTYPE_LP &&
1229 mac->mac_phy.type != BWN_PHYTYPE_N) {
1237 mac->mac_phy.phy_n = NULL;
1239 if (mac->mac_phy.type == BWN_PHYTYPE_G) {
1240 mac->mac_phy.attach = bwn_phy_g_attach;
1241 mac->mac_phy.detach = bwn_phy_g_detach;
1242 mac->mac_phy.prepare_hw = bwn_phy_g_prepare_hw;
1243 mac->mac_phy.init_pre = bwn_phy_g_init_pre;
1244 mac->mac_phy.init = bwn_phy_g_init;
1245 mac->mac_phy.exit = bwn_phy_g_exit;
1246 mac->mac_phy.phy_read = bwn_phy_g_read;
1247 mac->mac_phy.phy_write = bwn_phy_g_write;
1248 mac->mac_phy.rf_read = bwn_phy_g_rf_read;
1249 mac->mac_phy.rf_write = bwn_phy_g_rf_write;
1250 mac->mac_phy.use_hwpctl = bwn_phy_g_hwpctl;
1251 mac->mac_phy.rf_onoff = bwn_phy_g_rf_onoff;
1252 mac->mac_phy.switch_analog = bwn_phy_switch_analog;
1253 mac->mac_phy.switch_channel = bwn_phy_g_switch_channel;
1254 mac->mac_phy.get_default_chan = bwn_phy_g_get_default_chan;
1255 mac->mac_phy.set_antenna = bwn_phy_g_set_antenna;
1256 mac->mac_phy.set_im = bwn_phy_g_im;
1257 mac->mac_phy.recalc_txpwr = bwn_phy_g_recalc_txpwr;
1258 mac->mac_phy.set_txpwr = bwn_phy_g_set_txpwr;
1259 mac->mac_phy.task_15s = bwn_phy_g_task_15s;
1260 mac->mac_phy.task_60s = bwn_phy_g_task_60s;
1261 } else if (mac->mac_phy.type == BWN_PHYTYPE_LP) {
1262 mac->mac_phy.init_pre = bwn_phy_lp_init_pre;
1263 mac->mac_phy.init = bwn_phy_lp_init;
1264 mac->mac_phy.phy_read = bwn_phy_lp_read;
1265 mac->mac_phy.phy_write = bwn_phy_lp_write;
1266 mac->mac_phy.phy_maskset = bwn_phy_lp_maskset;
1267 mac->mac_phy.rf_read = bwn_phy_lp_rf_read;
1268 mac->mac_phy.rf_write = bwn_phy_lp_rf_write;
1269 mac->mac_phy.rf_onoff = bwn_phy_lp_rf_onoff;
1270 mac->mac_phy.switch_analog = bwn_phy_lp_switch_analog;
1271 mac->mac_phy.switch_channel = bwn_phy_lp_switch_channel;
1272 mac->mac_phy.get_default_chan = bwn_phy_lp_get_default_chan;
1273 mac->mac_phy.set_antenna = bwn_phy_lp_set_antenna;
1274 mac->mac_phy.task_60s = bwn_phy_lp_task_60s;
1275 } else if (mac->mac_phy.type == BWN_PHYTYPE_N) {
1276 mac->mac_phy.attach = bwn_phy_n_attach;
1277 mac->mac_phy.detach = bwn_phy_n_detach;
1278 mac->mac_phy.prepare_hw = bwn_phy_n_prepare_hw;
1279 mac->mac_phy.init_pre = bwn_phy_n_init_pre;
1280 mac->mac_phy.init = bwn_phy_n_init;
1281 mac->mac_phy.exit = bwn_phy_n_exit;
1282 mac->mac_phy.phy_read = bwn_phy_n_read;
1283 mac->mac_phy.phy_write = bwn_phy_n_write;
1284 mac->mac_phy.rf_read = bwn_phy_n_rf_read;
1285 mac->mac_phy.rf_write = bwn_phy_n_rf_write;
1286 mac->mac_phy.use_hwpctl = bwn_phy_n_hwpctl;
1287 mac->mac_phy.rf_onoff = bwn_phy_n_rf_onoff;
1288 mac->mac_phy.switch_analog = bwn_phy_n_switch_analog;
1289 mac->mac_phy.switch_channel = bwn_phy_n_switch_channel;
1290 mac->mac_phy.get_default_chan = bwn_phy_n_get_default_chan;
1291 mac->mac_phy.set_antenna = bwn_phy_n_set_antenna;
1292 mac->mac_phy.set_im = bwn_phy_n_im;
1293 mac->mac_phy.recalc_txpwr = bwn_phy_n_recalc_txpwr;
1294 mac->mac_phy.set_txpwr = bwn_phy_n_set_txpwr;
1295 mac->mac_phy.task_15s = bwn_phy_n_task_15s;
1296 mac->mac_phy.task_60s = bwn_phy_n_task_60s;
1299 mac->mac_phy.type);
1304 mac->mac_phy.gmode = have_bg;
1305 if (mac->mac_phy.attach != NULL) {
1306 error = mac->mac_phy.attach(mac);
1313 bwn_reset_core(mac, have_bg);
1315 error = bwn_chiptest(mac);
1318 error = bwn_setup_channels(mac, have_bg, have_a);
1325 sc->sc_curmac = mac;
1327 error = bwn_dma_attach(mac);
1333 mac->mac_phy.switch_analog(mac, 0);
1338 bwn_release_firmware(mac);
1348 bwn_reset_core(struct bwn_mac *mac, int g_mode)
1350 struct bwn_softc *sc = mac->mac_sc;
1361 if (mac->mac_phy.type == BWN_PHYTYPE_N)
1379 if (mac->mac_phy.switch_analog != NULL)
1380 mac->mac_phy.switch_analog(mac, 1);
1382 ctl = BWN_READ_4(mac, BWN_MACCTL) & ~BWN_MACCTL_GMODE;
1385 BWN_WRITE_4(mac, BWN_MACCTL, ctl | BWN_MACCTL_IHR_ON);
1389 bwn_phy_getinfo(struct bwn_mac *mac, int gmode)
1391 struct bwn_phy *phy = &mac->mac_phy;
1392 struct bwn_softc *sc = mac->mac_sc;
1396 tmp = BWN_READ_2(mac, BWN_PHYVER);
1419 BWN_WRITE_2(mac, BWN_RFCTL, BWN_RFCTL_ID);
1420 tmp = BWN_READ_2(mac, BWN_RFDATALO);
1421 BWN_WRITE_2(mac, BWN_RFCTL, BWN_RFCTL_ID);
1422 tmp |= (uint32_t)BWN_READ_2(mac, BWN_RFDATAHI) << 16;
1460 bwn_chiptest(struct bwn_mac *mac)
1464 struct bwn_softc *sc = mac->mac_sc;
1469 backup = bwn_shm_read_4(mac, BWN_SHARED, 0);
1471 bwn_shm_write_4(mac, BWN_SHARED, 0, TESTVAL0);
1472 if (bwn_shm_read_4(mac, BWN_SHARED, 0) != TESTVAL0)
1474 bwn_shm_write_4(mac, BWN_SHARED, 0, TESTVAL1);
1475 if (bwn_shm_read_4(mac, BWN_SHARED, 0) != TESTVAL1)
1478 bwn_shm_write_4(mac, BWN_SHARED, 0, backup);
1482 BWN_WRITE_2(mac, BWN_TSF_CFP_START, 0xaaaa);
1483 BWN_WRITE_4(mac, BWN_TSF_CFP_START, 0xccccbbbb);
1484 if (BWN_READ_2(mac, BWN_TSF_CFP_START_LOW) != 0xbbbb)
1486 if (BWN_READ_2(mac, BWN_TSF_CFP_START_HIGH) != 0xcccc)
1489 BWN_WRITE_4(mac, BWN_TSF_CFP_START, 0);
1491 v = BWN_READ_4(mac, BWN_MACCTL) | BWN_MACCTL_GMODE;
1504 bwn_setup_channels(struct bwn_mac *mac, int have_bg, int have_a)
1506 struct bwn_softc *sc = mac->mac_sc;
1533 mac->mac_phy.supports_2ghz = have_bg;
1534 mac->mac_phy.supports_5ghz = have_a;
1540 bwn_shm_read_4(struct bwn_mac *mac, uint16_t way, uint16_t offset)
1544 BWN_ASSERT_LOCKED(mac->mac_sc);
1550 bwn_shm_ctlword(mac, way, offset >> 2);
1551 ret = BWN_READ_2(mac, BWN_SHM_DATA_UNALIGNED);
1553 bwn_shm_ctlword(mac, way, (offset >> 2) + 1);
1554 ret |= BWN_READ_2(mac, BWN_SHM_DATA);
1559 bwn_shm_ctlword(mac, way, offset);
1560 ret = BWN_READ_4(mac, BWN_SHM_DATA);
1566 bwn_shm_read_2(struct bwn_mac *mac, uint16_t way, uint16_t offset)
1570 BWN_ASSERT_LOCKED(mac->mac_sc);
1576 bwn_shm_ctlword(mac, way, offset >> 2);
1577 ret = BWN_READ_2(mac, BWN_SHM_DATA_UNALIGNED);
1582 bwn_shm_ctlword(mac, way, offset);
1583 ret = BWN_READ_2(mac, BWN_SHM_DATA);
1590 bwn_shm_ctlword(struct bwn_mac *mac, uint16_t way,
1598 BWN_WRITE_4(mac, BWN_SHM_CONTROL, control);
1602 bwn_shm_write_4(struct bwn_mac *mac, uint16_t way, uint16_t offset,
1605 BWN_ASSERT_LOCKED(mac->mac_sc);
1611 bwn_shm_ctlword(mac, way, offset >> 2);
1612 BWN_WRITE_2(mac, BWN_SHM_DATA_UNALIGNED,
1614 bwn_shm_ctlword(mac, way, (offset >> 2) + 1);
1615 BWN_WRITE_2(mac, BWN_SHM_DATA, value & 0xffff);
1620 bwn_shm_ctlword(mac, way, offset);
1621 BWN_WRITE_4(mac, BWN_SHM_DATA, value);
1625 bwn_shm_write_2(struct bwn_mac *mac, uint16_t way, uint16_t offset,
1628 BWN_ASSERT_LOCKED(mac->mac_sc);
1634 bwn_shm_ctlword(mac, way, offset >> 2);
1635 BWN_WRITE_2(mac, BWN_SHM_DATA_UNALIGNED, value);
1640 bwn_shm_ctlword(mac, way, offset);
1641 BWN_WRITE_2(mac, BWN_SHM_DATA, value);
1664 struct bwn_mac *mac = sc->sc_curmac;
1668 mac->mac_status < BWN_MAC_STATUS_STARTED) {
1697 struct bwn_mac *mac;
1701 mac = (struct bwn_mac *)sc->sc_curmac;
1702 bwn_set_slot_time(mac, IEEE80211_GET_SLOTTIME(ic));
1718 struct bwn_mac *mac = sc->sc_curmac;
1721 mac = sc->sc_curmac;
1722 if (mac != NULL && mac->mac_status >= BWN_MAC_STATUS_INITED) {
1727 bwn_set_opmode(mac);
1739 struct bwn_mac *mac = sc->sc_curmac;
1744 mac = sc->sc_curmac;
1745 if (mac != NULL && mac->mac_status >= BWN_MAC_STATUS_INITED) {
1746 bwn_mac_suspend(mac);
1749 bwn_wme_loadparams(mac, wmep, bwn_wme_shm_offsets[i]);
1751 bwn_mac_enable(mac);
1761 struct bwn_mac *mac;
1764 mac = sc->sc_curmac;
1765 if (mac != NULL && mac->mac_status >= BWN_MAC_STATUS_INITED) {
1767 bwn_set_opmode(mac);
1769 bwn_hf_write(mac, bwn_hf_read(mac) | BWN_HF_SKIP_CFP_UPDATE);
1778 struct bwn_mac *mac;
1781 mac = sc->sc_curmac;
1782 if (mac != NULL && mac->mac_status >= BWN_MAC_STATUS_INITED) {
1784 bwn_set_opmode(mac);
1785 bwn_hf_write(mac, bwn_hf_read(mac) & ~BWN_HF_SKIP_CFP_UPDATE);
1794 struct bwn_mac *mac = sc->sc_curmac;
1795 struct bwn_phy *phy = &mac->mac_phy;
1803 bwn_mac_suspend(mac);
1804 bwn_set_txretry(mac, BWN_RETRY_SHORT, BWN_RETRY_LONG);
1807 bwn_switch_channel(mac, chan);
1813 bwn_phy_txpower_check(mac, BWN_TXPWR_IGNORE_TIME |
1817 bwn_set_txantenna(mac, BWN_ANT_DEFAULT);
1819 phy->set_antenna(mac, BWN_ANT_DEFAULT);
1823 bwn_rf_turnon(mac);
1824 if (!(mac->mac_flags & BWN_MAC_FLAG_RADIO_ON))
1828 bwn_rf_turnoff(mac);
1831 bwn_mac_enable(mac);
1841 const uint8_t mac[IEEE80211_ADDR_LEN])
1873 ieee80211_media_status, mac);
1890 struct bwn_mac *mac;
1904 mac = sc->sc_curmac;
1905 if (mac->mac_status == BWN_MAC_STATUS_UNINIT) {
1906 error = bwn_core_init(mac);
1910 if (mac->mac_status == BWN_MAC_STATUS_INITED)
1911 bwn_core_start(mac);
1913 bwn_set_opmode(mac);
1914 bwn_set_pretbtt(mac);
1915 bwn_spu_setdelay(mac, 0);
1916 bwn_set_macaddr(mac);
1928 struct bwn_mac *mac = sc->sc_curmac;
1934 if (mac->mac_status >= BWN_MAC_STATUS_INITED) {
1936 bwn_set_opmode(mac);
1937 bwn_set_macaddr(mac);
1940 if (mac->mac_status >= BWN_MAC_STATUS_STARTED)
1941 bwn_core_stop(mac);
1946 bwn_core_exit(mac);
2001 bwn_core_init(struct bwn_mac *mac)
2003 struct bwn_softc *sc = mac->mac_sc;
2007 KASSERT(mac->mac_status == BWN_MAC_STATUS_UNINIT,
2010 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: called\n", __func__);
2014 bwn_reset_core(mac, mac->mac_phy.gmode);
2016 mac->mac_flags &= ~BWN_MAC_FLAG_DFQVALID;
2017 mac->mac_flags |= BWN_MAC_FLAG_RADIO_ON;
2018 mac->mac_phy.hwpctl = (bwn_hwpctl) ? 1 : 0;
2019 BWN_GETTIME(mac->mac_phy.nexttime);
2020 mac->mac_phy.txerrors = BWN_TXERROR_MAX;
2021 bzero(&mac->mac_stats, sizeof(mac->mac_stats));
2022 mac->mac_stats.link_noise = -95;
2023 mac->mac_reason_intr = 0;
2024 bzero(mac->mac_reason, sizeof(mac->mac_reason));
2025 mac->mac_intr_mask = BWN_INTR_MASKTEMPLATE;
2028 mac->mac_intr_mask &= ~BWN_INTR_PHY_TXERR;
2030 mac->mac_suspended = 1;
2031 mac->mac_task_state = 0;
2032 memset(&mac->mac_noise, 0, sizeof(mac->mac_noise));
2034 mac->mac_phy.init_pre(mac);
2039 bwn_bt_disable(mac);
2040 if (mac->mac_phy.prepare_hw) {
2041 error = mac->mac_phy.prepare_hw(mac);
2045 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: chip_init\n", __func__);
2046 error = bwn_chip_init(mac);
2049 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_COREREV,
2051 hf = bwn_hf_read(mac);
2052 if (mac->mac_phy.type == BWN_PHYTYPE_G) {
2056 if (mac->mac_phy.rev == 1)
2059 if (mac->mac_phy.rf_ver == 0x2050) {
2060 if (mac->mac_phy.rf_rev < 6)
2062 if (mac->mac_phy.rf_rev == 6)
2071 bwn_hf_write(mac, hf);
2076 cap = BWN_READ_4(mac, BWN_MAC_HW_CAP);
2080 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_MACHW_L,
2082 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_MACHW_H,
2086 bwn_set_txretry(mac, BWN_RETRY_SHORT, BWN_RETRY_LONG);
2087 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_SHORT_RETRY_FALLBACK, 3);
2088 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_LONG_RETRY_FALLBACK, 2);
2089 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_PROBE_RESP_MAXTIME, 1);
2091 bwn_rate_init(mac);
2092 bwn_set_phytxctl(mac);
2094 bwn_shm_write_2(mac, BWN_SCRATCH, BWN_SCRATCH_CONT_MIN,
2095 (mac->mac_phy.type == BWN_PHYTYPE_B) ? 0x1f : 0xf);
2096 bwn_shm_write_2(mac, BWN_SCRATCH, BWN_SCRATCH_CONT_MAX, 0x3ff);
2099 bwn_pio_init(mac);
2101 bwn_dma_init(mac);
2102 bwn_wme_init(mac);
2103 bwn_spu_setdelay(mac, 1);
2104 bwn_bt_enable(mac);
2106 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: powerup\n", __func__);
2109 bwn_set_macaddr(mac);
2110 bwn_crypt_init(mac);
2114 mac->mac_status = BWN_MAC_STATUS_INITED;
2116 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: done\n", __func__);
2121 KASSERT(mac->mac_status == BWN_MAC_STATUS_UNINIT,
2123 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: fail\n", __func__);
2128 bwn_core_start(struct bwn_mac *mac)
2130 struct bwn_softc *sc = mac->mac_sc;
2133 KASSERT(mac->mac_status == BWN_MAC_STATUS_INITED,
2140 tmp = BWN_READ_4(mac, BWN_XMITSTAT_0);
2143 tmp = BWN_READ_4(mac, BWN_XMITSTAT_1);
2146 bwn_mac_enable(mac);
2147 BWN_WRITE_4(mac, BWN_INTR_MASK, mac->mac_intr_mask);
2148 callout_reset(&sc->sc_task_ch, hz * 15, bwn_tasks, mac);
2150 mac->mac_status = BWN_MAC_STATUS_STARTED;
2154 bwn_core_exit(struct bwn_mac *mac)
2156 struct bwn_softc *sc = mac->mac_sc;
2159 BWN_ASSERT_LOCKED(mac->mac_sc);
2161 KASSERT(mac->mac_status <= BWN_MAC_STATUS_INITED,
2164 if (mac->mac_status != BWN_MAC_STATUS_INITED)
2166 mac->mac_status = BWN_MAC_STATUS_UNINIT;
2168 macctl = BWN_READ_4(mac, BWN_MACCTL);
2171 BWN_WRITE_4(mac, BWN_MACCTL, macctl);
2173 bwn_dma_stop(mac);
2174 bwn_pio_stop(mac);
2175 bwn_chip_exit(mac);
2176 mac->mac_phy.switch_analog(mac, 0);
2182 bwn_bt_disable(struct bwn_mac *mac)
2184 struct bwn_softc *sc = mac->mac_sc;
2191 bwn_chip_init(struct bwn_mac *mac)
2193 struct bwn_softc *sc = mac->mac_sc;
2194 struct bwn_phy *phy = &mac->mac_phy;
2201 BWN_WRITE_4(mac, BWN_MACCTL, macctl);
2203 error = bwn_fw_fillinfo(mac);
2206 error = bwn_fw_loaducode(mac);
2210 error = bwn_gpio_init(mac);
2214 error = bwn_fw_loadinitvals(mac);
2219 phy->switch_analog(mac, 1);
2220 error = bwn_phy_init(mac);
2226 phy->set_im(mac, BWN_IMMODE_NONE);
2228 phy->set_antenna(mac, BWN_ANT_DEFAULT);
2229 bwn_set_txantenna(mac, BWN_ANT_DEFAULT);
2232 BWN_WRITE_2(mac, 0x005e, BWN_READ_2(mac, 0x005e) | 0x0004);
2233 BWN_WRITE_4(mac, 0x0100, 0x01000000);
2235 BWN_WRITE_4(mac, 0x010c, 0x01000000);
2237 BWN_WRITE_4(mac, BWN_MACCTL,
2238 BWN_READ_4(mac, BWN_MACCTL) & ~BWN_MACCTL_STA);
2239 BWN_WRITE_4(mac, BWN_MACCTL,
2240 BWN_READ_4(mac, BWN_MACCTL) | BWN_MACCTL_STA);
2241 bwn_shm_write_2(mac, BWN_SHARED, 0x0074, 0x0000);
2243 bwn_set_opmode(mac);
2245 BWN_WRITE_2(mac, 0x060e, 0x0000);
2246 BWN_WRITE_2(mac, 0x0610, 0x8000);
2247 BWN_WRITE_2(mac, 0x0604, 0x0000);
2248 BWN_WRITE_2(mac, 0x0606, 0x0200);
2250 BWN_WRITE_4(mac, 0x0188, 0x80000000);
2251 BWN_WRITE_4(mac, 0x018c, 0x02000000);
2253 BWN_WRITE_4(mac, BWN_INTR_REASON, 0x00004000);
2254 BWN_WRITE_4(mac, BWN_DMA0_INTR_MASK, 0x0001dc00);
2255 BWN_WRITE_4(mac, BWN_DMA1_INTR_MASK, 0x0000dc00);
2256 BWN_WRITE_4(mac, BWN_DMA2_INTR_MASK, 0x0000dc00);
2257 BWN_WRITE_4(mac, BWN_DMA3_INTR_MASK, 0x0001dc00);
2258 BWN_WRITE_4(mac, BWN_DMA4_INTR_MASK, 0x0000dc00);
2259 BWN_WRITE_4(mac, BWN_DMA5_INTR_MASK, 0x0000dc00);
2261 bwn_mac_phy_clock_set(mac, true);
2265 BWN_WRITE_2(mac, BWN_POWERUP_DELAY, siba_get_cc_powerdelay(sc->sc_dev));
2271 bwn_hf_read(struct bwn_mac *mac)
2275 ret = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_HFHI);
2277 ret |= bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_HFMI);
2279 ret |= bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_HFLO);
2284 bwn_hf_write(struct bwn_mac *mac, uint64_t value)
2287 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_HFLO,
2289 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_HFMI,
2291 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_HFHI,
2296 bwn_set_txretry(struct bwn_mac *mac, int s, int l)
2299 bwn_shm_write_2(mac, BWN_SCRATCH, BWN_SCRATCH_SHORT_RETRY, MIN(s, 0xf));
2300 bwn_shm_write_2(mac, BWN_SCRATCH, BWN_SCRATCH_LONG_RETRY, MIN(l, 0xf));
2304 bwn_rate_init(struct bwn_mac *mac)
2307 switch (mac->mac_phy.type) {
2312 bwn_rate_write(mac, BWN_OFDM_RATE_6MB, 1);
2313 bwn_rate_write(mac, BWN_OFDM_RATE_12MB, 1);
2314 bwn_rate_write(mac, BWN_OFDM_RATE_18MB, 1);
2315 bwn_rate_write(mac, BWN_OFDM_RATE_24MB, 1);
2316 bwn_rate_write(mac, BWN_OFDM_RATE_36MB, 1);
2317 bwn_rate_write(mac, BWN_OFDM_RATE_48MB, 1);
2318 bwn_rate_write(mac, BWN_OFDM_RATE_54MB, 1);
2319 if (mac->mac_phy.type == BWN_PHYTYPE_A)
2323 bwn_rate_write(mac, BWN_CCK_RATE_1MB, 0);
2324 bwn_rate_write(mac, BWN_CCK_RATE_2MB, 0);
2325 bwn_rate_write(mac, BWN_CCK_RATE_5MB, 0);
2326 bwn_rate_write(mac, BWN_CCK_RATE_11MB, 0);
2334 bwn_rate_write(struct bwn_mac *mac, uint16_t rate, int ofdm)
2345 bwn_shm_write_2(mac, BWN_SHARED, offset + 0x20,
2346 bwn_shm_read_2(mac, BWN_SHARED, offset));
2394 bwn_set_phytxctl(struct bwn_mac *mac)
2400 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_BEACON_PHYCTL, ctl);
2401 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_ACKCTS_PHYCTL, ctl);
2402 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_PROBE_RESP_PHYCTL, ctl);
2406 bwn_pio_init(struct bwn_mac *mac)
2408 struct bwn_pio *pio = &mac->mac_method.pio;
2410 BWN_WRITE_4(mac, BWN_MACCTL, BWN_READ_4(mac, BWN_MACCTL)
2412 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_RX_PADOFFSET, 0);
2414 bwn_pio_set_txqueue(mac, &pio->wme[WME_AC_BK], 0);
2415 bwn_pio_set_txqueue(mac, &pio->wme[WME_AC_BE], 1);
2416 bwn_pio_set_txqueue(mac, &pio->wme[WME_AC_VI], 2);
2417 bwn_pio_set_txqueue(mac, &pio->wme[WME_AC_VO], 3);
2418 bwn_pio_set_txqueue(mac, &pio->mcast, 4);
2419 bwn_pio_setupqueue_rx(mac, &pio->rx, 0);
2423 bwn_pio_set_txqueue(struct bwn_mac *mac, struct bwn_pio_txqueue *tq,
2427 struct bwn_softc *sc = mac->mac_sc;
2430 tq->tq_base = bwn_pio_idx2base(mac, index) + BWN_PIO_TXQOFFSET(mac);
2437 tq->tq_size = bwn_pio_read_2(mac, tq, BWN_PIO_TXQBUFSIZE);
2451 bwn_pio_idx2base(struct bwn_mac *mac, int index)
2453 struct bwn_softc *sc = mac->mac_sc;
2484 bwn_pio_setupqueue_rx(struct bwn_mac *mac, struct bwn_pio_rxqueue *prq,
2487 struct bwn_softc *sc = mac->mac_sc;
2489 prq->prq_mac = mac;
2491 prq->prq_base = bwn_pio_idx2base(mac, index) + BWN_PIO_RXQOFFSET(mac);
2492 bwn_dma_rxdirectfifo(mac, index, 1);
2511 bwn_pio_read_2(struct bwn_mac *mac, struct bwn_pio_txqueue *tq,
2515 return (BWN_READ_2(mac, tq->tq_base + offset));
2519 bwn_dma_rxdirectfifo(struct bwn_mac *mac, int idx, uint8_t enable)
2525 type = bwn_dma_mask2type(bwn_dma_mask(mac));
2528 ctl = BWN_READ_4(mac, base + BWN_DMA64_RXCTL);
2532 BWN_WRITE_4(mac, base + BWN_DMA64_RXCTL, ctl);
2534 ctl = BWN_READ_4(mac, base + BWN_DMA32_RXCTL);
2538 BWN_WRITE_4(mac, base + BWN_DMA32_RXCTL, ctl);
2543 bwn_dma_mask(struct bwn_mac *mac)
2548 tmp = BWN_READ_4(mac, SIBA_TGSHIGH);
2552 BWN_WRITE_4(mac, base + BWN_DMA32_TXCTL, BWN_DMA32_TXADDREXT_MASK);
2553 tmp = BWN_READ_4(mac, base + BWN_DMA32_TXCTL);
2620 bwn_dma_init(struct bwn_mac *mac)
2622 struct bwn_dma *dma = &mac->mac_method.dma;
2635 bwn_dma_ringsetup(struct bwn_mac *mac, int controller_index,
2638 struct bwn_dma *dma = &mac->mac_method.dma;
2642 struct bwn_softc *sc = mac->mac_sc;
2658 dr->dr_mac = mac;
2683 switch (mac->mac_fw.fw_hdr_format) {
2732 BWN_HDRSIZE(mac),
3030 struct bwn_mac *mac = dr->dr_mac;
3031 struct bwn_dma *dma = &mac->mac_method.dma;
3032 struct bwn_softc *sc = mac->mac_sc;
3178 struct bwn_mac *mac = dr->dr_mac;
3179 struct bwn_dma *dma = &mac->mac_method.dma;
3180 struct bwn_softc *sc = mac->mac_sc;
3208 bwn_dma_tx_reset(struct bwn_mac *mac, uint16_t base,
3211 struct bwn_softc *sc = mac->mac_sc;
3219 value = BWN_READ_4(mac, base + offset);
3236 BWN_WRITE_4(mac, base + offset, 0);
3240 value = BWN_READ_4(mac, base + offset);
3266 bwn_dma_rx_reset(struct bwn_mac *mac, uint16_t base,
3269 struct bwn_softc *sc = mac->mac_sc;
3275 BWN_WRITE_4(mac, base + offset, 0);
3279 value = BWN_READ_4(mac, base + offset);
3344 bwn_wme_init(struct bwn_mac *mac)
3347 bwn_wme_load(mac);
3350 bwn_hf_write(mac, bwn_hf_read(mac) | BWN_HF_EDCF);
3351 BWN_WRITE_2(mac, BWN_IFSCTL, BWN_READ_2(mac, BWN_IFSCTL) |
3356 bwn_spu_setdelay(struct bwn_mac *mac, int idle)
3358 struct bwn_softc *sc = mac->mac_sc;
3362 delay = (mac->mac_phy.type == BWN_PHYTYPE_A) ? 3700 : 1050;
3365 if ((mac->mac_phy.rf_ver == 0x2050) && (mac->mac_phy.rf_rev == 8))
3368 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_SPU_WAKEUP, delay);
3372 bwn_bt_enable(struct bwn_mac *mac)
3374 struct bwn_softc *sc = mac->mac_sc;
3381 if (mac->mac_phy.type != BWN_PHYTYPE_B && !mac->mac_phy.gmode)
3384 hf = bwn_hf_read(mac);
3389 bwn_hf_write(mac, hf);
3393 bwn_set_macaddr(struct bwn_mac *mac)
3396 bwn_mac_write_bssid(mac);
3397 bwn_mac_setfilter(mac, BWN_MACFILTER_SELF,
3398 mac->mac_sc->sc_ic.ic_macaddr);
3402 bwn_clear_keys(struct bwn_mac *mac)
3406 for (i = 0; i < mac->mac_max_nr_keys; i++) {
3407 KASSERT(i >= 0 && i < mac->mac_max_nr_keys,
3410 bwn_key_dowrite(mac, i, BWN_SEC_ALGO_NONE,
3412 if ((i <= 3) && !BWN_SEC_NEWAPI(mac)) {
3413 bwn_key_dowrite(mac, i + 4, BWN_SEC_ALGO_NONE,
3416 mac->mac_key[i].keyconf = NULL;
3421 bwn_crypt_init(struct bwn_mac *mac)
3423 struct bwn_softc *sc = mac->mac_sc;
3425 mac->mac_max_nr_keys = (siba_get_revid(sc->sc_dev) >= 5) ? 58 : 20;
3426 KASSERT(mac->mac_max_nr_keys <= N(mac->mac_key),
3428 mac->mac_ktp = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_KEY_TABLEP);
3429 mac->mac_ktp *= 2;
3431 BWN_WRITE_2(mac, BWN_RCMTA_COUNT, mac->mac_max_nr_keys - 8);
3432 bwn_clear_keys(mac);
3436 bwn_chip_exit(struct bwn_mac *mac)
3438 struct bwn_softc *sc = mac->mac_sc;
3440 bwn_phy_exit(mac);
3445 bwn_fw_fillinfo(struct bwn_mac *mac)
3449 error = bwn_fw_gets(mac, BWN_FWTYPE_DEFAULT);
3452 error = bwn_fw_gets(mac, BWN_FWTYPE_OPENSOURCE);
3459 bwn_gpio_init(struct bwn_mac *mac)
3461 struct bwn_softc *sc = mac->mac_sc;
3464 BWN_WRITE_4(mac, BWN_MACCTL,
3465 BWN_READ_4(mac, BWN_MACCTL) & ~BWN_MACCTL_GPOUT_MASK);
3466 BWN_WRITE_2(mac, BWN_GPIO_MASK,
3467 BWN_READ_2(mac, BWN_GPIO_MASK) | 0x000f);
3474 BWN_WRITE_2(mac, BWN_GPIO_MASK,
3475 BWN_READ_2(mac, BWN_GPIO_MASK) | 0x0200);
3491 bwn_fw_loadinitvals(struct bwn_mac *mac)
3497 struct bwn_fw *fw = &mac->mac_fw;
3501 error = bwn_fwinitvals_write(mac, GETFWOFFSET(fw->initvals, hdr_len),
3507 error = bwn_fwinitvals_write(mac,
3517 bwn_phy_init(struct bwn_mac *mac)
3519 struct bwn_softc *sc = mac->mac_sc;
3522 mac->mac_phy.chan = mac->mac_phy.get_default_chan(mac);
3523 mac->mac_phy.rf_onoff(mac, 1);
3524 error = mac->mac_phy.init(mac);
3529 error = bwn_switch_channel(mac,
3530 mac->mac_phy.get_default_chan(mac));
3538 if (mac->mac_phy.exit)
3539 mac->mac_phy.exit(mac);
3541 mac->mac_phy.rf_onoff(mac, 0);
3547 bwn_set_txantenna(struct bwn_mac *mac, int antenna)
3555 tmp = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_ACKCTS_PHYCTL);
3557 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_ACKCTS_PHYCTL, tmp);
3559 tmp = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_PROBE_RESP_PHYCTL);
3561 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_PROBE_RESP_PHYCTL, tmp);
3565 bwn_set_opmode(struct bwn_mac *mac)
3567 struct bwn_softc *sc = mac->mac_sc;
3572 ctl = BWN_READ_4(mac, BWN_MACCTL);
3588 BWN_WRITE_4(mac, BWN_MACCTL, ctl);
3598 BWN_WRITE_2(mac, 0x612, cfp_pretbtt);
3602 bwn_dma_gettype(struct bwn_mac *mac)
3607 tmp = BWN_READ_4(mac, SIBA_TGSHIGH);
3611 BWN_WRITE_4(mac, base + BWN_DMA32_TXCTL, BWN_DMA32_TXADDREXT_MASK);
3612 tmp = BWN_READ_4(mac, base + BWN_DMA32_TXCTL);
3629 bwn_dummy_transmission(struct bwn_mac *mac, int ofdm, int paon)
3631 struct bwn_phy *phy = &mac->mac_phy;
3632 struct bwn_softc *sc = mac->mac_sc;
3647 BWN_ASSERT_LOCKED(mac->mac_sc);
3650 bwn_ram_write(mac, i * 4, buffer[i]);
3652 BWN_WRITE_2(mac, 0x0568, 0x0000);
3653 BWN_WRITE_2(mac, 0x07c0,
3657 BWN_WRITE_2(mac, 0x050c, value);
3661 BWN_WRITE_2(mac, 0x0514, 0x1a02);
3662 BWN_WRITE_2(mac, 0x0508, 0x0000);
3663 BWN_WRITE_2(mac, 0x050a, 0x0000);
3664 BWN_WRITE_2(mac, 0x054c, 0x0000);
3665 BWN_WRITE_2(mac, 0x056a, 0x0014);
3666 BWN_WRITE_2(mac, 0x0568, 0x0826);
3667 BWN_WRITE_2(mac, 0x0500, 0x0000);
3674 BWN_WRITE_2(mac, 0x0502, 0x00d0);
3677 BWN_WRITE_2(mac, 0x0502, 0x0050);
3680 BWN_WRITE_2(mac, 0x0502, 0x0030);
3685 BWN_READ_2(mac, 0x0502);
3688 BWN_RF_WRITE(mac, 0x0051, 0x0017);
3690 value = BWN_READ_2(mac, 0x050e);
3696 value = BWN_READ_2(mac, 0x050e);
3702 value = BWN_READ_2(mac, 0x0690);
3708 BWN_RF_WRITE(mac, 0x0051, 0x0037);
3712 bwn_ram_write(struct bwn_mac *mac, uint16_t offset, uint32_t val)
3718 macctl = BWN_READ_4(mac, BWN_MACCTL);
3722 BWN_WRITE_4(mac, BWN_RAM_CONTROL, offset);
3723 BWN_BARRIER(mac, BUS_SPACE_BARRIER_WRITE);
3724 BWN_WRITE_4(mac, BWN_RAM_DATA, val);
3728 bwn_mac_suspend(struct bwn_mac *mac)
3730 struct bwn_softc *sc = mac->mac_sc;
3734 KASSERT(mac->mac_suspended >= 0,
3737 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: suspended=%d\n",
3738 __func__, mac->mac_suspended);
3740 if (mac->mac_suspended == 0) {
3741 bwn_psctl(mac, BWN_PS_AWAKE);
3742 BWN_WRITE_4(mac, BWN_MACCTL,
3743 BWN_READ_4(mac, BWN_MACCTL)
3745 BWN_READ_4(mac, BWN_MACCTL);
3747 tmp = BWN_READ_4(mac, BWN_INTR_REASON);
3753 tmp = BWN_READ_4(mac, BWN_INTR_REASON);
3761 mac->mac_suspended++;
3765 bwn_mac_enable(struct bwn_mac *mac)
3767 struct bwn_softc *sc = mac->mac_sc;
3770 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: suspended=%d\n",
3771 __func__, mac->mac_suspended);
3773 state = bwn_shm_read_2(mac, BWN_SHARED,
3782 mac->mac_suspended--;
3783 KASSERT(mac->mac_suspended >= 0,
3785 if (mac->mac_suspended == 0) {
3786 BWN_WRITE_4(mac, BWN_MACCTL,
3787 BWN_READ_4(mac, BWN_MACCTL) | BWN_MACCTL_ON);
3788 BWN_WRITE_4(mac, BWN_INTR_REASON, BWN_INTR_MAC_SUSPENDED);
3789 BWN_READ_4(mac, BWN_MACCTL);
3790 BWN_READ_4(mac, BWN_INTR_REASON);
3791 bwn_psctl(mac, 0);
3796 bwn_psctl(struct bwn_mac *mac, uint32_t flags)
3798 struct bwn_softc *sc = mac->mac_sc;
3809 BWN_WRITE_4(mac, BWN_MACCTL,
3810 (BWN_READ_4(mac, BWN_MACCTL) | BWN_MACCTL_AWAKE) &
3812 BWN_READ_4(mac, BWN_MACCTL);
3815 ucstat = bwn_shm_read_2(mac, BWN_SHARED,
3822 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: ucstat=%d\n", __func__,
3827 bwn_fw_gets(struct bwn_mac *mac, enum bwn_fwtype type)
3829 struct bwn_softc *sc = mac->mac_sc;
3830 struct bwn_fw *fw = &mac->mac_fw;
3840 if (mac->mac_phy.type == BWN_PHYTYPE_AC)
3844 if (mac->mac_phy.type == BWN_PHYTYPE_AC)
3848 if (mac->mac_phy.type == BWN_PHYTYPE_LCN40)
3852 if (mac->mac_phy.type == BWN_PHYTYPE_N)
3856 if (mac->mac_phy.type == BWN_PHYTYPE_HT)
3860 if (mac->mac_phy.type == BWN_PHYTYPE_HT)
3865 if (mac->mac_phy.type == BWN_PHYTYPE_N)
3867 else if (mac->mac_phy.type == BWN_PHYTYPE_LCN)
3871 if (mac->mac_phy.type == BWN_PHYTYPE_LCN)
3875 if (mac->mac_phy.type == BWN_PHYTYPE_N)
3882 if (mac->mac_phy.type == BWN_PHYTYPE_N)
3884 else if (mac->mac_phy.type == BWN_PHYTYPE_LP)
3910 bwn_release_firmware(mac);
3915 error = bwn_fw_get(mac, type, filename, &fw->ucode);
3917 bwn_release_firmware(mac);
3924 error = bwn_fw_get(mac, type, "pcm5", &fw->pcm);
3928 bwn_release_firmware(mac);
3933 bwn_release_firmware(mac);
3939 switch (mac->mac_phy.type) {
3985 error = bwn_fw_get(mac, type, filename, &fw->initvals);
3987 bwn_release_firmware(mac);
3992 switch (mac->mac_phy.type) {
4040 mac->mac_phy.type);
4043 error = bwn_fw_get(mac, type, filename, &fw->initvals_band);
4045 bwn_release_firmware(mac);
4051 rev, mac->mac_phy.type);
4052 bwn_release_firmware(mac);
4057 bwn_fw_get(struct bwn_mac *mac, enum bwn_fwtype type,
4061 struct bwn_softc *sc = mac->mac_sc;
4077 (mac->mac_phy.type == BWN_PHYTYPE_LP) ? "lp_" : "", name);
4114 bwn_release_firmware(struct bwn_mac *mac)
4117 bwn_do_release_fw(&mac->mac_fw.ucode);
4118 bwn_do_release_fw(&mac->mac_fw.pcm);
4119 bwn_do_release_fw(&mac->mac_fw.initvals);
4120 bwn_do_release_fw(&mac->mac_fw.initvals_band);
4134 bwn_fw_loaducode(struct bwn_mac *mac)
4140 struct bwn_softc *sc = mac->mac_sc;
4147 ctl = BWN_READ_4(mac, BWN_MACCTL);
4151 BWN_WRITE_4(mac, BWN_MACCTL, ctl);
4153 bwn_shm_write_2(mac, BWN_SCRATCH, i, 0);
4155 bwn_shm_write_2(mac, BWN_SHARED, i, 0);
4157 data = GETFWOFFSET(mac->mac_fw.ucode, sizeof(struct bwn_fwhdr));
4158 bwn_shm_ctlword(mac, BWN_UCODE | BWN_SHARED_AUTOINC, 0x0000);
4159 for (i = 0; i < GETFWSIZE(mac->mac_fw.ucode, sizeof(struct bwn_fwhdr));
4161 BWN_WRITE_4(mac, BWN_SHM_DATA, be32toh(data[i]));
4165 if (mac->mac_fw.pcm.fw) {
4166 data = GETFWOFFSET(mac->mac_fw.pcm, sizeof(struct bwn_fwhdr));
4167 bwn_shm_ctlword(mac, BWN_HW, 0x01ea);
4168 BWN_WRITE_4(mac, BWN_SHM_DATA, 0x00004000);
4169 bwn_shm_ctlword(mac, BWN_HW, 0x01eb);
4170 for (i = 0; i < GETFWSIZE(mac->mac_fw.pcm,
4172 BWN_WRITE_4(mac, BWN_SHM_DATA, be32toh(data[i]));
4177 BWN_WRITE_4(mac, BWN_INTR_REASON, BWN_INTR_ALL);
4178 BWN_WRITE_4(mac, BWN_MACCTL,
4179 (BWN_READ_4(mac, BWN_MACCTL) & ~BWN_MACCTL_MCODE_JMP0) |
4183 if (BWN_READ_4(mac, BWN_INTR_REASON) == BWN_INTR_MAC_SUSPENDED)
4192 BWN_READ_4(mac, BWN_INTR_REASON);
4194 mac->mac_fw.rev = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_UCODE_REV);
4195 if (mac->mac_fw.rev <= 0x128) {
4205 if (mac->mac_fw.rev >= 598)
4206 mac->mac_fw.fw_hdr_format = BWN_FW_HDR_598;
4207 else if (mac->mac_fw.rev >= 410)
4208 mac->mac_fw.fw_hdr_format = BWN_FW_HDR_410;
4210 mac->mac_fw.fw_hdr_format = BWN_FW_HDR_351;
4221 if (mac->mac_fw.fw_hdr_format == BWN_FW_HDR_598) {
4229 mac->mac_fw.patch = bwn_shm_read_2(mac, BWN_SHARED,
4231 date = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_UCODE_DATE);
4232 mac->mac_fw.opensource = (date == 0xffff);
4234 mac->mac_flags |= BWN_MAC_FLAG_WME;
4235 mac->mac_flags |= BWN_MAC_FLAG_HWCRYPTO;
4237 time = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_UCODE_TIME);
4238 if (mac->mac_fw.opensource == 0) {
4241 mac->mac_fw.rev, mac->mac_fw.patch, date, time);
4242 if (mac->mac_fw.no_pcmfile)
4246 mac->mac_fw.patch = time;
4247 fwcaps = bwn_fwcaps_read(mac);
4248 if (!(fwcaps & BWN_FWCAPS_HWCRYPTO) || mac->mac_fw.no_pcmfile) {
4251 mac->mac_flags &= ~BWN_MAC_FLAG_HWCRYPTO;
4255 mac->mac_flags &= ~BWN_MAC_FLAG_WME;
4259 if (BWN_ISOLDFMT(mac))
4265 BWN_WRITE_4(mac, BWN_MACCTL,
4266 (BWN_READ_4(mac, BWN_MACCTL) & ~BWN_MACCTL_MCODE_RUN) |
4276 bwn_fwcaps_read(struct bwn_mac *mac)
4279 KASSERT(mac->mac_fw.opensource == 1,
4281 return (bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_FWCAPS));
4285 bwn_fwinitvals_write(struct bwn_mac *mac, const struct bwn_fwinitvals *ivals,
4294 struct bwn_softc *sc = mac->mac_sc;
4316 BWN_WRITE_4(mac, offset, be32toh(iv->data.d32));
4323 BWN_WRITE_2(mac, offset, be16toh(iv->data.d16));
4339 bwn_switch_channel(struct bwn_mac *mac, int chan)
4341 struct bwn_phy *phy = &(mac->mac_phy);
4342 struct bwn_softc *sc = mac->mac_sc;
4348 chan = phy->get_default_chan(mac);
4353 savedcookie = bwn_shm_read_2(mac, BWN_SHARED, BWN_SHARED_CHAN);
4354 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_CHAN, channelcookie);
4355 error = phy->switch_channel(mac, chan);
4359 mac->mac_phy.chan = chan;
4364 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_CHAN, savedcookie);
4389 bwn_wme_load(struct bwn_mac *mac)
4391 struct bwn_softc *sc = mac->mac_sc;
4397 bwn_mac_suspend(mac);
4399 bwn_wme_loadparams(mac, &(sc->sc_wmeParams[i]),
4401 bwn_mac_enable(mac);
4405 bwn_wme_loadparams(struct bwn_mac *mac,
4409 struct bwn_softc *sc = mac->mac_sc;
4414 slot = BWN_READ_2(mac, BWN_RNG) &
4433 tmp = bwn_shm_read_2(mac, BWN_SHARED,
4436 bwn_shm_write_2(mac, BWN_SHARED, shm_offset + (i * 2),
4439 bwn_shm_write_2(mac, BWN_SHARED, shm_offset + (i * 2),
4446 bwn_mac_write_bssid(struct bwn_mac *mac)
4448 struct bwn_softc *sc = mac->mac_sc;
4453 bwn_mac_setfilter(mac, BWN_MACFILTER_BSSID, sc->sc_bssid);
4463 bwn_ram_write(mac, 0x20 + i, tmp);
4468 bwn_mac_setfilter(struct bwn_mac *mac, uint16_t offset,
4474 if (!mac)
4478 BWN_WRITE_2(mac, BWN_MACFILTER_CONTROL, offset);
4482 BWN_WRITE_2(mac, BWN_MACFILTER_DATA, data);
4485 BWN_WRITE_2(mac, BWN_MACFILTER_DATA, data);
4488 BWN_WRITE_2(mac, BWN_MACFILTER_DATA, data);
4492 bwn_key_dowrite(struct bwn_mac *mac, uint8_t index, uint8_t algorithm,
4498 if (BWN_SEC_NEWAPI(mac))
4501 KASSERT(index < mac->mac_max_nr_keys,
4507 bwn_key_macwrite(mac, index, NULL);
4510 bwn_key_write(mac, index, algorithm, buf);
4512 bwn_key_macwrite(mac, index, mac_addr);
4514 mac->mac_key[index].algorithm = algorithm;
4518 bwn_key_macwrite(struct bwn_mac *mac, uint8_t index, const uint8_t *addr)
4520 struct bwn_softc *sc = mac->mac_sc;
4524 if (BWN_SEC_NEWAPI(mac))
4541 bwn_shm_write_4(mac, BWN_RCMTA, (index * 2) + 0, addrtmp[0]);
4542 bwn_shm_write_2(mac, BWN_RCMTA, (index * 2) + 1, addrtmp[1]);
4545 bwn_shm_write_4(mac, BWN_SHARED,
4547 bwn_shm_write_2(mac, BWN_SHARED,
4554 bwn_key_write(struct bwn_mac *mac, uint8_t index, uint8_t algorithm,
4561 kidx = BWN_SEC_KEY2FW(mac, index);
4562 bwn_shm_write_2(mac, BWN_SHARED,
4565 offset = mac->mac_ktp + (index * BWN_SEC_KEYSIZE);
4569 bwn_shm_write_2(mac, BWN_SHARED, offset + i, value);
4574 bwn_phy_exit(struct bwn_mac *mac)
4577 mac->mac_phy.rf_onoff(mac, 0);
4578 if (mac->mac_phy.exit != NULL)
4579 mac->mac_phy.exit(mac);
4583 bwn_dma_free(struct bwn_mac *mac)
4587 if ((mac->mac_flags & BWN_MAC_FLAG_DMA) == 0)
4589 dma = &mac->mac_method.dma;
4600 bwn_core_stop(struct bwn_mac *mac)
4602 struct bwn_softc *sc = mac->mac_sc;
4606 if (mac->mac_status < BWN_MAC_STATUS_STARTED)
4613 BWN_WRITE_4(mac, BWN_INTR_MASK, 0);
4614 BWN_READ_4(mac, BWN_INTR_MASK);
4615 bwn_mac_suspend(mac);
4617 mac->mac_status = BWN_MAC_STATUS_INITED;
4625 struct bwn_mac *mac;
4631 TAILQ_FOREACH(mac, &sc->sc_maclist, mac_list) {
4633 mac->mac_phy.supports_2ghz) {
4634 up_dev = mac;
4637 mac->mac_phy.supports_5ghz) {
4638 up_dev = mac;
4690 bwn_rf_turnon(struct bwn_mac *mac)
4693 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: called\n", __func__);
4695 bwn_mac_suspend(mac);
4696 mac->mac_phy.rf_onoff(mac, 1);
4697 mac->mac_phy.rf_on = 1;
4698 bwn_mac_enable(mac);
4702 bwn_rf_turnoff(struct bwn_mac *mac)
4705 DPRINTF(mac->mac_sc, BWN_DEBUG_RESET, "%s: called\n", __func__);
4707 bwn_mac_suspend(mac);
4708 mac->mac_phy.rf_onoff(mac, 0);
4709 mac->mac_phy.rf_on = 0;
4710 bwn_mac_enable(mac);
4717 bwn_phy_reset_siba(struct bwn_mac *mac)
4719 struct bwn_softc *sc = mac->mac_sc;
4731 bwn_phy_reset(struct bwn_mac *mac)
4734 if (bwn_is_bus_siba(mac)) {
4735 bwn_phy_reset_siba(mac);
4737 BWN_ERRPRINTF(mac->mac_sc, "%s: unknown bus!\n", __func__);
4748 struct bwn_mac *mac = sc->sc_curmac;
4761 bwn_led_newstate(mac, nstate);
4776 bwn_set_macaddr(mac);
4786 bwn_set_opmode(mac);
4787 bwn_set_pretbtt(mac);
4788 bwn_spu_setdelay(mac, 0);
4789 bwn_set_macaddr(mac);
4798 bwn_set_pretbtt(struct bwn_mac *mac)
4800 struct bwn_softc *sc = mac->mac_sc;
4807 pretbtt = (mac->mac_phy.type == BWN_PHYTYPE_A) ? 120 : 250;
4808 bwn_shm_write_2(mac, BWN_SHARED, BWN_SHARED_PRETBTT, pretbtt);
4809 BWN_WRITE_2(mac, BWN_TSF_CFP_PRETBTT, pretbtt);
4815 struct bwn_mac *mac = arg;
4816 struct bwn_softc *sc = mac->mac_sc;
4819 if (mac->mac_status < BWN_MAC_STATUS_STARTED ||
4825 reason = BWN_READ_4(mac, BWN_INTR_REASON);
4828 reason &= mac->mac_intr_mask;
4833 mac->mac_reason[0] = BWN_READ_4(mac, BWN_DMA0_REASON) & 0x0001dc00;
4834 mac->mac_reason[1] = BWN_READ_4(mac, BWN_DMA1_REASON) & 0x0000dc00;
4835 mac->mac_reason[2] = BWN_READ_4(mac, BWN_DMA2_REASON) & 0x0000dc00;
4836 mac->mac_reason[3] = BWN_READ_4(mac, BWN_DMA3_REASON) & 0x0001dc00;
4837 mac->mac_reason[4] = BWN_READ_4(mac, BWN_DMA4_REASON) & 0x0000dc00;
4838 BWN_WRITE_4(mac, BWN_INTR_REASON, reason);
4839 BWN_WRITE_4(mac, BWN_DMA0_REASON, mac->mac_reason[0]);
4840 BWN_WRITE_4(mac, BWN_DMA1_REASON, mac->mac_reason[1]);
4841 BWN_WRITE_4(mac, BWN_DMA2_REASON, mac->mac_reason[2]);
4842 BWN_WRITE_4(mac, BWN_DMA3_REASON, mac->mac_reason[3]);
4843 BWN_WRITE_4(mac, BWN_DMA4_REASON, mac->mac_reason[4]);
4846 BWN_WRITE_4(mac, BWN_INTR_MASK, 0);
4848 mac->mac_reason_intr = reason;
4850 BWN_BARRIER(mac, BUS_SPACE_BARRIER_READ);
4851 BWN_BARRIER(mac, BUS_SPACE_BARRIER_WRITE);
4853 taskqueue_enqueue(sc->sc_tq, &mac->mac_intrtask);
4860 struct bwn_mac *mac = arg;
4861 struct bwn_softc *sc = mac->mac_sc;
4866 if (mac->mac_status < BWN_MAC_STATUS_STARTED ||
4872 for (i = 0; i < N(mac->mac_reason); i++)
4873 merged |= mac->mac_reason[i];
4875 if (mac->mac_reason_intr & BWN_INTR_MAC_TXERR)
4878 if (mac->mac_reason_intr & BWN_INTR_PHY_TXERR) {
4880 mac->mac_phy.txerrors--;
4881 if (mac->mac_phy.txerrors == 0) {
4882 mac->mac_phy.txerrors = BWN_TXERROR_MAX;
4883 bwn_restart(mac, "PHY TX errors");
4891 mac->mac_reason[0], mac->mac_reason[1],
4892 mac->mac_reason[2], mac->mac_reason[3],
4893 mac->mac_reason[4], mac->mac_reason[5]);
4894 bwn_restart(mac, "DMA error");
4901 mac->mac_reason[0], mac->mac_reason[1],
4902 mac->mac_reason[2], mac->mac_reason[3],
4903 mac->mac_reason[4], mac->mac_reason[5]);
4907 if (mac->mac_reason_intr & BWN_INTR_UCODE_DEBUG)
4908 bwn_intr_ucode_debug(mac);
4909 if (mac->mac_reason_intr & BWN_INTR_TBTT_INDI)
4910 bwn_intr_tbtt_indication(mac);
4911 if (mac->mac_reason_intr & BWN_INTR_ATIM_END)
4912 bwn_intr_atim_end(mac);
4913 if (mac->mac_reason_intr & BWN_INTR_BEACON)
4914 bwn_intr_beacon(mac);
4915 if (mac->mac_reason_intr & BWN_INTR_PMQ)
4916 bwn_intr_pmq(mac);
4917 if (mac->mac_reason_intr & BWN_INTR_NOISESAMPLE_OK)
4918 bwn_intr_noise(mac);
4920 if (mac->mac_flags & BWN_MAC_FLAG_DMA) {
4921 if (mac->mac_reason[0] & BWN_DMAINTR_RX_DONE) {
4922 bwn_dma_rx(mac->mac_method.dma.rx);
4926 rx = bwn_pio_rx(&mac->mac_method.pio.rx);
4928 KASSERT(!(mac->mac_reason[1] & BWN_DMAINTR_RX_DONE), ("%s", __func__));
4929 KASSERT(!(mac->mac_reason[2] & BWN_DMAINTR_RX_DONE), ("%s", __func__));
4930 KASSERT(!(mac->mac_reason[3] & BWN_DMAINTR_RX_DONE), ("%s", __func__));
4931 KASSERT(!(mac->mac_reason[4] & BWN_DMAINTR_RX_DONE), ("%s", __func__));
4932 KASSERT(!(mac->mac_reason[5] & BWN_DMAINTR_RX_DONE), ("%s", __func__));
4934 if (mac->mac_reason_intr & BWN_INTR_TX_OK) {
4935 bwn_intr_txeof(mac);
4939 BWN_WRITE_4(mac, BWN_INTR_MASK, mac->mac_intr_mask);
4958 bwn_led_event(mac, evt);
4964 BWN_BARRIER(mac, BUS_SPACE_BARRIER_READ);
4965 BWN_BARRIER(mac, BUS_SPACE_BARRIER_WRITE);
4971 bwn_restart(struct bwn_mac *mac, const char *msg)
4973 struct bwn_softc *sc = mac->mac_sc;
4976 if (mac->mac_status < BWN_MAC_STATUS_INITED)
4980 ieee80211_runtask(ic, &mac->mac_hwreset);
4984 bwn_intr_ucode_debug(struct bwn_mac *mac)
4986 struct bwn_softc *sc = mac->mac_sc;
4989 if (mac->mac_fw.opensource == 0)
4992 reason = bwn_shm_read_2(mac, BWN_SCRATCH, BWN_DEBUGINTR_REASON_REG);
4995 bwn_handle_fwpanic(mac);
5011 bwn_shm_write_2(mac, BWN_SCRATCH, BWN_DEBUGINTR_REASON_REG,
5016 bwn_intr_tbtt_indication(struct bwn_mac *mac)
5018 struct bwn_softc *sc = mac->mac_sc;
5022 bwn_psctl(mac, 0);
5024 mac->mac_flags |= BWN_MAC_FLAG_DFQVALID;
5028 bwn_intr_atim_end(struct bwn_mac *mac)
5031 if (mac->mac_flags & BWN_MAC_FLAG_DFQVALID) {
5032 BWN_WRITE_4(mac, BWN_MACCMD,
5033 BWN_READ_4(mac, BWN_MACCMD) | BWN_MACCMD_DFQ_VALID);
5034 mac->mac_flags &= ~BWN_MAC_FLAG_DFQVALID;
5039 bwn_intr_beacon(struct bwn_mac *mac)
5041 struct bwn_softc *sc = mac->mac_sc;
5049 mac->mac_intr_mask &= ~BWN_INTR_BEACON;
5051 cmd = BWN_READ_4(mac, BWN_MACCMD);
5056 BWN_WRITE_4(mac, BWN_INTR_REASON, BWN_INTR_BEACON);
5057 mac->mac_intr_mask |= BWN_INTR_BEACON;
5063 bwn_load_beacon0(mac);
5064 bwn_load_beacon1(mac);
5065 cmd = BWN_READ_4(mac, BWN_MACCMD);
5067 BWN_WRITE_4(mac, BWN_MACCMD, cmd);
5070 bwn_load_beacon0(mac);
5071 cmd = BWN_READ_4(mac, BWN_MACCMD);
5073 BWN_WRITE_4(mac, BWN_MACCMD, cmd);
5075 bwn_load_beacon1(mac);
5076 cmd = BWN_READ_4(mac, BWN_MACCMD);
5078 BWN_WRITE_4(mac, BWN_MACCMD, cmd);
5084 bwn_intr_pmq(struct bwn_mac *mac)
5089 tmp = BWN_READ_4(mac, BWN_PS_STATUS);
5093 BWN_WRITE_2(mac, BWN_PS_STATUS, 0x0002);
5097 bwn_intr_noise(struct bwn_mac *mac)
5099 struct bwn_phy_g *pg = &mac->mac_phy.phy_g;
5105 if (mac->mac_phy.type != BWN_PHYTYPE_G)
5108 KASSERT(mac->mac_noise.noi_running, ("%s: fail", __func__));
5109 *((uint32_t *)noise) = htole32(bwn_jssi_read(mac));
5114 KASSERT(mac->mac_noise.noi_nsamples < 8,
5116 i = mac->mac_noise.noi_nsamples;
5121 mac->mac_noise.noi_samples[i][0] = pg->pg_nrssi_lt[noise[0]];
5122 mac->mac_noise.noi_samples[i][1] = pg->pg_nrssi_lt[noise[1]];
5123 mac->mac_noise.noi_samples[i][2] = pg->pg_nrssi_lt[noise[2]];
5124 mac->mac_noise.noi_samples[i][3] = pg->pg_nrssi_lt[noise[3]];
5125 mac->mac_noise.noi_nsamples++;
5126 if (mac->mac_noise.noi_nsamples == 8) {
5130 average += mac->mac_noise.noi_samples[i][j];
5133 tmp = (bwn_shm_read_2(mac, BWN_SHARED, 0x40c) / 128) & 0x1f;
5140 mac->mac_stats.link_noise = average;
5141 mac->mac_noise.noi_running = 0;
5145 bwn_noise_gensample(mac);
5151 struct bwn_mac *mac = prq->prq_mac;
5152 struct bwn_softc *sc = mac->mac_sc;
5157 if (mac->mac_status < BWN_MAC_STATUS_STARTED)
5191 bwn_intr_txeof(struct bwn_mac *mac)
5197 BWN_ASSERT_LOCKED(mac->mac_sc);
5200 stat0 = BWN_READ_4(mac, BWN_XMITSTAT_0);
5203 stat1 = BWN_READ_4(mac, BWN_XMITSTAT_1);
5205 DPRINTF(mac->mac_sc, BWN_DEBUG_XMIT,
5223 DPRINTF(mac->mac_sc, BWN_DEBUG_XMIT,
5238 bwn_handle_txeof(mac, &stat);
5245 struct bwn_mac *mac = arg;
5246 struct bwn_softc *sc = mac->mac_sc;
5252 prev_status = mac->mac_status;
5254 bwn_core_stop(mac);
5256 bwn_core_exit(mac);
5259 error = bwn_core_init(mac);
5264 bwn_core_start(mac);
5274 bwn_handle_fwpanic(struct bwn_mac *mac)
5276 struct bwn_softc *sc = mac->mac_sc;
5279 reason = bwn_shm_read_2(mac, BWN_SCRATCH, BWN_FWPANIC_REASON_REG);
5283 bwn_restart(mac, "ucode panic");
5287 bwn_load_beacon0(struct bwn_mac *mac)
5294 bwn_load_beacon1(struct bwn_mac *mac)
5301 bwn_jssi_read(struct bwn_mac *mac)
5305 val = bwn_shm_read_2(mac, BWN_SHARED, 0x08a);
5307 val |= bwn_shm_read_2(mac, BWN_SHARED, 0x088);
5313 bwn_noise_gensample(struct bwn_mac *mac)
5317 bwn_shm_write_2(mac, BWN_SHARED, 0x088, (jssi & 0x0000ffff));
5318 bwn_shm_write_2(mac, BWN_SHARED, 0x08a, (jssi & 0xffff0000) >> 16);
5319 BWN_WRITE_4(mac, BWN_MACCMD,
5320 BWN_READ_4(mac, BWN_MACCMD) | BWN_MACCMD_BGNOISE);
5346 struct bwn_mac *mac = dr->dr_mac;
5347 struct bwn_softc *sc = mac->mac_sc;
5348 struct bwn_dma *dma = &mac->mac_method.dma;
5400 switch (mac->mac_fw.fw_hdr_format) {
5411 if (!(mac->mac_sc->sc_filters & BWN_MACCTL_PASS_BADFCS)) {
5424 bwn_handle_txeof(struct bwn_mac *mac, const struct bwn_txstatus *status)
5426 struct bwn_softc *sc = mac->mac_sc;
5427 struct bwn_stats *stats = &mac->mac_stats;
5429 BWN_ASSERT_LOCKED(mac->mac_sc);
5442 if (mac->mac_flags & BWN_MAC_FLAG_DMA) {
5443 bwn_dma_handle_txeof(mac, status);
5445 bwn_pio_handle_txeof(mac, status);
5448 bwn_phy_txpower_check(mac, 0);
5454 struct bwn_mac *mac = prq->prq_mac;
5455 struct bwn_softc *sc = mac->mac_sc;
5510 switch (mac->mac_fw.fw_hdr_format) {
5521 if (!(mac->mac_sc->sc_filters & BWN_MACCTL_PASS_BADFCS)) {
5580 struct bwn_mac *mac = dr->dr_mac;
5581 struct bwn_dma *dma = &mac->mac_method.dma;
5704 bwn_rx_rssi_calc(struct bwn_mac *mac, uint8_t in_rssi,
5707 struct bwn_phy *phy = &mac->mac_phy;
5723 if (siba_sprom_get_bf_lo(mac->mac_sc->sc_dev)
5756 bwn_rxeof(struct bwn_mac *mac, struct mbuf *m, const void *_rxhdr)
5760 struct bwn_softc *sc = mac->mac_sc;
5780 switch (mac->mac_fw.fw_hdr_format) {
5820 BWN_ISOLDFMT(mac),
5824 rate = bwn_plcp_get_ofdmrate(mac, plcp,
5827 rate = bwn_plcp_get_cckrate(mac, plcp);
5829 if (!(mac->mac_sc->sc_filters & BWN_MACCTL_PASS_BADPLCP))
5840 rssi = bwn_rx_rssi_calc(mac, rxhdr->phy.abg.rssi,
5852 DPRINTF(mac->mac_sc, BWN_DEBUG_RECV,
5868 noise = mac->mac_stats.link_noise;
5873 bwn_rx_radiotap(mac, m, rxhdr, plcp, rate, rssi, noise);
5892 bwn_dma_handle_txeof(struct bwn_mac *mac,
5895 struct bwn_dma *dma = &mac->mac_method.dma;
5899 struct bwn_softc *sc = mac->mac_sc;
5905 dr = bwn_dma_parse_cookie(mac, status, status->cookie, &slot);
5965 bwn_pio_handle_txeof(struct bwn_mac *mac,
5970 struct bwn_softc *sc = mac->mac_sc;
5975 tq = bwn_pio_parse_cookie(mac, status->cookie, &tp);
5979 tq->tq_used -= roundup(tp->tp_m->m_pkthdr.len + BWN_HDRSIZE(mac), 4);
6016 bwn_phy_txpower_check(struct bwn_mac *mac, uint32_t flags)
6018 struct bwn_softc *sc = mac->mac_sc;
6019 struct bwn_phy *phy = &mac->mac_phy;
6035 result = phy->recalc_txpwr(mac,
6043 ieee80211_runtask(ic, &mac->mac_txpower);
6113 bwn_set_txhdr_phyctl1(struct bwn_mac *mac, uint8_t bitrate)
6115 struct bwn_phy *phy = &mac->mac_phy;
6184 bwn_set_txhdr(struct bwn_mac *mac, struct ieee80211_node *ni,
6187 const struct bwn_phy *phy = &mac->mac_phy;
6188 struct bwn_softc *sc = mac->mac_sc;
6258 switch (mac->mac_fw.fw_hdr_format) {
6291 switch (bwn_antenna_sanitize(mac, 0)) {
6334 switch (mac->mac_fw.fw_hdr_format) {
6358 switch (mac->mac_fw.fw_hdr_format) {
6387 switch (mac->mac_fw.fw_hdr_format) {
6405 switch (mac->mac_fw.fw_hdr_format) {
6433 txhdr->phyctl_1rts = htole16(bwn_set_txhdr_phyctl1(mac, rts_rate));
6434 txhdr->phyctl_1rtsfb = htole16(bwn_set_txhdr_phyctl1(mac, rts_rate_fb));
6439 txhdr->phyctl_1 = htole16(bwn_set_txhdr_phyctl1(mac, rate));
6440 txhdr->phyctl_1fb = htole16(bwn_set_txhdr_phyctl1(mac, rate_fb));
6443 switch (mac->mac_fw.fw_hdr_format) {
6507 bwn_antenna_sanitize(struct bwn_mac *mac, uint8_t n)
6509 struct bwn_softc *sc = mac->mac_sc;
6514 if (mac->mac_phy.gmode)
6565 bwn_pio_write_multi_4(struct bwn_mac *mac, struct bwn_pio_txqueue *tq,
6568 struct bwn_softc *sc = mac->mac_sc;
6574 bwn_pio_write_4(mac, tq, BWN_PIO8_TXCTL, ctl);
6594 bwn_pio_write_4(mac, tq, BWN_PIO8_TXCTL, ctl);
6595 bwn_pio_write_4(mac, tq, BWN_PIO8_TXDATA, value);
6602 bwn_pio_write_4(struct bwn_mac *mac, struct bwn_pio_txqueue *tq,
6606 BWN_WRITE_4(mac, tq->tq_base + offset, value);
6610 bwn_pio_write_multi_2(struct bwn_mac *mac, struct bwn_pio_txqueue *tq,
6613 struct bwn_softc *sc = mac->mac_sc;
6617 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXCTL, ctl);
6623 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXCTL, ctl);
6624 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXDATA, data[len - 1]);
6631 bwn_pio_write_mbuf_2(struct bwn_mac *mac, struct bwn_pio_txqueue *tq,
6640 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXCTL, ctl);
6649 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXDATA, data);
6656 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXCTL, ctl);
6657 BWN_PIO_WRITE_2(mac, tq, BWN_PIO_TXDATA, data);
6664 bwn_set_slot_time(struct bwn_mac *mac, uint16_t time)
6668 if (mac->mac_phy.type != BWN_PHYTYPE_G)
6671 BWN_WRITE_2(mac, 0x684, 510 + time);
6674 bwn_shm_write_2(mac, BWN_SHARED, 0x0010, time);
6679 bwn_dma_select(struct bwn_mac *mac, uint8_t prio)
6682 if ((mac->mac_flags & BWN_MAC_FLAG_WME) == 0)
6683 return (mac->mac_method.dma.wme[WME_AC_BE]);
6687 return (mac->mac_method.dma.wme[WME_AC_VO]);
6689 return (mac->mac_method.dma.wme[WME_AC_VI]);
6691 return (mac->mac_method.dma.wme[WME_AC_BE]);
6693 return (mac->mac_method.dma.wme[WME_AC_BK]);
6719 bwn_pio_parse_cookie(struct bwn_mac *mac, uint16_t cookie,
6722 struct bwn_pio *pio = &mac->mac_method.pio;
6758 struct bwn_mac *mac = arg;
6759 struct bwn_softc *sc = mac->mac_sc;
6762 if (mac && mac->mac_status >= BWN_MAC_STATUS_STARTED &&
6763 mac->mac_phy.set_txpwr != NULL)
6764 mac->mac_phy.set_txpwr(mac);
6769 bwn_task_15s(struct bwn_mac *mac)
6773 if (mac->mac_fw.opensource) {
6774 reg = bwn_shm_read_2(mac, BWN_SCRATCH, BWN_WATCHDOG_REG);
6776 bwn_restart(mac, "fw watchdog");
6779 bwn_shm_write_2(mac, BWN_SCRATCH, BWN_WATCHDOG_REG, 1);
6781 if (mac->mac_phy.task_15s)
6782 mac->mac_phy.task_15s(mac);
6784 mac->mac_phy.txerrors = BWN_TXERROR_MAX;
6788 bwn_task_30s(struct bwn_mac *mac)
6791 if (mac->mac_phy.type != BWN_PHYTYPE_G || mac->mac_noise.noi_running)
6793 mac->mac_noise.noi_running = 1;
6794 mac->mac_noise.noi_nsamples = 0;
6796 bwn_noise_gensample(mac);
6800 bwn_task_60s(struct bwn_mac *mac)
6803 if (mac->mac_phy.task_60s)
6804 mac->mac_phy.task_60s(mac);
6805 bwn_phy_txpower_check(mac, BWN_TXPWR_IGNORE_TIME);
6811 struct bwn_mac *mac = arg;
6812 struct bwn_softc *sc = mac->mac_sc;
6815 if (mac->mac_status != BWN_MAC_STATUS_STARTED)
6818 if (mac->mac_task_state % 4 == 0)
6819 bwn_task_60s(mac);
6820 if (mac->mac_task_state % 2 == 0)
6821 bwn_task_30s(mac);
6822 bwn_task_15s(mac);
6824 mac->mac_task_state++;
6825 callout_reset(&sc->sc_task_ch, hz * 15, bwn_tasks, mac);
6829 bwn_plcp_get_ofdmrate(struct bwn_mac *mac, struct bwn_plcp6 *plcp, uint8_t a)
6831 struct bwn_softc *sc = mac->mac_sc;
6859 bwn_plcp_get_cckrate(struct bwn_mac *mac, struct bwn_plcp6 *plcp)
6861 struct bwn_softc *sc = mac->mac_sc;
6878 bwn_rx_radiotap(struct bwn_mac *mac, struct mbuf *m,
6882 struct bwn_softc *sc = mac->mac_sc;
6895 bwn_tsf_read(mac, &tsf);
6899 switch (mac->mac_fw.fw_hdr_format) {
6920 bwn_tsf_read(struct bwn_mac *mac, uint64_t *tsf)
6924 KASSERT(siba_get_revid(mac->mac_sc->sc_dev) >= 3,
6927 low = BWN_READ_4(mac, BWN_REV3PLUS_TSF_LOW);
6928 high = BWN_READ_4(mac, BWN_REV3PLUS_TSF_HIGH);
6935 bwn_dma_attach(struct bwn_mac *mac)
6937 struct bwn_dma *dma = &mac->mac_method.dma;
6938 struct bwn_softc *sc = mac->mac_sc;
6947 mac->mac_flags |= BWN_MAC_FLAG_DMA;
6949 dma->dmatype = bwn_dma_gettype(mac);
7012 dma->wme[WME_AC_BK] = bwn_dma_ringsetup(mac, 0, 1, dma->dmatype);
7016 dma->wme[WME_AC_BE] = bwn_dma_ringsetup(mac, 1, 1, dma->dmatype);
7020 dma->wme[WME_AC_VI] = bwn_dma_ringsetup(mac, 2, 1, dma->dmatype);
7024 dma->wme[WME_AC_VO] = bwn_dma_ringsetup(mac, 3, 1, dma->dmatype);
7028 dma->mcast = bwn_dma_ringsetup(mac, 4, 1, dma->dmatype);
7031 dma->rx = bwn_dma_ringsetup(mac, 0, 0, dma->dmatype);
7049 bwn_dma_parse_cookie(struct bwn_mac *mac, const struct bwn_txstatus *status,
7052 struct bwn_dma *dma = &mac->mac_method.dma;
7054 struct bwn_softc *sc = mac->mac_sc;
7056 BWN_ASSERT_LOCKED(mac->mac_sc);
7098 bwn_dma_stop(struct bwn_mac *mac)
7102 if ((mac->mac_flags & BWN_MAC_FLAG_DMA) == 0)
7104 dma = &mac->mac_method.dma;
7125 bwn_pio_stop(struct bwn_mac *mac)
7129 if (mac->mac_flags & BWN_MAC_FLAG_DMA)
7131 pio = &mac->mac_method.pio;
7141 bwn_led_attach(struct bwn_mac *mac)
7143 struct bwn_softc *sc = mac->mac_sc;
7215 bwn_led_newstate(struct bwn_mac *mac, enum ieee80211_state nstate)
7217 struct bwn_softc *sc = mac->mac_sc;
7230 val = BWN_READ_2(mac, BWN_GPIO_CONTROL);
7272 BWN_WRITE_2(mac, BWN_GPIO_CONTROL, val);
7276 bwn_led_event(struct bwn_mac *mac, int event)
7278 struct bwn_softc *sc = mac->mac_sc;
7307 bwn_led_blink_start(mac, bwn_led_duration[rate].on_dur,
7312 bwn_led_blink_start(struct bwn_mac *mac, int on_dur, int off_dur)
7314 struct bwn_softc *sc = mac->mac_sc;
7318 val = BWN_READ_2(mac, BWN_GPIO_CONTROL);
7320 BWN_WRITE_2(mac, BWN_GPIO_CONTROL, val);
7330 callout_reset(&sc->sc_led_blink_ch, on_dur, bwn_led_blink_next, mac);
7336 struct bwn_mac *mac = arg;
7337 struct bwn_softc *sc = mac->mac_sc;
7340 val = BWN_READ_2(mac, BWN_GPIO_CONTROL);
7342 BWN_WRITE_2(mac, BWN_GPIO_CONTROL, val);
7345 bwn_led_blink_end, mac);
7351 struct bwn_mac *mac = arg;
7352 struct bwn_softc *sc = mac->mac_sc;
7387 struct bwn_mac *mac = sc->sc_curmac;
7390 KASSERT(mac->mac_status >= BWN_MAC_STATUS_STARTED,
7391 ("%s: invalid MAC status %d", __func__, mac->mac_status));
7393 if (mac->mac_phy.rev >= 3 || mac->mac_phy.type == BWN_PHYTYPE_LP
7394 || mac->mac_phy.type == BWN_PHYTYPE_N) {
7395 if (!(BWN_READ_4(mac, BWN_RF_HWENABLED_HI)
7399 if (BWN_READ_2(mac, BWN_RF_HWENABLED_LO)
7404 if (mac->mac_flags & BWN_MAC_FLAG_RADIO_ON)
7412 mac->mac_flags |= BWN_MAC_FLAG_RADIO_ON;
7414 mac->mac_flags &= ~BWN_MAC_FLAG_RADIO_ON;
7419 if (cur != mac->mac_phy.rf_on) {
7421 bwn_rf_turnon(mac);
7423 bwn_rf_turnoff(mac);
7434 struct bwn_mac *mac;
7439 if ((mac = sc->sc_curmac) == NULL)
7441 stats = &mac->mac_stats;