![[BACK]](/icons/back.gif){kind=icon}
Return to if_wi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to if_wi.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: if_wi.c,v 1.137 2006/11/26 19:46:28 deraadt Exp $ */
2:
3: /*
4: * Copyright (c) 1997, 1998, 1999
5: * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Bill Paul.
18: * 4. Neither the name of the author nor the names of any co-contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
26: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32: * THE POSSIBILITY OF SUCH DAMAGE.
33: *
34: * From: if_wi.c,v 1.7 1999/07/04 14:40:22 wpaul Exp $
35: */
36:
37: /*
38: * Lucent WaveLAN/IEEE 802.11 driver for OpenBSD.
39: *
40: * Originally written by Bill Paul <wpaul@ctr.columbia.edu>
41: * Electrical Engineering Department
42: * Columbia University, New York City
43: */
44:
45: /*
46: * The WaveLAN/IEEE adapter is the second generation of the WaveLAN
47: * from Lucent. Unlike the older cards, the new ones are programmed
48: * entirely via a firmware-driven controller called the Hermes.
49: * Unfortunately, Lucent will not release the Hermes programming manual
50: * without an NDA (if at all). What they do release is an API library
51: * called the HCF (Hardware Control Functions) which is supposed to
52: * do the device-specific operations of a device driver for you. The
53: * publicly available version of the HCF library (the 'HCF Light') is
54: * a) extremely gross, b) lacks certain features, particularly support
55: * for 802.11 frames, and c) is contaminated by the GNU Public License.
56: *
57: * This driver does not use the HCF or HCF Light at all. Instead, it
58: * programs the Hermes controller directly, using information gleaned
59: * from the HCF Light code and corresponding documentation.
60: */
61:
62: #define WI_HERMES_AUTOINC_WAR /* Work around data write autoinc bug. */
63: #define WI_HERMES_STATS_WAR /* Work around stats counter bug. */
64:
65: #include "bpfilter.h"
66:
67: #include <sys/param.h>
68: #include <sys/systm.h>
69: #include <sys/sockio.h>
70: #include <sys/mbuf.h>
71: #include <sys/malloc.h>
72: #include <sys/kernel.h>
73: #include <sys/proc.h>
74: #include <sys/socket.h>
75: #include <sys/device.h>
76:
77: #include <net/if.h>
78: #include <net/if_dl.h>
79: #include <net/if_media.h>
80: #include <net/if_types.h>
81:
82: #ifdef INET
83: #include <netinet/in.h>
84: #include <netinet/in_systm.h>
85: #include <netinet/in_var.h>
86: #include <netinet/ip.h>
87: #include <netinet/if_ether.h>
88: #endif
89:
90: #include <net80211/ieee80211_var.h>
91: #include <net80211/ieee80211_ioctl.h>
92:
93: #if NBPFILTER > 0
94: #include <net/bpf.h>
95: #endif
96:
97: #include <machine/bus.h>
98:
99: #include <dev/rndvar.h>
100:
101: #include <dev/ic/if_wireg.h>
102: #include <dev/ic/if_wi_ieee.h>
103: #include <dev/ic/if_wivar.h>
104:
105: #include <crypto/arc4.h>
106:
107: #define BPFATTACH(if_bpf,if,dlt,sz)
108: #define STATIC
109:
110: #ifdef WIDEBUG
111:
112: u_int32_t widebug = WIDEBUG;
113:
114: #define WID_INTR 0x01
115: #define WID_START 0x02
116: #define WID_IOCTL 0x04
117: #define WID_INIT 0x08
118: #define WID_STOP 0x10
119: #define WID_RESET 0x20
120:
121: #define DPRINTF(mask,args) if (widebug & (mask)) printf args;
122:
123: #else /* !WIDEBUG */
124: #define DPRINTF(mask,args)
125: #endif /* WIDEBUG */
126:
127: #if !defined(lint) && !defined(__OpenBSD__)
128: static const char rcsid[] =
129: "$OpenBSD: if_wi.c,v 1.137 2006/11/26 19:46:28 deraadt Exp $";
130: #endif /* lint */
131:
132: #ifdef foo
133: static u_int8_t wi_mcast_addr[6] = { 0x01, 0x60, 0x1D, 0x00, 0x01, 0x00 };
134: #endif
135:
136: STATIC void wi_reset(struct wi_softc *);
137: STATIC int wi_ioctl(struct ifnet *, u_long, caddr_t);
138: STATIC void wi_init_io(struct wi_softc *);
139: STATIC void wi_start(struct ifnet *);
140: STATIC void wi_watchdog(struct ifnet *);
141: STATIC void wi_shutdown(void *);
142: STATIC void wi_rxeof(struct wi_softc *);
143: STATIC void wi_txeof(struct wi_softc *, int);
144: STATIC void wi_update_stats(struct wi_softc *);
145: STATIC void wi_setmulti(struct wi_softc *);
146:
147: STATIC int wi_cmd_io(struct wi_softc *, int, int, int, int);
148: STATIC int wi_read_record_io(struct wi_softc *, struct wi_ltv_gen *);
149: STATIC int wi_write_record_io(struct wi_softc *, struct wi_ltv_gen *);
150: STATIC int wi_read_data_io(struct wi_softc *, int,
151: int, caddr_t, int);
152: STATIC int wi_write_data_io(struct wi_softc *, int,
153: int, caddr_t, int);
154: STATIC int wi_seek(struct wi_softc *, int, int, int);
155:
156: STATIC void wi_inquire(void *);
157: STATIC int wi_setdef(struct wi_softc *, struct wi_req *);
158: STATIC void wi_get_id(struct wi_softc *);
159:
160: STATIC int wi_media_change(struct ifnet *);
161: STATIC void wi_media_status(struct ifnet *, struct ifmediareq *);
162:
163: STATIC int wi_set_ssid(struct ieee80211_nwid *, u_int8_t *, int);
164: STATIC int wi_set_nwkey(struct wi_softc *, struct ieee80211_nwkey *);
165: STATIC int wi_get_nwkey(struct wi_softc *, struct ieee80211_nwkey *);
166: STATIC int wi_sync_media(struct wi_softc *, int, int);
167: STATIC int wi_set_pm(struct wi_softc *, struct ieee80211_power *);
168: STATIC int wi_get_pm(struct wi_softc *, struct ieee80211_power *);
169: STATIC int wi_set_txpower(struct wi_softc *, struct ieee80211_txpower *);
170: STATIC int wi_get_txpower(struct wi_softc *, struct ieee80211_txpower *);
171:
172: STATIC int wi_get_debug(struct wi_softc *, struct wi_req *);
173: STATIC int wi_set_debug(struct wi_softc *, struct wi_req *);
174:
175: STATIC void wi_do_hostencrypt(struct wi_softc *, caddr_t, int);
176: STATIC int wi_do_hostdecrypt(struct wi_softc *, caddr_t, int);
177:
178: STATIC int wi_alloc_nicmem_io(struct wi_softc *, int, int *);
179: STATIC int wi_get_fid_io(struct wi_softc *sc, int fid);
180: STATIC void wi_intr_enable(struct wi_softc *sc, int mode);
181: STATIC void wi_intr_ack(struct wi_softc *sc, int mode);
182: void wi_scan_timeout(void *);
183:
184: /* Autoconfig definition of driver back-end */
185: struct cfdriver wi_cd = {
186: NULL, "wi", DV_IFNET
187: };
188:
189: const struct wi_card_ident wi_card_ident[] = {
190: WI_CARD_IDS
191: };
192:
193: struct wi_funcs wi_func_io = {
194: wi_cmd_io,
195: wi_read_record_io,
196: wi_write_record_io,
197: wi_alloc_nicmem_io,
198: wi_read_data_io,
199: wi_write_data_io,
200: wi_get_fid_io,
201: wi_init_io,
202:
203: wi_start,
204: wi_ioctl,
205: wi_watchdog,
206: wi_inquire,
207: };
208:
209: int
210: wi_attach(struct wi_softc *sc, struct wi_funcs *funcs)
211: {
212: struct ieee80211com *ic;
213: struct ifnet *ifp;
214: struct wi_ltv_macaddr mac;
215: struct wi_ltv_rates rates;
216: struct wi_ltv_gen gen;
217: int error;
218:
219: ic = &sc->sc_ic;
220: ifp = &ic->ic_if;
221:
222: sc->sc_funcs = funcs;
223: sc->wi_cmd_count = 500;
224:
225: wi_reset(sc);
226:
227: /* Read the station address. */
228: mac.wi_type = WI_RID_MAC_NODE;
229: mac.wi_len = 4;
230: error = wi_read_record(sc, (struct wi_ltv_gen *)&mac);
231: if (error) {
232: printf(": unable to read station address\n");
233: return (error);
234: }
235: bcopy((char *)&mac.wi_mac_addr, (char *)&ic->ic_myaddr,
236: IEEE80211_ADDR_LEN);
237:
238: wi_get_id(sc);
239: printf("address %s", ether_sprintf(ic->ic_myaddr));
240:
241: bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
242: ifp->if_softc = sc;
243: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
244: ifp->if_ioctl = funcs->f_ioctl;
245: ifp->if_start = funcs->f_start;
246: ifp->if_watchdog = funcs->f_watchdog;
247: ifp->if_baudrate = 10000000;
248: IFQ_SET_READY(&ifp->if_snd);
249:
250: (void)wi_set_ssid(&sc->wi_node_name, WI_DEFAULT_NODENAME,
251: sizeof(WI_DEFAULT_NODENAME) - 1);
252: (void)wi_set_ssid(&sc->wi_net_name, WI_DEFAULT_NETNAME,
253: sizeof(WI_DEFAULT_NETNAME) - 1);
254: (void)wi_set_ssid(&sc->wi_ibss_name, WI_DEFAULT_IBSS,
255: sizeof(WI_DEFAULT_IBSS) - 1);
256:
257: sc->wi_portnum = WI_DEFAULT_PORT;
258: sc->wi_ptype = WI_PORTTYPE_BSS;
259: sc->wi_ap_density = WI_DEFAULT_AP_DENSITY;
260: sc->wi_rts_thresh = WI_DEFAULT_RTS_THRESH;
261: sc->wi_tx_rate = WI_DEFAULT_TX_RATE;
262: sc->wi_max_data_len = WI_DEFAULT_DATALEN;
263: sc->wi_create_ibss = WI_DEFAULT_CREATE_IBSS;
264: sc->wi_pm_enabled = WI_DEFAULT_PM_ENABLED;
265: sc->wi_max_sleep = WI_DEFAULT_MAX_SLEEP;
266: sc->wi_roaming = WI_DEFAULT_ROAMING;
267: sc->wi_authtype = WI_DEFAULT_AUTHTYPE;
268: sc->wi_diversity = WI_DEFAULT_DIVERSITY;
269: sc->wi_crypto_algorithm = WI_CRYPTO_FIRMWARE_WEP;
270:
271: /*
272: * Read the default channel from the NIC. This may vary
273: * depending on the country where the NIC was purchased, so
274: * we can't hard-code a default and expect it to work for
275: * everyone.
276: */
277: gen.wi_type = WI_RID_OWN_CHNL;
278: gen.wi_len = 2;
279: if (wi_read_record(sc, &gen) == 0)
280: sc->wi_channel = letoh16(gen.wi_val);
281: else
282: sc->wi_channel = 3;
283:
284: /*
285: * Set flags based on firmware version.
286: */
287: switch (sc->sc_firmware_type) {
288: case WI_LUCENT:
289: sc->wi_flags |= WI_FLAGS_HAS_ROAMING;
290: if (sc->sc_sta_firmware_ver >= 60000)
291: sc->wi_flags |= WI_FLAGS_HAS_MOR;
292: if (sc->sc_sta_firmware_ver >= 60006) {
293: sc->wi_flags |= WI_FLAGS_HAS_IBSS;
294: sc->wi_flags |= WI_FLAGS_HAS_CREATE_IBSS;
295: }
296: sc->wi_ibss_port = htole16(1);
297: break;
298: case WI_INTERSIL:
299: sc->wi_flags |= WI_FLAGS_HAS_ROAMING;
300: /* older prism firmware is slow so crank the count */
301: if (sc->sc_sta_firmware_ver < 10000)
302: sc->wi_cmd_count = 5000;
303: else
304: sc->wi_cmd_count = 2000;
305: if (sc->sc_sta_firmware_ver >= 800) {
306: #ifndef SMALL_KERNEL
307: /*
308: * USB hostap is more pain than it is worth
309: * for now, things would have to be overhauled
310: */
311: if ((sc->sc_sta_firmware_ver != 10402) &&
312: (!(sc->wi_flags & WI_FLAGS_BUS_USB)))
313: sc->wi_flags |= WI_FLAGS_HAS_HOSTAP;
314: #endif
315: sc->wi_flags |= WI_FLAGS_HAS_IBSS;
316: sc->wi_flags |= WI_FLAGS_HAS_CREATE_IBSS;
317: }
318: if (sc->sc_sta_firmware_ver >= 10603)
319: sc->wi_flags |= WI_FLAGS_HAS_ENH_SECURITY;
320: sc->wi_ibss_port = htole16(0);
321: break;
322: case WI_SYMBOL:
323: sc->wi_flags |= WI_FLAGS_HAS_DIVERSITY;
324: if (sc->sc_sta_firmware_ver >= 20000)
325: sc->wi_flags |= WI_FLAGS_HAS_IBSS;
326: if (sc->sc_sta_firmware_ver >= 25000)
327: sc->wi_flags |= WI_FLAGS_HAS_CREATE_IBSS;
328: sc->wi_ibss_port = htole16(4);
329: break;
330: }
331:
332: /*
333: * Find out if we support WEP on this card.
334: */
335: gen.wi_type = WI_RID_WEP_AVAIL;
336: gen.wi_len = 2;
337: if (wi_read_record(sc, &gen) == 0 && gen.wi_val != htole16(0))
338: sc->wi_flags |= WI_FLAGS_HAS_WEP;
339: timeout_set(&sc->sc_timo, funcs->f_inquire, sc);
340:
341: bzero((char *)&sc->wi_stats, sizeof(sc->wi_stats));
342:
343: /* Find supported rates. */
344: rates.wi_type = WI_RID_DATA_RATES;
345: rates.wi_len = sizeof(rates.wi_rates);
346: if (wi_read_record(sc, (struct wi_ltv_gen *)&rates) == 0) {
347: int i, nrates;
348:
349: nrates = letoh16(*(u_int16_t *)rates.wi_rates);
350: if (nrates > sizeof(rates.wi_rates) - 2)
351: nrates = sizeof(rates.wi_rates) - 2;
352:
353: sc->wi_supprates = 0;
354: for (i = 0; i < nrates; i++)
355: sc->wi_supprates |= rates.wi_rates[2 + i];
356: } else
357: sc->wi_supprates = WI_SUPPRATES_1M | WI_SUPPRATES_2M |
358: WI_SUPPRATES_5M | WI_SUPPRATES_11M;
359:
360: ifmedia_init(&sc->sc_media, 0, wi_media_change, wi_media_status);
361: #define ADD(m, c) ifmedia_add(&sc->sc_media, (m), (c), NULL)
362: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 0, 0), 0);
363: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, IFM_IEEE80211_ADHOC, 0), 0);
364: if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
365: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, IFM_IEEE80211_IBSS,
366: 0), 0);
367: if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
368: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO,
369: IFM_IEEE80211_IBSSMASTER, 0), 0);
370: if (sc->wi_flags & WI_FLAGS_HAS_HOSTAP)
371: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO,
372: IFM_IEEE80211_HOSTAP, 0), 0);
373: if (sc->wi_supprates & WI_SUPPRATES_1M) {
374: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1, 0, 0), 0);
375: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
376: IFM_IEEE80211_ADHOC, 0), 0);
377: if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
378: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
379: IFM_IEEE80211_IBSS, 0), 0);
380: if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
381: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
382: IFM_IEEE80211_IBSSMASTER, 0), 0);
383: if (sc->wi_flags & WI_FLAGS_HAS_HOSTAP)
384: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS1,
385: IFM_IEEE80211_HOSTAP, 0), 0);
386: }
387: if (sc->wi_supprates & WI_SUPPRATES_2M) {
388: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2, 0, 0), 0);
389: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
390: IFM_IEEE80211_ADHOC, 0), 0);
391: if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
392: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
393: IFM_IEEE80211_IBSS, 0), 0);
394: if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
395: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
396: IFM_IEEE80211_IBSSMASTER, 0), 0);
397: if (sc->wi_flags & WI_FLAGS_HAS_HOSTAP)
398: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS2,
399: IFM_IEEE80211_HOSTAP, 0), 0);
400: }
401: if (sc->wi_supprates & WI_SUPPRATES_5M) {
402: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5, 0, 0), 0);
403: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
404: IFM_IEEE80211_ADHOC, 0), 0);
405: if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
406: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
407: IFM_IEEE80211_IBSS, 0), 0);
408: if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
409: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
410: IFM_IEEE80211_IBSSMASTER, 0), 0);
411: if (sc->wi_flags & WI_FLAGS_HAS_HOSTAP)
412: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS5,
413: IFM_IEEE80211_HOSTAP, 0), 0);
414: }
415: if (sc->wi_supprates & WI_SUPPRATES_11M) {
416: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11, 0, 0), 0);
417: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
418: IFM_IEEE80211_ADHOC, 0), 0);
419: if (sc->wi_flags & WI_FLAGS_HAS_IBSS)
420: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
421: IFM_IEEE80211_IBSS, 0), 0);
422: if (sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)
423: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
424: IFM_IEEE80211_IBSSMASTER, 0), 0);
425: if (sc->wi_flags & WI_FLAGS_HAS_HOSTAP)
426: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_IEEE80211_DS11,
427: IFM_IEEE80211_HOSTAP, 0), 0);
428: ADD(IFM_MAKEWORD(IFM_IEEE80211, IFM_MANUAL, 0, 0), 0);
429: }
430: #undef ADD
431: ifmedia_set(&sc->sc_media,
432: IFM_MAKEWORD(IFM_IEEE80211, IFM_AUTO, 0, 0));
433:
434: /*
435: * Call MI attach routines.
436: */
437: if_attach(ifp);
438: memcpy(((struct arpcom *)ifp)->ac_enaddr, ic->ic_myaddr,
439: ETHER_ADDR_LEN);
440: ether_ifattach(ifp);
441: printf("\n");
442:
443: sc->wi_flags |= WI_FLAGS_ATTACHED;
444:
445: #if NBPFILTER > 0
446: BPFATTACH(&ifp->if_bpf, ifp, DLT_EN10MB, sizeof(struct ether_header));
447: #endif
448:
449: sc->sc_sdhook = shutdownhook_establish(wi_shutdown, sc);
450:
451: wi_init(sc);
452: wi_stop(sc);
453:
454: return (0);
455: }
456:
457: STATIC void
458: wi_intr_enable(struct wi_softc *sc, int mode)
459: {
460: if (!(sc->wi_flags & WI_FLAGS_BUS_USB))
461: CSR_WRITE_2(sc, WI_INT_EN, mode);
462: }
463:
464: STATIC void
465: wi_intr_ack(struct wi_softc *sc, int mode)
466: {
467: if (!(sc->wi_flags & WI_FLAGS_BUS_USB))
468: CSR_WRITE_2(sc, WI_EVENT_ACK, mode);
469: }
470:
471: int
472: wi_intr(void *vsc)
473: {
474: struct wi_softc *sc = vsc;
475: struct ifnet *ifp;
476: u_int16_t status;
477:
478: DPRINTF(WID_INTR, ("wi_intr: sc %p\n", sc));
479:
480: ifp = &sc->sc_ic.ic_if;
481:
482: if (!(sc->wi_flags & WI_FLAGS_ATTACHED) || !(ifp->if_flags & IFF_UP)) {
483: CSR_WRITE_2(sc, WI_INT_EN, 0);
484: CSR_WRITE_2(sc, WI_EVENT_ACK, 0xffff);
485: return (0);
486: }
487:
488: /* Disable interrupts. */
489: CSR_WRITE_2(sc, WI_INT_EN, 0);
490:
491: status = CSR_READ_2(sc, WI_EVENT_STAT);
492: CSR_WRITE_2(sc, WI_EVENT_ACK, ~WI_INTRS);
493:
494: if (status & WI_EV_RX) {
495: wi_rxeof(sc);
496: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_RX);
497: }
498:
499: if (status & WI_EV_TX) {
500: wi_txeof(sc, status);
501: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX);
502: }
503:
504: if (status & WI_EV_ALLOC) {
505: int id;
506: id = CSR_READ_2(sc, WI_ALLOC_FID);
507: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_ALLOC);
508: if (id == sc->wi_tx_data_id)
509: wi_txeof(sc, status);
510: }
511:
512: if (status & WI_EV_INFO) {
513: wi_update_stats(sc);
514: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_INFO);
515: }
516:
517: if (status & WI_EV_TX_EXC) {
518: wi_txeof(sc, status);
519: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_TX_EXC);
520: }
521:
522: if (status & WI_EV_INFO_DROP) {
523: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_INFO_DROP);
524: }
525:
526: /* Re-enable interrupts. */
527: CSR_WRITE_2(sc, WI_INT_EN, WI_INTRS);
528:
529: if (!IFQ_IS_EMPTY(&ifp->if_snd))
530: wi_start(ifp);
531:
532: return (1);
533: }
534:
535: STATIC int
536: wi_get_fid_io(struct wi_softc *sc, int fid)
537: {
538: return CSR_READ_2(sc, fid);
539: }
540:
541:
542: void
543: wi_rxeof(struct wi_softc *sc)
544: {
545: struct ifnet *ifp;
546: struct ether_header *eh;
547: struct mbuf *m;
548: caddr_t olddata;
549: u_int16_t ftype;
550: int maxlen;
551: int id;
552:
553: ifp = &sc->sc_ic.ic_if;
554:
555: id = wi_get_fid(sc, WI_RX_FID);
556:
557: if (sc->wi_procframe || sc->wi_debug.wi_monitor) {
558: struct wi_frame *rx_frame;
559: int datlen, hdrlen;
560:
561: MGETHDR(m, M_DONTWAIT, MT_DATA);
562: if (m == NULL) {
563: ifp->if_ierrors++;
564: return;
565: }
566: MCLGET(m, M_DONTWAIT);
567: if (!(m->m_flags & M_EXT)) {
568: m_freem(m);
569: ifp->if_ierrors++;
570: return;
571: }
572:
573: m->m_pkthdr.rcvif = ifp;
574:
575: if (wi_read_data(sc, id, 0, mtod(m, caddr_t),
576: sizeof(struct wi_frame))) {
577: m_freem(m);
578: ifp->if_ierrors++;
579: return;
580: }
581:
582: rx_frame = mtod(m, struct wi_frame *);
583:
584: if (rx_frame->wi_status & htole16(WI_STAT_BADCRC)) {
585: m_freem(m);
586: ifp->if_ierrors++;
587: return;
588: }
589:
590: switch ((letoh16(rx_frame->wi_status) & WI_STAT_MAC_PORT)
591: >> 8) {
592: case 7:
593: switch (letoh16(rx_frame->wi_frame_ctl) &
594: WI_FCTL_FTYPE) {
595: case WI_FTYPE_DATA:
596: hdrlen = WI_DATA_HDRLEN;
597: datlen = letoh16(rx_frame->wi_dat_len);
598: break;
599: case WI_FTYPE_MGMT:
600: hdrlen = WI_MGMT_HDRLEN;
601: datlen = letoh16(rx_frame->wi_dat_len);
602: break;
603: case WI_FTYPE_CTL:
604: hdrlen = WI_CTL_HDRLEN;
605: datlen = 0;
606: break;
607: default:
608: printf(WI_PRT_FMT ": received packet of "
609: "unknown type on port 7\n", WI_PRT_ARG(sc));
610: m_freem(m);
611: ifp->if_ierrors++;
612: return;
613: }
614: break;
615: case 0:
616: hdrlen = WI_DATA_HDRLEN;
617: datlen = letoh16(rx_frame->wi_dat_len);
618: break;
619: default:
620: printf(WI_PRT_FMT ": received packet on invalid port "
621: "(wi_status=0x%x)\n", WI_PRT_ARG(sc),
622: letoh16(rx_frame->wi_status));
623: m_freem(m);
624: ifp->if_ierrors++;
625: return;
626: }
627:
628: if ((hdrlen + datlen + 2) > MCLBYTES) {
629: m_freem(m);
630: ifp->if_ierrors++;
631: return;
632: }
633:
634: if (wi_read_data(sc, id, hdrlen, mtod(m, caddr_t) + hdrlen,
635: datlen + 2)) {
636: m_freem(m);
637: ifp->if_ierrors++;
638: return;
639: }
640:
641: m->m_pkthdr.len = m->m_len = hdrlen + datlen;
642: } else {
643: struct wi_frame rx_frame;
644:
645: /* First read in the frame header */
646: if (wi_read_data(sc, id, 0, (caddr_t)&rx_frame,
647: sizeof(rx_frame))) {
648: ifp->if_ierrors++;
649: return;
650: }
651:
652: /* Drop undecryptable or packets with receive errors here */
653: if (rx_frame.wi_status & htole16(WI_STAT_ERRSTAT)) {
654: ifp->if_ierrors++;
655: return;
656: }
657:
658: /* Stash frame type in host byte order for later use */
659: ftype = letoh16(rx_frame.wi_frame_ctl) & WI_FCTL_FTYPE;
660:
661: MGETHDR(m, M_DONTWAIT, MT_DATA);
662: if (m == NULL) {
663: ifp->if_ierrors++;
664: return;
665: }
666: MCLGET(m, M_DONTWAIT);
667: if (!(m->m_flags & M_EXT)) {
668: m_freem(m);
669: ifp->if_ierrors++;
670: return;
671: }
672:
673: olddata = m->m_data;
674: /* Align the data after the ethernet header */
675: m->m_data = (caddr_t)ALIGN(m->m_data +
676: sizeof(struct ether_header)) - sizeof(struct ether_header);
677:
678: eh = mtod(m, struct ether_header *);
679: maxlen = MCLBYTES - (m->m_data - olddata);
680: m->m_pkthdr.rcvif = ifp;
681:
682: if (ftype == WI_FTYPE_MGMT &&
683: sc->wi_ptype == WI_PORTTYPE_HOSTAP) {
684:
685: u_int16_t rxlen = letoh16(rx_frame.wi_dat_len);
686:
687: if ((WI_802_11_OFFSET_RAW + rxlen + 2) > maxlen) {
688: printf("%s: oversized mgmt packet received in "
689: "hostap mode (wi_dat_len=%d, "
690: "wi_status=0x%x)\n", sc->sc_dev.dv_xname,
691: rxlen, letoh16(rx_frame.wi_status));
692: m_freem(m);
693: ifp->if_ierrors++;
694: return;
695: }
696:
697: /* Put the whole header in there. */
698: bcopy(&rx_frame, mtod(m, void *),
699: sizeof(struct wi_frame));
700: if (wi_read_data(sc, id, WI_802_11_OFFSET_RAW,
701: mtod(m, caddr_t) + WI_802_11_OFFSET_RAW,
702: rxlen + 2)) {
703: m_freem(m);
704: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
705: printf("wihap: failed to copy header\n");
706: ifp->if_ierrors++;
707: return;
708: }
709:
710: m->m_pkthdr.len = m->m_len =
711: WI_802_11_OFFSET_RAW + rxlen;
712:
713: /* XXX: consider giving packet to bhp? */
714:
715: wihap_mgmt_input(sc, &rx_frame, m);
716:
717: return;
718: }
719:
720: switch (letoh16(rx_frame.wi_status) & WI_RXSTAT_MSG_TYPE) {
721: case WI_STAT_1042:
722: case WI_STAT_TUNNEL:
723: case WI_STAT_WMP_MSG:
724: if ((letoh16(rx_frame.wi_dat_len) + WI_SNAPHDR_LEN) >
725: maxlen) {
726: printf(WI_PRT_FMT ": oversized packet received "
727: "(wi_dat_len=%d, wi_status=0x%x)\n",
728: WI_PRT_ARG(sc),
729: letoh16(rx_frame.wi_dat_len),
730: letoh16(rx_frame.wi_status));
731: m_freem(m);
732: ifp->if_ierrors++;
733: return;
734: }
735: m->m_pkthdr.len = m->m_len =
736: letoh16(rx_frame.wi_dat_len) + WI_SNAPHDR_LEN;
737:
738: bcopy((char *)&rx_frame.wi_dst_addr,
739: (char *)&eh->ether_dhost, ETHER_ADDR_LEN);
740: bcopy((char *)&rx_frame.wi_src_addr,
741: (char *)&eh->ether_shost, ETHER_ADDR_LEN);
742: bcopy((char *)&rx_frame.wi_type,
743: (char *)&eh->ether_type, ETHER_TYPE_LEN);
744:
745: if (wi_read_data(sc, id, WI_802_11_OFFSET,
746: mtod(m, caddr_t) + sizeof(struct ether_header),
747: m->m_len + 2)) {
748: ifp->if_ierrors++;
749: m_freem(m);
750: return;
751: }
752: break;
753: default:
754: if ((letoh16(rx_frame.wi_dat_len) +
755: sizeof(struct ether_header)) > maxlen) {
756: printf(WI_PRT_FMT ": oversized packet received "
757: "(wi_dat_len=%d, wi_status=0x%x)\n",
758: WI_PRT_ARG(sc),
759: letoh16(rx_frame.wi_dat_len),
760: letoh16(rx_frame.wi_status));
761: m_freem(m);
762: ifp->if_ierrors++;
763: return;
764: }
765: m->m_pkthdr.len = m->m_len =
766: letoh16(rx_frame.wi_dat_len) +
767: sizeof(struct ether_header);
768:
769: if (wi_read_data(sc, id, WI_802_3_OFFSET,
770: mtod(m, caddr_t), m->m_len + 2)) {
771: m_freem(m);
772: ifp->if_ierrors++;
773: return;
774: }
775: break;
776: }
777:
778: ifp->if_ipackets++;
779:
780: if (sc->wi_use_wep &&
781: rx_frame.wi_frame_ctl & htole16(WI_FCTL_WEP)) {
782: int len;
783:
784: switch (sc->wi_crypto_algorithm) {
785: case WI_CRYPTO_FIRMWARE_WEP:
786: break;
787: case WI_CRYPTO_SOFTWARE_WEP:
788: m_copydata(m, 0, m->m_pkthdr.len,
789: (caddr_t)sc->wi_rxbuf);
790: len = m->m_pkthdr.len -
791: sizeof(struct ether_header);
792: if (wi_do_hostdecrypt(sc, sc->wi_rxbuf +
793: sizeof(struct ether_header), len)) {
794: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
795: printf(WI_PRT_FMT ": Error decrypting incoming packet.\n", WI_PRT_ARG(sc));
796: m_freem(m);
797: ifp->if_ierrors++;
798: return;
799: }
800: len -= IEEE80211_WEP_IVLEN +
801: IEEE80211_WEP_KIDLEN + IEEE80211_WEP_CRCLEN;
802: /*
803: * copy data back to mbufs:
804: * we need to ditch the IV & most LLC/SNAP stuff
805: * (except SNAP type, we're going use that to
806: * overwrite the ethertype in the ether_header)
807: */
808: m_copyback(m, sizeof(struct ether_header) -
809: WI_ETHERTYPE_LEN, WI_ETHERTYPE_LEN +
810: (len - WI_SNAPHDR_LEN),
811: sc->wi_rxbuf + sizeof(struct ether_header) +
812: IEEE80211_WEP_IVLEN +
813: IEEE80211_WEP_KIDLEN + WI_SNAPHDR_LEN);
814: m_adj(m, -(WI_ETHERTYPE_LEN +
815: IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN +
816: WI_SNAPHDR_LEN));
817: break;
818: }
819: }
820:
821: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP) {
822: /*
823: * Give host AP code first crack at data packets.
824: * If it decides to handle it (or drop it), it will
825: * return a non-zero. Otherwise, it is destined for
826: * this host.
827: */
828: if (wihap_data_input(sc, &rx_frame, m))
829: return;
830: }
831: }
832:
833: #if NBPFILTER > 0
834: /* Handle BPF listeners. */
835: if (ifp->if_bpf)
836: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
837: #endif
838:
839: /* Receive packet unless in procframe or monitor mode. */
840: if (sc->wi_procframe || sc->wi_debug.wi_monitor)
841: m_freem(m);
842: else
843: ether_input_mbuf(ifp, m);
844:
845: return;
846: }
847:
848: void
849: wi_txeof(struct wi_softc *sc, int status)
850: {
851: struct ifnet *ifp;
852:
853: ifp = &sc->sc_ic.ic_if;
854:
855: ifp->if_timer = 0;
856: ifp->if_flags &= ~IFF_OACTIVE;
857:
858: if (status & WI_EV_TX_EXC)
859: ifp->if_oerrors++;
860: else
861: ifp->if_opackets++;
862:
863: return;
864: }
865:
866: void
867: wi_inquire(void *xsc)
868: {
869: struct wi_softc *sc;
870: struct ifnet *ifp;
871: int s, rv;
872:
873: sc = xsc;
874: ifp = &sc->sc_ic.ic_if;
875:
876: timeout_add(&sc->sc_timo, hz * 60);
877:
878: /* Don't do this while we're transmitting */
879: if (ifp->if_flags & IFF_OACTIVE)
880: return;
881:
882: s = splnet();
883: rv = wi_cmd(sc, WI_CMD_INQUIRE, WI_INFO_COUNTERS, 0, 0);
884: splx(s);
885: if (rv)
886: printf(WI_PRT_FMT ": wi_cmd failed with %d\n", WI_PRT_ARG(sc),
887: rv);
888:
889: return;
890: }
891:
892: void
893: wi_update_stats(struct wi_softc *sc)
894: {
895: struct wi_ltv_gen gen;
896: u_int16_t id;
897: struct ifnet *ifp;
898: u_int32_t *ptr;
899: int len, i;
900: u_int16_t t;
901:
902: ifp = &sc->sc_ic.ic_if;
903:
904: id = wi_get_fid(sc, WI_INFO_FID);
905:
906: wi_read_data(sc, id, 0, (char *)&gen, 4);
907:
908: if (gen.wi_type == htole16(WI_INFO_SCAN_RESULTS)) {
909: sc->wi_scanbuf_len = letoh16(gen.wi_len);
910: wi_read_data(sc, id, 4, (caddr_t)sc->wi_scanbuf,
911: sc->wi_scanbuf_len * 2);
912: return;
913: } else if (gen.wi_type != htole16(WI_INFO_COUNTERS))
914: return;
915:
916: /* Some card versions have a larger stats structure */
917: len = (letoh16(gen.wi_len) - 1 < sizeof(sc->wi_stats) / 4) ?
918: letoh16(gen.wi_len) - 1 : sizeof(sc->wi_stats) / 4;
919:
920: ptr = (u_int32_t *)&sc->wi_stats;
921:
922: for (i = 0; i < len; i++) {
923: if (sc->wi_flags & WI_FLAGS_BUS_USB) {
924: wi_read_data(sc, id, 4 + i*2, (char *)&t, 2);
925: t = letoh16(t);
926: } else
927: t = CSR_READ_2(sc, WI_DATA1);
928: #ifdef WI_HERMES_STATS_WAR
929: if (t > 0xF000)
930: t = ~t & 0xFFFF;
931: #endif
932: ptr[i] += t;
933: }
934:
935: ifp->if_collisions = sc->wi_stats.wi_tx_single_retries +
936: sc->wi_stats.wi_tx_multi_retries +
937: sc->wi_stats.wi_tx_retry_limit;
938:
939: return;
940: }
941:
942: STATIC int
943: wi_cmd_io(struct wi_softc *sc, int cmd, int val0, int val1, int val2)
944: {
945: int i, s = 0;
946:
947: /* Wait for the busy bit to clear. */
948: for (i = sc->wi_cmd_count; i--; DELAY(1000)) {
949: if (!(CSR_READ_2(sc, WI_COMMAND) & WI_CMD_BUSY))
950: break;
951: }
952: if (i < 0) {
953: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
954: printf(WI_PRT_FMT ": wi_cmd_io: busy bit won't clear\n",
955: WI_PRT_ARG(sc));
956: return(ETIMEDOUT);
957: }
958:
959: CSR_WRITE_2(sc, WI_PARAM0, val0);
960: CSR_WRITE_2(sc, WI_PARAM1, val1);
961: CSR_WRITE_2(sc, WI_PARAM2, val2);
962: CSR_WRITE_2(sc, WI_COMMAND, cmd);
963:
964: for (i = WI_TIMEOUT; i--; DELAY(WI_DELAY)) {
965: /*
966: * Wait for 'command complete' bit to be
967: * set in the event status register.
968: */
969: s = CSR_READ_2(sc, WI_EVENT_STAT) & WI_EV_CMD;
970: if (s) {
971: /* Ack the event and read result code. */
972: s = CSR_READ_2(sc, WI_STATUS);
973: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_CMD);
974: if (s & WI_STAT_CMD_RESULT)
975: return(EIO);
976: break;
977: }
978: }
979:
980: if (i < 0) {
981: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
982: printf(WI_PRT_FMT
983: ": timeout in wi_cmd 0x%04x; event status 0x%04x\n",
984: WI_PRT_ARG(sc), cmd, s);
985: return(ETIMEDOUT);
986: }
987:
988: return(0);
989: }
990:
991: STATIC void
992: wi_reset(struct wi_softc *sc)
993: {
994: int error, tries = 3;
995:
996: DPRINTF(WID_RESET, ("wi_reset: sc %p\n", sc));
997:
998: /* Symbol firmware cannot be initialized more than once. */
999: if (sc->sc_firmware_type == WI_SYMBOL) {
1000: if (sc->wi_flags & WI_FLAGS_INITIALIZED)
1001: return;
1002: tries = 1;
1003: }
1004:
1005: for (; tries--; DELAY(WI_DELAY * 1000)) {
1006: if ((error = wi_cmd(sc, WI_CMD_INI, 0, 0, 0)) == 0)
1007: break;
1008: }
1009: if (tries < 0) {
1010: printf(WI_PRT_FMT ": init failed\n", WI_PRT_ARG(sc));
1011: return;
1012: }
1013: sc->wi_flags |= WI_FLAGS_INITIALIZED;
1014:
1015: wi_intr_enable(sc, 0);
1016: wi_intr_ack(sc, 0xffff);
1017:
1018: /* Calibrate timer. */
1019: WI_SETVAL(WI_RID_TICK_TIME, 8);
1020:
1021: return;
1022: }
1023:
1024: STATIC void
1025: wi_cor_reset(struct wi_softc *sc)
1026: {
1027: u_int8_t cor_value;
1028:
1029: DPRINTF(WID_RESET, ("wi_cor_reset: sc %p\n", sc));
1030:
1031: /*
1032: * Do a soft reset of the card; this is required for Symbol cards.
1033: * This shouldn't hurt other cards but there have been reports
1034: * of the COR reset messing up old Lucent firmware revisions so
1035: * we avoid soft reset on Lucent cards for now.
1036: */
1037: if (sc->sc_firmware_type != WI_LUCENT) {
1038: cor_value = bus_space_read_1(sc->wi_ltag, sc->wi_lhandle,
1039: sc->wi_cor_offset);
1040: bus_space_write_1(sc->wi_ltag, sc->wi_lhandle,
1041: sc->wi_cor_offset, (cor_value | WI_COR_SOFT_RESET));
1042: DELAY(1000);
1043: bus_space_write_1(sc->wi_ltag, sc->wi_lhandle,
1044: sc->wi_cor_offset, (cor_value & ~WI_COR_SOFT_RESET));
1045: DELAY(1000);
1046: }
1047:
1048: return;
1049: }
1050:
1051: /*
1052: * Read an LTV record from the NIC.
1053: */
1054: STATIC int
1055: wi_read_record_io(struct wi_softc *sc, struct wi_ltv_gen *ltv)
1056: {
1057: u_int8_t *ptr;
1058: int len, code;
1059: struct wi_ltv_gen *oltv, p2ltv;
1060:
1061: if (sc->sc_firmware_type != WI_LUCENT) {
1062: oltv = ltv;
1063: switch (ltv->wi_type) {
1064: case WI_RID_ENCRYPTION:
1065: p2ltv.wi_type = WI_RID_P2_ENCRYPTION;
1066: p2ltv.wi_len = 2;
1067: ltv = &p2ltv;
1068: break;
1069: case WI_RID_TX_CRYPT_KEY:
1070: if (ltv->wi_val > WI_NLTV_KEYS)
1071: return (EINVAL);
1072: p2ltv.wi_type = WI_RID_P2_TX_CRYPT_KEY;
1073: p2ltv.wi_len = 2;
1074: ltv = &p2ltv;
1075: break;
1076: }
1077: }
1078:
1079: /* Tell the NIC to enter record read mode. */
1080: if (wi_cmd(sc, WI_CMD_ACCESS|WI_ACCESS_READ, ltv->wi_type, 0, 0))
1081: return(EIO);
1082:
1083: /* Seek to the record. */
1084: if (wi_seek(sc, ltv->wi_type, 0, WI_BAP1))
1085: return(EIO);
1086:
1087: /*
1088: * Read the length and record type and make sure they
1089: * match what we expect (this verifies that we have enough
1090: * room to hold all of the returned data).
1091: */
1092: len = CSR_READ_2(sc, WI_DATA1);
1093: if (len > ltv->wi_len)
1094: return(ENOSPC);
1095: code = CSR_READ_2(sc, WI_DATA1);
1096: if (code != ltv->wi_type)
1097: return(EIO);
1098:
1099: ltv->wi_len = len;
1100: ltv->wi_type = code;
1101:
1102: /* Now read the data. */
1103: ptr = (u_int8_t *)<v->wi_val;
1104: if (ltv->wi_len > 1)
1105: CSR_READ_RAW_2(sc, WI_DATA1, ptr, (ltv->wi_len-1)*2);
1106:
1107: if (ltv->wi_type == WI_RID_PORTTYPE && sc->wi_ptype == WI_PORTTYPE_IBSS
1108: && ltv->wi_val == sc->wi_ibss_port) {
1109: /*
1110: * Convert vendor IBSS port type to WI_PORTTYPE_IBSS.
1111: * Since Lucent uses port type 1 for BSS *and* IBSS we
1112: * have to rely on wi_ptype to distinguish this for us.
1113: */
1114: ltv->wi_val = htole16(WI_PORTTYPE_IBSS);
1115: } else if (sc->sc_firmware_type != WI_LUCENT) {
1116: int v;
1117:
1118: switch (oltv->wi_type) {
1119: case WI_RID_TX_RATE:
1120: case WI_RID_CUR_TX_RATE:
1121: switch (letoh16(ltv->wi_val)) {
1122: case 1: v = 1; break;
1123: case 2: v = 2; break;
1124: case 3: v = 6; break;
1125: case 4: v = 5; break;
1126: case 7: v = 7; break;
1127: case 8: v = 11; break;
1128: case 15: v = 3; break;
1129: default: v = 0x100 + letoh16(ltv->wi_val); break;
1130: }
1131: oltv->wi_val = htole16(v);
1132: break;
1133: case WI_RID_ENCRYPTION:
1134: oltv->wi_len = 2;
1135: if (ltv->wi_val & htole16(0x01))
1136: oltv->wi_val = htole16(1);
1137: else
1138: oltv->wi_val = htole16(0);
1139: break;
1140: case WI_RID_TX_CRYPT_KEY:
1141: case WI_RID_CNFAUTHMODE:
1142: oltv->wi_len = 2;
1143: oltv->wi_val = ltv->wi_val;
1144: break;
1145: }
1146: }
1147:
1148: return(0);
1149: }
1150:
1151: /*
1152: * Same as read, except we inject data instead of reading it.
1153: */
1154: STATIC int
1155: wi_write_record_io(struct wi_softc *sc, struct wi_ltv_gen *ltv)
1156: {
1157: u_int8_t *ptr;
1158: u_int16_t val = 0;
1159: int i;
1160: struct wi_ltv_gen p2ltv;
1161:
1162: if (ltv->wi_type == WI_RID_PORTTYPE &&
1163: letoh16(ltv->wi_val) == WI_PORTTYPE_IBSS) {
1164: /* Convert WI_PORTTYPE_IBSS to vendor IBSS port type. */
1165: p2ltv.wi_type = WI_RID_PORTTYPE;
1166: p2ltv.wi_len = 2;
1167: p2ltv.wi_val = sc->wi_ibss_port;
1168: ltv = &p2ltv;
1169: } else if (sc->sc_firmware_type != WI_LUCENT) {
1170: int v;
1171:
1172: switch (ltv->wi_type) {
1173: case WI_RID_TX_RATE:
1174: p2ltv.wi_type = WI_RID_TX_RATE;
1175: p2ltv.wi_len = 2;
1176: switch (letoh16(ltv->wi_val)) {
1177: case 1: v = 1; break;
1178: case 2: v = 2; break;
1179: case 3: v = 15; break;
1180: case 5: v = 4; break;
1181: case 6: v = 3; break;
1182: case 7: v = 7; break;
1183: case 11: v = 8; break;
1184: default: return EINVAL;
1185: }
1186: p2ltv.wi_val = htole16(v);
1187: ltv = &p2ltv;
1188: break;
1189: case WI_RID_ENCRYPTION:
1190: p2ltv.wi_type = WI_RID_P2_ENCRYPTION;
1191: p2ltv.wi_len = 2;
1192: if (ltv->wi_val & htole16(0x01)) {
1193: val = PRIVACY_INVOKED;
1194: /*
1195: * If using shared key WEP we must set the
1196: * EXCLUDE_UNENCRYPTED bit. Symbol cards
1197: * need this bit set even when not using
1198: * shared key. We can't just test for
1199: * IEEE80211_AUTH_SHARED since Symbol cards
1200: * have 2 shared key modes.
1201: */
1202: if (sc->wi_authtype != IEEE80211_AUTH_OPEN ||
1203: sc->sc_firmware_type == WI_SYMBOL)
1204: val |= EXCLUDE_UNENCRYPTED;
1205:
1206: switch (sc->wi_crypto_algorithm) {
1207: case WI_CRYPTO_FIRMWARE_WEP:
1208: /*
1209: * TX encryption is broken in
1210: * Host AP mode.
1211: */
1212: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP)
1213: val |= HOST_ENCRYPT;
1214: break;
1215: case WI_CRYPTO_SOFTWARE_WEP:
1216: val |= HOST_ENCRYPT|HOST_DECRYPT;
1217: break;
1218: }
1219: p2ltv.wi_val = htole16(val);
1220: } else
1221: p2ltv.wi_val = htole16(HOST_ENCRYPT | HOST_DECRYPT);
1222: ltv = &p2ltv;
1223: break;
1224: case WI_RID_TX_CRYPT_KEY:
1225: if (ltv->wi_val > WI_NLTV_KEYS)
1226: return (EINVAL);
1227: p2ltv.wi_type = WI_RID_P2_TX_CRYPT_KEY;
1228: p2ltv.wi_len = 2;
1229: p2ltv.wi_val = ltv->wi_val;
1230: ltv = &p2ltv;
1231: break;
1232: case WI_RID_DEFLT_CRYPT_KEYS: {
1233: int error;
1234: int keylen;
1235: struct wi_ltv_str ws;
1236: struct wi_ltv_keys *wk = (struct wi_ltv_keys *)ltv;
1237:
1238: keylen = wk->wi_keys[sc->wi_tx_key].wi_keylen;
1239: keylen = letoh16(keylen);
1240:
1241: for (i = 0; i < 4; i++) {
1242: bzero(&ws, sizeof(ws));
1243: ws.wi_len = (keylen > 5) ? 8 : 4;
1244: ws.wi_type = WI_RID_P2_CRYPT_KEY0 + i;
1245: bcopy(&wk->wi_keys[i].wi_keydat,
1246: ws.wi_str, keylen);
1247: error = wi_write_record(sc,
1248: (struct wi_ltv_gen *)&ws);
1249: if (error)
1250: return (error);
1251: }
1252: }
1253: return (0);
1254: }
1255: }
1256:
1257: if (wi_seek(sc, ltv->wi_type, 0, WI_BAP1))
1258: return(EIO);
1259:
1260: CSR_WRITE_2(sc, WI_DATA1, ltv->wi_len);
1261: CSR_WRITE_2(sc, WI_DATA1, ltv->wi_type);
1262:
1263: ptr = (u_int8_t *)<v->wi_val;
1264: if (ltv->wi_len > 1)
1265: CSR_WRITE_RAW_2(sc, WI_DATA1, ptr, (ltv->wi_len-1) *2);
1266:
1267: if (wi_cmd(sc, WI_CMD_ACCESS|WI_ACCESS_WRITE, ltv->wi_type, 0, 0))
1268: return(EIO);
1269:
1270: return(0);
1271: }
1272:
1273: STATIC int
1274: wi_seek(struct wi_softc *sc, int id, int off, int chan)
1275: {
1276: int i;
1277: int selreg, offreg;
1278:
1279: switch (chan) {
1280: case WI_BAP0:
1281: selreg = WI_SEL0;
1282: offreg = WI_OFF0;
1283: break;
1284: case WI_BAP1:
1285: selreg = WI_SEL1;
1286: offreg = WI_OFF1;
1287: break;
1288: default:
1289: printf(WI_PRT_FMT ": invalid data path: %x\n", WI_PRT_ARG(sc),
1290: chan);
1291: return(EIO);
1292: }
1293:
1294: CSR_WRITE_2(sc, selreg, id);
1295: CSR_WRITE_2(sc, offreg, off);
1296:
1297: for (i = WI_TIMEOUT; i--; DELAY(1))
1298: if (!(CSR_READ_2(sc, offreg) & (WI_OFF_BUSY|WI_OFF_ERR)))
1299: break;
1300:
1301: if (i < 0)
1302: return(ETIMEDOUT);
1303:
1304: return(0);
1305: }
1306:
1307: STATIC int
1308: wi_read_data_io(struct wi_softc *sc, int id, int off, caddr_t buf, int len)
1309: {
1310: u_int8_t *ptr;
1311:
1312: if (wi_seek(sc, id, off, WI_BAP1))
1313: return(EIO);
1314:
1315: ptr = (u_int8_t *)buf;
1316: CSR_READ_RAW_2(sc, WI_DATA1, ptr, len);
1317:
1318: return(0);
1319: }
1320:
1321: /*
1322: * According to the comments in the HCF Light code, there is a bug in
1323: * the Hermes (or possibly in certain Hermes firmware revisions) where
1324: * the chip's internal autoincrement counter gets thrown off during
1325: * data writes: the autoincrement is missed, causing one data word to
1326: * be overwritten and subsequent words to be written to the wrong memory
1327: * locations. The end result is that we could end up transmitting bogus
1328: * frames without realizing it. The workaround for this is to write a
1329: * couple of extra guard words after the end of the transfer, then
1330: * attempt to read then back. If we fail to locate the guard words where
1331: * we expect them, we preform the transfer over again.
1332: */
1333: STATIC int
1334: wi_write_data_io(struct wi_softc *sc, int id, int off, caddr_t buf, int len)
1335: {
1336: u_int8_t *ptr;
1337:
1338: #ifdef WI_HERMES_AUTOINC_WAR
1339: again:
1340: #endif
1341:
1342: if (wi_seek(sc, id, off, WI_BAP0))
1343: return(EIO);
1344:
1345: ptr = (u_int8_t *)buf;
1346: CSR_WRITE_RAW_2(sc, WI_DATA0, ptr, len);
1347:
1348: #ifdef WI_HERMES_AUTOINC_WAR
1349: CSR_WRITE_2(sc, WI_DATA0, 0x1234);
1350: CSR_WRITE_2(sc, WI_DATA0, 0x5678);
1351:
1352: if (wi_seek(sc, id, off + len, WI_BAP0))
1353: return(EIO);
1354:
1355: if (CSR_READ_2(sc, WI_DATA0) != 0x1234 ||
1356: CSR_READ_2(sc, WI_DATA0) != 0x5678)
1357: goto again;
1358: #endif
1359:
1360: return(0);
1361: }
1362:
1363: /*
1364: * Allocate a region of memory inside the NIC and zero
1365: * it out.
1366: */
1367: STATIC int
1368: wi_alloc_nicmem_io(struct wi_softc *sc, int len, int *id)
1369: {
1370: int i;
1371:
1372: if (wi_cmd(sc, WI_CMD_ALLOC_MEM, len, 0, 0)) {
1373: printf(WI_PRT_FMT ": failed to allocate %d bytes on NIC\n",
1374: WI_PRT_ARG(sc), len);
1375: return(ENOMEM);
1376: }
1377:
1378: for (i = WI_TIMEOUT; i--; DELAY(1)) {
1379: if (CSR_READ_2(sc, WI_EVENT_STAT) & WI_EV_ALLOC)
1380: break;
1381: }
1382:
1383: if (i < 0)
1384: return(ETIMEDOUT);
1385:
1386: *id = CSR_READ_2(sc, WI_ALLOC_FID);
1387: CSR_WRITE_2(sc, WI_EVENT_ACK, WI_EV_ALLOC);
1388:
1389: if (wi_seek(sc, *id, 0, WI_BAP0))
1390: return(EIO);
1391:
1392: for (i = 0; i < len / 2; i++)
1393: CSR_WRITE_2(sc, WI_DATA0, 0);
1394:
1395: return(0);
1396: }
1397:
1398: STATIC void
1399: wi_setmulti(struct wi_softc *sc)
1400: {
1401: struct ifnet *ifp;
1402: int i = 0;
1403: struct wi_ltv_mcast mcast;
1404: struct ether_multistep step;
1405: struct ether_multi *enm;
1406:
1407: ifp = &sc->sc_ic.ic_if;
1408:
1409: bzero((char *)&mcast, sizeof(mcast));
1410:
1411: mcast.wi_type = WI_RID_MCAST_LIST;
1412: mcast.wi_len = ((ETHER_ADDR_LEN / 2) * 16) + 1;
1413:
1414: allmulti:
1415: if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
1416: wi_write_record(sc, (struct wi_ltv_gen *)&mcast);
1417: return;
1418: }
1419:
1420: ETHER_FIRST_MULTI(step, &sc->sc_ic.ic_ac, enm);
1421: while (enm != NULL) {
1422: if (i >= 16) {
1423: bzero((char *)&mcast, sizeof(mcast));
1424: break;
1425: }
1426:
1427: if (bcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN)) {
1428: ifp->if_flags |= IFF_ALLMULTI;
1429: goto allmulti;
1430: }
1431: bcopy(enm->enm_addrlo, (char *)&mcast.wi_mcast[i],
1432: ETHER_ADDR_LEN);
1433: i++;
1434: ETHER_NEXT_MULTI(step, enm);
1435: }
1436:
1437: mcast.wi_len = (i * 3) + 1;
1438: wi_write_record(sc, (struct wi_ltv_gen *)&mcast);
1439:
1440: return;
1441: }
1442:
1443: STATIC int
1444: wi_setdef(struct wi_softc *sc, struct wi_req *wreq)
1445: {
1446: struct ifnet *ifp;
1447: int error = 0;
1448:
1449: ifp = &sc->sc_ic.ic_if;
1450:
1451: switch(wreq->wi_type) {
1452: case WI_RID_MAC_NODE:
1453: bcopy((char *)&wreq->wi_val, LLADDR(ifp->if_sadl),
1454: ETHER_ADDR_LEN);
1455: bcopy((char *)&wreq->wi_val, (char *)&sc->sc_ic.ic_myaddr,
1456: ETHER_ADDR_LEN);
1457: break;
1458: case WI_RID_PORTTYPE:
1459: error = wi_sync_media(sc, letoh16(wreq->wi_val[0]),
1460: sc->wi_tx_rate);
1461: break;
1462: case WI_RID_TX_RATE:
1463: error = wi_sync_media(sc, sc->wi_ptype,
1464: letoh16(wreq->wi_val[0]));
1465: break;
1466: case WI_RID_MAX_DATALEN:
1467: sc->wi_max_data_len = letoh16(wreq->wi_val[0]);
1468: break;
1469: case WI_RID_RTS_THRESH:
1470: sc->wi_rts_thresh = letoh16(wreq->wi_val[0]);
1471: break;
1472: case WI_RID_SYSTEM_SCALE:
1473: sc->wi_ap_density = letoh16(wreq->wi_val[0]);
1474: break;
1475: case WI_RID_CREATE_IBSS:
1476: sc->wi_create_ibss = letoh16(wreq->wi_val[0]);
1477: error = wi_sync_media(sc, sc->wi_ptype, sc->wi_tx_rate);
1478: break;
1479: case WI_RID_OWN_CHNL:
1480: sc->wi_channel = letoh16(wreq->wi_val[0]);
1481: break;
1482: case WI_RID_NODENAME:
1483: error = wi_set_ssid(&sc->wi_node_name,
1484: (u_int8_t *)&wreq->wi_val[1], letoh16(wreq->wi_val[0]));
1485: break;
1486: case WI_RID_DESIRED_SSID:
1487: error = wi_set_ssid(&sc->wi_net_name,
1488: (u_int8_t *)&wreq->wi_val[1], letoh16(wreq->wi_val[0]));
1489: break;
1490: case WI_RID_OWN_SSID:
1491: error = wi_set_ssid(&sc->wi_ibss_name,
1492: (u_int8_t *)&wreq->wi_val[1], letoh16(wreq->wi_val[0]));
1493: break;
1494: case WI_RID_PM_ENABLED:
1495: sc->wi_pm_enabled = letoh16(wreq->wi_val[0]);
1496: break;
1497: case WI_RID_MICROWAVE_OVEN:
1498: sc->wi_mor_enabled = letoh16(wreq->wi_val[0]);
1499: break;
1500: case WI_RID_MAX_SLEEP:
1501: sc->wi_max_sleep = letoh16(wreq->wi_val[0]);
1502: break;
1503: case WI_RID_CNFAUTHMODE:
1504: sc->wi_authtype = letoh16(wreq->wi_val[0]);
1505: break;
1506: case WI_RID_ROAMING_MODE:
1507: sc->wi_roaming = letoh16(wreq->wi_val[0]);
1508: break;
1509: case WI_RID_SYMBOL_DIVERSITY:
1510: sc->wi_diversity = letoh16(wreq->wi_val[0]);
1511: break;
1512: case WI_RID_ENH_SECURITY:
1513: sc->wi_enh_security = letoh16(wreq->wi_val[0]);
1514: break;
1515: case WI_RID_ENCRYPTION:
1516: sc->wi_use_wep = letoh16(wreq->wi_val[0]);
1517: break;
1518: case WI_RID_TX_CRYPT_KEY:
1519: sc->wi_tx_key = letoh16(wreq->wi_val[0]);
1520: break;
1521: case WI_RID_DEFLT_CRYPT_KEYS:
1522: bcopy((char *)wreq, (char *)&sc->wi_keys,
1523: sizeof(struct wi_ltv_keys));
1524: break;
1525: case WI_FRID_CRYPTO_ALG:
1526: switch (letoh16(wreq->wi_val[0])) {
1527: case WI_CRYPTO_FIRMWARE_WEP:
1528: sc->wi_crypto_algorithm = WI_CRYPTO_FIRMWARE_WEP;
1529: break;
1530: case WI_CRYPTO_SOFTWARE_WEP:
1531: sc->wi_crypto_algorithm = WI_CRYPTO_SOFTWARE_WEP;
1532: break;
1533: default:
1534: printf(WI_PRT_FMT ": unsupported crypto algorithm %d\n",
1535: WI_PRT_ARG(sc), letoh16(wreq->wi_val[0]));
1536: error = EINVAL;
1537: }
1538: break;
1539: default:
1540: error = EINVAL;
1541: break;
1542: }
1543:
1544: return (error);
1545: }
1546:
1547: STATIC int
1548: wi_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
1549: {
1550: int s, error = 0, i, j, len;
1551: struct wi_softc *sc;
1552: struct ifreq *ifr;
1553: struct proc *p = curproc;
1554: struct ifaddr *ifa = (struct ifaddr *)data;
1555: struct wi_scan_res *res;
1556: struct wi_scan_p2_hdr *p2;
1557: struct wi_req *wreq = NULL;
1558: u_int32_t flags;
1559:
1560: struct ieee80211_nwid *nwidp = NULL;
1561: struct ieee80211_nodereq_all *na;
1562: struct ieee80211_bssid *bssid;
1563:
1564: s = splnet();
1565:
1566: sc = ifp->if_softc;
1567: ifr = (struct ifreq *)data;
1568:
1569: if (!(sc->wi_flags & WI_FLAGS_ATTACHED)) {
1570: splx(s);
1571: return(ENODEV);
1572: }
1573:
1574: DPRINTF (WID_IOCTL, ("wi_ioctl: command %lu data %p\n",
1575: command, data));
1576:
1577: if ((error = ether_ioctl(ifp, &sc->sc_ic.ic_ac, command, data)) > 0) {
1578: splx(s);
1579: return error;
1580: }
1581:
1582: switch(command) {
1583: case SIOCSIFADDR:
1584: ifp->if_flags |= IFF_UP;
1585: switch (ifa->ifa_addr->sa_family) {
1586: #ifdef INET
1587: case AF_INET:
1588: wi_init(sc);
1589: arp_ifinit(&sc->sc_ic.ic_ac, ifa);
1590: break;
1591: #endif /* INET */
1592: default:
1593: wi_init(sc);
1594: break;
1595: }
1596: break;
1597:
1598: case SIOCSIFMTU:
1599: if (ifr->ifr_mtu > ETHERMTU || ifr->ifr_mtu < ETHERMIN) {
1600: error = EINVAL;
1601: } else if (ifp->if_mtu != ifr->ifr_mtu) {
1602: ifp->if_mtu = ifr->ifr_mtu;
1603: }
1604: break;
1605:
1606: case SIOCSIFFLAGS:
1607: if (ifp->if_flags & IFF_UP) {
1608: if (ifp->if_flags & IFF_RUNNING &&
1609: ifp->if_flags & IFF_PROMISC &&
1610: !(sc->wi_if_flags & IFF_PROMISC)) {
1611: if (sc->wi_ptype != WI_PORTTYPE_HOSTAP)
1612: WI_SETVAL(WI_RID_PROMISC, 1);
1613: } else if (ifp->if_flags & IFF_RUNNING &&
1614: !(ifp->if_flags & IFF_PROMISC) &&
1615: sc->wi_if_flags & IFF_PROMISC) {
1616: if (sc->wi_ptype != WI_PORTTYPE_HOSTAP)
1617: WI_SETVAL(WI_RID_PROMISC, 0);
1618: } else
1619: wi_init(sc);
1620: } else if (ifp->if_flags & IFF_RUNNING)
1621: wi_stop(sc);
1622: sc->wi_if_flags = ifp->if_flags;
1623: error = 0;
1624: break;
1625: case SIOCADDMULTI:
1626: case SIOCDELMULTI:
1627: /* Update our multicast list. */
1628: error = (command == SIOCADDMULTI) ?
1629: ether_addmulti(ifr, &sc->sc_ic.ic_ac) :
1630: ether_delmulti(ifr, &sc->sc_ic.ic_ac);
1631:
1632: if (error == ENETRESET) {
1633: /*
1634: * Multicast list has changed; set the hardware filter
1635: * accordingly.
1636: */
1637: if (ifp->if_flags & IFF_RUNNING)
1638: wi_setmulti(sc);
1639: error = 0;
1640: }
1641: break;
1642: case SIOCSIFMEDIA:
1643: case SIOCGIFMEDIA:
1644: error = ifmedia_ioctl(ifp, ifr, &sc->sc_media, command);
1645: break;
1646: case SIOCGWAVELAN:
1647: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1648: bzero(wreq, sizeof(*wreq));
1649: error = copyin(ifr->ifr_data, wreq, sizeof(*wreq));
1650: if (error)
1651: break;
1652: if (wreq->wi_len > WI_MAX_DATALEN) {
1653: error = EINVAL;
1654: break;
1655: }
1656: switch (wreq->wi_type) {
1657: case WI_RID_IFACE_STATS:
1658: /* XXX native byte order */
1659: bcopy((char *)&sc->wi_stats, (char *)&wreq->wi_val,
1660: sizeof(sc->wi_stats));
1661: wreq->wi_len = (sizeof(sc->wi_stats) / 2) + 1;
1662: break;
1663: case WI_RID_DEFLT_CRYPT_KEYS:
1664: /* For non-root user, return all-zeroes keys */
1665: if (suser(p, 0))
1666: bzero(wreq, sizeof(struct wi_ltv_keys));
1667: else
1668: bcopy((char *)&sc->wi_keys, wreq,
1669: sizeof(struct wi_ltv_keys));
1670: break;
1671: case WI_RID_PROCFRAME:
1672: wreq->wi_len = 2;
1673: wreq->wi_val[0] = htole16(sc->wi_procframe);
1674: break;
1675: case WI_RID_PRISM2:
1676: wreq->wi_len = 2;
1677: wreq->wi_val[0] = htole16(sc->sc_firmware_type ==
1678: WI_LUCENT ? 0 : 1);
1679: break;
1680: case WI_FRID_CRYPTO_ALG:
1681: wreq->wi_val[0] =
1682: htole16((u_int16_t)sc->wi_crypto_algorithm);
1683: wreq->wi_len = 1;
1684: break;
1685: case WI_RID_SCAN_RES:
1686: if (sc->sc_firmware_type == WI_LUCENT) {
1687: memcpy((char *)wreq->wi_val,
1688: (char *)sc->wi_scanbuf,
1689: sc->wi_scanbuf_len * 2);
1690: wreq->wi_len = sc->wi_scanbuf_len;
1691: break;
1692: }
1693: /* FALLTHROUGH */
1694: default:
1695: if (wi_read_record(sc, (struct wi_ltv_gen *)wreq)) {
1696: error = EINVAL;
1697: }
1698: break;
1699: }
1700: error = copyout(wreq, ifr->ifr_data, sizeof(*wreq));
1701: break;
1702: case SIOCSWAVELAN:
1703: if ((error = suser(curproc, 0)) != 0)
1704: break;
1705: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1706: bzero(wreq, sizeof(*wreq));
1707: error = copyin(ifr->ifr_data, wreq, sizeof(*wreq));
1708: if (error)
1709: break;
1710: error = EINVAL;
1711: if (wreq->wi_len > WI_MAX_DATALEN)
1712: break;
1713: switch (wreq->wi_type) {
1714: case WI_RID_IFACE_STATS:
1715: break;
1716: case WI_RID_MGMT_XMIT:
1717: error = wi_mgmt_xmit(sc, (caddr_t)&wreq->wi_val,
1718: wreq->wi_len);
1719: break;
1720: case WI_RID_PROCFRAME:
1721: sc->wi_procframe = letoh16(wreq->wi_val[0]);
1722: error = 0;
1723: break;
1724: case WI_RID_SCAN_REQ:
1725: error = 0;
1726: if (sc->sc_firmware_type == WI_LUCENT)
1727: wi_cmd(sc, WI_CMD_INQUIRE,
1728: WI_INFO_SCAN_RESULTS, 0, 0);
1729: else
1730: error = wi_write_record(sc,
1731: (struct wi_ltv_gen *)wreq);
1732: break;
1733: case WI_FRID_CRYPTO_ALG:
1734: if (sc->sc_firmware_type != WI_LUCENT) {
1735: error = wi_setdef(sc, wreq);
1736: if (!error && (ifp->if_flags & IFF_UP))
1737: wi_init(sc);
1738: }
1739: break;
1740: case WI_RID_SYMBOL_DIVERSITY:
1741: case WI_RID_ROAMING_MODE:
1742: case WI_RID_CREATE_IBSS:
1743: case WI_RID_MICROWAVE_OVEN:
1744: case WI_RID_OWN_SSID:
1745: case WI_RID_ENH_SECURITY:
1746: /*
1747: * Check for features that may not be supported
1748: * (must be just before default case).
1749: */
1750: if ((wreq->wi_type == WI_RID_SYMBOL_DIVERSITY &&
1751: !(sc->wi_flags & WI_FLAGS_HAS_DIVERSITY)) ||
1752: (wreq->wi_type == WI_RID_ROAMING_MODE &&
1753: !(sc->wi_flags & WI_FLAGS_HAS_ROAMING)) ||
1754: (wreq->wi_type == WI_RID_CREATE_IBSS &&
1755: !(sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS)) ||
1756: (wreq->wi_type == WI_RID_MICROWAVE_OVEN &&
1757: !(sc->wi_flags & WI_FLAGS_HAS_MOR)) ||
1758: (wreq->wi_type == WI_RID_ENH_SECURITY &&
1759: !(sc->wi_flags & WI_FLAGS_HAS_ENH_SECURITY)) ||
1760: (wreq->wi_type == WI_RID_OWN_SSID &&
1761: wreq->wi_len != 0))
1762: break;
1763: /* FALLTHROUGH */
1764: default:
1765: error = wi_write_record(sc, (struct wi_ltv_gen *)wreq);
1766: if (!error)
1767: error = wi_setdef(sc, wreq);
1768: if (!error && (ifp->if_flags & IFF_UP))
1769: wi_init(sc);
1770: }
1771: break;
1772: case SIOCGPRISM2DEBUG:
1773: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1774: bzero(wreq, sizeof(*wreq));
1775: error = copyin(ifr->ifr_data, wreq, sizeof(*wreq));
1776: if (error)
1777: break;
1778: if (!(ifp->if_flags & IFF_RUNNING) ||
1779: sc->sc_firmware_type == WI_LUCENT) {
1780: error = EIO;
1781: break;
1782: }
1783: error = wi_get_debug(sc, wreq);
1784: if (error == 0)
1785: error = copyout(wreq, ifr->ifr_data, sizeof(*wreq));
1786: break;
1787: case SIOCSPRISM2DEBUG:
1788: if ((error = suser(curproc, 0)) != 0)
1789: break;
1790: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1791: bzero(wreq, sizeof(*wreq));
1792: error = copyin(ifr->ifr_data, wreq, sizeof(*wreq));
1793: if (error)
1794: break;
1795: error = wi_set_debug(sc, wreq);
1796: break;
1797: case SIOCG80211NWID:
1798: if ((ifp->if_flags & IFF_UP) && sc->wi_net_name.i_len > 0) {
1799: /* Return the desired ID */
1800: error = copyout(&sc->wi_net_name, ifr->ifr_data,
1801: sizeof(sc->wi_net_name));
1802: } else {
1803: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1804: bzero(wreq, sizeof(*wreq));
1805: wreq->wi_type = WI_RID_CURRENT_SSID;
1806: wreq->wi_len = WI_MAX_DATALEN;
1807: if (wi_read_record(sc, (struct wi_ltv_gen *)wreq) ||
1808: letoh16(wreq->wi_val[0]) > IEEE80211_NWID_LEN)
1809: error = EINVAL;
1810: else {
1811: nwidp = malloc(sizeof *nwidp, M_DEVBUF, M_WAITOK);
1812: bzero(nwidp, sizeof(*nwidp));
1813: wi_set_ssid(nwidp, (u_int8_t *)&wreq->wi_val[1],
1814: letoh16(wreq->wi_val[0]));
1815: error = copyout(nwidp, ifr->ifr_data,
1816: sizeof(*nwidp));
1817: }
1818: }
1819: break;
1820: case SIOCS80211NWID:
1821: if ((error = suser(curproc, 0)) != 0)
1822: break;
1823: nwidp = malloc(sizeof *nwidp, M_DEVBUF, M_WAITOK);
1824: error = copyin(ifr->ifr_data, nwidp, sizeof(*nwidp));
1825: if (error)
1826: break;
1827: if (nwidp->i_len > IEEE80211_NWID_LEN) {
1828: error = EINVAL;
1829: break;
1830: }
1831: if (sc->wi_net_name.i_len == nwidp->i_len &&
1832: memcmp(sc->wi_net_name.i_nwid, nwidp->i_nwid, nwidp->i_len) == 0)
1833: break;
1834: wi_set_ssid(&sc->wi_net_name, nwidp->i_nwid, nwidp->i_len);
1835: WI_SETSTR(WI_RID_DESIRED_SSID, sc->wi_net_name);
1836: if (ifp->if_flags & IFF_UP)
1837: /* Reinitialize WaveLAN. */
1838: wi_init(sc);
1839: break;
1840: case SIOCS80211NWKEY:
1841: if ((error = suser(curproc, 0)) != 0)
1842: break;
1843: error = wi_set_nwkey(sc, (struct ieee80211_nwkey *)data);
1844: break;
1845: case SIOCG80211NWKEY:
1846: error = wi_get_nwkey(sc, (struct ieee80211_nwkey *)data);
1847: break;
1848: case SIOCS80211POWER:
1849: if ((error = suser(curproc, 0)) != 0)
1850: break;
1851: error = wi_set_pm(sc, (struct ieee80211_power *)data);
1852: break;
1853: case SIOCG80211POWER:
1854: error = wi_get_pm(sc, (struct ieee80211_power *)data);
1855: break;
1856: case SIOCS80211TXPOWER:
1857: if ((error = suser(curproc, 0)) != 0)
1858: break;
1859: error = wi_set_txpower(sc, (struct ieee80211_txpower *)data);
1860: break;
1861: case SIOCG80211TXPOWER:
1862: error = wi_get_txpower(sc, (struct ieee80211_txpower *)data);
1863: break;
1864: case SIOCS80211CHANNEL:
1865: if ((error = suser(curproc, 0)) != 0)
1866: break;
1867: if (((struct ieee80211chanreq *)data)->i_channel > 14) {
1868: error = EINVAL;
1869: break;
1870: }
1871: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1872: bzero(wreq, sizeof(*wreq));
1873: wreq->wi_type = WI_RID_OWN_CHNL;
1874: wreq->wi_val[0] =
1875: htole16(((struct ieee80211chanreq *)data)->i_channel);
1876: error = wi_setdef(sc, wreq);
1877: if (!error && (ifp->if_flags & IFF_UP))
1878: wi_init(sc);
1879: break;
1880: case SIOCG80211CHANNEL:
1881: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1882: bzero(wreq, sizeof(*wreq));
1883: wreq->wi_type = WI_RID_CURRENT_CHAN;
1884: wreq->wi_len = WI_MAX_DATALEN;
1885: if (wi_read_record(sc, (struct wi_ltv_gen *)wreq)) {
1886: error = EINVAL;
1887: break;
1888: }
1889: ((struct ieee80211chanreq *)data)->i_channel =
1890: letoh16(wreq->wi_val[0]);
1891: break;
1892: case SIOCG80211BSSID:
1893: bssid = (struct ieee80211_bssid *)data;
1894: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1895: bzero(wreq, sizeof(*wreq));
1896: wreq->wi_type = WI_RID_CURRENT_BSSID;
1897: wreq->wi_len = WI_MAX_DATALEN;
1898: if (wi_read_record(sc, (struct wi_ltv_gen *)wreq)) {
1899: error = EINVAL;
1900: break;
1901: }
1902: IEEE80211_ADDR_COPY(bssid->i_bssid, wreq->wi_val);
1903: break;
1904: case SIOCS80211SCAN:
1905: if ((error = suser(curproc, 0)) != 0)
1906: break;
1907: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP)
1908: break;
1909: if ((ifp->if_flags & IFF_UP) == 0) {
1910: error = ENETDOWN;
1911: break;
1912: }
1913: if (sc->sc_firmware_type == WI_LUCENT) {
1914: wi_cmd(sc, WI_CMD_INQUIRE,
1915: WI_INFO_SCAN_RESULTS, 0, 0);
1916: } else {
1917: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1918: bzero(wreq, sizeof(*wreq));
1919: wreq->wi_len = 3;
1920: wreq->wi_type = WI_RID_SCAN_REQ;
1921: wreq->wi_val[0] = 0x3FFF;
1922: wreq->wi_val[1] = 0x000F;
1923:
1924: error = wi_write_record(sc,
1925: (struct wi_ltv_gen *)wreq);
1926: if (error)
1927: break;
1928: }
1929: sc->wi_scan_lock = 0;
1930: timeout_set(&sc->wi_scan_timeout, wi_scan_timeout, sc);
1931: len = WI_WAVELAN_RES_TIMEOUT;
1932: if (sc->wi_flags & WI_FLAGS_BUS_USB) {
1933: /* Use a longer timeout for wi@usb */
1934: len = WI_WAVELAN_RES_TIMEOUT * 4;
1935: }
1936: timeout_add(&sc->wi_scan_timeout, len);
1937:
1938: /* Let the userspace process wait for completion */
1939: error = tsleep(&sc->wi_scan_lock, PCATCH, "wiscan",
1940: hz * IEEE80211_SCAN_TIMEOUT);
1941: break;
1942: case SIOCG80211ALLNODES:
1943: {
1944: struct ieee80211_nodereq *nr = NULL;
1945:
1946: if ((error = suser(curproc, 0)) != 0)
1947: break;
1948: na = (struct ieee80211_nodereq_all *)data;
1949: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP) {
1950: /* List all associated stations */
1951: error = wihap_ioctl(sc, command, data);
1952: break;
1953: }
1954: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
1955: bzero(wreq, sizeof(*wreq));
1956: wreq->wi_len = WI_MAX_DATALEN;
1957: wreq->wi_type = WI_RID_SCAN_RES;
1958: if (sc->sc_firmware_type == WI_LUCENT) {
1959: bcopy(sc->wi_scanbuf, wreq->wi_val,
1960: sc->wi_scanbuf_len * 2);
1961: wreq->wi_len = sc->wi_scanbuf_len;
1962: i = 0;
1963: len = WI_WAVELAN_RES_SIZE;
1964: } else {
1965: if (wi_read_record(sc, (struct wi_ltv_gen *)wreq)) {
1966: error = EINVAL;
1967: break;
1968: }
1969: p2 = (struct wi_scan_p2_hdr *)wreq->wi_val;
1970: if (p2->wi_reason == 0)
1971: break;
1972: i = sizeof(*p2);
1973: len = WI_PRISM2_RES_SIZE;
1974: }
1975:
1976: for (na->na_nodes = j = 0; (i < (wreq->wi_len * 2) - len) &&
1977: (na->na_size >= j + sizeof(struct ieee80211_nodereq));
1978: i += len) {
1979:
1980: if (nr == NULL)
1981: nr = malloc(sizeof *nr, M_DEVBUF, M_WAITOK);
1982: res = (struct wi_scan_res *)((char *)wreq->wi_val + i);
1983: if (res == NULL)
1984: break;
1985:
1986: bzero(nr, sizeof(*nr));
1987: IEEE80211_ADDR_COPY(nr->nr_macaddr, res->wi_bssid);
1988: IEEE80211_ADDR_COPY(nr->nr_bssid, res->wi_bssid);
1989: nr->nr_channel = letoh16(res->wi_chan);
1990: nr->nr_chan_flags = IEEE80211_CHAN_B;
1991: nr->nr_rssi = letoh16(res->wi_signal);
1992: nr->nr_max_rssi = 0; /* XXX */
1993: nr->nr_nwid_len = letoh16(res->wi_ssid_len);
1994: bcopy(res->wi_ssid, nr->nr_nwid, nr->nr_nwid_len);
1995: nr->nr_intval = letoh16(res->wi_interval);
1996: nr->nr_capinfo = letoh16(res->wi_capinfo);
1997: nr->nr_txrate = res->wi_rate == WI_WAVELAN_RES_1M ? 2 :
1998: (res->wi_rate == WI_WAVELAN_RES_2M ? 4 :
1999: (res->wi_rate == WI_WAVELAN_RES_5M ? 11 :
2000: (res->wi_rate == WI_WAVELAN_RES_11M ? 22 : 0)));
2001: nr->nr_nrates = 0;
2002: while (res->wi_srates[nr->nr_nrates] != 0) {
2003: nr->nr_rates[nr->nr_nrates] =
2004: res->wi_srates[nr->nr_nrates] &
2005: WI_VAR_SRATES_MASK;
2006: nr->nr_nrates++;
2007: }
2008: nr->nr_flags = 0;
2009: if (bcmp(nr->nr_macaddr, nr->nr_bssid,
2010: IEEE80211_ADDR_LEN) == 0)
2011: nr->nr_flags |= IEEE80211_NODEREQ_AP;
2012:
2013: error = copyout(nr, (caddr_t)na->na_node + j,
2014: sizeof(struct ieee80211_nodereq));
2015: if (error)
2016: break;
2017: j += sizeof(struct ieee80211_nodereq);
2018: na->na_nodes++;
2019: }
2020: if (nr)
2021: free(nr, M_DEVBUF);
2022: break;
2023: }
2024: case SIOCG80211FLAGS:
2025: if (sc->wi_ptype != WI_PORTTYPE_HOSTAP)
2026: break;
2027: ifr->ifr_flags = 0;
2028: if (sc->wi_flags & WI_FLAGS_HAS_ENH_SECURITY) {
2029: wreq = malloc(sizeof *wreq, M_DEVBUF, M_WAITOK);
2030: bzero(wreq, sizeof(*wreq));
2031: wreq->wi_len = WI_MAX_DATALEN;
2032: wreq->wi_type = WI_RID_ENH_SECURITY;
2033: if (wi_read_record(sc, (struct wi_ltv_gen *)wreq)) {
2034: error = EINVAL;
2035: break;
2036: }
2037: sc->wi_enh_security = letoh16(wreq->wi_val[0]);
2038: if (sc->wi_enh_security == WI_HIDESSID_IGNPROBES)
2039: ifr->ifr_flags |= IEEE80211_F_HIDENWID >>
2040: IEEE80211_F_USERSHIFT;
2041: }
2042: break;
2043: case SIOCS80211FLAGS:
2044: if ((error = suser(curproc, 0)) != 0)
2045: break;
2046: if (sc->wi_ptype != WI_PORTTYPE_HOSTAP) {
2047: error = EINVAL;
2048: break;
2049: }
2050: flags = (u_int32_t)ifr->ifr_flags << IEEE80211_F_USERSHIFT;
2051: if (sc->wi_flags & WI_FLAGS_HAS_ENH_SECURITY) {
2052: sc->wi_enh_security = (flags & IEEE80211_F_HIDENWID) ?
2053: WI_HIDESSID_IGNPROBES : 0;
2054: WI_SETVAL(WI_RID_ENH_SECURITY, sc->wi_enh_security);
2055: }
2056: break;
2057: case SIOCHOSTAP_ADD:
2058: case SIOCHOSTAP_DEL:
2059: case SIOCHOSTAP_GET:
2060: case SIOCHOSTAP_GETALL:
2061: case SIOCHOSTAP_GFLAGS:
2062: case SIOCHOSTAP_SFLAGS:
2063: /* Send all Host AP specific ioctl's to Host AP code. */
2064: error = wihap_ioctl(sc, command, data);
2065: break;
2066: default:
2067: error = EINVAL;
2068: break;
2069: }
2070:
2071: if (wreq)
2072: free(wreq, M_DEVBUF);
2073: if (nwidp)
2074: free(nwidp, M_DEVBUF);
2075: splx(s);
2076: return(error);
2077: }
2078:
2079: void
2080: wi_scan_timeout(void *arg)
2081: {
2082: struct wi_softc *sc = (struct wi_softc *)arg;
2083: struct wi_req wreq;
2084:
2085: if (sc->wi_scan_lock++ < WI_WAVELAN_RES_TRIES &&
2086: sc->sc_firmware_type != WI_LUCENT &&
2087: (sc->wi_flags & WI_FLAGS_BUS_USB) == 0) {
2088: /*
2089: * The Prism2/2.5/3 chipsets will set an extra field in the
2090: * scan result if the scan request has been completed by the
2091: * firmware. This allows to poll for completion and to
2092: * wait for some more time if the scan is still in progress.
2093: *
2094: * XXX This doesn't work with wi@usb because it isn't safe
2095: * to call wi_read_record_usb() while beeing in the timeout
2096: * handler.
2097: */
2098: wreq.wi_len = WI_MAX_DATALEN;
2099: wreq.wi_type = WI_RID_SCAN_RES;
2100:
2101: if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq) == 0 &&
2102: ((struct wi_scan_p2_hdr *)wreq.wi_val)->wi_reason == 0) {
2103: /* Wait some more time for scan completion */
2104: timeout_add(&sc->wi_scan_timeout, WI_WAVELAN_RES_TIMEOUT);
2105: return;
2106: }
2107: }
2108:
2109: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
2110: printf(WI_PRT_FMT ": wi_scan_timeout: %d tries\n",
2111: WI_PRT_ARG(sc), sc->wi_scan_lock);
2112:
2113: /* Wakeup the userland */
2114: wakeup(&sc->wi_scan_lock);
2115: sc->wi_scan_lock = 0;
2116: }
2117:
2118: STATIC void
2119: wi_init_io(struct wi_softc *sc)
2120: {
2121: struct ifnet *ifp = &sc->sc_ic.ic_ac.ac_if;
2122: int s;
2123: struct wi_ltv_macaddr mac;
2124: int id = 0;
2125:
2126: if (!(sc->wi_flags & WI_FLAGS_ATTACHED))
2127: return;
2128:
2129: DPRINTF(WID_INIT, ("wi_init: sc %p\n", sc));
2130:
2131: s = splnet();
2132:
2133: if (ifp->if_flags & IFF_RUNNING)
2134: wi_stop(sc);
2135:
2136: wi_reset(sc);
2137:
2138: /* Program max data length. */
2139: WI_SETVAL(WI_RID_MAX_DATALEN, sc->wi_max_data_len);
2140:
2141: /* Set the port type. */
2142: WI_SETVAL(WI_RID_PORTTYPE, sc->wi_ptype);
2143:
2144: /* Enable/disable IBSS creation. */
2145: WI_SETVAL(WI_RID_CREATE_IBSS, sc->wi_create_ibss);
2146:
2147: /* Program the RTS/CTS threshold. */
2148: WI_SETVAL(WI_RID_RTS_THRESH, sc->wi_rts_thresh);
2149:
2150: /* Program the TX rate */
2151: WI_SETVAL(WI_RID_TX_RATE, sc->wi_tx_rate);
2152:
2153: /* Access point density */
2154: WI_SETVAL(WI_RID_SYSTEM_SCALE, sc->wi_ap_density);
2155:
2156: /* Power Management Enabled */
2157: WI_SETVAL(WI_RID_PM_ENABLED, sc->wi_pm_enabled);
2158:
2159: /* Power Management Max Sleep */
2160: WI_SETVAL(WI_RID_MAX_SLEEP, sc->wi_max_sleep);
2161:
2162: /* Set Enhanced Security if supported. */
2163: if (sc->wi_flags & WI_FLAGS_HAS_ENH_SECURITY)
2164: WI_SETVAL(WI_RID_ENH_SECURITY, sc->wi_enh_security);
2165:
2166: /* Set Roaming Mode unless this is a Symbol card. */
2167: if (sc->wi_flags & WI_FLAGS_HAS_ROAMING)
2168: WI_SETVAL(WI_RID_ROAMING_MODE, sc->wi_roaming);
2169:
2170: /* Set Antenna Diversity if this is a Symbol card. */
2171: if (sc->wi_flags & WI_FLAGS_HAS_DIVERSITY)
2172: WI_SETVAL(WI_RID_SYMBOL_DIVERSITY, sc->wi_diversity);
2173:
2174: /* Specify the network name */
2175: WI_SETSTR(WI_RID_DESIRED_SSID, sc->wi_net_name);
2176:
2177: /* Specify the IBSS name */
2178: if (sc->wi_net_name.i_len != 0 && (sc->wi_ptype == WI_PORTTYPE_HOSTAP ||
2179: (sc->wi_create_ibss && sc->wi_ptype == WI_PORTTYPE_IBSS)))
2180: WI_SETSTR(WI_RID_OWN_SSID, sc->wi_net_name);
2181: else
2182: WI_SETSTR(WI_RID_OWN_SSID, sc->wi_ibss_name);
2183:
2184: /* Specify the frequency to use */
2185: WI_SETVAL(WI_RID_OWN_CHNL, sc->wi_channel);
2186:
2187: /* Program the nodename. */
2188: WI_SETSTR(WI_RID_NODENAME, sc->wi_node_name);
2189:
2190: /* Set our MAC address. */
2191: mac.wi_len = 4;
2192: mac.wi_type = WI_RID_MAC_NODE;
2193: bcopy(LLADDR(ifp->if_sadl),
2194: (char *)&sc->sc_ic.ic_myaddr, ETHER_ADDR_LEN);
2195: bcopy((char *)&sc->sc_ic.ic_myaddr,
2196: (char *)&mac.wi_mac_addr, ETHER_ADDR_LEN);
2197: wi_write_record(sc, (struct wi_ltv_gen *)&mac);
2198:
2199: /*
2200: * Initialize promisc mode.
2201: * Being in the Host-AP mode causes
2202: * great deal of pain if promisc mode is set.
2203: * Therefore we avoid confusing the firmware
2204: * and always reset promisc mode in Host-AP regime,
2205: * it shows us all the packets anyway.
2206: */
2207: if (sc->wi_ptype != WI_PORTTYPE_HOSTAP && ifp->if_flags & IFF_PROMISC)
2208: WI_SETVAL(WI_RID_PROMISC, 1);
2209: else
2210: WI_SETVAL(WI_RID_PROMISC, 0);
2211:
2212: /* Configure WEP. */
2213: if (sc->wi_flags & WI_FLAGS_HAS_WEP) {
2214: WI_SETVAL(WI_RID_ENCRYPTION, sc->wi_use_wep);
2215: WI_SETVAL(WI_RID_TX_CRYPT_KEY, sc->wi_tx_key);
2216: sc->wi_keys.wi_len = (sizeof(struct wi_ltv_keys) / 2) + 1;
2217: sc->wi_keys.wi_type = WI_RID_DEFLT_CRYPT_KEYS;
2218: wi_write_record(sc, (struct wi_ltv_gen *)&sc->wi_keys);
2219: if (sc->sc_firmware_type != WI_LUCENT && sc->wi_use_wep) {
2220: /*
2221: * HWB3163 EVAL-CARD Firmware version less than 0.8.2.
2222: *
2223: * If promiscuous mode is disabled, the Prism2 chip
2224: * does not work with WEP .
2225: * I'm currently investigating the details of this.
2226: * (ichiro@netbsd.org)
2227: */
2228: if (sc->sc_firmware_type == WI_INTERSIL &&
2229: sc->sc_sta_firmware_ver < 802 ) {
2230: /* firm ver < 0.8.2 */
2231: WI_SETVAL(WI_RID_PROMISC, 1);
2232: }
2233: WI_SETVAL(WI_RID_CNFAUTHMODE, sc->wi_authtype);
2234: }
2235: }
2236:
2237: /* Set multicast filter. */
2238: wi_setmulti(sc);
2239:
2240: /* Enable desired port */
2241: wi_cmd(sc, WI_CMD_ENABLE | sc->wi_portnum, 0, 0, 0);
2242:
2243: if (wi_alloc_nicmem(sc, ETHER_MAX_LEN + sizeof(struct wi_frame) + 8, &id))
2244: printf(WI_PRT_FMT ": tx buffer allocation failed\n",
2245: WI_PRT_ARG(sc));
2246: sc->wi_tx_data_id = id;
2247:
2248: if (wi_alloc_nicmem(sc, ETHER_MAX_LEN + sizeof(struct wi_frame) + 8, &id))
2249: printf(WI_PRT_FMT ": mgmt. buffer allocation failed\n",
2250: WI_PRT_ARG(sc));
2251: sc->wi_tx_mgmt_id = id;
2252:
2253: /* Set txpower */
2254: if (sc->wi_flags & WI_FLAGS_TXPOWER)
2255: wi_set_txpower(sc, NULL);
2256:
2257: /* enable interrupts */
2258: wi_intr_enable(sc, WI_INTRS);
2259:
2260: wihap_init(sc);
2261:
2262: splx(s);
2263:
2264: ifp->if_flags |= IFF_RUNNING;
2265: ifp->if_flags &= ~IFF_OACTIVE;
2266:
2267: timeout_add(&sc->sc_timo, hz * 60);
2268:
2269: return;
2270: }
2271:
2272: static const u_int32_t crc32tab[] = {
2273: 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL,
2274: 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
2275: 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L,
2276: 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L,
2277: 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
2278: 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L,
2279: 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL,
2280: 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L,
2281: 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L,
2282: 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
2283: 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L,
2284: 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L,
2285: 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L,
2286: 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL,
2287: 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
2288: 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL,
2289: 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL,
2290: 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L,
2291: 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L,
2292: 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
2293: 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL,
2294: 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L,
2295: 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL,
2296: 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L,
2297: 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
2298: 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL,
2299: 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L,
2300: 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L,
2301: 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L,
2302: 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
2303: 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L,
2304: 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL,
2305: 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL,
2306: 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L,
2307: 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
2308: 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L,
2309: 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL,
2310: 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L,
2311: 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL,
2312: 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
2313: 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L,
2314: 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL,
2315: 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L,
2316: 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L,
2317: 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
2318: 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL,
2319: 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L,
2320: 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL,
2321: 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL,
2322: 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
2323: 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L,
2324: 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L,
2325: 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL,
2326: 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L,
2327: 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
2328: 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L,
2329: 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L,
2330: 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL,
2331: 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L,
2332: 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
2333: 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L,
2334: 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
2335: 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L,
2336: 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
2337: };
2338:
2339: STATIC void
2340: wi_do_hostencrypt(struct wi_softc *sc, caddr_t buf, int len)
2341: {
2342: u_int32_t i, crc, klen;
2343: u_int8_t key[RC4KEYLEN];
2344: u_int8_t *dat;
2345: struct rc4_ctx ctx;
2346:
2347: if (!sc->wi_icv_flag) {
2348: sc->wi_icv = arc4random();
2349: sc->wi_icv_flag++;
2350: } else
2351: sc->wi_icv++;
2352: /*
2353: * Skip 'bad' IVs from Fluhrer/Mantin/Shamir:
2354: * (B, 255, N) with 3 <= B < 8
2355: */
2356: if (sc->wi_icv >= 0x03ff00 &&
2357: (sc->wi_icv & 0xf8ff00) == 0x00ff00)
2358: sc->wi_icv += 0x000100;
2359:
2360: /* prepend 24bit IV to tx key, byte order does not matter */
2361: bzero(key, sizeof(key));
2362: key[0] = sc->wi_icv >> 16;
2363: key[1] = sc->wi_icv >> 8;
2364: key[2] = sc->wi_icv;
2365:
2366: klen = letoh16(sc->wi_keys.wi_keys[sc->wi_tx_key].wi_keylen);
2367: bcopy((char *)&sc->wi_keys.wi_keys[sc->wi_tx_key].wi_keydat,
2368: (char *)key + IEEE80211_WEP_IVLEN, klen);
2369: klen = (klen > IEEE80211_WEP_KEYLEN) ? RC4KEYLEN : RC4KEYLEN / 2;
2370:
2371: /* rc4 keysetup */
2372: rc4_keysetup(&ctx, key, klen);
2373:
2374: /* output: IV, tx keyid, rc4(data), rc4(crc32(data)) */
2375: dat = buf;
2376: dat[0] = key[0];
2377: dat[1] = key[1];
2378: dat[2] = key[2];
2379: dat[3] = sc->wi_tx_key << 6; /* pad and keyid */
2380: dat += 4;
2381:
2382: /* compute crc32 over data and encrypt */
2383: crc = ~0;
2384: for (i = 0; i < len; i++)
2385: crc = crc32tab[(crc ^ dat[i]) & 0xff] ^ (crc >> 8);
2386: crc = ~crc;
2387: rc4_crypt(&ctx, dat, dat, len);
2388: dat += len;
2389:
2390: /* append little-endian crc32 and encrypt */
2391: dat[0] = crc;
2392: dat[1] = crc >> 8;
2393: dat[2] = crc >> 16;
2394: dat[3] = crc >> 24;
2395: rc4_crypt(&ctx, dat, dat, IEEE80211_WEP_CRCLEN);
2396: }
2397:
2398: STATIC int
2399: wi_do_hostdecrypt(struct wi_softc *sc, caddr_t buf, int len)
2400: {
2401: u_int32_t i, crc, klen, kid;
2402: u_int8_t key[RC4KEYLEN];
2403: u_int8_t *dat;
2404: struct rc4_ctx ctx;
2405:
2406: if (len < IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN +
2407: IEEE80211_WEP_CRCLEN)
2408: return -1;
2409: len -= (IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN +
2410: IEEE80211_WEP_CRCLEN);
2411:
2412: dat = buf;
2413:
2414: bzero(key, sizeof(key));
2415: key[0] = dat[0];
2416: key[1] = dat[1];
2417: key[2] = dat[2];
2418: kid = (dat[3] >> 6) % 4;
2419: dat += 4;
2420:
2421: klen = letoh16(sc->wi_keys.wi_keys[kid].wi_keylen);
2422: bcopy((char *)&sc->wi_keys.wi_keys[kid].wi_keydat,
2423: (char *)key + IEEE80211_WEP_IVLEN, klen);
2424: klen = (klen > IEEE80211_WEP_KEYLEN) ? RC4KEYLEN : RC4KEYLEN / 2;
2425:
2426: /* rc4 keysetup */
2427: rc4_keysetup(&ctx, key, klen);
2428:
2429: /* decrypt and compute crc32 over data */
2430: rc4_crypt(&ctx, dat, dat, len);
2431: crc = ~0;
2432: for (i = 0; i < len; i++)
2433: crc = crc32tab[(crc ^ dat[i]) & 0xff] ^ (crc >> 8);
2434: crc = ~crc;
2435: dat += len;
2436:
2437: /* decrypt little-endian crc32 and verify */
2438: rc4_crypt(&ctx, dat, dat, IEEE80211_WEP_CRCLEN);
2439:
2440: if ((dat[0] != crc) && (dat[1] != crc >> 8) &&
2441: (dat[2] != crc >> 16) && (dat[3] != crc >> 24)) {
2442: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
2443: printf(WI_PRT_FMT ": wi_do_hostdecrypt: iv mismatch: "
2444: "0x%02x%02x%02x%02x vs. 0x%x\n", WI_PRT_ARG(sc),
2445: dat[3], dat[2], dat[1], dat[0], crc);
2446: return -1;
2447: }
2448:
2449: return 0;
2450: }
2451:
2452: void
2453: wi_start(struct ifnet *ifp)
2454: {
2455: struct wi_softc *sc;
2456: struct mbuf *m0;
2457: struct wi_frame tx_frame;
2458: struct ether_header *eh;
2459: int id, hostencrypt = 0;
2460:
2461: sc = ifp->if_softc;
2462:
2463: DPRINTF(WID_START, ("wi_start: ifp %p sc %p\n", ifp, sc));
2464:
2465: if (!(sc->wi_flags & WI_FLAGS_ATTACHED))
2466: return;
2467:
2468: if (ifp->if_flags & IFF_OACTIVE)
2469: return;
2470:
2471: nextpkt:
2472: IFQ_DEQUEUE(&ifp->if_snd, m0);
2473: if (m0 == NULL)
2474: return;
2475:
2476: bzero((char *)&tx_frame, sizeof(tx_frame));
2477: tx_frame.wi_frame_ctl = htole16(WI_FTYPE_DATA | WI_STYPE_DATA);
2478: id = sc->wi_tx_data_id;
2479: eh = mtod(m0, struct ether_header *);
2480:
2481: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP) {
2482: if (!wihap_check_tx(&sc->wi_hostap_info, eh->ether_dhost,
2483: &tx_frame.wi_tx_rate) && !(ifp->if_flags & IFF_PROMISC)) {
2484: if (ifp->if_flags & IFF_DEBUG)
2485: printf(WI_PRT_FMT
2486: ": wi_start: dropping unassoc dst %s\n",
2487: WI_PRT_ARG(sc),
2488: ether_sprintf(eh->ether_dhost));
2489: m_freem(m0);
2490: goto nextpkt;
2491: }
2492: }
2493:
2494: /*
2495: * Use RFC1042 encoding for IP and ARP datagrams,
2496: * 802.3 for anything else.
2497: */
2498: if (eh->ether_type == htons(ETHERTYPE_IP) ||
2499: eh->ether_type == htons(ETHERTYPE_ARP) ||
2500: eh->ether_type == htons(ETHERTYPE_REVARP) ||
2501: eh->ether_type == htons(ETHERTYPE_IPV6)) {
2502: bcopy((char *)&eh->ether_dhost,
2503: (char *)&tx_frame.wi_addr1, ETHER_ADDR_LEN);
2504: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP) {
2505: tx_frame.wi_tx_ctl = htole16(WI_ENC_TX_MGMT); /* XXX */
2506: tx_frame.wi_frame_ctl |= htole16(WI_FCTL_FROMDS);
2507: bcopy((char *)&sc->sc_ic.ic_myaddr,
2508: (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
2509: bcopy((char *)&eh->ether_shost,
2510: (char *)&tx_frame.wi_addr3, ETHER_ADDR_LEN);
2511: if (sc->wi_use_wep)
2512: hostencrypt = 1;
2513: } else if (sc->wi_ptype == WI_PORTTYPE_BSS && sc->wi_use_wep &&
2514: sc->wi_crypto_algorithm != WI_CRYPTO_FIRMWARE_WEP) {
2515: tx_frame.wi_tx_ctl = htole16(WI_ENC_TX_MGMT); /* XXX */
2516: tx_frame.wi_frame_ctl |= htole16(WI_FCTL_TODS);
2517: bcopy((char *)&sc->sc_ic.ic_myaddr,
2518: (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
2519: bcopy((char *)&eh->ether_dhost,
2520: (char *)&tx_frame.wi_addr3, ETHER_ADDR_LEN);
2521: hostencrypt = 1;
2522: } else
2523: bcopy((char *)&eh->ether_shost,
2524: (char *)&tx_frame.wi_addr2, ETHER_ADDR_LEN);
2525: bcopy((char *)&eh->ether_dhost,
2526: (char *)&tx_frame.wi_dst_addr, ETHER_ADDR_LEN);
2527: bcopy((char *)&eh->ether_shost,
2528: (char *)&tx_frame.wi_src_addr, ETHER_ADDR_LEN);
2529:
2530: tx_frame.wi_dat_len = m0->m_pkthdr.len - WI_SNAPHDR_LEN;
2531: tx_frame.wi_dat[0] = htons(WI_SNAP_WORD0);
2532: tx_frame.wi_dat[1] = htons(WI_SNAP_WORD1);
2533: tx_frame.wi_len = htons(m0->m_pkthdr.len - WI_SNAPHDR_LEN);
2534: tx_frame.wi_type = eh->ether_type;
2535:
2536: if (hostencrypt) {
2537:
2538: /* Do host encryption. */
2539: tx_frame.wi_frame_ctl |= htole16(WI_FCTL_WEP);
2540: bcopy(&tx_frame.wi_dat[0], &sc->wi_txbuf[4], 8);
2541:
2542: m_copydata(m0, sizeof(struct ether_header),
2543: m0->m_pkthdr.len - sizeof(struct ether_header),
2544: (caddr_t)&sc->wi_txbuf[12]);
2545:
2546: wi_do_hostencrypt(sc, (caddr_t)&sc->wi_txbuf,
2547: tx_frame.wi_dat_len);
2548:
2549: tx_frame.wi_dat_len += IEEE80211_WEP_IVLEN +
2550: IEEE80211_WEP_KIDLEN + IEEE80211_WEP_CRCLEN;
2551:
2552: tx_frame.wi_dat_len = htole16(tx_frame.wi_dat_len);
2553: wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
2554: sizeof(struct wi_frame));
2555: wi_write_data(sc, id, WI_802_11_OFFSET_RAW,
2556: (caddr_t)&sc->wi_txbuf,
2557: (m0->m_pkthdr.len -
2558: sizeof(struct ether_header)) + 18);
2559: } else {
2560: m_copydata(m0, sizeof(struct ether_header),
2561: m0->m_pkthdr.len - sizeof(struct ether_header),
2562: (caddr_t)&sc->wi_txbuf);
2563:
2564: tx_frame.wi_dat_len = htole16(tx_frame.wi_dat_len);
2565: wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
2566: sizeof(struct wi_frame));
2567: wi_write_data(sc, id, WI_802_11_OFFSET,
2568: (caddr_t)&sc->wi_txbuf,
2569: (m0->m_pkthdr.len -
2570: sizeof(struct ether_header)) + 2);
2571: }
2572: } else {
2573: tx_frame.wi_dat_len = htole16(m0->m_pkthdr.len);
2574:
2575: if (sc->wi_ptype == WI_PORTTYPE_HOSTAP && sc->wi_use_wep) {
2576:
2577: /* Do host encryption. (XXX - not implemented) */
2578: printf(WI_PRT_FMT
2579: ": host encrypt not implemented for 802.3\n",
2580: WI_PRT_ARG(sc));
2581: } else {
2582: m_copydata(m0, 0, m0->m_pkthdr.len,
2583: (caddr_t)&sc->wi_txbuf);
2584:
2585: wi_write_data(sc, id, 0, (caddr_t)&tx_frame,
2586: sizeof(struct wi_frame));
2587: wi_write_data(sc, id, WI_802_3_OFFSET,
2588: (caddr_t)&sc->wi_txbuf, m0->m_pkthdr.len + 2);
2589: }
2590: }
2591:
2592: #if NBPFILTER > 0
2593: /*
2594: * If there's a BPF listener, bounce a copy of
2595: * this frame to him.
2596: */
2597: if (ifp->if_bpf)
2598: bpf_mtap(ifp->if_bpf, m0, BPF_DIRECTION_OUT);
2599: #endif
2600:
2601: m_freem(m0);
2602:
2603: ifp->if_flags |= IFF_OACTIVE;
2604:
2605: /*
2606: * Set a timeout in case the chip goes out to lunch.
2607: */
2608: ifp->if_timer = 5;
2609:
2610: if (wi_cmd(sc, WI_CMD_TX|WI_RECLAIM, id, 0, 0))
2611: printf(WI_PRT_FMT ": wi_start: xmit failed\n", WI_PRT_ARG(sc));
2612:
2613: return;
2614: }
2615:
2616: STATIC int
2617: wi_mgmt_xmit(struct wi_softc *sc, caddr_t data, int len)
2618: {
2619: struct wi_frame tx_frame;
2620: int id;
2621: struct wi_80211_hdr *hdr;
2622: caddr_t dptr;
2623:
2624: if (!(sc->wi_flags & WI_FLAGS_ATTACHED))
2625: return(ENODEV);
2626:
2627: hdr = (struct wi_80211_hdr *)data;
2628: dptr = data + sizeof(struct wi_80211_hdr);
2629:
2630: bzero((char *)&tx_frame, sizeof(tx_frame));
2631: id = sc->wi_tx_mgmt_id;
2632:
2633: bcopy((char *)hdr, (char *)&tx_frame.wi_frame_ctl,
2634: sizeof(struct wi_80211_hdr));
2635:
2636: tx_frame.wi_tx_ctl = htole16(WI_ENC_TX_MGMT);
2637: tx_frame.wi_dat_len = len - sizeof(struct wi_80211_hdr);
2638: tx_frame.wi_len = htole16(tx_frame.wi_dat_len);
2639:
2640: tx_frame.wi_dat_len = htole16(tx_frame.wi_dat_len);
2641: wi_write_data(sc, id, 0, (caddr_t)&tx_frame, sizeof(struct wi_frame));
2642: wi_write_data(sc, id, WI_802_11_OFFSET_RAW, dptr,
2643: (len - sizeof(struct wi_80211_hdr)) + 2);
2644:
2645: if (wi_cmd(sc, WI_CMD_TX|WI_RECLAIM, id, 0, 0)) {
2646: printf(WI_PRT_FMT ": wi_mgmt_xmit: xmit failed\n",
2647: WI_PRT_ARG(sc));
2648: /*
2649: * Hostile stations or corrupt frames may crash the card
2650: * and cause the kernel to get stuck printing complaints.
2651: * Reset the card and hope the problem goes away.
2652: */
2653: wi_reset(sc);
2654: return(EIO);
2655: }
2656:
2657: return(0);
2658: }
2659:
2660: void
2661: wi_stop(struct wi_softc *sc)
2662: {
2663: struct ifnet *ifp;
2664:
2665: wihap_shutdown(sc);
2666:
2667: if (!(sc->wi_flags & WI_FLAGS_ATTACHED))
2668: return;
2669:
2670: DPRINTF(WID_STOP, ("wi_stop: sc %p\n", sc));
2671:
2672: timeout_del(&sc->sc_timo);
2673:
2674: ifp = &sc->sc_ic.ic_if;
2675:
2676: wi_intr_enable(sc, 0);
2677: wi_cmd(sc, WI_CMD_DISABLE|sc->wi_portnum, 0, 0, 0);
2678:
2679: ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE);
2680: ifp->if_timer = 0;
2681:
2682: return;
2683: }
2684:
2685:
2686: void
2687: wi_watchdog(struct ifnet *ifp)
2688: {
2689: struct wi_softc *sc;
2690:
2691: sc = ifp->if_softc;
2692:
2693: printf(WI_PRT_FMT ": device timeout\n", WI_PRT_ARG(sc));
2694:
2695: wi_cor_reset(sc);
2696: wi_init(sc);
2697:
2698: ifp->if_oerrors++;
2699:
2700: return;
2701: }
2702:
2703: void
2704: wi_detach(struct wi_softc *sc)
2705: {
2706: struct ifnet *ifp;
2707: ifp = &sc->sc_ic.ic_if;
2708:
2709: if (ifp->if_flags & IFF_RUNNING)
2710: wi_stop(sc);
2711:
2712: if (sc->wi_flags & WI_FLAGS_ATTACHED) {
2713: sc->wi_flags &= ~WI_FLAGS_ATTACHED;
2714: if (sc->sc_sdhook != NULL)
2715: shutdownhook_disestablish(sc->sc_sdhook);
2716: }
2717: }
2718:
2719: STATIC void
2720: wi_shutdown(void *arg)
2721: {
2722: struct wi_softc *sc;
2723:
2724: sc = arg;
2725: wi_stop(sc);
2726:
2727: return;
2728: }
2729:
2730: STATIC void
2731: wi_get_id(struct wi_softc *sc)
2732: {
2733: struct wi_ltv_ver ver;
2734: const struct wi_card_ident *id;
2735: u_int16_t pri_fw_ver[3];
2736: const char *card_name;
2737: u_int16_t card_id;
2738:
2739: /* get chip identity */
2740: bzero(&ver, sizeof(ver));
2741: ver.wi_type = WI_RID_CARD_ID;
2742: ver.wi_len = 5;
2743: wi_read_record(sc, (struct wi_ltv_gen *)&ver);
2744: card_id = letoh16(ver.wi_ver[0]);
2745: for (id = wi_card_ident; id->firm_type != WI_NOTYPE; id++) {
2746: if (card_id == id->card_id)
2747: break;
2748: }
2749: if (id->firm_type != WI_NOTYPE) {
2750: sc->sc_firmware_type = id->firm_type;
2751: card_name = id->card_name;
2752: } else if (ver.wi_ver[0] & htole16(0x8000)) {
2753: sc->sc_firmware_type = WI_INTERSIL;
2754: card_name = "Unknown PRISM2 chip";
2755: } else {
2756: sc->sc_firmware_type = WI_LUCENT;
2757: }
2758:
2759: /* get primary firmware version (XXX - how to do Lucent?) */
2760: if (sc->sc_firmware_type != WI_LUCENT) {
2761: bzero(&ver, sizeof(ver));
2762: ver.wi_type = WI_RID_PRI_IDENTITY;
2763: ver.wi_len = 5;
2764: wi_read_record(sc, (struct wi_ltv_gen *)&ver);
2765: pri_fw_ver[0] = letoh16(ver.wi_ver[2]);
2766: pri_fw_ver[1] = letoh16(ver.wi_ver[3]);
2767: pri_fw_ver[2] = letoh16(ver.wi_ver[1]);
2768: }
2769:
2770: /* get station firmware version */
2771: bzero(&ver, sizeof(ver));
2772: ver.wi_type = WI_RID_STA_IDENTITY;
2773: ver.wi_len = 5;
2774: wi_read_record(sc, (struct wi_ltv_gen *)&ver);
2775: ver.wi_ver[1] = letoh16(ver.wi_ver[1]);
2776: ver.wi_ver[2] = letoh16(ver.wi_ver[2]);
2777: ver.wi_ver[3] = letoh16(ver.wi_ver[3]);
2778: sc->sc_sta_firmware_ver = ver.wi_ver[2] * 10000 +
2779: ver.wi_ver[3] * 100 + ver.wi_ver[1];
2780:
2781: if (sc->sc_firmware_type == WI_INTERSIL &&
2782: (sc->sc_sta_firmware_ver == 10102 || sc->sc_sta_firmware_ver == 20102)) {
2783: struct wi_ltv_str sver;
2784: char *p;
2785:
2786: bzero(&sver, sizeof(sver));
2787: sver.wi_type = WI_RID_SYMBOL_IDENTITY;
2788: sver.wi_len = 7;
2789: /* value should be something like "V2.00-11" */
2790: if (wi_read_record(sc, (struct wi_ltv_gen *)&sver) == 0 &&
2791: *(p = (char *)sver.wi_str) >= 'A' &&
2792: p[2] == '.' && p[5] == '-' && p[8] == '\0') {
2793: sc->sc_firmware_type = WI_SYMBOL;
2794: sc->sc_sta_firmware_ver = (p[1] - '0') * 10000 +
2795: (p[3] - '0') * 1000 + (p[4] - '0') * 100 +
2796: (p[6] - '0') * 10 + (p[7] - '0');
2797: }
2798: }
2799:
2800: if (sc->sc_firmware_type == WI_LUCENT) {
2801: printf("%s: Firmware %d.%02d variant %d, ", WI_PRT_ARG(sc),
2802: ver.wi_ver[2], ver.wi_ver[3], ver.wi_ver[1]);
2803: } else {
2804: printf("%s: %s%s (0x%04x), Firmware %d.%d.%d (primary), %d.%d.%d (station), ",
2805: WI_PRT_ARG(sc),
2806: sc->sc_firmware_type == WI_SYMBOL ? "Symbol " : "",
2807: card_name, card_id, pri_fw_ver[0], pri_fw_ver[1],
2808: pri_fw_ver[2], sc->sc_sta_firmware_ver / 10000,
2809: (sc->sc_sta_firmware_ver % 10000) / 100,
2810: sc->sc_sta_firmware_ver % 100);
2811: }
2812: }
2813:
2814: STATIC int
2815: wi_sync_media(struct wi_softc *sc, int ptype, int txrate)
2816: {
2817: int media = sc->sc_media.ifm_cur->ifm_media;
2818: int options = IFM_OPTIONS(media);
2819: int subtype;
2820:
2821: switch (txrate) {
2822: case 1:
2823: subtype = IFM_IEEE80211_DS1;
2824: break;
2825: case 2:
2826: subtype = IFM_IEEE80211_DS2;
2827: break;
2828: case 3:
2829: subtype = IFM_AUTO;
2830: break;
2831: case 5:
2832: subtype = IFM_IEEE80211_DS5;
2833: break;
2834: case 11:
2835: subtype = IFM_IEEE80211_DS11;
2836: break;
2837: default:
2838: subtype = IFM_MANUAL; /* Unable to represent */
2839: break;
2840: }
2841:
2842: options &= ~IFM_OMASK;
2843: switch (ptype) {
2844: case WI_PORTTYPE_BSS:
2845: /* default port type */
2846: break;
2847: case WI_PORTTYPE_ADHOC:
2848: options |= IFM_IEEE80211_ADHOC;
2849: break;
2850: case WI_PORTTYPE_HOSTAP:
2851: options |= IFM_IEEE80211_HOSTAP;
2852: break;
2853: case WI_PORTTYPE_IBSS:
2854: if (sc->wi_create_ibss)
2855: options |= IFM_IEEE80211_IBSSMASTER;
2856: else
2857: options |= IFM_IEEE80211_IBSS;
2858: break;
2859: default:
2860: subtype = IFM_MANUAL; /* Unable to represent */
2861: break;
2862: }
2863: media = IFM_MAKEWORD(IFM_TYPE(media), subtype, options,
2864: IFM_INST(media));
2865: if (ifmedia_match(&sc->sc_media, media, sc->sc_media.ifm_mask) == NULL)
2866: return (EINVAL);
2867: ifmedia_set(&sc->sc_media, media);
2868: sc->wi_ptype = ptype;
2869: sc->wi_tx_rate = txrate;
2870: return (0);
2871: }
2872:
2873: STATIC int
2874: wi_media_change(struct ifnet *ifp)
2875: {
2876: struct wi_softc *sc = ifp->if_softc;
2877: int otype = sc->wi_ptype;
2878: int orate = sc->wi_tx_rate;
2879: int ocreate_ibss = sc->wi_create_ibss;
2880:
2881: if ((sc->sc_media.ifm_cur->ifm_media & IFM_IEEE80211_HOSTAP) &&
2882: sc->sc_firmware_type != WI_INTERSIL)
2883: return (EINVAL);
2884:
2885: sc->wi_create_ibss = 0;
2886:
2887: switch (sc->sc_media.ifm_cur->ifm_media & IFM_OMASK) {
2888: case 0:
2889: sc->wi_ptype = WI_PORTTYPE_BSS;
2890: break;
2891: case IFM_IEEE80211_ADHOC:
2892: sc->wi_ptype = WI_PORTTYPE_ADHOC;
2893: break;
2894: case IFM_IEEE80211_HOSTAP:
2895: sc->wi_ptype = WI_PORTTYPE_HOSTAP;
2896: break;
2897: case IFM_IEEE80211_IBSSMASTER:
2898: case IFM_IEEE80211_IBSSMASTER|IFM_IEEE80211_IBSS:
2899: if (!(sc->wi_flags & WI_FLAGS_HAS_CREATE_IBSS))
2900: return (EINVAL);
2901: sc->wi_create_ibss = 1;
2902: /* FALLTHROUGH */
2903: case IFM_IEEE80211_IBSS:
2904: sc->wi_ptype = WI_PORTTYPE_IBSS;
2905: break;
2906: default:
2907: /* Invalid combination. */
2908: return (EINVAL);
2909: }
2910:
2911: switch (IFM_SUBTYPE(sc->sc_media.ifm_cur->ifm_media)) {
2912: case IFM_IEEE80211_DS1:
2913: sc->wi_tx_rate = 1;
2914: break;
2915: case IFM_IEEE80211_DS2:
2916: sc->wi_tx_rate = 2;
2917: break;
2918: case IFM_AUTO:
2919: sc->wi_tx_rate = 3;
2920: break;
2921: case IFM_IEEE80211_DS5:
2922: sc->wi_tx_rate = 5;
2923: break;
2924: case IFM_IEEE80211_DS11:
2925: sc->wi_tx_rate = 11;
2926: break;
2927: }
2928:
2929: if (sc->sc_ic.ic_if.if_flags & IFF_UP) {
2930: if (otype != sc->wi_ptype || orate != sc->wi_tx_rate ||
2931: ocreate_ibss != sc->wi_create_ibss)
2932: wi_init(sc);
2933: }
2934:
2935: ifp->if_baudrate = ifmedia_baudrate(sc->sc_media.ifm_cur->ifm_media);
2936:
2937: return (0);
2938: }
2939:
2940: STATIC void
2941: wi_media_status(struct ifnet *ifp, struct ifmediareq *imr)
2942: {
2943: struct wi_softc *sc = ifp->if_softc;
2944: struct wi_req wreq;
2945:
2946: if (!(sc->sc_ic.ic_if.if_flags & IFF_UP)) {
2947: imr->ifm_active = IFM_IEEE80211|IFM_NONE;
2948: imr->ifm_status = 0;
2949: return;
2950: }
2951:
2952: if (sc->wi_tx_rate == 3) {
2953: imr->ifm_active = IFM_IEEE80211|IFM_AUTO;
2954:
2955: wreq.wi_type = WI_RID_CUR_TX_RATE;
2956: wreq.wi_len = WI_MAX_DATALEN;
2957: if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq) == 0) {
2958: switch (letoh16(wreq.wi_val[0])) {
2959: case 1:
2960: imr->ifm_active |= IFM_IEEE80211_DS1;
2961: break;
2962: case 2:
2963: imr->ifm_active |= IFM_IEEE80211_DS2;
2964: break;
2965: case 6:
2966: imr->ifm_active |= IFM_IEEE80211_DS5;
2967: break;
2968: case 11:
2969: imr->ifm_active |= IFM_IEEE80211_DS11;
2970: break;
2971: }
2972: }
2973: } else {
2974: imr->ifm_active = sc->sc_media.ifm_cur->ifm_media;
2975: }
2976:
2977: imr->ifm_status = IFM_AVALID;
2978: switch (sc->wi_ptype) {
2979: case WI_PORTTYPE_ADHOC:
2980: case WI_PORTTYPE_IBSS:
2981: /*
2982: * XXX: It would be nice if we could give some actually
2983: * useful status like whether we joined another IBSS or
2984: * created one ourselves.
2985: */
2986: /* FALLTHROUGH */
2987: case WI_PORTTYPE_HOSTAP:
2988: imr->ifm_status |= IFM_ACTIVE;
2989: break;
2990: default:
2991: wreq.wi_type = WI_RID_COMMQUAL;
2992: wreq.wi_len = WI_MAX_DATALEN;
2993: if (wi_read_record(sc, (struct wi_ltv_gen *)&wreq) == 0 &&
2994: letoh16(wreq.wi_val[0]) != 0)
2995: imr->ifm_status |= IFM_ACTIVE;
2996: }
2997: }
2998:
2999: STATIC int
3000: wi_set_nwkey(struct wi_softc *sc, struct ieee80211_nwkey *nwkey)
3001: {
3002: int i, len, error;
3003: struct wi_req wreq;
3004: struct wi_ltv_keys *wk = (struct wi_ltv_keys *)&wreq;
3005:
3006: if (!(sc->wi_flags & WI_FLAGS_HAS_WEP))
3007: return ENODEV;
3008: if (nwkey->i_defkid <= 0 || nwkey->i_defkid > IEEE80211_WEP_NKID)
3009: return EINVAL;
3010: memcpy(wk, &sc->wi_keys, sizeof(*wk));
3011: for (i = 0; i < IEEE80211_WEP_NKID; i++) {
3012: if (nwkey->i_key[i].i_keydat == NULL)
3013: continue;
3014: len = nwkey->i_key[i].i_keylen;
3015: if (len > sizeof(wk->wi_keys[i].wi_keydat))
3016: return EINVAL;
3017: error = copyin(nwkey->i_key[i].i_keydat,
3018: wk->wi_keys[i].wi_keydat, len);
3019: if (error)
3020: return error;
3021: wk->wi_keys[i].wi_keylen = htole16(len);
3022: }
3023:
3024: wk->wi_len = (sizeof(*wk) / 2) + 1;
3025: wk->wi_type = WI_RID_DEFLT_CRYPT_KEYS;
3026: if (sc->sc_ic.ic_if.if_flags & IFF_UP) {
3027: error = wi_write_record(sc, (struct wi_ltv_gen *)&wreq);
3028: if (error)
3029: return error;
3030: }
3031: if ((error = wi_setdef(sc, &wreq)))
3032: return (error);
3033:
3034: wreq.wi_len = 2;
3035: wreq.wi_type = WI_RID_TX_CRYPT_KEY;
3036: wreq.wi_val[0] = htole16(nwkey->i_defkid - 1);
3037: if (sc->sc_ic.ic_if.if_flags & IFF_UP) {
3038: error = wi_write_record(sc, (struct wi_ltv_gen *)&wreq);
3039: if (error)
3040: return error;
3041: }
3042: if ((error = wi_setdef(sc, &wreq)))
3043: return (error);
3044:
3045: wreq.wi_type = WI_RID_ENCRYPTION;
3046: wreq.wi_val[0] = htole16(nwkey->i_wepon);
3047: if (sc->sc_ic.ic_if.if_flags & IFF_UP) {
3048: error = wi_write_record(sc, (struct wi_ltv_gen *)&wreq);
3049: if (error)
3050: return error;
3051: }
3052: if ((error = wi_setdef(sc, &wreq)))
3053: return (error);
3054:
3055: if (sc->sc_ic.ic_if.if_flags & IFF_UP)
3056: wi_init(sc);
3057: return 0;
3058: }
3059:
3060: STATIC int
3061: wi_get_nwkey(struct wi_softc *sc, struct ieee80211_nwkey *nwkey)
3062: {
3063: int i, len, error;
3064: struct wi_ltv_keys *wk = &sc->wi_keys;
3065:
3066: if (!(sc->wi_flags & WI_FLAGS_HAS_WEP))
3067: return ENODEV;
3068: nwkey->i_wepon = sc->wi_use_wep;
3069: nwkey->i_defkid = sc->wi_tx_key + 1;
3070:
3071: /* do not show any keys to non-root user */
3072: error = suser(curproc, 0);
3073: for (i = 0; i < IEEE80211_WEP_NKID; i++) {
3074: if (nwkey->i_key[i].i_keydat == NULL)
3075: continue;
3076: /* error holds results of suser() for the first time */
3077: if (error)
3078: return error;
3079: len = letoh16(wk->wi_keys[i].wi_keylen);
3080: if (nwkey->i_key[i].i_keylen < len)
3081: return ENOSPC;
3082: nwkey->i_key[i].i_keylen = len;
3083: error = copyout(wk->wi_keys[i].wi_keydat,
3084: nwkey->i_key[i].i_keydat, len);
3085: if (error)
3086: return error;
3087: }
3088: return 0;
3089: }
3090:
3091: STATIC int
3092: wi_set_pm(struct wi_softc *sc, struct ieee80211_power *power)
3093: {
3094:
3095: sc->wi_pm_enabled = power->i_enabled;
3096: sc->wi_max_sleep = power->i_maxsleep;
3097:
3098: if (sc->sc_ic.ic_if.if_flags & IFF_UP)
3099: wi_init(sc);
3100:
3101: return (0);
3102: }
3103:
3104: STATIC int
3105: wi_get_pm(struct wi_softc *sc, struct ieee80211_power *power)
3106: {
3107:
3108: power->i_enabled = sc->wi_pm_enabled;
3109: power->i_maxsleep = sc->wi_max_sleep;
3110:
3111: return (0);
3112: }
3113:
3114: STATIC int
3115: wi_set_txpower(struct wi_softc *sc, struct ieee80211_txpower *txpower)
3116: {
3117: u_int16_t cmd;
3118: u_int16_t power;
3119: int8_t tmp;
3120: int error;
3121: int alc;
3122:
3123: if (txpower == NULL) {
3124: if (!(sc->wi_flags & WI_FLAGS_TXPOWER))
3125: return (EINVAL);
3126: alc = 0; /* disable ALC */
3127: } else {
3128: if (txpower->i_mode == IEEE80211_TXPOWER_MODE_AUTO) {
3129: alc = 1; /* enable ALC */
3130: sc->wi_flags &= ~WI_FLAGS_TXPOWER;
3131: } else {
3132: alc = 0; /* disable ALC */
3133: sc->wi_flags |= WI_FLAGS_TXPOWER;
3134: sc->wi_txpower = txpower->i_val;
3135: }
3136: }
3137:
3138: /* Set ALC */
3139: cmd = WI_CMD_DEBUG | (WI_DEBUG_CONFBITS << 8);
3140: if ((error = wi_cmd(sc, cmd, alc, 0x8, 0)) != 0)
3141: return (error);
3142:
3143: /* No need to set the TX power value if ALC is enabled */
3144: if (alc)
3145: return (0);
3146:
3147: /* Convert dBM to internal TX power value */
3148: if (sc->wi_txpower > 20)
3149: power = 128;
3150: else if (sc->wi_txpower < -43)
3151: power = 127;
3152: else {
3153: tmp = sc->wi_txpower;
3154: tmp = -12 - tmp;
3155: tmp <<= 2;
3156:
3157: power = (u_int16_t)tmp;
3158: }
3159:
3160: /* Set manual TX power */
3161: cmd = WI_CMD_WRITE_MIF;
3162: if ((error = wi_cmd(sc, cmd,
3163: WI_HFA384X_CR_MANUAL_TX_POWER, power, 0)) != 0)
3164: return (error);
3165:
3166: if (sc->sc_ic.ic_if.if_flags & IFF_DEBUG)
3167: printf("%s: %u (%d dBm)\n", sc->sc_dev.dv_xname, power,
3168: sc->wi_txpower);
3169:
3170: return (0);
3171: }
3172:
3173: STATIC int
3174: wi_get_txpower(struct wi_softc *sc, struct ieee80211_txpower *txpower)
3175: {
3176: u_int16_t cmd;
3177: u_int16_t power;
3178: int8_t tmp;
3179: int error;
3180:
3181: if (sc->wi_flags & WI_FLAGS_BUS_USB)
3182: return (EOPNOTSUPP);
3183:
3184: /* Get manual TX power */
3185: cmd = WI_CMD_READ_MIF;
3186: if ((error = wi_cmd(sc, cmd,
3187: WI_HFA384X_CR_MANUAL_TX_POWER, 0, 0)) != 0)
3188: return (error);
3189:
3190: power = CSR_READ_2(sc, WI_RESP0);
3191:
3192: /* Convert internal TX power value to dBM */
3193: if (power > 255)
3194: txpower->i_val = 255;
3195: else {
3196: tmp = power;
3197: tmp >>= 2;
3198: txpower->i_val = (u_int16_t)(-12 - tmp);
3199: }
3200:
3201: if (sc->wi_flags & WI_FLAGS_TXPOWER)
3202: txpower->i_mode = IEEE80211_TXPOWER_MODE_FIXED;
3203: else
3204: txpower->i_mode = IEEE80211_TXPOWER_MODE_AUTO;
3205:
3206: return (0);
3207: }
3208:
3209: STATIC int
3210: wi_set_ssid(struct ieee80211_nwid *ws, u_int8_t *id, int len)
3211: {
3212:
3213: if (len > IEEE80211_NWID_LEN)
3214: return (EINVAL);
3215: ws->i_len = len;
3216: memcpy(ws->i_nwid, id, len);
3217: return (0);
3218: }
3219:
3220: STATIC int
3221: wi_get_debug(struct wi_softc *sc, struct wi_req *wreq)
3222: {
3223: int error = 0;
3224:
3225: wreq->wi_len = 1;
3226:
3227: switch (wreq->wi_type) {
3228: case WI_DEBUG_SLEEP:
3229: wreq->wi_len++;
3230: wreq->wi_val[0] = htole16(sc->wi_debug.wi_sleep);
3231: break;
3232: case WI_DEBUG_DELAYSUPP:
3233: wreq->wi_len++;
3234: wreq->wi_val[0] = htole16(sc->wi_debug.wi_delaysupp);
3235: break;
3236: case WI_DEBUG_TXSUPP:
3237: wreq->wi_len++;
3238: wreq->wi_val[0] = htole16(sc->wi_debug.wi_txsupp);
3239: break;
3240: case WI_DEBUG_MONITOR:
3241: wreq->wi_len++;
3242: wreq->wi_val[0] = htole16(sc->wi_debug.wi_monitor);
3243: break;
3244: case WI_DEBUG_LEDTEST:
3245: wreq->wi_len += 3;
3246: wreq->wi_val[0] = htole16(sc->wi_debug.wi_ledtest);
3247: wreq->wi_val[1] = htole16(sc->wi_debug.wi_ledtest_param0);
3248: wreq->wi_val[2] = htole16(sc->wi_debug.wi_ledtest_param1);
3249: break;
3250: case WI_DEBUG_CONTTX:
3251: wreq->wi_len += 2;
3252: wreq->wi_val[0] = htole16(sc->wi_debug.wi_conttx);
3253: wreq->wi_val[1] = htole16(sc->wi_debug.wi_conttx_param0);
3254: break;
3255: case WI_DEBUG_CONTRX:
3256: wreq->wi_len++;
3257: wreq->wi_val[0] = htole16(sc->wi_debug.wi_contrx);
3258: break;
3259: case WI_DEBUG_SIGSTATE:
3260: wreq->wi_len += 2;
3261: wreq->wi_val[0] = htole16(sc->wi_debug.wi_sigstate);
3262: wreq->wi_val[1] = htole16(sc->wi_debug.wi_sigstate_param0);
3263: break;
3264: case WI_DEBUG_CONFBITS:
3265: wreq->wi_len += 2;
3266: wreq->wi_val[0] = htole16(sc->wi_debug.wi_confbits);
3267: wreq->wi_val[1] = htole16(sc->wi_debug.wi_confbits_param0);
3268: break;
3269: default:
3270: error = EIO;
3271: break;
3272: }
3273:
3274: return (error);
3275: }
3276:
3277: STATIC int
3278: wi_set_debug(struct wi_softc *sc, struct wi_req *wreq)
3279: {
3280: int error = 0;
3281: u_int16_t cmd, param0 = 0, param1 = 0;
3282:
3283: switch (wreq->wi_type) {
3284: case WI_DEBUG_RESET:
3285: case WI_DEBUG_INIT:
3286: case WI_DEBUG_CALENABLE:
3287: break;
3288: case WI_DEBUG_SLEEP:
3289: sc->wi_debug.wi_sleep = 1;
3290: break;
3291: case WI_DEBUG_WAKE:
3292: sc->wi_debug.wi_sleep = 0;
3293: break;
3294: case WI_DEBUG_CHAN:
3295: param0 = letoh16(wreq->wi_val[0]);
3296: break;
3297: case WI_DEBUG_DELAYSUPP:
3298: sc->wi_debug.wi_delaysupp = 1;
3299: break;
3300: case WI_DEBUG_TXSUPP:
3301: sc->wi_debug.wi_txsupp = 1;
3302: break;
3303: case WI_DEBUG_MONITOR:
3304: sc->wi_debug.wi_monitor = 1;
3305: break;
3306: case WI_DEBUG_LEDTEST:
3307: param0 = letoh16(wreq->wi_val[0]);
3308: param1 = letoh16(wreq->wi_val[1]);
3309: sc->wi_debug.wi_ledtest = 1;
3310: sc->wi_debug.wi_ledtest_param0 = param0;
3311: sc->wi_debug.wi_ledtest_param1 = param1;
3312: break;
3313: case WI_DEBUG_CONTTX:
3314: param0 = letoh16(wreq->wi_val[0]);
3315: sc->wi_debug.wi_conttx = 1;
3316: sc->wi_debug.wi_conttx_param0 = param0;
3317: break;
3318: case WI_DEBUG_STOPTEST:
3319: sc->wi_debug.wi_delaysupp = 0;
3320: sc->wi_debug.wi_txsupp = 0;
3321: sc->wi_debug.wi_monitor = 0;
3322: sc->wi_debug.wi_ledtest = 0;
3323: sc->wi_debug.wi_ledtest_param0 = 0;
3324: sc->wi_debug.wi_ledtest_param1 = 0;
3325: sc->wi_debug.wi_conttx = 0;
3326: sc->wi_debug.wi_conttx_param0 = 0;
3327: sc->wi_debug.wi_contrx = 0;
3328: sc->wi_debug.wi_sigstate = 0;
3329: sc->wi_debug.wi_sigstate_param0 = 0;
3330: break;
3331: case WI_DEBUG_CONTRX:
3332: sc->wi_debug.wi_contrx = 1;
3333: break;
3334: case WI_DEBUG_SIGSTATE:
3335: param0 = letoh16(wreq->wi_val[0]);
3336: sc->wi_debug.wi_sigstate = 1;
3337: sc->wi_debug.wi_sigstate_param0 = param0;
3338: break;
3339: case WI_DEBUG_CONFBITS:
3340: param0 = letoh16(wreq->wi_val[0]);
3341: param1 = letoh16(wreq->wi_val[1]);
3342: sc->wi_debug.wi_confbits = param0;
3343: sc->wi_debug.wi_confbits_param0 = param1;
3344: break;
3345: default:
3346: error = EIO;
3347: break;
3348: }
3349:
3350: if (error)
3351: return (error);
3352:
3353: cmd = WI_CMD_DEBUG | (wreq->wi_type << 8);
3354: error = wi_cmd(sc, cmd, param0, param1, 0);
3355:
3356: return (error);
3357: }