2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Sepherosa Ziehau <sepherosa@gmail.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * $DragonFly: src/sys/dev/netif/iwl/iwl2100.c,v 1.4 2008/05/14 11:59:20 sephe Exp $
37 #include <sys/param.h>
39 #include <sys/endian.h>
40 #include <sys/firmware.h>
41 #include <sys/kernel.h>
42 #include <sys/interrupt.h>
44 #include <sys/module.h>
45 #include <sys/sysctl.h>
46 #include <sys/socket.h>
47 #include <sys/sockio.h>
52 #include <net/if_arp.h>
53 #include <net/ethernet.h>
54 #include <net/if_dl.h>
55 #include <net/if_media.h>
56 #include <net/ifq_var.h>
57 #include <net/netmsg2.h>
59 #include <netproto/802_11/ieee80211_var.h>
60 #include <netproto/802_11/ieee80211_radiotap.h>
62 #include <bus/pci/pcireg.h>
63 #include <bus/pci/pcivar.h>
65 #include "if_iwlvar.h"
66 #include "iwl2100reg.h"
67 #include "iwl2100var.h"
69 #define IWL2100_INIT_F_ENABLE 0x1
70 #define IWL2100_INIT_F_IBSSCHAN 0x2
72 #define sc_tx_th sc_u_tx_th.u_tx_th
73 #define sc_rx_th sc_u_rx_th.u_rx_th
75 static void iwl2100_init(void *);
76 static int iwl2100_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
77 static void iwl2100_start(struct ifnet *);
78 static void iwl2100_watchdog(struct ifnet *);
79 static int iwl2100_newstate(struct ieee80211com *, enum ieee80211_state, int);
80 static int iwl2100_media_change(struct ifnet *);
81 static void iwl2100_media_status(struct ifnet *, struct ifmediareq *);
82 static void iwl2100_stop(struct iwl2100_softc *);
83 static void iwl2100_restart(struct iwl2100_softc *);
84 static void iwl2100_reinit(struct iwl2100_softc *);
86 static void iwl2100_intr(void *);
87 static void iwl2100_txeof(struct iwl2100_softc *);
88 static void iwl2100_rxeof(struct iwl2100_softc *);
89 static void iwl2100_rxeof_status(struct iwl2100_softc *, int);
90 static void iwl2100_rxeof_note(struct iwl2100_softc *, int);
91 static void iwl2100_rxeof_cmd(struct iwl2100_softc *, int);
92 static void iwl2100_rxeof_data(struct iwl2100_softc *, int);
94 static void iwl2100_init_dispatch(struct netmsg *);
95 static void iwl2100_reinit_dispatch(struct netmsg *);
96 static void iwl2100_stop_dispatch(struct netmsg *);
97 static void iwl2100_newstate_dispatch(struct netmsg *);
98 static void iwl2100_scanend_dispatch(struct netmsg *);
99 static void iwl2100_restart_dispatch(struct netmsg *);
100 static void iwl2100_bmiss_dispatch(struct netmsg *);
102 static void iwl2100_stop_callouts(struct iwl2100_softc *);
103 static void iwl2100_restart_bmiss(void *);
104 static void iwl2100_ibss_bssid(void *);
105 static void iwl2100_reinit_callout(void *);
107 static int iwl2100_dma_alloc(device_t);
108 static void iwl2100_dma_free(device_t);
109 static int iwl2100_dma_mbuf_create(device_t);
110 static void iwl2100_dma_mbuf_destroy(device_t, int, int);
111 static int iwl2100_init_tx_ring(struct iwl2100_softc *);
112 static int iwl2100_init_rx_ring(struct iwl2100_softc *);
113 static void iwl2100_free_tx_ring(struct iwl2100_softc *);
114 static void iwl2100_free_rx_ring(struct iwl2100_softc *);
116 static int iwl2100_alloc_cmd(struct iwl2100_softc *);
117 static void iwl2100_free_cmd(struct iwl2100_softc *);
118 static int iwl2100_wait_cmd(struct iwl2100_softc *);
120 static void iwl2100_rxdesc_setup(struct iwl2100_softc *, int);
121 static int iwl2100_newbuf(struct iwl2100_softc *, int, int);
122 static int iwl2100_encap(struct iwl2100_softc *, struct mbuf *);
124 static void iwl2100_chan_change(struct iwl2100_softc *,
125 const struct ieee80211_channel *);
127 static int iwl2100_alloc_firmware(struct iwl2100_softc *,
128 enum ieee80211_opmode);
129 static void iwl2100_free_firmware(struct iwl2100_softc *);
130 static int iwl2100_load_firmware(struct iwl2100_softc *,
131 enum ieee80211_opmode);
132 static int iwl2100_load_fw_ucode(struct iwl2100_softc *,
133 const struct iwl2100_firmware *);
134 static int iwl2100_load_fw_data(struct iwl2100_softc *,
135 const struct iwl2100_firmware *);
136 static int iwl2100_init_firmware(struct iwl2100_softc *);
138 static int iwl2100_read_ord2(struct iwl2100_softc *, uint32_t,
140 static uint32_t iwl2100_read_ord1(struct iwl2100_softc *, uint32_t);
141 static void iwl2100_write_ord1(struct iwl2100_softc *, uint32_t, uint32_t);
143 static int iwl2100_reset(struct iwl2100_softc *);
144 static int iwl2100_hw_reset(struct iwl2100_softc *);
145 static int iwl2100_rfkilled(struct iwl2100_softc *);
147 static int iwl2100_scan(struct iwl2100_softc *);
148 static int iwl2100_auth(struct iwl2100_softc *);
149 static int iwl2100_ibss(struct iwl2100_softc *);
151 static int iwl2100_hw_init(struct iwl2100_softc *, const uint8_t *,
152 const uint8_t *, uint8_t, uint32_t);
153 static void iwl2100_hw_stop(struct iwl2100_softc *);
154 static int iwl2100_config(struct iwl2100_softc *, const uint8_t *,
155 const uint8_t *, uint8_t, int);
156 static int iwl2100_start_scan(struct iwl2100_softc *, uint32_t, uint32_t);
158 static int iwl2100_config_op(struct iwl2100_softc *, uint32_t);
159 static int iwl2100_set_addr(struct iwl2100_softc *, const uint8_t *);
160 static int iwl2100_set_opmode(struct iwl2100_softc *,
161 enum ieee80211_opmode);
162 static int iwl2100_set_80211(struct iwl2100_softc *);
163 static int iwl2100_set_basicrates(struct iwl2100_softc *);
164 static int iwl2100_set_txrates(struct iwl2100_softc *);
165 static int iwl2100_set_powersave(struct iwl2100_softc *, int);
166 static int iwl2100_set_rtsthreshold(struct iwl2100_softc *, uint16_t);
167 static int iwl2100_set_bssid(struct iwl2100_softc *, const uint8_t *);
168 static int iwl2100_set_essid(struct iwl2100_softc *, const uint8_t *, int);
169 static int iwl2100_set_auth_ciphers(struct iwl2100_softc *,
170 enum ieee80211_authmode);
171 static int iwl2100_set_wepkey(struct iwl2100_softc *,
172 const struct ieee80211_key *);
173 static int iwl2100_set_weptxkey(struct iwl2100_softc *, ieee80211_keyix);
174 static int iwl2100_set_privacy(struct iwl2100_softc *, int);
175 static int iwl2100_set_chan(struct iwl2100_softc *,
176 const struct ieee80211_channel *);
177 static int iwl2100_set_scanopt(struct iwl2100_softc *, uint32_t, uint32_t);
178 static int iwl2100_set_scan(struct iwl2100_softc *);
179 static int iwl2100_set_optie(struct iwl2100_softc *, void *, uint16_t);
180 static int iwl2100_set_bintval(struct iwl2100_softc *, uint16_t);
181 static int iwl2100_set_txpower(struct iwl2100_softc *, uint16_t);
184 iwl2100_config_done(struct iwl2100_softc *sc)
186 return iwl2100_config_op(sc, IWL2100_CMD_CONF_DONE);
190 iwl2100_config_start(struct iwl2100_softc *sc)
192 return iwl2100_config_op(sc, IWL2100_CMD_CONF_START);
196 iwl2100_restart_done(struct iwl2100_softc *sc)
198 callout_stop(&sc->sc_restart_bmiss);
199 sc->sc_flags &= ~IWL2100_F_RESTARTING;
203 iwl2100_attach(device_t dev)
205 struct iwl2100_softc *sc = device_get_softc(dev);
206 struct ieee80211com *ic = &sc->sc_ic;
207 struct ifnet *ifp = &ic->ic_if;
213 * Clear the retry timeout PCI configuration register to keep
214 * PCI TX retries from interfering with C3 CPU state.
216 pci_write_config(dev, IWL2100_PCIR_RETRY_TIMEOUT, 0, 1);
219 * Allocate DMA stuffs
221 error = iwl2100_dma_alloc(dev);
225 /* Disable interrupts */
226 CSR_WRITE_4(sc, IWL2100_INTR_MASK, 0);
229 * SW reset before reading EEPROM
231 error = iwl2100_reset(sc);
236 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
237 ifp->if_init = iwl2100_init;
238 ifp->if_ioctl = iwl2100_ioctl;
239 ifp->if_start = iwl2100_start;
240 ifp->if_watchdog = iwl2100_watchdog;
241 ifq_set_maxlen(&ifp->if_snd, IWL2100_TX_USED_MAX);
242 ifq_set_ready(&ifp->if_snd);
245 device_printf(dev, "eeprom\n");
246 for (i = 0; i < 128; ++i) {
247 if (i != 0 && i % 8 == 0)
249 val = iwl_read_eeprom(&sc->iwlcom, i);
250 kprintf("%04x ", val);
255 /* IBSS channel mask */
256 sc->sc_ibss_chans = iwl_read_eeprom(&sc->iwlcom,
257 IWL2100_EEPROM_IBSS_CHANS) & IWL2100_CFG_CHANMASK;
259 /* BSS channel mask */
260 sc->sc_bss_chans = iwl_read_eeprom(&sc->iwlcom, IWL2100_EEPROM_CHANS);
265 for (i = 0; i < ETHER_ADDR_LEN / 2; ++i) {
266 val = iwl_read_eeprom(&sc->iwlcom, IWL2100_EEPROM_MAC + i);
267 ic->ic_myaddr[i * 2] = val >> 8;
268 ic->ic_myaddr[(i * 2) + 1] = val & 0xff;
272 * Set supported channels
274 for (i = 0; i < 14; ++i) {
275 if (sc->sc_bss_chans & (1 << i)) {
278 ic->ic_channels[chan].ic_freq =
279 ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ);
280 ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_B;
284 ic->ic_sup_rates[IEEE80211_MODE_11B] = iwl_rateset_11b;
285 ic->ic_phytype = IEEE80211_T_DS;
286 ic->ic_caps = IEEE80211_C_MONITOR |
288 IEEE80211_C_SHPREAMBLE |
290 ic->ic_caps_ext = IEEE80211_CEXT_AUTOSCAN;
291 ic->ic_state = IEEE80211_S_INIT;
292 ic->ic_opmode = IEEE80211_M_STA;
294 ieee80211_ifattach(ic);
297 * ieee80211_frame will be stripped on TX path, so only
298 * extra space needs to be reserved.
300 ic->ic_headroom = sizeof(struct iwl2100_tx_hdr) -
301 sizeof(struct ieee80211_frame);
303 sc->sc_newstate = ic->ic_newstate;
304 ic->ic_newstate = iwl2100_newstate;
306 ieee80211_media_init(ic, iwl2100_media_change, iwl2100_media_status);
308 error = bus_setup_intr(dev, sc->sc_irq_res, INTR_MPSAFE,
309 iwl2100_intr, sc, &sc->sc_irq_handle,
312 device_printf(dev, "can't setup intr\n");
313 ieee80211_ifdetach(ic);
317 ifp->if_cpuid = ithread_cpuid(rman_get_start(sc->sc_irq_res));
318 KKASSERT(ifp->if_cpuid >= 0 && ifp->if_cpuid < ncpus);
323 bpfattach_dlt(ifp, DLT_IEEE802_11_RADIO,
324 sizeof(struct ieee80211_frame) + sizeof(sc->sc_tx_th),
327 sc->sc_tx_th_len = roundup(sizeof(sc->sc_tx_th), sizeof(uint32_t));
328 sc->sc_tx_th.wt_ihdr.it_len = htole16(sc->sc_tx_th_len);
329 sc->sc_tx_th.wt_ihdr.it_present = htole32(IWL2100_TX_RADIOTAP_PRESENT);
331 sc->sc_rx_th_len = roundup(sizeof(sc->sc_rx_th), sizeof(uint32_t));
332 sc->sc_rx_th.wr_ihdr.it_len = htole16(sc->sc_rx_th_len);
333 sc->sc_rx_th.wr_ihdr.it_present = htole32(IWL2100_RX_RADIOTAP_PRESENT);
335 sc->sc_tx_th.wt_chan_flags = sc->sc_rx_th.wr_chan_flags =
336 htole16(IEEE80211_CHAN_B);
339 * Create worker thread and initialize all necessary messages
341 iwl_create_thread(&sc->iwlcom, device_get_unit(dev));
343 iwlmsg_init(&sc->sc_scanend_msg, &netisr_adone_rport,
344 iwl2100_scanend_dispatch, sc);
345 iwlmsg_init(&sc->sc_restart_msg, &netisr_adone_rport,
346 iwl2100_restart_dispatch, sc);
347 iwlmsg_init(&sc->sc_bmiss_msg, &netisr_adone_rport,
348 iwl2100_bmiss_dispatch, sc);
349 iwlmsg_init(&sc->sc_reinit_msg, &netisr_adone_rport,
350 iwl2100_reinit_dispatch, sc);
352 iwlmsg_init(&sc->sc_assoc_msg, &netisr_adone_rport,
353 iwl2100_newstate_dispatch, sc);
354 sc->sc_assoc_msg.iwlm_nstate = IEEE80211_S_ASSOC;
355 sc->sc_assoc_msg.iwlm_arg = -1;
357 iwlmsg_init(&sc->sc_run_msg, &netisr_adone_rport,
358 iwl2100_newstate_dispatch, sc);
359 sc->sc_run_msg.iwlm_nstate = IEEE80211_S_RUN;
360 sc->sc_run_msg.iwlm_arg = -1;
363 * Initialize callouts
365 callout_init(&sc->sc_restart_bmiss);
366 callout_init(&sc->sc_ibss);
367 callout_init(&sc->sc_reinit);
369 /* Add sysctl node */
370 SYSCTL_ADD_UINT(&sc->sc_sysctl_ctx,
371 SYSCTL_CHILDREN(sc->sc_sysctl_tree), OID_AUTO,
372 "debug", CTLFLAG_RW, &sc->sc_debug, 0, "debug flags");
375 ieee80211_announce(ic);
380 iwl2100_detach(device_t dev)
382 struct iwl2100_softc *sc = device_get_softc(dev);
384 if (device_is_attached(dev)) {
385 struct ifnet *ifp = &sc->sc_ic.ic_if;
387 lwkt_serialize_enter(ifp->if_serializer);
389 sc->sc_flags |= IWL2100_F_DETACH;
391 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_handle);
392 iwl_destroy_thread(&sc->iwlcom);
394 lwkt_serialize_exit(ifp->if_serializer);
396 iwl2100_free_firmware(sc);
399 ieee80211_ifdetach(&sc->sc_ic);
401 iwl2100_dma_free(dev);
405 iwl2100_shutdown(device_t dev)
407 struct iwl2100_softc *sc = device_get_softc(dev);
408 struct ifnet *ifp = &sc->sc_ic.ic_if;
410 lwkt_serialize_enter(ifp->if_serializer);
412 lwkt_serialize_exit(ifp->if_serializer);
418 iwl2100_stop(struct iwl2100_softc *sc)
422 ASSERT_SERIALIZED(sc->sc_ic.ic_if.if_serializer);
424 iwl2100_stop_callouts(sc);
426 iwlmsg_init(&msg, &sc->sc_reply_port, iwl2100_stop_dispatch, sc);
427 lwkt_domsg(&sc->sc_thread_port, &msg.iwlm_nmsg.nm_lmsg, 0);
431 iwl2100_stop_dispatch(struct netmsg *nmsg)
433 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
434 struct iwl2100_softc *sc = msg->iwlm_softc;
436 ASSERT_SERIALIZED(sc->sc_ic.ic_if.if_serializer);
438 ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1);
440 lwkt_replymsg(&nmsg->nm_lmsg, 0);
444 iwl2100_hw_stop(struct iwl2100_softc *sc)
446 struct ifnet *ifp = &sc->sc_ic.ic_if;
448 ASSERT_SERIALIZED(ifp->if_serializer);
449 KKASSERT(curthread == &sc->sc_thread);
451 callout_stop(&sc->sc_reinit);
453 /* Disable interrupts */
454 CSR_WRITE_4(sc, IWL2100_INTR_MASK, 0);
459 iwl2100_hw_reset(sc);
465 iwl2100_free_tx_ring(sc);
466 iwl2100_free_rx_ring(sc);
468 /* NOTE: MUST after iwl2100_free_tx_ring() */
469 iwl2100_free_cmd(sc);
472 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
475 sc->sc_flags &= ~(IWL2100_F_WAITCMD |
478 IWL2100_F_RESTARTING |
485 iwl2100_reset(struct iwl2100_softc *sc)
492 #define WAIT_MAX 1000
494 CSR_WRITE_4(sc, IWL2100_RESET, IWL2100_RESET_SW);
495 for (i = 0; i < WAIT_MAX; ++i) {
497 if (CSR_READ_4(sc, IWL2100_RESET) & IWL2100_RESET_DONE)
501 if_printf(&sc->sc_ic.ic_if, "sw reset timed out\n");
508 * Move to D0 state, wait clock to become stable
510 #define WAIT_MAX 10000
512 CSR_WRITE_4(sc, IWL2100_CTRL, IWL2100_CTRL_INITDONE);
513 for (i = 0; i < WAIT_MAX; ++i) {
515 if (CSR_READ_4(sc, IWL2100_CTRL) & IWL2100_CTRL_CLKREADY)
519 if_printf(&sc->sc_ic.ic_if, "can't stablize clock\n");
528 CSR_SETBITS_4(sc, IWL2100_CTRL, IWL2100_CTRL_STANDBY);
533 iwl2100_dma_alloc(device_t dev)
535 struct iwl2100_softc *sc = device_get_softc(dev);
536 struct iwl2100_tx_ring *tr = &sc->sc_txring;
537 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
541 * Create top level DMA tag
543 error = bus_dma_tag_create(NULL, 1, 0,
544 BUS_SPACE_MAXADDR_32BIT,
548 BUS_SPACE_UNRESTRICTED,
549 BUS_SPACE_MAXSIZE_32BIT,
552 device_printf(dev, "can't create DMA tag\n");
557 * Create DMA stuffs for TX desc ring
559 error = iwl_dma_mem_create(dev, sc->sc_dtag, IWL2100_TXRING_SIZE,
560 &tr->tr_dtag, (void **)&tr->tr_desc,
561 &tr->tr_paddr, &tr->tr_dmap);
563 device_printf(dev, "can't create DMA memory for "
569 * Create DMA stuffs for RX desc ring
571 error = iwl_dma_mem_create(dev, sc->sc_dtag, IWL2100_RXRING_SIZE,
572 &rr->rr_dtag, (void **)&rr->rr_desc,
573 &rr->rr_paddr, &rr->rr_dmap);
575 device_printf(dev, "can't create DMA memory for "
581 * Create DMA stuffs for RX status ring
583 error = iwl_dma_mem_create(dev, sc->sc_dtag, IWL2100_RXSTATUS_SIZE,
584 &rr->rr_st_dtag, (void **)&rr->rr_status,
585 &rr->rr_st_paddr, &rr->rr_st_dmap);
587 device_printf(dev, "can't create DMA memory for "
593 * Create mbuf DMA stuffs
595 error = iwl2100_dma_mbuf_create(dev);
603 iwl2100_dma_free(device_t dev)
605 struct iwl2100_softc *sc = device_get_softc(dev);
606 struct iwl2100_tx_ring *tr = &sc->sc_txring;
607 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
609 /* Free DMA stuffs for TX desc ring */
610 iwl_dma_mem_destroy(tr->tr_dtag, tr->tr_desc, tr->tr_dmap);
612 /* Free DMA stuffs for RX desc ring */
613 iwl_dma_mem_destroy(rr->rr_dtag, rr->rr_desc, rr->rr_dmap);
615 /* Free DMA stuffs for RX status ring */
616 iwl_dma_mem_destroy(rr->rr_st_dtag, rr->rr_status, rr->rr_st_dmap);
618 /* Free DMA stuffs for mbufs */
619 iwl2100_dma_mbuf_destroy(dev, IWL2100_TX_NDESC, IWL2100_RX_NDESC);
621 /* Free top level DMA tag */
622 if (sc->sc_dtag != NULL)
623 bus_dma_tag_destroy(sc->sc_dtag);
627 iwl2100_dma_mbuf_create(device_t dev)
629 struct iwl2100_softc *sc = device_get_softc(dev);
630 struct iwl2100_tx_ring *tr = &sc->sc_txring;
631 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
635 * Create mbuf DMA tag
637 error = bus_dma_tag_create(sc->sc_dtag, 1, 0,
638 BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR,
640 MCLBYTES, IWL2100_NSEG_MAX,
641 BUS_SPACE_MAXSIZE_32BIT,
642 BUS_DMA_ALLOCNOW, &sc->sc_mbuf_dtag);
644 device_printf(dev, "can't create mbuf DMA tag\n");
649 * Create spare DMA map for RX mbufs
651 error = bus_dmamap_create(sc->sc_mbuf_dtag, 0, &rr->rr_tmp_dmap);
653 device_printf(dev, "can't create spare mbuf DMA map\n");
654 bus_dma_tag_destroy(sc->sc_mbuf_dtag);
655 sc->sc_mbuf_dtag = NULL;
660 * Create DMA maps for RX mbufs
662 for (i = 0; i < IWL2100_RX_NDESC; ++i) {
663 error = bus_dmamap_create(sc->sc_mbuf_dtag, 0,
664 &rr->rr_buf[i].rb_dmap);
666 device_printf(dev, "can't create %d RX mbuf "
668 iwl2100_dma_mbuf_destroy(dev, 0, i);
674 * Create DMA maps for TX mbufs
676 for (i = 0; i < IWL2100_TX_NDESC; ++i) {
677 error = bus_dmamap_create(sc->sc_mbuf_dtag, 0,
678 &tr->tr_buf[i].tb_dmap);
680 device_printf(dev, "can't create %d TX mbuf "
682 iwl2100_dma_mbuf_destroy(dev, i, IWL2100_RX_NDESC);
690 iwl2100_dma_mbuf_destroy(device_t dev, int tx_done, int rx_done)
692 struct iwl2100_softc *sc = device_get_softc(dev);
693 struct iwl2100_tx_ring *tr = &sc->sc_txring;
694 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
697 if (sc->sc_mbuf_dtag == NULL)
701 * Destroy DMA maps for RX mbufs
703 for (i = 0; i < rx_done; ++i) {
704 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
706 KASSERT(rb->rb_mbuf == NULL, ("RX mbuf is not freed yet\n"));
707 bus_dmamap_destroy(sc->sc_mbuf_dtag, rb->rb_dmap);
711 * Destroy DMA maps for TX mbufs
713 for (i = 0; i < tx_done; ++i) {
714 struct iwl2100_txbuf *tb = &tr->tr_buf[i];
716 KASSERT(tb->tb_mbuf == NULL, ("TX mbuf is not freed yet\n"));
717 bus_dmamap_destroy(sc->sc_mbuf_dtag, tb->tb_dmap);
721 * Destroy spare mbuf DMA map
723 bus_dmamap_destroy(sc->sc_mbuf_dtag, rr->rr_tmp_dmap);
726 * Destroy mbuf DMA tag
728 bus_dma_tag_destroy(sc->sc_mbuf_dtag);
729 sc->sc_mbuf_dtag = NULL;
733 iwl2100_init(void *xsc)
735 struct iwl2100_softc *sc = xsc;
738 ASSERT_SERIALIZED(sc->sc_ic.ic_if.if_serializer);
740 iwl2100_stop_callouts(sc);
742 iwlmsg_init(&msg, &sc->sc_reply_port, iwl2100_init_dispatch, sc);
743 lwkt_domsg(&sc->sc_thread_port, &msg.iwlm_nmsg.nm_lmsg, 0);
747 iwl2100_init_dispatch(struct netmsg *nmsg)
749 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
750 struct iwl2100_softc *sc = msg->iwlm_softc;
751 struct ieee80211com *ic = &sc->sc_ic;
752 struct ifnet *ifp = &ic->ic_if;
753 int error = 0, flags;
755 ASSERT_SERIALIZED(ifp->if_serializer);
757 if (sc->sc_flags & IWL2100_F_DETACH)
760 ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
762 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
765 * Workaround for dummy firmware:
766 * Don't enable hardware too early, since
767 * once it is enabled, it will start scanning.
771 flags = IWL2100_INIT_F_ENABLE;
774 /* Always put the device into a known state */
775 error = iwl2100_hw_init(sc, NULL,
776 ic->ic_des_essid, ic->ic_des_esslen, flags);
780 if (sc->sc_flags & IWL2100_F_ZERO_CMD) {
781 if_printf(ifp, "zero cmd, reinit 1s later\n");
784 callout_reset(&sc->sc_reinit, hz, iwl2100_reinit_callout, sc);
788 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
789 if (ic->ic_roaming != IEEE80211_ROAMING_MANUAL)
790 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
792 ieee80211_new_state(ic, IEEE80211_S_RUN, -1);
797 lwkt_replymsg(&nmsg->nm_lmsg, error);
801 iwl2100_ioctl(struct ifnet *ifp, u_long cmd, caddr_t req, struct ucred *cr)
803 struct iwl2100_softc *sc = ifp->if_softc;
806 ASSERT_SERIALIZED(ifp->if_serializer);
808 if (sc->sc_flags & IWL2100_F_DETACH)
813 if (ifp->if_flags & IFF_UP) {
814 if ((ifp->if_flags & IFF_RUNNING) == 0)
817 if (ifp->if_flags & IFF_RUNNING) {
821 * Stop callouts explicitly, since
822 * if reinitialization is happening,
823 * IFF_RUNNING will not be turned on.
825 iwl2100_stop_callouts(sc);
830 error = ieee80211_ioctl(&sc->sc_ic, cmd, req, cr);
834 if (error == ENETRESET) {
835 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
836 (IFF_UP | IFF_RUNNING))
844 iwl2100_start(struct ifnet *ifp)
846 struct iwl2100_softc *sc = ifp->if_softc;
847 struct ieee80211com *ic = &sc->sc_ic;
848 struct iwl2100_tx_ring *tr = &sc->sc_txring;
851 ASSERT_SERIALIZED(ifp->if_serializer);
853 if (sc->sc_flags & IWL2100_F_DETACH) {
854 ieee80211_drain_mgtq(&ic->ic_mgtq);
855 ifq_purge(&ifp->if_snd);
859 if ((ifp->if_flags & (IFF_OACTIVE | IFF_RUNNING)) != IFF_RUNNING)
862 if ((sc->sc_flags & IWL2100_F_IFSTART) == 0) {
863 ifq_purge(&ifp->if_snd);
867 while (tr->tr_used < IWL2100_TX_USED_MAX) {
868 struct ieee80211_frame *wh;
869 struct ieee80211_node *ni;
870 struct ether_header *eh;
873 m = ifq_dequeue(&ifp->if_snd, NULL);
877 if (m->m_len < sizeof(*eh)) {
878 m = m_pullup(m, sizeof(*eh));
884 eh = mtod(m, struct ether_header *);
886 ni = ieee80211_find_txnode(ic, eh->ether_dhost);
897 m = ieee80211_encap(ic, m, ni);
899 ieee80211_free_node(ni);
904 if (ic->ic_rawbpf != NULL)
905 bpf_mtap(ic->ic_rawbpf, m);
907 wh = mtod(m, struct ieee80211_frame *);
908 if (wh->i_fc[1] & IEEE80211_FC1_WEP) {
909 if (ieee80211_crypto_encap(ic, ni, m) == NULL) {
910 ieee80211_free_node(ni);
920 if (sc->sc_drvbpf != NULL) {
921 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
922 sc->sc_tx_th.wt_flags = IEEE80211_RADIOTAP_F_WEP;
924 sc->sc_tx_th.wt_flags = 0;
925 bpf_ptap(sc->sc_drvbpf, m, &sc->sc_tx_th,
928 wh = NULL; /* Catch any invalid use */
930 ieee80211_free_node(ni);
932 if (iwl2100_encap(sc, m)) {
941 if (tr->tr_used >= IWL2100_TX_USED_MAX)
942 ifp->if_flags |= IFF_OACTIVE;
945 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
946 CSR_WRITE_4(sc, IWL2100_TXQ_WRITE_IDX, tr->tr_index);
950 ieee80211_drain_mgtq(&ic->ic_mgtq);
955 iwl2100_watchdog(struct ifnet *ifp)
957 struct iwl2100_softc *sc = ifp->if_softc;
959 ASSERT_SERIALIZED(ifp->if_serializer);
961 if (sc->sc_flags & IWL2100_F_DETACH)
964 if (sc->sc_tx_timer) {
965 if (--sc->sc_tx_timer == 0) {
966 if_printf(ifp, "watchdog timeout!\n");
974 ieee80211_watchdog(&sc->sc_ic);
978 iwl2100_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
980 struct ifnet *ifp = &ic->ic_if;
981 struct iwl2100_softc *sc = ifp->if_softc;
984 ASSERT_SERIALIZED(ifp->if_serializer);
986 iwlmsg_init(&msg, &sc->sc_reply_port, iwl2100_newstate_dispatch, sc);
987 msg.iwlm_nstate = nstate;
990 return lwkt_domsg(&sc->sc_thread_port, &msg.iwlm_nmsg.nm_lmsg, 0);
994 iwl2100_newstate_dispatch(struct netmsg *nmsg)
996 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
997 struct iwl2100_softc *sc = msg->iwlm_softc;
998 struct ieee80211com *ic = &sc->sc_ic;
1000 struct ifnet *ifp = &ic->ic_if;
1002 enum ieee80211_state nstate, ostate;
1003 int arg = msg->iwlm_arg, error = 0;
1005 ASSERT_SERIALIZED(ifp->if_serializer);
1007 nstate = msg->iwlm_nstate;
1008 ostate = ic->ic_state;
1010 sc->sc_flags &= ~IWL2100_F_IFSTART;
1013 iwl2100_chan_change(sc, ic->ic_curchan);
1015 callout_stop(&sc->sc_ibss);
1016 iwl2100_restart_done(sc);
1018 if (nstate == IEEE80211_S_INIT)
1021 if (sc->sc_flags & IWL2100_F_DETACH) {
1023 * Except for INIT, we skip rest of the
1024 * state changes during detaching
1029 if (ic->ic_opmode == IEEE80211_M_STA) {
1030 if (nstate == IEEE80211_S_AUTH)
1031 error = iwl2100_auth(sc);
1032 else if (nstate == IEEE80211_S_RUN)
1033 sc->sc_flags |= IWL2100_F_IFSTART;
1034 } else if (ic->ic_opmode == IEEE80211_M_IBSS) {
1035 if (nstate == IEEE80211_S_RUN) {
1036 DPRINTF(sc, IWL2100_DBG_IBSS, "%s",
1037 "start/join ibss\n");
1040 * IWL2100_F_IFSTART can't be turned on
1041 * until BSSID generated by the firmware
1044 * XXX only if we started the IBSS
1046 error = iwl2100_ibss(sc);
1051 error = sc->sc_newstate(ic, nstate, arg);
1054 if (ic->ic_opmode != IEEE80211_M_MONITOR) {
1056 * Don't use 'nstate' here, since for IBSS
1057 * mode 802.11 layer may enter RUN state in
1058 * a recursive manner, i.e. when we reach
1059 * here, nstate != ic->ic_state
1061 if (ic->ic_state == IEEE80211_S_SCAN &&
1062 ic->ic_state != ostate) {
1063 DPRINTF(sc, IWL2100_DBG_SCAN, "%s",
1065 error = iwl2100_scan(sc);
1070 lwkt_replymsg(&nmsg->nm_lmsg, error);
1074 iwl2100_media_change(struct ifnet *ifp)
1078 ASSERT_SERIALIZED(ifp->if_serializer);
1080 error = ieee80211_media_change(ifp);
1081 if (error != ENETRESET)
1084 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING))
1085 iwl2100_init(ifp->if_softc);
1090 iwl2100_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1092 struct iwl2100_softc *sc = ifp->if_softc;
1094 if (sc->sc_flags & IWL2100_F_IFSTART) {
1095 struct ieee80211_node *ni = sc->sc_ic.ic_bss;
1099 txrate = iwl2100_read_ord1(sc, IWL2100_ORD1_TXRATE) & 0xf;
1100 if (ni->ni_rates.rs_nrates < 4)
1101 nrates = ni->ni_rates.rs_nrates;
1103 for (i = 0; i < nrates; ++i) {
1104 if ((1 << i) & txrate)
1108 ieee80211_media_status(ifp, imr);
1112 iwl2100_intr(void *xsc)
1114 struct iwl2100_softc *sc = xsc;
1115 struct ifnet *ifp = &sc->sc_ic.ic_if;
1116 uint32_t intr_status;
1118 ASSERT_SERIALIZED(ifp->if_serializer);
1120 if ((sc->sc_flags & IWL2100_F_INITED) == 0)
1123 intr_status = CSR_READ_4(sc, IWL2100_INTR_STATUS);
1124 if (intr_status == 0xffffffff) /* not for us */
1127 if ((intr_status & IWL2100_INTRS) == 0) /* not interested */
1130 sc->sc_flags |= IWL2100_F_IN_INTR;
1132 /* Disable interrupts */
1133 CSR_WRITE_4(sc, IWL2100_INTR_MASK, 0);
1135 if (intr_status & IWL2100_INTR_EFATAL) {
1136 uint32_t error_info;
1138 if_printf(ifp, "intr fatal error\n");
1139 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_EFATAL);
1141 error_info = IND_READ_4(sc, IWL2100_IND_ERROR_INFO);
1142 IND_READ_4(sc, error_info & IWL2100_IND_ERRORADDR_MASK);
1144 callout_stop(&sc->sc_reinit);
1147 /* Leave interrupts disabled */
1151 if (intr_status & IWL2100_INTR_EPARITY) {
1152 if_printf(ifp, "intr parity error\n");
1153 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_EPARITY);
1156 if (intr_status & IWL2100_INTR_RX) {
1157 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_RX);
1162 if (intr_status & IWL2100_INTR_TX) {
1163 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_TX);
1167 if (intr_status & IWL2100_INTR_FW_INITED)
1168 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_FW_INITED);
1169 if (intr_status & IWL2100_INTR_CMD_DONE)
1170 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, IWL2100_INTR_CMD_DONE);
1172 /* Enable interrupts */
1173 CSR_WRITE_4(sc, IWL2100_INTR_MASK, IWL2100_INTRS);
1175 sc->sc_flags &= ~IWL2100_F_IN_INTR;
1179 iwl2100_hw_reset(struct iwl2100_softc *sc)
1186 * - Make GPIO3 firmware writable
1190 CSR_WRITE_4(sc, IWL2100_GPIO,
1191 IWL2100_GPIO_3_EN | IWL2100_GPIO_3_FWWR |
1192 IWL2100_GPIO_1_EN | IWL2100_GPIO_LEDOFF);
1199 CSR_WRITE_4(sc, IWL2100_RESET, IWL2100_RESET_STOP_MASTER);
1200 for (i = 0; i < WAIT_MAX; ++i) {
1203 if (CSR_READ_4(sc, IWL2100_RESET) &
1204 IWL2100_RESET_MASTER_STOPPED)
1207 if (i == WAIT_MAX) {
1208 if_printf(&sc->sc_ic.ic_if, "can't stop master\n");
1214 CSR_WRITE_4(sc, IWL2100_RESET, IWL2100_RESET_SW);
1219 iwl2100_alloc_firmware(struct iwl2100_softc *sc, enum ieee80211_opmode opmode)
1224 enum ieee80211_opmode opmode;
1225 struct iwl2100_firmware *fw;
1227 { "", IWL2100_FW_M_STA, IEEE80211_M_STA,
1229 { "-i", IWL2100_FW_M_IBSS, IEEE80211_M_IBSS,
1231 { "-p", IWL2100_FW_M_MONITOR, IEEE80211_M_MONITOR,
1232 &sc->sc_fw_monitor },
1233 { NULL, 0, 0, NULL }
1235 struct ifnet *ifp = &sc->sc_ic.ic_if;
1236 const struct iwl2100_fwimg_hdr *hdr;
1237 struct iwl2100_firmware *fw = NULL;
1238 struct fw_image *image;
1242 for (i = 0; fw_arr[i].fw != NULL; ++i) {
1245 if (fw_arr[i].opmode == opmode) {
1246 if (fw->fw_image != NULL)
1252 KASSERT(fw_arr[i].fw != NULL, ("unsupported opmode %u\n", opmode));
1254 ksnprintf(filename, sizeof(filename), IWL2100_FW_PATH,
1258 * Release the serializer to avoid possible dead lock
1260 lwkt_serialize_exit(ifp->if_serializer);
1261 image = firmware_image_load(filename, NULL);
1262 lwkt_serialize_enter(ifp->if_serializer);
1266 fw->fw_image = image;
1273 hdr = (const struct iwl2100_fwimg_hdr *)image->fw_image;
1274 if ((hdr->version & 0xff) != 1) {
1275 if_printf(ifp, "%s unsupported firmware version %d",
1276 image->fw_name, hdr->version & 0xff);
1280 if (hdr->mode != fw_arr[i].mode) {
1281 if_printf(ifp, "%s contains %d mode firmware, should be %d\n",
1282 image->fw_name, hdr->mode, fw_arr[i].mode);
1286 if (hdr->data_size + hdr->ucode_size + sizeof(*hdr) !=
1289 "%s size mismatch, %zu/hdr %zu\n",
1290 image->fw_name, fw->fw_image->fw_imglen,
1291 hdr->data_size + hdr->ucode_size + sizeof(*hdr));
1295 fw->fw_data = (const uint8_t *)(hdr + 1);
1296 fw->fw_data_size = hdr->data_size;
1297 fw->fw_ucode = fw->fw_data + fw->fw_data_size;
1298 fw->fw_ucode_size = hdr->ucode_size;
1302 firmware_image_unload(fw->fw_image);
1303 bzero(fw, sizeof(*fw));
1309 iwl2100_free_firmware(struct iwl2100_softc *sc)
1311 struct iwl2100_firmware *fw_arr[] =
1312 { &sc->sc_fw_sta, &sc->sc_fw_ibss, &sc->sc_fw_monitor, NULL };
1315 for (i = 0; fw_arr[i] != NULL; ++i) {
1316 struct iwl2100_firmware *fw = fw_arr[i];
1318 if (fw->fw_image != NULL) {
1319 firmware_image_unload(fw->fw_image);
1320 bzero(fw, sizeof(*fw));
1326 iwl2100_load_firmware(struct iwl2100_softc *sc, enum ieee80211_opmode opmode)
1328 static const struct {
1332 { IWL2100_SHMEM0, IWL2100_SHMEM0_SIZE },
1333 { IWL2100_SHMEM1, IWL2100_SHMEM1_SIZE },
1334 { IWL2100_SHMEM2, IWL2100_SHMEM2_SIZE },
1335 { IWL2100_SHMEM3, IWL2100_SHMEM3_SIZE },
1336 { IWL2100_SHMEM_INTR, IWL2100_SHMEM_INTR_SIZE },
1339 const struct iwl2100_firmware *fw = NULL;
1343 * Pick up the firmware image corresponding to
1344 * the current operation mode
1347 case IEEE80211_M_STA:
1348 fw = &sc->sc_fw_sta;
1350 case IEEE80211_M_IBSS:
1351 fw = &sc->sc_fw_ibss;
1353 case IEEE80211_M_MONITOR:
1354 fw = &sc->sc_fw_monitor;
1357 panic("unsupported opmode %d\n", opmode);
1360 KASSERT(fw->fw_image != NULL,
1361 ("opmode %d firmware image is not allocated yet\n", opmode));
1364 error = iwl2100_load_fw_ucode(sc, fw);
1369 error = iwl2100_reset(sc);
1374 error = iwl2100_load_fw_data(sc, fw);
1378 /* Clear shared memory */
1379 for (i = 0; share_mem[i].size != 0; ++i) {
1380 uint32_t addr = share_mem[i].addr;
1383 for (j = 0; j < share_mem[i].size; j += 4)
1384 IND_WRITE_4(sc, addr + j, 0);
1390 #define IND_WRITE_FLUSH_2(sc, reg, val) \
1392 IND_WRITE_2((sc), (reg), (val)); \
1393 CSR_READ_4((sc), 0); \
1396 #define IND_WRITE_FLUSH_1(sc, reg, val) \
1398 IND_WRITE_1((sc), (reg), (val)); \
1399 CSR_READ_4((sc), 0); \
1402 /* XXX need more comment */
1404 iwl2100_load_fw_ucode(struct iwl2100_softc *sc,
1405 const struct iwl2100_firmware *fw)
1407 struct iwl2100_ucode_resp resp;
1412 IND_WRITE_4(sc, IWL2100_IND_HALT, IWL2100_IND_HALT_HOLD);
1414 /* Allow ARC to run */
1415 CSR_WRITE_4(sc, IWL2100_RESET, 0);
1417 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x703);
1418 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x707);
1420 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1421 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1423 IND_WRITE_FLUSH_1(sc, 0x210000, 0x40);
1424 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1425 IND_WRITE_FLUSH_1(sc, 0x210000, 0x40);
1428 for (i = 0; i < fw->fw_ucode_size; ++i, ++p)
1429 IND_WRITE_1(sc, 0x210010, *p);
1431 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1432 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1433 IND_WRITE_FLUSH_1(sc, 0x210000, 0x80);
1436 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x703);
1437 IND_WRITE_FLUSH_2(sc, IWL2100_IND_CTRL, 0x707);
1439 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1440 IND_WRITE_FLUSH_1(sc, 0x210014, 0x72);
1442 IND_WRITE_FLUSH_1(sc, 0x210000, 0);
1443 IND_WRITE_1(sc, 0x210000, 0x80);
1446 for (i = 0; i < WAIT_MAX; ++i) {
1449 if (IND_READ_1(sc, 0x210000) & 0x1)
1452 if (i == WAIT_MAX) {
1453 if_printf(&sc->sc_ic.ic_if,
1454 "wait ucode symbol init timed out\n");
1460 for (i = 0; i < WAIT_MAX; ++i) {
1461 uint16_t *r = (uint16_t *)&resp;
1464 for (j = 0; j < sizeof(resp) / 2; ++j, ++r)
1465 *r = IND_READ_2(sc, 0x210004);
1467 if (resp.cmd_id == 1 && resp.ucode_valid == 1)
1471 if (i == WAIT_MAX) {
1472 if_printf(&sc->sc_ic.ic_if,
1473 "wait ucode response timed out\n");
1479 IND_WRITE_4(sc, IWL2100_IND_HALT, 0);
1482 if_printf(&sc->sc_ic.ic_if, "ucode rev.%d date %d.%d.20%02d "
1483 "time %02d:%02d\n", resp.ucode_rev,
1484 resp.date_time[0], resp.date_time[1],
1485 resp.date_time[2], resp.date_time[3],
1492 #undef IND_WRITE_FLUSH_1
1493 #undef IND_WRITE_FLUSH_2
1496 iwl2100_load_fw_data(struct iwl2100_softc *sc,
1497 const struct iwl2100_firmware *fw)
1499 const uint8_t *p = fw->fw_data;
1502 while (w < fw->fw_data_size) {
1503 const struct iwl2100_fwdata_hdr *h;
1506 h = (const struct iwl2100_fwdata_hdr *)p;
1507 if (h->len > 32 || h->len == 0) {
1508 if_printf(&sc->sc_ic.ic_if,
1509 "firmware image data corrupted\n");
1512 if ((h->addr & 0x3) || (h->len & 0x3)) {
1513 if_printf(&sc->sc_ic.ic_if,
1514 "firmware image data with unaligned "
1515 "address %#x or length %#x\n",
1520 hlen = sizeof(*h) + h->len - 1;
1521 if (w + hlen > fw->fw_data_size) {
1522 if_printf(&sc->sc_ic.ic_if,
1523 "firmware image data size mismatch\n");
1527 CSR_WRITE_4(sc, IWL2100_AUTOINC_ADDR, h->addr);
1528 for (i = 0; i < h->len; i += 4) {
1529 CSR_WRITE_4(sc, IWL2100_AUTOINC_DATA,
1530 *(const uint32_t *)&h->data[i]);
1536 KKASSERT(w == fw->fw_data_size);
1542 iwl2100_free_tx_ring(struct iwl2100_softc *sc)
1544 struct iwl2100_tx_ring *tr = &sc->sc_txring;
1547 for (i = 0; i < IWL2100_TX_NDESC; ++i) {
1548 struct iwl2100_txbuf *tb = &tr->tr_buf[i];
1550 if (tb->tb_mbuf != NULL) {
1551 bus_dmamap_unload(sc->sc_mbuf_dtag, tb->tb_dmap);
1552 if (tb->tb_flags & IWL2100_TBF_CMDBUF) {
1553 KKASSERT(tb->tb_mbuf == sc->sc_cmd);
1554 tb->tb_flags &= ~IWL2100_TBF_CMDBUF;
1556 m_freem(tb->tb_mbuf);
1562 bzero(tr->tr_desc, IWL2100_TXRING_SIZE);
1563 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
1571 iwl2100_free_rx_ring(struct iwl2100_softc *sc)
1573 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1576 for (i = 0; i < IWL2100_RX_NDESC; ++i) {
1577 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
1579 if (rb->rb_mbuf != NULL) {
1580 bus_dmamap_unload(sc->sc_mbuf_dtag, rb->rb_dmap);
1581 m_freem(rb->rb_mbuf);
1586 bzero(rr->rr_desc, IWL2100_RXRING_SIZE);
1587 bus_dmamap_sync(rr->rr_dtag, rr->rr_dmap, BUS_DMASYNC_PREWRITE);
1589 bzero(rr->rr_status, IWL2100_RXSTATUS_SIZE);
1590 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap, BUS_DMASYNC_PREWRITE);
1596 iwl2100_free_cmd(struct iwl2100_softc *sc)
1598 if (sc->sc_cmd != NULL) {
1599 m_freem(sc->sc_cmd);
1605 iwl2100_init_tx_ring(struct iwl2100_softc *sc)
1607 struct iwl2100_tx_ring *tr = &sc->sc_txring;
1613 bzero(tr->tr_desc, IWL2100_TXRING_SIZE);
1614 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
1616 CSR_WRITE_4(sc, IWL2100_TXQ_ADDR, tr->tr_paddr);
1617 CSR_WRITE_4(sc, IWL2100_TXQ_SIZE, IWL2100_TX_NDESC);
1618 CSR_WRITE_4(sc, IWL2100_TXQ_READ_IDX, 0);
1619 CSR_WRITE_4(sc, IWL2100_TXQ_WRITE_IDX, tr->tr_index);
1625 iwl2100_init_rx_ring(struct iwl2100_softc *sc)
1627 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1630 for (i = 0; i < IWL2100_RX_NDESC; ++i) {
1631 error = iwl2100_newbuf(sc, i, 1);
1635 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap, BUS_DMASYNC_PREWRITE);
1636 bus_dmamap_sync(rr->rr_dtag, rr->rr_dmap, BUS_DMASYNC_PREWRITE);
1638 rr->rr_index = IWL2100_RX_NDESC - 1;
1640 CSR_WRITE_4(sc, IWL2100_RXQ_ADDR, rr->rr_paddr);
1641 CSR_WRITE_4(sc, IWL2100_RXQ_SIZE, IWL2100_RX_NDESC);
1642 CSR_WRITE_4(sc, IWL2100_RXQ_READ_IDX, 0);
1643 CSR_WRITE_4(sc, IWL2100_RXQ_WRITE_IDX, rr->rr_index);
1645 CSR_WRITE_4(sc, IWL2100_RX_STATUS_ADDR, rr->rr_st_paddr);
1651 iwl2100_alloc_cmd(struct iwl2100_softc *sc)
1653 KKASSERT(sc->sc_cmd == NULL);
1655 sc->sc_cmd = m_getcl(MB_WAIT, MT_DATA, M_PKTHDR);
1656 if (sc->sc_cmd == NULL)
1662 iwl2100_newbuf(struct iwl2100_softc *sc, int buf_idx, int init)
1664 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1665 struct iwl2100_rxbuf *rb;
1666 struct iwl_dmamap_ctx ctx;
1667 bus_dma_segment_t seg;
1672 KKASSERT(buf_idx < IWL2100_RX_NDESC);
1673 rb = &rr->rr_buf[buf_idx];
1675 m = m_getcl(init ? MB_WAIT : MB_DONTWAIT, MT_DATA, M_PKTHDR);
1680 if_printf(&sc->sc_ic.ic_if, "m_getcl failed\n");
1686 m->m_len = m->m_pkthdr.len = MCLBYTES;
1689 * Try load RX mbuf into temporary DMA map
1693 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, rr->rr_tmp_dmap, m,
1694 iwl_dma_buf_addr, &ctx,
1695 init ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT);
1696 if (error || ctx.nsegs == 0) {
1698 bus_dmamap_unload(sc->sc_mbuf_dtag, rr->rr_tmp_dmap);
1700 if_printf(&sc->sc_ic.ic_if, "too many segments?!\n");
1705 if_printf(&sc->sc_ic.ic_if, "can't load RX mbuf\n");
1713 bus_dmamap_unload(sc->sc_mbuf_dtag, rb->rb_dmap);
1715 rb->rb_paddr = seg.ds_addr;
1718 * Swap RX buf's DMA map with the loaded temporary one
1721 rb->rb_dmap = rr->rr_tmp_dmap;
1722 rr->rr_tmp_dmap = dmap;
1726 iwl2100_rxdesc_setup(sc, buf_idx);
1731 iwl2100_rxdesc_setup(struct iwl2100_softc *sc, int buf_idx)
1733 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
1734 struct iwl2100_rxbuf *rb;
1735 struct iwl2100_desc *d;
1736 struct iwl2100_rx_status *st;
1738 KKASSERT(buf_idx < IWL2100_RX_NDESC);
1739 rb = &rr->rr_buf[buf_idx];
1741 st = &rr->rr_status[buf_idx];
1742 bzero(st, sizeof(*st));
1744 d = &rr->rr_desc[buf_idx];
1745 bzero(d, sizeof(*d));
1746 d->d_paddr = rb->rb_paddr;
1747 d->d_len = MCLBYTES;
1751 iwl2100_init_firmware(struct iwl2100_softc *sc)
1754 struct ifnet *ifp = &sc->sc_ic.ic_if;
1759 ASSERT_SERIALIZED(ifp->if_serializer);
1761 CSR_WRITE_4(sc, IWL2100_GPIO,
1762 IWL2100_GPIO_3_EN | IWL2100_GPIO_3_FWWR |
1763 IWL2100_GPIO_1_EN | IWL2100_GPIO_LEDOFF);
1764 CSR_WRITE_4(sc, IWL2100_RESET, 0);
1767 * Wait for firmware to be initialized
1769 #define WAIT_MAX 5000
1771 for (i = 0; i < WAIT_MAX; ++i) {
1774 intr = CSR_READ_4(sc, IWL2100_INTR_STATUS);
1775 if (intr & IWL2100_INTR_FW_INITED) {
1776 CSR_WRITE_4(sc, IWL2100_INTR_STATUS,
1777 IWL2100_INTR_FW_INITED);
1780 if (intr & (IWL2100_INTR_EFATAL | IWL2100_INTR_EPARITY)) {
1781 CSR_WRITE_4(sc, IWL2100_INTR_STATUS,
1782 IWL2100_INTR_EFATAL | IWL2100_INTR_EPARITY);
1786 intr = CSR_READ_4(sc, IWL2100_INTR_STATUS) & IWL2100_INTRS;
1787 if (intr & CSR_READ_4(sc, IWL2100_INTR_MASK))
1788 CSR_WRITE_4(sc, IWL2100_INTR_STATUS, intr);
1790 if (i == WAIT_MAX) {
1791 if_printf(&sc->sc_ic.ic_if,
1792 "firmware initialization timed out\n");
1798 /* Enable GPIO1/3 and allow firmware to write to them */
1799 CSR_SETBITS_4(sc, IWL2100_GPIO,
1800 IWL2100_GPIO_1_EN | IWL2100_GPIO_1_FWWR |
1801 IWL2100_GPIO_3_EN | IWL2100_GPIO_3_FWWR);
1806 iwl2100_read_ord2(struct iwl2100_softc *sc, uint32_t ofs, void *buf0, int buflen)
1808 uint8_t *buf = buf0;
1809 uint32_t addr, info;
1813 #define IND_ALIGN_MASK 0x3
1815 addr = IND_READ_4(sc, sc->sc_ord2 + (ofs << 3));
1816 info = IND_READ_4(sc, sc->sc_ord2 + (ofs << 3) + sizeof(addr));
1818 len = info & 0xffff;
1821 if ((len * i) < buflen)
1825 i = addr & IND_ALIGN_MASK;
1826 addr &= ~IND_ALIGN_MASK;
1830 KKASSERT(i < IND_ALIGN);
1831 if (buflen + i < IND_ALIGN)
1837 CSR_WRITE_4(sc, IWL2100_IND_ADDR, addr);
1838 for (; i < lim; ++i, ++buf)
1839 *buf = CSR_READ_1(sc, IWL2100_IND_DATA + i);
1841 KKASSERT(buflen >= r);
1849 len = buflen & ~IND_ALIGN_MASK;
1850 buflen &= IND_ALIGN_MASK;
1853 CSR_WRITE_4(sc, IWL2100_AUTOINC_ADDR, addr);
1854 for (i = 0; i < len; i += 4, addr += 4, buf += 4) {
1855 *((uint32_t *)buf) =
1856 CSR_READ_4(sc, IWL2100_AUTOINC_DATA);
1860 CSR_WRITE_4(sc, IWL2100_IND_ADDR, addr);
1861 for (i = 0; i < buflen; ++i, ++buf)
1862 *buf = CSR_READ_1(sc, IWL2100_IND_DATA + i);
1868 #undef IND_ALIGN_MASK
1872 iwl2100_read_ord1(struct iwl2100_softc *sc, uint32_t ofs)
1876 addr = IND_READ_4(sc, sc->sc_ord1 + (ofs << 2));
1877 return IND_READ_4(sc, addr);
1881 iwl2100_write_ord1(struct iwl2100_softc *sc, uint32_t ofs, uint32_t val)
1885 addr = IND_READ_4(sc, sc->sc_ord1 + (ofs << 2));
1886 IND_WRITE_4(sc, addr, val);
1890 iwl2100_rfkilled(struct iwl2100_softc *sc)
1894 if ((sc->sc_caps & IWL2100_C_RFKILL) == 0)
1899 for (i = 0; i < TEST_MAX; ++i) {
1902 if (CSR_READ_4(sc, IWL2100_GPIO) & IWL2100_GPIO_RFKILLED)
1905 if (i != TEST_MAX) {
1906 if_printf(&sc->sc_ic.ic_if, "RF killed\n");
1916 iwl2100_set_addr(struct iwl2100_softc *sc, const uint8_t *eaddr)
1918 struct iwl2100_cmd *cmd;
1921 if (sc->sc_flags & IWL2100_F_WAITCMD) {
1922 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
1926 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
1927 bzero(cmd, sizeof(*cmd));
1929 cmd->c_cmd = IWL2100_CMD_SET_ADDR;
1930 cmd->c_param_len = IEEE80211_ADDR_LEN;
1931 IEEE80211_ADDR_COPY(cmd->c_param, eaddr);
1933 error = iwl2100_wait_cmd(sc);
1935 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
1942 iwl2100_set_opmode(struct iwl2100_softc *sc, enum ieee80211_opmode opmode)
1944 struct iwl2100_cmd *cmd;
1947 if (sc->sc_flags & IWL2100_F_WAITCMD) {
1948 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
1952 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
1953 bzero(cmd, sizeof(cmd));
1955 cmd->c_cmd = IWL2100_CMD_SET_OPMODE;
1956 cmd->c_param_len = sizeof(cmd->c_param[0]);
1958 case IEEE80211_M_STA:
1959 cmd->c_param[0] = IWL2100_OPMODE_STA;
1961 case IEEE80211_M_IBSS:
1962 cmd->c_param[0] = IWL2100_OPMODE_IBSS;
1964 case IEEE80211_M_MONITOR:
1965 /* YYY ipw2100 leave this unset */
1966 cmd->c_param[0] = IWL2100_OPMODE_MONITOR;
1969 panic("unsupported opmode %d\n", opmode);
1973 error = iwl2100_wait_cmd(sc);
1975 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
1982 iwl2100_set_80211(struct iwl2100_softc *sc)
1984 struct ieee80211com *ic = &sc->sc_ic;
1985 struct iwl2100_cmd *cmd;
1988 if (sc->sc_flags & IWL2100_F_WAITCMD) {
1989 if_printf(&ic->ic_if, "there is command pending\n");
1993 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
1994 bzero(cmd, sizeof(cmd));
1996 cmd->c_cmd = IWL2100_CMD_SET_80211;
1997 cmd->c_param_len = sizeof(cmd->c_param[0]) * 3;
1998 cmd->c_param[0] = IWL2100_CFG_IBSS | IWL2100_CFG_STA |
1999 IWL2100_CFG_8021X | IWL2100_CFG_AUTO_PREAMBLE;
2000 if (ic->ic_opmode == IEEE80211_M_IBSS)
2001 cmd->c_param[0] |= IWL2100_CFG_IBSS_AUTO_START;
2002 else if (ic->ic_opmode == IEEE80211_M_MONITOR) /* YYY not ipw2100 */
2003 cmd->c_param[0] |= IWL2100_CFG_MONITOR;
2004 cmd->c_param[1] = IWL2100_CFG_CHANMASK; /* XXX sc->sc_bss_chans */
2005 cmd->c_param[2] = IWL2100_CFG_CHANMASK; /* YYY sc->sc_ibss_chans */
2007 error = iwl2100_wait_cmd(sc);
2009 if_printf(&ic->ic_if, "%s failed\n", __func__);
2016 iwl2100_set_basicrates(struct iwl2100_softc *sc)
2018 struct iwl2100_cmd *cmd;
2021 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2022 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2026 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2027 bzero(cmd, sizeof(cmd));
2030 * This configuration does not seem to have any effects
2031 * on probe-req and assoc-req frames.
2033 cmd->c_cmd = IWL2100_CMD_SET_BASICRATES;
2034 cmd->c_param_len = sizeof(cmd->c_param[0]);
2035 cmd->c_param[0] = 0x3; /* 1Mbps and 2Mbps. XXX from caller */
2037 error = iwl2100_wait_cmd(sc);
2039 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2046 iwl2100_set_txrates(struct iwl2100_softc *sc)
2048 struct ieee80211com *ic = &sc->sc_ic;
2049 struct iwl2100_cmd *cmd;
2053 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2054 if_printf(&ic->ic_if, "there is command pending\n");
2058 /* Calculate TX rate mask. XXX let caller do this */
2059 if (ic->ic_fixed_rate != IEEE80211_FIXED_RATE_NONE)
2060 rate_mask = 1 << ic->ic_fixed_rate;
2062 rate_mask = 0xf; /* all 11b rates */
2063 KKASSERT((rate_mask & ~0xf) == 0);
2068 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2069 bzero(cmd, sizeof(cmd));
2071 cmd->c_cmd = IWL2100_CMD_SET_TXRATES;
2072 cmd->c_param_len = sizeof(cmd->c_param[0]);
2073 cmd->c_param[0] = rate_mask;
2075 error = iwl2100_wait_cmd(sc);
2077 if_printf(&ic->ic_if, "%s failed\n", __func__);
2084 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2085 bzero(cmd, sizeof(cmd));
2087 cmd->c_cmd = IWL2100_CMD_SET_MSDU_TXRATES;
2088 cmd->c_param_len = sizeof(cmd->c_param[0]);
2089 cmd->c_param[0] = rate_mask;
2091 error = iwl2100_wait_cmd(sc);
2093 if_printf(&ic->ic_if, "%s failed\n", __func__);
2100 iwl2100_set_powersave(struct iwl2100_softc *sc, int on)
2102 struct iwl2100_cmd *cmd;
2105 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2106 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2110 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2111 bzero(cmd, sizeof(cmd));
2113 cmd->c_cmd = IWL2100_CMD_SET_POWERSAVE;
2114 cmd->c_param_len = sizeof(cmd->c_param[0]);
2115 cmd->c_param[0] = on; /* XXX power level? */
2117 error = iwl2100_wait_cmd(sc);
2119 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2126 iwl2100_set_rtsthreshold(struct iwl2100_softc *sc, uint16_t rtsthreshold)
2128 struct iwl2100_cmd *cmd;
2131 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2132 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2136 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2137 bzero(cmd, sizeof(cmd));
2139 cmd->c_cmd = IWL2100_CMD_SET_RTSTHRESHOLD;
2140 cmd->c_param_len = sizeof(cmd->c_param[0]);
2141 if (rtsthreshold == IEEE80211_RTS_MAX) {
2142 /* Disable RTS threshold */
2143 cmd->c_param[0] = IWL2100_RTS_MAX;
2145 if (rtsthreshold >= IWL2100_RTS_MAX)
2146 rtsthreshold = IWL2100_RTS_MAX - 1;
2147 cmd->c_param[0] = rtsthreshold;
2150 error = iwl2100_wait_cmd(sc);
2152 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2159 iwl2100_set_bssid(struct iwl2100_softc *sc, const uint8_t *bssid)
2161 struct iwl2100_cmd *cmd;
2164 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2165 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2169 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2170 bzero(cmd, sizeof(cmd));
2172 cmd->c_cmd = IWL2100_CMD_SET_BSSID;
2173 if (bssid != NULL) {
2174 cmd->c_param_len = IEEE80211_ADDR_LEN;
2175 IEEE80211_ADDR_COPY(cmd->c_param, bssid);
2178 error = iwl2100_wait_cmd(sc);
2180 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2187 iwl2100_set_essid(struct iwl2100_softc *sc, const uint8_t *essid, int essid_len)
2189 struct iwl2100_cmd *cmd;
2192 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2193 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2197 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2198 bzero(cmd, sizeof(cmd));
2200 cmd->c_cmd = IWL2100_CMD_SET_ESSID;
2201 if (essid != NULL) {
2202 KKASSERT(essid_len <= sizeof(cmd->c_param));
2203 cmd->c_param_len = essid_len;
2205 bcopy(essid, cmd->c_param, essid_len);
2208 error = iwl2100_wait_cmd(sc);
2210 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2217 iwl2100_set_auth_ciphers(struct iwl2100_softc *sc,
2218 enum ieee80211_authmode authmode)
2220 struct iwl2100_cmdparam_sec *sec;
2221 struct iwl2100_cmd *cmd;
2224 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2225 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2229 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2230 bzero(cmd, sizeof(cmd));
2232 cmd->c_cmd = IWL2100_CMD_SET_SECURITY;
2233 cmd->c_param_len = sizeof(*sec);
2234 sec = (struct iwl2100_cmdparam_sec *)cmd->c_param;
2236 sec->sec_cipher_mask = IWL2100_CIPHER_NONE |
2237 IWL2100_CIPHER_WEP40 |
2238 IWL2100_CIPHER_TKIP |
2239 IWL2100_CIPHER_CCMP |
2240 IWL2100_CIPHER_WEP104;
2241 if (authmode == IEEE80211_AUTH_SHARED)
2242 sec->sec_authmode = IWL2100_AUTH_SHARED;
2244 sec->sec_authmode = IWL2100_AUTH_OPEN;
2246 error = iwl2100_wait_cmd(sc);
2248 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2255 iwl2100_set_wepkey(struct iwl2100_softc *sc, const struct ieee80211_key *k)
2257 struct iwl2100_cmdparam_wepkey *key;
2258 struct iwl2100_cmd *cmd;
2261 if (k->wk_keylen > IWL2100_KEYDATA_SIZE)
2264 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2265 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2269 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2270 bzero(cmd, sizeof(cmd));
2272 cmd->c_cmd = IWL2100_CMD_SET_WEPKEY;
2273 cmd->c_param_len = sizeof(*key);
2274 key = (struct iwl2100_cmdparam_wepkey *)cmd->c_param;
2275 key->key_index = k->wk_keyix;
2276 key->key_len = k->wk_keylen;
2277 bcopy(k->wk_key, key->key_data, key->key_len);
2279 error = iwl2100_wait_cmd(sc);
2281 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2288 iwl2100_set_weptxkey(struct iwl2100_softc *sc, ieee80211_keyix txkey)
2290 struct iwl2100_cmd *cmd;
2293 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2294 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2298 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2299 bzero(cmd, sizeof(cmd));
2301 cmd->c_cmd = IWL2100_CMD_SET_WEPTXKEY;
2302 cmd->c_param_len = sizeof(cmd->c_param[0]);
2303 cmd->c_param[0] = txkey;
2305 error = iwl2100_wait_cmd(sc);
2307 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2314 iwl2100_set_privacy(struct iwl2100_softc *sc, int on)
2316 struct iwl2100_cmd *cmd;
2319 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2320 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2324 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2325 bzero(cmd, sizeof(cmd));
2327 cmd->c_cmd = IWL2100_CMD_SET_PRIVACY;
2328 cmd->c_param_len = sizeof(cmd->c_param[0]);
2329 cmd->c_param[0] = on ? IWL2100_PRIVACY_ENABLE : 0;
2331 error = iwl2100_wait_cmd(sc);
2333 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2340 iwl2100_wait_cmd(struct iwl2100_softc *sc)
2342 struct ifnet *ifp = &sc->sc_ic.ic_if;
2343 struct iwl2100_tx_ring *tr = &sc->sc_txring;
2344 struct mbuf *m = sc->sc_cmd;
2345 struct iwl_dmamap_ctx ctx;
2346 bus_dma_segment_t seg;
2347 struct iwl2100_desc *d;
2348 struct iwl2100_txbuf *tb;
2351 ASSERT_SERIALIZED(ifp->if_serializer);
2353 KKASSERT(tr->tr_index < IWL2100_TX_NDESC);
2354 tb = &tr->tr_buf[tr->tr_index];
2358 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, tb->tb_dmap, m,
2359 iwl_dma_buf_addr, &ctx, BUS_DMA_WAITOK);
2360 if (error || ctx.nsegs == 0) {
2362 bus_dmamap_unload(sc->sc_mbuf_dtag, tb->tb_dmap);
2364 if_printf(ifp, "too many segments?!\n");
2367 if_printf(ifp, "can't load RX mbuf\n");
2370 tb->tb_mbuf = sc->sc_cmd;
2371 tb->tb_flags |= IWL2100_TBF_CMDBUF;
2373 d = &tr->tr_desc[tr->tr_index];
2374 d->d_paddr = seg.ds_addr;
2375 d->d_len = sizeof(struct iwl2100_cmd);
2377 d->d_flags = IWL2100_TXD_F_INTR | IWL2100_TXD_F_CMD;
2379 KKASSERT(tr->tr_used < IWL2100_TX_NDESC);
2381 tr->tr_index = (tr->tr_index + 1) % IWL2100_TX_NDESC;
2383 bus_dmamap_sync(tr->tr_dtag, tr->tr_dmap, BUS_DMASYNC_PREWRITE);
2385 CSR_WRITE_4(sc, IWL2100_TXQ_WRITE_IDX, tr->tr_index);
2387 if (sc->sc_flags & IWL2100_F_IN_INTR)
2388 panic("sleep in interrupt thread\n");
2390 sc->sc_flags |= IWL2100_F_WAITCMD;
2391 error = zsleep(sc, ifp->if_serializer, 0, "iwlcmd", 2 * hz);
2393 sc->sc_flags &= ~IWL2100_F_WAITCMD;
2394 if (sc->sc_flags & IWL2100_F_ERROR) {
2395 if_printf(ifp, "error happened when waiting "
2396 "command to be done\n");
2404 iwl2100_rxeof(struct iwl2100_softc *sc)
2406 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
2407 struct ifnet *ifp = &sc->sc_ic.ic_if;
2410 hwidx = CSR_READ_4(sc, IWL2100_RXQ_READ_IDX);
2411 CSR_READ_4(sc, IWL2100_RXQ_WRITE_IDX);
2413 if (hwidx >= IWL2100_RX_NDESC) {
2414 if_printf(ifp, "invalid hardware RX index %d\n", hwidx);
2418 KKASSERT(rr->rr_index < IWL2100_RX_NDESC);
2419 i = (rr->rr_index + 1) % IWL2100_RX_NDESC;
2420 while (hwidx != i) {
2421 struct iwl2100_rx_status *st = &rr->rr_status[i];
2422 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
2425 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap,
2426 BUS_DMASYNC_POSTREAD);
2427 frame_type = st->r_status & IWL2100_RXS_TYPE_MASK;
2429 bus_dmamap_sync(sc->sc_mbuf_dtag, rb->rb_dmap,
2430 BUS_DMASYNC_POSTREAD);
2431 switch (frame_type) {
2432 case IWL2100_RXS_TYPE_CMD:
2433 iwl2100_rxeof_cmd(sc, i);
2436 case IWL2100_RXS_TYPE_STATUS:
2437 iwl2100_rxeof_status(sc, i);
2440 case IWL2100_RXS_TYPE_NOTE:
2441 iwl2100_rxeof_note(sc, i);
2444 case IWL2100_RXS_TYPE_DATA:
2445 case IWL2100_RXS_TYPE_DATA1:
2446 iwl2100_rxeof_data(sc, i);
2450 if_printf(ifp, "unknown frame type: %d\n", frame_type);
2451 iwl2100_rxdesc_setup(sc, i);
2454 i = (i + 1) % IWL2100_RX_NDESC;
2456 bus_dmamap_sync(rr->rr_st_dtag, rr->rr_st_dmap, BUS_DMASYNC_POSTREAD);
2457 bus_dmamap_sync(rr->rr_dtag, rr->rr_dmap, BUS_DMASYNC_POSTREAD);
2460 rr->rr_index = IWL2100_RX_NDESC - 1;
2462 rr->rr_index = i - 1;
2463 CSR_WRITE_4(sc, IWL2100_RXQ_WRITE_IDX, rr->rr_index);
2467 iwl2100_txeof(struct iwl2100_softc *sc)
2469 struct iwl2100_tx_ring *tr = &sc->sc_txring;
2470 struct ifnet *ifp = &sc->sc_ic.ic_if;
2473 hwidx = CSR_READ_4(sc, IWL2100_TXQ_READ_IDX);
2474 CSR_READ_4(sc, IWL2100_TXQ_WRITE_IDX);
2475 if (hwidx >= IWL2100_TX_NDESC) {
2476 if_printf(ifp, "invalid hardware TX index %d\n", hwidx);
2480 KKASSERT(tr->tr_coll < IWL2100_TX_NDESC);
2481 while (tr->tr_used) {
2482 struct iwl2100_txbuf *tb;
2484 if (tr->tr_coll == hwidx)
2487 tb = &tr->tr_buf[tr->tr_coll];
2488 if (tb->tb_mbuf == NULL)
2491 bus_dmamap_unload(sc->sc_mbuf_dtag, tb->tb_dmap);
2492 if (tb->tb_flags & IWL2100_TBF_CMDBUF) {
2493 tb->tb_flags &= ~IWL2100_TBF_CMDBUF;
2494 KKASSERT(tb->tb_mbuf == sc->sc_cmd);
2496 m_freem(tb->tb_mbuf);
2500 tr->tr_coll = (tr->tr_coll + 1) % IWL2100_TX_NDESC;
2502 KKASSERT(tr->tr_used > 0);
2506 if (tr->tr_used < IWL2100_TX_USED_MAX) {
2507 if (tr->tr_used == 0) {
2508 KKASSERT(tr->tr_coll == tr->tr_index);
2509 sc->sc_tx_timer = 0;
2512 ifp->if_flags &= ~IFF_OACTIVE;
2518 iwl2100_config(struct iwl2100_softc *sc, const uint8_t *bssid,
2519 const uint8_t *essid, uint8_t esslen, int ibss_chan)
2521 struct ieee80211com *ic = &sc->sc_ic;
2522 struct ifnet *ifp = &ic->ic_if;
2525 if (ic->ic_opmode == IEEE80211_M_MONITOR) {
2526 error = iwl2100_set_chan(sc, ic->ic_curchan);
2528 if_printf(ifp, "can't set mon channel\n");
2533 IEEE80211_ADDR_COPY(ic->ic_myaddr, IF_LLADDR(ifp));
2534 error = iwl2100_set_addr(sc, ic->ic_myaddr);
2536 if_printf(ifp, "can't set MAC address\n");
2540 error = iwl2100_set_opmode(sc, ic->ic_opmode);
2542 if_printf(ifp, "can't set opmode\n");
2547 KKASSERT(ic->ic_opmode == IEEE80211_M_IBSS);
2548 error = iwl2100_set_chan(sc, ic->ic_curchan);
2550 if_printf(ifp, "can't set ibss channel\n");
2555 error = iwl2100_set_80211(sc);
2557 if_printf(ifp, "can't set 802.11 config\n");
2561 error = iwl2100_set_basicrates(sc);
2563 if_printf(ifp, "can't set basicrates\n");
2567 error = iwl2100_set_txrates(sc);
2569 if_printf(ifp, "can't set TX rates\n");
2573 error = iwl2100_set_powersave(sc, ic->ic_flags & IEEE80211_F_PMGTON);
2575 if_printf(ifp, "can't turn off powersave\n");
2579 error = iwl2100_set_rtsthreshold(sc, ic->ic_rtsthreshold);
2581 if_printf(ifp, "can't set RTS threshold\n");
2585 error = iwl2100_set_bssid(sc, bssid);
2587 if_printf(ifp, "can't set bssid\n");
2591 error = iwl2100_set_essid(sc, essid, esslen);
2593 if_printf(ifp, "can't set essid\n");
2597 error = iwl2100_set_auth_ciphers(sc, ic->ic_bss->ni_authmode);
2599 if_printf(ifp, "can't set authmode and ciphers\n");
2603 if (ic->ic_flags & IEEE80211_F_PRIVACY) {
2604 ieee80211_keyix txkey = IEEE80211_KEYIX_NONE;
2607 for (i = 0; i < IEEE80211_WEP_NKID; ++i) {
2608 const struct ieee80211_key *k = &ic->ic_nw_keys[i];
2610 if (k->wk_keyix == IEEE80211_KEYIX_NONE)
2613 error = iwl2100_set_wepkey(sc, k);
2614 if (error == E2BIG) {
2617 if_printf(ifp, "can't set wepkey\n");
2620 txkey = k->wk_keyix;
2623 if (txkey != IEEE80211_KEYIX_NONE) {
2625 * Found some valid WEP keys.
2627 * If WEP TX key index from 802.11 layer is not
2628 * set, then use the first valid WEP key as TX
2631 if (ic->ic_def_txkey != IEEE80211_KEYIX_NONE)
2632 txkey = ic->ic_def_txkey;
2634 error = iwl2100_set_weptxkey(sc, txkey);
2636 if_printf(ifp, "can't set weptxkey\n");
2642 error = iwl2100_set_privacy(sc, ic->ic_flags & IEEE80211_F_PRIVACY);
2644 if_printf(ifp, "can't set privacy\n");
2648 error = iwl2100_set_optie(sc, ic->ic_opt_ie, ic->ic_opt_ie_len);
2650 if (error != E2BIG) {
2651 if_printf(ifp, "can't set opt ie\n");
2656 if (ic->ic_opmode == IEEE80211_M_IBSS) {
2657 error = iwl2100_set_bintval(sc, ic->ic_bss->ni_intval);
2659 if_printf(ifp, "can't set bintval\n");
2663 error = iwl2100_set_txpower(sc, 32 /* XXX */);
2665 if_printf(ifp, "can't set txpwr\n");
2673 iwl2100_config_op(struct iwl2100_softc *sc, uint32_t op)
2675 struct iwl2100_cmd *cmd;
2678 KASSERT(op == IWL2100_CMD_CONF_DONE || op == IWL2100_CMD_CONF_START,
2679 ("unknown config_op %u", op));
2681 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2682 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2686 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2687 bzero(cmd, sizeof(cmd));
2690 error = iwl2100_wait_cmd(sc);
2692 if_printf(&sc->sc_ic.ic_if, "%s(%u) failed\n", __func__, op);
2696 iwl2100_read_ord1(sc, IWL2100_ORD1_CONF_START); /* dummy read */
2701 iwl2100_set_chan(struct iwl2100_softc *sc, const struct ieee80211_channel *c)
2703 struct ieee80211com *ic = &sc->sc_ic;
2704 struct iwl2100_cmd *cmd;
2708 KKASSERT(ic->ic_opmode != IEEE80211_M_STA);
2710 chan = ieee80211_chan2ieee(ic, c);
2711 if (chan == IEEE80211_CHAN_ANY) {
2712 if_printf(&ic->ic_if, "invalid channel!\n");
2716 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2717 if_printf(&ic->ic_if, "there is command pending\n");
2721 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2722 bzero(cmd, sizeof(cmd));
2724 cmd->c_cmd = IWL2100_CMD_SET_CHAN;
2725 cmd->c_param_len = sizeof(cmd->c_param[0]);
2726 cmd->c_param[0] = chan;
2728 error = iwl2100_wait_cmd(sc);
2730 if_printf(&ic->ic_if, "%s failed\n", __func__);
2737 iwl2100_set_scanopt(struct iwl2100_softc *sc, uint32_t chans, uint32_t flags)
2739 struct ieee80211com *ic = &sc->sc_ic;
2740 struct iwl2100_cmd *cmd;
2743 KKASSERT(ic->ic_opmode != IEEE80211_M_MONITOR);
2745 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2746 if_printf(&ic->ic_if, "there is command pending\n");
2750 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2751 bzero(cmd, sizeof(cmd));
2755 * 1) IWL2100_SCANOPT_NOASSOC is ignored by firmware, but same
2756 * function could be achieved by clearing bssid.
2757 * 2) Channel mask is ignored by firmware, if NIC is in STA opmode.
2759 * We leave the correct configuration here just with the hope
2760 * that one day firmware could do better.
2762 cmd->c_cmd = IWL2100_CMD_SET_SCANOPT;
2763 cmd->c_param_len = sizeof(cmd->c_param[0]) * 2;
2764 cmd->c_param[0] = flags | IWL2100_SCANOPT_MIXED;
2765 cmd->c_param[1] = chans;
2767 error = iwl2100_wait_cmd(sc);
2769 if_printf(&ic->ic_if, "%s failed\n", __func__);
2776 iwl2100_set_scan(struct iwl2100_softc *sc)
2778 struct ieee80211com *ic = &sc->sc_ic;
2779 struct iwl2100_cmd *cmd;
2782 KKASSERT(ic->ic_opmode != IEEE80211_M_MONITOR);
2784 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2785 if_printf(&ic->ic_if, "there is command pending\n");
2789 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2790 bzero(cmd, sizeof(cmd));
2792 cmd->c_cmd = IWL2100_CMD_SCAN;
2793 cmd->c_param_len = sizeof(cmd->c_param[0]);
2795 error = iwl2100_wait_cmd(sc);
2797 if_printf(&ic->ic_if, "%s failed\n", __func__);
2804 iwl2100_set_optie(struct iwl2100_softc *sc, void *optie, uint16_t optie_len)
2806 struct iwl2100_cmd *cmd;
2807 struct iwl2100_cmdparam_ie *ie;
2810 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2811 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2815 if (optie_len > IWL2100_OPTIE_MAX) {
2816 if_printf(&sc->sc_ic.ic_if, "optie too long\n");
2820 if (optie == NULL || optie_len == 0)
2823 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2824 bzero(cmd, sizeof(cmd));
2826 cmd->c_cmd = IWL2100_CMD_SET_IE;
2827 cmd->c_param_len = sizeof(*ie);
2828 ie = (struct iwl2100_cmdparam_ie *)cmd->c_param;
2829 ie->ie_optlen = optie_len;
2830 bcopy(optie, ie->ie_opt, optie_len);
2832 error = iwl2100_wait_cmd(sc);
2834 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2841 iwl2100_set_bintval(struct iwl2100_softc *sc, uint16_t bintval)
2843 struct iwl2100_cmd *cmd;
2846 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2847 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2851 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2852 bzero(cmd, sizeof(cmd));
2854 cmd->c_cmd = IWL2100_CMD_SET_BINTVAL;
2855 cmd->c_param_len = sizeof(cmd->c_param[0]);
2856 cmd->c_param[0] = bintval;
2858 error = iwl2100_wait_cmd(sc);
2860 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2867 iwl2100_set_txpower(struct iwl2100_softc *sc, uint16_t txpower)
2869 struct iwl2100_cmd *cmd;
2872 if (sc->sc_flags & IWL2100_F_WAITCMD) {
2873 if_printf(&sc->sc_ic.ic_if, "there is command pending\n");
2877 cmd = mtod(sc->sc_cmd, struct iwl2100_cmd *);
2878 bzero(cmd, sizeof(cmd));
2880 cmd->c_cmd = IWL2100_CMD_SET_TXPOWER;
2881 cmd->c_param_len = sizeof(cmd->c_param[0]);
2882 cmd->c_param[0] = txpower;
2884 error = iwl2100_wait_cmd(sc);
2886 if_printf(&sc->sc_ic.ic_if, "%s failed\n", __func__);
2893 iwl2100_rxeof_status(struct iwl2100_softc *sc, int i)
2895 struct ieee80211com *ic = &sc->sc_ic;
2896 struct ifnet *ifp = &ic->ic_if;
2897 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
2898 struct iwl2100_rx_status *st = &rr->rr_status[i];
2899 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
2900 struct mbuf *m = rb->rb_mbuf;
2903 if (st->r_len != sizeof(status)) {
2904 if_printf(ifp, "invalid status frame len %u\n", st->r_len);
2908 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2911 if ((ic->ic_flags & IEEE80211_F_SCAN) == 0)
2912 sc->sc_flags &= ~IWL2100_F_SCANNING;
2914 status = *mtod(m, uint32_t *);
2915 DPRINTF(sc, IWL2100_DBG_STATUS, "status 0x%08x\n", status);
2918 case IWL2100_STATUS_SCANDONE:
2919 if (ic->ic_flags & IEEE80211_F_SCAN) {
2921 * To make sure that firmware has iterated all
2922 * of the channels, we wait for the second scan
2923 * done status change.
2925 if (sc->sc_flags & IWL2100_F_SCANNING) {
2926 iwlmsg_send(&sc->sc_scanend_msg,
2927 &sc->sc_thread_port);
2929 sc->sc_flags |= IWL2100_F_SCANNING;
2934 case IWL2100_STATUS_RUNNING:
2935 iwl2100_restart_done(sc);
2936 if (ic->ic_state == IEEE80211_S_ASSOC) {
2937 KKASSERT(ic->ic_opmode == IEEE80211_M_STA);
2938 iwlmsg_send(&sc->sc_run_msg, &sc->sc_thread_port);
2939 } else if (ic->ic_state == IEEE80211_S_RUN) {
2940 if (ic->ic_opmode == IEEE80211_M_STA) {
2941 DPRINTF(sc, IWL2100_DBG_RESTART, "%s",
2943 sc->sc_flags |= IWL2100_F_IFSTART;
2946 KKASSERT(ic->ic_opmode == IEEE80211_M_IBSS);
2947 callout_reset(&sc->sc_ibss, (100 * hz) / 1000,
2948 iwl2100_ibss_bssid, sc);
2953 case IWL2100_STATUS_BMISS:
2954 if (ic->ic_opmode == IEEE80211_M_STA) {
2955 DPRINTF(sc, IWL2100_DBG_SCAN, "%s", "bmiss\n");
2956 iwlmsg_send(&sc->sc_bmiss_msg, &sc->sc_thread_port);
2960 case IWL2100_STATUS_SCANNING:
2961 if (ic->ic_opmode == IEEE80211_M_STA &&
2962 ic->ic_state == IEEE80211_S_RUN) {
2963 /* Firmware error happens */
2964 iwl2100_restart(sc);
2969 iwl2100_rxdesc_setup(sc, i);
2973 iwl2100_rxeof_note(struct iwl2100_softc *sc, int i)
2975 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
2976 struct iwl2100_rx_status *st = &rr->rr_status[i];
2977 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
2978 struct mbuf *m = rb->rb_mbuf;
2979 struct ieee80211com *ic = &sc->sc_ic;
2980 struct iwl2100_note *note;
2982 if (st->r_len < sizeof(*note)) {
2983 if_printf(&ic->ic_if, "invalid note frame len %u\n", st->r_len);
2987 if (ic->ic_opmode == IEEE80211_M_MONITOR)
2990 note = mtod(m, struct iwl2100_note *);
2991 DPRINTF(sc, IWL2100_DBG_NOTE, "note subtype %u, size %u\n",
2992 note->nt_subtype, note->nt_size);
2994 if (note->nt_subtype == 19 /* XXX */ &&
2995 ic->ic_state == IEEE80211_S_AUTH) {
2996 KKASSERT(ic->ic_opmode == IEEE80211_M_STA);
2997 iwlmsg_send(&sc->sc_assoc_msg, &sc->sc_thread_port);
3000 iwl2100_rxdesc_setup(sc, i);
3004 iwl2100_rxeof_cmd(struct iwl2100_softc *sc, int i)
3006 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
3007 struct iwl2100_rx_status *st = &rr->rr_status[i];
3008 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
3009 struct mbuf *m = rb->rb_mbuf;
3010 struct iwl2100_cmd *cmd;
3012 if (st->r_len != sizeof(*cmd)) {
3013 if_printf(&sc->sc_ic.ic_if,
3014 "invalid cmd done frame len %u\n", st->r_len);
3018 cmd = mtod(m, struct iwl2100_cmd *);
3019 DPRINTF(sc, IWL2100_DBG_CMD, "cmd %u\n", cmd->c_cmd);
3020 if (cmd->c_cmd == 0)
3021 sc->sc_flags |= IWL2100_F_ZERO_CMD;
3024 iwl2100_rxdesc_setup(sc, i);
3028 iwl2100_rxeof_data(struct iwl2100_softc *sc, int i)
3030 struct ieee80211com *ic = &sc->sc_ic;
3031 struct ifnet *ifp = &ic->ic_if;
3032 struct iwl2100_rx_ring *rr = &sc->sc_rxring;
3033 struct iwl2100_rx_status *st = &rr->rr_status[i];
3034 struct iwl2100_rxbuf *rb = &rr->rr_buf[i];
3035 struct mbuf *m = rb->rb_mbuf;
3036 struct ieee80211_frame_min *wh;
3037 struct ieee80211_node *ni;
3038 int frame_len, rssi;
3039 const struct ieee80211_channel *c;
3042 * Gather all necessary information from status ring _here_,
3043 * since the following iwl2100_newbuf() will clear them out.
3046 frame_len = st->r_len;
3048 if (iwl2100_newbuf(sc, i, 0)) {
3055 m->m_pkthdr.rcvif = ifp;
3056 m->m_len = m->m_pkthdr.len = frame_len;
3058 wh = mtod(m, struct ieee80211_frame_min *);
3059 ni = ieee80211_find_rxnode(ic, wh);
3064 if (sc->sc_drvbpf != NULL) {
3065 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3066 sc->sc_rx_th.wr_flags = IEEE80211_RADIOTAP_F_WEP;
3068 sc->sc_rx_th.wr_flags = 0;
3070 sc->sc_rx_th.wr_antsignal = rssi + IWL2100_NOISE_FLOOR;
3071 sc->sc_rx_th.wr_antnoise = IWL2100_NOISE_FLOOR;
3073 bpf_ptap(sc->sc_drvbpf, m, &sc->sc_rx_th, sc->sc_rx_th_len);
3076 ieee80211_input(ic, m, ni, rssi, 0);
3077 ieee80211_free_node(ni);
3079 if (c != ic->ic_curchan) /* Happen during scanning */
3080 iwl2100_chan_change(sc, ic->ic_curchan);
3084 iwl2100_scanend_dispatch(struct netmsg *nmsg)
3086 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3087 struct iwl2100_softc *sc = msg->iwlm_softc;
3088 struct ieee80211com *ic = &sc->sc_ic;
3089 struct ifnet *ifp = &ic->ic_if;
3091 ASSERT_SERIALIZED(ifp->if_serializer);
3093 if (sc->sc_flags & IWL2100_F_DETACH)
3096 if (ifp->if_flags & IFF_RUNNING) {
3097 ieee80211_end_scan(ic);
3098 sc->sc_flags &= ~IWL2100_F_SCANNING;
3101 lwkt_replymsg(&nmsg->nm_lmsg, 0);
3105 iwl2100_hw_init(struct iwl2100_softc *sc, const uint8_t *bssid,
3106 const uint8_t *essid, uint8_t esslen, uint32_t flags)
3108 struct ieee80211com *ic = &sc->sc_ic;
3109 struct ifnet *ifp = &ic->ic_if;
3113 ASSERT_SERIALIZED(ifp->if_serializer);
3114 KKASSERT(curthread == &sc->sc_thread);
3116 iwl2100_hw_stop(sc);
3118 error = iwl2100_alloc_firmware(sc, ic->ic_opmode);
3120 if_printf(ifp, "can't allocate firmware\n");
3124 error = iwl2100_load_firmware(sc, ic->ic_opmode);
3126 if_printf(ifp, "can't load firmware\n");
3130 error = iwl2100_alloc_cmd(sc);
3132 if_printf(ifp, "can't allocate cmd\n");
3136 error = iwl2100_init_tx_ring(sc);
3138 if_printf(ifp, "can't init TX ring\n");
3142 error = iwl2100_init_rx_ring(sc);
3144 if_printf(ifp, "can't init RX ring\n");
3148 error = iwl2100_init_firmware(sc);
3150 if_printf(ifp, "can't initialize firmware\n");
3154 sc->sc_ord1 = CSR_READ_4(sc, IWL2100_ORD1_ADDR);
3155 sc->sc_ord2 = CSR_READ_4(sc, IWL2100_ORD2_ADDR);
3157 db_addr = iwl2100_read_ord1(sc, IWL2100_ORD1_DBADDR);
3158 if ((IND_READ_4(sc, db_addr + 0x20) >> 24) & 0x1)
3159 sc->sc_caps &= ~IWL2100_C_RFKILL;
3161 sc->sc_caps |= IWL2100_C_RFKILL;
3163 /* Unlock firmware */
3164 iwl2100_write_ord1(sc, IWL2100_ORD1_FWLOCK, 0);
3166 if (iwl2100_rfkilled(sc)) {
3171 /* Let interrupt handler run */
3172 sc->sc_flags |= IWL2100_F_INITED;
3174 /* Enable interrupts */
3175 CSR_WRITE_4(sc, IWL2100_INTR_MASK, IWL2100_INTRS);
3177 error = iwl2100_config(sc, bssid, essid, esslen,
3178 flags & IWL2100_INIT_F_IBSSCHAN);
3182 if (flags & IWL2100_INIT_F_ENABLE) {
3183 error = iwl2100_config_done(sc);
3185 if_printf(ifp, "can't complete config\n");
3190 ifp->if_flags &= ~IFF_OACTIVE;
3191 ifp->if_flags |= IFF_RUNNING;
3199 iwl2100_start_scan(struct iwl2100_softc *sc, uint32_t chans, uint32_t flags)
3205 * Firmware always starts scanning once config is done
3207 error = iwl2100_set_scanopt(sc, chans, flags);
3209 if_printf(&sc->sc_ic.ic_if, "can't set scan opt\n");
3213 error = iwl2100_set_scan(sc);
3215 if_printf(&sc->sc_ic.ic_if, "can't set bcast scanning\n");
3222 iwl2100_scan(struct iwl2100_softc *sc)
3224 struct ieee80211com *ic = &sc->sc_ic;
3225 uint32_t chans, flags;
3228 KKASSERT(ic->ic_opmode != IEEE80211_M_MONITOR);
3230 error = iwl2100_hw_init(sc, NULL,
3231 ic->ic_des_essid, ic->ic_des_esslen, IWL2100_INIT_F_ENABLE);
3235 if (ic->ic_opmode == IEEE80211_M_STA) {
3236 chans = sc->sc_bss_chans;
3237 flags = IWL2100_SCANOPT_NOASSOC;
3240 * Normally # of IBSS channels is less than BSS's
3241 * but it seems IBSS mode works on all BSS channels
3244 chans = sc->sc_ibss_chans;
3246 chans = sc->sc_bss_chans;
3249 * Don't set NOASSOC scan option, it seems that
3250 * firmware will disable itself after scanning
3251 * if this flag is set. After all, we are in
3252 * IBSS mode, which does not have concept of
3258 /* See NOTE in iwl2100_set_scanopt() */
3259 error = iwl2100_start_scan(sc, chans, flags);
3266 iwl2100_auth(struct iwl2100_softc *sc)
3268 struct ieee80211com *ic = &sc->sc_ic;
3269 struct ieee80211_node *ni = ic->ic_bss;
3273 KKASSERT(ic->ic_opmode == IEEE80211_M_STA);
3275 chan = ieee80211_chan2ieee(ic, ic->ic_curchan);
3276 if (chan == IEEE80211_CHAN_ANY) {
3277 if_printf(&ic->ic_if, "invalid curchan\n");
3281 error = iwl2100_hw_init(sc, ni->ni_bssid,
3282 ni->ni_essid, ni->ni_esslen, IWL2100_INIT_F_ENABLE);
3286 /* See NOTE in iwl2100_set_scanopt() */
3287 error = iwl2100_start_scan(sc, 1 << (chan - 1), 0);
3294 iwl2100_ibss(struct iwl2100_softc *sc)
3296 struct ieee80211com *ic = &sc->sc_ic;
3297 struct ieee80211_node *ni = ic->ic_bss;
3299 return iwl2100_hw_init(sc, ni->ni_bssid,
3300 ni->ni_essid, ni->ni_esslen,
3301 IWL2100_INIT_F_ENABLE | IWL2100_INIT_F_IBSSCHAN);
3305 iwl2100_encap(struct iwl2100_softc *sc, struct mbuf *m)
3307 struct iwl2100_tx_ring *tr = &sc->sc_txring;
3308 struct iwl2100_tx_hdr *th;
3309 struct ieee80211_frame *wh;
3310 struct iwl_dmamap_ctx ctx;
3311 bus_dma_segment_t segs[IWL2100_NSEG_MAX];
3312 uint8_t src[IEEE80211_ADDR_LEN], dst[IEEE80211_ADDR_LEN];
3314 int maxsegs, i, first_idx, last_idx, error, host_enc;
3317 * Save necessary information and strip 802.11 header
3319 wh = mtod(m, struct ieee80211_frame *);
3320 IEEE80211_ADDR_COPY(src, wh->i_addr2);
3321 if (sc->sc_ic.ic_opmode == IEEE80211_M_STA)
3322 IEEE80211_ADDR_COPY(dst, wh->i_addr3);
3324 IEEE80211_ADDR_COPY(dst, wh->i_addr1);
3325 if (wh->i_fc[1] & IEEE80211_FC1_WEP)
3329 m_adj(m, sizeof(*wh));
3332 * Prepend and setup hardware TX header
3334 M_PREPEND(m, sizeof(*th), MB_DONTWAIT);
3336 if_printf(&sc->sc_ic.ic_if, "prepend TX header failed\n");
3339 th = mtod(m, struct iwl2100_tx_hdr *);
3341 bzero(th, sizeof(*th));
3342 th->th_cmd = IWL2100_CMD_TX_DATA;
3343 th->th_host_enc = host_enc;
3344 IEEE80211_ADDR_COPY(th->th_src, src);
3345 IEEE80211_ADDR_COPY(th->th_dst, dst);
3348 * Load mbuf into DMA map
3350 maxsegs = IWL2100_TX_USED_MAX - tr->tr_used;
3351 if (maxsegs > IWL2100_NSEG_MAX)
3352 maxsegs = IWL2100_NSEG_MAX;
3354 KKASSERT(tr->tr_index < IWL2100_TX_NDESC);
3355 first_idx = tr->tr_index;
3356 dmap = tr->tr_buf[first_idx].tb_dmap;
3358 ctx.nsegs = maxsegs;
3360 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, dmap, m,
3361 iwl_dma_buf_addr, &ctx, BUS_DMA_NOWAIT);
3362 if (!error && ctx.nsegs == 0) {
3363 bus_dmamap_unload(sc->sc_mbuf_dtag, dmap);
3366 if (error && error != EFBIG) {
3367 if_printf(&sc->sc_ic.ic_if, "can't load TX mbuf, error %d\n",
3371 if (error) { /* error == EFBIG */
3374 m_new = m_defrag(m, MB_DONTWAIT);
3375 if (m_new == NULL) {
3376 if_printf(&sc->sc_ic.ic_if, "can't defrag TX mbuf\n");
3383 ctx.nsegs = maxsegs;
3385 error = bus_dmamap_load_mbuf(sc->sc_mbuf_dtag, dmap, m,
3386 iwl_dma_buf_addr, &ctx,
3388 if (error || ctx.nsegs == 0) {
3389 if (ctx.nsegs == 0) {
3390 bus_dmamap_unload(sc->sc_mbuf_dtag, dmap);
3393 if_printf(&sc->sc_ic.ic_if,
3394 "can't load defraged TX mbuf\n");
3398 bus_dmamap_sync(sc->sc_mbuf_dtag, dmap, BUS_DMASYNC_PREWRITE);
3404 for (i = 0; i < ctx.nsegs; ++i) {
3405 struct iwl2100_desc *d = &tr->tr_desc[tr->tr_index];
3407 d->d_paddr = segs[i].ds_addr;
3408 d->d_len = segs[i].ds_len;
3412 d->d_nfrag = ctx.nsegs;
3414 if (i == ctx.nsegs - 1) {
3415 d->d_flags = IWL2100_TXD_F_INTR;
3416 last_idx = tr->tr_index;
3418 d->d_flags = IWL2100_TXD_F_NOTLAST;
3421 tr->tr_index = (tr->tr_index + 1) % IWL2100_TX_NDESC;
3423 KKASSERT(last_idx >= 0);
3425 tr->tr_buf[first_idx].tb_dmap = tr->tr_buf[last_idx].tb_dmap;
3426 tr->tr_buf[last_idx].tb_dmap = dmap;
3427 tr->tr_buf[last_idx].tb_mbuf = m;
3429 tr->tr_used += ctx.nsegs;
3430 KKASSERT(tr->tr_used <= IWL2100_TX_USED_MAX);
3440 iwl2100_restart_dispatch(struct netmsg *nmsg)
3442 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3443 struct iwl2100_softc *sc = msg->iwlm_softc;
3444 struct ieee80211com *ic = &sc->sc_ic;
3445 struct ifnet *ifp = &ic->ic_if;
3448 ASSERT_SERIALIZED(ifp->if_serializer);
3450 if (sc->sc_flags & IWL2100_F_DETACH)
3453 if ((ifp->if_flags & IFF_RUNNING) == 0)
3456 if (msg->iwlm_arg != sc->sc_state_age) {
3458 * Restarting was triggered in old 802.11 state
3459 * Don't do anything, this is a staled restarting.
3464 if (ic->ic_state != IEEE80211_S_RUN) {
3465 if_printf(ifp, "restart happened when not in RUN state\n");
3470 * iwl2100_auth() may release slizer, so stop all
3471 * callouts to prevent them from misfiring.
3473 callout_stop(&sc->sc_restart_bmiss);
3474 callout_stop(&sc->sc_ibss);
3476 if (ic->ic_opmode == IEEE80211_M_STA) {
3477 error = iwl2100_auth(sc);
3482 * Start software beacon missing to handle missing
3483 * firmware bmiss status change when we restarting
3485 callout_reset(&sc->sc_restart_bmiss, IEEE80211_TU_TO_TICKS(
3486 2 * ic->ic_bmissthreshold * ic->ic_bss->ni_intval),
3487 iwl2100_restart_bmiss, sc);
3488 } else if (ic->ic_opmode == IEEE80211_M_IBSS) {
3489 error = iwl2100_ibss(sc);
3494 /* Turn on restarting flag before reply this message */
3495 sc->sc_flags |= IWL2100_F_RESTARTING;
3497 lwkt_replymsg(&nmsg->nm_lmsg, error);
3501 iwl2100_restart(struct iwl2100_softc *sc)
3503 if ((sc->sc_flags & (IWL2100_F_RESTARTING | IWL2100_F_DETACH)) == 0) {
3504 struct iwlmsg *msg = &sc->sc_restart_msg;
3505 struct lwkt_msg *lmsg = &msg->iwlm_nmsg.nm_lmsg;
3507 DPRINTF(sc, IWL2100_DBG_RESTART, "%s", "restart\n");
3508 if (lmsg->ms_flags & MSGF_DONE) {
3509 sc->sc_flags &= ~IWL2100_F_IFSTART;
3510 msg->iwlm_arg = sc->sc_state_age;
3511 lwkt_sendmsg(&sc->sc_thread_port, lmsg);
3517 iwl2100_bmiss_dispatch(struct netmsg *nmsg)
3519 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3520 struct iwl2100_softc *sc = msg->iwlm_softc;
3521 struct ieee80211com *ic = &sc->sc_ic;
3522 struct ifnet *ifp = &ic->ic_if;
3524 ASSERT_SERIALIZED(ifp->if_serializer);
3526 if (sc->sc_flags & IWL2100_F_DETACH)
3529 if (ifp->if_flags & IFF_RUNNING) {
3531 * Fake a ic_bmiss_count to make sure that
3532 * ieee80211_beacon_miss() will do its job
3534 ic->ic_bmiss_count = ic->ic_bmiss_max;
3535 ieee80211_beacon_miss(ic);
3538 lwkt_replymsg(&nmsg->nm_lmsg, 0);
3542 iwl2100_restart_bmiss(void *xsc)
3544 struct iwl2100_softc *sc = xsc;
3545 struct ifnet *ifp = &sc->sc_ic.ic_if;
3547 lwkt_serialize_enter(ifp->if_serializer);
3549 if (sc->sc_flags & IWL2100_F_DETACH)
3552 if ((ifp->if_flags & IFF_RUNNING) == 0)
3555 if (sc->sc_flags & IWL2100_F_RESTARTING) {
3556 DPRINTF(sc, IWL2100_DBG_SCAN | IWL2100_DBG_RESTART, "%s",
3558 iwlmsg_send(&sc->sc_bmiss_msg, &sc->sc_thread_port);
3561 lwkt_serialize_exit(ifp->if_serializer);
3565 iwl2100_ibss_bssid(void *xsc)
3567 struct iwl2100_softc *sc = xsc;
3568 struct ieee80211com *ic = &sc->sc_ic;
3569 struct ifnet *ifp = &ic->ic_if;
3571 lwkt_serialize_enter(ifp->if_serializer);
3573 if (sc->sc_flags & IWL2100_F_DETACH)
3576 if ((ifp->if_flags & IFF_RUNNING) == 0)
3579 if (ic->ic_state == IEEE80211_S_RUN &&
3580 ic->ic_opmode == IEEE80211_M_IBSS) {
3581 uint8_t bssid[IEEE80211_ADDR_LEN];
3584 len = iwl2100_read_ord2(sc, IWL2100_ORD2_BSSID,
3585 bssid, sizeof(bssid));
3586 if (len < (int)sizeof(bssid)) {
3587 if_printf(ifp, "can't get IBSS bssid\n");
3589 DPRINTF(sc, IWL2100_DBG_IBSS, "IBSS bssid: %6D\n",
3591 IEEE80211_ADDR_COPY(ic->ic_bss->ni_bssid, bssid);
3593 sc->sc_flags |= IWL2100_F_IFSTART;
3598 lwkt_serialize_exit(ifp->if_serializer);
3602 iwl2100_reinit(struct iwl2100_softc *sc)
3604 struct ifnet *ifp = &sc->sc_ic.ic_if;
3606 callout_stop(&sc->sc_restart_bmiss);
3607 callout_stop(&sc->sc_ibss);
3609 ifp->if_flags &= ~IFF_RUNNING;
3612 sc->sc_flags &= ~IWL2100_F_INITED;
3613 sc->sc_tx_timer = 0;
3615 /* Mark error happened, and wake up the pending command */
3616 sc->sc_flags |= IWL2100_F_ERROR;
3619 if ((sc->sc_flags & IWL2100_F_DETACH) == 0) {
3621 * Schedule complete initialization,
3622 * i.e. blow away current state
3624 iwlmsg_send(&sc->sc_reinit_msg, &sc->sc_thread_port);
3629 iwl2100_reinit_dispatch(struct netmsg *nmsg)
3631 struct iwlmsg *msg = (struct iwlmsg *)nmsg;
3632 struct iwl2100_softc *sc = msg->iwlm_softc;
3633 struct ifnet *ifp = &sc->sc_ic.ic_if;
3635 ASSERT_SERIALIZED(ifp->if_serializer);
3638 * NOTE: Reply ASAP, so reinit msg could be used if error intr
3639 * happened again during following iwl2100_init()
3641 lwkt_replymsg(&nmsg->nm_lmsg, 0);
3643 if (sc->sc_flags & IWL2100_F_DETACH)
3646 if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) == IFF_UP)
3651 iwl2100_reinit_callout(void *xsc)
3653 struct iwl2100_softc *sc = xsc;
3654 struct ifnet *ifp = &sc->sc_ic.ic_if;
3656 lwkt_serialize_enter(ifp->if_serializer);
3657 if ((sc->sc_flags & IWL2100_F_DETACH) == 0)
3659 lwkt_serialize_exit(ifp->if_serializer);
3663 iwl2100_chan_change(struct iwl2100_softc *sc, const struct ieee80211_channel *c)
3665 sc->sc_tx_th.wt_chan_freq = sc->sc_rx_th.wr_chan_freq =
3666 htole16(c->ic_freq);
3670 iwl2100_stop_callouts(struct iwl2100_softc *sc)
3672 callout_stop(&sc->sc_restart_bmiss);
3673 callout_stop(&sc->sc_ibss);
3674 callout_stop(&sc->sc_reinit);