2 * Copyright (c) 1997, 1998, 1999
3 * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
32 * $FreeBSD: head/sys/dev/wi/if_wi.c 196970 2009-09-08 13:19:05Z phk $
36 * Lucent WaveLAN/IEEE 802.11 PCMCIA driver.
38 * Original FreeBSD driver written by Bill Paul <wpaul@ctr.columbia.edu>
39 * Electrical Engineering Department
40 * Columbia University, New York City
44 * The WaveLAN/IEEE adapter is the second generation of the WaveLAN
45 * from Lucent. Unlike the older cards, the new ones are programmed
46 * entirely via a firmware-driven controller called the Hermes.
47 * Unfortunately, Lucent will not release the Hermes programming manual
48 * without an NDA (if at all). What they do release is an API library
49 * called the HCF (Hardware Control Functions) which is supposed to
50 * do the device-specific operations of a device driver for you. The
51 * publically available version of the HCF library (the 'HCF Light') is
52 * a) extremely gross, b) lacks certain features, particularly support
53 * for 802.11 frames, and c) is contaminated by the GNU Public License.
55 * This driver does not use the HCF or HCF Light at all. Instead, it
56 * programs the Hermes controller directly, using information gleaned
57 * from the HCF Light code and corresponding documentation.
59 * This driver supports the ISA, PCMCIA and PCI versions of the Lucent
60 * WaveLan cards (based on the Hermes chipset), as well as the newer
61 * Prism 2 chipsets with firmware from Intersil and Symbol.
65 #define WI_HERMES_STATS_WAR /* Work around stats counter bug. */
67 #include <sys/param.h>
68 #include <sys/systm.h>
69 #include <sys/endian.h>
70 #include <sys/sockio.h>
74 #include <sys/kernel.h>
75 #include <sys/socket.h>
76 #include <sys/module.h>
78 #include <sys/random.h>
79 #include <sys/syslog.h>
80 #include <sys/sysctl.h>
82 #include <machine/atomic.h>
86 #include <net/if_arp.h>
87 #include <net/ethernet.h>
88 #include <net/if_dl.h>
89 #include <net/if_llc.h>
90 #include <net/if_media.h>
91 #include <net/if_types.h>
92 #include <net/ifq_var.h>
94 #include <netproto/802_11/ieee80211_var.h>
95 #include <netproto/802_11/ieee80211_ioctl.h>
96 #include <netproto/802_11/ieee80211_radiotap.h>
98 #include <netinet/in.h>
99 #include <netinet/in_systm.h>
100 #include <netinet/in_var.h>
101 #include <netinet/ip.h>
102 #include <netinet/if_ether.h>
106 #include <dev/netif/wi/if_wavelan_ieee.h>
107 #include <dev/netif/wi/if_wireg.h>
108 #include <dev/netif/wi/if_wivar.h>
110 static struct ieee80211vap
*wi_vap_create(struct ieee80211com
*ic
,
111 const char name
[IFNAMSIZ
], int unit
, int opmode
, int flags
,
112 const uint8_t bssid
[IEEE80211_ADDR_LEN
],
113 const uint8_t mac
[IEEE80211_ADDR_LEN
]);
114 static void wi_vap_delete(struct ieee80211vap
*vap
);
115 static void wi_stop_locked(struct wi_softc
*sc
, int disable
);
116 static void wi_start_locked(struct ifnet
*);
117 static void wi_start(struct ifnet
*);
118 static int wi_start_tx(struct ifnet
*ifp
, struct wi_frame
*frmhdr
,
120 static int wi_raw_xmit(struct ieee80211_node
*, struct mbuf
*,
121 const struct ieee80211_bpf_params
*);
122 static int wi_newstate_sta(struct ieee80211vap
*, enum ieee80211_state
, int);
123 static int wi_newstate_hostap(struct ieee80211vap
*, enum ieee80211_state
,
125 static void wi_recv_mgmt(struct ieee80211_node
*ni
, struct mbuf
*m
,
126 int subtype
, int rssi
, int nf
);
127 static int wi_reset(struct wi_softc
*);
128 static void wi_watchdog_callout(void *);
129 static int wi_ioctl(struct ifnet
*, u_long
, caddr_t
, struct ucred
*);
130 static void wi_media_status(struct ifnet
*, struct ifmediareq
*);
132 static void wi_rx_intr(struct wi_softc
*);
133 static void wi_tx_intr(struct wi_softc
*);
134 static void wi_tx_ex_intr(struct wi_softc
*);
136 static void wi_info_intr(struct wi_softc
*);
138 static int wi_write_txrate(struct wi_softc
*, struct ieee80211vap
*);
139 static int wi_write_wep(struct wi_softc
*, struct ieee80211vap
*);
140 static int wi_write_multi(struct wi_softc
*);
141 static void wi_update_mcast(struct ifnet
*);
142 static void wi_update_promisc(struct ifnet
*);
143 static int wi_alloc_fid(struct wi_softc
*, int, int *);
144 static void wi_read_nicid(struct wi_softc
*);
145 static int wi_write_ssid(struct wi_softc
*, int, u_int8_t
*, int);
147 static int wi_cmd(struct wi_softc
*, int, int, int, int);
148 static int wi_seek_bap(struct wi_softc
*, int, int);
149 static int wi_read_bap(struct wi_softc
*, int, int, void *, int);
150 static int wi_write_bap(struct wi_softc
*, int, int, void *, int);
151 static int wi_mwrite_bap(struct wi_softc
*, int, int, struct mbuf
*, int);
152 static int wi_read_rid(struct wi_softc
*, int, void *, int *);
153 static int wi_write_rid(struct wi_softc
*, int, void *, int);
154 static int wi_write_appie(struct wi_softc
*, int, const struct ieee80211_appie
*);
156 static void wi_scan_start(struct ieee80211com
*);
157 static void wi_scan_end(struct ieee80211com
*);
158 static void wi_set_channel(struct ieee80211com
*);
161 wi_write_val(struct wi_softc
*sc
, int rid
, u_int16_t val
)
165 return wi_write_rid(sc
, rid
, &val
, sizeof(val
));
168 SYSCTL_NODE(_hw
, OID_AUTO
, wi
, CTLFLAG_RD
, 0, "Wireless driver parameters");
170 static struct timeval lasttxerror
; /* time of last tx error msg */
171 static int curtxeps
; /* current tx error msgs/sec */
172 static int wi_txerate
= 0; /* tx error rate: max msgs/sec */
173 SYSCTL_INT(_hw_wi
, OID_AUTO
, txerate
, CTLFLAG_RW
, &wi_txerate
,
174 0, "max tx error msgs/sec; 0 to disable msgs");
178 static int wi_debug
= 0;
179 SYSCTL_INT(_hw_wi
, OID_AUTO
, debug
, CTLFLAG_RW
, &wi_debug
,
180 0, "control debugging printfs");
181 #define DPRINTF(X) if (wi_debug) kprintf X
186 #define WI_INTRS (WI_EV_RX | WI_EV_ALLOC | WI_EV_INFO)
188 struct wi_card_ident wi_card_ident
[] = {
189 /* CARD_ID CARD_NAME FIRM_TYPE */
190 { WI_NIC_LUCENT_ID
, WI_NIC_LUCENT_STR
, WI_LUCENT
},
191 { WI_NIC_SONY_ID
, WI_NIC_SONY_STR
, WI_LUCENT
},
192 { WI_NIC_LUCENT_EMB_ID
, WI_NIC_LUCENT_EMB_STR
, WI_LUCENT
},
193 { WI_NIC_EVB2_ID
, WI_NIC_EVB2_STR
, WI_INTERSIL
},
194 { WI_NIC_HWB3763_ID
, WI_NIC_HWB3763_STR
, WI_INTERSIL
},
195 { WI_NIC_HWB3163_ID
, WI_NIC_HWB3163_STR
, WI_INTERSIL
},
196 { WI_NIC_HWB3163B_ID
, WI_NIC_HWB3163B_STR
, WI_INTERSIL
},
197 { WI_NIC_EVB3_ID
, WI_NIC_EVB3_STR
, WI_INTERSIL
},
198 { WI_NIC_HWB1153_ID
, WI_NIC_HWB1153_STR
, WI_INTERSIL
},
199 { WI_NIC_P2_SST_ID
, WI_NIC_P2_SST_STR
, WI_INTERSIL
},
200 { WI_NIC_EVB2_SST_ID
, WI_NIC_EVB2_SST_STR
, WI_INTERSIL
},
201 { WI_NIC_3842_EVA_ID
, WI_NIC_3842_EVA_STR
, WI_INTERSIL
},
202 { WI_NIC_3842_PCMCIA_AMD_ID
, WI_NIC_3842_PCMCIA_STR
, WI_INTERSIL
},
203 { WI_NIC_3842_PCMCIA_SST_ID
, WI_NIC_3842_PCMCIA_STR
, WI_INTERSIL
},
204 { WI_NIC_3842_PCMCIA_ATL_ID
, WI_NIC_3842_PCMCIA_STR
, WI_INTERSIL
},
205 { WI_NIC_3842_PCMCIA_ATS_ID
, WI_NIC_3842_PCMCIA_STR
, WI_INTERSIL
},
206 { WI_NIC_3842_MINI_AMD_ID
, WI_NIC_3842_MINI_STR
, WI_INTERSIL
},
207 { WI_NIC_3842_MINI_SST_ID
, WI_NIC_3842_MINI_STR
, WI_INTERSIL
},
208 { WI_NIC_3842_MINI_ATL_ID
, WI_NIC_3842_MINI_STR
, WI_INTERSIL
},
209 { WI_NIC_3842_MINI_ATS_ID
, WI_NIC_3842_MINI_STR
, WI_INTERSIL
},
210 { WI_NIC_3842_PCI_AMD_ID
, WI_NIC_3842_PCI_STR
, WI_INTERSIL
},
211 { WI_NIC_3842_PCI_SST_ID
, WI_NIC_3842_PCI_STR
, WI_INTERSIL
},
212 { WI_NIC_3842_PCI_ATS_ID
, WI_NIC_3842_PCI_STR
, WI_INTERSIL
},
213 { WI_NIC_3842_PCI_ATL_ID
, WI_NIC_3842_PCI_STR
, WI_INTERSIL
},
214 { WI_NIC_P3_PCMCIA_AMD_ID
, WI_NIC_P3_PCMCIA_STR
, WI_INTERSIL
},
215 { WI_NIC_P3_PCMCIA_SST_ID
, WI_NIC_P3_PCMCIA_STR
, WI_INTERSIL
},
216 { WI_NIC_P3_PCMCIA_ATL_ID
, WI_NIC_P3_PCMCIA_STR
, WI_INTERSIL
},
217 { WI_NIC_P3_PCMCIA_ATS_ID
, WI_NIC_P3_PCMCIA_STR
, WI_INTERSIL
},
218 { WI_NIC_P3_MINI_AMD_ID
, WI_NIC_P3_MINI_STR
, WI_INTERSIL
},
219 { WI_NIC_P3_MINI_SST_ID
, WI_NIC_P3_MINI_STR
, WI_INTERSIL
},
220 { WI_NIC_P3_MINI_ATL_ID
, WI_NIC_P3_MINI_STR
, WI_INTERSIL
},
221 { WI_NIC_P3_MINI_ATS_ID
, WI_NIC_P3_MINI_STR
, WI_INTERSIL
},
225 static char *wi_firmware_names
[] = { "none", "Hermes", "Intersil", "Symbol" };
227 devclass_t wi_devclass
;
230 wi_attach(device_t dev
)
232 struct wi_softc
*sc
= device_get_softc(dev
);
233 struct ieee80211com
*ic
;
235 int i
, nrates
, buflen
;
237 u_int8_t ratebuf
[2 + IEEE80211_RATE_SIZE
];
238 struct ieee80211_rateset
*rs
;
239 struct sysctl_ctx_list
*sctx
;
240 struct sysctl_oid
*soid
;
241 static const u_int8_t empty_macaddr
[IEEE80211_ADDR_LEN
] = {
242 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
245 uint8_t macaddr
[IEEE80211_ADDR_LEN
];
247 ifp
= sc
->sc_ifp
= if_alloc(IFT_IEEE80211
);
249 device_printf(dev
, "can not if_alloc\n");
255 sc
->sc_firmware_type
= WI_NOTYPE
;
256 sc
->wi_cmd_count
= 500;
258 if (wi_reset(sc
) != 0) {
260 return ENXIO
; /* XXX */
263 /* Read NIC identification */
265 switch (sc
->sc_firmware_type
) {
267 if (sc
->sc_sta_firmware_ver
< 60006)
271 if (sc
->sc_sta_firmware_ver
< 800)
276 device_printf(dev
, "Sorry, this card is not supported "
277 "(type %d, firmware ver %d)\n",
278 sc
->sc_firmware_type
, sc
->sc_sta_firmware_ver
);
283 /* Export info about the device via sysctl */
284 sctx
= &sc
->sc_sysctl_ctx
;
285 sysctl_ctx_init(sctx
);
286 soid
= SYSCTL_ADD_NODE(sctx
, SYSCTL_STATIC_CHILDREN(_hw
),
288 device_get_nameunit(sc
->sc_dev
),
291 device_printf(sc
->sc_dev
, "can't add sysctl node\n");
295 SYSCTL_ADD_STRING(sctx
, SYSCTL_CHILDREN(soid
), OID_AUTO
,
296 "firmware_type", CTLFLAG_RD
,
297 wi_firmware_names
[sc
->sc_firmware_type
], 0,
298 "Firmware type string");
299 SYSCTL_ADD_INT(sctx
, SYSCTL_CHILDREN(soid
), OID_AUTO
, "sta_version",
300 CTLFLAG_RD
, &sc
->sc_sta_firmware_ver
, 0,
301 "Station Firmware version");
302 if (sc
->sc_firmware_type
== WI_INTERSIL
)
303 SYSCTL_ADD_INT(sctx
, SYSCTL_CHILDREN(soid
), OID_AUTO
,
304 "pri_version", CTLFLAG_RD
, &sc
->sc_pri_firmware_ver
, 0,
305 "Primary Firmware version");
306 SYSCTL_ADD_INT(sctx
, SYSCTL_CHILDREN(soid
), OID_AUTO
, "nic_id",
307 CTLFLAG_RD
, &sc
->sc_nic_id
, 0, "NIC id");
308 SYSCTL_ADD_STRING(sctx
, SYSCTL_CHILDREN(soid
), OID_AUTO
, "nic_name",
309 CTLFLAG_RD
, sc
->sc_nic_name
, 0, "NIC name");
311 callout_init(&sc
->sc_watchdog
);
314 * Read the station address.
315 * And do it twice. I've seen PRISM-based cards that return
316 * an error when trying to read it the first time, which causes
319 buflen
= IEEE80211_ADDR_LEN
;
320 error
= wi_read_rid(sc
, WI_RID_MAC_NODE
, macaddr
, &buflen
);
322 buflen
= IEEE80211_ADDR_LEN
;
323 error
= wi_read_rid(sc
, WI_RID_MAC_NODE
, macaddr
, &buflen
);
325 if (error
|| IEEE80211_ADDR_EQ(macaddr
, empty_macaddr
)) {
327 device_printf(dev
, "mac read failed %d\n", error
);
329 device_printf(dev
, "mac read failed (all zeros)\n");
337 if_initname(ifp
, device_get_name(dev
), device_get_unit(dev
));
338 ifp
->if_flags
= IFF_BROADCAST
| IFF_SIMPLEX
| IFF_MULTICAST
;
339 ifp
->if_ioctl
= wi_ioctl
;
340 ifp
->if_start
= wi_start
;
341 ifp
->if_init
= wi_init
;
342 ifq_set_maxlen(&ifp
->if_snd
, IFQ_MAXLEN
);
343 ifq_set_ready(&ifp
->if_snd
);
346 ic
->ic_phytype
= IEEE80211_T_DS
;
347 ic
->ic_opmode
= IEEE80211_M_STA
;
348 ic
->ic_caps
= IEEE80211_C_STA
350 | IEEE80211_C_MONITOR
354 * Query the card for available channels and setup the
355 * channel table. We assume these are all 11b channels.
357 buflen
= sizeof(val
);
358 if (wi_read_rid(sc
, WI_RID_CHANNEL_LIST
, &val
, &buflen
) != 0)
359 val
= htole16(0x1fff); /* assume 1-11 */
360 KASSERT(val
!= 0, ("wi_attach: no available channels listed!"));
362 val
<<= 1; /* shift for base 1 indices */
363 for (i
= 1; i
< 16; i
++) {
364 struct ieee80211_channel
*c
;
366 if (!isset((u_int8_t
*)&val
, i
))
368 c
= &ic
->ic_channels
[ic
->ic_nchans
++];
369 c
->ic_freq
= ieee80211_ieee2mhz(i
, IEEE80211_CHAN_B
);
370 c
->ic_flags
= IEEE80211_CHAN_B
;
376 * Set flags based on firmware version.
378 switch (sc
->sc_firmware_type
) {
381 ic
->ic_caps
|= IEEE80211_C_IBSS
;
383 sc
->sc_ibss_port
= WI_PORTTYPE_BSS
;
384 sc
->sc_monitor_port
= WI_PORTTYPE_ADHOC
;
385 sc
->sc_min_rssi
= WI_LUCENT_MIN_RSSI
;
386 sc
->sc_max_rssi
= WI_LUCENT_MAX_RSSI
;
387 sc
->sc_dbm_offset
= WI_LUCENT_DBM_OFFSET
;
390 sc
->sc_ntxbuf
= WI_NTXBUF
;
391 sc
->sc_flags
|= WI_FLAGS_HAS_FRAGTHR
392 | WI_FLAGS_HAS_ROAMING
;
394 * Old firmware are slow, so give peace a chance.
396 if (sc
->sc_sta_firmware_ver
< 10000)
397 sc
->wi_cmd_count
= 5000;
398 if (sc
->sc_sta_firmware_ver
> 10101)
399 sc
->sc_flags
|= WI_FLAGS_HAS_DBMADJUST
;
400 ic
->ic_caps
|= IEEE80211_C_IBSS
;
402 * version 0.8.3 and newer are the only ones that are known
403 * to currently work. Earlier versions can be made to work,
404 * at least according to the Linux driver but we require
405 * monitor mode so this is irrelevant.
407 ic
->ic_caps
|= IEEE80211_C_HOSTAP
;
408 if (sc
->sc_sta_firmware_ver
>= 10603)
409 sc
->sc_flags
|= WI_FLAGS_HAS_ENHSECURITY
;
410 if (sc
->sc_sta_firmware_ver
>= 10700) {
412 * 1.7.0+ have the necessary support for sta mode WPA.
414 sc
->sc_flags
|= WI_FLAGS_HAS_WPASUPPORT
;
415 ic
->ic_caps
|= IEEE80211_C_WPA
;
418 sc
->sc_ibss_port
= WI_PORTTYPE_IBSS
;
419 sc
->sc_monitor_port
= WI_PORTTYPE_APSILENT
;
420 sc
->sc_min_rssi
= WI_PRISM_MIN_RSSI
;
421 sc
->sc_max_rssi
= WI_PRISM_MAX_RSSI
;
422 sc
->sc_dbm_offset
= WI_PRISM_DBM_OFFSET
;
427 * Find out if we support WEP on this card.
429 buflen
= sizeof(val
);
430 if (wi_read_rid(sc
, WI_RID_WEP_AVAIL
, &val
, &buflen
) == 0 &&
432 ic
->ic_cryptocaps
|= IEEE80211_CRYPTO_WEP
;
434 /* Find supported rates. */
435 buflen
= sizeof(ratebuf
);
436 rs
= &ic
->ic_sup_rates
[IEEE80211_MODE_11B
];
437 if (wi_read_rid(sc
, WI_RID_DATA_RATES
, ratebuf
, &buflen
) == 0) {
438 nrates
= le16toh(*(u_int16_t
*)ratebuf
);
439 if (nrates
> IEEE80211_RATE_MAXSIZE
)
440 nrates
= IEEE80211_RATE_MAXSIZE
;
442 for (i
= 0; i
< nrates
; i
++)
444 rs
->rs_rates
[rs
->rs_nrates
++] = ratebuf
[2+i
];
446 /* XXX fallback on error? */
449 buflen
= sizeof(val
);
450 if ((sc
->sc_flags
& WI_FLAGS_HAS_DBMADJUST
) &&
451 wi_read_rid(sc
, WI_RID_DBM_ADJUST
, &val
, &buflen
) == 0) {
452 sc
->sc_dbm_offset
= le16toh(val
);
455 sc
->sc_portnum
= WI_DEFAULT_PORT
;
457 ieee80211_ifattach(ic
, macaddr
);
458 ic
->ic_raw_xmit
= wi_raw_xmit
;
459 ic
->ic_scan_start
= wi_scan_start
;
460 ic
->ic_scan_end
= wi_scan_end
;
461 ic
->ic_set_channel
= wi_set_channel
;
463 ic
->ic_vap_create
= wi_vap_create
;
464 ic
->ic_vap_delete
= wi_vap_delete
;
465 ic
->ic_update_mcast
= wi_update_mcast
;
466 ic
->ic_update_promisc
= wi_update_promisc
;
468 ieee80211_radiotap_attach(ic
,
469 &sc
->sc_tx_th
.wt_ihdr
, sizeof(sc
->sc_tx_th
),
470 WI_TX_RADIOTAP_PRESENT
,
471 &sc
->sc_rx_th
.wr_ihdr
, sizeof(sc
->sc_rx_th
),
472 WI_RX_RADIOTAP_PRESENT
);
475 ieee80211_announce(ic
);
477 error
= bus_setup_intr(dev
, sc
->irq
, INTR_MPSAFE
,
478 wi_intr
, sc
, &sc
->wi_intrhand
, NULL
);
480 device_printf(dev
, "bus_setup_intr() failed! (%d)\n", error
);
481 ieee80211_ifdetach(ic
);
491 wi_detach(device_t dev
)
493 struct wi_softc
*sc
= device_get_softc(dev
);
494 struct ifnet
*ifp
= sc
->sc_ifp
;
495 struct ieee80211com
*ic
= ifp
->if_l2com
;
497 /* check if device was removed */
498 sc
->wi_gone
|= !bus_child_present(dev
);
500 wi_stop_locked(sc
, 0);
501 ieee80211_ifdetach(ic
);
503 bus_teardown_intr(dev
, sc
->irq
, sc
->wi_intrhand
);
509 static struct ieee80211vap
*
510 wi_vap_create(struct ieee80211com
*ic
,
511 const char name
[IFNAMSIZ
], int unit
, int opmode
, int flags
,
512 const uint8_t bssid
[IEEE80211_ADDR_LEN
],
513 const uint8_t mac
[IEEE80211_ADDR_LEN
])
515 struct wi_softc
*sc
= ic
->ic_ifp
->if_softc
;
517 struct ieee80211vap
*vap
;
519 if (!TAILQ_EMPTY(&ic
->ic_vaps
)) /* only one at a time */
521 wvp
= (struct wi_vap
*) kmalloc(sizeof(struct wi_vap
),
522 M_80211_VAP
, M_NOWAIT
| M_ZERO
);
527 ieee80211_vap_setup(ic
, vap
, name
, unit
, opmode
, flags
, bssid
, mac
);
529 vap
->iv_max_aid
= WI_MAX_AID
;
532 case IEEE80211_M_STA
:
533 sc
->sc_porttype
= WI_PORTTYPE_BSS
;
534 wvp
->wv_newstate
= vap
->iv_newstate
;
535 vap
->iv_newstate
= wi_newstate_sta
;
536 /* need to filter mgt frames to avoid confusing state machine */
537 wvp
->wv_recv_mgmt
= vap
->iv_recv_mgmt
;
538 vap
->iv_recv_mgmt
= wi_recv_mgmt
;
540 case IEEE80211_M_IBSS
:
541 sc
->sc_porttype
= sc
->sc_ibss_port
;
542 wvp
->wv_newstate
= vap
->iv_newstate
;
543 vap
->iv_newstate
= wi_newstate_sta
;
545 case IEEE80211_M_AHDEMO
:
546 sc
->sc_porttype
= WI_PORTTYPE_ADHOC
;
548 case IEEE80211_M_HOSTAP
:
549 sc
->sc_porttype
= WI_PORTTYPE_HOSTAP
;
550 wvp
->wv_newstate
= vap
->iv_newstate
;
551 vap
->iv_newstate
= wi_newstate_hostap
;
553 case IEEE80211_M_MONITOR
:
554 sc
->sc_porttype
= sc
->sc_monitor_port
;
561 ieee80211_vap_attach(vap
, ieee80211_media_change
, wi_media_status
);
562 ic
->ic_opmode
= opmode
;
567 wi_vap_delete(struct ieee80211vap
*vap
)
569 struct wi_vap
*wvp
= WI_VAP(vap
);
571 ieee80211_vap_detach(vap
);
572 kfree(wvp
, M_80211_VAP
);
576 wi_shutdown(device_t dev
)
578 struct wi_softc
*sc
= device_get_softc(dev
);
587 struct wi_softc
*sc
= arg
;
588 struct ifnet
*ifp
= sc
->sc_ifp
;
591 if (sc
->wi_gone
|| !sc
->sc_enabled
|| (ifp
->if_flags
& IFF_UP
) == 0) {
592 CSR_WRITE_2(sc
, WI_INT_EN
, 0);
593 CSR_WRITE_2(sc
, WI_EVENT_ACK
, 0xFFFF);
597 /* Disable interrupts. */
598 CSR_WRITE_2(sc
, WI_INT_EN
, 0);
600 status
= CSR_READ_2(sc
, WI_EVENT_STAT
);
601 if (status
& WI_EV_RX
)
603 if (status
& WI_EV_ALLOC
)
605 if (status
& WI_EV_TX_EXC
)
607 if (status
& WI_EV_INFO
)
609 if ((ifp
->if_flags
& IFF_OACTIVE
) == 0 &&
610 !ifq_is_empty(&ifp
->if_snd
))
611 wi_start_locked(ifp
);
613 /* Re-enable interrupts. */
614 CSR_WRITE_2(sc
, WI_INT_EN
, WI_INTRS
);
620 wi_enable(struct wi_softc
*sc
)
622 /* Enable interrupts */
623 CSR_WRITE_2(sc
, WI_INT_EN
, WI_INTRS
);
626 wi_cmd(sc
, WI_CMD_ENABLE
| sc
->sc_portnum
, 0, 0, 0);
631 wi_setup_locked(struct wi_softc
*sc
, int porttype
, int mode
,
632 uint8_t mac
[IEEE80211_ADDR_LEN
])
638 wi_write_val(sc
, WI_RID_PORTTYPE
, porttype
);
639 wi_write_val(sc
, WI_RID_CREATE_IBSS
, mode
);
640 wi_write_val(sc
, WI_RID_MAX_DATALEN
, 2304);
641 /* XXX IEEE80211_BPF_NOACK wants 0 */
642 wi_write_val(sc
, WI_RID_ALT_RETRY_CNT
, 2);
643 if (sc
->sc_flags
& WI_FLAGS_HAS_ROAMING
)
644 wi_write_val(sc
, WI_RID_ROAMING_MODE
, 3); /* NB: disabled */
646 wi_write_rid(sc
, WI_RID_MAC_NODE
, mac
, IEEE80211_ADDR_LEN
);
648 /* Allocate fids for the card */
649 sc
->sc_buflen
= IEEE80211_MAX_LEN
+ sizeof(struct wi_frame
);
650 for (i
= 0; i
< sc
->sc_ntxbuf
; i
++) {
651 int error
= wi_alloc_fid(sc
, sc
->sc_buflen
,
652 &sc
->sc_txd
[i
].d_fid
);
654 device_printf(sc
->sc_dev
,
655 "tx buffer allocation failed (error %u)\n",
659 sc
->sc_txd
[i
].d_len
= 0;
661 sc
->sc_txcur
= sc
->sc_txnext
= 0;
667 wi_init_locked(struct wi_softc
*sc
)
669 struct ifnet
*ifp
= sc
->sc_ifp
;
672 wasenabled
= sc
->sc_enabled
;
674 wi_stop_locked(sc
, 1);
676 if (wi_setup_locked(sc
, sc
->sc_porttype
, 3, IF_LLADDR(ifp
)) != 0) {
677 if_printf(ifp
, "interface not running\n");
678 wi_stop_locked(sc
, 1);
682 ifp
->if_flags
|= IFF_RUNNING
;
683 ifp
->if_flags
&= ~IFF_OACTIVE
;
685 callout_reset(&sc
->sc_watchdog
, hz
, wi_watchdog_callout
, sc
);
687 wi_enable(sc
); /* Enable desired port */
693 struct wi_softc
*sc
= arg
;
694 struct ifnet
*ifp
= sc
->sc_ifp
;
695 struct ieee80211com
*ic
= ifp
->if_l2com
;
699 if (ifp
->if_flags
& IFF_RUNNING
)
700 ieee80211_start_all(ic
); /* start all vap's */
704 wi_stop_locked(struct wi_softc
*sc
, int disable
)
706 struct ifnet
*ifp
= sc
->sc_ifp
;
708 if (sc
->sc_enabled
&& !sc
->wi_gone
) {
709 CSR_WRITE_2(sc
, WI_INT_EN
, 0);
710 wi_cmd(sc
, WI_CMD_DISABLE
| sc
->sc_portnum
, 0, 0, 0);
713 } else if (sc
->wi_gone
&& disable
) /* gone --> not enabled */
716 callout_stop(&sc
->sc_watchdog
);
718 sc
->sc_false_syns
= 0;
720 ifp
->if_flags
&= ~(IFF_OACTIVE
| IFF_RUNNING
);
724 wi_stop(struct wi_softc
*sc
, int disable
)
726 wi_stop_locked(sc
, disable
);
730 wi_set_channel(struct ieee80211com
*ic
)
732 struct ifnet
*ifp
= ic
->ic_ifp
;
733 struct wi_softc
*sc
= ifp
->if_softc
;
735 DPRINTF(("%s: channel %d, %sscanning\n", __func__
,
736 ieee80211_chan2ieee(ic
, ic
->ic_curchan
),
737 ic
->ic_flags
& IEEE80211_F_SCAN
? "" : "!"));
739 wi_write_val(sc
, WI_RID_OWN_CHNL
,
740 ieee80211_chan2ieee(ic
, ic
->ic_curchan
));
744 wi_scan_start(struct ieee80211com
*ic
)
746 struct ifnet
*ifp
= ic
->ic_ifp
;
747 struct wi_softc
*sc
= ifp
->if_softc
;
748 struct ieee80211_scan_state
*ss
= ic
->ic_scan
;
750 DPRINTF(("%s\n", __func__
));
753 * Switch device to monitor mode.
755 wi_write_val(sc
, WI_RID_PORTTYPE
, sc
->sc_monitor_port
);
756 if (sc
->sc_firmware_type
== WI_INTERSIL
) {
757 wi_cmd(sc
, WI_CMD_DISABLE
| WI_PORT0
, 0, 0, 0);
758 wi_cmd(sc
, WI_CMD_ENABLE
| WI_PORT0
, 0, 0, 0);
760 /* force full dwell time to compensate for firmware overhead */
761 ss
->ss_mindwell
= ss
->ss_maxdwell
= msecs_to_ticks(400);
766 wi_scan_end(struct ieee80211com
*ic
)
768 struct ifnet
*ifp
= ic
->ic_ifp
;
769 struct wi_softc
*sc
= ifp
->if_softc
;
771 DPRINTF(("%s: restore port type %d\n", __func__
, sc
->sc_porttype
));
773 wi_write_val(sc
, WI_RID_PORTTYPE
, sc
->sc_porttype
);
774 if (sc
->sc_firmware_type
== WI_INTERSIL
) {
775 wi_cmd(sc
, WI_CMD_DISABLE
| WI_PORT0
, 0, 0, 0);
776 wi_cmd(sc
, WI_CMD_ENABLE
| WI_PORT0
, 0, 0, 0);
781 wi_recv_mgmt(struct ieee80211_node
*ni
, struct mbuf
*m
,
782 int subtype
, int rssi
, int nf
)
784 struct ieee80211vap
*vap
= ni
->ni_vap
;
787 case IEEE80211_FC0_SUBTYPE_AUTH
:
788 case IEEE80211_FC0_SUBTYPE_ASSOC_RESP
:
789 case IEEE80211_FC0_SUBTYPE_REASSOC_RESP
:
790 /* NB: filter frames that trigger state changes */
793 WI_VAP(vap
)->wv_recv_mgmt(ni
, m
, subtype
, rssi
, nf
);
797 wi_newstate_sta(struct ieee80211vap
*vap
, enum ieee80211_state nstate
, int arg
)
799 struct ieee80211com
*ic
= vap
->iv_ic
;
800 struct ifnet
*ifp
= ic
->ic_ifp
;
801 struct ieee80211_node
*bss
;
802 struct wi_softc
*sc
= ifp
->if_softc
;
804 DPRINTF(("%s: %s -> %s\n", __func__
,
805 ieee80211_state_name
[vap
->iv_state
],
806 ieee80211_state_name
[nstate
]));
808 if (nstate
== IEEE80211_S_AUTH
) {
809 wi_setup_locked(sc
, WI_PORTTYPE_BSS
, 3, vap
->iv_myaddr
);
811 if (vap
->iv_flags
& IEEE80211_F_PMGTON
) {
812 wi_write_val(sc
, WI_RID_MAX_SLEEP
, ic
->ic_lintval
);
813 wi_write_val(sc
, WI_RID_PM_ENABLED
, 1);
815 wi_write_val(sc
, WI_RID_RTS_THRESH
, vap
->iv_rtsthreshold
);
816 if (sc
->sc_flags
& WI_FLAGS_HAS_FRAGTHR
)
817 wi_write_val(sc
, WI_RID_FRAG_THRESH
,
818 vap
->iv_fragthreshold
);
819 wi_write_txrate(sc
, vap
);
822 wi_write_ssid(sc
, WI_RID_DESIRED_SSID
, bss
->ni_essid
, bss
->ni_esslen
);
823 wi_write_val(sc
, WI_RID_OWN_CHNL
,
824 ieee80211_chan2ieee(ic
, bss
->ni_chan
));
827 if (ic
->ic_cryptocaps
& IEEE80211_CRYPTO_WEP
)
828 wi_write_wep(sc
, vap
);
830 sc
->sc_encryption
= 0;
832 if ((sc
->sc_flags
& WI_FLAGS_HAS_WPASUPPORT
) &&
833 (vap
->iv_flags
& IEEE80211_F_WPA
)) {
834 wi_write_val(sc
, WI_RID_WPA_HANDLING
, 1);
835 if (vap
->iv_appie_wpa
!= NULL
)
836 wi_write_appie(sc
, WI_RID_WPA_DATA
,
840 wi_enable(sc
); /* enable port */
842 /* Lucent firmware does not support the JOIN RID. */
843 if (sc
->sc_firmware_type
== WI_INTERSIL
) {
844 struct wi_joinreq join
;
846 memset(&join
, 0, sizeof(join
));
847 IEEE80211_ADDR_COPY(&join
.wi_bssid
, bss
->ni_bssid
);
848 join
.wi_chan
= htole16(
849 ieee80211_chan2ieee(ic
, bss
->ni_chan
));
850 wi_write_rid(sc
, WI_RID_JOIN_REQ
, &join
, sizeof(join
));
854 * NB: don't go through 802.11 layer, it'll send auth frame;
855 * instead we drive the state machine from the link status
856 * notification we get on association.
858 vap
->iv_state
= nstate
;
861 return WI_VAP(vap
)->wv_newstate(vap
, nstate
, arg
);
865 wi_newstate_hostap(struct ieee80211vap
*vap
, enum ieee80211_state nstate
, int arg
)
867 struct ieee80211com
*ic
= vap
->iv_ic
;
868 struct ifnet
*ifp
= ic
->ic_ifp
;
869 struct ieee80211_node
*bss
;
870 struct wi_softc
*sc
= ifp
->if_softc
;
873 DPRINTF(("%s: %s -> %s\n", __func__
,
874 ieee80211_state_name
[vap
->iv_state
],
875 ieee80211_state_name
[nstate
]));
877 error
= WI_VAP(vap
)->wv_newstate(vap
, nstate
, arg
);
878 if (error
== 0 && nstate
== IEEE80211_S_RUN
) {
879 wi_setup_locked(sc
, WI_PORTTYPE_HOSTAP
, 0, vap
->iv_myaddr
);
882 wi_write_ssid(sc
, WI_RID_OWN_SSID
,
883 bss
->ni_essid
, bss
->ni_esslen
);
884 wi_write_val(sc
, WI_RID_OWN_CHNL
,
885 ieee80211_chan2ieee(ic
, bss
->ni_chan
));
886 wi_write_val(sc
, WI_RID_BASIC_RATE
, 0x3);
887 wi_write_val(sc
, WI_RID_SUPPORT_RATE
, 0xf);
888 wi_write_txrate(sc
, vap
);
890 wi_write_val(sc
, WI_RID_OWN_BEACON_INT
, bss
->ni_intval
);
891 wi_write_val(sc
, WI_RID_DTIM_PERIOD
, vap
->iv_dtim_period
);
893 wi_write_val(sc
, WI_RID_RTS_THRESH
, vap
->iv_rtsthreshold
);
894 if (sc
->sc_flags
& WI_FLAGS_HAS_FRAGTHR
)
895 wi_write_val(sc
, WI_RID_FRAG_THRESH
,
896 vap
->iv_fragthreshold
);
898 if ((sc
->sc_flags
& WI_FLAGS_HAS_ENHSECURITY
) &&
899 (vap
->iv_flags
& IEEE80211_F_HIDESSID
)) {
901 * bit 0 means hide SSID in beacons,
902 * bit 1 means don't respond to bcast probe req
904 wi_write_val(sc
, WI_RID_ENH_SECURITY
, 0x3);
907 if ((sc
->sc_flags
& WI_FLAGS_HAS_WPASUPPORT
) &&
908 (vap
->iv_flags
& IEEE80211_F_WPA
) &&
909 vap
->iv_appie_wpa
!= NULL
)
910 wi_write_appie(sc
, WI_RID_WPA_DATA
, vap
->iv_appie_wpa
);
912 wi_write_val(sc
, WI_RID_PROMISC
, 0);
915 if (ic
->ic_cryptocaps
& IEEE80211_CRYPTO_WEP
)
916 wi_write_wep(sc
, vap
);
918 sc
->sc_encryption
= 0;
920 wi_enable(sc
); /* enable port */
926 wi_start_locked(struct ifnet
*ifp
)
928 struct wi_softc
*sc
= ifp
->if_softc
;
929 struct ieee80211_node
*ni
;
930 struct ieee80211_frame
*wh
;
932 struct ieee80211_key
*k
;
933 struct wi_frame frmhdr
;
934 const struct llc
*llc
;
940 memset(&frmhdr
, 0, sizeof(frmhdr
));
943 IF_DEQUEUE(&ifp
->if_snd
, m0
);
946 if (sc
->sc_txd
[cur
].d_len
!= 0) {
947 IF_PREPEND(&ifp
->if_snd
, m0
);
948 ifp
->if_flags
|= IFF_OACTIVE
;
951 ni
= (struct ieee80211_node
*) m0
->m_pkthdr
.rcvif
;
953 /* reconstruct 802.3 header */
954 wh
= mtod(m0
, struct ieee80211_frame
*);
955 switch (wh
->i_fc
[1]) {
956 case IEEE80211_FC1_DIR_TODS
:
957 IEEE80211_ADDR_COPY(frmhdr
.wi_ehdr
.ether_shost
,
959 IEEE80211_ADDR_COPY(frmhdr
.wi_ehdr
.ether_dhost
,
962 case IEEE80211_FC1_DIR_NODS
:
963 IEEE80211_ADDR_COPY(frmhdr
.wi_ehdr
.ether_shost
,
965 IEEE80211_ADDR_COPY(frmhdr
.wi_ehdr
.ether_dhost
,
968 case IEEE80211_FC1_DIR_FROMDS
:
969 IEEE80211_ADDR_COPY(frmhdr
.wi_ehdr
.ether_shost
,
971 IEEE80211_ADDR_COPY(frmhdr
.wi_ehdr
.ether_dhost
,
975 llc
= (const struct llc
*)(
976 mtod(m0
, const uint8_t *) + ieee80211_hdrsize(wh
));
977 frmhdr
.wi_ehdr
.ether_type
= llc
->llc_snap
.ether_type
;
978 frmhdr
.wi_tx_ctl
= htole16(WI_ENC_TX_802_11
|WI_TXCNTL_TX_EX
);
979 if (wh
->i_fc
[1] & IEEE80211_FC1_WEP
) {
980 k
= ieee80211_crypto_encap(ni
, m0
);
982 ieee80211_free_node(ni
);
986 frmhdr
.wi_tx_ctl
|= htole16(WI_TXCNTL_NOCRYPT
);
989 if (ieee80211_radiotap_active_vap(ni
->ni_vap
)) {
990 sc
->sc_tx_th
.wt_rate
= ni
->ni_txrate
;
991 ieee80211_radiotap_tx(ni
->ni_vap
, m0
);
994 m_copydata(m0
, 0, sizeof(struct ieee80211_frame
),
995 (caddr_t
)&frmhdr
.wi_whdr
);
996 m_adj(m0
, sizeof(struct ieee80211_frame
));
997 frmhdr
.wi_dat_len
= htole16(m0
->m_pkthdr
.len
);
998 ieee80211_free_node(ni
);
999 if (wi_start_tx(ifp
, &frmhdr
, m0
))
1002 sc
->sc_txnext
= cur
= (cur
+ 1) % sc
->sc_ntxbuf
;
1008 wi_start(struct ifnet
*ifp
)
1010 wi_start_locked(ifp
);
1014 wi_start_tx(struct ifnet
*ifp
, struct wi_frame
*frmhdr
, struct mbuf
*m0
)
1016 struct wi_softc
*sc
= ifp
->if_softc
;
1017 int cur
= sc
->sc_txnext
;
1018 int fid
, off
, error
;
1020 fid
= sc
->sc_txd
[cur
].d_fid
;
1021 off
= sizeof(*frmhdr
);
1022 error
= wi_write_bap(sc
, fid
, 0, frmhdr
, sizeof(*frmhdr
)) != 0
1023 || wi_mwrite_bap(sc
, fid
, off
, m0
, m0
->m_pkthdr
.len
) != 0;
1029 sc
->sc_txd
[cur
].d_len
= off
;
1030 if (sc
->sc_txcur
== cur
) {
1031 if (wi_cmd(sc
, WI_CMD_TX
| WI_RECLAIM
, fid
, 0, 0)) {
1032 if_printf(ifp
, "xmit failed\n");
1033 sc
->sc_txd
[cur
].d_len
= 0;
1036 sc
->sc_tx_timer
= 5;
1042 wi_raw_xmit(struct ieee80211_node
*ni
, struct mbuf
*m0
,
1043 const struct ieee80211_bpf_params
*params
)
1045 struct ieee80211com
*ic
= ni
->ni_ic
;
1046 struct ifnet
*ifp
= ic
->ic_ifp
;
1047 struct ieee80211vap
*vap
= ni
->ni_vap
;
1048 struct wi_softc
*sc
= ifp
->if_softc
;
1049 struct ieee80211_key
*k
;
1050 struct ieee80211_frame
*wh
;
1051 struct wi_frame frmhdr
;
1059 memset(&frmhdr
, 0, sizeof(frmhdr
));
1060 cur
= sc
->sc_txnext
;
1061 if (sc
->sc_txd
[cur
].d_len
!= 0) {
1062 ifp
->if_flags
|= IFF_OACTIVE
;
1066 m0
->m_pkthdr
.rcvif
= NULL
;
1068 m_copydata(m0
, 4, ETHER_ADDR_LEN
* 2,
1069 (caddr_t
)&frmhdr
.wi_ehdr
);
1070 frmhdr
.wi_ehdr
.ether_type
= 0;
1071 wh
= mtod(m0
, struct ieee80211_frame
*);
1073 frmhdr
.wi_tx_ctl
= htole16(WI_ENC_TX_802_11
|WI_TXCNTL_TX_EX
);
1074 if (params
&& (params
->ibp_flags
& IEEE80211_BPF_NOACK
))
1075 frmhdr
.wi_tx_ctl
|= htole16(WI_TXCNTL_ALTRTRY
);
1076 if ((wh
->i_fc
[1] & IEEE80211_FC1_WEP
) &&
1077 (!params
|| (params
&& (params
->ibp_flags
& IEEE80211_BPF_CRYPTO
)))) {
1078 k
= ieee80211_crypto_encap(ni
, m0
);
1083 frmhdr
.wi_tx_ctl
|= htole16(WI_TXCNTL_NOCRYPT
);
1085 if (ieee80211_radiotap_active_vap(vap
)) {
1086 sc
->sc_tx_th
.wt_rate
= ni
->ni_txrate
;
1087 ieee80211_radiotap_tx(vap
, m0
);
1089 m_copydata(m0
, 0, sizeof(struct ieee80211_frame
),
1090 (caddr_t
)&frmhdr
.wi_whdr
);
1091 m_adj(m0
, sizeof(struct ieee80211_frame
));
1092 frmhdr
.wi_dat_len
= htole16(m0
->m_pkthdr
.len
);
1093 if (wi_start_tx(ifp
, &frmhdr
, m0
) < 0) {
1100 sc
->sc_txnext
= cur
= (cur
+ 1) % sc
->sc_ntxbuf
;
1105 ieee80211_free_node(ni
);
1110 wi_reset(struct wi_softc
*sc
)
1112 #define WI_INIT_TRIES 3
1115 for (i
= 0; i
< WI_INIT_TRIES
; i
++) {
1116 error
= wi_cmd(sc
, WI_CMD_INI
, 0, 0, 0);
1119 DELAY(WI_DELAY
* 1000);
1122 if (i
== WI_INIT_TRIES
) {
1123 if_printf(sc
->sc_ifp
, "reset failed\n");
1127 CSR_WRITE_2(sc
, WI_INT_EN
, 0);
1128 CSR_WRITE_2(sc
, WI_EVENT_ACK
, 0xFFFF);
1130 /* Calibrate timer. */
1131 wi_write_val(sc
, WI_RID_TICK_TIME
, 8);
1134 #undef WI_INIT_TRIES
1138 wi_watchdog_callout(void *arg
)
1140 struct wi_softc
*sc
= arg
;
1141 struct ifnet
*ifp
= sc
->sc_ifp
;
1143 if (!sc
->sc_enabled
)
1146 if (sc
->sc_tx_timer
&& --sc
->sc_tx_timer
== 0) {
1147 if_printf(ifp
, "device timeout\n");
1149 wi_init_locked(ifp
->if_softc
);
1152 callout_reset(&sc
->sc_watchdog
, hz
, wi_watchdog_callout
, sc
);
1156 wi_ioctl(struct ifnet
*ifp
, u_long cmd
, caddr_t data
, struct ucred
*ucred
)
1158 struct wi_softc
*sc
= ifp
->if_softc
;
1159 struct ieee80211com
*ic
= ifp
->if_l2com
;
1160 struct ifreq
*ifr
= (struct ifreq
*) data
;
1161 int error
= 0, startall
= 0;
1166 * Can't do promisc and hostap at the same time. If all that's
1167 * changing is the promisc flag, try to short-circuit a call to
1168 * wi_init() by just setting PROMISC in the hardware.
1170 if (ifp
->if_flags
& IFF_UP
) {
1171 if (ic
->ic_opmode
!= IEEE80211_M_HOSTAP
&&
1172 ifp
->if_flags
& IFF_RUNNING
) {
1173 if ((ifp
->if_flags
^ sc
->sc_if_flags
) & IFF_PROMISC
) {
1174 wi_write_val(sc
, WI_RID_PROMISC
,
1175 (ifp
->if_flags
& IFF_PROMISC
) != 0);
1185 if (ifp
->if_flags
& IFF_RUNNING
)
1186 wi_stop_locked(sc
, 1);
1189 sc
->sc_if_flags
= ifp
->if_flags
;
1191 ieee80211_start_all(ic
);
1194 error
= ifmedia_ioctl(ifp
, ifr
, &ic
->ic_media
, cmd
);
1197 error
= ether_ioctl(ifp
, cmd
, data
);
1207 wi_media_status(struct ifnet
*ifp
, struct ifmediareq
*imr
)
1209 struct ieee80211vap
*vap
= ifp
->if_softc
;
1210 struct ieee80211com
*ic
= vap
->iv_ic
;
1211 struct wi_softc
*sc
= ic
->ic_ifp
->if_softc
;
1216 if (sc
->sc_enabled
&&
1217 wi_read_rid(sc
, WI_RID_CUR_TX_RATE
, &val
, &len
) == 0 &&
1218 len
== sizeof(val
)) {
1219 /* convert to 802.11 rate */
1222 if (sc
->sc_firmware_type
== WI_LUCENT
) {
1224 rate
= 11; /* 5.5Mbps */
1227 rate
= 11; /* 5.5Mbps */
1228 else if (rate
== 8*2)
1229 rate
= 22; /* 11Mbps */
1231 vap
->iv_bss
->ni_txrate
= rate
;
1233 ieee80211_media_status(ifp
, imr
);
1237 wi_sync_bssid(struct wi_softc
*sc
, u_int8_t new_bssid
[IEEE80211_ADDR_LEN
])
1239 struct ifnet
*ifp
= sc
->sc_ifp
;
1240 struct ieee80211com
*ic
= ifp
->if_l2com
;
1241 struct ieee80211vap
*vap
= TAILQ_FIRST(&ic
->ic_vaps
);
1242 struct ieee80211_node
*ni
= vap
->iv_bss
;
1244 if (IEEE80211_ADDR_EQ(new_bssid
, ni
->ni_bssid
))
1247 DPRINTF(("wi_sync_bssid: bssid %6D -> ", ni
->ni_bssid
, ":"));
1248 DPRINTF(("%6D ?\n", new_bssid
, ":"));
1250 /* In promiscuous mode, the BSSID field is not a reliable
1251 * indicator of the firmware's BSSID. Damp spurious
1252 * change-of-BSSID indications.
1254 if ((ifp
->if_flags
& IFF_PROMISC
) != 0 &&
1255 !ppsratecheck(&sc
->sc_last_syn
, &sc
->sc_false_syns
,
1259 sc
->sc_false_syns
= MAX(0, sc
->sc_false_syns
- 1);
1262 * XXX hack; we should create a new node with the new bssid
1263 * and replace the existing ic_bss with it but since we don't
1264 * process management frames to collect state we cheat by
1265 * reusing the existing node as we know wi_newstate will be
1266 * called and it will overwrite the node state.
1268 ieee80211_sta_join(ic
, ieee80211_ref_node(ni
));
1272 static __noinline
void
1273 wi_rx_intr(struct wi_softc
*sc
)
1275 struct ifnet
*ifp
= sc
->sc_ifp
;
1276 struct ieee80211com
*ic
= ifp
->if_l2com
;
1277 struct wi_frame frmhdr
;
1279 struct ieee80211_frame
*wh
;
1280 struct ieee80211_node
*ni
;
1286 fid
= CSR_READ_2(sc
, WI_RX_FID
);
1288 /* First read in the frame header */
1289 if (wi_read_bap(sc
, fid
, 0, &frmhdr
, sizeof(frmhdr
))) {
1290 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_RX
);
1292 DPRINTF(("wi_rx_intr: read fid %x failed\n", fid
));
1297 * Drop undecryptable or packets with receive errors here
1299 status
= le16toh(frmhdr
.wi_status
);
1300 if (status
& WI_STAT_ERRSTAT
) {
1301 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_RX
);
1303 DPRINTF(("wi_rx_intr: fid %x error status %x\n", fid
, status
));
1307 len
= le16toh(frmhdr
.wi_dat_len
);
1308 off
= ALIGN(sizeof(struct ieee80211_frame
));
1311 * Sometimes the PRISM2.x returns bogusly large frames. Except
1312 * in monitor mode, just throw them away.
1314 if (off
+ len
> MCLBYTES
) {
1315 if (ic
->ic_opmode
!= IEEE80211_M_MONITOR
) {
1316 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_RX
);
1318 DPRINTF(("wi_rx_intr: oversized packet\n"));
1324 if (off
+ len
> MHLEN
)
1325 m
= m_getcl(MB_DONTWAIT
, MT_DATA
, M_PKTHDR
);
1327 m
= m_gethdr(MB_DONTWAIT
, MT_DATA
);
1329 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_RX
);
1331 DPRINTF(("wi_rx_intr: MGET failed\n"));
1334 m
->m_data
+= off
- sizeof(struct ieee80211_frame
);
1335 memcpy(m
->m_data
, &frmhdr
.wi_whdr
, sizeof(struct ieee80211_frame
));
1336 wi_read_bap(sc
, fid
, sizeof(frmhdr
),
1337 m
->m_data
+ sizeof(struct ieee80211_frame
), len
);
1338 m
->m_pkthdr
.len
= m
->m_len
= sizeof(struct ieee80211_frame
) + len
;
1339 m
->m_pkthdr
.rcvif
= ifp
;
1341 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_RX
);
1343 rssi
= frmhdr
.wi_rx_signal
;
1344 nf
= frmhdr
.wi_rx_silence
;
1345 if (ieee80211_radiotap_active(ic
)) {
1346 struct wi_rx_radiotap_header
*tap
= &sc
->sc_rx_th
;
1349 rstamp
= (le16toh(frmhdr
.wi_rx_tstamp0
) << 16) |
1350 le16toh(frmhdr
.wi_rx_tstamp1
);
1351 tap
->wr_tsf
= htole64((uint64_t)rstamp
);
1352 /* XXX replace divide by table */
1353 tap
->wr_rate
= frmhdr
.wi_rx_rate
/ 5;
1355 if (frmhdr
.wi_status
& WI_STAT_PCF
)
1356 tap
->wr_flags
|= IEEE80211_RADIOTAP_F_CFP
;
1357 if (m
->m_flags
& M_WEP
)
1358 tap
->wr_flags
|= IEEE80211_RADIOTAP_F_WEP
;
1359 tap
->wr_antsignal
= rssi
;
1360 tap
->wr_antnoise
= nf
;
1363 /* synchronize driver's BSSID with firmware's BSSID */
1364 wh
= mtod(m
, struct ieee80211_frame
*);
1365 dir
= wh
->i_fc
[1] & IEEE80211_FC1_DIR_MASK
;
1366 if (ic
->ic_opmode
== IEEE80211_M_IBSS
&& dir
== IEEE80211_FC1_DIR_NODS
)
1367 wi_sync_bssid(sc
, wh
->i_addr3
);
1369 ni
= ieee80211_find_rxnode(ic
, mtod(m
, struct ieee80211_frame_min
*));
1371 (void) ieee80211_input(ni
, m
, rssi
, nf
);
1372 ieee80211_free_node(ni
);
1374 (void) ieee80211_input_all(ic
, m
, rssi
, nf
);
1378 static __noinline
void
1379 wi_tx_ex_intr(struct wi_softc
*sc
)
1381 struct ifnet
*ifp
= sc
->sc_ifp
;
1382 struct wi_frame frmhdr
;
1385 fid
= CSR_READ_2(sc
, WI_TX_CMP_FID
);
1386 /* Read in the frame header */
1387 if (wi_read_bap(sc
, fid
, 0, &frmhdr
, sizeof(frmhdr
)) == 0) {
1388 u_int16_t status
= le16toh(frmhdr
.wi_status
);
1390 * Spontaneous station disconnects appear as xmit
1391 * errors. Don't announce them and/or count them
1392 * as an output error.
1394 if ((status
& WI_TXSTAT_DISCONNECT
) == 0) {
1395 if (ppsratecheck(&lasttxerror
, &curtxeps
, wi_txerate
)) {
1396 if_printf(ifp
, "tx failed");
1397 if (status
& WI_TXSTAT_RET_ERR
)
1398 kprintf(", retry limit exceeded");
1399 if (status
& WI_TXSTAT_AGED_ERR
)
1400 kprintf(", max transmit lifetime exceeded");
1401 if (status
& WI_TXSTAT_DISCONNECT
)
1402 kprintf(", port disconnected");
1403 if (status
& WI_TXSTAT_FORM_ERR
)
1404 kprintf(", invalid format (data len %u src %6D)",
1405 le16toh(frmhdr
.wi_dat_len
),
1406 frmhdr
.wi_ehdr
.ether_shost
, ":");
1408 kprintf(", status=0x%x", status
);
1413 DPRINTF(("port disconnected\n"));
1414 ifp
->if_collisions
++; /* XXX */
1417 DPRINTF(("wi_tx_ex_intr: read fid %x failed\n", fid
));
1418 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_TX_EXC
);
1421 static __noinline
void
1422 wi_tx_intr(struct wi_softc
*sc
)
1424 struct ifnet
*ifp
= sc
->sc_ifp
;
1430 fid
= CSR_READ_2(sc
, WI_ALLOC_FID
);
1431 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_ALLOC
);
1434 if (sc
->sc_txd
[cur
].d_fid
!= fid
) {
1435 if_printf(ifp
, "bad alloc %x != %x, cur %d nxt %d\n",
1436 fid
, sc
->sc_txd
[cur
].d_fid
, cur
, sc
->sc_txnext
);
1439 sc
->sc_tx_timer
= 0;
1440 sc
->sc_txd
[cur
].d_len
= 0;
1441 sc
->sc_txcur
= cur
= (cur
+ 1) % sc
->sc_ntxbuf
;
1442 if (sc
->sc_txd
[cur
].d_len
== 0)
1443 ifp
->if_flags
&= ~IFF_OACTIVE
;
1445 if (wi_cmd(sc
, WI_CMD_TX
| WI_RECLAIM
, sc
->sc_txd
[cur
].d_fid
,
1447 if_printf(ifp
, "xmit failed\n");
1448 sc
->sc_txd
[cur
].d_len
= 0;
1450 sc
->sc_tx_timer
= 5;
1455 static __noinline
void
1456 wi_info_intr(struct wi_softc
*sc
)
1458 struct ifnet
*ifp
= sc
->sc_ifp
;
1459 struct ieee80211com
*ic
= ifp
->if_l2com
;
1460 struct ieee80211vap
*vap
= TAILQ_FIRST(&ic
->ic_vaps
);
1461 int i
, fid
, len
, off
;
1466 fid
= CSR_READ_2(sc
, WI_INFO_FID
);
1467 wi_read_bap(sc
, fid
, 0, ltbuf
, sizeof(ltbuf
));
1469 switch (le16toh(ltbuf
[1])) {
1470 case WI_INFO_LINK_STAT
:
1471 wi_read_bap(sc
, fid
, sizeof(ltbuf
), &stat
, sizeof(stat
));
1472 DPRINTF(("wi_info_intr: LINK_STAT 0x%x\n", le16toh(stat
)));
1473 switch (le16toh(stat
)) {
1474 case WI_INFO_LINK_STAT_CONNECTED
:
1475 if (vap
->iv_state
== IEEE80211_S_RUN
&&
1476 vap
->iv_opmode
!= IEEE80211_M_IBSS
)
1479 case WI_INFO_LINK_STAT_AP_CHG
:
1480 vap
->iv_bss
->ni_associd
= 1 | 0xc000; /* NB: anything will do */
1481 ieee80211_new_state(vap
, IEEE80211_S_RUN
, 0);
1483 case WI_INFO_LINK_STAT_AP_INR
:
1485 case WI_INFO_LINK_STAT_DISCONNECTED
:
1486 /* we dropped off the net; e.g. due to deauth/disassoc */
1487 vap
->iv_bss
->ni_associd
= 0;
1488 vap
->iv_stats
.is_rx_deauth
++;
1489 ieee80211_new_state(vap
, IEEE80211_S_SCAN
, 0);
1491 case WI_INFO_LINK_STAT_AP_OOR
:
1492 /* XXX does this need to be per-vap? */
1493 ieee80211_beacon_miss(ic
);
1495 case WI_INFO_LINK_STAT_ASSOC_FAILED
:
1496 if (vap
->iv_opmode
== IEEE80211_M_STA
)
1497 ieee80211_new_state(vap
, IEEE80211_S_SCAN
,
1498 IEEE80211_SCAN_FAIL_TIMEOUT
);
1502 case WI_INFO_COUNTERS
:
1503 /* some card versions have a larger stats structure */
1504 len
= min(le16toh(ltbuf
[0]) - 1, sizeof(sc
->sc_stats
) / 4);
1505 ptr
= (u_int32_t
*)&sc
->sc_stats
;
1506 off
= sizeof(ltbuf
);
1507 for (i
= 0; i
< len
; i
++, off
+= 2, ptr
++) {
1508 wi_read_bap(sc
, fid
, off
, &stat
, sizeof(stat
));
1509 #ifdef WI_HERMES_STATS_WAR
1515 ifp
->if_collisions
= sc
->sc_stats
.wi_tx_single_retries
+
1516 sc
->sc_stats
.wi_tx_multi_retries
+
1517 sc
->sc_stats
.wi_tx_retry_limit
;
1520 DPRINTF(("wi_info_intr: got fid %x type %x len %d\n", fid
,
1521 le16toh(ltbuf
[1]), le16toh(ltbuf
[0])));
1524 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_INFO
);
1528 wi_write_multi(struct wi_softc
*sc
)
1530 struct ifnet
*ifp
= sc
->sc_ifp
;
1532 struct ifmultiaddr
*ifma
;
1533 struct wi_mcast mlist
;
1535 if (ifp
->if_flags
& IFF_ALLMULTI
|| ifp
->if_flags
& IFF_PROMISC
) {
1537 memset(&mlist
, 0, sizeof(mlist
));
1538 return wi_write_rid(sc
, WI_RID_MCAST_LIST
, &mlist
,
1544 if_maddr_rlock(ifp
);
1546 TAILQ_FOREACH(ifma
, &ifp
->if_multiaddrs
, ifma_link
) {
1547 if (ifma
->ifma_addr
->sa_family
!= AF_LINK
)
1551 IEEE80211_ADDR_COPY(&mlist
.wi_mcast
[n
],
1552 (LLADDR((struct sockaddr_dl
*)ifma
->ifma_addr
)));
1556 if_maddr_runlock(ifp
);
1558 return wi_write_rid(sc
, WI_RID_MCAST_LIST
, &mlist
,
1559 IEEE80211_ADDR_LEN
* n
);
1563 wi_update_mcast(struct ifnet
*ifp
)
1565 wi_write_multi(ifp
->if_softc
);
1569 wi_update_promisc(struct ifnet
*ifp
)
1571 struct wi_softc
*sc
= ifp
->if_softc
;
1572 struct ieee80211com
*ic
= ifp
->if_l2com
;
1574 /* XXX handle WEP special case handling? */
1575 wi_write_val(sc
, WI_RID_PROMISC
,
1576 (ic
->ic_opmode
== IEEE80211_M_MONITOR
||
1577 (ifp
->if_flags
& IFF_PROMISC
)));
1581 wi_read_nicid(struct wi_softc
*sc
)
1583 struct wi_card_ident
*id
;
1588 /* getting chip identity */
1589 memset(ver
, 0, sizeof(ver
));
1591 wi_read_rid(sc
, WI_RID_CARD_ID
, ver
, &len
);
1593 sc
->sc_firmware_type
= WI_NOTYPE
;
1594 sc
->sc_nic_id
= le16toh(ver
[0]);
1595 for (id
= wi_card_ident
; id
->card_name
!= NULL
; id
++) {
1596 if (sc
->sc_nic_id
== id
->card_id
) {
1597 sc
->sc_nic_name
= id
->card_name
;
1598 sc
->sc_firmware_type
= id
->firm_type
;
1602 if (sc
->sc_firmware_type
== WI_NOTYPE
) {
1603 if (sc
->sc_nic_id
& 0x8000) {
1604 sc
->sc_firmware_type
= WI_INTERSIL
;
1605 sc
->sc_nic_name
= "Unknown Prism chip";
1607 sc
->sc_firmware_type
= WI_LUCENT
;
1608 sc
->sc_nic_name
= "Unknown Lucent chip";
1612 device_printf(sc
->sc_dev
, "using %s\n", sc
->sc_nic_name
);
1614 /* get primary firmware version (Only Prism chips) */
1615 if (sc
->sc_firmware_type
!= WI_LUCENT
) {
1616 memset(ver
, 0, sizeof(ver
));
1618 wi_read_rid(sc
, WI_RID_PRI_IDENTITY
, ver
, &len
);
1619 sc
->sc_pri_firmware_ver
= le16toh(ver
[2]) * 10000 +
1620 le16toh(ver
[3]) * 100 + le16toh(ver
[1]);
1623 /* get station firmware version */
1624 memset(ver
, 0, sizeof(ver
));
1626 wi_read_rid(sc
, WI_RID_STA_IDENTITY
, ver
, &len
);
1627 sc
->sc_sta_firmware_ver
= le16toh(ver
[2]) * 10000 +
1628 le16toh(ver
[3]) * 100 + le16toh(ver
[1]);
1629 if (sc
->sc_firmware_type
== WI_INTERSIL
&&
1630 (sc
->sc_sta_firmware_ver
== 10102 ||
1631 sc
->sc_sta_firmware_ver
== 20102)) {
1633 memset(ident
, 0, sizeof(ident
));
1634 len
= sizeof(ident
);
1635 /* value should be the format like "V2.00-11" */
1636 if (wi_read_rid(sc
, WI_RID_SYMBOL_IDENTITY
, ident
, &len
) == 0 &&
1637 *(p
= (char *)ident
) >= 'A' &&
1638 p
[2] == '.' && p
[5] == '-' && p
[8] == '\0') {
1639 sc
->sc_firmware_type
= WI_SYMBOL
;
1640 sc
->sc_sta_firmware_ver
= (p
[1] - '0') * 10000 +
1641 (p
[3] - '0') * 1000 + (p
[4] - '0') * 100 +
1642 (p
[6] - '0') * 10 + (p
[7] - '0');
1646 device_printf(sc
->sc_dev
, "%s Firmware: ",
1647 wi_firmware_names
[sc
->sc_firmware_type
]);
1648 if (sc
->sc_firmware_type
!= WI_LUCENT
) /* XXX */
1649 kprintf("Primary (%u.%u.%u), ",
1650 sc
->sc_pri_firmware_ver
/ 10000,
1651 (sc
->sc_pri_firmware_ver
% 10000) / 100,
1652 sc
->sc_pri_firmware_ver
% 100);
1653 kprintf("Station (%u.%u.%u)\n",
1654 sc
->sc_sta_firmware_ver
/ 10000,
1655 (sc
->sc_sta_firmware_ver
% 10000) / 100,
1656 sc
->sc_sta_firmware_ver
% 100);
1661 wi_write_ssid(struct wi_softc
*sc
, int rid
, u_int8_t
*buf
, int buflen
)
1663 struct wi_ssid ssid
;
1665 if (buflen
> IEEE80211_NWID_LEN
)
1667 memset(&ssid
, 0, sizeof(ssid
));
1668 ssid
.wi_len
= htole16(buflen
);
1669 memcpy(ssid
.wi_ssid
, buf
, buflen
);
1670 return wi_write_rid(sc
, rid
, &ssid
, sizeof(ssid
));
1674 wi_write_txrate(struct wi_softc
*sc
, struct ieee80211vap
*vap
)
1676 static const uint16_t lucent_rates
[12] = {
1677 [ 0] = 3, /* auto */
1678 [ 1] = 1, /* 1Mb/s */
1679 [ 2] = 2, /* 2Mb/s */
1680 [ 5] = 4, /* 5.5Mb/s */
1681 [11] = 5 /* 11Mb/s */
1683 static const uint16_t intersil_rates
[12] = {
1684 [ 0] = 0xf, /* auto */
1685 [ 1] = 0, /* 1Mb/s */
1686 [ 2] = 1, /* 2Mb/s */
1687 [ 5] = 2, /* 5.5Mb/s */
1688 [11] = 3, /* 11Mb/s */
1690 const uint16_t *rates
= sc
->sc_firmware_type
== WI_LUCENT
?
1691 lucent_rates
: intersil_rates
;
1692 struct ieee80211com
*ic
= vap
->iv_ic
;
1693 const struct ieee80211_txparam
*tp
;
1695 tp
= &vap
->iv_txparms
[ieee80211_chan2mode(ic
->ic_bsschan
)];
1696 return wi_write_val(sc
, WI_RID_TX_RATE
,
1697 (tp
->ucastrate
== IEEE80211_FIXED_RATE_NONE
?
1698 rates
[0] : rates
[tp
->ucastrate
/ 2]));
1702 wi_write_wep(struct wi_softc
*sc
, struct ieee80211vap
*vap
)
1707 struct wi_key wkey
[IEEE80211_WEP_NKID
];
1709 switch (sc
->sc_firmware_type
) {
1711 val
= (vap
->iv_flags
& IEEE80211_F_PRIVACY
) ? 1 : 0;
1712 error
= wi_write_val(sc
, WI_RID_ENCRYPTION
, val
);
1715 if ((vap
->iv_flags
& IEEE80211_F_PRIVACY
) == 0)
1717 error
= wi_write_val(sc
, WI_RID_TX_CRYPT_KEY
, vap
->iv_def_txkey
);
1720 memset(wkey
, 0, sizeof(wkey
));
1721 for (i
= 0; i
< IEEE80211_WEP_NKID
; i
++) {
1722 keylen
= vap
->iv_nw_keys
[i
].wk_keylen
;
1723 wkey
[i
].wi_keylen
= htole16(keylen
);
1724 memcpy(wkey
[i
].wi_keydat
, vap
->iv_nw_keys
[i
].wk_key
,
1727 error
= wi_write_rid(sc
, WI_RID_DEFLT_CRYPT_KEYS
,
1728 wkey
, sizeof(wkey
));
1729 sc
->sc_encryption
= 0;
1733 val
= HOST_ENCRYPT
| HOST_DECRYPT
;
1734 if (vap
->iv_flags
& IEEE80211_F_PRIVACY
) {
1736 * ONLY HWB3163 EVAL-CARD Firmware version
1737 * less than 0.8 variant2
1739 * If promiscuous mode disable, Prism2 chip
1740 * does not work with WEP .
1741 * It is under investigation for details.
1742 * (ichiro@netbsd.org)
1744 if (sc
->sc_sta_firmware_ver
< 802 ) {
1745 /* firm ver < 0.8 variant 2 */
1746 wi_write_val(sc
, WI_RID_PROMISC
, 1);
1748 wi_write_val(sc
, WI_RID_CNFAUTHMODE
,
1749 vap
->iv_bss
->ni_authmode
);
1750 val
|= PRIVACY_INVOKED
;
1752 wi_write_val(sc
, WI_RID_CNFAUTHMODE
, IEEE80211_AUTH_OPEN
);
1754 error
= wi_write_val(sc
, WI_RID_P2_ENCRYPTION
, val
);
1757 sc
->sc_encryption
= val
;
1758 if ((val
& PRIVACY_INVOKED
) == 0)
1760 error
= wi_write_val(sc
, WI_RID_P2_TX_CRYPT_KEY
, vap
->iv_def_txkey
);
1767 wi_cmd(struct wi_softc
*sc
, int cmd
, int val0
, int val1
, int val2
)
1774 /* wait for the busy bit to clear */
1775 for (i
= sc
->wi_cmd_count
; i
> 0; i
--) { /* 500ms */
1776 if (!(CSR_READ_2(sc
, WI_COMMAND
) & WI_CMD_BUSY
))
1778 DELAY(1*1000); /* 1ms */
1781 device_printf(sc
->sc_dev
, "%s: busy bit won't clear, cmd 0x%x\n",
1787 CSR_WRITE_2(sc
, WI_PARAM0
, val0
);
1788 CSR_WRITE_2(sc
, WI_PARAM1
, val1
);
1789 CSR_WRITE_2(sc
, WI_PARAM2
, val2
);
1790 CSR_WRITE_2(sc
, WI_COMMAND
, cmd
);
1792 if (cmd
== WI_CMD_INI
) {
1793 /* XXX: should sleep here. */
1794 DELAY(100*1000); /* 100ms delay for init */
1796 for (i
= 0; i
< WI_TIMEOUT
; i
++) {
1798 * Wait for 'command complete' bit to be
1799 * set in the event status register.
1801 s
= CSR_READ_2(sc
, WI_EVENT_STAT
);
1802 if (s
& WI_EV_CMD
) {
1803 /* Ack the event and read result code. */
1804 s
= CSR_READ_2(sc
, WI_STATUS
);
1805 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_CMD
);
1806 if (s
& WI_STAT_CMD_RESULT
) {
1814 if (i
== WI_TIMEOUT
) {
1815 device_printf(sc
->sc_dev
, "%s: timeout on cmd 0x%04x; "
1816 "event status 0x%04x\n", __func__
, cmd
, s
);
1825 wi_seek_bap(struct wi_softc
*sc
, int id
, int off
)
1829 CSR_WRITE_2(sc
, WI_SEL0
, id
);
1830 CSR_WRITE_2(sc
, WI_OFF0
, off
);
1832 for (i
= 0; ; i
++) {
1833 status
= CSR_READ_2(sc
, WI_OFF0
);
1834 if ((status
& WI_OFF_BUSY
) == 0)
1836 if (i
== WI_TIMEOUT
) {
1837 device_printf(sc
->sc_dev
, "%s: timeout, id %x off %x\n",
1839 sc
->sc_bap_off
= WI_OFF_ERR
; /* invalidate */
1840 if (status
== 0xffff)
1846 if (status
& WI_OFF_ERR
) {
1847 device_printf(sc
->sc_dev
, "%s: error, id %x off %x\n",
1849 sc
->sc_bap_off
= WI_OFF_ERR
; /* invalidate */
1853 sc
->sc_bap_off
= off
;
1858 wi_read_bap(struct wi_softc
*sc
, int id
, int off
, void *buf
, int buflen
)
1865 if (id
!= sc
->sc_bap_id
|| off
!= sc
->sc_bap_off
) {
1866 if ((error
= wi_seek_bap(sc
, id
, off
)) != 0)
1869 cnt
= (buflen
+ 1) / 2;
1870 ptr
= (u_int16_t
*)buf
;
1871 for (i
= 0; i
< cnt
; i
++)
1872 *ptr
++ = CSR_READ_2(sc
, WI_DATA0
);
1873 sc
->sc_bap_off
+= cnt
* 2;
1878 wi_write_bap(struct wi_softc
*sc
, int id
, int off
, void *buf
, int buflen
)
1886 if (id
!= sc
->sc_bap_id
|| off
!= sc
->sc_bap_off
) {
1887 if ((error
= wi_seek_bap(sc
, id
, off
)) != 0)
1890 cnt
= (buflen
+ 1) / 2;
1891 ptr
= (u_int16_t
*)buf
;
1892 for (i
= 0; i
< cnt
; i
++)
1893 CSR_WRITE_2(sc
, WI_DATA0
, ptr
[i
]);
1894 sc
->sc_bap_off
+= cnt
* 2;
1900 wi_mwrite_bap(struct wi_softc
*sc
, int id
, int off
, struct mbuf
*m0
, int totlen
)
1905 for (m
= m0
; m
!= NULL
&& totlen
> 0; m
= m
->m_next
) {
1909 len
= min(m
->m_len
, totlen
);
1911 if (((u_long
)m
->m_data
) % 2 != 0 || len
% 2 != 0) {
1912 m_copydata(m
, 0, totlen
, (caddr_t
)&sc
->sc_txbuf
);
1913 return wi_write_bap(sc
, id
, off
, (caddr_t
)&sc
->sc_txbuf
,
1917 if ((error
= wi_write_bap(sc
, id
, off
, m
->m_data
, len
)) != 0)
1927 wi_alloc_fid(struct wi_softc
*sc
, int len
, int *idp
)
1931 if (wi_cmd(sc
, WI_CMD_ALLOC_MEM
, len
, 0, 0)) {
1932 device_printf(sc
->sc_dev
, "%s: failed to allocate %d bytes on NIC\n",
1937 for (i
= 0; i
< WI_TIMEOUT
; i
++) {
1938 if (CSR_READ_2(sc
, WI_EVENT_STAT
) & WI_EV_ALLOC
)
1942 if (i
== WI_TIMEOUT
) {
1943 device_printf(sc
->sc_dev
, "%s: timeout in alloc\n", __func__
);
1946 *idp
= CSR_READ_2(sc
, WI_ALLOC_FID
);
1947 CSR_WRITE_2(sc
, WI_EVENT_ACK
, WI_EV_ALLOC
);
1952 wi_read_rid(struct wi_softc
*sc
, int rid
, void *buf
, int *buflenp
)
1957 /* Tell the NIC to enter record read mode. */
1958 error
= wi_cmd(sc
, WI_CMD_ACCESS
| WI_ACCESS_READ
, rid
, 0, 0);
1962 error
= wi_read_bap(sc
, rid
, 0, ltbuf
, sizeof(ltbuf
));
1966 if (le16toh(ltbuf
[1]) != rid
) {
1967 device_printf(sc
->sc_dev
, "record read mismatch, rid=%x, got=%x\n",
1968 rid
, le16toh(ltbuf
[1]));
1971 len
= (le16toh(ltbuf
[0]) - 1) * 2; /* already got rid */
1972 if (*buflenp
< len
) {
1973 device_printf(sc
->sc_dev
, "record buffer is too small, "
1974 "rid=%x, size=%d, len=%d\n",
1975 rid
, *buflenp
, len
);
1979 return wi_read_bap(sc
, rid
, sizeof(ltbuf
), buf
, len
);
1983 wi_write_rid(struct wi_softc
*sc
, int rid
, void *buf
, int buflen
)
1988 ltbuf
[0] = htole16((buflen
+ 1) / 2 + 1); /* includes rid */
1989 ltbuf
[1] = htole16(rid
);
1991 error
= wi_write_bap(sc
, rid
, 0, ltbuf
, sizeof(ltbuf
));
1993 device_printf(sc
->sc_dev
, "%s: bap0 write failure, rid 0x%x\n",
1997 error
= wi_write_bap(sc
, rid
, sizeof(ltbuf
), buf
, buflen
);
1999 device_printf(sc
->sc_dev
, "%s: bap1 write failure, rid 0x%x\n",
2004 return wi_cmd(sc
, WI_CMD_ACCESS
| WI_ACCESS_WRITE
, rid
, 0, 0);
2008 wi_write_appie(struct wi_softc
*sc
, int rid
, const struct ieee80211_appie
*ie
)
2010 /* NB: 42 bytes is probably ok to have on the stack */
2011 char buf
[sizeof(uint16_t) + 40];
2013 if (ie
->ie_len
> 40)
2015 /* NB: firmware requires 16-bit ie length before ie data */
2016 *(uint16_t *) buf
= htole16(ie
->ie_len
);
2017 memcpy(buf
+ sizeof(uint16_t), ie
->ie_data
, ie
->ie_len
);
2018 return wi_write_rid(sc
, rid
, buf
, ie
->ie_len
+ sizeof(uint16_t));
2022 wi_alloc(device_t dev
, int rid
)
2024 struct wi_softc
*sc
= device_get_softc(dev
);
2026 if (sc
->wi_bus_type
!= WI_BUS_PCI_NATIVE
) {
2027 sc
->iobase_rid
= rid
;
2028 sc
->iobase
= bus_alloc_resource(dev
, SYS_RES_IOPORT
,
2029 &sc
->iobase_rid
, 0, ~0, (1 << 6),
2030 rman_make_alignment_flags(1 << 6) | RF_ACTIVE
);
2031 if (sc
->iobase
== NULL
) {
2032 device_printf(dev
, "No I/O space?!\n");
2036 sc
->wi_io_addr
= rman_get_start(sc
->iobase
);
2037 sc
->wi_btag
= rman_get_bustag(sc
->iobase
);
2038 sc
->wi_bhandle
= rman_get_bushandle(sc
->iobase
);
2041 sc
->mem
= bus_alloc_resource_any(dev
, SYS_RES_MEMORY
,
2042 &sc
->mem_rid
, RF_ACTIVE
);
2043 if (sc
->mem
== NULL
) {
2044 device_printf(dev
, "No Mem space on prism2.5?\n");
2048 sc
->wi_btag
= rman_get_bustag(sc
->mem
);
2049 sc
->wi_bhandle
= rman_get_bushandle(sc
->mem
);
2053 sc
->irq
= bus_alloc_resource_any(dev
, SYS_RES_IRQ
, &sc
->irq_rid
,
2055 ((sc
->wi_bus_type
== WI_BUS_PCCARD
) ? 0 : RF_SHAREABLE
));
2056 if (sc
->irq
== NULL
) {
2058 device_printf(dev
, "No irq?!\n");
2063 sc
->sc_unit
= device_get_unit(dev
);
2068 wi_free(device_t dev
)
2070 struct wi_softc
*sc
= device_get_softc(dev
);
2072 if (sc
->iobase
!= NULL
) {
2073 bus_release_resource(dev
, SYS_RES_IOPORT
, sc
->iobase_rid
, sc
->iobase
);
2076 if (sc
->irq
!= NULL
) {
2077 bus_release_resource(dev
, SYS_RES_IRQ
, sc
->irq_rid
, sc
->irq
);
2080 if (sc
->mem
!= NULL
) {
2081 bus_release_resource(dev
, SYS_RES_MEMORY
, sc
->mem_rid
, sc
->mem
);