32#include <sys/sockio.h>
33#include <sys/sysctl.h>
36#include <sys/condvar.h>
38#include <sys/kernel.h>
39#include <sys/socket.h>
41#include <sys/malloc.h>
42#include <sys/module.h>
44#include <sys/endian.h>
49#include <net/if_var.h>
50#include <net/if_arp.h>
51#include <net/ethernet.h>
53#include <net/if_media.h>
54#include <net/if_types.h>
57#include <netinet/in.h>
58#include <netinet/in_systm.h>
59#include <netinet/in_var.h>
60#include <netinet/if_ether.h>
61#include <netinet/ip.h>
64#include <net80211/ieee80211_var.h>
65#include <net80211/ieee80211_regdomain.h>
66#include <net80211/ieee80211_radiotap.h>
67#include <net80211/ieee80211_ratectl.h>
78static int zyd_debug = 0;
80static SYSCTL_NODE(_hw_usb, OID_AUTO, zyd, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
86 ZYD_DEBUG_XMIT = 0x00000001,
87 ZYD_DEBUG_RECV = 0x00000002,
88 ZYD_DEBUG_RESET = 0x00000004,
89 ZYD_DEBUG_INIT = 0x00000008,
90 ZYD_DEBUG_TX_PROC = 0x00000010,
91 ZYD_DEBUG_RX_PROC = 0x00000020,
92 ZYD_DEBUG_STATE = 0x00000040,
93 ZYD_DEBUG_STAT = 0x00000080,
94 ZYD_DEBUG_FW = 0x00000100,
95 ZYD_DEBUG_CMD = 0x00000200,
96 ZYD_DEBUG_ANY = 0xffffffff
98#define DPRINTF(sc, m, fmt, ...) do { \
99 if (zyd_debug & (m)) \
100 printf("%s: " fmt, __func__, ## __VA_ARGS__); \
103#define DPRINTF(sc, m, fmt, ...) do { \
108#define zyd_do_request(sc,req,data) \
109 usbd_do_request_flags((sc)->sc_udev, &(sc)->sc_mtx, req, data, 0, NULL, 5000)
121 const char [IFNAMSIZ],
int,
enum ieee80211_opmode,
int,
122 const uint8_t [IEEE80211_ADDR_LEN],
123 const uint8_t [IEEE80211_ADDR_LEN]);
128static int zyd_newstate(
struct ieee80211vap *,
enum ieee80211_state,
int);
155 struct ieee80211_node *);
156static int zyd_transmit(
struct ieee80211com *,
struct mbuf *);
158static int zyd_raw_xmit(
struct ieee80211_node *,
struct mbuf *,
159 const struct ieee80211_bpf_params *);
167 struct ieee80211_channel[]);
201#define ZYD_ZD1211_DEV(v,p) \
202 { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, ZYD_ZD1211) }
203#define ZYD_ZD1211B_DEV(v,p) \
204 { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, ZYD_ZD1211B) }
263 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
273 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
281 .bufsize =
sizeof(
struct zyd_cmd),
282 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
291 .bufsize =
sizeof(
struct zyd_cmd),
292 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
296#define zyd_read16_m(sc, val, data) do { \
297 error = zyd_read16(sc, val, data); \
301#define zyd_write16_m(sc, val, data) do { \
302 error = zyd_write16(sc, val, data); \
306#define zyd_read32_m(sc, val, data) do { \
307 error = zyd_read32(sc, val, data); \
311#define zyd_write32_m(sc, val, data) do { \
312 error = zyd_write32(sc, val, data); \
337 struct ieee80211com *ic = &sc->
sc_ic;
342 device_printf(
dev,
"device version mismatch: 0x%X "
343 "(only >= 43.30 supported)\n",
354 MTX_NETWORK_LOCK, MTX_DEF);
355 STAILQ_INIT(&sc->sc_rqh);
356 mbufq_init(&sc->
sc_snd, ifqmaxlen);
363 device_printf(
dev,
"could not allocate USB transfers, "
370 device_printf(sc->
sc_dev,
"could not read EEPROM\n");
377 ic->ic_name = device_get_nameunit(
dev);
378 ic->ic_phytype = IEEE80211_T_OFDM;
379 ic->ic_opmode = IEEE80211_M_STA;
384 | IEEE80211_C_MONITOR
385 | IEEE80211_C_SHPREAMBLE
394 ieee80211_ifattach(ic);
407 ieee80211_radiotap_attach(ic,
414 ieee80211_announce(ic);
427 struct ieee80211_node *ni;
430 while ((m = mbufq_dequeue(&sc->
sc_snd)) != NULL) {
431 ni = (
struct ieee80211_node *)m->m_pkthdr.rcvif;
432 m->m_pkthdr.rcvif = NULL;
433 ieee80211_free_node(ni);
442 struct ieee80211com *ic = &sc->
sc_ic;
452 STAILQ_INIT(&sc->
tx_q);
468 if (ic->ic_softc == sc)
469 ieee80211_ifdetach(ic);
475static struct ieee80211vap *
477 enum ieee80211_opmode opmode,
int flags,
478 const uint8_t bssid[IEEE80211_ADDR_LEN],
479 const uint8_t mac[IEEE80211_ADDR_LEN])
482 struct ieee80211vap *vap;
484 if (!TAILQ_EMPTY(&ic->ic_vaps))
486 zvp = malloc(
sizeof(
struct zyd_vap), M_80211_VAP, M_WAITOK | M_ZERO);
490 if (ieee80211_vap_setup(ic, vap,
name, unit, opmode,
491 flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) {
493 free(zvp, M_80211_VAP);
501 ieee80211_ratectl_init(vap);
502 ieee80211_ratectl_setinterval(vap, 1000 );
505 ieee80211_vap_attach(vap, ieee80211_media_change,
506 ieee80211_media_status, mac);
507 ic->ic_opmode = opmode;
516 ieee80211_ratectl_deinit(
vap);
517 ieee80211_vap_detach(
vap);
518 free(zvp, M_80211_VAP);
526 if (
data->m != NULL) {
527 ieee80211_tx_complete(
data->ni,
data->m, txerr);
569 if (
data->m != NULL) {
573 if (
data->ni != NULL) {
574 ieee80211_free_node(
data->ni);
581zyd_newstate(
struct ieee80211vap *vap,
enum ieee80211_state nstate,
int arg)
584 struct ieee80211com *ic = vap->iv_ic;
588 DPRINTF(sc, ZYD_DEBUG_STATE,
"%s: %s -> %s\n", __func__,
589 ieee80211_state_name[vap->iv_state],
590 ieee80211_state_name[nstate]);
592 IEEE80211_UNLOCK(ic);
595 case IEEE80211_S_AUTH:
598 case IEEE80211_S_RUN:
599 if (vap->iv_opmode == IEEE80211_M_MONITOR)
610 IEEE80211_ADDR_COPY(sc->
sc_bssid, vap->iv_bss->ni_bssid);
619 return (zvp->
newstate(vap, nstate, arg));
629 struct ieee80211com *ic = &sc->
sc_ic;
630 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
631 struct ieee80211_node *ni;
644 switch (le16toh(cmd->
code)) {
652 "retry intr: rate=0x%x addr=%s count=%d (0x%x)\n",
653 le16toh(
retry->rate), ether_sprintf(
retry->macaddr),
662 ni = ieee80211_find_txnode(vap,
retry->macaddr);
664 struct ieee80211_ratectl_tx_status *txs =
666 int retrycnt =
count & 0xff;
669 IEEE80211_RATECTL_STATUS_LONG_RETRY;
670 txs->long_retries = retrycnt;
673 IEEE80211_RATECTL_TX_FAIL_LONG;
676 IEEE80211_RATECTL_TX_SUCCESS;
679 ieee80211_ratectl_tx_complete(ni, txs);
680 ieee80211_free_node(ni);
684 if_inc_counter(vap->iv_ifp, IFCOUNTER_OERRORS,
695 datalen = actlen -
sizeof(
cmd->
code);
698 STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) {
702 if (rqp->
olen != datalen)
705 for (i = 0; i <
count; i++) {
706 if (*(((
const uint16_t *)rqp->
idata) + i) !=
715 "command %p complete, data = %*D \n",
716 rqp, rqp->
olen, (
char *)rqp->
odata,
":");
722 "unexpected IORD notification %*D\n",
723 datalen, cmd->
data,
":");
728 device_printf(sc->
sc_dev,
"unknown notification %x\n",
740 DPRINTF(sc, ZYD_DEBUG_CMD,
"error = %s\n",
762 DPRINTF(sc, ZYD_DEBUG_CMD,
"command %p transferred\n", cmd);
763 STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) {
773 STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) {
789 DPRINTF(sc, ZYD_DEBUG_ANY,
"error = %s\n",
803 void *odata,
int olen,
int flags)
814 DPRINTF(sc, ZYD_DEBUG_CMD,
"sending cmd %p = %*D\n",
823 STAILQ_INSERT_TAIL(&sc->sc_rqh, &rq, rq);
828 error = mtx_sleep(&rq, &sc->
sc_mtx, 0 ,
"zydcmd", hz);
830 device_printf(sc->
sc_dev,
"command timeout\n");
831 STAILQ_REMOVE(&sc->sc_rqh, &rq,
zyd_rq, rq);
832 DPRINTF(sc, ZYD_DEBUG_CMD,
"finsihed cmd %p, error = %d \n",
864 *
val = le16toh(tmp[0].
val) << 16 | le16toh(tmp[1].
val);
885 pair[0].
val = htole16(
val >> 16);
887 pair[1].
val = htole16(
val & 0xffff);
903 req.code = htole16(2);
905 for (i = 0; i < rf->
width; i++) {
906 req.bit[i] = htole16(cr203);
907 if (
val & (1 << (rf->
width - 1 - i)))
934 tmp &= ~ZYD_UNLOCK_PHY_REGS;
965 for (i = 0; i < nitems(phyini); i++) {
970 for (i = 0; i < nitems(rfini); i++) {
995 static const struct {
1029 for (i = 0; i < nitems(phyini); i++)
1033 for (i = 0; i < nitems(phy2230s); i++)
1038 for (i = 0; i < nitems(rfini1); i++) {
1051 for (i = 0; i < nitems(rfini2); i++) {
1057 for (i = 0; i < nitems(phypll); i++)
1060 for (i = 0; i < nitems(rfini3); i++) {
1076 for (i = 0; i < nitems(phy); i++)
1102 for (i = 0; i < nitems(phy1); i++)
1106 for (i = 0; i < nitems(phyini); i++)
1110 for (i = 0; i < nitems(phy2230s); i++)
1114 for (i = 0; i < 3; i++) {
1120 for (i = 0; i < nitems(rfini_part1); i++) {
1133 for (i = 0; i < nitems(rfini_part2); i++) {
1139 for (i = 0; i < nitems(phy2); i++)
1142 for (i = 0; i < nitems(rfini_part3); i++) {
1148 for (i = 0; i < nitems(phy3); i++)
1176 static const struct {
1177 uint32_t
r1,
r2, r3;
1190 for (i = 0; i < nitems(phy1); i++)
1202 static const struct {
1203 uint32_t
r1,
r2, r3;
1206 for (i = 0; i < nitems(phy1); i++)
1223#define ZYD_AL2230_PHY_BANDEDGE6 \
1225 { ZYD_CR128, 0x14 }, { ZYD_CR129, 0x12 }, { ZYD_CR130, 0x10 }, \
1226 { ZYD_CR47, 0x1e } \
1234 struct ieee80211com *ic = &sc->
sc_ic;
1236 int chan = ieee80211_chan2ieee(ic, c);
1241 for (i = 0; i < nitems(
r); i++)
1264 for (i = 0; i < nitems(phyini_1); i++)
1268 for (i = 0; i < nitems(rfini_1); i++) {
1273 for (i = 0; i < nitems(phyini_2); i++)
1277 for (i = 0; i < nitems(rfini_2); i++) {
1282 for (i = 0; i < nitems(phyini_3); i++)
1304 static const struct {
1313 for (i = 0; i < nitems(rfsc); i++) {
1356 for (i = 0; i < nitems(phyini); i++)
1360 for (i = 0; i < nitems(rfini); i++) {
1417#define ZYD_GCT_INTR_REG 0x85c1
1422 int i, idx = -1,
error;
1426 for (i = 0; i < nitems(phyini); i++)
1430 for (i = 0; i < nitems(rfini); i++) {
1439 for (i = 0; i < (int)(nitems(vco) - 1); i++) {
1448 if ((
data & 0xf) == 0) {
1466#undef ZYD_GCT_INTR_REG
1473 static const uint32_t mode[] = {
1474 0x25f98, 0x25f9a, 0x25f94, 0x27fd4
1478 for (i = 0; i < nitems(mode); i++) {
1495 (acal == 1) ? acal_synth[idx] : std_synth[idx]);
1541 vco[rf->
idx][((
chan - 1) / 2)]);
1547 for (i = 0; i < nitems(cmd); i++)
1564 if (idx >= nitems(txgain)) {
1565 device_printf(sc->
sc_dev,
"could not set TX gain (%d %#x)\n",
1586 for (i = 0; i < nitems(phyini); i++)
1593 for (i = 0; i < nitems(rfini); i++) {
1617 static const struct {
1629 for (i = 0; i < nitems(phyini); i++)
1644 for (i = 2; i < nitems(rfini); i++) {
1709 device_printf(sc->
sc_dev,
1710 "sorry, radio \"%s\" is not supported yet\n",
1720 static const char *
const zyd_rfs[] = {
1721 "unknown",
"unknown",
"UW2451",
"UCHIP",
"AL2230",
1722 "AL7230B",
"THETA",
"AL2210",
"MAXIM_NEW",
"GCT",
1723 "AL2230S",
"RALINK",
"INTERSIL",
"RFMD",
"MAXIM_NEW2",
1727 return zyd_rfs[(
type > 15) ? 0 :
type];
1741 DPRINTF(sc, ZYD_DEBUG_FW,
"firmware base address=0x%04x\n",
1755 device_printf(sc->
sc_dev,
"could not read EEPROM\n");
1764 for (; phyp->
reg != 0; phyp++)
1816 device_printf(sc->
sc_dev,
"could not attach RF, rev 0x%x\n",
1827 device_printf(sc->
sc_dev,
1828 "radio initialization failed, error %d\n",
error);
1836 device_printf(sc->
sc_dev,
"could not read EEPROM\n");
1858 sc->
sc_txled = ((tmp & (1 << 24)) && (tmp & (1 << 29))) ? 0 : 1;
1870 for (i = 0; i < 7; i++) {
1901 USETW(
req.wLength, IEEE80211_ADDR_LEN);
1905 device_printf(sc->
sc_dev,
"could not read EEPROM: %s\n",
1975 uint32_t *hash = arg;
1978 v = ((uint8_t *)LLADDR(sdl))[5] >> 2;
1982 hash[1] |= 1 << (v - 32);
1990 struct ieee80211com *ic = &sc->
sc_ic;
1997 hash[0] = 0x00000000;
1998 hash[1] = 0x80000000;
2000 if (ic->ic_opmode == IEEE80211_M_MONITOR || ic->ic_allmulti > 0 ||
2001 ic->ic_promisc > 0) {
2002 hash[0] = 0xffffffff;
2003 hash[1] = 0xffffffff;
2005 struct ieee80211vap *vap;
2007 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next)
2016 device_printf(sc->
sc_dev,
2017 "could not set multicast hash table\n");
2033 struct ieee80211com *ic = &sc->
sc_ic;
2036 switch (ic->ic_opmode) {
2037 case IEEE80211_M_STA:
2040 case IEEE80211_M_IBSS:
2041 case IEEE80211_M_HOSTAP:
2044 case IEEE80211_M_MONITOR:
2058 struct ieee80211com *ic = &sc->
sc_ic;
2063 chan = ieee80211_chan2ieee(ic, c);
2064 if (
chan == 0 ||
chan == IEEE80211_CHAN_ANY) {
2066 device_printf(sc->
sc_dev,
2067 "%s: invalid channel %x\n", __func__,
chan);
2112 htole16(c->ic_freq);
2114 htole16(c->ic_flags);
2149 struct ieee80211com *ic = &sc->
sc_ic;
2157 DPRINTF(sc, ZYD_DEBUG_RECV,
"%s: frame too short (length=%d)\n",
2159 counter_u64_add(ic->ic_ierrors, 1);
2168 "%s: RX status indicated error (%x)\n",
2170 counter_u64_add(ic->ic_ierrors, 1);
2179 if (rlen > (
int)MCLBYTES) {
2180 DPRINTF(sc, ZYD_DEBUG_RECV,
"%s: frame too long (length=%d)\n",
2181 device_get_nameunit(sc->
sc_dev), rlen);
2182 counter_u64_add(ic->ic_ierrors, 1);
2184 }
else if (rlen > (
int)MHLEN)
2185 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);
2187 m = m_gethdr(M_NOWAIT, MT_DATA);
2189 DPRINTF(sc, ZYD_DEBUG_RECV,
"%s: could not allocate rx mbuf\n",
2190 device_get_nameunit(sc->
sc_dev));
2191 counter_u64_add(ic->ic_ierrors, 1);
2194 m->m_pkthdr.len = m->m_len = rlen;
2197 if (ieee80211_radiotap_active(ic)) {
2202 tap->
wr_flags |= IEEE80211_RADIOTAP_F_BADFCS;
2205 tap->
wr_flags |= IEEE80211_RADIOTAP_F_BADFCS;
2208 IEEE80211_T_OFDM : IEEE80211_T_CCK);
2212 rssi = (stat.
rssi > 63) ? 127 : 2 * stat.
rssi;
2223 struct ieee80211com *ic = &sc->
sc_ic;
2224 struct ieee80211_node *ni;
2225 struct epoch_tracker et;
2246 "%s: received multi-frame transfer\n", __func__);
2251 if (len16 == 0 || len16 > actlen)
2257 len16 = (len16 + 3) & ~3;
2265 "%s: received single-frame transfer\n", __func__);
2281 NET_EPOCH_ENTER(et);
2289 ni = ieee80211_find_rxnode(ic,
2290 mtod(m,
struct ieee80211_frame_min *));
2292 (void)ieee80211_input(ni, m, rssi, nf);
2293 ieee80211_free_node(ni);
2295 (
void)ieee80211_input_all(ic, m, rssi, nf);
2346 device_printf(sc->
sc_dev,
"unsupported rate %d\n", rate);
2354 struct ieee80211vap *vap;
2364 DPRINTF(sc, ZYD_DEBUG_ANY,
"transfer complete, %u bytes\n",
2377 STAILQ_REMOVE_HEAD(&sc->
tx_q,
next);
2381 DPRINTF(sc, ZYD_DEBUG_ANY,
"data overflow, %u bytes\n",
2390 vap =
data->ni->ni_vap;
2391 if (ieee80211_radiotap_active_vap(vap)) {
2397 ieee80211_radiotap_tx(vap, m);
2408 DPRINTF(sc, ZYD_DEBUG_ANY,
"transfer error, %s\n",
2411 counter_u64_add(sc->
sc_ic.ic_oerrors, 1);
2419 device_printf(sc->
sc_dev,
"device timeout\n");
2436 struct ieee80211vap *vap = ni->ni_vap;
2437 struct ieee80211com *ic = ni->ni_ic;
2440 struct ieee80211_frame *wh;
2441 const struct ieee80211_txparam *tp = ni->ni_txparms;
2442 struct ieee80211_key *
k;
2443 int rate, totlen,
type, ismcast;
2449 wh = mtod(m0,
struct ieee80211_frame *);
2454 ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1);
2455 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
2457 if (
type == IEEE80211_FC0_TYPE_MGT ||
2458 type == IEEE80211_FC0_TYPE_CTL ||
2459 (m0->m_flags & M_EAPOL) != 0) {
2460 rate = tp->mgmtrate;
2464 rate = tp->mcastrate;
2465 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE)
2466 rate = tp->ucastrate;
2468 (void) ieee80211_ratectl_rate(ni, NULL, 0);
2469 rate = ni->ni_txrate;
2473 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) {
2474 k = ieee80211_crypto_encap(ni, m0);
2479 wh = mtod(m0,
struct ieee80211_frame *);
2492 if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan))
2494 }
else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE))
2497 totlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN;
2498 desc->len = htole16(totlen);
2503 if (totlen > vap->iv_rtsthreshold) {
2506 (ic->ic_flags & IEEE80211_F_USEPROT)) {
2507 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
2509 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
2515 (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) ==
2516 (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL))
2523 desc->pktlen = htole16(pktlen);
2525 bits = (rate == 11) ? (totlen * 16) + 10 :
2526 ((rate == 22) ? (totlen * 8) + 10 : (totlen * 8));
2527 desc->plcp_length = htole16(bits / ratediv[phy]);
2528 desc->plcp_service = 0;
2529 if (rate == 22 && (bits % 11) > 0 && (bits % 11) <= 3)
2533 if (ieee80211_radiotap_active_vap(vap)) {
2539 ieee80211_radiotap_tx(vap, m0);
2543 "%s: sending data frame len=%zu rate=%u\n",
2544 device_get_nameunit(sc->
sc_dev), (
size_t)m0->m_pkthdr.len,
2578 struct ieee80211_node *ni;
2583 while (sc->
tx_nfree > 0 && (m = mbufq_dequeue(&sc->
sc_snd)) != NULL) {
2584 ni = (
struct ieee80211_node *)m->m_pkthdr.rcvif;
2587 if_inc_counter(ni->ni_vap->iv_ifp,
2588 IFCOUNTER_OERRORS, 1);
2589 ieee80211_free_node(ni);
2597 const struct ieee80211_bpf_params *params)
2599 struct ieee80211com *ic = ni->ni_ic;
2640 if (ic->ic_nrunning > 0) {
2650 ieee80211_start_all(ic);
2656 struct ieee80211com *ic = &sc->
sc_ic;
2657 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
2667 device_printf(sc->
sc_dev,
2668 "could not load firmware (error=%d)\n",
error);
2677 device_printf(sc->
sc_dev,
"reset failed, continuing\n");
2681 device_printf(sc->
sc_dev,
2682 "hardware initialization failed\n");
2686 device_printf(sc->
sc_dev,
2687 "HMAC ZD1211%s, FW %02x.%02x, RF %s S%x, PA%x LED %x "
2688 "BE%x NP%x Gain%x F%x\n",
2698 DPRINTF(sc, ZYD_DEBUG_INIT,
"regulatory domain %x\n",
2702 DPRINTF(sc, ZYD_DEBUG_INIT,
"%s: setting encryption type\n",
2712 DPRINTF(sc, ZYD_DEBUG_INIT,
"setting MAC address to %6D\n",
2713 vap ? vap->iv_myaddr : ic->ic_macaddr,
":");
2719 if (ic->ic_curmode == IEEE80211_MODE_11B)
2721 else if (ic->ic_curmode == IEEE80211_MODE_11A)
2829 const int mlen = min(
size, 64);
2832 "loading firmware block: len=%d, addr=0x%x\n", mlen,
addr);
2855 return (stat & 0x80) ? (EIO) : (0);
2882 int maxchans,
int *nchans,
struct ieee80211_channel chans[])
2884 uint8_t bands[IEEE80211_MODE_BYTES];
2886 memset(bands, 0,
sizeof(bands));
2887 setbit(bands, IEEE80211_MODE_11B);
2888 setbit(bands, IEEE80211_MODE_11G);
2889 ieee80211_add_channels_default_2ghz(chans, maxchans, nchans, bands, 0);
static SYSCTL_NODE(_hw_usb, OID_AUTO, dwc_otg, CTLFLAG_RW|CTLFLAG_MPSAFE, 0, "USB DWC OTG")
SYSCTL_INT(_hw_usb_dwc_otg, OID_AUTO, phy_type, CTLFLAG_RDTUN, &dwc_otg_phy_type, 0, "DWC OTG PHY TYPE - 0/1/2/3 - ULPI/HSIC/INTERNAL/UTMI+")
static void zyd_scan_start(struct ieee80211com *)
static void zyd_update_mcast(struct ieee80211com *)
static int zyd_al2210_set_channel(struct zyd_rf *, uint8_t)
static void zyd_getradiocaps(struct ieee80211com *, int, int *, struct ieee80211_channel[])
static int zyd_al2230_init_b(struct zyd_rf *)
static u_int zyd_hash_maddr(void *arg, struct sockaddr_dl *sdl, u_int cnt)
#define ZYD_ZD1211B_DEV(v, p)
static int zyd_lock_phy(struct zyd_softc *)
#define zyd_read16_m(sc, val, data)
static int zyd_rf_attach(struct zyd_softc *, uint8_t)
static int zyd_al2230_switch_radio(struct zyd_rf *, int)
static int zyd_al2230_set_channel_b(struct zyd_rf *, uint8_t)
static usb_callback_t zyd_bulk_read_callback
static int zyd_get_macaddr(struct zyd_softc *)
static const struct usb_config zyd_config[ZYD_N_TRANSFER]
static void zyd_setup_tx_list(struct zyd_softc *)
static usb_callback_t zyd_bulk_write_callback
static int zyd_al2210_switch_radio(struct zyd_rf *, int)
static struct ieee80211vap * zyd_vap_create(struct ieee80211com *, const char[IFNAMSIZ], int, enum ieee80211_opmode, int, const uint8_t[IEEE80211_ADDR_LEN], const uint8_t[IEEE80211_ADDR_LEN])
static int zyd_gct_set_channel(struct zyd_rf *, uint8_t)
static int zyd_gct_txgain(struct zyd_rf *, uint8_t)
static int zyd_tx_start(struct zyd_softc *, struct mbuf *, struct ieee80211_node *)
static int zyd_raw_xmit(struct ieee80211_node *, struct mbuf *, const struct ieee80211_bpf_params *)
static void zyd_vap_delete(struct ieee80211vap *)
USB_PNP_HOST_INFO(zyd_devs)
static uint8_t zyd_plcp_signal(struct zyd_softc *sc, int rate)
static int zyd_set_led(struct zyd_softc *, int, int)
static int zyd_al7230B_switch_radio(struct zyd_rf *, int)
static int zyd_loadfirmware(struct zyd_softc *)
static void zyd_parent(struct ieee80211com *)
static int zyd_set_beacon_interval(struct zyd_softc *, int)
static usb_callback_t zyd_intr_read_callback
static void zyd_tx_free(struct zyd_tx_data *, int)
#define ZYD_AL2230_PHY_BANDEDGE6
static driver_t zyd_driver
static int zyd_gct_set_channel_synth(struct zyd_rf *, int, int)
static int zyd_rfmd_init(struct zyd_rf *)
static int zyd_read32(struct zyd_softc *, uint16_t, uint32_t *)
static int zyd_gct_mode(struct zyd_rf *)
static int zyd_maxim2_set_channel(struct zyd_rf *, uint8_t)
static int zyd_unlock_phy(struct zyd_softc *)
#define zyd_write16_m(sc, val, data)
#define ZYD_ZD1211_DEV(v, p)
static int zyd_newstate(struct ieee80211vap *, enum ieee80211_state, int)
static void zyd_set_chan(struct zyd_softc *, struct ieee80211_channel *)
static const struct zyd_phy_pair zyd_def_phyB[]
MODULE_DEPEND(zyd, usb, 1, 1, 1)
static int zyd_rfmd_switch_radio(struct zyd_rf *, int)
static void zyd_init_locked(struct zyd_softc *)
static device_detach_t zyd_detach
static void zyd_start(struct zyd_softc *)
#define DPRINTF(sc, m, fmt,...)
static int zyd_al7230B_init(struct zyd_rf *)
static int zyd_maxim2_switch_radio(struct zyd_rf *, int)
static int zyd_set_bssid(struct zyd_softc *, const uint8_t *)
static int zyd_write16(struct zyd_softc *, uint16_t, uint16_t)
#define zyd_write32_m(sc, val, data)
static usb_callback_t zyd_intr_write_callback
static int zyd_rfwrite_cr(struct zyd_softc *sc, uint32_t val)
DRIVER_MODULE(zyd, uhub, zyd_driver, zyd_devclass, NULL, 0)
static int zyd_switch_radio(struct zyd_softc *, int)
static const STRUCT_USB_HOST_ID zyd_devs[]
static int zyd_cmd(struct zyd_softc *, uint16_t, const void *, int, void *, int, int)
static int zyd_rfmd_set_channel(struct zyd_rf *, uint8_t)
static void zyd_scan_end(struct ieee80211com *)
static int zyd_al2230_bandedge6(struct zyd_rf *rf, struct ieee80211_channel *c)
static int zyd_rfwrite(struct zyd_softc *, uint32_t)
static void zyd_unsetup_tx_list(struct zyd_softc *)
static int zyd_read_pod(struct zyd_softc *)
static int zyd_gct_init(struct zyd_rf *)
static int zyd_hw_init(struct zyd_softc *)
static void zyd_drain_mbufq(struct zyd_softc *sc)
static const char * zyd_rf_name(uint8_t)
static device_method_t zyd_methods[]
static void zyd_set_channel(struct ieee80211com *)
static device_attach_t zyd_attach
static devclass_t zyd_devclass
static int zyd_transmit(struct ieee80211com *, struct mbuf *)
static int zyd_al7230B_set_channel(struct zyd_rf *, uint8_t)
static device_probe_t zyd_match
static int zyd_gct_switch_radio(struct zyd_rf *, int)
static void zyd_set_multi(struct zyd_softc *)
static const struct zyd_phy_pair zyd_def_phy[]
static int zyd_al2230_fini(struct zyd_rf *rf)
static int zyd_al2210_init(struct zyd_rf *)
static int zyd_al2230_set_channel(struct zyd_rf *, uint8_t)
static int zyd_maxim2_init(struct zyd_rf *)
static int zyd_read16(struct zyd_softc *, uint16_t, uint16_t *)
static int zyd_set_rxfilter(struct zyd_softc *)
static void zyd_rx_data(struct usb_xfer *, int, uint16_t)
static int zyd_gct_write(struct zyd_rf *, uint16_t)
static int zyd_write32(struct zyd_softc *, uint16_t, uint32_t)
static int zyd_read_eeprom(struct zyd_softc *)
static void zyd_stop(struct zyd_softc *)
#define zyd_read32_m(sc, val, data)
#define zyd_do_request(sc, req, data)
static int zyd_al2230_init(struct zyd_rf *)
static int zyd_set_macaddr(struct zyd_softc *, const uint8_t *)
uint8_t zd1211_firmware[]
uint8_t zd1211b_firmware[]
#define ZYD_TX_FLAG_BACKOFF
#define ZYD_FILTER_MONITOR
#define ZYD_MAC_TX_PE_CONTROL
#define ZYD_CR_ADDA_PWR_DWN
#define ZYD_FIRMWARE_START_ADDR
#define ZYD_AL2230_CHANTABLE
#define ZYD_TX_RADIOTAP_PRESENT
#define ZYD_LOCK_ASSERT(sc, t)
#define ZYD_AL2230_RF_PART1
#define ZYD_AL2230_PHY_PART2
#define ZYD_CR_ATIM_WND_PERIOD
#define ZYD_TX_FLAG_TYPE(x)
#define ZYD_EEPROM_36M_CAL
#define ZYD_MAC_PHY_DELAY2
#define ZYD_TX_PHY_SHPREAMBLE
#define ZYD_RX_RADIOTAP_PRESENT
#define ZYD_MAC_RX_THRESHOLD
#define ZYD_EEPROM_54M_CAL
#define ZYD_MACB_MAX_RETRY
#define ZYD_MAC_ENCRYPTION_TYPE
#define ZYD_CMD_FLAG_READ
#define ZYD_READFWDATAREQ
#define ZYD_AL2230_CHANTABLE_B
#define ZYD_GCT_CHANNEL_ACAL
#define ZYD_RFMD_CHANTABLE
#define ZYD_MACB_AIFS_CTL2
#define ZYD_EEPROM_48M_CAL
#define ZYD_RF_MAXIM_NEW2
#define ZYD_AL7230B_PHY_3
#define ZYD_AL7230B_PHY_1
#define ZYD_AL2230_PHY_PART1
#define ZYD_AL2210_CHANTABLE
#define ZYD_MAX_RXFRAMECNT
#define ZYD_AL7230B_RF_SETCHANNEL
#define ZYD_RATE_IS_OFDM(rate)
#define ZYD_MAC_CONT_WIN_LIMIT
#define ZYD_GCT_CHANNEL_DIV
#define ZYD_AL2230_RF_B_PART2
#define ZYD_AL2230_RF_PART3
#define ZYD_AL2230_RF_PART2
#define ZYD_TX_FLAG_MULTICAST
#define ZYD_REG32_HI(reg)
#define ZYD_TAG_MULTIFRAME
#define ZYD_CMD_FLAG_SENT
#define ZYD_EEPROM_PWR_INT
#define ZYD_FW_LINK_STATUS
#define ZYD_FILTER_HOSTAP
#define ZYD_CR_ADDA_MBIAS_WT
#define ZYD_FLAG_INITONCE
#define ZYD_CR_CONFIG_PHILIPS
#define ZYD_CR_RX_PE_DELAY
#define ZYD_EEPROM_MAC_ADDR_P1
#define ZYD_EEPROM_PWR_CAL
#define ZYD_MACB_TXPWR_CTL3
#define ZYD_MAC_RTSCTSRATE
#define ZYD_MACB_TXPWR_CTL1
#define ZYD_MAC_BACKOFF_PROTECT
#define ZYD_AL2230_RF_B_PART3
#define ZYD_AL2230_PHY_PART3
#define ZYD_FLAG_FWLOADED
#define ZYD_AL2230S_PHY_INIT
#define ZYD_MACB_TXPWR_CTL4
#define ZYD_CR_BCN_INTERVAL
#define ZYD_FW_FIRMWARE_REV
#define ZYD_MACB_AIFS_CTL1
#define ZYD_MACB_TXPWR_CTL2
#define ZYD_MAC_SIFS_ACK_TIME
#define ZYD_FIRMWARE_BASE_ADDR
#define ZYD_FLAG_DETACHED
#define ZYD_AL7230B_CHANTABLE
#define ZYD_AL2230_PHY_FINI_PART1
#define ZYD_TX_FLAG_CTS_TO_SELF
#define ZYD_MAXIM2_CHANTABLE
#define ZYD_AL2230_RF_B_PART1
#define ZYD_REG32_LO(reg)
#define ZYD_UNLOCK_PHY_REGS
#define ZYD_MAC_DIFS_EIFS_SIFS
#define ZYD_NOTIF_RETRYSTATUS
#define ZYD_AL7230B_PHY_2
#define ZYD_RX_DECRYPTERR
#define ZYD_TX_TYPE_PS_POLL
#define ZYD_EEPROM_PHY_REG
#define ZYD_MAC_AFTER_PNP
#define ZYD_GCT_CHANNEL_STD
enum usb_hc_mode usb_mode
struct usbd_lookup_info info
struct usb_device * device
uByte bConfigurationValue
int(* init)(struct zyd_rf *)
int(* set_channel)(struct zyd_rf *, uint8_t)
int(* bandedge6)(struct zyd_rf *, struct ieee80211_channel *)
int(* switch_radio)(struct zyd_rf *, int)
struct ieee80211_ratectl_tx_status sc_txs
uint8_t sc_ofdm48_cal[14]
struct zyd_rx_radiotap_header sc_rxtap
uint8_t sc_ofdm36_cal[14]
struct zyd_rx_data sc_rx_data[ZYD_MAX_RXFRAMECNT]
struct ieee80211com sc_ic
struct zyd_tx_radiotap_header sc_txtap
struct usb_xfer * sc_xfer[ZYD_N_TRANSFER]
uint8_t sc_ofdm54_cal[14]
struct zyd_tx_data tx_data[ZYD_TX_LIST_CNT]
uint8_t sc_bssid[IEEE80211_ADDR_LEN]
struct usb_device * sc_udev
int(* newstate)(struct ieee80211vap *, enum ieee80211_state, int)
#define UT_WRITE_VENDOR_DEVICE
#define UT_READ_VENDOR_DEVICE
void usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset, const void *ptr, usb_frlength_t len)
void usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset, void *ptr, usb_frlength_t len)
struct usb_config_descriptor * usbd_get_config_descriptor(struct usb_device *udev)
struct usb_endpoint_descriptor desc
const char * usbd_errstr(usb_error_t err)
int usbd_lookup_id_by_uaa(const struct usb_device_id *id, usb_size_t sizeof_id, struct usb_attach_arg *uaa)
usb_error_t usbd_req_set_config(struct usb_device *udev, struct mtx *mtx, uint8_t conf)
void usbd_transfer_submit(struct usb_xfer *xfer)
void * usbd_xfer_get_priv(struct usb_xfer *xfer)
void usbd_transfer_unsetup(struct usb_xfer **pxfer, uint16_t n_setup)
void usbd_xfer_set_frame_len(struct usb_xfer *xfer, usb_frcount_t frindex, usb_frlength_t len)
struct usb_page_cache * usbd_xfer_get_frame(struct usb_xfer *xfer, usb_frcount_t frindex)
usb_error_t usbd_transfer_setup(struct usb_device *udev, const uint8_t *ifaces, struct usb_xfer **ppxfer, const struct usb_config *setup_start, uint16_t n_setup, void *priv_sc, struct mtx *xfer_mtx)
void usbd_transfer_start(struct usb_xfer *xfer)
void usbd_xfer_set_priv(struct usb_xfer *xfer, void *ptr)
void usbd_transfer_drain(struct usb_xfer *xfer)
void * usbd_xfer_softc(struct usb_xfer *xfer)
void usbd_xfer_set_stall(struct usb_xfer *xfer)
void usbd_xfer_status(struct usb_xfer *xfer, int *actlen, int *sumlen, int *aframes, int *nframes)
usb_frlength_t usbd_xfer_max_len(struct usb_xfer *xfer)
void device_set_usb_desc(device_t dev)
#define USB_ST_TRANSFERRED
void usbd_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset, struct mbuf *m, usb_size_t src_offset, usb_frlength_t src_len)
void() usb_callback_t(struct usb_xfer *, usb_error_t)
#define STRUCT_USB_HOST_ID
#define USB_GET_DRIVER_INFO(did)
#define USB_GET_STATE(xfer)