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