Lines Matching +full:cmdq +full:- +full:sync
2 /*-
3 * Copyright (c) 2005-2007 Damien Bergamini <damien.bergamini@free.fr>
5 * Copyright (c) 2007-2008 Hans Petter Selasky <hselasky@FreeBSD.org>
22 /*-
468 if (uaa->usb_mode != USB_MODE_HOST)
470 if (uaa->info.bConfigIndex != 0)
472 if (uaa->info.bIfaceIndex != RT2573_IFACE_INDEX)
483 struct ieee80211com *ic = &sc->sc_ic;
489 sc->sc_udev = uaa->device;
490 sc->sc_dev = self;
494 mbufq_init(&sc->sc_snd, ifqmaxlen);
497 error = usbd_transfer_setup(uaa->device, &iface_index,
498 sc->sc_xfer, rum_config, RUM_N_TRANSFER, sc, &sc->sc_mtx);
514 device_printf(sc->sc_dev, "timeout waiting for chip to settle\n");
522 device_printf(sc->sc_dev, "MAC/BBP RT2573 (rev 0x%05x), RF %s\n",
523 tmp, rum_get_rf(sc->rf_rev));
528 ic->ic_softc = sc;
529 ic->ic_name = device_get_nameunit(self);
530 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */
533 ic->ic_caps =
545 | IEEE80211_C_PMGT /* Station-side power mgmt */
549 ic->ic_cryptocaps =
555 rum_getradiocaps(ic, IEEE80211_CHAN_MAX, &ic->ic_nchans,
556 ic->ic_channels);
559 ic->ic_update_promisc = rum_update_promisc;
560 ic->ic_raw_xmit = rum_raw_xmit;
561 ic->ic_scan_start = rum_scan_start;
562 ic->ic_scan_end = rum_scan_end;
563 ic->ic_set_channel = rum_set_channel;
564 ic->ic_getradiocaps = rum_getradiocaps;
565 ic->ic_transmit = rum_transmit;
566 ic->ic_parent = rum_parent;
567 ic->ic_vap_create = rum_vap_create;
568 ic->ic_vap_delete = rum_vap_delete;
569 ic->ic_updateslot = rum_update_slot;
570 ic->ic_wme.wme_update = rum_wme_update;
571 ic->ic_update_mcast = rum_update_mcast;
574 &sc->sc_txtap.wt_ihdr, sizeof(sc->sc_txtap),
576 &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap),
579 TASK_INIT(&sc->cmdq_task, 0, rum_cmdq_cb, sc);
595 struct ieee80211com *ic = &sc->sc_ic;
599 sc->sc_detached = 1;
603 usbd_transfer_unsetup(sc->sc_xfer, RUM_N_TRANSFER);
610 if (ic->ic_softc == sc) {
611 ieee80211_draintask(ic, &sc->cmdq_task);
615 mbufq_drain(&sc->sc_snd);
629 while (ntries--) {
630 err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx,
663 struct rum_softc *sc = ic->ic_softc;
667 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */
670 vap = &rvp->vap;
681 rvp->newstate = vap->iv_newstate;
682 vap->iv_newstate = rum_newstate;
683 vap->iv_key_alloc = rum_key_alloc;
684 vap->iv_key_set = rum_key_set;
685 vap->iv_key_delete = rum_key_delete;
686 vap->iv_update_beacon = rum_update_beacon;
687 vap->iv_reset = rum_reset;
688 vap->iv_max_aid = RT2573_ADDR_MAX;
697 rvp->recv_mgmt = vap->iv_recv_mgmt;
698 vap->iv_recv_mgmt = rum_sta_recv_mgmt;
701 rvp->bmiss = vap->iv_bmiss;
702 vap->iv_bmiss = rum_beacon_miss;
705 usb_callout_init_mtx(&rvp->ratectl_ch, &sc->sc_mtx, 0);
706 TASK_INIT(&rvp->ratectl_task, 0, rum_ratectl_task, rvp);
712 ic->ic_opmode = opmode;
720 struct ieee80211com *ic = vap->iv_ic;
721 struct rum_softc *sc = ic->ic_softc;
725 ieee80211_new_state(vap, IEEE80211_S_INIT, -1);
727 ieee80211_draintask(ic, &vap->iv_nstate_task[i]);
734 usb_callout_drain(&rvp->ratectl_ch);
735 ieee80211_draintask(ic, &rvp->ratectl_task);
738 m_freem(rvp->bcn_mbuf);
749 while (sc->cmdq[sc->cmdq_first].func != NULL) {
750 rc = &sc->cmdq[sc->cmdq_first];
754 rc->func(sc, &rc->data, rc->rvp_id);
759 sc->cmdq_first = (sc->cmdq_first + 1) % RUM_CMDQ_SIZE;
768 struct ieee80211com *ic = &sc->sc_ic;
773 if (sc->cmdq[sc->cmdq_last].func != NULL) {
774 device_printf(sc->sc_dev, "%s: cmdq overflow\n", __func__);
781 memcpy(&sc->cmdq[sc->cmdq_last].data, ptr, len);
782 sc->cmdq[sc->cmdq_last].rvp_id = rvp_id;
783 sc->cmdq[sc->cmdq_last].func = func;
784 sc->cmdq_last = (sc->cmdq_last + 1) % RUM_CMDQ_SIZE;
787 ieee80211_runtask(ic, &sc->cmdq_task);
795 struct rum_softc *sc = data->sc;
797 if (data->m != NULL) {
798 ieee80211_tx_complete(data->ni, data->m, txerr);
799 data->m = NULL;
800 data->ni = NULL;
802 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
803 sc->tx_nfree++;
812 sc->tx_nfree = 0;
813 STAILQ_INIT(&sc->tx_q);
814 STAILQ_INIT(&sc->tx_free);
817 data = &sc->tx_data[i];
819 data->sc = sc;
820 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
821 sc->tx_nfree++;
832 STAILQ_FOREACH_SAFE(data, &sc->tx_q, next, tmp) {
833 if (data->ni != NULL && data->ni->ni_vap == vap) {
834 ieee80211_free_node(data->ni);
835 data->ni = NULL;
837 KASSERT(data->m != NULL, ("%s: m is NULL\n",
839 m_freem(data->m);
840 data->m = NULL;
842 STAILQ_REMOVE(&sc->tx_q, data, rum_tx_data, next);
843 STAILQ_INSERT_TAIL(&sc->tx_free, data, next);
844 sc->tx_nfree++;
856 sc->tx_nfree = 0;
857 STAILQ_INIT(&sc->tx_q);
858 STAILQ_INIT(&sc->tx_free);
862 data = &sc->tx_data[i];
864 if (data->m != NULL) {
865 m_freem(data->m);
866 data->m = NULL;
868 if (data->ni != NULL) {
869 ieee80211_free_node(data->ni);
870 data->ni = NULL;
878 struct ieee80211com *ic = vap->iv_ic;
879 struct rum_softc *sc = ic->ic_softc;
884 if (sc->sc_sleeping && sc->sc_sleep_end < ticks) {
888 sc->sc_sleeping = 0;
891 sleep = sc->sc_sleeping;
895 rvp->bmiss(vap);
907 struct ieee80211vap *vap = ni->ni_vap;
908 struct rum_softc *sc = vap->iv_ic->ic_softc;
911 if (vap->iv_state == IEEE80211_S_SLEEP &&
915 !!(sc->last_rx_flags & RT2573_RX_MYBSS),
916 sc->last_rx_flags);
918 if ((sc->last_rx_flags & (RT2573_RX_MYBSS | RT2573_RX_BC)) ==
923 * SLEEP -> RUN state transition.
930 rvp->recv_mgmt(ni, m, subtype, rxs, rssi, nf);
941 sleep ? "sleep" : "awake", sc->sc_sleep_time);
946 device_printf(sc->sc_dev,
952 sc->sc_sleeping = !!sleep;
953 sc->sc_sleep_end = sleep ? ticks + sc->sc_sleep_time : 0;
962 struct ieee80211com *ic = vap->iv_ic;
963 struct rum_softc *sc = ic->ic_softc;
970 ostate = vap->iv_state;
971 DPRINTF("%s -> %s\n",
977 usb_callout_stop(&rvp->ratectl_ch);
979 if (ostate == IEEE80211_S_SLEEP && vap->iv_opmode == IEEE80211_M_STA) {
1001 ni = ieee80211_ref_node(vap->iv_bss);
1003 if (vap->iv_opmode != IEEE80211_M_MONITOR) {
1004 if (ic->ic_bsschan == IEEE80211_CHAN_ANYC ||
1005 ni->ni_chan == IEEE80211_CHAN_ANYC) {
1014 IEEE80211_ADDR_COPY(sc->sc_bssid, ni->ni_bssid);
1015 rum_set_bssid(sc, sc->sc_bssid);
1018 if (vap->iv_opmode == IEEE80211_M_HOSTAP ||
1019 vap->iv_opmode == IEEE80211_M_IBSS) {
1024 if (vap->iv_opmode != IEEE80211_M_MONITOR &&
1025 vap->iv_opmode != IEEE80211_M_AHDEMO) {
1032 tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)];
1033 if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE)
1040 if (vap->iv_opmode != IEEE80211_M_STA)
1057 device_printf(sc->sc_dev,
1067 return (ret == 0 ? rvp->newstate(vap, nstate, arg) : ret);
1095 data = STAILQ_FIRST(&sc->tx_q);
1097 STAILQ_REMOVE_HEAD(&sc->tx_q, next);
1098 m = data->m;
1100 if (m->m_pkthdr.len > (int)(MCLBYTES + RT2573_TX_DESC_SIZE)) {
1102 m->m_pkthdr.len);
1103 m->m_pkthdr.len = (MCLBYTES + RT2573_TX_DESC_SIZE);
1106 usbd_copy_in(pc, 0, &data->desc, RT2573_TX_DESC_SIZE);
1108 m->m_pkthdr.len);
1110 vap = data->ni->ni_vap;
1112 struct rum_tx_radiotap_header *tap = &sc->sc_txtap;
1114 tap->wt_flags = 0;
1115 tap->wt_rate = data->rate;
1116 tap->wt_antenna = sc->tx_ant;
1121 /* align end on a 4-bytes boundary */
1122 len = (RT2573_TX_DESC_SIZE + m->m_pkthdr.len + 3) & ~3;
1127 m->m_pkthdr.len, len);
1141 counter_u64_add(sc->sc_ic.ic_oerrors, 1);
1150 device_printf(sc->sc_dev, "device timeout\n");
1168 struct ieee80211com *ic = &sc->sc_ic;
1186 device_get_nameunit(sc->sc_dev), len);
1187 counter_u64_add(ic->ic_ierrors, 1);
1191 len -= RT2573_RX_DESC_SIZE;
1193 usbd_copy_out(pc, 0, &sc->sc_rx_desc, RT2573_RX_DESC_SIZE);
1195 rssi = rum_get_rssi(sc, sc->sc_rx_desc.rssi);
1196 flags = le32toh(sc->sc_rx_desc.flags);
1197 sc->last_rx_flags = flags;
1200 "bytes\n", device_get_nameunit(sc->sc_dev),
1202 counter_u64_add(ic->ic_ierrors, 1);
1208 device_get_nameunit(sc->sc_dev), len);
1209 counter_u64_add(ic->ic_ierrors, 1);
1219 counter_u64_add(ic->ic_ierrors, 1);
1234 counter_u64_add(ic->ic_ierrors, 1);
1241 counter_u64_add(ic->ic_ierrors, 1);
1249 if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) &&
1252 wh->i_fc[1] &= ~IEEE80211_FC1_PROTECTED;
1253 m->m_flags |= M_WEP;
1257 m->m_pkthdr.len = m->m_len = len;
1260 struct rum_rx_radiotap_header *tap = &sc->sc_rxtap;
1262 tap->wr_flags = 0;
1263 tap->wr_rate = ieee80211_plcp2rate(sc->sc_rx_desc.rate,
1266 rum_get_tsf(sc, &tap->wr_tsf);
1267 tap->wr_antsignal = RT2573_NOISE_FLOOR + rssi;
1268 tap->wr_antnoise = RT2573_NOISE_FLOOR;
1269 tap->wr_antenna = sc->rx_ant;
1284 if (m->m_len >= sizeof(struct ieee80211_frame_min))
1315 /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */
1325 /* CCK rates (NB: not IEEE std, device-specific) */
1348 device_printf(sc->sc_dev, "unknown cipher %d\n", cipher);
1358 struct ieee80211com *ic = &sc->sc_ic;
1359 struct wmeParams *wmep = &sc->wme_params[qid];
1366 if (k != NULL && !(k->wk_flags & IEEE80211_KEY_SWCRYPT)) {
1367 const struct ieee80211_cipher *cip = k->wk_cipher;
1369 len += cip->ic_header + cip->ic_trailer + cip->ic_miclen;
1371 desc->eiv = 0; /* for WEP */
1372 cip->ic_setiv(k, (uint8_t *)&desc->iv);
1376 desc->plcp_signal = rum_plcp_signal(rate);
1377 desc->plcp_service = 4;
1380 if (ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM) {
1384 desc->plcp_length_hi = plcp_length >> 6;
1385 desc->plcp_length_lo = plcp_length & 0x3f;
1393 desc->plcp_service |= RT2573_PLCP_LENGEXT;
1395 desc->plcp_length_hi = plcp_length >> 8;
1396 desc->plcp_length_lo = plcp_length & 0xff;
1398 if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
1399 desc->plcp_signal |= 0x08;
1402 desc->flags = htole32(flags);
1403 desc->hdrlen = hdrlen;
1404 desc->xflags = xflags;
1406 desc->wme = htole16(RT2573_QID(qid) |
1407 RT2573_AIFSN(wmep->wmep_aifsn) |
1408 RT2573_LOGCWMIN(wmep->wmep_logcwmin) |
1409 RT2573_LOGCWMAX(wmep->wmep_logcwmax));
1416 struct ieee80211com *ic = ni->ni_ic;
1425 if_inc_counter(ni->ni_vap->iv_ifp, IFCOUNTER_OERRORS, 1);
1426 device_printf(sc->sc_dev,
1431 protrate = ieee80211_ctl_rate(ic->ic_rt, rate);
1436 data = STAILQ_FIRST(&sc->tx_free);
1437 STAILQ_REMOVE_HEAD(&sc->tx_free, next);
1438 sc->tx_nfree--;
1440 data->m = mprot;
1441 data->ni = ieee80211_ref_node(ni);
1442 data->rate = protrate;
1443 rum_setup_tx_desc(sc, &data->desc, NULL, flags, 0, 0, 0,
1444 mprot->m_pkthdr.len, protrate);
1446 STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1447 usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
1456 struct ieee80211vap *vap = ni->ni_vap;
1461 if (!(k->wk_flags & IEEE80211_KEY_SWCRYPT)) {
1462 cipher = k->wk_cipher->ic_cipher;
1463 pos = k->wk_keyix;
1464 mode = rum_crypto_mode(sc, cipher, k->wk_keylen);
1488 const struct ieee80211_txparam *tp = ni->ni_txparms;
1489 struct ieee80211com *ic = &sc->sc_ic;
1500 data = STAILQ_FIRST(&sc->tx_free);
1501 STAILQ_REMOVE_HEAD(&sc->tx_free, next);
1502 sc->tx_nfree--;
1505 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
1509 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
1514 if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) &&
1515 !k->wk_cipher->ic_encap(k, m0))
1521 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1524 dur = ieee80211_ack_duration(ic->ic_rt, tp->mgmtrate,
1525 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
1526 USETW(wh->i_dur, dur);
1539 data->m = m0;
1540 data->ni = ni;
1541 data->rate = tp->mgmtrate;
1543 rum_setup_tx_desc(sc, &data->desc, k, flags, xflags, ac, hdrlen,
1544 m0->m_pkthdr.len, tp->mgmtrate);
1547 m0->m_pkthdr.len + (int)RT2573_TX_DESC_SIZE, tp->mgmtrate);
1549 STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1550 usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
1559 struct ieee80211com *ic = ni->ni_ic;
1569 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
1571 ac = params->ibp_pri & 3;
1573 rate = params->ibp_rate0;
1574 if (!ieee80211_isratevalid(ic->ic_rt, rate))
1578 if ((params->ibp_flags & IEEE80211_BPF_NOACK) == 0)
1580 if (params->ibp_flags & (IEEE80211_BPF_RTS|IEEE80211_BPF_CTS)) {
1582 params->ibp_flags & IEEE80211_BPF_RTS ?
1585 if (error || sc->tx_nfree == 0)
1594 data = STAILQ_FIRST(&sc->tx_free);
1595 STAILQ_REMOVE_HEAD(&sc->tx_free, next);
1596 sc->tx_nfree--;
1598 data->m = m0;
1599 data->ni = ni;
1600 data->rate = rate;
1603 rum_setup_tx_desc(sc, &data->desc, NULL, flags, xflags, ac, 0,
1604 m0->m_pkthdr.len, rate);
1607 m0->m_pkthdr.len, rate);
1609 STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1610 usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
1618 struct ieee80211vap *vap = ni->ni_vap;
1619 struct ieee80211com *ic = &sc->sc_ic;
1622 const struct ieee80211_txparam *tp = ni->ni_txparms;
1632 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
1636 qos = ((const struct ieee80211_qosframe *)wh)->i_qos[0];
1641 if (m0->m_flags & M_EAPOL)
1642 rate = tp->mgmtrate;
1643 else if (IEEE80211_IS_MULTICAST(wh->i_addr1))
1644 rate = tp->mcastrate;
1645 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
1646 rate = tp->ucastrate;
1649 rate = ni->ni_txrate;
1652 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
1658 if ((k->wk_flags & IEEE80211_KEY_SWCRYPT) &&
1659 !k->wk_cipher->ic_encap(k, m0)) {
1671 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1673 if (m0->m_pkthdr.len + IEEE80211_CRC_LEN > vap->iv_rtsthreshold)
1675 else if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
1676 ieee80211_rate2phytype(ic->ic_rt, rate) == IEEE80211_T_OFDM)
1677 prot = ic->ic_protmode;
1680 if (error || sc->tx_nfree == 0) {
1691 data = STAILQ_FIRST(&sc->tx_free);
1692 STAILQ_REMOVE_HEAD(&sc->tx_free, next);
1693 sc->tx_nfree--;
1695 data->m = m0;
1696 data->ni = ni;
1697 data->rate = rate;
1699 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
1705 dur = ieee80211_ack_duration(ic->ic_rt, rate,
1706 ic->ic_flags & IEEE80211_F_SHPREAMBLE);
1707 USETW(wh->i_dur, dur);
1710 rum_setup_tx_desc(sc, &data->desc, k, flags, xflags, ac, hdrlen,
1711 m0->m_pkthdr.len, rate);
1714 m0->m_pkthdr.len + (int)RT2573_TX_DESC_SIZE, rate);
1716 STAILQ_INSERT_TAIL(&sc->tx_q, data, next);
1717 usbd_transfer_start(sc->sc_xfer[RUM_BULK_WR]);
1725 struct rum_softc *sc = ic->ic_softc;
1729 if (!sc->sc_running) {
1733 error = mbufq_enqueue(&sc->sc_snd, m);
1752 if (!sc->sc_running)
1755 while (sc->tx_nfree >= RUM_TX_MINFREE &&
1756 (m = mbufq_dequeue(&sc->sc_snd)) != NULL) {
1757 ni = (struct ieee80211_node *) m->m_pkthdr.rcvif;
1759 if_inc_counter(ni->ni_vap->iv_ifp,
1770 struct rum_softc *sc = ic->ic_softc;
1771 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
1774 if (sc->sc_detached) {
1780 if (ic->ic_nrunning > 0) {
1803 device_printf(sc->sc_dev, "could not read EEPROM: %s\n",
1832 device_printf(sc->sc_dev,
1860 USETW(req.wLength, MIN(len - offset, 64));
1864 device_printf(sc->sc_dev,
1917 device_printf(sc->sc_dev, "could not write to BBP\n");
1934 device_printf(sc->sc_dev, "could not read BBP\n");
1949 device_printf(sc->sc_dev, "could not read BBP\n");
1966 device_printf(sc->sc_dev, "could not write to RF\n");
1975 sc->rf_regs[reg] = val;
1977 DPRINTFN(15, "RF R[%u] <- 0x%05x\n", reg & 3, val & 0xfffff);
2002 * Enable multi-rate retries for frames sent at OFDM rates.
2008 struct ieee80211com *ic = &sc->sc_ic;
2010 if (!IEEE80211_IS_CHAN_5GHZ(ic->ic_bsschan)) {
2022 struct ieee80211com *ic = &sc->sc_ic;
2024 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE)
2033 struct ieee80211com *ic = &sc->sc_ic;
2036 if (ic->ic_curmode == IEEE80211_MODE_11B) {
2039 } else if (IEEE80211_IS_CHAN_5GHZ(ic->ic_bsschan)) {
2064 if ((IEEE80211_IS_CHAN_2GHZ(c) && sc->ext_2ghz_lna) ||
2065 (IEEE80211_IS_CHAN_5GHZ(c) && sc->ext_5ghz_lna)) {
2069 sc->bbp17 = bbp17;
2074 if ((IEEE80211_IS_CHAN_2GHZ(c) && sc->ext_2ghz_lna) ||
2075 (IEEE80211_IS_CHAN_5GHZ(c) && sc->ext_5ghz_lna)) {
2097 struct ieee80211com *ic = &sc->sc_ic;
2108 rfprog = (sc->rf_rev == RT2573_RF_5225 ||
2109 sc->rf_rev == RT2573_RF_2527) ? rum_rf5225 : rum_rf5226;
2114 power = sc->txpow[i];
2119 bbp94 += power - 31;
2125 * vice-versa, BBP registers need to be reprogrammed.
2127 if (c->ic_flags != ic->ic_curchan->ic_flags) {
2131 ic->ic_curchan = c;
2136 rum_rf_write(sc, RT2573_RF4, rfprog[i].r4 | sc->rffreq << 10);
2141 rum_rf_write(sc, RT2573_RF4, rfprog[i].r4 | sc->rffreq << 10);
2146 rum_rf_write(sc, RT2573_RF4, rfprog[i].r4 | sc->rffreq << 10);
2150 /* enable smart mode for MIMO-capable RFs */
2154 if (sc->rf_rev == RT2573_RF_5225 || sc->rf_rev == RT2573_RF_2527)
2169 struct ieee80211_node *ni = vap->iv_bss;
2170 const struct ieee80211_txparam *tp = ni->ni_txparms;
2173 rvp->maxretry = MIN(tp->maxretry, 0xf);
2175 rum_modbits(sc, RT2573_TXRX_CSR4, RT2573_SHORT_RETRY(rvp->maxretry) |
2176 RT2573_LONG_RETRY(rvp->maxretry),
2187 struct ieee80211com *ic = &sc->sc_ic;
2188 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2192 if (vap->iv_opmode != IEEE80211_M_STA) {
2204 bintval = vap->iv_bss->ni_intval;
2208 switch (vap->iv_opmode) {
2225 /* SYNC with nobody */
2230 device_printf(sc->sc_dev,
2232 vap->iv_opmode);
2265 struct ieee80211com *ic = &sc->sc_ic;
2278 rum_cmd_sleepable(ic->ic_softc, NULL, 0, 0, rum_update_slot_cb);
2286 struct rum_softc *sc = ic->ic_softc;
2325 memcpy(sc->wme_params, chanp, sizeof(*chanp) * WME_NUM_AC);
2330 device_printf(sc->sc_dev, "%s: WME update failed, error %d\n",
2360 struct ieee80211com *ic = &sc->sc_ic;
2362 if (ic->ic_promisc == 0)
2367 DPRINTF("%s promiscuous mode\n", ic->ic_promisc > 0 ?
2374 struct rum_softc *sc = ic->ic_softc;
2377 if (sc->sc_running)
2409 rum_eeprom_read(sc, RT2573_EEPROM_ADDRESS, sc->sc_ic.ic_macaddr, 6);
2413 sc->rf_rev = (val >> 11) & 0x1f;
2414 sc->hw_radio = (val >> 10) & 0x1;
2415 sc->rx_ant = (val >> 4) & 0x3;
2416 sc->tx_ant = (val >> 2) & 0x3;
2417 sc->nb_ant = val & 0x3;
2419 DPRINTF("RF revision=%d\n", sc->rf_rev);
2423 sc->ext_5ghz_lna = (val >> 6) & 0x1;
2424 sc->ext_2ghz_lna = (val >> 4) & 0x1;
2427 sc->ext_2ghz_lna, sc->ext_5ghz_lna);
2432 sc->rssi_2ghz_corr = (int8_t)(val & 0xff); /* signed */
2434 /* Only [-10, 10] is valid */
2435 if (sc->rssi_2ghz_corr < -10 || sc->rssi_2ghz_corr > 10)
2436 sc->rssi_2ghz_corr = 0;
2441 sc->rssi_5ghz_corr = (int8_t)(val & 0xff); /* signed */
2443 /* Only [-10, 10] is valid */
2444 if (sc->rssi_5ghz_corr < -10 || sc->rssi_5ghz_corr > 10)
2445 sc->rssi_5ghz_corr = 0;
2447 if (sc->ext_2ghz_lna)
2448 sc->rssi_2ghz_corr -= 14;
2449 if (sc->ext_5ghz_lna)
2450 sc->rssi_5ghz_corr -= 14;
2453 sc->rssi_2ghz_corr, sc->rssi_5ghz_corr);
2458 sc->rffreq = val & 0xff;
2460 DPRINTF("RF freq=%d\n", sc->rffreq);
2463 rum_eeprom_read(sc, RT2573_EEPROM_TXPOWER, sc->txpow, 14);
2465 memset(sc->txpow + 14, 24, sizeof (sc->txpow) - 14);
2468 DPRINTF("Channel=%d Tx power=%d\n", i + 1, sc->txpow[i]);
2472 rum_eeprom_read(sc, RT2573_EEPROM_BBP_BASE, sc->bbp_prom, 2 * 16);
2475 if (sc->bbp_prom[i].reg == 0 || sc->bbp_prom[i].reg == 0xff)
2477 DPRINTF("BBP R%d=%02x\n", sc->bbp_prom[i].reg,
2478 sc->bbp_prom[i].val);
2496 device_printf(sc->sc_dev,
2518 device_printf(sc->sc_dev, "timeout waiting for BBP\n");
2526 /* write vendor-specific BBP values (from EEPROM) */
2528 if (sc->bbp_prom[i].reg == 0 || sc->bbp_prom[i].reg == 0xff)
2530 rum_bbp_write(sc, sc->bbp_prom[i].reg, sc->bbp_prom[i].val);
2547 struct ieee80211com *ic = &sc->sc_ic;
2548 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2553 if (sc->sc_running) {
2563 sc->wme_params[0].wmep_aifsn = 2;
2564 sc->wme_params[0].wmep_logcwmin = 4;
2565 sc->wme_params[0].wmep_logcwmax = 10;
2579 rum_select_band(sc, ic->ic_curchan);
2581 rum_set_chan(sc, ic->ic_curchan);
2584 rum_read_multi(sc, RT2573_STA_CSR0, sc->sta, sizeof sc->sta);
2587 if (sc->sc_clr_shkeys == 0) {
2589 sc->sc_clr_shkeys = 1;
2592 rum_set_macaddr(sc, vap ? vap->iv_myaddr : ic->ic_macaddr);
2606 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
2609 if (ic->ic_opmode != IEEE80211_M_HOSTAP)
2611 if (ic->ic_promisc == 0)
2616 sc->sc_running = 1;
2617 usbd_xfer_set_stall(sc->sc_xfer[RUM_BULK_WR]);
2618 usbd_transfer_start(sc->sc_xfer[RUM_BULK_RD]);
2633 if (!sc->sc_running) {
2637 sc->sc_running = 0;
2643 usbd_transfer_drain(sc->sc_xfer[RUM_BULK_WR]);
2644 usbd_transfer_drain(sc->sc_xfer[RUM_BULK_RD]);
2665 for (; size >= 4; reg += 4, ucode += 4, size -= 4) {
2669 device_printf(sc->sc_dev, "Firmware load "
2677 device_printf(sc->sc_dev, "could not run firmware: %s\n",
2688 struct ieee80211com *ic = &sc->sc_ic;
2694 exp = ic->ic_lintval / bintval;
2695 delay = ic->ic_lintval % bintval;
2711 sc->sc_sleep_time = IEEE80211_TU_TO_TICKS(exp * bintval + delay);
2719 struct ieee80211com *ic = vap->iv_ic;
2721 struct rum_softc *sc = ic->ic_softc;
2731 ni = ieee80211_ref_node(vap->iv_bss);
2734 error = rum_set_sleep_time(sc, ni->ni_intval);
2735 if (vap->iv_state == IEEE80211_S_SLEEP) {
2756 struct ieee80211com *ic = vap->iv_ic;
2758 struct mbuf *m = rvp->bcn_mbuf;
2766 if (ic->ic_bsschan == IEEE80211_CHAN_ANYC)
2769 tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_bsschan)];
2771 RT2573_TX_HWSEQ, 0, 0, m->m_pkthdr.len, tp->mgmtrate);
2780 mtod(m, uint8_t *), m->m_pkthdr.len) != 0)
2790 struct ieee80211_node *ni = vap->iv_bss;
2793 if (ni->ni_chan == IEEE80211_CHAN_ANYC)
2800 if (rvp->bcn_mbuf != NULL)
2801 m_freem(rvp->bcn_mbuf);
2803 rvp->bcn_mbuf = m;
2812 struct ieee80211vap *vap = data->vap;
2820 struct ieee80211com *ic = vap->iv_ic;
2821 struct rum_softc *sc = ic->ic_softc;
2823 struct ieee80211_beacon_offsets *bo = &vap->iv_bcn_off;
2824 struct ieee80211_node *ni = vap->iv_bss;
2825 struct mbuf *m = rvp->bcn_mbuf;
2832 device_printf(sc->sc_dev,
2837 rvp->bcn_mbuf = m;
2852 setbit(bo->bo_flags, item);
2863 if (rum_write_multi(sc, base, k->wk_key, k->wk_keylen))
2866 if (k->wk_cipher->ic_cipher == IEEE80211_CIPHER_TKIP) {
2868 k->wk_txmic, 8))
2871 k->wk_rxmic, 8))
2882 struct ieee80211_key *k = &data->key;
2885 if (sc->sc_clr_shkeys == 0) {
2887 sc->sc_clr_shkeys = 1;
2890 mode = rum_crypto_mode(sc, k->wk_cipher->ic_cipher, k->wk_keylen);
2895 "(tx %s, rx %s)\n", k->wk_keyix, rvp_id, mode,
2896 (k->wk_flags & IEEE80211_KEY_XMIT) ? "on" : "off",
2897 (k->wk_flags & IEEE80211_KEY_RECV) ? "on" : "off");
2900 if (rum_common_key_set(sc, k, RT2573_SKEY(rvp_id, k->wk_keyix)) != 0)
2905 mode << (rvp_id % 2 + k->wk_keyix) * RT2573_SKEY_MAX,
2906 RT2573_MODE_MASK << (rvp_id % 2 + k->wk_keyix) * RT2573_SKEY_MAX)
2912 1 << (rvp_id * RT2573_SKEY_MAX + k->wk_keyix)) != 0)
2918 device_printf(sc->sc_dev, "%s: cannot set group key %d for vap %d\n",
2919 __func__, k->wk_keyix, rvp_id);
2926 struct ieee80211_key *k = &data->key;
2929 k->wk_keyix, rvp_id);
2932 RT2573_MODE_MASK << (rvp_id % 2 + k->wk_keyix) * RT2573_SKEY_MAX);
2934 rvp_id * RT2573_SKEY_MAX + k->wk_keyix);
2941 struct ieee80211_key *k = &data->key;
2945 mode = rum_crypto_mode(sc, k->wk_cipher->ic_cipher, k->wk_keylen);
2950 "(tx %s, rx %s)\n", k->wk_keyix, rvp_id, mode,
2951 (k->wk_flags & IEEE80211_KEY_XMIT) ? "on" : "off",
2952 (k->wk_flags & IEEE80211_KEY_RECV) ? "on" : "off");
2955 if (rum_common_key_set(sc, k, RT2573_PKEY(k->wk_keyix)) != 0)
2958 IEEE80211_ADDR_COPY(buf, k->wk_macaddr);
2962 if (rum_write_multi(sc, RT2573_ADDR_ENTRY(k->wk_keyix),
2967 if (sc->vap_key_count[rvp_id]++ == 0)
2973 k->wk_keyix < 32 ? RT2573_SEC_CSR2 : RT2573_SEC_CSR3,
2974 1 << (k->wk_keyix % 32)) != 0)
2980 device_printf(sc->sc_dev,
2981 "%s: cannot set pairwise key %d, vap %d\n", __func__, k->wk_keyix,
2989 struct ieee80211_key *k = &data->key;
2991 DPRINTF("%s: removing key %d\n", __func__, k->wk_keyix);
2992 rum_clrbits(sc, (k->wk_keyix < 32) ? RT2573_SEC_CSR2 : RT2573_SEC_CSR3,
2993 1 << (k->wk_keyix % 32));
2994 sc->keys_bmap &= ~(1ULL << k->wk_keyix);
2995 if (--sc->vap_key_count[rvp_id] == 0)
3003 struct rum_softc *sc = vap->iv_ic->ic_softc;
3007 if (!(k->wk_flags & IEEE80211_KEY_SWCRYPT)) {
3010 if ((sc->keys_bmap & (1ULL << i)) == 0) {
3011 sc->keys_bmap |= (1ULL << i);
3018 device_printf(sc->sc_dev,
3035 struct rum_softc *sc = vap->iv_ic->ic_softc;
3038 if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
3052 struct rum_softc *sc = vap->iv_ic->ic_softc;
3055 if (k->wk_flags & IEEE80211_KEY_SWCRYPT) {
3070 struct rum_softc *sc = ni->ni_ic->ic_softc;
3075 if (!sc->sc_running) {
3079 if (sc->tx_nfree < RUM_TX_MINFREE) {
3111 struct ieee80211vap *vap = ni->ni_vap;
3115 rum_read_multi(sc, RT2573_STA_CSR0, sc->sta, sizeof sc->sta);
3117 usb_callout_reset(&rvp->ratectl_ch, hz, rum_ratectl_timeout, rvp);
3124 struct ieee80211vap *vap = &rvp->vap;
3125 struct ieee80211com *ic = vap->iv_ic;
3127 ieee80211_runtask(ic, &rvp->ratectl_task);
3134 struct ieee80211vap *vap = &rvp->vap;
3135 struct rum_softc *sc = vap->iv_ic->ic_softc;
3136 struct ieee80211_ratectl_tx_stats *txs = &sc->sc_txs;
3141 rum_read_multi(sc, RT2573_STA_CSR0, sc->sta, sizeof(sc->sta));
3143 ok[0] = (le32toh(sc->sta[4]) & 0xffff); /* TX ok w/o retry */
3144 ok[1] = (le32toh(sc->sta[4]) >> 16); /* TX ok w/ one retry */
3145 ok[2] = (le32toh(sc->sta[5]) & 0xffff); /* TX ok w/ multiple retries */
3146 fail = (le32toh(sc->sta[5]) >> 16); /* TX retry-fail count */
3148 txs->flags = IEEE80211_RATECTL_TX_STATS_RETRIES;
3149 txs->nframes = ok[0] + ok[1] + ok[2] + fail;
3150 txs->nsuccess = txs->nframes - fail;
3152 txs->nretries = ok[1] + ok[2] * 2 + fail * (rvp->maxretry + 1);
3154 if (txs->nframes != 0)
3157 /* count TX retry-fail as Tx errors */
3158 if_inc_counter(vap->iv_ifp, IFCOUNTER_OERRORS, fail);
3160 usb_callout_reset(&rvp->ratectl_ch, hz, rum_ratectl_timeout, rvp);
3167 struct rum_softc *sc = ic->ic_softc;
3179 struct rum_softc *sc = ic->ic_softc;
3181 if (ic->ic_flags_ext & IEEE80211_FEXT_BGSCAN) {
3183 if (ic->ic_opmode != IEEE80211_M_AHDEMO)
3187 rum_set_bssid(sc, sc->sc_bssid);
3195 struct rum_softc *sc = ic->ic_softc;
3198 rum_set_chan(sc, ic->ic_curchan);
3206 struct rum_softc *sc = ic->ic_softc;
3214 if (sc->rf_rev == RT2573_RF_5225 || sc->rf_rev == RT2573_RF_5226) {
3224 struct ieee80211com *ic = &sc->sc_ic;
3234 * NB: Since RSSI is relative to noise floor, -1 is
3237 return -1;
3240 rssi = (2 * agc) - RT2573_NOISE_FLOOR;
3242 if (IEEE80211_IS_CHAN_2GHZ(ic->ic_curchan)) {
3243 rssi += sc->rssi_2ghz_corr;
3246 rssi -= 64;
3248 rssi -= 74;
3250 rssi -= 90;
3252 rssi += sc->rssi_5ghz_corr;
3254 if (!sc->ext_5ghz_lna && lna != 1)
3258 rssi -= 64;
3260 rssi -= 86;
3262 rssi -= 100;
3271 usb_pause_mtx(&sc->sc_mtx, timeout);