if_iwi.c revision 166416
1145247Sdamien/*- 2158089Smlaier * Copyright (c) 2004, 2005 3145247Sdamien * Damien Bergamini <damien.bergamini@free.fr>. All rights reserved. 4158089Smlaier * Copyright (c) 2005-2006 Sam Leffler, Errno Consulting 5145247Sdamien * 6145247Sdamien * Redistribution and use in source and binary forms, with or without 7145247Sdamien * modification, are permitted provided that the following conditions 8145247Sdamien * are met: 9145247Sdamien * 1. Redistributions of source code must retain the above copyright 10145247Sdamien * notice unmodified, this list of conditions, and the following 11145247Sdamien * disclaimer. 12145247Sdamien * 2. Redistributions in binary form must reproduce the above copyright 13145247Sdamien * notice, this list of conditions and the following disclaimer in the 14145247Sdamien * documentation and/or other materials provided with the distribution. 15145247Sdamien * 16145247Sdamien * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17145247Sdamien * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18145247Sdamien * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19145247Sdamien * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20145247Sdamien * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21145247Sdamien * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22145247Sdamien * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23145247Sdamien * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24145247Sdamien * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25145247Sdamien * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26145247Sdamien * SUCH DAMAGE. 27145247Sdamien */ 28145247Sdamien 29145247Sdamien#include <sys/cdefs.h> 30145247Sdamien__FBSDID("$FreeBSD: head/sys/dev/iwi/if_iwi.c 166416 2007-02-02 05:17:18Z kevlo $"); 31145247Sdamien 32145247Sdamien/*- 33145247Sdamien * Intel(R) PRO/Wireless 2200BG/2225BG/2915ABG driver 34145247Sdamien * http://www.intel.com/network/connectivity/products/wireless/prowireless_mobile.htm 35145247Sdamien */ 36145247Sdamien 37145247Sdamien#include <sys/param.h> 38145247Sdamien#include <sys/sysctl.h> 39145247Sdamien#include <sys/sockio.h> 40145247Sdamien#include <sys/mbuf.h> 41145247Sdamien#include <sys/kernel.h> 42145247Sdamien#include <sys/socket.h> 43145247Sdamien#include <sys/systm.h> 44145247Sdamien#include <sys/malloc.h> 45164982Skevlo#include <sys/lock.h> 46164982Skevlo#include <sys/mutex.h> 47145247Sdamien#include <sys/module.h> 48145247Sdamien#include <sys/bus.h> 49145247Sdamien#include <sys/endian.h> 50158089Smlaier#include <sys/proc.h> 51158089Smlaier#include <sys/mount.h> 52158089Smlaier#include <sys/namei.h> 53156546Sdamien#include <sys/linker.h> 54156546Sdamien#include <sys/firmware.h> 55158089Smlaier#include <sys/kthread.h> 56158089Smlaier#include <sys/taskqueue.h> 57145247Sdamien 58145247Sdamien#include <machine/bus.h> 59145247Sdamien#include <machine/resource.h> 60145247Sdamien#include <sys/rman.h> 61145247Sdamien 62145247Sdamien#include <dev/pci/pcireg.h> 63145247Sdamien#include <dev/pci/pcivar.h> 64145247Sdamien 65145247Sdamien#include <net/bpf.h> 66145247Sdamien#include <net/if.h> 67145247Sdamien#include <net/if_arp.h> 68145247Sdamien#include <net/ethernet.h> 69145247Sdamien#include <net/if_dl.h> 70145247Sdamien#include <net/if_media.h> 71145247Sdamien#include <net/if_types.h> 72145247Sdamien 73145247Sdamien#include <net80211/ieee80211_var.h> 74145247Sdamien#include <net80211/ieee80211_radiotap.h> 75145247Sdamien 76145247Sdamien#include <netinet/in.h> 77145247Sdamien#include <netinet/in_systm.h> 78145247Sdamien#include <netinet/in_var.h> 79145247Sdamien#include <netinet/ip.h> 80145247Sdamien#include <netinet/if_ether.h> 81145247Sdamien 82158089Smlaier#include <dev/iwi/if_iwireg.h> 83154992Sdamien#include <dev/iwi/if_iwivar.h> 84145247Sdamien 85158089Smlaier#define IWI_DEBUG 86145247Sdamien#ifdef IWI_DEBUG 87145247Sdamien#define DPRINTF(x) do { if (iwi_debug > 0) printf x; } while (0) 88145247Sdamien#define DPRINTFN(n, x) do { if (iwi_debug >= (n)) printf x; } while (0) 89145247Sdamienint iwi_debug = 0; 90145247SdamienSYSCTL_INT(_debug, OID_AUTO, iwi, CTLFLAG_RW, &iwi_debug, 0, "iwi debug level"); 91145247Sdamien#else 92145247Sdamien#define DPRINTF(x) 93145247Sdamien#define DPRINTFN(n, x) 94145247Sdamien#endif 95145247Sdamien 96145247SdamienMODULE_DEPEND(iwi, pci, 1, 1, 1); 97145247SdamienMODULE_DEPEND(iwi, wlan, 1, 1, 1); 98156571SdamienMODULE_DEPEND(iwi, firmware, 1, 1, 1); 99145247Sdamien 100158089Smlaierenum { 101158089Smlaier IWI_LED_TX, 102158089Smlaier IWI_LED_RX, 103158089Smlaier IWI_LED_POLL, 104158089Smlaier}; 105158089Smlaier 106145247Sdamienstruct iwi_ident { 107145247Sdamien uint16_t vendor; 108145247Sdamien uint16_t device; 109145247Sdamien const char *name; 110145247Sdamien}; 111145247Sdamien 112145247Sdamienstatic const struct iwi_ident iwi_ident_table[] = { 113145247Sdamien { 0x8086, 0x4220, "Intel(R) PRO/Wireless 2200BG" }, 114145247Sdamien { 0x8086, 0x4221, "Intel(R) PRO/Wireless 2225BG" }, 115145247Sdamien { 0x8086, 0x4223, "Intel(R) PRO/Wireless 2915ABG" }, 116145247Sdamien { 0x8086, 0x4224, "Intel(R) PRO/Wireless 2915ABG" }, 117145247Sdamien 118145247Sdamien { 0, 0, NULL } 119145247Sdamien}; 120145247Sdamien 121145247Sdamienstatic void iwi_dma_map_addr(void *, bus_dma_segment_t *, int, int); 122145247Sdamienstatic int iwi_alloc_cmd_ring(struct iwi_softc *, struct iwi_cmd_ring *, 123145247Sdamien int); 124145247Sdamienstatic void iwi_reset_cmd_ring(struct iwi_softc *, struct iwi_cmd_ring *); 125145247Sdamienstatic void iwi_free_cmd_ring(struct iwi_softc *, struct iwi_cmd_ring *); 126145247Sdamienstatic int iwi_alloc_tx_ring(struct iwi_softc *, struct iwi_tx_ring *, 127149338Sdamien int, bus_addr_t, bus_addr_t); 128145247Sdamienstatic void iwi_reset_tx_ring(struct iwi_softc *, struct iwi_tx_ring *); 129145247Sdamienstatic void iwi_free_tx_ring(struct iwi_softc *, struct iwi_tx_ring *); 130145247Sdamienstatic int iwi_alloc_rx_ring(struct iwi_softc *, struct iwi_rx_ring *, 131145247Sdamien int); 132145247Sdamienstatic void iwi_reset_rx_ring(struct iwi_softc *, struct iwi_rx_ring *); 133145247Sdamienstatic void iwi_free_rx_ring(struct iwi_softc *, struct iwi_rx_ring *); 134150341Sdamienstatic struct ieee80211_node *iwi_node_alloc(struct ieee80211_node_table *); 135150341Sdamienstatic void iwi_node_free(struct ieee80211_node *); 136145247Sdamienstatic int iwi_media_change(struct ifnet *); 137145247Sdamienstatic void iwi_media_status(struct ifnet *, struct ifmediareq *); 138145247Sdamienstatic int iwi_newstate(struct ieee80211com *, enum ieee80211_state, int); 139158089Smlaierstatic void iwi_wme_init(struct iwi_softc *); 140158089Smlaierstatic void iwi_wme_setparams(void *, int); 141149338Sdamienstatic int iwi_wme_update(struct ieee80211com *); 142145247Sdamienstatic uint16_t iwi_read_prom_word(struct iwi_softc *, uint8_t); 143145247Sdamienstatic void iwi_frame_intr(struct iwi_softc *, struct iwi_rx_data *, int, 144145247Sdamien struct iwi_frame *); 145145247Sdamienstatic void iwi_notification_intr(struct iwi_softc *, struct iwi_notif *); 146145247Sdamienstatic void iwi_rx_intr(struct iwi_softc *); 147149338Sdamienstatic void iwi_tx_intr(struct iwi_softc *, struct iwi_tx_ring *); 148145247Sdamienstatic void iwi_intr(void *); 149158089Smlaierstatic int iwi_cmd(struct iwi_softc *, uint8_t, void *, uint8_t); 150158089Smlaierstatic void iwi_write_ibssnode(struct iwi_softc *, const u_int8_t [], int); 151145247Sdamienstatic int iwi_tx_start(struct ifnet *, struct mbuf *, 152150245Sdamien struct ieee80211_node *, int); 153145247Sdamienstatic void iwi_start(struct ifnet *); 154145247Sdamienstatic void iwi_watchdog(struct ifnet *); 155145247Sdamienstatic int iwi_ioctl(struct ifnet *, u_long, caddr_t); 156145247Sdamienstatic void iwi_stop_master(struct iwi_softc *); 157145247Sdamienstatic int iwi_reset(struct iwi_softc *); 158158089Smlaierstatic int iwi_load_ucode(struct iwi_softc *, const struct iwi_fw *); 159158089Smlaierstatic int iwi_load_firmware(struct iwi_softc *, const struct iwi_fw *); 160145247Sdamienstatic int iwi_config(struct iwi_softc *); 161158089Smlaierstatic int iwi_get_firmware(struct iwi_softc *); 162158089Smlaierstatic void iwi_put_firmware(struct iwi_softc *); 163158089Smlaierstatic void iwi_scanabort(void *, int); 164158089Smlaierstatic void iwi_scandone(void *, int); 165158089Smlaierstatic void iwi_scanstart(void *, int); 166158089Smlaierstatic void iwi_scanchan(void *, int); 167145247Sdamienstatic int iwi_auth_and_assoc(struct iwi_softc *); 168158089Smlaierstatic int iwi_disassociate(struct iwi_softc *, int quiet); 169158089Smlaierstatic void iwi_down(void *, int); 170145247Sdamienstatic void iwi_init(void *); 171158089Smlaierstatic void iwi_init_locked(void *, int); 172145247Sdamienstatic void iwi_stop(void *); 173158089Smlaierstatic void iwi_restart(void *, int); 174158089Smlaierstatic int iwi_getrfkill(struct iwi_softc *); 175158089Smlaierstatic void iwi_radio_on(void *, int); 176158089Smlaierstatic void iwi_radio_off(void *, int); 177158089Smlaierstatic void iwi_sysctlattach(struct iwi_softc *); 178158089Smlaierstatic void iwi_led_event(struct iwi_softc *, int); 179158089Smlaierstatic void iwi_ledattach(struct iwi_softc *); 180145247Sdamien 181145247Sdamienstatic int iwi_probe(device_t); 182145247Sdamienstatic int iwi_attach(device_t); 183145247Sdamienstatic int iwi_detach(device_t); 184145247Sdamienstatic int iwi_shutdown(device_t); 185145247Sdamienstatic int iwi_suspend(device_t); 186145247Sdamienstatic int iwi_resume(device_t); 187145247Sdamien 188145247Sdamienstatic device_method_t iwi_methods[] = { 189145247Sdamien /* Device interface */ 190145247Sdamien DEVMETHOD(device_probe, iwi_probe), 191145247Sdamien DEVMETHOD(device_attach, iwi_attach), 192145247Sdamien DEVMETHOD(device_detach, iwi_detach), 193145247Sdamien DEVMETHOD(device_shutdown, iwi_shutdown), 194145247Sdamien DEVMETHOD(device_suspend, iwi_suspend), 195145247Sdamien DEVMETHOD(device_resume, iwi_resume), 196145247Sdamien 197145247Sdamien { 0, 0 } 198145247Sdamien}; 199145247Sdamien 200145247Sdamienstatic driver_t iwi_driver = { 201145247Sdamien "iwi", 202145247Sdamien iwi_methods, 203145247Sdamien sizeof (struct iwi_softc) 204145247Sdamien}; 205145247Sdamien 206145247Sdamienstatic devclass_t iwi_devclass; 207145247Sdamien 208145247SdamienDRIVER_MODULE(iwi, pci, iwi_driver, iwi_devclass, 0, 0); 209145247Sdamien 210145247Sdamien/* 211145247Sdamien * Supported rates for 802.11a/b/g modes (in 500Kbps unit). 212145247Sdamien */ 213145247Sdamienstatic const struct ieee80211_rateset iwi_rateset_11a = 214145247Sdamien { 8, { 12, 18, 24, 36, 48, 72, 96, 108 } }; 215145247Sdamien 216145247Sdamienstatic const struct ieee80211_rateset iwi_rateset_11b = 217145247Sdamien { 4, { 2, 4, 11, 22 } }; 218145247Sdamien 219145247Sdamienstatic const struct ieee80211_rateset iwi_rateset_11g = 220145247Sdamien { 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } }; 221145247Sdamien 222158089Smlaierstatic __inline uint8_t 223158089SmlaierMEM_READ_1(struct iwi_softc *sc, uint32_t addr) 224158089Smlaier{ 225158089Smlaier CSR_WRITE_4(sc, IWI_CSR_INDIRECT_ADDR, addr); 226158089Smlaier return CSR_READ_1(sc, IWI_CSR_INDIRECT_DATA); 227158089Smlaier} 228158089Smlaier 229158089Smlaierstatic __inline uint32_t 230158089SmlaierMEM_READ_4(struct iwi_softc *sc, uint32_t addr) 231158089Smlaier{ 232158089Smlaier CSR_WRITE_4(sc, IWI_CSR_INDIRECT_ADDR, addr); 233158089Smlaier return CSR_READ_4(sc, IWI_CSR_INDIRECT_DATA); 234158089Smlaier} 235158089Smlaier 236145247Sdamienstatic int 237145247Sdamieniwi_probe(device_t dev) 238145247Sdamien{ 239145247Sdamien const struct iwi_ident *ident; 240145247Sdamien 241145247Sdamien for (ident = iwi_ident_table; ident->name != NULL; ident++) { 242145247Sdamien if (pci_get_vendor(dev) == ident->vendor && 243145247Sdamien pci_get_device(dev) == ident->device) { 244145247Sdamien device_set_desc(dev, ident->name); 245145247Sdamien return 0; 246145247Sdamien } 247145247Sdamien } 248145247Sdamien return ENXIO; 249145247Sdamien} 250145247Sdamien 251145247Sdamien/* Base Address Register */ 252145247Sdamien#define IWI_PCI_BAR0 0x10 253145247Sdamien 254145247Sdamienstatic int 255145247Sdamieniwi_attach(device_t dev) 256145247Sdamien{ 257145247Sdamien struct iwi_softc *sc = device_get_softc(dev); 258147256Sbrooks struct ifnet *ifp; 259145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 260145247Sdamien uint16_t val; 261145247Sdamien int error, i; 262145247Sdamien 263145247Sdamien sc->sc_dev = dev; 264145247Sdamien 265145247Sdamien mtx_init(&sc->sc_mtx, device_get_nameunit(dev), MTX_NETWORK_LOCK, 266158089Smlaier MTX_DEF); 267145247Sdamien 268158089Smlaier sc->sc_unr = new_unrhdr(1, IWI_MAX_IBSSNODE-1, &sc->sc_mtx); 269150341Sdamien 270158089Smlaier#if __FreeBSD_version >= 700000 271158089Smlaier sc->sc_tq = taskqueue_create("iwi_taskq", M_NOWAIT, 272158089Smlaier taskqueue_thread_enqueue, &sc->sc_tq); 273158089Smlaier taskqueue_start_threads(&sc->sc_tq, 1, PI_NET, "%s taskq", 274158089Smlaier device_get_nameunit(dev)); 275158089Smlaier#else 276158089Smlaier sc->sc_tq = taskqueue_create("iwi_taskq", M_NOWAIT, 277158089Smlaier taskqueue_thread_enqueue, &sc->sc_tq, &sc->sc_tqproc); 278158089Smlaier kthread_create(taskqueue_thread_loop, &sc->sc_tq, &sc->sc_tqproc, 279158089Smlaier 0, 0, "%s taskq", device_get_nameunit(dev)); 280158089Smlaier#endif 281158089Smlaier TASK_INIT(&sc->sc_radiontask, 0, iwi_radio_on, sc); 282158089Smlaier TASK_INIT(&sc->sc_radiofftask, 0, iwi_radio_off, sc); 283158089Smlaier TASK_INIT(&sc->sc_scanstarttask, 0, iwi_scanstart, sc); 284158089Smlaier TASK_INIT(&sc->sc_scanaborttask, 0, iwi_scanabort, sc); 285158089Smlaier TASK_INIT(&sc->sc_scandonetask, 0, iwi_scandone, sc); 286158089Smlaier TASK_INIT(&sc->sc_scantask, 0, iwi_scanchan, sc); 287158089Smlaier TASK_INIT(&sc->sc_setwmetask, 0, iwi_wme_setparams, sc); 288158089Smlaier TASK_INIT(&sc->sc_downtask, 0, iwi_down, sc); 289158089Smlaier TASK_INIT(&sc->sc_restarttask, 0, iwi_restart, sc); 290156598Sdamien 291145247Sdamien if (pci_get_powerstate(dev) != PCI_POWERSTATE_D0) { 292145247Sdamien device_printf(dev, "chip is in D%d power mode " 293145247Sdamien "-- setting to D0\n", pci_get_powerstate(dev)); 294145247Sdamien pci_set_powerstate(dev, PCI_POWERSTATE_D0); 295145247Sdamien } 296145247Sdamien 297146500Sdamien pci_write_config(dev, 0x41, 0, 1); 298146500Sdamien 299145247Sdamien /* enable bus-mastering */ 300145247Sdamien pci_enable_busmaster(dev); 301145247Sdamien 302145247Sdamien sc->mem_rid = IWI_PCI_BAR0; 303145247Sdamien sc->mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->mem_rid, 304145247Sdamien RF_ACTIVE); 305145247Sdamien if (sc->mem == NULL) { 306145247Sdamien device_printf(dev, "could not allocate memory resource\n"); 307145247Sdamien goto fail; 308145247Sdamien } 309145247Sdamien 310145247Sdamien sc->sc_st = rman_get_bustag(sc->mem); 311145247Sdamien sc->sc_sh = rman_get_bushandle(sc->mem); 312145247Sdamien 313145247Sdamien sc->irq_rid = 0; 314145247Sdamien sc->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &sc->irq_rid, 315145247Sdamien RF_ACTIVE | RF_SHAREABLE); 316145247Sdamien if (sc->irq == NULL) { 317145247Sdamien device_printf(dev, "could not allocate interrupt resource\n"); 318145247Sdamien goto fail; 319145247Sdamien } 320145247Sdamien 321145247Sdamien if (iwi_reset(sc) != 0) { 322145247Sdamien device_printf(dev, "could not reset adapter\n"); 323145247Sdamien goto fail; 324145247Sdamien } 325145247Sdamien 326145247Sdamien /* 327145247Sdamien * Allocate rings. 328145247Sdamien */ 329145247Sdamien if (iwi_alloc_cmd_ring(sc, &sc->cmdq, IWI_CMD_RING_COUNT) != 0) { 330145247Sdamien device_printf(dev, "could not allocate Cmd ring\n"); 331145247Sdamien goto fail; 332145247Sdamien } 333145247Sdamien 334149338Sdamien error = iwi_alloc_tx_ring(sc, &sc->txq[0], IWI_TX_RING_COUNT, 335149338Sdamien IWI_CSR_TX1_RIDX, IWI_CSR_TX1_WIDX); 336149338Sdamien if (error != 0) { 337149338Sdamien device_printf(dev, "could not allocate Tx ring 1\n"); 338145247Sdamien goto fail; 339145247Sdamien } 340145247Sdamien 341149338Sdamien error = iwi_alloc_tx_ring(sc, &sc->txq[1], IWI_TX_RING_COUNT, 342149338Sdamien IWI_CSR_TX2_RIDX, IWI_CSR_TX2_WIDX); 343149338Sdamien if (error != 0) { 344149338Sdamien device_printf(dev, "could not allocate Tx ring 2\n"); 345149338Sdamien goto fail; 346149338Sdamien } 347149338Sdamien 348149338Sdamien error = iwi_alloc_tx_ring(sc, &sc->txq[2], IWI_TX_RING_COUNT, 349149338Sdamien IWI_CSR_TX3_RIDX, IWI_CSR_TX3_WIDX); 350149338Sdamien if (error != 0) { 351149338Sdamien device_printf(dev, "could not allocate Tx ring 3\n"); 352149338Sdamien goto fail; 353149338Sdamien } 354149338Sdamien 355149338Sdamien error = iwi_alloc_tx_ring(sc, &sc->txq[3], IWI_TX_RING_COUNT, 356149338Sdamien IWI_CSR_TX4_RIDX, IWI_CSR_TX4_WIDX); 357149338Sdamien if (error != 0) { 358149338Sdamien device_printf(dev, "could not allocate Tx ring 4\n"); 359149338Sdamien goto fail; 360149338Sdamien } 361149338Sdamien 362145247Sdamien if (iwi_alloc_rx_ring(sc, &sc->rxq, IWI_RX_RING_COUNT) != 0) { 363145247Sdamien device_printf(dev, "could not allocate Rx ring\n"); 364145247Sdamien goto fail; 365145247Sdamien } 366145247Sdamien 367158089Smlaier iwi_wme_init(sc); 368158089Smlaier 369147256Sbrooks ifp = sc->sc_ifp = if_alloc(IFT_ETHER); 370147256Sbrooks if (ifp == NULL) { 371147256Sbrooks device_printf(dev, "can not if_alloc()\n"); 372147256Sbrooks goto fail; 373147256Sbrooks } 374145247Sdamien ifp->if_softc = sc; 375145247Sdamien if_initname(ifp, device_get_name(dev), device_get_unit(dev)); 376145247Sdamien ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST; 377145247Sdamien ifp->if_init = iwi_init; 378145247Sdamien ifp->if_ioctl = iwi_ioctl; 379145247Sdamien ifp->if_start = iwi_start; 380145247Sdamien ifp->if_watchdog = iwi_watchdog; 381145247Sdamien IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN); 382145247Sdamien ifp->if_snd.ifq_drv_maxlen = IFQ_MAXLEN; 383145247Sdamien IFQ_SET_READY(&ifp->if_snd); 384145247Sdamien 385145247Sdamien ic->ic_ifp = ifp; 386149338Sdamien ic->ic_wme.wme_update = iwi_wme_update; 387145247Sdamien ic->ic_phytype = IEEE80211_T_OFDM; /* not only, but not used */ 388145247Sdamien ic->ic_opmode = IEEE80211_M_STA; /* default to BSS mode */ 389145247Sdamien ic->ic_state = IEEE80211_S_INIT; 390145247Sdamien 391145247Sdamien /* set device capabilities */ 392149338Sdamien ic->ic_caps = 393150245Sdamien IEEE80211_C_IBSS | /* IBSS mode supported */ 394149338Sdamien IEEE80211_C_MONITOR | /* monitor mode supported */ 395158089Smlaier IEEE80211_C_PMGT | /* power save supported */ 396149338Sdamien IEEE80211_C_SHPREAMBLE | /* short preamble supported */ 397149338Sdamien IEEE80211_C_WPA | /* 802.11i */ 398149338Sdamien IEEE80211_C_WME; /* 802.11e */ 399145247Sdamien 400145247Sdamien /* read MAC address from EEPROM */ 401145247Sdamien val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 0); 402152389Sdamien ic->ic_myaddr[0] = val & 0xff; 403152389Sdamien ic->ic_myaddr[1] = val >> 8; 404145247Sdamien val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 1); 405152389Sdamien ic->ic_myaddr[2] = val & 0xff; 406152389Sdamien ic->ic_myaddr[3] = val >> 8; 407145247Sdamien val = iwi_read_prom_word(sc, IWI_EEPROM_MAC + 2); 408152389Sdamien ic->ic_myaddr[4] = val & 0xff; 409152389Sdamien ic->ic_myaddr[5] = val >> 8; 410145247Sdamien 411145247Sdamien if (pci_get_device(dev) >= 0x4223) { 412145247Sdamien /* set supported .11a rates (2915ABG only) */ 413145247Sdamien ic->ic_sup_rates[IEEE80211_MODE_11A] = iwi_rateset_11a; 414145247Sdamien 415145247Sdamien /* set supported .11a channels */ 416145247Sdamien for (i = 36; i <= 64; i += 4) { 417145247Sdamien ic->ic_channels[i].ic_freq = 418145247Sdamien ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ); 419145247Sdamien ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A; 420145247Sdamien } 421145247Sdamien for (i = 149; i <= 165; i += 4) { 422145247Sdamien ic->ic_channels[i].ic_freq = 423145247Sdamien ieee80211_ieee2mhz(i, IEEE80211_CHAN_5GHZ); 424145247Sdamien ic->ic_channels[i].ic_flags = IEEE80211_CHAN_A; 425145247Sdamien } 426145247Sdamien } 427145247Sdamien 428145247Sdamien /* set supported .11b and .11g rates */ 429145247Sdamien ic->ic_sup_rates[IEEE80211_MODE_11B] = iwi_rateset_11b; 430145247Sdamien ic->ic_sup_rates[IEEE80211_MODE_11G] = iwi_rateset_11g; 431145247Sdamien 432145247Sdamien /* set supported .11b and .11g channels (1 through 14) */ 433145247Sdamien for (i = 1; i <= 14; i++) { 434145247Sdamien ic->ic_channels[i].ic_freq = 435145247Sdamien ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ); 436145247Sdamien ic->ic_channels[i].ic_flags = 437145247Sdamien IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM | 438145247Sdamien IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ; 439145247Sdamien } 440145247Sdamien 441145247Sdamien ieee80211_ifattach(ic); 442160688Ssam ic->ic_bmissthreshold = 10; /* override default */ 443150341Sdamien /* override default methods */ 444150341Sdamien ic->ic_node_alloc = iwi_node_alloc; 445150341Sdamien sc->sc_node_free = ic->ic_node_free; 446150341Sdamien ic->ic_node_free = iwi_node_free; 447145247Sdamien /* override state transition machine */ 448145247Sdamien sc->sc_newstate = ic->ic_newstate; 449145247Sdamien ic->ic_newstate = iwi_newstate; 450145247Sdamien ieee80211_media_init(ic, iwi_media_change, iwi_media_status); 451145247Sdamien 452145247Sdamien bpfattach2(ifp, DLT_IEEE802_11_RADIO, 453158089Smlaier sizeof (struct ieee80211_frame) + sizeof (sc->sc_txtap), 454158089Smlaier &sc->sc_drvbpf); 455145247Sdamien 456158089Smlaier sc->sc_rxtap_len = sizeof sc->sc_rxtap; 457145247Sdamien sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len); 458145247Sdamien sc->sc_rxtap.wr_ihdr.it_present = htole32(IWI_RX_RADIOTAP_PRESENT); 459145247Sdamien 460158089Smlaier sc->sc_txtap_len = sizeof sc->sc_txtap; 461145247Sdamien sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len); 462145247Sdamien sc->sc_txtap.wt_ihdr.it_present = htole32(IWI_TX_RADIOTAP_PRESENT); 463145247Sdamien 464158089Smlaier iwi_sysctlattach(sc); 465158089Smlaier iwi_ledattach(sc); 466145247Sdamien 467145247Sdamien /* 468145247Sdamien * Hook our interrupt after all initialization is complete. 469145247Sdamien */ 470145247Sdamien error = bus_setup_intr(dev, sc->irq, INTR_TYPE_NET | INTR_MPSAFE, 471145247Sdamien iwi_intr, sc, &sc->sc_ih); 472145247Sdamien if (error != 0) { 473145247Sdamien device_printf(dev, "could not set up interrupt\n"); 474145247Sdamien goto fail; 475145247Sdamien } 476145247Sdamien 477145247Sdamien if (bootverbose) 478145247Sdamien ieee80211_announce(ic); 479145247Sdamien 480145247Sdamien return 0; 481145247Sdamien 482145247Sdamienfail: iwi_detach(dev); 483145247Sdamien return ENXIO; 484145247Sdamien} 485145247Sdamien 486145247Sdamienstatic int 487145247Sdamieniwi_detach(device_t dev) 488145247Sdamien{ 489145247Sdamien struct iwi_softc *sc = device_get_softc(dev); 490145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 491145247Sdamien struct ifnet *ifp = ic->ic_ifp; 492145247Sdamien 493150245Sdamien if (ifp != NULL) { 494164069Sjhb iwi_stop(sc); 495147256Sbrooks bpfdetach(ifp); 496150245Sdamien ieee80211_ifdetach(ic); 497150245Sdamien } 498164069Sjhb iwi_put_firmware(sc); 499145247Sdamien 500145247Sdamien iwi_free_cmd_ring(sc, &sc->cmdq); 501149338Sdamien iwi_free_tx_ring(sc, &sc->txq[0]); 502149338Sdamien iwi_free_tx_ring(sc, &sc->txq[1]); 503149338Sdamien iwi_free_tx_ring(sc, &sc->txq[2]); 504149338Sdamien iwi_free_tx_ring(sc, &sc->txq[3]); 505145247Sdamien iwi_free_rx_ring(sc, &sc->rxq); 506145247Sdamien 507145247Sdamien if (sc->irq != NULL) { 508145247Sdamien bus_teardown_intr(dev, sc->irq, sc->sc_ih); 509145247Sdamien bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq); 510145247Sdamien } 511145247Sdamien 512145247Sdamien if (sc->mem != NULL) 513145247Sdamien bus_release_resource(dev, SYS_RES_MEMORY, sc->mem_rid, sc->mem); 514145247Sdamien 515150306Simp if (ifp != NULL) 516150306Simp if_free(ifp); 517150330Sdamien 518158089Smlaier taskqueue_free(sc->sc_tq); 519158089Smlaier 520150341Sdamien if (sc->sc_unr != NULL) 521150341Sdamien delete_unrhdr(sc->sc_unr); 522150341Sdamien 523145247Sdamien mtx_destroy(&sc->sc_mtx); 524145247Sdamien 525145247Sdamien return 0; 526145247Sdamien} 527145247Sdamien 528145247Sdamienstatic void 529145247Sdamieniwi_dma_map_addr(void *arg, bus_dma_segment_t *segs, int nseg, int error) 530145247Sdamien{ 531145247Sdamien if (error != 0) 532145247Sdamien return; 533145247Sdamien 534145247Sdamien KASSERT(nseg == 1, ("too many DMA segments, %d should be 1", nseg)); 535145247Sdamien 536145247Sdamien *(bus_addr_t *)arg = segs[0].ds_addr; 537145247Sdamien} 538145247Sdamien 539145247Sdamienstatic int 540145247Sdamieniwi_alloc_cmd_ring(struct iwi_softc *sc, struct iwi_cmd_ring *ring, int count) 541145247Sdamien{ 542145247Sdamien int error; 543145247Sdamien 544145247Sdamien ring->count = count; 545145247Sdamien ring->queued = 0; 546145247Sdamien ring->cur = ring->next = 0; 547145247Sdamien 548166416Skevlo error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 4, 0, 549166416Skevlo BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 550166416Skevlo count * IWI_CMD_DESC_SIZE, 1, count * IWI_CMD_DESC_SIZE, 0, 551166416Skevlo NULL, NULL, &ring->desc_dmat); 552145247Sdamien if (error != 0) { 553145247Sdamien device_printf(sc->sc_dev, "could not create desc DMA tag\n"); 554145247Sdamien goto fail; 555145247Sdamien } 556145247Sdamien 557145247Sdamien error = bus_dmamem_alloc(ring->desc_dmat, (void **)&ring->desc, 558145247Sdamien BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_map); 559145247Sdamien if (error != 0) { 560145247Sdamien device_printf(sc->sc_dev, "could not allocate DMA memory\n"); 561145247Sdamien goto fail; 562145247Sdamien } 563145247Sdamien 564145247Sdamien error = bus_dmamap_load(ring->desc_dmat, ring->desc_map, ring->desc, 565145247Sdamien count * IWI_CMD_DESC_SIZE, iwi_dma_map_addr, &ring->physaddr, 0); 566145247Sdamien if (error != 0) { 567145247Sdamien device_printf(sc->sc_dev, "could not load desc DMA map\n"); 568145247Sdamien goto fail; 569145247Sdamien } 570145247Sdamien 571145247Sdamien return 0; 572145247Sdamien 573145247Sdamienfail: iwi_free_cmd_ring(sc, ring); 574145247Sdamien return error; 575145247Sdamien} 576145247Sdamien 577145247Sdamienstatic void 578145247Sdamieniwi_reset_cmd_ring(struct iwi_softc *sc, struct iwi_cmd_ring *ring) 579145247Sdamien{ 580145247Sdamien ring->queued = 0; 581145247Sdamien ring->cur = ring->next = 0; 582145247Sdamien} 583145247Sdamien 584145247Sdamienstatic void 585145247Sdamieniwi_free_cmd_ring(struct iwi_softc *sc, struct iwi_cmd_ring *ring) 586145247Sdamien{ 587145247Sdamien if (ring->desc != NULL) { 588145247Sdamien bus_dmamap_sync(ring->desc_dmat, ring->desc_map, 589145247Sdamien BUS_DMASYNC_POSTWRITE); 590145247Sdamien bus_dmamap_unload(ring->desc_dmat, ring->desc_map); 591145247Sdamien bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map); 592145247Sdamien } 593145247Sdamien 594145247Sdamien if (ring->desc_dmat != NULL) 595145247Sdamien bus_dma_tag_destroy(ring->desc_dmat); 596145247Sdamien} 597145247Sdamien 598145247Sdamienstatic int 599149338Sdamieniwi_alloc_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring, int count, 600149338Sdamien bus_addr_t csr_ridx, bus_addr_t csr_widx) 601145247Sdamien{ 602145247Sdamien int i, error; 603145247Sdamien 604145247Sdamien ring->count = count; 605145247Sdamien ring->queued = 0; 606145247Sdamien ring->cur = ring->next = 0; 607149338Sdamien ring->csr_ridx = csr_ridx; 608149338Sdamien ring->csr_widx = csr_widx; 609145247Sdamien 610166416Skevlo error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 4, 0, 611166416Skevlo BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 612166416Skevlo count * IWI_TX_DESC_SIZE, 1, count * IWI_TX_DESC_SIZE, 0, NULL, 613166416Skevlo NULL, &ring->desc_dmat); 614145247Sdamien if (error != 0) { 615145247Sdamien device_printf(sc->sc_dev, "could not create desc DMA tag\n"); 616145247Sdamien goto fail; 617145247Sdamien } 618145247Sdamien 619145247Sdamien error = bus_dmamem_alloc(ring->desc_dmat, (void **)&ring->desc, 620145247Sdamien BUS_DMA_NOWAIT | BUS_DMA_ZERO, &ring->desc_map); 621145247Sdamien if (error != 0) { 622145247Sdamien device_printf(sc->sc_dev, "could not allocate DMA memory\n"); 623145247Sdamien goto fail; 624145247Sdamien } 625145247Sdamien 626145247Sdamien error = bus_dmamap_load(ring->desc_dmat, ring->desc_map, ring->desc, 627145247Sdamien count * IWI_TX_DESC_SIZE, iwi_dma_map_addr, &ring->physaddr, 0); 628145247Sdamien if (error != 0) { 629145247Sdamien device_printf(sc->sc_dev, "could not load desc DMA map\n"); 630145247Sdamien goto fail; 631145247Sdamien } 632145247Sdamien 633145247Sdamien ring->data = malloc(count * sizeof (struct iwi_tx_data), M_DEVBUF, 634145247Sdamien M_NOWAIT | M_ZERO); 635145247Sdamien if (ring->data == NULL) { 636145247Sdamien device_printf(sc->sc_dev, "could not allocate soft data\n"); 637145247Sdamien error = ENOMEM; 638145247Sdamien goto fail; 639145247Sdamien } 640145247Sdamien 641166416Skevlo error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 642166416Skevlo BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 643166416Skevlo IWI_MAX_NSEG, MCLBYTES, 0, NULL, NULL, &ring->data_dmat); 644145247Sdamien if (error != 0) { 645145247Sdamien device_printf(sc->sc_dev, "could not create data DMA tag\n"); 646145247Sdamien goto fail; 647145247Sdamien } 648145247Sdamien 649145247Sdamien for (i = 0; i < count; i++) { 650145247Sdamien error = bus_dmamap_create(ring->data_dmat, 0, 651145247Sdamien &ring->data[i].map); 652145247Sdamien if (error != 0) { 653145247Sdamien device_printf(sc->sc_dev, "could not create DMA map\n"); 654145247Sdamien goto fail; 655145247Sdamien } 656145247Sdamien } 657145247Sdamien 658145247Sdamien return 0; 659145247Sdamien 660145247Sdamienfail: iwi_free_tx_ring(sc, ring); 661145247Sdamien return error; 662145247Sdamien} 663145247Sdamien 664145247Sdamienstatic void 665145247Sdamieniwi_reset_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring) 666145247Sdamien{ 667145247Sdamien struct iwi_tx_data *data; 668145247Sdamien int i; 669145247Sdamien 670145247Sdamien for (i = 0; i < ring->count; i++) { 671145247Sdamien data = &ring->data[i]; 672145247Sdamien 673145247Sdamien if (data->m != NULL) { 674145247Sdamien bus_dmamap_sync(ring->data_dmat, data->map, 675145247Sdamien BUS_DMASYNC_POSTWRITE); 676145247Sdamien bus_dmamap_unload(ring->data_dmat, data->map); 677145247Sdamien m_freem(data->m); 678145247Sdamien data->m = NULL; 679145247Sdamien } 680145247Sdamien 681145247Sdamien if (data->ni != NULL) { 682145247Sdamien ieee80211_free_node(data->ni); 683145247Sdamien data->ni = NULL; 684145247Sdamien } 685145247Sdamien } 686145247Sdamien 687145247Sdamien ring->queued = 0; 688145247Sdamien ring->cur = ring->next = 0; 689145247Sdamien} 690145247Sdamien 691145247Sdamienstatic void 692145247Sdamieniwi_free_tx_ring(struct iwi_softc *sc, struct iwi_tx_ring *ring) 693145247Sdamien{ 694145247Sdamien struct iwi_tx_data *data; 695145247Sdamien int i; 696145247Sdamien 697145247Sdamien if (ring->desc != NULL) { 698145247Sdamien bus_dmamap_sync(ring->desc_dmat, ring->desc_map, 699145247Sdamien BUS_DMASYNC_POSTWRITE); 700145247Sdamien bus_dmamap_unload(ring->desc_dmat, ring->desc_map); 701145247Sdamien bus_dmamem_free(ring->desc_dmat, ring->desc, ring->desc_map); 702145247Sdamien } 703145247Sdamien 704145247Sdamien if (ring->desc_dmat != NULL) 705145247Sdamien bus_dma_tag_destroy(ring->desc_dmat); 706145247Sdamien 707145247Sdamien if (ring->data != NULL) { 708145247Sdamien for (i = 0; i < ring->count; i++) { 709145247Sdamien data = &ring->data[i]; 710145247Sdamien 711145247Sdamien if (data->m != NULL) { 712145247Sdamien bus_dmamap_sync(ring->data_dmat, data->map, 713145247Sdamien BUS_DMASYNC_POSTWRITE); 714145247Sdamien bus_dmamap_unload(ring->data_dmat, data->map); 715145247Sdamien m_freem(data->m); 716145247Sdamien } 717145247Sdamien 718145247Sdamien if (data->ni != NULL) 719145247Sdamien ieee80211_free_node(data->ni); 720145247Sdamien 721145247Sdamien if (data->map != NULL) 722145247Sdamien bus_dmamap_destroy(ring->data_dmat, data->map); 723145247Sdamien } 724145247Sdamien 725145247Sdamien free(ring->data, M_DEVBUF); 726145247Sdamien } 727145247Sdamien 728145247Sdamien if (ring->data_dmat != NULL) 729145247Sdamien bus_dma_tag_destroy(ring->data_dmat); 730145247Sdamien} 731145247Sdamien 732145247Sdamienstatic int 733145247Sdamieniwi_alloc_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring, int count) 734145247Sdamien{ 735145247Sdamien struct iwi_rx_data *data; 736145247Sdamien int i, error; 737145247Sdamien 738145247Sdamien ring->count = count; 739145247Sdamien ring->cur = 0; 740145247Sdamien 741145247Sdamien ring->data = malloc(count * sizeof (struct iwi_rx_data), M_DEVBUF, 742145247Sdamien M_NOWAIT | M_ZERO); 743145247Sdamien if (ring->data == NULL) { 744145247Sdamien device_printf(sc->sc_dev, "could not allocate soft data\n"); 745145247Sdamien error = ENOMEM; 746145247Sdamien goto fail; 747145247Sdamien } 748145247Sdamien 749166416Skevlo error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 1, 0, 750166416Skevlo BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, MCLBYTES, 751166416Skevlo 1, MCLBYTES, 0, NULL, NULL, &ring->data_dmat); 752145247Sdamien if (error != 0) { 753145247Sdamien device_printf(sc->sc_dev, "could not create data DMA tag\n"); 754145247Sdamien goto fail; 755145247Sdamien } 756145247Sdamien 757145247Sdamien for (i = 0; i < count; i++) { 758145247Sdamien data = &ring->data[i]; 759145247Sdamien 760145247Sdamien error = bus_dmamap_create(ring->data_dmat, 0, &data->map); 761145247Sdamien if (error != 0) { 762145247Sdamien device_printf(sc->sc_dev, "could not create DMA map\n"); 763145247Sdamien goto fail; 764145247Sdamien } 765145247Sdamien 766145247Sdamien data->m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 767145247Sdamien if (data->m == NULL) { 768145247Sdamien device_printf(sc->sc_dev, 769145247Sdamien "could not allocate rx mbuf\n"); 770145247Sdamien error = ENOMEM; 771145247Sdamien goto fail; 772145247Sdamien } 773145247Sdamien 774145247Sdamien error = bus_dmamap_load(ring->data_dmat, data->map, 775145247Sdamien mtod(data->m, void *), MCLBYTES, iwi_dma_map_addr, 776145247Sdamien &data->physaddr, 0); 777145247Sdamien if (error != 0) { 778145247Sdamien device_printf(sc->sc_dev, 779145247Sdamien "could not load rx buf DMA map"); 780145247Sdamien goto fail; 781145247Sdamien } 782145247Sdamien 783145247Sdamien data->reg = IWI_CSR_RX_BASE + i * 4; 784145247Sdamien } 785145247Sdamien 786145247Sdamien return 0; 787145247Sdamien 788145247Sdamienfail: iwi_free_rx_ring(sc, ring); 789145247Sdamien return error; 790145247Sdamien} 791145247Sdamien 792145247Sdamienstatic void 793145247Sdamieniwi_reset_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring) 794145247Sdamien{ 795145247Sdamien ring->cur = 0; 796145247Sdamien} 797145247Sdamien 798145247Sdamienstatic void 799145247Sdamieniwi_free_rx_ring(struct iwi_softc *sc, struct iwi_rx_ring *ring) 800145247Sdamien{ 801145247Sdamien struct iwi_rx_data *data; 802145247Sdamien int i; 803145247Sdamien 804145247Sdamien if (ring->data != NULL) { 805145247Sdamien for (i = 0; i < ring->count; i++) { 806145247Sdamien data = &ring->data[i]; 807145247Sdamien 808145247Sdamien if (data->m != NULL) { 809145247Sdamien bus_dmamap_sync(ring->data_dmat, data->map, 810145247Sdamien BUS_DMASYNC_POSTREAD); 811145247Sdamien bus_dmamap_unload(ring->data_dmat, data->map); 812145247Sdamien m_freem(data->m); 813145247Sdamien } 814145247Sdamien 815145247Sdamien if (data->map != NULL) 816145247Sdamien bus_dmamap_destroy(ring->data_dmat, data->map); 817145247Sdamien } 818145247Sdamien 819145247Sdamien free(ring->data, M_DEVBUF); 820145247Sdamien } 821145247Sdamien 822145247Sdamien if (ring->data_dmat != NULL) 823145247Sdamien bus_dma_tag_destroy(ring->data_dmat); 824145247Sdamien} 825145247Sdamien 826145247Sdamienstatic int 827145247Sdamieniwi_shutdown(device_t dev) 828145247Sdamien{ 829145247Sdamien struct iwi_softc *sc = device_get_softc(dev); 830145247Sdamien 831145247Sdamien iwi_stop(sc); 832158089Smlaier iwi_put_firmware(sc); /* ??? XXX */ 833145247Sdamien 834145247Sdamien return 0; 835145247Sdamien} 836145247Sdamien 837145247Sdamienstatic int 838145247Sdamieniwi_suspend(device_t dev) 839145247Sdamien{ 840145247Sdamien struct iwi_softc *sc = device_get_softc(dev); 841145247Sdamien 842145247Sdamien iwi_stop(sc); 843145247Sdamien 844145247Sdamien return 0; 845145247Sdamien} 846145247Sdamien 847145247Sdamienstatic int 848145247Sdamieniwi_resume(device_t dev) 849145247Sdamien{ 850145247Sdamien struct iwi_softc *sc = device_get_softc(dev); 851145247Sdamien struct ifnet *ifp = sc->sc_ic.ic_ifp; 852158089Smlaier IWI_LOCK_DECL; 853145247Sdamien 854158089Smlaier IWI_LOCK(sc); 855145247Sdamien 856146500Sdamien pci_write_config(dev, 0x41, 0, 1); 857146500Sdamien 858145247Sdamien if (ifp->if_flags & IFF_UP) { 859145247Sdamien ifp->if_init(ifp->if_softc); 860148887Srwatson if (ifp->if_drv_flags & IFF_DRV_RUNNING) 861145247Sdamien ifp->if_start(ifp); 862145247Sdamien } 863145247Sdamien 864158089Smlaier IWI_UNLOCK(sc); 865145247Sdamien 866145247Sdamien return 0; 867145247Sdamien} 868145247Sdamien 869150341Sdamienstatic struct ieee80211_node * 870150341Sdamieniwi_node_alloc(struct ieee80211_node_table *nt) 871150341Sdamien{ 872150341Sdamien struct iwi_node *in; 873150341Sdamien 874150341Sdamien in = malloc(sizeof (struct iwi_node), M_80211_NODE, M_NOWAIT | M_ZERO); 875150341Sdamien if (in == NULL) 876150341Sdamien return NULL; 877150341Sdamien 878150341Sdamien in->in_station = -1; 879150341Sdamien 880150341Sdamien return &in->in_node; 881150341Sdamien} 882150341Sdamien 883150341Sdamienstatic void 884150341Sdamieniwi_node_free(struct ieee80211_node *ni) 885150341Sdamien{ 886150341Sdamien struct ieee80211com *ic = ni->ni_ic; 887150341Sdamien struct iwi_softc *sc = ic->ic_ifp->if_softc; 888150341Sdamien struct iwi_node *in = (struct iwi_node *)ni; 889150341Sdamien 890158089Smlaier if (in->in_station != -1) { 891158089Smlaier DPRINTF(("%s mac %6D station %u\n", __func__, 892158089Smlaier ni->ni_macaddr, ":", in->in_station)); 893150341Sdamien free_unr(sc->sc_unr, in->in_station); 894158089Smlaier } 895150341Sdamien 896150341Sdamien sc->sc_node_free(ni); 897150341Sdamien} 898150341Sdamien 899145247Sdamienstatic int 900145247Sdamieniwi_media_change(struct ifnet *ifp) 901145247Sdamien{ 902145247Sdamien struct iwi_softc *sc = ifp->if_softc; 903145247Sdamien int error; 904158089Smlaier IWI_LOCK_DECL; 905145247Sdamien 906158089Smlaier IWI_LOCK(sc); 907145247Sdamien 908145247Sdamien error = ieee80211_media_change(ifp); 909158089Smlaier if (error == ENETRESET && 910158089Smlaier (ifp->if_flags & IFF_UP) && (ifp->if_drv_flags & IFF_DRV_RUNNING)) 911158089Smlaier iwi_init_locked(sc, 0); 912145247Sdamien 913158089Smlaier IWI_UNLOCK(sc); 914145247Sdamien 915158089Smlaier return error; 916158089Smlaier} 917145247Sdamien 918158089Smlaier/* 919158089Smlaier * Convert h/w rate code to IEEE rate code. 920158089Smlaier */ 921158089Smlaierstatic int 922158089Smlaieriwi_cvtrate(int iwirate) 923158089Smlaier{ 924158089Smlaier switch (iwirate) { 925158089Smlaier case IWI_RATE_DS1: return 2; 926158089Smlaier case IWI_RATE_DS2: return 4; 927158089Smlaier case IWI_RATE_DS5: return 11; 928158089Smlaier case IWI_RATE_DS11: return 22; 929158089Smlaier case IWI_RATE_OFDM6: return 12; 930158089Smlaier case IWI_RATE_OFDM9: return 18; 931158089Smlaier case IWI_RATE_OFDM12: return 24; 932158089Smlaier case IWI_RATE_OFDM18: return 36; 933158089Smlaier case IWI_RATE_OFDM24: return 48; 934158089Smlaier case IWI_RATE_OFDM36: return 72; 935158089Smlaier case IWI_RATE_OFDM48: return 96; 936158089Smlaier case IWI_RATE_OFDM54: return 108; 937158089Smlaier } 938145247Sdamien return 0; 939145247Sdamien} 940145247Sdamien 941145247Sdamien/* 942150341Sdamien * The firmware automatically adapts the transmit speed. We report its current 943150341Sdamien * value here. 944145247Sdamien */ 945145247Sdamienstatic void 946145247Sdamieniwi_media_status(struct ifnet *ifp, struct ifmediareq *imr) 947145247Sdamien{ 948145247Sdamien struct iwi_softc *sc = ifp->if_softc; 949145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 950158089Smlaier int rate; 951145247Sdamien 952145247Sdamien imr->ifm_status = IFM_AVALID; 953145247Sdamien imr->ifm_active = IFM_IEEE80211; 954145247Sdamien if (ic->ic_state == IEEE80211_S_RUN) 955145247Sdamien imr->ifm_status |= IFM_ACTIVE; 956145247Sdamien 957145247Sdamien /* read current transmission rate from adapter */ 958158089Smlaier rate = iwi_cvtrate(CSR_READ_4(sc, IWI_CSR_CURRENT_TX_RATE)); 959145247Sdamien imr->ifm_active |= ieee80211_rate2media(ic, rate, ic->ic_curmode); 960145247Sdamien 961158089Smlaier if (ic->ic_opmode == IEEE80211_M_IBSS) 962145247Sdamien imr->ifm_active |= IFM_IEEE80211_ADHOC; 963158089Smlaier else if (ic->ic_opmode == IEEE80211_M_MONITOR) 964145247Sdamien imr->ifm_active |= IFM_IEEE80211_MONITOR; 965145247Sdamien} 966145247Sdamien 967145247Sdamienstatic int 968145247Sdamieniwi_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) 969145247Sdamien{ 970145247Sdamien struct ifnet *ifp = ic->ic_ifp; 971145247Sdamien struct iwi_softc *sc = ifp->if_softc; 972145247Sdamien 973158089Smlaier DPRINTF(("%s: %s -> %s flags 0x%x\n", __func__, 974158089Smlaier ieee80211_state_name[ic->ic_state], 975158089Smlaier ieee80211_state_name[nstate], sc->flags)); 976154992Sdamien 977158089Smlaier /* XXX state change race with taskqueue */ 978145247Sdamien switch (nstate) { 979145247Sdamien case IEEE80211_S_SCAN: 980158089Smlaier if (ic->ic_state == IEEE80211_S_RUN) { 981158089Smlaier /* 982158089Smlaier * Beacon miss, send disassoc and wait for a reply 983158089Smlaier * from the card; we'll start a scan then. Note 984158089Smlaier * this only happens with auto roaming; otherwise 985158089Smlaier * just notify users and wait to be directed. 986158089Smlaier */ 987158089Smlaier /* notify directly as we bypass net80211 */ 988158089Smlaier ieee80211_sta_leave(ic, ic->ic_bss); 989158089Smlaier if (ic->ic_roaming == IEEE80211_ROAMING_AUTO) 990158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_downtask); 991146500Sdamien break; 992158089Smlaier } 993158089Smlaier if ((sc->flags & IWI_FLAG_SCANNING) == 0) { 994158089Smlaier sc->flags |= IWI_FLAG_SCANNING; 995158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_scanstarttask); 996158089Smlaier } 997145247Sdamien break; 998145247Sdamien 999145247Sdamien case IEEE80211_S_AUTH: 1000145247Sdamien iwi_auth_and_assoc(sc); 1001145247Sdamien break; 1002145247Sdamien 1003145247Sdamien case IEEE80211_S_RUN: 1004158089Smlaier if (ic->ic_opmode == IEEE80211_M_IBSS) { 1005158089Smlaier /* 1006158089Smlaier * XXX when joining an ibss network we are called 1007158089Smlaier * with a SCAN -> RUN transition on scan complete. 1008158089Smlaier * Use that to call iwi_auth_and_assoc. On completing 1009158089Smlaier * the join we are then called again with an 1010158089Smlaier * AUTH -> RUN transition and we want to do nothing. 1011158089Smlaier * This is all totally bogus and needs to be redone. 1012158089Smlaier */ 1013158089Smlaier if (ic->ic_state == IEEE80211_S_SCAN) 1014158089Smlaier iwi_auth_and_assoc(sc); 1015158089Smlaier } else if (ic->ic_opmode == IEEE80211_M_MONITOR) 1016158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_scantask); 1017146500Sdamien 1018158089Smlaier /* XXX way wrong */ 1019146500Sdamien return sc->sc_newstate(ic, nstate, 1020146500Sdamien IEEE80211_FC0_SUBTYPE_ASSOC_RESP); 1021146500Sdamien 1022146500Sdamien case IEEE80211_S_ASSOC: 1023145247Sdamien break; 1024145247Sdamien 1025145247Sdamien case IEEE80211_S_INIT: 1026158089Smlaier /* 1027158089Smlaier * NB: don't try to do this if iwi_stop_master has 1028158089Smlaier * shutdown the firmware and disabled interrupts. 1029158089Smlaier */ 1030158089Smlaier if (ic->ic_state == IEEE80211_S_RUN && 1031158089Smlaier (sc->flags & IWI_FLAG_FW_INITED)) 1032158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_downtask); 1033145247Sdamien break; 1034145247Sdamien } 1035145247Sdamien 1036145247Sdamien ic->ic_state = nstate; 1037145247Sdamien return 0; 1038145247Sdamien} 1039145247Sdamien 1040149346Sdamien/* 1041149346Sdamien * WME parameters coming from IEEE 802.11e specification. These values are 1042149346Sdamien * already declared in ieee80211_proto.c, but they are static so they can't 1043149346Sdamien * be reused here. 1044149346Sdamien */ 1045149346Sdamienstatic const struct wmeParams iwi_wme_cck_params[WME_NUM_AC] = { 1046149346Sdamien { 0, 3, 5, 7, 0 }, /* WME_AC_BE */ 1047149346Sdamien { 0, 3, 5, 10, 0 }, /* WME_AC_BK */ 1048149346Sdamien { 0, 2, 4, 5, 188 }, /* WME_AC_VI */ 1049149346Sdamien { 0, 2, 3, 4, 102 } /* WME_AC_VO */ 1050149346Sdamien}; 1051149346Sdamien 1052149346Sdamienstatic const struct wmeParams iwi_wme_ofdm_params[WME_NUM_AC] = { 1053149346Sdamien { 0, 3, 4, 6, 0 }, /* WME_AC_BE */ 1054149346Sdamien { 0, 3, 4, 10, 0 }, /* WME_AC_BK */ 1055149346Sdamien { 0, 2, 3, 4, 94 }, /* WME_AC_VI */ 1056149346Sdamien { 0, 2, 2, 3, 47 } /* WME_AC_VO */ 1057149346Sdamien}; 1058158089Smlaier#define IWI_EXP2(v) htole16((1 << (v)) - 1) 1059158089Smlaier#define IWI_USEC(v) htole16(IEEE80211_TXOP_TO_US(v)) 1060149346Sdamien 1061158089Smlaierstatic void 1062158089Smlaieriwi_wme_init(struct iwi_softc *sc) 1063149338Sdamien{ 1064149346Sdamien const struct wmeParams *wmep; 1065149346Sdamien int ac; 1066149338Sdamien 1067158089Smlaier memset(sc->wme, 0, sizeof sc->wme); 1068149346Sdamien for (ac = 0; ac < WME_NUM_AC; ac++) { 1069149346Sdamien /* set WME values for CCK modulation */ 1070149346Sdamien wmep = &iwi_wme_cck_params[ac]; 1071158089Smlaier sc->wme[1].aifsn[ac] = wmep->wmep_aifsn; 1072158089Smlaier sc->wme[1].cwmin[ac] = IWI_EXP2(wmep->wmep_logcwmin); 1073158089Smlaier sc->wme[1].cwmax[ac] = IWI_EXP2(wmep->wmep_logcwmax); 1074158089Smlaier sc->wme[1].burst[ac] = IWI_USEC(wmep->wmep_txopLimit); 1075158089Smlaier sc->wme[1].acm[ac] = wmep->wmep_acm; 1076149346Sdamien 1077149346Sdamien /* set WME values for OFDM modulation */ 1078149346Sdamien wmep = &iwi_wme_ofdm_params[ac]; 1079158089Smlaier sc->wme[2].aifsn[ac] = wmep->wmep_aifsn; 1080158089Smlaier sc->wme[2].cwmin[ac] = IWI_EXP2(wmep->wmep_logcwmin); 1081158089Smlaier sc->wme[2].cwmax[ac] = IWI_EXP2(wmep->wmep_logcwmax); 1082158089Smlaier sc->wme[2].burst[ac] = IWI_USEC(wmep->wmep_txopLimit); 1083158089Smlaier sc->wme[2].acm[ac] = wmep->wmep_acm; 1084149346Sdamien } 1085158089Smlaier} 1086149346Sdamien 1087158089Smlaierstatic int 1088158089Smlaieriwi_wme_setparams_locked(struct iwi_softc *sc) 1089158089Smlaier{ 1090158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 1091158089Smlaier const struct wmeParams *wmep; 1092158089Smlaier int ac; 1093158089Smlaier 1094158089Smlaier for (ac = 0; ac < WME_NUM_AC; ac++) { 1095158089Smlaier /* set WME values for current operating mode */ 1096158089Smlaier wmep = &ic->ic_wme.wme_chanParams.cap_wmeParams[ac]; 1097158089Smlaier sc->wme[0].aifsn[ac] = wmep->wmep_aifsn; 1098158089Smlaier sc->wme[0].cwmin[ac] = IWI_EXP2(wmep->wmep_logcwmin); 1099158089Smlaier sc->wme[0].cwmax[ac] = IWI_EXP2(wmep->wmep_logcwmax); 1100158089Smlaier sc->wme[0].burst[ac] = IWI_USEC(wmep->wmep_txopLimit); 1101158089Smlaier sc->wme[0].acm[ac] = wmep->wmep_acm; 1102158089Smlaier } 1103158089Smlaier 1104149346Sdamien DPRINTF(("Setting WME parameters\n")); 1105158089Smlaier return iwi_cmd(sc, IWI_CMD_SET_WME_PARAMS, sc->wme, sizeof sc->wme); 1106158089Smlaier} 1107158089Smlaier 1108158089Smlaierstatic void 1109158089Smlaieriwi_wme_setparams(void *arg, int npending) 1110158089Smlaier{ 1111158089Smlaier struct iwi_softc *sc = arg; 1112158089Smlaier IWI_LOCK_DECL; 1113158089Smlaier 1114158089Smlaier IWI_LOCK(sc); 1115158089Smlaier (void) iwi_wme_setparams_locked(sc); 1116158089Smlaier IWI_UNLOCK(sc); 1117158089Smlaier} 1118149346Sdamien#undef IWI_USEC 1119149346Sdamien#undef IWI_EXP2 1120158089Smlaier 1121158089Smlaierstatic int 1122158089Smlaieriwi_wme_update(struct ieee80211com *ic) 1123158089Smlaier{ 1124158089Smlaier struct iwi_softc *sc = ic->ic_ifp->if_softc; 1125158089Smlaier 1126158089Smlaier /* 1127158089Smlaier * We may be called to update the WME parameters in 1128158089Smlaier * the adapter at various places. If we're already 1129158089Smlaier * associated then initiate the request immediately 1130158089Smlaier * (via the taskqueue); otherwise we assume the params 1131158089Smlaier * will get sent down to the adapter as part of the 1132158089Smlaier * work iwi_auth_and_assoc does. 1133158089Smlaier */ 1134158089Smlaier if (ic->ic_state == IEEE80211_S_RUN) 1135158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_setwmetask); 1136158089Smlaier return 0; 1137149338Sdamien} 1138149338Sdamien 1139158089Smlaierstatic int 1140158089Smlaieriwi_wme_setie(struct iwi_softc *sc) 1141158089Smlaier{ 1142158089Smlaier struct ieee80211_wme_info wme; 1143158089Smlaier 1144158089Smlaier memset(&wme, 0, sizeof wme); 1145158089Smlaier wme.wme_id = IEEE80211_ELEMID_VENDOR; 1146158089Smlaier wme.wme_len = sizeof (struct ieee80211_wme_info) - 2; 1147158089Smlaier wme.wme_oui[0] = 0x00; 1148158089Smlaier wme.wme_oui[1] = 0x50; 1149158089Smlaier wme.wme_oui[2] = 0xf2; 1150158089Smlaier wme.wme_type = WME_OUI_TYPE; 1151158089Smlaier wme.wme_subtype = WME_INFO_OUI_SUBTYPE; 1152158089Smlaier wme.wme_version = WME_VERSION; 1153158089Smlaier wme.wme_info = 0; 1154158089Smlaier 1155158089Smlaier DPRINTF(("Setting WME IE (len=%u)\n", wme.wme_len)); 1156158089Smlaier return iwi_cmd(sc, IWI_CMD_SET_WMEIE, &wme, sizeof wme); 1157158089Smlaier} 1158158089Smlaier 1159145247Sdamien/* 1160145247Sdamien * Read 16 bits at address 'addr' from the serial EEPROM. 1161145247Sdamien */ 1162145247Sdamienstatic uint16_t 1163145247Sdamieniwi_read_prom_word(struct iwi_softc *sc, uint8_t addr) 1164145247Sdamien{ 1165145247Sdamien uint32_t tmp; 1166145247Sdamien uint16_t val; 1167145247Sdamien int n; 1168145247Sdamien 1169145247Sdamien /* clock C once before the first command */ 1170145247Sdamien IWI_EEPROM_CTL(sc, 0); 1171145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1172145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C); 1173145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1174145247Sdamien 1175145247Sdamien /* write start bit (1) */ 1176145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D); 1177145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D | IWI_EEPROM_C); 1178145247Sdamien 1179145247Sdamien /* write READ opcode (10) */ 1180145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D); 1181145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_D | IWI_EEPROM_C); 1182145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1183145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C); 1184145247Sdamien 1185145247Sdamien /* write address A7-A0 */ 1186145247Sdamien for (n = 7; n >= 0; n--) { 1187145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | 1188145247Sdamien (((addr >> n) & 1) << IWI_EEPROM_SHIFT_D)); 1189145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | 1190145247Sdamien (((addr >> n) & 1) << IWI_EEPROM_SHIFT_D) | IWI_EEPROM_C); 1191145247Sdamien } 1192145247Sdamien 1193145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1194145247Sdamien 1195145247Sdamien /* read data Q15-Q0 */ 1196145247Sdamien val = 0; 1197145247Sdamien for (n = 15; n >= 0; n--) { 1198145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S | IWI_EEPROM_C); 1199145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1200145247Sdamien tmp = MEM_READ_4(sc, IWI_MEM_EEPROM_CTL); 1201145247Sdamien val |= ((tmp & IWI_EEPROM_Q) >> IWI_EEPROM_SHIFT_Q) << n; 1202145247Sdamien } 1203145247Sdamien 1204145247Sdamien IWI_EEPROM_CTL(sc, 0); 1205145247Sdamien 1206145247Sdamien /* clear Chip Select and clock C */ 1207145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_S); 1208145247Sdamien IWI_EEPROM_CTL(sc, 0); 1209145247Sdamien IWI_EEPROM_CTL(sc, IWI_EEPROM_C); 1210145247Sdamien 1211152389Sdamien return val; 1212145247Sdamien} 1213145247Sdamien 1214145247Sdamienstatic void 1215158089Smlaieriwi_setcurchan(struct iwi_softc *sc, int chan) 1216145247Sdamien{ 1217158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 1218145247Sdamien 1219158089Smlaier ic->ic_curchan = &ic->ic_channels[chan]; 1220158089Smlaier sc->curchan = chan; 1221145247Sdamien 1222158089Smlaier sc->sc_rxtap.wr_chan_freq = sc->sc_txtap.wt_chan_freq = 1223158089Smlaier htole16(ic->ic_curchan->ic_freq); 1224158089Smlaier sc->sc_rxtap.wr_chan_flags = sc->sc_txtap.wt_chan_flags = 1225158089Smlaier htole16(ic->ic_curchan->ic_flags); 1226145247Sdamien} 1227145247Sdamien 1228145247Sdamienstatic void 1229145247Sdamieniwi_frame_intr(struct iwi_softc *sc, struct iwi_rx_data *data, int i, 1230145247Sdamien struct iwi_frame *frame) 1231145247Sdamien{ 1232145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 1233145247Sdamien struct ifnet *ifp = ic->ic_ifp; 1234152384Sdamien struct mbuf *mnew, *m; 1235145247Sdamien struct ieee80211_node *ni; 1236158089Smlaier int type, error, framelen; 1237164964Smlaier IWI_LOCK_DECL; 1238145247Sdamien 1239158089Smlaier framelen = le16toh(frame->len); 1240158089Smlaier if (framelen < IEEE80211_MIN_LEN || framelen > MCLBYTES) { 1241158089Smlaier /* 1242158089Smlaier * XXX >MCLBYTES is bogus as it means the h/w dma'd 1243158089Smlaier * out of bounds; need to figure out how to limit 1244158089Smlaier * frame size in the firmware 1245158089Smlaier */ 1246158089Smlaier /* XXX stat */ 1247158089Smlaier DPRINTFN(1, 1248158089Smlaier ("drop rx frame len=%u chan=%u rssi=%u rssi_dbm=%u\n", 1249158089Smlaier le16toh(frame->len), frame->chan, frame->rssi, 1250158089Smlaier frame->rssi_dbm)); 1251146500Sdamien return; 1252158089Smlaier } 1253146500Sdamien 1254158089Smlaier DPRINTFN(5, ("received frame len=%u chan=%u rssi=%u rssi_dbm=%u\n", 1255158089Smlaier le16toh(frame->len), frame->chan, frame->rssi, frame->rssi_dbm)); 1256158089Smlaier 1257158089Smlaier if (frame->chan != sc->curchan) 1258158089Smlaier iwi_setcurchan(sc, frame->chan); 1259158089Smlaier 1260152384Sdamien /* 1261152384Sdamien * Try to allocate a new mbuf for this ring element and load it before 1262152384Sdamien * processing the current mbuf. If the ring element cannot be loaded, 1263152384Sdamien * drop the received packet and reuse the old mbuf. In the unlikely 1264152384Sdamien * case that the old mbuf can't be reloaded either, explicitly panic. 1265152384Sdamien */ 1266152384Sdamien mnew = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR); 1267152384Sdamien if (mnew == NULL) { 1268152384Sdamien ifp->if_ierrors++; 1269152384Sdamien return; 1270152384Sdamien } 1271152384Sdamien 1272145247Sdamien bus_dmamap_unload(sc->rxq.data_dmat, data->map); 1273145247Sdamien 1274152384Sdamien error = bus_dmamap_load(sc->rxq.data_dmat, data->map, 1275152384Sdamien mtod(mnew, void *), MCLBYTES, iwi_dma_map_addr, &data->physaddr, 1276152384Sdamien 0); 1277152384Sdamien if (error != 0) { 1278152384Sdamien m_freem(mnew); 1279152384Sdamien 1280152384Sdamien /* try to reload the old mbuf */ 1281152384Sdamien error = bus_dmamap_load(sc->rxq.data_dmat, data->map, 1282152384Sdamien mtod(data->m, void *), MCLBYTES, iwi_dma_map_addr, 1283152384Sdamien &data->physaddr, 0); 1284152384Sdamien if (error != 0) { 1285152384Sdamien /* very unlikely that it will fail... */ 1286152384Sdamien panic("%s: could not load old rx mbuf", 1287152384Sdamien device_get_name(sc->sc_dev)); 1288152384Sdamien } 1289152384Sdamien ifp->if_ierrors++; 1290152384Sdamien return; 1291152384Sdamien } 1292152384Sdamien 1293152384Sdamien /* 1294152384Sdamien * New mbuf successfully loaded, update Rx ring and continue 1295152384Sdamien * processing. 1296152384Sdamien */ 1297152384Sdamien m = data->m; 1298152384Sdamien data->m = mnew; 1299152384Sdamien CSR_WRITE_4(sc, data->reg, data->physaddr); 1300152384Sdamien 1301145247Sdamien /* finalize mbuf */ 1302145247Sdamien m->m_pkthdr.rcvif = ifp; 1303145247Sdamien m->m_pkthdr.len = m->m_len = sizeof (struct iwi_hdr) + 1304158089Smlaier sizeof (struct iwi_frame) + framelen; 1305145247Sdamien 1306145247Sdamien m_adj(m, sizeof (struct iwi_hdr) + sizeof (struct iwi_frame)); 1307145247Sdamien 1308159180Scsjp if (bpf_peers_present(sc->sc_drvbpf)) { 1309145247Sdamien struct iwi_rx_radiotap_header *tap = &sc->sc_rxtap; 1310145247Sdamien 1311145247Sdamien tap->wr_flags = 0; 1312158089Smlaier tap->wr_rate = iwi_cvtrate(frame->rate); 1313145247Sdamien tap->wr_antsignal = frame->signal; 1314145247Sdamien tap->wr_antenna = frame->antenna; 1315145247Sdamien 1316145247Sdamien bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_rxtap_len, m); 1317145247Sdamien } 1318164964Smlaier IWI_UNLOCK(sc); 1319145247Sdamien 1320158089Smlaier ni = ieee80211_find_rxnode(ic, mtod(m, struct ieee80211_frame_min *)); 1321145247Sdamien 1322145247Sdamien /* send the frame to the 802.11 layer */ 1323158089Smlaier type = ieee80211_input(ic, m, ni, frame->rssi_dbm, 0); 1324145247Sdamien 1325145247Sdamien /* node is no longer needed */ 1326145247Sdamien ieee80211_free_node(ni); 1327158089Smlaier 1328164964Smlaier IWI_LOCK(sc); 1329158089Smlaier if (sc->sc_softled) { 1330158089Smlaier /* 1331158089Smlaier * Blink for any data frame. Otherwise do a 1332158089Smlaier * heartbeat-style blink when idle. The latter 1333158089Smlaier * is mainly for station mode where we depend on 1334158089Smlaier * periodic beacon frames to trigger the poll event. 1335158089Smlaier */ 1336158089Smlaier if (type == IEEE80211_FC0_TYPE_DATA) { 1337158089Smlaier sc->sc_rxrate = frame->rate; 1338158089Smlaier iwi_led_event(sc, IWI_LED_RX); 1339158089Smlaier } else if (ticks - sc->sc_ledevent >= sc->sc_ledidle) 1340158089Smlaier iwi_led_event(sc, IWI_LED_POLL); 1341158089Smlaier } 1342145247Sdamien} 1343145247Sdamien 1344158089Smlaier/* unaligned little endian access */ 1345158089Smlaier#define LE_READ_2(p) \ 1346158089Smlaier ((u_int16_t) \ 1347158089Smlaier ((((const u_int8_t *)(p))[0] ) | \ 1348158089Smlaier (((const u_int8_t *)(p))[1] << 8))) 1349158089Smlaier#define LE_READ_4(p) \ 1350158089Smlaier ((u_int32_t) \ 1351158089Smlaier ((((const u_int8_t *)(p))[0] ) | \ 1352158089Smlaier (((const u_int8_t *)(p))[1] << 8) | \ 1353158089Smlaier (((const u_int8_t *)(p))[2] << 16) | \ 1354158089Smlaier (((const u_int8_t *)(p))[3] << 24))) 1355158089Smlaier 1356158089Smlaier#define IEEE80211_VERIFY_LENGTH(_len, _minlen) do { \ 1357158089Smlaier if ((_len) < (_minlen)) { \ 1358158089Smlaier return; \ 1359158089Smlaier } \ 1360158089Smlaier} while (0) 1361158089Smlaier 1362158089Smlaierstatic int __inline 1363158089Smlaieriswmeoui(const u_int8_t *frm) 1364158089Smlaier{ 1365158089Smlaier return frm[1] > 3 && LE_READ_4(frm+2) == ((WME_OUI_TYPE<<24)|WME_OUI); 1366158089Smlaier} 1367158089Smlaier 1368158089Smlaier/* 1369158089Smlaier * Check for an association response frame to see if QoS 1370158089Smlaier * has been negotiated. We parse just enough to figure 1371158089Smlaier * out if we're supposed to use QoS. The proper solution 1372158089Smlaier * is to pass the frame up so ieee80211_input can do the 1373158089Smlaier * work but that's made hard by how things currently are 1374158089Smlaier * done in the driver. 1375158089Smlaier */ 1376145247Sdamienstatic void 1377158089Smlaieriwi_checkforqos(struct iwi_softc *sc, const struct ieee80211_frame *wh, int len) 1378158089Smlaier{ 1379158089Smlaier#define SUBTYPE(wh) ((wh)->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) 1380158089Smlaier const uint8_t *frm, *efrm, *wme; 1381158089Smlaier struct ieee80211_node *ni; 1382158089Smlaier 1383158089Smlaier /* NB: +8 for capinfo, status, associd, and first ie */ 1384158089Smlaier if (!(sizeof(*wh)+8 < len && len < IEEE80211_MAX_LEN) || 1385158089Smlaier SUBTYPE(wh) != IEEE80211_FC0_SUBTYPE_ASSOC_RESP) 1386158089Smlaier return; 1387158089Smlaier /* 1388158089Smlaier * asresp frame format 1389158089Smlaier * [2] capability information 1390158089Smlaier * [2] status 1391158089Smlaier * [2] association ID 1392158089Smlaier * [tlv] supported rates 1393158089Smlaier * [tlv] extended supported rates 1394158089Smlaier * [tlv] WME 1395158089Smlaier */ 1396158089Smlaier frm = (const uint8_t *)&wh[1]; 1397158089Smlaier efrm = ((const uint8_t *) wh) + len; 1398158089Smlaier frm += 6; 1399158089Smlaier 1400158089Smlaier wme = NULL; 1401158089Smlaier while (frm < efrm) { 1402158089Smlaier IEEE80211_VERIFY_LENGTH(efrm - frm, frm[1]); 1403158089Smlaier switch (*frm) { 1404158089Smlaier case IEEE80211_ELEMID_VENDOR: 1405158089Smlaier if (iswmeoui(frm)) 1406158089Smlaier wme = frm; 1407158089Smlaier break; 1408158089Smlaier } 1409158089Smlaier frm += frm[1] + 2; 1410158089Smlaier } 1411158089Smlaier 1412158089Smlaier ni = sc->sc_ic.ic_bss; 1413158089Smlaier if (wme != NULL) 1414158089Smlaier ni->ni_flags |= IEEE80211_NODE_QOS; 1415158089Smlaier else 1416158089Smlaier ni->ni_flags &= ~IEEE80211_NODE_QOS; 1417158089Smlaier#undef SUBTYPE 1418158089Smlaier} 1419158089Smlaier 1420158089Smlaierstatic void 1421145247Sdamieniwi_notification_intr(struct iwi_softc *sc, struct iwi_notif *notif) 1422145247Sdamien{ 1423145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 1424145247Sdamien struct iwi_notif_scan_channel *chan; 1425145247Sdamien struct iwi_notif_scan_complete *scan; 1426145247Sdamien struct iwi_notif_authentication *auth; 1427145247Sdamien struct iwi_notif_association *assoc; 1428158089Smlaier struct iwi_notif_beacon_state *beacon; 1429145247Sdamien 1430145247Sdamien switch (notif->type) { 1431145247Sdamien case IWI_NOTIF_TYPE_SCAN_CHANNEL: 1432145247Sdamien chan = (struct iwi_notif_scan_channel *)(notif + 1); 1433145247Sdamien 1434158089Smlaier DPRINTFN(3, ("Scan of channel %u complete (%u)\n", 1435158089Smlaier ic->ic_channels[chan->nchan].ic_freq, chan->nchan)); 1436145247Sdamien break; 1437145247Sdamien 1438145247Sdamien case IWI_NOTIF_TYPE_SCAN_COMPLETE: 1439145247Sdamien scan = (struct iwi_notif_scan_complete *)(notif + 1); 1440145247Sdamien 1441145247Sdamien DPRINTFN(2, ("Scan completed (%u, %u)\n", scan->nchan, 1442145247Sdamien scan->status)); 1443145247Sdamien 1444158089Smlaier sc->sc_scan_timer = 0; 1445158089Smlaier 1446158089Smlaier if (ic->ic_opmode == IEEE80211_M_MONITOR) { 1447158089Smlaier /* 1448158089Smlaier * Monitor mode works by doing a passive scan to set 1449158089Smlaier * the channel and enable rx. Because we don't want 1450158089Smlaier * to abort a scan lest the firmware crash we scan 1451158089Smlaier * for a short period of time and automatically restart 1452158089Smlaier * the scan when notified the sweep has completed. 1453158089Smlaier */ 1454158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_scantask); 1455158089Smlaier } else { 1456146500Sdamien sc->flags &= ~IWI_FLAG_SCANNING; 1457158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_scandonetask); 1458158089Smlaier } 1459145247Sdamien break; 1460145247Sdamien 1461145247Sdamien case IWI_NOTIF_TYPE_AUTHENTICATION: 1462145247Sdamien auth = (struct iwi_notif_authentication *)(notif + 1); 1463145247Sdamien 1464145247Sdamien switch (auth->state) { 1465158089Smlaier case IWI_AUTH_SUCCESS: 1466158089Smlaier DPRINTFN(2, ("Authentication succeeeded\n")); 1467148302Ssam ieee80211_node_authorize(ic->ic_bss); 1468145247Sdamien ieee80211_new_state(ic, IEEE80211_S_ASSOC, -1); 1469145247Sdamien break; 1470145247Sdamien 1471158089Smlaier case IWI_AUTH_FAIL: 1472158089Smlaier DPRINTFN(2, ("Authentication failed\n")); 1473158089Smlaier sc->flags &= ~IWI_FLAG_ASSOCIATED; 1474158089Smlaier /* XXX */ 1475145247Sdamien break; 1476145247Sdamien 1477158089Smlaier case IWI_AUTH_SENT_1: 1478158089Smlaier case IWI_AUTH_RECV_2: 1479158089Smlaier case IWI_AUTH_SEQ1_PASS: 1480158089Smlaier break; 1481158089Smlaier 1482158089Smlaier case IWI_AUTH_SEQ1_FAIL: 1483158089Smlaier DPRINTFN(2, ("Initial authentication handshake failed; " 1484158089Smlaier "you probably need shared key\n")); 1485158089Smlaier /* XXX retry shared key when in auto */ 1486158089Smlaier break; 1487158089Smlaier 1488145247Sdamien default: 1489145247Sdamien device_printf(sc->sc_dev, 1490145247Sdamien "unknown authentication state %u\n", auth->state); 1491145247Sdamien } 1492145247Sdamien break; 1493145247Sdamien 1494145247Sdamien case IWI_NOTIF_TYPE_ASSOCIATION: 1495145247Sdamien assoc = (struct iwi_notif_association *)(notif + 1); 1496145247Sdamien 1497145247Sdamien switch (assoc->state) { 1498158089Smlaier case IWI_AUTH_SUCCESS: 1499145247Sdamien /* re-association, do nothing */ 1500145247Sdamien break; 1501145247Sdamien 1502158089Smlaier case IWI_ASSOC_SUCCESS: 1503158089Smlaier DPRINTFN(2, ("Association succeeded\n")); 1504158089Smlaier sc->flags |= IWI_FLAG_ASSOCIATED; 1505158089Smlaier iwi_checkforqos(sc, 1506158089Smlaier (const struct ieee80211_frame *)(assoc+1), 1507158089Smlaier le16toh(notif->len) - sizeof(*assoc)); 1508145247Sdamien ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 1509145247Sdamien break; 1510145247Sdamien 1511158089Smlaier case IWI_ASSOC_FAIL: 1512158089Smlaier DPRINTFN(2, ("Association failed\n")); 1513158089Smlaier sc->flags &= ~IWI_FLAG_ASSOCIATED; 1514158089Smlaier ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 1515145247Sdamien break; 1516145247Sdamien 1517145247Sdamien default: 1518145247Sdamien device_printf(sc->sc_dev, 1519145247Sdamien "unknown association state %u\n", assoc->state); 1520145247Sdamien } 1521145247Sdamien break; 1522145247Sdamien 1523158089Smlaier case IWI_NOTIF_TYPE_BEACON: 1524158089Smlaier /* XXX check struct length */ 1525158089Smlaier beacon = (struct iwi_notif_beacon_state *)(notif + 1); 1526158089Smlaier 1527158089Smlaier DPRINTFN(5, ("Beacon state (%u, %u)\n", 1528158089Smlaier beacon->state, le32toh(beacon->number))); 1529158089Smlaier 1530158089Smlaier if (beacon->state == IWI_BEACON_MISS) { 1531158089Smlaier#if 0 1532158089Smlaier if (sc->flags & IWI_FLAG_SCANNING) { 1533158089Smlaier /* XXX terminate scan, linux driver 1534158089Smlaier says fw can get stuck */ 1535158089Smlaier /* XXX should be handled in iwi_newstate */ 1536158089Smlaier taskqueue_enqueue(sc->sc_tq, 1537158089Smlaier &sc->sc_scanaborttask); 1538158089Smlaier } 1539158089Smlaier#endif 1540158089Smlaier /* 1541158089Smlaier * The firmware notifies us of every beacon miss 1542158089Smlaier * so we need to track the count against the 1543158089Smlaier * configured threshold before notifying the 1544158089Smlaier * 802.11 layer. 1545158089Smlaier * XXX try to roam, drop assoc only on much higher count 1546158089Smlaier */ 1547158089Smlaier if (le32toh(beacon->number) >= ic->ic_bmissthreshold) { 1548158089Smlaier DPRINTF(("Beacon miss: %u >= %u\n", 1549158089Smlaier le32toh(beacon->number), 1550158089Smlaier ic->ic_bmissthreshold)); 1551158089Smlaier ieee80211_beacon_miss(ic); 1552158089Smlaier } 1553158089Smlaier } 1554158089Smlaier break; 1555158089Smlaier 1556158089Smlaier case IWI_NOTIF_TYPE_CALIBRATION: 1557158089Smlaier case IWI_NOTIF_TYPE_NOISE: 1558158089Smlaier case IWI_NOTIF_TYPE_LINK_QUALITY: 1559158089Smlaier DPRINTFN(5, ("Notification (%u)\n", notif->type)); 1560158089Smlaier break; 1561158089Smlaier 1562154992Sdamien default: 1563158089Smlaier DPRINTF(("unknown notification type %u flags 0x%x len %u\n", 1564158089Smlaier notif->type, notif->flags, le16toh(notif->len))); 1565145247Sdamien } 1566145247Sdamien} 1567145247Sdamien 1568145247Sdamienstatic void 1569145247Sdamieniwi_rx_intr(struct iwi_softc *sc) 1570145247Sdamien{ 1571145247Sdamien struct iwi_rx_data *data; 1572145247Sdamien struct iwi_hdr *hdr; 1573145247Sdamien uint32_t hw; 1574145247Sdamien 1575145247Sdamien hw = CSR_READ_4(sc, IWI_CSR_RX_RIDX); 1576145247Sdamien 1577145247Sdamien for (; sc->rxq.cur != hw;) { 1578145247Sdamien data = &sc->rxq.data[sc->rxq.cur]; 1579145247Sdamien 1580145247Sdamien bus_dmamap_sync(sc->rxq.data_dmat, data->map, 1581145247Sdamien BUS_DMASYNC_POSTREAD); 1582145247Sdamien 1583145247Sdamien hdr = mtod(data->m, struct iwi_hdr *); 1584145247Sdamien 1585145247Sdamien switch (hdr->type) { 1586145247Sdamien case IWI_HDR_TYPE_FRAME: 1587145247Sdamien iwi_frame_intr(sc, data, sc->rxq.cur, 1588145247Sdamien (struct iwi_frame *)(hdr + 1)); 1589145247Sdamien break; 1590145247Sdamien 1591145247Sdamien case IWI_HDR_TYPE_NOTIF: 1592145247Sdamien iwi_notification_intr(sc, 1593145247Sdamien (struct iwi_notif *)(hdr + 1)); 1594145247Sdamien break; 1595145247Sdamien 1596145247Sdamien default: 1597145247Sdamien device_printf(sc->sc_dev, "unknown hdr type %u\n", 1598145247Sdamien hdr->type); 1599145247Sdamien } 1600145247Sdamien 1601145247Sdamien DPRINTFN(15, ("rx done idx=%u\n", sc->rxq.cur)); 1602145247Sdamien 1603145247Sdamien sc->rxq.cur = (sc->rxq.cur + 1) % IWI_RX_RING_COUNT; 1604145247Sdamien } 1605145247Sdamien 1606145247Sdamien /* tell the firmware what we have processed */ 1607145247Sdamien hw = (hw == 0) ? IWI_RX_RING_COUNT - 1 : hw - 1; 1608145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RX_WIDX, hw); 1609145247Sdamien} 1610145247Sdamien 1611145247Sdamienstatic void 1612149338Sdamieniwi_tx_intr(struct iwi_softc *sc, struct iwi_tx_ring *txq) 1613145247Sdamien{ 1614145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 1615145247Sdamien struct ifnet *ifp = ic->ic_ifp; 1616145247Sdamien struct iwi_tx_data *data; 1617145247Sdamien uint32_t hw; 1618145247Sdamien 1619149338Sdamien hw = CSR_READ_4(sc, txq->csr_ridx); 1620145247Sdamien 1621149338Sdamien for (; txq->next != hw;) { 1622149338Sdamien data = &txq->data[txq->next]; 1623145247Sdamien 1624149338Sdamien bus_dmamap_sync(txq->data_dmat, data->map, 1625145247Sdamien BUS_DMASYNC_POSTWRITE); 1626149338Sdamien bus_dmamap_unload(txq->data_dmat, data->map); 1627145247Sdamien m_freem(data->m); 1628145247Sdamien data->m = NULL; 1629145247Sdamien ieee80211_free_node(data->ni); 1630145247Sdamien data->ni = NULL; 1631145247Sdamien 1632149338Sdamien DPRINTFN(15, ("tx done idx=%u\n", txq->next)); 1633145247Sdamien 1634145247Sdamien ifp->if_opackets++; 1635145247Sdamien 1636149338Sdamien txq->queued--; 1637149338Sdamien txq->next = (txq->next + 1) % IWI_TX_RING_COUNT; 1638145247Sdamien } 1639145247Sdamien 1640145247Sdamien sc->sc_tx_timer = 0; 1641148887Srwatson ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 1642158089Smlaier 1643158089Smlaier if (sc->sc_softled) 1644158089Smlaier iwi_led_event(sc, IWI_LED_TX); 1645158089Smlaier 1646145247Sdamien iwi_start(ifp); 1647145247Sdamien} 1648145247Sdamien 1649145247Sdamienstatic void 1650145247Sdamieniwi_intr(void *arg) 1651145247Sdamien{ 1652145247Sdamien struct iwi_softc *sc = arg; 1653145247Sdamien uint32_t r; 1654158089Smlaier IWI_LOCK_DECL; 1655145247Sdamien 1656158089Smlaier IWI_LOCK(sc); 1657145247Sdamien 1658145247Sdamien if ((r = CSR_READ_4(sc, IWI_CSR_INTR)) == 0 || r == 0xffffffff) { 1659158089Smlaier IWI_UNLOCK(sc); 1660145247Sdamien return; 1661145247Sdamien } 1662145247Sdamien 1663156547Sdamien /* acknowledge interrupts */ 1664156547Sdamien CSR_WRITE_4(sc, IWI_CSR_INTR, r); 1665145247Sdamien 1666158089Smlaier if (r & IWI_INTR_FATAL_ERROR) { 1667156598Sdamien device_printf(sc->sc_dev, "firmware error\n"); 1668158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_restarttask); 1669145247Sdamien } 1670145247Sdamien 1671158089Smlaier if (r & IWI_INTR_FW_INITED) { 1672158089Smlaier if (!(r & (IWI_INTR_FATAL_ERROR | IWI_INTR_PARITY_ERROR))) 1673158089Smlaier wakeup(sc); 1674145247Sdamien } 1675145247Sdamien 1676158089Smlaier if (r & IWI_INTR_RADIO_OFF) 1677158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_radiofftask); 1678158089Smlaier 1679158089Smlaier if (r & IWI_INTR_CMD_DONE) { 1680158089Smlaier sc->flags &= ~IWI_FLAG_BUSY; 1681145247Sdamien wakeup(sc); 1682158089Smlaier } 1683145247Sdamien 1684145247Sdamien if (r & IWI_INTR_TX1_DONE) 1685149338Sdamien iwi_tx_intr(sc, &sc->txq[0]); 1686145247Sdamien 1687149338Sdamien if (r & IWI_INTR_TX2_DONE) 1688149338Sdamien iwi_tx_intr(sc, &sc->txq[1]); 1689149338Sdamien 1690149338Sdamien if (r & IWI_INTR_TX3_DONE) 1691149338Sdamien iwi_tx_intr(sc, &sc->txq[2]); 1692149338Sdamien 1693149338Sdamien if (r & IWI_INTR_TX4_DONE) 1694149338Sdamien iwi_tx_intr(sc, &sc->txq[3]); 1695149338Sdamien 1696149338Sdamien if (r & IWI_INTR_RX_DONE) 1697149338Sdamien iwi_rx_intr(sc); 1698149338Sdamien 1699158089Smlaier if (r & IWI_INTR_PARITY_ERROR) { 1700158089Smlaier /* XXX rate-limit */ 1701158089Smlaier device_printf(sc->sc_dev, "parity error\n"); 1702158089Smlaier } 1703145247Sdamien 1704158089Smlaier IWI_UNLOCK(sc); 1705145247Sdamien} 1706145247Sdamien 1707145247Sdamienstatic int 1708158089Smlaieriwi_cmd(struct iwi_softc *sc, uint8_t type, void *data, uint8_t len) 1709145247Sdamien{ 1710145247Sdamien struct iwi_cmd_desc *desc; 1711145247Sdamien 1712158089Smlaier if (sc->flags & IWI_FLAG_BUSY) { 1713158089Smlaier device_printf(sc->sc_dev, "%s: cmd %d not sent, busy\n", 1714158089Smlaier __func__, type); 1715158089Smlaier return EAGAIN; 1716158089Smlaier } 1717158089Smlaier sc->flags |= IWI_FLAG_BUSY; 1718158089Smlaier 1719145247Sdamien desc = &sc->cmdq.desc[sc->cmdq.cur]; 1720145247Sdamien 1721145247Sdamien desc->hdr.type = IWI_HDR_TYPE_COMMAND; 1722145247Sdamien desc->hdr.flags = IWI_HDR_FLAG_IRQ; 1723145247Sdamien desc->type = type; 1724145247Sdamien desc->len = len; 1725145247Sdamien memcpy(desc->data, data, len); 1726145247Sdamien 1727145247Sdamien bus_dmamap_sync(sc->cmdq.desc_dmat, sc->cmdq.desc_map, 1728145247Sdamien BUS_DMASYNC_PREWRITE); 1729145247Sdamien 1730145247Sdamien DPRINTFN(2, ("sending command idx=%u type=%u len=%u\n", sc->cmdq.cur, 1731145247Sdamien type, len)); 1732145247Sdamien 1733145247Sdamien sc->cmdq.cur = (sc->cmdq.cur + 1) % IWI_CMD_RING_COUNT; 1734145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CMD_WIDX, sc->cmdq.cur); 1735145247Sdamien 1736158089Smlaier return msleep(sc, &sc->sc_mtx, 0, "iwicmd", hz); 1737145247Sdamien} 1738145247Sdamien 1739150341Sdamienstatic void 1740158089Smlaieriwi_write_ibssnode(struct iwi_softc *sc, 1741158089Smlaier const u_int8_t addr[IEEE80211_ADDR_LEN], int entry) 1742150341Sdamien{ 1743150341Sdamien struct iwi_ibssnode node; 1744150341Sdamien 1745150341Sdamien /* write node information into NIC memory */ 1746150341Sdamien memset(&node, 0, sizeof node); 1747158089Smlaier IEEE80211_ADDR_COPY(node.bssid, addr); 1748150341Sdamien 1749158089Smlaier DPRINTF(("%s mac %6D station %u\n", __func__, node.bssid, ":", entry)); 1750158089Smlaier 1751150341Sdamien CSR_WRITE_REGION_1(sc, 1752158089Smlaier IWI_CSR_NODE_BASE + entry * sizeof node, 1753150341Sdamien (uint8_t *)&node, sizeof node); 1754150341Sdamien} 1755150341Sdamien 1756145247Sdamienstatic int 1757150245Sdamieniwi_tx_start(struct ifnet *ifp, struct mbuf *m0, struct ieee80211_node *ni, 1758150245Sdamien int ac) 1759145247Sdamien{ 1760145247Sdamien struct iwi_softc *sc = ifp->if_softc; 1761145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 1762150341Sdamien struct iwi_node *in = (struct iwi_node *)ni; 1763158089Smlaier const struct ieee80211_frame *wh; 1764146500Sdamien struct ieee80211_key *k; 1765149338Sdamien const struct chanAccParams *cap; 1766150245Sdamien struct iwi_tx_ring *txq = &sc->txq[ac]; 1767145247Sdamien struct iwi_tx_data *data; 1768145247Sdamien struct iwi_tx_desc *desc; 1769145247Sdamien struct mbuf *mnew; 1770145247Sdamien bus_dma_segment_t segs[IWI_MAX_NSEG]; 1771158089Smlaier int error, nsegs, hdrlen, i; 1772158089Smlaier int ismcast, flags, xflags, staid; 1773145247Sdamien 1774158089Smlaier wh = mtod(m0, const struct ieee80211_frame *); 1775158089Smlaier /* NB: only data frames use this path */ 1776158089Smlaier hdrlen = ieee80211_hdrsize(wh); 1777158089Smlaier ismcast = IEEE80211_IS_MULTICAST(wh->i_addr1); 1778158089Smlaier flags = xflags = 0; 1779149338Sdamien 1780158089Smlaier if (!ismcast) 1781158089Smlaier flags |= IWI_DATA_FLAG_NEED_ACK; 1782158089Smlaier if (ic->ic_flags & IEEE80211_F_SHPREAMBLE) 1783158089Smlaier flags |= IWI_DATA_FLAG_SHPREAMBLE; 1784158089Smlaier if (IEEE80211_QOS_HAS_SEQ(wh)) { 1785158089Smlaier xflags |= IWI_DATA_XFLAG_QOS; 1786149338Sdamien cap = &ic->ic_wme.wme_chanParams; 1787158089Smlaier if (!cap->cap_wmeParams[ac].wmep_noackPolicy) 1788158089Smlaier flags &= ~IWI_DATA_FLAG_NEED_ACK; 1789158089Smlaier } 1790149338Sdamien 1791150341Sdamien /* 1792150341Sdamien * This is only used in IBSS mode where the firmware expect an index 1793150341Sdamien * in a h/w table instead of a destination address. 1794150341Sdamien */ 1795158089Smlaier if (ic->ic_opmode == IEEE80211_M_IBSS) { 1796158089Smlaier if (!ismcast) { 1797158089Smlaier if (in->in_station == -1) { 1798158089Smlaier in->in_station = alloc_unr(sc->sc_unr); 1799158089Smlaier if (in->in_station == -1) { 1800158089Smlaier /* h/w table is full */ 1801158089Smlaier m_freem(m0); 1802158089Smlaier ieee80211_free_node(ni); 1803158089Smlaier ifp->if_oerrors++; 1804158089Smlaier return 0; 1805158089Smlaier } 1806158089Smlaier iwi_write_ibssnode(sc, 1807158089Smlaier ni->ni_macaddr, in->in_station); 1808158089Smlaier } 1809158089Smlaier staid = in->in_station; 1810158089Smlaier } else { 1811158089Smlaier /* 1812158089Smlaier * Multicast addresses have no associated node 1813158089Smlaier * so there will be no station entry. We reserve 1814158089Smlaier * entry 0 for one mcast address and use that. 1815158089Smlaier * If there are many being used this will be 1816158089Smlaier * expensive and we'll need to do a better job 1817158089Smlaier * but for now this handles the broadcast case. 1818158089Smlaier */ 1819158089Smlaier if (!IEEE80211_ADDR_EQ(wh->i_addr1, sc->sc_mcast)) { 1820158089Smlaier IEEE80211_ADDR_COPY(sc->sc_mcast, wh->i_addr1); 1821158089Smlaier iwi_write_ibssnode(sc, sc->sc_mcast, 0); 1822158089Smlaier } 1823158089Smlaier staid = 0; 1824150245Sdamien } 1825158089Smlaier } else 1826158089Smlaier staid = 0; 1827149338Sdamien 1828149338Sdamien if (wh->i_fc[1] & IEEE80211_FC1_WEP) { 1829146500Sdamien k = ieee80211_crypto_encap(ic, ni, m0); 1830147806Ssam if (k == NULL) { 1831147806Ssam m_freem(m0); 1832146500Sdamien return ENOBUFS; 1833147806Ssam } 1834149338Sdamien 1835149338Sdamien /* packet header may have moved, reset our local pointer */ 1836149338Sdamien wh = mtod(m0, struct ieee80211_frame *); 1837146500Sdamien } 1838146500Sdamien 1839159180Scsjp if (bpf_peers_present(sc->sc_drvbpf)) { 1840145247Sdamien struct iwi_tx_radiotap_header *tap = &sc->sc_txtap; 1841145247Sdamien 1842145247Sdamien tap->wt_flags = 0; 1843145247Sdamien 1844145247Sdamien bpf_mtap2(sc->sc_drvbpf, tap, sc->sc_txtap_len, m0); 1845145247Sdamien } 1846145247Sdamien 1847149338Sdamien data = &txq->data[txq->cur]; 1848149338Sdamien desc = &txq->desc[txq->cur]; 1849145247Sdamien 1850149338Sdamien /* save and trim IEEE802.11 header */ 1851149338Sdamien m_copydata(m0, 0, hdrlen, (caddr_t)&desc->wh); 1852149338Sdamien m_adj(m0, hdrlen); 1853145247Sdamien 1854149338Sdamien error = bus_dmamap_load_mbuf_sg(txq->data_dmat, data->map, m0, segs, 1855145247Sdamien &nsegs, 0); 1856145247Sdamien if (error != 0 && error != EFBIG) { 1857145247Sdamien device_printf(sc->sc_dev, "could not map mbuf (error %d)\n", 1858145247Sdamien error); 1859145247Sdamien m_freem(m0); 1860145247Sdamien return error; 1861145247Sdamien } 1862145247Sdamien if (error != 0) { 1863145247Sdamien mnew = m_defrag(m0, M_DONTWAIT); 1864145247Sdamien if (mnew == NULL) { 1865145247Sdamien device_printf(sc->sc_dev, 1866145247Sdamien "could not defragment mbuf\n"); 1867145247Sdamien m_freem(m0); 1868145247Sdamien return ENOBUFS; 1869145247Sdamien } 1870145247Sdamien m0 = mnew; 1871145247Sdamien 1872149338Sdamien error = bus_dmamap_load_mbuf_sg(txq->data_dmat, data->map, 1873145247Sdamien m0, segs, &nsegs, 0); 1874145247Sdamien if (error != 0) { 1875145247Sdamien device_printf(sc->sc_dev, 1876145247Sdamien "could not map mbuf (error %d)\n", error); 1877145247Sdamien m_freem(m0); 1878145247Sdamien return error; 1879145247Sdamien } 1880145247Sdamien } 1881145247Sdamien 1882145247Sdamien data->m = m0; 1883145247Sdamien data->ni = ni; 1884145247Sdamien 1885145247Sdamien desc->hdr.type = IWI_HDR_TYPE_DATA; 1886145247Sdamien desc->hdr.flags = IWI_HDR_FLAG_IRQ; 1887158089Smlaier desc->station = staid; 1888145247Sdamien desc->cmd = IWI_DATA_CMD_TX; 1889145247Sdamien desc->len = htole16(m0->m_pkthdr.len); 1890158089Smlaier desc->flags = flags; 1891158089Smlaier desc->xflags = xflags; 1892145247Sdamien 1893146500Sdamien#if 0 1894158089Smlaier if (ic->ic_flags & IEEE80211_F_PRIVACY) 1895158089Smlaier desc->wep_txkey = ic->ic_crypto.cs_def_txkey; 1896158089Smlaier else 1897146500Sdamien#endif 1898145247Sdamien desc->flags |= IWI_DATA_FLAG_NO_WEP; 1899145247Sdamien 1900145247Sdamien desc->nseg = htole32(nsegs); 1901145247Sdamien for (i = 0; i < nsegs; i++) { 1902145247Sdamien desc->seg_addr[i] = htole32(segs[i].ds_addr); 1903152389Sdamien desc->seg_len[i] = htole16(segs[i].ds_len); 1904145247Sdamien } 1905145247Sdamien 1906149338Sdamien bus_dmamap_sync(txq->data_dmat, data->map, BUS_DMASYNC_PREWRITE); 1907149338Sdamien bus_dmamap_sync(txq->desc_dmat, txq->desc_map, BUS_DMASYNC_PREWRITE); 1908145247Sdamien 1909149338Sdamien DPRINTFN(5, ("sending data frame txq=%u idx=%u len=%u nseg=%u\n", 1910152389Sdamien ac, txq->cur, le16toh(desc->len), nsegs)); 1911145247Sdamien 1912149338Sdamien txq->queued++; 1913149338Sdamien txq->cur = (txq->cur + 1) % IWI_TX_RING_COUNT; 1914149338Sdamien CSR_WRITE_4(sc, txq->csr_widx, txq->cur); 1915145247Sdamien 1916145247Sdamien return 0; 1917145247Sdamien} 1918145247Sdamien 1919145247Sdamienstatic void 1920145247Sdamieniwi_start(struct ifnet *ifp) 1921145247Sdamien{ 1922145247Sdamien struct iwi_softc *sc = ifp->if_softc; 1923145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 1924145247Sdamien struct mbuf *m0; 1925145247Sdamien struct ether_header *eh; 1926145247Sdamien struct ieee80211_node *ni; 1927150245Sdamien int ac; 1928158089Smlaier IWI_LOCK_DECL; 1929145247Sdamien 1930158089Smlaier IWI_LOCK(sc); 1931145247Sdamien 1932145247Sdamien if (ic->ic_state != IEEE80211_S_RUN) { 1933158089Smlaier IWI_UNLOCK(sc); 1934145247Sdamien return; 1935145247Sdamien } 1936145247Sdamien 1937145247Sdamien for (;;) { 1938158089Smlaier IF_DEQUEUE(&ic->ic_mgtq, m0); 1939158089Smlaier if (m0 == NULL) { 1940158089Smlaier IFQ_DRV_DEQUEUE(&ifp->if_snd, m0); 1941158089Smlaier if (m0 == NULL) 1942158089Smlaier break; 1943145247Sdamien 1944158089Smlaier if (m0->m_len < sizeof (struct ether_header) && 1945158089Smlaier (m0 = m_pullup(m0, sizeof (struct ether_header))) == NULL) { 1946158089Smlaier ifp->if_oerrors++; 1947158089Smlaier continue; 1948158089Smlaier } 1949158089Smlaier eh = mtod(m0, struct ether_header *); 1950158089Smlaier ni = ieee80211_find_txnode(ic, eh->ether_dhost); 1951158089Smlaier if (ni == NULL) { 1952158089Smlaier m_freem(m0); 1953158089Smlaier ifp->if_oerrors++; 1954158089Smlaier continue; 1955158089Smlaier } 1956150245Sdamien 1957158089Smlaier /* classify mbuf so we can find which tx ring to use */ 1958158089Smlaier if (ieee80211_classify(ic, m0, ni) != 0) { 1959158089Smlaier m_freem(m0); 1960158089Smlaier ieee80211_free_node(ni); 1961158089Smlaier ifp->if_oerrors++; 1962158089Smlaier continue; 1963158089Smlaier } 1964150245Sdamien 1965158089Smlaier /* XXX does not belong here */ 1966158089Smlaier /* no QoS encapsulation for EAPOL frames */ 1967158089Smlaier ac = (eh->ether_type != htons(ETHERTYPE_PAE)) ? 1968158089Smlaier M_WME_GETAC(m0) : WME_AC_BE; 1969150245Sdamien 1970158089Smlaier if (sc->txq[ac].queued > IWI_TX_RING_COUNT - 8) { 1971158089Smlaier /* there is no place left in this ring */ 1972158089Smlaier IFQ_DRV_PREPEND(&ifp->if_snd, m0); 1973158089Smlaier ifp->if_drv_flags |= IFF_DRV_OACTIVE; 1974158089Smlaier break; 1975158089Smlaier } 1976150245Sdamien 1977158089Smlaier BPF_MTAP(ifp, m0); 1978145247Sdamien 1979158089Smlaier m0 = ieee80211_encap(ic, m0, ni); 1980158089Smlaier if (m0 == NULL) { 1981158089Smlaier ieee80211_free_node(ni); 1982158089Smlaier ifp->if_oerrors++; 1983158089Smlaier continue; 1984158089Smlaier } 1985158089Smlaier } else { 1986158089Smlaier ni = (struct ieee80211_node *) m0->m_pkthdr.rcvif; 1987158089Smlaier m0->m_pkthdr.rcvif = NULL; 1988158089Smlaier /* XXX no way to send mgt frames (yet), discard */ 1989158089Smlaier m_freem(m0); 1990147834Ssam ieee80211_free_node(ni); 1991145247Sdamien continue; 1992147834Ssam } 1993145247Sdamien 1994159183Ssam if (bpf_peers_present(ic->ic_rawbpf)) 1995145247Sdamien bpf_mtap(ic->ic_rawbpf, m0); 1996145247Sdamien 1997150245Sdamien if (iwi_tx_start(ifp, m0, ni, ac) != 0) { 1998145247Sdamien ieee80211_free_node(ni); 1999145247Sdamien ifp->if_oerrors++; 2000145247Sdamien break; 2001145247Sdamien } 2002145247Sdamien 2003145247Sdamien sc->sc_tx_timer = 5; 2004145247Sdamien ifp->if_timer = 1; 2005145247Sdamien } 2006145247Sdamien 2007158089Smlaier IWI_UNLOCK(sc); 2008145247Sdamien} 2009145247Sdamien 2010145247Sdamienstatic void 2011145247Sdamieniwi_watchdog(struct ifnet *ifp) 2012145247Sdamien{ 2013145247Sdamien struct iwi_softc *sc = ifp->if_softc; 2014145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 2015158089Smlaier IWI_LOCK_DECL; 2016145247Sdamien 2017158089Smlaier IWI_LOCK(sc); 2018145247Sdamien 2019145247Sdamien if (sc->sc_tx_timer > 0) { 2020145247Sdamien if (--sc->sc_tx_timer == 0) { 2021145247Sdamien if_printf(ifp, "device timeout\n"); 2022145247Sdamien ifp->if_oerrors++; 2023158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_restarttask); 2024145247Sdamien } 2025158089Smlaier } 2026158089Smlaier if (sc->sc_rfkill_timer > 0) { 2027158089Smlaier if (--sc->sc_rfkill_timer == 0) { 2028158089Smlaier /* 2029158089Smlaier * Check for a change in rfkill state. We get an 2030158089Smlaier * interrupt when a radio is disabled but not when 2031158089Smlaier * it is enabled so we must poll for the latter. 2032158089Smlaier */ 2033158089Smlaier if (!iwi_getrfkill(sc)) 2034158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_radiontask); 2035158089Smlaier else 2036158089Smlaier sc->sc_rfkill_timer = 2; 2037158089Smlaier } 2038158089Smlaier } 2039158089Smlaier if (sc->sc_scan_timer > 0) { 2040158089Smlaier if (--sc->sc_scan_timer == 0) { 2041158089Smlaier if (sc->flags & IWI_FLAG_SCANNING) { 2042158089Smlaier if_printf(ifp, "scan stuck\n"); 2043158089Smlaier taskqueue_enqueue(sc->sc_tq, &sc->sc_restarttask); 2044158089Smlaier } 2045158089Smlaier } 2046158089Smlaier } 2047158089Smlaier if (sc->sc_tx_timer || sc->sc_rfkill_timer || sc->sc_scan_timer) 2048145247Sdamien ifp->if_timer = 1; 2049158089Smlaier else 2050158089Smlaier ifp->if_timer = 0; 2051145247Sdamien 2052145247Sdamien ieee80211_watchdog(ic); 2053145247Sdamien 2054158089Smlaier IWI_UNLOCK(sc); 2055145247Sdamien} 2056145247Sdamien 2057145247Sdamienstatic int 2058145247Sdamieniwi_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 2059145247Sdamien{ 2060145247Sdamien struct iwi_softc *sc = ifp->if_softc; 2061145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 2062145247Sdamien int error = 0; 2063158089Smlaier IWI_LOCK_DECL; 2064145247Sdamien 2065158089Smlaier IWI_LOCK(sc); 2066145247Sdamien 2067145247Sdamien switch (cmd) { 2068145247Sdamien case SIOCSIFFLAGS: 2069145247Sdamien if (ifp->if_flags & IFF_UP) { 2070148887Srwatson if (!(ifp->if_drv_flags & IFF_DRV_RUNNING)) 2071158089Smlaier iwi_init_locked(sc, 0); 2072145247Sdamien } else { 2073148887Srwatson if (ifp->if_drv_flags & IFF_DRV_RUNNING) 2074145247Sdamien iwi_stop(sc); 2075158089Smlaier else { 2076158089Smlaier /* 2077158089Smlaier * If device was stopped due to rfkill then 2078158089Smlaier * marked down we'll have the polling thread 2079158089Smlaier * running; stop it explicitly. 2080158089Smlaier */ 2081158089Smlaier sc->sc_rfkill_timer = 0; 2082158089Smlaier } 2083158089Smlaier iwi_put_firmware(sc); 2084145247Sdamien } 2085145247Sdamien break; 2086145247Sdamien 2087145247Sdamien default: 2088145247Sdamien error = ieee80211_ioctl(ic, cmd, data); 2089145247Sdamien } 2090145247Sdamien 2091145247Sdamien if (error == ENETRESET) { 2092148887Srwatson if ((ifp->if_flags & IFF_UP) && 2093149333Sdamien (ifp->if_drv_flags & IFF_DRV_RUNNING) && 2094149333Sdamien (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)) 2095158089Smlaier iwi_init_locked(sc, 0); 2096145247Sdamien error = 0; 2097145247Sdamien } 2098145247Sdamien 2099158089Smlaier IWI_UNLOCK(sc); 2100145247Sdamien 2101145247Sdamien return error; 2102145247Sdamien} 2103145247Sdamien 2104145247Sdamienstatic void 2105145247Sdamieniwi_stop_master(struct iwi_softc *sc) 2106145247Sdamien{ 2107145247Sdamien uint32_t tmp; 2108145247Sdamien int ntries; 2109145247Sdamien 2110145247Sdamien /* disable interrupts */ 2111145247Sdamien CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, 0); 2112145247Sdamien 2113145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, IWI_RST_STOP_MASTER); 2114145247Sdamien for (ntries = 0; ntries < 5; ntries++) { 2115145247Sdamien if (CSR_READ_4(sc, IWI_CSR_RST) & IWI_RST_MASTER_DISABLED) 2116145247Sdamien break; 2117145247Sdamien DELAY(10); 2118145247Sdamien } 2119145247Sdamien if (ntries == 5) 2120145247Sdamien device_printf(sc->sc_dev, "timeout waiting for master\n"); 2121145247Sdamien 2122145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_RST); 2123145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, tmp | IWI_RST_PRINCETON_RESET); 2124145247Sdamien 2125145247Sdamien sc->flags &= ~IWI_FLAG_FW_INITED; 2126145247Sdamien} 2127145247Sdamien 2128145247Sdamienstatic int 2129145247Sdamieniwi_reset(struct iwi_softc *sc) 2130145247Sdamien{ 2131145247Sdamien uint32_t tmp; 2132145247Sdamien int i, ntries; 2133145247Sdamien 2134145247Sdamien iwi_stop_master(sc); 2135145247Sdamien 2136145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_CTL); 2137145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CTL, tmp | IWI_CTL_INIT); 2138145247Sdamien 2139145247Sdamien CSR_WRITE_4(sc, IWI_CSR_READ_INT, IWI_READ_INT_INIT_HOST); 2140145247Sdamien 2141145247Sdamien /* wait for clock stabilization */ 2142145247Sdamien for (ntries = 0; ntries < 1000; ntries++) { 2143145247Sdamien if (CSR_READ_4(sc, IWI_CSR_CTL) & IWI_CTL_CLOCK_READY) 2144145247Sdamien break; 2145145247Sdamien DELAY(200); 2146145247Sdamien } 2147145247Sdamien if (ntries == 1000) { 2148145247Sdamien device_printf(sc->sc_dev, 2149145247Sdamien "timeout waiting for clock stabilization\n"); 2150145247Sdamien return EIO; 2151145247Sdamien } 2152145247Sdamien 2153145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_RST); 2154145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, tmp | IWI_RST_SOFT_RESET); 2155145247Sdamien 2156145247Sdamien DELAY(10); 2157145247Sdamien 2158145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_CTL); 2159145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CTL, tmp | IWI_CTL_INIT); 2160145247Sdamien 2161145247Sdamien /* clear NIC memory */ 2162145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_ADDR, 0); 2163145247Sdamien for (i = 0; i < 0xc000; i++) 2164145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, 0); 2165145247Sdamien 2166145247Sdamien return 0; 2167145247Sdamien} 2168145247Sdamien 2169158089Smlaierstatic const struct iwi_firmware_ohdr * 2170158089Smlaieriwi_setup_ofw(struct iwi_softc *sc, struct iwi_fw *fw) 2171158089Smlaier{ 2172158089Smlaier struct firmware *fp = fw->fp; 2173158089Smlaier const struct iwi_firmware_ohdr *hdr; 2174158089Smlaier 2175158089Smlaier if (fp->datasize < sizeof (struct iwi_firmware_ohdr)) { 2176158089Smlaier device_printf(sc->sc_dev, "image '%s' too small\n", fp->name); 2177158089Smlaier return NULL; 2178158089Smlaier } 2179158089Smlaier hdr = (const struct iwi_firmware_ohdr *)fp->data; 2180158089Smlaier if ((IWI_FW_GET_MAJOR(le32toh(hdr->version)) != IWI_FW_REQ_MAJOR) || 2181158089Smlaier (IWI_FW_GET_MINOR(le32toh(hdr->version)) != IWI_FW_REQ_MINOR)) { 2182158089Smlaier device_printf(sc->sc_dev, "version for '%s' %d.%d != %d.%d\n", 2183158089Smlaier fp->name, IWI_FW_GET_MAJOR(le32toh(hdr->version)), 2184158089Smlaier IWI_FW_GET_MINOR(le32toh(hdr->version)), IWI_FW_REQ_MAJOR, 2185158089Smlaier IWI_FW_REQ_MINOR); 2186158089Smlaier return NULL; 2187158089Smlaier } 2188158089Smlaier fw->data = ((const char *) fp->data) + sizeof(struct iwi_firmware_ohdr); 2189158089Smlaier fw->size = fp->datasize - sizeof(struct iwi_firmware_ohdr); 2190158089Smlaier fw->name = fp->name; 2191158089Smlaier return hdr; 2192158089Smlaier} 2193158089Smlaier 2194158089Smlaierstatic const struct iwi_firmware_ohdr * 2195158089Smlaieriwi_setup_oucode(struct iwi_softc *sc, struct iwi_fw *fw) 2196158089Smlaier{ 2197158089Smlaier const struct iwi_firmware_ohdr *hdr; 2198158089Smlaier 2199158089Smlaier hdr = iwi_setup_ofw(sc, fw); 2200158089Smlaier if (hdr != NULL && le32toh(hdr->mode) != IWI_FW_MODE_UCODE) { 2201158089Smlaier device_printf(sc->sc_dev, "%s is not a ucode image\n", 2202158089Smlaier fw->name); 2203158089Smlaier hdr = NULL; 2204158089Smlaier } 2205158089Smlaier return hdr; 2206158089Smlaier} 2207158089Smlaier 2208158089Smlaierstatic void 2209158089Smlaieriwi_getfw(struct iwi_fw *fw, const char *fwname, 2210158089Smlaier struct iwi_fw *uc, const char *ucname) 2211158089Smlaier{ 2212158089Smlaier if (fw->fp == NULL) 2213158089Smlaier fw->fp = firmware_get(fwname); 2214158089Smlaier /* NB: pre-3.0 ucode is packaged separately */ 2215158089Smlaier if (uc->fp == NULL && fw->fp != NULL && fw->fp->version < 300) 2216158089Smlaier uc->fp = firmware_get(ucname); 2217158089Smlaier} 2218158089Smlaier 2219158089Smlaier/* 2220158089Smlaier * Get the required firmware images if not already loaded. 2221158089Smlaier * Note that we hold firmware images so long as the device 2222158089Smlaier * is marked up in case we need to reload them on device init. 2223158089Smlaier * This is necessary because we re-init the device sometimes 2224158089Smlaier * from a context where we cannot read from the filesystem 2225158089Smlaier * (e.g. from the taskqueue thread when rfkill is re-enabled). 2226158089Smlaier * 2227158089Smlaier * NB: the order of get'ing and put'ing images here is 2228158089Smlaier * intentional to support handling firmware images bundled 2229158089Smlaier * by operating mode and/or all together in one file with 2230158089Smlaier * the boot firmware as "master". 2231158089Smlaier */ 2232145247Sdamienstatic int 2233158089Smlaieriwi_get_firmware(struct iwi_softc *sc) 2234145247Sdamien{ 2235158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 2236158089Smlaier const struct iwi_firmware_hdr *hdr; 2237158089Smlaier struct firmware *fp; 2238158089Smlaier 2239158089Smlaier /* invalidate cached firmware on mode change */ 2240158089Smlaier if (sc->fw_mode != ic->ic_opmode) 2241158089Smlaier iwi_put_firmware(sc); 2242158089Smlaier 2243158089Smlaier switch (ic->ic_opmode) { 2244158089Smlaier case IEEE80211_M_STA: 2245158089Smlaier iwi_getfw(&sc->fw_fw, "iwi_bss", &sc->fw_uc, "iwi_ucode_bss"); 2246158089Smlaier break; 2247158089Smlaier 2248158089Smlaier case IEEE80211_M_IBSS: 2249158089Smlaier iwi_getfw(&sc->fw_fw, "iwi_ibss", &sc->fw_uc, "iwi_ucode_ibss"); 2250158089Smlaier break; 2251158089Smlaier 2252158089Smlaier case IEEE80211_M_MONITOR: 2253158089Smlaier iwi_getfw(&sc->fw_fw, "iwi_monitor", 2254158089Smlaier &sc->fw_uc, "iwi_ucode_monitor"); 2255158089Smlaier break; 2256158089Smlaier 2257158089Smlaier default: 2258158089Smlaier break; 2259158089Smlaier } 2260158089Smlaier fp = sc->fw_fw.fp; 2261158089Smlaier if (fp == NULL) { 2262158089Smlaier device_printf(sc->sc_dev, "could not load firmware\n"); 2263158089Smlaier goto bad; 2264158089Smlaier } 2265158089Smlaier if (fp->version < 300) { 2266158089Smlaier /* 2267158089Smlaier * Firmware prior to 3.0 was packaged as separate 2268158089Smlaier * boot, firmware, and ucode images. Verify the 2269158089Smlaier * ucode image was read in, retrieve the boot image 2270158089Smlaier * if needed, and check version stamps for consistency. 2271158089Smlaier * The version stamps in the data are also checked 2272158089Smlaier * above; this is a bit paranoid but is a cheap 2273158089Smlaier * safeguard against mis-packaging. 2274158089Smlaier */ 2275158089Smlaier if (sc->fw_uc.fp == NULL) { 2276158089Smlaier device_printf(sc->sc_dev, "could not load ucode\n"); 2277158089Smlaier goto bad; 2278158089Smlaier } 2279158089Smlaier if (sc->fw_boot.fp == NULL) { 2280158089Smlaier sc->fw_boot.fp = firmware_get("iwi_boot"); 2281158089Smlaier if (sc->fw_boot.fp == NULL) { 2282158089Smlaier device_printf(sc->sc_dev, 2283158089Smlaier "could not load boot firmware\n"); 2284158089Smlaier goto bad; 2285158089Smlaier } 2286158089Smlaier } 2287158089Smlaier if (sc->fw_boot.fp->version != sc->fw_fw.fp->version || 2288158089Smlaier sc->fw_boot.fp->version != sc->fw_uc.fp->version) { 2289158089Smlaier device_printf(sc->sc_dev, 2290158089Smlaier "firmware version mismatch: " 2291158089Smlaier "'%s' is %d, '%s' is %d, '%s' is %d\n", 2292158089Smlaier sc->fw_boot.fp->name, sc->fw_boot.fp->version, 2293158089Smlaier sc->fw_uc.fp->name, sc->fw_uc.fp->version, 2294158089Smlaier sc->fw_fw.fp->name, sc->fw_fw.fp->version 2295158089Smlaier ); 2296158089Smlaier goto bad; 2297158089Smlaier } 2298158089Smlaier /* 2299158089Smlaier * Check and setup each image. 2300158089Smlaier */ 2301158089Smlaier if (iwi_setup_oucode(sc, &sc->fw_uc) == NULL || 2302158089Smlaier iwi_setup_ofw(sc, &sc->fw_boot) == NULL || 2303158089Smlaier iwi_setup_ofw(sc, &sc->fw_fw) == NULL) 2304158089Smlaier goto bad; 2305158089Smlaier } else { 2306158089Smlaier /* 2307158089Smlaier * Check and setup combined image. 2308158089Smlaier */ 2309158089Smlaier if (fp->datasize < sizeof(hdr)) { 2310158089Smlaier device_printf(sc->sc_dev, "image '%s' too small\n", 2311158089Smlaier fp->name); 2312158089Smlaier goto bad; 2313158089Smlaier } 2314158089Smlaier hdr = (const struct iwi_firmware_hdr *)fp->data; 2315158089Smlaier if (fp->datasize < sizeof(*hdr) + hdr->bsize + hdr->usize + hdr->fsize) { 2316158089Smlaier device_printf(sc->sc_dev, "image '%s' too small (2)\n", 2317158089Smlaier fp->name); 2318158089Smlaier goto bad; 2319158089Smlaier } 2320158089Smlaier sc->fw_boot.data = ((const char *) fp->data) + sizeof(*hdr); 2321158089Smlaier sc->fw_boot.size = hdr->bsize; 2322158089Smlaier sc->fw_boot.name = fp->name; 2323158089Smlaier sc->fw_uc.data = sc->fw_boot.data + sc->fw_boot.size; 2324158089Smlaier sc->fw_uc.size = hdr->usize; 2325158089Smlaier sc->fw_uc.name = fp->name; 2326158089Smlaier sc->fw_fw.data = sc->fw_uc.data + sc->fw_uc.size; 2327158089Smlaier sc->fw_fw.size = hdr->fsize; 2328158089Smlaier sc->fw_fw.name = fp->name; 2329158089Smlaier } 2330158089Smlaier 2331158089Smlaier sc->fw_mode = ic->ic_opmode; 2332158089Smlaier return 1; 2333158089Smlaierbad: 2334158089Smlaier iwi_put_firmware(sc); 2335158089Smlaier return 0; 2336158089Smlaier} 2337158089Smlaier 2338158089Smlaierstatic void 2339158089Smlaieriwi_put_fw(struct iwi_fw *fw) 2340158089Smlaier{ 2341158089Smlaier if (fw->fp != NULL) { 2342158089Smlaier firmware_put(fw->fp, FIRMWARE_UNLOAD); 2343158089Smlaier fw->fp = NULL; 2344158089Smlaier } 2345158089Smlaier fw->data = NULL; 2346158089Smlaier fw->size = 0; 2347158089Smlaier fw->name = NULL; 2348158089Smlaier} 2349158089Smlaier 2350158089Smlaier/* 2351158089Smlaier * Release any cached firmware images. 2352158089Smlaier */ 2353158089Smlaierstatic void 2354158089Smlaieriwi_put_firmware(struct iwi_softc *sc) 2355158089Smlaier{ 2356158089Smlaier iwi_put_fw(&sc->fw_uc); 2357158089Smlaier iwi_put_fw(&sc->fw_fw); 2358158089Smlaier iwi_put_fw(&sc->fw_boot); 2359158089Smlaier} 2360158089Smlaier 2361158089Smlaierstatic int 2362158089Smlaieriwi_load_ucode(struct iwi_softc *sc, const struct iwi_fw *fw) 2363158089Smlaier{ 2364158089Smlaier uint32_t tmp; 2365156546Sdamien const uint16_t *w; 2366158089Smlaier const char *uc = fw->data; 2367158089Smlaier size_t size = fw->size; 2368158089Smlaier int i, ntries, error; 2369145247Sdamien 2370158089Smlaier error = 0; 2371145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, CSR_READ_4(sc, IWI_CSR_RST) | 2372145247Sdamien IWI_RST_STOP_MASTER); 2373145247Sdamien for (ntries = 0; ntries < 5; ntries++) { 2374145247Sdamien if (CSR_READ_4(sc, IWI_CSR_RST) & IWI_RST_MASTER_DISABLED) 2375145247Sdamien break; 2376145247Sdamien DELAY(10); 2377145247Sdamien } 2378145247Sdamien if (ntries == 5) { 2379145247Sdamien device_printf(sc->sc_dev, "timeout waiting for master\n"); 2380158089Smlaier error = EIO; 2381158089Smlaier goto fail; 2382145247Sdamien } 2383145247Sdamien 2384145247Sdamien MEM_WRITE_4(sc, 0x3000e0, 0x80000000); 2385145247Sdamien DELAY(5000); 2386145247Sdamien 2387145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_RST); 2388145247Sdamien tmp &= ~IWI_RST_PRINCETON_RESET; 2389145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, tmp); 2390145247Sdamien 2391145247Sdamien DELAY(5000); 2392145247Sdamien MEM_WRITE_4(sc, 0x3000e0, 0); 2393145247Sdamien DELAY(1000); 2394158089Smlaier MEM_WRITE_4(sc, IWI_MEM_EEPROM_EVENT, 1); 2395145247Sdamien DELAY(1000); 2396158089Smlaier MEM_WRITE_4(sc, IWI_MEM_EEPROM_EVENT, 0); 2397145247Sdamien DELAY(1000); 2398145247Sdamien MEM_WRITE_1(sc, 0x200000, 0x00); 2399145247Sdamien MEM_WRITE_1(sc, 0x200000, 0x40); 2400145247Sdamien DELAY(1000); 2401145247Sdamien 2402145247Sdamien /* write microcode into adapter memory */ 2403158089Smlaier for (w = (const uint16_t *)uc; size > 0; w++, size -= 2) 2404152389Sdamien MEM_WRITE_2(sc, 0x200010, htole16(*w)); 2405145247Sdamien 2406145247Sdamien MEM_WRITE_1(sc, 0x200000, 0x00); 2407145247Sdamien MEM_WRITE_1(sc, 0x200000, 0x80); 2408145247Sdamien 2409145247Sdamien /* wait until we get an answer */ 2410145247Sdamien for (ntries = 0; ntries < 100; ntries++) { 2411145247Sdamien if (MEM_READ_1(sc, 0x200000) & 1) 2412145247Sdamien break; 2413145247Sdamien DELAY(100); 2414145247Sdamien } 2415145247Sdamien if (ntries == 100) { 2416145247Sdamien device_printf(sc->sc_dev, 2417145247Sdamien "timeout waiting for ucode to initialize\n"); 2418158089Smlaier error = EIO; 2419158089Smlaier goto fail; 2420145247Sdamien } 2421145247Sdamien 2422145247Sdamien /* read the answer or the firmware will not initialize properly */ 2423145247Sdamien for (i = 0; i < 7; i++) 2424145247Sdamien MEM_READ_4(sc, 0x200004); 2425145247Sdamien 2426145247Sdamien MEM_WRITE_1(sc, 0x200000, 0x00); 2427145247Sdamien 2428158089Smlaierfail: 2429158089Smlaier return error; 2430145247Sdamien} 2431145247Sdamien 2432145247Sdamien/* macro to handle unaligned little endian data in firmware image */ 2433145247Sdamien#define GETLE32(p) ((p)[0] | (p)[1] << 8 | (p)[2] << 16 | (p)[3] << 24) 2434145247Sdamien 2435145247Sdamienstatic int 2436158089Smlaieriwi_load_firmware(struct iwi_softc *sc, const struct iwi_fw *fw) 2437145247Sdamien{ 2438145247Sdamien u_char *p, *end; 2439145247Sdamien uint32_t sentinel, ctl, src, dst, sum, len, mlen, tmp; 2440152629Sscottl int ntries, error; 2441145247Sdamien 2442145247Sdamien /* copy firmware image to DMA memory */ 2443158089Smlaier memcpy(sc->fw_virtaddr, fw->data, fw->size); 2444145247Sdamien 2445145247Sdamien /* make sure the adapter will get up-to-date values */ 2446158089Smlaier bus_dmamap_sync(sc->fw_dmat, sc->fw_map, BUS_DMASYNC_PREWRITE); 2447145247Sdamien 2448145247Sdamien /* tell the adapter where the command blocks are stored */ 2449145247Sdamien MEM_WRITE_4(sc, 0x3000a0, 0x27000); 2450145247Sdamien 2451145247Sdamien /* 2452145247Sdamien * Store command blocks into adapter's internal memory using register 2453145247Sdamien * indirections. The adapter will read the firmware image through DMA 2454145247Sdamien * using information stored in command blocks. 2455145247Sdamien */ 2456158089Smlaier src = sc->fw_physaddr; 2457158089Smlaier p = sc->fw_virtaddr; 2458158089Smlaier end = p + fw->size; 2459145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_ADDR, 0x27000); 2460145247Sdamien 2461145247Sdamien while (p < end) { 2462145247Sdamien dst = GETLE32(p); p += 4; src += 4; 2463145247Sdamien len = GETLE32(p); p += 4; src += 4; 2464145247Sdamien p += len; 2465145247Sdamien 2466145247Sdamien while (len > 0) { 2467145247Sdamien mlen = min(len, IWI_CB_MAXDATALEN); 2468145247Sdamien 2469145247Sdamien ctl = IWI_CB_DEFAULT_CTL | mlen; 2470145247Sdamien sum = ctl ^ src ^ dst; 2471145247Sdamien 2472145247Sdamien /* write a command block */ 2473145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, ctl); 2474145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, src); 2475145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, dst); 2476145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, sum); 2477145247Sdamien 2478145247Sdamien src += mlen; 2479145247Sdamien dst += mlen; 2480145247Sdamien len -= mlen; 2481145247Sdamien } 2482145247Sdamien } 2483145247Sdamien 2484145247Sdamien /* write a fictive final command block (sentinel) */ 2485145247Sdamien sentinel = CSR_READ_4(sc, IWI_CSR_AUTOINC_ADDR); 2486145247Sdamien CSR_WRITE_4(sc, IWI_CSR_AUTOINC_DATA, 0); 2487145247Sdamien 2488145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_RST); 2489145247Sdamien tmp &= ~(IWI_RST_MASTER_DISABLED | IWI_RST_STOP_MASTER); 2490145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, tmp); 2491145247Sdamien 2492145247Sdamien /* tell the adapter to start processing command blocks */ 2493145247Sdamien MEM_WRITE_4(sc, 0x3000a4, 0x540100); 2494145247Sdamien 2495152611Sdamien /* wait until the adapter reaches the sentinel */ 2496145247Sdamien for (ntries = 0; ntries < 400; ntries++) { 2497145247Sdamien if (MEM_READ_4(sc, 0x3000d0) >= sentinel) 2498145247Sdamien break; 2499145247Sdamien DELAY(100); 2500145247Sdamien } 2501145247Sdamien if (ntries == 400) { 2502145247Sdamien device_printf(sc->sc_dev, 2503158089Smlaier "timeout processing command blocks for %s firmware\n", 2504158089Smlaier fw->name); 2505145247Sdamien error = EIO; 2506158089Smlaier goto fail5; 2507145247Sdamien } 2508145247Sdamien 2509145247Sdamien /* we're done with command blocks processing */ 2510145247Sdamien MEM_WRITE_4(sc, 0x3000a4, 0x540c00); 2511145247Sdamien 2512152611Sdamien /* allow interrupts so we know when the firmware is ready */ 2513145247Sdamien CSR_WRITE_4(sc, IWI_CSR_INTR_MASK, IWI_INTR_MASK); 2514145247Sdamien 2515145247Sdamien /* tell the adapter to initialize the firmware */ 2516145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, 0); 2517145247Sdamien 2518145247Sdamien tmp = CSR_READ_4(sc, IWI_CSR_CTL); 2519145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CTL, tmp | IWI_CTL_ALLOW_STANDBY); 2520145247Sdamien 2521145247Sdamien /* wait at most one second for firmware initialization to complete */ 2522145247Sdamien if ((error = msleep(sc, &sc->sc_mtx, 0, "iwiinit", hz)) != 0) { 2523158089Smlaier device_printf(sc->sc_dev, "timeout waiting for %s firmware " 2524158089Smlaier "initialization to complete\n", fw->name); 2525145247Sdamien } 2526145247Sdamien 2527158089Smlaierfail5: 2528145247Sdamien return error; 2529145247Sdamien} 2530145247Sdamien 2531145247Sdamienstatic int 2532158089Smlaieriwi_setpowermode(struct iwi_softc *sc) 2533158089Smlaier{ 2534158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 2535158089Smlaier uint32_t data; 2536158089Smlaier 2537158089Smlaier if (ic->ic_flags & IEEE80211_F_PMGTON) { 2538158089Smlaier /* XXX set more fine-grained operation */ 2539158089Smlaier data = htole32(IWI_POWER_MODE_MAX); 2540158089Smlaier } else 2541158089Smlaier data = htole32(IWI_POWER_MODE_CAM); 2542158089Smlaier 2543158089Smlaier DPRINTF(("Setting power mode to %u\n", le32toh(data))); 2544158089Smlaier return iwi_cmd(sc, IWI_CMD_SET_POWER_MODE, &data, sizeof data); 2545158089Smlaier} 2546158089Smlaier 2547158089Smlaierstatic int 2548158089Smlaieriwi_setwepkeys(struct iwi_softc *sc) 2549158089Smlaier{ 2550158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 2551158089Smlaier struct iwi_wep_key wepkey; 2552158089Smlaier struct ieee80211_key *wk; 2553158089Smlaier int error, i; 2554158089Smlaier 2555158089Smlaier for (i = 0; i < IEEE80211_WEP_NKID; i++) { 2556158089Smlaier wk = &ic->ic_crypto.cs_nw_keys[i]; 2557158089Smlaier 2558158089Smlaier wepkey.cmd = IWI_WEP_KEY_CMD_SETKEY; 2559158089Smlaier wepkey.idx = i; 2560158089Smlaier wepkey.len = wk->wk_keylen; 2561158089Smlaier memset(wepkey.key, 0, sizeof wepkey.key); 2562158089Smlaier memcpy(wepkey.key, wk->wk_key, wk->wk_keylen); 2563158089Smlaier DPRINTF(("Setting wep key index %u len %u\n", wepkey.idx, 2564158089Smlaier wepkey.len)); 2565158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_WEP_KEY, &wepkey, 2566158089Smlaier sizeof wepkey); 2567158089Smlaier if (error != 0) 2568158089Smlaier return error; 2569158089Smlaier } 2570158089Smlaier return 0; 2571158089Smlaier} 2572158089Smlaier 2573158089Smlaierstatic int 2574145247Sdamieniwi_config(struct iwi_softc *sc) 2575145247Sdamien{ 2576145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 2577145247Sdamien struct ifnet *ifp = ic->ic_ifp; 2578145247Sdamien struct iwi_configuration config; 2579145247Sdamien struct iwi_rateset rs; 2580145247Sdamien struct iwi_txpower power; 2581145247Sdamien uint32_t data; 2582145247Sdamien int error, i; 2583145247Sdamien 2584145247Sdamien IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp)); 2585145247Sdamien DPRINTF(("Setting MAC address to %6D\n", ic->ic_myaddr, ":")); 2586145247Sdamien error = iwi_cmd(sc, IWI_CMD_SET_MAC_ADDRESS, ic->ic_myaddr, 2587158089Smlaier IEEE80211_ADDR_LEN); 2588145247Sdamien if (error != 0) 2589145247Sdamien return error; 2590145247Sdamien 2591145247Sdamien memset(&config, 0, sizeof config); 2592145247Sdamien config.bluetooth_coexistence = sc->bluetooth; 2593158089Smlaier config.silence_threshold = 0x1e; 2594146500Sdamien config.antenna = sc->antenna; 2595145247Sdamien config.multicast_enabled = 1; 2596146500Sdamien config.answer_pbreq = (ic->ic_opmode == IEEE80211_M_IBSS) ? 1 : 0; 2597146500Sdamien config.disable_unicast_decryption = 1; 2598146500Sdamien config.disable_multicast_decryption = 1; 2599145247Sdamien DPRINTF(("Configuring adapter\n")); 2600158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_CONFIG, &config, sizeof config); 2601145247Sdamien if (error != 0) 2602145247Sdamien return error; 2603145247Sdamien 2604158089Smlaier error = iwi_setpowermode(sc); 2605145247Sdamien if (error != 0) 2606145247Sdamien return error; 2607145247Sdamien 2608145247Sdamien data = htole32(ic->ic_rtsthreshold); 2609145247Sdamien DPRINTF(("Setting RTS threshold to %u\n", le32toh(data))); 2610158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_RTS_THRESHOLD, &data, sizeof data); 2611145247Sdamien if (error != 0) 2612145247Sdamien return error; 2613145247Sdamien 2614146500Sdamien data = htole32(ic->ic_fragthreshold); 2615146500Sdamien DPRINTF(("Setting fragmentation threshold to %u\n", le32toh(data))); 2616158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_FRAG_THRESHOLD, &data, sizeof data); 2617146500Sdamien if (error != 0) 2618146500Sdamien return error; 2619146500Sdamien 2620145247Sdamien if (ic->ic_opmode == IEEE80211_M_IBSS) { 2621145247Sdamien power.mode = IWI_MODE_11B; 2622145247Sdamien power.nchan = 11; 2623145247Sdamien for (i = 0; i < 11; i++) { 2624145247Sdamien power.chan[i].chan = i + 1; 2625145247Sdamien power.chan[i].power = IWI_TXPOWER_MAX; 2626145247Sdamien } 2627145247Sdamien DPRINTF(("Setting .11b channels tx power\n")); 2628158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power); 2629145247Sdamien if (error != 0) 2630145247Sdamien return error; 2631145247Sdamien 2632145247Sdamien power.mode = IWI_MODE_11G; 2633145247Sdamien DPRINTF(("Setting .11g channels tx power\n")); 2634158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_TX_POWER, &power, sizeof power); 2635145247Sdamien if (error != 0) 2636145247Sdamien return error; 2637145247Sdamien } 2638145247Sdamien 2639145247Sdamien rs.mode = IWI_MODE_11G; 2640145247Sdamien rs.type = IWI_RATESET_TYPE_SUPPORTED; 2641145247Sdamien rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates; 2642145247Sdamien memcpy(rs.rates, ic->ic_sup_rates[IEEE80211_MODE_11G].rs_rates, 2643145247Sdamien rs.nrates); 2644145247Sdamien DPRINTF(("Setting .11bg supported rates (%u)\n", rs.nrates)); 2645158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs); 2646145247Sdamien if (error != 0) 2647145247Sdamien return error; 2648145247Sdamien 2649145247Sdamien rs.mode = IWI_MODE_11A; 2650145247Sdamien rs.type = IWI_RATESET_TYPE_SUPPORTED; 2651145247Sdamien rs.nrates = ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates; 2652145247Sdamien memcpy(rs.rates, ic->ic_sup_rates[IEEE80211_MODE_11A].rs_rates, 2653145247Sdamien rs.nrates); 2654145247Sdamien DPRINTF(("Setting .11a supported rates (%u)\n", rs.nrates)); 2655158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs); 2656145247Sdamien if (error != 0) 2657145247Sdamien return error; 2658145247Sdamien 2659150245Sdamien /* if we have a desired ESSID, set it now */ 2660150245Sdamien if (ic->ic_des_esslen != 0) { 2661150245Sdamien#ifdef IWI_DEBUG 2662150245Sdamien if (iwi_debug > 0) { 2663150245Sdamien printf("Setting desired ESSID to "); 2664150245Sdamien ieee80211_print_essid(ic->ic_des_essid, 2665150245Sdamien ic->ic_des_esslen); 2666150245Sdamien printf("\n"); 2667150245Sdamien } 2668150245Sdamien#endif 2669150245Sdamien error = iwi_cmd(sc, IWI_CMD_SET_ESSID, ic->ic_des_essid, 2670158089Smlaier ic->ic_des_esslen); 2671150245Sdamien if (error != 0) 2672150245Sdamien return error; 2673150245Sdamien } 2674150245Sdamien 2675145247Sdamien data = htole32(arc4random()); 2676145247Sdamien DPRINTF(("Setting initialization vector to %u\n", le32toh(data))); 2677158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_IV, &data, sizeof data); 2678145247Sdamien if (error != 0) 2679145247Sdamien return error; 2680145247Sdamien 2681158089Smlaier error = iwi_setwepkeys(sc); 2682158089Smlaier if (error != 0) 2683158089Smlaier return error; 2684145247Sdamien 2685145247Sdamien /* enable adapter */ 2686145247Sdamien DPRINTF(("Enabling adapter\n")); 2687158089Smlaier return iwi_cmd(sc, IWI_CMD_ENABLE, NULL, 0); 2688145247Sdamien} 2689145247Sdamien 2690158089Smlaierstatic __inline void 2691158089Smlaierset_scan_type(struct iwi_scan_ext *scan, int ix, int scan_type) 2692146500Sdamien{ 2693158089Smlaier uint8_t *st = &scan->scan_type[ix / 2]; 2694158089Smlaier if (ix % 2) 2695158089Smlaier *st = (*st & 0xf0) | ((scan_type & 0xf) << 0); 2696158089Smlaier else 2697158089Smlaier *st = (*st & 0x0f) | ((scan_type & 0xf) << 4); 2698146500Sdamien} 2699146500Sdamien 2700146500Sdamienstatic int 2701145247Sdamieniwi_scan(struct iwi_softc *sc) 2702145247Sdamien{ 2703158089Smlaier#define IEEE80211_MODE_5GHZ (1<<IEEE80211_MODE_11A) 2704158089Smlaier#define IEEE80211_MODE_2GHZ ((1<<IEEE80211_MODE_11B)|1<<IEEE80211_MODE_11G) 2705145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 2706158089Smlaier const struct ieee80211_channel *c; 2707158089Smlaier struct iwi_scan_ext scan; 2708163209Smlaier int i, ix, start, scan_type, error; 2709145247Sdamien 2710145247Sdamien memset(&scan, 0, sizeof scan); 2711145247Sdamien 2712158089Smlaier /* XXX different dwell times for different scan types */ 2713158089Smlaier scan.dwell_time[IWI_SCAN_TYPE_PASSIVE] = htole16(sc->dwelltime); 2714158089Smlaier scan.dwell_time[IWI_SCAN_TYPE_BROADCAST] = htole16(sc->dwelltime); 2715158089Smlaier scan.dwell_time[IWI_SCAN_TYPE_BDIRECTED] = htole16(sc->dwelltime); 2716151030Sdamien 2717158089Smlaier scan.full_scan_index = htole32(ic->ic_scan.nt_scangen); 2718158089Smlaier 2719163209Smlaier if (ic->ic_des_esslen != 0) { 2720163209Smlaier scan_type = IWI_SCAN_TYPE_BDIRECTED; 2721163209Smlaier#ifdef IWI_DEBUG 2722163209Smlaier if (iwi_debug > 0) { 2723163209Smlaier printf("Setting desired ESSID to "); 2724163209Smlaier ieee80211_print_essid(ic->ic_des_essid, 2725163209Smlaier ic->ic_des_esslen); 2726163209Smlaier printf("\n"); 2727163209Smlaier } 2728163209Smlaier#endif 2729163209Smlaier error = iwi_cmd(sc, IWI_CMD_SET_ESSID, ic->ic_des_essid, 2730163209Smlaier ic->ic_des_esslen); 2731163209Smlaier if (error != 0) 2732163209Smlaier return error; 2733163209Smlaier } else 2734163209Smlaier scan_type = IWI_SCAN_TYPE_BROADCAST; 2735158089Smlaier 2736158089Smlaier ix = 0; 2737158089Smlaier if (ic->ic_modecaps & IEEE80211_MODE_5GHZ) { 2738158089Smlaier start = ix; 2739158089Smlaier for (i = 0; i <= IEEE80211_CHAN_MAX; i++) { 2740158089Smlaier c = &ic->ic_channels[i]; 2741158089Smlaier /* 2742158089Smlaier * NB: ieee80211_next_scan clears curchan from the 2743158089Smlaier * channel list so we must explicitly check; this 2744158089Smlaier * will be fixed when the new scanning support arrives. 2745158089Smlaier */ 2746158089Smlaier if (!IEEE80211_IS_CHAN_5GHZ(c) || 2747158089Smlaier !(isset(ic->ic_chan_scan,i) || c == ic->ic_curchan)) 2748158089Smlaier continue; 2749158089Smlaier ix++; 2750158089Smlaier scan.channels[ix] = i; 2751158089Smlaier if (c->ic_flags & IEEE80211_CHAN_PASSIVE) 2752158089Smlaier set_scan_type(&scan, ix, IWI_SCAN_TYPE_PASSIVE); 2753158089Smlaier else 2754158089Smlaier set_scan_type(&scan, ix, scan_type); 2755145247Sdamien } 2756158089Smlaier if (start != ix) { 2757158089Smlaier scan.channels[start] = IWI_CHAN_5GHZ | (ix - start); 2758158089Smlaier ix++; 2759158089Smlaier } 2760145247Sdamien } 2761158089Smlaier if (ic->ic_modecaps & IEEE80211_MODE_2GHZ) { 2762158089Smlaier start = ix; 2763158089Smlaier for (i = 0; i <= IEEE80211_CHAN_MAX; i++) { 2764158089Smlaier c = &ic->ic_channels[i]; 2765158089Smlaier /* NB: see above */ 2766158089Smlaier if (!IEEE80211_IS_CHAN_2GHZ(c) || 2767158089Smlaier !(isset(ic->ic_chan_scan,i) || c == ic->ic_curchan)) 2768158089Smlaier continue; 2769158089Smlaier ix++; 2770158089Smlaier scan.channels[ix] = i; 2771158089Smlaier if (c->ic_flags & IEEE80211_CHAN_PASSIVE) 2772158089Smlaier set_scan_type(&scan, ix, IWI_SCAN_TYPE_PASSIVE); 2773158089Smlaier else 2774158089Smlaier set_scan_type(&scan, ix, scan_type); 2775145247Sdamien } 2776158089Smlaier if (start != ix) 2777158089Smlaier scan.channels[start] = IWI_CHAN_2GHZ | (ix - start); 2778145247Sdamien } 2779145247Sdamien 2780145247Sdamien DPRINTF(("Start scanning\n")); 2781158089Smlaier /* 2782158089Smlaier * With 100ms/channel dwell time and a max of ~20 channels 2783158089Smlaier * 5 seconds may be too tight; leave a bit more slack. 2784158089Smlaier */ 2785158089Smlaier sc->sc_scan_timer = 7; /* seconds to complete */ 2786158089Smlaier sc->sc_ifp->if_timer = 1; 2787158089Smlaier sc->flags |= IWI_FLAG_SCANNING; 2788158089Smlaier return iwi_cmd(sc, IWI_CMD_SCAN_EXT, &scan, sizeof scan); 2789158089Smlaier#undef IEEE80211_MODE_5GHZ 2790158089Smlaier#undef IEEE80211_MODE_2GHZ 2791145247Sdamien} 2792145247Sdamien 2793158089Smlaierstatic void 2794158089Smlaieriwi_scanabort(void *arg, int npending) 2795158089Smlaier{ 2796158089Smlaier struct iwi_softc *sc = arg; 2797158089Smlaier IWI_LOCK_DECL; 2798158089Smlaier 2799158089Smlaier IWI_LOCK(sc); 2800158089Smlaier /* NB: make sure we're still scanning */ 2801158089Smlaier if (sc->flags & IWI_FLAG_SCANNING) 2802158089Smlaier iwi_cmd(sc, IWI_CMD_ABORT_SCAN, NULL, 0); 2803158089Smlaier IWI_UNLOCK(sc); 2804158089Smlaier} 2805158089Smlaier 2806158089Smlaierstatic void 2807158089Smlaieriwi_scanstart(void *arg, int npending) 2808158089Smlaier{ 2809158089Smlaier struct iwi_softc *sc = arg; 2810158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 2811158089Smlaier IWI_LOCK_DECL; 2812158089Smlaier 2813158089Smlaier IWI_LOCK(sc); 2814158089Smlaier /* 2815158089Smlaier * Tell the card to kick off a scan. We guard this 2816158089Smlaier * by checking IWI_FLAG_SCANNING as otherwise we'll 2817158089Smlaier * do this twice because ieee80211_begin_scan will 2818158089Smlaier * immediately call us back to scan the first channel 2819158089Smlaier * in the list. 2820158089Smlaier */ 2821158089Smlaier if (sc->flags & IWI_FLAG_SCANNING) { 2822158089Smlaier ieee80211_begin_scan(ic, 1); 2823158089Smlaier if (iwi_scan(sc) != 0) { 2824158089Smlaier /* XXX should not happen */ 2825158089Smlaier sc->flags &= ~IWI_FLAG_SCANNING; 2826158089Smlaier ieee80211_new_state(ic, IEEE80211_S_INIT, 0); 2827158089Smlaier } 2828158089Smlaier } 2829158089Smlaier IWI_UNLOCK(sc); 2830158089Smlaier} 2831158089Smlaier 2832158089Smlaierstatic void 2833158089Smlaieriwi_scandone(void *arg, int npending) 2834158089Smlaier{ 2835158089Smlaier struct iwi_softc *sc = arg; 2836158089Smlaier struct ieee80211com *ic = &sc->sc_ic; 2837158089Smlaier IWI_LOCK_DECL; 2838158089Smlaier 2839158089Smlaier IWI_LOCK(sc); 2840158089Smlaier if (sc->flags & IWI_FLAG_ASSOCIATED) 2841158089Smlaier iwi_disassociate(sc, 0); 2842158089Smlaier ieee80211_end_scan(ic); 2843158089Smlaier IWI_UNLOCK(sc); 2844158089Smlaier} 2845158089Smlaier 2846158089Smlaier/* 2847158089Smlaier * Set the current channel by doing a passive scan. Note this 2848158089Smlaier * is explicitly for monitor mode operation; do not use it for 2849158089Smlaier * anything else (sigh). 2850158089Smlaier */ 2851158089Smlaierstatic void 2852158089Smlaieriwi_scanchan(void *arg, int npending) 2853158089Smlaier{ 2854158089Smlaier struct iwi_softc *sc = arg; 2855158089Smlaier struct ieee80211com *ic; 2856158089Smlaier struct ieee80211_channel *chan; 2857158089Smlaier struct iwi_scan_ext scan; 2858158089Smlaier IWI_LOCK_DECL; 2859158089Smlaier 2860158089Smlaier IWI_LOCK(sc); 2861158089Smlaier ic = &sc->sc_ic; 2862158089Smlaier KASSERT(ic->ic_opmode == IEEE80211_M_MONITOR, 2863158089Smlaier ("opmode %u", ic->ic_opmode)); 2864158089Smlaier chan = ic->ic_ibss_chan; 2865158089Smlaier 2866158089Smlaier memset(&scan, 0, sizeof scan); 2867158089Smlaier /* 2868158089Smlaier * Set the dwell time to a fairly small value. The firmware 2869158089Smlaier * is prone to crash when aborting a scan so it's better to 2870158089Smlaier * let a scan complete before changing channels--such as when 2871158089Smlaier * channel hopping in monitor mode. 2872158089Smlaier */ 2873158089Smlaier scan.dwell_time[IWI_SCAN_TYPE_PASSIVE] = htole16(2000); 2874158089Smlaier scan.full_scan_index = htole32(ic->ic_scan.nt_scangen); 2875158089Smlaier if (IEEE80211_IS_CHAN_5GHZ(chan)) 2876158089Smlaier scan.channels[0] = 1 | IWI_CHAN_5GHZ; 2877158089Smlaier else 2878158089Smlaier scan.channels[0] = 1 | IWI_CHAN_2GHZ; 2879158089Smlaier scan.channels[1] = ieee80211_chan2ieee(ic, chan); 2880158089Smlaier set_scan_type(&scan, 1, IWI_SCAN_TYPE_PASSIVE); 2881158089Smlaier 2882158089Smlaier DPRINTF(("Setting channel to %u\n", ieee80211_chan2ieee(ic, chan))); 2883158089Smlaier sc->flags |= IWI_FLAG_SCANNING; 2884158089Smlaier (void) iwi_cmd(sc, IWI_CMD_SCAN_EXT, &scan, sizeof scan); 2885158089Smlaier IWI_UNLOCK(sc); 2886158089Smlaier} 2887158089Smlaier 2888145247Sdamienstatic int 2889158089Smlaieriwi_set_sensitivity(struct iwi_softc *sc, int8_t rssi_dbm) 2890158089Smlaier{ 2891158089Smlaier struct iwi_sensitivity sens; 2892158089Smlaier 2893158089Smlaier DPRINTF(("Setting sensitivity to %d\n", rssi_dbm)); 2894158089Smlaier 2895158089Smlaier memset(&sens, 0, sizeof sens); 2896158089Smlaier sens.rssi = htole16(rssi_dbm); 2897158089Smlaier return iwi_cmd(sc, IWI_CMD_SET_SENSITIVITY, &sens, sizeof sens); 2898158089Smlaier} 2899158089Smlaier 2900158089Smlaierstatic int 2901145247Sdamieniwi_auth_and_assoc(struct iwi_softc *sc) 2902145247Sdamien{ 2903145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 2904145247Sdamien struct ifnet *ifp = ic->ic_ifp; 2905145247Sdamien struct ieee80211_node *ni = ic->ic_bss; 2906145247Sdamien struct iwi_configuration config; 2907158089Smlaier struct iwi_associate *assoc = &sc->assoc; 2908145247Sdamien struct iwi_rateset rs; 2909146500Sdamien uint16_t capinfo; 2910145247Sdamien int error; 2911145247Sdamien 2912145247Sdamien if (IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) { 2913145247Sdamien memset(&config, 0, sizeof config); 2914145247Sdamien config.bluetooth_coexistence = sc->bluetooth; 2915146500Sdamien config.antenna = sc->antenna; 2916145247Sdamien config.multicast_enabled = 1; 2917145247Sdamien config.use_protection = 1; 2918146500Sdamien config.answer_pbreq = 2919146500Sdamien (ic->ic_opmode == IEEE80211_M_IBSS) ? 1 : 0; 2920146500Sdamien config.disable_unicast_decryption = 1; 2921146500Sdamien config.disable_multicast_decryption = 1; 2922145247Sdamien DPRINTF(("Configuring adapter\n")); 2923158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_CONFIG, &config, sizeof config); 2924145247Sdamien if (error != 0) 2925145247Sdamien return error; 2926145247Sdamien } 2927145247Sdamien 2928145247Sdamien#ifdef IWI_DEBUG 2929145247Sdamien if (iwi_debug > 0) { 2930145247Sdamien printf("Setting ESSID to "); 2931145247Sdamien ieee80211_print_essid(ni->ni_essid, ni->ni_esslen); 2932145247Sdamien printf("\n"); 2933145247Sdamien } 2934145247Sdamien#endif 2935158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_ESSID, ni->ni_essid, ni->ni_esslen); 2936145247Sdamien if (error != 0) 2937145247Sdamien return error; 2938145247Sdamien 2939151030Sdamien /* the rate set has already been "negotiated" */ 2940145247Sdamien rs.mode = IEEE80211_IS_CHAN_5GHZ(ni->ni_chan) ? IWI_MODE_11A : 2941145247Sdamien IWI_MODE_11G; 2942151030Sdamien rs.type = IWI_RATESET_TYPE_NEGOTIATED; 2943145247Sdamien rs.nrates = ni->ni_rates.rs_nrates; 2944163618Smlaier if (rs.nrates > IWI_RATESET_SIZE) { 2945163618Smlaier DPRINTF(("Truncating negotiated rate set from %u\n", 2946163618Smlaier rs.nrates)); 2947163618Smlaier rs.nrates = IWI_RATESET_SIZE; 2948163618Smlaier } 2949145247Sdamien memcpy(rs.rates, ni->ni_rates.rs_rates, rs.nrates); 2950158089Smlaier DPRINTF(("Setting negotiated rates (%u)\n", rs.nrates)); 2951158089Smlaier error = iwi_cmd(sc, IWI_CMD_SET_RATES, &rs, sizeof rs); 2952145247Sdamien if (error != 0) 2953145247Sdamien return error; 2954145247Sdamien 2955158089Smlaier memset(assoc, 0, sizeof *assoc); 2956158089Smlaier 2957149338Sdamien if ((ic->ic_flags & IEEE80211_F_WME) && ni->ni_wme_ie != NULL) { 2958158089Smlaier /* NB: don't treat WME setup as failure */ 2959158089Smlaier if (iwi_wme_setparams_locked(sc) == 0 && iwi_wme_setie(sc) == 0) 2960158089Smlaier assoc->policy |= htole16(IWI_POLICY_WME); 2961158089Smlaier /* XXX complain on failure? */ 2962149338Sdamien } 2963149338Sdamien 2964146500Sdamien if (ic->ic_opt_ie != NULL) { 2965146500Sdamien DPRINTF(("Setting optional IE (len=%u)\n", ic->ic_opt_ie_len)); 2966146500Sdamien error = iwi_cmd(sc, IWI_CMD_SET_OPTIE, ic->ic_opt_ie, 2967158089Smlaier ic->ic_opt_ie_len); 2968146500Sdamien if (error != 0) 2969146500Sdamien return error; 2970146500Sdamien } 2971146500Sdamien 2972158089Smlaier error = iwi_set_sensitivity(sc, ni->ni_rssi); 2973145247Sdamien if (error != 0) 2974145247Sdamien return error; 2975145247Sdamien 2976158089Smlaier if (IEEE80211_IS_CHAN_A(ni->ni_chan)) 2977158089Smlaier assoc->mode = IWI_MODE_11A; 2978158089Smlaier else if (IEEE80211_IS_CHAN_G(ni->ni_chan)) 2979158089Smlaier assoc->mode = IWI_MODE_11G; 2980158089Smlaier else if (IEEE80211_IS_CHAN_B(ni->ni_chan)) 2981158089Smlaier assoc->mode = IWI_MODE_11B; 2982158089Smlaier /* XXX else error */ 2983158089Smlaier assoc->chan = ieee80211_chan2ieee(ic, ni->ni_chan); 2984158089Smlaier /* 2985158089Smlaier * NB: do not arrange for shared key auth w/o privacy 2986158089Smlaier * (i.e. a wep key); it causes a firmware error. 2987158089Smlaier */ 2988158089Smlaier if ((ic->ic_flags & IEEE80211_F_PRIVACY) && 2989158089Smlaier ni->ni_authmode == IEEE80211_AUTH_SHARED) { 2990158089Smlaier assoc->auth = IWI_AUTH_SHARED; 2991158089Smlaier /* 2992158089Smlaier * It's possible to have privacy marked but no default 2993158089Smlaier * key setup. This typically is due to a user app bug 2994158089Smlaier * but if we blindly grab the key the firmware will 2995158089Smlaier * barf so avoid it for now. 2996158089Smlaier */ 2997158089Smlaier if (ic->ic_crypto.cs_def_txkey != IEEE80211_KEYIX_NONE) 2998158089Smlaier assoc->auth |= ic->ic_crypto.cs_def_txkey << 4; 2999158089Smlaier 3000158089Smlaier error = iwi_setwepkeys(sc); 3001158089Smlaier if (error != 0) 3002158089Smlaier return error; 3003158089Smlaier } 3004155864Ssam if (ic->ic_flags & IEEE80211_F_WPA) 3005158089Smlaier assoc->policy |= htole16(IWI_POLICY_WPA); 3006158089Smlaier if (ic->ic_opmode == IEEE80211_M_IBSS && ni->ni_tstamp.tsf == 0) 3007158089Smlaier assoc->type = IWI_HC_IBSS_START; 3008158089Smlaier else 3009158089Smlaier assoc->type = IWI_HC_ASSOC; 3010158089Smlaier memcpy(assoc->tstamp, ni->ni_tstamp.data, 8); 3011146500Sdamien 3012146500Sdamien if (ic->ic_opmode == IEEE80211_M_IBSS) 3013146500Sdamien capinfo = IEEE80211_CAPINFO_IBSS; 3014146500Sdamien else 3015146500Sdamien capinfo = IEEE80211_CAPINFO_ESS; 3016146500Sdamien if (ic->ic_flags & IEEE80211_F_PRIVACY) 3017146500Sdamien capinfo |= IEEE80211_CAPINFO_PRIVACY; 3018146500Sdamien if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) && 3019146500Sdamien IEEE80211_IS_CHAN_2GHZ(ni->ni_chan)) 3020146500Sdamien capinfo |= IEEE80211_CAPINFO_SHORT_PREAMBLE; 3021158089Smlaier if (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_SLOTTIME) 3022146500Sdamien capinfo |= IEEE80211_CAPINFO_SHORT_SLOTTIME; 3023158089Smlaier assoc->capinfo = htole16(capinfo); 3024146500Sdamien 3025158089Smlaier assoc->lintval = htole16(ic->ic_lintval); 3026158089Smlaier assoc->intval = htole16(ni->ni_intval); 3027158089Smlaier IEEE80211_ADDR_COPY(assoc->bssid, ni->ni_bssid); 3028145247Sdamien if (ic->ic_opmode == IEEE80211_M_IBSS) 3029158089Smlaier IEEE80211_ADDR_COPY(assoc->dst, ifp->if_broadcastaddr); 3030145247Sdamien else 3031158089Smlaier IEEE80211_ADDR_COPY(assoc->dst, ni->ni_bssid); 3032145247Sdamien 3033158089Smlaier DPRINTF(("%s bssid %6D dst %6D channel %u policy 0x%x " 3034158089Smlaier "auth %u capinfo 0x%x lintval %u bintval %u\n", 3035158089Smlaier assoc->type == IWI_HC_IBSS_START ? "Start" : "Join", 3036158089Smlaier assoc->bssid, ":", assoc->dst, ":", 3037158089Smlaier assoc->chan, le16toh(assoc->policy), assoc->auth, 3038158089Smlaier le16toh(assoc->capinfo), le16toh(assoc->lintval), 3039158089Smlaier le16toh(assoc->intval))); 3040158089Smlaier return iwi_cmd(sc, IWI_CMD_ASSOCIATE, assoc, sizeof *assoc); 3041145247Sdamien} 3042145247Sdamien 3043158089Smlaierstatic int 3044158089Smlaieriwi_disassociate(struct iwi_softc *sc, int quiet) 3045158089Smlaier{ 3046158089Smlaier struct iwi_associate *assoc = &sc->assoc; 3047158089Smlaier 3048158089Smlaier if (quiet) 3049158089Smlaier assoc->type = IWI_HC_DISASSOC_QUIET; 3050158089Smlaier else 3051158089Smlaier assoc->type = IWI_HC_DISASSOC; 3052158089Smlaier 3053158089Smlaier DPRINTF(("Trying to disassociate from %6D channel %u\n", 3054158089Smlaier assoc->bssid, ":", assoc->chan)); 3055158089Smlaier return iwi_cmd(sc, IWI_CMD_ASSOCIATE, assoc, sizeof *assoc); 3056158089Smlaier} 3057158089Smlaier 3058145247Sdamienstatic void 3059158089Smlaieriwi_down(void *arg, int npending) 3060156598Sdamien{ 3061158089Smlaier struct iwi_softc *sc = arg; 3062158089Smlaier IWI_LOCK_DECL; 3063158089Smlaier 3064158089Smlaier IWI_LOCK(sc); 3065158089Smlaier iwi_disassociate(sc, 0); 3066158089Smlaier IWI_UNLOCK(sc); 3067156598Sdamien} 3068156598Sdamien 3069156598Sdamienstatic void 3070145247Sdamieniwi_init(void *priv) 3071145247Sdamien{ 3072145247Sdamien struct iwi_softc *sc = priv; 3073158089Smlaier IWI_LOCK_DECL; 3074158089Smlaier 3075158089Smlaier IWI_LOCK(sc); 3076158089Smlaier iwi_init_locked(sc, 0); 3077158089Smlaier IWI_UNLOCK(sc); 3078158089Smlaier} 3079158089Smlaier 3080158089Smlaierstatic void 3081158089Smlaieriwi_init_locked(void *priv, int force) 3082158089Smlaier{ 3083158089Smlaier struct iwi_softc *sc = priv; 3084145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 3085145247Sdamien struct ifnet *ifp = ic->ic_ifp; 3086145247Sdamien struct iwi_rx_data *data; 3087158089Smlaier int i; 3088158089Smlaier IWI_LOCK_DECL; 3089145247Sdamien 3090158089Smlaier if (sc->flags & IWI_FLAG_FW_LOADING) 3091158089Smlaier return; /* XXX: condvar? */ 3092156539Sdamien 3093145247Sdamien iwi_stop(sc); 3094145247Sdamien 3095145247Sdamien if (iwi_reset(sc) != 0) { 3096145247Sdamien device_printf(sc->sc_dev, "could not reset adapter\n"); 3097158089Smlaier goto fail; 3098145247Sdamien } 3099145247Sdamien 3100158089Smlaier sc->flags |= IWI_FLAG_FW_LOADING; 3101158089Smlaier 3102158089Smlaier IWI_UNLOCK(sc); 3103158089Smlaier if (!iwi_get_firmware(sc)) { 3104158089Smlaier IWI_LOCK(sc); 3105158089Smlaier goto fail; 3106152611Sdamien } 3107152611Sdamien 3108158089Smlaier /* allocate DMA memory for mapping firmware image */ 3109158089Smlaier if (sc->fw_boot.size > sc->fw_dma_size) 3110158089Smlaier sc->fw_dma_size = sc->fw_boot.size; 3111158089Smlaier if (sc->fw_fw.size > sc->fw_dma_size) 3112158089Smlaier sc->fw_dma_size = sc->fw_fw.size; 3113158089Smlaier if (sc->fw_uc.size > sc->fw_dma_size) 3114158089Smlaier sc->fw_dma_size = sc->fw_uc.size; 3115156546Sdamien 3116166416Skevlo if (bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), 4, 0, 3117166416Skevlo BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL, 3118166416Skevlo sc->fw_dma_size, 1, sc->fw_dma_size, 0, NULL, NULL, 3119166416Skevlo &sc->fw_dmat) != 0) { 3120156546Sdamien device_printf(sc->sc_dev, 3121158089Smlaier "could not create firmware DMA tag\n"); 3122158089Smlaier IWI_LOCK(sc); 3123158089Smlaier goto fail; 3124156546Sdamien } 3125158089Smlaier if (bus_dmamem_alloc(sc->fw_dmat, &sc->fw_virtaddr, 0, 3126158089Smlaier &sc->fw_map) != 0) { 3127156546Sdamien device_printf(sc->sc_dev, 3128158089Smlaier "could not allocate firmware DMA memory\n"); 3129158089Smlaier IWI_LOCK(sc); 3130156546Sdamien goto fail2; 3131156546Sdamien } 3132158089Smlaier if (bus_dmamap_load(sc->fw_dmat, sc->fw_map, sc->fw_virtaddr, 3133158089Smlaier sc->fw_dma_size, iwi_dma_map_addr, &sc->fw_physaddr, 0) != 0) { 3134158089Smlaier device_printf(sc->sc_dev, "could not load firmware DMA map\n"); 3135158089Smlaier IWI_LOCK(sc); 3136158089Smlaier goto fail3; 3137158089Smlaier } 3138158089Smlaier IWI_LOCK(sc); 3139156546Sdamien 3140158089Smlaier if (iwi_load_firmware(sc, &sc->fw_boot) != 0) { 3141156546Sdamien device_printf(sc->sc_dev, 3142158089Smlaier "could not load boot firmware %s\n", sc->fw_boot.name); 3143158089Smlaier goto fail4; 3144156546Sdamien } 3145156546Sdamien 3146158089Smlaier if (iwi_load_ucode(sc, &sc->fw_uc) != 0) { 3147158089Smlaier device_printf(sc->sc_dev, 3148158089Smlaier "could not load microcode %s\n", sc->fw_uc.name); 3149158089Smlaier goto fail4; 3150145247Sdamien } 3151145247Sdamien 3152145247Sdamien iwi_stop_master(sc); 3153145247Sdamien 3154145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CMD_BASE, sc->cmdq.physaddr); 3155145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CMD_SIZE, sc->cmdq.count); 3156145247Sdamien CSR_WRITE_4(sc, IWI_CSR_CMD_WIDX, sc->cmdq.cur); 3157145247Sdamien 3158149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX1_BASE, sc->txq[0].physaddr); 3159149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX1_SIZE, sc->txq[0].count); 3160149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX1_WIDX, sc->txq[0].cur); 3161145247Sdamien 3162149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX2_BASE, sc->txq[1].physaddr); 3163149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX2_SIZE, sc->txq[1].count); 3164149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX2_WIDX, sc->txq[1].cur); 3165145247Sdamien 3166149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX3_BASE, sc->txq[2].physaddr); 3167149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX3_SIZE, sc->txq[2].count); 3168149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX3_WIDX, sc->txq[2].cur); 3169145247Sdamien 3170149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX4_BASE, sc->txq[3].physaddr); 3171149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX4_SIZE, sc->txq[3].count); 3172149338Sdamien CSR_WRITE_4(sc, IWI_CSR_TX4_WIDX, sc->txq[3].cur); 3173145247Sdamien 3174145247Sdamien for (i = 0; i < sc->rxq.count; i++) { 3175145247Sdamien data = &sc->rxq.data[i]; 3176145247Sdamien CSR_WRITE_4(sc, data->reg, data->physaddr); 3177145247Sdamien } 3178145247Sdamien 3179145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RX_WIDX, sc->rxq.count - 1); 3180145247Sdamien 3181158089Smlaier if (iwi_load_firmware(sc, &sc->fw_fw) != 0) { 3182158089Smlaier device_printf(sc->sc_dev, 3183158089Smlaier "could not load main firmware %s\n", sc->fw_fw.name); 3184158089Smlaier goto fail4; 3185145247Sdamien } 3186145247Sdamien sc->flags |= IWI_FLAG_FW_INITED; 3187145247Sdamien 3188158089Smlaier bus_dmamap_sync(sc->fw_dmat, sc->fw_map, BUS_DMASYNC_POSTWRITE); 3189158089Smlaier bus_dmamap_unload(sc->fw_dmat, sc->fw_map); 3190158089Smlaier bus_dmamem_free(sc->fw_dmat, sc->fw_virtaddr, sc->fw_map); 3191158089Smlaier bus_dma_tag_destroy(sc->fw_dmat); 3192158089Smlaier 3193145247Sdamien if (iwi_config(sc) != 0) { 3194145247Sdamien device_printf(sc->sc_dev, "device configuration failed\n"); 3195158089Smlaier goto fail; 3196145247Sdamien } 3197145247Sdamien 3198149333Sdamien if (ic->ic_opmode != IEEE80211_M_MONITOR) { 3199158089Smlaier /* 3200158089Smlaier * NB: When restarting the adapter clock the state 3201158089Smlaier * machine regardless of the roaming mode; otherwise 3202158089Smlaier * we need to notify user apps so they can manually 3203158089Smlaier * get us going again. 3204158089Smlaier */ 3205158089Smlaier if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL || force) 3206149333Sdamien ieee80211_new_state(ic, IEEE80211_S_SCAN, -1); 3207149333Sdamien } else 3208146500Sdamien ieee80211_new_state(ic, IEEE80211_S_RUN, -1); 3209145247Sdamien 3210148887Srwatson ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 3211148887Srwatson ifp->if_drv_flags |= IFF_DRV_RUNNING; 3212145247Sdamien 3213158089Smlaier sc->flags &= ~IWI_FLAG_FW_LOADING; 3214145247Sdamien return; 3215145247Sdamien 3216158089Smlaierfail4: bus_dmamap_sync(sc->fw_dmat, sc->fw_map, BUS_DMASYNC_POSTWRITE); 3217158089Smlaier bus_dmamap_unload(sc->fw_dmat, sc->fw_map); 3218158089Smlaierfail3: bus_dmamem_free(sc->fw_dmat, sc->fw_virtaddr, sc->fw_map); 3219158089Smlaierfail2: bus_dma_tag_destroy(sc->fw_dmat); 3220158089Smlaierfail: ifp->if_flags &= ~IFF_UP; 3221158089Smlaier sc->flags &= ~IWI_FLAG_FW_LOADING; 3222145247Sdamien iwi_stop(sc); 3223158089Smlaier iwi_put_firmware(sc); 3224145247Sdamien} 3225145247Sdamien 3226145247Sdamienstatic void 3227145247Sdamieniwi_stop(void *priv) 3228145247Sdamien{ 3229145247Sdamien struct iwi_softc *sc = priv; 3230145247Sdamien struct ieee80211com *ic = &sc->sc_ic; 3231145247Sdamien struct ifnet *ifp = ic->ic_ifp; 3232145247Sdamien 3233158089Smlaier if (sc->sc_softled) { 3234158089Smlaier callout_stop(&sc->sc_ledtimer); 3235158089Smlaier sc->sc_blinking = 0; 3236158089Smlaier } 3237156539Sdamien 3238145247Sdamien iwi_stop_master(sc); 3239145247Sdamien 3240145247Sdamien CSR_WRITE_4(sc, IWI_CSR_RST, IWI_RST_SOFT_RESET); 3241145247Sdamien 3242145247Sdamien /* reset rings */ 3243145247Sdamien iwi_reset_cmd_ring(sc, &sc->cmdq); 3244149338Sdamien iwi_reset_tx_ring(sc, &sc->txq[0]); 3245149338Sdamien iwi_reset_tx_ring(sc, &sc->txq[1]); 3246149338Sdamien iwi_reset_tx_ring(sc, &sc->txq[2]); 3247149338Sdamien iwi_reset_tx_ring(sc, &sc->txq[3]); 3248145247Sdamien iwi_reset_rx_ring(sc, &sc->rxq); 3249145247Sdamien 3250145247Sdamien ifp->if_timer = 0; 3251148887Srwatson ifp->if_drv_flags &= ~(IFF_DRV_RUNNING | IFF_DRV_OACTIVE); 3252156539Sdamien 3253158089Smlaier sc->sc_tx_timer = 0; 3254158089Smlaier sc->sc_rfkill_timer = 0; 3255158089Smlaier sc->sc_scan_timer = 0; 3256158089Smlaier sc->flags &= ~(IWI_FLAG_BUSY | IWI_FLAG_SCANNING | IWI_FLAG_ASSOCIATED); 3257158089Smlaier 3258158089Smlaier ieee80211_new_state(ic, IEEE80211_S_INIT, -1); 3259145247Sdamien} 3260145247Sdamien 3261158089Smlaierstatic void 3262158089Smlaieriwi_restart(void *arg, int npending) 3263158089Smlaier{ 3264158089Smlaier struct iwi_softc *sc = arg; 3265158089Smlaier IWI_LOCK_DECL; 3266158089Smlaier 3267158089Smlaier IWI_LOCK(sc); 3268158089Smlaier iwi_init_locked(sc, 1); /* NB: force state machine */ 3269158089Smlaier IWI_UNLOCK(sc); 3270158089Smlaier} 3271158089Smlaier 3272158089Smlaier/* 3273158089Smlaier * Return whether or not the radio is enabled in hardware 3274158089Smlaier * (i.e. the rfkill switch is "off"). 3275158089Smlaier */ 3276145247Sdamienstatic int 3277158089Smlaieriwi_getrfkill(struct iwi_softc *sc) 3278158089Smlaier{ 3279158089Smlaier return (CSR_READ_4(sc, IWI_CSR_IO) & IWI_IO_RADIO_ENABLED) == 0; 3280158089Smlaier} 3281158089Smlaier 3282158089Smlaierstatic void 3283158089Smlaieriwi_radio_on(void *arg, int pending) 3284158089Smlaier{ 3285158089Smlaier struct iwi_softc *sc = arg; 3286158089Smlaier 3287158089Smlaier device_printf(sc->sc_dev, "radio turned on\n"); 3288158089Smlaier iwi_init(sc); 3289158089Smlaier} 3290158089Smlaier 3291158089Smlaierstatic void 3292158089Smlaieriwi_radio_off(void *arg, int pending) 3293158089Smlaier{ 3294158089Smlaier struct iwi_softc *sc = arg; 3295158089Smlaier 3296158089Smlaier device_printf(sc->sc_dev, "radio turned off\n"); 3297158089Smlaier iwi_stop(sc); 3298158089Smlaier sc->sc_rfkill_timer = 2; 3299158089Smlaier sc->sc_ifp->if_timer = 1; 3300158089Smlaier} 3301158089Smlaier 3302158089Smlaierstatic int 3303145247Sdamieniwi_sysctl_stats(SYSCTL_HANDLER_ARGS) 3304145247Sdamien{ 3305145247Sdamien struct iwi_softc *sc = arg1; 3306145247Sdamien uint32_t size, buf[128]; 3307145247Sdamien 3308145247Sdamien if (!(sc->flags & IWI_FLAG_FW_INITED)) { 3309145247Sdamien memset(buf, 0, sizeof buf); 3310145247Sdamien return SYSCTL_OUT(req, buf, sizeof buf); 3311145247Sdamien } 3312145247Sdamien 3313145247Sdamien size = min(CSR_READ_4(sc, IWI_CSR_TABLE0_SIZE), 128 - 1); 3314145247Sdamien CSR_READ_REGION_4(sc, IWI_CSR_TABLE0_BASE, &buf[1], size); 3315145247Sdamien 3316145247Sdamien return SYSCTL_OUT(req, buf, sizeof buf); 3317145247Sdamien} 3318145247Sdamien 3319145247Sdamienstatic int 3320145247Sdamieniwi_sysctl_radio(SYSCTL_HANDLER_ARGS) 3321145247Sdamien{ 3322145247Sdamien struct iwi_softc *sc = arg1; 3323158089Smlaier int val = !iwi_getrfkill(sc); 3324145247Sdamien 3325145247Sdamien return SYSCTL_OUT(req, &val, sizeof val); 3326145247Sdamien} 3327158089Smlaier 3328158089Smlaier/* 3329158089Smlaier * Add sysctl knobs. 3330158089Smlaier */ 3331158089Smlaierstatic void 3332158089Smlaieriwi_sysctlattach(struct iwi_softc *sc) 3333158089Smlaier{ 3334158089Smlaier struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 3335158089Smlaier struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 3336158089Smlaier 3337158089Smlaier SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "radio", 3338158089Smlaier CTLTYPE_INT | CTLFLAG_RD, sc, 0, iwi_sysctl_radio, "I", 3339158089Smlaier "radio transmitter switch state (0=off, 1=on)"); 3340158089Smlaier 3341158089Smlaier SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "stats", 3342158089Smlaier CTLTYPE_OPAQUE | CTLFLAG_RD, sc, 0, iwi_sysctl_stats, "S", 3343158089Smlaier "statistics"); 3344158089Smlaier 3345158089Smlaier sc->dwelltime = 100; 3346158089Smlaier SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "dwell", 3347158089Smlaier CTLFLAG_RW, &sc->dwelltime, 0, 3348158089Smlaier "channel dwell time (ms) for AP/station scanning"); 3349158089Smlaier 3350158089Smlaier sc->bluetooth = 0; 3351158089Smlaier SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "bluetooth", 3352158089Smlaier CTLFLAG_RW, &sc->bluetooth, 0, "bluetooth coexistence"); 3353158089Smlaier 3354158089Smlaier sc->antenna = IWI_ANTENNA_AUTO; 3355158089Smlaier SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "antenna", 3356158089Smlaier CTLFLAG_RW, &sc->antenna, 0, "antenna (0=auto)"); 3357158089Smlaier} 3358158089Smlaier 3359158089Smlaier/* 3360158089Smlaier * LED support. 3361158089Smlaier * 3362158089Smlaier * Different cards have different capabilities. Some have three 3363158089Smlaier * led's while others have only one. The linux ipw driver defines 3364158089Smlaier * led's for link state (associated or not), band (11a, 11g, 11b), 3365158089Smlaier * and for link activity. We use one led and vary the blink rate 3366158089Smlaier * according to the tx/rx traffic a la the ath driver. 3367158089Smlaier */ 3368158089Smlaier 3369158089Smlaierstatic __inline uint32_t 3370158089Smlaieriwi_toggle_event(uint32_t r) 3371158089Smlaier{ 3372158089Smlaier return r &~ (IWI_RST_STANDBY | IWI_RST_GATE_ODMA | 3373158089Smlaier IWI_RST_GATE_IDMA | IWI_RST_GATE_ADMA); 3374158089Smlaier} 3375158089Smlaier 3376158089Smlaierstatic uint32_t 3377158089Smlaieriwi_read_event(struct iwi_softc *sc) 3378158089Smlaier{ 3379158089Smlaier return MEM_READ_4(sc, IWI_MEM_EEPROM_EVENT); 3380158089Smlaier} 3381158089Smlaier 3382158089Smlaierstatic void 3383158089Smlaieriwi_write_event(struct iwi_softc *sc, uint32_t v) 3384158089Smlaier{ 3385158089Smlaier MEM_WRITE_4(sc, IWI_MEM_EEPROM_EVENT, v); 3386158089Smlaier} 3387158089Smlaier 3388158089Smlaierstatic void 3389158089Smlaieriwi_led_done(void *arg) 3390158089Smlaier{ 3391158089Smlaier struct iwi_softc *sc = arg; 3392158089Smlaier 3393158089Smlaier sc->sc_blinking = 0; 3394158089Smlaier} 3395158089Smlaier 3396158089Smlaier/* 3397158089Smlaier * Turn the activity LED off: flip the pin and then set a timer so no 3398158089Smlaier * update will happen for the specified duration. 3399158089Smlaier */ 3400158089Smlaierstatic void 3401158089Smlaieriwi_led_off(void *arg) 3402158089Smlaier{ 3403158089Smlaier struct iwi_softc *sc = arg; 3404158089Smlaier uint32_t v; 3405158089Smlaier 3406158089Smlaier v = iwi_read_event(sc); 3407158089Smlaier v &= ~sc->sc_ledpin; 3408158089Smlaier iwi_write_event(sc, iwi_toggle_event(v)); 3409158089Smlaier callout_reset(&sc->sc_ledtimer, sc->sc_ledoff, iwi_led_done, sc); 3410158089Smlaier} 3411158089Smlaier 3412158089Smlaier/* 3413158089Smlaier * Blink the LED according to the specified on/off times. 3414158089Smlaier */ 3415158089Smlaierstatic void 3416158089Smlaieriwi_led_blink(struct iwi_softc *sc, int on, int off) 3417158089Smlaier{ 3418158089Smlaier uint32_t v; 3419158089Smlaier 3420158089Smlaier v = iwi_read_event(sc); 3421158089Smlaier v |= sc->sc_ledpin; 3422158089Smlaier iwi_write_event(sc, iwi_toggle_event(v)); 3423158089Smlaier sc->sc_blinking = 1; 3424158089Smlaier sc->sc_ledoff = off; 3425158089Smlaier callout_reset(&sc->sc_ledtimer, on, iwi_led_off, sc); 3426158089Smlaier} 3427158089Smlaier 3428158089Smlaierstatic void 3429158089Smlaieriwi_led_event(struct iwi_softc *sc, int event) 3430158089Smlaier{ 3431158089Smlaier#define N(a) (sizeof(a)/sizeof(a[0])) 3432158089Smlaier /* NB: on/off times from the Atheros NDIS driver, w/ permission */ 3433158089Smlaier static const struct { 3434158089Smlaier u_int rate; /* tx/rx iwi rate */ 3435158089Smlaier u_int16_t timeOn; /* LED on time (ms) */ 3436158089Smlaier u_int16_t timeOff; /* LED off time (ms) */ 3437158089Smlaier } blinkrates[] = { 3438158089Smlaier { IWI_RATE_OFDM54, 40, 10 }, 3439158089Smlaier { IWI_RATE_OFDM48, 44, 11 }, 3440158089Smlaier { IWI_RATE_OFDM36, 50, 13 }, 3441158089Smlaier { IWI_RATE_OFDM24, 57, 14 }, 3442158089Smlaier { IWI_RATE_OFDM18, 67, 16 }, 3443158089Smlaier { IWI_RATE_OFDM12, 80, 20 }, 3444158089Smlaier { IWI_RATE_DS11, 100, 25 }, 3445158089Smlaier { IWI_RATE_OFDM9, 133, 34 }, 3446158089Smlaier { IWI_RATE_OFDM6, 160, 40 }, 3447158089Smlaier { IWI_RATE_DS5, 200, 50 }, 3448158089Smlaier { 6, 240, 58 }, /* XXX 3Mb/s if it existed */ 3449158089Smlaier { IWI_RATE_DS2, 267, 66 }, 3450158089Smlaier { IWI_RATE_DS1, 400, 100 }, 3451158089Smlaier { 0, 500, 130 }, /* unknown rate/polling */ 3452158089Smlaier }; 3453158089Smlaier uint32_t txrate; 3454158089Smlaier int j = 0; /* XXX silence compiler */ 3455158089Smlaier 3456158089Smlaier sc->sc_ledevent = ticks; /* time of last event */ 3457158089Smlaier if (sc->sc_blinking) /* don't interrupt active blink */ 3458158089Smlaier return; 3459158089Smlaier switch (event) { 3460158089Smlaier case IWI_LED_POLL: 3461158089Smlaier j = N(blinkrates)-1; 3462158089Smlaier break; 3463158089Smlaier case IWI_LED_TX: 3464158089Smlaier /* read current transmission rate from adapter */ 3465158089Smlaier txrate = CSR_READ_4(sc, IWI_CSR_CURRENT_TX_RATE); 3466158089Smlaier if (blinkrates[sc->sc_txrix].rate != txrate) { 3467158089Smlaier for (j = 0; j < N(blinkrates)-1; j++) 3468158089Smlaier if (blinkrates[j].rate == txrate) 3469158089Smlaier break; 3470158089Smlaier sc->sc_txrix = j; 3471158089Smlaier } else 3472158089Smlaier j = sc->sc_txrix; 3473158089Smlaier break; 3474158089Smlaier case IWI_LED_RX: 3475158089Smlaier if (blinkrates[sc->sc_rxrix].rate != sc->sc_rxrate) { 3476158089Smlaier for (j = 0; j < N(blinkrates)-1; j++) 3477158089Smlaier if (blinkrates[j].rate == sc->sc_rxrate) 3478158089Smlaier break; 3479158089Smlaier sc->sc_rxrix = j; 3480158089Smlaier } else 3481158089Smlaier j = sc->sc_rxrix; 3482158089Smlaier break; 3483158089Smlaier } 3484158089Smlaier /* XXX beware of overflow */ 3485158089Smlaier iwi_led_blink(sc, (blinkrates[j].timeOn * hz) / 1000, 3486158089Smlaier (blinkrates[j].timeOff * hz) / 1000); 3487158089Smlaier#undef N 3488158089Smlaier} 3489158089Smlaier 3490158089Smlaierstatic int 3491158089Smlaieriwi_sysctl_softled(SYSCTL_HANDLER_ARGS) 3492158089Smlaier{ 3493158089Smlaier struct iwi_softc *sc = arg1; 3494158089Smlaier int softled = sc->sc_softled; 3495158089Smlaier int error; 3496158089Smlaier 3497158089Smlaier error = sysctl_handle_int(oidp, &softled, 0, req); 3498158089Smlaier if (error || !req->newptr) 3499158089Smlaier return error; 3500158089Smlaier softled = (softled != 0); 3501158089Smlaier if (softled != sc->sc_softled) { 3502158089Smlaier if (softled) { 3503158089Smlaier uint32_t v = iwi_read_event(sc); 3504158089Smlaier v &= ~sc->sc_ledpin; 3505158089Smlaier iwi_write_event(sc, iwi_toggle_event(v)); 3506158089Smlaier } 3507158089Smlaier sc->sc_softled = softled; 3508158089Smlaier } 3509158089Smlaier return 0; 3510158089Smlaier} 3511158089Smlaier 3512158089Smlaierstatic void 3513158089Smlaieriwi_ledattach(struct iwi_softc *sc) 3514158089Smlaier{ 3515158089Smlaier struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 3516158089Smlaier struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 3517158089Smlaier 3518158089Smlaier sc->sc_blinking = 0; 3519158089Smlaier sc->sc_ledstate = 1; 3520158089Smlaier sc->sc_ledidle = (2700*hz)/1000; /* 2.7sec */ 3521158089Smlaier callout_init_mtx(&sc->sc_ledtimer, &sc->sc_mtx, 0); 3522158089Smlaier 3523158089Smlaier SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 3524158089Smlaier "softled", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 3525158089Smlaier iwi_sysctl_softled, "I", "enable/disable software LED support"); 3526158089Smlaier SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 3527158089Smlaier "ledpin", CTLFLAG_RW, &sc->sc_ledpin, 0, 3528158089Smlaier "pin setting to turn activity LED on"); 3529158089Smlaier SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 3530158089Smlaier "ledidle", CTLFLAG_RW, &sc->sc_ledidle, 0, 3531158089Smlaier "idle time for inactivity LED (ticks)"); 3532158089Smlaier /* XXX for debugging */ 3533158089Smlaier SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 3534158089Smlaier "nictype", CTLFLAG_RD, &sc->sc_nictype, 0, 3535158089Smlaier "NIC type from EEPROM"); 3536158089Smlaier 3537158089Smlaier sc->sc_ledpin = IWI_RST_LED_ACTIVITY; 3538158089Smlaier sc->sc_softled = 1; 3539158089Smlaier 3540158089Smlaier sc->sc_nictype = (iwi_read_prom_word(sc, IWI_EEPROM_NIC) >> 8) & 0xff; 3541158089Smlaier if (sc->sc_nictype == 1) { 3542158089Smlaier /* 3543158089Smlaier * NB: led's are reversed. 3544158089Smlaier */ 3545158089Smlaier sc->sc_ledpin = IWI_RST_LED_ASSOCIATED; 3546158089Smlaier } 3547158089Smlaier} 3548