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