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