1 /* 2 * Copyright (c) 2004, 2005 3 * Damien Bergamini <damien.bergamini@free.fr>. 4 * Copyright (c) 2004, 2005 5 * Andrew Atrens <atrens@nortelnetworks.com>. 6 * 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice unmodified, this list of conditions, and the following 14 * disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * $DragonFly: src/sys/dev/netif/iwi/if_iwi.c,v 1.3 2005/05/24 20:59:01 dillon Exp $ 32 */ 33 34 #include "opt_inet.h" 35 36 #include <sys/cdefs.h> 37 38 /*- 39 * Intel(R) PRO/Wireless 2200BG/2915ABG driver 40 * http://www.intel.com/network/connectivity/products/wireless/prowireless_mobile.htm 41 */ 42 43 #include <sys/param.h> 44 #include <sys/sysctl.h> 45 #include <sys/sockio.h> 46 #include <sys/mbuf.h> 47 #include <sys/kernel.h> 48 #include <sys/kthread.h> 49 #include <sys/socket.h> 50 #include <sys/systm.h> 51 #include <sys/malloc.h> 52 #include <sys/module.h> 53 #include <sys/bus.h> 54 #include <sys/endian.h> 55 #include <sys/proc.h> 56 #include <sys/ucred.h> 57 #include <sys/thread2.h> 58 59 #include <machine/bus.h> 60 #include <machine/resource.h> 61 #include <machine/clock.h> 62 #include <sys/rman.h> 63 64 #include <bus/pci/pcireg.h> 65 #include <bus/pci/pcivar.h> 66 67 #include <net/bpf.h> 68 #include <net/if.h> 69 #include <net/if_arp.h> 70 #include <net/ifq_var.h> 71 #include <net/ethernet.h> 72 #include <net/if_dl.h> 73 #include <net/if_media.h> 74 #include <net/if_types.h> 75 #include <net/ifq_var.h> 76 77 #include <netinet/in.h> 78 #include <netinet/in_systm.h> 79 #include <netinet/in_var.h> 80 #include <netinet/ip.h> 81 #include <netinet/if_ether.h> 82 83 #ifdef IPX 84 #include <netproto/ipx/ipx.h> 85 #include <netproto/ipx/ipx_if.h> 86 #endif 87 88 #include <netproto/802_11/ieee80211_var.h> 89 #include <netproto/802_11/ieee80211_ioctl.h> 90 #include <netproto/802_11/ieee80211_radiotap.h> 91 #include <netproto/802_11/if_wavelan_ieee.h> 92 93 #include "if_iwireg.h" 94 #include "if_iwivar.h" 95 96 #ifdef IWI_DEBUG 97 #define DPRINTF(x) if (sc->debug_level > 0) printf x 98 #define DPRINTFN(n, x) if (sc->debug_level >= (n)) printf x 99 100 #else 101 #define DPRINTF(x) 102 #define DPRINTFN(n, x) 103 #endif 104 105 MODULE_DEPEND(iwi, pci, 1, 1, 1); 106 MODULE_DEPEND(iwi, wlan, 1, 1, 1); 107 108 struct iwi_dump_buffer { 109 u_int32_t buf[128]; 110 }; 111 112 struct iwi_ident { 113 u_int16_t vendor; 114 u_int16_t device; 115 const char *name; 116 }; 117 118 static const struct iwi_ident iwi_ident_table[] = { 119 { 0x8086, 0x4220, "Intel(R) PRO/Wireless 2200BG MiniPCI" }, 120 { 0x8086, 0x4223, "Intel(R) PRO/Wireless 2915ABG MiniPCI" }, 121 { 0x8086, 0x4224, "Intel(R) PRO/Wireless 2915ABG MiniPCI" }, 122 123 { 0, 0, NULL } 124 }; 125 126 static const struct ieee80211_rateset iwi_rateset_11a = 127 { 8, { 12, 18, 24, 36, 48, 72, 96, 108 } }; 128 129 static const struct ieee80211_rateset iwi_rateset_11b = 130 { 4, { 2, 4, 11, 22 } }; 131 132 static const struct ieee80211_rateset iwi_rateset_11g = 133 { 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } }; 134 135 static int iwi_dma_alloc(struct iwi_softc *); 136 static void iwi_release(struct iwi_softc *); 137 static int iwi_media_change(struct ifnet *); 138 static void iwi_media_status(struct ifnet *, struct ifmediareq *); 139 static u_int16_t iwi_read_prom_word(struct iwi_softc *, u_int8_t); 140 static int iwi_newstate(struct ieee80211com *, 141 enum ieee80211_state, int); 142 static void iwi_fix_channel(struct iwi_softc *, struct mbuf *); 143 static void iwi_frame_intr(struct iwi_softc *, 144 struct iwi_rx_buf *, int, struct iwi_frame *); 145 static void iwi_notification_intr(struct iwi_softc *, 146 struct iwi_notif *); 147 static void iwi_rx_intr(struct iwi_softc *); 148 static void iwi_tx_intr(struct iwi_softc *); 149 static void iwi_intr(void *); 150 static void iwi_dma_map_buf(void *, bus_dma_segment_t *, int, 151 bus_size_t, int); 152 static void iwi_dma_map_addr(void *, bus_dma_segment_t *, int, int); 153 static int iwi_cmd(struct iwi_softc *, u_int8_t, void *, u_int8_t, 154 int); 155 static int iwi_tx_start(struct ifnet *, struct mbuf *, 156 struct ieee80211_node *); 157 static void iwi_start(struct ifnet *); 158 static void iwi_watchdog(struct ifnet *); 159 static int iwi_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *cr); 160 static void iwi_stop_master(struct iwi_softc *); 161 static int iwi_reset(struct iwi_softc *); 162 static int iwi_load_ucode(struct iwi_softc *, void *, int); 163 static int iwi_load_firmware(struct iwi_softc *, void *, int); 164 static int iwi_cache_firmware(struct iwi_softc *, void *, int); 165 static void iwi_free_firmware(struct iwi_softc *); 166 static int iwi_config(struct iwi_softc *); 167 static int iwi_scan(struct iwi_softc *); 168 static int iwi_auth_and_assoc(struct iwi_softc *); 169 static void iwi_init(void *); 170 static void iwi_init_locked(void *); 171 static void iwi_stop(void *); 172 static void iwi_dump_fw_event_log(struct iwi_softc *sc); 173 static void iwi_dump_fw_error_log(struct iwi_softc *sc); 174 static u_int8_t iwi_find_station(struct iwi_softc *sc, u_int8_t *mac); 175 static int8_t iwi_cache_station(struct iwi_softc *sc, u_int8_t *mac); 176 static int iwi_adapter_config(struct iwi_softc *sc, int is_a, int cmd_wait); 177 178 static int iwi_sysctl_bt_coexist(SYSCTL_HANDLER_ARGS); 179 static int iwi_sysctl_bg_autodetect(SYSCTL_HANDLER_ARGS); 180 static int iwi_sysctl_cts_to_self(SYSCTL_HANDLER_ARGS); 181 static int iwi_sysctl_antenna_diversity(SYSCTL_HANDLER_ARGS); 182 static int iwi_sysctl_radio(SYSCTL_HANDLER_ARGS); 183 static int iwi_sysctl_stats(SYSCTL_HANDLER_ARGS); 184 static int iwi_sysctl_dump_logs(SYSCTL_HANDLER_ARGS); 185 static int iwi_sysctl_neg_best_rates_first(SYSCTL_HANDLER_ARGS); 186 static int iwi_sysctl_disable_unicast_decryption(SYSCTL_HANDLER_ARGS); 187 static int iwi_sysctl_disable_multicast_decryption(SYSCTL_HANDLER_ARGS); 188 189 static __inline u_int8_t MEM_READ_1(struct iwi_softc *sc, u_int32_t addr) 190 { 191 CSR_WRITE_4(sc, IWI_CSR_INDIRECT_ADDR, addr); 192 return CSR_READ_1(sc, IWI_CSR_INDIRECT_DATA); 193 } 194 195 static __inline u_int32_t MEM_READ_4(struct iwi_softc *sc, u_int32_t addr) 196 { 197 CSR_WRITE_4(sc, IWI_CSR_INDIRECT_ADDR, addr); 198 return CSR_READ_4(sc, IWI_CSR_INDIRECT_DATA); 199 } 200 201 static int iwi_probe(device_t); 202 static int iwi_attach(device_t); 203 static int iwi_detach(device_t); 204 static int iwi_shutdown(device_t); 205 static int iwi_suspend(device_t); 206 static int iwi_resume(device_t); 207 208 static device_method_t iwi_methods[] = { 209 /* Device interface */ 210 DEVMETHOD(device_probe, iwi_probe), 211 DEVMETHOD(device_attach, iwi_attach), 212 DEVMETHOD(device_detach, iwi_detach), 213 DEVMETHOD(device_shutdown, iwi_shutdown), 214 DEVMETHOD(device_suspend, iwi_suspend), 215 DEVMETHOD(device_resume, iwi_resume), 216 217 { 0, 0 } 218 }; 219 220 static driver_t iwi_driver = { 221 "iwi", 222 iwi_methods, 223 sizeof (struct iwi_softc), 224 0, /* baseclasses */ 225 0, /* refs */ 226 0 /* ops */ 227 }; 228 229 static devclass_t iwi_devclass; 230 231 DRIVER_MODULE(iwi, pci, iwi_driver, iwi_devclass, 0, 0); 232 233 static int 234 iwi_probe(device_t dev) 235 { 236 const struct iwi_ident *ident; 237 238 for (ident = iwi_ident_table; ident->name != NULL; ident++) { 239 if (pci_get_vendor(dev) == ident->vendor && 240 pci_get_device(dev) == ident->device) { 241 device_set_desc(dev, ident->name); 242 return 0; 243 } 244 } 245 return ENXIO; 246 } 247 248 static void 249 iwi_fw_monitor(void *arg) 250 { 251 struct iwi_softc *sc = (struct iwi_softc *)arg; 252 int error, boff; 253 for ( ;; ) { 254 error = tsleep(IWI_FW_WAKE_MONITOR(sc), 0, "iwifwm", 0 ); 255 if ( error == 0 ) { 256 if ( sc->flags & IWI_FLAG_EXIT ) { 257 sc->flags &= ~( IWI_FLAG_EXIT ); 258 break; 259 } else if ( sc->flags & IWI_FLAG_RESET ) { 260 device_printf(sc->sc_dev, "firmware reset\n"); 261 for ( boff = 1; sc->flags & IWI_FLAG_RESET ; boff++ ) { 262 if ( sc->debug_level > 0 ) 263 iwi_dump_fw_error_log(sc); 264 iwi_init_locked(sc); 265 if ((sc->flags & IWI_FLAG_FW_INITED)) 266 sc->flags &= ~( IWI_FLAG_RESET ); 267 error = tsleep( IWI_FW_CMD_ACKED(sc), 0, 268 "iwirun", boff * hz ); 269 } 270 } 271 } 272 } 273 wakeup(IWI_FW_MON_EXIT(sc)); 274 kthread_exit(); 275 } 276 277 static int 278 iwi_start_fw_monitor_thread( struct iwi_softc *sc ) 279 { 280 if (kthread_create(iwi_fw_monitor, sc, &sc->event_thread, 281 "%s%d:fw-monitor", device_get_name(sc->sc_dev), 282 device_get_unit(sc->sc_dev))) { 283 device_printf (sc->sc_dev, 284 "unable to create firmware monitor thread.\n"); 285 return -1; 286 } 287 return 0; 288 } 289 290 /* Base Address Register */ 291 #define IWI_PCI_BAR0 0x10 292 293 static int 294 iwi_attach(device_t dev) 295 { 296 struct iwi_softc *sc = device_get_softc(dev); 297 struct ieee80211com *ic = &sc->sc_ic; 298 struct ifnet *ifp = &ic->ic_if; 299 u_int16_t val; 300 int error, rid, i; 301 302 sc->sc_dev = dev; 303 304 IWI_LOCK_INIT( &sc->sc_lock ); 305 IWI_LOCK_INIT( &sc->sc_intrlock ); 306 307 if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0) { 308 device_printf(dev, "chip is in D%d power mode " 309 "-- setting to D0\n", pci_get_powerstate(dev)); 310 pci_set_powerstate(dev, PCI_POWERSTATE_D0); 311 } 312 313 pci_write_config(dev, 0x41, 0, 1); 314 315 /* enable bus-mastering */ 316 pci_enable_busmaster(dev); 317 318 sc->num_stations = 0; 319 320 /* map the register window */ 321 rid = IWI_PCI_BAR0; 322 sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, RF_ACTIVE); 323 if (sc->mem == NULL) { 324 device_printf(dev, "could not allocate memory resource\n"); 325 goto fail; 326 } 327 328 sc->sc_st = rman_get_bustag(sc->mem); 329 sc->sc_sh = rman_get_bushandle(sc->mem); 330 331 rid = 0; 332 sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, RF_ACTIVE | 333 RF_SHAREABLE); 334 if (sc->irq == NULL) { 335 device_printf(dev, "could not allocate interrupt resource\n"); 336 goto fail; 337 } 338 339 if (iwi_reset(sc) != 0) { 340 device_printf(dev, "could not reset adapter\n"); 341 goto fail; 342 } 343 344 if (iwi_start_fw_monitor_thread(sc) ) { 345 device_printf(dev, "could not start f/w reset thread\n"); 346 goto fail; 347 } 348 349 if (iwi_dma_alloc(sc) != 0) { 350 device_printf(dev, "could not allocate DMA resources\n"); 351 goto fail; 352 } 353 354 ic->ic_phytype = IEEE80211_T_OFDM; 355 ic->ic_opmode = IEEE80211_M_STA; 356 ic->ic_state = IEEE80211_S_INIT; 357 358 /* set device capabilities */ 359 ic->ic_caps = IEEE80211_C_IBSS | IEEE80211_C_PMGT | IEEE80211_C_WEP | 360 IEEE80211_C_TXPMGT | IEEE80211_C_SHPREAMBLE; 361 362 /* read MAC address from EEPROM */ 363 val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 0); 364 ic->ic_myaddr[0] = val >> 8; 365 ic->ic_myaddr[1] = val & 0xff; 366 val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 1); 367 ic->ic_myaddr[2] = val >> 8; 368 ic->ic_myaddr[3] = val & 0xff; 369 val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 2); 370 ic->ic_myaddr[4] = val >> 8; 371 ic->ic_myaddr[5] = val & 0xff; 372 373 if (pci_get_device(dev) != 0x4220) { 374 /* set supported .11a rates */ 375 ic->ic_sup_rates[IEEE80211_MODE_11A] = iwi_rateset_11a; 376 377 /* set supported .11a channels */ 378 for (i = 36; i <= 64; i += 4) { 379 ic->ic_channels[i].ic_freq = 380 ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ); 381 ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A; 382 } 383 for (i = 149; i <= 165; i += 4) { 384 ic->ic_channels[i].ic_freq = 385 ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ); 386 ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A; 387 } 388 } 389 390 /* set supported .11b and .11g rates */ 391 ic->ic_sup_rates[IEEE80211_MODE_11B] = iwi_rateset_11b; 392 ic->ic_sup_rates[IEEE80211_MODE_11G] = iwi_rateset_11g; 393 394 /* set supported .11b and .11g channels (1 through 14) */ 395 for (i = 1; i <= 14; i++) { 396 ic->ic_channels[i].ic_freq = 397 ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ); 398 ic->ic_channels[i].ic_flags = 399 IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM | 400 IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ; 401 } 402 403 /* default to authmode OPEN */ 404 sc->authmode = IEEE80211_AUTH_OPEN; 405 406 /* IBSS channel undefined for now */ 407 ic->ic_ibss_chan = &ic->ic_channels[0]; 408 409 ifp->if_softc = sc; 410 if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 411 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 412 ifp->if_init = iwi_init_locked; 413 ifp->if_ioctl = iwi_ioctl; 414 ifp->if_start = iwi_start; 415 ifp->if_watchdog = iwi_watchdog; 416 ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN); 417 ifq_set_ready(&ifp->if_snd); 418 419 ieee80211_ifattach(ifp); 420 /* override state transition machine */ 421 sc->sc_newstate = ic->ic_newstate; 422 ic->ic_newstate = iwi_newstate; 423 ieee80211_media_init(ifp, iwi_media_change, iwi_media_status); 424 425 bpfattach_dlt(ifp, DLT_IEEE802_11_RADIO, 426 sizeof (struct ieee80211_frame) + 64, &sc->sc_drvbpf); 427 428 sc->sc_rxtap_len = sizeof sc->sc_rxtapu; 429 sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len); 430 sc->sc_rxtap.wr_ihdr.it_present = htole32(IWI_RX_RADIOTAP_PRESENT); 431 432 sc->sc_txtap_len = sizeof sc->sc_txtapu; 433 sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len); 434 sc->sc_txtap.wt_ihdr.it_present = htole32(IWI_TX_RADIOTAP_PRESENT); 435 436 /* 437 * Hook our interrupt after all initialization is complete 438 */ 439 error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, 440 iwi_intr, sc, &sc->sc_ih, NULL); 441 if (error != 0) { 442 device_printf(dev, "could not set up interrupt\n"); 443 goto fail; 444 } 445 446 /* 447 * Add sysctl knobs 448 * 449 * use -1 to indicate 'default / not set' 450 */ 451 452 sc->enable_bg_autodetect = -1; 453 sc->enable_bt_coexist = -1; 454 sc->enable_cts_to_self = -1; 455 sc->antenna_diversity = -1; 456 sc->enable_neg_best_first = -1; 457 sc->disable_unicast_decryption = -1; 458 sc->disable_multicast_decryption = -1; 459 460 sysctl_ctx_init(&sc->sysctl_ctx); 461 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx, 462 SYSCTL_STATIC_CHILDREN(_hw), 463 OID_AUTO, 464 device_get_nameunit(dev), 465 CTLFLAG_RD, 466 0, ""); 467 468 if (sc->sysctl_tree == NULL) { 469 error = EIO; 470 goto fail; 471 } 472 473 SYSCTL_ADD_INT(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree), 474 OID_AUTO, "debug", CTLFLAG_RW, &sc->debug_level, 0, 475 "Set driver debug level (0 = off)"); 476 477 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 478 SYSCTL_CHILDREN(sc->sysctl_tree), 479 OID_AUTO, "cts_to_self", CTLTYPE_INT|CTLFLAG_RW, 480 (void *)sc, 0, iwi_sysctl_cts_to_self, "I", 481 "Enable cts to self [0 = Off] [1 = On] [-1 = Auto]" ); 482 483 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 484 SYSCTL_CHILDREN(sc->sysctl_tree), 485 OID_AUTO, "antenna_diversity", CTLTYPE_INT|CTLFLAG_RW, 486 (void *)sc, 0, iwi_sysctl_antenna_diversity, 487 "I", "Set antenna diversity [0 = Both] " 488 "[1 = Antenna A] [3 = Antenna B] [-1 = Auto]" ); 489 490 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 491 SYSCTL_CHILDREN(sc->sysctl_tree), 492 OID_AUTO, "bluetooth_coexist", CTLTYPE_INT|CTLFLAG_RW, 493 (void *)sc, 0, iwi_sysctl_bt_coexist, 494 "I", "Enable bluetooth coexistence heuristics " 495 "[0 = Off] [1 = On] [-1 = Auto]" ); 496 497 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 498 SYSCTL_CHILDREN(sc->sysctl_tree), 499 OID_AUTO, "bg_autodetect", CTLTYPE_INT|CTLFLAG_RW, 500 (void *)sc, 0, iwi_sysctl_bg_autodetect, 501 "I", "Set b/g autodetect [0 = Off] [1 = On] [-1 = Auto]" ); 502 503 504 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 505 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "radio", 506 CTLTYPE_INT | CTLFLAG_RD, sc, 0, iwi_sysctl_radio, "I", 507 "Radio transmitter switch"); 508 509 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 510 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, "stats", 511 CTLTYPE_OPAQUE | CTLFLAG_RD, sc, 0, iwi_sysctl_stats, 512 "S,iwi_dump_buffer", "statistics"); 513 514 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 515 SYSCTL_CHILDREN(sc->sysctl_tree), 516 OID_AUTO, "firmware_logs", CTLTYPE_INT|CTLFLAG_RW, 517 (void *)sc, 0, iwi_sysctl_dump_logs, "I", "Dump firmware logs"); 518 519 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 520 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 521 "neg_best_rates_first", 522 CTLTYPE_INT | CTLFLAG_RW, sc, 0, 523 iwi_sysctl_neg_best_rates_first, "I", 524 "Negotiate highest rates first."); 525 526 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 527 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 528 "disable_unicast_decrypt", 529 CTLTYPE_INT | CTLFLAG_RW, sc, 0, 530 iwi_sysctl_disable_unicast_decryption, "I", 531 "Disable unicast decryption."); 532 533 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 534 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 535 "disable_multicast_decrypt", 536 CTLTYPE_INT | CTLFLAG_RW, sc, 0, 537 iwi_sysctl_disable_multicast_decryption, "I", 538 "Disable multicast decryption."); 539 540 return 0; 541 542 fail: iwi_detach(dev); 543 return ENXIO; 544 } 545 546 static int 547 iwi_detach(device_t dev) 548 { 549 struct iwi_softc *sc = device_get_softc(dev); 550 struct ifnet *ifp = &sc->sc_ic.ic_if; 551 IWI_LOCK_INFO; 552 IWI_IPLLOCK_INFO; 553 554 sc->flags |= IWI_FLAG_EXIT; 555 wakeup(IWI_FW_WAKE_MONITOR(sc)); /* Stop firmware monitor. */ 556 557 (void) tsleep(IWI_FW_MON_EXIT(sc), 0, "iwiexi", 10 * hz ); 558 559 IWI_LOCK(sc); 560 IWI_IPLLOCK(sc); 561 562 iwi_stop(sc); 563 iwi_free_firmware(sc); 564 565 if ( sc->sysctl_tree ) { 566 crit_enter(); 567 sysctl_ctx_free(&sc->sysctl_ctx); 568 crit_exit(); 569 sc->sysctl_tree = 0; 570 } 571 572 IWI_IPLUNLOCK(sc); 573 IWI_UNLOCK(sc); 574 575 bpfdetach(ifp); 576 577 ieee80211_ifdetach(ifp); 578 579 iwi_release(sc); 580 581 if (sc->irq != NULL) { 582 bus_teardown_intr(dev, sc->irq, sc->sc_ih); 583 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq); 584 } 585 586 if (sc->mem != NULL) 587 bus_release_resource(dev, SYS_RES_MEMORY, IWI_PCI_BAR0, 588 sc->mem); 589 590 IWI_LOCK_DESTROY(&(sc->sc_lock)); 591 IWI_LOCK_DESTROY(&(sc->sc_intrlock)); 592 593 return 0; 594 } 595 596 static int 597 iwi_dma_alloc(struct iwi_softc *sc) 598 { 599 int i, error; 600 601 error = bus_dma_tag_create(NULL, /* parent */ 602 1, 0, 603 BUS_SPACE_MAXADDR_32BIT, 604 BUS_SPACE_MAXADDR, 605 NULL, NULL, 606 MAXBSIZE, 128, 607 BUS_SPACE_MAXSIZE_32BIT, 608 BUS_DMA_ALLOCNOW, 609 &sc->iwi_parent_tag ); 610 if (error != 0) { 611 device_printf(sc->sc_dev, "could not create parent tag\n"); 612 goto fail; 613 } 614 /* 615 * Allocate and map Tx ring 616 */ 617 error = bus_dma_tag_create(sc->iwi_parent_tag, 4, 0, BUS_SPACE_MAXADDR_32BIT, 618 BUS_SPACE_MAXADDR, NULL, NULL, 619 sizeof (struct iwi_tx_desc) * IWI_TX_RING_SIZE, 1, 620 sizeof (struct iwi_tx_desc) * IWI_TX_RING_SIZE, 621 BUS_DMA_ALLOCNOW, &sc->tx_ring_dmat); 622 if (error != 0) { 623 device_printf(sc->sc_dev, "could not create tx ring DMA tag\n"); 624 goto fail; 625 } 626 627 error = bus_dmamem_alloc(sc->tx_ring_dmat,(void **) &sc->tx_desc, 628 BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->tx_ring_map); 629 if (error != 0) { 630 device_printf(sc->sc_dev, 631 "could not allocate tx ring DMA memory\n"); 632 goto fail; 633 } 634 635 error = bus_dmamap_load(sc->tx_ring_dmat, sc->tx_ring_map, 636 sc->tx_desc, sizeof (struct iwi_tx_desc) * IWI_TX_RING_SIZE, 637 iwi_dma_map_addr, &sc->tx_ring_pa, 0); 638 if (error != 0) { 639 device_printf(sc->sc_dev, "could not load tx ring DMA map\n"); 640 goto fail; 641 } 642 643 /* 644 * Allocate and map command ring 645 */ 646 error = bus_dma_tag_create(sc->iwi_parent_tag, 4, 0, BUS_SPACE_MAXADDR_32BIT, 647 BUS_SPACE_MAXADDR, NULL, NULL, 648 sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_SIZE, 1, 649 sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_SIZE, 650 BUS_DMA_ALLOCNOW, 651 &sc->cmd_ring_dmat); 652 if (error != 0) { 653 device_printf(sc->sc_dev, 654 "could not create command ring DMA tag\n"); 655 goto fail; 656 } 657 658 error = bus_dmamem_alloc(sc->cmd_ring_dmat, (void **)&sc->cmd_desc, 659 BUS_DMA_WAITOK | BUS_DMA_ZERO, &sc->cmd_ring_map); 660 if (error != 0) { 661 device_printf(sc->sc_dev, 662 "could not allocate command ring DMA memory\n"); 663 goto fail; 664 } 665 666 error = bus_dmamap_load(sc->cmd_ring_dmat, sc->cmd_ring_map, 667 sc->cmd_desc, sizeof (struct iwi_cmd_desc) * IWI_CMD_RING_SIZE, 668 iwi_dma_map_addr, &sc->cmd_ring_pa, 0); 669 if (error != 0) { 670 device_printf(sc->sc_dev, 671 "could not load command ring DMA map\n"); 672 goto fail; 673 } 674 675 /* 676 * Allocate Tx buffers DMA maps 677 */ 678 error = bus_dma_tag_create(sc->iwi_parent_tag, 1, 0, BUS_SPACE_MAXADDR_32BIT, 679 BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, IWI_MAX_NSEG, MCLBYTES, 680 BUS_DMA_ALLOCNOW, &sc->tx_buf_dmat); 681 if (error != 0) { 682 device_printf(sc->sc_dev, "could not create tx buf DMA tag\n"); 683 goto fail; 684 } 685 686 for (i = 0; i < IWI_TX_RING_SIZE; i++) { 687 error = bus_dmamap_create(sc->tx_buf_dmat, 0, 688 &sc->tx_buf[i].map); 689 if (error != 0) { 690 device_printf(sc->sc_dev, 691 "could not create tx buf DMA map"); 692 goto fail; 693 } 694 } 695 696 /* 697 * Allocate and map Rx buffers 698 */ 699 error = bus_dma_tag_create(sc->iwi_parent_tag, 1, 0, BUS_SPACE_MAXADDR_32BIT, 700 BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 1, MCLBYTES, 701 BUS_DMA_ALLOCNOW, &sc->rx_buf_dmat); 702 if (error != 0) { 703 device_printf(sc->sc_dev, "could not create rx buf DMA tag\n"); 704 goto fail; 705 } 706 707 for (i = 0; i < IWI_RX_RING_SIZE; i++) { 708 709 error = bus_dmamap_create(sc->rx_buf_dmat, 0, 710 &sc->rx_buf[i].map); 711 if (error != 0) { 712 device_printf(sc->sc_dev, 713 "could not create rx buf DMA map"); 714 goto fail; 715 } 716 717 sc->rx_buf[i].m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR); 718 if (sc->rx_buf[i].m == NULL) { 719 device_printf(sc->sc_dev, 720 "could not allocate rx mbuf\n"); 721 error = ENOMEM; 722 goto fail; 723 } 724 725 error = bus_dmamap_load(sc->rx_buf_dmat, sc->rx_buf[i].map, 726 mtod(sc->rx_buf[i].m, void *), MCLBYTES, iwi_dma_map_addr, 727 &sc->rx_buf[i].physaddr, 0); 728 if (error != 0) { 729 device_printf(sc->sc_dev, 730 "could not load rx buf DMA map"); 731 goto fail; 732 } 733 } 734 735 return 0; 736 737 fail: iwi_release(sc); 738 return error; 739 } 740 741 static void 742 iwi_release(struct iwi_softc *sc) 743 { 744 int i; 745 746 if (sc->tx_ring_dmat != NULL) { 747 if (sc->tx_desc != NULL) { 748 bus_dmamap_sync(sc->tx_ring_dmat, sc->tx_ring_map, 749 BUS_DMASYNC_POSTWRITE); 750 bus_dmamap_unload(sc->tx_ring_dmat, sc->tx_ring_map); 751 bus_dmamem_free(sc->tx_ring_dmat, sc->tx_desc, 752 sc->tx_ring_map); 753 } 754 bus_dma_tag_destroy(sc->tx_ring_dmat); 755 } 756 757 if (sc->cmd_ring_dmat != NULL) { 758 if (sc->cmd_desc != NULL) { 759 bus_dmamap_sync(sc->cmd_ring_dmat, sc->cmd_ring_map, 760 BUS_DMASYNC_POSTWRITE); 761 bus_dmamap_unload(sc->cmd_ring_dmat, sc->cmd_ring_map); 762 bus_dmamem_free(sc->cmd_ring_dmat, sc->cmd_desc, 763 sc->cmd_ring_map); 764 } 765 bus_dma_tag_destroy(sc->cmd_ring_dmat); 766 } 767 768 if (sc->tx_buf_dmat != NULL) { 769 for (i = 0; i < IWI_TX_RING_SIZE; i++) { 770 if (sc->tx_buf[i].m != NULL) { 771 bus_dmamap_sync(sc->tx_buf_dmat, 772 sc->tx_buf[i].map, BUS_DMASYNC_POSTWRITE); 773 bus_dmamap_unload(sc->tx_buf_dmat, 774 sc->tx_buf[i].map); 775 m_freem(sc->tx_buf[i].m); 776 } 777 bus_dmamap_destroy(sc->tx_buf_dmat, sc->tx_buf[i].map); 778 } 779 bus_dma_tag_destroy(sc->tx_buf_dmat); 780 } 781 782 if (sc->rx_buf_dmat != NULL) { 783 for (i = 0; i < IWI_RX_RING_SIZE; i++) { 784 if (sc->rx_buf[i].m != NULL) { 785 bus_dmamap_sync(sc->rx_buf_dmat, 786 sc->rx_buf[i].map, BUS_DMASYNC_POSTREAD); 787 bus_dmamap_unload(sc->rx_buf_dmat, 788 sc->rx_buf[i].map); 789 m_freem(sc->rx_buf[i].m); 790 } 791 bus_dmamap_destroy(sc->rx_buf_dmat, sc->rx_buf[i].map); 792 } 793 bus_dma_tag_destroy(sc->rx_buf_dmat); 794 } 795 if ( sc->iwi_parent_tag != NULL ) { 796 bus_dma_tag_destroy(sc->iwi_parent_tag); 797 } 798 } 799 800 static int 801 iwi_shutdown(device_t dev) 802 { 803 struct iwi_softc *sc = device_get_softc(dev); 804 IWI_LOCK_INFO; 805 806 IWI_LOCK(sc); 807 808 iwi_stop(sc); 809 810 IWI_UNLOCK(sc); 811 812 return 0; 813 } 814 815 static int 816 iwi_suspend(device_t dev) 817 { 818 struct iwi_softc *sc = device_get_softc(dev); 819 820 IWI_LOCK_INFO; 821 822 IWI_LOCK(sc); 823 824 iwi_stop(sc); 825 826 IWI_UNLOCK(sc); 827 828 return 0; 829 } 830 831 static int 832 iwi_resume(device_t dev) 833 { 834 struct iwi_softc *sc = device_get_softc(dev); 835 struct ifnet *ifp = &sc->sc_ic.ic_if; 836 IWI_LOCK_INFO; 837 838 IWI_LOCK(sc); 839 840 pci_write_config(dev, 0x41, 0, 1); 841 842 if (ifp->if_flags & IFF_UP) { 843 ifp->if_init(ifp->if_softc); 844 if (ifp->if_flags & IFF_RUNNING) 845 ifp->if_start(ifp); 846 } 847 848 IWI_UNLOCK(sc); 849 850 return 0; 851 } 852 853 static int 854 iwi_media_change(struct ifnet *ifp) 855 { 856 struct iwi_softc *sc = ifp->if_softc; 857 int error = 0; 858 IWI_LOCK_INFO; 859 860 IWI_LOCK(sc); 861 862 error = ieee80211_media_change(ifp); 863 if (error != ENETRESET) { 864 IWI_UNLOCK(sc); 865 return error; 866 } 867 error = 0; /* clear ENETRESET */ 868 869 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING)){ 870 iwi_init(sc); 871 error = tsleep( IWI_FW_CMD_ACKED(sc), 0, "iwirun", hz ); 872 } 873 874 875 IWI_UNLOCK(sc); 876 877 return error; 878 } 879 880 static void 881 iwi_media_status(struct ifnet *ifp, struct ifmediareq *imr) 882 { 883 struct iwi_softc *sc = ifp->if_softc; 884 struct ieee80211com *ic = &sc->sc_ic; 885 #define N(a) (sizeof (a) / sizeof (a[0])) 886 static const struct { 887 u_int32_t val; 888 int rate; 889 } rates[] = { 890 { IWI_RATE_DS1, 2 }, 891 { IWI_RATE_DS2, 4 }, 892 { IWI_RATE_DS5, 11 }, 893 { IWI_RATE_DS11, 22 }, 894 { IWI_RATE_OFDM6, 12 }, 895 { IWI_RATE_OFDM9, 18 }, 896 { IWI_RATE_OFDM12, 24 }, 897 { IWI_RATE_OFDM18, 36 }, 898 { IWI_RATE_OFDM24, 48 }, 899 { IWI_RATE_OFDM36, 72 }, 900 { IWI_RATE_OFDM48, 96 }, 901 { IWI_RATE_OFDM54, 108 }, 902 }; 903 u_int32_t val, i; 904 int rate; 905 906 imr->ifm_status = IFM_AVALID; 907 imr->ifm_active = IFM_IEEE80211; 908 if (ic->ic_state == IEEE80211_S_RUN) 909 imr->ifm_status |= IFM_ACTIVE; 910 911 /* read current transmission rate from adapter */ 912 val = CSR_READ_4(sc, IWI_CSR_CURRENT_TX_RATE); 913 914 /* convert rate to 802.11 rate */ 915 for (i = 0; i < N(rates) && rates[i].val != val ; i++); 916 rate = (i < N(rates)) ? rates[i].rate : 0; 917 918 imr->ifm_active |= ieee80211_rate2media(ic, rate, ic->ic_curmode); 919 switch (ic->ic_opmode) { 920 case IEEE80211_M_STA: 921 break; 922 923 case IEEE80211_M_IBSS: 924 imr->ifm_active |= IFM_IEEE80211_ADHOC; 925 break; 926 927 case IEEE80211_M_MONITOR: 928 imr->ifm_active |= IFM_IEEE80211_MONITOR; 929 break; 930 931 case IEEE80211_M_AHDEMO: 932 case IEEE80211_M_HOSTAP: 933 /* should not get there */ 934 break; 935 } 936 #undef N 937 } 938 939 static int 940 iwi_disassociate( struct iwi_softc *sc ) 941 { 942 sc->assoc.type = 2; /* DISASSOCIATE */ 943 return iwi_cmd(sc, IWI_CMD_ASSOCIATE, &sc->assoc, sizeof sc->assoc, 0); 944 } 945 946 947 static int 948 iwi_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg __unused) 949 { 950 struct iwi_softc *sc = ic->ic_softc; 951 952 switch (nstate) { 953 case IEEE80211_S_SCAN: 954 if ( sc->flags & IWI_FLAG_ASSOCIATED ) { 955 sc->flags &= ~( IWI_FLAG_ASSOCIATED ); 956 iwi_disassociate(sc); 957 (void) tsleep( IWI_FW_DEASSOCIATED(sc), 958 0, "iwisca", hz ); 959 960 } 961 if ( !(sc->flags & IWI_FLAG_SCANNING) && 962 !(sc->flags & IWI_FLAG_RF_DISABLED) ) { 963 iwi_scan(sc); 964 } 965 break; 966 967 case IEEE80211_S_AUTH: 968 if ( sc->flags & IWI_FLAG_ASSOCIATED ) { 969 sc->flags &= ~( IWI_FLAG_ASSOCIATED ); 970 iwi_disassociate(sc); 971 (void) tsleep( IWI_FW_DEASSOCIATED(sc), 0, 972 "iwiaut", hz ); 973 974 } 975 if ( iwi_auth_and_assoc(sc) != 0 ) 976 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 977 break; 978 979 case IEEE80211_S_RUN: 980 if (sc->flags & IWI_FLAG_SCAN_COMPLETE) { 981 sc->flags &= ~(IWI_FLAG_SCAN_COMPLETE); 982 if (ic->ic_opmode == IEEE80211_M_IBSS || 983 ic->ic_opmode == IEEE80211_M_MONITOR ) { 984 /* 985 * In IBSS mode, following an end_scan 986 * the ieee80211 stack state machine transitions 987 * straight to 'run' state. This is out of 988 * step with the firmware which requires 989 * an association first. Flip our state from 990 * RUN back to AUTH to allow us to tell the 991 * firmware to associate. 992 */ 993 ieee80211_new_state(ic, IEEE80211_S_AUTH, -1); 994 } 995 } 996 break; 997 998 case IEEE80211_S_ASSOC: 999 break; 1000 case IEEE80211_S_INIT: 1001 sc->flags &= ~( IWI_FLAG_SCANNING | IWI_FLAG_ASSOCIATED ); 1002 break; 1003 } 1004 1005 ic->ic_state = nstate; 1006 return 0; 1007 } 1008 1009 /* 1010 * Read 16 bits at address 'addr' from the serial EEPROM. 1011 * DON'T PLAY WITH THIS CODE UNLESS YOU KNOW *EXACTLY* WHAT YOU'RE DOING! 1012 */ 1013 static u_int16_t 1014 iwi_read_prom_word(struct iwi_softc *sc, u_int8_t addr) 1015 { 1016 u_int32_t tmp; 1017 u_int16_t val; 1018 int n; 1019 1020 /* Clock C once before the first command */ 1021 IWI_EEPROM_CTL(sc, 0); 1022 IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1023 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C); 1024 IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1025 1026 /* Write start bit (1) */ 1027 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D); 1028 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D | IWI_EEPROM_C); 1029 1030 /* Write READ opcode (10) */ 1031 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D); 1032 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D | IWI_EEPROM_C); 1033 IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1034 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C); 1035 1036 /* Write address A7-A0 */ 1037 for (n = 7; n >= 0; n--) { 1038 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | 1039 (((addr >> n) & 1) << IWI_EEPROM_SHIFT_D)); 1040 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | 1041 (((addr >> n) & 1) << IWI_EEPROM_SHIFT_D) | IWI_EEPROM_C); 1042 } 1043 1044 IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1045 1046 /* Read data Q15-Q0 */ 1047 val = 0; 1048 for (n = 15; n >= 0; n--) { 1049 IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C); 1050 IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1051 tmp = MEM_READ_4(sc, IWI_MEM_EEPROM_CTL); 1052 val |= ((tmp & IWI_EEPROM_Q) >> IWI_EEPROM_SHIFT_Q) << n; 1053 } 1054 1055 IWI_EEPROM_CTL(sc, 0); 1056 1057 /* Clear Chip Select and clock C */ 1058 IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1059 IWI_EEPROM_CTL(sc, 0); 1060 IWI_EEPROM_CTL(sc, IWI_EEPROM_C); 1061 1062 return be16toh(val); 1063 } 1064 1065 /* 1066 * XXX: Hack to set the current channel to the value advertised in beacons or 1067 * probe responses. Only used during AP detection. 1068 */ 1069 static void 1070 iwi_fix_channel(struct iwi_softc *sc, struct mbuf *m) 1071 { 1072 struct ieee80211com *ic = &sc->sc_ic; 1073 struct ieee80211_frame *wh; 1074 u_int8_t subtype; 1075 u_int8_t *frm, *efrm; 1076 1077 wh = mtod(m, struct ieee80211_frame *); 1078 1079 if ((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) != IEEE80211_FC0_TYPE_MGT) 1080 return; 1081 1082 subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; 1083 1084 if (subtype != IEEE80211_FC0_SUBTYPE_BEACON && 1085 subtype != IEEE80211_FC0_SUBTYPE_PROBE_RESP) 1086 return; 1087 1088 /* 1089 * Cache station entries from beacons and probes. 1090 */ 1091 if ( iwi_find_station(sc, wh->i_addr2) == 0xff ) 1092 iwi_cache_station(sc, wh->i_addr2); 1093 1094 frm = (u_int8_t *)(wh + 1); 1095 efrm = mtod(m, u_int8_t *) + m->m_len; 1096 1097 frm += 12; /* skip tstamp, bintval and capinfo fields */ 1098 #if 0 1099 { /* XXX - debugging code */ 1100 u_int8_t *ptr; 1101 u_int32_t cnt; 1102 printf("Frame -->"); 1103 for ( ptr = frm, cnt = 0 ; ptr < efrm ; ptr++, cnt++ ) { 1104 if ( cnt % 8 == 0 ) 1105 printf("\n"); 1106 printf("0x%-2.2x ", *ptr); 1107 } 1108 printf("<-- End Frame\n"); 1109 } 1110 #endif 1111 1112 while (frm < efrm) { 1113 if (*frm == IEEE80211_ELEMID_DSPARMS) 1114 #if IEEE80211_CHAN_MAX < 255 1115 if (frm[2] <= IEEE80211_CHAN_MAX) 1116 #endif 1117 ic->ic_bss->ni_chan = &ic->ic_channels[frm[2]]; 1118 1119 frm += frm[1] + 2; /* advance to the next tag */ 1120 } 1121 } 1122 1123 static void 1124 iwi_frame_intr(struct iwi_softc *sc, struct iwi_rx_buf *buf, int i, 1125 struct iwi_frame *frame) 1126 { 1127 struct ieee80211com *ic = &sc->sc_ic; 1128 struct ifnet *ifp = &ic->ic_if; 1129 struct mbuf *m; 1130 struct ieee80211_frame *wh; 1131 struct ieee80211_node *ni; 1132 int error; 1133 1134 DPRINTFN(5, ("RX!DATA!%u!%u!%u\n", le16toh(frame->len), frame->chan, 1135 frame->rssi_dbm)); 1136 1137 if (le16toh(frame->len) < sizeof (struct ieee80211_frame_min) || 1138 le16toh(frame->len) > MCLBYTES) { 1139 device_printf(sc->sc_dev, "bad frame length\n"); 1140 return; 1141 } 1142 1143 bus_dmamap_unload(sc->rx_buf_dmat, buf->map); 1144 1145 /* Finalize mbuf */ 1146 m = buf->m; 1147 m->m_pkthdr.rcvif = ifp; 1148 m->m_pkthdr.len = m->m_len = sizeof (struct iwi_hdr) + 1149 sizeof (struct iwi_frame) + le16toh(frame->len); 1150 1151 m_adj(m, sizeof (struct iwi_hdr) + sizeof (struct iwi_frame)); 1152 1153 wh = mtod(m, struct ieee80211_frame *); 1154 if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 1155 /* 1156 * Hardware decrypts the frame itself but leaves the WEP bit 1157 * set in the 802.11 header and don't remove the iv and crc 1158 * fields 1159 */ 1160 wh->i_fc[1] &= ~IEEE80211_FC1_WEP; 1161 bcopy(wh, (char *)wh + IEEE80211_WEP_IVLEN + 1162 IEEE80211_WEP_KIDLEN, sizeof (struct ieee80211_frame)); 1163 m_adj(m, IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN); 1164 m_adj(m, -IEEE80211_WEP_CRCLEN); 1165 wh = mtod(m, struct ieee80211_frame *); 1166 } 1167 1168 if (sc->sc_drvbpf != NULL) { 1169 struct iwi_rx_radiotap_header *tap = &sc->sc_rxtap; 1170 1171 tap->wr_flags = 0; 1172 tap->wr_rate = frame->rate; 1173 tap->wr_chan_freq = 1174 htole16(ic->ic_channels[frame->chan].ic_freq); 1175 tap->wr_chan_flags = 1176 htole16(ic->ic_channels[frame->chan].ic_flags); 1177 tap->wr_antsignal = frame->signal; 1178 tap->wr_antnoise = frame->noise; 1179 tap->wr_antenna = frame->antenna; 1180 1181 bpf_ptap(sc->sc_drvbpf, m, tap, sc->sc_rxtap_len); 1182 } 1183 1184 if (ic->ic_state == IEEE80211_S_SCAN) 1185 iwi_fix_channel(sc, m); 1186 1187 if (ic->ic_opmode != IEEE80211_M_STA) { 1188 ni = ieee80211_find_node(ic, wh->i_addr2); 1189 if (ni == NULL) 1190 ni = ieee80211_ref_node(ic->ic_bss); 1191 } else 1192 ni = ieee80211_ref_node(ic->ic_bss); 1193 1194 /* Send the frame to the upper layer */ 1195 ieee80211_input(ifp, m, ni, IWI_RSSIDBM2RAW(frame->rssi_dbm), 0); 1196 1197 if (ni == ic->ic_bss) 1198 ieee80211_unref_node(&ni); 1199 else 1200 ieee80211_free_node(ic, ni); 1201 1202 buf->m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR); 1203 if (buf->m == NULL) { 1204 device_printf(sc->sc_dev, "could not allocate rx mbuf\n"); 1205 return; 1206 } 1207 1208 error = bus_dmamap_load(sc->rx_buf_dmat, buf->map, mtod(buf->m, void *), 1209 MCLBYTES, iwi_dma_map_addr, &buf->physaddr, 0); 1210 if (error != 0) { 1211 device_printf(sc->sc_dev, "could not load rx buf DMA map\n"); 1212 m_freem(buf->m); 1213 buf->m = NULL; 1214 return; 1215 } 1216 1217 CSR_WRITE_4(sc, IWI_CSR_RX_BASE + i * 4, buf->physaddr); 1218 } 1219 1220 static void 1221 iwi_notification_intr(struct iwi_softc *sc, struct iwi_notif *notif) 1222 { 1223 struct ieee80211com *ic = &sc->sc_ic; 1224 struct ifnet *ifp = &ic->ic_if; 1225 struct iwi_notif_scan_channel *chan; 1226 struct iwi_notif_scan_complete *scan; 1227 struct iwi_notif_authentication *auth; 1228 struct iwi_notif_association *assoc; 1229 1230 switch (notif->type) { 1231 case IWI_NOTIF_TYPE_SCAN_CHANNEL: 1232 chan = (struct iwi_notif_scan_channel *)(notif + 1); 1233 1234 DPRINTFN(2, ("Scan channel (%u)\n", chan->nchan)); 1235 break; 1236 1237 case IWI_NOTIF_TYPE_SCAN_COMPLETE: 1238 scan = (struct iwi_notif_scan_complete *)(notif + 1); 1239 1240 DPRINTFN(2, ("Scan completed (%u, %u)\n", scan->nchan, 1241 scan->status)); 1242 1243 sc->flags &= ~(IWI_FLAG_SCANNING); 1244 sc->flags |= IWI_FLAG_SCAN_COMPLETE; 1245 1246 if ( sc->flags & IWI_FLAG_SCAN_ABORT ) { 1247 sc->flags &= ~(IWI_FLAG_SCAN_ABORT); 1248 wakeup(IWI_FW_SCAN_COMPLETED(sc)); 1249 } else { 1250 ieee80211_end_scan(ifp); 1251 wakeup(IWI_FW_SCAN_COMPLETED(sc)); 1252 } 1253 break; 1254 1255 case IWI_NOTIF_TYPE_AUTHENTICATION: 1256 auth = (struct iwi_notif_authentication *)(notif + 1); 1257 1258 DPRINTFN(2, ("Authentication (%u)\n", auth->state)); 1259 1260 switch (auth->state) { 1261 case IWI_AUTHENTICATED: 1262 ieee80211_new_state(ic, IEEE80211_S_ASSOC, -1); 1263 break; 1264 1265 case IWI_DEAUTHENTICATED: 1266 ieee80211_begin_scan(ifp);/* not necessary */ 1267 break; 1268 1269 default: 1270 device_printf(sc->sc_dev, 1271 "unknown authentication state %u\n", auth->state); 1272 } 1273 break; 1274 1275 case IWI_NOTIF_TYPE_ASSOCIATION: 1276 assoc = (struct iwi_notif_association *)(notif + 1); 1277 1278 DPRINTFN(2, ("Association (%u, %u)\n", assoc->state, 1279 assoc->status)); 1280 1281 switch (assoc->state) { 1282 case IWI_ASSOCIATED: 1283 sc->flags |= IWI_FLAG_ASSOCIATED; 1284 ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 1285 break; 1286 1287 case IWI_DEASSOCIATED: 1288 sc->flags &= ~(IWI_FLAG_ASSOCIATED); 1289 wakeup(IWI_FW_DEASSOCIATED(sc)); 1290 ieee80211_begin_scan(ifp);/* probably not necessary */ 1291 break; 1292 1293 default: 1294 device_printf(sc->sc_dev, 1295 "unknown association state %u\n", assoc->state); 1296 } 1297 break; 1298 1299 case IWI_NOTIF_TYPE_CALIBRATION: 1300 DPRINTFN(5, ("Notification calib (%u)\n", notif->type)); 1301 break; 1302 case IWI_NOTIF_TYPE_BEACON: 1303 DPRINTFN(5, ("Notification beacon (%u)\n", notif->type)); 1304 break; 1305 case IWI_NOTIF_TYPE_NOISE: 1306 DPRINTFN(5, ("Notification noise (%u)\n", notif->type)); 1307 break; 1308 1309 default: 1310 device_printf(sc->sc_dev, "unknown notification type %u\n", 1311 notif->type); 1312 } 1313 } 1314 1315 static void 1316 iwi_rx_intr(struct iwi_softc *sc) 1317 { 1318 struct iwi_rx_buf *buf; 1319 struct iwi_hdr *hdr; 1320 u_int32_t r, i; 1321 1322 r = CSR_READ_4(sc, IWI_CSR_RX_READ_INDEX); 1323 1324 for (i = (sc->rx_cur + 1) % IWI_RX_RING_SIZE; i != r; 1325 i = (i + 1) % IWI_RX_RING_SIZE) { 1326 1327 buf = &sc->rx_buf[i]; 1328 1329 bus_dmamap_sync(sc->rx_buf_dmat, buf->map, 1330 BUS_DMASYNC_POSTREAD); 1331 1332 hdr = mtod(buf->m, struct iwi_hdr *); 1333 1334 switch (hdr->type) { 1335 case IWI_HDR_TYPE_FRAME: 1336 iwi_frame_intr(sc, buf, i, 1337 (struct iwi_frame *)(hdr + 1)); 1338 break; 1339 1340 case IWI_HDR_TYPE_NOTIF: 1341 iwi_notification_intr(sc, 1342 (struct iwi_notif *)(hdr + 1)); 1343 break; 1344 1345 default: 1346 device_printf(sc->sc_dev, "unknown hdr type %u\n", 1347 hdr->type); 1348 } 1349 } 1350 1351 /* Tell the firmware what we have processed */ 1352 sc->rx_cur = (r == 0) ? IWI_RX_RING_SIZE - 1 : r - 1; 1353 CSR_WRITE_4(sc, IWI_CSR_RX_WRITE_INDEX, sc->rx_cur); 1354 } 1355 1356 static void 1357 iwi_tx_intr(struct iwi_softc *sc) 1358 { 1359 struct ieee80211com *ic = &sc->sc_ic; 1360 struct ifnet *ifp = &ic->ic_if; 1361 struct iwi_tx_buf *buf; 1362 u_int32_t r, i; 1363 1364 r = CSR_READ_4(sc, IWI_CSR_TX1_READ_INDEX); 1365 #if notyet 1366 bus_dmamap_sync(sc->tx_ring_dmat, sc->tx_ring_map, BUS_DMASYNC_POSTWRITE); 1367 #endif 1368 1369 for (i = (sc->tx_old + 1) % IWI_TX_RING_SIZE; i != r; 1370 i = (i + 1) % IWI_TX_RING_SIZE) { 1371 1372 buf = &sc->tx_buf[i]; 1373 1374 bus_dmamap_sync(sc->tx_buf_dmat, buf->map, 1375 BUS_DMASYNC_POSTWRITE); 1376 bus_dmamap_unload(sc->tx_buf_dmat, buf->map); 1377 m_freem(buf->m); 1378 buf->m = NULL; 1379 if (buf->ni != ic->ic_bss) 1380 ieee80211_free_node(ic, buf->ni); 1381 buf->ni = NULL; 1382 1383 sc->tx_queued--; 1384 1385 /* kill watchdog timer */ 1386 sc->sc_tx_timer = 0; 1387 } 1388 1389 /* Remember what the firmware has processed */ 1390 sc->tx_old = (r == 0) ? IWI_TX_RING_SIZE - 1 : r - 1; 1391 1392 /* Call start() since some buffer descriptors have been released */ 1393 ifp->if_flags &= ~IFF_OACTIVE; 1394 (*ifp->if_start)(ifp); 1395 } 1396 1397 static void 1398 iwi_intr(void *arg) 1399 { 1400 struct iwi_softc *sc = arg; 1401 struct ieee80211com *ic = &sc->sc_ic; 1402 struct ifnet *ifp = &ic->ic_if; 1403 u_int32_t r; 1404 IWI_LOCK_INFO; 1405 IWI_IPLLOCK_INFO; 1406 1407 IWI_IPLLOCK(sc); 1408 1409 if ((r = CSR_READ_4(sc, IWI_CSR_INTR)) == 0 || r == 0xffffffff) { 1410 IWI_IPLUNLOCK(sc); 1411 return; 1412 } 1413 1414 /* Disable interrupts */ 1415 CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, 0); 1416 1417 DPRINTFN(8, ("INTR!0x%08x\n", r)); 1418 1419 sc->flags &= ~(IWI_FLAG_RF_DISABLED); 1420 1421 if ( r & IWI_INTR_FATAL_ERROR ) { 1422 if ( !(sc->flags & (IWI_FLAG_RESET | IWI_FLAG_EXIT))) { 1423 sc->flags |= IWI_FLAG_RESET; 1424 wakeup(IWI_FW_WAKE_MONITOR(sc)); 1425 } 1426 } 1427 1428 if (r & IWI_INTR_PARITY_ERROR) { 1429 device_printf(sc->sc_dev, "fatal error\n"); 1430 sc->sc_ic.ic_if.if_flags &= ~IFF_UP; 1431 IWI_LOCK(sc); 1432 iwi_stop(sc); 1433 IWI_UNLOCK(sc); 1434 } 1435 1436 if (r & IWI_INTR_FW_INITED) { 1437 if (!(r & (IWI_INTR_FATAL_ERROR | IWI_INTR_PARITY_ERROR))) 1438 wakeup(IWI_FW_INITIALIZED(sc)); 1439 } 1440 1441 if (r & IWI_INTR_RADIO_OFF) { 1442 DPRINTF(("radio transmitter off\n")); 1443 sc->sc_ic.ic_if.if_flags &= ~IFF_UP; 1444 IWI_LOCK(sc); 1445 iwi_stop(sc); 1446 IWI_UNLOCK(sc); 1447 sc->flags |= IWI_FLAG_RF_DISABLED; 1448 } 1449 1450 if (r & IWI_INTR_RX_TRANSFER) 1451 iwi_rx_intr(sc); 1452 1453 if (r & IWI_INTR_CMD_TRANSFER) 1454 wakeup(IWI_FW_CMD_ACKED(sc)); 1455 1456 if (r & IWI_INTR_TX1_TRANSFER) 1457 iwi_tx_intr(sc); 1458 1459 if (r & ~(IWI_HANDLED_INTR_MASK)) 1460 device_printf(sc->sc_dev, 1461 "unhandled interrupt(s) INTR!0x%08x\n", 1462 r & ~(IWI_HANDLED_INTR_MASK)); 1463 1464 /* Acknowledge interrupts */ 1465 CSR_WRITE_4(sc, IWI_CSR_INTR, r); 1466 1467 /* Re-enable interrupts */ 1468 CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, IWI_INTR_MASK); 1469 1470 IWI_IPLUNLOCK(sc); 1471 1472 if ((ifp->if_flags & IFF_RUNNING) && !ifq_is_empty(&ifp->if_snd)) 1473 iwi_start(ifp); 1474 } 1475 1476 struct iwi_dma_mapping { 1477 bus_dma_segment_t segs[IWI_MAX_NSEG]; 1478 int nseg; 1479 bus_size_t mapsize; 1480 }; 1481 1482 static void 1483 iwi_dma_map_buf(void *arg, bus_dma_segment_t *segs, int nseg, 1484 bus_size_t mapsize, int error) 1485 { 1486 struct iwi_dma_mapping *map = arg; 1487 1488 if (error != 0) 1489 return; 1490 1491 KASSERT(nseg <= IWI_MAX_NSEG, ("too many DMA segments %d", nseg)); 1492 1493 bcopy(segs, map->segs, nseg * sizeof (bus_dma_segment_t)); 1494 map->nseg = nseg; 1495 map->mapsize = mapsize; 1496 } 1497 1498 static void 1499 iwi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg __unused, int error) 1500 { 1501 if (error != 0) { 1502 printf("iwi: fatal DMA mapping error !!!\n"); 1503 return; 1504 } 1505 1506 KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg)); 1507 1508 *(bus_addr_t *)arg = segs[0].ds_addr; 1509 } 1510 1511 static int 1512 iwi_cmd(struct iwi_softc *sc, u_int8_t type, void *data, u_int8_t len, 1513 int async) 1514 { 1515 struct iwi_cmd_desc *desc; 1516 1517 DPRINTFN(2, ("TX!CMD!%u!%u\n", type, len)); 1518 1519 desc = &sc->cmd_desc[sc->cmd_cur]; 1520 desc->hdr.type = IWI_HDR_TYPE_COMMAND; 1521 desc->hdr.flags = IWI_HDR_FLAG_IRQ; 1522 desc->type = type; 1523 desc->len = len; 1524 bcopy(data, desc->data, len); 1525 1526 bus_dmamap_sync(sc->cmd_ring_dmat, sc->cmd_ring_map, 1527 BUS_DMASYNC_PREWRITE); 1528 1529 sc->cmd_cur = (sc->cmd_cur + 1) % IWI_CMD_RING_SIZE; 1530 CSR_WRITE_4(sc, IWI_CSR_CMD_WRITE_INDEX, sc->cmd_cur); 1531 1532 return async ? 0 : tsleep( IWI_FW_CMD_ACKED(sc), 0, "iwicmd", hz); 1533 } 1534 1535 static int 1536 iwi_tx_start(struct ifnet *ifp, struct mbuf *m0, struct ieee80211_node *ni) 1537 { 1538 struct iwi_softc *sc = ifp->if_softc; 1539 struct ieee80211com *ic = &sc->sc_ic; 1540 struct ieee80211_frame *wh; 1541 struct iwi_tx_buf *buf; 1542 struct iwi_tx_desc *desc; 1543 struct iwi_dma_mapping map; 1544 struct mbuf *mnew; 1545 u_int32_t id = 0; 1546 int error, i; 1547 IWI_IPLLOCK_INFO; /* XXX still need old ipl locking mech. here */ 1548 IWI_IPLLOCK(sc); 1549 1550 if (sc->sc_drvbpf != NULL) { 1551 struct iwi_tx_radiotap_header *tap = &sc->sc_txtap; 1552 1553 tap->wt_flags = 0; 1554 tap->wt_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq); 1555 tap->wt_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags); 1556 1557 bpf_ptap(sc->sc_drvbpf, m0, tap, sc->sc_txtap_len); 1558 } 1559 1560 buf = &sc->tx_buf[sc->tx_cur]; 1561 desc = &sc->tx_desc[sc->tx_cur]; 1562 1563 wh = mtod(m0, struct ieee80211_frame *); 1564 1565 if ( (id = iwi_find_station( sc, wh->i_addr1 ) ) == 0xff ) 1566 id = iwi_cache_station( sc, wh->i_addr1 ); 1567 1568 bzero( desc, sizeof (struct iwi_tx_desc) ); 1569 desc->station_number = id; 1570 1571 /* trim IEEE802.11 header */ 1572 m_adj(m0, sizeof (struct ieee80211_frame)); 1573 1574 error = bus_dmamap_load_mbuf(sc->tx_buf_dmat, buf->map, m0, 1575 iwi_dma_map_buf, &map, BUS_DMA_NOWAIT); 1576 if (error != 0 && error != EFBIG) { 1577 device_printf(sc->sc_dev, "could not map mbuf (error %d)\n", 1578 error); 1579 m_freem(m0); 1580 IWI_IPLUNLOCK(sc); 1581 return error; 1582 } 1583 if (error != 0) { 1584 mnew = m_defrag(m0, MB_DONTWAIT); 1585 if (mnew == NULL) { 1586 device_printf(sc->sc_dev, 1587 "could not defragment mbuf\n"); 1588 m_freem(m0); 1589 IWI_IPLUNLOCK(sc); 1590 return ENOBUFS; 1591 } 1592 m0 = mnew; 1593 1594 error = bus_dmamap_load_mbuf(sc->tx_buf_dmat, buf->map, m0, 1595 iwi_dma_map_buf, &map, BUS_DMA_NOWAIT); 1596 if (error != 0) { 1597 device_printf(sc->sc_dev, 1598 "could not map mbuf (error %d)\n", error); 1599 m_freem(m0); 1600 IWI_IPLUNLOCK(sc); 1601 return error; 1602 } 1603 } 1604 1605 buf->m = m0; 1606 buf->ni = ni; 1607 1608 desc->hdr.type = IWI_HDR_TYPE_DATA; 1609 desc->hdr.flags = IWI_HDR_FLAG_IRQ; 1610 desc->cmd = IWI_DATA_CMD_TX; 1611 desc->len = htole16(m0->m_pkthdr.len); 1612 desc->flags = 0; 1613 if (ic->ic_opmode == IEEE80211_M_IBSS) { 1614 if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) 1615 desc->flags |= IWI_DATA_FLAG_NEED_ACK; 1616 } else if (!IEEE80211_IS_MULTICAST(wh->i_addr3)) 1617 desc->flags |= IWI_DATA_FLAG_NEED_ACK; 1618 1619 if (ic->ic_flags & IEEE80211_F_WEPON) { 1620 wh->i_fc[1] |= IEEE80211_FC1_WEP; 1621 desc->wep_txkey = ic->ic_wep_txkey; 1622 } else 1623 desc->flags |= IWI_DATA_FLAG_NO_WEP; 1624 1625 if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 1626 desc->flags |= IWI_DATA_FLAG_SHPREAMBLE; 1627 1628 bcopy(wh, &desc->wh, sizeof (struct ieee80211_frame)); 1629 desc->nseg = htole32(map.nseg); 1630 for (i = 0; i < map.nseg; i++) { 1631 desc->seg_addr[i] = htole32(map.segs[i].ds_addr); 1632 desc->seg_len[i] = htole32(map.segs[i].ds_len); 1633 } 1634 1635 bus_dmamap_sync(sc->tx_buf_dmat, buf->map, BUS_DMASYNC_PREWRITE); 1636 bus_dmamap_sync(sc->tx_ring_dmat, sc->tx_ring_map, 1637 BUS_DMASYNC_PREWRITE); 1638 1639 DPRINTFN(5, ("TX!DATA!%u!%u\n", desc->len, desc->nseg)); 1640 1641 /* Inform firmware about this new packet */ 1642 sc->tx_queued++; 1643 sc->tx_cur = (sc->tx_cur + 1) % IWI_TX_RING_SIZE; 1644 CSR_WRITE_4(sc, IWI_CSR_TX1_WRITE_INDEX, sc->tx_cur); 1645 1646 IWI_IPLUNLOCK(sc); 1647 return 0; 1648 } 1649 1650 static void 1651 iwi_start(struct ifnet *ifp) 1652 { 1653 struct iwi_softc *sc = ifp->if_softc; 1654 struct ieee80211com *ic = &sc->sc_ic; 1655 struct mbuf *m0; 1656 struct ieee80211_node *ni; 1657 1658 if (ic->ic_state != IEEE80211_S_RUN) { 1659 return; 1660 } 1661 1662 for (;;) { 1663 m0 = ifq_poll(&ifp->if_snd); 1664 if (m0 == NULL) 1665 break; 1666 1667 if (sc->tx_queued >= IWI_TX_RING_SIZE - 4) { 1668 ifp->if_flags |= IFF_OACTIVE; 1669 break; 1670 } 1671 1672 m0 = ifq_dequeue(&ifp->if_snd); 1673 1674 #if NBPFILTER > 0 1675 BPF_MTAP(ifp, m0); 1676 #endif 1677 1678 m0 = ieee80211_encap(ifp, m0, &ni); 1679 if (m0 == NULL) 1680 continue; 1681 1682 if (ic->ic_rawbpf != NULL) 1683 bpf_mtap(ic->ic_rawbpf, m0); 1684 1685 if (iwi_tx_start(ifp, m0, ni) != 0) { 1686 if (ni != NULL && ni != ic->ic_bss) 1687 ieee80211_free_node(ic, ni); 1688 break; 1689 } 1690 1691 /* start watchdog timer */ 1692 sc->sc_tx_timer = 5; 1693 ifp->if_timer = 1; 1694 } 1695 1696 } 1697 1698 static void 1699 iwi_watchdog(struct ifnet *ifp) 1700 { 1701 struct iwi_softc *sc = ifp->if_softc; 1702 1703 ifp->if_timer = 0; 1704 1705 if (sc->sc_tx_timer > 0) { 1706 if (--sc->sc_tx_timer == 0) { 1707 if_printf(ifp, "device timeout\n"); 1708 wakeup(IWI_FW_WAKE_MONITOR(sc)); 1709 return; 1710 } 1711 ifp->if_timer = 1; 1712 } 1713 1714 ieee80211_watchdog(ifp); 1715 } 1716 1717 1718 static int 1719 iwi_wi_ioctl_get(struct ifnet *ifp, caddr_t data) 1720 { 1721 struct wi_req wreq; 1722 struct ifreq *ifr; 1723 struct iwi_softc *sc; 1724 int error; 1725 1726 sc = ifp->if_softc; 1727 ifr = (struct ifreq *)data; 1728 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq)); 1729 if (error) 1730 return (error); 1731 1732 switch (wreq.wi_type) { 1733 case WI_RID_READ_APS: 1734 ieee80211_begin_scan(ifp); 1735 (void) tsleep(IWI_FW_SCAN_COMPLETED(sc), 1736 PPAUSE|PCATCH, "ssidscan", hz * 2); 1737 ieee80211_end_scan(ifp); 1738 break; 1739 default: 1740 error = ENOTTY; 1741 break; 1742 } 1743 return (error); 1744 } 1745 1746 1747 1748 1749 static int 1750 iwi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr) 1751 { 1752 struct iwi_softc *sc = ifp->if_softc; 1753 struct ifreq *ifr; 1754 struct ieee80211req *ireq; 1755 struct ifaddr *ifa; 1756 int error = 0; 1757 IWI_LOCK_INFO; 1758 1759 IWI_LOCK(sc); 1760 1761 switch (cmd) { 1762 case SIOCSIFADDR: 1763 /* 1764 * Handle this here instead of in net80211_ioctl.c 1765 * so that we can lock (IWI_LOCK) the call to 1766 * iwi_init(). 1767 */ 1768 ifa = (struct ifaddr *) data; 1769 switch (ifa->ifa_addr->sa_family) { 1770 #ifdef INET 1771 case AF_INET: 1772 if ((ifp->if_flags & IFF_UP) == 0) { 1773 ifp->if_flags |= IFF_UP; 1774 ifp->if_init(ifp->if_softc); 1775 } 1776 arp_ifinit(ifp, ifa); 1777 break; 1778 #endif 1779 #ifdef IPX 1780 #warning "IPX support has not been tested" 1781 /* 1782 * XXX - This code is probably wrong, 1783 * but has been copied many times. 1784 */ 1785 case AF_IPX: { 1786 struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr); 1787 struct arpcom *ac = (struct arpcom *)ifp; 1788 1789 if (ipx_nullhost(*ina)) 1790 ina->x_host = *(union ipx_host *) ac->ac_enaddr; 1791 else 1792 bcopy((caddr_t) ina->x_host.c_host, 1793 (caddr_t) ac->ac_enaddr, 1794 sizeof(ac->ac_enaddr)); 1795 /* fall thru... */ 1796 } 1797 #endif 1798 default: 1799 if ((ifp->if_flags & IFF_UP) == 0) { 1800 ifp->if_flags |= IFF_UP; 1801 ifp->if_init(ifp->if_softc); 1802 } 1803 break; 1804 } 1805 break; 1806 1807 case SIOCSIFFLAGS: 1808 if (ifp->if_flags & IFF_UP) { 1809 if (!(ifp->if_flags & IFF_RUNNING)) { 1810 iwi_init(sc); 1811 error = tsleep(IWI_FW_CMD_ACKED(sc), 0, 1812 "iwirun", hz); 1813 } 1814 } else { 1815 if (ifp->if_flags & IFF_RUNNING) { 1816 iwi_stop(sc); 1817 } 1818 } 1819 break; 1820 1821 case SIOCSLOADFW: 1822 case SIOCSLOADIBSSFW: 1823 /* only super-user can do that! */ 1824 if ((error = suser(curthread)) != 0) 1825 break; 1826 1827 ifr = (struct ifreq *)data; 1828 error = iwi_cache_firmware(sc, ifr->ifr_data, 1829 (cmd == SIOCSLOADIBSSFW) ? 1 : 0); 1830 break; 1831 1832 case SIOCSKILLFW: 1833 /* only super-user can do that! */ 1834 if ((error = suser(curthread)) != 0) 1835 break; 1836 1837 ifp->if_flags &= ~IFF_UP; 1838 iwi_stop(sc); 1839 iwi_free_firmware(sc); 1840 break; 1841 1842 case SIOCG80211: 1843 ireq = (struct ieee80211req *)data; 1844 switch (ireq->i_type) { 1845 case IEEE80211_IOC_AUTHMODE: 1846 ireq->i_val = sc->authmode; 1847 break; 1848 1849 default: 1850 error = ieee80211_ioctl(ifp, cmd, data, cr); 1851 } 1852 break; 1853 1854 case SIOCS80211: 1855 /* only super-user can do that! */ 1856 if ((error = suser(curthread)) != 0) 1857 break; 1858 1859 ireq = (struct ieee80211req *)data; 1860 switch (ireq->i_type) { 1861 case IEEE80211_IOC_AUTHMODE: 1862 sc->authmode = ireq->i_val; 1863 break; 1864 1865 default: 1866 error = ieee80211_ioctl(ifp, cmd, data, cr); 1867 } 1868 break; 1869 case SIOCGIFGENERIC: 1870 if (sc->flags & IWI_FLAG_FW_INITED) { 1871 error = iwi_wi_ioctl_get(ifp, data); 1872 if (! error) 1873 error = ieee80211_ioctl(ifp, cmd, data, cr); 1874 } else 1875 error = ENOTTY; 1876 if (error != ENOTTY) 1877 break; 1878 1879 default: 1880 error = ieee80211_ioctl(ifp, cmd, data, cr); 1881 } 1882 1883 if (error == ENETRESET) { 1884 error = 0; 1885 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == 1886 (IFF_UP | IFF_RUNNING)) { 1887 iwi_init(sc); 1888 error = tsleep(IWI_FW_CMD_ACKED(sc), 0, "iwirun", hz); 1889 } 1890 } 1891 1892 IWI_UNLOCK(sc); 1893 1894 return error; 1895 } 1896 1897 static int 1898 iwi_abort_scan( struct iwi_softc *sc ) 1899 { 1900 sc->flags |= IWI_FLAG_SCAN_ABORT; 1901 return iwi_cmd(sc, IWI_CMD_SCAN_ABORT, NULL, 0, 1); 1902 } 1903 1904 static void 1905 iwi_stop_master(struct iwi_softc *sc) 1906 { 1907 int ntries; 1908 1909 /* 1910 * If the master is busy scanning, we will occasionally 1911 * timeout waiting for it (the master) to stop. Make the 1912 * 'stopping' process more robust by ceasing all scans 1913 * prior to asking for the stop. 1914 */ 1915 if ( ( sc->flags & IWI_FLAG_SCANNING ) && 1916 !( sc->flags & IWI_FLAG_RF_DISABLED ) ) { 1917 iwi_abort_scan(sc); 1918 if (( sc->flags & IWI_FLAG_SCAN_ABORT ) && 1919 !( sc->flags & IWI_FLAG_RF_DISABLED )) { 1920 (void) tsleep(IWI_FW_SCAN_COMPLETED(sc), 0, 1921 "iwiabr", hz); 1922 } 1923 } 1924 /* Disable interrupts */ 1925 1926 CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, 0); 1927 1928 CSR_WRITE_4(sc, IWI_CSR_RST, IWI_RST_STOP_MASTER); 1929 for (ntries = 0; ntries < 5; ntries++) { 1930 if (CSR_READ_4(sc, IWI_CSR_RST) & IWI_RST_MASTER_DISABLED) 1931 break; 1932 DELAY(10); 1933 } 1934 if (ntries == 5 && sc->debug_level > 0) 1935 device_printf(sc->sc_dev, "timeout waiting for master\n"); 1936 1937 CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) | 1938 IWI_RST_PRINCETON_RESET); 1939 1940 sc->flags &= ~IWI_FLAG_FW_INITED; 1941 } 1942 1943 static int 1944 iwi_reset(struct iwi_softc *sc) 1945 { 1946 int i, ntries; 1947 1948 iwi_stop_master(sc); 1949 1950 /* Move adapter to D0 state */ 1951 CSR_WRITE_4(sc, IWI_CSR_CTL, CSR_READ_4(sc, IWI_CSR_CTL) | 1952 IWI_CTL_INIT); 1953 1954 /* Initialize Phase-Locked Level (PLL) */ 1955 CSR_WRITE_4(sc, IWI_CSR_READ_INT, IWI_READ_INT_INIT_HOST); 1956 1957 /* Wait for clock stabilization */ 1958 for (ntries = 0; ntries < 1000; ntries++) { 1959 if (CSR_READ_4(sc, IWI_CSR_CTL) & IWI_CTL_CLOCK_READY) 1960 break; 1961 DELAY(200); 1962 } 1963 if (ntries == 1000) { 1964 return EIO; 1965 } 1966 1967 CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) | 1968 IWI_RST_SW_RESET); 1969 1970 DELAY(10); 1971 1972 CSR_WRITE_4(sc, IWI_CSR_CTL, CSR_READ_4(sc, IWI_CSR_CTL) | 1973 IWI_CTL_INIT); 1974 1975 1976 /* Clear NIC memory */ 1977 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_ADDR, 0); 1978 1979 for (i = 0; i < 0xc000; i++) { 1980 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, 0); 1981 } 1982 1983 sc->num_stations = 0; 1984 return 0; 1985 } 1986 1987 static int 1988 iwi_load_ucode(struct iwi_softc *sc, void *uc, int size) 1989 { 1990 u_int16_t *w; 1991 int ntries, i; 1992 1993 CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) | 1994 IWI_RST_STOP_MASTER); 1995 for (ntries = 0; ntries < 5; ntries++) { 1996 if (CSR_READ_4(sc, IWI_CSR_RST) & IWI_RST_MASTER_DISABLED) 1997 break; 1998 DELAY(10); 1999 } 2000 if (ntries == 5) { 2001 device_printf(sc->sc_dev, "timeout waiting for master\n"); 2002 return EIO; 2003 } 2004 2005 MEM_WRITE_4(sc, 0x3000e0, 0x80000000); 2006 DELAY(5000); 2007 CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) & 2008 ~IWI_RST_PRINCETON_RESET); 2009 DELAY(5000); 2010 MEM_WRITE_4(sc, 0x3000e0, 0); 2011 DELAY(1000); 2012 MEM_WRITE_4(sc, 0x300004, 1); 2013 DELAY(1000); 2014 MEM_WRITE_4(sc, 0x300004, 0); 2015 DELAY(1000); 2016 MEM_WRITE_1(sc, 0x200000, 0x00); 2017 MEM_WRITE_1(sc, 0x200000, 0x40); 2018 DELAY(1000); 2019 2020 /* Adapter is buggy, we must set the address for each word */ 2021 for (w = uc; size > 0; w++, size -= 2) 2022 MEM_WRITE_2(sc, 0x200010, *w); 2023 2024 MEM_WRITE_1(sc, 0x200000, 0x00); 2025 MEM_WRITE_1(sc, 0x200000, 0x80); 2026 2027 /* Wait until we get a response in the uc queue */ 2028 for (ntries = 0; ntries < 100; ntries++) { 2029 if (MEM_READ_1(sc, 0x200000) & 1) 2030 break; 2031 DELAY(100); 2032 } 2033 if (ntries == 100) { 2034 device_printf(sc->sc_dev, 2035 "timeout waiting for ucode to initialize\n"); 2036 return EIO; 2037 } 2038 2039 /* Empty the uc queue or the firmware will not initialize properly */ 2040 for (i = 0; i < 7; i++) 2041 MEM_READ_4(sc, 0x200004); 2042 2043 MEM_WRITE_1(sc, 0x200000, 0x00); 2044 2045 return 0; 2046 } 2047 2048 /* macro to handle unaligned little endian data in firmware image */ 2049 #define GETLE32(p) ((p)[0] | (p)[1] << 8 | (p)[2] << 16 | (p)[3] << 24) 2050 static int 2051 iwi_load_firmware(struct iwi_softc *sc, void *fw, int size) 2052 { 2053 bus_dma_tag_t dmat; 2054 bus_dmamap_t map; 2055 bus_addr_t physaddr; 2056 void *virtaddr; 2057 u_char *p, *end; 2058 u_int32_t sentinel, ctl, src, dst, sum, len, mlen; 2059 int ntries, error = 0; 2060 2061 sc->flags &= ~(IWI_FLAG_FW_INITED); 2062 2063 /* Allocate DMA memory for storing firmware image */ 2064 error = bus_dma_tag_create(sc->iwi_parent_tag, 1, 0, BUS_SPACE_MAXADDR_32BIT, 2065 BUS_SPACE_MAXADDR, NULL, NULL, size, 1, size, BUS_DMA_ALLOCNOW, &dmat); 2066 if (error != 0) { 2067 device_printf(sc->sc_dev, 2068 "could not create firmware DMA tag\n"); 2069 goto fail1; 2070 } 2071 2072 /* 2073 * We cannot map fw directly because of some hardware constraints on 2074 * the mapping address. 2075 */ 2076 error = bus_dmamem_alloc(dmat, &virtaddr, BUS_DMA_WAITOK, &map); 2077 if (error != 0) { 2078 device_printf(sc->sc_dev, 2079 "could not allocate firmware DMA memory\n"); 2080 goto fail2; 2081 } 2082 2083 error = bus_dmamap_load(dmat, map, virtaddr, size, iwi_dma_map_addr, 2084 &physaddr, 0); 2085 if (error != 0) { 2086 device_printf(sc->sc_dev, "could not load firmware DMA map\n"); 2087 goto fail3; 2088 } 2089 2090 /* Copy firmware image to DMA memory */ 2091 bcopy(fw, virtaddr, size); 2092 2093 /* Make sure the adapter will get up-to-date values */ 2094 bus_dmamap_sync(dmat, map, BUS_DMASYNC_PREWRITE); 2095 2096 /* Tell the adapter where the command blocks are stored */ 2097 MEM_WRITE_4(sc, 0x3000a0, 0x27000); 2098 2099 /* 2100 * Store command blocks into adapter's internal memory using register 2101 * indirections. The adapter will read the firmware image through DMA 2102 * using information stored in command blocks. 2103 */ 2104 src = physaddr; 2105 p = virtaddr; 2106 end = p + size; 2107 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_ADDR, 0x27000); 2108 2109 while (p < end) { 2110 dst = GETLE32(p); p += 4; src += 4; 2111 len = GETLE32(p); p += 4; src += 4; 2112 p += len; 2113 2114 while (len > 0) { 2115 mlen = min(len, IWI_CB_MAXDATALEN); 2116 2117 ctl = IWI_CB_DEFAULT_CTL | mlen; 2118 sum = ctl ^ src ^ dst; 2119 2120 /* Write a command block */ 2121 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, ctl); 2122 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, src); 2123 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, dst); 2124 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, sum); 2125 2126 src += mlen; 2127 dst += mlen; 2128 len -= mlen; 2129 } 2130 } 2131 2132 /* Write a fictive final command block (sentinel) */ 2133 sentinel = CSR_READ_4(sc, IWI_CSR_AUTOINC_ADDR); 2134 CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, 0); 2135 2136 CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) & 2137 ~(IWI_RST_MASTER_DISABLED | IWI_RST_STOP_MASTER)); 2138 2139 /* Tell the adapter to start processing command blocks */ 2140 MEM_WRITE_4(sc, 0x3000a4, 0x540100); 2141 2142 /* Wait until the adapter has processed all command blocks */ 2143 for (ntries = 0; ntries < 400; ntries++) { 2144 if (MEM_READ_4(sc, 0x3000d0) >= sentinel) 2145 break; 2146 DELAY(100); 2147 } 2148 if (ntries == 400) { 2149 device_printf(sc->sc_dev, 2150 "timeout processing command blocks\n"); 2151 error = EIO; 2152 goto fail4; 2153 } 2154 2155 2156 /* We're done with command blocks processing */ 2157 MEM_WRITE_4(sc, 0x3000a4, 0x540c00); 2158 2159 /* Allow interrupts so we know when the firmware is inited */ 2160 CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, IWI_INTR_MASK); 2161 2162 /* Tell the adapter to initialize the firmware */ 2163 CSR_WRITE_4(sc, IWI_CSR_RST, 0); 2164 CSR_WRITE_4(sc, IWI_CSR_CTL, CSR_READ_4(sc, IWI_CSR_CTL) | 2165 IWI_CTL_ALLOW_STANDBY); 2166 2167 /* Wait at most one second for firmware initialization to complete */ 2168 if ((error = tsleep(IWI_FW_INITIALIZED(sc), 0, "iwiini", hz)) != 0) { 2169 device_printf(sc->sc_dev, "timeout waiting for firmware " 2170 "initialization to complete\n"); 2171 goto fail4; 2172 } 2173 2174 fail4: bus_dmamap_sync(dmat, map, BUS_DMASYNC_POSTWRITE); 2175 bus_dmamap_unload(dmat, map); 2176 fail3: bus_dmamem_free(dmat, virtaddr, map); 2177 fail2: bus_dma_tag_destroy(dmat); 2178 fail1: 2179 return error; 2180 } 2181 2182 /* 2183 * Store firmware into kernel memory so we can download it when we need to, 2184 * e.g when the adapter wakes up from suspend mode. 2185 */ 2186 static int 2187 iwi_cache_firmware(struct iwi_softc *sc, void *data, int is_ibss) 2188 { 2189 struct iwi_firmware *kfw = &sc->fw; 2190 struct iwi_firmware ufw; 2191 int error; 2192 2193 iwi_free_firmware(sc); 2194 2195 /* 2196 * mutex(9): no mutexes should be held across functions which access 2197 * memory in userspace, such as copyin(9) [...] 2198 */ 2199 2200 if ((error = copyin(data, &ufw, sizeof ufw)) != 0) 2201 goto fail1; 2202 2203 kfw->boot_size = ufw.boot_size; 2204 kfw->ucode_size = ufw.ucode_size; 2205 kfw->main_size = ufw.main_size; 2206 2207 kfw->boot = malloc(kfw->boot_size, M_DEVBUF, M_WAITOK); 2208 if (kfw->boot == NULL) { 2209 error = ENOMEM; 2210 goto fail1; 2211 } 2212 2213 kfw->ucode = malloc(kfw->ucode_size, M_DEVBUF, M_WAITOK); 2214 if (kfw->ucode == NULL) { 2215 error = ENOMEM; 2216 goto fail2; 2217 } 2218 2219 kfw->main = malloc(kfw->main_size, M_DEVBUF, M_WAITOK); 2220 if (kfw->main == NULL) { 2221 error = ENOMEM; 2222 goto fail3; 2223 } 2224 2225 if ((error = copyin(ufw.boot, kfw->boot, kfw->boot_size)) != 0) 2226 goto fail4; 2227 2228 if ((error = copyin(ufw.ucode, kfw->ucode, kfw->ucode_size)) != 0) 2229 goto fail4; 2230 2231 if ((error = copyin(ufw.main, kfw->main, kfw->main_size)) != 0) 2232 goto fail4; 2233 2234 DPRINTF(("Firmware cached: boot %u, ucode %u, main %u\n", 2235 kfw->boot_size, kfw->ucode_size, kfw->main_size)); 2236 2237 2238 sc->flags |= IWI_FLAG_FW_CACHED; 2239 sc->flags |= is_ibss ? IWI_FLAG_FW_IBSS : 0; 2240 return 0; 2241 2242 fail4: free(kfw->boot, M_DEVBUF); 2243 fail3: free(kfw->ucode, M_DEVBUF); 2244 fail2: free(kfw->main, M_DEVBUF); 2245 fail1: 2246 2247 return error; 2248 } 2249 2250 static void 2251 iwi_free_firmware(struct iwi_softc *sc) 2252 { 2253 if (!(sc->flags & IWI_FLAG_FW_CACHED)) 2254 return; 2255 2256 free(sc->fw.boot, M_DEVBUF); 2257 free(sc->fw.ucode, M_DEVBUF); 2258 free(sc->fw.main, M_DEVBUF); 2259 2260 sc->flags &= ~( IWI_FLAG_FW_CACHED | IWI_FLAG_FW_IBSS ); 2261 } 2262 2263 static int 2264 iwi_adapter_config(struct iwi_softc *sc, int is_a, int cmd_wait) 2265 { 2266 struct iwi_configuration config; 2267 2268 bzero(&config, sizeof config); 2269 config.enable_multicast = 1; 2270 config.noise_reported = 1; 2271 2272 config.bg_autodetect = 2273 ( !(is_a) && 2274 ( sc->enable_bg_autodetect != 0 ) ) ? 1 : 0; /* default: on */ 2275 2276 config.bluetooth_coexistence = 2277 ( sc->enable_bt_coexist != 0 ) ? 1 : 0; /* default: on */ 2278 2279 config.enable_cts_to_self = 2280 ( sc->enable_cts_to_self > 0 ) ? 1 : 0; /* default: off */ 2281 2282 if (sc->antenna_diversity > 0 ) { /* default: BOTH */ 2283 switch( sc->antenna_diversity ) { 2284 case 1: case 3: 2285 config.antenna_diversity = sc->antenna_diversity; 2286 } 2287 } 2288 2289 config.disable_unicast_decryption = 2290 ( sc->disable_unicast_decryption != 0 ) ? 1 : 0; /* default: on */ 2291 2292 config.disable_multicast_decryption = 2293 ( sc->disable_multicast_decryption != 0 ) ? 1 : 0;/* default: on */ 2294 2295 2296 if ( sc->debug_level > 0 ) { 2297 printf("config.bluetooth_coexistence = %d\n", 2298 config.bluetooth_coexistence ); 2299 printf("config.bg_autodetect = %d\n", 2300 config.bg_autodetect ); 2301 printf("config.enable_cts_to_self = %d\n", 2302 config.enable_cts_to_self ); 2303 printf("config.antenna_diversity = %d\n", 2304 config.antenna_diversity ); 2305 printf("config.disable_unicast_decryption = %d\n", 2306 config.disable_unicast_decryption ); 2307 printf("config.disable_multicast_decryption = %d\n", 2308 config.disable_multicast_decryption ); 2309 printf("config.neg_best_rates_first = %d\n", 2310 sc->enable_neg_best_first ); 2311 } 2312 2313 return iwi_cmd(sc, IWI_CMD_SET_CONFIGURATION, &config, 2314 sizeof config, cmd_wait ); 2315 } 2316 2317 static int 2318 iwi_config(struct iwi_softc *sc) 2319 { 2320 struct ieee80211com *ic = &sc->sc_ic; 2321 struct ifnet *ifp = &ic->ic_if; 2322 struct iwi_rateset rs; 2323 struct iwi_txpower power; 2324 struct ieee80211_wepkey *k; 2325 struct iwi_wep_key wepkey; 2326 u_int32_t data; 2327 int error, i; 2328 2329 IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp)); 2330 DPRINTF(("Setting MAC address to %6D\n", ic->ic_myaddr, ":")); 2331 error = iwi_cmd(sc, IWI_CMD_SET_MAC_ADDRESS, ic->ic_myaddr, 2332 IEEE80211_ADDR_LEN, 0); 2333 if (error != 0) 2334 return error; 2335 2336 DPRINTF(("Configuring adapter\n")); 2337 if ((error = iwi_adapter_config(sc, 1, 0)) != 0) 2338 return error; 2339 2340 data = htole32(IWI_POWER_MODE_CAM); 2341 DPRINTF(("Setting power mode to %u\n", le32toh(data))); 2342 error = iwi_cmd(sc, IWI_CMD_SET_POWER_MODE, &data, sizeof data, 0); 2343 if (error != 0) 2344 return error; 2345 2346 data = htole32(ic->ic_rtsthreshold); 2347 DPRINTF(("Setting RTS threshold to %u\n", le32toh(data))); 2348 error = iwi_cmd(sc, IWI_CMD_SET_RTS_THRESHOLD, &data, sizeof data, 0); 2349 if (error != 0) 2350 return error; 2351 2352 if (ic->ic_opmode == IEEE80211_M_IBSS) { 2353 power.mode = IWI_MODE_11B; 2354 power.nchan = 11; 2355 for (i = 0; i < 11; i++) { 2356 power.chan[i].chan = i + 1; 2357 power.chan[i].power = IWI_TXPOWER_MAX; 2358 } 2359 DPRINTF(("Setting .11b channels tx power\n")); 2360 error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power, 2361 0); 2362 if (error != 0) 2363 return error; 2364 2365 power.mode = IWI_MODE_11G; 2366 DPRINTF(("Setting .11g channels tx power\n")); 2367 error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power, 2368 0); 2369 if (error != 0) 2370 return error; 2371 } 2372 2373 rs.mode = IWI_MODE_11G; 2374 rs.type = IWI_RATESET_TYPE_SUPPORTED; 2375 rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates; 2376 bcopy(ic->ic_sup_rates[IEEE80211_MODE_11G].rs_rates, rs.rates, 2377 rs.nrates); 2378 DPRINTF(("Setting .11bg supported rates (%u)\n", rs.nrates)); 2379 error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs, 0); 2380 if (error != 0) 2381 return error; 2382 2383 rs.mode = IWI_MODE_11A; 2384 rs.type = IWI_RATESET_TYPE_SUPPORTED; 2385 rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates; 2386 bcopy(ic->ic_sup_rates[IEEE80211_MODE_11A].rs_rates, rs.rates, 2387 rs.nrates); 2388 DPRINTF(("Setting .11a supported rates (%u)\n", rs.nrates)); 2389 error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs, 0); 2390 if (error != 0) 2391 return error; 2392 2393 data = htole32(arc4random()); 2394 DPRINTF(("Setting initialization vector to %u\n", le32toh(data))); 2395 error = iwi_cmd(sc, IWI_CMD_SET_IV, &data, sizeof data, 0); 2396 if (error != 0) 2397 return error; 2398 2399 if (ic->ic_flags & IEEE80211_F_WEPON) { 2400 k = ic->ic_nw_keys; 2401 for (i = 0; i < IEEE80211_WEP_NKID; i++, k++) { 2402 wepkey.cmd = IWI_WEP_KEY_CMD_SETKEY; 2403 wepkey.idx = i; 2404 wepkey.len = k->wk_len; 2405 bzero(wepkey.key, sizeof wepkey.key); 2406 bcopy(k->wk_key, wepkey.key, k->wk_len); 2407 DPRINTF(("Setting wep key index %u len %u\n", 2408 wepkey.idx, wepkey.len)); 2409 error = iwi_cmd(sc, IWI_CMD_SET_WEP_KEY, &wepkey, 2410 sizeof wepkey, 0); 2411 if (error != 0) 2412 return error; 2413 } 2414 } 2415 2416 /* Enable adapter */ 2417 DPRINTF(("Enabling adapter\n")); 2418 return iwi_cmd(sc, IWI_CMD_ENABLE, NULL, 0, 0); 2419 } 2420 2421 static int 2422 iwi_scan(struct iwi_softc *sc) 2423 { 2424 struct ieee80211com *ic = &sc->sc_ic; 2425 struct iwi_scan scan; 2426 u_int8_t *p; 2427 int i, count; 2428 int do_5ghz_scan = 0; 2429 2430 sc->scan_counter++; /* track the number of scans started */ 2431 2432 sc->flags |= IWI_FLAG_SCANNING; 2433 2434 bzero(&scan, sizeof scan); 2435 2436 /* 2437 * Alternate two broadcast scans with 2438 * two broadcast/direct scans. 2439 */ 2440 if ( sc->scan_counter & 2 ) { 2441 scan.type = IWI_SCAN_TYPE_BROADCAST_AND_DIRECT; 2442 scan.intval = htole16(100); 2443 } else { 2444 scan.type = IWI_SCAN_TYPE_BROADCAST; 2445 scan.intval = htole16(40); 2446 } 2447 2448 p = scan.channels; 2449 2450 /* 2451 * If we have .11a capable adapter, and 2452 * - we are in .11a mode, or 2453 * - we are in auto mode and this is an odd numbered scan 2454 * then do a 5GHz scan, otherwise do a 2GHz scan. 2455 */ 2456 if ( ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates > 0 ) { 2457 if (( ic->ic_curmode == IEEE80211_MODE_11A ) || 2458 (( ic->ic_curmode == IEEE80211_MODE_AUTO ) && 2459 ( sc->scan_counter & 1))) 2460 do_5ghz_scan = 1; 2461 } 2462 count = 0; 2463 if ( do_5ghz_scan ) { 2464 DPRINTF(("Scanning 5GHz band\n")); 2465 for (i = 0; i <= IEEE80211_CHAN_MAX; i++) { 2466 if (IEEE80211_IS_CHAN_5GHZ(&ic->ic_channels[i]) && 2467 isset(ic->ic_chan_active, i)) { 2468 *++p = i; 2469 count++; 2470 } 2471 } 2472 *(p - count) = IWI_CHAN_5GHZ | count; 2473 } else { 2474 DPRINTF(("Scanning 2GHz band\n")); 2475 for (i = 0; i <= IEEE80211_CHAN_MAX; i++) { 2476 if (IEEE80211_IS_CHAN_2GHZ(&ic->ic_channels[i]) && 2477 isset(ic->ic_chan_active, i)) { 2478 *++p = i; 2479 count++; 2480 } 2481 } 2482 *(p - count) = IWI_CHAN_2GHZ | count; 2483 } 2484 return iwi_cmd(sc, IWI_CMD_SCAN, &scan, sizeof scan, 1); 2485 } 2486 2487 static int 2488 iwi_auth_and_assoc(struct iwi_softc *sc) 2489 { 2490 struct ieee80211com *ic = &sc->sc_ic; 2491 struct ifnet *ifp = &ic->ic_if; 2492 struct ieee80211_node *ni = ic->ic_bss; 2493 struct iwi_rateset rs; 2494 u_int32_t data; 2495 int error, x; 2496 2497 if ( ( sc->flags & IWI_FLAG_FW_IBSS ) && 2498 !( ni->ni_capinfo & IEEE80211_CAPINFO_IBSS ) ) { 2499 return -1; /* IBSS F/W requires network ibss capability */ 2500 } 2501 2502 DPRINTF(("Configuring adapter\n")); 2503 if ((error = iwi_adapter_config(sc, 2504 IEEE80211_IS_CHAN_5GHZ(ni->ni_chan), 1)) != 0) 2505 return error; 2506 2507 #ifdef IWI_DEBUG 2508 if (sc->debug_level > 0) { 2509 printf("Setting ESSID to "); 2510 ieee80211_print_essid(ni->ni_essid, ni->ni_esslen); 2511 printf("\n"); 2512 } 2513 #endif 2514 error = iwi_cmd(sc, IWI_CMD_SET_ESSID, ni->ni_essid, ni->ni_esslen, 1); 2515 if (error != 0) 2516 return error; 2517 2518 /* the rate set has already been "negotiated" */ 2519 rs.mode = IEEE80211_IS_CHAN_5GHZ(ni->ni_chan) ? IWI_MODE_11A : 2520 IWI_MODE_11G; 2521 rs.type = IWI_RATESET_TYPE_NEGOTIATED; 2522 rs.nrates = ni->ni_rates.rs_nrates; 2523 if ( sc->enable_neg_best_first != 1 ) { 2524 bcopy(ni->ni_rates.rs_rates, rs.rates, rs.nrates); 2525 } else { 2526 for ( x = 0 ; x < rs.nrates; x++ ) { 2527 /* 2528 * Present the firmware with the most favourable 2529 * of the negotiated rates first. 2530 */ 2531 rs.rates[rs.nrates-x-1] = ni->ni_rates.rs_rates[x]; 2532 } 2533 } 2534 2535 if ( sc->debug_level > 0 ) { 2536 printf("Setting negotiated rates (%u) : ", rs.nrates); 2537 for ( x = 0 ; x < rs.nrates; x++ ) { 2538 printf("%d ", rs.rates[x]); 2539 } 2540 printf("\n"); 2541 } 2542 2543 error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs, 1); 2544 if (error != 0) 2545 return error; 2546 2547 data = htole32(ni->ni_rssi); 2548 DPRINTF(("Setting sensitivity to %d\n", (int8_t)ni->ni_rssi)); 2549 error = iwi_cmd(sc, IWI_CMD_SET_SENSITIVITY, &data, sizeof data, 1); 2550 if (error != 0) 2551 return error; 2552 2553 bzero(&sc->assoc, sizeof sc->assoc); 2554 sc->assoc.mode = IEEE80211_IS_CHAN_5GHZ(ni->ni_chan) ? IWI_MODE_11A : 2555 IWI_MODE_11G; 2556 sc->assoc.chan = ieee80211_chan2ieee(ic, ni->ni_chan); 2557 if (sc->authmode == IEEE80211_AUTH_SHARED) 2558 sc->assoc.auth = (ic->ic_wep_txkey << 4) | IWI_AUTH_SHARED; 2559 bcopy(ni->ni_tstamp, sc->assoc.tstamp, 8); 2560 sc->assoc.capinfo = htole16(ni->ni_capinfo); 2561 sc->assoc.lintval = htole16(ic->ic_lintval); 2562 sc->assoc.intval = htole16(ni->ni_intval); 2563 IEEE80211_ADDR_COPY(sc->assoc.bssid, ni->ni_bssid); 2564 if ( ic->ic_opmode == IEEE80211_M_IBSS ) 2565 IEEE80211_ADDR_COPY(sc->assoc.dst, ifp->if_broadcastaddr); 2566 else 2567 IEEE80211_ADDR_COPY(sc->assoc.dst, ni->ni_bssid); 2568 2569 DPRINTF(("Trying to associate to %6D channel %u auth %u\n", 2570 sc->assoc.bssid, ":", sc->assoc.chan, sc->assoc.auth)); 2571 return iwi_cmd(sc, IWI_CMD_ASSOCIATE, &sc->assoc, sizeof sc->assoc, 1); 2572 } 2573 2574 static void 2575 iwi_init(void *priv) 2576 { 2577 struct iwi_softc *sc = priv; 2578 struct ieee80211com *ic = &sc->sc_ic; 2579 struct ifnet *ifp = &ic->ic_if; 2580 struct iwi_firmware *fw = &sc->fw; 2581 int i; 2582 2583 /* exit immediately if firmware has not been ioctl'd */ 2584 if (!(sc->flags & IWI_FLAG_FW_CACHED)) { 2585 ifp->if_flags &= ~IFF_UP; 2586 return; 2587 } 2588 2589 iwi_stop(sc); 2590 2591 if (iwi_reset(sc) != 0) { 2592 device_printf(sc->sc_dev, "could not reset adapter\n"); 2593 goto fail; 2594 } 2595 2596 if (iwi_load_firmware(sc, fw->boot, fw->boot_size) != 0) { 2597 device_printf(sc->sc_dev, "could not load boot firmware\n"); 2598 goto fail; 2599 } 2600 2601 if (iwi_load_ucode(sc, fw->ucode, fw->ucode_size) != 0) { 2602 device_printf(sc->sc_dev, "could not load microcode\n"); 2603 goto fail; 2604 } 2605 2606 iwi_stop_master(sc); 2607 2608 sc->tx_cur = 0; 2609 sc->tx_queued = 0; 2610 sc->tx_old = IWI_TX_RING_SIZE - 1; 2611 sc->cmd_cur = 0; 2612 sc->rx_cur = IWI_RX_RING_SIZE - 1; 2613 2614 CSR_WRITE_4(sc, IWI_CSR_CMD_BASE, sc->cmd_ring_pa); 2615 CSR_WRITE_4(sc, IWI_CSR_CMD_SIZE, IWI_CMD_RING_SIZE); 2616 CSR_WRITE_4(sc, IWI_CSR_CMD_READ_INDEX, 0); 2617 CSR_WRITE_4(sc, IWI_CSR_CMD_WRITE_INDEX, sc->cmd_cur); 2618 2619 CSR_WRITE_4(sc, IWI_CSR_TX1_BASE, sc->tx_ring_pa); 2620 CSR_WRITE_4(sc, IWI_CSR_TX1_SIZE, IWI_TX_RING_SIZE); 2621 CSR_WRITE_4(sc, IWI_CSR_TX1_READ_INDEX, 0); 2622 CSR_WRITE_4(sc, IWI_CSR_TX1_WRITE_INDEX, sc->tx_cur); 2623 2624 CSR_WRITE_4(sc, IWI_CSR_TX2_BASE, sc->tx_ring_pa); 2625 CSR_WRITE_4(sc, IWI_CSR_TX2_SIZE, IWI_TX_RING_SIZE); 2626 CSR_WRITE_4(sc, IWI_CSR_TX2_READ_INDEX, 0); 2627 CSR_WRITE_4(sc, IWI_CSR_TX2_WRITE_INDEX, 0); 2628 2629 CSR_WRITE_4(sc, IWI_CSR_TX3_BASE, sc->tx_ring_pa); 2630 CSR_WRITE_4(sc, IWI_CSR_TX3_SIZE, IWI_TX_RING_SIZE); 2631 CSR_WRITE_4(sc, IWI_CSR_TX3_READ_INDEX, 0); 2632 CSR_WRITE_4(sc, IWI_CSR_TX3_WRITE_INDEX, 0); 2633 2634 CSR_WRITE_4(sc, IWI_CSR_TX4_BASE, sc->tx_ring_pa); 2635 CSR_WRITE_4(sc, IWI_CSR_TX4_SIZE, IWI_TX_RING_SIZE); 2636 CSR_WRITE_4(sc, IWI_CSR_TX4_READ_INDEX, 0); 2637 CSR_WRITE_4(sc, IWI_CSR_TX4_WRITE_INDEX, 0); 2638 2639 for (i = 0; i < IWI_RX_RING_SIZE; i++) 2640 CSR_WRITE_4(sc, IWI_CSR_RX_BASE + i * 4, 2641 sc->rx_buf[i].physaddr); 2642 2643 /* 2644 * Kick Rx 2645 */ 2646 CSR_WRITE_4(sc, IWI_CSR_RX_WRITE_INDEX, sc->rx_cur); 2647 CSR_WRITE_4(sc, IWI_CSR_RX_READ_INDEX, 0); 2648 2649 if (iwi_load_firmware(sc, fw->main, fw->main_size) != 0) { 2650 device_printf(sc->sc_dev, "could not load main firmware\n"); 2651 goto fail; 2652 } 2653 2654 /* 2655 * Force the opmode based on what firmware is loaded. This 2656 * stops folks from killing the firmware by asking it to 2657 * do something it doesn't support. 2658 */ 2659 if ( ic->ic_opmode != IEEE80211_M_MONITOR ) { 2660 ic->ic_opmode = ( sc->flags & IWI_FLAG_FW_IBSS ) 2661 ? IEEE80211_M_IBSS : IEEE80211_M_STA; 2662 } 2663 2664 sc->flags |= IWI_FLAG_FW_INITED; 2665 2666 sc->flags &= ~( IWI_FLAG_SCANNING | 2667 IWI_FLAG_SCAN_COMPLETE | 2668 IWI_FLAG_SCAN_ABORT | 2669 IWI_FLAG_ASSOCIATED ); 2670 2671 if (iwi_config(sc) != 0) { 2672 device_printf(sc->sc_dev, "device configuration failed\n"); 2673 goto fail; 2674 } 2675 2676 if ( ic->ic_opmode != IEEE80211_M_MONITOR ) { 2677 ieee80211_begin_scan(ifp); 2678 ifp->if_flags &= ~IFF_OACTIVE; 2679 ifp->if_flags |= IFF_RUNNING; 2680 } else { 2681 ieee80211_begin_scan(ifp); 2682 ifp->if_flags &= ~IFF_OACTIVE; 2683 ifp->if_flags |= IFF_RUNNING; 2684 } 2685 2686 return; 2687 2688 fail: 2689 if ( !(sc->flags & IWI_FLAG_RESET) ) 2690 ifp->if_flags &= ~IFF_UP; 2691 iwi_stop(sc); 2692 } 2693 2694 static void 2695 iwi_init_locked(void *priv) 2696 { 2697 struct iwi_softc *sc = priv; 2698 IWI_LOCK_INFO; 2699 IWI_LOCK(sc); 2700 iwi_init(sc); 2701 IWI_UNLOCK(sc); 2702 } 2703 2704 static void 2705 iwi_stop(void *priv) 2706 { 2707 struct iwi_softc *sc = priv; 2708 struct ieee80211com *ic = &sc->sc_ic; 2709 struct ifnet *ifp = &ic->ic_if; 2710 struct iwi_tx_buf *buf; 2711 int i; 2712 2713 iwi_stop_master(sc); 2714 CSR_WRITE_4(sc, IWI_CSR_RST, IWI_RST_SW_RESET); 2715 2716 /* 2717 * Release Tx buffers 2718 */ 2719 for (i = 0; i < IWI_TX_RING_SIZE; i++) { 2720 buf = &sc->tx_buf[i]; 2721 2722 if (buf->m != NULL) { 2723 bus_dmamap_sync(sc->tx_buf_dmat, buf->map, 2724 BUS_DMASYNC_POSTWRITE); 2725 bus_dmamap_unload(sc->tx_buf_dmat, buf->map); 2726 m_freem(buf->m); 2727 buf->m = NULL; 2728 2729 if (buf->ni != NULL) { 2730 if (buf->ni != ic->ic_bss) 2731 ieee80211_free_node(ic, buf->ni); 2732 buf->ni = NULL; 2733 } 2734 } 2735 } 2736 2737 ifp->if_timer = 0; 2738 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE); 2739 2740 ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 2741 } 2742 2743 static int8_t 2744 iwi_cache_station(struct iwi_softc *sc, u_int8_t *mac) 2745 { 2746 int i, x, base, elemsize = sizeof(struct iwi_fw_station); 2747 for (i = 0; i < sc->num_stations; i++) 2748 if (!memcmp(sc->stations[i], mac, IEEE80211_ADDR_LEN)) 2749 break; 2750 if (i == IWI_FW_MAX_STATIONS) 2751 return 0xff; 2752 memcpy(sc->stations[i], mac, IEEE80211_ADDR_LEN); 2753 for (x = 0, base = IWI_STATION_TABLE + (i * elemsize) ; 2754 x < IEEE80211_ADDR_LEN ; x++ ) { 2755 CSR_WRITE_1(sc, base + x, mac[x]); 2756 } 2757 if ( (i + 1) > sc->num_stations ) 2758 sc->num_stations++; 2759 return i; 2760 } 2761 2762 static u_int8_t 2763 iwi_find_station(struct iwi_softc *sc, u_int8_t *mac) 2764 { 2765 u_int8_t i; 2766 for (i = 0; i < sc->num_stations; i++) 2767 if (!memcmp(sc->stations[i], mac, IEEE80211_ADDR_LEN)) 2768 return i; 2769 return 0xff; 2770 } 2771 2772 static const char * 2773 iwi_error_desc(u_int32_t val) 2774 { 2775 switch (val) { 2776 case IWI_FW_ERROR_OK: 2777 return "OK"; 2778 case IWI_FW_ERROR_FAIL: 2779 return "FAIL"; 2780 case IWI_FW_ERROR_MEMORY_UNDERFLOW: 2781 return "MEMORY_UNDERFLOW"; 2782 case IWI_FW_ERROR_MEMORY_OVERFLOW: 2783 return "MEMORY_OVERFLOW"; 2784 case IWI_FW_ERROR_BAD_PARAM: 2785 return "BAD_PARAMETER"; 2786 case IWI_FW_ERROR_BAD_CHECKSUM: 2787 return "BAD_CHECKSUM"; 2788 case IWI_FW_ERROR_NMI_INTERRUPT: 2789 return "NMI_INTERRUPT"; 2790 case IWI_FW_ERROR_BAD_DATABASE: 2791 return "BAD_DATABASE"; 2792 case IWI_FW_ERROR_ALLOC_FAIL: 2793 return "ALLOC_FAIL"; 2794 case IWI_FW_ERROR_DMA_UNDERRUN: 2795 return "DMA_UNDERRUN"; 2796 case IWI_FW_ERROR_DMA_STATUS: 2797 return "DMA_STATUS"; 2798 case IWI_FW_ERROR_DINOSTATUS_ERROR: 2799 return "DINOSTATUS_ERROR"; 2800 case IWI_FW_ERROR_EEPROMSTATUS_ERROR: 2801 return "EEPROMSTATUS_ERROR"; 2802 case IWI_FW_ERROR_SYSASSERT: 2803 return "SYSASSERT"; 2804 case IWI_FW_ERROR_FATAL_ERROR: 2805 return "FATAL"; 2806 default: 2807 return "UNKNOWN_ERROR"; 2808 } 2809 } 2810 2811 static void 2812 iwi_dump_fw_event_log(struct iwi_softc *sc) 2813 { 2814 u_int32_t ev, time, data, i, count, base; 2815 base = CSR_READ_4(sc, IWI_FW_EVENT_LOG); 2816 count = MEM_READ_4(sc, base); 2817 if ( count > 0 && (sc->flags & IWI_FLAG_FW_INITED) ) { 2818 printf("Reading %d event log entries from base address 0x%x.\n", 2819 count, base); 2820 if (IWI_FW_EVENT_START_OFFSET <= count * IWI_FW_EVENT_ELEM_SIZE) 2821 device_printf(sc->sc_dev,"Start IWI Event Log Dump:\n"); 2822 for (i = IWI_FW_EVENT_START_OFFSET; 2823 i <= count * IWI_FW_EVENT_ELEM_SIZE; 2824 i += IWI_FW_EVENT_ELEM_SIZE) { 2825 ev = MEM_READ_4(sc, base + i); 2826 time = MEM_READ_4(sc, base + i + 1 * sizeof(u_int32_t)); 2827 data = MEM_READ_4(sc, base + i + 2 * sizeof(u_int32_t)); 2828 printf("%d %8p %8.8d\n", time, (void *) data, ev); 2829 } 2830 } else { 2831 printf("There are no entries in the firmware event log.\n"); 2832 } 2833 } 2834 2835 static void 2836 iwi_dump_fw_error_log(struct iwi_softc *sc) 2837 { 2838 u_int32_t i = 0; 2839 int32_t count, base; 2840 base = CSR_READ_4(sc, IWI_FW_ERROR_LOG); 2841 count = MEM_READ_4(sc, base); 2842 if ( count > 0 && (sc->flags & IWI_FLAG_FW_INITED) ) { 2843 printf("Reading %d error log entries " 2844 "from base address 0x%p.\n", count, (void *)base); 2845 for ( i = IWI_FW_ERROR_START_OFFSET; 2846 i <= count * IWI_FW_EVENT_ELEM_SIZE; 2847 i += IWI_FW_ERROR_ELEM_SIZE ) { 2848 u_int32_t elems; 2849 printf("%15.15s", 2850 iwi_error_desc(MEM_READ_4(sc, base + i))); 2851 printf(" time(%8.8d)", MEM_READ_4(sc, base + i + 4)); 2852 for ( elems = 2 ; elems < 7 ; elems++ ) { 2853 printf(" %8p", (void *) 2854 MEM_READ_4(sc, base + i + (4 * elems))); 2855 } 2856 printf("\n"); 2857 } 2858 } 2859 } 2860 2861 static int 2862 iwi_sysctl_cts_to_self(SYSCTL_HANDLER_ARGS) 2863 { 2864 struct iwi_softc *sc = (void *)arg1; 2865 int cts_to_self = sc->enable_cts_to_self; 2866 int error = sysctl_handle_int(oidp, &cts_to_self, 0, req); 2867 2868 (void)arg2; /* silence WARNS == 6 */ 2869 2870 if ( !error && req->newptr && cts_to_self != sc->enable_cts_to_self ) { 2871 switch ( cts_to_self ) { 2872 case -1: case 0: case 1: 2873 sc->enable_cts_to_self = cts_to_self; 2874 error = iwi_adapter_config(sc, 0, 0); 2875 break; 2876 } 2877 } 2878 return error; 2879 } 2880 2881 2882 static int 2883 iwi_sysctl_antenna_diversity(SYSCTL_HANDLER_ARGS) 2884 { 2885 struct iwi_softc *sc = (void *)arg1; 2886 int antenna_diversity = sc->antenna_diversity; 2887 int error = sysctl_handle_int(oidp, &antenna_diversity, 0, req); 2888 2889 (void)arg2; /* silence WARNS == 6 */ 2890 2891 if ( !error && req->newptr && antenna_diversity != sc->antenna_diversity ) { 2892 switch ( antenna_diversity ) { 2893 case 1: case 3: case 0: case -1: 2894 sc->antenna_diversity = antenna_diversity; 2895 error = iwi_adapter_config(sc, 0, 0); 2896 break; 2897 } 2898 } 2899 return error; 2900 } 2901 2902 static int 2903 iwi_sysctl_bg_autodetect(SYSCTL_HANDLER_ARGS) 2904 { 2905 struct iwi_softc *sc = (void *)arg1; 2906 int bg_autodetect = sc->enable_bg_autodetect; 2907 int error = sysctl_handle_int(oidp, &bg_autodetect, 0, req); 2908 2909 (void)arg2; /* silence WARNS == 6 */ 2910 2911 if ( !error && req->newptr && bg_autodetect != sc->enable_bg_autodetect ) { 2912 switch ( bg_autodetect ) { 2913 case 1: case 0: case -1: 2914 sc->enable_bg_autodetect = bg_autodetect; 2915 error = iwi_adapter_config(sc, 0, 0); 2916 break; 2917 } 2918 } 2919 return error; 2920 } 2921 2922 static int 2923 iwi_sysctl_bt_coexist(SYSCTL_HANDLER_ARGS) 2924 { 2925 struct iwi_softc *sc = (void *)arg1; 2926 int bt_coexist = sc->enable_bt_coexist; 2927 int error = sysctl_handle_int(oidp, &bt_coexist, 0, req); 2928 2929 (void)arg2; /* silence WARNS == 6 */ 2930 2931 if ( !error && req->newptr && bt_coexist != sc->enable_bt_coexist ) { 2932 switch ( bt_coexist ) { 2933 case 1: case 0: case -1: 2934 sc->enable_bt_coexist = bt_coexist; 2935 error = iwi_adapter_config(sc, 0, 0); 2936 break; 2937 } 2938 } 2939 return error; 2940 } 2941 2942 static int 2943 iwi_sysctl_dump_logs(SYSCTL_HANDLER_ARGS) 2944 { 2945 struct iwi_softc *sc = arg1; 2946 int result = -1; 2947 int error = sysctl_handle_int(oidp, &result, 0, req); 2948 2949 (void)arg2; /* silence WARNS == 6 */ 2950 2951 if (!error && req->newptr && result == 1) { 2952 iwi_dump_fw_event_log(sc); 2953 iwi_dump_fw_error_log(sc); 2954 } 2955 return error; 2956 } 2957 2958 static int 2959 iwi_sysctl_stats(SYSCTL_HANDLER_ARGS) 2960 { 2961 struct iwi_softc *sc = arg1; 2962 u_int32_t size; 2963 struct iwi_dump_buffer dump; 2964 2965 (void)arg2; /* silence WARNS == 6 */ 2966 (void)oidp; /* silence WARNS == 6 */ 2967 2968 if (!(sc->flags & IWI_FLAG_FW_INITED)) { 2969 bzero(dump.buf, sizeof dump.buf); 2970 return SYSCTL_OUT(req, &dump, sizeof dump); 2971 } 2972 2973 size = min(CSR_READ_4(sc, IWI_CSR_TABLE0_SIZE), 128 - 1); 2974 CSR_READ_REGION_4(sc, IWI_CSR_TABLE0_BASE, &dump.buf[1], size); 2975 2976 return SYSCTL_OUT(req, &dump, sizeof dump); 2977 } 2978 2979 static int 2980 iwi_sysctl_radio(SYSCTL_HANDLER_ARGS) 2981 { 2982 struct iwi_softc *sc = arg1; 2983 int val; 2984 2985 (void)arg2; /* silence WARNS == 6 */ 2986 (void)oidp; /* silence WARNS == 6 */ 2987 2988 val = (CSR_READ_4(sc, IWI_CSR_IO) & IWI_IO_RADIO_ENABLED) ? 1 : 0; 2989 return SYSCTL_OUT(req, &val, sizeof val); 2990 } 2991 2992 static int 2993 iwi_sysctl_neg_best_rates_first(SYSCTL_HANDLER_ARGS) 2994 { 2995 struct iwi_softc *sc = arg1; 2996 int best_first = sc->enable_neg_best_first; 2997 int error = sysctl_handle_int(oidp, &best_first, 0, req); 2998 2999 (void)arg2; /* silence WARNS == 6 */ 3000 (void)oidp; /* silence WARNS == 6 */ 3001 3002 if ( !error && req->newptr && best_first != sc->enable_neg_best_first ) { 3003 switch ( best_first ) { 3004 case 1: case 0: case -1: 3005 sc->enable_neg_best_first = best_first; 3006 break; 3007 } 3008 } 3009 return error; 3010 } 3011 3012 static int 3013 iwi_sysctl_disable_unicast_decryption(SYSCTL_HANDLER_ARGS) 3014 { 3015 struct iwi_softc *sc = arg1; 3016 int disable_uni = sc->disable_unicast_decryption; 3017 int error = sysctl_handle_int(oidp, &disable_uni, 0, req); 3018 3019 (void)arg2; /* silence WARNS == 6 */ 3020 (void)oidp; /* silence WARNS == 6 */ 3021 3022 if (!error && req->newptr && disable_uni != sc->disable_unicast_decryption) { 3023 switch ( disable_uni ) { 3024 case 1: case 0: case -1: 3025 sc->disable_unicast_decryption = disable_uni; 3026 break; 3027 } 3028 } 3029 return error; 3030 } 3031 3032 static int 3033 iwi_sysctl_disable_multicast_decryption(SYSCTL_HANDLER_ARGS) 3034 { 3035 struct iwi_softc *sc = arg1; 3036 int disable_mul = sc->disable_multicast_decryption; 3037 int error = sysctl_handle_int(oidp, &disable_mul, 0, req); 3038 3039 (void)arg2; /* silence WARNS == 6 */ 3040 (void)oidp; /* silence WARNS == 6 */ 3041 3042 if (!error && req->newptr && disable_mul!=sc->disable_multicast_decryption){ 3043 switch ( disable_mul ) { 3044 case 1: case 0: case -1: 3045 sc->disable_multicast_decryption = disable_mul; 3046 break; 3047 } 3048 } 3049 return error; 3050 } 3051 3052 3053