1 /* $OpenBSD: if_urtwn.c,v 1.16 2011/02/10 17:26:40 jakemsr Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr> 5 * Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org> 6 * Copyright (c) 2015 Andriy Voskoboinyk <avos@FreeBSD.org> 7 * 8 * Permission to use, copy, modify, and distribute this software for any 9 * purpose with or without fee is hereby granted, provided that the above 10 * copyright notice and this permission notice appear in all copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 19 */ 20 21 #include <sys/cdefs.h> 22 __FBSDID("$FreeBSD$"); 23 24 /* 25 * Driver for Realtek RTL8188CE-VAU/RTL8188CUS/RTL8188EU/RTL8188RU/RTL8192CU. 26 */ 27 28 #include "opt_wlan.h" 29 #include "opt_urtwn.h" 30 31 #include <sys/param.h> 32 #include <sys/sockio.h> 33 #include <sys/sysctl.h> 34 #include <sys/lock.h> 35 #include <sys/mutex.h> 36 #include <sys/condvar.h> 37 #include <sys/mbuf.h> 38 #include <sys/kernel.h> 39 #include <sys/socket.h> 40 #include <sys/systm.h> 41 #include <sys/malloc.h> 42 #include <sys/module.h> 43 #include <sys/bus.h> 44 #include <sys/endian.h> 45 #include <sys/linker.h> 46 #include <sys/firmware.h> 47 #if defined(__DragonFly__) 48 #else 49 #include <sys/kdb.h> 50 51 #include <machine/bus.h> 52 #include <machine/resource.h> 53 #endif 54 55 #include <sys/rman.h> 56 57 #include <net/bpf.h> 58 #include <net/if.h> 59 #include <net/if_var.h> 60 #include <net/if_arp.h> 61 #include <net/ethernet.h> 62 #include <net/if_dl.h> 63 #include <net/if_media.h> 64 #include <net/if_types.h> 65 66 #include <netinet/in.h> 67 #include <netinet/in_systm.h> 68 #include <netinet/in_var.h> 69 #include <netinet/if_ether.h> 70 #include <netinet/ip.h> 71 72 #include <netproto/802_11/ieee80211_var.h> 73 #include <netproto/802_11/ieee80211_regdomain.h> 74 #include <netproto/802_11/ieee80211_radiotap.h> 75 #include <netproto/802_11/ieee80211_ratectl.h> 76 #ifdef IEEE80211_SUPPORT_SUPERG 77 #include <netproto/802_11/ieee80211_superg.h> 78 #endif 79 80 #include <bus/u4b/usb.h> 81 #include <bus/u4b/usbdi.h> 82 #include <bus/u4b/usb_device.h> 83 #include "usbdevs.h" 84 85 #include <bus/u4b/usb_debug.h> 86 87 #include <bus/u4b/wlan/if_urtwnreg.h> 88 #include <bus/u4b/wlan/if_urtwnvar.h> 89 90 #ifdef USB_DEBUG 91 enum { 92 URTWN_DEBUG_XMIT = 0x00000001, /* basic xmit operation */ 93 URTWN_DEBUG_RECV = 0x00000002, /* basic recv operation */ 94 URTWN_DEBUG_STATE = 0x00000004, /* 802.11 state transitions */ 95 URTWN_DEBUG_RA = 0x00000008, /* f/w rate adaptation setup */ 96 URTWN_DEBUG_USB = 0x00000010, /* usb requests */ 97 URTWN_DEBUG_FIRMWARE = 0x00000020, /* firmware(9) loading debug */ 98 URTWN_DEBUG_BEACON = 0x00000040, /* beacon handling */ 99 URTWN_DEBUG_INTR = 0x00000080, /* ISR */ 100 URTWN_DEBUG_TEMP = 0x00000100, /* temperature calibration */ 101 URTWN_DEBUG_ROM = 0x00000200, /* various ROM info */ 102 URTWN_DEBUG_KEY = 0x00000400, /* crypto keys management */ 103 URTWN_DEBUG_TXPWR = 0x00000800, /* dump Tx power values */ 104 URTWN_DEBUG_RSSI = 0x00001000, /* dump RSSI lookups */ 105 URTWN_DEBUG_ANY = 0xffffffff 106 }; 107 108 #define URTWN_DPRINTF(_sc, _m, ...) do { \ 109 if ((_sc)->sc_debug & (_m)) \ 110 device_printf((_sc)->sc_dev, __VA_ARGS__); \ 111 } while(0) 112 113 #else 114 #define URTWN_DPRINTF(_sc, _m, ...) do { (void) sc; } while (0) 115 #endif 116 117 #define IEEE80211_HAS_ADDR4(wh) IEEE80211_IS_DSTODS(wh) 118 119 static int urtwn_enable_11n = 1; 120 TUNABLE_INT("hw.usb.urtwn.enable_11n", &urtwn_enable_11n); 121 122 /* various supported device vendors/products */ 123 static const STRUCT_USB_HOST_ID urtwn_devs[] = { 124 #define URTWN_DEV(v,p) { USB_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p) } 125 #define URTWN_RTL8188E_DEV(v,p) \ 126 { USB_VPI(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, URTWN_RTL8188E) } 127 #define URTWN_RTL8188E 1 128 URTWN_DEV(ABOCOM, RTL8188CU_1), 129 URTWN_DEV(ABOCOM, RTL8188CU_2), 130 URTWN_DEV(ABOCOM, RTL8192CU), 131 URTWN_DEV(ASUS, RTL8192CU), 132 URTWN_DEV(ASUS, USBN10NANO), 133 URTWN_DEV(AZUREWAVE, RTL8188CE_1), 134 URTWN_DEV(AZUREWAVE, RTL8188CE_2), 135 URTWN_DEV(AZUREWAVE, RTL8188CU), 136 URTWN_DEV(BELKIN, F7D2102), 137 URTWN_DEV(BELKIN, RTL8188CU), 138 URTWN_DEV(BELKIN, RTL8192CU), 139 URTWN_DEV(CHICONY, RTL8188CUS_1), 140 URTWN_DEV(CHICONY, RTL8188CUS_2), 141 URTWN_DEV(CHICONY, RTL8188CUS_3), 142 URTWN_DEV(CHICONY, RTL8188CUS_4), 143 URTWN_DEV(CHICONY, RTL8188CUS_5), 144 URTWN_DEV(COREGA, RTL8192CU), 145 URTWN_DEV(DLINK, RTL8188CU), 146 URTWN_DEV(DLINK, RTL8192CU_1), 147 URTWN_DEV(DLINK, RTL8192CU_2), 148 URTWN_DEV(DLINK, RTL8192CU_3), 149 URTWN_DEV(DLINK, DWA131B), 150 URTWN_DEV(EDIMAX, EW7811UN), 151 URTWN_DEV(EDIMAX, RTL8192CU), 152 URTWN_DEV(FEIXUN, RTL8188CU), 153 URTWN_DEV(FEIXUN, RTL8192CU), 154 URTWN_DEV(GUILLEMOT, HWNUP150), 155 URTWN_DEV(HAWKING, RTL8192CU), 156 URTWN_DEV(HP3, RTL8188CU), 157 URTWN_DEV(NETGEAR, WNA1000M), 158 URTWN_DEV(NETGEAR, RTL8192CU), 159 URTWN_DEV(NETGEAR4, RTL8188CU), 160 URTWN_DEV(NOVATECH, RTL8188CU), 161 URTWN_DEV(PLANEX2, RTL8188CU_1), 162 URTWN_DEV(PLANEX2, RTL8188CU_2), 163 URTWN_DEV(PLANEX2, RTL8188CU_3), 164 URTWN_DEV(PLANEX2, RTL8188CU_4), 165 URTWN_DEV(PLANEX2, RTL8188CUS), 166 URTWN_DEV(PLANEX2, RTL8192CU), 167 URTWN_DEV(REALTEK, RTL8188CE_0), 168 URTWN_DEV(REALTEK, RTL8188CE_1), 169 URTWN_DEV(REALTEK, RTL8188CTV), 170 URTWN_DEV(REALTEK, RTL8188CU_0), 171 URTWN_DEV(REALTEK, RTL8188CU_1), 172 URTWN_DEV(REALTEK, RTL8188CU_2), 173 URTWN_DEV(REALTEK, RTL8188CU_3), 174 URTWN_DEV(REALTEK, RTL8188CU_COMBO), 175 URTWN_DEV(REALTEK, RTL8188CUS), 176 URTWN_DEV(REALTEK, RTL8188RU_1), 177 URTWN_DEV(REALTEK, RTL8188RU_2), 178 URTWN_DEV(REALTEK, RTL8188RU_3), 179 URTWN_DEV(REALTEK, RTL8191CU), 180 URTWN_DEV(REALTEK, RTL8192CE), 181 URTWN_DEV(REALTEK, RTL8192CU), 182 URTWN_DEV(SITECOMEU, RTL8188CU_1), 183 URTWN_DEV(SITECOMEU, RTL8188CU_2), 184 URTWN_DEV(SITECOMEU, RTL8192CU), 185 URTWN_DEV(TRENDNET, RTL8188CU), 186 URTWN_DEV(TRENDNET, RTL8192CU), 187 URTWN_DEV(ZYXEL, RTL8192CU), 188 /* URTWN_RTL8188E */ 189 URTWN_RTL8188E_DEV(ABOCOM, RTL8188EU), 190 URTWN_RTL8188E_DEV(DLINK, DWA123D1), 191 URTWN_RTL8188E_DEV(DLINK, DWA125D1), 192 URTWN_RTL8188E_DEV(ELECOM, WDC150SU2M), 193 URTWN_RTL8188E_DEV(REALTEK, RTL8188ETV), 194 URTWN_RTL8188E_DEV(REALTEK, RTL8188EU), 195 #undef URTWN_RTL8188E_DEV 196 #undef URTWN_DEV 197 }; 198 199 static device_probe_t urtwn_match; 200 static device_attach_t urtwn_attach; 201 static device_detach_t urtwn_detach; 202 203 static usb_callback_t urtwn_bulk_tx_callback; 204 static usb_callback_t urtwn_bulk_rx_callback; 205 206 static void urtwn_sysctlattach(struct urtwn_softc *); 207 static void urtwn_drain_mbufq(struct urtwn_softc *); 208 static usb_error_t urtwn_do_request(struct urtwn_softc *, 209 struct usb_device_request *, void *); 210 static struct ieee80211vap *urtwn_vap_create(struct ieee80211com *, 211 const char [IFNAMSIZ], int, enum ieee80211_opmode, int, 212 const uint8_t [IEEE80211_ADDR_LEN], 213 const uint8_t [IEEE80211_ADDR_LEN]); 214 static void urtwn_vap_delete(struct ieee80211vap *); 215 static struct mbuf * urtwn_rx_copy_to_mbuf(struct urtwn_softc *, 216 struct r92c_rx_stat *, int); 217 static struct mbuf * urtwn_report_intr(struct usb_xfer *, 218 struct urtwn_data *); 219 static struct mbuf * urtwn_rxeof(struct urtwn_softc *, uint8_t *, int); 220 static void urtwn_r88e_ratectl_tx_complete(struct urtwn_softc *, 221 void *); 222 static struct ieee80211_node *urtwn_rx_frame(struct urtwn_softc *, 223 struct mbuf *, int8_t *); 224 static void urtwn_txeof(struct urtwn_softc *, struct urtwn_data *, 225 int); 226 static int urtwn_alloc_list(struct urtwn_softc *, 227 struct urtwn_data[], int, int); 228 static int urtwn_alloc_rx_list(struct urtwn_softc *); 229 static int urtwn_alloc_tx_list(struct urtwn_softc *); 230 static void urtwn_free_list(struct urtwn_softc *, 231 struct urtwn_data data[], int); 232 static void urtwn_free_rx_list(struct urtwn_softc *); 233 static void urtwn_free_tx_list(struct urtwn_softc *); 234 static struct urtwn_data * _urtwn_getbuf(struct urtwn_softc *); 235 static struct urtwn_data * urtwn_getbuf(struct urtwn_softc *); 236 static usb_error_t urtwn_write_region_1(struct urtwn_softc *, uint16_t, 237 uint8_t *, int); 238 static usb_error_t urtwn_write_1(struct urtwn_softc *, uint16_t, uint8_t); 239 static usb_error_t urtwn_write_2(struct urtwn_softc *, uint16_t, uint16_t); 240 static usb_error_t urtwn_write_4(struct urtwn_softc *, uint16_t, uint32_t); 241 static usb_error_t urtwn_read_region_1(struct urtwn_softc *, uint16_t, 242 uint8_t *, int); 243 static uint8_t urtwn_read_1(struct urtwn_softc *, uint16_t); 244 static uint16_t urtwn_read_2(struct urtwn_softc *, uint16_t); 245 static uint32_t urtwn_read_4(struct urtwn_softc *, uint16_t); 246 static int urtwn_fw_cmd(struct urtwn_softc *, uint8_t, 247 const void *, int); 248 static void urtwn_cmdq_cb(void *, int); 249 static int urtwn_cmd_sleepable(struct urtwn_softc *, const void *, 250 size_t, CMD_FUNC_PROTO); 251 static void urtwn_r92c_rf_write(struct urtwn_softc *, int, 252 uint8_t, uint32_t); 253 static void urtwn_r88e_rf_write(struct urtwn_softc *, int, 254 uint8_t, uint32_t); 255 static uint32_t urtwn_rf_read(struct urtwn_softc *, int, uint8_t); 256 static int urtwn_llt_write(struct urtwn_softc *, uint32_t, 257 uint32_t); 258 static int urtwn_efuse_read_next(struct urtwn_softc *, uint8_t *); 259 static int urtwn_efuse_read_data(struct urtwn_softc *, uint8_t *, 260 uint8_t, uint8_t); 261 #ifdef USB_DEBUG 262 static void urtwn_dump_rom_contents(struct urtwn_softc *, 263 uint8_t *, uint16_t); 264 #endif 265 static int urtwn_efuse_read(struct urtwn_softc *, uint8_t *, 266 uint16_t); 267 static int urtwn_efuse_switch_power(struct urtwn_softc *); 268 static int urtwn_read_chipid(struct urtwn_softc *); 269 static int urtwn_read_rom(struct urtwn_softc *); 270 static int urtwn_r88e_read_rom(struct urtwn_softc *); 271 static int urtwn_ra_init(struct urtwn_softc *); 272 static void urtwn_init_beacon(struct urtwn_softc *, 273 struct urtwn_vap *); 274 static int urtwn_setup_beacon(struct urtwn_softc *, 275 struct ieee80211_node *); 276 static void urtwn_update_beacon(struct ieee80211vap *, int); 277 static int urtwn_tx_beacon(struct urtwn_softc *sc, 278 struct urtwn_vap *); 279 static int urtwn_key_alloc(struct ieee80211vap *, 280 struct ieee80211_key *, ieee80211_keyix *, 281 ieee80211_keyix *); 282 static void urtwn_key_set_cb(struct urtwn_softc *, 283 union sec_param *); 284 static void urtwn_key_del_cb(struct urtwn_softc *, 285 union sec_param *); 286 static int urtwn_key_set(struct ieee80211vap *, 287 const struct ieee80211_key *); 288 static int urtwn_key_delete(struct ieee80211vap *, 289 const struct ieee80211_key *); 290 static void urtwn_tsf_task_adhoc(void *, int); 291 static void urtwn_tsf_sync_enable(struct urtwn_softc *, 292 struct ieee80211vap *); 293 static void urtwn_get_tsf(struct urtwn_softc *, uint64_t *); 294 static void urtwn_set_led(struct urtwn_softc *, int, int); 295 static void urtwn_set_mode(struct urtwn_softc *, uint8_t); 296 static void urtwn_ibss_recv_mgmt(struct ieee80211_node *, 297 struct mbuf *, int, 298 const struct ieee80211_rx_stats *, int, int); 299 static int urtwn_newstate(struct ieee80211vap *, 300 enum ieee80211_state, int); 301 static void urtwn_calib_to(void *); 302 static void urtwn_calib_cb(struct urtwn_softc *, 303 union sec_param *); 304 static void urtwn_watchdog(void *); 305 static void urtwn_update_avgrssi(struct urtwn_softc *, int, int8_t); 306 static int8_t urtwn_get_rssi(struct urtwn_softc *, int, void *); 307 static int8_t urtwn_r88e_get_rssi(struct urtwn_softc *, int, void *); 308 static int urtwn_tx_data(struct urtwn_softc *, 309 struct ieee80211_node *, struct mbuf *, 310 struct urtwn_data *); 311 static int urtwn_tx_raw(struct urtwn_softc *, 312 struct ieee80211_node *, struct mbuf *, 313 struct urtwn_data *, 314 const struct ieee80211_bpf_params *); 315 static void urtwn_tx_start(struct urtwn_softc *, struct mbuf *, 316 uint8_t, struct urtwn_data *); 317 static int urtwn_transmit(struct ieee80211com *, struct mbuf *); 318 static void urtwn_start(struct urtwn_softc *); 319 static void urtwn_parent(struct ieee80211com *); 320 static int urtwn_r92c_power_on(struct urtwn_softc *); 321 static int urtwn_r88e_power_on(struct urtwn_softc *); 322 static void urtwn_r92c_power_off(struct urtwn_softc *); 323 static void urtwn_r88e_power_off(struct urtwn_softc *); 324 static int urtwn_llt_init(struct urtwn_softc *); 325 #ifndef URTWN_WITHOUT_UCODE 326 static void urtwn_fw_reset(struct urtwn_softc *); 327 static void urtwn_r88e_fw_reset(struct urtwn_softc *); 328 static int urtwn_fw_loadpage(struct urtwn_softc *, int, 329 const uint8_t *, int); 330 static int urtwn_load_firmware(struct urtwn_softc *); 331 #endif 332 static int urtwn_dma_init(struct urtwn_softc *); 333 static int urtwn_mac_init(struct urtwn_softc *); 334 static void urtwn_bb_init(struct urtwn_softc *); 335 static void urtwn_rf_init(struct urtwn_softc *); 336 static void urtwn_cam_init(struct urtwn_softc *); 337 static int urtwn_cam_write(struct urtwn_softc *, uint32_t, 338 uint32_t); 339 static void urtwn_pa_bias_init(struct urtwn_softc *); 340 static void urtwn_rxfilter_init(struct urtwn_softc *); 341 static void urtwn_edca_init(struct urtwn_softc *); 342 static void urtwn_write_txpower(struct urtwn_softc *, int, 343 uint16_t[]); 344 static void urtwn_get_txpower(struct urtwn_softc *, int, 345 struct ieee80211_channel *, 346 struct ieee80211_channel *, uint16_t[]); 347 static void urtwn_r88e_get_txpower(struct urtwn_softc *, int, 348 struct ieee80211_channel *, 349 struct ieee80211_channel *, uint16_t[]); 350 static void urtwn_set_txpower(struct urtwn_softc *, 351 struct ieee80211_channel *, 352 struct ieee80211_channel *); 353 static void urtwn_set_rx_bssid_all(struct urtwn_softc *, int); 354 static void urtwn_set_gain(struct urtwn_softc *, uint8_t); 355 static void urtwn_scan_start(struct ieee80211com *); 356 static void urtwn_scan_end(struct ieee80211com *); 357 static void urtwn_set_channel(struct ieee80211com *); 358 static int urtwn_wme_update(struct ieee80211com *); 359 static void urtwn_update_slot(struct ieee80211com *); 360 static void urtwn_update_slot_cb(struct urtwn_softc *, 361 union sec_param *); 362 static void urtwn_update_aifs(struct urtwn_softc *, uint8_t); 363 static uint8_t urtwn_get_multi_pos(const uint8_t[]); 364 static void urtwn_set_multi(struct urtwn_softc *); 365 static void urtwn_set_promisc(struct urtwn_softc *); 366 static void urtwn_update_promisc(struct ieee80211com *); 367 static void urtwn_update_mcast(struct ieee80211com *); 368 static struct ieee80211_node *urtwn_node_alloc(struct ieee80211vap *, 369 const uint8_t mac[IEEE80211_ADDR_LEN]); 370 static void urtwn_newassoc(struct ieee80211_node *, int); 371 static void urtwn_node_free(struct ieee80211_node *); 372 static void urtwn_set_chan(struct urtwn_softc *, 373 struct ieee80211_channel *, 374 struct ieee80211_channel *); 375 static void urtwn_iq_calib(struct urtwn_softc *); 376 static void urtwn_lc_calib(struct urtwn_softc *); 377 static void urtwn_temp_calib(struct urtwn_softc *); 378 static int urtwn_init(struct urtwn_softc *); 379 static void urtwn_stop(struct urtwn_softc *); 380 static void urtwn_abort_xfers(struct urtwn_softc *); 381 static int urtwn_raw_xmit(struct ieee80211_node *, struct mbuf *, 382 const struct ieee80211_bpf_params *); 383 static void urtwn_ms_delay(struct urtwn_softc *); 384 385 /* Aliases. */ 386 #define urtwn_bb_write urtwn_write_4 387 #define urtwn_bb_read urtwn_read_4 388 389 static const struct usb_config urtwn_config[URTWN_N_TRANSFER] = { 390 [URTWN_BULK_RX] = { 391 .type = UE_BULK, 392 .endpoint = UE_ADDR_ANY, 393 .direction = UE_DIR_IN, 394 .bufsize = URTWN_RXBUFSZ, 395 .flags = { 396 .pipe_bof = 1, 397 .short_xfer_ok = 1 398 }, 399 .callback = urtwn_bulk_rx_callback, 400 }, 401 [URTWN_BULK_TX_BE] = { 402 .type = UE_BULK, 403 .endpoint = 0x03, 404 .direction = UE_DIR_OUT, 405 .bufsize = URTWN_TXBUFSZ, 406 .flags = { 407 .ext_buffer = 1, 408 .pipe_bof = 1, 409 .force_short_xfer = 1 410 }, 411 .callback = urtwn_bulk_tx_callback, 412 .timeout = URTWN_TX_TIMEOUT, /* ms */ 413 }, 414 [URTWN_BULK_TX_BK] = { 415 .type = UE_BULK, 416 .endpoint = 0x03, 417 .direction = UE_DIR_OUT, 418 .bufsize = URTWN_TXBUFSZ, 419 .flags = { 420 .ext_buffer = 1, 421 .pipe_bof = 1, 422 .force_short_xfer = 1, 423 }, 424 .callback = urtwn_bulk_tx_callback, 425 .timeout = URTWN_TX_TIMEOUT, /* ms */ 426 }, 427 [URTWN_BULK_TX_VI] = { 428 .type = UE_BULK, 429 .endpoint = 0x02, 430 .direction = UE_DIR_OUT, 431 .bufsize = URTWN_TXBUFSZ, 432 .flags = { 433 .ext_buffer = 1, 434 .pipe_bof = 1, 435 .force_short_xfer = 1 436 }, 437 .callback = urtwn_bulk_tx_callback, 438 .timeout = URTWN_TX_TIMEOUT, /* ms */ 439 }, 440 [URTWN_BULK_TX_VO] = { 441 .type = UE_BULK, 442 .endpoint = 0x02, 443 .direction = UE_DIR_OUT, 444 .bufsize = URTWN_TXBUFSZ, 445 .flags = { 446 .ext_buffer = 1, 447 .pipe_bof = 1, 448 .force_short_xfer = 1 449 }, 450 .callback = urtwn_bulk_tx_callback, 451 .timeout = URTWN_TX_TIMEOUT, /* ms */ 452 }, 453 }; 454 455 static const struct wme_to_queue { 456 uint16_t reg; 457 uint8_t qid; 458 } wme2queue[WME_NUM_AC] = { 459 { R92C_EDCA_BE_PARAM, URTWN_BULK_TX_BE}, 460 { R92C_EDCA_BK_PARAM, URTWN_BULK_TX_BK}, 461 { R92C_EDCA_VI_PARAM, URTWN_BULK_TX_VI}, 462 { R92C_EDCA_VO_PARAM, URTWN_BULK_TX_VO} 463 }; 464 465 static int 466 urtwn_match(device_t self) 467 { 468 struct usb_attach_arg *uaa = device_get_ivars(self); 469 470 if (uaa->usb_mode != USB_MODE_HOST) 471 return (ENXIO); 472 if (uaa->info.bConfigIndex != URTWN_CONFIG_INDEX) 473 return (ENXIO); 474 if (uaa->info.bIfaceIndex != URTWN_IFACE_INDEX) 475 return (ENXIO); 476 477 return (usbd_lookup_id_by_uaa(urtwn_devs, sizeof(urtwn_devs), uaa)); 478 } 479 480 static void 481 urtwn_update_chw(struct ieee80211com *ic) 482 { 483 } 484 485 static int 486 urtwn_ampdu_enable(struct ieee80211_node *ni, struct ieee80211_tx_ampdu *tap) 487 { 488 489 /* We're driving this ourselves (eventually); don't involve net80211 */ 490 return (0); 491 } 492 493 static int 494 urtwn_attach(device_t self) 495 { 496 struct usb_attach_arg *uaa = device_get_ivars(self); 497 struct urtwn_softc *sc = device_get_softc(self); 498 struct ieee80211com *ic = &sc->sc_ic; 499 uint8_t bands[IEEE80211_MODE_BYTES]; 500 int error; 501 502 device_set_usb_desc(self); 503 sc->sc_udev = uaa->device; 504 sc->sc_dev = self; 505 if (USB_GET_DRIVER_INFO(uaa) == URTWN_RTL8188E) 506 sc->chip |= URTWN_CHIP_88E; 507 508 #ifdef USB_DEBUG 509 int debug; 510 if (resource_int_value(device_get_name(sc->sc_dev), 511 device_get_unit(sc->sc_dev), "debug", &debug) == 0) 512 sc->sc_debug = debug; 513 #endif 514 515 #if defined(__DragonFly__) 516 lockinit(&sc->sc_mtx, device_get_nameunit(self), 0, 0); 517 #else 518 mtx_init(&sc->sc_mtx, device_get_nameunit(self), 519 MTX_NETWORK_LOCK, MTX_DEF); 520 #endif 521 URTWN_CMDQ_LOCK_INIT(sc); 522 URTWN_NT_LOCK_INIT(sc); 523 #if defined(__DragonFly__) 524 callout_init(&sc->sc_calib_to); 525 callout_init(&sc->sc_watchdog_ch); 526 #else 527 callout_init(&sc->sc_calib_to, 0); 528 callout_init(&sc->sc_watchdog_ch, 0); 529 #endif 530 mbufq_init(&sc->sc_snd, ifqmaxlen); 531 532 sc->sc_iface_index = URTWN_IFACE_INDEX; 533 error = usbd_transfer_setup(uaa->device, &sc->sc_iface_index, 534 sc->sc_xfer, urtwn_config, URTWN_N_TRANSFER, sc, &sc->sc_mtx); 535 if (error) { 536 device_printf(self, "could not allocate USB transfers, " 537 "err=%s\n", usbd_errstr(error)); 538 goto detach; 539 } 540 541 URTWN_LOCK(sc); 542 543 error = urtwn_read_chipid(sc); 544 if (error) { 545 device_printf(sc->sc_dev, "unsupported test chip\n"); 546 URTWN_UNLOCK(sc); 547 goto detach; 548 } 549 550 /* Determine number of Tx/Rx chains. */ 551 if (sc->chip & URTWN_CHIP_92C) { 552 sc->ntxchains = (sc->chip & URTWN_CHIP_92C_1T2R) ? 1 : 2; 553 sc->nrxchains = 2; 554 } else { 555 sc->ntxchains = 1; 556 sc->nrxchains = 1; 557 } 558 559 if (sc->chip & URTWN_CHIP_88E) 560 error = urtwn_r88e_read_rom(sc); 561 else 562 error = urtwn_read_rom(sc); 563 if (error != 0) { 564 device_printf(sc->sc_dev, "%s: cannot read rom, error %d\n", 565 __func__, error); 566 URTWN_UNLOCK(sc); 567 goto detach; 568 } 569 570 device_printf(sc->sc_dev, "MAC/BB RTL%s, RF 6052 %dT%dR\n", 571 (sc->chip & URTWN_CHIP_92C) ? "8192CU" : 572 (sc->chip & URTWN_CHIP_88E) ? "8188EU" : 573 (sc->board_type == R92C_BOARD_TYPE_HIGHPA) ? "8188RU" : 574 (sc->board_type == R92C_BOARD_TYPE_MINICARD) ? "8188CE-VAU" : 575 "8188CUS", sc->ntxchains, sc->nrxchains); 576 577 URTWN_UNLOCK(sc); 578 579 ic->ic_softc = sc; 580 ic->ic_name = device_get_nameunit(self); 581 ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 582 ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ 583 584 /* set device capabilities */ 585 ic->ic_caps = 586 IEEE80211_C_STA /* station mode */ 587 | IEEE80211_C_MONITOR /* monitor mode */ 588 | IEEE80211_C_IBSS /* adhoc mode */ 589 | IEEE80211_C_HOSTAP /* hostap mode */ 590 | IEEE80211_C_SHPREAMBLE /* short preamble supported */ 591 | IEEE80211_C_SHSLOT /* short slot time supported */ 592 #if 0 593 | IEEE80211_C_BGSCAN /* capable of bg scanning */ 594 #endif 595 | IEEE80211_C_WPA /* 802.11i */ 596 | IEEE80211_C_WME /* 802.11e */ 597 | IEEE80211_C_SWAMSDUTX /* Do software A-MSDU TX */ 598 | IEEE80211_C_FF /* Atheros fast-frames */ 599 ; 600 601 ic->ic_cryptocaps = 602 IEEE80211_CRYPTO_WEP | 603 IEEE80211_CRYPTO_TKIP | 604 IEEE80211_CRYPTO_AES_CCM; 605 606 /* Assume they're all 11n capable for now */ 607 if (urtwn_enable_11n) { 608 device_printf(self, "enabling 11n\n"); 609 ic->ic_htcaps = IEEE80211_HTC_HT | 610 #if 0 611 IEEE80211_HTC_AMPDU | 612 #endif 613 IEEE80211_HTC_AMSDU | 614 IEEE80211_HTCAP_MAXAMSDU_3839 | 615 IEEE80211_HTCAP_SMPS_OFF; 616 /* no HT40 just yet */ 617 // ic->ic_htcaps |= IEEE80211_HTCAP_CHWIDTH40; 618 619 /* XXX TODO: verify chains versus streams for urtwn */ 620 ic->ic_txstream = sc->ntxchains; 621 ic->ic_rxstream = sc->nrxchains; 622 } 623 624 memset(bands, 0, sizeof(bands)); 625 setbit(bands, IEEE80211_MODE_11B); 626 setbit(bands, IEEE80211_MODE_11G); 627 if (urtwn_enable_11n) 628 setbit(bands, IEEE80211_MODE_11NG); 629 ieee80211_init_channels(ic, NULL, bands); 630 631 ieee80211_ifattach(ic); 632 ic->ic_raw_xmit = urtwn_raw_xmit; 633 ic->ic_scan_start = urtwn_scan_start; 634 ic->ic_scan_end = urtwn_scan_end; 635 ic->ic_set_channel = urtwn_set_channel; 636 ic->ic_transmit = urtwn_transmit; 637 ic->ic_parent = urtwn_parent; 638 ic->ic_vap_create = urtwn_vap_create; 639 ic->ic_vap_delete = urtwn_vap_delete; 640 ic->ic_wme.wme_update = urtwn_wme_update; 641 ic->ic_updateslot = urtwn_update_slot; 642 ic->ic_update_promisc = urtwn_update_promisc; 643 ic->ic_update_mcast = urtwn_update_mcast; 644 if (sc->chip & URTWN_CHIP_88E) { 645 ic->ic_node_alloc = urtwn_node_alloc; 646 ic->ic_newassoc = urtwn_newassoc; 647 sc->sc_node_free = ic->ic_node_free; 648 ic->ic_node_free = urtwn_node_free; 649 } 650 ic->ic_update_chw = urtwn_update_chw; 651 ic->ic_ampdu_enable = urtwn_ampdu_enable; 652 653 ieee80211_radiotap_attach(ic, &sc->sc_txtap.wt_ihdr, 654 sizeof(sc->sc_txtap), URTWN_TX_RADIOTAP_PRESENT, 655 &sc->sc_rxtap.wr_ihdr, sizeof(sc->sc_rxtap), 656 URTWN_RX_RADIOTAP_PRESENT); 657 658 TASK_INIT(&sc->cmdq_task, 0, urtwn_cmdq_cb, sc); 659 660 urtwn_sysctlattach(sc); 661 662 if (bootverbose) 663 ieee80211_announce(ic); 664 665 return (0); 666 667 detach: 668 urtwn_detach(self); 669 return (ENXIO); /* failure */ 670 } 671 672 static void 673 urtwn_sysctlattach(struct urtwn_softc *sc) 674 { 675 #ifdef USB_DEBUG 676 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 677 struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 678 679 SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 680 "debug", CTLFLAG_RW, &sc->sc_debug, sc->sc_debug, 681 "control debugging printfs"); 682 #endif 683 } 684 685 static int 686 urtwn_detach(device_t self) 687 { 688 struct urtwn_softc *sc = device_get_softc(self); 689 struct ieee80211com *ic = &sc->sc_ic; 690 unsigned int x; 691 692 /* Prevent further ioctls. */ 693 URTWN_LOCK(sc); 694 sc->sc_flags |= URTWN_DETACHED; 695 URTWN_UNLOCK(sc); 696 697 urtwn_stop(sc); 698 699 callout_drain(&sc->sc_watchdog_ch); 700 callout_drain(&sc->sc_calib_to); 701 702 /* stop all USB transfers */ 703 usbd_transfer_unsetup(sc->sc_xfer, URTWN_N_TRANSFER); 704 705 /* Prevent further allocations from RX/TX data lists. */ 706 URTWN_LOCK(sc); 707 STAILQ_INIT(&sc->sc_tx_active); 708 STAILQ_INIT(&sc->sc_tx_inactive); 709 STAILQ_INIT(&sc->sc_tx_pending); 710 711 STAILQ_INIT(&sc->sc_rx_active); 712 STAILQ_INIT(&sc->sc_rx_inactive); 713 URTWN_UNLOCK(sc); 714 715 /* drain USB transfers */ 716 for (x = 0; x != URTWN_N_TRANSFER; x++) 717 usbd_transfer_drain(sc->sc_xfer[x]); 718 719 /* Free data buffers. */ 720 URTWN_LOCK(sc); 721 urtwn_free_tx_list(sc); 722 urtwn_free_rx_list(sc); 723 URTWN_UNLOCK(sc); 724 725 if (ic->ic_softc == sc) { 726 ieee80211_draintask(ic, &sc->cmdq_task); 727 ieee80211_ifdetach(ic); 728 } 729 730 URTWN_NT_LOCK_DESTROY(sc); 731 URTWN_CMDQ_LOCK_DESTROY(sc); 732 lockuninit(&sc->sc_mtx); 733 734 return (0); 735 } 736 737 static void 738 urtwn_drain_mbufq(struct urtwn_softc *sc) 739 { 740 struct mbuf *m; 741 struct ieee80211_node *ni; 742 URTWN_ASSERT_LOCKED(sc); 743 while ((m = mbufq_dequeue(&sc->sc_snd)) != NULL) { 744 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 745 m->m_pkthdr.rcvif = NULL; 746 ieee80211_free_node(ni); 747 m_freem(m); 748 } 749 } 750 751 static usb_error_t 752 urtwn_do_request(struct urtwn_softc *sc, struct usb_device_request *req, 753 void *data) 754 { 755 usb_error_t err; 756 int ntries = 10; 757 758 URTWN_ASSERT_LOCKED(sc); 759 760 while (ntries--) { 761 err = usbd_do_request_flags(sc->sc_udev, &sc->sc_mtx, 762 req, data, 0, NULL, 250 /* ms */); 763 if (err == 0) 764 break; 765 766 URTWN_DPRINTF(sc, URTWN_DEBUG_USB, 767 "%s: control request failed, %s (retries left: %d)\n", 768 __func__, usbd_errstr(err), ntries); 769 usb_pause_mtx(&sc->sc_mtx, hz / 100); 770 } 771 return (err); 772 } 773 774 static struct ieee80211vap * 775 urtwn_vap_create(struct ieee80211com *ic, const char name[IFNAMSIZ], int unit, 776 enum ieee80211_opmode opmode, int flags, 777 const uint8_t bssid[IEEE80211_ADDR_LEN], 778 const uint8_t mac[IEEE80211_ADDR_LEN]) 779 { 780 struct urtwn_softc *sc = ic->ic_softc; 781 struct urtwn_vap *uvp; 782 struct ieee80211vap *vap; 783 784 if (!TAILQ_EMPTY(&ic->ic_vaps)) /* only one at a time */ 785 return (NULL); 786 787 uvp = kmalloc(sizeof(struct urtwn_vap), M_80211_VAP, M_WAITOK | M_ZERO); 788 vap = &uvp->vap; 789 /* enable s/w bmiss handling for sta mode */ 790 791 if (ieee80211_vap_setup(ic, vap, name, unit, opmode, 792 flags | IEEE80211_CLONE_NOBEACONS, bssid) != 0) { 793 /* out of memory */ 794 kfree(uvp, M_80211_VAP); 795 return (NULL); 796 } 797 798 if (opmode == IEEE80211_M_HOSTAP || opmode == IEEE80211_M_IBSS) 799 urtwn_init_beacon(sc, uvp); 800 801 /* override state transition machine */ 802 uvp->newstate = vap->iv_newstate; 803 vap->iv_newstate = urtwn_newstate; 804 vap->iv_update_beacon = urtwn_update_beacon; 805 vap->iv_key_alloc = urtwn_key_alloc; 806 vap->iv_key_set = urtwn_key_set; 807 vap->iv_key_delete = urtwn_key_delete; 808 809 /* 802.11n parameters */ 810 vap->iv_ampdu_density = IEEE80211_HTCAP_MPDUDENSITY_16; 811 vap->iv_ampdu_rxmax = IEEE80211_HTCAP_MAXRXAMPDU_64K; 812 813 if (opmode == IEEE80211_M_IBSS) { 814 uvp->recv_mgmt = vap->iv_recv_mgmt; 815 vap->iv_recv_mgmt = urtwn_ibss_recv_mgmt; 816 TASK_INIT(&uvp->tsf_task_adhoc, 0, urtwn_tsf_task_adhoc, vap); 817 } 818 819 if (URTWN_CHIP_HAS_RATECTL(sc)) 820 ieee80211_ratectl_init(vap); 821 /* complete setup */ 822 ieee80211_vap_attach(vap, ieee80211_media_change, 823 ieee80211_media_status, mac); 824 ic->ic_opmode = opmode; 825 return (vap); 826 } 827 828 static void 829 urtwn_vap_delete(struct ieee80211vap *vap) 830 { 831 struct ieee80211com *ic = vap->iv_ic; 832 struct urtwn_softc *sc = ic->ic_softc; 833 struct urtwn_vap *uvp = URTWN_VAP(vap); 834 835 if (uvp->bcn_mbuf != NULL) 836 m_freem(uvp->bcn_mbuf); 837 if (vap->iv_opmode == IEEE80211_M_IBSS) 838 ieee80211_draintask(ic, &uvp->tsf_task_adhoc); 839 if (URTWN_CHIP_HAS_RATECTL(sc)) 840 ieee80211_ratectl_deinit(vap); 841 ieee80211_vap_detach(vap); 842 kfree(uvp, M_80211_VAP); 843 } 844 845 static struct mbuf * 846 urtwn_rx_copy_to_mbuf(struct urtwn_softc *sc, struct r92c_rx_stat *stat, 847 int totlen) 848 { 849 /* ic is not used, remove to fix gcc warning */ 850 /* struct ieee80211com *ic = &sc->sc_ic; */ 851 struct mbuf *m; 852 uint32_t rxdw0; 853 int pktlen; 854 855 /* 856 * don't pass packets to the ieee80211 framework if the driver isn't 857 * RUNNING. 858 */ 859 if (!(sc->sc_flags & URTWN_RUNNING)) 860 return (NULL); 861 862 rxdw0 = le32toh(stat->rxdw0); 863 if (rxdw0 & (R92C_RXDW0_CRCERR | R92C_RXDW0_ICVERR)) { 864 /* 865 * This should not happen since we setup our Rx filter 866 * to not receive these frames. 867 */ 868 URTWN_DPRINTF(sc, URTWN_DEBUG_RECV, 869 "%s: RX flags error (%s)\n", __func__, 870 rxdw0 & R92C_RXDW0_CRCERR ? "CRC" : "ICV"); 871 goto fail; 872 } 873 874 pktlen = MS(rxdw0, R92C_RXDW0_PKTLEN); 875 if (pktlen < sizeof(struct ieee80211_frame_ack)) { 876 URTWN_DPRINTF(sc, URTWN_DEBUG_RECV, 877 "%s: frame is too short: %d\n", __func__, pktlen); 878 goto fail; 879 } 880 881 if (__predict_false(totlen > MCLBYTES)) { 882 /* convert to m_getjcl if this happens */ 883 device_printf(sc->sc_dev, "%s: frame too long: %d (%d)\n", 884 __func__, pktlen, totlen); 885 goto fail; 886 } 887 888 m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR); 889 if (__predict_false(m == NULL)) { 890 device_printf(sc->sc_dev, "%s: could not allocate RX mbuf\n", 891 __func__); 892 goto fail; 893 } 894 895 /* Finalize mbuf. */ 896 memcpy(mtod(m, uint8_t *), (uint8_t *)stat, totlen); 897 m->m_pkthdr.len = m->m_len = totlen; 898 899 return (m); 900 fail: 901 #if defined(__DragonFly__) 902 /* unimplemented */ 903 #else 904 counter_u64_add(ic->ic_ierrors, 1); 905 #endif 906 return (NULL); 907 } 908 909 static struct mbuf * 910 urtwn_report_intr(struct usb_xfer *xfer, struct urtwn_data *data) 911 { 912 struct urtwn_softc *sc = data->sc; 913 /* ic not used, remove to fix gcc error */ 914 /* struct ieee80211com *ic = &sc->sc_ic;*/ 915 struct r92c_rx_stat *stat; 916 uint8_t *buf; 917 int len; 918 919 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 920 921 if (len < sizeof(*stat)) { 922 #if defined(__DragonFly__) 923 /* unimplemented */ 924 #else 925 counter_u64_add(ic->ic_ierrors, 1); 926 #endif 927 return (NULL); 928 } 929 930 buf = data->buf; 931 stat = (struct r92c_rx_stat *)buf; 932 933 /* 934 * For 88E chips we can tie the FF flushing here; 935 * this is where we do know exactly how deep the 936 * transmit queue is. 937 * 938 * But it won't work for R92 chips, so we can't 939 * take the easy way out. 940 */ 941 942 if (sc->chip & URTWN_CHIP_88E) { 943 int report_sel = MS(le32toh(stat->rxdw3), R88E_RXDW3_RPT); 944 945 switch (report_sel) { 946 case R88E_RXDW3_RPT_RX: 947 return (urtwn_rxeof(sc, buf, len)); 948 case R88E_RXDW3_RPT_TX1: 949 urtwn_r88e_ratectl_tx_complete(sc, &stat[1]); 950 break; 951 default: 952 URTWN_DPRINTF(sc, URTWN_DEBUG_INTR, 953 "%s: case %d was not handled\n", __func__, 954 report_sel); 955 break; 956 } 957 } else 958 return (urtwn_rxeof(sc, buf, len)); 959 960 return (NULL); 961 } 962 963 static struct mbuf * 964 urtwn_rxeof(struct urtwn_softc *sc, uint8_t *buf, int len) 965 { 966 struct r92c_rx_stat *stat; 967 struct mbuf *m, *m0 = NULL, *prevm = NULL; 968 uint32_t rxdw0; 969 int totlen, pktlen, infosz, npkts; 970 971 /* Get the number of encapsulated frames. */ 972 stat = (struct r92c_rx_stat *)buf; 973 npkts = MS(le32toh(stat->rxdw2), R92C_RXDW2_PKTCNT); 974 URTWN_DPRINTF(sc, URTWN_DEBUG_RECV, 975 "%s: Rx %d frames in one chunk\n", __func__, npkts); 976 977 /* Process all of them. */ 978 while (npkts-- > 0) { 979 if (len < sizeof(*stat)) 980 break; 981 stat = (struct r92c_rx_stat *)buf; 982 rxdw0 = le32toh(stat->rxdw0); 983 984 pktlen = MS(rxdw0, R92C_RXDW0_PKTLEN); 985 if (pktlen == 0) 986 break; 987 988 infosz = MS(rxdw0, R92C_RXDW0_INFOSZ) * 8; 989 990 /* Make sure everything fits in xfer. */ 991 totlen = sizeof(*stat) + infosz + pktlen; 992 if (totlen > len) 993 break; 994 995 m = urtwn_rx_copy_to_mbuf(sc, stat, totlen); 996 if (m0 == NULL) 997 m0 = m; 998 if (prevm == NULL) 999 prevm = m; 1000 else { 1001 prevm->m_next = m; 1002 prevm = m; 1003 } 1004 1005 /* Next chunk is 128-byte aligned. */ 1006 totlen = (totlen + 127) & ~127; 1007 buf += totlen; 1008 len -= totlen; 1009 } 1010 1011 return (m0); 1012 } 1013 1014 static void 1015 urtwn_r88e_ratectl_tx_complete(struct urtwn_softc *sc, void *arg) 1016 { 1017 struct r88e_tx_rpt_ccx *rpt = arg; 1018 struct ieee80211vap *vap; 1019 struct ieee80211_node *ni; 1020 uint8_t macid; 1021 int ntries; 1022 1023 macid = MS(rpt->rptb1, R88E_RPTB1_MACID); 1024 ntries = MS(rpt->rptb2, R88E_RPTB2_RETRY_CNT); 1025 1026 URTWN_NT_LOCK(sc); 1027 ni = sc->node_list[macid]; 1028 if (ni != NULL) { 1029 vap = ni->ni_vap; 1030 URTWN_DPRINTF(sc, URTWN_DEBUG_INTR, "%s: frame for macid %d was" 1031 "%s sent (%d retries)\n", __func__, macid, 1032 (rpt->rptb1 & R88E_RPTB1_PKT_OK) ? "" : " not", 1033 ntries); 1034 1035 if (rpt->rptb1 & R88E_RPTB1_PKT_OK) { 1036 ieee80211_ratectl_tx_complete(vap, ni, 1037 IEEE80211_RATECTL_TX_SUCCESS, &ntries, NULL); 1038 } else { 1039 ieee80211_ratectl_tx_complete(vap, ni, 1040 IEEE80211_RATECTL_TX_FAILURE, &ntries, NULL); 1041 } 1042 } else { 1043 URTWN_DPRINTF(sc, URTWN_DEBUG_INTR, "%s: macid %d, ni is NULL\n", 1044 __func__, macid); 1045 } 1046 URTWN_NT_UNLOCK(sc); 1047 } 1048 1049 static struct ieee80211_node * 1050 urtwn_rx_frame(struct urtwn_softc *sc, struct mbuf *m, int8_t *rssi_p) 1051 { 1052 struct ieee80211com *ic = &sc->sc_ic; 1053 struct ieee80211_frame_min *wh; 1054 struct r92c_rx_stat *stat; 1055 uint32_t rxdw0, rxdw3; 1056 uint8_t rate, cipher; 1057 int8_t rssi = -127; 1058 int infosz; 1059 1060 stat = mtod(m, struct r92c_rx_stat *); 1061 rxdw0 = le32toh(stat->rxdw0); 1062 rxdw3 = le32toh(stat->rxdw3); 1063 1064 rate = MS(rxdw3, R92C_RXDW3_RATE); 1065 cipher = MS(rxdw0, R92C_RXDW0_CIPHER); 1066 infosz = MS(rxdw0, R92C_RXDW0_INFOSZ) * 8; 1067 1068 /* Get RSSI from PHY status descriptor if present. */ 1069 if (infosz != 0 && (rxdw0 & R92C_RXDW0_PHYST)) { 1070 if (sc->chip & URTWN_CHIP_88E) 1071 rssi = urtwn_r88e_get_rssi(sc, rate, &stat[1]); 1072 else 1073 rssi = urtwn_get_rssi(sc, rate, &stat[1]); 1074 URTWN_DPRINTF(sc, URTWN_DEBUG_RSSI, "%s: rssi=%d\n", __func__, rssi); 1075 /* Update our average RSSI. */ 1076 urtwn_update_avgrssi(sc, rate, rssi); 1077 } 1078 1079 if (ieee80211_radiotap_active(ic)) { 1080 struct urtwn_rx_radiotap_header *tap = &sc->sc_rxtap; 1081 1082 tap->wr_flags = 0; 1083 1084 urtwn_get_tsf(sc, &tap->wr_tsft); 1085 if (__predict_false(le32toh((uint32_t)tap->wr_tsft) < 1086 le32toh(stat->rxdw5))) { 1087 tap->wr_tsft = le32toh(tap->wr_tsft >> 32) - 1; 1088 tap->wr_tsft = (uint64_t)htole32(tap->wr_tsft) << 32; 1089 } else 1090 tap->wr_tsft &= 0xffffffff00000000; 1091 tap->wr_tsft += stat->rxdw5; 1092 1093 /* XXX 20/40? */ 1094 /* XXX shortgi? */ 1095 1096 /* Map HW rate index to 802.11 rate. */ 1097 if (!(rxdw3 & R92C_RXDW3_HT)) { 1098 tap->wr_rate = ridx2rate[rate]; 1099 } else if (rate >= 12) { /* MCS0~15. */ 1100 /* Bit 7 set means HT MCS instead of rate. */ 1101 tap->wr_rate = 0x80 | (rate - 12); 1102 } 1103 1104 /* XXX TODO: this isn't right; should use the last good RSSI */ 1105 tap->wr_dbm_antsignal = rssi; 1106 tap->wr_dbm_antnoise = URTWN_NOISE_FLOOR; 1107 } 1108 1109 *rssi_p = rssi; 1110 1111 /* Drop descriptor. */ 1112 m_adj(m, sizeof(*stat) + infosz); 1113 wh = mtod(m, struct ieee80211_frame_min *); 1114 1115 if ((wh->i_fc[1] & IEEE80211_FC1_PROTECTED) && 1116 cipher != R92C_CAM_ALGO_NONE) { 1117 m->m_flags |= M_WEP; 1118 } 1119 1120 if (m->m_len >= sizeof(*wh)) 1121 return (ieee80211_find_rxnode(ic, wh)); 1122 1123 return (NULL); 1124 } 1125 1126 static void 1127 urtwn_bulk_rx_callback(struct usb_xfer *xfer, usb_error_t error) 1128 { 1129 struct urtwn_softc *sc = usbd_xfer_softc(xfer); 1130 struct ieee80211com *ic = &sc->sc_ic; 1131 struct ieee80211_node *ni; 1132 struct mbuf *m = NULL, *next; 1133 struct urtwn_data *data; 1134 int8_t nf, rssi; 1135 1136 URTWN_ASSERT_LOCKED(sc); 1137 1138 switch (USB_GET_STATE(xfer)) { 1139 case USB_ST_TRANSFERRED: 1140 data = STAILQ_FIRST(&sc->sc_rx_active); 1141 if (data == NULL) 1142 goto tr_setup; 1143 STAILQ_REMOVE_HEAD(&sc->sc_rx_active, next); 1144 m = urtwn_report_intr(xfer, data); 1145 STAILQ_INSERT_TAIL(&sc->sc_rx_inactive, data, next); 1146 /* FALLTHROUGH */ 1147 case USB_ST_SETUP: 1148 tr_setup: 1149 data = STAILQ_FIRST(&sc->sc_rx_inactive); 1150 if (data == NULL) { 1151 KASSERT(m == NULL, ("mbuf isn't NULL")); 1152 goto finish; 1153 } 1154 STAILQ_REMOVE_HEAD(&sc->sc_rx_inactive, next); 1155 STAILQ_INSERT_TAIL(&sc->sc_rx_active, data, next); 1156 usbd_xfer_set_frame_data(xfer, 0, data->buf, 1157 usbd_xfer_max_len(xfer)); 1158 usbd_transfer_submit(xfer); 1159 1160 /* 1161 * To avoid LOR we should unlock our private mutex here to call 1162 * ieee80211_input() because here is at the end of a USB 1163 * callback and safe to unlock. 1164 */ 1165 while (m != NULL) { 1166 next = m->m_next; 1167 m->m_next = NULL; 1168 1169 ni = urtwn_rx_frame(sc, m, &rssi); 1170 1171 /* Store a global last-good RSSI */ 1172 if (rssi != -127) 1173 sc->last_rssi = rssi; 1174 1175 URTWN_UNLOCK(sc); 1176 1177 nf = URTWN_NOISE_FLOOR; 1178 if (ni != NULL) { 1179 if (rssi != -127) 1180 URTWN_NODE(ni)->last_rssi = rssi; 1181 if (ni->ni_flags & IEEE80211_NODE_HT) 1182 m->m_flags |= M_AMPDU; 1183 (void)ieee80211_input(ni, m, 1184 URTWN_NODE(ni)->last_rssi - nf, nf); 1185 ieee80211_free_node(ni); 1186 } else { 1187 /* Use last good global RSSI */ 1188 (void)ieee80211_input_all(ic, m, 1189 sc->last_rssi - nf, nf); 1190 } 1191 URTWN_LOCK(sc); 1192 m = next; 1193 } 1194 break; 1195 default: 1196 /* needs it to the inactive queue due to a error. */ 1197 data = STAILQ_FIRST(&sc->sc_rx_active); 1198 if (data != NULL) { 1199 STAILQ_REMOVE_HEAD(&sc->sc_rx_active, next); 1200 STAILQ_INSERT_TAIL(&sc->sc_rx_inactive, data, next); 1201 } 1202 if (error != USB_ERR_CANCELLED) { 1203 usbd_xfer_set_stall(xfer); 1204 #if defined(__DragonFly__) 1205 /* unimplemented */ 1206 #else 1207 counter_u64_add(ic->ic_ierrors, 1); 1208 #endif 1209 goto tr_setup; 1210 } 1211 break; 1212 } 1213 finish: 1214 /* Finished receive; age anything left on the FF queue by a little bump */ 1215 /* 1216 * XXX TODO: just make this a callout timer schedule so we can 1217 * flush the FF staging queue if we're approaching idle. 1218 */ 1219 #ifdef IEEE80211_SUPPORT_SUPERG 1220 URTWN_UNLOCK(sc); 1221 ieee80211_ff_age_all(ic, 1); 1222 URTWN_LOCK(sc); 1223 #endif 1224 1225 /* Kick-start more transmit in case we stalled */ 1226 urtwn_start(sc); 1227 } 1228 1229 static void 1230 urtwn_txeof(struct urtwn_softc *sc, struct urtwn_data *data, int status) 1231 { 1232 1233 URTWN_ASSERT_LOCKED(sc); 1234 1235 if (data->ni != NULL) /* not a beacon frame */ 1236 ieee80211_tx_complete(data->ni, data->m, status); 1237 1238 if (sc->sc_tx_n_active > 0) 1239 sc->sc_tx_n_active--; 1240 1241 data->ni = NULL; 1242 data->m = NULL; 1243 1244 sc->sc_txtimer = 0; 1245 1246 STAILQ_INSERT_TAIL(&sc->sc_tx_inactive, data, next); 1247 } 1248 1249 static int 1250 urtwn_alloc_list(struct urtwn_softc *sc, struct urtwn_data data[], 1251 int ndata, int maxsz) 1252 { 1253 int i, error; 1254 1255 for (i = 0; i < ndata; i++) { 1256 struct urtwn_data *dp = &data[i]; 1257 dp->sc = sc; 1258 dp->m = NULL; 1259 dp->buf = kmalloc(maxsz, M_USBDEV, M_INTWAIT); 1260 if (dp->buf == NULL) { 1261 device_printf(sc->sc_dev, 1262 "could not allocate buffer\n"); 1263 error = ENOMEM; 1264 goto fail; 1265 } 1266 dp->ni = NULL; 1267 } 1268 1269 return (0); 1270 fail: 1271 urtwn_free_list(sc, data, ndata); 1272 return (error); 1273 } 1274 1275 static int 1276 urtwn_alloc_rx_list(struct urtwn_softc *sc) 1277 { 1278 int error, i; 1279 1280 error = urtwn_alloc_list(sc, sc->sc_rx, URTWN_RX_LIST_COUNT, 1281 URTWN_RXBUFSZ); 1282 if (error != 0) 1283 return (error); 1284 1285 STAILQ_INIT(&sc->sc_rx_active); 1286 STAILQ_INIT(&sc->sc_rx_inactive); 1287 1288 for (i = 0; i < URTWN_RX_LIST_COUNT; i++) 1289 STAILQ_INSERT_HEAD(&sc->sc_rx_inactive, &sc->sc_rx[i], next); 1290 1291 return (0); 1292 } 1293 1294 static int 1295 urtwn_alloc_tx_list(struct urtwn_softc *sc) 1296 { 1297 int error, i; 1298 1299 error = urtwn_alloc_list(sc, sc->sc_tx, URTWN_TX_LIST_COUNT, 1300 URTWN_TXBUFSZ); 1301 if (error != 0) 1302 return (error); 1303 1304 STAILQ_INIT(&sc->sc_tx_active); 1305 STAILQ_INIT(&sc->sc_tx_inactive); 1306 STAILQ_INIT(&sc->sc_tx_pending); 1307 1308 for (i = 0; i < URTWN_TX_LIST_COUNT; i++) 1309 STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, &sc->sc_tx[i], next); 1310 1311 return (0); 1312 } 1313 1314 static void 1315 urtwn_free_list(struct urtwn_softc *sc, struct urtwn_data data[], int ndata) 1316 { 1317 int i; 1318 1319 for (i = 0; i < ndata; i++) { 1320 struct urtwn_data *dp = &data[i]; 1321 1322 if (dp->buf != NULL) { 1323 kfree(dp->buf, M_USBDEV); 1324 dp->buf = NULL; 1325 } 1326 if (dp->ni != NULL) { 1327 ieee80211_free_node(dp->ni); 1328 dp->ni = NULL; 1329 } 1330 } 1331 } 1332 1333 static void 1334 urtwn_free_rx_list(struct urtwn_softc *sc) 1335 { 1336 urtwn_free_list(sc, sc->sc_rx, URTWN_RX_LIST_COUNT); 1337 } 1338 1339 static void 1340 urtwn_free_tx_list(struct urtwn_softc *sc) 1341 { 1342 urtwn_free_list(sc, sc->sc_tx, URTWN_TX_LIST_COUNT); 1343 } 1344 1345 static void 1346 urtwn_bulk_tx_callback(struct usb_xfer *xfer, usb_error_t error) 1347 { 1348 struct urtwn_softc *sc = usbd_xfer_softc(xfer); 1349 #ifdef IEEE80211_SUPPORT_SUPERG 1350 struct ieee80211com *ic = &sc->sc_ic; 1351 #endif 1352 struct urtwn_data *data; 1353 1354 URTWN_ASSERT_LOCKED(sc); 1355 1356 switch (USB_GET_STATE(xfer)){ 1357 case USB_ST_TRANSFERRED: 1358 data = STAILQ_FIRST(&sc->sc_tx_active); 1359 if (data == NULL) 1360 goto tr_setup; 1361 STAILQ_REMOVE_HEAD(&sc->sc_tx_active, next); 1362 urtwn_txeof(sc, data, 0); 1363 /* FALLTHROUGH */ 1364 case USB_ST_SETUP: 1365 tr_setup: 1366 data = STAILQ_FIRST(&sc->sc_tx_pending); 1367 if (data == NULL) { 1368 URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT, 1369 "%s: empty pending queue\n", __func__); 1370 sc->sc_tx_n_active = 0; 1371 goto finish; 1372 } 1373 STAILQ_REMOVE_HEAD(&sc->sc_tx_pending, next); 1374 STAILQ_INSERT_TAIL(&sc->sc_tx_active, data, next); 1375 usbd_xfer_set_frame_data(xfer, 0, data->buf, data->buflen); 1376 usbd_transfer_submit(xfer); 1377 sc->sc_tx_n_active++; 1378 break; 1379 default: 1380 data = STAILQ_FIRST(&sc->sc_tx_active); 1381 if (data == NULL) 1382 goto tr_setup; 1383 STAILQ_REMOVE_HEAD(&sc->sc_tx_active, next); 1384 urtwn_txeof(sc, data, 1); 1385 if (error != USB_ERR_CANCELLED) { 1386 usbd_xfer_set_stall(xfer); 1387 goto tr_setup; 1388 } 1389 break; 1390 } 1391 finish: 1392 #ifdef IEEE80211_SUPPORT_SUPERG 1393 /* 1394 * If the TX active queue drops below a certain 1395 * threshold, ensure we age fast-frames out so they're 1396 * transmitted. 1397 */ 1398 if (sc->sc_tx_n_active <= 1) { 1399 /* XXX ew - net80211 should defer this for us! */ 1400 1401 /* 1402 * Note: this sc_tx_n_active currently tracks 1403 * the number of pending transmit submissions 1404 * and not the actual depth of the TX frames 1405 * pending to the hardware. That means that 1406 * we're going to end up with some sub-optimal 1407 * aggregation behaviour. 1408 */ 1409 /* 1410 * XXX TODO: just make this a callout timer schedule so we can 1411 * flush the FF staging queue if we're approaching idle. 1412 */ 1413 URTWN_UNLOCK(sc); 1414 ieee80211_ff_flush(ic, WME_AC_VO); 1415 ieee80211_ff_flush(ic, WME_AC_VI); 1416 ieee80211_ff_flush(ic, WME_AC_BE); 1417 ieee80211_ff_flush(ic, WME_AC_BK); 1418 URTWN_LOCK(sc); 1419 } 1420 #endif 1421 /* Kick-start more transmit */ 1422 urtwn_start(sc); 1423 } 1424 1425 static struct urtwn_data * 1426 _urtwn_getbuf(struct urtwn_softc *sc) 1427 { 1428 struct urtwn_data *bf; 1429 1430 bf = STAILQ_FIRST(&sc->sc_tx_inactive); 1431 if (bf != NULL) 1432 STAILQ_REMOVE_HEAD(&sc->sc_tx_inactive, next); 1433 else { 1434 URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT, 1435 "%s: out of xmit buffers\n", __func__); 1436 } 1437 return (bf); 1438 } 1439 1440 static struct urtwn_data * 1441 urtwn_getbuf(struct urtwn_softc *sc) 1442 { 1443 struct urtwn_data *bf; 1444 1445 URTWN_ASSERT_LOCKED(sc); 1446 1447 bf = _urtwn_getbuf(sc); 1448 if (bf == NULL) { 1449 URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT, "%s: stop queue\n", 1450 __func__); 1451 } 1452 return (bf); 1453 } 1454 1455 static usb_error_t 1456 urtwn_write_region_1(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf, 1457 int len) 1458 { 1459 usb_device_request_t req; 1460 1461 req.bmRequestType = UT_WRITE_VENDOR_DEVICE; 1462 req.bRequest = R92C_REQ_REGS; 1463 USETW(req.wValue, addr); 1464 USETW(req.wIndex, 0); 1465 USETW(req.wLength, len); 1466 return (urtwn_do_request(sc, &req, buf)); 1467 } 1468 1469 static usb_error_t 1470 urtwn_write_1(struct urtwn_softc *sc, uint16_t addr, uint8_t val) 1471 { 1472 return (urtwn_write_region_1(sc, addr, &val, sizeof(val))); 1473 } 1474 1475 static usb_error_t 1476 urtwn_write_2(struct urtwn_softc *sc, uint16_t addr, uint16_t val) 1477 { 1478 val = htole16(val); 1479 return (urtwn_write_region_1(sc, addr, (uint8_t *)&val, sizeof(val))); 1480 } 1481 1482 static usb_error_t 1483 urtwn_write_4(struct urtwn_softc *sc, uint16_t addr, uint32_t val) 1484 { 1485 val = htole32(val); 1486 return (urtwn_write_region_1(sc, addr, (uint8_t *)&val, sizeof(val))); 1487 } 1488 1489 static usb_error_t 1490 urtwn_read_region_1(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf, 1491 int len) 1492 { 1493 usb_device_request_t req; 1494 1495 req.bmRequestType = UT_READ_VENDOR_DEVICE; 1496 req.bRequest = R92C_REQ_REGS; 1497 USETW(req.wValue, addr); 1498 USETW(req.wIndex, 0); 1499 USETW(req.wLength, len); 1500 return (urtwn_do_request(sc, &req, buf)); 1501 } 1502 1503 static uint8_t 1504 urtwn_read_1(struct urtwn_softc *sc, uint16_t addr) 1505 { 1506 uint8_t val; 1507 1508 if (urtwn_read_region_1(sc, addr, &val, 1) != 0) 1509 return (0xff); 1510 return (val); 1511 } 1512 1513 static uint16_t 1514 urtwn_read_2(struct urtwn_softc *sc, uint16_t addr) 1515 { 1516 uint16_t val; 1517 1518 if (urtwn_read_region_1(sc, addr, (uint8_t *)&val, 2) != 0) 1519 return (0xffff); 1520 return (le16toh(val)); 1521 } 1522 1523 static uint32_t 1524 urtwn_read_4(struct urtwn_softc *sc, uint16_t addr) 1525 { 1526 uint32_t val; 1527 1528 if (urtwn_read_region_1(sc, addr, (uint8_t *)&val, 4) != 0) 1529 return (0xffffffff); 1530 return (le32toh(val)); 1531 } 1532 1533 static int 1534 urtwn_fw_cmd(struct urtwn_softc *sc, uint8_t id, const void *buf, int len) 1535 { 1536 struct r92c_fw_cmd cmd; 1537 usb_error_t error; 1538 int ntries; 1539 1540 if (!(sc->sc_flags & URTWN_FW_LOADED)) { 1541 URTWN_DPRINTF(sc, URTWN_DEBUG_FIRMWARE, "%s: firmware " 1542 "was not loaded; command (id %d) will be discarded\n", 1543 __func__, id); 1544 return (0); 1545 } 1546 1547 /* Wait for current FW box to be empty. */ 1548 for (ntries = 0; ntries < 100; ntries++) { 1549 if (!(urtwn_read_1(sc, R92C_HMETFR) & (1 << sc->fwcur))) 1550 break; 1551 urtwn_ms_delay(sc); 1552 } 1553 if (ntries == 100) { 1554 device_printf(sc->sc_dev, 1555 "could not send firmware command\n"); 1556 return (ETIMEDOUT); 1557 } 1558 memset(&cmd, 0, sizeof(cmd)); 1559 cmd.id = id; 1560 if (len > 3) 1561 cmd.id |= R92C_CMD_FLAG_EXT; 1562 KASSERT(len <= sizeof(cmd.msg), ("urtwn_fw_cmd\n")); 1563 memcpy(cmd.msg, buf, len); 1564 1565 /* Write the first word last since that will trigger the FW. */ 1566 error = urtwn_write_region_1(sc, R92C_HMEBOX_EXT(sc->fwcur), 1567 (uint8_t *)&cmd + 4, 2); 1568 if (error != USB_ERR_NORMAL_COMPLETION) 1569 return (EIO); 1570 error = urtwn_write_region_1(sc, R92C_HMEBOX(sc->fwcur), 1571 (uint8_t *)&cmd + 0, 4); 1572 if (error != USB_ERR_NORMAL_COMPLETION) 1573 return (EIO); 1574 1575 sc->fwcur = (sc->fwcur + 1) % R92C_H2C_NBOX; 1576 return (0); 1577 } 1578 1579 static void 1580 urtwn_cmdq_cb(void *arg, int pending) 1581 { 1582 struct urtwn_softc *sc = arg; 1583 struct urtwn_cmdq *item; 1584 1585 /* 1586 * Device must be powered on (via urtwn_power_on()) 1587 * before any command may be sent. 1588 */ 1589 URTWN_LOCK(sc); 1590 if (!(sc->sc_flags & URTWN_RUNNING)) { 1591 URTWN_UNLOCK(sc); 1592 return; 1593 } 1594 1595 URTWN_CMDQ_LOCK(sc); 1596 while (sc->cmdq[sc->cmdq_first].func != NULL) { 1597 item = &sc->cmdq[sc->cmdq_first]; 1598 sc->cmdq_first = (sc->cmdq_first + 1) % URTWN_CMDQ_SIZE; 1599 URTWN_CMDQ_UNLOCK(sc); 1600 1601 item->func(sc, &item->data); 1602 1603 URTWN_CMDQ_LOCK(sc); 1604 memset(item, 0, sizeof (*item)); 1605 } 1606 URTWN_CMDQ_UNLOCK(sc); 1607 URTWN_UNLOCK(sc); 1608 } 1609 1610 static int 1611 urtwn_cmd_sleepable(struct urtwn_softc *sc, const void *ptr, size_t len, 1612 CMD_FUNC_PROTO) 1613 { 1614 struct ieee80211com *ic = &sc->sc_ic; 1615 1616 KASSERT(len <= sizeof(union sec_param), ("buffer overflow")); 1617 1618 URTWN_CMDQ_LOCK(sc); 1619 if (sc->cmdq[sc->cmdq_last].func != NULL) { 1620 device_printf(sc->sc_dev, "%s: cmdq overflow\n", __func__); 1621 URTWN_CMDQ_UNLOCK(sc); 1622 1623 return (EAGAIN); 1624 } 1625 1626 if (ptr != NULL) 1627 memcpy(&sc->cmdq[sc->cmdq_last].data, ptr, len); 1628 sc->cmdq[sc->cmdq_last].func = func; 1629 sc->cmdq_last = (sc->cmdq_last + 1) % URTWN_CMDQ_SIZE; 1630 URTWN_CMDQ_UNLOCK(sc); 1631 1632 ieee80211_runtask(ic, &sc->cmdq_task); 1633 1634 return (0); 1635 } 1636 1637 static __inline void 1638 urtwn_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr, uint32_t val) 1639 { 1640 1641 sc->sc_rf_write(sc, chain, addr, val); 1642 } 1643 1644 static void 1645 urtwn_r92c_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr, 1646 uint32_t val) 1647 { 1648 urtwn_bb_write(sc, R92C_LSSI_PARAM(chain), 1649 SM(R92C_LSSI_PARAM_ADDR, addr) | 1650 SM(R92C_LSSI_PARAM_DATA, val)); 1651 } 1652 1653 static void 1654 urtwn_r88e_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr, 1655 uint32_t val) 1656 { 1657 urtwn_bb_write(sc, R92C_LSSI_PARAM(chain), 1658 SM(R88E_LSSI_PARAM_ADDR, addr) | 1659 SM(R92C_LSSI_PARAM_DATA, val)); 1660 } 1661 1662 static uint32_t 1663 urtwn_rf_read(struct urtwn_softc *sc, int chain, uint8_t addr) 1664 { 1665 uint32_t reg[R92C_MAX_CHAINS], val; 1666 1667 reg[0] = urtwn_bb_read(sc, R92C_HSSI_PARAM2(0)); 1668 if (chain != 0) 1669 reg[chain] = urtwn_bb_read(sc, R92C_HSSI_PARAM2(chain)); 1670 1671 urtwn_bb_write(sc, R92C_HSSI_PARAM2(0), 1672 reg[0] & ~R92C_HSSI_PARAM2_READ_EDGE); 1673 urtwn_ms_delay(sc); 1674 1675 urtwn_bb_write(sc, R92C_HSSI_PARAM2(chain), 1676 RW(reg[chain], R92C_HSSI_PARAM2_READ_ADDR, addr) | 1677 R92C_HSSI_PARAM2_READ_EDGE); 1678 urtwn_ms_delay(sc); 1679 1680 urtwn_bb_write(sc, R92C_HSSI_PARAM2(0), 1681 reg[0] | R92C_HSSI_PARAM2_READ_EDGE); 1682 urtwn_ms_delay(sc); 1683 1684 if (urtwn_bb_read(sc, R92C_HSSI_PARAM1(chain)) & R92C_HSSI_PARAM1_PI) 1685 val = urtwn_bb_read(sc, R92C_HSPI_READBACK(chain)); 1686 else 1687 val = urtwn_bb_read(sc, R92C_LSSI_READBACK(chain)); 1688 return (MS(val, R92C_LSSI_READBACK_DATA)); 1689 } 1690 1691 static int 1692 urtwn_llt_write(struct urtwn_softc *sc, uint32_t addr, uint32_t data) 1693 { 1694 usb_error_t error; 1695 int ntries; 1696 1697 error = urtwn_write_4(sc, R92C_LLT_INIT, 1698 SM(R92C_LLT_INIT_OP, R92C_LLT_INIT_OP_WRITE) | 1699 SM(R92C_LLT_INIT_ADDR, addr) | 1700 SM(R92C_LLT_INIT_DATA, data)); 1701 if (error != USB_ERR_NORMAL_COMPLETION) 1702 return (EIO); 1703 /* Wait for write operation to complete. */ 1704 for (ntries = 0; ntries < 20; ntries++) { 1705 if (MS(urtwn_read_4(sc, R92C_LLT_INIT), R92C_LLT_INIT_OP) == 1706 R92C_LLT_INIT_OP_NO_ACTIVE) 1707 return (0); 1708 urtwn_ms_delay(sc); 1709 } 1710 return (ETIMEDOUT); 1711 } 1712 1713 static int 1714 urtwn_efuse_read_next(struct urtwn_softc *sc, uint8_t *val) 1715 { 1716 uint32_t reg; 1717 usb_error_t error; 1718 int ntries; 1719 1720 if (sc->last_rom_addr >= URTWN_EFUSE_MAX_LEN) 1721 return (EFAULT); 1722 1723 reg = urtwn_read_4(sc, R92C_EFUSE_CTRL); 1724 reg = RW(reg, R92C_EFUSE_CTRL_ADDR, sc->last_rom_addr); 1725 reg &= ~R92C_EFUSE_CTRL_VALID; 1726 1727 error = urtwn_write_4(sc, R92C_EFUSE_CTRL, reg); 1728 if (error != USB_ERR_NORMAL_COMPLETION) 1729 return (EIO); 1730 /* Wait for read operation to complete. */ 1731 for (ntries = 0; ntries < 100; ntries++) { 1732 reg = urtwn_read_4(sc, R92C_EFUSE_CTRL); 1733 if (reg & R92C_EFUSE_CTRL_VALID) 1734 break; 1735 urtwn_ms_delay(sc); 1736 } 1737 if (ntries == 100) { 1738 device_printf(sc->sc_dev, 1739 "could not read efuse byte at address 0x%x\n", 1740 sc->last_rom_addr); 1741 return (ETIMEDOUT); 1742 } 1743 1744 *val = MS(reg, R92C_EFUSE_CTRL_DATA); 1745 sc->last_rom_addr++; 1746 1747 return (0); 1748 } 1749 1750 static int 1751 urtwn_efuse_read_data(struct urtwn_softc *sc, uint8_t *rom, uint8_t off, 1752 uint8_t msk) 1753 { 1754 uint8_t reg; 1755 int i, error; 1756 1757 for (i = 0; i < 4; i++) { 1758 if (msk & (1 << i)) 1759 continue; 1760 error = urtwn_efuse_read_next(sc, ®); 1761 if (error != 0) 1762 return (error); 1763 URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "rom[0x%03X] == 0x%02X\n", 1764 off * 8 + i * 2, reg); 1765 rom[off * 8 + i * 2 + 0] = reg; 1766 1767 error = urtwn_efuse_read_next(sc, ®); 1768 if (error != 0) 1769 return (error); 1770 URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "rom[0x%03X] == 0x%02X\n", 1771 off * 8 + i * 2 + 1, reg); 1772 rom[off * 8 + i * 2 + 1] = reg; 1773 } 1774 1775 return (0); 1776 } 1777 1778 #ifdef USB_DEBUG 1779 static void 1780 urtwn_dump_rom_contents(struct urtwn_softc *sc, uint8_t *rom, uint16_t size) 1781 { 1782 int i; 1783 1784 /* Dump ROM contents. */ 1785 device_printf(sc->sc_dev, "%s:", __func__); 1786 for (i = 0; i < size; i++) { 1787 if (i % 32 == 0) 1788 kprintf("\n%03X: ", i); 1789 else if (i % 4 == 0) 1790 kprintf(" "); 1791 1792 kprintf("%02X", rom[i]); 1793 } 1794 kprintf("\n"); 1795 } 1796 #endif 1797 1798 static int 1799 urtwn_efuse_read(struct urtwn_softc *sc, uint8_t *rom, uint16_t size) 1800 { 1801 #define URTWN_CHK(res) do { \ 1802 if ((error = res) != 0) \ 1803 goto end; \ 1804 } while(0) 1805 uint8_t msk, off, reg; 1806 int error; 1807 1808 URTWN_CHK(urtwn_efuse_switch_power(sc)); 1809 1810 /* Read full ROM image. */ 1811 sc->last_rom_addr = 0; 1812 memset(rom, 0xff, size); 1813 1814 URTWN_CHK(urtwn_efuse_read_next(sc, ®)); 1815 while (reg != 0xff) { 1816 /* check for extended header */ 1817 if ((sc->chip & URTWN_CHIP_88E) && (reg & 0x1f) == 0x0f) { 1818 off = reg >> 5; 1819 URTWN_CHK(urtwn_efuse_read_next(sc, ®)); 1820 1821 if ((reg & 0x0f) != 0x0f) 1822 off = ((reg & 0xf0) >> 1) | off; 1823 else 1824 continue; 1825 } else 1826 off = reg >> 4; 1827 msk = reg & 0xf; 1828 1829 URTWN_CHK(urtwn_efuse_read_data(sc, rom, off, msk)); 1830 URTWN_CHK(urtwn_efuse_read_next(sc, ®)); 1831 } 1832 1833 end: 1834 1835 #ifdef USB_DEBUG 1836 if (sc->sc_debug & URTWN_DEBUG_ROM) 1837 urtwn_dump_rom_contents(sc, rom, size); 1838 #endif 1839 1840 urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_OFF); 1841 1842 if (error != 0) { 1843 device_printf(sc->sc_dev, "%s: error while reading ROM\n", 1844 __func__); 1845 } 1846 1847 return (error); 1848 #undef URTWN_CHK 1849 } 1850 1851 static int 1852 urtwn_efuse_switch_power(struct urtwn_softc *sc) 1853 { 1854 usb_error_t error; 1855 uint32_t reg; 1856 1857 error = urtwn_write_1(sc, R92C_EFUSE_ACCESS, R92C_EFUSE_ACCESS_ON); 1858 if (error != USB_ERR_NORMAL_COMPLETION) 1859 return (EIO); 1860 1861 reg = urtwn_read_2(sc, R92C_SYS_ISO_CTRL); 1862 if (!(reg & R92C_SYS_ISO_CTRL_PWC_EV12V)) { 1863 error = urtwn_write_2(sc, R92C_SYS_ISO_CTRL, 1864 reg | R92C_SYS_ISO_CTRL_PWC_EV12V); 1865 if (error != USB_ERR_NORMAL_COMPLETION) 1866 return (EIO); 1867 } 1868 reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN); 1869 if (!(reg & R92C_SYS_FUNC_EN_ELDR)) { 1870 error = urtwn_write_2(sc, R92C_SYS_FUNC_EN, 1871 reg | R92C_SYS_FUNC_EN_ELDR); 1872 if (error != USB_ERR_NORMAL_COMPLETION) 1873 return (EIO); 1874 } 1875 reg = urtwn_read_2(sc, R92C_SYS_CLKR); 1876 if ((reg & (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) != 1877 (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) { 1878 error = urtwn_write_2(sc, R92C_SYS_CLKR, 1879 reg | R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M); 1880 if (error != USB_ERR_NORMAL_COMPLETION) 1881 return (EIO); 1882 } 1883 1884 return (0); 1885 } 1886 1887 static int 1888 urtwn_read_chipid(struct urtwn_softc *sc) 1889 { 1890 uint32_t reg; 1891 1892 if (sc->chip & URTWN_CHIP_88E) 1893 return (0); 1894 1895 reg = urtwn_read_4(sc, R92C_SYS_CFG); 1896 if (reg & R92C_SYS_CFG_TRP_VAUX_EN) 1897 return (EIO); 1898 1899 if (reg & R92C_SYS_CFG_TYPE_92C) { 1900 sc->chip |= URTWN_CHIP_92C; 1901 /* Check if it is a castrated 8192C. */ 1902 if (MS(urtwn_read_4(sc, R92C_HPON_FSM), 1903 R92C_HPON_FSM_CHIP_BONDING_ID) == 1904 R92C_HPON_FSM_CHIP_BONDING_ID_92C_1T2R) 1905 sc->chip |= URTWN_CHIP_92C_1T2R; 1906 } 1907 if (reg & R92C_SYS_CFG_VENDOR_UMC) { 1908 sc->chip |= URTWN_CHIP_UMC; 1909 if (MS(reg, R92C_SYS_CFG_CHIP_VER_RTL) == 0) 1910 sc->chip |= URTWN_CHIP_UMC_A_CUT; 1911 } 1912 return (0); 1913 } 1914 1915 static int 1916 urtwn_read_rom(struct urtwn_softc *sc) 1917 { 1918 struct r92c_rom *rom = &sc->rom.r92c_rom; 1919 int error; 1920 1921 /* Read full ROM image. */ 1922 error = urtwn_efuse_read(sc, (uint8_t *)rom, sizeof(*rom)); 1923 if (error != 0) 1924 return (error); 1925 1926 /* XXX Weird but this is what the vendor driver does. */ 1927 sc->last_rom_addr = 0x1fa; 1928 error = urtwn_efuse_read_next(sc, &sc->pa_setting); 1929 if (error != 0) 1930 return (error); 1931 URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "%s: PA setting=0x%x\n", __func__, 1932 sc->pa_setting); 1933 1934 sc->board_type = MS(rom->rf_opt1, R92C_ROM_RF1_BOARD_TYPE); 1935 1936 sc->regulatory = MS(rom->rf_opt1, R92C_ROM_RF1_REGULATORY); 1937 URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "%s: regulatory type=%d\n", 1938 __func__, sc->regulatory); 1939 IEEE80211_ADDR_COPY(sc->sc_ic.ic_macaddr, rom->macaddr); 1940 1941 sc->sc_rf_write = urtwn_r92c_rf_write; 1942 sc->sc_power_on = urtwn_r92c_power_on; 1943 sc->sc_power_off = urtwn_r92c_power_off; 1944 1945 return (0); 1946 } 1947 1948 static int 1949 urtwn_r88e_read_rom(struct urtwn_softc *sc) 1950 { 1951 struct r88e_rom *rom = &sc->rom.r88e_rom; 1952 int error; 1953 1954 error = urtwn_efuse_read(sc, (uint8_t *)rom, sizeof(sc->rom.r88e_rom)); 1955 if (error != 0) 1956 return (error); 1957 1958 sc->bw20_tx_pwr_diff = (rom->tx_pwr_diff >> 4); 1959 if (sc->bw20_tx_pwr_diff & 0x08) 1960 sc->bw20_tx_pwr_diff |= 0xf0; 1961 sc->ofdm_tx_pwr_diff = (rom->tx_pwr_diff & 0xf); 1962 if (sc->ofdm_tx_pwr_diff & 0x08) 1963 sc->ofdm_tx_pwr_diff |= 0xf0; 1964 sc->regulatory = MS(rom->rf_board_opt, R92C_ROM_RF1_REGULATORY); 1965 URTWN_DPRINTF(sc, URTWN_DEBUG_ROM, "%s: regulatory type %d\n", 1966 __func__,sc->regulatory); 1967 IEEE80211_ADDR_COPY(sc->sc_ic.ic_macaddr, rom->macaddr); 1968 1969 sc->sc_rf_write = urtwn_r88e_rf_write; 1970 sc->sc_power_on = urtwn_r88e_power_on; 1971 sc->sc_power_off = urtwn_r88e_power_off; 1972 1973 return (0); 1974 } 1975 1976 static __inline uint8_t 1977 rate2ridx(uint8_t rate) 1978 { 1979 if (rate & IEEE80211_RATE_MCS) { 1980 /* 11n rates start at idx 12 */ 1981 return ((rate & 0xf) + 12); 1982 } 1983 switch (rate) { 1984 /* 11g */ 1985 case 12: return 4; 1986 case 18: return 5; 1987 case 24: return 6; 1988 case 36: return 7; 1989 case 48: return 8; 1990 case 72: return 9; 1991 case 96: return 10; 1992 case 108: return 11; 1993 /* 11b */ 1994 case 2: return 0; 1995 case 4: return 1; 1996 case 11: return 2; 1997 case 22: return 3; 1998 default: return URTWN_RIDX_UNKNOWN; 1999 } 2000 } 2001 2002 /* 2003 * Initialize rate adaptation in firmware. 2004 */ 2005 static int 2006 urtwn_ra_init(struct urtwn_softc *sc) 2007 { 2008 struct ieee80211com *ic = &sc->sc_ic; 2009 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 2010 struct ieee80211_node *ni; 2011 struct ieee80211_rateset *rs, *rs_ht; 2012 struct r92c_fw_cmd_macid_cfg cmd; 2013 uint32_t rates, basicrates; 2014 uint8_t mode, ridx; 2015 int maxrate, maxbasicrate, error, i; 2016 2017 ni = ieee80211_ref_node(vap->iv_bss); 2018 rs = &ni->ni_rates; 2019 rs_ht = (struct ieee80211_rateset *) &ni->ni_htrates; 2020 2021 /* Get normal and basic rates mask. */ 2022 rates = basicrates = 0; 2023 maxrate = maxbasicrate = 0; 2024 2025 /* This is for 11bg */ 2026 for (i = 0; i < rs->rs_nrates; i++) { 2027 /* Convert 802.11 rate to HW rate index. */ 2028 ridx = rate2ridx(IEEE80211_RV(rs->rs_rates[i])); 2029 if (ridx == URTWN_RIDX_UNKNOWN) /* Unknown rate, skip. */ 2030 continue; 2031 rates |= 1 << ridx; 2032 if (ridx > maxrate) 2033 maxrate = ridx; 2034 if (rs->rs_rates[i] & IEEE80211_RATE_BASIC) { 2035 basicrates |= 1 << ridx; 2036 if (ridx > maxbasicrate) 2037 maxbasicrate = ridx; 2038 } 2039 } 2040 2041 /* If we're doing 11n, enable 11n rates */ 2042 if (ni->ni_flags & IEEE80211_NODE_HT) { 2043 for (i = 0; i < rs_ht->rs_nrates; i++) { 2044 if ((rs_ht->rs_rates[i] & 0x7f) > 0xf) 2045 continue; 2046 /* 11n rates start at index 12 */ 2047 ridx = ((rs_ht->rs_rates[i]) & 0xf) + 12; 2048 rates |= (1 << ridx); 2049 2050 /* Guard against the rate table being oddly ordered */ 2051 if (ridx > maxrate) 2052 maxrate = ridx; 2053 } 2054 } 2055 2056 #if 0 2057 if (ic->ic_curmode == IEEE80211_MODE_11NG) 2058 raid = R92C_RAID_11GN; 2059 #endif 2060 /* NB: group addressed frames are done at 11bg rates for now */ 2061 if (ic->ic_curmode == IEEE80211_MODE_11B) 2062 mode = R92C_RAID_11B; 2063 else 2064 mode = R92C_RAID_11BG; 2065 /* XXX misleading 'mode' value here for unicast frames */ 2066 URTWN_DPRINTF(sc, URTWN_DEBUG_RA, 2067 "%s: mode 0x%x, rates 0x%08x, basicrates 0x%08x\n", __func__, 2068 mode, rates, basicrates); 2069 2070 /* Set rates mask for group addressed frames. */ 2071 cmd.macid = URTWN_MACID_BC | URTWN_MACID_VALID; 2072 cmd.mask = htole32(mode << 28 | basicrates); 2073 error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd)); 2074 if (error != 0) { 2075 ieee80211_free_node(ni); 2076 device_printf(sc->sc_dev, 2077 "could not add broadcast station\n"); 2078 return (error); 2079 } 2080 2081 /* Set initial MRR rate. */ 2082 URTWN_DPRINTF(sc, URTWN_DEBUG_RA, "%s: maxbasicrate %d\n", __func__, 2083 maxbasicrate); 2084 urtwn_write_1(sc, R92C_INIDATA_RATE_SEL(URTWN_MACID_BC), 2085 maxbasicrate); 2086 2087 /* Set rates mask for unicast frames. */ 2088 if (ni->ni_flags & IEEE80211_NODE_HT) 2089 mode = R92C_RAID_11GN; 2090 else if (ic->ic_curmode == IEEE80211_MODE_11B) 2091 mode = R92C_RAID_11B; 2092 else 2093 mode = R92C_RAID_11BG; 2094 cmd.macid = URTWN_MACID_BSS | URTWN_MACID_VALID; 2095 cmd.mask = htole32(mode << 28 | rates); 2096 error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd)); 2097 if (error != 0) { 2098 ieee80211_free_node(ni); 2099 device_printf(sc->sc_dev, "could not add BSS station\n"); 2100 return (error); 2101 } 2102 /* Set initial MRR rate. */ 2103 URTWN_DPRINTF(sc, URTWN_DEBUG_RA, "%s: maxrate %d\n", __func__, 2104 maxrate); 2105 urtwn_write_1(sc, R92C_INIDATA_RATE_SEL(URTWN_MACID_BSS), 2106 maxrate); 2107 2108 /* Indicate highest supported rate. */ 2109 if (ni->ni_flags & IEEE80211_NODE_HT) 2110 ni->ni_txrate = rs_ht->rs_rates[rs_ht->rs_nrates - 1] 2111 | IEEE80211_RATE_MCS; 2112 else 2113 ni->ni_txrate = rs->rs_rates[rs->rs_nrates - 1]; 2114 ieee80211_free_node(ni); 2115 2116 return (0); 2117 } 2118 2119 static void 2120 urtwn_init_beacon(struct urtwn_softc *sc, struct urtwn_vap *uvp) 2121 { 2122 struct r92c_tx_desc *txd = &uvp->bcn_desc; 2123 2124 txd->txdw0 = htole32( 2125 SM(R92C_TXDW0_OFFSET, sizeof(*txd)) | R92C_TXDW0_BMCAST | 2126 R92C_TXDW0_OWN | R92C_TXDW0_FSG | R92C_TXDW0_LSG); 2127 txd->txdw1 = htole32( 2128 SM(R92C_TXDW1_QSEL, R92C_TXDW1_QSEL_BEACON) | 2129 SM(R92C_TXDW1_RAID, R92C_RAID_11B)); 2130 2131 if (sc->chip & URTWN_CHIP_88E) { 2132 txd->txdw1 |= htole32(SM(R88E_TXDW1_MACID, URTWN_MACID_BC)); 2133 txd->txdseq |= htole16(R88E_TXDSEQ_HWSEQ_EN); 2134 } else { 2135 txd->txdw1 |= htole32(SM(R92C_TXDW1_MACID, URTWN_MACID_BC)); 2136 txd->txdw4 |= htole32(R92C_TXDW4_HWSEQ_EN); 2137 } 2138 2139 txd->txdw4 = htole32(R92C_TXDW4_DRVRATE); 2140 txd->txdw5 = htole32(SM(R92C_TXDW5_DATARATE, URTWN_RIDX_CCK1)); 2141 } 2142 2143 static int 2144 urtwn_setup_beacon(struct urtwn_softc *sc, struct ieee80211_node *ni) 2145 { 2146 struct ieee80211vap *vap = ni->ni_vap; 2147 struct urtwn_vap *uvp = URTWN_VAP(vap); 2148 struct mbuf *m; 2149 int error; 2150 2151 URTWN_ASSERT_LOCKED(sc); 2152 2153 if (ni->ni_chan == IEEE80211_CHAN_ANYC) 2154 return (EINVAL); 2155 2156 m = ieee80211_beacon_alloc(ni); 2157 if (m == NULL) { 2158 device_printf(sc->sc_dev, 2159 "%s: could not allocate beacon frame\n", __func__); 2160 return (ENOMEM); 2161 } 2162 2163 if (uvp->bcn_mbuf != NULL) 2164 m_freem(uvp->bcn_mbuf); 2165 2166 uvp->bcn_mbuf = m; 2167 2168 if ((error = urtwn_tx_beacon(sc, uvp)) != 0) 2169 return (error); 2170 2171 /* XXX bcnq stuck workaround */ 2172 if ((error = urtwn_tx_beacon(sc, uvp)) != 0) 2173 return (error); 2174 2175 URTWN_DPRINTF(sc, URTWN_DEBUG_BEACON, "%s: beacon was %srecognized\n", 2176 __func__, urtwn_read_1(sc, R92C_TDECTRL + 2) & 2177 (R92C_TDECTRL_BCN_VALID >> 16) ? "" : "not "); 2178 2179 return (0); 2180 } 2181 2182 static void 2183 urtwn_update_beacon(struct ieee80211vap *vap, int item) 2184 { 2185 struct urtwn_softc *sc = vap->iv_ic->ic_softc; 2186 struct urtwn_vap *uvp = URTWN_VAP(vap); 2187 struct ieee80211_beacon_offsets *bo = &vap->iv_bcn_off; 2188 struct ieee80211_node *ni = vap->iv_bss; 2189 int mcast = 0; 2190 2191 URTWN_LOCK(sc); 2192 if (uvp->bcn_mbuf == NULL) { 2193 uvp->bcn_mbuf = ieee80211_beacon_alloc(ni); 2194 if (uvp->bcn_mbuf == NULL) { 2195 device_printf(sc->sc_dev, 2196 "%s: could not allocate beacon frame\n", __func__); 2197 URTWN_UNLOCK(sc); 2198 return; 2199 } 2200 } 2201 URTWN_UNLOCK(sc); 2202 2203 if (item == IEEE80211_BEACON_TIM) 2204 mcast = 1; /* XXX */ 2205 2206 setbit(bo->bo_flags, item); 2207 ieee80211_beacon_update(ni, uvp->bcn_mbuf, mcast); 2208 2209 URTWN_LOCK(sc); 2210 urtwn_tx_beacon(sc, uvp); 2211 URTWN_UNLOCK(sc); 2212 } 2213 2214 /* 2215 * Push a beacon frame into the chip. Beacon will 2216 * be repeated by the chip every R92C_BCN_INTERVAL. 2217 */ 2218 static int 2219 urtwn_tx_beacon(struct urtwn_softc *sc, struct urtwn_vap *uvp) 2220 { 2221 struct r92c_tx_desc *desc = &uvp->bcn_desc; 2222 struct urtwn_data *bf; 2223 2224 URTWN_ASSERT_LOCKED(sc); 2225 2226 bf = urtwn_getbuf(sc); 2227 if (bf == NULL) 2228 return (ENOMEM); 2229 2230 memcpy(bf->buf, desc, sizeof(*desc)); 2231 urtwn_tx_start(sc, uvp->bcn_mbuf, IEEE80211_FC0_TYPE_MGT, bf); 2232 2233 sc->sc_txtimer = 5; 2234 callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc); 2235 2236 return (0); 2237 } 2238 2239 static int 2240 urtwn_key_alloc(struct ieee80211vap *vap, struct ieee80211_key *k, 2241 ieee80211_keyix *keyix, ieee80211_keyix *rxkeyix) 2242 { 2243 struct urtwn_softc *sc = vap->iv_ic->ic_softc; 2244 uint8_t i; 2245 2246 if (!(&vap->iv_nw_keys[0] <= k && 2247 k < &vap->iv_nw_keys[IEEE80211_WEP_NKID])) { 2248 if (!(k->wk_flags & IEEE80211_KEY_SWCRYPT)) { 2249 URTWN_LOCK(sc); 2250 /* 2251 * First 4 slots for group keys, 2252 * what is left - for pairwise. 2253 * XXX incompatible with IBSS RSN. 2254 */ 2255 for (i = IEEE80211_WEP_NKID; 2256 i < R92C_CAM_ENTRY_COUNT; i++) { 2257 if ((sc->keys_bmap & (1 << i)) == 0) { 2258 sc->keys_bmap |= 1 << i; 2259 *keyix = i; 2260 break; 2261 } 2262 } 2263 URTWN_UNLOCK(sc); 2264 if (i == R92C_CAM_ENTRY_COUNT) { 2265 device_printf(sc->sc_dev, 2266 "%s: no free space in the key table\n", 2267 __func__); 2268 return 0; 2269 } 2270 } else 2271 *keyix = 0; 2272 } else { 2273 *keyix = k - vap->iv_nw_keys; 2274 } 2275 *rxkeyix = *keyix; 2276 return 1; 2277 } 2278 2279 static void 2280 urtwn_key_set_cb(struct urtwn_softc *sc, union sec_param *data) 2281 { 2282 struct ieee80211_key *k = &data->key; 2283 uint8_t algo, keyid; 2284 int i, error; 2285 2286 if (k->wk_keyix < IEEE80211_WEP_NKID) 2287 keyid = k->wk_keyix; 2288 else 2289 keyid = 0; 2290 2291 /* Map net80211 cipher to HW crypto algorithm. */ 2292 switch (k->wk_cipher->ic_cipher) { 2293 case IEEE80211_CIPHER_WEP: 2294 if (k->wk_keylen < 8) 2295 algo = R92C_CAM_ALGO_WEP40; 2296 else 2297 algo = R92C_CAM_ALGO_WEP104; 2298 break; 2299 case IEEE80211_CIPHER_TKIP: 2300 algo = R92C_CAM_ALGO_TKIP; 2301 break; 2302 case IEEE80211_CIPHER_AES_CCM: 2303 algo = R92C_CAM_ALGO_AES; 2304 break; 2305 default: 2306 device_printf(sc->sc_dev, "%s: undefined cipher %d\n", 2307 __func__, k->wk_cipher->ic_cipher); 2308 return; 2309 } 2310 2311 URTWN_DPRINTF(sc, URTWN_DEBUG_KEY, 2312 "%s: keyix %d, keyid %d, algo %d/%d, flags %04X, len %d, " 2313 "macaddr %s\n", __func__, k->wk_keyix, keyid, 2314 k->wk_cipher->ic_cipher, algo, k->wk_flags, k->wk_keylen, 2315 ether_sprintf(k->wk_macaddr)); 2316 2317 /* Write key. */ 2318 for (i = 0; i < 4; i++) { 2319 error = urtwn_cam_write(sc, R92C_CAM_KEY(k->wk_keyix, i), 2320 le32dec(&k->wk_key[i * 4])); 2321 if (error != 0) 2322 goto fail; 2323 } 2324 2325 /* Write CTL0 last since that will validate the CAM entry. */ 2326 error = urtwn_cam_write(sc, R92C_CAM_CTL1(k->wk_keyix), 2327 le32dec(&k->wk_macaddr[2])); 2328 if (error != 0) 2329 goto fail; 2330 error = urtwn_cam_write(sc, R92C_CAM_CTL0(k->wk_keyix), 2331 SM(R92C_CAM_ALGO, algo) | 2332 SM(R92C_CAM_KEYID, keyid) | 2333 SM(R92C_CAM_MACLO, le16dec(&k->wk_macaddr[0])) | 2334 R92C_CAM_VALID); 2335 if (error != 0) 2336 goto fail; 2337 2338 return; 2339 2340 fail: 2341 device_printf(sc->sc_dev, "%s fails, error %d\n", __func__, error); 2342 } 2343 2344 static void 2345 urtwn_key_del_cb(struct urtwn_softc *sc, union sec_param *data) 2346 { 2347 struct ieee80211_key *k = &data->key; 2348 int i; 2349 2350 URTWN_DPRINTF(sc, URTWN_DEBUG_KEY, 2351 "%s: keyix %d, flags %04X, macaddr %s\n", __func__, 2352 k->wk_keyix, k->wk_flags, ether_sprintf(k->wk_macaddr)); 2353 2354 urtwn_cam_write(sc, R92C_CAM_CTL0(k->wk_keyix), 0); 2355 urtwn_cam_write(sc, R92C_CAM_CTL1(k->wk_keyix), 0); 2356 2357 /* Clear key. */ 2358 for (i = 0; i < 4; i++) 2359 urtwn_cam_write(sc, R92C_CAM_KEY(k->wk_keyix, i), 0); 2360 sc->keys_bmap &= ~(1 << k->wk_keyix); 2361 } 2362 2363 static int 2364 urtwn_key_set(struct ieee80211vap *vap, const struct ieee80211_key *k) 2365 { 2366 struct urtwn_softc *sc = vap->iv_ic->ic_softc; 2367 2368 if (k->wk_flags & IEEE80211_KEY_SWCRYPT) { 2369 /* Not for us. */ 2370 return (1); 2371 } 2372 2373 return (!urtwn_cmd_sleepable(sc, k, sizeof(*k), urtwn_key_set_cb)); 2374 } 2375 2376 static int 2377 urtwn_key_delete(struct ieee80211vap *vap, const struct ieee80211_key *k) 2378 { 2379 struct urtwn_softc *sc = vap->iv_ic->ic_softc; 2380 2381 if (k->wk_flags & IEEE80211_KEY_SWCRYPT) { 2382 /* Not for us. */ 2383 return (1); 2384 } 2385 2386 return (!urtwn_cmd_sleepable(sc, k, sizeof(*k), urtwn_key_del_cb)); 2387 } 2388 2389 static void 2390 urtwn_tsf_task_adhoc(void *arg, int pending) 2391 { 2392 struct ieee80211vap *vap = arg; 2393 struct urtwn_softc *sc = vap->iv_ic->ic_softc; 2394 struct ieee80211_node *ni; 2395 uint32_t reg; 2396 2397 URTWN_LOCK(sc); 2398 ni = ieee80211_ref_node(vap->iv_bss); 2399 reg = urtwn_read_1(sc, R92C_BCN_CTRL); 2400 2401 /* Accept beacons with the same BSSID. */ 2402 urtwn_set_rx_bssid_all(sc, 0); 2403 2404 /* Enable synchronization. */ 2405 reg &= ~R92C_BCN_CTRL_DIS_TSF_UDT0; 2406 urtwn_write_1(sc, R92C_BCN_CTRL, reg); 2407 2408 /* Synchronize. */ 2409 usb_pause_mtx(&sc->sc_mtx, hz * ni->ni_intval * 5 / 1000); 2410 2411 /* Disable synchronization. */ 2412 reg |= R92C_BCN_CTRL_DIS_TSF_UDT0; 2413 urtwn_write_1(sc, R92C_BCN_CTRL, reg); 2414 2415 /* Remove beacon filter. */ 2416 urtwn_set_rx_bssid_all(sc, 1); 2417 2418 /* Enable beaconing. */ 2419 urtwn_write_1(sc, R92C_MBID_NUM, 2420 urtwn_read_1(sc, R92C_MBID_NUM) | R92C_MBID_TXBCN_RPT0); 2421 reg |= R92C_BCN_CTRL_EN_BCN; 2422 2423 urtwn_write_1(sc, R92C_BCN_CTRL, reg); 2424 ieee80211_free_node(ni); 2425 URTWN_UNLOCK(sc); 2426 } 2427 2428 static void 2429 urtwn_tsf_sync_enable(struct urtwn_softc *sc, struct ieee80211vap *vap) 2430 { 2431 struct ieee80211com *ic = &sc->sc_ic; 2432 struct urtwn_vap *uvp = URTWN_VAP(vap); 2433 2434 /* Reset TSF. */ 2435 urtwn_write_1(sc, R92C_DUAL_TSF_RST, R92C_DUAL_TSF_RST0); 2436 2437 switch (vap->iv_opmode) { 2438 case IEEE80211_M_STA: 2439 /* Enable TSF synchronization. */ 2440 urtwn_write_1(sc, R92C_BCN_CTRL, 2441 urtwn_read_1(sc, R92C_BCN_CTRL) & 2442 ~R92C_BCN_CTRL_DIS_TSF_UDT0); 2443 break; 2444 case IEEE80211_M_IBSS: 2445 ieee80211_runtask(ic, &uvp->tsf_task_adhoc); 2446 break; 2447 case IEEE80211_M_HOSTAP: 2448 /* Enable beaconing. */ 2449 urtwn_write_1(sc, R92C_MBID_NUM, 2450 urtwn_read_1(sc, R92C_MBID_NUM) | R92C_MBID_TXBCN_RPT0); 2451 urtwn_write_1(sc, R92C_BCN_CTRL, 2452 urtwn_read_1(sc, R92C_BCN_CTRL) | R92C_BCN_CTRL_EN_BCN); 2453 break; 2454 default: 2455 device_printf(sc->sc_dev, "undefined opmode %d\n", 2456 vap->iv_opmode); 2457 return; 2458 } 2459 } 2460 2461 static void 2462 urtwn_get_tsf(struct urtwn_softc *sc, uint64_t *buf) 2463 { 2464 urtwn_read_region_1(sc, R92C_TSFTR, (uint8_t *)buf, sizeof(*buf)); 2465 } 2466 2467 static void 2468 urtwn_set_led(struct urtwn_softc *sc, int led, int on) 2469 { 2470 uint8_t reg; 2471 2472 if (led == URTWN_LED_LINK) { 2473 if (sc->chip & URTWN_CHIP_88E) { 2474 reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0xf0; 2475 urtwn_write_1(sc, R92C_LEDCFG2, reg | 0x60); 2476 if (!on) { 2477 reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0x90; 2478 urtwn_write_1(sc, R92C_LEDCFG2, 2479 reg | R92C_LEDCFG0_DIS); 2480 urtwn_write_1(sc, R92C_MAC_PINMUX_CFG, 2481 urtwn_read_1(sc, R92C_MAC_PINMUX_CFG) & 2482 0xfe); 2483 } 2484 } else { 2485 reg = urtwn_read_1(sc, R92C_LEDCFG0) & 0x70; 2486 if (!on) 2487 reg |= R92C_LEDCFG0_DIS; 2488 urtwn_write_1(sc, R92C_LEDCFG0, reg); 2489 } 2490 sc->ledlink = on; /* Save LED state. */ 2491 } 2492 } 2493 2494 static void 2495 urtwn_set_mode(struct urtwn_softc *sc, uint8_t mode) 2496 { 2497 uint8_t reg; 2498 2499 reg = urtwn_read_1(sc, R92C_MSR); 2500 reg = (reg & ~R92C_MSR_MASK) | mode; 2501 urtwn_write_1(sc, R92C_MSR, reg); 2502 } 2503 2504 static void 2505 urtwn_ibss_recv_mgmt(struct ieee80211_node *ni, struct mbuf *m, int subtype, 2506 const struct ieee80211_rx_stats *rxs, 2507 int rssi, int nf) 2508 { 2509 struct ieee80211vap *vap = ni->ni_vap; 2510 struct urtwn_softc *sc = vap->iv_ic->ic_softc; 2511 struct urtwn_vap *uvp = URTWN_VAP(vap); 2512 uint64_t ni_tstamp, curr_tstamp; 2513 2514 uvp->recv_mgmt(ni, m, subtype, rxs, rssi, nf); 2515 2516 if (vap->iv_state == IEEE80211_S_RUN && 2517 (subtype == IEEE80211_FC0_SUBTYPE_BEACON || 2518 subtype == IEEE80211_FC0_SUBTYPE_PROBE_RESP)) { 2519 ni_tstamp = le64toh(ni->ni_tstamp.tsf); 2520 URTWN_LOCK(sc); 2521 urtwn_get_tsf(sc, &curr_tstamp); 2522 URTWN_UNLOCK(sc); 2523 curr_tstamp = le64toh(curr_tstamp); 2524 2525 if (ni_tstamp >= curr_tstamp) 2526 (void) ieee80211_ibss_merge(ni); 2527 } 2528 } 2529 2530 static int 2531 urtwn_newstate(struct ieee80211vap *vap, enum ieee80211_state nstate, int arg) 2532 { 2533 struct urtwn_vap *uvp = URTWN_VAP(vap); 2534 struct ieee80211com *ic = vap->iv_ic; 2535 struct urtwn_softc *sc = ic->ic_softc; 2536 struct ieee80211_node *ni; 2537 enum ieee80211_state ostate; 2538 uint32_t reg; 2539 uint8_t mode; 2540 int error = 0; 2541 2542 ostate = vap->iv_state; 2543 URTWN_DPRINTF(sc, URTWN_DEBUG_STATE, "%s -> %s\n", 2544 ieee80211_state_name[ostate], ieee80211_state_name[nstate]); 2545 2546 IEEE80211_UNLOCK(ic); 2547 URTWN_LOCK(sc); 2548 callout_stop(&sc->sc_watchdog_ch); 2549 2550 if (ostate == IEEE80211_S_RUN) { 2551 /* Stop calibration. */ 2552 callout_stop(&sc->sc_calib_to); 2553 2554 /* Turn link LED off. */ 2555 urtwn_set_led(sc, URTWN_LED_LINK, 0); 2556 2557 /* Set media status to 'No Link'. */ 2558 urtwn_set_mode(sc, R92C_MSR_NOLINK); 2559 2560 /* Stop Rx of data frames. */ 2561 urtwn_write_2(sc, R92C_RXFLTMAP2, 0); 2562 2563 /* Disable TSF synchronization. */ 2564 urtwn_write_1(sc, R92C_BCN_CTRL, 2565 (urtwn_read_1(sc, R92C_BCN_CTRL) & ~R92C_BCN_CTRL_EN_BCN) | 2566 R92C_BCN_CTRL_DIS_TSF_UDT0); 2567 2568 /* Disable beaconing. */ 2569 urtwn_write_1(sc, R92C_MBID_NUM, 2570 urtwn_read_1(sc, R92C_MBID_NUM) & ~R92C_MBID_TXBCN_RPT0); 2571 2572 /* Reset TSF. */ 2573 urtwn_write_1(sc, R92C_DUAL_TSF_RST, R92C_DUAL_TSF_RST0); 2574 2575 /* Reset EDCA parameters. */ 2576 urtwn_write_4(sc, R92C_EDCA_VO_PARAM, 0x002f3217); 2577 urtwn_write_4(sc, R92C_EDCA_VI_PARAM, 0x005e4317); 2578 urtwn_write_4(sc, R92C_EDCA_BE_PARAM, 0x00105320); 2579 urtwn_write_4(sc, R92C_EDCA_BK_PARAM, 0x0000a444); 2580 } 2581 2582 switch (nstate) { 2583 case IEEE80211_S_INIT: 2584 /* Turn link LED off. */ 2585 urtwn_set_led(sc, URTWN_LED_LINK, 0); 2586 break; 2587 case IEEE80211_S_SCAN: 2588 /* Pause AC Tx queues. */ 2589 urtwn_write_1(sc, R92C_TXPAUSE, 2590 urtwn_read_1(sc, R92C_TXPAUSE) | R92C_TX_QUEUE_AC); 2591 break; 2592 case IEEE80211_S_AUTH: 2593 urtwn_set_chan(sc, ic->ic_curchan, NULL); 2594 break; 2595 case IEEE80211_S_RUN: 2596 if (vap->iv_opmode == IEEE80211_M_MONITOR) { 2597 /* Turn link LED on. */ 2598 urtwn_set_led(sc, URTWN_LED_LINK, 1); 2599 break; 2600 } 2601 2602 ni = ieee80211_ref_node(vap->iv_bss); 2603 2604 if (ic->ic_bsschan == IEEE80211_CHAN_ANYC || 2605 ni->ni_chan == IEEE80211_CHAN_ANYC) { 2606 device_printf(sc->sc_dev, 2607 "%s: could not move to RUN state\n", __func__); 2608 error = EINVAL; 2609 goto end_run; 2610 } 2611 2612 switch (vap->iv_opmode) { 2613 case IEEE80211_M_STA: 2614 mode = R92C_MSR_INFRA; 2615 break; 2616 case IEEE80211_M_IBSS: 2617 mode = R92C_MSR_ADHOC; 2618 break; 2619 case IEEE80211_M_HOSTAP: 2620 mode = R92C_MSR_AP; 2621 break; 2622 default: 2623 device_printf(sc->sc_dev, "undefined opmode %d\n", 2624 vap->iv_opmode); 2625 error = EINVAL; 2626 goto end_run; 2627 } 2628 2629 /* Set media status to 'Associated'. */ 2630 urtwn_set_mode(sc, mode); 2631 2632 /* Set BSSID. */ 2633 urtwn_write_4(sc, R92C_BSSID + 0, le32dec(&ni->ni_bssid[0])); 2634 urtwn_write_4(sc, R92C_BSSID + 4, le16dec(&ni->ni_bssid[4])); 2635 2636 if (ic->ic_curmode == IEEE80211_MODE_11B) 2637 urtwn_write_1(sc, R92C_INIRTS_RATE_SEL, 0); 2638 else /* 802.11b/g */ 2639 urtwn_write_1(sc, R92C_INIRTS_RATE_SEL, 3); 2640 2641 /* Enable Rx of data frames. */ 2642 urtwn_write_2(sc, R92C_RXFLTMAP2, 0xffff); 2643 2644 /* Flush all AC queues. */ 2645 urtwn_write_1(sc, R92C_TXPAUSE, 0); 2646 2647 /* Set beacon interval. */ 2648 urtwn_write_2(sc, R92C_BCN_INTERVAL, ni->ni_intval); 2649 2650 /* Allow Rx from our BSSID only. */ 2651 if (ic->ic_promisc == 0) { 2652 reg = urtwn_read_4(sc, R92C_RCR); 2653 2654 if (vap->iv_opmode != IEEE80211_M_HOSTAP) 2655 reg |= R92C_RCR_CBSSID_DATA; 2656 if (vap->iv_opmode != IEEE80211_M_IBSS) 2657 reg |= R92C_RCR_CBSSID_BCN; 2658 2659 urtwn_write_4(sc, R92C_RCR, reg); 2660 } 2661 2662 if (vap->iv_opmode == IEEE80211_M_HOSTAP || 2663 vap->iv_opmode == IEEE80211_M_IBSS) { 2664 error = urtwn_setup_beacon(sc, ni); 2665 if (error != 0) { 2666 device_printf(sc->sc_dev, 2667 "unable to push beacon into the chip, " 2668 "error %d\n", error); 2669 goto end_run; 2670 } 2671 } 2672 2673 /* Enable TSF synchronization. */ 2674 urtwn_tsf_sync_enable(sc, vap); 2675 2676 urtwn_write_1(sc, R92C_SIFS_CCK + 1, 10); 2677 urtwn_write_1(sc, R92C_SIFS_OFDM + 1, 10); 2678 urtwn_write_1(sc, R92C_SPEC_SIFS + 1, 10); 2679 urtwn_write_1(sc, R92C_MAC_SPEC_SIFS + 1, 10); 2680 urtwn_write_1(sc, R92C_R2T_SIFS + 1, 10); 2681 urtwn_write_1(sc, R92C_T2T_SIFS + 1, 10); 2682 2683 /* Intialize rate adaptation. */ 2684 if (!(sc->chip & URTWN_CHIP_88E)) 2685 urtwn_ra_init(sc); 2686 /* Turn link LED on. */ 2687 urtwn_set_led(sc, URTWN_LED_LINK, 1); 2688 2689 sc->avg_pwdb = -1; /* Reset average RSSI. */ 2690 /* Reset temperature calibration state machine. */ 2691 sc->sc_flags &= ~URTWN_TEMP_MEASURED; 2692 sc->thcal_lctemp = 0; 2693 /* Start periodic calibration. */ 2694 callout_reset(&sc->sc_calib_to, 2*hz, urtwn_calib_to, sc); 2695 2696 end_run: 2697 ieee80211_free_node(ni); 2698 break; 2699 default: 2700 break; 2701 } 2702 2703 URTWN_UNLOCK(sc); 2704 IEEE80211_LOCK(ic); 2705 return (error != 0 ? error : uvp->newstate(vap, nstate, arg)); 2706 } 2707 2708 static void 2709 urtwn_calib_to(void *arg) 2710 { 2711 struct urtwn_softc *sc = arg; 2712 2713 /* Do it in a process context. */ 2714 urtwn_cmd_sleepable(sc, NULL, 0, urtwn_calib_cb); 2715 } 2716 2717 static void 2718 urtwn_calib_cb(struct urtwn_softc *sc, union sec_param *data) 2719 { 2720 /* Do temperature compensation. */ 2721 urtwn_temp_calib(sc); 2722 2723 if ((urtwn_read_1(sc, R92C_MSR) & R92C_MSR_MASK) != R92C_MSR_NOLINK) 2724 callout_reset(&sc->sc_calib_to, 2*hz, urtwn_calib_to, sc); 2725 } 2726 2727 static void 2728 urtwn_watchdog(void *arg) 2729 { 2730 struct urtwn_softc *sc = arg; 2731 2732 if (sc->sc_txtimer > 0) { 2733 if (--sc->sc_txtimer == 0) { 2734 device_printf(sc->sc_dev, "device timeout\n"); 2735 #if defined(__DragonFly__) 2736 /* unimplemented */ 2737 #else 2738 counter_u64_add(sc->sc_ic.ic_oerrors, 1); 2739 #endif 2740 return; 2741 } 2742 callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc); 2743 } 2744 } 2745 2746 static void 2747 urtwn_update_avgrssi(struct urtwn_softc *sc, int rate, int8_t rssi) 2748 { 2749 int pwdb; 2750 2751 /* Convert antenna signal to percentage. */ 2752 if (rssi <= -100 || rssi >= 20) 2753 pwdb = 0; 2754 else if (rssi >= 0) 2755 pwdb = 100; 2756 else 2757 pwdb = 100 + rssi; 2758 if (!(sc->chip & URTWN_CHIP_88E)) { 2759 if (rate <= URTWN_RIDX_CCK11) { 2760 /* CCK gain is smaller than OFDM/MCS gain. */ 2761 pwdb += 6; 2762 if (pwdb > 100) 2763 pwdb = 100; 2764 if (pwdb <= 14) 2765 pwdb -= 4; 2766 else if (pwdb <= 26) 2767 pwdb -= 8; 2768 else if (pwdb <= 34) 2769 pwdb -= 6; 2770 else if (pwdb <= 42) 2771 pwdb -= 2; 2772 } 2773 } 2774 if (sc->avg_pwdb == -1) /* Init. */ 2775 sc->avg_pwdb = pwdb; 2776 else if (sc->avg_pwdb < pwdb) 2777 sc->avg_pwdb = ((sc->avg_pwdb * 19 + pwdb) / 20) + 1; 2778 else 2779 sc->avg_pwdb = ((sc->avg_pwdb * 19 + pwdb) / 20); 2780 URTWN_DPRINTF(sc, URTWN_DEBUG_RSSI, "%s: PWDB %d, EMA %d\n", __func__, 2781 pwdb, sc->avg_pwdb); 2782 } 2783 2784 static int8_t 2785 urtwn_get_rssi(struct urtwn_softc *sc, int rate, void *physt) 2786 { 2787 static const int8_t cckoff[] = { 16, -12, -26, -46 }; 2788 struct r92c_rx_phystat *phy; 2789 struct r92c_rx_cck *cck; 2790 uint8_t rpt; 2791 int8_t rssi; 2792 2793 if (rate <= URTWN_RIDX_CCK11) { 2794 cck = (struct r92c_rx_cck *)physt; 2795 if (sc->sc_flags & URTWN_FLAG_CCK_HIPWR) { 2796 rpt = (cck->agc_rpt >> 5) & 0x3; 2797 rssi = (cck->agc_rpt & 0x1f) << 1; 2798 } else { 2799 rpt = (cck->agc_rpt >> 6) & 0x3; 2800 rssi = cck->agc_rpt & 0x3e; 2801 } 2802 rssi = cckoff[rpt] - rssi; 2803 } else { /* OFDM/HT. */ 2804 phy = (struct r92c_rx_phystat *)physt; 2805 rssi = ((le32toh(phy->phydw1) >> 1) & 0x7f) - 110; 2806 } 2807 return (rssi); 2808 } 2809 2810 static int8_t 2811 urtwn_r88e_get_rssi(struct urtwn_softc *sc, int rate, void *physt) 2812 { 2813 struct r92c_rx_phystat *phy; 2814 struct r88e_rx_cck *cck; 2815 uint8_t cck_agc_rpt, lna_idx, vga_idx; 2816 int8_t rssi; 2817 2818 rssi = 0; 2819 if (rate <= URTWN_RIDX_CCK11) { 2820 cck = (struct r88e_rx_cck *)physt; 2821 cck_agc_rpt = cck->agc_rpt; 2822 lna_idx = (cck_agc_rpt & 0xe0) >> 5; 2823 vga_idx = cck_agc_rpt & 0x1f; 2824 switch (lna_idx) { 2825 case 7: 2826 if (vga_idx <= 27) 2827 rssi = -100 + 2* (27 - vga_idx); 2828 else 2829 rssi = -100; 2830 break; 2831 case 6: 2832 rssi = -48 + 2 * (2 - vga_idx); 2833 break; 2834 case 5: 2835 rssi = -42 + 2 * (7 - vga_idx); 2836 break; 2837 case 4: 2838 rssi = -36 + 2 * (7 - vga_idx); 2839 break; 2840 case 3: 2841 rssi = -24 + 2 * (7 - vga_idx); 2842 break; 2843 case 2: 2844 rssi = -12 + 2 * (5 - vga_idx); 2845 break; 2846 case 1: 2847 rssi = 8 - (2 * vga_idx); 2848 break; 2849 case 0: 2850 rssi = 14 - (2 * vga_idx); 2851 break; 2852 } 2853 rssi += 6; 2854 } else { /* OFDM/HT. */ 2855 phy = (struct r92c_rx_phystat *)physt; 2856 rssi = ((le32toh(phy->phydw1) >> 1) & 0x7f) - 110; 2857 } 2858 return (rssi); 2859 } 2860 2861 static int 2862 urtwn_tx_data(struct urtwn_softc *sc, struct ieee80211_node *ni, 2863 struct mbuf *m, struct urtwn_data *data) 2864 { 2865 const struct ieee80211_txparam *tp; 2866 struct ieee80211com *ic = &sc->sc_ic; 2867 struct ieee80211vap *vap = ni->ni_vap; 2868 struct ieee80211_key *k = NULL; 2869 struct ieee80211_channel *chan; 2870 struct ieee80211_frame *wh; 2871 struct r92c_tx_desc *txd; 2872 uint8_t macid, raid, rate, ridx, subtype, type, tid, qsel; 2873 int hasqos, ismcast; 2874 2875 URTWN_ASSERT_LOCKED(sc); 2876 2877 /* 2878 * Software crypto. 2879 */ 2880 wh = mtod(m, struct ieee80211_frame *); 2881 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 2882 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 2883 hasqos = IEEE80211_QOS_HAS_SEQ(wh); 2884 ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 2885 2886 /* Select TX ring for this frame. */ 2887 if (hasqos) { 2888 tid = ((const struct ieee80211_qosframe *)wh)->i_qos[0]; 2889 tid &= IEEE80211_QOS_TID; 2890 } else 2891 tid = 0; 2892 2893 chan = (ni->ni_chan != IEEE80211_CHAN_ANYC) ? 2894 ni->ni_chan : ic->ic_curchan; 2895 tp = &vap->iv_txparms[ieee80211_chan2mode(chan)]; 2896 2897 /* Choose a TX rate index. */ 2898 if (type == IEEE80211_FC0_TYPE_MGT) 2899 rate = tp->mgmtrate; 2900 else if (ismcast) 2901 rate = tp->mcastrate; 2902 else if (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) 2903 rate = tp->ucastrate; 2904 else if (m->m_flags & M_EAPOL) 2905 rate = tp->mgmtrate; 2906 else { 2907 if (URTWN_CHIP_HAS_RATECTL(sc)) { 2908 /* XXX pass pktlen */ 2909 (void) ieee80211_ratectl_rate(ni, NULL, 0); 2910 rate = ni->ni_txrate; 2911 } else { 2912 /* XXX TODO: drop the default rate for 11b/11g? */ 2913 if (ni->ni_flags & IEEE80211_NODE_HT) 2914 rate = IEEE80211_RATE_MCS | 0x4; /* MCS4 */ 2915 else if (ic->ic_curmode != IEEE80211_MODE_11B) 2916 rate = 108; 2917 else 2918 rate = 22; 2919 } 2920 } 2921 2922 /* 2923 * XXX TODO: this should be per-node, for 11b versus 11bg 2924 * nodes in hostap mode 2925 */ 2926 ridx = rate2ridx(rate); 2927 if (ni->ni_flags & IEEE80211_NODE_HT) 2928 raid = R92C_RAID_11GN; 2929 else if (ic->ic_curmode != IEEE80211_MODE_11B) 2930 raid = R92C_RAID_11BG; 2931 else 2932 raid = R92C_RAID_11B; 2933 2934 if (wh->i_fc[1] & IEEE80211_FC1_PROTECTED) { 2935 k = ieee80211_crypto_encap(ni, m); 2936 if (k == NULL) { 2937 device_printf(sc->sc_dev, 2938 "ieee80211_crypto_encap returns NULL.\n"); 2939 return (ENOBUFS); 2940 } 2941 2942 /* in case packet header moved, reset pointer */ 2943 wh = mtod(m, struct ieee80211_frame *); 2944 } 2945 2946 /* Fill Tx descriptor. */ 2947 txd = (struct r92c_tx_desc *)data->buf; 2948 memset(txd, 0, sizeof(*txd)); 2949 2950 txd->txdw0 |= htole32( 2951 SM(R92C_TXDW0_OFFSET, sizeof(*txd)) | 2952 R92C_TXDW0_OWN | R92C_TXDW0_FSG | R92C_TXDW0_LSG); 2953 if (ismcast) 2954 txd->txdw0 |= htole32(R92C_TXDW0_BMCAST); 2955 2956 if (!ismcast) { 2957 if (sc->chip & URTWN_CHIP_88E) { 2958 struct urtwn_node *un = URTWN_NODE(ni); 2959 macid = un->id; 2960 } else 2961 macid = URTWN_MACID_BSS; 2962 2963 if (type == IEEE80211_FC0_TYPE_DATA) { 2964 qsel = tid % URTWN_MAX_TID; 2965 2966 if (sc->chip & URTWN_CHIP_88E) { 2967 txd->txdw2 |= htole32( 2968 R88E_TXDW2_AGGBK | 2969 R88E_TXDW2_CCX_RPT); 2970 } else 2971 txd->txdw1 |= htole32(R92C_TXDW1_AGGBK); 2972 2973 /* protmode, non-HT */ 2974 /* XXX TODO: noack frames? */ 2975 if ((rate & 0x80) == 0 && 2976 (ic->ic_flags & IEEE80211_F_USEPROT)) { 2977 switch (ic->ic_protmode) { 2978 case IEEE80211_PROT_CTSONLY: 2979 txd->txdw4 |= htole32( 2980 R92C_TXDW4_CTS2SELF | 2981 R92C_TXDW4_HWRTSEN); 2982 break; 2983 case IEEE80211_PROT_RTSCTS: 2984 txd->txdw4 |= htole32( 2985 R92C_TXDW4_RTSEN | 2986 R92C_TXDW4_HWRTSEN); 2987 break; 2988 default: 2989 break; 2990 } 2991 } 2992 2993 /* protmode, HT */ 2994 /* XXX TODO: noack frames? */ 2995 if ((rate & 0x80) && 2996 (ic->ic_htprotmode == IEEE80211_PROT_RTSCTS)) { 2997 txd->txdw4 |= htole32( 2998 R92C_TXDW4_RTSEN | 2999 R92C_TXDW4_HWRTSEN); 3000 } 3001 3002 /* XXX TODO: rtsrate is configurable? 24mbit may 3003 * be a bit high for RTS rate? */ 3004 txd->txdw4 |= htole32(SM(R92C_TXDW4_RTSRATE, 3005 URTWN_RIDX_OFDM24)); 3006 3007 txd->txdw5 |= htole32(0x0001ff00); 3008 } else /* IEEE80211_FC0_TYPE_MGT */ 3009 qsel = R92C_TXDW1_QSEL_MGNT; 3010 } else { 3011 macid = URTWN_MACID_BC; 3012 qsel = R92C_TXDW1_QSEL_MGNT; 3013 } 3014 3015 txd->txdw1 |= htole32( 3016 SM(R92C_TXDW1_QSEL, qsel) | 3017 SM(R92C_TXDW1_RAID, raid)); 3018 3019 /* XXX TODO: 40MHZ flag? */ 3020 /* XXX TODO: AMPDU flag? (AGG_ENABLE or AGG_BREAK?) Density shift? */ 3021 /* XXX Short preamble? */ 3022 /* XXX Short-GI? */ 3023 3024 if (sc->chip & URTWN_CHIP_88E) 3025 txd->txdw1 |= htole32(SM(R88E_TXDW1_MACID, macid)); 3026 else 3027 txd->txdw1 |= htole32(SM(R92C_TXDW1_MACID, macid)); 3028 3029 txd->txdw5 |= htole32(SM(R92C_TXDW5_DATARATE, ridx)); 3030 3031 /* Force this rate if needed. */ 3032 if (URTWN_CHIP_HAS_RATECTL(sc) || ismcast || 3033 (tp->ucastrate != IEEE80211_FIXED_RATE_NONE) || 3034 (m->m_flags & M_EAPOL) || type != IEEE80211_FC0_TYPE_DATA) 3035 txd->txdw4 |= htole32(R92C_TXDW4_DRVRATE); 3036 3037 if (!hasqos) { 3038 /* Use HW sequence numbering for non-QoS frames. */ 3039 if (sc->chip & URTWN_CHIP_88E) 3040 txd->txdseq = htole16(R88E_TXDSEQ_HWSEQ_EN); 3041 else 3042 txd->txdw4 |= htole32(R92C_TXDW4_HWSEQ_EN); 3043 } else { 3044 /* Set sequence number. */ 3045 txd->txdseq = htole16(M_SEQNO_GET(m) % IEEE80211_SEQ_RANGE); 3046 } 3047 3048 if (k != NULL && !(k->wk_flags & IEEE80211_KEY_SWCRYPT)) { 3049 uint8_t cipher; 3050 3051 switch (k->wk_cipher->ic_cipher) { 3052 case IEEE80211_CIPHER_WEP: 3053 case IEEE80211_CIPHER_TKIP: 3054 cipher = R92C_TXDW1_CIPHER_RC4; 3055 break; 3056 case IEEE80211_CIPHER_AES_CCM: 3057 cipher = R92C_TXDW1_CIPHER_AES; 3058 break; 3059 default: 3060 device_printf(sc->sc_dev, "%s: unknown cipher %d\n", 3061 __func__, k->wk_cipher->ic_cipher); 3062 return (EINVAL); 3063 } 3064 3065 txd->txdw1 |= htole32(SM(R92C_TXDW1_CIPHER, cipher)); 3066 } 3067 3068 if (ieee80211_radiotap_active_vap(vap)) { 3069 struct urtwn_tx_radiotap_header *tap = &sc->sc_txtap; 3070 3071 tap->wt_flags = 0; 3072 if (k != NULL) 3073 tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 3074 ieee80211_radiotap_tx(vap, m); 3075 } 3076 3077 data->ni = ni; 3078 3079 urtwn_tx_start(sc, m, type, data); 3080 3081 return (0); 3082 } 3083 3084 static int 3085 urtwn_tx_raw(struct urtwn_softc *sc, struct ieee80211_node *ni, 3086 struct mbuf *m, struct urtwn_data *data, 3087 const struct ieee80211_bpf_params *params) 3088 { 3089 struct ieee80211vap *vap = ni->ni_vap; 3090 struct ieee80211_key *k = NULL; 3091 struct ieee80211_frame *wh; 3092 struct r92c_tx_desc *txd; 3093 uint8_t cipher, ridx, type; 3094 3095 /* Encrypt the frame if need be. */ 3096 cipher = R92C_TXDW1_CIPHER_NONE; 3097 if (params->ibp_flags & IEEE80211_BPF_CRYPTO) { 3098 /* Retrieve key for TX. */ 3099 k = ieee80211_crypto_encap(ni, m); 3100 if (k == NULL) 3101 return (ENOBUFS); 3102 3103 if (!(k->wk_flags & IEEE80211_KEY_SWCRYPT)) { 3104 switch (k->wk_cipher->ic_cipher) { 3105 case IEEE80211_CIPHER_WEP: 3106 case IEEE80211_CIPHER_TKIP: 3107 cipher = R92C_TXDW1_CIPHER_RC4; 3108 break; 3109 case IEEE80211_CIPHER_AES_CCM: 3110 cipher = R92C_TXDW1_CIPHER_AES; 3111 break; 3112 default: 3113 device_printf(sc->sc_dev, 3114 "%s: unknown cipher %d\n", 3115 __func__, k->wk_cipher->ic_cipher); 3116 return (EINVAL); 3117 } 3118 } 3119 } 3120 3121 /* XXX TODO: 11n checks, matching urtwn_tx_data() */ 3122 3123 wh = mtod(m, struct ieee80211_frame *); 3124 type = wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK; 3125 3126 /* Fill Tx descriptor. */ 3127 txd = (struct r92c_tx_desc *)data->buf; 3128 memset(txd, 0, sizeof(*txd)); 3129 3130 txd->txdw0 |= htole32( 3131 SM(R92C_TXDW0_OFFSET, sizeof(*txd)) | 3132 R92C_TXDW0_OWN | R92C_TXDW0_FSG | R92C_TXDW0_LSG); 3133 if (IEEE80211_IS_MULTICAST(wh->i_addr1)) 3134 txd->txdw0 |= htole32(R92C_TXDW0_BMCAST); 3135 3136 if (params->ibp_flags & IEEE80211_BPF_RTS) 3137 txd->txdw4 |= htole32(R92C_TXDW4_RTSEN); 3138 if (params->ibp_flags & IEEE80211_BPF_CTS) 3139 txd->txdw4 |= htole32(R92C_TXDW4_CTS2SELF); 3140 if (txd->txdw4 & htole32(R92C_TXDW4_RTSEN | R92C_TXDW4_CTS2SELF)) { 3141 txd->txdw4 |= htole32(R92C_TXDW4_HWRTSEN); 3142 txd->txdw4 |= htole32(SM(R92C_TXDW4_RTSRATE, 3143 URTWN_RIDX_OFDM24)); 3144 } 3145 3146 if (sc->chip & URTWN_CHIP_88E) 3147 txd->txdw1 |= htole32(SM(R88E_TXDW1_MACID, URTWN_MACID_BC)); 3148 else 3149 txd->txdw1 |= htole32(SM(R92C_TXDW1_MACID, URTWN_MACID_BC)); 3150 3151 /* XXX TODO: rate index/config (RAID) for 11n? */ 3152 txd->txdw1 |= htole32(SM(R92C_TXDW1_QSEL, R92C_TXDW1_QSEL_MGNT)); 3153 txd->txdw1 |= htole32(SM(R92C_TXDW1_CIPHER, cipher)); 3154 3155 /* Choose a TX rate index. */ 3156 ridx = rate2ridx(params->ibp_rate0); 3157 txd->txdw5 |= htole32(SM(R92C_TXDW5_DATARATE, ridx)); 3158 txd->txdw5 |= htole32(0x0001ff00); 3159 txd->txdw4 |= htole32(R92C_TXDW4_DRVRATE); 3160 3161 if (!IEEE80211_QOS_HAS_SEQ(wh)) { 3162 /* Use HW sequence numbering for non-QoS frames. */ 3163 if (sc->chip & URTWN_CHIP_88E) 3164 txd->txdseq = htole16(R88E_TXDSEQ_HWSEQ_EN); 3165 else 3166 txd->txdw4 |= htole32(R92C_TXDW4_HWSEQ_EN); 3167 } else { 3168 /* Set sequence number. */ 3169 txd->txdseq = htole16(M_SEQNO_GET(m) % IEEE80211_SEQ_RANGE); 3170 } 3171 3172 if (ieee80211_radiotap_active_vap(vap)) { 3173 struct urtwn_tx_radiotap_header *tap = &sc->sc_txtap; 3174 3175 tap->wt_flags = 0; 3176 if (k != NULL) 3177 tap->wt_flags |= IEEE80211_RADIOTAP_F_WEP; 3178 ieee80211_radiotap_tx(vap, m); 3179 } 3180 3181 data->ni = ni; 3182 3183 urtwn_tx_start(sc, m, type, data); 3184 3185 return (0); 3186 } 3187 3188 static void 3189 urtwn_tx_start(struct urtwn_softc *sc, struct mbuf *m, uint8_t type, 3190 struct urtwn_data *data) 3191 { 3192 struct usb_xfer *xfer; 3193 struct r92c_tx_desc *txd; 3194 uint16_t ac, sum; 3195 int i, xferlen; 3196 3197 URTWN_ASSERT_LOCKED(sc); 3198 3199 ac = M_WME_GETAC(m); 3200 3201 switch (type) { 3202 case IEEE80211_FC0_TYPE_CTL: 3203 case IEEE80211_FC0_TYPE_MGT: 3204 xfer = sc->sc_xfer[URTWN_BULK_TX_VO]; 3205 break; 3206 default: 3207 xfer = sc->sc_xfer[wme2queue[ac].qid]; 3208 break; 3209 } 3210 3211 txd = (struct r92c_tx_desc *)data->buf; 3212 txd->txdw0 |= htole32(SM(R92C_TXDW0_PKTLEN, m->m_pkthdr.len)); 3213 3214 /* Compute Tx descriptor checksum. */ 3215 sum = 0; 3216 for (i = 0; i < sizeof(*txd) / 2; i++) 3217 sum ^= ((uint16_t *)txd)[i]; 3218 txd->txdsum = sum; /* NB: already little endian. */ 3219 3220 xferlen = sizeof(*txd) + m->m_pkthdr.len; 3221 m_copydata(m, 0, m->m_pkthdr.len, (caddr_t)&txd[1]); 3222 3223 data->buflen = xferlen; 3224 data->m = m; 3225 3226 STAILQ_INSERT_TAIL(&sc->sc_tx_pending, data, next); 3227 usbd_transfer_start(xfer); 3228 } 3229 3230 static int 3231 urtwn_transmit(struct ieee80211com *ic, struct mbuf *m) 3232 { 3233 struct urtwn_softc *sc = ic->ic_softc; 3234 int error; 3235 3236 URTWN_LOCK(sc); 3237 if ((sc->sc_flags & URTWN_RUNNING) == 0) { 3238 URTWN_UNLOCK(sc); 3239 return (ENXIO); 3240 } 3241 error = mbufq_enqueue(&sc->sc_snd, m); 3242 if (error) { 3243 URTWN_UNLOCK(sc); 3244 return (error); 3245 } 3246 urtwn_start(sc); 3247 URTWN_UNLOCK(sc); 3248 3249 return (0); 3250 } 3251 3252 static void 3253 urtwn_start(struct urtwn_softc *sc) 3254 { 3255 struct ieee80211_node *ni; 3256 struct mbuf *m; 3257 struct urtwn_data *bf; 3258 3259 URTWN_ASSERT_LOCKED(sc); 3260 while ((m = mbufq_dequeue(&sc->sc_snd)) != NULL) { 3261 bf = urtwn_getbuf(sc); 3262 if (bf == NULL) { 3263 mbufq_prepend(&sc->sc_snd, m); 3264 break; 3265 } 3266 ni = (struct ieee80211_node *)m->m_pkthdr.rcvif; 3267 m->m_pkthdr.rcvif = NULL; 3268 3269 URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT, "%s: called; m=%p\n", 3270 __func__, 3271 m); 3272 3273 if (urtwn_tx_data(sc, ni, m, bf) != 0) { 3274 if_inc_counter(ni->ni_vap->iv_ifp, 3275 IFCOUNTER_OERRORS, 1); 3276 STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); 3277 m_freem(m); 3278 ieee80211_free_node(ni); 3279 break; 3280 } 3281 sc->sc_txtimer = 5; 3282 callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc); 3283 } 3284 } 3285 3286 static void 3287 urtwn_parent(struct ieee80211com *ic) 3288 { 3289 struct urtwn_softc *sc = ic->ic_softc; 3290 3291 URTWN_LOCK(sc); 3292 if (sc->sc_flags & URTWN_DETACHED) { 3293 URTWN_UNLOCK(sc); 3294 return; 3295 } 3296 URTWN_UNLOCK(sc); 3297 3298 if (ic->ic_nrunning > 0) { 3299 if (urtwn_init(sc) != 0) { 3300 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 3301 if (vap != NULL) 3302 ieee80211_stop(vap); 3303 } else 3304 ieee80211_start_all(ic); 3305 } else 3306 urtwn_stop(sc); 3307 } 3308 3309 static __inline int 3310 urtwn_power_on(struct urtwn_softc *sc) 3311 { 3312 3313 return sc->sc_power_on(sc); 3314 } 3315 3316 static int 3317 urtwn_r92c_power_on(struct urtwn_softc *sc) 3318 { 3319 uint32_t reg; 3320 usb_error_t error; 3321 int ntries; 3322 3323 /* Wait for autoload done bit. */ 3324 for (ntries = 0; ntries < 1000; ntries++) { 3325 if (urtwn_read_1(sc, R92C_APS_FSMCO) & R92C_APS_FSMCO_PFM_ALDN) 3326 break; 3327 urtwn_ms_delay(sc); 3328 } 3329 if (ntries == 1000) { 3330 device_printf(sc->sc_dev, 3331 "timeout waiting for chip autoload\n"); 3332 return (ETIMEDOUT); 3333 } 3334 3335 /* Unlock ISO/CLK/Power control register. */ 3336 error = urtwn_write_1(sc, R92C_RSV_CTRL, 0); 3337 if (error != USB_ERR_NORMAL_COMPLETION) 3338 return (EIO); 3339 /* Move SPS into PWM mode. */ 3340 error = urtwn_write_1(sc, R92C_SPS0_CTRL, 0x2b); 3341 if (error != USB_ERR_NORMAL_COMPLETION) 3342 return (EIO); 3343 urtwn_ms_delay(sc); 3344 3345 reg = urtwn_read_1(sc, R92C_LDOV12D_CTRL); 3346 if (!(reg & R92C_LDOV12D_CTRL_LDV12_EN)) { 3347 error = urtwn_write_1(sc, R92C_LDOV12D_CTRL, 3348 reg | R92C_LDOV12D_CTRL_LDV12_EN); 3349 if (error != USB_ERR_NORMAL_COMPLETION) 3350 return (EIO); 3351 urtwn_ms_delay(sc); 3352 error = urtwn_write_1(sc, R92C_SYS_ISO_CTRL, 3353 urtwn_read_1(sc, R92C_SYS_ISO_CTRL) & 3354 ~R92C_SYS_ISO_CTRL_MD2PP); 3355 if (error != USB_ERR_NORMAL_COMPLETION) 3356 return (EIO); 3357 } 3358 3359 /* Auto enable WLAN. */ 3360 error = urtwn_write_2(sc, R92C_APS_FSMCO, 3361 urtwn_read_2(sc, R92C_APS_FSMCO) | R92C_APS_FSMCO_APFM_ONMAC); 3362 if (error != USB_ERR_NORMAL_COMPLETION) 3363 return (EIO); 3364 for (ntries = 0; ntries < 1000; ntries++) { 3365 if (!(urtwn_read_2(sc, R92C_APS_FSMCO) & 3366 R92C_APS_FSMCO_APFM_ONMAC)) 3367 break; 3368 urtwn_ms_delay(sc); 3369 } 3370 if (ntries == 1000) { 3371 device_printf(sc->sc_dev, 3372 "timeout waiting for MAC auto ON\n"); 3373 return (ETIMEDOUT); 3374 } 3375 3376 /* Enable radio, GPIO and LED functions. */ 3377 error = urtwn_write_2(sc, R92C_APS_FSMCO, 3378 R92C_APS_FSMCO_AFSM_HSUS | 3379 R92C_APS_FSMCO_PDN_EN | 3380 R92C_APS_FSMCO_PFM_ALDN); 3381 if (error != USB_ERR_NORMAL_COMPLETION) 3382 return (EIO); 3383 /* Release RF digital isolation. */ 3384 error = urtwn_write_2(sc, R92C_SYS_ISO_CTRL, 3385 urtwn_read_2(sc, R92C_SYS_ISO_CTRL) & ~R92C_SYS_ISO_CTRL_DIOR); 3386 if (error != USB_ERR_NORMAL_COMPLETION) 3387 return (EIO); 3388 3389 /* Initialize MAC. */ 3390 error = urtwn_write_1(sc, R92C_APSD_CTRL, 3391 urtwn_read_1(sc, R92C_APSD_CTRL) & ~R92C_APSD_CTRL_OFF); 3392 if (error != USB_ERR_NORMAL_COMPLETION) 3393 return (EIO); 3394 for (ntries = 0; ntries < 200; ntries++) { 3395 if (!(urtwn_read_1(sc, R92C_APSD_CTRL) & 3396 R92C_APSD_CTRL_OFF_STATUS)) 3397 break; 3398 urtwn_ms_delay(sc); 3399 } 3400 if (ntries == 200) { 3401 device_printf(sc->sc_dev, 3402 "timeout waiting for MAC initialization\n"); 3403 return (ETIMEDOUT); 3404 } 3405 3406 /* Enable MAC DMA/WMAC/SCHEDULE/SEC blocks. */ 3407 reg = urtwn_read_2(sc, R92C_CR); 3408 reg |= R92C_CR_HCI_TXDMA_EN | R92C_CR_HCI_RXDMA_EN | 3409 R92C_CR_TXDMA_EN | R92C_CR_RXDMA_EN | R92C_CR_PROTOCOL_EN | 3410 R92C_CR_SCHEDULE_EN | R92C_CR_MACTXEN | R92C_CR_MACRXEN | 3411 R92C_CR_ENSEC; 3412 error = urtwn_write_2(sc, R92C_CR, reg); 3413 if (error != USB_ERR_NORMAL_COMPLETION) 3414 return (EIO); 3415 3416 error = urtwn_write_1(sc, 0xfe10, 0x19); 3417 if (error != USB_ERR_NORMAL_COMPLETION) 3418 return (EIO); 3419 return (0); 3420 } 3421 3422 static int 3423 urtwn_r88e_power_on(struct urtwn_softc *sc) 3424 { 3425 uint32_t reg; 3426 usb_error_t error; 3427 int ntries; 3428 3429 /* Wait for power ready bit. */ 3430 for (ntries = 0; ntries < 5000; ntries++) { 3431 if (urtwn_read_4(sc, R92C_APS_FSMCO) & R92C_APS_FSMCO_SUS_HOST) 3432 break; 3433 urtwn_ms_delay(sc); 3434 } 3435 if (ntries == 5000) { 3436 device_printf(sc->sc_dev, 3437 "timeout waiting for chip power up\n"); 3438 return (ETIMEDOUT); 3439 } 3440 3441 /* Reset BB. */ 3442 error = urtwn_write_1(sc, R92C_SYS_FUNC_EN, 3443 urtwn_read_1(sc, R92C_SYS_FUNC_EN) & ~(R92C_SYS_FUNC_EN_BBRSTB | 3444 R92C_SYS_FUNC_EN_BB_GLB_RST)); 3445 if (error != USB_ERR_NORMAL_COMPLETION) 3446 return (EIO); 3447 3448 error = urtwn_write_1(sc, R92C_AFE_XTAL_CTRL + 2, 3449 urtwn_read_1(sc, R92C_AFE_XTAL_CTRL + 2) | 0x80); 3450 if (error != USB_ERR_NORMAL_COMPLETION) 3451 return (EIO); 3452 3453 /* Disable HWPDN. */ 3454 error = urtwn_write_2(sc, R92C_APS_FSMCO, 3455 urtwn_read_2(sc, R92C_APS_FSMCO) & ~R92C_APS_FSMCO_APDM_HPDN); 3456 if (error != USB_ERR_NORMAL_COMPLETION) 3457 return (EIO); 3458 3459 /* Disable WL suspend. */ 3460 error = urtwn_write_2(sc, R92C_APS_FSMCO, 3461 urtwn_read_2(sc, R92C_APS_FSMCO) & 3462 ~(R92C_APS_FSMCO_AFSM_HSUS | R92C_APS_FSMCO_AFSM_PCIE)); 3463 if (error != USB_ERR_NORMAL_COMPLETION) 3464 return (EIO); 3465 3466 error = urtwn_write_2(sc, R92C_APS_FSMCO, 3467 urtwn_read_2(sc, R92C_APS_FSMCO) | R92C_APS_FSMCO_APFM_ONMAC); 3468 if (error != USB_ERR_NORMAL_COMPLETION) 3469 return (EIO); 3470 for (ntries = 0; ntries < 5000; ntries++) { 3471 if (!(urtwn_read_2(sc, R92C_APS_FSMCO) & 3472 R92C_APS_FSMCO_APFM_ONMAC)) 3473 break; 3474 urtwn_ms_delay(sc); 3475 } 3476 if (ntries == 5000) 3477 return (ETIMEDOUT); 3478 3479 /* Enable LDO normal mode. */ 3480 error = urtwn_write_1(sc, R92C_LPLDO_CTRL, 3481 urtwn_read_1(sc, R92C_LPLDO_CTRL) & ~R92C_LPLDO_CTRL_SLEEP); 3482 if (error != USB_ERR_NORMAL_COMPLETION) 3483 return (EIO); 3484 3485 /* Enable MAC DMA/WMAC/SCHEDULE/SEC blocks. */ 3486 error = urtwn_write_2(sc, R92C_CR, 0); 3487 if (error != USB_ERR_NORMAL_COMPLETION) 3488 return (EIO); 3489 reg = urtwn_read_2(sc, R92C_CR); 3490 reg |= R92C_CR_HCI_TXDMA_EN | R92C_CR_HCI_RXDMA_EN | 3491 R92C_CR_TXDMA_EN | R92C_CR_RXDMA_EN | R92C_CR_PROTOCOL_EN | 3492 R92C_CR_SCHEDULE_EN | R92C_CR_ENSEC | R92C_CR_CALTMR_EN; 3493 error = urtwn_write_2(sc, R92C_CR, reg); 3494 if (error != USB_ERR_NORMAL_COMPLETION) 3495 return (EIO); 3496 3497 return (0); 3498 } 3499 3500 static __inline void 3501 urtwn_power_off(struct urtwn_softc *sc) 3502 { 3503 3504 return sc->sc_power_off(sc); 3505 } 3506 3507 static void 3508 urtwn_r92c_power_off(struct urtwn_softc *sc) 3509 { 3510 uint32_t reg; 3511 3512 /* Block all Tx queues. */ 3513 urtwn_write_1(sc, R92C_TXPAUSE, R92C_TX_QUEUE_ALL); 3514 3515 /* Disable RF */ 3516 urtwn_rf_write(sc, 0, 0, 0); 3517 3518 urtwn_write_1(sc, R92C_APSD_CTRL, R92C_APSD_CTRL_OFF); 3519 3520 /* Reset BB state machine */ 3521 urtwn_write_1(sc, R92C_SYS_FUNC_EN, 3522 R92C_SYS_FUNC_EN_USBD | R92C_SYS_FUNC_EN_USBA | 3523 R92C_SYS_FUNC_EN_BB_GLB_RST); 3524 urtwn_write_1(sc, R92C_SYS_FUNC_EN, 3525 R92C_SYS_FUNC_EN_USBD | R92C_SYS_FUNC_EN_USBA); 3526 3527 /* 3528 * Reset digital sequence 3529 */ 3530 #ifndef URTWN_WITHOUT_UCODE 3531 if (urtwn_read_1(sc, R92C_MCUFWDL) & R92C_MCUFWDL_RDY) { 3532 /* Reset MCU ready status */ 3533 urtwn_write_1(sc, R92C_MCUFWDL, 0); 3534 3535 /* If firmware in ram code, do reset */ 3536 urtwn_fw_reset(sc); 3537 } 3538 #endif 3539 3540 /* Reset MAC and Enable 8051 */ 3541 urtwn_write_1(sc, R92C_SYS_FUNC_EN + 1, 3542 (R92C_SYS_FUNC_EN_CPUEN | 3543 R92C_SYS_FUNC_EN_ELDR | 3544 R92C_SYS_FUNC_EN_HWPDN) >> 8); 3545 3546 /* Reset MCU ready status */ 3547 urtwn_write_1(sc, R92C_MCUFWDL, 0); 3548 3549 /* Disable MAC clock */ 3550 urtwn_write_2(sc, R92C_SYS_CLKR, 3551 R92C_SYS_CLKR_ANAD16V_EN | 3552 R92C_SYS_CLKR_ANA8M | 3553 R92C_SYS_CLKR_LOADER_EN | 3554 R92C_SYS_CLKR_80M_SSC_DIS | 3555 R92C_SYS_CLKR_SYS_EN | 3556 R92C_SYS_CLKR_RING_EN | 3557 0x4000); 3558 3559 /* Disable AFE PLL */ 3560 urtwn_write_1(sc, R92C_AFE_PLL_CTRL, 0x80); 3561 3562 /* Gated AFE DIG_CLOCK */ 3563 urtwn_write_2(sc, R92C_AFE_XTAL_CTRL, 0x880F); 3564 3565 /* Isolated digital to PON */ 3566 urtwn_write_1(sc, R92C_SYS_ISO_CTRL, 3567 R92C_SYS_ISO_CTRL_MD2PP | 3568 R92C_SYS_ISO_CTRL_PA2PCIE | 3569 R92C_SYS_ISO_CTRL_PD2CORE | 3570 R92C_SYS_ISO_CTRL_IP2MAC | 3571 R92C_SYS_ISO_CTRL_DIOP | 3572 R92C_SYS_ISO_CTRL_DIOE); 3573 3574 /* 3575 * Pull GPIO PIN to balance level and LED control 3576 */ 3577 /* 1. Disable GPIO[7:0] */ 3578 urtwn_write_2(sc, R92C_GPIO_IOSEL, 0x0000); 3579 3580 reg = urtwn_read_4(sc, R92C_GPIO_PIN_CTRL) & ~0x0000ff00; 3581 reg |= ((reg << 8) & 0x0000ff00) | 0x00ff0000; 3582 urtwn_write_4(sc, R92C_GPIO_PIN_CTRL, reg); 3583 3584 /* Disable GPIO[10:8] */ 3585 urtwn_write_1(sc, R92C_MAC_PINMUX_CFG, 0x00); 3586 3587 reg = urtwn_read_2(sc, R92C_GPIO_IO_SEL) & ~0x00f0; 3588 reg |= (((reg & 0x000f) << 4) | 0x0780); 3589 urtwn_write_2(sc, R92C_GPIO_IO_SEL, reg); 3590 3591 /* Disable LED0 & 1 */ 3592 urtwn_write_2(sc, R92C_LEDCFG0, 0x8080); 3593 3594 /* 3595 * Reset digital sequence 3596 */ 3597 /* Disable ELDR clock */ 3598 urtwn_write_2(sc, R92C_SYS_CLKR, 3599 R92C_SYS_CLKR_ANAD16V_EN | 3600 R92C_SYS_CLKR_ANA8M | 3601 R92C_SYS_CLKR_LOADER_EN | 3602 R92C_SYS_CLKR_80M_SSC_DIS | 3603 R92C_SYS_CLKR_SYS_EN | 3604 R92C_SYS_CLKR_RING_EN | 3605 0x4000); 3606 3607 /* Isolated ELDR to PON */ 3608 urtwn_write_1(sc, R92C_SYS_ISO_CTRL + 1, 3609 (R92C_SYS_ISO_CTRL_DIOR | 3610 R92C_SYS_ISO_CTRL_PWC_EV12V) >> 8); 3611 3612 /* 3613 * Disable analog sequence 3614 */ 3615 /* Disable A15 power */ 3616 urtwn_write_1(sc, R92C_LDOA15_CTRL, R92C_LDOA15_CTRL_OBUF); 3617 /* Disable digital core power */ 3618 urtwn_write_1(sc, R92C_LDOV12D_CTRL, 3619 urtwn_read_1(sc, R92C_LDOV12D_CTRL) & 3620 ~R92C_LDOV12D_CTRL_LDV12_EN); 3621 3622 /* Enter PFM mode */ 3623 urtwn_write_1(sc, R92C_SPS0_CTRL, 0x23); 3624 3625 /* Set USB suspend */ 3626 urtwn_write_2(sc, R92C_APS_FSMCO, 3627 R92C_APS_FSMCO_APDM_HOST | 3628 R92C_APS_FSMCO_AFSM_HSUS | 3629 R92C_APS_FSMCO_PFM_ALDN); 3630 3631 /* Lock ISO/CLK/Power control register. */ 3632 urtwn_write_1(sc, R92C_RSV_CTRL, 0x0E); 3633 } 3634 3635 static void 3636 urtwn_r88e_power_off(struct urtwn_softc *sc) 3637 { 3638 uint8_t reg; 3639 int ntries; 3640 3641 /* Disable any kind of TX reports. */ 3642 urtwn_write_1(sc, R88E_TX_RPT_CTRL, 3643 urtwn_read_1(sc, R88E_TX_RPT_CTRL) & 3644 ~(R88E_TX_RPT1_ENA | R88E_TX_RPT2_ENA)); 3645 3646 /* Stop Rx. */ 3647 urtwn_write_1(sc, R92C_CR, 0); 3648 3649 /* Move card to Low Power State. */ 3650 /* Block all Tx queues. */ 3651 urtwn_write_1(sc, R92C_TXPAUSE, R92C_TX_QUEUE_ALL); 3652 3653 for (ntries = 0; ntries < 20; ntries++) { 3654 /* Should be zero if no packet is transmitting. */ 3655 if (urtwn_read_4(sc, R88E_SCH_TXCMD) == 0) 3656 break; 3657 3658 urtwn_ms_delay(sc); 3659 } 3660 if (ntries == 20) { 3661 device_printf(sc->sc_dev, "%s: failed to block Tx queues\n", 3662 __func__); 3663 return; 3664 } 3665 3666 /* CCK and OFDM are disabled, and clock are gated. */ 3667 urtwn_write_1(sc, R92C_SYS_FUNC_EN, 3668 urtwn_read_1(sc, R92C_SYS_FUNC_EN) & ~R92C_SYS_FUNC_EN_BBRSTB); 3669 3670 urtwn_ms_delay(sc); 3671 3672 /* Reset MAC TRX */ 3673 urtwn_write_1(sc, R92C_CR, 3674 R92C_CR_HCI_TXDMA_EN | R92C_CR_HCI_RXDMA_EN | 3675 R92C_CR_TXDMA_EN | R92C_CR_RXDMA_EN | 3676 R92C_CR_PROTOCOL_EN | R92C_CR_SCHEDULE_EN); 3677 3678 /* check if removed later */ 3679 urtwn_write_1(sc, R92C_CR + 1, 3680 urtwn_read_1(sc, R92C_CR + 1) & ~(R92C_CR_ENSEC >> 8)); 3681 3682 /* Respond TxOK to scheduler */ 3683 urtwn_write_1(sc, R92C_DUAL_TSF_RST, 3684 urtwn_read_1(sc, R92C_DUAL_TSF_RST) | 0x20); 3685 3686 /* If firmware in ram code, do reset. */ 3687 #ifndef URTWN_WITHOUT_UCODE 3688 if (urtwn_read_1(sc, R92C_MCUFWDL) & R92C_MCUFWDL_RDY) 3689 urtwn_r88e_fw_reset(sc); 3690 #endif 3691 3692 /* Reset MCU ready status. */ 3693 urtwn_write_1(sc, R92C_MCUFWDL, 0x00); 3694 3695 /* Disable 32k. */ 3696 urtwn_write_1(sc, R88E_32K_CTRL, 3697 urtwn_read_1(sc, R88E_32K_CTRL) & ~0x01); 3698 3699 /* Move card to Disabled state. */ 3700 /* Turn off RF. */ 3701 urtwn_write_1(sc, R92C_RF_CTRL, 0); 3702 3703 /* LDO Sleep mode. */ 3704 urtwn_write_1(sc, R92C_LPLDO_CTRL, 3705 urtwn_read_1(sc, R92C_LPLDO_CTRL) | R92C_LPLDO_CTRL_SLEEP); 3706 3707 /* Turn off MAC by HW state machine */ 3708 urtwn_write_1(sc, R92C_APS_FSMCO + 1, 3709 urtwn_read_1(sc, R92C_APS_FSMCO + 1) | 3710 (R92C_APS_FSMCO_APFM_OFF >> 8)); 3711 3712 for (ntries = 0; ntries < 20; ntries++) { 3713 /* Wait until it will be disabled. */ 3714 if ((urtwn_read_1(sc, R92C_APS_FSMCO + 1) & 3715 (R92C_APS_FSMCO_APFM_OFF >> 8)) == 0) 3716 break; 3717 3718 urtwn_ms_delay(sc); 3719 } 3720 if (ntries == 20) { 3721 device_printf(sc->sc_dev, "%s: could not turn off MAC\n", 3722 __func__); 3723 return; 3724 } 3725 3726 /* schmit trigger */ 3727 urtwn_write_1(sc, R92C_AFE_XTAL_CTRL + 2, 3728 urtwn_read_1(sc, R92C_AFE_XTAL_CTRL + 2) | 0x80); 3729 3730 /* Enable WL suspend. */ 3731 urtwn_write_1(sc, R92C_APS_FSMCO + 1, 3732 (urtwn_read_1(sc, R92C_APS_FSMCO + 1) & ~0x10) | 0x08); 3733 3734 /* Enable bandgap mbias in suspend. */ 3735 urtwn_write_1(sc, R92C_APS_FSMCO + 3, 0); 3736 3737 /* Clear SIC_EN register. */ 3738 urtwn_write_1(sc, R92C_GPIO_MUXCFG + 1, 3739 urtwn_read_1(sc, R92C_GPIO_MUXCFG + 1) & ~0x10); 3740 3741 /* Set USB suspend enable local register */ 3742 urtwn_write_1(sc, R92C_USB_SUSPEND, 3743 urtwn_read_1(sc, R92C_USB_SUSPEND) | 0x10); 3744 3745 /* Reset MCU IO Wrapper. */ 3746 reg = urtwn_read_1(sc, R92C_RSV_CTRL + 1); 3747 urtwn_write_1(sc, R92C_RSV_CTRL + 1, reg & ~0x08); 3748 urtwn_write_1(sc, R92C_RSV_CTRL + 1, reg | 0x08); 3749 3750 /* marked as 'For Power Consumption' code. */ 3751 urtwn_write_1(sc, R92C_GPIO_OUT, urtwn_read_1(sc, R92C_GPIO_IN)); 3752 urtwn_write_1(sc, R92C_GPIO_IOSEL, 0xff); 3753 3754 urtwn_write_1(sc, R92C_GPIO_IO_SEL, 3755 urtwn_read_1(sc, R92C_GPIO_IO_SEL) << 4); 3756 urtwn_write_1(sc, R92C_GPIO_MOD, 3757 urtwn_read_1(sc, R92C_GPIO_MOD) | 0x0f); 3758 3759 /* Set LNA, TRSW, EX_PA Pin to output mode. */ 3760 urtwn_write_4(sc, R88E_BB_PAD_CTRL, 0x00080808); 3761 } 3762 3763 static int 3764 urtwn_llt_init(struct urtwn_softc *sc) 3765 { 3766 int i, error, page_count, pktbuf_count; 3767 3768 page_count = (sc->chip & URTWN_CHIP_88E) ? 3769 R88E_TX_PAGE_COUNT : R92C_TX_PAGE_COUNT; 3770 pktbuf_count = (sc->chip & URTWN_CHIP_88E) ? 3771 R88E_TXPKTBUF_COUNT : R92C_TXPKTBUF_COUNT; 3772 3773 /* Reserve pages [0; page_count]. */ 3774 for (i = 0; i < page_count; i++) { 3775 if ((error = urtwn_llt_write(sc, i, i + 1)) != 0) 3776 return (error); 3777 } 3778 /* NB: 0xff indicates end-of-list. */ 3779 if ((error = urtwn_llt_write(sc, i, 0xff)) != 0) 3780 return (error); 3781 /* 3782 * Use pages [page_count + 1; pktbuf_count - 1] 3783 * as ring buffer. 3784 */ 3785 for (++i; i < pktbuf_count - 1; i++) { 3786 if ((error = urtwn_llt_write(sc, i, i + 1)) != 0) 3787 return (error); 3788 } 3789 /* Make the last page point to the beginning of the ring buffer. */ 3790 error = urtwn_llt_write(sc, i, page_count + 1); 3791 return (error); 3792 } 3793 3794 #ifndef URTWN_WITHOUT_UCODE 3795 static void 3796 urtwn_fw_reset(struct urtwn_softc *sc) 3797 { 3798 uint16_t reg; 3799 int ntries; 3800 3801 /* Tell 8051 to reset itself. */ 3802 urtwn_write_1(sc, R92C_HMETFR + 3, 0x20); 3803 3804 /* Wait until 8051 resets by itself. */ 3805 for (ntries = 0; ntries < 100; ntries++) { 3806 reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN); 3807 if (!(reg & R92C_SYS_FUNC_EN_CPUEN)) 3808 return; 3809 urtwn_ms_delay(sc); 3810 } 3811 /* Force 8051 reset. */ 3812 urtwn_write_2(sc, R92C_SYS_FUNC_EN, reg & ~R92C_SYS_FUNC_EN_CPUEN); 3813 } 3814 3815 static void 3816 urtwn_r88e_fw_reset(struct urtwn_softc *sc) 3817 { 3818 uint16_t reg; 3819 3820 reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN); 3821 urtwn_write_2(sc, R92C_SYS_FUNC_EN, reg & ~R92C_SYS_FUNC_EN_CPUEN); 3822 urtwn_write_2(sc, R92C_SYS_FUNC_EN, reg | R92C_SYS_FUNC_EN_CPUEN); 3823 } 3824 3825 static int 3826 urtwn_fw_loadpage(struct urtwn_softc *sc, int page, const uint8_t *buf, int len) 3827 { 3828 uint32_t reg; 3829 usb_error_t error = USB_ERR_NORMAL_COMPLETION; 3830 int off, mlen; 3831 3832 reg = urtwn_read_4(sc, R92C_MCUFWDL); 3833 reg = RW(reg, R92C_MCUFWDL_PAGE, page); 3834 urtwn_write_4(sc, R92C_MCUFWDL, reg); 3835 3836 off = R92C_FW_START_ADDR; 3837 while (len > 0) { 3838 if (len > 196) 3839 mlen = 196; 3840 else if (len > 4) 3841 mlen = 4; 3842 else 3843 mlen = 1; 3844 /* XXX fix this deconst */ 3845 error = urtwn_write_region_1(sc, off, 3846 __DECONST(uint8_t *, buf), mlen); 3847 if (error != USB_ERR_NORMAL_COMPLETION) 3848 break; 3849 off += mlen; 3850 buf += mlen; 3851 len -= mlen; 3852 } 3853 return (error); 3854 } 3855 3856 static int 3857 urtwn_load_firmware(struct urtwn_softc *sc) 3858 { 3859 const struct firmware *fw; 3860 const struct r92c_fw_hdr *hdr; 3861 const char *imagename; 3862 const u_char *ptr; 3863 size_t len; 3864 uint32_t reg; 3865 int mlen, ntries, page, error; 3866 3867 URTWN_UNLOCK(sc); 3868 /* Read firmware image from the filesystem. */ 3869 if (sc->chip & URTWN_CHIP_88E) 3870 imagename = "urtwn-rtl8188eufw"; 3871 else if ((sc->chip & (URTWN_CHIP_UMC_A_CUT | URTWN_CHIP_92C)) == 3872 URTWN_CHIP_UMC_A_CUT) 3873 imagename = "urtwn-rtl8192cfwU"; 3874 else 3875 imagename = "urtwn-rtl8192cfwT"; 3876 3877 fw = firmware_get(imagename); 3878 URTWN_LOCK(sc); 3879 if (fw == NULL) { 3880 device_printf(sc->sc_dev, 3881 "failed loadfirmware of file %s\n", imagename); 3882 return (ENOENT); 3883 } 3884 3885 len = fw->datasize; 3886 3887 if (len < sizeof(*hdr)) { 3888 device_printf(sc->sc_dev, "firmware too short\n"); 3889 error = EINVAL; 3890 goto fail; 3891 } 3892 ptr = fw->data; 3893 hdr = (const struct r92c_fw_hdr *)ptr; 3894 /* Check if there is a valid FW header and skip it. */ 3895 if ((le16toh(hdr->signature) >> 4) == 0x88c || 3896 (le16toh(hdr->signature) >> 4) == 0x88e || 3897 (le16toh(hdr->signature) >> 4) == 0x92c) { 3898 URTWN_DPRINTF(sc, URTWN_DEBUG_FIRMWARE, 3899 "FW V%d.%d %02d-%02d %02d:%02d\n", 3900 le16toh(hdr->version), le16toh(hdr->subversion), 3901 hdr->month, hdr->date, hdr->hour, hdr->minute); 3902 ptr += sizeof(*hdr); 3903 len -= sizeof(*hdr); 3904 } 3905 3906 if (urtwn_read_1(sc, R92C_MCUFWDL) & R92C_MCUFWDL_RAM_DL_SEL) { 3907 if (sc->chip & URTWN_CHIP_88E) 3908 urtwn_r88e_fw_reset(sc); 3909 else 3910 urtwn_fw_reset(sc); 3911 urtwn_write_1(sc, R92C_MCUFWDL, 0); 3912 } 3913 3914 if (!(sc->chip & URTWN_CHIP_88E)) { 3915 urtwn_write_2(sc, R92C_SYS_FUNC_EN, 3916 urtwn_read_2(sc, R92C_SYS_FUNC_EN) | 3917 R92C_SYS_FUNC_EN_CPUEN); 3918 } 3919 urtwn_write_1(sc, R92C_MCUFWDL, 3920 urtwn_read_1(sc, R92C_MCUFWDL) | R92C_MCUFWDL_EN); 3921 urtwn_write_1(sc, R92C_MCUFWDL + 2, 3922 urtwn_read_1(sc, R92C_MCUFWDL + 2) & ~0x08); 3923 3924 /* Reset the FWDL checksum. */ 3925 urtwn_write_1(sc, R92C_MCUFWDL, 3926 urtwn_read_1(sc, R92C_MCUFWDL) | R92C_MCUFWDL_CHKSUM_RPT); 3927 3928 for (page = 0; len > 0; page++) { 3929 mlen = min(len, R92C_FW_PAGE_SIZE); 3930 error = urtwn_fw_loadpage(sc, page, ptr, mlen); 3931 if (error != 0) { 3932 device_printf(sc->sc_dev, 3933 "could not load firmware page\n"); 3934 goto fail; 3935 } 3936 ptr += mlen; 3937 len -= mlen; 3938 } 3939 urtwn_write_1(sc, R92C_MCUFWDL, 3940 urtwn_read_1(sc, R92C_MCUFWDL) & ~R92C_MCUFWDL_EN); 3941 urtwn_write_1(sc, R92C_MCUFWDL + 1, 0); 3942 3943 /* Wait for checksum report. */ 3944 for (ntries = 0; ntries < 1000; ntries++) { 3945 if (urtwn_read_4(sc, R92C_MCUFWDL) & R92C_MCUFWDL_CHKSUM_RPT) 3946 break; 3947 urtwn_ms_delay(sc); 3948 } 3949 if (ntries == 1000) { 3950 device_printf(sc->sc_dev, 3951 "timeout waiting for checksum report\n"); 3952 error = ETIMEDOUT; 3953 goto fail; 3954 } 3955 3956 reg = urtwn_read_4(sc, R92C_MCUFWDL); 3957 reg = (reg & ~R92C_MCUFWDL_WINTINI_RDY) | R92C_MCUFWDL_RDY; 3958 urtwn_write_4(sc, R92C_MCUFWDL, reg); 3959 if (sc->chip & URTWN_CHIP_88E) 3960 urtwn_r88e_fw_reset(sc); 3961 /* Wait for firmware readiness. */ 3962 for (ntries = 0; ntries < 1000; ntries++) { 3963 if (urtwn_read_4(sc, R92C_MCUFWDL) & R92C_MCUFWDL_WINTINI_RDY) 3964 break; 3965 urtwn_ms_delay(sc); 3966 } 3967 if (ntries == 1000) { 3968 device_printf(sc->sc_dev, 3969 "timeout waiting for firmware readiness\n"); 3970 error = ETIMEDOUT; 3971 goto fail; 3972 } 3973 fail: 3974 firmware_put(fw, FIRMWARE_UNLOAD); 3975 return (error); 3976 } 3977 #endif 3978 3979 static int 3980 urtwn_dma_init(struct urtwn_softc *sc) 3981 { 3982 struct usb_endpoint *ep, *ep_end; 3983 usb_error_t usb_err; 3984 uint32_t reg; 3985 int hashq, hasnq, haslq, nqueues, ntx; 3986 int error, pagecount, npubqpages, nqpages, nrempages, tx_boundary; 3987 3988 /* Initialize LLT table. */ 3989 error = urtwn_llt_init(sc); 3990 if (error != 0) 3991 return (error); 3992 3993 /* Determine the number of bulk-out pipes. */ 3994 ntx = 0; 3995 ep = sc->sc_udev->endpoints; 3996 ep_end = sc->sc_udev->endpoints + sc->sc_udev->endpoints_max; 3997 for (; ep != ep_end; ep++) { 3998 if ((ep->edesc == NULL) || 3999 (ep->iface_index != sc->sc_iface_index)) 4000 continue; 4001 if (UE_GET_DIR(ep->edesc->bEndpointAddress) == UE_DIR_OUT) 4002 ntx++; 4003 } 4004 if (ntx == 0) { 4005 device_printf(sc->sc_dev, 4006 "%d: invalid number of Tx bulk pipes\n", ntx); 4007 return (EIO); 4008 } 4009 4010 /* Get Tx queues to USB endpoints mapping. */ 4011 hashq = hasnq = haslq = nqueues = 0; 4012 switch (ntx) { 4013 case 1: hashq = 1; break; 4014 case 2: hashq = hasnq = 1; break; 4015 case 3: case 4: hashq = hasnq = haslq = 1; break; 4016 } 4017 nqueues = hashq + hasnq + haslq; 4018 if (nqueues == 0) 4019 return (EIO); 4020 4021 npubqpages = nqpages = nrempages = pagecount = 0; 4022 if (sc->chip & URTWN_CHIP_88E) 4023 tx_boundary = R88E_TX_PAGE_BOUNDARY; 4024 else { 4025 pagecount = R92C_TX_PAGE_COUNT; 4026 npubqpages = R92C_PUBQ_NPAGES; 4027 tx_boundary = R92C_TX_PAGE_BOUNDARY; 4028 } 4029 4030 /* Set number of pages for normal priority queue. */ 4031 if (sc->chip & URTWN_CHIP_88E) { 4032 usb_err = urtwn_write_2(sc, R92C_RQPN_NPQ, 0xd); 4033 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4034 return (EIO); 4035 usb_err = urtwn_write_4(sc, R92C_RQPN, 0x808e000d); 4036 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4037 return (EIO); 4038 } else { 4039 /* Get the number of pages for each queue. */ 4040 nqpages = (pagecount - npubqpages) / nqueues; 4041 /* 4042 * The remaining pages are assigned to the high priority 4043 * queue. 4044 */ 4045 nrempages = (pagecount - npubqpages) % nqueues; 4046 usb_err = urtwn_write_1(sc, R92C_RQPN_NPQ, hasnq ? nqpages : 0); 4047 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4048 return (EIO); 4049 usb_err = urtwn_write_4(sc, R92C_RQPN, 4050 /* Set number of pages for public queue. */ 4051 SM(R92C_RQPN_PUBQ, npubqpages) | 4052 /* Set number of pages for high priority queue. */ 4053 SM(R92C_RQPN_HPQ, hashq ? nqpages + nrempages : 0) | 4054 /* Set number of pages for low priority queue. */ 4055 SM(R92C_RQPN_LPQ, haslq ? nqpages : 0) | 4056 /* Load values. */ 4057 R92C_RQPN_LD); 4058 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4059 return (EIO); 4060 } 4061 4062 usb_err = urtwn_write_1(sc, R92C_TXPKTBUF_BCNQ_BDNY, tx_boundary); 4063 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4064 return (EIO); 4065 usb_err = urtwn_write_1(sc, R92C_TXPKTBUF_MGQ_BDNY, tx_boundary); 4066 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4067 return (EIO); 4068 usb_err = urtwn_write_1(sc, R92C_TXPKTBUF_WMAC_LBK_BF_HD, tx_boundary); 4069 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4070 return (EIO); 4071 usb_err = urtwn_write_1(sc, R92C_TRXFF_BNDY, tx_boundary); 4072 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4073 return (EIO); 4074 usb_err = urtwn_write_1(sc, R92C_TDECTRL + 1, tx_boundary); 4075 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4076 return (EIO); 4077 4078 /* Set queue to USB pipe mapping. */ 4079 reg = urtwn_read_2(sc, R92C_TRXDMA_CTRL); 4080 reg &= ~R92C_TRXDMA_CTRL_QMAP_M; 4081 if (nqueues == 1) { 4082 if (hashq) 4083 reg |= R92C_TRXDMA_CTRL_QMAP_HQ; 4084 else if (hasnq) 4085 reg |= R92C_TRXDMA_CTRL_QMAP_NQ; 4086 else 4087 reg |= R92C_TRXDMA_CTRL_QMAP_LQ; 4088 } else if (nqueues == 2) { 4089 /* 4090 * All 2-endpoints configs have high and normal 4091 * priority queues. 4092 */ 4093 reg |= R92C_TRXDMA_CTRL_QMAP_HQ_NQ; 4094 } else 4095 reg |= R92C_TRXDMA_CTRL_QMAP_3EP; 4096 usb_err = urtwn_write_2(sc, R92C_TRXDMA_CTRL, reg); 4097 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4098 return (EIO); 4099 4100 /* Set Tx/Rx transfer page boundary. */ 4101 usb_err = urtwn_write_2(sc, R92C_TRXFF_BNDY + 2, 4102 (sc->chip & URTWN_CHIP_88E) ? 0x23ff : 0x27ff); 4103 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4104 return (EIO); 4105 4106 /* Set Tx/Rx transfer page size. */ 4107 usb_err = urtwn_write_1(sc, R92C_PBP, 4108 SM(R92C_PBP_PSRX, R92C_PBP_128) | 4109 SM(R92C_PBP_PSTX, R92C_PBP_128)); 4110 if (usb_err != USB_ERR_NORMAL_COMPLETION) 4111 return (EIO); 4112 4113 return (0); 4114 } 4115 4116 static int 4117 urtwn_mac_init(struct urtwn_softc *sc) 4118 { 4119 usb_error_t error; 4120 int i; 4121 4122 /* Write MAC initialization values. */ 4123 if (sc->chip & URTWN_CHIP_88E) { 4124 for (i = 0; i < nitems(rtl8188eu_mac); i++) { 4125 error = urtwn_write_1(sc, rtl8188eu_mac[i].reg, 4126 rtl8188eu_mac[i].val); 4127 if (error != USB_ERR_NORMAL_COMPLETION) 4128 return (EIO); 4129 } 4130 urtwn_write_1(sc, R92C_MAX_AGGR_NUM, 0x07); 4131 } else { 4132 for (i = 0; i < nitems(rtl8192cu_mac); i++) 4133 error = urtwn_write_1(sc, rtl8192cu_mac[i].reg, 4134 rtl8192cu_mac[i].val); 4135 if (error != USB_ERR_NORMAL_COMPLETION) 4136 return (EIO); 4137 } 4138 4139 return (0); 4140 } 4141 4142 static void 4143 urtwn_bb_init(struct urtwn_softc *sc) 4144 { 4145 const struct urtwn_bb_prog *prog; 4146 uint32_t reg; 4147 uint8_t crystalcap; 4148 int i; 4149 4150 /* Enable BB and RF. */ 4151 urtwn_write_2(sc, R92C_SYS_FUNC_EN, 4152 urtwn_read_2(sc, R92C_SYS_FUNC_EN) | 4153 R92C_SYS_FUNC_EN_BBRSTB | R92C_SYS_FUNC_EN_BB_GLB_RST | 4154 R92C_SYS_FUNC_EN_DIO_RF); 4155 4156 if (!(sc->chip & URTWN_CHIP_88E)) 4157 urtwn_write_2(sc, R92C_AFE_PLL_CTRL, 0xdb83); 4158 4159 urtwn_write_1(sc, R92C_RF_CTRL, 4160 R92C_RF_CTRL_EN | R92C_RF_CTRL_RSTB | R92C_RF_CTRL_SDMRSTB); 4161 urtwn_write_1(sc, R92C_SYS_FUNC_EN, 4162 R92C_SYS_FUNC_EN_USBA | R92C_SYS_FUNC_EN_USBD | 4163 R92C_SYS_FUNC_EN_BB_GLB_RST | R92C_SYS_FUNC_EN_BBRSTB); 4164 4165 if (!(sc->chip & URTWN_CHIP_88E)) { 4166 urtwn_write_1(sc, R92C_LDOHCI12_CTRL, 0x0f); 4167 urtwn_write_1(sc, 0x15, 0xe9); 4168 urtwn_write_1(sc, R92C_AFE_XTAL_CTRL + 1, 0x80); 4169 } 4170 4171 /* Select BB programming based on board type. */ 4172 if (sc->chip & URTWN_CHIP_88E) 4173 prog = &rtl8188eu_bb_prog; 4174 else if (!(sc->chip & URTWN_CHIP_92C)) { 4175 if (sc->board_type == R92C_BOARD_TYPE_MINICARD) 4176 prog = &rtl8188ce_bb_prog; 4177 else if (sc->board_type == R92C_BOARD_TYPE_HIGHPA) 4178 prog = &rtl8188ru_bb_prog; 4179 else 4180 prog = &rtl8188cu_bb_prog; 4181 } else { 4182 if (sc->board_type == R92C_BOARD_TYPE_MINICARD) 4183 prog = &rtl8192ce_bb_prog; 4184 else 4185 prog = &rtl8192cu_bb_prog; 4186 } 4187 /* Write BB initialization values. */ 4188 for (i = 0; i < prog->count; i++) { 4189 urtwn_bb_write(sc, prog->regs[i], prog->vals[i]); 4190 urtwn_ms_delay(sc); 4191 } 4192 4193 if (sc->chip & URTWN_CHIP_92C_1T2R) { 4194 /* 8192C 1T only configuration. */ 4195 reg = urtwn_bb_read(sc, R92C_FPGA0_TXINFO); 4196 reg = (reg & ~0x00000003) | 0x2; 4197 urtwn_bb_write(sc, R92C_FPGA0_TXINFO, reg); 4198 4199 reg = urtwn_bb_read(sc, R92C_FPGA1_TXINFO); 4200 reg = (reg & ~0x00300033) | 0x00200022; 4201 urtwn_bb_write(sc, R92C_FPGA1_TXINFO, reg); 4202 4203 reg = urtwn_bb_read(sc, R92C_CCK0_AFESETTING); 4204 reg = (reg & ~0xff000000) | 0x45 << 24; 4205 urtwn_bb_write(sc, R92C_CCK0_AFESETTING, reg); 4206 4207 reg = urtwn_bb_read(sc, R92C_OFDM0_TRXPATHENA); 4208 reg = (reg & ~0x000000ff) | 0x23; 4209 urtwn_bb_write(sc, R92C_OFDM0_TRXPATHENA, reg); 4210 4211 reg = urtwn_bb_read(sc, R92C_OFDM0_AGCPARAM1); 4212 reg = (reg & ~0x00000030) | 1 << 4; 4213 urtwn_bb_write(sc, R92C_OFDM0_AGCPARAM1, reg); 4214 4215 reg = urtwn_bb_read(sc, 0xe74); 4216 reg = (reg & ~0x0c000000) | 2 << 26; 4217 urtwn_bb_write(sc, 0xe74, reg); 4218 reg = urtwn_bb_read(sc, 0xe78); 4219 reg = (reg & ~0x0c000000) | 2 << 26; 4220 urtwn_bb_write(sc, 0xe78, reg); 4221 reg = urtwn_bb_read(sc, 0xe7c); 4222 reg = (reg & ~0x0c000000) | 2 << 26; 4223 urtwn_bb_write(sc, 0xe7c, reg); 4224 reg = urtwn_bb_read(sc, 0xe80); 4225 reg = (reg & ~0x0c000000) | 2 << 26; 4226 urtwn_bb_write(sc, 0xe80, reg); 4227 reg = urtwn_bb_read(sc, 0xe88); 4228 reg = (reg & ~0x0c000000) | 2 << 26; 4229 urtwn_bb_write(sc, 0xe88, reg); 4230 } 4231 4232 /* Write AGC values. */ 4233 for (i = 0; i < prog->agccount; i++) { 4234 urtwn_bb_write(sc, R92C_OFDM0_AGCRSSITABLE, 4235 prog->agcvals[i]); 4236 urtwn_ms_delay(sc); 4237 } 4238 4239 if (sc->chip & URTWN_CHIP_88E) { 4240 urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(0), 0x69553422); 4241 urtwn_ms_delay(sc); 4242 urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(0), 0x69553420); 4243 urtwn_ms_delay(sc); 4244 4245 crystalcap = sc->rom.r88e_rom.crystalcap; 4246 if (crystalcap == 0xff) 4247 crystalcap = 0x20; 4248 crystalcap &= 0x3f; 4249 reg = urtwn_bb_read(sc, R92C_AFE_XTAL_CTRL); 4250 urtwn_bb_write(sc, R92C_AFE_XTAL_CTRL, 4251 RW(reg, R92C_AFE_XTAL_CTRL_ADDR, 4252 crystalcap | crystalcap << 6)); 4253 } else { 4254 if (urtwn_bb_read(sc, R92C_HSSI_PARAM2(0)) & 4255 R92C_HSSI_PARAM2_CCK_HIPWR) 4256 sc->sc_flags |= URTWN_FLAG_CCK_HIPWR; 4257 } 4258 } 4259 4260 static void 4261 urtwn_rf_init(struct urtwn_softc *sc) 4262 { 4263 const struct urtwn_rf_prog *prog; 4264 uint32_t reg, type; 4265 int i, j, idx, off; 4266 4267 /* Select RF programming based on board type. */ 4268 if (sc->chip & URTWN_CHIP_88E) 4269 prog = rtl8188eu_rf_prog; 4270 else if (!(sc->chip & URTWN_CHIP_92C)) { 4271 if (sc->board_type == R92C_BOARD_TYPE_MINICARD) 4272 prog = rtl8188ce_rf_prog; 4273 else if (sc->board_type == R92C_BOARD_TYPE_HIGHPA) 4274 prog = rtl8188ru_rf_prog; 4275 else 4276 prog = rtl8188cu_rf_prog; 4277 } else 4278 prog = rtl8192ce_rf_prog; 4279 4280 for (i = 0; i < sc->nrxchains; i++) { 4281 /* Save RF_ENV control type. */ 4282 idx = i / 2; 4283 off = (i % 2) * 16; 4284 reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACESW(idx)); 4285 type = (reg >> off) & 0x10; 4286 4287 /* Set RF_ENV enable. */ 4288 reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACEOE(i)); 4289 reg |= 0x100000; 4290 urtwn_bb_write(sc, R92C_FPGA0_RFIFACEOE(i), reg); 4291 urtwn_ms_delay(sc); 4292 /* Set RF_ENV output high. */ 4293 reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACEOE(i)); 4294 reg |= 0x10; 4295 urtwn_bb_write(sc, R92C_FPGA0_RFIFACEOE(i), reg); 4296 urtwn_ms_delay(sc); 4297 /* Set address and data lengths of RF registers. */ 4298 reg = urtwn_bb_read(sc, R92C_HSSI_PARAM2(i)); 4299 reg &= ~R92C_HSSI_PARAM2_ADDR_LENGTH; 4300 urtwn_bb_write(sc, R92C_HSSI_PARAM2(i), reg); 4301 urtwn_ms_delay(sc); 4302 reg = urtwn_bb_read(sc, R92C_HSSI_PARAM2(i)); 4303 reg &= ~R92C_HSSI_PARAM2_DATA_LENGTH; 4304 urtwn_bb_write(sc, R92C_HSSI_PARAM2(i), reg); 4305 urtwn_ms_delay(sc); 4306 4307 /* Write RF initialization values for this chain. */ 4308 for (j = 0; j < prog[i].count; j++) { 4309 if (prog[i].regs[j] >= 0xf9 && 4310 prog[i].regs[j] <= 0xfe) { 4311 /* 4312 * These are fake RF registers offsets that 4313 * indicate a delay is required. 4314 */ 4315 usb_pause_mtx(&sc->sc_mtx, hz / 20); /* 50ms */ 4316 continue; 4317 } 4318 urtwn_rf_write(sc, i, prog[i].regs[j], 4319 prog[i].vals[j]); 4320 urtwn_ms_delay(sc); 4321 } 4322 4323 /* Restore RF_ENV control type. */ 4324 reg = urtwn_bb_read(sc, R92C_FPGA0_RFIFACESW(idx)); 4325 reg &= ~(0x10 << off) | (type << off); 4326 urtwn_bb_write(sc, R92C_FPGA0_RFIFACESW(idx), reg); 4327 4328 /* Cache RF register CHNLBW. */ 4329 sc->rf_chnlbw[i] = urtwn_rf_read(sc, i, R92C_RF_CHNLBW); 4330 } 4331 4332 if ((sc->chip & (URTWN_CHIP_UMC_A_CUT | URTWN_CHIP_92C)) == 4333 URTWN_CHIP_UMC_A_CUT) { 4334 urtwn_rf_write(sc, 0, R92C_RF_RX_G1, 0x30255); 4335 urtwn_rf_write(sc, 0, R92C_RF_RX_G2, 0x50a00); 4336 } 4337 } 4338 4339 static void 4340 urtwn_cam_init(struct urtwn_softc *sc) 4341 { 4342 /* Invalidate all CAM entries. */ 4343 urtwn_write_4(sc, R92C_CAMCMD, 4344 R92C_CAMCMD_POLLING | R92C_CAMCMD_CLR); 4345 } 4346 4347 static int 4348 urtwn_cam_write(struct urtwn_softc *sc, uint32_t addr, uint32_t data) 4349 { 4350 usb_error_t error; 4351 4352 error = urtwn_write_4(sc, R92C_CAMWRITE, data); 4353 if (error != USB_ERR_NORMAL_COMPLETION) 4354 return (EIO); 4355 error = urtwn_write_4(sc, R92C_CAMCMD, 4356 R92C_CAMCMD_POLLING | R92C_CAMCMD_WRITE | 4357 SM(R92C_CAMCMD_ADDR, addr)); 4358 if (error != USB_ERR_NORMAL_COMPLETION) 4359 return (EIO); 4360 4361 return (0); 4362 } 4363 4364 static void 4365 urtwn_pa_bias_init(struct urtwn_softc *sc) 4366 { 4367 uint8_t reg; 4368 int i; 4369 4370 for (i = 0; i < sc->nrxchains; i++) { 4371 if (sc->pa_setting & (1 << i)) 4372 continue; 4373 urtwn_rf_write(sc, i, R92C_RF_IPA, 0x0f406); 4374 urtwn_rf_write(sc, i, R92C_RF_IPA, 0x4f406); 4375 urtwn_rf_write(sc, i, R92C_RF_IPA, 0x8f406); 4376 urtwn_rf_write(sc, i, R92C_RF_IPA, 0xcf406); 4377 } 4378 if (!(sc->pa_setting & 0x10)) { 4379 reg = urtwn_read_1(sc, 0x16); 4380 reg = (reg & ~0xf0) | 0x90; 4381 urtwn_write_1(sc, 0x16, reg); 4382 } 4383 } 4384 4385 static void 4386 urtwn_rxfilter_init(struct urtwn_softc *sc) 4387 { 4388 struct ieee80211com *ic = &sc->sc_ic; 4389 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 4390 uint32_t rcr; 4391 uint16_t filter; 4392 4393 URTWN_ASSERT_LOCKED(sc); 4394 4395 /* Setup multicast filter. */ 4396 urtwn_set_multi(sc); 4397 4398 /* Filter for management frames. */ 4399 filter = 0x7f3f; 4400 switch (vap->iv_opmode) { 4401 case IEEE80211_M_STA: 4402 filter &= ~( 4403 R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_ASSOC_REQ) | 4404 R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_REASSOC_REQ) | 4405 R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_PROBE_REQ)); 4406 break; 4407 case IEEE80211_M_HOSTAP: 4408 filter &= ~( 4409 R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_ASSOC_RESP) | 4410 R92C_RXFLTMAP_SUBTYPE(IEEE80211_FC0_SUBTYPE_REASSOC_RESP)); 4411 break; 4412 case IEEE80211_M_MONITOR: 4413 case IEEE80211_M_IBSS: 4414 break; 4415 default: 4416 device_printf(sc->sc_dev, "%s: undefined opmode %d\n", 4417 __func__, vap->iv_opmode); 4418 break; 4419 } 4420 urtwn_write_2(sc, R92C_RXFLTMAP0, filter); 4421 4422 /* Reject all control frames. */ 4423 urtwn_write_2(sc, R92C_RXFLTMAP1, 0x0000); 4424 4425 /* Reject all data frames. */ 4426 urtwn_write_2(sc, R92C_RXFLTMAP2, 0x0000); 4427 4428 rcr = R92C_RCR_AM | R92C_RCR_AB | R92C_RCR_APM | 4429 R92C_RCR_HTC_LOC_CTRL | R92C_RCR_APP_PHYSTS | 4430 R92C_RCR_APP_ICV | R92C_RCR_APP_MIC; 4431 4432 if (vap->iv_opmode == IEEE80211_M_MONITOR) { 4433 /* Accept all frames. */ 4434 rcr |= R92C_RCR_ACF | R92C_RCR_ADF | R92C_RCR_AMF | 4435 R92C_RCR_AAP; 4436 } 4437 4438 /* Set Rx filter. */ 4439 urtwn_write_4(sc, R92C_RCR, rcr); 4440 4441 if (ic->ic_promisc != 0) { 4442 /* Update Rx filter. */ 4443 urtwn_set_promisc(sc); 4444 } 4445 } 4446 4447 static void 4448 urtwn_edca_init(struct urtwn_softc *sc) 4449 { 4450 urtwn_write_2(sc, R92C_SPEC_SIFS, 0x100a); 4451 urtwn_write_2(sc, R92C_MAC_SPEC_SIFS, 0x100a); 4452 urtwn_write_2(sc, R92C_SIFS_CCK, 0x100a); 4453 urtwn_write_2(sc, R92C_SIFS_OFDM, 0x100a); 4454 urtwn_write_4(sc, R92C_EDCA_BE_PARAM, 0x005ea42b); 4455 urtwn_write_4(sc, R92C_EDCA_BK_PARAM, 0x0000a44f); 4456 urtwn_write_4(sc, R92C_EDCA_VI_PARAM, 0x005ea324); 4457 urtwn_write_4(sc, R92C_EDCA_VO_PARAM, 0x002fa226); 4458 } 4459 4460 static void 4461 urtwn_write_txpower(struct urtwn_softc *sc, int chain, 4462 uint16_t power[URTWN_RIDX_COUNT]) 4463 { 4464 uint32_t reg; 4465 4466 /* Write per-CCK rate Tx power. */ 4467 if (chain == 0) { 4468 reg = urtwn_bb_read(sc, R92C_TXAGC_A_CCK1_MCS32); 4469 reg = RW(reg, R92C_TXAGC_A_CCK1, power[0]); 4470 urtwn_bb_write(sc, R92C_TXAGC_A_CCK1_MCS32, reg); 4471 reg = urtwn_bb_read(sc, R92C_TXAGC_B_CCK11_A_CCK2_11); 4472 reg = RW(reg, R92C_TXAGC_A_CCK2, power[1]); 4473 reg = RW(reg, R92C_TXAGC_A_CCK55, power[2]); 4474 reg = RW(reg, R92C_TXAGC_A_CCK11, power[3]); 4475 urtwn_bb_write(sc, R92C_TXAGC_B_CCK11_A_CCK2_11, reg); 4476 } else { 4477 reg = urtwn_bb_read(sc, R92C_TXAGC_B_CCK1_55_MCS32); 4478 reg = RW(reg, R92C_TXAGC_B_CCK1, power[0]); 4479 reg = RW(reg, R92C_TXAGC_B_CCK2, power[1]); 4480 reg = RW(reg, R92C_TXAGC_B_CCK55, power[2]); 4481 urtwn_bb_write(sc, R92C_TXAGC_B_CCK1_55_MCS32, reg); 4482 reg = urtwn_bb_read(sc, R92C_TXAGC_B_CCK11_A_CCK2_11); 4483 reg = RW(reg, R92C_TXAGC_B_CCK11, power[3]); 4484 urtwn_bb_write(sc, R92C_TXAGC_B_CCK11_A_CCK2_11, reg); 4485 } 4486 /* Write per-OFDM rate Tx power. */ 4487 urtwn_bb_write(sc, R92C_TXAGC_RATE18_06(chain), 4488 SM(R92C_TXAGC_RATE06, power[ 4]) | 4489 SM(R92C_TXAGC_RATE09, power[ 5]) | 4490 SM(R92C_TXAGC_RATE12, power[ 6]) | 4491 SM(R92C_TXAGC_RATE18, power[ 7])); 4492 urtwn_bb_write(sc, R92C_TXAGC_RATE54_24(chain), 4493 SM(R92C_TXAGC_RATE24, power[ 8]) | 4494 SM(R92C_TXAGC_RATE36, power[ 9]) | 4495 SM(R92C_TXAGC_RATE48, power[10]) | 4496 SM(R92C_TXAGC_RATE54, power[11])); 4497 /* Write per-MCS Tx power. */ 4498 urtwn_bb_write(sc, R92C_TXAGC_MCS03_MCS00(chain), 4499 SM(R92C_TXAGC_MCS00, power[12]) | 4500 SM(R92C_TXAGC_MCS01, power[13]) | 4501 SM(R92C_TXAGC_MCS02, power[14]) | 4502 SM(R92C_TXAGC_MCS03, power[15])); 4503 urtwn_bb_write(sc, R92C_TXAGC_MCS07_MCS04(chain), 4504 SM(R92C_TXAGC_MCS04, power[16]) | 4505 SM(R92C_TXAGC_MCS05, power[17]) | 4506 SM(R92C_TXAGC_MCS06, power[18]) | 4507 SM(R92C_TXAGC_MCS07, power[19])); 4508 urtwn_bb_write(sc, R92C_TXAGC_MCS11_MCS08(chain), 4509 SM(R92C_TXAGC_MCS08, power[20]) | 4510 SM(R92C_TXAGC_MCS09, power[21]) | 4511 SM(R92C_TXAGC_MCS10, power[22]) | 4512 SM(R92C_TXAGC_MCS11, power[23])); 4513 urtwn_bb_write(sc, R92C_TXAGC_MCS15_MCS12(chain), 4514 SM(R92C_TXAGC_MCS12, power[24]) | 4515 SM(R92C_TXAGC_MCS13, power[25]) | 4516 SM(R92C_TXAGC_MCS14, power[26]) | 4517 SM(R92C_TXAGC_MCS15, power[27])); 4518 } 4519 4520 static void 4521 urtwn_get_txpower(struct urtwn_softc *sc, int chain, 4522 struct ieee80211_channel *c, struct ieee80211_channel *extc, 4523 uint16_t power[URTWN_RIDX_COUNT]) 4524 { 4525 struct ieee80211com *ic = &sc->sc_ic; 4526 struct r92c_rom *rom = &sc->rom.r92c_rom; 4527 uint16_t cckpow, ofdmpow, htpow, diff, max; 4528 const struct urtwn_txpwr *base; 4529 int ridx, chan, group; 4530 4531 /* Determine channel group. */ 4532 chan = ieee80211_chan2ieee(ic, c); /* XXX center freq! */ 4533 if (chan <= 3) 4534 group = 0; 4535 else if (chan <= 9) 4536 group = 1; 4537 else 4538 group = 2; 4539 4540 /* Get original Tx power based on board type and RF chain. */ 4541 if (!(sc->chip & URTWN_CHIP_92C)) { 4542 if (sc->board_type == R92C_BOARD_TYPE_HIGHPA) 4543 base = &rtl8188ru_txagc[chain]; 4544 else 4545 base = &rtl8192cu_txagc[chain]; 4546 } else 4547 base = &rtl8192cu_txagc[chain]; 4548 4549 memset(power, 0, URTWN_RIDX_COUNT * sizeof(power[0])); 4550 if (sc->regulatory == 0) { 4551 for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++) 4552 power[ridx] = base->pwr[0][ridx]; 4553 } 4554 for (ridx = URTWN_RIDX_OFDM6; ridx < URTWN_RIDX_COUNT; ridx++) { 4555 if (sc->regulatory == 3) { 4556 power[ridx] = base->pwr[0][ridx]; 4557 /* Apply vendor limits. */ 4558 if (extc != NULL) 4559 max = rom->ht40_max_pwr[group]; 4560 else 4561 max = rom->ht20_max_pwr[group]; 4562 max = (max >> (chain * 4)) & 0xf; 4563 if (power[ridx] > max) 4564 power[ridx] = max; 4565 } else if (sc->regulatory == 1) { 4566 if (extc == NULL) 4567 power[ridx] = base->pwr[group][ridx]; 4568 } else if (sc->regulatory != 2) 4569 power[ridx] = base->pwr[0][ridx]; 4570 } 4571 4572 /* Compute per-CCK rate Tx power. */ 4573 cckpow = rom->cck_tx_pwr[chain][group]; 4574 for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++) { 4575 power[ridx] += cckpow; 4576 if (power[ridx] > R92C_MAX_TX_PWR) 4577 power[ridx] = R92C_MAX_TX_PWR; 4578 } 4579 4580 htpow = rom->ht40_1s_tx_pwr[chain][group]; 4581 if (sc->ntxchains > 1) { 4582 /* Apply reduction for 2 spatial streams. */ 4583 diff = rom->ht40_2s_tx_pwr_diff[group]; 4584 diff = (diff >> (chain * 4)) & 0xf; 4585 htpow = (htpow > diff) ? htpow - diff : 0; 4586 } 4587 4588 /* Compute per-OFDM rate Tx power. */ 4589 diff = rom->ofdm_tx_pwr_diff[group]; 4590 diff = (diff >> (chain * 4)) & 0xf; 4591 ofdmpow = htpow + diff; /* HT->OFDM correction. */ 4592 for (ridx = URTWN_RIDX_OFDM6; ridx <= URTWN_RIDX_OFDM54; ridx++) { 4593 power[ridx] += ofdmpow; 4594 if (power[ridx] > R92C_MAX_TX_PWR) 4595 power[ridx] = R92C_MAX_TX_PWR; 4596 } 4597 4598 /* Compute per-MCS Tx power. */ 4599 if (extc == NULL) { 4600 diff = rom->ht20_tx_pwr_diff[group]; 4601 diff = (diff >> (chain * 4)) & 0xf; 4602 htpow += diff; /* HT40->HT20 correction. */ 4603 } 4604 for (ridx = 12; ridx <= 27; ridx++) { 4605 power[ridx] += htpow; 4606 if (power[ridx] > R92C_MAX_TX_PWR) 4607 power[ridx] = R92C_MAX_TX_PWR; 4608 } 4609 #ifdef USB_DEBUG 4610 if (sc->sc_debug & URTWN_DEBUG_TXPWR) { 4611 /* Dump per-rate Tx power values. */ 4612 kprintf("Tx power for chain %d:\n", chain); 4613 for (ridx = URTWN_RIDX_CCK1; ridx < URTWN_RIDX_COUNT; ridx++) 4614 kprintf("Rate %d = %u\n", ridx, power[ridx]); 4615 } 4616 #endif 4617 } 4618 4619 static void 4620 urtwn_r88e_get_txpower(struct urtwn_softc *sc, int chain, 4621 struct ieee80211_channel *c, struct ieee80211_channel *extc, 4622 uint16_t power[URTWN_RIDX_COUNT]) 4623 { 4624 struct ieee80211com *ic = &sc->sc_ic; 4625 struct r88e_rom *rom = &sc->rom.r88e_rom; 4626 uint16_t cckpow, ofdmpow, bw20pow, htpow; 4627 const struct urtwn_r88e_txpwr *base; 4628 int ridx, chan, group; 4629 4630 /* Determine channel group. */ 4631 chan = ieee80211_chan2ieee(ic, c); /* XXX center freq! */ 4632 if (chan <= 2) 4633 group = 0; 4634 else if (chan <= 5) 4635 group = 1; 4636 else if (chan <= 8) 4637 group = 2; 4638 else if (chan <= 11) 4639 group = 3; 4640 else if (chan <= 13) 4641 group = 4; 4642 else 4643 group = 5; 4644 4645 /* Get original Tx power based on board type and RF chain. */ 4646 base = &rtl8188eu_txagc[chain]; 4647 4648 memset(power, 0, URTWN_RIDX_COUNT * sizeof(power[0])); 4649 if (sc->regulatory == 0) { 4650 for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++) 4651 power[ridx] = base->pwr[0][ridx]; 4652 } 4653 for (ridx = URTWN_RIDX_OFDM6; ridx < URTWN_RIDX_COUNT; ridx++) { 4654 if (sc->regulatory == 3) 4655 power[ridx] = base->pwr[0][ridx]; 4656 else if (sc->regulatory == 1) { 4657 if (extc == NULL) 4658 power[ridx] = base->pwr[group][ridx]; 4659 } else if (sc->regulatory != 2) 4660 power[ridx] = base->pwr[0][ridx]; 4661 } 4662 4663 /* Compute per-CCK rate Tx power. */ 4664 cckpow = rom->cck_tx_pwr[group]; 4665 for (ridx = URTWN_RIDX_CCK1; ridx <= URTWN_RIDX_CCK11; ridx++) { 4666 power[ridx] += cckpow; 4667 if (power[ridx] > R92C_MAX_TX_PWR) 4668 power[ridx] = R92C_MAX_TX_PWR; 4669 } 4670 4671 htpow = rom->ht40_tx_pwr[group]; 4672 4673 /* Compute per-OFDM rate Tx power. */ 4674 ofdmpow = htpow + sc->ofdm_tx_pwr_diff; 4675 for (ridx = URTWN_RIDX_OFDM6; ridx <= URTWN_RIDX_OFDM54; ridx++) { 4676 power[ridx] += ofdmpow; 4677 if (power[ridx] > R92C_MAX_TX_PWR) 4678 power[ridx] = R92C_MAX_TX_PWR; 4679 } 4680 4681 bw20pow = htpow + sc->bw20_tx_pwr_diff; 4682 for (ridx = 12; ridx <= 27; ridx++) { 4683 power[ridx] += bw20pow; 4684 if (power[ridx] > R92C_MAX_TX_PWR) 4685 power[ridx] = R92C_MAX_TX_PWR; 4686 } 4687 } 4688 4689 static void 4690 urtwn_set_txpower(struct urtwn_softc *sc, struct ieee80211_channel *c, 4691 struct ieee80211_channel *extc) 4692 { 4693 uint16_t power[URTWN_RIDX_COUNT]; 4694 int i; 4695 4696 for (i = 0; i < sc->ntxchains; i++) { 4697 /* Compute per-rate Tx power values. */ 4698 if (sc->chip & URTWN_CHIP_88E) 4699 urtwn_r88e_get_txpower(sc, i, c, extc, power); 4700 else 4701 urtwn_get_txpower(sc, i, c, extc, power); 4702 /* Write per-rate Tx power values to hardware. */ 4703 urtwn_write_txpower(sc, i, power); 4704 } 4705 } 4706 4707 static void 4708 urtwn_set_rx_bssid_all(struct urtwn_softc *sc, int enable) 4709 { 4710 uint32_t reg; 4711 4712 reg = urtwn_read_4(sc, R92C_RCR); 4713 if (enable) 4714 reg &= ~R92C_RCR_CBSSID_BCN; 4715 else 4716 reg |= R92C_RCR_CBSSID_BCN; 4717 urtwn_write_4(sc, R92C_RCR, reg); 4718 } 4719 4720 static void 4721 urtwn_set_gain(struct urtwn_softc *sc, uint8_t gain) 4722 { 4723 uint32_t reg; 4724 4725 reg = urtwn_bb_read(sc, R92C_OFDM0_AGCCORE1(0)); 4726 reg = RW(reg, R92C_OFDM0_AGCCORE1_GAIN, gain); 4727 urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(0), reg); 4728 4729 if (!(sc->chip & URTWN_CHIP_88E)) { 4730 reg = urtwn_bb_read(sc, R92C_OFDM0_AGCCORE1(1)); 4731 reg = RW(reg, R92C_OFDM0_AGCCORE1_GAIN, gain); 4732 urtwn_bb_write(sc, R92C_OFDM0_AGCCORE1(1), reg); 4733 } 4734 } 4735 4736 static void 4737 urtwn_scan_start(struct ieee80211com *ic) 4738 { 4739 struct urtwn_softc *sc = ic->ic_softc; 4740 4741 URTWN_LOCK(sc); 4742 /* Receive beacons / probe responses from any BSSID. */ 4743 if (ic->ic_opmode != IEEE80211_M_IBSS) 4744 urtwn_set_rx_bssid_all(sc, 1); 4745 4746 /* Set gain for scanning. */ 4747 urtwn_set_gain(sc, 0x20); 4748 URTWN_UNLOCK(sc); 4749 } 4750 4751 static void 4752 urtwn_scan_end(struct ieee80211com *ic) 4753 { 4754 struct urtwn_softc *sc = ic->ic_softc; 4755 4756 URTWN_LOCK(sc); 4757 /* Restore limitations. */ 4758 if (ic->ic_promisc == 0 && ic->ic_opmode != IEEE80211_M_IBSS) 4759 urtwn_set_rx_bssid_all(sc, 0); 4760 4761 /* Set gain under link. */ 4762 urtwn_set_gain(sc, 0x32); 4763 URTWN_UNLOCK(sc); 4764 } 4765 4766 static void 4767 urtwn_set_channel(struct ieee80211com *ic) 4768 { 4769 struct urtwn_softc *sc = ic->ic_softc; 4770 struct ieee80211_channel *c = ic->ic_curchan; 4771 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 4772 4773 URTWN_LOCK(sc); 4774 if (vap->iv_state == IEEE80211_S_SCAN) { 4775 /* Make link LED blink during scan. */ 4776 urtwn_set_led(sc, URTWN_LED_LINK, !sc->ledlink); 4777 } 4778 urtwn_set_chan(sc, c, NULL); 4779 sc->sc_rxtap.wr_chan_freq = htole16(c->ic_freq); 4780 sc->sc_rxtap.wr_chan_flags = htole16(c->ic_flags); 4781 sc->sc_txtap.wt_chan_freq = htole16(c->ic_freq); 4782 sc->sc_txtap.wt_chan_flags = htole16(c->ic_flags); 4783 URTWN_UNLOCK(sc); 4784 } 4785 4786 static int 4787 urtwn_wme_update(struct ieee80211com *ic) 4788 { 4789 const struct wmeParams *wmep = 4790 ic->ic_wme.wme_chanParams.cap_wmeParams; 4791 struct urtwn_softc *sc = ic->ic_softc; 4792 uint8_t aifs, acm, slottime; 4793 int ac; 4794 4795 acm = 0; 4796 slottime = IEEE80211_GET_SLOTTIME(ic); 4797 4798 URTWN_LOCK(sc); 4799 for (ac = WME_AC_BE; ac < WME_NUM_AC; ac++) { 4800 /* AIFS[AC] = AIFSN[AC] * aSlotTime + aSIFSTime. */ 4801 aifs = wmep[ac].wmep_aifsn * slottime + IEEE80211_DUR_SIFS; 4802 urtwn_write_4(sc, wme2queue[ac].reg, 4803 SM(R92C_EDCA_PARAM_TXOP, wmep[ac].wmep_txopLimit) | 4804 SM(R92C_EDCA_PARAM_ECWMIN, wmep[ac].wmep_logcwmin) | 4805 SM(R92C_EDCA_PARAM_ECWMAX, wmep[ac].wmep_logcwmax) | 4806 SM(R92C_EDCA_PARAM_AIFS, aifs)); 4807 if (ac != WME_AC_BE) 4808 acm |= wmep[ac].wmep_acm << ac; 4809 } 4810 4811 if (acm != 0) 4812 acm |= R92C_ACMHWCTRL_EN; 4813 urtwn_write_1(sc, R92C_ACMHWCTRL, 4814 (urtwn_read_1(sc, R92C_ACMHWCTRL) & ~R92C_ACMHWCTRL_ACM_MASK) | 4815 acm); 4816 4817 URTWN_UNLOCK(sc); 4818 4819 return 0; 4820 } 4821 4822 static void 4823 urtwn_update_slot(struct ieee80211com *ic) 4824 { 4825 urtwn_cmd_sleepable(ic->ic_softc, NULL, 0, urtwn_update_slot_cb); 4826 } 4827 4828 static void 4829 urtwn_update_slot_cb(struct urtwn_softc *sc, union sec_param *data) 4830 { 4831 struct ieee80211com *ic = &sc->sc_ic; 4832 uint8_t slottime; 4833 4834 slottime = IEEE80211_GET_SLOTTIME(ic); 4835 4836 URTWN_DPRINTF(sc, URTWN_DEBUG_ANY, "%s: setting slot time to %uus\n", 4837 __func__, slottime); 4838 4839 urtwn_write_1(sc, R92C_SLOT, slottime); 4840 urtwn_update_aifs(sc, slottime); 4841 } 4842 4843 static void 4844 urtwn_update_aifs(struct urtwn_softc *sc, uint8_t slottime) 4845 { 4846 const struct wmeParams *wmep = 4847 sc->sc_ic.ic_wme.wme_chanParams.cap_wmeParams; 4848 uint8_t aifs, ac; 4849 4850 for (ac = WME_AC_BE; ac < WME_NUM_AC; ac++) { 4851 /* AIFS[AC] = AIFSN[AC] * aSlotTime + aSIFSTime. */ 4852 aifs = wmep[ac].wmep_aifsn * slottime + IEEE80211_DUR_SIFS; 4853 urtwn_write_1(sc, wme2queue[ac].reg, aifs); 4854 } 4855 } 4856 4857 static uint8_t 4858 urtwn_get_multi_pos(const uint8_t maddr[]) 4859 { 4860 uint64_t mask = 0x00004d101df481b4; 4861 uint8_t pos = 0x27; /* initial value */ 4862 int i, j; 4863 4864 for (i = 0; i < IEEE80211_ADDR_LEN; i++) 4865 for (j = (i == 0) ? 1 : 0; j < 8; j++) 4866 if ((maddr[i] >> j) & 1) 4867 pos ^= (mask >> (i * 8 + j - 1)); 4868 4869 pos &= 0x3f; 4870 4871 return (pos); 4872 } 4873 4874 static void 4875 urtwn_set_multi(struct urtwn_softc *sc) 4876 { 4877 struct ieee80211com *ic = &sc->sc_ic; 4878 uint32_t mfilt[2]; 4879 4880 URTWN_ASSERT_LOCKED(sc); 4881 4882 /* general structure was copied from ath(4). */ 4883 if (ic->ic_allmulti == 0) { 4884 struct ieee80211vap *vap; 4885 struct ifnet *ifp; 4886 struct ifmultiaddr *ifma; 4887 4888 /* 4889 * Merge multicast addresses to form the hardware filter. 4890 */ 4891 mfilt[0] = mfilt[1] = 0; 4892 TAILQ_FOREACH(vap, &ic->ic_vaps, iv_next) { 4893 ifp = vap->iv_ifp; 4894 #if defined(__DragonFly__) 4895 /* XXX not implemented */ 4896 #else 4897 if_maddr_rlock(ifp); 4898 #endif 4899 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 4900 caddr_t dl; 4901 uint8_t pos; 4902 4903 dl = LLADDR((struct sockaddr_dl *) 4904 ifma->ifma_addr); 4905 pos = urtwn_get_multi_pos(dl); 4906 4907 mfilt[pos / 32] |= (1 << (pos % 32)); 4908 } 4909 #if defined(__DragonFly__) 4910 /* XXX not implemented */ 4911 #else 4912 if_maddr_runlock(ifp); 4913 #endif 4914 } 4915 } else 4916 mfilt[0] = mfilt[1] = ~0; 4917 4918 4919 urtwn_write_4(sc, R92C_MAR + 0, mfilt[0]); 4920 urtwn_write_4(sc, R92C_MAR + 4, mfilt[1]); 4921 4922 URTWN_DPRINTF(sc, URTWN_DEBUG_STATE, "%s: MC filter %08x:%08x\n", 4923 __func__, mfilt[0], mfilt[1]); 4924 } 4925 4926 static void 4927 urtwn_set_promisc(struct urtwn_softc *sc) 4928 { 4929 struct ieee80211com *ic = &sc->sc_ic; 4930 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 4931 uint32_t rcr, mask1, mask2; 4932 4933 URTWN_ASSERT_LOCKED(sc); 4934 4935 if (vap->iv_opmode == IEEE80211_M_MONITOR) 4936 return; 4937 4938 mask1 = R92C_RCR_ACF | R92C_RCR_ADF | R92C_RCR_AMF | R92C_RCR_AAP; 4939 mask2 = R92C_RCR_APM; 4940 4941 if (vap->iv_state == IEEE80211_S_RUN) { 4942 switch (vap->iv_opmode) { 4943 case IEEE80211_M_STA: 4944 mask2 |= R92C_RCR_CBSSID_DATA; 4945 /* FALLTHROUGH */ 4946 case IEEE80211_M_HOSTAP: 4947 mask2 |= R92C_RCR_CBSSID_BCN; 4948 break; 4949 case IEEE80211_M_IBSS: 4950 mask2 |= R92C_RCR_CBSSID_DATA; 4951 break; 4952 default: 4953 device_printf(sc->sc_dev, "%s: undefined opmode %d\n", 4954 __func__, vap->iv_opmode); 4955 return; 4956 } 4957 } 4958 4959 rcr = urtwn_read_4(sc, R92C_RCR); 4960 if (ic->ic_promisc == 0) 4961 rcr = (rcr & ~mask1) | mask2; 4962 else 4963 rcr = (rcr & ~mask2) | mask1; 4964 urtwn_write_4(sc, R92C_RCR, rcr); 4965 } 4966 4967 static void 4968 urtwn_update_promisc(struct ieee80211com *ic) 4969 { 4970 struct urtwn_softc *sc = ic->ic_softc; 4971 4972 URTWN_LOCK(sc); 4973 if (sc->sc_flags & URTWN_RUNNING) 4974 urtwn_set_promisc(sc); 4975 URTWN_UNLOCK(sc); 4976 } 4977 4978 static void 4979 urtwn_update_mcast(struct ieee80211com *ic) 4980 { 4981 struct urtwn_softc *sc = ic->ic_softc; 4982 4983 URTWN_LOCK(sc); 4984 if (sc->sc_flags & URTWN_RUNNING) 4985 urtwn_set_multi(sc); 4986 URTWN_UNLOCK(sc); 4987 } 4988 4989 static struct ieee80211_node * 4990 urtwn_node_alloc(struct ieee80211vap *vap, 4991 const uint8_t mac[IEEE80211_ADDR_LEN]) 4992 { 4993 struct urtwn_node *un; 4994 4995 un = kmalloc(sizeof (struct urtwn_node), M_80211_NODE, 4996 M_INTWAIT | M_ZERO); 4997 4998 if (un == NULL) 4999 return NULL; 5000 5001 un->id = URTWN_MACID_UNDEFINED; 5002 5003 return &un->ni; 5004 } 5005 5006 static void 5007 urtwn_newassoc(struct ieee80211_node *ni, int isnew) 5008 { 5009 struct urtwn_softc *sc = ni->ni_ic->ic_softc; 5010 struct urtwn_node *un = URTWN_NODE(ni); 5011 uint8_t id; 5012 5013 /* Only do this bit for R88E chips */ 5014 if (! (sc->chip & URTWN_CHIP_88E)) 5015 return; 5016 5017 if (!isnew) 5018 return; 5019 5020 URTWN_NT_LOCK(sc); 5021 for (id = 0; id <= URTWN_MACID_MAX(sc); id++) { 5022 if (id != URTWN_MACID_BC && sc->node_list[id] == NULL) { 5023 un->id = id; 5024 sc->node_list[id] = ni; 5025 break; 5026 } 5027 } 5028 URTWN_NT_UNLOCK(sc); 5029 5030 if (id > URTWN_MACID_MAX(sc)) { 5031 device_printf(sc->sc_dev, "%s: node table is full\n", 5032 __func__); 5033 } 5034 } 5035 5036 static void 5037 urtwn_node_free(struct ieee80211_node *ni) 5038 { 5039 struct urtwn_softc *sc = ni->ni_ic->ic_softc; 5040 struct urtwn_node *un = URTWN_NODE(ni); 5041 5042 URTWN_NT_LOCK(sc); 5043 if (un->id != URTWN_MACID_UNDEFINED) 5044 sc->node_list[un->id] = NULL; 5045 URTWN_NT_UNLOCK(sc); 5046 5047 sc->sc_node_free(ni); 5048 } 5049 5050 static void 5051 urtwn_set_chan(struct urtwn_softc *sc, struct ieee80211_channel *c, 5052 struct ieee80211_channel *extc) 5053 { 5054 struct ieee80211com *ic = &sc->sc_ic; 5055 uint32_t reg; 5056 u_int chan; 5057 int i; 5058 5059 chan = ieee80211_chan2ieee(ic, c); /* XXX center freq! */ 5060 if (chan == 0 || chan == IEEE80211_CHAN_ANY) { 5061 device_printf(sc->sc_dev, 5062 "%s: invalid channel %x\n", __func__, chan); 5063 return; 5064 } 5065 5066 /* Set Tx power for this new channel. */ 5067 urtwn_set_txpower(sc, c, extc); 5068 5069 for (i = 0; i < sc->nrxchains; i++) { 5070 urtwn_rf_write(sc, i, R92C_RF_CHNLBW, 5071 RW(sc->rf_chnlbw[i], R92C_RF_CHNLBW_CHNL, chan)); 5072 } 5073 #ifndef IEEE80211_NO_HT 5074 if (extc != NULL) { 5075 /* Is secondary channel below or above primary? */ 5076 int prichlo = c->ic_freq < extc->ic_freq; 5077 5078 urtwn_write_1(sc, R92C_BWOPMODE, 5079 urtwn_read_1(sc, R92C_BWOPMODE) & ~R92C_BWOPMODE_20MHZ); 5080 5081 reg = urtwn_read_1(sc, R92C_RRSR + 2); 5082 reg = (reg & ~0x6f) | (prichlo ? 1 : 2) << 5; 5083 urtwn_write_1(sc, R92C_RRSR + 2, reg); 5084 5085 urtwn_bb_write(sc, R92C_FPGA0_RFMOD, 5086 urtwn_bb_read(sc, R92C_FPGA0_RFMOD) | R92C_RFMOD_40MHZ); 5087 urtwn_bb_write(sc, R92C_FPGA1_RFMOD, 5088 urtwn_bb_read(sc, R92C_FPGA1_RFMOD) | R92C_RFMOD_40MHZ); 5089 5090 /* Set CCK side band. */ 5091 reg = urtwn_bb_read(sc, R92C_CCK0_SYSTEM); 5092 reg = (reg & ~0x00000010) | (prichlo ? 0 : 1) << 4; 5093 urtwn_bb_write(sc, R92C_CCK0_SYSTEM, reg); 5094 5095 reg = urtwn_bb_read(sc, R92C_OFDM1_LSTF); 5096 reg = (reg & ~0x00000c00) | (prichlo ? 1 : 2) << 10; 5097 urtwn_bb_write(sc, R92C_OFDM1_LSTF, reg); 5098 5099 urtwn_bb_write(sc, R92C_FPGA0_ANAPARAM2, 5100 urtwn_bb_read(sc, R92C_FPGA0_ANAPARAM2) & 5101 ~R92C_FPGA0_ANAPARAM2_CBW20); 5102 5103 reg = urtwn_bb_read(sc, 0x818); 5104 reg = (reg & ~0x0c000000) | (prichlo ? 2 : 1) << 26; 5105 urtwn_bb_write(sc, 0x818, reg); 5106 5107 /* Select 40MHz bandwidth. */ 5108 urtwn_rf_write(sc, 0, R92C_RF_CHNLBW, 5109 (sc->rf_chnlbw[0] & ~0xfff) | chan); 5110 } else 5111 #endif 5112 { 5113 urtwn_write_1(sc, R92C_BWOPMODE, 5114 urtwn_read_1(sc, R92C_BWOPMODE) | R92C_BWOPMODE_20MHZ); 5115 5116 urtwn_bb_write(sc, R92C_FPGA0_RFMOD, 5117 urtwn_bb_read(sc, R92C_FPGA0_RFMOD) & ~R92C_RFMOD_40MHZ); 5118 urtwn_bb_write(sc, R92C_FPGA1_RFMOD, 5119 urtwn_bb_read(sc, R92C_FPGA1_RFMOD) & ~R92C_RFMOD_40MHZ); 5120 5121 if (!(sc->chip & URTWN_CHIP_88E)) { 5122 urtwn_bb_write(sc, R92C_FPGA0_ANAPARAM2, 5123 urtwn_bb_read(sc, R92C_FPGA0_ANAPARAM2) | 5124 R92C_FPGA0_ANAPARAM2_CBW20); 5125 } 5126 5127 /* Select 20MHz bandwidth. */ 5128 urtwn_rf_write(sc, 0, R92C_RF_CHNLBW, 5129 (sc->rf_chnlbw[0] & ~0xfff) | chan | 5130 ((sc->chip & URTWN_CHIP_88E) ? R88E_RF_CHNLBW_BW20 : 5131 R92C_RF_CHNLBW_BW20)); 5132 } 5133 } 5134 5135 static void 5136 urtwn_iq_calib(struct urtwn_softc *sc) 5137 { 5138 /* TODO */ 5139 } 5140 5141 static void 5142 urtwn_lc_calib(struct urtwn_softc *sc) 5143 { 5144 uint32_t rf_ac[2]; 5145 uint8_t txmode; 5146 int i; 5147 5148 txmode = urtwn_read_1(sc, R92C_OFDM1_LSTF + 3); 5149 if ((txmode & 0x70) != 0) { 5150 /* Disable all continuous Tx. */ 5151 urtwn_write_1(sc, R92C_OFDM1_LSTF + 3, txmode & ~0x70); 5152 5153 /* Set RF mode to standby mode. */ 5154 for (i = 0; i < sc->nrxchains; i++) { 5155 rf_ac[i] = urtwn_rf_read(sc, i, R92C_RF_AC); 5156 urtwn_rf_write(sc, i, R92C_RF_AC, 5157 RW(rf_ac[i], R92C_RF_AC_MODE, 5158 R92C_RF_AC_MODE_STANDBY)); 5159 } 5160 } else { 5161 /* Block all Tx queues. */ 5162 urtwn_write_1(sc, R92C_TXPAUSE, R92C_TX_QUEUE_ALL); 5163 } 5164 /* Start calibration. */ 5165 urtwn_rf_write(sc, 0, R92C_RF_CHNLBW, 5166 urtwn_rf_read(sc, 0, R92C_RF_CHNLBW) | R92C_RF_CHNLBW_LCSTART); 5167 5168 /* Give calibration the time to complete. */ 5169 usb_pause_mtx(&sc->sc_mtx, hz / 10); /* 100ms */ 5170 5171 /* Restore configuration. */ 5172 if ((txmode & 0x70) != 0) { 5173 /* Restore Tx mode. */ 5174 urtwn_write_1(sc, R92C_OFDM1_LSTF + 3, txmode); 5175 /* Restore RF mode. */ 5176 for (i = 0; i < sc->nrxchains; i++) 5177 urtwn_rf_write(sc, i, R92C_RF_AC, rf_ac[i]); 5178 } else { 5179 /* Unblock all Tx queues. */ 5180 urtwn_write_1(sc, R92C_TXPAUSE, 0x00); 5181 } 5182 } 5183 5184 static void 5185 urtwn_temp_calib(struct urtwn_softc *sc) 5186 { 5187 uint8_t temp; 5188 5189 URTWN_ASSERT_LOCKED(sc); 5190 5191 if (!(sc->sc_flags & URTWN_TEMP_MEASURED)) { 5192 /* Start measuring temperature. */ 5193 URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP, 5194 "%s: start measuring temperature\n", __func__); 5195 if (sc->chip & URTWN_CHIP_88E) { 5196 urtwn_rf_write(sc, 0, R88E_RF_T_METER, 5197 R88E_RF_T_METER_START); 5198 } else { 5199 urtwn_rf_write(sc, 0, R92C_RF_T_METER, 5200 R92C_RF_T_METER_START); 5201 } 5202 sc->sc_flags |= URTWN_TEMP_MEASURED; 5203 return; 5204 } 5205 sc->sc_flags &= ~URTWN_TEMP_MEASURED; 5206 5207 /* Read measured temperature. */ 5208 if (sc->chip & URTWN_CHIP_88E) { 5209 temp = MS(urtwn_rf_read(sc, 0, R88E_RF_T_METER), 5210 R88E_RF_T_METER_VAL); 5211 } else { 5212 temp = MS(urtwn_rf_read(sc, 0, R92C_RF_T_METER), 5213 R92C_RF_T_METER_VAL); 5214 } 5215 if (temp == 0) { /* Read failed, skip. */ 5216 URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP, 5217 "%s: temperature read failed, skipping\n", __func__); 5218 return; 5219 } 5220 5221 URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP, 5222 "%s: temperature: previous %u, current %u\n", 5223 __func__, sc->thcal_lctemp, temp); 5224 5225 /* 5226 * Redo LC calibration if temperature changed significantly since 5227 * last calibration. 5228 */ 5229 if (sc->thcal_lctemp == 0) { 5230 /* First LC calibration is performed in urtwn_init(). */ 5231 sc->thcal_lctemp = temp; 5232 } else if (abs(temp - sc->thcal_lctemp) > 1) { 5233 URTWN_DPRINTF(sc, URTWN_DEBUG_TEMP, 5234 "%s: LC calib triggered by temp: %u -> %u\n", 5235 __func__, sc->thcal_lctemp, temp); 5236 urtwn_lc_calib(sc); 5237 /* Record temperature of last LC calibration. */ 5238 sc->thcal_lctemp = temp; 5239 } 5240 } 5241 5242 static int 5243 urtwn_init(struct urtwn_softc *sc) 5244 { 5245 struct ieee80211com *ic = &sc->sc_ic; 5246 struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps); 5247 uint8_t macaddr[IEEE80211_ADDR_LEN]; 5248 uint32_t reg; 5249 usb_error_t usb_err = USB_ERR_NORMAL_COMPLETION; 5250 int error; 5251 5252 URTWN_LOCK(sc); 5253 if (sc->sc_flags & URTWN_RUNNING) { 5254 URTWN_UNLOCK(sc); 5255 return (0); 5256 } 5257 5258 /* Init firmware commands ring. */ 5259 sc->fwcur = 0; 5260 5261 /* Allocate Tx/Rx buffers. */ 5262 error = urtwn_alloc_rx_list(sc); 5263 if (error != 0) 5264 goto fail; 5265 5266 error = urtwn_alloc_tx_list(sc); 5267 if (error != 0) 5268 goto fail; 5269 5270 /* Power on adapter. */ 5271 error = urtwn_power_on(sc); 5272 if (error != 0) 5273 goto fail; 5274 5275 /* Initialize DMA. */ 5276 error = urtwn_dma_init(sc); 5277 if (error != 0) 5278 goto fail; 5279 5280 /* Set info size in Rx descriptors (in 64-bit words). */ 5281 urtwn_write_1(sc, R92C_RX_DRVINFO_SZ, 4); 5282 5283 /* Init interrupts. */ 5284 if (sc->chip & URTWN_CHIP_88E) { 5285 usb_err = urtwn_write_4(sc, R88E_HISR, 0xffffffff); 5286 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5287 goto fail; 5288 usb_err = urtwn_write_4(sc, R88E_HIMR, R88E_HIMR_CPWM | R88E_HIMR_CPWM2 | 5289 R88E_HIMR_TBDER | R88E_HIMR_PSTIMEOUT); 5290 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5291 goto fail; 5292 usb_err = urtwn_write_4(sc, R88E_HIMRE, R88E_HIMRE_RXFOVW | 5293 R88E_HIMRE_TXFOVW | R88E_HIMRE_RXERR | R88E_HIMRE_TXERR); 5294 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5295 goto fail; 5296 usb_err = urtwn_write_1(sc, R92C_USB_SPECIAL_OPTION, 5297 urtwn_read_1(sc, R92C_USB_SPECIAL_OPTION) | 5298 R92C_USB_SPECIAL_OPTION_INT_BULK_SEL); 5299 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5300 goto fail; 5301 } else { 5302 usb_err = urtwn_write_4(sc, R92C_HISR, 0xffffffff); 5303 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5304 goto fail; 5305 usb_err = urtwn_write_4(sc, R92C_HIMR, 0xffffffff); 5306 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5307 goto fail; 5308 } 5309 5310 /* Set MAC address. */ 5311 IEEE80211_ADDR_COPY(macaddr, vap ? vap->iv_myaddr : ic->ic_macaddr); 5312 usb_err = urtwn_write_region_1(sc, R92C_MACID, macaddr, IEEE80211_ADDR_LEN); 5313 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5314 goto fail; 5315 5316 /* Set initial network type. */ 5317 urtwn_set_mode(sc, R92C_MSR_INFRA); 5318 5319 /* Initialize Rx filter. */ 5320 urtwn_rxfilter_init(sc); 5321 5322 /* Set response rate. */ 5323 reg = urtwn_read_4(sc, R92C_RRSR); 5324 reg = RW(reg, R92C_RRSR_RATE_BITMAP, R92C_RRSR_RATE_CCK_ONLY_1M); 5325 urtwn_write_4(sc, R92C_RRSR, reg); 5326 5327 /* Set short/long retry limits. */ 5328 urtwn_write_2(sc, R92C_RL, 5329 SM(R92C_RL_SRL, 0x30) | SM(R92C_RL_LRL, 0x30)); 5330 5331 /* Initialize EDCA parameters. */ 5332 urtwn_edca_init(sc); 5333 5334 /* Setup rate fallback. */ 5335 if (!(sc->chip & URTWN_CHIP_88E)) { 5336 urtwn_write_4(sc, R92C_DARFRC + 0, 0x00000000); 5337 urtwn_write_4(sc, R92C_DARFRC + 4, 0x10080404); 5338 urtwn_write_4(sc, R92C_RARFRC + 0, 0x04030201); 5339 urtwn_write_4(sc, R92C_RARFRC + 4, 0x08070605); 5340 } 5341 5342 urtwn_write_1(sc, R92C_FWHW_TXQ_CTRL, 5343 urtwn_read_1(sc, R92C_FWHW_TXQ_CTRL) | 5344 R92C_FWHW_TXQ_CTRL_AMPDU_RTY_NEW); 5345 /* Set ACK timeout. */ 5346 urtwn_write_1(sc, R92C_ACKTO, 0x40); 5347 5348 /* Setup USB aggregation. */ 5349 reg = urtwn_read_4(sc, R92C_TDECTRL); 5350 reg = RW(reg, R92C_TDECTRL_BLK_DESC_NUM, 6); 5351 urtwn_write_4(sc, R92C_TDECTRL, reg); 5352 urtwn_write_1(sc, R92C_TRXDMA_CTRL, 5353 urtwn_read_1(sc, R92C_TRXDMA_CTRL) | 5354 R92C_TRXDMA_CTRL_RXDMA_AGG_EN); 5355 urtwn_write_1(sc, R92C_RXDMA_AGG_PG_TH, 48); 5356 if (sc->chip & URTWN_CHIP_88E) 5357 urtwn_write_1(sc, R92C_RXDMA_AGG_PG_TH + 1, 4); 5358 else { 5359 urtwn_write_1(sc, R92C_USB_DMA_AGG_TO, 4); 5360 urtwn_write_1(sc, R92C_USB_SPECIAL_OPTION, 5361 urtwn_read_1(sc, R92C_USB_SPECIAL_OPTION) | 5362 R92C_USB_SPECIAL_OPTION_AGG_EN); 5363 urtwn_write_1(sc, R92C_USB_AGG_TH, 8); 5364 urtwn_write_1(sc, R92C_USB_AGG_TO, 6); 5365 } 5366 5367 /* Initialize beacon parameters. */ 5368 urtwn_write_2(sc, R92C_BCN_CTRL, 0x1010); 5369 urtwn_write_2(sc, R92C_TBTT_PROHIBIT, 0x6404); 5370 urtwn_write_1(sc, R92C_DRVERLYINT, 0x05); 5371 urtwn_write_1(sc, R92C_BCNDMATIM, 0x02); 5372 urtwn_write_2(sc, R92C_BCNTCFG, 0x660f); 5373 5374 if (!(sc->chip & URTWN_CHIP_88E)) { 5375 /* Setup AMPDU aggregation. */ 5376 urtwn_write_4(sc, R92C_AGGLEN_LMT, 0x99997631); /* MCS7~0 */ 5377 urtwn_write_1(sc, R92C_AGGR_BREAK_TIME, 0x16); 5378 urtwn_write_2(sc, R92C_MAX_AGGR_NUM, 0x0708); 5379 5380 urtwn_write_1(sc, R92C_BCN_MAX_ERR, 0xff); 5381 } 5382 5383 #ifndef URTWN_WITHOUT_UCODE 5384 /* Load 8051 microcode. */ 5385 error = urtwn_load_firmware(sc); 5386 if (error == 0) 5387 sc->sc_flags |= URTWN_FW_LOADED; 5388 #endif 5389 5390 /* Initialize MAC/BB/RF blocks. */ 5391 error = urtwn_mac_init(sc); 5392 if (error != 0) { 5393 device_printf(sc->sc_dev, 5394 "%s: error while initializing MAC block\n", __func__); 5395 goto fail; 5396 } 5397 urtwn_bb_init(sc); 5398 urtwn_rf_init(sc); 5399 5400 /* Reinitialize Rx filter (D3845 is not committed yet). */ 5401 urtwn_rxfilter_init(sc); 5402 5403 if (sc->chip & URTWN_CHIP_88E) { 5404 urtwn_write_2(sc, R92C_CR, 5405 urtwn_read_2(sc, R92C_CR) | R92C_CR_MACTXEN | 5406 R92C_CR_MACRXEN); 5407 } 5408 5409 /* Turn CCK and OFDM blocks on. */ 5410 reg = urtwn_bb_read(sc, R92C_FPGA0_RFMOD); 5411 reg |= R92C_RFMOD_CCK_EN; 5412 usb_err = urtwn_bb_write(sc, R92C_FPGA0_RFMOD, reg); 5413 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5414 goto fail; 5415 reg = urtwn_bb_read(sc, R92C_FPGA0_RFMOD); 5416 reg |= R92C_RFMOD_OFDM_EN; 5417 usb_err = urtwn_bb_write(sc, R92C_FPGA0_RFMOD, reg); 5418 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5419 goto fail; 5420 5421 /* Clear per-station keys table. */ 5422 urtwn_cam_init(sc); 5423 5424 /* Enable decryption / encryption. */ 5425 urtwn_write_2(sc, R92C_SECCFG, 5426 R92C_SECCFG_TXUCKEY_DEF | R92C_SECCFG_RXUCKEY_DEF | 5427 R92C_SECCFG_TXENC_ENA | R92C_SECCFG_RXDEC_ENA | 5428 R92C_SECCFG_TXBCKEY_DEF | R92C_SECCFG_RXBCKEY_DEF); 5429 5430 /* 5431 * Install static keys (if any). 5432 * Must be called after urtwn_cam_init(). 5433 */ 5434 ieee80211_runtask(ic, &sc->cmdq_task); 5435 5436 /* Enable hardware sequence numbering. */ 5437 urtwn_write_1(sc, R92C_HWSEQ_CTRL, R92C_TX_QUEUE_ALL); 5438 5439 /* Enable per-packet TX report. */ 5440 if (sc->chip & URTWN_CHIP_88E) { 5441 urtwn_write_1(sc, R88E_TX_RPT_CTRL, 5442 urtwn_read_1(sc, R88E_TX_RPT_CTRL) | R88E_TX_RPT1_ENA); 5443 } 5444 5445 /* Perform LO and IQ calibrations. */ 5446 urtwn_iq_calib(sc); 5447 /* Perform LC calibration. */ 5448 urtwn_lc_calib(sc); 5449 5450 /* Fix USB interference issue. */ 5451 if (!(sc->chip & URTWN_CHIP_88E)) { 5452 urtwn_write_1(sc, 0xfe40, 0xe0); 5453 urtwn_write_1(sc, 0xfe41, 0x8d); 5454 urtwn_write_1(sc, 0xfe42, 0x80); 5455 5456 urtwn_pa_bias_init(sc); 5457 } 5458 5459 /* Initialize GPIO setting. */ 5460 urtwn_write_1(sc, R92C_GPIO_MUXCFG, 5461 urtwn_read_1(sc, R92C_GPIO_MUXCFG) & ~R92C_GPIO_MUXCFG_ENBT); 5462 5463 /* Fix for lower temperature. */ 5464 if (!(sc->chip & URTWN_CHIP_88E)) 5465 urtwn_write_1(sc, 0x15, 0xe9); 5466 5467 usbd_transfer_start(sc->sc_xfer[URTWN_BULK_RX]); 5468 5469 sc->sc_flags |= URTWN_RUNNING; 5470 5471 callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc); 5472 fail: 5473 if (usb_err != USB_ERR_NORMAL_COMPLETION) 5474 error = EIO; 5475 5476 URTWN_UNLOCK(sc); 5477 5478 return (error); 5479 } 5480 5481 static void 5482 urtwn_stop(struct urtwn_softc *sc) 5483 { 5484 5485 URTWN_LOCK(sc); 5486 if (!(sc->sc_flags & URTWN_RUNNING)) { 5487 URTWN_UNLOCK(sc); 5488 return; 5489 } 5490 5491 sc->sc_flags &= ~(URTWN_RUNNING | URTWN_FW_LOADED | 5492 URTWN_TEMP_MEASURED); 5493 sc->thcal_lctemp = 0; 5494 callout_stop(&sc->sc_watchdog_ch); 5495 5496 urtwn_abort_xfers(sc); 5497 urtwn_drain_mbufq(sc); 5498 urtwn_power_off(sc); 5499 URTWN_UNLOCK(sc); 5500 } 5501 5502 static void 5503 urtwn_abort_xfers(struct urtwn_softc *sc) 5504 { 5505 int i; 5506 5507 URTWN_ASSERT_LOCKED(sc); 5508 5509 /* abort any pending transfers */ 5510 for (i = 0; i < URTWN_N_TRANSFER; i++) 5511 usbd_transfer_stop(sc->sc_xfer[i]); 5512 } 5513 5514 static int 5515 urtwn_raw_xmit(struct ieee80211_node *ni, struct mbuf *m, 5516 const struct ieee80211_bpf_params *params) 5517 { 5518 struct ieee80211com *ic = ni->ni_ic; 5519 struct urtwn_softc *sc = ic->ic_softc; 5520 struct urtwn_data *bf; 5521 int error; 5522 5523 URTWN_DPRINTF(sc, URTWN_DEBUG_XMIT, "%s: called; m=%p\n", 5524 __func__, 5525 m); 5526 5527 /* prevent management frames from being sent if we're not ready */ 5528 URTWN_LOCK(sc); 5529 if (!(sc->sc_flags & URTWN_RUNNING)) { 5530 error = ENETDOWN; 5531 goto end; 5532 } 5533 5534 bf = urtwn_getbuf(sc); 5535 if (bf == NULL) { 5536 error = ENOBUFS; 5537 goto end; 5538 } 5539 5540 if (params == NULL) { 5541 /* 5542 * Legacy path; interpret frame contents to decide 5543 * precisely how to send the frame. 5544 */ 5545 error = urtwn_tx_data(sc, ni, m, bf); 5546 } else { 5547 /* 5548 * Caller supplied explicit parameters to use in 5549 * sending the frame. 5550 */ 5551 error = urtwn_tx_raw(sc, ni, m, bf, params); 5552 } 5553 if (error != 0) { 5554 STAILQ_INSERT_HEAD(&sc->sc_tx_inactive, bf, next); 5555 goto end; 5556 } 5557 5558 sc->sc_txtimer = 5; 5559 callout_reset(&sc->sc_watchdog_ch, hz, urtwn_watchdog, sc); 5560 5561 end: 5562 if (error != 0) 5563 m_freem(m); 5564 5565 URTWN_UNLOCK(sc); 5566 5567 return (error); 5568 } 5569 5570 static void 5571 urtwn_ms_delay(struct urtwn_softc *sc) 5572 { 5573 usb_pause_mtx(&sc->sc_mtx, hz / 1000); 5574 } 5575 5576 static device_method_t urtwn_methods[] = { 5577 /* Device interface */ 5578 DEVMETHOD(device_probe, urtwn_match), 5579 DEVMETHOD(device_attach, urtwn_attach), 5580 DEVMETHOD(device_detach, urtwn_detach), 5581 5582 DEVMETHOD_END 5583 }; 5584 5585 static driver_t urtwn_driver = { 5586 "urtwn", 5587 urtwn_methods, 5588 sizeof(struct urtwn_softc) 5589 }; 5590 5591 static devclass_t urtwn_devclass; 5592 5593 DRIVER_MODULE(urtwn, uhub, urtwn_driver, urtwn_devclass, NULL, NULL); 5594 MODULE_DEPEND(urtwn, usb, 1, 1, 1); 5595 MODULE_DEPEND(urtwn, wlan, 1, 1, 1); 5596 #ifndef URTWN_WITHOUT_UCODE 5597 MODULE_DEPEND(urtwn, firmware, 1, 1, 1); 5598 #endif 5599 MODULE_VERSION(urtwn, 1); 5600 #if defined(__DragonFly__) 5601 /* USB_PNP_HOST_INFO() not implemented */ 5602 #else 5603 USB_PNP_HOST_INFO(urtwn_devs); 5604 #endif 5605