if_zyd.c revision 187378
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 187378 2009-01-18 05:35:58Z 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 187378 2009-01-18 05:35:58Z 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_ifp = ifp; 2082 ic = ifp->if_l2com; 2083 2084 ifp->if_softc = sc; 2085 if_initname(ifp, "zyd", sc->sc_unit); 2086 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 2087 ifp->if_init = &zyd_init_cb; 2088 ifp->if_ioctl = &zyd_ioctl_cb; 2089 ifp->if_start = &zyd_start_cb; 2090 ifp->if_watchdog = NULL; 2091 IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 2092 ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; 2093 IFQ_SET_READY(&ifp->if_snd); 2094 2095 bcopy(sc->sc_myaddr, ic->ic_myaddr, sizeof(ic->ic_myaddr)); 2096 2097 ic->ic_ifp = ifp; 2098 ic->ic_phytype = IEEE80211_T_OFDM; 2099 ic->ic_opmode = IEEE80211_M_STA; 2100 2101 /* Set device capabilities */ 2102 ic->ic_caps = 2103 IEEE80211_C_STA /* station mode supported */ 2104 | IEEE80211_C_MONITOR /* monitor mode */ 2105 | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 2106 | IEEE80211_C_SHSLOT /* short slot time supported */ 2107 | IEEE80211_C_BGSCAN /* capable of bg scanning */ 2108 | IEEE80211_C_WPA /* 802.11i */ 2109 ; 2110 2111 bands = 0; 2112 setbit(&bands, IEEE80211_MODE_11B); 2113 setbit(&bands, IEEE80211_MODE_11G); 2114 ieee80211_init_channels(ic, NULL, &bands); 2115 2116 mtx_unlock(&sc->sc_mtx); 2117 2118 ieee80211_ifattach(ic); 2119 2120 mtx_lock(&sc->sc_mtx); 2121 2122 ic->ic_node_alloc = &zyd_node_alloc_cb; 2123 ic->ic_raw_xmit = &zyd_raw_xmit_cb; 2124 ic->ic_newassoc = &zyd_newassoc_cb; 2125 2126 ic->ic_scan_start = &zyd_scan_start_cb; 2127 ic->ic_scan_end = &zyd_scan_end_cb; 2128 ic->ic_set_channel = &zyd_set_channel_cb; 2129 ic->ic_vap_create = &zyd_vap_create; 2130 ic->ic_vap_delete = &zyd_vap_delete; 2131 ic->ic_update_mcast = &zyd_update_mcast_cb; 2132 ic->ic_update_promisc = &zyd_update_promisc_cb; 2133 2134 sc->sc_rates = ieee80211_get_ratetable(ic->ic_curchan); 2135 2136 mtx_unlock(&sc->sc_mtx); 2137 2138 bpfattach(ifp, DLT_IEEE802_11_RADIO, 2139 sizeof(struct ieee80211_frame) + 2140 sizeof(sc->sc_txtap)); 2141 2142 mtx_lock(&sc->sc_mtx); 2143 2144 if (bootverbose) { 2145 ieee80211_announce(ic); 2146 } 2147 usb2_transfer_start(sc->sc_xfer[ZYD_INTR_DT_RD]); 2148done: 2149 return; 2150} 2151 2152/* 2153 * Detach device 2154 */ 2155static int 2156zyd_detach(device_t dev) 2157{ 2158 struct zyd_softc *sc = device_get_softc(dev); 2159 struct ieee80211com *ic; 2160 struct ifnet *ifp; 2161 2162 usb2_config_td_drain(&sc->sc_config_td); 2163 2164 mtx_lock(&sc->sc_mtx); 2165 2166 usb2_callout_stop(&sc->sc_watchdog); 2167 2168 zyd_cfg_pre_stop(sc, NULL, 0); 2169 2170 ifp = sc->sc_ifp; 2171 ic = ifp->if_l2com; 2172 2173 mtx_unlock(&sc->sc_mtx); 2174 2175 /* stop all USB transfers first */ 2176 usb2_transfer_unsetup(sc->sc_xfer, ZYD_N_TRANSFER); 2177 2178 /* get rid of any late children */ 2179 bus_generic_detach(dev); 2180 2181 if (ifp) { 2182 bpfdetach(ifp); 2183 ieee80211_ifdetach(ic); 2184 if_free(ifp); 2185 } 2186 usb2_config_td_unsetup(&sc->sc_config_td); 2187 2188 usb2_callout_drain(&sc->sc_watchdog); 2189 2190 usb2_cv_destroy(&sc->sc_intr_cv); 2191 2192 mtx_destroy(&sc->sc_mtx); 2193 2194 return (0); 2195} 2196 2197static void 2198zyd_cfg_newstate(struct zyd_softc *sc, 2199 struct usb2_config_td_cc *cc, uint16_t refcount) 2200{ 2201 struct ifnet *ifp = sc->sc_ifp; 2202 struct ieee80211com *ic = ifp->if_l2com; 2203 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2204 struct zyd_vap *uvp = ZYD_VAP(vap); 2205 enum ieee80211_state ostate; 2206 enum ieee80211_state nstate; 2207 int arg; 2208 2209 ostate = vap->iv_state; 2210 nstate = sc->sc_ns_state; 2211 arg = sc->sc_ns_arg; 2212 2213 switch (nstate) { 2214 case IEEE80211_S_INIT: 2215 break; 2216 2217 case IEEE80211_S_RUN: 2218 zyd_cfg_set_run(sc, cc); 2219 break; 2220 2221 default: 2222 break; 2223 } 2224 2225 mtx_unlock(&sc->sc_mtx); 2226 IEEE80211_LOCK(ic); 2227 uvp->newstate(vap, nstate, arg); 2228 if (vap->iv_newstate_cb != NULL) 2229 vap->iv_newstate_cb(vap, nstate, arg); 2230 IEEE80211_UNLOCK(ic); 2231 mtx_lock(&sc->sc_mtx); 2232} 2233 2234static void 2235zyd_cfg_set_run(struct zyd_softc *sc, 2236 struct usb2_config_td_cc *cc) 2237{ 2238 zyd_cfg_set_chan(sc, cc, 0); 2239 2240 if (cc->ic_opmode != IEEE80211_M_MONITOR) { 2241 /* turn link LED on */ 2242 zyd_cfg_set_led(sc, ZYD_LED1, 1); 2243 2244 /* make data LED blink upon Tx */ 2245 zyd_cfg_write32(sc, sc->sc_firmware_base + ZYD_FW_LINK_STATUS, 1); 2246 2247 zyd_cfg_set_bssid(sc, cc->iv_bss.ni_bssid); 2248 } 2249 if (cc->iv_bss.fixed_rate_none) { 2250 /* enable automatic rate adaptation */ 2251 zyd_cfg_amrr_start(sc); 2252 } 2253} 2254 2255static int 2256zyd_newstate_cb(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2257{ 2258 struct zyd_vap *uvp = ZYD_VAP(vap); 2259 struct ieee80211com *ic = vap->iv_ic; 2260 struct zyd_softc *sc = ic->ic_ifp->if_softc; 2261 2262 DPRINTF("setting new state: %d\n", nstate); 2263 2264 mtx_lock(&sc->sc_mtx); 2265 if (usb2_config_td_is_gone(&sc->sc_config_td)) { 2266 mtx_unlock(&sc->sc_mtx); 2267 /* Special case which happens at detach. */ 2268 if (nstate == IEEE80211_S_INIT) { 2269 (uvp->newstate) (vap, nstate, arg); 2270 } 2271 return (0); /* nothing to do */ 2272 } 2273 /* store next state */ 2274 sc->sc_ns_state = nstate; 2275 sc->sc_ns_arg = arg; 2276 2277 /* stop timers */ 2278 sc->sc_amrr_timer = 0; 2279 2280 /* 2281 * USB configuration can only be done from the USB configuration 2282 * thread: 2283 */ 2284 usb2_config_td_queue_command 2285 (&sc->sc_config_td, &zyd_config_copy, 2286 &zyd_cfg_newstate, 0, 0); 2287 2288 mtx_unlock(&sc->sc_mtx); 2289 2290 return EINPROGRESS; 2291} 2292 2293static void 2294zyd_cfg_update_promisc(struct zyd_softc *sc, 2295 struct usb2_config_td_cc *cc, uint16_t refcount) 2296{ 2297 uint32_t low; 2298 uint32_t high; 2299 2300 if ((cc->ic_opmode == IEEE80211_M_MONITOR) || 2301 (cc->if_flags & (IFF_ALLMULTI | IFF_PROMISC))) { 2302 low = 0xffffffff; 2303 high = 0xffffffff; 2304 } else { 2305 low = cc->zyd_multi_low; 2306 high = cc->zyd_multi_high; 2307 } 2308 2309 /* reprogram multicast global hash table */ 2310 zyd_cfg_write32(sc, ZYD_MAC_GHTBL, low); 2311 zyd_cfg_write32(sc, ZYD_MAC_GHTBH, high); 2312} 2313 2314/* 2315 * Rate-to-bit-converter (Field "rate" in zyd_controlsetformat) 2316 */ 2317static uint8_t 2318zyd_plcp_signal(uint8_t rate) 2319{ 2320 ; /* fix for indent */ 2321 2322 switch (rate) { 2323 /* CCK rates (NB: not IEEE std, device-specific) */ 2324 case 2: 2325 return (0x0); 2326 case 4: 2327 return (0x1); 2328 case 11: 2329 return (0x2); 2330 case 22: 2331 return (0x3); 2332 2333 /* OFDM rates (cf IEEE Std 802.11a-1999, pp. 14 Table 80) */ 2334 case 12: 2335 return (0xb); 2336 case 18: 2337 return (0xf); 2338 case 24: 2339 return (0xa); 2340 case 36: 2341 return (0xe); 2342 case 48: 2343 return (0x9); 2344 case 72: 2345 return (0xd); 2346 case 96: 2347 return (0x8); 2348 case 108: 2349 return (0xc); 2350 2351 /* XXX unsupported/unknown rate */ 2352 default: 2353 return (0xff); 2354 } 2355} 2356 2357static void 2358zyd_std_command(struct ieee80211com *ic, usb2_config_td_command_t *func) 2359{ 2360 struct zyd_softc *sc = ic->ic_ifp->if_softc; 2361 2362 mtx_lock(&sc->sc_mtx); 2363 2364 sc->sc_rates = ieee80211_get_ratetable(ic->ic_curchan); 2365 2366 usb2_config_td_queue_command 2367 (&sc->sc_config_td, &zyd_config_copy, func, 0, 0); 2368 2369 mtx_unlock(&sc->sc_mtx); 2370} 2371 2372static void 2373zyd_scan_start_cb(struct ieee80211com *ic) 2374{ 2375 zyd_std_command(ic, &zyd_cfg_scan_start); 2376} 2377 2378static void 2379zyd_scan_end_cb(struct ieee80211com *ic) 2380{ 2381 zyd_std_command(ic, &zyd_cfg_scan_end); 2382} 2383 2384static void 2385zyd_set_channel_cb(struct ieee80211com *ic) 2386{ 2387 zyd_std_command(ic, &zyd_cfg_set_chan); 2388} 2389 2390/*========================================================================* 2391 * configure sub-routines, zyd_cfg_xxx 2392 *========================================================================*/ 2393 2394static void 2395zyd_cfg_scan_start(struct zyd_softc *sc, 2396 struct usb2_config_td_cc *cc, uint16_t refcount) 2397{ 2398 zyd_cfg_set_bssid(sc, cc->if_broadcastaddr); 2399} 2400 2401static void 2402zyd_cfg_scan_end(struct zyd_softc *sc, 2403 struct usb2_config_td_cc *cc, uint16_t refcount) 2404{ 2405 zyd_cfg_set_bssid(sc, cc->iv_bss.ni_bssid); 2406} 2407 2408static void 2409zyd_cfg_set_chan(struct zyd_softc *sc, 2410 struct usb2_config_td_cc *cc, uint16_t refcount) 2411{ 2412 uint32_t chan; 2413 uint32_t tmp; 2414 2415 chan = cc->ic_curchan.chan_to_ieee; 2416 2417 DPRINTF("Will try %d\n", chan); 2418 2419 if ((chan == 0) || (chan == IEEE80211_CHAN_ANY)) { 2420 DPRINTF("0 or ANY, exiting\n"); 2421 return; 2422 } 2423 zyd_cfg_lock_phy(sc); 2424 2425 (sc->sc_rf.cfg_set_channel) (sc, &sc->sc_rf, chan); 2426 2427 /* update Tx power */ 2428 zyd_cfg_write16(sc, ZYD_CR31, sc->sc_pwr_int[chan - 1]); 2429 2430 if (sc->sc_mac_rev == ZYD_ZD1211B) { 2431 zyd_cfg_write16(sc, ZYD_CR67, sc->sc_ofdm36_cal[chan - 1]); 2432 zyd_cfg_write16(sc, ZYD_CR66, sc->sc_ofdm48_cal[chan - 1]); 2433 zyd_cfg_write16(sc, ZYD_CR65, sc->sc_ofdm54_cal[chan - 1]); 2434 zyd_cfg_write16(sc, ZYD_CR68, sc->sc_pwr_cal[chan - 1]); 2435 zyd_cfg_write16(sc, ZYD_CR69, 0x28); 2436 zyd_cfg_write16(sc, ZYD_CR69, 0x2a); 2437 } 2438 if (sc->sc_cckgain) { 2439 /* set CCK baseband gain from EEPROM */ 2440 zyd_cfg_read32(sc, ZYD_EEPROM_PHY_REG, &tmp); 2441 zyd_cfg_write16(sc, ZYD_CR47, tmp & 0xff); 2442 } 2443 if (sc->sc_bandedge6 && (sc->sc_rf.cfg_bandedge6 != NULL)) { 2444 (sc->sc_rf.cfg_bandedge6) (sc, &sc->sc_rf, chan); 2445 } 2446 zyd_cfg_write32(sc, ZYD_CR_CONFIG_PHILIPS, 0); 2447 2448 zyd_cfg_unlock_phy(sc); 2449 2450 sc->sc_rxtap.wr_chan_freq = 2451 sc->sc_txtap.wt_chan_freq = 2452 htole16(cc->ic_curchan.ic_freq); 2453 2454 sc->sc_rxtap.wr_chan_flags = 2455 sc->sc_txtap.wt_chan_flags = 2456 htole16(cc->ic_flags); 2457} 2458 2459/* 2460 * Interface: init 2461 */ 2462 2463/* immediate configuration */ 2464 2465static void 2466zyd_cfg_pre_init(struct zyd_softc *sc, 2467 struct usb2_config_td_cc *cc, uint16_t refcount) 2468{ 2469 struct ifnet *ifp = sc->sc_ifp; 2470 struct ieee80211com *ic = ifp->if_l2com; 2471 2472 zyd_cfg_pre_stop(sc, cc, 0); 2473 2474 ifp->if_drv_flags |= IFF_DRV_RUNNING; 2475 2476 sc->sc_flags |= ZYD_FLAG_HL_READY; 2477 2478 IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp)); 2479} 2480 2481/* delayed configuration */ 2482 2483static void 2484zyd_cfg_init(struct zyd_softc *sc, 2485 struct usb2_config_td_cc *cc, uint16_t refcount) 2486{ 2487 zyd_cfg_stop(sc, cc, 0); 2488 2489 /* Do initial setup */ 2490 2491 zyd_cfg_set_mac_addr(sc, cc->ic_myaddr); 2492 2493 zyd_cfg_write32(sc, ZYD_MAC_ENCRYPTION_TYPE, ZYD_ENC_SNIFFER); 2494 2495 /* promiscuous mode */ 2496 zyd_cfg_write32(sc, ZYD_MAC_SNIFFER, 2497 (cc->ic_opmode == IEEE80211_M_MONITOR) ? 1 : 0); 2498 2499 /* multicast setup */ 2500 zyd_cfg_update_promisc(sc, cc, refcount); 2501 2502 zyd_cfg_set_rxfilter(sc, cc, refcount); 2503 2504 /* switch radio transmitter ON */ 2505 zyd_cfg_switch_radio(sc, 1); 2506 2507 /* XXX wrong, can't set here */ 2508 /* set basic rates */ 2509 if (cc->ic_curmode == IEEE80211_MODE_11B) 2510 zyd_cfg_write32(sc, ZYD_MAC_BAS_RATE, 0x0003); 2511 else if (cc->ic_curmode == IEEE80211_MODE_11A) 2512 zyd_cfg_write32(sc, ZYD_MAC_BAS_RATE, 0x1500); 2513 else /* assumes 802.11b/g */ 2514 zyd_cfg_write32(sc, ZYD_MAC_BAS_RATE, 0xff0f); 2515 2516 /* set mandatory rates */ 2517 if (cc->ic_curmode == IEEE80211_MODE_11B) 2518 zyd_cfg_write32(sc, ZYD_MAC_MAN_RATE, 0x000f); 2519 else if (cc->ic_curmode == IEEE80211_MODE_11A) 2520 zyd_cfg_write32(sc, ZYD_MAC_MAN_RATE, 0x1500); 2521 else /* assumes 802.11b/g */ 2522 zyd_cfg_write32(sc, ZYD_MAC_MAN_RATE, 0x150f); 2523 2524 /* set default BSS channel */ 2525 zyd_cfg_set_chan(sc, cc, 0); 2526 2527 /* enable interrupts */ 2528 zyd_cfg_write32(sc, ZYD_CR_INTERRUPT, ZYD_HWINT_MASK); 2529 2530 /* make sure that the transfers get started */ 2531 sc->sc_flags |= ( 2532 ZYD_FLAG_BULK_READ_STALL | 2533 ZYD_FLAG_BULK_WRITE_STALL | 2534 ZYD_FLAG_LL_READY); 2535 2536 if ((sc->sc_flags & ZYD_FLAG_LL_READY) && 2537 (sc->sc_flags & ZYD_FLAG_HL_READY)) { 2538 struct ifnet *ifp = sc->sc_ifp; 2539 struct ieee80211com *ic = ifp->if_l2com; 2540 2541 /* 2542 * start the USB transfers, if not already started: 2543 */ 2544 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_DT_RD]); 2545 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_DT_WR]); 2546 2547 /* 2548 * start IEEE802.11 layer 2549 */ 2550 mtx_unlock(&sc->sc_mtx); 2551 ieee80211_start_all(ic); 2552 mtx_lock(&sc->sc_mtx); 2553 } 2554} 2555 2556/* immediate configuration */ 2557 2558static void 2559zyd_cfg_pre_stop(struct zyd_softc *sc, 2560 struct usb2_config_td_cc *cc, uint16_t refcount) 2561{ 2562 struct ifnet *ifp = sc->sc_ifp; 2563 2564 if (cc) { 2565 /* copy the needed configuration */ 2566 zyd_config_copy(sc, cc, refcount); 2567 } 2568 if (ifp) { 2569 /* clear flags */ 2570 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 2571 } 2572 sc->sc_flags &= ~(ZYD_FLAG_HL_READY | 2573 ZYD_FLAG_LL_READY); 2574 2575 /* 2576 * stop all the transfers, if not already stopped: 2577 */ 2578 usb2_transfer_stop(sc->sc_xfer[ZYD_BULK_DT_WR]); 2579 usb2_transfer_stop(sc->sc_xfer[ZYD_BULK_DT_RD]); 2580 usb2_transfer_stop(sc->sc_xfer[ZYD_BULK_CS_WR]); 2581 usb2_transfer_stop(sc->sc_xfer[ZYD_BULK_CS_RD]); 2582 2583 /* clean up transmission */ 2584 zyd_tx_clean_queue(sc); 2585} 2586 2587/* delayed configuration */ 2588 2589static void 2590zyd_cfg_stop(struct zyd_softc *sc, 2591 struct usb2_config_td_cc *cc, uint16_t refcount) 2592{ 2593 /* switch radio transmitter OFF */ 2594 zyd_cfg_switch_radio(sc, 0); 2595 2596 /* disable Rx */ 2597 zyd_cfg_write32(sc, ZYD_MAC_RXFILTER, 0); 2598 2599 /* disable interrupts */ 2600 zyd_cfg_write32(sc, ZYD_CR_INTERRUPT, 0); 2601} 2602 2603static void 2604zyd_update_mcast_cb(struct ifnet *ifp) 2605{ 2606 struct zyd_softc *sc = ifp->if_softc; 2607 2608 mtx_lock(&sc->sc_mtx); 2609 usb2_config_td_queue_command 2610 (&sc->sc_config_td, &zyd_config_copy, 2611 &zyd_cfg_update_promisc, 0, 0); 2612 mtx_unlock(&sc->sc_mtx); 2613} 2614 2615static void 2616zyd_update_promisc_cb(struct ifnet *ifp) 2617{ 2618 struct zyd_softc *sc = ifp->if_softc; 2619 2620 mtx_lock(&sc->sc_mtx); 2621 usb2_config_td_queue_command 2622 (&sc->sc_config_td, &zyd_config_copy, 2623 &zyd_cfg_update_promisc, 0, 0); 2624 mtx_unlock(&sc->sc_mtx); 2625} 2626 2627static void 2628zyd_cfg_set_rxfilter(struct zyd_softc *sc, 2629 struct usb2_config_td_cc *cc, uint16_t refcount) 2630{ 2631 uint32_t rxfilter; 2632 2633 switch (cc->ic_opmode) { 2634 case IEEE80211_M_STA: 2635 rxfilter = ZYD_FILTER_BSS; 2636 break; 2637 case IEEE80211_M_IBSS: 2638 case IEEE80211_M_HOSTAP: 2639 rxfilter = ZYD_FILTER_HOSTAP; 2640 break; 2641 case IEEE80211_M_MONITOR: 2642 rxfilter = ZYD_FILTER_MONITOR; 2643 break; 2644 default: 2645 /* should not get there */ 2646 return; 2647 } 2648 zyd_cfg_write32(sc, ZYD_MAC_RXFILTER, rxfilter); 2649} 2650 2651static void 2652zyd_cfg_set_led(struct zyd_softc *sc, uint32_t which, uint8_t on) 2653{ 2654 uint32_t tmp; 2655 2656 zyd_cfg_read32(sc, ZYD_MAC_TX_PE_CONTROL, &tmp); 2657 if (on) 2658 tmp |= which; 2659 else 2660 tmp &= ~which; 2661 2662 zyd_cfg_write32(sc, ZYD_MAC_TX_PE_CONTROL, tmp); 2663} 2664 2665static void 2666zyd_start_cb(struct ifnet *ifp) 2667{ 2668 struct zyd_softc *sc = ifp->if_softc; 2669 2670 mtx_lock(&sc->sc_mtx); 2671 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_DT_WR]); 2672 mtx_unlock(&sc->sc_mtx); 2673} 2674 2675static void 2676zyd_bulk_write_clear_stall_callback(struct usb2_xfer *xfer) 2677{ 2678 struct zyd_softc *sc = xfer->priv_sc; 2679 struct usb2_xfer *xfer_other = sc->sc_xfer[ZYD_BULK_DT_WR]; 2680 2681 if (usb2_clear_stall_callback(xfer, xfer_other)) { 2682 DPRINTF("stall cleared\n"); 2683 sc->sc_flags &= ~ZYD_FLAG_BULK_WRITE_STALL; 2684 usb2_transfer_start(xfer_other); 2685 } 2686} 2687 2688/* 2689 * We assume that "m->m_pkthdr.rcvif" is pointing to the "ni" that 2690 * should be freed, when "zyd_setup_desc_and_tx" is called. 2691 */ 2692static void 2693zyd_setup_desc_and_tx(struct zyd_softc *sc, struct mbuf *m, 2694 uint16_t rate) 2695{ 2696 struct ifnet *ifp = sc->sc_ifp; 2697 struct ieee80211com *ic = ifp->if_l2com; 2698 struct mbuf *mm; 2699 enum ieee80211_phytype phytype; 2700 uint16_t len; 2701 uint16_t totlen; 2702 uint16_t pktlen; 2703 uint8_t remainder; 2704 2705 if (sc->sc_tx_queue.ifq_len >= IFQ_MAXLEN) { 2706 /* free packet */ 2707 zyd_tx_freem(m); 2708 ifp->if_oerrors++; 2709 return; 2710 } 2711 if (!((sc->sc_flags & ZYD_FLAG_LL_READY) && 2712 (sc->sc_flags & ZYD_FLAG_HL_READY))) { 2713 /* free packet */ 2714 zyd_tx_freem(m); 2715 ifp->if_oerrors++; 2716 return; 2717 } 2718 if (rate < 2) { 2719 DPRINTF("rate < 2!\n"); 2720 2721 /* avoid division by zero */ 2722 rate = 2; 2723 } 2724 ic->ic_lastdata = ticks; 2725 2726 if (bpf_peers_present(ifp->if_bpf)) { 2727 struct zyd_tx_radiotap_header *tap = &sc->sc_txtap; 2728 2729 tap->wt_flags = 0; 2730 tap->wt_rate = rate; 2731 tap->wt_chan_freq = htole16(ic->ic_curchan->ic_freq); 2732 tap->wt_chan_flags = htole16(ic->ic_curchan->ic_flags); 2733 2734 bpf_mtap2(ifp->if_bpf, tap, sc->sc_txtap_len, m); 2735 } 2736 len = m->m_pkthdr.len; 2737 totlen = m->m_pkthdr.len + IEEE80211_CRC_LEN; 2738 phytype = ieee80211_rate2phytype(sc->sc_rates, rate); 2739 2740 sc->sc_tx_desc.len = htole16(totlen); 2741 sc->sc_tx_desc.phy = zyd_plcp_signal(rate); 2742 if (phytype == IEEE80211_T_OFDM) { 2743 sc->sc_tx_desc.phy |= ZYD_TX_PHY_OFDM; 2744 if (IEEE80211_IS_CHAN_5GHZ(ic->ic_curchan)) 2745 sc->sc_tx_desc.phy |= ZYD_TX_PHY_5GHZ; 2746 } else if (rate != 2 && (ic->ic_flags & IEEE80211_F_SHPREAMBLE)) 2747 sc->sc_tx_desc.phy |= ZYD_TX_PHY_SHPREAMBLE; 2748 2749 /* actual transmit length (XXX why +10?) */ 2750 pktlen = sizeof(struct zyd_tx_desc) + 10; 2751 if (sc->sc_mac_rev == ZYD_ZD1211) 2752 pktlen += totlen; 2753 sc->sc_tx_desc.pktlen = htole16(pktlen); 2754 2755 sc->sc_tx_desc.plcp_length = ((16 * totlen) + rate - 1) / rate; 2756 sc->sc_tx_desc.plcp_service = 0; 2757 if (rate == 22) { 2758 remainder = (16 * totlen) % 22; 2759 if ((remainder != 0) && (remainder < 7)) 2760 sc->sc_tx_desc.plcp_service |= ZYD_PLCP_LENGEXT; 2761 } 2762 if (sizeof(sc->sc_tx_desc) > MHLEN) { 2763 DPRINTF("No room for header structure!\n"); 2764 zyd_tx_freem(m); 2765 return; 2766 } 2767 mm = m_gethdr(M_NOWAIT, MT_DATA); 2768 if (mm == NULL) { 2769 DPRINTF("Could not allocate header mbuf!\n"); 2770 zyd_tx_freem(m); 2771 return; 2772 } 2773 bcopy(&sc->sc_tx_desc, mm->m_data, sizeof(sc->sc_tx_desc)); 2774 mm->m_len = sizeof(sc->sc_tx_desc); 2775 2776 mm->m_next = m; 2777 mm->m_pkthdr.len = mm->m_len + m->m_pkthdr.len; 2778 mm->m_pkthdr.rcvif = NULL; 2779 2780 /* start write transfer, if not started */ 2781 _IF_ENQUEUE(&sc->sc_tx_queue, mm); 2782 2783 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_DT_WR]); 2784} 2785 2786static void 2787zyd_bulk_write_callback(struct usb2_xfer *xfer) 2788{ 2789 struct zyd_softc *sc = xfer->priv_sc; 2790 struct ifnet *ifp = sc->sc_ifp; 2791 struct mbuf *m; 2792 uint16_t temp_len; 2793 2794 DPRINTF("\n"); 2795 2796 switch (USB_GET_STATE(xfer)) { 2797 case USB_ST_TRANSFERRED: 2798 DPRINTFN(11, "transfer complete\n"); 2799 2800 ifp->if_opackets++; 2801 2802 case USB_ST_SETUP: 2803 if (sc->sc_flags & ZYD_FLAG_BULK_WRITE_STALL) { 2804 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_CS_WR]); 2805 DPRINTFN(11, "write stalled\n"); 2806 break; 2807 } 2808 if (sc->sc_flags & ZYD_FLAG_WAIT_COMMAND) { 2809 /* 2810 * don't send anything while a command is pending ! 2811 */ 2812 DPRINTFN(11, "wait command\n"); 2813 break; 2814 } 2815 zyd_fill_write_queue(sc); 2816 2817 _IF_DEQUEUE(&sc->sc_tx_queue, m); 2818 2819 if (m) { 2820 if (m->m_pkthdr.len > ZYD_MAX_TXBUFSZ) { 2821 DPRINTFN(0, "data overflow, %u bytes\n", 2822 m->m_pkthdr.len); 2823 m->m_pkthdr.len = ZYD_MAX_TXBUFSZ; 2824 } 2825 usb2_m_copy_in(xfer->frbuffers, 0, 2826 m, 0, m->m_pkthdr.len); 2827 2828 /* get transfer length */ 2829 temp_len = m->m_pkthdr.len; 2830 2831 DPRINTFN(11, "sending frame len=%u xferlen=%u\n", 2832 m->m_pkthdr.len, temp_len); 2833 2834 xfer->frlengths[0] = temp_len; 2835 2836 usb2_start_hardware(xfer); 2837 2838 /* free mbuf and node */ 2839 zyd_tx_freem(m); 2840 } 2841 break; 2842 2843 default: /* Error */ 2844 DPRINTFN(11, "transfer error, %s\n", 2845 usb2_errstr(xfer->error)); 2846 2847 if (xfer->error != USB_ERR_CANCELLED) { 2848 /* try to clear stall first */ 2849 sc->sc_flags |= ZYD_FLAG_BULK_WRITE_STALL; 2850 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_CS_WR]); 2851 } 2852 ifp->if_oerrors++; 2853 break; 2854 } 2855} 2856 2857static void 2858zyd_init_cb(void *arg) 2859{ 2860 struct zyd_softc *sc = arg; 2861 2862 mtx_lock(&sc->sc_mtx); 2863 usb2_config_td_queue_command 2864 (&sc->sc_config_td, &zyd_cfg_pre_init, 2865 &zyd_cfg_init, 0, 0); 2866 mtx_unlock(&sc->sc_mtx); 2867} 2868 2869static int 2870zyd_ioctl_cb(struct ifnet *ifp, u_long cmd, caddr_t data) 2871{ 2872 struct zyd_softc *sc = ifp->if_softc; 2873 struct ieee80211com *ic = ifp->if_l2com; 2874 int error; 2875 2876 switch (cmd) { 2877 case SIOCSIFFLAGS: 2878 mtx_lock(&sc->sc_mtx); 2879 if (ifp->if_flags & IFF_UP) { 2880 if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) { 2881 usb2_config_td_queue_command 2882 (&sc->sc_config_td, &zyd_cfg_pre_init, 2883 &zyd_cfg_init, 0, 0); 2884 } 2885 } else { 2886 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 2887 usb2_config_td_queue_command 2888 (&sc->sc_config_td, &zyd_cfg_pre_stop, 2889 &zyd_cfg_stop, 0, 0); 2890 } 2891 } 2892 mtx_unlock(&sc->sc_mtx); 2893 error = 0; 2894 break; 2895 2896 case SIOCGIFMEDIA: 2897 case SIOCADDMULTI: 2898 case SIOCDELMULTI: 2899 error = ifmedia_ioctl(ifp, (void *)data, &ic->ic_media, cmd); 2900 break; 2901 2902 default: 2903 error = ether_ioctl(ifp, cmd, data); 2904 break; 2905 } 2906 return (error); 2907} 2908 2909static void 2910zyd_watchdog(void *arg) 2911{ 2912 struct zyd_softc *sc = arg; 2913 2914 mtx_assert(&sc->sc_mtx, MA_OWNED); 2915 2916 if (sc->sc_amrr_timer) { 2917 usb2_config_td_queue_command 2918 (&sc->sc_config_td, NULL, 2919 &zyd_cfg_amrr_timeout, 0, 0); 2920 } 2921 usb2_callout_reset(&sc->sc_watchdog, 2922 hz, &zyd_watchdog, sc); 2923} 2924 2925static void 2926zyd_config_copy_chan(struct zyd_config_copy_chan *cc, 2927 struct ieee80211com *ic, struct ieee80211_channel *c) 2928{ 2929 if (!c) 2930 return; 2931 cc->chan_to_ieee = 2932 ieee80211_chan2ieee(ic, c); 2933 if (c != IEEE80211_CHAN_ANYC) { 2934 cc->chan_to_mode = 2935 ieee80211_chan2mode(c); 2936 cc->ic_freq = c->ic_freq; 2937 if (IEEE80211_IS_CHAN_B(c)) 2938 cc->chan_is_b = 1; 2939 if (IEEE80211_IS_CHAN_A(c)) 2940 cc->chan_is_a = 1; 2941 if (IEEE80211_IS_CHAN_2GHZ(c)) 2942 cc->chan_is_2ghz = 1; 2943 if (IEEE80211_IS_CHAN_5GHZ(c)) 2944 cc->chan_is_5ghz = 1; 2945 if (IEEE80211_IS_CHAN_ANYG(c)) 2946 cc->chan_is_g = 1; 2947 } 2948} 2949 2950static void 2951zyd_config_copy(struct zyd_softc *sc, 2952 struct usb2_config_td_cc *cc, uint16_t refcount) 2953{ 2954 const struct ieee80211_txparam *tp; 2955 struct ieee80211vap *vap; 2956 struct ifmultiaddr *ifma; 2957 struct ieee80211_node *ni; 2958 struct ieee80211com *ic; 2959 struct ifnet *ifp; 2960 2961 bzero(cc, sizeof(*cc)); 2962 2963 ifp = sc->sc_ifp; 2964 if (ifp) { 2965 cc->if_flags = ifp->if_flags; 2966 bcopy(ifp->if_broadcastaddr, cc->if_broadcastaddr, 2967 sizeof(cc->if_broadcastaddr)); 2968 2969 cc->zyd_multi_low = 0x00000000; 2970 cc->zyd_multi_high = 0x80000000; 2971 2972 IF_ADDR_LOCK(ifp); 2973 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 2974 uint8_t v; 2975 2976 if (ifma->ifma_addr->sa_family != AF_LINK) 2977 continue; 2978 v = ((uint8_t *)LLADDR((struct sockaddr_dl *) 2979 ifma->ifma_addr))[5] >> 2; 2980 if (v < 32) 2981 cc->zyd_multi_low |= 1 << v; 2982 else 2983 cc->zyd_multi_high |= 1 << (v - 32); 2984 } 2985 IF_ADDR_UNLOCK(ifp); 2986 2987 ic = ifp->if_l2com; 2988 if (ic) { 2989 zyd_config_copy_chan(&cc->ic_curchan, ic, ic->ic_curchan); 2990 zyd_config_copy_chan(&cc->ic_bsschan, ic, ic->ic_bsschan); 2991 vap = TAILQ_FIRST(&ic->ic_vaps); 2992 if (vap) { 2993 ni = vap->iv_bss; 2994 if (ni) { 2995 cc->iv_bss.ni_intval = ni->ni_intval; 2996 bcopy(ni->ni_bssid, cc->iv_bss.ni_bssid, 2997 sizeof(cc->iv_bss.ni_bssid)); 2998 } 2999 tp = vap->iv_txparms + cc->ic_bsschan.chan_to_mode; 3000 if (tp->ucastrate == IEEE80211_FIXED_RATE_NONE) { 3001 cc->iv_bss.fixed_rate_none = 1; 3002 } 3003 } 3004 cc->ic_opmode = ic->ic_opmode; 3005 cc->ic_flags = ic->ic_flags; 3006 cc->ic_txpowlimit = ic->ic_txpowlimit; 3007 cc->ic_curmode = ic->ic_curmode; 3008 3009 bcopy(ic->ic_myaddr, cc->ic_myaddr, 3010 sizeof(cc->ic_myaddr)); 3011 } 3012 } 3013 sc->sc_flags |= ZYD_FLAG_WAIT_COMMAND; 3014} 3015 3016static void 3017zyd_end_of_commands(struct zyd_softc *sc) 3018{ 3019 sc->sc_flags &= ~ZYD_FLAG_WAIT_COMMAND; 3020 3021 /* start write transfer, if not started */ 3022 usb2_transfer_start(sc->sc_xfer[ZYD_BULK_DT_WR]); 3023} 3024 3025static void 3026zyd_newassoc_cb(struct ieee80211_node *ni, int isnew) 3027{ 3028 struct ieee80211vap *vap = ni->ni_vap; 3029 3030 ieee80211_amrr_node_init(&ZYD_VAP(vap)->amrr, &ZYD_NODE(ni)->amn, ni); 3031} 3032 3033static void 3034zyd_cfg_amrr_timeout(struct zyd_softc *sc, 3035 struct usb2_config_td_cc *cc, uint16_t refcount) 3036{ 3037 struct ieee80211vap *vap; 3038 struct ieee80211_node *ni; 3039 3040 vap = zyd_get_vap(sc); 3041 if (vap == NULL) { 3042 return; 3043 } 3044 ni = vap->iv_bss; 3045 if (ni == NULL) { 3046 return; 3047 } 3048 if ((sc->sc_flags & ZYD_FLAG_LL_READY) && 3049 (sc->sc_flags & ZYD_FLAG_HL_READY)) { 3050 3051 if (sc->sc_amrr_timer) { 3052 3053 if (ieee80211_amrr_choose(ni, &ZYD_NODE(ni)->amn)) { 3054 /* ignore */ 3055 } 3056 } 3057 } 3058} 3059 3060static void 3061zyd_cfg_amrr_start(struct zyd_softc *sc) 3062{ 3063 struct ieee80211vap *vap; 3064 struct ieee80211_node *ni; 3065 3066 vap = zyd_get_vap(sc); 3067 3068 if (vap == NULL) { 3069 return; 3070 } 3071 ni = vap->iv_bss; 3072 if (ni == NULL) { 3073 return; 3074 } 3075 /* init AMRR */ 3076 3077 ieee80211_amrr_node_init(&ZYD_VAP(vap)->amrr, &ZYD_NODE(ni)->amn, ni); 3078 3079 /* enable AMRR timer */ 3080 3081 sc->sc_amrr_timer = 1; 3082} 3083 3084static struct ieee80211vap * 3085zyd_vap_create(struct ieee80211com *ic, 3086 const char name[IFNAMSIZ], int unit, int opmode, int flags, 3087 const uint8_t bssid[IEEE80211_ADDR_LEN], 3088 const uint8_t mac[IEEE80211_ADDR_LEN]) 3089{ 3090 struct zyd_vap *zvp; 3091 struct ieee80211vap *vap; 3092 struct zyd_softc *sc = ic->ic_ifp->if_softc; 3093 3094 /* Need to sync with config thread: */ 3095 mtx_lock(&sc->sc_mtx); 3096 if (usb2_config_td_sync(&sc->sc_config_td)) { 3097 mtx_unlock(&sc->sc_mtx); 3098 /* config thread is gone */ 3099 return (NULL); 3100 } 3101 mtx_unlock(&sc->sc_mtx); 3102 3103 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 3104 return NULL; 3105 zvp = (struct zyd_vap *)malloc(sizeof(struct zyd_vap), 3106 M_80211_VAP, M_NOWAIT | M_ZERO); 3107 if (zvp == NULL) 3108 return NULL; 3109 vap = &zvp->vap; 3110 /* enable s/w bmiss handling for sta mode */ 3111 ieee80211_vap_setup(ic, vap, name, unit, opmode, 3112 flags | IEEE80211_CLONE_NOBEACONS, bssid, mac); 3113 3114 /* override state transition machine */ 3115 zvp->newstate = vap->iv_newstate; 3116 vap->iv_newstate = &zyd_newstate_cb; 3117 3118 ieee80211_amrr_init(&zvp->amrr, vap, 3119 IEEE80211_AMRR_MIN_SUCCESS_THRESHOLD, 3120 IEEE80211_AMRR_MAX_SUCCESS_THRESHOLD, 3121 1000 /* 1 sec */ ); 3122 3123 /* complete setup */ 3124 ieee80211_vap_attach(vap, ieee80211_media_change, ieee80211_media_status); 3125 ic->ic_opmode = opmode; 3126 3127 return (vap); 3128} 3129 3130static void 3131zyd_vap_delete(struct ieee80211vap *vap) 3132{ 3133 struct zyd_vap *zvp = ZYD_VAP(vap); 3134 struct zyd_softc *sc = vap->iv_ic->ic_ifp->if_softc; 3135 3136 /* Need to sync with config thread: */ 3137 mtx_lock(&sc->sc_mtx); 3138 if (usb2_config_td_sync(&sc->sc_config_td)) { 3139 /* ignore */ 3140 } 3141 mtx_unlock(&sc->sc_mtx); 3142 3143 ieee80211_amrr_cleanup(&zvp->amrr); 3144 ieee80211_vap_detach(vap); 3145 free(zvp, M_80211_VAP); 3146} 3147 3148/* ARGUSED */ 3149static struct ieee80211_node * 3150zyd_node_alloc_cb(struct ieee80211vap *vap __unused, 3151 const uint8_t mac[IEEE80211_ADDR_LEN] __unused) 3152{ 3153 struct zyd_node *zn; 3154 3155 zn = malloc(sizeof(struct zyd_node), M_80211_NODE, M_NOWAIT | M_ZERO); 3156 return ((zn != NULL) ? &zn->ni : NULL); 3157} 3158 3159static void 3160zyd_fill_write_queue(struct zyd_softc *sc) 3161{ 3162 struct ifnet *ifp = sc->sc_ifp; 3163 struct ieee80211_node *ni; 3164 struct mbuf *m; 3165 3166 /* 3167 * We only fill up half of the queue with data frames. The rest is 3168 * reserved for other kinds of frames. 3169 */ 3170 3171 while (sc->sc_tx_queue.ifq_len < (IFQ_MAXLEN / 2)) { 3172 3173 IFQ_DRV_DEQUEUE(&ifp->if_snd, m); 3174 if (m == NULL) 3175 break; 3176 3177 ni = (void *)(m->m_pkthdr.rcvif); 3178 m = ieee80211_encap(ni, m); 3179 if (m == NULL) { 3180 ieee80211_free_node(ni); 3181 continue; 3182 } 3183 zyd_tx_data(sc, m, ni); 3184 } 3185} 3186 3187static void 3188zyd_tx_clean_queue(struct zyd_softc *sc) 3189{ 3190 struct mbuf *m; 3191 3192 for (;;) { 3193 _IF_DEQUEUE(&sc->sc_tx_queue, m); 3194 3195 if (!m) { 3196 break; 3197 } 3198 zyd_tx_freem(m); 3199 } 3200} 3201 3202static void 3203zyd_tx_freem(struct mbuf *m) 3204{ 3205 struct ieee80211_node *ni; 3206 3207 while (m) { 3208 ni = (void *)(m->m_pkthdr.rcvif); 3209 if (!ni) { 3210 m = m_free(m); 3211 continue; 3212 } 3213 if (m->m_flags & M_TXCB) { 3214 ieee80211_process_callback(ni, m, 0); 3215 } 3216 m_freem(m); 3217 ieee80211_free_node(ni); 3218 3219 break; 3220 } 3221} 3222 3223static void 3224zyd_tx_mgt(struct zyd_softc *sc, struct mbuf *m, struct ieee80211_node *ni) 3225{ 3226 struct ieee80211vap *vap = ni->ni_vap; 3227 struct ieee80211com *ic = ni->ni_ic; 3228 const struct ieee80211_txparam *tp; 3229 struct ieee80211_frame *wh; 3230 struct ieee80211_key *k; 3231 uint16_t totlen; 3232 uint16_t rate; 3233 3234 tp = &vap->iv_txparms[ieee80211_chan2mode(ic->ic_curchan)]; 3235 rate = tp->mgmtrate; 3236 3237 wh = mtod(m, struct ieee80211_frame *); 3238 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 3239 k = ieee80211_crypto_encap(ni, m); 3240 if (k == NULL) { 3241 m_freem(m); 3242 ieee80211_free_node(ni); 3243 return; 3244 } 3245 wh = mtod(m, struct ieee80211_frame *); 3246 } 3247 /* fill Tx descriptor */ 3248 3249 sc->sc_tx_desc.flags = ZYD_TX_FLAG_BACKOFF; 3250 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { 3251 /* get total length */ 3252 totlen = m->m_pkthdr.len + IEEE80211_CRC_LEN; 3253 /* multicast frames are not sent at OFDM rates in 802.11b/g */ 3254 if (totlen > vap->iv_rtsthreshold) { 3255 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_RTS; 3256 } else if (ZYD_RATE_IS_OFDM(rate) && 3257 (ic->ic_flags & IEEE80211_F_USEPROT)) { 3258 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 3259 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_CTS_TO_SELF; 3260 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 3261 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_RTS; 3262 } 3263 } else 3264 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_MULTICAST; 3265 3266 if ((wh->i_fc[0] & 3267 (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == 3268 (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL)) 3269 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL); 3270 3271 m->m_pkthdr.rcvif = (void *)ni; 3272 zyd_setup_desc_and_tx(sc, m, rate); 3273} 3274 3275static void 3276zyd_tx_data(struct zyd_softc *sc, struct mbuf *m, struct ieee80211_node *ni) 3277{ 3278 struct ieee80211vap *vap = ni->ni_vap; 3279 struct ieee80211com *ic = ni->ni_ic; 3280 const struct ieee80211_txparam *tp; 3281 struct ieee80211_frame *wh; 3282 struct ieee80211_key *k; 3283 uint16_t rate; 3284 3285 wh = mtod(m, struct ieee80211_frame *); 3286 3287 sc->sc_tx_desc.flags = ZYD_TX_FLAG_BACKOFF; 3288 tp = &vap->iv_txparms[ieee80211_chan2mode(ni->ni_chan)]; 3289 if (IEEE80211_IS_MULTICAST(wh->i_addr1)) { 3290 rate = tp->mcastrate; 3291 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_MULTICAST; 3292 } else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) { 3293 rate = tp->ucastrate; 3294 } else 3295 rate = ni->ni_txrate; 3296 3297 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 3298 k = ieee80211_crypto_encap(ni, m); 3299 if (k == NULL) { 3300 m_freem(m); 3301 ieee80211_free_node(ni); 3302 return; 3303 } 3304 /* packet header may have moved, reset our local pointer */ 3305 wh = mtod(m, struct ieee80211_frame *); 3306 } 3307 /* fill Tx descriptor */ 3308 3309 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) { 3310 uint16_t totlen; 3311 3312 totlen = m->m_pkthdr.len + IEEE80211_CRC_LEN; 3313 3314 /* multicast frames are not sent at OFDM rates in 802.11b/g */ 3315 if (totlen > vap->iv_rtsthreshold) { 3316 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_RTS; 3317 } else if (ZYD_RATE_IS_OFDM(rate) && 3318 (ic->ic_flags & IEEE80211_F_USEPROT)) { 3319 if (ic->ic_protmode == IEEE80211_PROT_CTSONLY) 3320 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_CTS_TO_SELF; 3321 else if (ic->ic_protmode == IEEE80211_PROT_RTSCTS) 3322 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_RTS; 3323 } 3324 } 3325 if ((wh->i_fc[0] & 3326 (IEEE80211_FC0_TYPE_MASK | IEEE80211_FC0_SUBTYPE_MASK)) == 3327 (IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_PS_POLL)) 3328 sc->sc_tx_desc.flags |= ZYD_TX_FLAG_TYPE(ZYD_TX_TYPE_PS_POLL); 3329 3330 m->m_pkthdr.rcvif = (void *)ni; 3331 zyd_setup_desc_and_tx(sc, m, rate); 3332} 3333 3334static int 3335zyd_raw_xmit_cb(struct ieee80211_node *ni, struct mbuf *m, 3336 const struct ieee80211_bpf_params *params) 3337{ 3338 struct ieee80211com *ic = ni->ni_ic; 3339 struct ifnet *ifp = ic->ic_ifp; 3340 struct zyd_softc *sc = ifp->if_softc; 3341 3342 mtx_lock(&sc->sc_mtx); 3343 if (params == NULL) { 3344 /* 3345 * Legacy path; interpret frame contents to decide 3346 * precisely how to send the frame. 3347 */ 3348 zyd_tx_mgt(sc, m, ni); 3349 } else { 3350 /* 3351 * Caller supplied explicit parameters to use in 3352 * sending the frame. 3353 */ 3354 zyd_tx_mgt(sc, m, ni); /* XXX zyd_tx_raw() */ 3355 } 3356 mtx_unlock(&sc->sc_mtx); 3357 return (0); 3358} 3359 3360static struct ieee80211vap * 3361zyd_get_vap(struct zyd_softc *sc) 3362{ 3363 struct ifnet *ifp; 3364 struct ieee80211com *ic; 3365 3366 if (sc == NULL) { 3367 return NULL; 3368 } 3369 ifp = sc->sc_ifp; 3370 if (ifp == NULL) { 3371 return NULL; 3372 } 3373 ic = ifp->if_l2com; 3374 if (ic == NULL) { 3375 return NULL; 3376 } 3377 return TAILQ_FIRST(&ic->ic_vaps); 3378} 3379