2 * Copyright (c) 2004-2006
3 * Damien Bergamini <damien.bergamini@free.fr>.
4 * Copyright (c) 2004, 2005
5 * Andrew Atrens <atrens@nortelnetworks.com>.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice unmodified, this list of conditions, and the following
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * $FreeBSD: src/sys/dev/iwi/if_iwi.c,v 1.8.2.6 2006/02/23 02:06:46 sam Exp $
32 * $DragonFly: src/sys/dev/netif/iwi/if_iwi.c,v 1.21 2008/05/14 11:59:20 sephe Exp $
36 * Intel(R) PRO/Wireless 2200BG/2225BG/2915ABG driver
37 * http://www.intel.com/network/connectivity/products/wireless/prowireless_mobile.htm
40 #include <sys/param.h>
41 #include <sys/sysctl.h>
42 #include <sys/sockio.h>
44 #include <sys/kernel.h>
45 #include <sys/kthread.h>
46 #include <sys/interrupt.h>
47 #include <sys/socket.h>
48 #include <sys/systm.h>
49 #include <sys/malloc.h>
50 #include <sys/module.h>
51 #include <sys/endian.h>
53 #include <sys/ucred.h>
56 #include <sys/serialize.h>
58 #include <bus/pci/pcidevs.h>
59 #include <bus/pci/pcireg.h>
60 #include <bus/pci/pcivar.h>
64 #include <net/if_arp.h>
65 #include <net/ethernet.h>
66 #include <net/if_dl.h>
67 #include <net/if_media.h>
68 #include <net/if_types.h>
69 #include <net/ifq_var.h>
71 #include <netproto/802_11/ieee80211_var.h>
72 #include <netproto/802_11/ieee80211_radiotap.h>
74 #include <netinet/in.h>
75 #include <netinet/in_systm.h>
76 #include <netinet/in_var.h>
77 #include <netinet/ip.h>
78 #include <netinet/if_ether.h>
80 #include <dev/netif/iwi/if_iwireg.h>
81 #include <dev/netif/iwi/if_iwivar.h>
84 #define DPRINTF(x) do { if (iwi_debug > 0) kprintf x; } while (0)
85 #define DPRINTFN(n, x) do { if (iwi_debug >= (n)) kprintf x; } while (0)
87 SYSCTL_INT(_debug
, OID_AUTO
, iwi
, CTLFLAG_RW
, &iwi_debug
, 0, "iwi debug level");
90 #define DPRINTFN(n, x)
93 static struct iwi_ident
{
97 } iwi_ident_table
[] = {
98 { PCI_VENDOR_INTEL
, PCI_PRODUCT_INTEL_PRO_WL_2200BG
,
99 "Intel(R) PRO/Wireless 2200BG" },
100 { PCI_VENDOR_INTEL
, PCI_PRODUCT_INTEL_PRO_WL_2225BG
,
101 "Intel(R) PRO/Wireless 2225BG" },
102 { PCI_VENDOR_INTEL
, PCI_PRODUCT_INTEL_PRO_WL_2915ABG_1
,
103 "Intel(R) PRO/Wireless 2915ABG" },
104 { PCI_VENDOR_INTEL
, PCI_PRODUCT_INTEL_PRO_WL_2915ABG_2
,
105 "Intel(R) PRO/Wireless 2915ABG" },
109 static void iwi_fw_monitor(void *);
110 static void iwi_dma_map_addr(void *, bus_dma_segment_t
*, int, int);
111 static void iwi_dma_map_mbuf(void *, bus_dma_segment_t
*, int, bus_size_t
,
113 static int iwi_alloc_cmd_ring(struct iwi_softc
*, struct iwi_cmd_ring
*,
115 static void iwi_reset_cmd_ring(struct iwi_softc
*, struct iwi_cmd_ring
*);
116 static void iwi_free_cmd_ring(struct iwi_softc
*, struct iwi_cmd_ring
*);
117 static int iwi_alloc_tx_ring(struct iwi_softc
*, struct iwi_tx_ring
*,
118 int, bus_addr_t
, bus_addr_t
);
119 static void iwi_reset_tx_ring(struct iwi_softc
*, struct iwi_tx_ring
*);
120 static void iwi_free_tx_ring(struct iwi_softc
*, struct iwi_tx_ring
*);
121 static int iwi_alloc_rx_ring(struct iwi_softc
*, struct iwi_rx_ring
*,
123 static void iwi_reset_rx_ring(struct iwi_softc
*, struct iwi_rx_ring
*);
124 static void iwi_free_rx_ring(struct iwi_softc
*, struct iwi_rx_ring
*);
125 static struct ieee80211_node
*iwi_node_alloc(struct ieee80211_node_table
*);
126 static void iwi_node_free(struct ieee80211_node
*);
127 static int iwi_media_change(struct ifnet
*);
128 static void iwi_media_status(struct ifnet
*, struct ifmediareq
*);
129 static int iwi_newstate(struct ieee80211com
*, enum ieee80211_state
, int);
130 static int iwi_wme_update(struct ieee80211com
*);
131 static uint16_t iwi_read_prom_word(struct iwi_softc
*, uint8_t);
132 static void iwi_fix_channel(struct ieee80211com
*, struct mbuf
*);
133 static void iwi_frame_intr(struct iwi_softc
*, struct iwi_rx_data
*, int,
135 static void iwi_notification_intr(struct iwi_softc
*, struct iwi_notif
*);
136 static void iwi_rx_intr(struct iwi_softc
*);
137 static void iwi_tx_intr(struct iwi_softc
*, struct iwi_tx_ring
*);
138 static void iwi_intr(void *);
139 static int iwi_cmd(struct iwi_softc
*, uint8_t, void *, uint8_t, int);
140 static void iwi_write_ibssnode(struct iwi_softc
*, const struct iwi_node
*);
141 static int iwi_tx_start(struct ifnet
*, struct mbuf
*,
142 struct ieee80211_node
*, int);
143 static void iwi_start(struct ifnet
*);
144 static void iwi_watchdog(struct ifnet
*);
145 static int iwi_ioctl(struct ifnet
*, u_long
, caddr_t
, struct ucred
*);
146 static void iwi_stop_master(struct iwi_softc
*);
147 static int iwi_reset(struct iwi_softc
*);
148 static int iwi_load_ucode(struct iwi_softc
*, void *, int);
149 static int iwi_load_firmware(struct iwi_softc
*, void *, int);
150 static int iwi_cache_firmware(struct iwi_softc
*, void *);
151 static void iwi_free_firmware(struct iwi_softc
*);
152 static int iwi_config(struct iwi_softc
*);
153 static int iwi_set_chan(struct iwi_softc
*, struct ieee80211_channel
*);
154 static int iwi_scan(struct iwi_softc
*);
155 static int iwi_auth_and_assoc(struct iwi_softc
*);
156 static void iwi_init(void *);
157 static void iwi_stop(void *);
158 static int iwi_sysctl_stats(SYSCTL_HANDLER_ARGS
);
159 static int iwi_sysctl_radio(SYSCTL_HANDLER_ARGS
);
161 static int iwi_probe(device_t
);
162 static int iwi_attach(device_t
);
163 static int iwi_detach(device_t
);
164 static int iwi_shutdown(device_t
);
165 static int iwi_suspend(device_t
);
166 static int iwi_resume(device_t
);
168 static int iwi_alloc_ibss_node(struct iwi_softc
*);
169 static void iwi_free_ibss_node(struct iwi_softc
*, int);
171 static device_method_t iwi_methods
[] = {
172 /* Device interface */
173 DEVMETHOD(device_probe
, iwi_probe
),
174 DEVMETHOD(device_attach
, iwi_attach
),
175 DEVMETHOD(device_detach
, iwi_detach
),
176 DEVMETHOD(device_shutdown
, iwi_shutdown
),
177 DEVMETHOD(device_suspend
, iwi_suspend
),
178 DEVMETHOD(device_resume
, iwi_resume
),
183 static driver_t iwi_driver
= {
186 sizeof (struct iwi_softc
)
189 static devclass_t iwi_devclass
;
191 DRIVER_MODULE(iwi
, pci
, iwi_driver
, iwi_devclass
, 0, 0);
193 MODULE_DEPEND(iwi
, pci
, 1, 1, 1);
194 MODULE_DEPEND(iwi
, wlan
, 1, 1, 1);
197 * Supported rates for 802.11a/b/g modes (in 500Kbps unit).
199 static const struct ieee80211_rateset iwi_rateset_11a
=
200 { 8, { 12, 18, 24, 36, 48, 72, 96, 108 } };
202 static const struct ieee80211_rateset iwi_rateset_11b
=
203 { 4, { 2, 4, 11, 22 } };
205 static const struct ieee80211_rateset iwi_rateset_11g
=
206 { 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } };
209 iwi_fw_monitor(void *arg
)
211 struct iwi_softc
*sc
= arg
;
212 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
214 lwkt_serialize_enter(ifp
->if_serializer
);
219 * Test to see whether we are detaching,
220 * this is used to avoid race condition
221 * especially when attaching fails.
223 if ((sc
->flags
& IWI_FLAG_EXIT
) == 0) {
225 tsleep_interlock(IWI_FW_WAKE_MONITOR(sc
));
226 lwkt_serialize_exit(ifp
->if_serializer
);
227 error
= tsleep(IWI_FW_WAKE_MONITOR(sc
),
230 lwkt_serialize_enter(ifp
->if_serializer
);
236 if (sc
->flags
& IWI_FLAG_EXIT
)
238 else if ((sc
->flags
& IWI_FLAG_RESET
) == 0)
241 if_printf(ifp
, "reset firmware\n");
242 for (boff
= 1; sc
->flags
& IWI_FLAG_RESET
; boff
++) {
244 if (sc
->flags
& IWI_FLAG_FW_INITED
) {
245 sc
->flags
&= ~IWI_FLAG_RESET
;
246 } else if (boff
> 10) { /* XXX */
247 if_printf(ifp
, "fw reset failed. "
250 /* XXX avoid to sleep to long */
255 * Since this would be infinite loop,
256 * if reseting firmware never succeeded,
257 * we test to see whether we are detaching.
259 if (sc
->flags
& IWI_FLAG_EXIT
)
263 tsleep_interlock(IWI_FW_CMD_ACKED(sc
));
264 lwkt_serialize_exit(ifp
->if_serializer
);
265 error
= tsleep(IWI_FW_CMD_ACKED(sc
), 0,
266 "iwirun", boff
* hz
);
268 lwkt_serialize_enter(ifp
->if_serializer
);
272 lwkt_serialize_exit(ifp
->if_serializer
);
274 if_printf(ifp
, "fw monitor exiting\n");
275 wakeup(IWI_FW_EXIT_MONITOR(sc
));
280 iwi_probe(device_t dev
)
282 const struct iwi_ident
*ident
;
285 vid
= pci_get_vendor(dev
);
286 did
= pci_get_device(dev
);
287 for (ident
= iwi_ident_table
; ident
->name
!= NULL
; ident
++) {
288 if (vid
== ident
->vendor
&& did
== ident
->device
) {
289 device_set_desc(dev
, ident
->name
);
296 /* Base Address Register */
297 #define IWI_PCI_BAR0 0x10
300 iwi_attach(device_t dev
)
302 struct iwi_softc
*sc
= device_get_softc(dev
);
303 struct ieee80211com
*ic
= &sc
->sc_ic
;
304 struct ifnet
*ifp
= &ic
->ic_if
;
309 if_initname(ifp
, device_get_name(dev
), device_get_unit(dev
));
311 if (pci_get_powerstate(dev
) != PCI_POWERSTATE_D0
) {
312 device_printf(dev
, "chip is in D%d power mode "
313 "-- setting to D0\n", pci_get_powerstate(dev
));
314 pci_set_powerstate(dev
, PCI_POWERSTATE_D0
);
317 pci_write_config(dev
, 0x41, 0, 1);
319 /* enable bus-mastering */
320 pci_enable_busmaster(dev
);
322 sc
->mem_rid
= IWI_PCI_BAR0
;
323 sc
->mem
= bus_alloc_resource_any(dev
, SYS_RES_MEMORY
, &sc
->mem_rid
,
325 if (sc
->mem
== NULL
) {
326 device_printf(dev
, "could not allocate memory resource\n");
329 sc
->sc_st
= rman_get_bustag(sc
->mem
);
330 sc
->sc_sh
= rman_get_bushandle(sc
->mem
);
333 sc
->irq
= bus_alloc_resource_any(dev
, SYS_RES_IRQ
, &sc
->irq_rid
,
334 RF_ACTIVE
| RF_SHAREABLE
);
335 if (sc
->irq
== NULL
) {
336 device_printf(dev
, "could not allocate interrupt resource\n");
340 if (iwi_reset(sc
) != 0) {
341 device_printf(dev
, "could not reset adapter\n");
348 error
= iwi_alloc_cmd_ring(sc
, &sc
->cmdq
, IWI_CMD_RING_COUNT
);
350 device_printf(dev
, "could not allocate Cmd ring\n");
354 error
= iwi_alloc_tx_ring(sc
, &sc
->txq
[0], IWI_TX_RING_COUNT
,
355 IWI_CSR_TX1_RIDX
, IWI_CSR_TX1_WIDX
);
357 device_printf(dev
, "could not allocate Tx ring 1\n");
361 error
= iwi_alloc_tx_ring(sc
, &sc
->txq
[1], IWI_TX_RING_COUNT
,
362 IWI_CSR_TX2_RIDX
, IWI_CSR_TX2_WIDX
);
364 device_printf(dev
, "could not allocate Tx ring 2\n");
368 error
= iwi_alloc_tx_ring(sc
, &sc
->txq
[2], IWI_TX_RING_COUNT
,
369 IWI_CSR_TX3_RIDX
, IWI_CSR_TX3_WIDX
);
371 device_printf(dev
, "could not allocate Tx ring 3\n");
375 error
= iwi_alloc_tx_ring(sc
, &sc
->txq
[3], IWI_TX_RING_COUNT
,
376 IWI_CSR_TX4_RIDX
, IWI_CSR_TX4_WIDX
);
378 device_printf(dev
, "could not allocate Tx ring 4\n");
382 error
= iwi_alloc_rx_ring(sc
, &sc
->rxq
, IWI_RX_RING_COUNT
);
384 device_printf(dev
, "could not allocate Rx ring\n");
388 sysctl_ctx_init(&sc
->sysctl_ctx
);
389 sc
->sysctl_tree
= SYSCTL_ADD_NODE(&sc
->sysctl_ctx
,
390 SYSCTL_STATIC_CHILDREN(_hw
),
392 device_get_nameunit(dev
),
395 if (sc
->sysctl_tree
== NULL
) {
396 device_printf(dev
, "sysctl add node failed\n");
402 ifp
->if_flags
= IFF_BROADCAST
| IFF_SIMPLEX
| IFF_MULTICAST
;
403 ifp
->if_init
= iwi_init
;
404 ifp
->if_ioctl
= iwi_ioctl
;
405 ifp
->if_start
= iwi_start
;
406 ifp
->if_watchdog
= iwi_watchdog
;
407 ifq_set_maxlen(&ifp
->if_snd
, IFQ_MAXLEN
);
408 ifq_set_ready(&ifp
->if_snd
);
410 ic
->ic_wme
.wme_update
= iwi_wme_update
;
411 ic
->ic_phytype
= IEEE80211_T_OFDM
; /* not only, but not used */
412 ic
->ic_opmode
= IEEE80211_M_STA
; /* default to BSS mode */
413 ic
->ic_state
= IEEE80211_S_INIT
;
415 /* set device capabilities */
417 IEEE80211_C_IBSS
| /* IBSS mode supported */
418 IEEE80211_C_MONITOR
| /* monitor mode supported */
419 IEEE80211_C_TXPMGT
| /* tx power management */
420 IEEE80211_C_SHPREAMBLE
| /* short preamble supported */
421 IEEE80211_C_WPA
| /* 802.11i */
422 IEEE80211_C_WME
; /* 802.11e */
424 /* read MAC address from EEPROM */
425 val
= iwi_read_prom_word(sc
, IWI_EEPROM_MAC
+ 0);
426 ic
->ic_myaddr
[0] = val
& 0xff;
427 ic
->ic_myaddr
[1] = val
>> 8;
428 val
= iwi_read_prom_word(sc
, IWI_EEPROM_MAC
+ 1);
429 ic
->ic_myaddr
[2] = val
& 0xff;
430 ic
->ic_myaddr
[3] = val
>> 8;
431 val
= iwi_read_prom_word(sc
, IWI_EEPROM_MAC
+ 2);
432 ic
->ic_myaddr
[4] = val
& 0xff;
433 ic
->ic_myaddr
[5] = val
>> 8;
435 if (pci_get_device(dev
) >= 0x4223) {
436 /* set supported .11a rates (2915ABG only) */
437 ic
->ic_sup_rates
[IEEE80211_MODE_11A
] = iwi_rateset_11a
;
439 /* set supported .11a channels */
440 for (i
= 36; i
<= 64; i
+= 4) {
441 ic
->ic_channels
[i
].ic_freq
=
442 ieee80211_ieee2mhz(i
, IEEE80211_CHAN_5GHZ
);
443 ic
->ic_channels
[i
].ic_flags
= IEEE80211_CHAN_A
;
445 for (i
= 149; i
<= 165; i
+= 4) {
446 ic
->ic_channels
[i
].ic_freq
=
447 ieee80211_ieee2mhz(i
, IEEE80211_CHAN_5GHZ
);
448 ic
->ic_channels
[i
].ic_flags
= IEEE80211_CHAN_A
;
452 /* set supported .11b and .11g rates */
453 ic
->ic_sup_rates
[IEEE80211_MODE_11B
] = iwi_rateset_11b
;
454 ic
->ic_sup_rates
[IEEE80211_MODE_11G
] = iwi_rateset_11g
;
456 /* set supported .11b and .11g channels (1 through 14) */
457 for (i
= 1; i
<= 14; i
++) {
458 ic
->ic_channels
[i
].ic_freq
=
459 ieee80211_ieee2mhz(i
, IEEE80211_CHAN_2GHZ
);
460 ic
->ic_channels
[i
].ic_flags
=
461 IEEE80211_CHAN_CCK
| IEEE80211_CHAN_OFDM
|
462 IEEE80211_CHAN_DYN
| IEEE80211_CHAN_2GHZ
;
465 ieee80211_ifattach(ic
);
466 /* override default methods */
467 ic
->ic_node_alloc
= iwi_node_alloc
;
468 sc
->sc_node_free
= ic
->ic_node_free
;
469 ic
->ic_node_free
= iwi_node_free
;
470 /* override state transition machine */
471 sc
->sc_newstate
= ic
->ic_newstate
;
472 ic
->ic_newstate
= iwi_newstate
;
473 ieee80211_media_init(ic
, iwi_media_change
, iwi_media_status
);
475 bpfattach_dlt(ifp
, DLT_IEEE802_11_RADIO
,
476 sizeof (struct ieee80211_frame
) + 64, &sc
->sc_drvbpf
);
478 sc
->sc_rxtap_len
= sizeof sc
->sc_rxtapu
;
479 sc
->sc_rxtap
.wr_ihdr
.it_len
= htole16(sc
->sc_rxtap_len
);
480 sc
->sc_rxtap
.wr_ihdr
.it_present
= htole32(IWI_RX_RADIOTAP_PRESENT
);
482 sc
->sc_txtap_len
= sizeof sc
->sc_txtapu
;
483 sc
->sc_txtap
.wt_ihdr
.it_len
= htole16(sc
->sc_txtap_len
);
484 sc
->sc_txtap
.wt_ihdr
.it_present
= htole32(IWI_TX_RADIOTAP_PRESENT
);
487 * Add a few sysctl knobs.
493 SYSCTL_ADD_PROC(&sc
->sysctl_ctx
,
494 SYSCTL_CHILDREN(sc
->sysctl_tree
), OID_AUTO
, "radio",
495 CTLTYPE_INT
| CTLFLAG_RD
, sc
, 0, iwi_sysctl_radio
, "I",
496 "radio transmitter switch state (0=off, 1=on)");
498 SYSCTL_ADD_PROC(&sc
->sysctl_ctx
,
499 SYSCTL_CHILDREN(sc
->sysctl_tree
), OID_AUTO
, "stats",
500 CTLTYPE_OPAQUE
| CTLFLAG_RD
, sc
, 0, iwi_sysctl_stats
, "S",
503 SYSCTL_ADD_INT(&sc
->sysctl_ctx
,
504 SYSCTL_CHILDREN(sc
->sysctl_tree
), OID_AUTO
, "dwell",
505 CTLFLAG_RW
, &sc
->dwelltime
, 0,
506 "channel dwell time (ms) for AP/station scanning");
508 SYSCTL_ADD_INT(&sc
->sysctl_ctx
,
509 SYSCTL_CHILDREN(sc
->sysctl_tree
), OID_AUTO
, "bluetooth",
510 CTLFLAG_RW
, &sc
->bluetooth
, 0, "bluetooth coexistence");
512 SYSCTL_ADD_INT(&sc
->sysctl_ctx
,
513 SYSCTL_CHILDREN(sc
->sysctl_tree
), OID_AUTO
, "antenna",
514 CTLFLAG_RW
, &sc
->antenna
, 0, "antenna (0=auto)");
517 * Start firmware monitoring thread
520 * This should be done only after serializer is initialized,
521 * i.e. after ieee80211_ifattach(), because serializer will be
522 * held once iwi_fw_monitor() is entered.
524 error
= kthread_create(iwi_fw_monitor
, sc
, &sc
->sc_fw_monitor
,
525 "%s:fw-monitor", device_get_nameunit(dev
));
527 device_printf(dev
, "could not create fw monitor\n");
530 sc
->flags
|= IWI_FLAG_MONITOR
;
533 * Hook our interrupt after all initialization is complete.
535 error
= bus_setup_intr(dev
, sc
->irq
, INTR_MPSAFE
, iwi_intr
, sc
,
536 &sc
->sc_ih
, ifp
->if_serializer
);
538 device_printf(dev
, "could not set up interrupt\n");
542 ifp
->if_cpuid
= ithread_cpuid(rman_get_start(sc
->irq
));
543 KKASSERT(ifp
->if_cpuid
>= 0 && ifp
->if_cpuid
< ncpus
);
546 ieee80211_announce(ic
);
552 ieee80211_ifdetach(ic
);
559 iwi_detach(device_t dev
)
561 struct iwi_softc
*sc
= device_get_softc(dev
);
562 struct ieee80211com
*ic
= &sc
->sc_ic
;
563 struct ifnet
*ifp
= ic
->ic_ifp
;
565 if (sc
->flags
& IWI_FLAG_MONITOR
) {
566 lwkt_serialize_enter(ifp
->if_serializer
);
567 sc
->flags
|= IWI_FLAG_EXIT
;
568 wakeup(IWI_FW_WAKE_MONITOR(sc
));
571 tsleep_interlock(IWI_FW_EXIT_MONITOR(sc
));
572 lwkt_serialize_exit(ifp
->if_serializer
);
573 tsleep(IWI_FW_EXIT_MONITOR(sc
), 0, "iwiexi", 0);
575 /* No need to hold serializer again */
577 if_printf(ifp
, "fw monitor exited\n");
580 if (device_is_attached(dev
)) {
581 lwkt_serialize_enter(ifp
->if_serializer
);
584 bus_teardown_intr(dev
, sc
->irq
, sc
->sc_ih
);
585 iwi_free_firmware(sc
);
587 lwkt_serialize_exit(ifp
->if_serializer
);
590 ieee80211_ifdetach(ic
);
593 iwi_free_cmd_ring(sc
, &sc
->cmdq
);
594 iwi_free_tx_ring(sc
, &sc
->txq
[0]);
595 iwi_free_tx_ring(sc
, &sc
->txq
[1]);
596 iwi_free_tx_ring(sc
, &sc
->txq
[2]);
597 iwi_free_tx_ring(sc
, &sc
->txq
[3]);
598 iwi_free_rx_ring(sc
, &sc
->rxq
);
601 bus_release_resource(dev
, SYS_RES_IRQ
, sc
->irq_rid
, sc
->irq
);
604 bus_release_resource(dev
, SYS_RES_MEMORY
, sc
->mem_rid
, sc
->mem
);
606 if (sc
->sysctl_tree
!= NULL
)
607 sysctl_ctx_free(&sc
->sysctl_ctx
);
613 iwi_dma_map_addr(void *arg
, bus_dma_segment_t
*segs
, int nseg
, int error
)
618 KASSERT(nseg
== 1, ("too many DMA segments, %d should be 1", nseg
));
620 *(bus_addr_t
*)arg
= segs
[0].ds_addr
;
624 iwi_alloc_cmd_ring(struct iwi_softc
*sc
, struct iwi_cmd_ring
*ring
, int count
)
630 ring
->cur
= ring
->next
= 0;
632 error
= bus_dma_tag_create(NULL
, 4, 0, BUS_SPACE_MAXADDR_32BIT
,
633 BUS_SPACE_MAXADDR
, NULL
, NULL
, count
* IWI_CMD_DESC_SIZE
, 1,
634 count
* IWI_CMD_DESC_SIZE
, 0, &ring
->desc_dmat
);
636 device_printf(sc
->sc_dev
, "could not create desc DMA tag\n");
640 error
= bus_dmamem_alloc(ring
->desc_dmat
, (void **)&ring
->desc
,
641 BUS_DMA_WAITOK
| BUS_DMA_ZERO
, &ring
->desc_map
);
643 device_printf(sc
->sc_dev
, "could not allocate DMA memory\n");
647 error
= bus_dmamap_load(ring
->desc_dmat
, ring
->desc_map
, ring
->desc
,
648 count
* IWI_CMD_DESC_SIZE
, iwi_dma_map_addr
, &ring
->physaddr
, 0);
650 device_printf(sc
->sc_dev
, "could not load desc DMA map\n");
651 bus_dmamem_free(ring
->desc_dmat
, ring
->desc
, ring
->desc_map
);
658 fail
: iwi_free_cmd_ring(sc
, ring
);
663 iwi_reset_cmd_ring(struct iwi_softc
*sc
, struct iwi_cmd_ring
*ring
)
666 ring
->cur
= ring
->next
= 0;
670 iwi_free_cmd_ring(struct iwi_softc
*sc
, struct iwi_cmd_ring
*ring
)
672 if (ring
->desc
!= NULL
) {
673 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
,
674 BUS_DMASYNC_POSTWRITE
);
675 bus_dmamap_unload(ring
->desc_dmat
, ring
->desc_map
);
676 bus_dmamem_free(ring
->desc_dmat
, ring
->desc
, ring
->desc_map
);
680 if (ring
->desc_dmat
!= NULL
) {
681 bus_dma_tag_destroy(ring
->desc_dmat
);
682 ring
->desc_dmat
= NULL
;
687 iwi_alloc_tx_ring(struct iwi_softc
*sc
, struct iwi_tx_ring
*ring
, int count
,
688 bus_addr_t csr_ridx
, bus_addr_t csr_widx
)
694 ring
->cur
= ring
->next
= 0;
695 ring
->csr_ridx
= csr_ridx
;
696 ring
->csr_widx
= csr_widx
;
698 error
= bus_dma_tag_create(NULL
, 4, 0, BUS_SPACE_MAXADDR_32BIT
,
699 BUS_SPACE_MAXADDR
, NULL
, NULL
, count
* IWI_TX_DESC_SIZE
, 1,
700 count
* IWI_TX_DESC_SIZE
, 0, &ring
->desc_dmat
);
702 device_printf(sc
->sc_dev
, "could not create desc DMA tag\n");
706 error
= bus_dmamem_alloc(ring
->desc_dmat
, (void **)&ring
->desc
,
707 BUS_DMA_WAITOK
| BUS_DMA_ZERO
, &ring
->desc_map
);
709 device_printf(sc
->sc_dev
, "could not allocate DMA memory\n");
713 error
= bus_dmamap_load(ring
->desc_dmat
, ring
->desc_map
, ring
->desc
,
714 count
* IWI_TX_DESC_SIZE
, iwi_dma_map_addr
, &ring
->physaddr
, 0);
716 device_printf(sc
->sc_dev
, "could not load desc DMA map\n");
718 bus_dmamem_free(ring
->desc_dmat
, ring
->desc
, ring
->desc_map
);
723 ring
->data
= kmalloc(count
* sizeof (struct iwi_tx_data
), M_DEVBUF
,
726 error
= bus_dma_tag_create(NULL
, 1, 0, BUS_SPACE_MAXADDR_32BIT
,
727 BUS_SPACE_MAXADDR
, NULL
, NULL
, MCLBYTES
, IWI_MAX_NSEG
- 2,
728 MCLBYTES
, 0, &ring
->data_dmat
);
730 device_printf(sc
->sc_dev
, "could not create data DMA tag\n");
734 for (i
= 0; i
< count
; i
++) {
735 error
= bus_dmamap_create(ring
->data_dmat
, 0,
738 device_printf(sc
->sc_dev
, "could not create DMA map\n");
745 fail
: iwi_free_tx_ring(sc
, ring
);
750 iwi_reset_tx_ring(struct iwi_softc
*sc
, struct iwi_tx_ring
*ring
)
752 struct iwi_tx_data
*data
;
755 for (i
= 0; i
< ring
->count
; i
++) {
756 data
= &ring
->data
[i
];
758 if (data
->m
!= NULL
) {
759 bus_dmamap_sync(ring
->data_dmat
, data
->map
,
760 BUS_DMASYNC_POSTWRITE
);
761 bus_dmamap_unload(ring
->data_dmat
, data
->map
);
766 if (data
->ni
!= NULL
) {
767 ieee80211_free_node(data
->ni
);
773 ring
->cur
= ring
->next
= 0;
777 iwi_free_tx_ring(struct iwi_softc
*sc
, struct iwi_tx_ring
*ring
)
779 struct iwi_tx_data
*data
;
782 if (ring
->desc
!= NULL
) {
783 bus_dmamap_sync(ring
->desc_dmat
, ring
->desc_map
,
784 BUS_DMASYNC_POSTWRITE
);
785 bus_dmamap_unload(ring
->desc_dmat
, ring
->desc_map
);
786 bus_dmamem_free(ring
->desc_dmat
, ring
->desc
, ring
->desc_map
);
790 if (ring
->desc_dmat
!= NULL
) {
791 bus_dma_tag_destroy(ring
->desc_dmat
);
792 ring
->desc_dmat
= NULL
;
795 if (ring
->data
!= NULL
) {
796 for (i
= 0; i
< ring
->count
; i
++) {
797 data
= &ring
->data
[i
];
799 if (data
->m
!= NULL
) {
800 bus_dmamap_sync(ring
->data_dmat
, data
->map
,
801 BUS_DMASYNC_POSTWRITE
);
802 bus_dmamap_unload(ring
->data_dmat
, data
->map
);
807 if (data
->ni
!= NULL
) {
808 ieee80211_free_node(data
->ni
);
812 if (data
->map
!= NULL
) {
813 bus_dmamap_destroy(ring
->data_dmat
, data
->map
);
818 kfree(ring
->data
, M_DEVBUF
);
822 if (ring
->data_dmat
!= NULL
) {
823 bus_dma_tag_destroy(ring
->data_dmat
);
824 ring
->data_dmat
= NULL
;
829 iwi_alloc_rx_ring(struct iwi_softc
*sc
, struct iwi_rx_ring
*ring
, int count
)
831 struct iwi_rx_data
*data
;
837 ring
->data
= kmalloc(count
* sizeof (struct iwi_rx_data
), M_DEVBUF
,
840 error
= bus_dma_tag_create(NULL
, 1, 0, BUS_SPACE_MAXADDR_32BIT
,
841 BUS_SPACE_MAXADDR
, NULL
, NULL
, MCLBYTES
, 1, MCLBYTES
, 0,
844 device_printf(sc
->sc_dev
, "could not create data DMA tag\n");
848 for (i
= 0; i
< count
; i
++) {
849 data
= &ring
->data
[i
];
851 error
= bus_dmamap_create(ring
->data_dmat
, 0, &data
->map
);
853 device_printf(sc
->sc_dev
, "could not create DMA map\n");
857 data
->m
= m_getcl(MB_WAIT
, MT_DATA
, M_PKTHDR
);
858 if (data
->m
== NULL
) {
859 device_printf(sc
->sc_dev
,
860 "could not allocate rx mbuf\n");
865 error
= bus_dmamap_load(ring
->data_dmat
, data
->map
,
866 mtod(data
->m
, void *), MCLBYTES
, iwi_dma_map_addr
,
869 device_printf(sc
->sc_dev
,
870 "could not load rx buf DMA map");
877 data
->reg
= IWI_CSR_RX_BASE
+ i
* 4;
882 fail
: iwi_free_rx_ring(sc
, ring
);
887 iwi_reset_rx_ring(struct iwi_softc
*sc
, struct iwi_rx_ring
*ring
)
893 iwi_free_rx_ring(struct iwi_softc
*sc
, struct iwi_rx_ring
*ring
)
895 struct iwi_rx_data
*data
;
898 if (ring
->data
!= NULL
) {
899 for (i
= 0; i
< ring
->count
; i
++) {
900 data
= &ring
->data
[i
];
902 if (data
->m
!= NULL
) {
903 bus_dmamap_sync(ring
->data_dmat
, data
->map
,
904 BUS_DMASYNC_POSTREAD
);
905 bus_dmamap_unload(ring
->data_dmat
, data
->map
);
910 if (data
->map
!= NULL
) {
911 bus_dmamap_destroy(ring
->data_dmat
, data
->map
);
916 kfree(ring
->data
, M_DEVBUF
);
920 if (ring
->data_dmat
!= NULL
) {
921 bus_dma_tag_destroy(ring
->data_dmat
);
922 ring
->data_dmat
= NULL
;
927 iwi_shutdown(device_t dev
)
929 struct iwi_softc
*sc
= device_get_softc(dev
);
930 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
932 lwkt_serialize_enter(ifp
->if_serializer
);
934 lwkt_serialize_exit(ifp
->if_serializer
);
940 iwi_suspend(device_t dev
)
942 struct iwi_softc
*sc
= device_get_softc(dev
);
943 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
945 lwkt_serialize_enter(ifp
->if_serializer
);
947 lwkt_serialize_exit(ifp
->if_serializer
);
953 iwi_resume(device_t dev
)
955 struct iwi_softc
*sc
= device_get_softc(dev
);
956 struct ifnet
*ifp
= sc
->sc_ic
.ic_ifp
;
958 lwkt_serialize_enter(ifp
->if_serializer
);
960 pci_write_config(dev
, 0x41, 0, 1);
962 if (ifp
->if_flags
& IFF_UP
) {
963 ifp
->if_init(ifp
->if_softc
);
964 if (ifp
->if_flags
& IFF_RUNNING
)
968 lwkt_serialize_exit(ifp
->if_serializer
);
973 static struct ieee80211_node
*
974 iwi_node_alloc(struct ieee80211_node_table
*nt
)
978 in
= kmalloc(sizeof (struct iwi_node
), M_80211_NODE
, M_NOWAIT
| M_ZERO
);
988 iwi_node_free(struct ieee80211_node
*ni
)
990 struct ieee80211com
*ic
= ni
->ni_ic
;
991 struct iwi_softc
*sc
= ic
->ic_ifp
->if_softc
;
992 struct iwi_node
*in
= (struct iwi_node
*)ni
;
994 if (in
->in_station
!= -1)
995 iwi_free_ibss_node(sc
, in
->in_station
);
997 sc
->sc_node_free(ni
);
1001 iwi_media_change(struct ifnet
*ifp
)
1003 struct iwi_softc
*sc
= ifp
->if_softc
;
1006 ASSERT_SERIALIZED(ifp
->if_serializer
);
1008 error
= ieee80211_media_change(ifp
);
1009 if (error
!= ENETRESET
)
1012 if ((ifp
->if_flags
& (IFF_UP
| IFF_RUNNING
)) == (IFF_UP
| IFF_RUNNING
))
1018 * The firmware automatically adapts the transmit speed. We report its current
1022 iwi_media_status(struct ifnet
*ifp
, struct ifmediareq
*imr
)
1024 struct iwi_softc
*sc
= ifp
->if_softc
;
1025 struct ieee80211com
*ic
= &sc
->sc_ic
;
1026 #define N(a) (sizeof (a) / sizeof (a[0]))
1027 static const struct {
1031 { IWI_RATE_DS1
, 2 },
1032 { IWI_RATE_DS2
, 4 },
1033 { IWI_RATE_DS5
, 11 },
1034 { IWI_RATE_DS11
, 22 },
1035 { IWI_RATE_OFDM6
, 12 },
1036 { IWI_RATE_OFDM9
, 18 },
1037 { IWI_RATE_OFDM12
, 24 },
1038 { IWI_RATE_OFDM18
, 36 },
1039 { IWI_RATE_OFDM24
, 48 },
1040 { IWI_RATE_OFDM36
, 72 },
1041 { IWI_RATE_OFDM48
, 96 },
1042 { IWI_RATE_OFDM54
, 108 },
1047 imr
->ifm_status
= IFM_AVALID
;
1048 imr
->ifm_active
= IFM_IEEE80211
;
1049 if (ic
->ic_state
== IEEE80211_S_RUN
)
1050 imr
->ifm_status
|= IFM_ACTIVE
;
1052 /* read current transmission rate from adapter */
1053 val
= CSR_READ_4(sc
, IWI_CSR_CURRENT_TX_RATE
);
1055 /* convert rate to 802.11 rate */
1056 for (i
= 0; i
< N(rates
) && rates
[i
].val
!= val
; i
++);
1057 rate
= (i
< N(rates
)) ? rates
[i
].rate
: 0;
1059 imr
->ifm_active
|= ieee80211_rate2media(ic
, rate
, ic
->ic_curmode
);
1060 switch (ic
->ic_opmode
) {
1061 case IEEE80211_M_STA
:
1064 case IEEE80211_M_IBSS
:
1065 imr
->ifm_active
|= IFM_IEEE80211_ADHOC
;
1068 case IEEE80211_M_MONITOR
:
1069 imr
->ifm_active
|= IFM_IEEE80211_MONITOR
;
1072 case IEEE80211_M_AHDEMO
:
1073 case IEEE80211_M_HOSTAP
:
1074 /* should not get there */
1081 iwi_newstate(struct ieee80211com
*ic
, enum ieee80211_state nstate
, int arg
)
1083 struct ifnet
*ifp
= ic
->ic_ifp
;
1084 struct iwi_softc
*sc
= ifp
->if_softc
;
1085 enum ieee80211_state ostate
;
1088 ostate
= ic
->ic_state
;
1091 case IEEE80211_S_SCAN
:
1092 if (sc
->flags
& IWI_FLAG_SCANNING
)
1095 ieee80211_node_table_reset(&ic
->ic_scan
);
1096 ic
->ic_flags
|= IEEE80211_F_SCAN
| IEEE80211_F_ASCAN
;
1097 sc
->flags
|= IWI_FLAG_SCANNING
;
1101 case IEEE80211_S_AUTH
:
1102 iwi_auth_and_assoc(sc
);
1105 case IEEE80211_S_RUN
:
1106 if (ic
->ic_opmode
== IEEE80211_M_IBSS
)
1107 iwi_auth_and_assoc(sc
);
1108 else if (ic
->ic_opmode
== IEEE80211_M_MONITOR
)
1109 iwi_set_chan(sc
, ic
->ic_ibss_chan
);
1112 tmp
= MEM_READ_4(sc
, IWI_MEM_EVENT_CTL
) & IWI_LED_MASK
;
1113 MEM_WRITE_4(sc
, IWI_MEM_EVENT_CTL
, tmp
| IWI_LED_ASSOC
);
1115 return sc
->sc_newstate(ic
, nstate
,
1116 IEEE80211_FC0_SUBTYPE_ASSOC_RESP
);
1118 case IEEE80211_S_ASSOC
:
1121 case IEEE80211_S_INIT
:
1122 sc
->flags
&= ~IWI_FLAG_SCANNING
;
1124 if (ostate
!= IEEE80211_S_RUN
)
1128 tmp
= MEM_READ_4(sc
, IWI_MEM_EVENT_CTL
) & IWI_LED_MASK
;
1129 MEM_WRITE_4(sc
, IWI_MEM_EVENT_CTL
, tmp
& ~IWI_LED_ASSOC
);
1133 ic
->ic_state
= nstate
;
1139 * WME parameters coming from IEEE 802.11e specification. These values are
1140 * already declared in ieee80211_proto.c, but they are static so they can't
1143 static const struct wmeParams iwi_wme_cck_params
[WME_NUM_AC
] = {
1144 { 0, 3, 5, 7, 0 }, /* WME_AC_BE */
1145 { 0, 3, 5, 10, 0 }, /* WME_AC_BK */
1146 { 0, 2, 4, 5, 188 }, /* WME_AC_VI */
1147 { 0, 2, 3, 4, 102 } /* WME_AC_VO */
1150 static const struct wmeParams iwi_wme_ofdm_params
[WME_NUM_AC
] = {
1151 { 0, 3, 4, 6, 0 }, /* WME_AC_BE */
1152 { 0, 3, 4, 10, 0 }, /* WME_AC_BK */
1153 { 0, 2, 3, 4, 94 }, /* WME_AC_VI */
1154 { 0, 2, 2, 3, 47 } /* WME_AC_VO */
1158 iwi_wme_update(struct ieee80211com
*ic
)
1160 #define IWI_EXP2(v) htole16((1 << (v)) - 1)
1161 #define IWI_USEC(v) htole16(IEEE80211_TXOP_TO_US(v))
1162 struct iwi_softc
*sc
= ic
->ic_ifp
->if_softc
;
1163 struct iwi_wme_params wme
[3];
1164 const struct wmeParams
*wmep
;
1168 * We shall not override firmware default WME values if WME is not
1171 if (!(ic
->ic_flags
& IEEE80211_F_WME
))
1174 for (ac
= 0; ac
< WME_NUM_AC
; ac
++) {
1175 /* set WME values for current operating mode */
1176 wmep
= &ic
->ic_wme
.wme_chanParams
.cap_wmeParams
[ac
];
1177 wme
[0].aifsn
[ac
] = wmep
->wmep_aifsn
;
1178 wme
[0].cwmin
[ac
] = IWI_EXP2(wmep
->wmep_logcwmin
);
1179 wme
[0].cwmax
[ac
] = IWI_EXP2(wmep
->wmep_logcwmax
);
1180 wme
[0].burst
[ac
] = IWI_USEC(wmep
->wmep_txopLimit
);
1181 wme
[0].acm
[ac
] = wmep
->wmep_acm
;
1183 /* set WME values for CCK modulation */
1184 wmep
= &iwi_wme_cck_params
[ac
];
1185 wme
[1].aifsn
[ac
] = wmep
->wmep_aifsn
;
1186 wme
[1].cwmin
[ac
] = IWI_EXP2(wmep
->wmep_logcwmin
);
1187 wme
[1].cwmax
[ac
] = IWI_EXP2(wmep
->wmep_logcwmax
);
1188 wme
[1].burst
[ac
] = IWI_USEC(wmep
->wmep_txopLimit
);
1189 wme
[1].acm
[ac
] = wmep
->wmep_acm
;
1191 /* set WME values for OFDM modulation */
1192 wmep
= &iwi_wme_ofdm_params
[ac
];
1193 wme
[2].aifsn
[ac
] = wmep
->wmep_aifsn
;
1194 wme
[2].cwmin
[ac
] = IWI_EXP2(wmep
->wmep_logcwmin
);
1195 wme
[2].cwmax
[ac
] = IWI_EXP2(wmep
->wmep_logcwmax
);
1196 wme
[2].burst
[ac
] = IWI_USEC(wmep
->wmep_txopLimit
);
1197 wme
[2].acm
[ac
] = wmep
->wmep_acm
;
1200 DPRINTF(("Setting WME parameters\n"));
1201 return iwi_cmd(sc
, IWI_CMD_SET_WME_PARAMS
, wme
, sizeof wme
, 1);
1207 * Read 16 bits at address 'addr' from the serial EEPROM.
1210 iwi_read_prom_word(struct iwi_softc
*sc
, uint8_t addr
)
1216 /* Clock C once before the first command */
1217 IWI_EEPROM_CTL(sc
, 0);
1218 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
);
1219 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_C
);
1220 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
);
1222 /* Write start bit (1) */
1223 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_D
);
1224 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_D
| IWI_EEPROM_C
);
1226 /* Write READ opcode (10) */
1227 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_D
);
1228 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_D
| IWI_EEPROM_C
);
1229 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
);
1230 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_C
);
1232 /* Write address A7-A0 */
1233 for (n
= 7; n
>= 0; n
--) {
1234 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
|
1235 (((addr
>> n
) & 1) << IWI_EEPROM_SHIFT_D
));
1236 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
|
1237 (((addr
>> n
) & 1) << IWI_EEPROM_SHIFT_D
) | IWI_EEPROM_C
);
1240 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
);
1242 /* Read data Q15-Q0 */
1244 for (n
= 15; n
>= 0; n
--) {
1245 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
| IWI_EEPROM_C
);
1246 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
);
1247 tmp
= MEM_READ_4(sc
, IWI_MEM_EEPROM_CTL
);
1248 val
|= ((tmp
& IWI_EEPROM_Q
) >> IWI_EEPROM_SHIFT_Q
) << n
;
1251 IWI_EEPROM_CTL(sc
, 0);
1253 /* Clear Chip Select and clock C */
1254 IWI_EEPROM_CTL(sc
, IWI_EEPROM_S
);
1255 IWI_EEPROM_CTL(sc
, 0);
1256 IWI_EEPROM_CTL(sc
, IWI_EEPROM_C
);
1262 * XXX: Hack to set the current channel to the value advertised in beacons or
1263 * probe responses. Only used during AP detection.
1266 iwi_fix_channel(struct ieee80211com
*ic
, struct mbuf
*m
)
1268 struct ieee80211_frame
*wh
;
1270 uint8_t *frm
, *efrm
;
1272 wh
= mtod(m
, struct ieee80211_frame
*);
1274 if ((wh
->i_fc
[0] & IEEE80211_FC0_TYPE_MASK
) != IEEE80211_FC0_TYPE_MGT
)
1277 subtype
= wh
->i_fc
[0] & IEEE80211_FC0_SUBTYPE_MASK
;
1279 if (subtype
!= IEEE80211_FC0_SUBTYPE_BEACON
&&
1280 subtype
!= IEEE80211_FC0_SUBTYPE_PROBE_RESP
)
1283 frm
= (uint8_t *)(wh
+ 1);
1284 efrm
= mtod(m
, uint8_t *) + m
->m_len
;
1286 frm
+= 12; /* skip tstamp, bintval and capinfo fields */
1287 while (frm
< efrm
) {
1288 if (*frm
== IEEE80211_ELEMID_DSPARMS
)
1289 #if IEEE80211_CHAN_MAX < 255
1290 if (frm
[2] <= IEEE80211_CHAN_MAX
)
1292 ic
->ic_curchan
= &ic
->ic_channels
[frm
[2]];
1299 iwi_frame_intr(struct iwi_softc
*sc
, struct iwi_rx_data
*data
, int i
,
1300 struct iwi_frame
*frame
)
1302 struct ieee80211com
*ic
= &sc
->sc_ic
;
1303 struct ifnet
*ifp
= ic
->ic_ifp
;
1304 struct mbuf
*mnew
, *m
;
1305 struct ieee80211_frame
*wh
;
1306 struct ieee80211_node
*ni
;
1309 DPRINTFN(5, ("received frame len=%u chan=%u rssi=%u\n",
1310 le16toh(frame
->len
), frame
->chan
, frame
->rssi_dbm
));
1312 if (le16toh(frame
->len
) < sizeof (struct ieee80211_frame
))
1316 * Try to allocate a new mbuf for this ring element and load it before
1317 * processing the current mbuf. If the ring element cannot be loaded,
1318 * drop the received packet and reuse the old mbuf. In the unlikely
1319 * case that the old mbuf can't be reloaded either, explicitly panic.
1321 mnew
= m_getcl(MB_DONTWAIT
, MT_DATA
, M_PKTHDR
);
1327 bus_dmamap_unload(sc
->rxq
.data_dmat
, data
->map
);
1329 error
= bus_dmamap_load(sc
->rxq
.data_dmat
, data
->map
,
1330 mtod(mnew
, void *), MCLBYTES
, iwi_dma_map_addr
, &data
->physaddr
,
1335 /* try to reload the old mbuf */
1336 error
= bus_dmamap_load(sc
->rxq
.data_dmat
, data
->map
,
1337 mtod(data
->m
, void *), MCLBYTES
, iwi_dma_map_addr
,
1338 &data
->physaddr
, 0);
1340 /* very unlikely that it will fail... */
1341 panic("%s: could not load old rx mbuf",
1342 device_get_name(sc
->sc_dev
));
1349 * New mbuf successfully loaded, update Rx ring and continue
1354 CSR_WRITE_4(sc
, data
->reg
, data
->physaddr
);
1357 m
->m_pkthdr
.rcvif
= ifp
;
1358 m
->m_pkthdr
.len
= m
->m_len
= sizeof (struct iwi_hdr
) +
1359 sizeof (struct iwi_frame
) + le16toh(frame
->len
);
1361 m_adj(m
, sizeof (struct iwi_hdr
) + sizeof (struct iwi_frame
));
1363 if (ic
->ic_state
== IEEE80211_S_SCAN
)
1364 iwi_fix_channel(ic
, m
);
1366 if (sc
->sc_drvbpf
!= NULL
) {
1367 struct iwi_rx_radiotap_header
*tap
= &sc
->sc_rxtap
;
1370 tap
->wr_rate
= frame
->rate
;
1372 htole16(ic
->ic_channels
[frame
->chan
].ic_freq
);
1373 tap
->wr_chan_flags
=
1374 htole16(ic
->ic_channels
[frame
->chan
].ic_flags
);
1375 tap
->wr_antsignal
= frame
->signal
;
1376 tap
->wr_antenna
= frame
->antenna
;
1378 bpf_ptap(sc
->sc_drvbpf
, m
, tap
, sc
->sc_rxtap_len
);
1381 wh
= mtod(m
, struct ieee80211_frame
*);
1382 ni
= ieee80211_find_rxnode(ic
, (struct ieee80211_frame_min
*)wh
);
1384 /* send the frame to the 802.11 layer */
1385 ieee80211_input(ic
, m
, ni
, frame
->rssi_dbm
, 0);
1387 /* node is no longer needed */
1388 ieee80211_free_node(ni
);
1392 iwi_notification_intr(struct iwi_softc
*sc
, struct iwi_notif
*notif
)
1394 struct ieee80211com
*ic
= &sc
->sc_ic
;
1395 struct iwi_notif_scan_channel
*chan
;
1396 struct iwi_notif_scan_complete
*scan
;
1397 struct iwi_notif_authentication
*auth
;
1398 struct iwi_notif_association
*assoc
;
1400 switch (notif
->type
) {
1401 case IWI_NOTIF_TYPE_SCAN_CHANNEL
:
1402 chan
= (struct iwi_notif_scan_channel
*)(notif
+ 1);
1404 DPRINTFN(2, ("Scanning channel (%u)\n", chan
->nchan
));
1407 case IWI_NOTIF_TYPE_SCAN_COMPLETE
:
1408 scan
= (struct iwi_notif_scan_complete
*)(notif
+ 1);
1410 DPRINTFN(2, ("Scan completed (%u, %u)\n", scan
->nchan
,
1413 /* monitor mode uses scan to set the channel ... */
1414 if (ic
->ic_opmode
!= IEEE80211_M_MONITOR
) {
1415 sc
->flags
&= ~IWI_FLAG_SCANNING
;
1416 ieee80211_end_scan(ic
);
1418 iwi_set_chan(sc
, ic
->ic_ibss_chan
);
1421 case IWI_NOTIF_TYPE_AUTHENTICATION
:
1422 auth
= (struct iwi_notif_authentication
*)(notif
+ 1);
1424 DPRINTFN(2, ("Authentication (%u)\n", auth
->state
));
1426 switch (auth
->state
) {
1427 case IWI_AUTHENTICATED
:
1428 ieee80211_node_authorize(ic
->ic_bss
);
1429 ieee80211_new_state(ic
, IEEE80211_S_ASSOC
, -1);
1432 case IWI_DEAUTHENTICATED
:
1436 device_printf(sc
->sc_dev
,
1437 "unknown authentication state %u\n", auth
->state
);
1441 case IWI_NOTIF_TYPE_ASSOCIATION
:
1442 assoc
= (struct iwi_notif_association
*)(notif
+ 1);
1444 DPRINTFN(2, ("Association (%u, %u)\n", assoc
->state
,
1447 switch (assoc
->state
) {
1448 case IWI_AUTHENTICATED
:
1449 /* re-association, do nothing */
1452 case IWI_ASSOCIATED
:
1453 ieee80211_new_state(ic
, IEEE80211_S_RUN
, -1);
1456 case IWI_DEASSOCIATED
:
1457 ieee80211_begin_scan(ic
, 1);
1461 device_printf(sc
->sc_dev
,
1462 "unknown association state %u\n", assoc
->state
);
1467 DPRINTFN(5, ("Notification (%u)\n", notif
->type
));
1472 iwi_rx_intr(struct iwi_softc
*sc
)
1474 struct iwi_rx_data
*data
;
1475 struct iwi_hdr
*hdr
;
1478 hw
= CSR_READ_4(sc
, IWI_CSR_RX_RIDX
);
1480 for (; sc
->rxq
.cur
!= hw
;) {
1481 data
= &sc
->rxq
.data
[sc
->rxq
.cur
];
1483 bus_dmamap_sync(sc
->rxq
.data_dmat
, data
->map
,
1484 BUS_DMASYNC_POSTREAD
);
1486 hdr
= mtod(data
->m
, struct iwi_hdr
*);
1488 switch (hdr
->type
) {
1489 case IWI_HDR_TYPE_FRAME
:
1490 iwi_frame_intr(sc
, data
, sc
->rxq
.cur
,
1491 (struct iwi_frame
*)(hdr
+ 1));
1494 case IWI_HDR_TYPE_NOTIF
:
1495 iwi_notification_intr(sc
,
1496 (struct iwi_notif
*)(hdr
+ 1));
1500 device_printf(sc
->sc_dev
, "unknown hdr type %u\n",
1504 DPRINTFN(15, ("rx done idx=%u\n", sc
->rxq
.cur
));
1506 sc
->rxq
.cur
= (sc
->rxq
.cur
+ 1) % IWI_RX_RING_COUNT
;
1509 /* Tell the firmware what we have processed */
1510 hw
= (hw
== 0) ? IWI_RX_RING_COUNT
- 1 : hw
- 1;
1511 CSR_WRITE_4(sc
, IWI_CSR_RX_WIDX
, hw
);
1515 iwi_tx_intr(struct iwi_softc
*sc
, struct iwi_tx_ring
*txq
)
1517 struct ieee80211com
*ic
= &sc
->sc_ic
;
1518 struct ifnet
*ifp
= ic
->ic_ifp
;
1519 struct iwi_tx_data
*data
;
1522 hw
= CSR_READ_4(sc
, txq
->csr_ridx
);
1524 for (; txq
->next
!= hw
;) {
1525 data
= &txq
->data
[txq
->next
];
1527 bus_dmamap_sync(txq
->data_dmat
, data
->map
,
1528 BUS_DMASYNC_POSTWRITE
);
1529 bus_dmamap_unload(txq
->data_dmat
, data
->map
);
1532 ieee80211_free_node(data
->ni
);
1535 DPRINTFN(15, ("tx done idx=%u\n", txq
->next
));
1540 txq
->next
= (txq
->next
+ 1) % IWI_TX_RING_COUNT
;
1543 sc
->sc_tx_timer
= 0;
1544 ifp
->if_flags
&= ~IFF_OACTIVE
;
1551 struct iwi_softc
*sc
= arg
;
1554 r
= CSR_READ_4(sc
, IWI_CSR_INTR
);
1555 if (r
== 0 || r
== 0xffffffff)
1558 /* disable interrupts */
1559 CSR_WRITE_4(sc
, IWI_CSR_INTR_MASK
, 0);
1561 if (r
& IWI_INTR_FATAL_ERROR
) {
1562 device_printf(sc
->sc_dev
, "fatal error\n");
1564 if ((sc
->flags
& (IWI_FLAG_EXIT
| IWI_FLAG_RESET
)) == 0) {
1565 sc
->flags
|= IWI_FLAG_RESET
;
1566 device_printf(sc
->sc_dev
, "wake firmware monitor\n");
1567 wakeup(IWI_FW_WAKE_MONITOR(sc
));
1571 if (r
& IWI_INTR_PARITY_ERROR
) {
1572 device_printf(sc
->sc_dev
, "parity error\n");
1573 sc
->sc_ic
.ic_ifp
->if_flags
&= ~IFF_UP
;
1577 if (r
& IWI_INTR_FW_INITED
) {
1578 if (!(r
& (IWI_INTR_FATAL_ERROR
| IWI_INTR_PARITY_ERROR
)))
1579 wakeup(IWI_FW_INITIALIZED(sc
));
1582 if (r
& IWI_INTR_RADIO_OFF
) {
1583 DPRINTF(("radio transmitter turned off\n"));
1584 sc
->sc_ic
.ic_ifp
->if_flags
&= ~IFF_UP
;
1588 if (r
& IWI_INTR_CMD_DONE
)
1589 wakeup(IWI_FW_CMD_ACKED(sc
));
1591 if (r
& IWI_INTR_TX1_DONE
)
1592 iwi_tx_intr(sc
, &sc
->txq
[0]);
1594 if (r
& IWI_INTR_TX2_DONE
)
1595 iwi_tx_intr(sc
, &sc
->txq
[1]);
1597 if (r
& IWI_INTR_TX3_DONE
)
1598 iwi_tx_intr(sc
, &sc
->txq
[2]);
1600 if (r
& IWI_INTR_TX4_DONE
)
1601 iwi_tx_intr(sc
, &sc
->txq
[3]);
1603 if (r
& IWI_INTR_RX_DONE
)
1606 /* acknowledge interrupts */
1607 CSR_WRITE_4(sc
, IWI_CSR_INTR
, r
);
1609 /* re-enable interrupts */
1610 CSR_WRITE_4(sc
, IWI_CSR_INTR_MASK
, IWI_INTR_MASK
);
1614 iwi_cmd(struct iwi_softc
*sc
, uint8_t type
, void *data
, uint8_t len
, int async
)
1616 struct iwi_cmd_desc
*desc
;
1617 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
1620 desc
= &sc
->cmdq
.desc
[sc
->cmdq
.cur
];
1622 desc
->hdr
.type
= IWI_HDR_TYPE_COMMAND
;
1623 desc
->hdr
.flags
= IWI_HDR_FLAG_IRQ
;
1626 memcpy(desc
->data
, data
, len
);
1628 bus_dmamap_sync(sc
->cmdq
.desc_dmat
, sc
->cmdq
.desc_map
,
1629 BUS_DMASYNC_PREWRITE
);
1631 DPRINTFN(2, ("sending command idx=%u type=%u len=%u\n", sc
->cmdq
.cur
,
1634 sc
->cmdq
.cur
= (sc
->cmdq
.cur
+ 1) % IWI_CMD_RING_COUNT
;
1635 CSR_WRITE_4(sc
, IWI_CSR_CMD_WIDX
, sc
->cmdq
.cur
);
1638 ASSERT_SERIALIZED(ifp
->if_serializer
);
1641 tsleep_interlock(IWI_FW_CMD_ACKED(sc
));
1642 lwkt_serialize_exit(ifp
->if_serializer
);
1643 ret
= tsleep(IWI_FW_CMD_ACKED(sc
), 0, "iwicmd", hz
);
1645 lwkt_serialize_enter(ifp
->if_serializer
);
1654 iwi_write_ibssnode(struct iwi_softc
*sc
, const struct iwi_node
*in
)
1656 struct iwi_ibssnode node
;
1658 /* write node information into NIC memory */
1659 memset(&node
, 0, sizeof node
);
1660 IEEE80211_ADDR_COPY(node
.bssid
, in
->in_node
.ni_macaddr
);
1662 CSR_WRITE_REGION_1(sc
,
1663 IWI_CSR_NODE_BASE
+ in
->in_station
* sizeof node
,
1664 (uint8_t *)&node
, sizeof node
);
1667 struct iwi_dma_mapping
{
1668 bus_dma_segment_t segs
[IWI_MAX_NSEG
];
1674 iwi_dma_map_mbuf(void *arg
, bus_dma_segment_t
*segs
, int nseg
,
1675 bus_size_t mapsize
, int error
)
1677 struct iwi_dma_mapping
*map
= arg
;
1682 KASSERT(nseg
<= IWI_MAX_NSEG
, ("too many DMA segments %d", nseg
));
1684 bcopy(segs
, map
->segs
, nseg
* sizeof(bus_dma_segment_t
));
1686 map
->mapsize
= mapsize
;
1690 iwi_tx_start(struct ifnet
*ifp
, struct mbuf
*m0
, struct ieee80211_node
*ni
,
1693 struct iwi_softc
*sc
= ifp
->if_softc
;
1694 struct ieee80211com
*ic
= &sc
->sc_ic
;
1695 struct iwi_node
*in
= (struct iwi_node
*)ni
;
1696 struct ieee80211_frame
*wh
;
1697 struct ieee80211_key
*k
;
1698 const struct chanAccParams
*cap
;
1699 struct iwi_tx_ring
*txq
= &sc
->txq
[ac
];
1700 struct iwi_tx_data
*data
;
1701 struct iwi_tx_desc
*desc
;
1703 struct iwi_dma_mapping map
;
1704 int error
, hdrlen
, i
, noack
= 0;
1706 wh
= mtod(m0
, struct ieee80211_frame
*);
1708 if (wh
->i_fc
[0] & IEEE80211_FC0_SUBTYPE_QOS
) {
1709 hdrlen
= sizeof (struct ieee80211_qosframe
);
1710 cap
= &ic
->ic_wme
.wme_chanParams
;
1711 noack
= cap
->cap_wmeParams
[ac
].wmep_noackPolicy
;
1713 hdrlen
= sizeof (struct ieee80211_frame
);
1716 * This is only used in IBSS mode where the firmware expect an index
1717 * in a h/w table instead of a destination address.
1719 if (ic
->ic_opmode
== IEEE80211_M_IBSS
&& in
->in_station
== -1) {
1720 in
->in_station
= iwi_alloc_ibss_node(sc
);
1721 if (in
->in_station
== -1) { /* h/w table is full */
1723 ieee80211_free_node(ni
);
1725 if_printf(ifp
, "ibss table is full\n");
1728 iwi_write_ibssnode(sc
, in
);
1731 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
) {
1732 k
= ieee80211_crypto_encap(ic
, ni
, m0
);
1738 /* packet header may have moved, reset our local pointer */
1739 wh
= mtod(m0
, struct ieee80211_frame
*);
1742 if (sc
->sc_drvbpf
!= NULL
) {
1743 struct iwi_tx_radiotap_header
*tap
= &sc
->sc_txtap
;
1746 tap
->wt_chan_freq
= htole16(ic
->ic_ibss_chan
->ic_freq
);
1747 tap
->wt_chan_flags
= htole16(ic
->ic_ibss_chan
->ic_flags
);
1749 bpf_ptap(sc
->sc_drvbpf
, m0
, tap
, sc
->sc_txtap_len
);
1752 data
= &txq
->data
[txq
->cur
];
1753 desc
= &txq
->desc
[txq
->cur
];
1755 /* save and trim IEEE802.11 header */
1756 m_copydata(m0
, 0, hdrlen
, (caddr_t
)&desc
->wh
);
1759 error
= bus_dmamap_load_mbuf(txq
->data_dmat
, data
->map
, m0
,
1760 iwi_dma_map_mbuf
, &map
, BUS_DMA_NOWAIT
);
1761 if (error
!= 0 && error
!= EFBIG
) {
1762 device_printf(sc
->sc_dev
, "could not map mbuf (error %d)\n",
1768 mnew
= m_defrag(m0
, MB_DONTWAIT
);
1770 device_printf(sc
->sc_dev
,
1771 "could not defragment mbuf\n");
1777 error
= bus_dmamap_load_mbuf(txq
->data_dmat
, data
->map
, m0
,
1778 iwi_dma_map_mbuf
, &map
,
1781 device_printf(sc
->sc_dev
,
1782 "could not map mbuf (error %d)\n", error
);
1791 desc
->hdr
.type
= IWI_HDR_TYPE_DATA
;
1792 desc
->hdr
.flags
= IWI_HDR_FLAG_IRQ
;
1794 (ic
->ic_opmode
== IEEE80211_M_IBSS
) ? in
->in_station
: 0;
1795 desc
->cmd
= IWI_DATA_CMD_TX
;
1796 desc
->len
= htole16(m0
->m_pkthdr
.len
);
1800 if (!noack
&& !IEEE80211_IS_MULTICAST(desc
->wh
.i_addr1
))
1801 desc
->flags
|= IWI_DATA_FLAG_NEED_ACK
;
1804 if (ic
->ic_flags
& IEEE80211_F_PRIVACY
) {
1805 desc
->wh
.i_fc
[1] |= IEEE80211_FC1_WEP
;
1806 desc
->weptxkey
= ic
->ic_crypto
.cs_def_txkey
;
1809 desc
->flags
|= IWI_DATA_FLAG_NO_WEP
;
1811 if (ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
)
1812 desc
->flags
|= IWI_DATA_FLAG_SHPREAMBLE
;
1814 if (desc
->wh
.i_fc
[0] & IEEE80211_FC0_SUBTYPE_QOS
)
1815 desc
->xflags
|= IWI_DATA_XFLAG_QOS
;
1817 desc
->nseg
= htole32(map
.nseg
);
1818 for (i
= 0; i
< map
.nseg
; i
++) {
1819 desc
->seg_addr
[i
] = htole32(map
.segs
[i
].ds_addr
);
1820 desc
->seg_len
[i
] = htole16(map
.segs
[i
].ds_len
);
1823 bus_dmamap_sync(txq
->data_dmat
, data
->map
, BUS_DMASYNC_PREWRITE
);
1824 bus_dmamap_sync(txq
->desc_dmat
, txq
->desc_map
, BUS_DMASYNC_PREWRITE
);
1826 DPRINTFN(5, ("sending data frame txq=%u idx=%u len=%u nseg=%u\n",
1827 ac
, txq
->cur
, le16toh(desc
->len
), map
.nseg
));
1830 txq
->cur
= (txq
->cur
+ 1) % IWI_TX_RING_COUNT
;
1831 CSR_WRITE_4(sc
, txq
->csr_widx
, txq
->cur
);
1837 iwi_start(struct ifnet
*ifp
)
1839 struct iwi_softc
*sc
= ifp
->if_softc
;
1840 struct ieee80211com
*ic
= &sc
->sc_ic
;
1842 struct ether_header
*eh
;
1843 struct ieee80211_node
*ni
;
1846 ieee80211_drain_mgtq(&ic
->ic_mgtq
);
1847 if (ic
->ic_state
!= IEEE80211_S_RUN
) {
1848 ifq_purge(&ifp
->if_snd
);
1853 m0
= ifq_dequeue(&ifp
->if_snd
, NULL
);
1857 if (m0
->m_len
< sizeof (struct ether_header
) &&
1858 (m0
= m_pullup(m0
, sizeof (struct ether_header
))) == NULL
) {
1862 eh
= mtod(m0
, struct ether_header
*);
1863 ni
= ieee80211_find_txnode(ic
, eh
->ether_dhost
);
1870 /* classify mbuf so we can find which tx ring to use */
1871 if (ieee80211_classify(ic
, m0
, ni
) != 0) {
1873 ieee80211_free_node(ni
);
1878 /* no QoS encapsulation for EAPOL frames */
1879 ac
= (eh
->ether_type
!= htons(ETHERTYPE_PAE
)) ?
1880 M_WME_GETAC(m0
) : WME_AC_BE
;
1882 if (sc
->txq
[ac
].queued
> IWI_TX_RING_COUNT
- 8) {
1883 /* there is no place left in this ring */
1885 ieee80211_free_node(ni
);
1886 ifp
->if_flags
|= IFF_OACTIVE
;
1892 m0
= ieee80211_encap(ic
, m0
, ni
);
1894 ieee80211_free_node(ni
);
1899 if (ic
->ic_rawbpf
!= NULL
)
1900 bpf_mtap(ic
->ic_rawbpf
, m0
);
1902 if (iwi_tx_start(ifp
, m0
, ni
, ac
) != 0) {
1903 ieee80211_free_node(ni
);
1908 sc
->sc_tx_timer
= 5;
1914 iwi_watchdog(struct ifnet
*ifp
)
1916 struct iwi_softc
*sc
= ifp
->if_softc
;
1917 struct ieee80211com
*ic
= &sc
->sc_ic
;
1921 if (sc
->sc_tx_timer
> 0) {
1922 if (--sc
->sc_tx_timer
== 0) {
1923 if_printf(ifp
, "device timeout\n");
1925 sc
->flags
|= IWI_FLAG_RESET
;
1926 wakeup(IWI_FW_WAKE_MONITOR(sc
));
1932 ieee80211_watchdog(ic
);
1936 iwi_ioctl(struct ifnet
*ifp
, u_long cmd
, caddr_t data
, struct ucred
*cr
)
1938 struct iwi_softc
*sc
= ifp
->if_softc
;
1939 struct ieee80211com
*ic
= &sc
->sc_ic
;
1945 if (ifp
->if_flags
& IFF_UP
) {
1946 if (!(ifp
->if_flags
& IFF_RUNNING
))
1949 if (ifp
->if_flags
& IFF_RUNNING
)
1955 /* only super-user can do that! */
1956 error
= suser_cred(cr
, NULL_CRED_OKAY
);
1960 ifr
= (struct ifreq
*)data
;
1961 error
= iwi_cache_firmware(sc
, ifr
->ifr_data
);
1965 /* only super-user can do that! */
1966 error
= suser_cred(cr
, NULL_CRED_OKAY
);
1970 ifp
->if_flags
&= ~IFF_UP
;
1972 iwi_free_firmware(sc
);
1976 error
= ieee80211_ioctl(ic
, cmd
, data
, cr
);
1979 if (error
== ENETRESET
) {
1980 if ((ifp
->if_flags
& (IFF_UP
| IFF_RUNNING
)) ==
1981 (IFF_UP
| IFF_RUNNING
) &&
1982 (ic
->ic_roaming
!= IEEE80211_ROAMING_MANUAL
))
1991 iwi_stop_master(struct iwi_softc
*sc
)
1996 /* disable interrupts */
1997 CSR_WRITE_4(sc
, IWI_CSR_INTR_MASK
, 0);
1999 CSR_WRITE_4(sc
, IWI_CSR_RST
, IWI_RST_STOP_MASTER
);
2000 for (ntries
= 0; ntries
< 5; ntries
++) {
2001 if (CSR_READ_4(sc
, IWI_CSR_RST
) & IWI_RST_MASTER_DISABLED
)
2006 if_printf(&sc
->sc_ic
.ic_if
, "timeout waiting for master\n");
2008 tmp
= CSR_READ_4(sc
, IWI_CSR_RST
);
2009 CSR_WRITE_4(sc
, IWI_CSR_RST
, tmp
| IWI_RST_PRINCETON_RESET
);
2011 sc
->flags
&= ~IWI_FLAG_FW_INITED
;
2015 iwi_reset(struct iwi_softc
*sc
)
2020 iwi_stop_master(sc
);
2022 tmp
= CSR_READ_4(sc
, IWI_CSR_CTL
);
2023 CSR_WRITE_4(sc
, IWI_CSR_CTL
, tmp
| IWI_CTL_INIT
);
2025 CSR_WRITE_4(sc
, IWI_CSR_READ_INT
, IWI_READ_INT_INIT_HOST
);
2027 /* Wait for clock stabilization */
2028 for (ntries
= 0; ntries
< 1000; ntries
++) {
2029 if (CSR_READ_4(sc
, IWI_CSR_CTL
) & IWI_CTL_CLOCK_READY
)
2033 if (ntries
== 1000) {
2034 if_printf(&sc
->sc_ic
.ic_if
,
2035 "timeout waiting for clock stabilization\n");
2039 tmp
= CSR_READ_4(sc
, IWI_CSR_RST
);
2040 CSR_WRITE_4(sc
, IWI_CSR_RST
, tmp
| IWI_RST_SOFT_RESET
);
2044 tmp
= CSR_READ_4(sc
, IWI_CSR_CTL
);
2045 CSR_WRITE_4(sc
, IWI_CSR_CTL
, tmp
| IWI_CTL_INIT
);
2047 /* Clear NIC memory */
2048 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_ADDR
, 0);
2049 for (i
= 0; i
< 0xc000; i
++)
2050 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_DATA
, 0);
2056 iwi_load_ucode(struct iwi_softc
*sc
, void *uc
, int size
)
2062 CSR_WRITE_4(sc
, IWI_CSR_RST
, CSR_READ_4(sc
, IWI_CSR_RST
) |
2063 IWI_RST_STOP_MASTER
);
2064 for (ntries
= 0; ntries
< 5; ntries
++) {
2065 if (CSR_READ_4(sc
, IWI_CSR_RST
) & IWI_RST_MASTER_DISABLED
)
2070 device_printf(sc
->sc_dev
, "timeout waiting for master\n");
2074 MEM_WRITE_4(sc
, 0x3000e0, 0x80000000);
2077 tmp
= CSR_READ_4(sc
, IWI_CSR_RST
);
2078 tmp
&= ~IWI_RST_PRINCETON_RESET
;
2079 CSR_WRITE_4(sc
, IWI_CSR_RST
, tmp
);
2082 MEM_WRITE_4(sc
, 0x3000e0, 0);
2084 MEM_WRITE_4(sc
, IWI_MEM_EVENT_CTL
, 1);
2086 MEM_WRITE_4(sc
, IWI_MEM_EVENT_CTL
, 0);
2088 MEM_WRITE_1(sc
, 0x200000, 0x00);
2089 MEM_WRITE_1(sc
, 0x200000, 0x40);
2092 /* write microcode into adapter memory */
2093 for (w
= uc
; size
> 0; w
++, size
-= 2)
2094 MEM_WRITE_2(sc
, 0x200010, htole16(*w
));
2096 MEM_WRITE_1(sc
, 0x200000, 0x00);
2097 MEM_WRITE_1(sc
, 0x200000, 0x80);
2099 /* wait until we get an answer */
2100 for (ntries
= 0; ntries
< 100; ntries
++) {
2101 if (MEM_READ_1(sc
, 0x200000) & 1)
2105 if (ntries
== 100) {
2106 device_printf(sc
->sc_dev
,
2107 "timeout waiting for ucode to initialize\n");
2111 /* read the answer or the firmware will not initialize properly */
2112 for (i
= 0; i
< 7; i
++)
2113 MEM_READ_4(sc
, 0x200004);
2115 MEM_WRITE_1(sc
, 0x200000, 0x00);
2120 /* macro to handle unaligned little endian data in firmware image */
2121 #define GETLE32(p) ((p)[0] | (p)[1] << 8 | (p)[2] << 16 | (p)[3] << 24)
2124 iwi_load_firmware(struct iwi_softc
*sc
, void *fw
, int size
)
2128 bus_addr_t physaddr
;
2131 uint32_t sentinel
, ctl
, src
, dst
, sum
, len
, mlen
, tmp
;
2132 int ntries
, error
= 0;
2133 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
2135 ASSERT_SERIALIZED(ifp
->if_serializer
);
2137 /* Allocate DMA memory for mapping firmware image */
2138 error
= bus_dma_tag_create(NULL
, 4, 0, BUS_SPACE_MAXADDR_32BIT
,
2139 BUS_SPACE_MAXADDR
, NULL
, NULL
, size
, 1, size
, 0, &dmat
);
2141 device_printf(sc
->sc_dev
,
2142 "could not create firmware DMA tag\n");
2146 error
= bus_dmamem_alloc(dmat
, &virtaddr
, BUS_DMA_WAITOK
, &map
);
2148 device_printf(sc
->sc_dev
,
2149 "could not allocate firmware DMA memory\n");
2153 error
= bus_dmamap_load(dmat
, map
, virtaddr
, size
, iwi_dma_map_addr
,
2156 device_printf(sc
->sc_dev
, "could not load firmware DMA map\n");
2160 /* Copy firmware image to DMA memory */
2161 memcpy(virtaddr
, fw
, size
);
2163 /* Make sure the adapter will get up-to-date values */
2164 bus_dmamap_sync(dmat
, map
, BUS_DMASYNC_PREWRITE
);
2166 /* Tell the adapter where the command blocks are stored */
2167 MEM_WRITE_4(sc
, 0x3000a0, 0x27000);
2170 * Store command blocks into adapter's internal memory using register
2171 * indirections. The adapter will read the firmware image through DMA
2172 * using information stored in command blocks.
2177 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_ADDR
, 0x27000);
2180 dst
= GETLE32(p
); p
+= 4; src
+= 4;
2181 len
= GETLE32(p
); p
+= 4; src
+= 4;
2185 mlen
= min(len
, IWI_CB_MAXDATALEN
);
2187 ctl
= IWI_CB_DEFAULT_CTL
| mlen
;
2188 sum
= ctl
^ src
^ dst
;
2190 /* Write a command block */
2191 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_DATA
, ctl
);
2192 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_DATA
, src
);
2193 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_DATA
, dst
);
2194 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_DATA
, sum
);
2202 /* Write a fictive final command block (sentinel) */
2203 sentinel
= CSR_READ_4(sc
, IWI_CSR_AUTOINC_ADDR
);
2204 CSR_WRITE_4(sc
, IWI_CSR_AUTOINC_DATA
, 0);
2206 tmp
= CSR_READ_4(sc
, IWI_CSR_RST
);
2207 tmp
&= ~(IWI_RST_MASTER_DISABLED
| IWI_RST_STOP_MASTER
);
2208 CSR_WRITE_4(sc
, IWI_CSR_RST
, tmp
);
2210 /* Tell the adapter to start processing command blocks */
2211 MEM_WRITE_4(sc
, 0x3000a4, 0x540100);
2213 /* Wait until the adapter reaches the sentinel */
2214 for (ntries
= 0; ntries
< 400; ntries
++) {
2215 if (MEM_READ_4(sc
, 0x3000d0) >= sentinel
)
2219 if (ntries
== 400) {
2220 device_printf(sc
->sc_dev
,
2221 "timeout processing command blocks\n");
2226 /* We're done with command blocks processing */
2227 MEM_WRITE_4(sc
, 0x3000a4, 0x540c00);
2229 /* Allow interrupts so we know when the firmware is ready */
2230 CSR_WRITE_4(sc
, IWI_CSR_INTR_MASK
, IWI_INTR_MASK
);
2232 /* Tell the adapter to initialize the firmware */
2233 CSR_WRITE_4(sc
, IWI_CSR_RST
, 0);
2235 tmp
= CSR_READ_4(sc
, IWI_CSR_CTL
);
2236 CSR_WRITE_4(sc
, IWI_CSR_CTL
, tmp
| IWI_CTL_ALLOW_STANDBY
);
2238 /* wait at most one second for firmware initialization to complete */
2240 tsleep_interlock(IWI_FW_INITIALIZED(sc
));
2241 lwkt_serialize_exit(ifp
->if_serializer
);
2242 error
= tsleep(IWI_FW_INITIALIZED(sc
), 0, "iwiinit", hz
);
2244 lwkt_serialize_enter(ifp
->if_serializer
);
2246 device_printf(sc
->sc_dev
, "timeout waiting for firmware "
2247 "initialization to complete\n");
2251 fail4
: bus_dmamap_sync(dmat
, map
, BUS_DMASYNC_POSTWRITE
);
2252 bus_dmamap_unload(dmat
, map
);
2253 fail3
: bus_dmamem_free(dmat
, virtaddr
, map
);
2254 fail2
: bus_dma_tag_destroy(dmat
);
2260 * Store firmware into kernel memory so we can download it when we need to,
2261 * e.g when the adapter wakes up from suspend mode.
2264 iwi_cache_firmware(struct iwi_softc
*sc
, void *data
)
2266 struct iwi_firmware
*kfw
= &sc
->fw
;
2267 struct iwi_firmware ufw
;
2270 iwi_free_firmware(sc
);
2272 if ((error
= copyin(data
, &ufw
, sizeof ufw
)) != 0)
2275 kfw
->boot_size
= ufw
.boot_size
;
2276 kfw
->ucode_size
= ufw
.ucode_size
;
2277 kfw
->main_size
= ufw
.main_size
;
2279 kfw
->boot
= kmalloc(kfw
->boot_size
, M_DEVBUF
, M_WAITOK
);
2280 kfw
->ucode
= kmalloc(kfw
->ucode_size
, M_DEVBUF
, M_WAITOK
);
2281 kfw
->main
= kmalloc(kfw
->main_size
, M_DEVBUF
, M_WAITOK
);
2283 if ((error
= copyin(ufw
.boot
, kfw
->boot
, kfw
->boot_size
)) != 0)
2286 if ((error
= copyin(ufw
.ucode
, kfw
->ucode
, kfw
->ucode_size
)) != 0)
2289 if ((error
= copyin(ufw
.main
, kfw
->main
, kfw
->main_size
)) != 0)
2292 DPRINTF(("Firmware cached: boot %u, ucode %u, main %u\n",
2293 kfw
->boot_size
, kfw
->ucode_size
, kfw
->main_size
));
2295 sc
->flags
|= IWI_FLAG_FW_CACHED
;
2300 kfree(kfw
->boot
, M_DEVBUF
);
2301 kfree(kfw
->ucode
, M_DEVBUF
);
2302 kfree(kfw
->main
, M_DEVBUF
);
2308 iwi_free_firmware(struct iwi_softc
*sc
)
2310 if (!(sc
->flags
& IWI_FLAG_FW_CACHED
))
2313 kfree(sc
->fw
.boot
, M_DEVBUF
);
2314 kfree(sc
->fw
.ucode
, M_DEVBUF
);
2315 kfree(sc
->fw
.main
, M_DEVBUF
);
2317 sc
->flags
&= ~IWI_FLAG_FW_CACHED
;
2321 iwi_config(struct iwi_softc
*sc
)
2323 struct ieee80211com
*ic
= &sc
->sc_ic
;
2324 struct ifnet
*ifp
= ic
->ic_ifp
;
2325 struct iwi_configuration config
;
2326 struct iwi_rateset rs
;
2327 struct iwi_txpower power
;
2328 struct ieee80211_key
*wk
;
2329 struct iwi_wep_key wepkey
;
2333 IEEE80211_ADDR_COPY(ic
->ic_myaddr
, IF_LLADDR(ifp
));
2334 DPRINTF(("Setting MAC address to %6D\n", ic
->ic_myaddr
, ":"));
2335 error
= iwi_cmd(sc
, IWI_CMD_SET_MAC_ADDRESS
, ic
->ic_myaddr
,
2336 IEEE80211_ADDR_LEN
, 0);
2340 memset(&config
, 0, sizeof config
);
2341 config
.bluetooth_coexistence
= sc
->bluetooth
;
2342 config
.antenna
= sc
->antenna
;
2343 config
.multicast_enabled
= 1;
2344 config
.answer_pbreq
= (ic
->ic_opmode
== IEEE80211_M_IBSS
) ? 1 : 0;
2345 config
.disable_unicast_decryption
= 1;
2346 config
.disable_multicast_decryption
= 1;
2347 DPRINTF(("Configuring adapter\n"));
2348 error
= iwi_cmd(sc
, IWI_CMD_SET_CONFIG
, &config
, sizeof config
, 0);
2352 data
= htole32(IWI_POWER_MODE_CAM
);
2353 DPRINTF(("Setting power mode to %u\n", le32toh(data
)));
2354 error
= iwi_cmd(sc
, IWI_CMD_SET_POWER_MODE
, &data
, sizeof data
, 0);
2358 data
= htole32(ic
->ic_rtsthreshold
);
2359 DPRINTF(("Setting RTS threshold to %u\n", le32toh(data
)));
2360 error
= iwi_cmd(sc
, IWI_CMD_SET_RTS_THRESHOLD
, &data
, sizeof data
, 0);
2364 data
= htole32(ic
->ic_fragthreshold
);
2365 DPRINTF(("Setting fragmentation threshold to %u\n", le32toh(data
)));
2366 error
= iwi_cmd(sc
, IWI_CMD_SET_FRAG_THRESHOLD
, &data
, sizeof data
, 0);
2370 if (ic
->ic_opmode
== IEEE80211_M_IBSS
) {
2371 power
.mode
= IWI_MODE_11B
;
2373 for (i
= 0; i
< 11; i
++) {
2374 power
.chan
[i
].chan
= i
+ 1;
2375 power
.chan
[i
].power
= IWI_TXPOWER_MAX
;
2377 DPRINTF(("Setting .11b channels tx power\n"));
2378 error
= iwi_cmd(sc
, IWI_CMD_SET_TX_POWER
, &power
, sizeof power
,
2383 power
.mode
= IWI_MODE_11G
;
2384 DPRINTF(("Setting .11g channels tx power\n"));
2385 error
= iwi_cmd(sc
, IWI_CMD_SET_TX_POWER
, &power
, sizeof power
,
2391 rs
.mode
= IWI_MODE_11G
;
2392 rs
.type
= IWI_RATESET_TYPE_SUPPORTED
;
2393 rs
.nrates
= ic
->ic_sup_rates
[IEEE80211_MODE_11G
].rs_nrates
;
2394 memcpy(rs
.rates
, ic
->ic_sup_rates
[IEEE80211_MODE_11G
].rs_rates
,
2396 DPRINTF(("Setting .11bg supported rates (%u)\n", rs
.nrates
));
2397 error
= iwi_cmd(sc
, IWI_CMD_SET_RATES
, &rs
, sizeof rs
, 0);
2401 rs
.mode
= IWI_MODE_11A
;
2402 rs
.type
= IWI_RATESET_TYPE_SUPPORTED
;
2403 rs
.nrates
= ic
->ic_sup_rates
[IEEE80211_MODE_11A
].rs_nrates
;
2404 memcpy(rs
.rates
, ic
->ic_sup_rates
[IEEE80211_MODE_11A
].rs_rates
,
2406 DPRINTF(("Setting .11a supported rates (%u)\n", rs
.nrates
));
2407 error
= iwi_cmd(sc
, IWI_CMD_SET_RATES
, &rs
, sizeof rs
, 0);
2411 /* if we have a desired ESSID, set it now */
2412 if (ic
->ic_des_esslen
!= 0) {
2414 if (iwi_debug
> 0) {
2415 kprintf("Setting desired ESSID to ");
2416 ieee80211_print_essid(ic
->ic_des_essid
,
2421 error
= iwi_cmd(sc
, IWI_CMD_SET_ESSID
, ic
->ic_des_essid
,
2422 ic
->ic_des_esslen
, 0);
2427 data
= htole32(karc4random());
2428 DPRINTF(("Setting initialization vector to %u\n", le32toh(data
)));
2429 error
= iwi_cmd(sc
, IWI_CMD_SET_IV
, &data
, sizeof data
, 0);
2433 for (i
= 0; i
< IEEE80211_WEP_NKID
; i
++) {
2434 wk
= &ic
->ic_crypto
.cs_nw_keys
[i
];
2436 wepkey
.cmd
= IWI_WEP_KEY_CMD_SETKEY
;
2438 wepkey
.len
= wk
->wk_keylen
;
2439 memset(wepkey
.key
, 0, sizeof wepkey
.key
);
2440 memcpy(wepkey
.key
, wk
->wk_key
, wk
->wk_keylen
);
2441 DPRINTF(("Setting wep key index %u len %u\n", wepkey
.idx
,
2443 error
= iwi_cmd(sc
, IWI_CMD_SET_WEP_KEY
, &wepkey
,
2449 /* Enable adapter */
2450 DPRINTF(("Enabling adapter\n"));
2451 return iwi_cmd(sc
, IWI_CMD_ENABLE
, NULL
, 0, 0);
2455 iwi_set_chan(struct iwi_softc
*sc
, struct ieee80211_channel
*chan
)
2457 struct ieee80211com
*ic
= &sc
->sc_ic
;
2458 struct iwi_scan scan
;
2460 memset(&scan
, 0, sizeof scan
);
2461 memset(scan
.type
, IWI_SCAN_TYPE_PASSIVE
, sizeof scan
.type
);
2462 scan
.passive
= htole16(2000);
2463 scan
.channels
[0] = 1 |
2464 (IEEE80211_IS_CHAN_5GHZ(chan
) ? IWI_CHAN_5GHZ
: IWI_CHAN_2GHZ
);
2465 scan
.channels
[1] = ieee80211_chan2ieee(ic
, chan
);
2467 DPRINTF(("Setting channel to %u\n", ieee80211_chan2ieee(ic
, chan
)));
2468 return iwi_cmd(sc
, IWI_CMD_SCAN
, &scan
, sizeof scan
, 1);
2472 iwi_scan(struct iwi_softc
*sc
)
2474 struct ieee80211com
*ic
= &sc
->sc_ic
;
2475 struct iwi_scan scan
;
2479 memset(&scan
, 0, sizeof scan
);
2481 if (ic
->ic_des_esslen
!= 0) {
2482 scan
.bdirected
= htole16(sc
->dwelltime
);
2483 memset(scan
.type
, IWI_SCAN_TYPE_BDIRECTED
, sizeof scan
.type
);
2485 scan
.broadcast
= htole16(sc
->dwelltime
);
2486 memset(scan
.type
, IWI_SCAN_TYPE_BROADCAST
, sizeof scan
.type
);
2491 for (i
= 0; i
<= IEEE80211_CHAN_MAX
; i
++) {
2492 if (IEEE80211_IS_CHAN_5GHZ(&ic
->ic_channels
[i
]) &&
2493 isset(ic
->ic_chan_active
, i
)) {
2498 *(p
- count
) = IWI_CHAN_5GHZ
| count
;
2500 p
= (count
> 0) ? p
+ 1 : scan
.channels
;
2502 for (i
= 0; i
<= IEEE80211_CHAN_MAX
; i
++) {
2503 if (IEEE80211_IS_CHAN_2GHZ(&ic
->ic_channels
[i
]) &&
2504 isset(ic
->ic_chan_active
, i
)) {
2509 *(p
- count
) = IWI_CHAN_2GHZ
| count
;
2511 DPRINTF(("Start scanning\n"));
2512 return iwi_cmd(sc
, IWI_CMD_SCAN
, &scan
, sizeof scan
, 1);
2516 iwi_auth_and_assoc(struct iwi_softc
*sc
)
2518 struct ieee80211com
*ic
= &sc
->sc_ic
;
2519 struct ifnet
*ifp
= ic
->ic_ifp
;
2520 struct ieee80211_node
*ni
= ic
->ic_bss
;
2521 struct ieee80211_wme_info wme
;
2522 struct iwi_configuration config
;
2523 struct iwi_associate assoc
;
2524 struct iwi_rateset rs
;
2529 if (IEEE80211_IS_CHAN_2GHZ(ni
->ni_chan
)) {
2530 memset(&config
, 0, sizeof config
);
2531 config
.bluetooth_coexistence
= sc
->bluetooth
;
2532 config
.antenna
= sc
->antenna
;
2533 config
.multicast_enabled
= 1;
2534 config
.use_protection
= 1;
2535 config
.answer_pbreq
=
2536 (ic
->ic_opmode
== IEEE80211_M_IBSS
) ? 1 : 0;
2537 config
.disable_unicast_decryption
= 1;
2538 config
.disable_multicast_decryption
= 1;
2539 DPRINTF(("Configuring adapter\n"));
2540 error
= iwi_cmd(sc
, IWI_CMD_SET_CONFIG
, &config
, sizeof config
,
2547 if (iwi_debug
> 0) {
2548 kprintf("Setting ESSID to ");
2549 ieee80211_print_essid(ni
->ni_essid
, ni
->ni_esslen
);
2553 error
= iwi_cmd(sc
, IWI_CMD_SET_ESSID
, ni
->ni_essid
, ni
->ni_esslen
, 1);
2557 /* the rate set has already been "negotiated" */
2558 rs
.mode
= IEEE80211_IS_CHAN_5GHZ(ni
->ni_chan
) ? IWI_MODE_11A
:
2560 rs
.type
= IWI_RATESET_TYPE_NEGOTIATED
;
2561 rs
.nrates
= ni
->ni_rates
.rs_nrates
;
2562 KKASSERT(rs
.nrates
<= IWI_RATESET_MAXSIZE
);
2563 memcpy(rs
.rates
, ni
->ni_rates
.rs_rates
, rs
.nrates
);
2564 DPRINTF(("Setting negociated rates (%u)\n", rs
.nrates
));
2565 error
= iwi_cmd(sc
, IWI_CMD_SET_RATES
, &rs
, sizeof rs
, 1);
2569 if ((ic
->ic_flags
& IEEE80211_F_WME
) && ni
->ni_wme_ie
!= NULL
) {
2570 wme
.wme_id
= IEEE80211_ELEMID_VENDOR
;
2571 wme
.wme_len
= sizeof (struct ieee80211_wme_info
) - 2;
2572 wme
.wme_oui
[0] = 0x00;
2573 wme
.wme_oui
[1] = 0x50;
2574 wme
.wme_oui
[2] = 0xf2;
2575 wme
.wme_type
= WME_OUI_TYPE
;
2576 wme
.wme_subtype
= WME_INFO_OUI_SUBTYPE
;
2577 wme
.wme_version
= WME_VERSION
;
2580 DPRINTF(("Setting WME IE (len=%u)\n", wme
.wme_len
));
2581 error
= iwi_cmd(sc
, IWI_CMD_SET_WMEIE
, &wme
, sizeof wme
, 1);
2586 if (ic
->ic_opt_ie
!= NULL
) {
2587 DPRINTF(("Setting optional IE (len=%u)\n", ic
->ic_opt_ie_len
));
2588 error
= iwi_cmd(sc
, IWI_CMD_SET_OPTIE
, ic
->ic_opt_ie
,
2589 ic
->ic_opt_ie_len
, 1);
2594 data
= htole32(ni
->ni_rssi
);
2595 DPRINTF(("Setting sensitivity to %d\n", (int8_t)ni
->ni_rssi
));
2596 error
= iwi_cmd(sc
, IWI_CMD_SET_SENSITIVITY
, &data
, sizeof data
, 1);
2600 memset(&assoc
, 0, sizeof assoc
);
2601 assoc
.mode
= IEEE80211_IS_CHAN_5GHZ(ni
->ni_chan
) ? IWI_MODE_11A
:
2603 assoc
.chan
= ieee80211_chan2ieee(ic
, ni
->ni_chan
);
2604 if (ni
->ni_authmode
== IEEE80211_AUTH_SHARED
)
2605 assoc
.auth
= ic
->ic_crypto
.cs_def_txkey
<< 4 | IWI_AUTH_SHARED
;
2606 if ((ic
->ic_flags
& IEEE80211_F_WME
) && ni
->ni_wme_ie
!= NULL
)
2607 assoc
.policy
|= htole16(IWI_POLICY_WME
);
2608 if (ic
->ic_flags
& IEEE80211_F_WPA
)
2609 assoc
.policy
|= htole16(IWI_POLICY_WPA
);
2610 memcpy(assoc
.tstamp
, ni
->ni_tstamp
.data
, 8);
2612 if (ic
->ic_opmode
== IEEE80211_M_IBSS
)
2613 capinfo
= IEEE80211_CAPINFO_IBSS
;
2615 capinfo
= IEEE80211_CAPINFO_ESS
;
2616 if (ic
->ic_flags
& IEEE80211_F_PRIVACY
)
2617 capinfo
|= IEEE80211_CAPINFO_PRIVACY
;
2618 if ((ic
->ic_flags
& IEEE80211_F_SHPREAMBLE
) &&
2619 IEEE80211_IS_CHAN_2GHZ(ni
->ni_chan
))
2620 capinfo
|= IEEE80211_CAPINFO_SHORT_PREAMBLE
;
2621 if (ic
->ic_flags
& IEEE80211_F_SHSLOT
)
2622 capinfo
|= IEEE80211_CAPINFO_SHORT_SLOTTIME
;
2623 assoc
.capinfo
= htole16(capinfo
);
2625 assoc
.lintval
= htole16(ic
->ic_lintval
);
2626 assoc
.intval
= htole16(ni
->ni_intval
);
2627 IEEE80211_ADDR_COPY(assoc
.bssid
, ni
->ni_bssid
);
2628 if (ic
->ic_opmode
== IEEE80211_M_IBSS
)
2629 IEEE80211_ADDR_COPY(assoc
.dst
, ifp
->if_broadcastaddr
);
2631 IEEE80211_ADDR_COPY(assoc
.dst
, ni
->ni_bssid
);
2633 DPRINTF(("Trying to associate to %6D channel %u auth %u\n",
2634 assoc
.bssid
, ":", assoc
.chan
, assoc
.auth
));
2635 return iwi_cmd(sc
, IWI_CMD_ASSOCIATE
, &assoc
, sizeof assoc
, 1);
2639 iwi_init(void *priv
)
2641 struct iwi_softc
*sc
= priv
;
2642 struct ieee80211com
*ic
= &sc
->sc_ic
;
2643 struct ifnet
*ifp
= ic
->ic_ifp
;
2644 struct iwi_firmware
*fw
= &sc
->fw
;
2645 struct iwi_rx_data
*data
;
2648 /* exit immediately if firmware has not been ioctl'd */
2649 if (!(sc
->flags
& IWI_FLAG_FW_CACHED
)) {
2650 if (!(sc
->flags
& IWI_FLAG_FW_WARNED
))
2651 device_printf(sc
->sc_dev
, "Please load firmware\n");
2652 sc
->flags
|= IWI_FLAG_FW_WARNED
;
2653 ifp
->if_flags
&= ~IFF_UP
;
2659 if (iwi_reset(sc
) != 0) {
2660 device_printf(sc
->sc_dev
, "could not reset adapter\n");
2664 if (iwi_load_firmware(sc
, fw
->boot
, fw
->boot_size
) != 0) {
2665 device_printf(sc
->sc_dev
, "could not load boot firmware\n");
2669 if (iwi_load_ucode(sc
, fw
->ucode
, fw
->ucode_size
) != 0) {
2670 device_printf(sc
->sc_dev
, "could not load microcode\n");
2674 iwi_stop_master(sc
);
2676 CSR_WRITE_4(sc
, IWI_CSR_CMD_BASE
, sc
->cmdq
.physaddr
);
2677 CSR_WRITE_4(sc
, IWI_CSR_CMD_SIZE
, sc
->cmdq
.count
);
2678 CSR_WRITE_4(sc
, IWI_CSR_CMD_WIDX
, sc
->cmdq
.cur
);
2680 CSR_WRITE_4(sc
, IWI_CSR_TX1_BASE
, sc
->txq
[0].physaddr
);
2681 CSR_WRITE_4(sc
, IWI_CSR_TX1_SIZE
, sc
->txq
[0].count
);
2682 CSR_WRITE_4(sc
, IWI_CSR_TX1_WIDX
, sc
->txq
[0].cur
);
2684 CSR_WRITE_4(sc
, IWI_CSR_TX2_BASE
, sc
->txq
[1].physaddr
);
2685 CSR_WRITE_4(sc
, IWI_CSR_TX2_SIZE
, sc
->txq
[1].count
);
2686 CSR_WRITE_4(sc
, IWI_CSR_TX2_WIDX
, sc
->txq
[1].cur
);
2688 CSR_WRITE_4(sc
, IWI_CSR_TX3_BASE
, sc
->txq
[2].physaddr
);
2689 CSR_WRITE_4(sc
, IWI_CSR_TX3_SIZE
, sc
->txq
[2].count
);
2690 CSR_WRITE_4(sc
, IWI_CSR_TX3_WIDX
, sc
->txq
[2].cur
);
2692 CSR_WRITE_4(sc
, IWI_CSR_TX4_BASE
, sc
->txq
[3].physaddr
);
2693 CSR_WRITE_4(sc
, IWI_CSR_TX4_SIZE
, sc
->txq
[3].count
);
2694 CSR_WRITE_4(sc
, IWI_CSR_TX4_WIDX
, sc
->txq
[3].cur
);
2696 for (i
= 0; i
< sc
->rxq
.count
; i
++) {
2697 data
= &sc
->rxq
.data
[i
];
2698 CSR_WRITE_4(sc
, data
->reg
, data
->physaddr
);
2701 CSR_WRITE_4(sc
, IWI_CSR_RX_WIDX
, sc
->rxq
.count
- 1);
2703 if (iwi_load_firmware(sc
, fw
->main
, fw
->main_size
) != 0) {
2704 device_printf(sc
->sc_dev
, "could not load main firmware\n");
2708 sc
->flags
|= IWI_FLAG_FW_INITED
;
2710 if (iwi_config(sc
) != 0) {
2711 device_printf(sc
->sc_dev
, "device configuration failed\n");
2715 if (ic
->ic_opmode
!= IEEE80211_M_MONITOR
) {
2716 if (ic
->ic_roaming
!= IEEE80211_ROAMING_MANUAL
)
2717 ieee80211_new_state(ic
, IEEE80211_S_SCAN
, -1);
2719 ieee80211_new_state(ic
, IEEE80211_S_RUN
, -1);
2721 ifp
->if_flags
&= ~IFF_OACTIVE
;
2722 ifp
->if_flags
|= IFF_RUNNING
;
2726 fail
: ifp
->if_flags
&= ~IFF_UP
;
2731 iwi_stop(void *priv
)
2733 struct iwi_softc
*sc
= priv
;
2734 struct ieee80211com
*ic
= &sc
->sc_ic
;
2735 struct ifnet
*ifp
= ic
->ic_ifp
;
2737 ieee80211_new_state(ic
, IEEE80211_S_INIT
, -1);
2739 iwi_stop_master(sc
);
2741 CSR_WRITE_4(sc
, IWI_CSR_RST
, IWI_RST_SOFT_RESET
);
2744 iwi_reset_cmd_ring(sc
, &sc
->cmdq
);
2745 iwi_reset_tx_ring(sc
, &sc
->txq
[0]);
2746 iwi_reset_tx_ring(sc
, &sc
->txq
[1]);
2747 iwi_reset_tx_ring(sc
, &sc
->txq
[2]);
2748 iwi_reset_tx_ring(sc
, &sc
->txq
[3]);
2749 iwi_reset_rx_ring(sc
, &sc
->rxq
);
2751 sc
->sc_tx_timer
= 0;
2753 ifp
->if_flags
&= ~(IFF_RUNNING
| IFF_OACTIVE
);
2757 iwi_sysctl_stats(SYSCTL_HANDLER_ARGS
)
2759 struct iwi_softc
*sc
= arg1
;
2760 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
2761 uint32_t size
, buf
[128];
2763 lwkt_serialize_enter(ifp
->if_serializer
);
2765 if (!(sc
->flags
& IWI_FLAG_FW_INITED
)) {
2766 memset(buf
, 0, sizeof buf
);
2770 size
= min(CSR_READ_4(sc
, IWI_CSR_TABLE0_SIZE
), 128 - 1);
2771 CSR_READ_REGION_4(sc
, IWI_CSR_TABLE0_BASE
, &buf
[1], size
);
2773 lwkt_serialize_exit(ifp
->if_serializer
);
2774 return SYSCTL_OUT(req
, buf
, sizeof buf
);
2778 iwi_sysctl_radio(SYSCTL_HANDLER_ARGS
)
2780 struct iwi_softc
*sc
= arg1
;
2781 struct ifnet
*ifp
= &sc
->sc_ic
.ic_if
;
2784 lwkt_serialize_enter(ifp
->if_serializer
);
2785 val
= (CSR_READ_4(sc
, IWI_CSR_IO
) & IWI_IO_RADIO_ENABLED
) ? 1 : 0;
2786 lwkt_serialize_exit(ifp
->if_serializer
);
2788 return SYSCTL_OUT(req
, &val
, sizeof val
);
2791 static const int8_t iwi_bitmap
[256] = {
2792 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2793 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5,
2794 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2795 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6,
2796 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2797 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5,
2798 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2799 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 7,
2800 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2801 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5,
2802 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2803 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6,
2804 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2805 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 5,
2806 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4,
2807 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, -1
2811 iwi_alloc_ibss_node(struct iwi_softc
*sc
)
2815 ASSERT_SERIALIZED(sc
->sc_ic
.ic_if
.if_serializer
);
2817 for (i
= 0; i
< IWI_MAX_IBSSNODE_NBYTE
; ++i
) {
2820 ret
= iwi_bitmap
[sc
->sc_ibss_node
[i
]];
2822 sc
->sc_ibss_node
[i
] |= (1 << ret
);
2831 iwi_free_ibss_node(struct iwi_softc
*sc
, int ibss_node
)
2835 ASSERT_SERIALIZED(sc
->sc_ic
.ic_if
.if_serializer
);
2836 KASSERT(ibss_node
< IWI_MAX_IBSSNODE
, ("free ibss node, out of range"));
2838 i
= ibss_node
/ NBBY
;
2839 b
= ibss_node
% NBBY
;
2841 sc
->sc_ibss_node
[i
] &= ~(1 << b
);