if_zyd.c revision 188418
1/* $OpenBSD: if_zyd.c,v 1.52 2007/02/11 00:08:04 jsg Exp $ */ 2/* $NetBSD: if_zyd.c,v 1.7 2007/06/21 04:04:29 kiyohara Exp $ */ 3/* $FreeBSD: head/sys/dev/usb2/wlan/if_zyd2.c 188418 2009-02-09 22:14:38Z thompsa $ */ 4 5/*- 6 * Copyright (c) 2006 by Damien Bergamini <damien.bergamini@free.fr> 7 * Copyright (c) 2006 by Florian Stoehr <ich@florian-stoehr.de> 8 * 9 * Permission to use, copy, modify, and distribute this software for any 10 * purpose with or without fee is hereby granted, provided that the above 11 * copyright notice and this permission notice appear in all copies. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 14 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 15 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 16 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 17 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 18 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 19 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 20 */ 21 22#include <sys/cdefs.h> 23__FBSDID("$FreeBSD: head/sys/dev/usb2/wlan/if_zyd2.c 188418 2009-02-09 22:14:38Z thompsa $"); 24 25/* 26 * ZyDAS ZD1211/ZD1211B USB WLAN driver. 27 */ 28 29#include <dev/usb2/include/usb2_devid.h> 30#include <dev/usb2/include/usb2_standard.h> 31#include <dev/usb2/include/usb2_mfunc.h> 32#include <dev/usb2/include/usb2_error.h> 33 34#include <dev/usb2/core/usb2_core.h> 35#include <dev/usb2/core/usb2_lookup.h> 36#include <dev/usb2/core/usb2_process.h> 37#include <dev/usb2/core/usb2_debug.h> 38#include <dev/usb2/core/usb2_request.h> 39#include <dev/usb2/core/usb2_busdma.h> 40#include <dev/usb2/core/usb2_util.h> 41 42#include <dev/usb2/wlan/usb2_wlan.h> 43#include <dev/usb2/wlan/if_zydreg.h> 44#include <dev/usb2/wlan/if_zydfw.h> 45 46#if USB_DEBUG 47static int zyd_debug = 0; 48 49SYSCTL_NODE(_hw_usb2, OID_AUTO, zyd, CTLFLAG_RW, 0, "USB zyd"); 50SYSCTL_INT(_hw_usb2_zyd, OID_AUTO, debug, CTLFLAG_RW, &zyd_debug, 0, 51 "zyd debug level"); 52 53enum { 54 ZYD_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ 55 ZYD_DEBUG_RECV = 0x00000002, /* basic recv operation */ 56 ZYD_DEBUG_RESET = 0x00000004, /* reset processing */ 57 ZYD_DEBUG_INIT = 0x00000008, /* device init */ 58 ZYD_DEBUG_TX_PROC = 0x00000010, /* tx ISR proc */ 59 ZYD_DEBUG_RX_PROC = 0x00000020, /* rx ISR proc */ 60 ZYD_DEBUG_STATE = 0x00000040, /* 802.11 state transitions */ 61 ZYD_DEBUG_STAT = 0x00000080, /* statistic */ 62 ZYD_DEBUG_FW = 0x00000100, /* firmware */ 63 ZYD_DEBUG_CMD = 0x00000200, /* fw commands */ 64 ZYD_DEBUG_ANY = 0xffffffff 65}; 66#define DPRINTF(sc, m, fmt, ...) do { \ 67 if (sc->sc_debug & (m)) \ 68 printf("%s: " fmt, __func__, ## __VA_ARGS__); \ 69} while (0) 70#else 71#define DPRINTF(sc, m, fmt, ...) do { \ 72 (void) sc; \ 73} while (0) 74#endif 75 76static device_probe_t zyd_match; 77static device_attach_t zyd_attach; 78static device_detach_t zyd_detach; 79 80static usb2_callback_t zyd_intr_read_callback; 81static usb2_callback_t zyd_intr_write_callback; 82static usb2_callback_t zyd_bulk_read_callback; 83static usb2_callback_t zyd_bulk_write_callback; 84 85static usb2_proc_callback_t zyd_task; 86static usb2_proc_callback_t zyd_scantask; 87static usb2_proc_callback_t zyd_multitask; 88 89static struct ieee80211vap *zyd_vap_create(struct ieee80211com *, 90 const char name[IFNAMSIZ], int unit, int opmode, 91 int flags, const uint8_t bssid[IEEE80211_ADDR_LEN], 92 const uint8_t mac[IEEE80211_ADDR_LEN]); 93static void zyd_vap_delete(struct ieee80211vap *); 94static void zyd_tx_free(struct zyd_tx_data *, int); 95static int zyd_alloc_tx_list(struct zyd_softc *); 96static void zyd_free_tx_list(struct zyd_softc *); 97static struct ieee80211_node *zyd_node_alloc(struct ieee80211vap *, 98 const uint8_t mac[IEEE80211_ADDR_LEN]); 99static int zyd_newstate(struct ieee80211vap *, enum ieee80211_state, int); 100static int zyd_cmd(struct zyd_softc *, uint16_t, const void *, int, 101 void *, int, u_int); 102static int zyd_read16(struct zyd_softc *, uint16_t, uint16_t *); 103static int zyd_read32(struct zyd_softc *, uint16_t, uint32_t *); 104static int zyd_write16(struct zyd_softc *, uint16_t, uint16_t); 105static int zyd_write32(struct zyd_softc *, uint16_t, uint32_t); 106static int zyd_rfwrite(struct zyd_softc *, uint32_t); 107static int zyd_lock_phy(struct zyd_softc *); 108static int zyd_unlock_phy(struct zyd_softc *); 109static int zyd_rf_attach(struct zyd_softc *, uint8_t); 110static const char *zyd_rf_name(uint8_t); 111static int zyd_hw_init(struct zyd_softc *); 112static int zyd_read_pod(struct zyd_softc *); 113static int zyd_read_eeprom(struct zyd_softc *); 114static int zyd_get_macaddr(struct zyd_softc *); 115static int zyd_set_macaddr(struct zyd_softc *, const uint8_t *); 116static int zyd_set_bssid(struct zyd_softc *, const uint8_t *); 117static int zyd_switch_radio(struct zyd_softc *, int); 118static int zyd_set_led(struct zyd_softc *, int, int); 119static void zyd_set_multi(struct zyd_softc *); 120static void zyd_update_mcast(struct ifnet *); 121static int zyd_set_rxfilter(struct zyd_softc *); 122static void zyd_set_chan(struct zyd_softc *, struct ieee80211_channel *); 123static int zyd_set_beacon_interval(struct zyd_softc *, int); 124static void zyd_rx_data(struct usb2_xfer *, int, uint16_t); 125static int zyd_tx_mgt(struct zyd_softc *, struct mbuf *, 126 struct ieee80211_node *); 127static int zyd_tx_data(struct zyd_softc *, struct mbuf *, 128 struct ieee80211_node *); 129static void zyd_start(struct ifnet *); 130static int zyd_raw_xmit(struct ieee80211_node *, struct mbuf *, 131 const struct ieee80211_bpf_params *); 132static int zyd_ioctl(struct ifnet *, u_long, caddr_t); 133static void zyd_init_locked(struct zyd_softc *); 134static void zyd_init(void *); 135static void zyd_stop(struct zyd_softc *); 136static int zyd_loadfirmware(struct zyd_softc *); 137static void zyd_newassoc(struct ieee80211_node *, int); 138static void zyd_scan_start(struct ieee80211com *); 139static void zyd_scan_end(struct ieee80211com *); 140static void zyd_set_channel(struct ieee80211com *); 141static void zyd_wakeup(struct zyd_softc *); 142static int zyd_rfmd_init(struct zyd_rf *); 143static int zyd_rfmd_switch_radio(struct zyd_rf *, int); 144static int zyd_rfmd_set_channel(struct zyd_rf *, uint8_t); 145static int zyd_al2230_init(struct zyd_rf *); 146static int zyd_al2230_switch_radio(struct zyd_rf *, int); 147static int zyd_al2230_set_channel(struct zyd_rf *, uint8_t); 148static int zyd_al2230_set_channel_b(struct zyd_rf *, uint8_t); 149static int zyd_al2230_init_b(struct zyd_rf *); 150static int zyd_al7230B_init(struct zyd_rf *); 151static int zyd_al7230B_switch_radio(struct zyd_rf *, int); 152static int zyd_al7230B_set_channel(struct zyd_rf *, uint8_t); 153static int zyd_al2210_init(struct zyd_rf *); 154static int zyd_al2210_switch_radio(struct zyd_rf *, int); 155static int zyd_al2210_set_channel(struct zyd_rf *, uint8_t); 156static int zyd_gct_init(struct zyd_rf *); 157static int zyd_gct_switch_radio(struct zyd_rf *, int); 158static int zyd_gct_set_channel(struct zyd_rf *, uint8_t); 159static int zyd_maxim_init(struct zyd_rf *); 160static int zyd_maxim_switch_radio(struct zyd_rf *, int); 161static int zyd_maxim_set_channel(struct zyd_rf *, uint8_t); 162static int zyd_maxim2_init(struct zyd_rf *); 163static int zyd_maxim2_switch_radio(struct zyd_rf *, int); 164static int zyd_maxim2_set_channel(struct zyd_rf *, uint8_t); 165static void zyd_queue_command(struct zyd_softc *, usb2_proc_callback_t *, 166 struct usb2_proc_msg *, struct usb2_proc_msg *); 167 168static const struct zyd_phy_pair zyd_def_phy[] = ZYD_DEF_PHY; 169static const struct zyd_phy_pair zyd_def_phyB[] = ZYD_DEF_PHYB; 170 171/* various supported device vendors/products */ 172#define ZYD_ZD1211 0 173#define ZYD_ZD1211B 1 174 175static const struct usb2_device_id zyd_devs[] = { 176 /* ZYD_ZD1211 */ 177 {USB_VPI(USB_VENDOR_3COM2, USB_PRODUCT_3COM2_3CRUSB10075, ZYD_ZD1211)}, 178 {USB_VPI(USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_WL54, ZYD_ZD1211)}, 179 {USB_VPI(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_WL159G, ZYD_ZD1211)}, 180 {USB_VPI(USB_VENDOR_CYBERTAN, USB_PRODUCT_CYBERTAN_TG54USB, ZYD_ZD1211)}, 181 {USB_VPI(USB_VENDOR_DRAYTEK, USB_PRODUCT_DRAYTEK_VIGOR550, ZYD_ZD1211)}, 182 {USB_VPI(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GWUS54GD, ZYD_ZD1211)}, 183 {USB_VPI(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GWUS54GZL, ZYD_ZD1211)}, 184 {USB_VPI(USB_VENDOR_PLANEX3, USB_PRODUCT_PLANEX3_GWUS54GZ, ZYD_ZD1211)}, 185 {USB_VPI(USB_VENDOR_PLANEX3, USB_PRODUCT_PLANEX3_GWUS54MINI, ZYD_ZD1211)}, 186 {USB_VPI(USB_VENDOR_SAGEM, USB_PRODUCT_SAGEM_XG760A, ZYD_ZD1211)}, 187 {USB_VPI(USB_VENDOR_SENAO, USB_PRODUCT_SENAO_NUB8301, ZYD_ZD1211)}, 188 {USB_VPI(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_WL113, ZYD_ZD1211)}, 189 {USB_VPI(USB_VENDOR_SWEEX, USB_PRODUCT_SWEEX_ZD1211, ZYD_ZD1211)}, 190 {USB_VPI(USB_VENDOR_TEKRAM, USB_PRODUCT_TEKRAM_QUICKWLAN, ZYD_ZD1211)}, 191 {USB_VPI(USB_VENDOR_TEKRAM, USB_PRODUCT_TEKRAM_ZD1211_1, ZYD_ZD1211)}, 192 {USB_VPI(USB_VENDOR_TEKRAM, USB_PRODUCT_TEKRAM_ZD1211_2, ZYD_ZD1211)}, 193 {USB_VPI(USB_VENDOR_TWINMOS, USB_PRODUCT_TWINMOS_G240, ZYD_ZD1211)}, 194 {USB_VPI(USB_VENDOR_UMEDIA, USB_PRODUCT_UMEDIA_ALL0298V2, ZYD_ZD1211)}, 195 {USB_VPI(USB_VENDOR_UMEDIA, USB_PRODUCT_UMEDIA_TEW429UB_A, ZYD_ZD1211)}, 196 {USB_VPI(USB_VENDOR_UMEDIA, USB_PRODUCT_UMEDIA_TEW429UB, ZYD_ZD1211)}, 197 {USB_VPI(USB_VENDOR_WISTRONNEWEB, USB_PRODUCT_WISTRONNEWEB_UR055G, ZYD_ZD1211)}, 198 {USB_VPI(USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_ZD1211, ZYD_ZD1211)}, 199 {USB_VPI(USB_VENDOR_ZYDAS, USB_PRODUCT_ZYDAS_ZD1211, ZYD_ZD1211)}, 200 {USB_VPI(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_AG225H, ZYD_ZD1211)}, 201 {USB_VPI(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_ZYAIRG220, ZYD_ZD1211)}, 202 {USB_VPI(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_G200V2, ZYD_ZD1211)}, 203 {USB_VPI(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_G202, ZYD_ZD1211)}, 204 /* ZYD_ZD1211B */ 205 {USB_VPI(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_SMCWUSBG, ZYD_ZD1211B)}, 206 {USB_VPI(USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_ZD1211B, ZYD_ZD1211B)}, 207 {USB_VPI(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_A9T_WIFI, ZYD_ZD1211B)}, 208 {USB_VPI(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5D7050_V4000, ZYD_ZD1211B)}, 209 {USB_VPI(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_ZD1211B, ZYD_ZD1211B)}, 210 {USB_VPI(USB_VENDOR_CISCOLINKSYS, USB_PRODUCT_CISCOLINKSYS_WUSBF54G, ZYD_ZD1211B)}, 211 {USB_VPI(USB_VENDOR_FIBERLINE, USB_PRODUCT_FIBERLINE_WL430U, ZYD_ZD1211B)}, 212 {USB_VPI(USB_VENDOR_MELCO, USB_PRODUCT_MELCO_KG54L, ZYD_ZD1211B)}, 213 {USB_VPI(USB_VENDOR_PHILIPS, USB_PRODUCT_PHILIPS_SNU5600, ZYD_ZD1211B)}, 214 {USB_VPI(USB_VENDOR_PLANEX2, USB_PRODUCT_PLANEX2_GW_US54GXS, ZYD_ZD1211B)}, 215 {USB_VPI(USB_VENDOR_SAGEM, USB_PRODUCT_SAGEM_XG76NA, ZYD_ZD1211B)}, 216 {USB_VPI(USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_ZD1211B, ZYD_ZD1211B)}, 217 {USB_VPI(USB_VENDOR_UMEDIA, USB_PRODUCT_UMEDIA_TEW429UBC1, ZYD_ZD1211B)}, 218 {USB_VPI(USB_VENDOR_USR, USB_PRODUCT_USR_USR5423, ZYD_ZD1211B)}, 219 {USB_VPI(USB_VENDOR_VTECH, USB_PRODUCT_VTECH_ZD1211B, ZYD_ZD1211B)}, 220 {USB_VPI(USB_VENDOR_ZCOM, USB_PRODUCT_ZCOM_ZD1211B, ZYD_ZD1211B)}, 221 {USB_VPI(USB_VENDOR_ZYDAS, USB_PRODUCT_ZYDAS_ZD1211B, ZYD_ZD1211B)}, 222 {USB_VPI(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_M202, ZYD_ZD1211B)}, 223 {USB_VPI(USB_VENDOR_ZYXEL, USB_PRODUCT_ZYXEL_G220V2, ZYD_ZD1211B)}, 224}; 225 226static const struct usb2_config zyd_config[ZYD_N_TRANSFER] = { 227 [ZYD_BULK_WR] = { 228 .type = UE_BULK, 229 .endpoint = UE_ADDR_ANY, 230 .direction = UE_DIR_OUT, 231 .mh.bufsize = ZYD_MAX_TXBUFSZ, 232 .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 233 .mh.callback = zyd_bulk_write_callback, 234 .ep_index = 0, 235 .mh.timeout = 10000, /* 10 seconds */ 236 }, 237 [ZYD_BULK_RD] = { 238 .type = UE_BULK, 239 .endpoint = UE_ADDR_ANY, 240 .direction = UE_DIR_IN, 241 .mh.bufsize = ZYX_MAX_RXBUFSZ, 242 .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 243 .mh.callback = zyd_bulk_read_callback, 244 .ep_index = 0, 245 }, 246 [ZYD_INTR_WR] = { 247 .type = UE_BULK_INTR, 248 .endpoint = UE_ADDR_ANY, 249 .direction = UE_DIR_OUT, 250 .mh.bufsize = sizeof(struct zyd_cmd), 251 .mh.flags = {.pipe_bof = 1,.force_short_xfer = 1,}, 252 .mh.callback = zyd_intr_write_callback, 253 .mh.timeout = 1000, /* 1 second */ 254 .ep_index = 1, 255 }, 256 [ZYD_INTR_RD] = { 257 .type = UE_INTERRUPT, 258 .endpoint = UE_ADDR_ANY, 259 .direction = UE_DIR_IN, 260 .mh.bufsize = sizeof(struct zyd_cmd), 261 .mh.flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 262 .mh.callback = zyd_intr_read_callback, 263 }, 264}; 265#define zyd_read16_m(sc, val, data) do { \ 266 error = zyd_read16(sc, val, data); \ 267 if (error != 0) \ 268 goto fail; \ 269} while (0) 270#define zyd_write16_m(sc, val, data) do { \ 271 error = zyd_write16(sc, val, data); \ 272 if (error != 0) \ 273 goto fail; \ 274} while (0) 275#define zyd_read32_m(sc, val, data) do { \ 276 error = zyd_read32(sc, val, data); \ 277 if (error != 0) \ 278 goto fail; \ 279} while (0) 280#define zyd_write32_m(sc, val, data) do { \ 281 error = zyd_write32(sc, val, data); \ 282 if (error != 0) \ 283 goto fail; \ 284} while (0) 285 286static int 287zyd_match(device_t dev) 288{ 289 struct usb2_attach_arg *uaa = device_get_ivars(dev); 290 291 if (uaa->usb2_mode != USB_MODE_HOST) 292 return (ENXIO); 293 if (uaa->info.bConfigIndex != 0) 294 return (ENXIO); 295 if (uaa->info.bIfaceIndex != ZYD_IFACE_INDEX) 296 return (ENXIO); 297 298 return (usb2_lookup_id_by_uaa(zyd_devs, sizeof(zyd_devs), uaa)); 299} 300 301static int 302zyd_attach(device_t dev) 303{ 304 int error = ENXIO; 305 struct ieee80211com *ic; 306 struct ifnet *ifp; 307 struct usb2_attach_arg *uaa = device_get_ivars(dev); 308 struct zyd_softc *sc = device_get_softc(dev); 309 uint8_t bands, iface_index; 310 311 if (uaa->info.bcdDevice < 0x4330) { 312 device_printf(dev, "device version mismatch: 0x%X " 313 "(only >= 43.30 supported)\n", 314 uaa->info.bcdDevice); 315 return (EINVAL); 316 } 317 318 device_set_usb2_desc(dev); 319 sc->sc_dev = dev; 320 sc->sc_udev = uaa->device; 321 sc->sc_macrev = USB_GET_DRIVER_INFO(uaa); 322#ifdef USB_DEBUG 323 sc->sc_debug = zyd_debug; 324#endif 325 mtx_init(&sc->sc_mtx, device_get_nameunit(sc->sc_dev), 326 MTX_NETWORK_LOCK, MTX_DEF); 327 328 STAILQ_INIT(&sc->sc_rqh); 329 330 iface_index = ZYD_IFACE_INDEX; 331 error = usb2_transfer_setup(uaa->device, 332 &iface_index, sc->sc_xfer, zyd_config, 333 ZYD_N_TRANSFER, sc, &sc->sc_mtx); 334 if (error) { 335 device_printf(dev, "could not allocate USB transfers, " 336 "err=%s\n", usb2_errstr(error)); 337 goto fail0; 338 } 339 error = usb2_proc_create(&sc->sc_tq, &sc->sc_mtx, 340 device_get_nameunit(dev), USB_PRI_MED); 341 if (error) { 342 device_printf(dev, "could not setup config thread!\n"); 343 goto fail0; 344 } 345 346 if ((error = zyd_get_macaddr(sc)) != 0) { 347 device_printf(sc->sc_dev, "could not read EEPROM\n"); 348 error = ENXIO; 349 goto fail0; 350 } 351 352 ifp = sc->sc_ifp = if_alloc(IFT_IEEE80211); 353 if (ifp == NULL) { 354 device_printf(dev, "can not if_alloc()\n"); 355 error = ENXIO; 356 goto fail0; 357 } 358 ifp->if_softc = sc; 359 if_initname(ifp, "zyd", device_get_unit(sc->sc_dev)); 360 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 361 ifp->if_init = zyd_init; 362 ifp->if_ioctl = zyd_ioctl; 363 ifp->if_start = zyd_start; 364 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 365 IFQ_SET_READY(&ifp->if_snd); 366 367 ic = ifp->if_l2com; 368 ic->ic_ifp = ifp; 369 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 370 ic->ic_opmode = IEEE80211_M_STA; 371 IEEE80211_ADDR_COPY(ic->ic_myaddr, sc->sc_bssid); 372 373 /* set device capabilities */ 374 ic->ic_caps = 375 IEEE80211_C_STA /* station mode */ 376 | IEEE80211_C_MONITOR /* monitor mode */ 377 | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 378 | IEEE80211_C_SHSLOT /* short slot time supported */ 379 | IEEE80211_C_BGSCAN /* capable of bg scanning */ 380 | IEEE80211_C_WPA /* 802.11i */ 381 ; 382 383 bands = 0; 384 setbit(&bands, IEEE80211_MODE_11B); 385 setbit(&bands, IEEE80211_MODE_11G); 386 ieee80211_init_channels(ic, NULL, &bands); 387 388 ieee80211_ifattach(ic); 389 ic->ic_newassoc = zyd_newassoc; 390 ic->ic_raw_xmit = zyd_raw_xmit; 391 ic->ic_node_alloc = zyd_node_alloc; 392 ic->ic_scan_start = zyd_scan_start; 393 ic->ic_scan_end = zyd_scan_end; 394 ic->ic_set_channel = zyd_set_channel; 395 396 ic->ic_vap_create = zyd_vap_create; 397 ic->ic_vap_delete = zyd_vap_delete; 398 ic->ic_update_mcast = zyd_update_mcast; 399 400 bpfattach(ifp, DLT_IEEE802_11_RADIO, 401 sizeof(struct ieee80211_frame) + sizeof(sc->sc_txtap)); 402 sc->sc_rxtap_len = sizeof(sc->sc_rxtap); 403 sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len); 404 sc->sc_rxtap.wr_ihdr.it_present = htole32(ZYD_RX_RADIOTAP_PRESENT); 405 sc->sc_txtap_len = sizeof(sc->sc_txtap); 406 sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len); 407 sc->sc_txtap.wt_ihdr.it_present = htole32(ZYD_TX_RADIOTAP_PRESENT); 408 409 if (bootverbose) 410 ieee80211_announce(ic); 411 412 return (0); 413 414fail0: mtx_destroy(&sc->sc_mtx); 415 return (error); 416} 417 418static int 419zyd_detach(device_t dev) 420{ 421 struct zyd_softc *sc = device_get_softc(dev); 422 struct ifnet *ifp = sc->sc_ifp; 423 struct ieee80211com *ic = ifp->if_l2com; 424 425 ZYD_LOCK(sc); 426 sc->sc_flags |= ZYD_FLAG_DETACHING; 427 zyd_stop(sc); 428 zyd_wakeup(sc); 429 ZYD_UNLOCK(sc); 430 431 /* stop all USB transfers first */ 432 usb2_transfer_unsetup(sc->sc_xfer, ZYD_N_TRANSFER); 433 usb2_proc_free(&sc->sc_tq); 434 435 if (ifp) { 436 bpfdetach(ifp); 437 ieee80211_ifdetach(ic); 438 if_free(ifp); 439 } 440 mtx_destroy(&sc->sc_mtx); 441 442 return (0); 443} 444 445static struct ieee80211vap * 446zyd_vap_create(struct ieee80211com *ic, 447 const char name[IFNAMSIZ], int unit, int opmode, int flags, 448 const uint8_t bssid[IEEE80211_ADDR_LEN], 449 const uint8_t mac[IEEE80211_ADDR_LEN]) 450{ 451 struct zyd_vap *zvp; 452 struct ieee80211vap *vap; 453 454 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 455 return (NULL); 456 zvp = (struct zyd_vap *) malloc(sizeof(struct zyd_vap), 457 M_80211_VAP, M_NOWAIT | M_ZERO); 458 if (zvp == NULL) 459 return (NULL); 460 vap = &zvp->vap; 461 /* enable s/w bmiss handling for sta mode */ 462 ieee80211_vap_setup(ic, vap, name, unit, opmode, 463 flags | IEEE80211_CLONE_NOBEACONS, bssid, mac); 464 465 /* override state transition machine */ 466 zvp->newstate = vap->iv_newstate; 467 vap->iv_newstate = zyd_newstate; 468 469 ieee80211_amrr_init(&zvp->amrr, vap, 470 IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD, 471 IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD, 472 1000 /* 1 sec */); 473 474 /* complete setup */ 475 ieee80211_vap_attach(vap, ieee80211_media_change, 476 ieee80211_media_status); 477 ic->ic_opmode = opmode; 478 return (vap); 479} 480 481static void 482zyd_vap_delete(struct ieee80211vap *vap) 483{ 484 struct zyd_vap *zvp = ZYD_VAP(vap); 485 486 ieee80211_amrr_cleanup(&zvp->amrr); 487 ieee80211_vap_detach(vap); 488 free(zvp, M_80211_VAP); 489} 490 491static void 492zyd_tx_free(struct zyd_tx_data *data, int txerr) 493{ 494 struct zyd_softc *sc = data->sc; 495 496 if (data->m != NULL) { 497 if (data->m->m_flags & M_TXCB) 498 ieee80211_process_callback(data->ni, data->m, 499 txerr ? ETIMEDOUT : 0); 500 m_freem(data->m); 501 data->m = NULL; 502 503 ieee80211_free_node(data->ni); 504 data->ni = NULL; 505 } 506 STAILQ_INSERT_TAIL(&sc->tx_free, data, next); 507 sc->tx_nfree++; 508} 509 510static int 511zyd_alloc_tx_list(struct zyd_softc *sc) 512{ 513 struct zyd_tx_data *data; 514 int i; 515 516 sc->tx_data = malloc(sizeof(struct zyd_tx_data) * ZYD_TX_LIST_CNT, 517 M_USB, M_NOWAIT|M_ZERO); 518 if (sc->tx_data == NULL) 519 return (ENOMEM); 520 521 sc->tx_nfree = 0; 522 STAILQ_INIT(&sc->tx_q); 523 STAILQ_INIT(&sc->tx_free); 524 525 for (i = 0; i < ZYD_TX_LIST_CNT; i++) { 526 data = &sc->tx_data[i]; 527 528 data->sc = sc; 529 STAILQ_INSERT_TAIL(&sc->tx_free, data, next); 530 sc->tx_nfree++; 531 } 532 return 0; 533} 534 535static void 536zyd_free_tx_list(struct zyd_softc *sc) 537{ 538 struct zyd_tx_data *data; 539 int i; 540 541 if (sc->tx_data == NULL) 542 return; 543 544 for (i = 0; i < ZYD_TX_LIST_CNT; i++) { 545 data = &sc->tx_data[i]; 546 547 if (data->m != NULL) { 548 m_freem(data->m); 549 data->m = NULL; 550 } 551 if (data->ni != NULL) { 552 ieee80211_free_node(data->ni); 553 data->ni = NULL; 554 } 555 } 556 free(sc->tx_data, M_USB); 557 sc->tx_data = NULL; 558} 559 560/* ARGUSED */ 561static struct ieee80211_node * 562zyd_node_alloc(struct ieee80211vap *vap __unused, 563 const uint8_t mac[IEEE80211_ADDR_LEN] __unused) 564{ 565 struct zyd_node *zn; 566 567 zn = malloc(sizeof(struct zyd_node), M_80211_NODE, M_NOWAIT | M_ZERO); 568 return (zn != NULL) ? (&zn->ni) : (NULL); 569} 570 571static void 572zyd_task(struct usb2_proc_msg *pm) 573{ 574 struct zyd_task *task = (struct zyd_task *)pm; 575 struct zyd_softc *sc = task->sc; 576 struct ifnet *ifp = sc->sc_ifp; 577 struct ieee80211com *ic = ifp->if_l2com; 578 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 579 struct ieee80211_node *ni = vap->iv_bss; 580 struct zyd_vap *zvp = ZYD_VAP(vap); 581 int error; 582 583 switch (sc->sc_state) { 584 case IEEE80211_S_AUTH: 585 zyd_set_chan(sc, ic->ic_curchan); 586 break; 587 case IEEE80211_S_RUN: 588 if (vap->iv_opmode == IEEE80211_M_MONITOR) 589 break; 590 591 /* turn link LED on */ 592 error = zyd_set_led(sc, ZYD_LED1, 1); 593 if (error != 0) 594 goto fail; 595 596 /* make data LED blink upon Tx */ 597 zyd_write32_m(sc, sc->sc_fwbase + ZYD_FW_LINK_STATUS, 1); 598 599 IEEE80211_ADDR_COPY(sc->sc_bssid, ni->ni_bssid); 600 zyd_set_bssid(sc, sc->sc_bssid); 601 break; 602 default: 603 break; 604 } 605fail: 606 ZYD_UNLOCK(sc); 607 IEEE80211_LOCK(ic); 608 zvp->newstate(vap, sc->sc_state, sc->sc_arg); 609 if (vap->iv_newstate_cb != NULL) 610 vap->iv_newstate_cb(vap, sc->sc_state, sc->sc_arg); 611 IEEE80211_UNLOCK(ic); 612 ZYD_LOCK(sc); 613} 614 615static int 616zyd_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 617{ 618 struct zyd_vap *zvp = ZYD_VAP(vap); 619 struct ieee80211com *ic = vap->iv_ic; 620 struct zyd_softc *sc = ic->ic_ifp->if_softc; 621 622 DPRINTF(sc, ZYD_DEBUG_STATE, "%s: %s -> %s\n", __func__, 623 ieee80211_state_name[vap->iv_state], 624 ieee80211_state_name[nstate]); 625 626 ZYD_LOCK(sc); 627 /* do it in a process context */ 628 sc->sc_state = nstate; 629 sc->sc_arg = arg; 630 ZYD_UNLOCK(sc); 631 632 if (nstate == IEEE80211_S_INIT) { 633 zvp->newstate(vap, nstate, arg); 634 return (0); 635 } else { 636 ZYD_LOCK(sc); 637 zyd_queue_command(sc, zyd_task, &sc->sc_task[0].hdr, 638 &sc->sc_task[1].hdr); 639 ZYD_UNLOCK(sc); 640 return (EINPROGRESS); 641 } 642} 643 644/* 645 * Callback handler for interrupt transfer 646 */ 647static void 648zyd_intr_read_callback(struct usb2_xfer *xfer) 649{ 650 struct zyd_softc *sc = xfer->priv_sc; 651 struct ifnet *ifp = sc->sc_ifp; 652 struct ieee80211com *ic = ifp->if_l2com; 653 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 654 struct ieee80211_node *ni; 655 struct zyd_cmd *cmd = &sc->sc_ibuf; 656 int datalen; 657 658 switch (USB_GET_STATE(xfer)) { 659 case USB_ST_TRANSFERRED: 660 usb2_copy_out(xfer->frbuffers, 0, cmd, sizeof(*cmd)); 661 662 switch (le16toh(cmd->code)) { 663 case ZYD_NOTIF_RETRYSTATUS: 664 { 665 struct zyd_notif_retry *retry = 666 (struct zyd_notif_retry *)cmd->data; 667 668 DPRINTF(sc, ZYD_DEBUG_TX_PROC, 669 "retry intr: rate=0x%x addr=%s count=%d (0x%x)\n", 670 le16toh(retry->rate), ether_sprintf(retry->macaddr), 671 le16toh(retry->count)&0xff, le16toh(retry->count)); 672 673 /* 674 * Find the node to which the packet was sent and 675 * update its retry statistics. In BSS mode, this node 676 * is the AP we're associated to so no lookup is 677 * actually needed. 678 */ 679 ni = ieee80211_find_txnode(vap, retry->macaddr); 680 if (ni != NULL) { 681 ieee80211_amrr_tx_complete(&ZYD_NODE(ni)->amn, 682 IEEE80211_AMRR_FAILURE, 1); 683 ieee80211_free_node(ni); 684 } 685 if (le16toh(retry->count) & 0x100) 686 ifp->if_oerrors++; /* too many retries */ 687 break; 688 } 689 case ZYD_NOTIF_IORD: 690 { 691 struct zyd_rq *rqp; 692 693 if (le16toh(*(uint16_t *)cmd->data) == ZYD_CR_INTERRUPT) 694 break; /* HMAC interrupt */ 695 696 datalen = xfer->actlen - sizeof(cmd->code); 697 datalen -= 2; /* XXX: padding? */ 698 699 STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) { 700 int i, cnt; 701 702 if (rqp->olen != datalen) 703 continue; 704 cnt = rqp->olen / sizeof(struct zyd_pair); 705 for (i = 0; i < cnt; i++) { 706 if (*(((const uint16_t *)rqp->idata) + i) != 707 (((struct zyd_pair *)cmd->data) + i)->reg) 708 break; 709 } 710 if (i != cnt) 711 continue; 712 /* copy answer into caller-supplied buffer */ 713 bcopy(cmd->data, rqp->odata, rqp->olen); 714 DPRINTF(sc, ZYD_DEBUG_CMD, 715 "command %p complete, data = %*D \n", 716 rqp, rqp->olen, rqp->odata, ":"); 717 wakeup(rqp); /* wakeup caller */ 718 break; 719 } 720 if (rqp == NULL) { 721 device_printf(sc->sc_dev, 722 "unexpected IORD notification %*D\n", 723 datalen, cmd->data, ":"); 724 } 725 break; 726 } 727 default: 728 device_printf(sc->sc_dev, "unknown notification %x\n", 729 le16toh(cmd->code)); 730 } 731 732 /* FALLTHROUGH */ 733 case USB_ST_SETUP: 734tr_setup: 735 xfer->frlengths[0] = xfer->max_data_length; 736 usb2_start_hardware(xfer); 737 break; 738 739 default: /* Error */ 740 DPRINTF(sc, ZYD_DEBUG_CMD, "error = %s\n", 741 usb2_errstr(xfer->error)); 742 743 if (xfer->error != USB_ERR_CANCELLED) { 744 /* try to clear stall first */ 745 xfer->flags.stall_pipe = 1; 746 goto tr_setup; 747 } 748 break; 749 } 750} 751 752static void 753zyd_intr_write_callback(struct usb2_xfer *xfer) 754{ 755 struct zyd_softc *sc = xfer->priv_sc; 756 struct zyd_rq *rqp; 757 758 switch (USB_GET_STATE(xfer)) { 759 case USB_ST_TRANSFERRED: 760 rqp = xfer->priv_fifo; 761 DPRINTF(sc, ZYD_DEBUG_CMD, "command %p transferred\n", rqp); 762 if ((rqp->flags & ZYD_CMD_FLAG_READ) == 0) 763 wakeup(rqp); /* wakeup caller */ 764 765 /* FALLTHROUGH */ 766 case USB_ST_SETUP: 767tr_setup: 768 STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) { 769 if (rqp->flags & ZYD_CMD_FLAG_SENT) 770 continue; 771 772 usb2_copy_in(xfer->frbuffers, 0, rqp->cmd, rqp->ilen); 773 774 xfer->frlengths[0] = rqp->ilen; 775 xfer->priv_fifo = rqp; 776 rqp->flags |= ZYD_CMD_FLAG_SENT; 777 usb2_start_hardware(xfer); 778 break; 779 } 780 break; 781 782 default: /* Error */ 783 DPRINTF(sc, ZYD_DEBUG_ANY, "error = %s\n", 784 usb2_errstr(xfer->error)); 785 786 if (xfer->error != USB_ERR_CANCELLED) { 787 /* try to clear stall first */ 788 xfer->flags.stall_pipe = 1; 789 goto tr_setup; 790 } 791 break; 792 } 793} 794 795static int 796zyd_cmd(struct zyd_softc *sc, uint16_t code, const void *idata, int ilen, 797 void *odata, int olen, u_int flags) 798{ 799 struct zyd_cmd cmd; 800 struct zyd_rq rq; 801 int error; 802 803 if (ilen > sizeof(cmd.data)) 804 return (EINVAL); 805 if (sc->sc_flags & ZYD_FLAG_DETACHING) 806 return (ENXIO); 807 808 cmd.code = htole16(code); 809 bcopy(idata, cmd.data, ilen); 810 DPRINTF(sc, ZYD_DEBUG_CMD, "sending cmd %p = %*D\n", 811 &rq, ilen, idata, ":"); 812 813 rq.cmd = &cmd; 814 rq.idata = idata; 815 rq.odata = odata; 816 rq.ilen = sizeof(uint16_t) + ilen; 817 rq.olen = olen; 818 rq.flags = flags; 819 STAILQ_INSERT_TAIL(&sc->sc_rqh, &rq, rq); 820 usb2_transfer_start(sc->sc_xfer[ZYD_INTR_RD]); 821 usb2_transfer_start(sc->sc_xfer[ZYD_INTR_WR]); 822 823 /* wait at most one second for command reply */ 824 error = mtx_sleep(&rq, &sc->sc_mtx, 0 , "zydcmd", hz); 825 if (error) 826 device_printf(sc->sc_dev, "command timeout\n"); 827 STAILQ_REMOVE(&sc->sc_rqh, &rq, zyd_rq, rq); 828 DPRINTF(sc, ZYD_DEBUG_CMD, "finsihed cmd %p, error = %d \n", 829 &rq, error); 830 831 return (error); 832} 833 834static int 835zyd_read16(struct zyd_softc *sc, uint16_t reg, uint16_t *val) 836{ 837 struct zyd_pair tmp; 838 int error; 839 840 reg = htole16(reg); 841 error = zyd_cmd(sc, ZYD_CMD_IORD, ®, sizeof(reg), &tmp, sizeof(tmp), 842 ZYD_CMD_FLAG_READ); 843 if (error == 0) 844 *val = le16toh(tmp.val); 845 return (error); 846} 847 848static int 849zyd_read32(struct zyd_softc *sc, uint16_t reg, uint32_t *val) 850{ 851 struct zyd_pair tmp[2]; 852 uint16_t regs[2]; 853 int error; 854 855 regs[0] = htole16(ZYD_REG32_HI(reg)); 856 regs[1] = htole16(ZYD_REG32_LO(reg)); 857 error = zyd_cmd(sc, ZYD_CMD_IORD, regs, sizeof(regs), tmp, sizeof(tmp), 858 ZYD_CMD_FLAG_READ); 859 if (error == 0) 860 *val = le16toh(tmp[0].val) << 16 | le16toh(tmp[1].val); 861 return (error); 862} 863 864static int 865zyd_write16(struct zyd_softc *sc, uint16_t reg, uint16_t val) 866{ 867 struct zyd_pair pair; 868 869 pair.reg = htole16(reg); 870 pair.val = htole16(val); 871 872 return zyd_cmd(sc, ZYD_CMD_IOWR, &pair, sizeof(pair), NULL, 0, 0); 873} 874 875static int 876zyd_write32(struct zyd_softc *sc, uint16_t reg, uint32_t val) 877{ 878 struct zyd_pair pair[2]; 879 880 pair[0].reg = htole16(ZYD_REG32_HI(reg)); 881 pair[0].val = htole16(val >> 16); 882 pair[1].reg = htole16(ZYD_REG32_LO(reg)); 883 pair[1].val = htole16(val & 0xffff); 884 885 return zyd_cmd(sc, ZYD_CMD_IOWR, pair, sizeof(pair), NULL, 0, 0); 886} 887 888static int 889zyd_rfwrite(struct zyd_softc *sc, uint32_t val) 890{ 891 struct zyd_rf *rf = &sc->sc_rf; 892 struct zyd_rfwrite_cmd req; 893 uint16_t cr203; 894 int error, i; 895 896 zyd_read16_m(sc, ZYD_CR203, &cr203); 897 cr203 &= ~(ZYD_RF_IF_LE | ZYD_RF_CLK | ZYD_RF_DATA); 898 899 req.code = htole16(2); 900 req.width = htole16(rf->width); 901 for (i = 0; i < rf->width; i++) { 902 req.bit[i] = htole16(cr203); 903 if (val & (1 << (rf->width - 1 - i))) 904 req.bit[i] |= htole16(ZYD_RF_DATA); 905 } 906 error = zyd_cmd(sc, ZYD_CMD_RFCFG, &req, 4 + 2 * rf->width, NULL, 0, 0); 907fail: 908 return (error); 909} 910 911static int 912zyd_rfwrite_cr(struct zyd_softc *sc, uint32_t val) 913{ 914 int error; 915 916 zyd_write16_m(sc, ZYD_CR244, (val >> 16) & 0xff); 917 zyd_write16_m(sc, ZYD_CR243, (val >> 8) & 0xff); 918 zyd_write16_m(sc, ZYD_CR242, (val >> 0) & 0xff); 919fail: 920 return (error); 921} 922 923static int 924zyd_lock_phy(struct zyd_softc *sc) 925{ 926 int error; 927 uint32_t tmp; 928 929 zyd_read32_m(sc, ZYD_MAC_MISC, &tmp); 930 tmp &= ~ZYD_UNLOCK_PHY_REGS; 931 zyd_write32_m(sc, ZYD_MAC_MISC, tmp); 932fail: 933 return (error); 934} 935 936static int 937zyd_unlock_phy(struct zyd_softc *sc) 938{ 939 int error; 940 uint32_t tmp; 941 942 zyd_read32_m(sc, ZYD_MAC_MISC, &tmp); 943 tmp |= ZYD_UNLOCK_PHY_REGS; 944 zyd_write32_m(sc, ZYD_MAC_MISC, tmp); 945fail: 946 return (error); 947} 948 949/* 950 * RFMD RF methods. 951 */ 952static int 953zyd_rfmd_init(struct zyd_rf *rf) 954{ 955#define N(a) (sizeof(a) / sizeof((a)[0])) 956 struct zyd_softc *sc = rf->rf_sc; 957 static const struct zyd_phy_pair phyini[] = ZYD_RFMD_PHY; 958 static const uint32_t rfini[] = ZYD_RFMD_RF; 959 int i, error; 960 961 /* init RF-dependent PHY registers */ 962 for (i = 0; i < N(phyini); i++) { 963 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 964 } 965 966 /* init RFMD radio */ 967 for (i = 0; i < N(rfini); i++) { 968 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 969 return (error); 970 } 971fail: 972 return (error); 973#undef N 974} 975 976static int 977zyd_rfmd_switch_radio(struct zyd_rf *rf, int on) 978{ 979 int error; 980 struct zyd_softc *sc = rf->rf_sc; 981 982 zyd_write16_m(sc, ZYD_CR10, on ? 0x89 : 0x15); 983 zyd_write16_m(sc, ZYD_CR11, on ? 0x00 : 0x81); 984fail: 985 return (error); 986} 987 988static int 989zyd_rfmd_set_channel(struct zyd_rf *rf, uint8_t chan) 990{ 991 int error; 992 struct zyd_softc *sc = rf->rf_sc; 993 static const struct { 994 uint32_t r1, r2; 995 } rfprog[] = ZYD_RFMD_CHANTABLE; 996 997 error = zyd_rfwrite(sc, rfprog[chan - 1].r1); 998 if (error != 0) 999 goto fail; 1000 error = zyd_rfwrite(sc, rfprog[chan - 1].r2); 1001 if (error != 0) 1002 goto fail; 1003 1004fail: 1005 return (error); 1006} 1007 1008/* 1009 * AL2230 RF methods. 1010 */ 1011static int 1012zyd_al2230_init(struct zyd_rf *rf) 1013{ 1014#define N(a) (sizeof(a) / sizeof((a)[0])) 1015 struct zyd_softc *sc = rf->rf_sc; 1016 static const struct zyd_phy_pair phyini[] = ZYD_AL2230_PHY; 1017 static const struct zyd_phy_pair phy2230s[] = ZYD_AL2230S_PHY_INIT; 1018 static const struct zyd_phy_pair phypll[] = { 1019 { ZYD_CR251, 0x2f }, { ZYD_CR251, 0x3f }, 1020 { ZYD_CR138, 0x28 }, { ZYD_CR203, 0x06 } 1021 }; 1022 static const uint32_t rfini1[] = ZYD_AL2230_RF_PART1; 1023 static const uint32_t rfini2[] = ZYD_AL2230_RF_PART2; 1024 static const uint32_t rfini3[] = ZYD_AL2230_RF_PART3; 1025 int i, error; 1026 1027 /* init RF-dependent PHY registers */ 1028 for (i = 0; i < N(phyini); i++) 1029 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1030 1031 if (sc->sc_rfrev == ZYD_RF_AL2230S || sc->sc_al2230s != 0) { 1032 for (i = 0; i < N(phy2230s); i++) 1033 zyd_write16_m(sc, phy2230s[i].reg, phy2230s[i].val); 1034 } 1035 1036 /* init AL2230 radio */ 1037 for (i = 0; i < N(rfini1); i++) { 1038 error = zyd_rfwrite(sc, rfini1[i]); 1039 if (error != 0) 1040 goto fail; 1041 } 1042 1043 if (sc->sc_rfrev == ZYD_RF_AL2230S || sc->sc_al2230s != 0) 1044 error = zyd_rfwrite(sc, 0x000824); 1045 else 1046 error = zyd_rfwrite(sc, 0x0005a4); 1047 if (error != 0) 1048 goto fail; 1049 1050 for (i = 0; i < N(rfini2); i++) { 1051 error = zyd_rfwrite(sc, rfini2[i]); 1052 if (error != 0) 1053 goto fail; 1054 } 1055 1056 for (i = 0; i < N(phypll); i++) 1057 zyd_write16_m(sc, phypll[i].reg, phypll[i].val); 1058 1059 for (i = 0; i < N(rfini3); i++) { 1060 error = zyd_rfwrite(sc, rfini3[i]); 1061 if (error != 0) 1062 goto fail; 1063 } 1064fail: 1065 return (error); 1066#undef N 1067} 1068 1069static int 1070zyd_al2230_fini(struct zyd_rf *rf) 1071{ 1072#define N(a) (sizeof(a) / sizeof((a)[0])) 1073 int error, i; 1074 struct zyd_softc *sc = rf->rf_sc; 1075 static const struct zyd_phy_pair phy[] = ZYD_AL2230_PHY_FINI_PART1; 1076 1077 for (i = 0; i < N(phy); i++) 1078 zyd_write16_m(sc, phy[i].reg, phy[i].val); 1079 1080 if (sc->sc_newphy != 0) 1081 zyd_write16_m(sc, ZYD_CR9, 0xe1); 1082 1083 zyd_write16_m(sc, ZYD_CR203, 0x6); 1084fail: 1085 return (error); 1086#undef N 1087} 1088 1089static int 1090zyd_al2230_init_b(struct zyd_rf *rf) 1091{ 1092#define N(a) (sizeof(a) / sizeof((a)[0])) 1093 struct zyd_softc *sc = rf->rf_sc; 1094 static const struct zyd_phy_pair phy1[] = ZYD_AL2230_PHY_PART1; 1095 static const struct zyd_phy_pair phy2[] = ZYD_AL2230_PHY_PART2; 1096 static const struct zyd_phy_pair phy3[] = ZYD_AL2230_PHY_PART3; 1097 static const struct zyd_phy_pair phy2230s[] = ZYD_AL2230S_PHY_INIT; 1098 static const struct zyd_phy_pair phyini[] = ZYD_AL2230_PHY_B; 1099 static const uint32_t rfini_part1[] = ZYD_AL2230_RF_B_PART1; 1100 static const uint32_t rfini_part2[] = ZYD_AL2230_RF_B_PART2; 1101 static const uint32_t rfini_part3[] = ZYD_AL2230_RF_B_PART3; 1102 static const uint32_t zyd_al2230_chtable[][3] = ZYD_AL2230_CHANTABLE; 1103 int i, error; 1104 1105 for (i = 0; i < N(phy1); i++) 1106 zyd_write16_m(sc, phy1[i].reg, phy1[i].val); 1107 1108 /* init RF-dependent PHY registers */ 1109 for (i = 0; i < N(phyini); i++) 1110 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1111 1112 if (sc->sc_rfrev == ZYD_RF_AL2230S || sc->sc_al2230s != 0) { 1113 for (i = 0; i < N(phy2230s); i++) 1114 zyd_write16_m(sc, phy2230s[i].reg, phy2230s[i].val); 1115 } 1116 1117 for (i = 0; i < 3; i++) { 1118 error = zyd_rfwrite_cr(sc, zyd_al2230_chtable[0][i]); 1119 if (error != 0) 1120 return (error); 1121 } 1122 1123 for (i = 0; i < N(rfini_part1); i++) { 1124 error = zyd_rfwrite_cr(sc, rfini_part1[i]); 1125 if (error != 0) 1126 return (error); 1127 } 1128 1129 if (sc->sc_rfrev == ZYD_RF_AL2230S || sc->sc_al2230s != 0) 1130 error = zyd_rfwrite(sc, 0x241000); 1131 else 1132 error = zyd_rfwrite(sc, 0x25a000); 1133 if (error != 0) 1134 goto fail; 1135 1136 for (i = 0; i < N(rfini_part2); i++) { 1137 error = zyd_rfwrite_cr(sc, rfini_part2[i]); 1138 if (error != 0) 1139 return (error); 1140 } 1141 1142 for (i = 0; i < N(phy2); i++) 1143 zyd_write16_m(sc, phy2[i].reg, phy2[i].val); 1144 1145 for (i = 0; i < N(rfini_part3); i++) { 1146 error = zyd_rfwrite_cr(sc, rfini_part3[i]); 1147 if (error != 0) 1148 return (error); 1149 } 1150 1151 for (i = 0; i < N(phy3); i++) 1152 zyd_write16_m(sc, phy3[i].reg, phy3[i].val); 1153 1154 error = zyd_al2230_fini(rf); 1155fail: 1156 return (error); 1157#undef N 1158} 1159 1160static int 1161zyd_al2230_switch_radio(struct zyd_rf *rf, int on) 1162{ 1163 struct zyd_softc *sc = rf->rf_sc; 1164 int error, on251 = (sc->sc_macrev == ZYD_ZD1211) ? 0x3f : 0x7f; 1165 1166 zyd_write16_m(sc, ZYD_CR11, on ? 0x00 : 0x04); 1167 zyd_write16_m(sc, ZYD_CR251, on ? on251 : 0x2f); 1168fail: 1169 return (error); 1170} 1171 1172static int 1173zyd_al2230_set_channel(struct zyd_rf *rf, uint8_t chan) 1174{ 1175#define N(a) (sizeof(a) / sizeof((a)[0])) 1176 int error, i; 1177 struct zyd_softc *sc = rf->rf_sc; 1178 static const struct zyd_phy_pair phy1[] = { 1179 { ZYD_CR138, 0x28 }, { ZYD_CR203, 0x06 }, 1180 }; 1181 static const struct { 1182 uint32_t r1, r2, r3; 1183 } rfprog[] = ZYD_AL2230_CHANTABLE; 1184 1185 error = zyd_rfwrite(sc, rfprog[chan - 1].r1); 1186 if (error != 0) 1187 goto fail; 1188 error = zyd_rfwrite(sc, rfprog[chan - 1].r2); 1189 if (error != 0) 1190 goto fail; 1191 error = zyd_rfwrite(sc, rfprog[chan - 1].r3); 1192 if (error != 0) 1193 goto fail; 1194 1195 for (i = 0; i < N(phy1); i++) 1196 zyd_write16_m(sc, phy1[i].reg, phy1[i].val); 1197fail: 1198 return (error); 1199#undef N 1200} 1201 1202static int 1203zyd_al2230_set_channel_b(struct zyd_rf *rf, uint8_t chan) 1204{ 1205#define N(a) (sizeof(a) / sizeof((a)[0])) 1206 int error, i; 1207 struct zyd_softc *sc = rf->rf_sc; 1208 static const struct zyd_phy_pair phy1[] = ZYD_AL2230_PHY_PART1; 1209 static const struct { 1210 uint32_t r1, r2, r3; 1211 } rfprog[] = ZYD_AL2230_CHANTABLE_B; 1212 1213 for (i = 0; i < N(phy1); i++) 1214 zyd_write16_m(sc, phy1[i].reg, phy1[i].val); 1215 1216 error = zyd_rfwrite_cr(sc, rfprog[chan - 1].r1); 1217 if (error != 0) 1218 goto fail; 1219 error = zyd_rfwrite_cr(sc, rfprog[chan - 1].r2); 1220 if (error != 0) 1221 goto fail; 1222 error = zyd_rfwrite_cr(sc, rfprog[chan - 1].r3); 1223 if (error != 0) 1224 goto fail; 1225 error = zyd_al2230_fini(rf); 1226fail: 1227 return (error); 1228#undef N 1229} 1230 1231#define ZYD_AL2230_PHY_BANDEDGE6 \ 1232{ \ 1233 { ZYD_CR128, 0x14 }, { ZYD_CR129, 0x12 }, { ZYD_CR130, 0x10 }, \ 1234 { ZYD_CR47, 0x1e } \ 1235} 1236 1237static int 1238zyd_al2230_bandedge6(struct zyd_rf *rf, struct ieee80211_channel *c) 1239{ 1240#define N(a) (sizeof(a) / sizeof((a)[0])) 1241 int error = 0, i; 1242 struct zyd_softc *sc = rf->rf_sc; 1243 struct ifnet *ifp = sc->sc_ifp; 1244 struct ieee80211com *ic = ifp->if_l2com; 1245 struct zyd_phy_pair r[] = ZYD_AL2230_PHY_BANDEDGE6; 1246 u_int chan = ieee80211_chan2ieee(ic, c); 1247 1248 if (chan == 1 || chan == 11) 1249 r[0].val = 0x12; 1250 1251 for (i = 0; i < N(r); i++) 1252 zyd_write16_m(sc, r[i].reg, r[i].val); 1253fail: 1254 return (error); 1255#undef N 1256} 1257 1258/* 1259 * AL7230B RF methods. 1260 */ 1261static int 1262zyd_al7230B_init(struct zyd_rf *rf) 1263{ 1264#define N(a) (sizeof(a) / sizeof((a)[0])) 1265 struct zyd_softc *sc = rf->rf_sc; 1266 static const struct zyd_phy_pair phyini_1[] = ZYD_AL7230B_PHY_1; 1267 static const struct zyd_phy_pair phyini_2[] = ZYD_AL7230B_PHY_2; 1268 static const struct zyd_phy_pair phyini_3[] = ZYD_AL7230B_PHY_3; 1269 static const uint32_t rfini_1[] = ZYD_AL7230B_RF_1; 1270 static const uint32_t rfini_2[] = ZYD_AL7230B_RF_2; 1271 int i, error; 1272 1273 /* for AL7230B, PHY and RF need to be initialized in "phases" */ 1274 1275 /* init RF-dependent PHY registers, part one */ 1276 for (i = 0; i < N(phyini_1); i++) 1277 zyd_write16_m(sc, phyini_1[i].reg, phyini_1[i].val); 1278 1279 /* init AL7230B radio, part one */ 1280 for (i = 0; i < N(rfini_1); i++) { 1281 if ((error = zyd_rfwrite(sc, rfini_1[i])) != 0) 1282 return (error); 1283 } 1284 /* init RF-dependent PHY registers, part two */ 1285 for (i = 0; i < N(phyini_2); i++) 1286 zyd_write16_m(sc, phyini_2[i].reg, phyini_2[i].val); 1287 1288 /* init AL7230B radio, part two */ 1289 for (i = 0; i < N(rfini_2); i++) { 1290 if ((error = zyd_rfwrite(sc, rfini_2[i])) != 0) 1291 return (error); 1292 } 1293 /* init RF-dependent PHY registers, part three */ 1294 for (i = 0; i < N(phyini_3); i++) 1295 zyd_write16_m(sc, phyini_3[i].reg, phyini_3[i].val); 1296fail: 1297 return (error); 1298#undef N 1299} 1300 1301static int 1302zyd_al7230B_switch_radio(struct zyd_rf *rf, int on) 1303{ 1304 int error; 1305 struct zyd_softc *sc = rf->rf_sc; 1306 1307 zyd_write16_m(sc, ZYD_CR11, on ? 0x00 : 0x04); 1308 zyd_write16_m(sc, ZYD_CR251, on ? 0x3f : 0x2f); 1309fail: 1310 return (error); 1311} 1312 1313static int 1314zyd_al7230B_set_channel(struct zyd_rf *rf, uint8_t chan) 1315{ 1316#define N(a) (sizeof(a) / sizeof((a)[0])) 1317 struct zyd_softc *sc = rf->rf_sc; 1318 static const struct { 1319 uint32_t r1, r2; 1320 } rfprog[] = ZYD_AL7230B_CHANTABLE; 1321 static const uint32_t rfsc[] = ZYD_AL7230B_RF_SETCHANNEL; 1322 int i, error; 1323 1324 zyd_write16_m(sc, ZYD_CR240, 0x57); 1325 zyd_write16_m(sc, ZYD_CR251, 0x2f); 1326 1327 for (i = 0; i < N(rfsc); i++) { 1328 if ((error = zyd_rfwrite(sc, rfsc[i])) != 0) 1329 return (error); 1330 } 1331 1332 zyd_write16_m(sc, ZYD_CR128, 0x14); 1333 zyd_write16_m(sc, ZYD_CR129, 0x12); 1334 zyd_write16_m(sc, ZYD_CR130, 0x10); 1335 zyd_write16_m(sc, ZYD_CR38, 0x38); 1336 zyd_write16_m(sc, ZYD_CR136, 0xdf); 1337 1338 error = zyd_rfwrite(sc, rfprog[chan - 1].r1); 1339 if (error != 0) 1340 goto fail; 1341 error = zyd_rfwrite(sc, rfprog[chan - 1].r2); 1342 if (error != 0) 1343 goto fail; 1344 error = zyd_rfwrite(sc, 0x3c9000); 1345 if (error != 0) 1346 goto fail; 1347 1348 zyd_write16_m(sc, ZYD_CR251, 0x3f); 1349 zyd_write16_m(sc, ZYD_CR203, 0x06); 1350 zyd_write16_m(sc, ZYD_CR240, 0x08); 1351fail: 1352 return (error); 1353#undef N 1354} 1355 1356/* 1357 * AL2210 RF methods. 1358 */ 1359static int 1360zyd_al2210_init(struct zyd_rf *rf) 1361{ 1362#define N(a) (sizeof(a) / sizeof((a)[0])) 1363 struct zyd_softc *sc = rf->rf_sc; 1364 static const struct zyd_phy_pair phyini[] = ZYD_AL2210_PHY; 1365 static const uint32_t rfini[] = ZYD_AL2210_RF; 1366 uint32_t tmp; 1367 int i, error; 1368 1369 zyd_write32_m(sc, ZYD_CR18, 2); 1370 1371 /* init RF-dependent PHY registers */ 1372 for (i = 0; i < N(phyini); i++) 1373 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1374 1375 /* init AL2210 radio */ 1376 for (i = 0; i < N(rfini); i++) { 1377 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 1378 return (error); 1379 } 1380 zyd_write16_m(sc, ZYD_CR47, 0x1e); 1381 zyd_read32_m(sc, ZYD_CR_RADIO_PD, &tmp); 1382 zyd_write32_m(sc, ZYD_CR_RADIO_PD, tmp & ~1); 1383 zyd_write32_m(sc, ZYD_CR_RADIO_PD, tmp | 1); 1384 zyd_write32_m(sc, ZYD_CR_RFCFG, 0x05); 1385 zyd_write32_m(sc, ZYD_CR_RFCFG, 0x00); 1386 zyd_write16_m(sc, ZYD_CR47, 0x1e); 1387 zyd_write32_m(sc, ZYD_CR18, 3); 1388fail: 1389 return (error); 1390#undef N 1391} 1392 1393static int 1394zyd_al2210_switch_radio(struct zyd_rf *rf, int on) 1395{ 1396 /* vendor driver does nothing for this RF chip */ 1397 1398 return (0); 1399} 1400 1401static int 1402zyd_al2210_set_channel(struct zyd_rf *rf, uint8_t chan) 1403{ 1404 int error; 1405 struct zyd_softc *sc = rf->rf_sc; 1406 static const uint32_t rfprog[] = ZYD_AL2210_CHANTABLE; 1407 uint32_t tmp; 1408 1409 zyd_write32_m(sc, ZYD_CR18, 2); 1410 zyd_write16_m(sc, ZYD_CR47, 0x1e); 1411 zyd_read32_m(sc, ZYD_CR_RADIO_PD, &tmp); 1412 zyd_write32_m(sc, ZYD_CR_RADIO_PD, tmp & ~1); 1413 zyd_write32_m(sc, ZYD_CR_RADIO_PD, tmp | 1); 1414 zyd_write32_m(sc, ZYD_CR_RFCFG, 0x05); 1415 zyd_write32_m(sc, ZYD_CR_RFCFG, 0x00); 1416 zyd_write16_m(sc, ZYD_CR47, 0x1e); 1417 1418 /* actually set the channel */ 1419 error = zyd_rfwrite(sc, rfprog[chan - 1]); 1420 if (error != 0) 1421 goto fail; 1422 1423 zyd_write32_m(sc, ZYD_CR18, 3); 1424fail: 1425 return (error); 1426} 1427 1428/* 1429 * GCT RF methods. 1430 */ 1431static int 1432zyd_gct_init(struct zyd_rf *rf) 1433{ 1434#define N(a) (sizeof(a) / sizeof((a)[0])) 1435 struct zyd_softc *sc = rf->rf_sc; 1436 static const struct zyd_phy_pair phyini[] = ZYD_GCT_PHY; 1437 static const uint32_t rfini[] = ZYD_GCT_RF; 1438 int i, error; 1439 1440 /* init RF-dependent PHY registers */ 1441 for (i = 0; i < N(phyini); i++) 1442 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1443 1444 /* init cgt radio */ 1445 for (i = 0; i < N(rfini); i++) { 1446 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 1447 return (error); 1448 } 1449fail: 1450 return (error); 1451#undef N 1452} 1453 1454static int 1455zyd_gct_switch_radio(struct zyd_rf *rf, int on) 1456{ 1457 /* vendor driver does nothing for this RF chip */ 1458 1459 return (0); 1460} 1461 1462static int 1463zyd_gct_set_channel(struct zyd_rf *rf, uint8_t chan) 1464{ 1465 int error; 1466 struct zyd_softc *sc = rf->rf_sc; 1467 static const uint32_t rfprog[] = ZYD_GCT_CHANTABLE; 1468 1469 error = zyd_rfwrite(sc, 0x1c0000); 1470 if (error != 0) 1471 goto fail; 1472 error = zyd_rfwrite(sc, rfprog[chan - 1]); 1473 if (error != 0) 1474 goto fail; 1475 error = zyd_rfwrite(sc, 0x1c0008); 1476fail: 1477 return (error); 1478} 1479 1480/* 1481 * Maxim RF methods. 1482 */ 1483static int 1484zyd_maxim_init(struct zyd_rf *rf) 1485{ 1486#define N(a) (sizeof(a) / sizeof((a)[0])) 1487 struct zyd_softc *sc = rf->rf_sc; 1488 static const struct zyd_phy_pair phyini[] = ZYD_MAXIM_PHY; 1489 static const uint32_t rfini[] = ZYD_MAXIM_RF; 1490 uint16_t tmp; 1491 int i, error; 1492 1493 /* init RF-dependent PHY registers */ 1494 for (i = 0; i < N(phyini); i++) 1495 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1496 1497 zyd_read16_m(sc, ZYD_CR203, &tmp); 1498 zyd_write16_m(sc, ZYD_CR203, tmp & ~(1 << 4)); 1499 1500 /* init maxim radio */ 1501 for (i = 0; i < N(rfini); i++) { 1502 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 1503 return (error); 1504 } 1505 zyd_read16_m(sc, ZYD_CR203, &tmp); 1506 zyd_write16_m(sc, ZYD_CR203, tmp | (1 << 4)); 1507fail: 1508 return (error); 1509#undef N 1510} 1511 1512static int 1513zyd_maxim_switch_radio(struct zyd_rf *rf, int on) 1514{ 1515 1516 /* vendor driver does nothing for this RF chip */ 1517 return (0); 1518} 1519 1520static int 1521zyd_maxim_set_channel(struct zyd_rf *rf, uint8_t chan) 1522{ 1523#define N(a) (sizeof(a) / sizeof((a)[0])) 1524 struct zyd_softc *sc = rf->rf_sc; 1525 static const struct zyd_phy_pair phyini[] = ZYD_MAXIM_PHY; 1526 static const uint32_t rfini[] = ZYD_MAXIM_RF; 1527 static const struct { 1528 uint32_t r1, r2; 1529 } rfprog[] = ZYD_MAXIM_CHANTABLE; 1530 uint16_t tmp; 1531 int i, error; 1532 1533 /* 1534 * Do the same as we do when initializing it, except for the channel 1535 * values coming from the two channel tables. 1536 */ 1537 1538 /* init RF-dependent PHY registers */ 1539 for (i = 0; i < N(phyini); i++) 1540 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1541 1542 zyd_read16_m(sc, ZYD_CR203, &tmp); 1543 zyd_write16_m(sc, ZYD_CR203, tmp & ~(1 << 4)); 1544 1545 /* first two values taken from the chantables */ 1546 error = zyd_rfwrite(sc, rfprog[chan - 1].r1); 1547 if (error != 0) 1548 goto fail; 1549 error = zyd_rfwrite(sc, rfprog[chan - 1].r2); 1550 if (error != 0) 1551 goto fail; 1552 1553 /* init maxim radio - skipping the two first values */ 1554 for (i = 2; i < N(rfini); i++) { 1555 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 1556 return (error); 1557 } 1558 zyd_read16_m(sc, ZYD_CR203, &tmp); 1559 zyd_write16_m(sc, ZYD_CR203, tmp | (1 << 4)); 1560fail: 1561 return (error); 1562#undef N 1563} 1564 1565/* 1566 * Maxim2 RF methods. 1567 */ 1568static int 1569zyd_maxim2_init(struct zyd_rf *rf) 1570{ 1571#define N(a) (sizeof(a) / sizeof((a)[0])) 1572 struct zyd_softc *sc = rf->rf_sc; 1573 static const struct zyd_phy_pair phyini[] = ZYD_MAXIM2_PHY; 1574 static const uint32_t rfini[] = ZYD_MAXIM2_RF; 1575 uint16_t tmp; 1576 int i, error; 1577 1578 /* init RF-dependent PHY registers */ 1579 for (i = 0; i < N(phyini); i++) 1580 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1581 1582 zyd_read16_m(sc, ZYD_CR203, &tmp); 1583 zyd_write16_m(sc, ZYD_CR203, tmp & ~(1 << 4)); 1584 1585 /* init maxim2 radio */ 1586 for (i = 0; i < N(rfini); i++) { 1587 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 1588 return (error); 1589 } 1590 zyd_read16_m(sc, ZYD_CR203, &tmp); 1591 zyd_write16_m(sc, ZYD_CR203, tmp | (1 << 4)); 1592fail: 1593 return (error); 1594#undef N 1595} 1596 1597static int 1598zyd_maxim2_switch_radio(struct zyd_rf *rf, int on) 1599{ 1600 1601 /* vendor driver does nothing for this RF chip */ 1602 return (0); 1603} 1604 1605static int 1606zyd_maxim2_set_channel(struct zyd_rf *rf, uint8_t chan) 1607{ 1608#define N(a) (sizeof(a) / sizeof((a)[0])) 1609 struct zyd_softc *sc = rf->rf_sc; 1610 static const struct zyd_phy_pair phyini[] = ZYD_MAXIM2_PHY; 1611 static const uint32_t rfini[] = ZYD_MAXIM2_RF; 1612 static const struct { 1613 uint32_t r1, r2; 1614 } rfprog[] = ZYD_MAXIM2_CHANTABLE; 1615 uint16_t tmp; 1616 int i, error; 1617 1618 /* 1619 * Do the same as we do when initializing it, except for the channel 1620 * values coming from the two channel tables. 1621 */ 1622 1623 /* init RF-dependent PHY registers */ 1624 for (i = 0; i < N(phyini); i++) 1625 zyd_write16_m(sc, phyini[i].reg, phyini[i].val); 1626 1627 zyd_read16_m(sc, ZYD_CR203, &tmp); 1628 zyd_write16_m(sc, ZYD_CR203, tmp & ~(1 << 4)); 1629 1630 /* first two values taken from the chantables */ 1631 error = zyd_rfwrite(sc, rfprog[chan - 1].r1); 1632 if (error != 0) 1633 goto fail; 1634 error = zyd_rfwrite(sc, rfprog[chan - 1].r2); 1635 if (error != 0) 1636 goto fail; 1637 1638 /* init maxim2 radio - skipping the two first values */ 1639 for (i = 2; i < N(rfini); i++) { 1640 if ((error = zyd_rfwrite(sc, rfini[i])) != 0) 1641 return (error); 1642 } 1643 zyd_read16_m(sc, ZYD_CR203, &tmp); 1644 zyd_write16_m(sc, ZYD_CR203, tmp | (1 << 4)); 1645fail: 1646 return (error); 1647#undef N 1648} 1649 1650static int 1651zyd_rf_attach(struct zyd_softc *sc, uint8_t type) 1652{ 1653 struct zyd_rf *rf = &sc->sc_rf; 1654 1655 rf->rf_sc = sc; 1656 1657 switch (type) { 1658 case ZYD_RF_RFMD: 1659 rf->init = zyd_rfmd_init; 1660 rf->switch_radio = zyd_rfmd_switch_radio; 1661 rf->set_channel = zyd_rfmd_set_channel; 1662 rf->width = 24; /* 24-bit RF values */ 1663 break; 1664 case ZYD_RF_AL2230: 1665 case ZYD_RF_AL2230S: 1666 if (sc->sc_macrev == ZYD_ZD1211B) { 1667 rf->init = zyd_al2230_init_b; 1668 rf->set_channel = zyd_al2230_set_channel_b; 1669 } else { 1670 rf->init = zyd_al2230_init; 1671 rf->set_channel = zyd_al2230_set_channel; 1672 } 1673 rf->switch_radio = zyd_al2230_switch_radio; 1674 rf->bandedge6 = zyd_al2230_bandedge6; 1675 rf->width = 24; /* 24-bit RF values */ 1676 break; 1677 case ZYD_RF_AL7230B: 1678 rf->init = zyd_al7230B_init; 1679 rf->switch_radio = zyd_al7230B_switch_radio; 1680 rf->set_channel = zyd_al7230B_set_channel; 1681 rf->width = 24; /* 24-bit RF values */ 1682 break; 1683 case ZYD_RF_AL2210: 1684 rf->init = zyd_al2210_init; 1685 rf->switch_radio = zyd_al2210_switch_radio; 1686 rf->set_channel = zyd_al2210_set_channel; 1687 rf->width = 24; /* 24-bit RF values */ 1688 break; 1689 case ZYD_RF_GCT: 1690 rf->init = zyd_gct_init; 1691 rf->switch_radio = zyd_gct_switch_radio; 1692 rf->set_channel = zyd_gct_set_channel; 1693 rf->width = 21; /* 21-bit RF values */ 1694 break; 1695 case ZYD_RF_MAXIM_NEW: 1696 rf->init = zyd_maxim_init; 1697 rf->switch_radio = zyd_maxim_switch_radio; 1698 rf->set_channel = zyd_maxim_set_channel; 1699 rf->width = 18; /* 18-bit RF values */ 1700 break; 1701 case ZYD_RF_MAXIM_NEW2: 1702 rf->init = zyd_maxim2_init; 1703 rf->switch_radio = zyd_maxim2_switch_radio; 1704 rf->set_channel = zyd_maxim2_set_channel; 1705 rf->width = 18; /* 18-bit RF values */ 1706 break; 1707 default: 1708 device_printf(sc->sc_dev, 1709 "sorry, radio \"%s\" is not supported yet\n", 1710 zyd_rf_name(type)); 1711 return (EINVAL); 1712 } 1713 return (0); 1714} 1715 1716static const char * 1717zyd_rf_name(uint8_t type) 1718{ 1719 static const char * const zyd_rfs[] = { 1720 "unknown", "unknown", "UW2451", "UCHIP", "AL2230", 1721 "AL7230B", "THETA", "AL2210", "MAXIM_NEW", "GCT", 1722 "AL2230S", "RALINK", "INTERSIL", "RFMD", "MAXIM_NEW2", 1723 "PHILIPS" 1724 }; 1725 1726 return zyd_rfs[(type > 15) ? 0 : type]; 1727} 1728 1729static int 1730zyd_hw_init(struct zyd_softc *sc) 1731{ 1732 int error; 1733 const struct zyd_phy_pair *phyp; 1734 struct zyd_rf *rf = &sc->sc_rf; 1735 uint16_t val; 1736 1737 /* specify that the plug and play is finished */ 1738 zyd_write32_m(sc, ZYD_MAC_AFTER_PNP, 1); 1739 zyd_read16_m(sc, ZYD_FIRMWARE_BASE_ADDR, &sc->sc_fwbase); 1740 DPRINTF(sc, ZYD_DEBUG_FW, "firmware base address=0x%04x\n", 1741 sc->sc_fwbase); 1742 1743 /* retrieve firmware revision number */ 1744 zyd_read16_m(sc, sc->sc_fwbase + ZYD_FW_FIRMWARE_REV, &sc->sc_fwrev); 1745 zyd_write32_m(sc, ZYD_CR_GPI_EN, 0); 1746 zyd_write32_m(sc, ZYD_MAC_CONT_WIN_LIMIT, 0x7f043f); 1747 /* set mandatory rates - XXX assumes 802.11b/g */ 1748 zyd_write32_m(sc, ZYD_MAC_MAN_RATE, 0x150f); 1749 1750 /* disable interrupts */ 1751 zyd_write32_m(sc, ZYD_CR_INTERRUPT, 0); 1752 1753 if ((error = zyd_read_pod(sc)) != 0) { 1754 device_printf(sc->sc_dev, "could not read EEPROM\n"); 1755 goto fail; 1756 } 1757 1758 /* PHY init (resetting) */ 1759 error = zyd_lock_phy(sc); 1760 if (error != 0) 1761 goto fail; 1762 phyp = (sc->sc_macrev == ZYD_ZD1211B) ? zyd_def_phyB : zyd_def_phy; 1763 for (; phyp->reg != 0; phyp++) 1764 zyd_write16_m(sc, phyp->reg, phyp->val); 1765 if (sc->sc_macrev == ZYD_ZD1211 && sc->sc_fix_cr157 != 0) { 1766 zyd_read16_m(sc, ZYD_EEPROM_PHY_REG, &val); 1767 zyd_write32_m(sc, ZYD_CR157, val >> 8); 1768 } 1769 error = zyd_unlock_phy(sc); 1770 if (error != 0) 1771 goto fail; 1772 1773 /* HMAC init */ 1774 zyd_write32_m(sc, ZYD_MAC_ACK_EXT, 0x00000020); 1775 zyd_write32_m(sc, ZYD_CR_ADDA_MBIAS_WT, 0x30000808); 1776 zyd_write32_m(sc, ZYD_MAC_SNIFFER, 0x00000000); 1777 zyd_write32_m(sc, ZYD_MAC_RXFILTER, 0x00000000); 1778 zyd_write32_m(sc, ZYD_MAC_GHTBL, 0x00000000); 1779 zyd_write32_m(sc, ZYD_MAC_GHTBH, 0x80000000); 1780 zyd_write32_m(sc, ZYD_MAC_MISC, 0x000000a4); 1781 zyd_write32_m(sc, ZYD_CR_ADDA_PWR_DWN, 0x0000007f); 1782 zyd_write32_m(sc, ZYD_MAC_BCNCFG, 0x00f00401); 1783 zyd_write32_m(sc, ZYD_MAC_PHY_DELAY2, 0x00000000); 1784 zyd_write32_m(sc, ZYD_MAC_ACK_EXT, 0x00000080); 1785 zyd_write32_m(sc, ZYD_CR_ADDA_PWR_DWN, 0x00000000); 1786 zyd_write32_m(sc, ZYD_MAC_SIFS_ACK_TIME, 0x00000100); 1787 zyd_write32_m(sc, ZYD_CR_RX_PE_DELAY, 0x00000070); 1788 zyd_write32_m(sc, ZYD_CR_PS_CTRL, 0x10000000); 1789 zyd_write32_m(sc, ZYD_MAC_RTSCTSRATE, 0x02030203); 1790 zyd_write32_m(sc, ZYD_MAC_AFTER_PNP, 1); 1791 zyd_write32_m(sc, ZYD_MAC_BACKOFF_PROTECT, 0x00000114); 1792 zyd_write32_m(sc, ZYD_MAC_DIFS_EIFS_SIFS, 0x0a47c032); 1793 zyd_write32_m(sc, ZYD_MAC_CAM_MODE, 0x3); 1794 1795 if (sc->sc_macrev == ZYD_ZD1211) { 1796 zyd_write32_m(sc, ZYD_MAC_RETRY, 0x00000002); 1797 zyd_write32_m(sc, ZYD_MAC_RX_THRESHOLD, 0x000c0640); 1798 } else { 1799 zyd_write32_m(sc, ZYD_MACB_MAX_RETRY, 0x02020202); 1800 zyd_write32_m(sc, ZYD_MACB_TXPWR_CTL4, 0x007f003f); 1801 zyd_write32_m(sc, ZYD_MACB_TXPWR_CTL3, 0x007f003f); 1802 zyd_write32_m(sc, ZYD_MACB_TXPWR_CTL2, 0x003f001f); 1803 zyd_write32_m(sc, ZYD_MACB_TXPWR_CTL1, 0x001f000f); 1804 zyd_write32_m(sc, ZYD_MACB_AIFS_CTL1, 0x00280028); 1805 zyd_write32_m(sc, ZYD_MACB_AIFS_CTL2, 0x008C003C); 1806 zyd_write32_m(sc, ZYD_MACB_TXOP, 0x01800824); 1807 zyd_write32_m(sc, ZYD_MAC_RX_THRESHOLD, 0x000c0eff); 1808 } 1809 1810 /* init beacon interval to 100ms */ 1811 if ((error = zyd_set_beacon_interval(sc, 100)) != 0) 1812 goto fail; 1813 1814 if ((error = zyd_rf_attach(sc, sc->sc_rfrev)) != 0) { 1815 device_printf(sc->sc_dev, "could not attach RF, rev 0x%x\n", 1816 sc->sc_rfrev); 1817 goto fail; 1818 } 1819 1820 /* RF chip init */ 1821 error = zyd_lock_phy(sc); 1822 if (error != 0) 1823 goto fail; 1824 error = (*rf->init)(rf); 1825 if (error != 0) { 1826 device_printf(sc->sc_dev, 1827 "radio initialization failed, error %d\n", error); 1828 goto fail; 1829 } 1830 error = zyd_unlock_phy(sc); 1831 if (error != 0) 1832 goto fail; 1833 1834 if ((error = zyd_read_eeprom(sc)) != 0) { 1835 device_printf(sc->sc_dev, "could not read EEPROM\n"); 1836 goto fail; 1837 } 1838 1839fail: return (error); 1840} 1841 1842static int 1843zyd_read_pod(struct zyd_softc *sc) 1844{ 1845 int error; 1846 uint32_t tmp; 1847 1848 zyd_read32_m(sc, ZYD_EEPROM_POD, &tmp); 1849 sc->sc_rfrev = tmp & 0x0f; 1850 sc->sc_ledtype = (tmp >> 4) & 0x01; 1851 sc->sc_al2230s = (tmp >> 7) & 0x01; 1852 sc->sc_cckgain = (tmp >> 8) & 0x01; 1853 sc->sc_fix_cr157 = (tmp >> 13) & 0x01; 1854 sc->sc_parev = (tmp >> 16) & 0x0f; 1855 sc->sc_bandedge6 = (tmp >> 21) & 0x01; 1856 sc->sc_newphy = (tmp >> 31) & 0x01; 1857 sc->sc_txled = ((tmp & (1 << 24)) && (tmp & (1 << 29))) ? 0 : 1; 1858fail: 1859 return (error); 1860} 1861 1862static int 1863zyd_read_eeprom(struct zyd_softc *sc) 1864{ 1865 uint16_t val; 1866 int error, i; 1867 1868 /* read Tx power calibration tables */ 1869 for (i = 0; i < 7; i++) { 1870 zyd_read16_m(sc, ZYD_EEPROM_PWR_CAL + i, &val); 1871 sc->sc_pwrcal[i * 2] = val >> 8; 1872 sc->sc_pwrcal[i * 2 + 1] = val & 0xff; 1873 zyd_read16_m(sc, ZYD_EEPROM_PWR_INT + i, &val); 1874 sc->sc_pwrint[i * 2] = val >> 8; 1875 sc->sc_pwrint[i * 2 + 1] = val & 0xff; 1876 zyd_read16_m(sc, ZYD_EEPROM_36M_CAL + i, &val); 1877 sc->sc_ofdm36_cal[i * 2] = val >> 8; 1878 sc->sc_ofdm36_cal[i * 2 + 1] = val & 0xff; 1879 zyd_read16_m(sc, ZYD_EEPROM_48M_CAL + i, &val); 1880 sc->sc_ofdm48_cal[i * 2] = val >> 8; 1881 sc->sc_ofdm48_cal[i * 2 + 1] = val & 0xff; 1882 zyd_read16_m(sc, ZYD_EEPROM_54M_CAL + i, &val); 1883 sc->sc_ofdm54_cal[i * 2] = val >> 8; 1884 sc->sc_ofdm54_cal[i * 2 + 1] = val & 0xff; 1885 } 1886fail: 1887 return (error); 1888} 1889 1890static int 1891zyd_get_macaddr(struct zyd_softc *sc) 1892{ 1893 struct usb2_device_request req; 1894 usb2_error_t error; 1895 1896 req.bmRequestType = UT_READ_VENDOR_DEVICE; 1897 req.bRequest = ZYD_READFWDATAREQ; 1898 USETW(req.wValue, ZYD_EEPROM_MAC_ADDR_P1); 1899 USETW(req.wIndex, 0); 1900 USETW(req.wLength, IEEE80211_ADDR_LEN); 1901 1902 ZYD_LOCK(sc); 1903 error = usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, sc->sc_bssid); 1904 if (error != 0) { 1905 device_printf(sc->sc_dev, "could not read EEPROM: %s\n", 1906 usb2_errstr(error)); 1907 } 1908 ZYD_UNLOCK(sc); 1909 1910 return (error); 1911} 1912 1913static int 1914zyd_set_macaddr(struct zyd_softc *sc, const uint8_t *addr) 1915{ 1916 int error; 1917 uint32_t tmp; 1918 1919 tmp = addr[3] << 24 | addr[2] << 16 | addr[1] << 8 | addr[0]; 1920 zyd_write32_m(sc, ZYD_MAC_MACADRL, tmp); 1921 tmp = addr[5] << 8 | addr[4]; 1922 zyd_write32_m(sc, ZYD_MAC_MACADRH, tmp); 1923fail: 1924 return (error); 1925} 1926 1927static int 1928zyd_set_bssid(struct zyd_softc *sc, const uint8_t *addr) 1929{ 1930 int error; 1931 uint32_t tmp; 1932 1933 tmp = addr[3] << 24 | addr[2] << 16 | addr[1] << 8 | addr[0]; 1934 zyd_write32_m(sc, ZYD_MAC_BSSADRL, tmp); 1935 tmp = addr[5] << 8 | addr[4]; 1936 zyd_write32_m(sc, ZYD_MAC_BSSADRH, tmp); 1937fail: 1938 return (error); 1939} 1940 1941static int 1942zyd_switch_radio(struct zyd_softc *sc, int on) 1943{ 1944 struct zyd_rf *rf = &sc->sc_rf; 1945 int error; 1946 1947 error = zyd_lock_phy(sc); 1948 if (error != 0) 1949 goto fail; 1950 error = (*rf->switch_radio)(rf, on); 1951 if (error != 0) 1952 goto fail; 1953 error = zyd_unlock_phy(sc); 1954fail: 1955 return (error); 1956} 1957 1958static int 1959zyd_set_led(struct zyd_softc *sc, int which, int on) 1960{ 1961 int error; 1962 uint32_t tmp; 1963 1964 zyd_read32_m(sc, ZYD_MAC_TX_PE_CONTROL, &tmp); 1965 tmp &= ~which; 1966 if (on) 1967 tmp |= which; 1968 zyd_write32_m(sc, ZYD_MAC_TX_PE_CONTROL, tmp); 1969fail: 1970 return (error); 1971} 1972 1973static void 1974zyd_multitask(struct usb2_proc_msg *pm) 1975{ 1976 struct zyd_task *task = (struct zyd_task *)pm; 1977 struct zyd_softc *sc = task->sc; 1978 1979 zyd_set_multi(sc); 1980} 1981 1982static void 1983zyd_set_multi(struct zyd_softc *sc) 1984{ 1985 int error; 1986 struct ifnet *ifp = sc->sc_ifp; 1987 struct ieee80211com *ic = ifp->if_l2com; 1988 struct ifmultiaddr *ifma; 1989 uint32_t low, high; 1990 uint8_t v; 1991 1992 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 1993 return; 1994 1995 low = 0x00000000; 1996 high = 0x80000000; 1997 1998 if (ic->ic_opmode == IEEE80211_M_MONITOR || 1999 (ifp->if_flags & (IFF_ALLMULTI | IFF_PROMISC))) { 2000 low = 0xffffffff; 2001 high = 0xffffffff; 2002 } else { 2003 IF_ADDR_LOCK(ifp); 2004 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 2005 if (ifma->ifma_addr->sa_family != AF_LINK) 2006 continue; 2007 v = ((uint8_t *)LLADDR((struct sockaddr_dl *) 2008 ifma->ifma_addr))[5] >> 2; 2009 if (v < 32) 2010 low |= 1 << v; 2011 else 2012 high |= 1 << (v - 32); 2013 } 2014 IF_ADDR_UNLOCK(ifp); 2015 } 2016 2017 /* reprogram multicast global hash table */ 2018 zyd_write32_m(sc, ZYD_MAC_GHTBL, low); 2019 zyd_write32_m(sc, ZYD_MAC_GHTBH, high); 2020fail: 2021 if (error != 0) 2022 device_printf(sc->sc_dev, 2023 "could not set multicast hash table\n"); 2024} 2025 2026static void 2027zyd_update_mcast(struct ifnet *ifp) 2028{ 2029 struct zyd_softc *sc = ifp->if_softc; 2030 2031 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) 2032 return; 2033 2034 ZYD_LOCK(sc); 2035 zyd_queue_command(sc, zyd_multitask, 2036 &sc->sc_mcasttask[0].hdr, &sc->sc_mcasttask[1].hdr); 2037 ZYD_UNLOCK(sc); 2038} 2039 2040static int 2041zyd_set_rxfilter(struct zyd_softc *sc) 2042{ 2043 struct ifnet *ifp = sc->sc_ifp; 2044 struct ieee80211com *ic = ifp->if_l2com; 2045 uint32_t rxfilter; 2046 2047 switch (ic->ic_opmode) { 2048 case IEEE80211_M_STA: 2049 rxfilter = ZYD_FILTER_BSS; 2050 break; 2051 case IEEE80211_M_IBSS: 2052 case IEEE80211_M_HOSTAP: 2053 rxfilter = ZYD_FILTER_HOSTAP; 2054 break; 2055 case IEEE80211_M_MONITOR: 2056 rxfilter = ZYD_FILTER_MONITOR; 2057 break; 2058 default: 2059 /* should not get there */ 2060 return (EINVAL); 2061 } 2062 return zyd_write32(sc, ZYD_MAC_RXFILTER, rxfilter); 2063} 2064 2065static void 2066zyd_set_chan(struct zyd_softc *sc, struct ieee80211_channel *c) 2067{ 2068 int error; 2069 struct ifnet *ifp = sc->sc_ifp; 2070 struct ieee80211com *ic = ifp->if_l2com; 2071 struct zyd_rf *rf = &sc->sc_rf; 2072 uint32_t tmp; 2073 u_int chan; 2074 2075 chan = ieee80211_chan2ieee(ic, c); 2076 if (chan == 0 || chan == IEEE80211_CHAN_ANY) { 2077 /* XXX should NEVER happen */ 2078 device_printf(sc->sc_dev, 2079 "%s: invalid channel %x\n", __func__, chan); 2080 return; 2081 } 2082 2083 error = zyd_lock_phy(sc); 2084 if (error != 0) 2085 goto fail; 2086 2087 error = (*rf->set_channel)(rf, chan); 2088 if (error != 0) 2089 goto fail; 2090 2091 /* update Tx power */ 2092 zyd_write16_m(sc, ZYD_CR31, sc->sc_pwrint[chan - 1]); 2093 2094 if (sc->sc_macrev == ZYD_ZD1211B) { 2095 zyd_write16_m(sc, ZYD_CR67, sc->sc_ofdm36_cal[chan - 1]); 2096 zyd_write16_m(sc, ZYD_CR66, sc->sc_ofdm48_cal[chan - 1]); 2097 zyd_write16_m(sc, ZYD_CR65, sc->sc_ofdm54_cal[chan - 1]); 2098 zyd_write16_m(sc, ZYD_CR68, sc->sc_pwrcal[chan - 1]); 2099 zyd_write16_m(sc, ZYD_CR69, 0x28); 2100 zyd_write16_m(sc, ZYD_CR69, 0x2a); 2101 } 2102 if (sc->sc_cckgain) { 2103 /* set CCK baseband gain from EEPROM */ 2104 if (zyd_read32(sc, ZYD_EEPROM_PHY_REG, &tmp) == 0) 2105 zyd_write16_m(sc, ZYD_CR47, tmp & 0xff); 2106 } 2107 if (sc->sc_bandedge6 && rf->bandedge6 != NULL) { 2108 error = (*rf->bandedge6)(rf, c); 2109 if (error != 0) 2110 goto fail; 2111 } 2112 zyd_write32_m(sc, ZYD_CR_CONFIG_PHILIPS, 0); 2113 2114 error = zyd_unlock_phy(sc); 2115 if (error != 0) 2116 goto fail; 2117 2118 sc->sc_rxtap.wr_chan_freq = sc->sc_txtap.wt_chan_freq = 2119 htole16(c->ic_freq); 2120 sc->sc_rxtap.wr_chan_flags = sc->sc_txtap.wt_chan_flags = 2121 htole16(c->ic_flags); 2122fail: 2123 return; 2124} 2125 2126static int 2127zyd_set_beacon_interval(struct zyd_softc *sc, int bintval) 2128{ 2129 int error; 2130 uint32_t val; 2131 2132 zyd_read32_m(sc, ZYD_CR_ATIM_WND_PERIOD, &val); 2133 sc->sc_atim_wnd = val; 2134 zyd_read32_m(sc, ZYD_CR_PRE_TBTT, &val); 2135 sc->sc_pre_tbtt = val; 2136 sc->sc_bcn_int = bintval; 2137 2138 if (sc->sc_bcn_int <= 5) 2139 sc->sc_bcn_int = 5; 2140 if (sc->sc_pre_tbtt < 4 || sc->sc_pre_tbtt >= sc->sc_bcn_int) 2141 sc->sc_pre_tbtt = sc->sc_bcn_int - 1; 2142 if (sc->sc_atim_wnd >= sc->sc_pre_tbtt) 2143 sc->sc_atim_wnd = sc->sc_pre_tbtt - 1; 2144 2145 zyd_write32_m(sc, ZYD_CR_ATIM_WND_PERIOD, sc->sc_atim_wnd); 2146 zyd_write32_m(sc, ZYD_CR_PRE_TBTT, sc->sc_pre_tbtt); 2147 zyd_write32_m(sc, ZYD_CR_BCN_INTERVAL, sc->sc_bcn_int); 2148fail: 2149 return (error); 2150} 2151 2152static void 2153zyd_rx_data(struct usb2_xfer *xfer, int offset, uint16_t len) 2154{ 2155 struct zyd_softc *sc = xfer->priv_sc; 2156 struct ifnet *ifp = sc->sc_ifp; 2157 struct zyd_plcphdr plcp; 2158 struct zyd_rx_stat stat; 2159 struct mbuf *m; 2160 int rlen, rssi; 2161 2162 if (len < ZYD_MIN_FRAGSZ) { 2163 DPRINTF(sc, ZYD_DEBUG_RECV, "%s: frame too short (length=%d)\n", 2164 device_get_nameunit(sc->sc_dev), len); 2165 ifp->if_ierrors++; 2166 return; 2167 } 2168 usb2_copy_out(xfer->frbuffers, offset, &plcp, sizeof(plcp)); 2169 usb2_copy_out(xfer->frbuffers, offset + len - sizeof(stat), 2170 &stat, sizeof(stat)); 2171 2172 if (stat.flags & ZYD_RX_ERROR) { 2173 DPRINTF(sc, ZYD_DEBUG_RECV, 2174 "%s: RX status indicated error (%x)\n", 2175 device_get_nameunit(sc->sc_dev), stat.flags); 2176 ifp->if_ierrors++; 2177 return; 2178 } 2179 2180 /* compute actual frame length */ 2181 rlen = len - sizeof(struct zyd_plcphdr) - 2182 sizeof(struct zyd_rx_stat) - IEEE80211_CRC_LEN; 2183 2184 /* allocate a mbuf to store the frame */ 2185 if (rlen > MCLBYTES) { 2186 DPRINTF(sc, ZYD_DEBUG_RECV, "%s: frame too long (length=%d)\n", 2187 device_get_nameunit(sc->sc_dev), rlen); 2188 ifp->if_ierrors++; 2189 return; 2190 } else if (rlen > MHLEN) 2191 m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 2192 else 2193 m = m_gethdr(M_DONTWAIT, MT_DATA); 2194 if (m == NULL) { 2195 DPRINTF(sc, ZYD_DEBUG_RECV, "%s: could not allocate rx mbuf\n", 2196 device_get_nameunit(sc->sc_dev)); 2197 ifp->if_ierrors++; 2198 return; 2199 } 2200 m->m_pkthdr.rcvif = ifp; 2201 m->m_pkthdr.len = m->m_len = rlen; 2202 usb2_copy_out(xfer->frbuffers, offset + sizeof(plcp), 2203 mtod(m, uint8_t *), rlen); 2204 2205 if (bpf_peers_present(ifp->if_bpf)) { 2206 struct zyd_rx_radiotap_header *tap = &sc->sc_rxtap; 2207 2208 tap->wr_flags = 0; 2209 if (stat.flags & (ZYD_RX_BADCRC16 | ZYD_RX_BADCRC32)) 2210 tap->wr_flags |= IEEE80211_RADIOTAP_F_BADFCS; 2211 /* XXX toss, no way to express errors */ 2212 if (stat.flags & ZYD_RX_DECRYPTERR) 2213 tap->wr_flags |= IEEE80211_RADIOTAP_F_BADFCS; 2214 tap->wr_rate = ieee80211_plcp2rate(plcp.signal, 2215 (stat.flags & ZYD_RX_OFDM) ? 2216 IEEE80211_T_OFDM : IEEE80211_T_CCK); 2217 tap->wr_antsignal = stat.rssi + -95; 2218 tap->wr_antnoise = -95; /* XXX */ 2219 2220 bpf_mtap2(ifp->if_bpf, tap, sc->sc_rxtap_len, m); 2221 } 2222 rssi = (stat.rssi > 63) ? 127 : 2 * stat.rssi; 2223 2224 sc->sc_rx_data[sc->sc_rx_count].rssi = rssi; 2225 sc->sc_rx_data[sc->sc_rx_count].m = m; 2226 sc->sc_rx_count++; 2227} 2228 2229static void 2230zyd_bulk_read_callback(struct usb2_xfer *xfer) 2231{ 2232 struct zyd_softc *sc = xfer->priv_sc; 2233 struct ifnet *ifp = sc->sc_ifp; 2234 struct ieee80211com *ic = ifp->if_l2com; 2235 struct ieee80211_node *ni; 2236 struct zyd_rx_desc desc; 2237 struct mbuf *m; 2238 uint32_t offset; 2239 uint8_t rssi; 2240 int8_t nf; 2241 int i; 2242 2243 sc->sc_rx_count = 0; 2244 switch (USB_GET_STATE(xfer)) { 2245 case USB_ST_TRANSFERRED: 2246 usb2_copy_out(xfer->frbuffers, xfer->actlen - sizeof(desc), 2247 &desc, sizeof(desc)); 2248 2249 offset = 0; 2250 if (UGETW(desc.tag) == ZYD_TAG_MULTIFRAME) { 2251 DPRINTF(sc, ZYD_DEBUG_RECV, 2252 "%s: received multi-frame transfer\n", __func__); 2253 2254 for (i = 0; i < ZYD_MAX_RXFRAMECNT; i++) { 2255 uint16_t len16 = UGETW(desc.len[i]); 2256 2257 if (len16 == 0 || len16 > xfer->actlen) 2258 break; 2259 2260 zyd_rx_data(xfer, offset, len16); 2261 2262 /* next frame is aligned on a 32-bit boundary */ 2263 len16 = (len16 + 3) & ~3; 2264 offset += len16; 2265 if (len16 > xfer->actlen) 2266 break; 2267 xfer->actlen -= len16; 2268 } 2269 } else { 2270 DPRINTF(sc, ZYD_DEBUG_RECV, 2271 "%s: received single-frame transfer\n", __func__); 2272 2273 zyd_rx_data(xfer, 0, xfer->actlen); 2274 } 2275 /* FALLTHROUGH */ 2276 case USB_ST_SETUP: 2277tr_setup: 2278 xfer->frlengths[0] = xfer->max_data_length; 2279 usb2_start_hardware(xfer); 2280 2281 /* 2282 * At the end of a USB callback it is always safe to unlock 2283 * the private mutex of a device! That is why we do the 2284 * "ieee80211_input" here, and not some lines up! 2285 */ 2286 ZYD_UNLOCK(sc); 2287 for (i = 0; i < sc->sc_rx_count; i++) { 2288 rssi = sc->sc_rx_data[i].rssi; 2289 m = sc->sc_rx_data[i].m; 2290 sc->sc_rx_data[i].m = NULL; 2291 2292 nf = -95; /* XXX */ 2293 2294 ni = ieee80211_find_rxnode(ic, 2295 mtod(m, struct ieee80211_frame_min *)); 2296 if (ni != NULL) { 2297 (void)ieee80211_input(ni, m, rssi, nf, 0); 2298 ieee80211_free_node(ni); 2299 } else 2300 (void)ieee80211_input_all(ic, m, rssi, nf, 0); 2301 } 2302 ZYD_LOCK(sc); 2303 break; 2304 2305 default: /* Error */ 2306 DPRINTF(sc, ZYD_DEBUG_ANY, "frame error: %s\n", usb2_errstr(xfer->error)); 2307 2308 if (xfer->error != USB_ERR_CANCELLED) { 2309 /* try to clear stall first */ 2310 xfer->flags.stall_pipe = 1; 2311 goto tr_setup; 2312 } 2313 break; 2314 } 2315} 2316 2317static uint8_t 2318zyd_plcp_signal(int rate) 2319{ 2320 switch (rate) { 2321 /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */ 2322 case 12: 2323 return (0xb); 2324 case 18: 2325 return (0xf); 2326 case 24: 2327 return (0xa); 2328 case 36: 2329 return (0xe); 2330 case 48: 2331 return (0x9); 2332 case 72: 2333 return (0xd); 2334 case 96: 2335 return (0x8); 2336 case 108: 2337 return (0xc); 2338 /* CCK rates (NB: not IEEE std, device-specific) */ 2339 case 2: 2340 return (0x0); 2341 case 4: 2342 return (0x1); 2343 case 11: 2344 return (0x2); 2345 case 22: 2346 return (0x3); 2347 } 2348 return (0xff); /* XXX unsupported/unknown rate */ 2349} 2350 2351static int 2352zyd_tx_mgt(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) 2353{ 2354 struct ieee80211vap *vap = ni->ni_vap; 2355 struct ieee80211com *ic = ni->ni_ic; 2356 struct ifnet *ifp = sc->sc_ifp; 2357 struct zyd_tx_desc *desc; 2358 struct zyd_tx_data *data; 2359 struct ieee80211_frame *wh; 2360 struct ieee80211_key *k; 2361 int rate, totlen; 2362 uint16_t pktlen; 2363 2364 data = STAILQ_FIRST(&sc->tx_free); 2365 STAILQ_REMOVE_HEAD(&sc->tx_free, next); 2366 sc->tx_nfree--; 2367 desc = &data->desc; 2368 2369 rate = IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan) ? 12 : 2; 2370 2371 wh = mtod(m0, struct ieee80211_frame *); 2372 2373 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 2374 k = ieee80211_crypto_encap(ni, m0); 2375 if (k == NULL) { 2376 m_freem(m0); 2377 return (ENOBUFS); 2378 } 2379 } 2380 2381 data->ni = ni; 2382 data->m = m0; 2383 data->rate = rate; 2384 2385 wh = mtod(m0, struct ieee80211_frame *); 2386 2387 totlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN; 2388 2389 /* fill Tx descriptor */ 2390 desc->len = htole16(totlen); 2391 2392 desc->flags = ZYD_TX_FLAG_BACKOFF; 2393 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { 2394 /* multicast frames are not sent at OFDM rates in 802.11b/g */ 2395 if (totlen > vap->iv_rtsthreshold) { 2396 desc->flags |= ZYD_TX_FLAG_RTS; 2397 } else if (ZYD_RATE_IS_OFDM(rate) && 2398 (ic->ic_flags & IEEE80211_F_USEPROT)) { 2399 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 2400 desc->flags |= ZYD_TX_FLAG_CTS_TO_SELF; 2401 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 2402 desc->flags |= ZYD_TX_FLAG_RTS; 2403 } 2404 } else 2405 desc->flags |= ZYD_TX_FLAG_MULTICAST; 2406 2407 if ((wh->i_fc[0] & 2408 (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == 2409 (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL)) 2410 desc->flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL); 2411 2412 desc->phy = zyd_plcp_signal(rate); 2413 if (ZYD_RATE_IS_OFDM(rate)) { 2414 desc->phy |= ZYD_TX_PHY_OFDM; 2415 if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) 2416 desc->phy |= ZYD_TX_PHY_5GHZ; 2417 } else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) 2418 desc->phy |= ZYD_TX_PHY_SHPREAMBLE; 2419 2420 /* actual transmit length (XXX why +10?) */ 2421 pktlen = ZYD_TX_DESC_SIZE + 10; 2422 if (sc->sc_macrev == ZYD_ZD1211) 2423 pktlen += totlen; 2424 desc->pktlen = htole16(pktlen); 2425 2426 desc->plcp_length = (16 * totlen + rate - 1) / rate; 2427 desc->plcp_service = 0; 2428 if (rate == 22) { 2429 const int remainder = (16 * totlen) % 22; 2430 if (remainder != 0 && remainder < 7) 2431 desc->plcp_service |= ZYD_PLCP_LENGEXT; 2432 } 2433 2434 if (bpf_peers_present(ifp->if_bpf)) { 2435 struct zyd_tx_radiotap_header *tap = &sc->sc_txtap; 2436 2437 tap->wt_flags = 0; 2438 tap->wt_rate = rate; 2439 2440 bpf_mtap2(ifp->if_bpf, tap, sc->sc_txtap_len, m0); 2441 } 2442 2443 DPRINTF(sc, ZYD_DEBUG_XMIT, 2444 "%s: sending mgt frame len=%zu rate=%u\n", 2445 device_get_nameunit(sc->sc_dev), (size_t)m0->m_pkthdr.len, 2446 rate); 2447 2448 STAILQ_INSERT_TAIL(&sc->tx_q, data, next); 2449 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_WR]); 2450 2451 return (0); 2452} 2453 2454static void 2455zyd_bulk_write_callback(struct usb2_xfer *xfer) 2456{ 2457 struct zyd_softc *sc = xfer->priv_sc; 2458 struct ifnet *ifp = sc->sc_ifp; 2459 struct ieee80211com *ic = ifp->if_l2com; 2460 struct ieee80211_channel *c = ic->ic_curchan; 2461 struct zyd_tx_data *data; 2462 struct mbuf *m; 2463 2464 switch (USB_GET_STATE(xfer)) { 2465 case USB_ST_TRANSFERRED: 2466 DPRINTF(sc, ZYD_DEBUG_ANY, "transfer complete, %u bytes\n", 2467 xfer->actlen); 2468 2469 /* free resources */ 2470 data = xfer->priv_fifo; 2471 zyd_tx_free(data, 0); 2472 xfer->priv_fifo = NULL; 2473 2474 ifp->if_opackets++; 2475 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 2476 2477 /* FALLTHROUGH */ 2478 case USB_ST_SETUP: 2479tr_setup: 2480#if 0 2481 if (sc->sc_flags & ZYD_FLAG_WAIT_COMMAND) { 2482 /* 2483 * don't send anything while a command is pending ! 2484 */ 2485 DPRINTF(sc, ZYD_DEBUG_ANY, "wait command\n"); 2486 break; 2487 } 2488#endif 2489 2490 data = STAILQ_FIRST(&sc->tx_q); 2491 if (data) { 2492 STAILQ_REMOVE_HEAD(&sc->tx_q, next); 2493 m = data->m; 2494 2495 if (m->m_pkthdr.len > ZYD_MAX_TXBUFSZ) { 2496 DPRINTF(sc, ZYD_DEBUG_ANY, "data overflow, %u bytes\n", 2497 m->m_pkthdr.len); 2498 m->m_pkthdr.len = ZYD_MAX_TXBUFSZ; 2499 } 2500 usb2_copy_in(xfer->frbuffers, 0, &data->desc, 2501 ZYD_TX_DESC_SIZE); 2502 usb2_m_copy_in(xfer->frbuffers, ZYD_TX_DESC_SIZE, m, 0, 2503 m->m_pkthdr.len); 2504 2505 if (bpf_peers_present(ifp->if_bpf)) { 2506 struct zyd_tx_radiotap_header *tap = &sc->sc_txtap; 2507 2508 tap->wt_flags = 0; 2509 tap->wt_rate = data->rate; 2510 tap->wt_chan_freq = htole16(c->ic_freq); 2511 tap->wt_chan_flags = htole16(c->ic_flags); 2512 2513 bpf_mtap2(ifp->if_bpf, tap, sc->sc_txtap_len, m); 2514 } 2515 2516 xfer->frlengths[0] = ZYD_TX_DESC_SIZE + m->m_pkthdr.len; 2517 xfer->priv_fifo = data; 2518 usb2_start_hardware(xfer); 2519 } 2520 break; 2521 2522 default: /* Error */ 2523 DPRINTF(sc, ZYD_DEBUG_ANY, "transfer error, %s\n", 2524 usb2_errstr(xfer->error)); 2525 2526 if (xfer->error == USB_ERR_STALLED) { 2527 /* try to clear stall first */ 2528 xfer->flags.stall_pipe = 1; 2529 goto tr_setup; 2530 } 2531 if (xfer->error == USB_ERR_TIMEOUT) 2532 device_printf(sc->sc_dev, "device timeout\n"); 2533 2534 ifp->if_oerrors++; 2535 data = xfer->priv_fifo; 2536 xfer->priv_fifo = NULL; 2537 if (data != NULL && ifp->if_drv_flags & IFF_DRV_RUNNING) 2538 zyd_tx_free(data, xfer->error); 2539 break; 2540 } 2541} 2542 2543static int 2544zyd_tx_data(struct zyd_softc *sc, struct mbuf *m0, struct ieee80211_node *ni) 2545{ 2546 struct ieee80211vap *vap = ni->ni_vap; 2547 struct ieee80211com *ic = ni->ni_ic; 2548 struct zyd_tx_desc *desc; 2549 struct zyd_tx_data *data; 2550 struct ieee80211_frame *wh; 2551 const struct ieee80211_txparam *tp; 2552 struct ieee80211_key *k; 2553 int rate, totlen; 2554 uint16_t pktlen; 2555 2556 wh = mtod(m0, struct ieee80211_frame *); 2557 data = STAILQ_FIRST(&sc->tx_free); 2558 STAILQ_REMOVE_HEAD(&sc->tx_free, next); 2559 sc->tx_nfree--; 2560 desc = &data->desc; 2561 2562 desc->flags = ZYD_TX_FLAG_BACKOFF; 2563 tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)]; 2564 if (IEEE80211_IS_MULTICAST(wh->i_addr1)) { 2565 rate = tp->mcastrate; 2566 desc->flags |= ZYD_TX_FLAG_MULTICAST; 2567 } else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) { 2568 rate = tp->ucastrate; 2569 } else { 2570 (void) ieee80211_amrr_choose(ni, &ZYD_NODE(ni)->amn); 2571 rate = ni->ni_txrate; 2572 } 2573 2574 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 2575 k = ieee80211_crypto_encap(ni, m0); 2576 if (k == NULL) { 2577 m_freem(m0); 2578 return (ENOBUFS); 2579 } 2580 /* packet header may have moved, reset our local pointer */ 2581 wh = mtod(m0, struct ieee80211_frame *); 2582 } 2583 2584 data->ni = ni; 2585 data->m = m0; 2586 2587 totlen = m0->m_pkthdr.len + IEEE80211_CRC_LEN; 2588 2589 /* fill Tx descriptor */ 2590 desc->len = htole16(totlen); 2591 2592 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { 2593 /* multicast frames are not sent at OFDM rates in 802.11b/g */ 2594 if (totlen > vap->iv_rtsthreshold) { 2595 desc->flags |= ZYD_TX_FLAG_RTS; 2596 } else if (ZYD_RATE_IS_OFDM(rate) && 2597 (ic->ic_flags & IEEE80211_F_USEPROT)) { 2598 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 2599 desc->flags |= ZYD_TX_FLAG_CTS_TO_SELF; 2600 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 2601 desc->flags |= ZYD_TX_FLAG_RTS; 2602 } 2603 } 2604 2605 if ((wh->i_fc[0] & 2606 (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == 2607 (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL)) 2608 desc->flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL); 2609 2610 desc->phy = zyd_plcp_signal(rate); 2611 if (ZYD_RATE_IS_OFDM(rate)) { 2612 desc->phy |= ZYD_TX_PHY_OFDM; 2613 if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) 2614 desc->phy |= ZYD_TX_PHY_5GHZ; 2615 } else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) 2616 desc->phy |= ZYD_TX_PHY_SHPREAMBLE; 2617 2618 /* actual transmit length (XXX why +10?) */ 2619 pktlen = sizeof(struct zyd_tx_desc) + 10; 2620 if (sc->sc_macrev == ZYD_ZD1211) 2621 pktlen += totlen; 2622 desc->pktlen = htole16(pktlen); 2623 2624 desc->plcp_length = (16 * totlen + rate - 1) / rate; 2625 desc->plcp_service = 0; 2626 if (rate == 22) { 2627 const int remainder = (16 * totlen) % 22; 2628 if (remainder != 0 && remainder < 7) 2629 desc->plcp_service |= ZYD_PLCP_LENGEXT; 2630 } 2631 2632 DPRINTF(sc, ZYD_DEBUG_XMIT, 2633 "%s: sending data frame len=%zu rate=%u\n", 2634 device_get_nameunit(sc->sc_dev), (size_t)m0->m_pkthdr.len, 2635 rate); 2636 2637 STAILQ_INSERT_TAIL(&sc->tx_q, data, next); 2638 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_WR]); 2639 2640 return (0); 2641} 2642 2643static void 2644zyd_start(struct ifnet *ifp) 2645{ 2646 struct zyd_softc *sc = ifp->if_softc; 2647 struct ieee80211_node *ni; 2648 struct mbuf *m; 2649 2650 ZYD_LOCK(sc); 2651 for (;;) { 2652 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 2653 if (m == NULL) 2654 break; 2655 if (sc->tx_nfree == 0) { 2656 IFQ_DRV_PREPEND(&ifp->if_snd, m); 2657 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 2658 break; 2659 } 2660 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 2661 m = ieee80211_encap(ni, m); 2662 if (m == NULL) { 2663 ieee80211_free_node(ni); 2664 ifp->if_oerrors++; 2665 continue; 2666 } 2667 if (zyd_tx_data(sc, m, ni) != 0) { 2668 ieee80211_free_node(ni); 2669 ifp->if_oerrors++; 2670 break; 2671 } 2672 } 2673 ZYD_UNLOCK(sc); 2674} 2675 2676static int 2677zyd_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 2678 const struct ieee80211_bpf_params *params) 2679{ 2680 struct ieee80211com *ic = ni->ni_ic; 2681 struct ifnet *ifp = ic->ic_ifp; 2682 struct zyd_softc *sc = ifp->if_softc; 2683 2684 ZYD_LOCK(sc); 2685 /* prevent management frames from being sent if we're not ready */ 2686 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { 2687 ZYD_UNLOCK(sc); 2688 m_freem(m); 2689 ieee80211_free_node(ni); 2690 return (ENETDOWN); 2691 } 2692 if (sc->tx_nfree == 0) { 2693 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 2694 ZYD_UNLOCK(sc); 2695 m_freem(m); 2696 ieee80211_free_node(ni); 2697 return (ENOBUFS); /* XXX */ 2698 } 2699 2700 /* 2701 * Legacy path; interpret frame contents to decide 2702 * precisely how to send the frame. 2703 * XXX raw path 2704 */ 2705 if (zyd_tx_mgt(sc, m, ni) != 0) { 2706 ZYD_UNLOCK(sc); 2707 ifp->if_oerrors++; 2708 ieee80211_free_node(ni); 2709 return (EIO); 2710 } 2711 ZYD_UNLOCK(sc); 2712 return (0); 2713} 2714 2715static int 2716zyd_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 2717{ 2718 struct zyd_softc *sc = ifp->if_softc; 2719 struct ieee80211com *ic = ifp->if_l2com; 2720 struct ifreq *ifr = (struct ifreq *) data; 2721 int error = 0, startall = 0; 2722 2723 switch (cmd) { 2724 case SIOCSIFFLAGS: 2725 ZYD_LOCK(sc); 2726 if (ifp->if_flags & IFF_UP) { 2727 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2728 if ((ifp->if_flags ^ sc->sc_if_flags) & 2729 (IFF_ALLMULTI | IFF_PROMISC)) 2730 zyd_set_multi(sc); 2731 } else { 2732 zyd_init_locked(sc); 2733 startall = 1; 2734 } 2735 } else { 2736 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2737 zyd_stop(sc); 2738 } 2739 sc->sc_if_flags = ifp->if_flags; 2740 ZYD_UNLOCK(sc); 2741 if (startall) 2742 ieee80211_start_all(ic); 2743 break; 2744 case SIOCGIFMEDIA: 2745 error = ifmedia_ioctl(ifp, ifr, &ic->ic_media, cmd); 2746 break; 2747 case SIOCGIFADDR: 2748 error = ether_ioctl(ifp, cmd, data); 2749 break; 2750 default: 2751 error = EINVAL; 2752 break; 2753 } 2754 return (error); 2755} 2756 2757static void 2758zyd_init_locked(struct zyd_softc *sc) 2759{ 2760 int error; 2761 struct ifnet *ifp = sc->sc_ifp; 2762 struct ieee80211com *ic = ifp->if_l2com; 2763 struct usb2_config_descriptor *cd; 2764 uint32_t val; 2765 2766 ZYD_LOCK_ASSERT(sc, MA_OWNED); 2767 2768 if (sc->sc_flags & ZYD_FLAG_DETACHING) 2769 return; 2770 2771 if (!(sc->sc_flags & ZYD_FLAG_INITONCE)) { 2772 error = zyd_loadfirmware(sc); 2773 if (error != 0) { 2774 device_printf(sc->sc_dev, 2775 "could not load firmware (error=%d)\n", error); 2776 goto fail; 2777 } 2778 2779 /* reset device */ 2780 cd = usb2_get_config_descriptor(sc->sc_udev); 2781 error = usb2_req_set_config(sc->sc_udev, &sc->sc_mtx, 2782 cd->bConfigurationValue); 2783 if (error) 2784 device_printf(sc->sc_dev, "reset failed, continuing\n"); 2785 2786 error = zyd_hw_init(sc); 2787 if (error) { 2788 device_printf(sc->sc_dev, 2789 "hardware initialization failed\n"); 2790 goto fail; 2791 } 2792 2793 device_printf(sc->sc_dev, 2794 "HMAC ZD1211%s, FW %02x.%02x, RF %s S%x, PA%x LED %x " 2795 "BE%x NP%x Gain%x F%x\n", 2796 (sc->sc_macrev == ZYD_ZD1211) ? "": "B", 2797 sc->sc_fwrev >> 8, sc->sc_fwrev & 0xff, 2798 zyd_rf_name(sc->sc_rfrev), sc->sc_al2230s, sc->sc_parev, 2799 sc->sc_ledtype, sc->sc_bandedge6, sc->sc_newphy, 2800 sc->sc_cckgain, sc->sc_fix_cr157); 2801 2802 /* read regulatory domain (currently unused) */ 2803 zyd_read32_m(sc, ZYD_EEPROM_SUBID, &val); 2804 sc->sc_regdomain = val >> 16; 2805 DPRINTF(sc, ZYD_DEBUG_INIT, "regulatory domain %x\n", 2806 sc->sc_regdomain); 2807 2808 /* we'll do software WEP decryption for now */ 2809 DPRINTF(sc, ZYD_DEBUG_INIT, "%s: setting encryption type\n", 2810 __func__); 2811 zyd_write32_m(sc, ZYD_MAC_ENCRYPTION_TYPE, ZYD_ENC_SNIFFER); 2812 2813 sc->sc_flags |= ZYD_FLAG_INITONCE; 2814 } 2815 2816 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2817 zyd_stop(sc); 2818 2819 IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp)); 2820 DPRINTF(sc, ZYD_DEBUG_INIT, "setting MAC address to %s\n", 2821 ether_sprintf(ic->ic_myaddr)); 2822 error = zyd_set_macaddr(sc, ic->ic_myaddr); 2823 if (error != 0) 2824 return; 2825 2826 /* set basic rates */ 2827 if (ic->ic_curmode == IEEE80211_MODE_11B) 2828 zyd_write32_m(sc, ZYD_MAC_BAS_RATE, 0x0003); 2829 else if (ic->ic_curmode == IEEE80211_MODE_11A) 2830 zyd_write32_m(sc, ZYD_MAC_BAS_RATE, 0x1500); 2831 else /* assumes 802.11b/g */ 2832 zyd_write32_m(sc, ZYD_MAC_BAS_RATE, 0xff0f); 2833 2834 /* promiscuous mode */ 2835 zyd_write32_m(sc, ZYD_MAC_SNIFFER, 0); 2836 /* multicast setup */ 2837 zyd_set_multi(sc); 2838 /* set RX filter */ 2839 error = zyd_set_rxfilter(sc); 2840 if (error != 0) 2841 goto fail; 2842 2843 /* switch radio transmitter ON */ 2844 error = zyd_switch_radio(sc, 1); 2845 if (error != 0) 2846 goto fail; 2847 /* set default BSS channel */ 2848 zyd_set_chan(sc, ic->ic_curchan); 2849 2850 /* 2851 * Allocate Tx and Rx xfer queues. 2852 */ 2853 if ((error = zyd_alloc_tx_list(sc)) != 0) { 2854 device_printf(sc->sc_dev, "could not allocate Tx list\n"); 2855 goto fail; 2856 } 2857 2858 /* enable interrupts */ 2859 zyd_write32_m(sc, ZYD_CR_INTERRUPT, ZYD_HWINT_MASK); 2860 2861 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 2862 ifp->if_drv_flags |= IFF_DRV_RUNNING; 2863 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_RD]); 2864 usb2_transfer_start(sc->sc_xfer[ZYD_INTR_RD]); 2865 2866 return; 2867 2868fail: zyd_stop(sc); 2869 return; 2870} 2871 2872static void 2873zyd_init(void *priv) 2874{ 2875 struct zyd_softc *sc = priv; 2876 struct ifnet *ifp = sc->sc_ifp; 2877 struct ieee80211com *ic = ifp->if_l2com; 2878 2879 ZYD_LOCK(sc); 2880 zyd_init_locked(sc); 2881 ZYD_UNLOCK(sc); 2882 2883 if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2884 ieee80211_start_all(ic); /* start all vap's */ 2885} 2886 2887static void 2888zyd_stop(struct zyd_softc *sc) 2889{ 2890 struct ifnet *ifp = sc->sc_ifp; 2891 int error; 2892 2893 ZYD_LOCK_ASSERT(sc, MA_OWNED); 2894 2895 ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 2896 2897 /* 2898 * stop all the transfers, if not already stopped: 2899 */ 2900 usb2_transfer_stop(sc->sc_xfer[ZYD_BULK_WR]); 2901 usb2_transfer_stop(sc->sc_xfer[ZYD_BULK_RD]); 2902 2903 zyd_free_tx_list(sc); 2904 2905 /* Stop now if the device has vanished or was never set up */ 2906 if (sc->sc_flags & ZYD_FLAG_DETACHING || 2907 (sc->sc_flags & ZYD_FLAG_INITONCE) == 0) 2908 return; 2909 2910 /* switch radio transmitter OFF */ 2911 error = zyd_switch_radio(sc, 0); 2912 if (error != 0) 2913 goto fail; 2914 /* disable Rx */ 2915 zyd_write32_m(sc, ZYD_MAC_RXFILTER, 0); 2916 /* disable interrupts */ 2917 zyd_write32_m(sc, ZYD_CR_INTERRUPT, 0); 2918 2919fail: 2920 return; 2921} 2922 2923static int 2924zyd_loadfirmware(struct zyd_softc *sc) 2925{ 2926 struct usb2_device_request req; 2927 size_t size; 2928 u_char *fw; 2929 uint8_t stat; 2930 uint16_t addr; 2931 2932 if (sc->sc_flags & ZYD_FLAG_FWLOADED) 2933 return (0); 2934 2935 if (sc->sc_macrev == ZYD_ZD1211) { 2936 fw = (u_char *)zd1211_firmware; 2937 size = sizeof(zd1211_firmware); 2938 } else { 2939 fw = (u_char *)zd1211b_firmware; 2940 size = sizeof(zd1211b_firmware); 2941 } 2942 2943 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 2944 req.bRequest = ZYD_DOWNLOADREQ; 2945 USETW(req.wIndex, 0); 2946 2947 addr = ZYD_FIRMWARE_START_ADDR; 2948 while (size > 0) { 2949 /* 2950 * When the transfer size is 4096 bytes, it is not 2951 * likely to be able to transfer it. 2952 * The cause is port or machine or chip? 2953 */ 2954 const int mlen = min(size, 64); 2955 2956 DPRINTF(sc, ZYD_DEBUG_FW, 2957 "loading firmware block: len=%d, addr=0x%x\n", mlen, addr); 2958 2959 USETW(req.wValue, addr); 2960 USETW(req.wLength, mlen); 2961 if (usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, fw) != 0) 2962 return (EIO); 2963 2964 addr += mlen / 2; 2965 fw += mlen; 2966 size -= mlen; 2967 } 2968 2969 /* check whether the upload succeeded */ 2970 req.bmRequestType = UT_READ_VENDOR_DEVICE; 2971 req.bRequest = ZYD_DOWNLOADSTS; 2972 USETW(req.wValue, 0); 2973 USETW(req.wIndex, 0); 2974 USETW(req.wLength, sizeof(stat)); 2975 if (usb2_do_request(sc->sc_udev, &sc->sc_mtx, &req, &stat) != 0) 2976 return (EIO); 2977 2978 sc->sc_flags |= ZYD_FLAG_FWLOADED; 2979 2980 return (stat & 0x80) ? (EIO) : (0); 2981} 2982 2983static void 2984zyd_newassoc(struct ieee80211_node *ni, int isnew) 2985{ 2986 struct ieee80211vap *vap = ni->ni_vap; 2987 2988 ieee80211_amrr_node_init(&ZYD_VAP(vap)->amrr, &ZYD_NODE(ni)->amn, ni); 2989} 2990 2991static void 2992zyd_scan_start(struct ieee80211com *ic) 2993{ 2994 struct zyd_softc *sc = ic->ic_ifp->if_softc; 2995 2996 ZYD_LOCK(sc); 2997 /* do it in a process context */ 2998 sc->sc_scan_action = ZYD_SCAN_START; 2999 zyd_queue_command(sc, zyd_scantask, 3000 &sc->sc_scantask[0].hdr, &sc->sc_scantask[1].hdr); 3001 ZYD_UNLOCK(sc); 3002} 3003 3004static void 3005zyd_scan_end(struct ieee80211com *ic) 3006{ 3007 struct zyd_softc *sc = ic->ic_ifp->if_softc; 3008 3009 ZYD_LOCK(sc); 3010 /* do it in a process context */ 3011 sc->sc_scan_action = ZYD_SCAN_END; 3012 zyd_queue_command(sc, zyd_scantask, 3013 &sc->sc_scantask[0].hdr, &sc->sc_scantask[1].hdr); 3014 ZYD_UNLOCK(sc); 3015} 3016 3017static void 3018zyd_set_channel(struct ieee80211com *ic) 3019{ 3020 struct zyd_softc *sc = ic->ic_ifp->if_softc; 3021 3022 ZYD_LOCK(sc); 3023 /* do it in a process context */ 3024 sc->sc_scan_action = ZYD_SET_CHANNEL; 3025 zyd_queue_command(sc, zyd_scantask, 3026 &sc->sc_scantask[0].hdr, &sc->sc_scantask[1].hdr); 3027 ZYD_UNLOCK(sc); 3028} 3029 3030static void 3031zyd_scantask(struct usb2_proc_msg *pm) 3032{ 3033 struct zyd_task *task = (struct zyd_task *)pm; 3034 struct zyd_softc *sc = task->sc; 3035 struct ifnet *ifp = sc->sc_ifp; 3036 struct ieee80211com *ic = ifp->if_l2com; 3037 3038 ZYD_LOCK_ASSERT(sc, MA_OWNED); 3039 3040 switch (sc->sc_scan_action) { 3041 case ZYD_SCAN_START: 3042 /* want broadcast address while scanning */ 3043 zyd_set_bssid(sc, ifp->if_broadcastaddr); 3044 break; 3045 case ZYD_SCAN_END: 3046 /* restore previous bssid */ 3047 zyd_set_bssid(sc, sc->sc_bssid); 3048 break; 3049 case ZYD_SET_CHANNEL: 3050 zyd_set_chan(sc, ic->ic_curchan); 3051 break; 3052 default: 3053 device_printf(sc->sc_dev, "unknown scan action %d\n", 3054 sc->sc_scan_action); 3055 break; 3056 } 3057} 3058 3059static void 3060zyd_wakeup(struct zyd_softc *sc) 3061{ 3062 struct zyd_rq *rqp; 3063 3064 STAILQ_FOREACH(rqp, &sc->sc_rqh, rq) 3065 wakeup(rqp); /* wakeup sleeping caller */ 3066} 3067 3068static void 3069zyd_queue_command(struct zyd_softc *sc, usb2_proc_callback_t *fn, 3070 struct usb2_proc_msg *t0, struct usb2_proc_msg *t1) 3071{ 3072 struct zyd_task *task; 3073 3074 ZYD_LOCK_ASSERT(sc, MA_OWNED); 3075 3076 if (usb2_proc_is_gone(&sc->sc_tq)) { 3077 DPRINTF(sc, ZYD_DEBUG_STATE, "proc is gone\n"); 3078 return; /* nothing to do */ 3079 } 3080 /* 3081 * NOTE: The task cannot get executed before we drop the 3082 * "sc_mtx" mutex. It is safe to update fields in the message 3083 * structure after that the message got queued. 3084 */ 3085 task = (struct zyd_task *) 3086 usb2_proc_msignal(&sc->sc_tq, t0, t1); 3087 3088 /* Setup callback and softc pointers */ 3089 task->hdr.pm_callback = fn; 3090 task->sc = sc; 3091 3092} 3093 3094static device_method_t zyd_methods[] = { 3095 /* Device interface */ 3096 DEVMETHOD(device_probe, zyd_match), 3097 DEVMETHOD(device_attach, zyd_attach), 3098 DEVMETHOD(device_detach, zyd_detach), 3099 3100 { 0, 0 } 3101}; 3102 3103static driver_t zyd_driver = { 3104 "zyd", 3105 zyd_methods, 3106 sizeof(struct zyd_softc) 3107}; 3108 3109static devclass_t zyd_devclass; 3110 3111DRIVER_MODULE(zyd, ushub, zyd_driver, zyd_devclass, NULL, 0); 3112MODULE_DEPEND(zyd, usb2_wlan, 1, 1, 1); 3113MODULE_DEPEND(zyd, usb2_core, 1, 1, 1); 3114MODULE_DEPEND(zyd, wlan, 1, 1, 1); 3115MODULE_DEPEND(zyd, wlan_amrr, 1, 1, 1); 3116