1 | /* $NetBSD: an.c,v 1.63 2016/06/10 13:27:13 ozaki-r Exp $ */ |
2 | /* |
3 | * Copyright (c) 1997, 1998, 1999 |
4 | * Bill Paul <wpaul@ctr.columbia.edu>. All rights reserved. |
5 | * |
6 | * Redistribution and use in source and binary forms, with or without |
7 | * modification, are permitted provided that the following conditions |
8 | * are met: |
9 | * 1. Redistributions of source code must retain the above copyright |
10 | * notice, this list of conditions and the following disclaimer. |
11 | * 2. Redistributions in binary form must reproduce the above copyright |
12 | * notice, this list of conditions and the following disclaimer in the |
13 | * documentation and/or other materials provided with the distribution. |
14 | * 3. All advertising materials mentioning features or use of this software |
15 | * must display the following acknowledgement: |
16 | * This product includes software developed by Bill Paul. |
17 | * 4. Neither the name of the author nor the names of any co-contributors |
18 | * may be used to endorse or promote products derived from this software |
19 | * without specific prior written permission. |
20 | * |
21 | * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND |
22 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
23 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
24 | * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD |
25 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
26 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
27 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
28 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
29 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
30 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
31 | * THE POSSIBILITY OF SUCH DAMAGE. |
32 | * |
33 | * $FreeBSD: src/sys/dev/an/if_an.c,v 1.12 2000/11/13 23:04:12 wpaul Exp $ |
34 | */ |
35 | /* |
36 | * Copyright (c) 2004, 2005 David Young. All rights reserved. |
37 | * Copyright (c) 2004, 2005 OJC Technologies. All rights reserved. |
38 | * Copyright (c) 2004, 2005 Dayton Data Center Services, LLC. All |
39 | * rights reserved. |
40 | * |
41 | * Redistribution and use in source and binary forms, with or without |
42 | * modification, are permitted provided that the following conditions |
43 | * are met: |
44 | * 1. Redistributions of source code must retain the above copyright |
45 | * notice, this list of conditions and the following disclaimer. |
46 | * 2. Redistributions in binary form must reproduce the above copyright |
47 | * notice, this list of conditions and the following disclaimer in the |
48 | * documentation and/or other materials provided with the distribution. |
49 | * 3. Neither the name of the author nor the names of any co-contributors |
50 | * may be used to endorse or promote products derived from this software |
51 | * without specific prior written permission. |
52 | * |
53 | * THIS SOFTWARE IS PROVIDED BY David Young AND CONTRIBUTORS ``AS IS'' AND |
54 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
55 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
56 | * ARE DISCLAIMED. IN NO EVENT SHALL David Young AND CONTRIBUTORS |
57 | * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
58 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
59 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
60 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
61 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
62 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
63 | * THE POSSIBILITY OF SUCH DAMAGE. |
64 | */ |
65 | |
66 | /* |
67 | * Aironet 4500/4800 802.11 PCMCIA/ISA/PCI driver for FreeBSD. |
68 | * |
69 | * Written by Bill Paul <wpaul@ctr.columbia.edu> |
70 | * Electrical Engineering Department |
71 | * Columbia University, New York City |
72 | */ |
73 | |
74 | /* |
75 | * Ported to NetBSD from FreeBSD by Atsushi Onoe at the San Diego |
76 | * IETF meeting. |
77 | */ |
78 | |
79 | #include <sys/cdefs.h> |
80 | __KERNEL_RCSID(0, "$NetBSD: an.c,v 1.63 2016/06/10 13:27:13 ozaki-r Exp $" ); |
81 | |
82 | |
83 | #include <sys/param.h> |
84 | #include <sys/callout.h> |
85 | #include <sys/sysctl.h> |
86 | #include <sys/systm.h> |
87 | #include <sys/sockio.h> |
88 | #include <sys/mbuf.h> |
89 | #include <sys/kernel.h> |
90 | #include <sys/ucred.h> |
91 | #include <sys/socket.h> |
92 | #include <sys/device.h> |
93 | #include <sys/proc.h> |
94 | #include <sys/md4.h> |
95 | #include <sys/endian.h> |
96 | #include <sys/kauth.h> |
97 | |
98 | #include <sys/bus.h> |
99 | |
100 | #include <net/if.h> |
101 | #include <net/if_dl.h> |
102 | #include <net/if_ether.h> |
103 | #include <net/if_llc.h> |
104 | #include <net/if_media.h> |
105 | #include <net/if_types.h> |
106 | |
107 | #include <net80211/ieee80211_netbsd.h> |
108 | #include <net80211/ieee80211_var.h> |
109 | #include <net80211/ieee80211_radiotap.h> |
110 | |
111 | #include <net/bpf.h> |
112 | #include <net/bpfdesc.h> |
113 | |
114 | #include <dev/ic/anreg.h> |
115 | #include <dev/ic/anvar.h> |
116 | |
117 | static int an_reset(struct an_softc *); |
118 | static void an_wait(struct an_softc *); |
119 | static int an_init(struct ifnet *); |
120 | static void an_stop(struct ifnet *, int); |
121 | static void an_start(struct ifnet *); |
122 | static void an_watchdog(struct ifnet *); |
123 | static int an_ioctl(struct ifnet *, u_long, void *); |
124 | static int an_media_change(struct ifnet *); |
125 | static void an_media_status(struct ifnet *, struct ifmediareq *); |
126 | |
127 | static int an_set_nwkey(struct an_softc *, struct ieee80211_nwkey *); |
128 | static int an_set_nwkey_wep(struct an_softc *, struct ieee80211_nwkey *); |
129 | static int an_set_nwkey_eap(struct an_softc *, struct ieee80211_nwkey *); |
130 | static int an_get_nwkey(struct an_softc *, struct ieee80211_nwkey *); |
131 | static int an_write_wepkey(struct an_softc *, int, struct an_wepkey *, |
132 | int); |
133 | |
134 | static void an_rx_intr(struct an_softc *); |
135 | static void an_tx_intr(struct an_softc *, int); |
136 | static void an_linkstat_intr(struct an_softc *); |
137 | |
138 | static int an_cmd(struct an_softc *, int, int); |
139 | static int an_seek_bap(struct an_softc *, int, int); |
140 | static int an_read_bap(struct an_softc *, int, int, void *, int); |
141 | static int an_write_bap(struct an_softc *, int, int, void *, int); |
142 | static int an_mwrite_bap(struct an_softc *, int, int, struct mbuf *, int); |
143 | static int an_read_rid(struct an_softc *, int, void *, int *); |
144 | static int an_write_rid(struct an_softc *, int, void *, int); |
145 | |
146 | static int an_alloc_fid(struct an_softc *, int, int *); |
147 | |
148 | static int an_newstate(struct ieee80211com *, enum ieee80211_state, int); |
149 | |
150 | #ifdef AN_DEBUG |
151 | int an_debug = 0; |
152 | |
153 | #define DPRINTF(X) if (an_debug) printf X |
154 | #define DPRINTF2(X) if (an_debug > 1) printf X |
155 | static int an_sysctl_verify(SYSCTLFN_PROTO, int lower, int upper); |
156 | static int an_sysctl_verify_debug(SYSCTLFN_PROTO); |
157 | #else |
158 | #define DPRINTF(X) |
159 | #define DPRINTF2(X) |
160 | #endif |
161 | |
162 | int |
163 | an_attach(struct an_softc *sc) |
164 | { |
165 | struct ieee80211com *ic = &sc->sc_ic; |
166 | struct ifnet *ifp = &sc->sc_if; |
167 | int i, s; |
168 | struct an_rid_wepkey *akey; |
169 | int buflen, kid, rid; |
170 | int chan, chan_min, chan_max; |
171 | |
172 | s = splnet(); |
173 | |
174 | an_wait(sc); |
175 | if (an_reset(sc) != 0) { |
176 | config_deactivate(sc->sc_dev); |
177 | splx(s); |
178 | return 1; |
179 | } |
180 | |
181 | /* Load factory config */ |
182 | if (an_cmd(sc, AN_CMD_READCFG, 0) != 0) { |
183 | splx(s); |
184 | aprint_error_dev(sc->sc_dev, "failed to load config data\n" ); |
185 | return 1; |
186 | } |
187 | |
188 | /* Read the current configuration */ |
189 | buflen = sizeof(sc->sc_config); |
190 | if (an_read_rid(sc, AN_RID_GENCONFIG, &sc->sc_config, &buflen) != 0) { |
191 | splx(s); |
192 | aprint_error_dev(sc->sc_dev, "read config failed\n" ); |
193 | return 1; |
194 | } |
195 | |
196 | /* Read the card capabilities */ |
197 | buflen = sizeof(sc->sc_caps); |
198 | if (an_read_rid(sc, AN_RID_CAPABILITIES, &sc->sc_caps, &buflen) != 0) { |
199 | splx(s); |
200 | aprint_error_dev(sc->sc_dev, "read caps failed\n" ); |
201 | return 1; |
202 | } |
203 | |
204 | #ifdef AN_DEBUG |
205 | if (an_debug) { |
206 | static const int dumprid[] = { |
207 | AN_RID_GENCONFIG, AN_RID_CAPABILITIES, AN_RID_SSIDLIST, |
208 | AN_RID_APLIST, AN_RID_STATUS, AN_RID_ENCAP |
209 | }; |
210 | |
211 | for (rid = 0; rid < sizeof(dumprid)/sizeof(dumprid[0]); rid++) { |
212 | buflen = sizeof(sc->sc_buf); |
213 | if (an_read_rid(sc, dumprid[rid], &sc->sc_buf, &buflen) |
214 | != 0) |
215 | continue; |
216 | printf("%04x (%d):\n" , dumprid[rid], buflen); |
217 | for (i = 0; i < (buflen + 1) / 2; i++) |
218 | printf(" %04x" , sc->sc_buf.sc_val[i]); |
219 | printf("\n" ); |
220 | } |
221 | } |
222 | #endif |
223 | |
224 | /* Read WEP settings from persistent memory */ |
225 | akey = &sc->sc_buf.sc_wepkey; |
226 | buflen = sizeof(struct an_rid_wepkey); |
227 | rid = AN_RID_WEP_VOLATILE; /* first persistent key */ |
228 | while (an_read_rid(sc, rid, akey, &buflen) == 0) { |
229 | kid = le16toh(akey->an_key_index); |
230 | DPRINTF(("an_attach: wep rid=0x%x len=%d(%zu) index=0x%04x " |
231 | "mac[0]=%02x keylen=%d\n" , |
232 | rid, buflen, sizeof(*akey), kid, |
233 | akey->an_mac_addr[0], le16toh(akey->an_key_len))); |
234 | if (kid == 0xffff) { |
235 | sc->sc_tx_perskey = akey->an_mac_addr[0]; |
236 | sc->sc_tx_key = -1; |
237 | break; |
238 | } |
239 | if (kid >= IEEE80211_WEP_NKID) |
240 | break; |
241 | sc->sc_perskeylen[kid] = le16toh(akey->an_key_len); |
242 | sc->sc_wepkeys[kid].an_wep_keylen = -1; |
243 | rid = AN_RID_WEP_PERSISTENT; /* for next key */ |
244 | buflen = sizeof(struct an_rid_wepkey); |
245 | } |
246 | |
247 | aprint_normal_dev(sc->sc_dev, "%s %s (firmware %s)\n" , |
248 | sc->sc_caps.an_manufname, sc->sc_caps.an_prodname, |
249 | sc->sc_caps.an_prodvers); |
250 | |
251 | memcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ); |
252 | |
253 | ifp->if_softc = sc; |
254 | ifp->if_flags = IFF_BROADCAST | IFF_NOTRAILERS | IFF_SIMPLEX | |
255 | IFF_MULTICAST | IFF_ALLMULTI; |
256 | ifp->if_ioctl = an_ioctl; |
257 | ifp->if_start = an_start; |
258 | ifp->if_init = an_init; |
259 | ifp->if_stop = an_stop; |
260 | ifp->if_watchdog = an_watchdog; |
261 | IFQ_SET_READY(&ifp->if_snd); |
262 | |
263 | ic->ic_ifp = ifp; |
264 | ic->ic_phytype = IEEE80211_T_DS; |
265 | ic->ic_opmode = IEEE80211_M_STA; |
266 | ic->ic_caps = IEEE80211_C_WEP | IEEE80211_C_PMGT | IEEE80211_C_IBSS | |
267 | IEEE80211_C_MONITOR; |
268 | ic->ic_state = IEEE80211_S_INIT; |
269 | IEEE80211_ADDR_COPY(ic->ic_myaddr, sc->sc_caps.an_oemaddr); |
270 | |
271 | switch (le16toh(sc->sc_caps.an_regdomain)) { |
272 | default: |
273 | case AN_REGDOMAIN_USA: |
274 | case AN_REGDOMAIN_CANADA: |
275 | chan_min = 1; chan_max = 11; break; |
276 | case AN_REGDOMAIN_EUROPE: |
277 | case AN_REGDOMAIN_AUSTRALIA: |
278 | chan_min = 1; chan_max = 13; break; |
279 | case AN_REGDOMAIN_JAPAN: |
280 | chan_min = 14; chan_max = 14; break; |
281 | case AN_REGDOMAIN_SPAIN: |
282 | chan_min = 10; chan_max = 11; break; |
283 | case AN_REGDOMAIN_FRANCE: |
284 | chan_min = 10; chan_max = 13; break; |
285 | case AN_REGDOMAIN_JAPANWIDE: |
286 | chan_min = 1; chan_max = 14; break; |
287 | } |
288 | |
289 | for (chan = chan_min; chan <= chan_max; chan++) { |
290 | ic->ic_channels[chan].ic_freq = |
291 | ieee80211_ieee2mhz(chan, IEEE80211_CHAN_2GHZ); |
292 | ic->ic_channels[chan].ic_flags = IEEE80211_CHAN_B; |
293 | } |
294 | ic->ic_ibss_chan = &ic->ic_channels[chan_min]; |
295 | |
296 | aprint_normal("%s: 802.11 address: %s, channel: %d-%d\n" , |
297 | ifp->if_xname, ether_sprintf(ic->ic_myaddr), chan_min, chan_max); |
298 | |
299 | /* Find supported rate */ |
300 | for (i = 0; i < sizeof(sc->sc_caps.an_rates); i++) { |
301 | if (sc->sc_caps.an_rates[i] == 0) |
302 | continue; |
303 | ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[ |
304 | ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates++] = |
305 | sc->sc_caps.an_rates[i]; |
306 | } |
307 | |
308 | /* |
309 | * Call MI attach routine. |
310 | */ |
311 | if_attach(ifp); |
312 | ieee80211_ifattach(ic); |
313 | |
314 | sc->sc_newstate = ic->ic_newstate; |
315 | ic->ic_newstate = an_newstate; |
316 | |
317 | ieee80211_media_init(ic, an_media_change, an_media_status); |
318 | |
319 | /* |
320 | * radiotap BPF device |
321 | */ |
322 | bpf_attach2(ifp, DLT_IEEE802_11_RADIO, |
323 | sizeof(struct ieee80211_frame) + 64, &sc->sc_drvbpf); |
324 | |
325 | memset(&sc->sc_rxtapu, 0, sizeof(sc->sc_rxtapu)); |
326 | sc->sc_rxtap.ar_ihdr.it_len = htole16(sizeof(sc->sc_rxtapu)); |
327 | sc->sc_rxtap.ar_ihdr.it_present = htole32(AN_RX_RADIOTAP_PRESENT); |
328 | |
329 | memset(&sc->sc_txtapu, 0, sizeof(sc->sc_txtapu)); |
330 | sc->sc_txtap.at_ihdr.it_len = htole16(sizeof(sc->sc_txtapu)); |
331 | sc->sc_txtap.at_ihdr.it_present = htole32(AN_TX_RADIOTAP_PRESENT); |
332 | |
333 | sc->sc_attached = 1; |
334 | splx(s); |
335 | |
336 | ieee80211_announce(ic); |
337 | return 0; |
338 | } |
339 | |
340 | #ifdef AN_DEBUG |
341 | /* |
342 | * Setup sysctl(3) MIB, hw.an.* |
343 | * |
344 | * TBD condition CTLFLAG_PERMANENT on being a module or not |
345 | */ |
346 | SYSCTL_SETUP(sysctl_an, "sysctl an(4) subtree setup" ) |
347 | { |
348 | int rc; |
349 | const struct sysctlnode *cnode, *rnode; |
350 | |
351 | if ((rc = sysctl_createv(clog, 0, NULL, &rnode, |
352 | CTLFLAG_PERMANENT, CTLTYPE_NODE, "an" , |
353 | "Cisco/Aironet 802.11 controls" , |
354 | NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) |
355 | goto err; |
356 | |
357 | /* control debugging printfs */ |
358 | if ((rc = sysctl_createv(clog, 0, &rnode, &cnode, |
359 | CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT, |
360 | "debug" , SYSCTL_DESCR("Enable Cisco/Aironet debugging output" ), |
361 | an_sysctl_verify_debug, 0, &an_debug, 0, |
362 | CTL_CREATE, CTL_EOL)) != 0) |
363 | goto err; |
364 | |
365 | return; |
366 | err: |
367 | printf("%s: sysctl_createv failed (rc = %d)\n" , __func__, rc); |
368 | } |
369 | |
370 | static int |
371 | an_sysctl_verify(SYSCTLFN_ARGS, int lower, int upper) |
372 | { |
373 | int error, t; |
374 | struct sysctlnode node; |
375 | |
376 | node = *rnode; |
377 | t = *(int*)rnode->sysctl_data; |
378 | node.sysctl_data = &t; |
379 | error = sysctl_lookup(SYSCTLFN_CALL(&node)); |
380 | if (error || newp == NULL) |
381 | return (error); |
382 | |
383 | if (t < lower || t > upper) |
384 | return (EINVAL); |
385 | |
386 | *(int*)rnode->sysctl_data = t; |
387 | |
388 | return (0); |
389 | } |
390 | |
391 | static int |
392 | an_sysctl_verify_debug(SYSCTLFN_ARGS) |
393 | { |
394 | return an_sysctl_verify(SYSCTLFN_CALL(rnode), 0, 2); |
395 | } |
396 | #endif /* AN_DEBUG */ |
397 | |
398 | int |
399 | an_detach(struct an_softc *sc) |
400 | { |
401 | struct ieee80211com *ic = &sc->sc_ic; |
402 | struct ifnet *ifp = &sc->sc_if; |
403 | int s; |
404 | |
405 | if (!sc->sc_attached) |
406 | return 0; |
407 | |
408 | s = splnet(); |
409 | an_stop(ifp, 1); |
410 | ieee80211_ifdetach(ic); |
411 | if_detach(ifp); |
412 | splx(s); |
413 | return 0; |
414 | } |
415 | |
416 | int |
417 | an_activate(device_t self, enum devact act) |
418 | { |
419 | struct an_softc *sc = device_private(self); |
420 | |
421 | switch (act) { |
422 | case DVACT_DEACTIVATE: |
423 | if_deactivate(&sc->sc_if); |
424 | return 0; |
425 | default: |
426 | return EOPNOTSUPP; |
427 | } |
428 | } |
429 | |
430 | int |
431 | an_intr(void *arg) |
432 | { |
433 | struct an_softc *sc = arg; |
434 | struct ifnet *ifp = &sc->sc_if; |
435 | int i; |
436 | u_int16_t status; |
437 | |
438 | if (!sc->sc_enabled || !device_is_active(sc->sc_dev) || |
439 | (ifp->if_flags & IFF_RUNNING) == 0) |
440 | return 0; |
441 | |
442 | if ((ifp->if_flags & IFF_UP) == 0) { |
443 | CSR_WRITE_2(sc, AN_INT_EN, 0); |
444 | CSR_WRITE_2(sc, AN_EVENT_ACK, ~0); |
445 | return 1; |
446 | } |
447 | |
448 | /* maximum 10 loops per interrupt */ |
449 | for (i = 0; i < 10; i++) { |
450 | if (!sc->sc_enabled || !device_is_active(sc->sc_dev)) |
451 | return 1; |
452 | if (CSR_READ_2(sc, AN_SW0) != AN_MAGIC) { |
453 | DPRINTF(("an_intr: magic number changed: %x\n" , |
454 | CSR_READ_2(sc, AN_SW0))); |
455 | config_deactivate(sc->sc_dev); |
456 | return 1; |
457 | } |
458 | status = CSR_READ_2(sc, AN_EVENT_STAT); |
459 | CSR_WRITE_2(sc, AN_EVENT_ACK, status & ~(AN_INTRS)); |
460 | if ((status & AN_INTRS) == 0) |
461 | break; |
462 | |
463 | if (status & AN_EV_RX) |
464 | an_rx_intr(sc); |
465 | |
466 | if (status & (AN_EV_TX | AN_EV_TX_EXC)) |
467 | an_tx_intr(sc, status); |
468 | |
469 | if (status & AN_EV_LINKSTAT) |
470 | an_linkstat_intr(sc); |
471 | |
472 | if ((ifp->if_flags & IFF_OACTIVE) == 0 && |
473 | sc->sc_ic.ic_state == IEEE80211_S_RUN && |
474 | !IFQ_IS_EMPTY(&ifp->if_snd)) |
475 | an_start(ifp); |
476 | } |
477 | |
478 | return 1; |
479 | } |
480 | |
481 | static int |
482 | an_init(struct ifnet *ifp) |
483 | { |
484 | struct an_softc *sc = ifp->if_softc; |
485 | struct ieee80211com *ic = &sc->sc_ic; |
486 | int i, error, fid; |
487 | |
488 | DPRINTF(("an_init: enabled %d\n" , sc->sc_enabled)); |
489 | if (!sc->sc_enabled) { |
490 | if (sc->sc_enable) |
491 | (*sc->sc_enable)(sc); |
492 | an_wait(sc); |
493 | sc->sc_enabled = 1; |
494 | } else { |
495 | an_stop(ifp, 0); |
496 | if ((error = an_reset(sc)) != 0) { |
497 | printf("%s: failed to reset\n" , ifp->if_xname); |
498 | an_stop(ifp, 1); |
499 | return error; |
500 | } |
501 | } |
502 | CSR_WRITE_2(sc, AN_SW0, AN_MAGIC); |
503 | |
504 | /* Allocate the TX buffers */ |
505 | for (i = 0; i < AN_TX_RING_CNT; i++) { |
506 | if ((error = an_alloc_fid(sc, AN_TX_MAX_LEN, &fid)) != 0) { |
507 | printf("%s: failed to allocate nic memory\n" , |
508 | ifp->if_xname); |
509 | an_stop(ifp, 1); |
510 | return error; |
511 | } |
512 | DPRINTF2(("an_init: txbuf %d allocated %x\n" , i, fid)); |
513 | sc->sc_txd[i].d_fid = fid; |
514 | sc->sc_txd[i].d_inuse = 0; |
515 | } |
516 | sc->sc_txcur = sc->sc_txnext = 0; |
517 | |
518 | IEEE80211_ADDR_COPY(sc->sc_config.an_macaddr, ic->ic_myaddr); |
519 | sc->sc_config.an_scanmode = htole16(AN_SCANMODE_ACTIVE); |
520 | sc->sc_config.an_authtype = htole16(AN_AUTHTYPE_OPEN); /*XXX*/ |
521 | if (ic->ic_flags & IEEE80211_F_PRIVACY) { |
522 | sc->sc_config.an_authtype |= |
523 | htole16(AN_AUTHTYPE_PRIVACY_IN_USE); |
524 | if (sc->sc_use_leap) |
525 | sc->sc_config.an_authtype |= |
526 | htole16(AN_AUTHTYPE_LEAP); |
527 | } |
528 | sc->sc_config.an_listen_interval = htole16(ic->ic_lintval); |
529 | sc->sc_config.an_beacon_period = htole16(ic->ic_lintval); |
530 | if (ic->ic_flags & IEEE80211_F_PMGTON) |
531 | sc->sc_config.an_psave_mode = htole16(AN_PSAVE_PSP); |
532 | else |
533 | sc->sc_config.an_psave_mode = htole16(AN_PSAVE_CAM); |
534 | sc->sc_config.an_ds_channel = |
535 | htole16(ieee80211_chan2ieee(ic, ic->ic_ibss_chan)); |
536 | |
537 | switch (ic->ic_opmode) { |
538 | case IEEE80211_M_STA: |
539 | sc->sc_config.an_opmode = |
540 | htole16(AN_OPMODE_INFRASTRUCTURE_STATION); |
541 | sc->sc_config.an_rxmode = htole16(AN_RXMODE_BC_MC_ADDR); |
542 | break; |
543 | case IEEE80211_M_IBSS: |
544 | sc->sc_config.an_opmode = htole16(AN_OPMODE_IBSS_ADHOC); |
545 | sc->sc_config.an_rxmode = htole16(AN_RXMODE_BC_MC_ADDR); |
546 | break; |
547 | case IEEE80211_M_MONITOR: |
548 | sc->sc_config.an_opmode = |
549 | htole16(AN_OPMODE_INFRASTRUCTURE_STATION); |
550 | sc->sc_config.an_rxmode = |
551 | htole16(AN_RXMODE_80211_MONITOR_ANYBSS); |
552 | sc->sc_config.an_authtype = htole16(AN_AUTHTYPE_NONE); |
553 | if (ic->ic_flags & IEEE80211_F_PRIVACY) |
554 | sc->sc_config.an_authtype |= |
555 | htole16(AN_AUTHTYPE_PRIVACY_IN_USE | |
556 | AN_AUTHTYPE_ALLOW_UNENCRYPTED); |
557 | break; |
558 | default: |
559 | printf("%s: bad opmode %d\n" , ifp->if_xname, ic->ic_opmode); |
560 | an_stop(ifp, 1); |
561 | return EIO; |
562 | } |
563 | sc->sc_config.an_rxmode |= htole16(AN_RXMODE_NO_8023_HEADER); |
564 | |
565 | /* Set the ssid list */ |
566 | memset(&sc->sc_buf, 0, sizeof(sc->sc_buf.sc_ssidlist)); |
567 | sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid_len = |
568 | htole16(ic->ic_des_esslen); |
569 | if (ic->ic_des_esslen) |
570 | memcpy(sc->sc_buf.sc_ssidlist.an_entry[0].an_ssid, |
571 | ic->ic_des_essid, ic->ic_des_esslen); |
572 | if ((error = an_write_rid(sc, AN_RID_SSIDLIST, &sc->sc_buf, |
573 | sizeof(sc->sc_buf.sc_ssidlist))) != 0) { |
574 | printf("%s: failed to write ssid list\n" , ifp->if_xname); |
575 | an_stop(ifp, 1); |
576 | return error; |
577 | } |
578 | |
579 | /* Set the AP list */ |
580 | memset(&sc->sc_buf, 0, sizeof(sc->sc_buf.sc_aplist)); |
581 | (void)an_write_rid(sc, AN_RID_APLIST, &sc->sc_buf, |
582 | sizeof(sc->sc_buf.sc_aplist)); |
583 | |
584 | /* Set the encapsulation */ |
585 | for (i = 0; i < AN_ENCAP_NENTS; i++) { |
586 | sc->sc_buf.sc_encap.an_entry[i].an_ethertype = htole16(0); |
587 | sc->sc_buf.sc_encap.an_entry[i].an_action = |
588 | htole16(AN_RXENCAP_RFC1024 | AN_TXENCAP_RFC1024); |
589 | } |
590 | (void)an_write_rid(sc, AN_RID_ENCAP, &sc->sc_buf, |
591 | sizeof(sc->sc_buf.sc_encap)); |
592 | |
593 | /* Set the WEP Keys */ |
594 | if (ic->ic_flags & IEEE80211_F_PRIVACY) |
595 | an_write_wepkey(sc, AN_RID_WEP_VOLATILE, sc->sc_wepkeys, |
596 | sc->sc_tx_key); |
597 | |
598 | /* Set the configuration */ |
599 | #ifdef AN_DEBUG |
600 | if (an_debug) { |
601 | printf("write config:\n" ); |
602 | for (i = 0; i < sizeof(sc->sc_config) / 2; i++) |
603 | printf(" %04x" , ((u_int16_t *)&sc->sc_config)[i]); |
604 | printf("\n" ); |
605 | } |
606 | #endif |
607 | if ((error = an_write_rid(sc, AN_RID_GENCONFIG, &sc->sc_config, |
608 | sizeof(sc->sc_config))) != 0) { |
609 | printf("%s: failed to write config\n" , ifp->if_xname); |
610 | an_stop(ifp, 1); |
611 | return error; |
612 | } |
613 | |
614 | /* Enable the MAC */ |
615 | if (an_cmd(sc, AN_CMD_ENABLE, 0)) { |
616 | aprint_error_dev(sc->sc_dev, "failed to enable MAC\n" ); |
617 | an_stop(ifp, 1); |
618 | return ENXIO; |
619 | } |
620 | if (ifp->if_flags & IFF_PROMISC) |
621 | an_cmd(sc, AN_CMD_SET_MODE, 0xffff); |
622 | |
623 | ifp->if_flags |= IFF_RUNNING; |
624 | ifp->if_flags &= ~IFF_OACTIVE; |
625 | ic->ic_state = IEEE80211_S_INIT; |
626 | if (ic->ic_opmode == IEEE80211_M_MONITOR) |
627 | ieee80211_new_state(ic, IEEE80211_S_RUN, -1); |
628 | |
629 | /* enable interrupts */ |
630 | CSR_WRITE_2(sc, AN_INT_EN, AN_INTRS); |
631 | return 0; |
632 | } |
633 | |
634 | static void |
635 | an_stop(struct ifnet *ifp, int disable) |
636 | { |
637 | struct an_softc *sc = ifp->if_softc; |
638 | int i, s; |
639 | |
640 | if (!sc->sc_enabled) |
641 | return; |
642 | |
643 | DPRINTF(("an_stop: disable %d\n" , disable)); |
644 | |
645 | s = splnet(); |
646 | ieee80211_new_state(&sc->sc_ic, IEEE80211_S_INIT, -1); |
647 | if (device_is_active(sc->sc_dev)) { |
648 | an_cmd(sc, AN_CMD_FORCE_SYNCLOSS, 0); |
649 | CSR_WRITE_2(sc, AN_INT_EN, 0); |
650 | an_cmd(sc, AN_CMD_DISABLE, 0); |
651 | |
652 | for (i = 0; i < AN_TX_RING_CNT; i++) |
653 | an_cmd(sc, AN_CMD_DEALLOC_MEM, sc->sc_txd[i].d_fid); |
654 | } |
655 | |
656 | sc->sc_tx_timer = 0; |
657 | ifp->if_timer = 0; |
658 | ifp->if_flags &= ~(IFF_RUNNING|IFF_OACTIVE); |
659 | |
660 | if (disable) { |
661 | if (sc->sc_disable) |
662 | (*sc->sc_disable)(sc); |
663 | sc->sc_enabled = 0; |
664 | } |
665 | splx(s); |
666 | } |
667 | |
668 | static void |
669 | an_start(struct ifnet *ifp) |
670 | { |
671 | struct an_softc *sc = (struct an_softc *)ifp->if_softc; |
672 | struct ieee80211com *ic = &sc->sc_ic; |
673 | struct ieee80211_node *ni; |
674 | struct ieee80211_frame *wh; |
675 | struct an_txframe frmhdr; |
676 | struct ether_header *eh; |
677 | struct mbuf *m; |
678 | u_int16_t len; |
679 | int cur, fid; |
680 | |
681 | if (!sc->sc_enabled || !device_is_active(sc->sc_dev)) { |
682 | DPRINTF(("an_start: noop: enabled %d invalid %d\n" , |
683 | sc->sc_enabled, !device_is_active(sc->sc_dev))); |
684 | return; |
685 | } |
686 | |
687 | memset(&frmhdr, 0, sizeof(frmhdr)); |
688 | cur = sc->sc_txnext; |
689 | for (;;) { |
690 | if (ic->ic_state != IEEE80211_S_RUN) { |
691 | DPRINTF(("an_start: not running %d\n" , ic->ic_state)); |
692 | break; |
693 | } |
694 | IFQ_POLL(&ifp->if_snd, m); |
695 | if (m == NULL) { |
696 | DPRINTF2(("an_start: no pending mbuf\n" )); |
697 | break; |
698 | } |
699 | if (sc->sc_txd[cur].d_inuse) { |
700 | DPRINTF2(("an_start: %x/%d busy\n" , |
701 | sc->sc_txd[cur].d_fid, cur)); |
702 | ifp->if_flags |= IFF_OACTIVE; |
703 | break; |
704 | } |
705 | IFQ_DEQUEUE(&ifp->if_snd, m); |
706 | ifp->if_opackets++; |
707 | bpf_mtap(ifp, m); |
708 | eh = mtod(m, struct ether_header *); |
709 | ni = ieee80211_find_txnode(ic, eh->ether_dhost); |
710 | if (ni == NULL) { |
711 | /* NB: ieee80211_find_txnode does stat+msg */ |
712 | goto bad; |
713 | } |
714 | if ((m = ieee80211_encap(ic, m, ni)) == NULL) |
715 | goto bad; |
716 | ieee80211_free_node(ni); |
717 | bpf_mtap3(ic->ic_rawbpf, m); |
718 | |
719 | wh = mtod(m, struct ieee80211_frame *); |
720 | if (ic->ic_flags & IEEE80211_F_PRIVACY) |
721 | wh->i_fc[1] |= IEEE80211_FC1_WEP; |
722 | m_copydata(m, 0, sizeof(struct ieee80211_frame), |
723 | (void *)&frmhdr.an_whdr); |
724 | |
725 | /* insert payload length in front of llc/snap */ |
726 | len = htons(m->m_pkthdr.len - sizeof(struct ieee80211_frame)); |
727 | m_adj(m, sizeof(struct ieee80211_frame) - sizeof(len)); |
728 | if (mtod(m, u_long) & 0x01) |
729 | memcpy(mtod(m, void *), &len, sizeof(len)); |
730 | else |
731 | *mtod(m, u_int16_t *) = len; |
732 | |
733 | /* |
734 | * XXX Aironet firmware apparently convert the packet |
735 | * with longer than 1500 bytes in length into LLC/SNAP. |
736 | * If we have 1500 bytes in ethernet payload, it is |
737 | * 1508 bytes including LLC/SNAP and will be inserted |
738 | * additional LLC/SNAP header with 1501-1508 in its |
739 | * ethertype !! |
740 | * So we skip LLC/SNAP header and force firmware to |
741 | * convert it to LLC/SNAP again. |
742 | */ |
743 | m_adj(m, sizeof(struct llc)); |
744 | |
745 | frmhdr.an_tx_ctl = htole16(AN_TXCTL_80211); |
746 | frmhdr.an_tx_payload_len = htole16(m->m_pkthdr.len); |
747 | frmhdr.an_gaplen = htole16(AN_TXGAP_802_11); |
748 | |
749 | if (ic->ic_fixed_rate != -1) |
750 | frmhdr.an_tx_rate = |
751 | ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[ |
752 | ic->ic_fixed_rate] & IEEE80211_RATE_VAL; |
753 | else |
754 | frmhdr.an_tx_rate = 0; |
755 | |
756 | /* XXX radiotap for tx must be completed */ |
757 | if (sc->sc_drvbpf) { |
758 | struct an_tx_radiotap_header *tap = &sc->sc_txtap; |
759 | tap->at_rate = ic->ic_bss->ni_rates.rs_rates[ic->ic_bss->ni_txrate]; |
760 | tap->at_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq); |
761 | tap->at_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags); |
762 | /* TBD tap->wt_flags */ |
763 | bpf_mtap2(sc->sc_drvbpf, tap, tap->at_ihdr.it_len, m); |
764 | } |
765 | |
766 | #ifdef AN_DEBUG |
767 | if ((ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == |
768 | (IFF_DEBUG|IFF_LINK2)) { |
769 | ieee80211_dump_pkt((u_int8_t *)&frmhdr.an_whdr, |
770 | sizeof(struct ieee80211_frame), -1, 0); |
771 | printf(" txctl 0x%x plen %u\n" , |
772 | le16toh(frmhdr.an_tx_ctl), |
773 | le16toh(frmhdr.an_tx_payload_len)); |
774 | } |
775 | #endif |
776 | if (sizeof(frmhdr) + AN_TXGAP_802_11 + sizeof(len) + |
777 | m->m_pkthdr.len > AN_TX_MAX_LEN) |
778 | goto bad; |
779 | |
780 | fid = sc->sc_txd[cur].d_fid; |
781 | if (an_write_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0) |
782 | goto bad; |
783 | /* dummy write to avoid seek. */ |
784 | an_write_bap(sc, fid, -1, &frmhdr, AN_TXGAP_802_11); |
785 | an_mwrite_bap(sc, fid, -1, m, m->m_pkthdr.len); |
786 | m_freem(m); |
787 | |
788 | DPRINTF2(("an_start: send %zu byte via %x/%d\n" , |
789 | ntohs(len) + sizeof(struct ieee80211_frame), |
790 | fid, cur)); |
791 | sc->sc_txd[cur].d_inuse = 1; |
792 | if (an_cmd(sc, AN_CMD_TX, fid)) { |
793 | printf("%s: xmit failed\n" , ifp->if_xname); |
794 | sc->sc_txd[cur].d_inuse = 0; |
795 | continue; |
796 | } |
797 | sc->sc_tx_timer = 5; |
798 | ifp->if_timer = 1; |
799 | AN_INC(cur, AN_TX_RING_CNT); |
800 | sc->sc_txnext = cur; |
801 | continue; |
802 | bad: |
803 | ifp->if_oerrors++; |
804 | m_freem(m); |
805 | } |
806 | } |
807 | |
808 | static int |
809 | an_reset(struct an_softc *sc) |
810 | { |
811 | |
812 | DPRINTF(("an_reset\n" )); |
813 | |
814 | if (!sc->sc_enabled) |
815 | return ENXIO; |
816 | |
817 | an_cmd(sc, AN_CMD_ENABLE, 0); |
818 | an_cmd(sc, AN_CMD_FW_RESTART, 0); |
819 | an_cmd(sc, AN_CMD_NOOP2, 0); |
820 | |
821 | if (an_cmd(sc, AN_CMD_FORCE_SYNCLOSS, 0) == ETIMEDOUT) { |
822 | aprint_error_dev(sc->sc_dev, "reset failed\n" ); |
823 | return ETIMEDOUT; |
824 | } |
825 | |
826 | an_cmd(sc, AN_CMD_DISABLE, 0); |
827 | return 0; |
828 | } |
829 | |
830 | static void |
831 | an_watchdog(struct ifnet *ifp) |
832 | { |
833 | struct an_softc *sc = ifp->if_softc; |
834 | |
835 | if (!sc->sc_enabled) |
836 | return; |
837 | |
838 | if (sc->sc_tx_timer) { |
839 | if (--sc->sc_tx_timer == 0) { |
840 | printf("%s: device timeout\n" , ifp->if_xname); |
841 | ifp->if_oerrors++; |
842 | an_init(ifp); |
843 | return; |
844 | } |
845 | ifp->if_timer = 1; |
846 | } |
847 | ieee80211_watchdog(&sc->sc_ic); |
848 | } |
849 | |
850 | static int |
851 | an_ioctl(struct ifnet *ifp, u_long command, void *data) |
852 | { |
853 | struct an_softc *sc = ifp->if_softc; |
854 | int s, error = 0; |
855 | |
856 | if (!device_is_active(sc->sc_dev)) |
857 | return ENXIO; |
858 | |
859 | s = splnet(); |
860 | |
861 | switch (command) { |
862 | case SIOCSIFFLAGS: |
863 | if ((error = ifioctl_common(ifp, command, data)) != 0) |
864 | break; |
865 | if (ifp->if_flags & IFF_UP) { |
866 | if (sc->sc_enabled) { |
867 | /* |
868 | * To avoid rescanning another access point, |
869 | * do not call an_init() here. Instead, only |
870 | * reflect promisc mode settings. |
871 | */ |
872 | error = an_cmd(sc, AN_CMD_SET_MODE, |
873 | (ifp->if_flags & IFF_PROMISC) ? 0xffff : 0); |
874 | } else |
875 | error = an_init(ifp); |
876 | } else if (sc->sc_enabled) |
877 | an_stop(ifp, 1); |
878 | break; |
879 | case SIOCADDMULTI: |
880 | case SIOCDELMULTI: |
881 | error = ether_ioctl(ifp, command, data); |
882 | if (error == ENETRESET) { |
883 | /* we don't have multicast filter. */ |
884 | error = 0; |
885 | } |
886 | break; |
887 | case SIOCS80211NWKEY: |
888 | error = an_set_nwkey(sc, (struct ieee80211_nwkey *)data); |
889 | break; |
890 | case SIOCG80211NWKEY: |
891 | error = an_get_nwkey(sc, (struct ieee80211_nwkey *)data); |
892 | break; |
893 | default: |
894 | error = ieee80211_ioctl(&sc->sc_ic, command, data); |
895 | break; |
896 | } |
897 | if (error == ENETRESET) { |
898 | if (sc->sc_enabled) |
899 | error = an_init(ifp); |
900 | else |
901 | error = 0; |
902 | } |
903 | splx(s); |
904 | return error; |
905 | } |
906 | |
907 | /* TBD factor with ieee80211_media_change */ |
908 | static int |
909 | an_media_change(struct ifnet *ifp) |
910 | { |
911 | struct an_softc *sc = ifp->if_softc; |
912 | struct ieee80211com *ic = &sc->sc_ic; |
913 | struct ifmedia_entry *ime; |
914 | enum ieee80211_opmode newmode; |
915 | int i, rate, error = 0; |
916 | |
917 | ime = ic->ic_media.ifm_cur; |
918 | if (IFM_SUBTYPE(ime->ifm_media) == IFM_AUTO) { |
919 | i = -1; |
920 | } else { |
921 | struct ieee80211_rateset *rs = |
922 | &ic->ic_sup_rates[IEEE80211_MODE_11B]; |
923 | rate = ieee80211_media2rate(ime->ifm_media); |
924 | if (rate == 0) |
925 | return EINVAL; |
926 | for (i = 0; i < rs->rs_nrates; i++) { |
927 | if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) == rate) |
928 | break; |
929 | } |
930 | if (i == rs->rs_nrates) |
931 | return EINVAL; |
932 | } |
933 | if (ic->ic_fixed_rate != i) { |
934 | ic->ic_fixed_rate = i; |
935 | error = ENETRESET; |
936 | } |
937 | |
938 | if (ime->ifm_media & IFM_IEEE80211_ADHOC) |
939 | newmode = IEEE80211_M_IBSS; |
940 | else if (ime->ifm_media & IFM_IEEE80211_HOSTAP) |
941 | newmode = IEEE80211_M_HOSTAP; |
942 | else if (ime->ifm_media & IFM_IEEE80211_MONITOR) |
943 | newmode = IEEE80211_M_MONITOR; |
944 | else |
945 | newmode = IEEE80211_M_STA; |
946 | if (ic->ic_opmode != newmode) { |
947 | ic->ic_opmode = newmode; |
948 | error = ENETRESET; |
949 | } |
950 | if (error == ENETRESET) { |
951 | if (sc->sc_enabled) |
952 | error = an_init(ifp); |
953 | else |
954 | error = 0; |
955 | } |
956 | ifp->if_baudrate = ifmedia_baudrate(ic->ic_media.ifm_cur->ifm_media); |
957 | |
958 | return error; |
959 | } |
960 | |
961 | static void |
962 | an_media_status(struct ifnet *ifp, struct ifmediareq *imr) |
963 | { |
964 | struct an_softc *sc = ifp->if_softc; |
965 | struct ieee80211com *ic = &sc->sc_ic; |
966 | int rate, buflen; |
967 | |
968 | if (sc->sc_enabled == 0) { |
969 | imr->ifm_active = IFM_IEEE80211 | IFM_NONE; |
970 | imr->ifm_status = 0; |
971 | return; |
972 | } |
973 | |
974 | imr->ifm_status = IFM_AVALID; |
975 | imr->ifm_active = IFM_IEEE80211; |
976 | if (ic->ic_state == IEEE80211_S_RUN) |
977 | imr->ifm_status |= IFM_ACTIVE; |
978 | buflen = sizeof(sc->sc_buf); |
979 | if (ic->ic_fixed_rate != -1) |
980 | rate = ic->ic_sup_rates[IEEE80211_MODE_11B].rs_rates[ |
981 | ic->ic_fixed_rate] & IEEE80211_RATE_VAL; |
982 | else if (an_read_rid(sc, AN_RID_STATUS, &sc->sc_buf, &buflen) != 0) |
983 | rate = 0; |
984 | else |
985 | rate = le16toh(sc->sc_buf.sc_status.an_current_tx_rate); |
986 | imr->ifm_active |= ieee80211_rate2media(ic, rate, IEEE80211_MODE_11B); |
987 | switch (ic->ic_opmode) { |
988 | case IEEE80211_M_STA: |
989 | break; |
990 | case IEEE80211_M_IBSS: |
991 | imr->ifm_active |= IFM_IEEE80211_ADHOC; |
992 | break; |
993 | case IEEE80211_M_HOSTAP: |
994 | imr->ifm_active |= IFM_IEEE80211_HOSTAP; |
995 | break; |
996 | case IEEE80211_M_MONITOR: |
997 | imr->ifm_active |= IFM_IEEE80211_MONITOR; |
998 | break; |
999 | default: |
1000 | break; |
1001 | } |
1002 | } |
1003 | |
1004 | static int |
1005 | an_set_nwkey(struct an_softc *sc, struct ieee80211_nwkey *nwkey) |
1006 | { |
1007 | int error; |
1008 | struct ieee80211com *ic = &sc->sc_ic; |
1009 | u_int16_t prevauth; |
1010 | |
1011 | error = 0; |
1012 | prevauth = sc->sc_config.an_authtype; |
1013 | |
1014 | switch (nwkey->i_wepon) { |
1015 | case IEEE80211_NWKEY_OPEN: |
1016 | sc->sc_config.an_authtype = AN_AUTHTYPE_OPEN; |
1017 | ic->ic_flags &= ~IEEE80211_F_PRIVACY; |
1018 | break; |
1019 | |
1020 | case IEEE80211_NWKEY_WEP: |
1021 | case IEEE80211_NWKEY_WEP | IEEE80211_NWKEY_PERSIST: |
1022 | error = an_set_nwkey_wep(sc, nwkey); |
1023 | if (error == 0 || error == ENETRESET) { |
1024 | sc->sc_config.an_authtype = |
1025 | AN_AUTHTYPE_OPEN | AN_AUTHTYPE_PRIVACY_IN_USE; |
1026 | ic->ic_flags |= IEEE80211_F_PRIVACY; |
1027 | } |
1028 | break; |
1029 | |
1030 | case IEEE80211_NWKEY_EAP: |
1031 | error = an_set_nwkey_eap(sc, nwkey); |
1032 | if (error == 0 || error == ENETRESET) { |
1033 | sc->sc_config.an_authtype = AN_AUTHTYPE_OPEN | |
1034 | AN_AUTHTYPE_PRIVACY_IN_USE | AN_AUTHTYPE_LEAP; |
1035 | ic->ic_flags |= IEEE80211_F_PRIVACY; |
1036 | } |
1037 | break; |
1038 | default: |
1039 | error = EINVAL; |
1040 | break; |
1041 | } |
1042 | if (error == 0 && prevauth != sc->sc_config.an_authtype) |
1043 | error = ENETRESET; |
1044 | return error; |
1045 | } |
1046 | |
1047 | static int |
1048 | an_set_nwkey_wep(struct an_softc *sc, struct ieee80211_nwkey *nwkey) |
1049 | { |
1050 | int i, txkey, anysetkey, needreset, error; |
1051 | struct an_wepkey keys[IEEE80211_WEP_NKID]; |
1052 | |
1053 | error = 0; |
1054 | memset(keys, 0, sizeof(keys)); |
1055 | anysetkey = needreset = 0; |
1056 | |
1057 | /* load argument and sanity check */ |
1058 | for (i = 0; i < IEEE80211_WEP_NKID; i++) { |
1059 | keys[i].an_wep_keylen = nwkey->i_key[i].i_keylen; |
1060 | if (keys[i].an_wep_keylen < 0) |
1061 | continue; |
1062 | if (keys[i].an_wep_keylen != 0 && |
1063 | keys[i].an_wep_keylen < IEEE80211_WEP_KEYLEN) |
1064 | return EINVAL; |
1065 | if (keys[i].an_wep_keylen > sizeof(keys[i].an_wep_key)) |
1066 | return EINVAL; |
1067 | if ((error = copyin(nwkey->i_key[i].i_keydat, |
1068 | keys[i].an_wep_key, keys[i].an_wep_keylen)) != 0) |
1069 | return error; |
1070 | anysetkey++; |
1071 | } |
1072 | txkey = nwkey->i_defkid - 1; |
1073 | if (txkey >= 0) { |
1074 | if (txkey >= IEEE80211_WEP_NKID) |
1075 | return EINVAL; |
1076 | /* default key must have a valid value */ |
1077 | if (keys[txkey].an_wep_keylen == 0 || |
1078 | (keys[txkey].an_wep_keylen < 0 && |
1079 | sc->sc_perskeylen[txkey] == 0)) |
1080 | return EINVAL; |
1081 | anysetkey++; |
1082 | } |
1083 | DPRINTF(("an_set_nwkey_wep: %s: %sold(%d:%d,%d,%d,%d) " |
1084 | "pers(%d:%d,%d,%d,%d) new(%d:%d,%d,%d,%d)\n" , |
1085 | device_xname(sc->sc_dev), |
1086 | ((nwkey->i_wepon & IEEE80211_NWKEY_PERSIST) ? "persist: " : "" ), |
1087 | sc->sc_tx_key, |
1088 | sc->sc_wepkeys[0].an_wep_keylen, sc->sc_wepkeys[1].an_wep_keylen, |
1089 | sc->sc_wepkeys[2].an_wep_keylen, sc->sc_wepkeys[3].an_wep_keylen, |
1090 | sc->sc_tx_perskey, |
1091 | sc->sc_perskeylen[0], sc->sc_perskeylen[1], |
1092 | sc->sc_perskeylen[2], sc->sc_perskeylen[3], |
1093 | txkey, |
1094 | keys[0].an_wep_keylen, keys[1].an_wep_keylen, |
1095 | keys[2].an_wep_keylen, keys[3].an_wep_keylen)); |
1096 | if (!(nwkey->i_wepon & IEEE80211_NWKEY_PERSIST)) { |
1097 | /* set temporary keys */ |
1098 | sc->sc_tx_key = txkey; |
1099 | for (i = 0; i < IEEE80211_WEP_NKID; i++) { |
1100 | if (keys[i].an_wep_keylen < 0) |
1101 | continue; |
1102 | memcpy(&sc->sc_wepkeys[i], &keys[i], sizeof(keys[i])); |
1103 | } |
1104 | } else { |
1105 | /* set persist keys */ |
1106 | if (anysetkey) { |
1107 | /* prepare to write nvram */ |
1108 | if (!sc->sc_enabled) { |
1109 | if (sc->sc_enable) |
1110 | (*sc->sc_enable)(sc); |
1111 | an_wait(sc); |
1112 | sc->sc_enabled = 1; |
1113 | error = an_write_wepkey(sc, |
1114 | AN_RID_WEP_PERSISTENT, keys, txkey); |
1115 | if (sc->sc_disable) |
1116 | (*sc->sc_disable)(sc); |
1117 | sc->sc_enabled = 0; |
1118 | } else { |
1119 | an_cmd(sc, AN_CMD_DISABLE, 0); |
1120 | error = an_write_wepkey(sc, |
1121 | AN_RID_WEP_PERSISTENT, keys, txkey); |
1122 | an_cmd(sc, AN_CMD_ENABLE, 0); |
1123 | } |
1124 | if (error) |
1125 | return error; |
1126 | } |
1127 | if (txkey >= 0) |
1128 | sc->sc_tx_perskey = txkey; |
1129 | if (sc->sc_tx_key >= 0) { |
1130 | sc->sc_tx_key = -1; |
1131 | needreset++; |
1132 | } |
1133 | for (i = 0; i < IEEE80211_WEP_NKID; i++) { |
1134 | if (sc->sc_wepkeys[i].an_wep_keylen >= 0) { |
1135 | memset(&sc->sc_wepkeys[i].an_wep_key, 0, |
1136 | sizeof(sc->sc_wepkeys[i].an_wep_key)); |
1137 | sc->sc_wepkeys[i].an_wep_keylen = -1; |
1138 | needreset++; |
1139 | } |
1140 | if (keys[i].an_wep_keylen >= 0) |
1141 | sc->sc_perskeylen[i] = keys[i].an_wep_keylen; |
1142 | } |
1143 | } |
1144 | if (needreset) { |
1145 | /* firmware restart to reload persistent key */ |
1146 | an_reset(sc); |
1147 | } |
1148 | if (anysetkey || needreset) |
1149 | error = ENETRESET; |
1150 | return error; |
1151 | } |
1152 | |
1153 | static int |
1154 | an_set_nwkey_eap(struct an_softc *sc, struct ieee80211_nwkey *nwkey) |
1155 | { |
1156 | int i, error, len; |
1157 | struct ifnet *ifp = &sc->sc_if; |
1158 | struct an_rid_leapkey *key; |
1159 | u_int16_t unibuf[sizeof(key->an_key)]; |
1160 | static const int leap_rid[] = { AN_RID_LEAP_PASS, AN_RID_LEAP_USER }; |
1161 | MD4_CTX ctx; |
1162 | |
1163 | error = 0; |
1164 | |
1165 | if (nwkey->i_key[0].i_keydat == NULL && |
1166 | nwkey->i_key[1].i_keydat == NULL) |
1167 | return 0; |
1168 | if (!sc->sc_enabled) |
1169 | return ENXIO; |
1170 | an_cmd(sc, AN_CMD_DISABLE, 0); |
1171 | key = &sc->sc_buf.sc_leapkey; |
1172 | for (i = 0; i < 2; i++) { |
1173 | if (nwkey->i_key[i].i_keydat == NULL) |
1174 | continue; |
1175 | len = nwkey->i_key[i].i_keylen; |
1176 | if (len > sizeof(key->an_key)) |
1177 | return EINVAL; |
1178 | memset(key, 0, sizeof(*key)); |
1179 | key->an_key_len = htole16(len); |
1180 | if ((error = copyin(nwkey->i_key[i].i_keydat, key->an_key, |
1181 | len)) != 0) |
1182 | return error; |
1183 | if (i == 1) { |
1184 | /* |
1185 | * Cisco seems to use PasswordHash and PasswordHashHash |
1186 | * in RFC-2759 (MS-CHAP-V2). |
1187 | */ |
1188 | memset(unibuf, 0, sizeof(unibuf)); |
1189 | /* XXX: convert password to unicode */ |
1190 | for (i = 0; i < len; i++) |
1191 | unibuf[i] = key->an_key[i]; |
1192 | /* set PasswordHash */ |
1193 | MD4Init(&ctx); |
1194 | MD4Update(&ctx, (u_int8_t *)unibuf, len * 2); |
1195 | MD4Final(key->an_key, &ctx); |
1196 | /* set PasswordHashHash */ |
1197 | MD4Init(&ctx); |
1198 | MD4Update(&ctx, key->an_key, 16); |
1199 | MD4Final(key->an_key + 16, &ctx); |
1200 | key->an_key_len = htole16(32); |
1201 | } |
1202 | if ((error = an_write_rid(sc, leap_rid[i], key, |
1203 | sizeof(*key))) != 0) { |
1204 | printf("%s: LEAP set failed\n" , ifp->if_xname); |
1205 | return error; |
1206 | } |
1207 | } |
1208 | error = an_cmd(sc, AN_CMD_ENABLE, 0); |
1209 | if (error) |
1210 | printf("%s: an_set_nwkey: failed to enable MAC\n" , |
1211 | ifp->if_xname); |
1212 | else |
1213 | error = ENETRESET; |
1214 | return error; |
1215 | } |
1216 | |
1217 | static int |
1218 | an_get_nwkey(struct an_softc *sc, struct ieee80211_nwkey *nwkey) |
1219 | { |
1220 | int i, error; |
1221 | |
1222 | error = 0; |
1223 | if (sc->sc_config.an_authtype & AN_AUTHTYPE_LEAP) |
1224 | nwkey->i_wepon = IEEE80211_NWKEY_EAP; |
1225 | else if (sc->sc_config.an_authtype & AN_AUTHTYPE_PRIVACY_IN_USE) |
1226 | nwkey->i_wepon = IEEE80211_NWKEY_WEP; |
1227 | else |
1228 | nwkey->i_wepon = IEEE80211_NWKEY_OPEN; |
1229 | if (sc->sc_tx_key == -1) |
1230 | nwkey->i_defkid = sc->sc_tx_perskey + 1; |
1231 | else |
1232 | nwkey->i_defkid = sc->sc_tx_key + 1; |
1233 | if (nwkey->i_key[0].i_keydat == NULL) |
1234 | return 0; |
1235 | for (i = 0; i < IEEE80211_WEP_NKID; i++) { |
1236 | if (nwkey->i_key[i].i_keydat == NULL) |
1237 | continue; |
1238 | /* do not show any keys to non-root user */ |
1239 | /* XXX-elad: why is this inside a loop? */ |
1240 | if ((error = kauth_authorize_network(curlwp->l_cred, |
1241 | KAUTH_NETWORK_INTERFACE, |
1242 | KAUTH_REQ_NETWORK_INTERFACE_GETPRIV, sc->sc_ic.ic_ifp, |
1243 | KAUTH_ARG(SIOCG80211NWKEY), NULL)) != 0) |
1244 | break; |
1245 | nwkey->i_key[i].i_keylen = sc->sc_wepkeys[i].an_wep_keylen; |
1246 | if (nwkey->i_key[i].i_keylen < 0) { |
1247 | if (sc->sc_perskeylen[i] == 0) |
1248 | nwkey->i_key[i].i_keylen = 0; |
1249 | continue; |
1250 | } |
1251 | if ((error = copyout(sc->sc_wepkeys[i].an_wep_key, |
1252 | nwkey->i_key[i].i_keydat, |
1253 | sc->sc_wepkeys[i].an_wep_keylen)) != 0) |
1254 | break; |
1255 | } |
1256 | return error; |
1257 | } |
1258 | |
1259 | static int |
1260 | an_write_wepkey(struct an_softc *sc, int type, struct an_wepkey *keys, int kid) |
1261 | { |
1262 | int i, error; |
1263 | struct an_rid_wepkey *akey; |
1264 | |
1265 | error = 0; |
1266 | akey = &sc->sc_buf.sc_wepkey; |
1267 | memset(akey, 0, sizeof(struct an_rid_wepkey)); |
1268 | for (i = 0; i < IEEE80211_WEP_NKID; i++) { |
1269 | if (keys[i].an_wep_keylen < 0 || |
1270 | keys[i].an_wep_keylen > sizeof(akey->an_key)) |
1271 | continue; |
1272 | akey->an_key_len = htole16(keys[i].an_wep_keylen); |
1273 | akey->an_key_index = htole16(i); |
1274 | akey->an_mac_addr[0] = 1; /* default mac */ |
1275 | memcpy(akey->an_key, keys[i].an_wep_key, keys[i].an_wep_keylen); |
1276 | if ((error = an_write_rid(sc, type, akey, sizeof(*akey))) != 0) |
1277 | return error; |
1278 | } |
1279 | if (kid >= 0) { |
1280 | akey->an_key_index = htole16(0xffff); |
1281 | akey->an_mac_addr[0] = kid; |
1282 | akey->an_key_len = htole16(0); |
1283 | memset(akey->an_key, 0, sizeof(akey->an_key)); |
1284 | error = an_write_rid(sc, type, akey, sizeof(*akey)); |
1285 | } |
1286 | return error; |
1287 | } |
1288 | |
1289 | #ifdef AN_DEBUG |
1290 | static void |
1291 | an_dump_pkt(const char *devname, struct mbuf *m) |
1292 | { |
1293 | int col, col0, i; |
1294 | uint8_t *pkt = mtod(m, uint8_t *); |
1295 | const char *delim = "" ; |
1296 | int delimw = 0; |
1297 | |
1298 | printf("%s: pkt " , devname); |
1299 | col = col0 = strlen(devname) + strlen(": pkt " ); |
1300 | for (i = 0; i < m->m_len; i++) { |
1301 | printf("%s%02x" , delim, pkt[i]); |
1302 | delim = ":" ; |
1303 | delimw = 1; |
1304 | col += delimw + 2; |
1305 | if (col >= 72) { |
1306 | printf("\n%*s" , col0, "" ); |
1307 | col = col0; |
1308 | delim = "" ; |
1309 | delimw = 0; |
1310 | } |
1311 | } |
1312 | if (col != 0) |
1313 | printf("\n" ); |
1314 | } |
1315 | #endif /* AN_DEBUG */ |
1316 | |
1317 | /* |
1318 | * Low level functions |
1319 | */ |
1320 | |
1321 | static void |
1322 | an_rx_intr(struct an_softc *sc) |
1323 | { |
1324 | struct ieee80211com *ic = &sc->sc_ic; |
1325 | struct ifnet *ifp = &sc->sc_if; |
1326 | struct ieee80211_frame_min *wh; |
1327 | struct ieee80211_node *ni; |
1328 | struct an_rxframe frmhdr; |
1329 | struct mbuf *m; |
1330 | u_int16_t status; |
1331 | int fid, gaplen, len, off; |
1332 | uint8_t *gap; |
1333 | |
1334 | fid = CSR_READ_2(sc, AN_RX_FID); |
1335 | |
1336 | /* First read in the frame header */ |
1337 | if (an_read_bap(sc, fid, 0, &frmhdr, sizeof(frmhdr)) != 0) { |
1338 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1339 | ifp->if_ierrors++; |
1340 | DPRINTF(("an_rx_intr: read fid %x failed\n" , fid)); |
1341 | return; |
1342 | } |
1343 | |
1344 | #ifdef AN_DEBUG |
1345 | if ((ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == (IFF_DEBUG|IFF_LINK2)) { |
1346 | ieee80211_dump_pkt((u_int8_t *)&frmhdr.an_whdr, |
1347 | sizeof(struct ieee80211_frame), frmhdr.an_rx_rate, |
1348 | frmhdr.an_rx_signal_strength); |
1349 | printf(" time 0x%x status 0x%x plen %u chan %u" |
1350 | " plcp %02x %02x %02x %02x gap %u\n" , |
1351 | le32toh(frmhdr.an_rx_time), le16toh(frmhdr.an_rx_status), |
1352 | le16toh(frmhdr.an_rx_payload_len), frmhdr.an_rx_chan, |
1353 | frmhdr.an_plcp_hdr[0], frmhdr.an_plcp_hdr[1], |
1354 | frmhdr.an_plcp_hdr[2], frmhdr.an_plcp_hdr[3], |
1355 | le16toh(frmhdr.an_gaplen)); |
1356 | } |
1357 | #endif |
1358 | |
1359 | status = le16toh(frmhdr.an_rx_status); |
1360 | if ((status & AN_STAT_ERRSTAT) != 0 && |
1361 | ic->ic_opmode != IEEE80211_M_MONITOR) { |
1362 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1363 | ifp->if_ierrors++; |
1364 | DPRINTF(("an_rx_intr: fid %x status %x\n" , fid, status)); |
1365 | return; |
1366 | } |
1367 | |
1368 | /* the payload length field includes a 16-bit "mystery field" */ |
1369 | len = le16toh(frmhdr.an_rx_payload_len) - sizeof(uint16_t); |
1370 | off = ALIGN(sizeof(struct ieee80211_frame)); |
1371 | |
1372 | if (off + len > MCLBYTES) { |
1373 | if (ic->ic_opmode != IEEE80211_M_MONITOR) { |
1374 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1375 | ifp->if_ierrors++; |
1376 | DPRINTF(("an_rx_intr: oversized packet %d\n" , len)); |
1377 | return; |
1378 | } |
1379 | len = 0; |
1380 | } |
1381 | |
1382 | MGETHDR(m, M_DONTWAIT, MT_DATA); |
1383 | if (m == NULL) { |
1384 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1385 | ifp->if_ierrors++; |
1386 | DPRINTF(("an_rx_intr: MGET failed\n" )); |
1387 | return; |
1388 | } |
1389 | if (off + len + AN_GAPLEN_MAX > MHLEN) { |
1390 | MCLGET(m, M_DONTWAIT); |
1391 | if ((m->m_flags & M_EXT) == 0) { |
1392 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1393 | m_freem(m); |
1394 | ifp->if_ierrors++; |
1395 | DPRINTF(("an_rx_intr: MCLGET failed\n" )); |
1396 | return; |
1397 | } |
1398 | } |
1399 | m->m_data += off - sizeof(struct ieee80211_frame); |
1400 | |
1401 | if (ic->ic_opmode != IEEE80211_M_MONITOR) { |
1402 | gaplen = le16toh(frmhdr.an_gaplen); |
1403 | if (gaplen > AN_GAPLEN_MAX) { |
1404 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1405 | m_freem(m); |
1406 | ifp->if_ierrors++; |
1407 | DPRINTF(("%s: gap too long\n" , __func__)); |
1408 | return; |
1409 | } |
1410 | /* |
1411 | * We don't need the 16-bit mystery field (payload length?), |
1412 | * so read it into the region reserved for the 802.11 header. |
1413 | * |
1414 | * When Cisco Aironet 350 cards w/ firmware version 5 or |
1415 | * greater operate with certain Cisco 350 APs, |
1416 | * the "gap" is filled with the SNAP header. Read |
1417 | * it in after the 802.11 header. |
1418 | */ |
1419 | gap = m->m_data + sizeof(struct ieee80211_frame) - |
1420 | sizeof(uint16_t); |
1421 | an_read_bap(sc, fid, -1, gap, gaplen + sizeof(u_int16_t)); |
1422 | #ifdef AN_DEBUG |
1423 | if ((ifp->if_flags & (IFF_DEBUG|IFF_LINK2)) == |
1424 | (IFF_DEBUG|IFF_LINK2)) { |
1425 | int i; |
1426 | printf(" gap&len" ); |
1427 | for (i = 0; i < gaplen + sizeof(u_int16_t); i++) |
1428 | printf(" %02x" , gap[i]); |
1429 | printf("\n" ); |
1430 | } |
1431 | #endif |
1432 | } else |
1433 | gaplen = 0; |
1434 | |
1435 | an_read_bap(sc, fid, -1, |
1436 | m->m_data + sizeof(struct ieee80211_frame) + gaplen, len); |
1437 | m->m_pkthdr.len = m->m_len = sizeof(struct ieee80211_frame) + gaplen + |
1438 | len; |
1439 | |
1440 | memcpy(m->m_data, &frmhdr.an_whdr, sizeof(struct ieee80211_frame)); |
1441 | m_set_rcvif(m, ifp); |
1442 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_RX); |
1443 | |
1444 | if (sc->sc_drvbpf) { |
1445 | struct an_rx_radiotap_header *tap = &sc->sc_rxtap; |
1446 | |
1447 | tap->ar_rate = frmhdr.an_rx_rate; |
1448 | tap->ar_chan_flags = htole16(ic->ic_bss->ni_chan->ic_flags); |
1449 | tap->ar_chan_freq = htole16(ic->ic_bss->ni_chan->ic_freq); |
1450 | tap->ar_antsignal = frmhdr.an_rx_signal_strength; |
1451 | if ((le16toh(frmhdr.an_rx_status) & AN_STAT_BADCRC) || |
1452 | (le16toh(frmhdr.an_rx_status) & AN_STAT_ERRSTAT) || |
1453 | (le16toh(frmhdr.an_rx_status) & AN_STAT_UNDECRYPTABLE)) |
1454 | tap->ar_flags |= IEEE80211_RADIOTAP_F_BADFCS; |
1455 | |
1456 | bpf_mtap2(sc->sc_drvbpf, tap, tap->ar_ihdr.it_len, m); |
1457 | } |
1458 | wh = mtod(m, struct ieee80211_frame_min *); |
1459 | if (wh->i_fc[1] & IEEE80211_FC1_WEP) { |
1460 | /* |
1461 | * WEP is decrypted by hardware. Clear WEP bit |
1462 | * header for ieee80211_input(). |
1463 | */ |
1464 | wh->i_fc[1] &= ~IEEE80211_FC1_WEP; |
1465 | } |
1466 | |
1467 | #ifdef AN_DEBUG |
1468 | if (an_debug > 1) |
1469 | an_dump_pkt(device_xname(sc->sc_dev), m); |
1470 | #endif /* AN_DEBUG */ |
1471 | |
1472 | ni = ieee80211_find_rxnode(ic, wh); |
1473 | ieee80211_input(ic, m, ni, frmhdr.an_rx_signal_strength, |
1474 | le32toh(frmhdr.an_rx_time)); |
1475 | ieee80211_free_node(ni); |
1476 | } |
1477 | |
1478 | static void |
1479 | an_tx_intr(struct an_softc *sc, int status) |
1480 | { |
1481 | struct ifnet *ifp = &sc->sc_if; |
1482 | int cur, fid; |
1483 | |
1484 | sc->sc_tx_timer = 0; |
1485 | ifp->if_flags &= ~IFF_OACTIVE; |
1486 | |
1487 | fid = CSR_READ_2(sc, AN_TX_CMP_FID); |
1488 | CSR_WRITE_2(sc, AN_EVENT_ACK, status & (AN_EV_TX | AN_EV_TX_EXC)); |
1489 | |
1490 | if (status & AN_EV_TX_EXC) |
1491 | ifp->if_oerrors++; |
1492 | else |
1493 | ifp->if_opackets++; |
1494 | |
1495 | cur = sc->sc_txcur; |
1496 | if (sc->sc_txd[cur].d_fid == fid) { |
1497 | sc->sc_txd[cur].d_inuse = 0; |
1498 | DPRINTF2(("an_tx_intr: sent %x/%d\n" , fid, cur)); |
1499 | AN_INC(cur, AN_TX_RING_CNT); |
1500 | sc->sc_txcur = cur; |
1501 | } else { |
1502 | for (cur = 0; cur < AN_TX_RING_CNT; cur++) { |
1503 | if (fid == sc->sc_txd[cur].d_fid) { |
1504 | sc->sc_txd[cur].d_inuse = 0; |
1505 | break; |
1506 | } |
1507 | } |
1508 | if (ifp->if_flags & IFF_DEBUG) |
1509 | printf("%s: tx mismatch: " |
1510 | "expected %x(%d), actual %x(%d)\n" , |
1511 | device_xname(sc->sc_dev), |
1512 | sc->sc_txd[sc->sc_txcur].d_fid, sc->sc_txcur, |
1513 | fid, cur); |
1514 | } |
1515 | |
1516 | return; |
1517 | } |
1518 | |
1519 | static void |
1520 | an_linkstat_intr(struct an_softc *sc) |
1521 | { |
1522 | struct ieee80211com *ic = &sc->sc_ic; |
1523 | u_int16_t status; |
1524 | |
1525 | status = CSR_READ_2(sc, AN_LINKSTAT); |
1526 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_LINKSTAT); |
1527 | DPRINTF(("an_linkstat_intr: status 0x%x\n" , status)); |
1528 | |
1529 | if (status == AN_LINKSTAT_ASSOCIATED) { |
1530 | if (ic->ic_state != IEEE80211_S_RUN || |
1531 | ic->ic_opmode == IEEE80211_M_IBSS) |
1532 | ieee80211_new_state(ic, IEEE80211_S_RUN, -1); |
1533 | } else { |
1534 | if (ic->ic_opmode == IEEE80211_M_STA) |
1535 | ieee80211_new_state(ic, IEEE80211_S_INIT, -1); |
1536 | } |
1537 | } |
1538 | |
1539 | /* Must be called at proper protection level! */ |
1540 | static int |
1541 | an_cmd(struct an_softc *sc, int cmd, int val) |
1542 | { |
1543 | int i, status; |
1544 | |
1545 | /* make sure that previous command completed */ |
1546 | if (CSR_READ_2(sc, AN_COMMAND) & AN_CMD_BUSY) { |
1547 | if (sc->sc_if.if_flags & IFF_DEBUG) |
1548 | printf("%s: command 0x%x busy\n" , device_xname(sc->sc_dev), |
1549 | CSR_READ_2(sc, AN_COMMAND)); |
1550 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CLR_STUCK_BUSY); |
1551 | } |
1552 | |
1553 | CSR_WRITE_2(sc, AN_PARAM0, val); |
1554 | CSR_WRITE_2(sc, AN_PARAM1, 0); |
1555 | CSR_WRITE_2(sc, AN_PARAM2, 0); |
1556 | CSR_WRITE_2(sc, AN_COMMAND, cmd); |
1557 | |
1558 | if (cmd == AN_CMD_FW_RESTART) { |
1559 | /* XXX: should sleep here */ |
1560 | DELAY(100*1000); |
1561 | } |
1562 | |
1563 | for (i = 0; i < AN_TIMEOUT; i++) { |
1564 | if (CSR_READ_2(sc, AN_EVENT_STAT) & AN_EV_CMD) |
1565 | break; |
1566 | DELAY(10); |
1567 | } |
1568 | |
1569 | status = CSR_READ_2(sc, AN_STATUS); |
1570 | |
1571 | /* clear stuck command busy if necessary */ |
1572 | if (CSR_READ_2(sc, AN_COMMAND) & AN_CMD_BUSY) |
1573 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CLR_STUCK_BUSY); |
1574 | |
1575 | /* Ack the command */ |
1576 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CMD); |
1577 | |
1578 | if (i == AN_TIMEOUT) { |
1579 | if (sc->sc_if.if_flags & IFF_DEBUG) |
1580 | printf("%s: command 0x%x param 0x%x timeout\n" , |
1581 | device_xname(sc->sc_dev), cmd, val); |
1582 | return ETIMEDOUT; |
1583 | } |
1584 | if (status & AN_STAT_CMD_RESULT) { |
1585 | if (sc->sc_if.if_flags & IFF_DEBUG) |
1586 | printf("%s: command 0x%x param 0x%x status 0x%x " |
1587 | "resp 0x%x 0x%x 0x%x\n" , |
1588 | device_xname(sc->sc_dev), cmd, val, status, |
1589 | CSR_READ_2(sc, AN_RESP0), CSR_READ_2(sc, AN_RESP1), |
1590 | CSR_READ_2(sc, AN_RESP2)); |
1591 | return EIO; |
1592 | } |
1593 | |
1594 | return 0; |
1595 | } |
1596 | |
1597 | |
1598 | /* |
1599 | * Wait for firmware come up after power enabled. |
1600 | */ |
1601 | static void |
1602 | an_wait(struct an_softc *sc) |
1603 | { |
1604 | int i; |
1605 | |
1606 | CSR_WRITE_2(sc, AN_COMMAND, AN_CMD_NOOP2); |
1607 | for (i = 0; i < 3*hz; i++) { |
1608 | if (CSR_READ_2(sc, AN_EVENT_STAT) & AN_EV_CMD) |
1609 | break; |
1610 | (void)tsleep(sc, PWAIT, "anatch" , 1); |
1611 | } |
1612 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_CMD); |
1613 | } |
1614 | |
1615 | static int |
1616 | an_seek_bap(struct an_softc *sc, int id, int off) |
1617 | { |
1618 | int i, status; |
1619 | |
1620 | CSR_WRITE_2(sc, AN_SEL0, id); |
1621 | CSR_WRITE_2(sc, AN_OFF0, off); |
1622 | |
1623 | for (i = 0; ; i++) { |
1624 | status = CSR_READ_2(sc, AN_OFF0); |
1625 | if ((status & AN_OFF_BUSY) == 0) |
1626 | break; |
1627 | if (i == AN_TIMEOUT) { |
1628 | printf("%s: timeout in an_seek_bap to 0x%x/0x%x\n" , |
1629 | device_xname(sc->sc_dev), id, off); |
1630 | sc->sc_bap_off = AN_OFF_ERR; /* invalidate */ |
1631 | return ETIMEDOUT; |
1632 | } |
1633 | DELAY(10); |
1634 | } |
1635 | if (status & AN_OFF_ERR) { |
1636 | aprint_error_dev(sc->sc_dev, "failed in an_seek_bap to 0x%x/0x%x\n" , |
1637 | id, off); |
1638 | sc->sc_bap_off = AN_OFF_ERR; /* invalidate */ |
1639 | return EIO; |
1640 | } |
1641 | sc->sc_bap_id = id; |
1642 | sc->sc_bap_off = off; |
1643 | return 0; |
1644 | } |
1645 | |
1646 | static int |
1647 | an_read_bap(struct an_softc *sc, int id, int off, void *buf, int buflen) |
1648 | { |
1649 | int error, cnt; |
1650 | |
1651 | if (buflen == 0) |
1652 | return 0; |
1653 | if (off == -1) |
1654 | off = sc->sc_bap_off; |
1655 | if (id != sc->sc_bap_id || off != sc->sc_bap_off) { |
1656 | if ((error = an_seek_bap(sc, id, off)) != 0) |
1657 | return EIO; |
1658 | } |
1659 | |
1660 | cnt = (buflen + 1) / 2; |
1661 | CSR_READ_MULTI_STREAM_2(sc, AN_DATA0, (u_int16_t *)buf, cnt); |
1662 | sc->sc_bap_off += cnt * 2; |
1663 | return 0; |
1664 | } |
1665 | |
1666 | static int |
1667 | an_write_bap(struct an_softc *sc, int id, int off, void *buf, int buflen) |
1668 | { |
1669 | int error, cnt; |
1670 | |
1671 | if (buflen == 0) |
1672 | return 0; |
1673 | if (off == -1) |
1674 | off = sc->sc_bap_off; |
1675 | if (id != sc->sc_bap_id || off != sc->sc_bap_off) { |
1676 | if ((error = an_seek_bap(sc, id, off)) != 0) |
1677 | return EIO; |
1678 | } |
1679 | |
1680 | cnt = (buflen + 1) / 2; |
1681 | CSR_WRITE_MULTI_STREAM_2(sc, AN_DATA0, (u_int16_t *)buf, cnt); |
1682 | sc->sc_bap_off += cnt * 2; |
1683 | return 0; |
1684 | } |
1685 | |
1686 | static int |
1687 | an_mwrite_bap(struct an_softc *sc, int id, int off, struct mbuf *m, int totlen) |
1688 | { |
1689 | int error, len, cnt; |
1690 | |
1691 | if (off == -1) |
1692 | off = sc->sc_bap_off; |
1693 | if (id != sc->sc_bap_id || off != sc->sc_bap_off) { |
1694 | if ((error = an_seek_bap(sc, id, off)) != 0) |
1695 | return EIO; |
1696 | } |
1697 | |
1698 | for (len = 0; m != NULL; m = m->m_next) { |
1699 | if (m->m_len == 0) |
1700 | continue; |
1701 | len = min(m->m_len, totlen); |
1702 | |
1703 | if ((mtod(m, u_long) & 0x1) || (len & 0x1)) { |
1704 | m_copydata(m, 0, totlen, (void *)&sc->sc_buf.sc_txbuf); |
1705 | cnt = (totlen + 1) / 2; |
1706 | CSR_WRITE_MULTI_STREAM_2(sc, AN_DATA0, |
1707 | sc->sc_buf.sc_val, cnt); |
1708 | off += cnt * 2; |
1709 | break; |
1710 | } |
1711 | cnt = len / 2; |
1712 | CSR_WRITE_MULTI_STREAM_2(sc, AN_DATA0, mtod(m, u_int16_t *), |
1713 | cnt); |
1714 | off += len; |
1715 | totlen -= len; |
1716 | } |
1717 | sc->sc_bap_off = off; |
1718 | return 0; |
1719 | } |
1720 | |
1721 | static int |
1722 | an_alloc_fid(struct an_softc *sc, int len, int *idp) |
1723 | { |
1724 | int i; |
1725 | |
1726 | if (an_cmd(sc, AN_CMD_ALLOC_MEM, len)) { |
1727 | aprint_error_dev(sc->sc_dev, "failed to allocate %d bytes on NIC\n" , |
1728 | len); |
1729 | return ENOMEM; |
1730 | } |
1731 | |
1732 | for (i = 0; i < AN_TIMEOUT; i++) { |
1733 | if (CSR_READ_2(sc, AN_EVENT_STAT) & AN_EV_ALLOC) |
1734 | break; |
1735 | if (i == AN_TIMEOUT) { |
1736 | printf("%s: timeout in alloc\n" , device_xname(sc->sc_dev)); |
1737 | return ETIMEDOUT; |
1738 | } |
1739 | DELAY(10); |
1740 | } |
1741 | |
1742 | *idp = CSR_READ_2(sc, AN_ALLOC_FID); |
1743 | CSR_WRITE_2(sc, AN_EVENT_ACK, AN_EV_ALLOC); |
1744 | return 0; |
1745 | } |
1746 | |
1747 | static int |
1748 | an_read_rid(struct an_softc *sc, int rid, void *buf, int *buflenp) |
1749 | { |
1750 | int error; |
1751 | u_int16_t len; |
1752 | |
1753 | /* Tell the NIC to enter record read mode. */ |
1754 | error = an_cmd(sc, AN_CMD_ACCESS | AN_ACCESS_READ, rid); |
1755 | if (error) |
1756 | return error; |
1757 | |
1758 | /* length in byte, including length itself */ |
1759 | error = an_read_bap(sc, rid, 0, &len, sizeof(len)); |
1760 | if (error) |
1761 | return error; |
1762 | |
1763 | len = le16toh(len) - 2; |
1764 | if (*buflenp < len) { |
1765 | aprint_error_dev(sc->sc_dev, "record buffer is too small, " |
1766 | "rid=%x, size=%d, len=%d\n" , |
1767 | rid, *buflenp, len); |
1768 | return ENOSPC; |
1769 | } |
1770 | *buflenp = len; |
1771 | return an_read_bap(sc, rid, sizeof(len), buf, len); |
1772 | } |
1773 | |
1774 | static int |
1775 | an_write_rid(struct an_softc *sc, int rid, void *buf, int buflen) |
1776 | { |
1777 | int error; |
1778 | u_int16_t len; |
1779 | |
1780 | /* length in byte, including length itself */ |
1781 | len = htole16(buflen + 2); |
1782 | |
1783 | error = an_write_bap(sc, rid, 0, &len, sizeof(len)); |
1784 | if (error) |
1785 | return error; |
1786 | error = an_write_bap(sc, rid, sizeof(len), buf, buflen); |
1787 | if (error) |
1788 | return error; |
1789 | |
1790 | return an_cmd(sc, AN_CMD_ACCESS | AN_ACCESS_WRITE, rid); |
1791 | } |
1792 | |
1793 | static int |
1794 | an_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg) |
1795 | { |
1796 | struct an_softc *sc = (struct an_softc *)ic->ic_ifp->if_softc; |
1797 | struct ieee80211_node *ni = ic->ic_bss; |
1798 | int buflen; |
1799 | |
1800 | DPRINTF(("an_newstate: %s -> %s\n" , ieee80211_state_name[ic->ic_state], |
1801 | ieee80211_state_name[nstate])); |
1802 | |
1803 | switch (nstate) { |
1804 | case IEEE80211_S_INIT: |
1805 | ic->ic_flags &= ~IEEE80211_F_IBSSON; |
1806 | return (*sc->sc_newstate)(ic, nstate, arg); |
1807 | |
1808 | case IEEE80211_S_SCAN: |
1809 | case IEEE80211_S_AUTH: |
1810 | case IEEE80211_S_ASSOC: |
1811 | ic->ic_state = nstate; /* NB: skip normal ieee80211 handling */ |
1812 | return 0; |
1813 | |
1814 | case IEEE80211_S_RUN: |
1815 | buflen = sizeof(sc->sc_buf); |
1816 | an_read_rid(sc, AN_RID_STATUS, &sc->sc_buf, &buflen); |
1817 | IEEE80211_ADDR_COPY(ni->ni_bssid, |
1818 | sc->sc_buf.sc_status.an_cur_bssid); |
1819 | IEEE80211_ADDR_COPY(ni->ni_macaddr, ni->ni_bssid); |
1820 | ni->ni_chan = &ic->ic_channels[ |
1821 | le16toh(sc->sc_buf.sc_status.an_cur_channel)]; |
1822 | ni->ni_esslen = le16toh(sc->sc_buf.sc_status.an_ssidlen); |
1823 | if (ni->ni_esslen > IEEE80211_NWID_LEN) |
1824 | ni->ni_esslen = IEEE80211_NWID_LEN; /*XXX*/ |
1825 | memcpy(ni->ni_essid, sc->sc_buf.sc_status.an_ssid, |
1826 | ni->ni_esslen); |
1827 | ni->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11B]; /*XXX*/ |
1828 | if (ic->ic_ifp->if_flags & IFF_DEBUG) { |
1829 | printf("%s: " , device_xname(sc->sc_dev)); |
1830 | if (ic->ic_opmode == IEEE80211_M_STA) |
1831 | printf("associated " ); |
1832 | else |
1833 | printf("synchronized " ); |
1834 | printf("with %s ssid " , ether_sprintf(ni->ni_bssid)); |
1835 | ieee80211_print_essid(ni->ni_essid, ni->ni_esslen); |
1836 | printf(" channel %u start %uMb\n" , |
1837 | le16toh(sc->sc_buf.sc_status.an_cur_channel), |
1838 | le16toh(sc->sc_buf.sc_status.an_current_tx_rate)/2); |
1839 | } |
1840 | break; |
1841 | |
1842 | default: |
1843 | break; |
1844 | } |
1845 | return (*sc->sc_newstate)(ic, nstate, arg); |
1846 | } |
1847 | |