?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
suser_* to priv_* conversion
[dragonfly.git] / sys / dev / netif / ndis / if_ndis.c
bloba367764bf9101ae0b801dc55b97f9059fde6190e
1 /*
2 * Copyright (c) 2003
3 * Bill Paul <wpaul@windriver.com>. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 * $FreeBSD: src/sys/dev/if_ndis/if_ndis.c,v 1.65 2004/07/07 17:46:30 wpaul Exp $
33 * $DragonFly: src/sys/dev/netif/ndis/if_ndis.c,v 1.23 2008/08/17 04:32:34 sephe Exp $
34 */
35
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/sockio.h>
39 #include <sys/mbuf.h>
40 #include <sys/malloc.h>
41 #include <sys/kernel.h>
42 #include <sys/socket.h>
43 #include <sys/queue.h>
44 #include <sys/proc.h>
45 #include <sys/priv.h>
46 #include <sys/sysctl.h>
47 #include <sys/bus.h>
48 #include <sys/rman.h>
49 #include <sys/serialize.h>
50 #include <sys/thread2.h>
51
52 #include <net/if.h>
53 #include <net/ifq_var.h>
54 #include <net/if_arp.h>
55 #include <net/ethernet.h>
56 #include <net/if_dl.h>
57 #include <net/if_media.h>
58 #include <net/route.h>
59
60 #include <net/bpf.h>
61
62 #include <netproto/802_11/ieee80211_var.h>
63 #include <netproto/802_11/ieee80211_ioctl.h>
64
65 #include <netproto/802_11/if_wavelan_ieee.h>
66
67 #include <bus/pci/pcireg.h>
68 #include <bus/pci/pcivar.h>
69
70 #include <emulation/ndis/regcall.h>
71 #include <emulation/ndis/pe_var.h>
72 #include <emulation/ndis/resource_var.h>
73 #include <emulation/ndis/ntoskrnl_var.h>
74 #include <emulation/ndis/hal_var.h>
75 #include <emulation/ndis/ndis_var.h>
76 #include <emulation/ndis/cfg_var.h>
77 #include "if_ndisvar.h"
78
79 #define NDIS_IMAGE
80 #define NDIS_REGVALS
81
82 #include "ndis_driver_data.h"
83
84 int ndis_attach (device_t);
85 int ndis_detach (device_t);
86 int ndis_suspend (device_t);
87 int ndis_resume (device_t);
88 void ndis_shutdown (device_t);
89
90 static __stdcall void ndis_txeof (ndis_handle,
91 ndis_packet *, ndis_status);
92 static __stdcall void ndis_rxeof (ndis_handle,
93 ndis_packet **, uint32_t);
94 static __stdcall void ndis_linksts (ndis_handle,
95 ndis_status, void *, uint32_t);
96 static __stdcall void ndis_linksts_done (ndis_handle);
97
98 static void ndis_intr (void *);
99 static void ndis_intrtask (void *);
100 static void ndis_tick (void *);
101 static void ndis_ticktask (void *);
102 static void ndis_start (struct ifnet *);
103 static void ndis_starttask (void *);
104 static int ndis_ioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
105 static int ndis_wi_ioctl_get (struct ifnet *, u_long, caddr_t);
106 static int ndis_wi_ioctl_set (struct ifnet *, u_long, caddr_t);
107 static void ndis_init (void *);
108 static void ndis_stop (struct ndis_softc *);
109 static void ndis_watchdog (struct ifnet *);
110 static int ndis_ifmedia_upd (struct ifnet *);
111 static void ndis_ifmedia_sts (struct ifnet *, struct ifmediareq *);
112 static int ndis_get_assoc (struct ndis_softc *, ndis_wlan_bssid_ex **);
113 static int ndis_probe_offload (struct ndis_softc *);
114 static int ndis_set_offload (struct ndis_softc *);
115 static void ndis_getstate_80211 (struct ndis_softc *);
116 static void ndis_setstate_80211 (struct ndis_softc *);
117 static void ndis_media_status (struct ifnet *, struct ifmediareq *);
118
119 static void ndis_setmulti (struct ndis_softc *);
120 static void ndis_map_sclist (void *, bus_dma_segment_t *,
121 int, bus_size_t, int);
122
123 /*
124 * Program the 64-bit multicast hash filter.
125 */
126 static void
127 ndis_setmulti(struct ndis_softc *sc)
128 {
129 struct ifnet *ifp;
130 struct ifmultiaddr *ifma;
131 int len, mclistsz, error;
132 uint8_t *mclist;
133
134 ifp = &sc->arpcom.ac_if;
135
136 if (!NDIS_INITIALIZED(sc))
137 return;
138
139 if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
140 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
141 len = sizeof(sc->ndis_filter);
142 error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER,
143 &sc->ndis_filter, &len);
144 if (error)
145 device_printf (sc->ndis_dev,
146 "set filter failed: %d\n", error);
147 return;
148 }
149
150 if (LIST_EMPTY(&ifp->if_multiaddrs))
151 return;
152
153 len = sizeof(mclistsz);
154 ndis_get_info(sc, OID_802_3_MAXIMUM_LIST_SIZE, &mclistsz, &len);
155
156 mclist = kmalloc(ETHER_ADDR_LEN * mclistsz, M_TEMP, M_NOWAIT|M_ZERO);
157
158 if (mclist == NULL) {
159 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
160 goto out;
161 }
162
163 sc->ndis_filter |= NDIS_PACKET_TYPE_MULTICAST;
164
165 len = 0;
166 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
167 if (ifma->ifma_addr->sa_family != AF_LINK)
168 continue;
169 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
170 mclist + (ETHER_ADDR_LEN * len), ETHER_ADDR_LEN);
171 len++;
172 if (len > mclistsz) {
173 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
174 sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST;
175 goto out;
176 }
177 }
178
179 len = len * ETHER_ADDR_LEN;
180 error = ndis_set_info(sc, OID_802_3_MULTICAST_LIST, mclist, &len);
181 if (error) {
182 device_printf (sc->ndis_dev, "set mclist failed: %d\n", error);
183 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
184 sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST;
185 }
186
187 out:
188 kfree(mclist, M_TEMP);
189
190 len = sizeof(sc->ndis_filter);
191 error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER,
192 &sc->ndis_filter, &len);
193 if (error)
194 device_printf (sc->ndis_dev, "set filter failed: %d\n", error);
195 }
196
197 static int
198 ndis_set_offload(struct ndis_softc *sc)
199 {
200 ndis_task_offload *nto;
201 ndis_task_offload_hdr *ntoh;
202 ndis_task_tcpip_csum *nttc;
203 struct ifnet *ifp;
204 int len, error;
205
206 ifp = &sc->arpcom.ac_if;
207
208 if (!NDIS_INITIALIZED(sc))
209 return(EINVAL);
210
211 /* See if there's anything to set. */
212
213 error = ndis_probe_offload(sc);
214 if (error)
215 return(error);
216
217 if (sc->ndis_hwassist == 0 && ifp->if_capabilities == 0)
218 return(0);
219
220 len = sizeof(ndis_task_offload_hdr) + sizeof(ndis_task_offload) +
221 sizeof(ndis_task_tcpip_csum);
222
223 ntoh = kmalloc(len, M_TEMP, M_NOWAIT|M_ZERO);
224
225 if (ntoh == NULL)
226 return(ENOMEM);
227
228 ntoh->ntoh_vers = NDIS_TASK_OFFLOAD_VERSION;
229 ntoh->ntoh_len = sizeof(ndis_task_offload_hdr);
230 ntoh->ntoh_offset_firsttask = sizeof(ndis_task_offload_hdr);
231 ntoh->ntoh_encapfmt.nef_encaphdrlen = sizeof(struct ether_header);
232 ntoh->ntoh_encapfmt.nef_encap = NDIS_ENCAP_IEEE802_3;
233 ntoh->ntoh_encapfmt.nef_flags = NDIS_ENCAPFLAG_FIXEDHDRLEN;
234
235 nto = (ndis_task_offload *)((char *)ntoh +
236 ntoh->ntoh_offset_firsttask);
237
238 nto->nto_vers = NDIS_TASK_OFFLOAD_VERSION;
239 nto->nto_len = sizeof(ndis_task_offload);
240 nto->nto_task = NDIS_TASK_TCPIP_CSUM;
241 nto->nto_offset_nexttask = 0;
242 nto->nto_taskbuflen = sizeof(ndis_task_tcpip_csum);
243
244 nttc = (ndis_task_tcpip_csum *)nto->nto_taskbuf;
245
246 if (ifp->if_capenable & IFCAP_TXCSUM)
247 nttc->nttc_v4tx = sc->ndis_v4tx;
248
249 if (ifp->if_capenable & IFCAP_RXCSUM)
250 nttc->nttc_v4rx = sc->ndis_v4rx;
251
252 error = ndis_set_info(sc, OID_TCP_TASK_OFFLOAD, ntoh, &len);
253 kfree(ntoh, M_TEMP);
254
255 return(error);
256 }
257
258 static int
259 ndis_probe_offload(struct ndis_softc *sc)
260 {
261 ndis_task_offload *nto;
262 ndis_task_offload_hdr *ntoh;
263 ndis_task_tcpip_csum *nttc = NULL;
264 struct ifnet *ifp;
265 int len, error, dummy;
266
267 ifp = &sc->arpcom.ac_if;
268
269 len = sizeof(dummy);
270 error = ndis_get_info(sc, OID_TCP_TASK_OFFLOAD, &dummy, &len);
271
272 if (error != ENOSPC)
273 return(error);
274
275 ntoh = kmalloc(len, M_TEMP, M_NOWAIT|M_ZERO);
276
277 if (ntoh == NULL)
278 return(ENOMEM);
279
280 ntoh->ntoh_vers = NDIS_TASK_OFFLOAD_VERSION;
281 ntoh->ntoh_len = sizeof(ndis_task_offload_hdr);
282 ntoh->ntoh_encapfmt.nef_encaphdrlen = sizeof(struct ether_header);
283 ntoh->ntoh_encapfmt.nef_encap = NDIS_ENCAP_IEEE802_3;
284 ntoh->ntoh_encapfmt.nef_flags = NDIS_ENCAPFLAG_FIXEDHDRLEN;
285
286 error = ndis_get_info(sc, OID_TCP_TASK_OFFLOAD, ntoh, &len);
287
288 if (error) {
289 kfree(ntoh, M_TEMP);
290 return(error);
291 }
292
293 if (ntoh->ntoh_vers != NDIS_TASK_OFFLOAD_VERSION) {
294 kfree(ntoh, M_TEMP);
295 return(EINVAL);
296 }
297
298 nto = (ndis_task_offload *)((char *)ntoh +
299 ntoh->ntoh_offset_firsttask);
300
301 while (1) {
302 switch (nto->nto_task) {
303 case NDIS_TASK_TCPIP_CSUM:
304 nttc = (ndis_task_tcpip_csum *)nto->nto_taskbuf;
305 break;
306 /* Don't handle these yet. */
307 case NDIS_TASK_IPSEC:
308 case NDIS_TASK_TCP_LARGESEND:
309 default:
310 break;
311 }
312 if (nto->nto_offset_nexttask == 0)
313 break;
314 nto = (ndis_task_offload *)((char *)nto +
315 nto->nto_offset_nexttask);
316 }
317
318 if (nttc == NULL) {
319 kfree(ntoh, M_TEMP);
320 return(ENOENT);
321 }
322
323 sc->ndis_v4tx = nttc->nttc_v4tx;
324 sc->ndis_v4rx = nttc->nttc_v4rx;
325
326 if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_IP_CSUM)
327 sc->ndis_hwassist |= CSUM_IP;
328 if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_TCP_CSUM)
329 sc->ndis_hwassist |= CSUM_TCP;
330 if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_UDP_CSUM)
331 sc->ndis_hwassist |= CSUM_UDP;
332
333 if (sc->ndis_hwassist)
334 ifp->if_capabilities |= IFCAP_TXCSUM;
335
336 if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_IP_CSUM)
337 ifp->if_capabilities |= IFCAP_RXCSUM;
338 if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_TCP_CSUM)
339 ifp->if_capabilities |= IFCAP_RXCSUM;
340 if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_UDP_CSUM)
341 ifp->if_capabilities |= IFCAP_RXCSUM;
342
343 kfree(ntoh, M_TEMP);
344 return(0);
345 }
346
347 /*
348 * Attach the interface. Allocate softc structures, do ifmedia
349 * setup and ethernet/BPF attach.
350 */
351 int
352 ndis_attach(device_t dev)
353 {
354 u_char eaddr[ETHER_ADDR_LEN];
355 struct ndis_softc *sc;
356 struct ifnet *ifp;
357 void *img;
358 int error = 0, len;
359 int i;
360
361 sc = device_get_softc(dev);
362
363 callout_init(&sc->ndis_stat_timer);
364
365 sc->ndis_regvals = ndis_regvals;
366
367 #if __FreeBSD_version < 502113
368 sysctl_ctx_init(&sc->ndis_ctx);
369
370 #endif
371 /* Create sysctl registry nodes */
372 ndis_create_sysctls(sc);
373
374 /* Set up driver image in memory. */
375 img = drv_data;
376 ndis_load_driver((vm_offset_t)img, sc);
377
378 /* Tell the user what version of the API the driver is using. */
379 device_printf(dev, "NDIS API version: %d.%d\n",
380 sc->ndis_chars.nmc_version_major,
381 sc->ndis_chars.nmc_version_minor);
382
383 /* Do resource conversion. */
384 ndis_convert_res(sc);
385
386 /* Install our RX and TX interrupt handlers. */
387 sc->ndis_block.nmb_senddone_func = ndis_txeof;
388 sc->ndis_block.nmb_pktind_func = ndis_rxeof;
389
390 /* Call driver's init routine. */
391 if (ndis_init_nic(sc)) {
392 device_printf (dev, "init handler failed\n");
393 error = ENXIO;
394 goto fail;
395 }
396
397 /*
398 * Get station address from the driver.
399 */
400 len = sizeof(eaddr);
401 ndis_get_info(sc, OID_802_3_CURRENT_ADDRESS, &eaddr, &len);
402
403 bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
404
405 /*
406 * Figure out of we're allowed to use multipacket sends
407 * with this driver, and if so, how many.
408 */
409
410 if (sc->ndis_chars.nmc_sendsingle_func &&
411 sc->ndis_chars.nmc_sendmulti_func == NULL) {
412 sc->ndis_maxpkts = 1;
413 } else {
414 len = sizeof(sc->ndis_maxpkts);
415 ndis_get_info(sc, OID_GEN_MAXIMUM_SEND_PACKETS,
416 &sc->ndis_maxpkts, &len);
417 }
418
419 sc->ndis_txarray = kmalloc(sizeof(ndis_packet *) *
420 sc->ndis_maxpkts, M_DEVBUF, M_WAITOK|M_ZERO);
421
422 sc->ndis_txpending = sc->ndis_maxpkts;
423
424 sc->ndis_oidcnt = 0;
425 /* Get supported oid list. */
426 ndis_get_supported_oids(sc, &sc->ndis_oids, &sc->ndis_oidcnt);
427
428 /* If the NDIS module requested scatter/gather, init maps. */
429 if (sc->ndis_sc)
430 ndis_init_dma(sc);
431
432 /*
433 * See if the OID_802_11_CONFIGURATION OID is
434 * supported by this driver. If it is, then this an 802.11
435 * wireless driver, and we should set up media for wireless.
436 */
437 for (i = 0; i < sc->ndis_oidcnt; i++) {
438 if (sc->ndis_oids[i] == OID_802_11_CONFIGURATION) {
439 sc->ndis_80211++;
440 break;
441 }
442 }
443
444 /* Check for task offload support. */
445 ndis_probe_offload(sc);
446
447 ifp = &sc->arpcom.ac_if;
448 ifp->if_softc = sc;
449 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
450 ifp->if_mtu = ETHERMTU;
451 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
452 ifp->if_ioctl = ndis_ioctl;
453 ifp->if_start = ndis_start;
454 ifp->if_watchdog = ndis_watchdog;
455 ifp->if_init = ndis_init;
456 ifp->if_baudrate = 10000000;
457 ifq_set_maxlen(&ifp->if_snd, 50);
458 ifq_set_ready(&ifp->if_snd);
459 ifp->if_capenable = ifp->if_capabilities;
460 ifp->if_hwassist = sc->ndis_hwassist;
461
462 /* Do media setup */
463 if (sc->ndis_80211) {
464 struct ieee80211com *ic = (void *)ifp;
465 ndis_80211_rates_ex rates;
466 struct ndis_80211_nettype_list *ntl;
467 uint32_t arg;
468 int r;
469
470 ic->ic_phytype = IEEE80211_T_DS;
471 ic->ic_opmode = IEEE80211_M_STA;
472 ic->ic_caps = IEEE80211_C_IBSS;
473 ic->ic_state = IEEE80211_S_ASSOC;
474 ic->ic_modecaps = (1<<IEEE80211_MODE_AUTO);
475 len = 0;
476 r = ndis_get_info(sc, OID_802_11_NETWORK_TYPES_SUPPORTED,
477 NULL, &len);
478 if (r != ENOSPC)
479 goto nonettypes;
480 ntl = kmalloc(len, M_DEVBUF, M_WAITOK|M_ZERO);
481 r = ndis_get_info(sc, OID_802_11_NETWORK_TYPES_SUPPORTED,
482 ntl, &len);
483 if (r != 0) {
484 kfree(ntl, M_DEVBUF);
485 goto nonettypes;
486 }
487
488 for (i = 0; i < ntl->ntl_items; i++) {
489 switch (ntl->ntl_type[i]) {
490 case NDIS_80211_NETTYPE_11FH:
491 case NDIS_80211_NETTYPE_11DS:
492 ic->ic_modecaps |= (1<<IEEE80211_MODE_11B);
493 break;
494 case NDIS_80211_NETTYPE_11OFDM5:
495 ic->ic_modecaps |= (1<<IEEE80211_MODE_11A);
496 break;
497 case NDIS_80211_NETTYPE_11OFDM24:
498 ic->ic_modecaps |= (1<<IEEE80211_MODE_11G);
499 break;
500 default:
501 break;
502 }
503 }
504 kfree(ntl, M_DEVBUF);
505 nonettypes:
506 len = sizeof(rates);
507 bzero((char *)&rates, len);
508 r = ndis_get_info(sc, OID_802_11_SUPPORTED_RATES,
509 (void *)rates, &len);
510 if (r)
511 device_printf (dev, "get rates failed: 0x%x\n", r);
512 /*
513 * Since the supported rates only up to 8 can be supported,
514 * if this is not 802.11b we're just going to be faking it
515 * all up to heck.
516 */
517
518 #define TESTSETRATE(x, y) \
519 do { \
520 int i; \
521 for (i = 0; i < ic->ic_sup_rates[x].rs_nrates; i++) { \
522 if (ic->ic_sup_rates[x].rs_rates[i] == (y)) \
523 break; \
524 } \
525 if (i == ic->ic_sup_rates[x].rs_nrates) { \
526 ic->ic_sup_rates[x].rs_rates[i] = (y); \
527 ic->ic_sup_rates[x].rs_nrates++; \
528 } \
529 } while (0)
530
531 #define SETRATE(x, y) \
532 ic->ic_sup_rates[x].rs_rates[ic->ic_sup_rates[x].rs_nrates] = (y)
533 #define INCRATE(x) \
534 ic->ic_sup_rates[x].rs_nrates++
535
536 ic->ic_curmode = IEEE80211_MODE_AUTO;
537 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11A))
538 ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates = 0;
539 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11B))
540 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates = 0;
541 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G))
542 ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates = 0;
543 for (i = 0; i < len; i++) {
544 switch (rates[i] & IEEE80211_RATE_VAL) {
545 case 2:
546 case 4:
547 case 11:
548 case 10:
549 case 22:
550 if (!(ic->ic_modecaps &
551 (1<<IEEE80211_MODE_11B))) {
552 /* Lazy-init 802.11b. */
553 ic->ic_modecaps |=
554 (1<<IEEE80211_MODE_11B);
555 ic->ic_sup_rates[IEEE80211_MODE_11B].
556 rs_nrates = 0;
557 }
558 SETRATE(IEEE80211_MODE_11B, rates[i]);
559 INCRATE(IEEE80211_MODE_11B);
560 break;
561 default:
562 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11A)) {
563 SETRATE(IEEE80211_MODE_11A, rates[i]);
564 INCRATE(IEEE80211_MODE_11A);
565 }
566 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) {
567 SETRATE(IEEE80211_MODE_11G, rates[i]);
568 INCRATE(IEEE80211_MODE_11G);
569 }
570 break;
571 }
572 }
573
574 /*
575 * If the hardware supports 802.11g, it most
576 * likely supports 802.11b and all of the
577 * 802.11b and 802.11g speeds, so maybe we can
578 * just cheat here. Just how in the heck do
579 * we detect turbo modes, though?
580 */
581 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11B)) {
582 TESTSETRATE(IEEE80211_MODE_11B,
583 IEEE80211_RATE_BASIC|2);
584 TESTSETRATE(IEEE80211_MODE_11B,
585 IEEE80211_RATE_BASIC|4);
586 TESTSETRATE(IEEE80211_MODE_11B,
587 IEEE80211_RATE_BASIC|11);
588 TESTSETRATE(IEEE80211_MODE_11B,
589 IEEE80211_RATE_BASIC|22);
590 }
591 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) {
592 TESTSETRATE(IEEE80211_MODE_11G, 47);
593 TESTSETRATE(IEEE80211_MODE_11G, 72);
594 TESTSETRATE(IEEE80211_MODE_11G, 96);
595 TESTSETRATE(IEEE80211_MODE_11G, 108);
596 }
597 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11A)) {
598 TESTSETRATE(IEEE80211_MODE_11A, 47);
599 TESTSETRATE(IEEE80211_MODE_11A, 72);
600 TESTSETRATE(IEEE80211_MODE_11A, 96);
601 TESTSETRATE(IEEE80211_MODE_11A, 108);
602 }
603 #undef SETRATE
604 #undef INCRATE
605 /*
606 * Taking yet more guesses here.
607 */
608 for (i = 1; i < IEEE80211_CHAN_MAX; i++) {
609 int chanflag = 0;
610
611 if (ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates)
612 chanflag |= IEEE80211_CHAN_G;
613 if (i <= 14)
614 chanflag |= IEEE80211_CHAN_B;
615 if (ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates &&
616 i > 14)
617 chanflag = IEEE80211_CHAN_A;
618 if (chanflag == 0)
619 break;
620 ic->ic_channels[i].ic_freq =
621 ieee80211_ieee2mhz(i, chanflag);
622 ic->ic_channels[i].ic_flags = chanflag;
623 }
624
625 i = sizeof(arg);
626 r = ndis_get_info(sc, OID_802_11_WEP_STATUS, &arg, &i);
627 if (arg != NDIS_80211_WEPSTAT_NOTSUPPORTED)
628 ic->ic_caps |= IEEE80211_C_WEP;
629 i = sizeof(arg);
630 r = ndis_get_info(sc, OID_802_11_POWER_MODE, &arg, &i);
631 if (r == 0)
632 ic->ic_caps |= IEEE80211_C_PMGT;
633 bcopy(eaddr, &ic->ic_myaddr, sizeof(eaddr));
634 ieee80211_ifattach(ic);
635 ieee80211_media_init(ic, ieee80211_media_change,
636 ndis_media_status);
637 ic->ic_ibss_chan = IEEE80211_CHAN_ANYC;
638 ic->ic_bss->ni_chan = ic->ic_ibss_chan;
639 } else {
640 ifmedia_init(&sc->ifmedia, IFM_IMASK, ndis_ifmedia_upd,
641 ndis_ifmedia_sts);
642 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
643 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
644 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_TX, 0, NULL);
645 ifmedia_add(&sc->ifmedia,
646 IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL);
647 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_AUTO, 0, NULL);
648 ifmedia_set(&sc->ifmedia, IFM_ETHER|IFM_AUTO);
649 ether_ifattach(ifp, eaddr, NULL);
650 }
651
652 if (error == 0) {
653 error = bus_setup_intr(dev, sc->ndis_irq, INTR_MPSAFE,
654 ndis_intr, sc,
655 &sc->ndis_intrhand,
656 ifp->if_serializer);
657 if (error) {
658 device_printf(dev, "couldn't set up irq\n");
659 goto fail;
660 }
661 }
662
663
664 /* Override the status handler so we can detect link changes. */
665 sc->ndis_block.nmb_status_func = ndis_linksts;
666 sc->ndis_block.nmb_statusdone_func = ndis_linksts_done;
667 fail:
668 if (error)
669 ndis_detach(dev);
670 else
671 /* We're done talking to the NIC for now; halt it. */
672 ndis_halt_nic(sc);
673
674 return(error);
675 }
676
677 /*
678 * Shutdown hardware and free up resources. This can be called any
679 * time after the mutex has been initialized. It is called in both
680 * the error case in attach and the normal detach case so it needs
681 * to be careful about only freeing resources that have actually been
682 * allocated.
683 */
684 int
685 ndis_detach(device_t dev)
686 {
687 struct ndis_softc *sc;
688 struct ifnet *ifp;
689
690 sc = device_get_softc(dev);
691 ifp = &sc->arpcom.ac_if;
692
693 ifp->if_flags &= ~IFF_UP;
694
695 if (device_is_attached(dev)) {
696 lwkt_serialize_enter(ifp->if_serializer);
697 ndis_stop(sc);
698 bus_teardown_intr(dev, sc->ndis_irq, sc->ndis_intrhand);
699 lwkt_serialize_exit(ifp->if_serializer);
700
701 if (sc->ndis_80211)
702 ieee80211_ifdetach(&sc->ic);
703 else
704 ether_ifdetach(ifp);
705 }
706 bus_generic_detach(dev);
707
708 if (sc->ndis_irq)
709 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ndis_irq);
710 if (sc->ndis_res_io)
711 bus_release_resource(dev, SYS_RES_IOPORT,
712 sc->ndis_io_rid, sc->ndis_res_io);
713 if (sc->ndis_res_mem)
714 bus_release_resource(dev, SYS_RES_MEMORY,
715 sc->ndis_mem_rid, sc->ndis_res_mem);
716 if (sc->ndis_res_altmem)
717 bus_release_resource(dev, SYS_RES_MEMORY,
718 sc->ndis_altmem_rid, sc->ndis_res_altmem);
719
720 if (sc->ndis_sc)
721 ndis_destroy_dma(sc);
722
723 ndis_unload_driver((void *)ifp);
724
725 if (sc->ndis_iftype == PCIBus)
726 bus_dma_tag_destroy(sc->ndis_parent_tag);
727
728 #if __FreeBSD_version < 502113
729 sysctl_ctx_free(&sc->ndis_ctx);
730 #endif
731 return(0);
732 }
733
734 int
735 ndis_suspend(device_t dev)
736 {
737 struct ndis_softc *sc;
738 struct ifnet *ifp;
739
740 sc = device_get_softc(dev);
741 ifp = &sc->arpcom.ac_if;
742 lwkt_serialize_enter(ifp->if_serializer);
743
744 #ifdef notdef
745 if (NDIS_INITIALIZED(sc))
746 ndis_stop(sc);
747 #endif
748 lwkt_serialize_exit(ifp->if_serializer);
749 return(0);
750 }
751
752 int
753 ndis_resume(device_t dev)
754 {
755 struct ndis_softc *sc;
756 struct ifnet *ifp;
757
758 sc = device_get_softc(dev);
759 ifp = &sc->arpcom.ac_if;
760
761 lwkt_serialize_enter(ifp->if_serializer);
762 if (NDIS_INITIALIZED(sc))
763 ndis_init(sc);
764 lwkt_serialize_exit(ifp->if_serializer);
765
766 return(0);
767 }
768
769 /*
770 * A frame has been uploaded: pass the resulting mbuf chain up to
771 * the higher level protocols.
772 *
773 * When handling received NDIS packets, the 'status' field in the
774 * out-of-band portion of the ndis_packet has special meaning. In the
775 * most common case, the underlying NDIS driver will set this field
776 * to NDIS_STATUS_SUCCESS, which indicates that it's ok for us to
777 * take posession of it. We then change the status field to
778 * NDIS_STATUS_PENDING to tell the driver that we now own the packet,
779 * and that we will return it at some point in the future via the
780 * return packet handler.
781 *
782 * If the driver hands us a packet with a status of NDIS_STATUS_RESOURCES,
783 * this means the driver is running out of packet/buffer resources and
784 * wants to maintain ownership of the packet. In this case, we have to
785 * copy the packet data into local storage and let the driver keep the
786 * packet.
787 */
788 __stdcall static void
789 ndis_rxeof(ndis_handle adapter, ndis_packet **packets, uint32_t pktcnt)
790 {
791 struct ndis_softc *sc;
792 ndis_miniport_block *block;
793 ndis_packet *p;
794 uint32_t s;
795 ndis_tcpip_csum *csum;
796 struct ifnet *ifp;
797 struct mbuf *m0, *m;
798 int i;
799
800 block = (ndis_miniport_block *)adapter;
801 sc = (struct ndis_softc *)(block->nmb_ifp);
802 ifp = block->nmb_ifp;
803
804 for (i = 0; i < pktcnt; i++) {
805 p = packets[i];
806 /* Stash the softc here so ptom can use it. */
807 p->np_softc = sc;
808 if (ndis_ptom(&m0, p)) {
809 device_printf (sc->ndis_dev, "ptom failed\n");
810 if (p->np_oob.npo_status == NDIS_STATUS_SUCCESS)
811 ndis_return_packet(sc, p);
812 } else {
813 if (p->np_oob.npo_status == NDIS_STATUS_RESOURCES) {
814 m = m_dup(m0, MB_DONTWAIT);
815 /*
816 * NOTE: we want to destroy the mbuf here, but
817 * we don't actually want to return it to the
818 * driver via the return packet handler. By
819 * bumping np_refcnt, we can prevent the
820 * ndis_return_packet() routine from actually
821 * doing anything.
822 */
823 p->np_refcnt++;
824 m_freem(m0);
825 if (m == NULL)
826 ifp->if_ierrors++;
827 else
828 m0 = m;
829 } else
830 p->np_oob.npo_status = NDIS_STATUS_PENDING;
831 m0->m_pkthdr.rcvif = ifp;
832 ifp->if_ipackets++;
833
834 /* Deal with checksum offload. */
835
836 if (ifp->if_capenable & IFCAP_RXCSUM &&
837 p->np_ext.npe_info[ndis_tcpipcsum_info] != NULL) {
838 s = (uintptr_t)
839 p->np_ext.npe_info[ndis_tcpipcsum_info];
840 csum = (ndis_tcpip_csum *)&s;
841 if (csum->u.ntc_rxflags &
842 NDIS_RXCSUM_IP_PASSED)
843 m0->m_pkthdr.csum_flags |=
844 CSUM_IP_CHECKED|CSUM_IP_VALID;
845 if (csum->u.ntc_rxflags &
846 (NDIS_RXCSUM_TCP_PASSED |
847 NDIS_RXCSUM_UDP_PASSED)) {
848 m0->m_pkthdr.csum_flags |=
849 CSUM_DATA_VALID|CSUM_PSEUDO_HDR|
850 CSUM_FRAG_NOT_CHECKED;
851 m0->m_pkthdr.csum_data = 0xFFFF;
852 }
853 }
854
855 ifp->if_input(ifp, m0);
856 }
857 }
858 }
859
860 /*
861 * A frame was downloaded to the chip. It's safe for us to clean up
862 * the list buffers.
863 */
864 __stdcall static void
865 ndis_txeof(ndis_handle adapter, ndis_packet *packet, ndis_status status)
866 {
867 struct ndis_softc *sc;
868 ndis_miniport_block *block;
869 struct ifnet *ifp;
870 int idx;
871 struct mbuf *m;
872
873 block = (ndis_miniport_block *)adapter;
874 sc = (struct ndis_softc *)block->nmb_ifp;
875 ifp = block->nmb_ifp;
876
877 m = packet->np_m0;
878 idx = packet->np_txidx;
879 if (sc->ndis_sc)
880 bus_dmamap_unload(sc->ndis_ttag, sc->ndis_tmaps[idx]);
881
882 ndis_free_packet(packet);
883 m_freem(m);
884
885 sc->ndis_txarray[idx] = NULL;
886 sc->ndis_txpending++;
887
888 if (status == NDIS_STATUS_SUCCESS)
889 ifp->if_opackets++;
890 else
891 ifp->if_oerrors++;
892 ifp->if_timer = 0;
893 ifp->if_flags &= ~IFF_OACTIVE;
894
895 ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE);
896 }
897
898 __stdcall static void
899 ndis_linksts(ndis_handle adapter, ndis_status status, void *sbuf, uint32_t slen)
900 {
901 ndis_miniport_block *block;
902
903 block = adapter;
904 block->nmb_getstat = status;
905 }
906
907 __stdcall static void
908 ndis_linksts_done(ndis_handle adapter)
909 {
910 ndis_miniport_block *block;
911 struct ndis_softc *sc;
912 struct ifnet *ifp;
913
914 block = adapter;
915 ifp = block->nmb_ifp;
916 sc = ifp->if_softc;
917
918 if (!NDIS_INITIALIZED(sc))
919 return;
920
921 switch (block->nmb_getstat) {
922 case NDIS_STATUS_MEDIA_CONNECT:
923 ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE);
924 ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE);
925 break;
926 case NDIS_STATUS_MEDIA_DISCONNECT:
927 if (sc->ndis_link)
928 ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE);
929 break;
930 default:
931 break;
932 }
933 }
934
935 static void
936 ndis_intrtask(void *arg)
937 {
938 struct ndis_softc *sc;
939 struct ifnet *ifp;
940 uint8_t irql;
941
942 sc = arg;
943 ifp = &sc->arpcom.ac_if;
944
945 lwkt_serialize_enter(ifp->if_serializer);
946 irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
947 ndis_intrhand(sc);
948 FASTCALL1(hal_lower_irql, irql);
949 ndis_enable_intr(sc);
950 lwkt_serialize_exit(ifp->if_serializer);
951 }
952
953 static void
954 ndis_intr(void *arg)
955 {
956 struct ndis_softc *sc;
957 struct ifnet *ifp;
958 int is_our_intr = 0;
959 int call_isr = 0;
960
961 sc = arg;
962 ifp = &sc->arpcom.ac_if;
963
964 if (sc->ndis_block.nmb_miniportadapterctx == NULL)
965 return;
966
967 if (sc->ndis_block.nmb_interrupt->ni_isrreq == TRUE)
968 ndis_isr(sc, &is_our_intr, &call_isr);
969 else {
970 ndis_disable_intr(sc);
971 call_isr = 1;
972 }
973
974 if ((is_our_intr || call_isr))
975 ndis_sched(ndis_intrtask, ifp, NDIS_SWI);
976 }
977
978 static void
979 ndis_tick(void *xsc)
980 {
981 struct ndis_softc *sc;
982
983 sc = xsc;
984
985 ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE);
986 callout_reset(&sc->ndis_stat_timer,
987 hz *sc->ndis_block.nmb_checkforhangsecs, ndis_tick, sc);
988 }
989
990 static void
991 ndis_ticktask(void *xsc)
992 {
993 struct ndis_softc *sc;
994 struct ifnet *ifp;
995 __stdcall ndis_checkforhang_handler hangfunc;
996 uint8_t rval;
997 ndis_media_state linkstate;
998 int error, len;
999
1000 sc = xsc;
1001 ifp = &sc->arpcom.ac_if;
1002
1003 lwkt_serialize_enter(ifp->if_serializer);
1004 hangfunc = sc->ndis_chars.nmc_checkhang_func;
1005
1006 if (hangfunc != NULL) {
1007 rval = hangfunc(sc->ndis_block.nmb_miniportadapterctx);
1008 if (rval == TRUE) {
1009 ndis_reset_nic(sc);
1010 lwkt_serialize_exit(ifp->if_serializer);
1011 return;
1012 }
1013 }
1014
1015 len = sizeof(linkstate);
1016 error = ndis_get_info(sc, OID_GEN_MEDIA_CONNECT_STATUS,
1017 (void *)&linkstate, &len);
1018
1019 if (sc->ndis_link == 0 && linkstate == nmc_connected) {
1020 device_printf(sc->ndis_dev, "link up\n");
1021 sc->ndis_link = 1;
1022 if (sc->ndis_80211)
1023 ndis_getstate_80211(sc);
1024 #ifdef LINK_STATE_UP
1025 sc->arpcom.ac_if.if_link_state = LINK_STATE_UP;
1026 rt_ifmsg(&(sc->arpcom.ac_if));
1027 #endif /* LINK_STATE_UP */
1028 }
1029
1030 if (sc->ndis_link == 1 && linkstate == nmc_disconnected) {
1031 device_printf(sc->ndis_dev, "link down\n");
1032 sc->ndis_link = 0;
1033 #ifdef LINK_STATE_DOWN
1034 sc->arpcom.ac_if.if_link_state = LINK_STATE_DOWN;
1035 rt_ifmsg(&(sc->arpcom.ac_if));
1036 #endif /* LINK_STATE_DOWN */
1037 }
1038
1039 lwkt_serialize_exit(ifp->if_serializer);
1040 }
1041
1042 static void
1043 ndis_map_sclist(void *arg, bus_dma_segment_t *segs, int nseg,
1044 bus_size_t mapsize, int error)
1045 {
1046 struct ndis_sc_list *sclist;
1047 int i;
1048
1049 if (error || arg == NULL)
1050 return;
1051
1052 sclist = arg;
1053
1054 sclist->nsl_frags = nseg;
1055
1056 for (i = 0; i < nseg; i++) {
1057 sclist->nsl_elements[i].nse_addr.np_quad = segs[i].ds_addr;
1058 sclist->nsl_elements[i].nse_len = segs[i].ds_len;
1059 }
1060 }
1061
1062 static void
1063 ndis_starttask(void *arg)
1064 {
1065 struct ifnet *ifp;
1066
1067 ifp = arg;
1068 if (!ifq_is_empty(&ifp->if_snd))
1069 if_devstart(ifp);
1070 }
1071
1072 /*
1073 * Main transmit routine. To make NDIS drivers happy, we need to
1074 * transform mbuf chains into NDIS packets and feed them to the
1075 * send packet routines. Most drivers allow you to send several
1076 * packets at once (up to the maxpkts limit). Unfortunately, rather
1077 * that accepting them in the form of a linked list, they expect
1078 * a contiguous array of pointers to packets.
1079 *
1080 * For those drivers which use the NDIS scatter/gather DMA mechanism,
1081 * we need to perform busdma work here. Those that use map registers
1082 * will do the mapping themselves on a buffer by buffer basis.
1083 */
1084
1085 static void
1086 ndis_start(struct ifnet *ifp)
1087 {
1088 struct ndis_softc *sc;
1089 struct mbuf *m = NULL;
1090 ndis_packet **p0 = NULL, *p = NULL;
1091 ndis_tcpip_csum *csum;
1092 int pcnt = 0;
1093
1094 sc = ifp->if_softc;
1095
1096 if (!sc->ndis_link || ifp->if_flags & IFF_OACTIVE) {
1097 return;
1098 }
1099
1100 p0 = &sc->ndis_txarray[sc->ndis_txidx];
1101
1102 while(sc->ndis_txpending) {
1103 m = ifq_dequeue(&ifp->if_snd, NULL);
1104 if (m == NULL)
1105 break;
1106
1107 sc->ndis_txarray[sc->ndis_txidx] = NULL;
1108
1109 if (ndis_mtop(m, &sc->ndis_txarray[sc->ndis_txidx])) {
1110 m_freem(m);
1111 return;
1112 }
1113
1114 /*
1115 * Save pointer to original mbuf
1116 * so we can free it later.
1117 */
1118
1119 p = sc->ndis_txarray[sc->ndis_txidx];
1120 p->np_txidx = sc->ndis_txidx;
1121 p->np_m0 = m;
1122 p->np_oob.npo_status = NDIS_STATUS_PENDING;
1123
1124 /*
1125 * Do scatter/gather processing, if driver requested it.
1126 */
1127 if (sc->ndis_sc) {
1128 bus_dmamap_load_mbuf(sc->ndis_ttag,
1129 sc->ndis_tmaps[sc->ndis_txidx], m,
1130 ndis_map_sclist, &p->np_sclist, BUS_DMA_NOWAIT);
1131 bus_dmamap_sync(sc->ndis_ttag,
1132 sc->ndis_tmaps[sc->ndis_txidx],
1133 BUS_DMASYNC_PREREAD);
1134 p->np_ext.npe_info[ndis_sclist_info] = &p->np_sclist;
1135 }
1136
1137 /* Handle checksum offload. */
1138
1139 if (ifp->if_capenable & IFCAP_TXCSUM &&
1140 m->m_pkthdr.csum_flags) {
1141 csum = (ndis_tcpip_csum *)
1142 &p->np_ext.npe_info[ndis_tcpipcsum_info];
1143 csum->u.ntc_txflags = NDIS_TXCSUM_DO_IPV4;
1144 if (m->m_pkthdr.csum_flags & CSUM_IP)
1145 csum->u.ntc_txflags |= NDIS_TXCSUM_DO_IP;
1146 if (m->m_pkthdr.csum_flags & CSUM_TCP)
1147 csum->u.ntc_txflags |= NDIS_TXCSUM_DO_TCP;
1148 if (m->m_pkthdr.csum_flags & CSUM_UDP)
1149 csum->u.ntc_txflags |= NDIS_TXCSUM_DO_UDP;
1150 p->np_private.npp_flags = NDIS_PROTOCOL_ID_TCP_IP;
1151 }
1152
1153 NDIS_INC(sc);
1154 sc->ndis_txpending--;
1155
1156 pcnt++;
1157
1158 /*
1159 * If there's a BPF listener, bounce a copy of this frame
1160 * to him.
1161 */
1162
1163 BPF_MTAP(ifp, m);
1164
1165 /*
1166 * The array that p0 points to must appear contiguous,
1167 * so we must not wrap past the end of sc->ndis_txarray[].
1168 * If it looks like we're about to wrap, break out here
1169 * so the this batch of packets can be transmitted, then
1170 * wait for txeof to ask us to send the rest.
1171 */
1172
1173 if (sc->ndis_txidx == 0)
1174 break;
1175 }
1176
1177 if (pcnt == 0) {
1178 return;
1179 }
1180
1181 if (sc->ndis_txpending == 0)
1182 ifp->if_flags |= IFF_OACTIVE;
1183
1184 /*
1185 * Set a timeout in case the chip goes out to lunch.
1186 */
1187 ifp->if_timer = 5;
1188
1189 if (sc->ndis_maxpkts == 1)
1190 ndis_send_packet(sc, p);
1191 else
1192 ndis_send_packets(sc, p0, pcnt);
1193 }
1194
1195 static void
1196 ndis_init(void *xsc)
1197 {
1198 struct ndis_softc *sc = xsc;
1199 struct ifnet *ifp = &sc->arpcom.ac_if;
1200 int i, error;
1201
1202 /*
1203 * Avoid reintializing the link unnecessarily.
1204 * This should be dealt with in a better way by
1205 * fixing the upper layer modules so they don't
1206 * call ifp->if_init() quite as often.
1207 */
1208 if (sc->ndis_link && sc->ndis_skip)
1209 return;
1210
1211 /*
1212 * Cancel pending I/O and free all RX/TX buffers.
1213 */
1214 ndis_stop(sc);
1215 if (ndis_init_nic(sc))
1216 return;
1217
1218 /* Init our MAC address */
1219
1220 /* Program the packet filter */
1221
1222 sc->ndis_filter = NDIS_PACKET_TYPE_DIRECTED;
1223
1224 if (ifp->if_flags & IFF_BROADCAST)
1225 sc->ndis_filter |= NDIS_PACKET_TYPE_BROADCAST;
1226
1227 if (ifp->if_flags & IFF_PROMISC)
1228 sc->ndis_filter |= NDIS_PACKET_TYPE_PROMISCUOUS;
1229
1230 i = sizeof(sc->ndis_filter);
1231
1232 error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER,
1233 &sc->ndis_filter, &i);
1234
1235 if (error)
1236 device_printf (sc->ndis_dev, "set filter failed: %d\n", error);
1237
1238 /*
1239 * Program the multicast filter, if necessary.
1240 */
1241 ndis_setmulti(sc);
1242
1243 /* Setup task offload. */
1244 ndis_set_offload(sc);
1245
1246 /* Enable interrupts. */
1247 ndis_enable_intr(sc);
1248
1249 if (sc->ndis_80211)
1250 ndis_setstate_80211(sc);
1251
1252 sc->ndis_txidx = 0;
1253 sc->ndis_txpending = sc->ndis_maxpkts;
1254 sc->ndis_link = 0;
1255
1256 ifp->if_flags |= IFF_RUNNING;
1257 ifp->if_flags &= ~IFF_OACTIVE;
1258
1259 /*
1260 * Some drivers don't set this value. The NDIS spec says
1261 * the default checkforhang timeout is "approximately 2
1262 * seconds." We use 3 seconds, because it seems for some
1263 * drivers, exactly 2 seconds is too fast.
1264 */
1265
1266 if (sc->ndis_block.nmb_checkforhangsecs == 0)
1267 sc->ndis_block.nmb_checkforhangsecs = 3;
1268
1269 callout_reset(&sc->ndis_stat_timer,
1270 hz * sc->ndis_block.nmb_checkforhangsecs, ndis_tick, sc);
1271 }
1272
1273 /*
1274 * Set media options.
1275 */
1276 static int
1277 ndis_ifmedia_upd(struct ifnet *ifp)
1278 {
1279 struct ndis_softc *sc;
1280
1281 sc = ifp->if_softc;
1282
1283 if (NDIS_INITIALIZED(sc))
1284 ndis_init(sc);
1285
1286 return(0);
1287 }
1288
1289 /*
1290 * Report current media status.
1291 */
1292 static void
1293 ndis_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1294 {
1295 struct ndis_softc *sc;
1296 uint32_t media_info;
1297 ndis_media_state linkstate;
1298 int error, len;
1299
1300 ifmr->ifm_status = IFM_AVALID;
1301 ifmr->ifm_active = IFM_ETHER;
1302 sc = ifp->if_softc;
1303
1304 if (!NDIS_INITIALIZED(sc))
1305 return;
1306
1307 len = sizeof(linkstate);
1308 error = ndis_get_info(sc, OID_GEN_MEDIA_CONNECT_STATUS,
1309 (void *)&linkstate, &len);
1310
1311 len = sizeof(media_info);
1312 error = ndis_get_info(sc, OID_GEN_LINK_SPEED,
1313 (void *)&media_info, &len);
1314
1315 if (linkstate == nmc_connected)
1316 ifmr->ifm_status |= IFM_ACTIVE;
1317
1318 switch(media_info) {
1319 case 100000:
1320 ifmr->ifm_active |= IFM_10_T;
1321 break;
1322 case 1000000:
1323 ifmr->ifm_active |= IFM_100_TX;
1324 break;
1325 case 10000000:
1326 ifmr->ifm_active |= IFM_1000_T;
1327 break;
1328 default:
1329 device_printf(sc->ndis_dev, "unknown speed: %d\n", media_info);
1330 break;
1331 }
1332 }
1333
1334 static void
1335 ndis_setstate_80211(struct ndis_softc *sc)
1336 {
1337 struct ieee80211com *ic;
1338 ndis_80211_ssid ssid;
1339 ndis_80211_config config;
1340 ndis_80211_wep wep;
1341 int i, rval = 0, len;
1342 uint32_t arg;
1343 struct ifnet *ifp;
1344
1345 ic = &sc->ic;
1346 ifp = &sc->ic.ic_ac.ac_if;
1347
1348 if (!NDIS_INITIALIZED(sc))
1349 return;
1350
1351 /* Set network infrastructure mode. */
1352
1353 len = sizeof(arg);
1354 if (ic->ic_opmode == IEEE80211_M_IBSS)
1355 arg = NDIS_80211_NET_INFRA_IBSS;
1356 else
1357 arg = NDIS_80211_NET_INFRA_BSS;
1358
1359 rval = ndis_set_info(sc, OID_802_11_INFRASTRUCTURE_MODE, &arg, &len);
1360
1361 if (rval)
1362 device_printf (sc->ndis_dev, "set infra failed: %d\n", rval);
1363
1364 /* Set WEP */
1365
1366 #ifdef IEEE80211_F_PRIVACY
1367 if (ic->ic_flags & IEEE80211_F_PRIVACY) {
1368 #else
1369 if (ic->ic_wep_mode >= IEEE80211_WEP_ON) {
1370 #endif
1371 for (i = 0; i < IEEE80211_WEP_NKID; i++) {
1372 if (ic->ic_nw_keys[i].wk_keylen) {
1373 bzero((char *)&wep, sizeof(wep));
1374 wep.nw_keylen = ic->ic_nw_keys[i].wk_keylen;
1375 #ifdef notdef
1376 /* 5 and 13 are the only valid key lengths */
1377 if (ic->ic_nw_keys[i].wk_len < 5)
1378 wep.nw_keylen = 5;
1379 else if (ic->ic_nw_keys[i].wk_len > 5 &&
1380 ic->ic_nw_keys[i].wk_len < 13)
1381 wep.nw_keylen = 13;
1382 #endif
1383 wep.nw_keyidx = i;
1384 wep.nw_length = (sizeof(uint32_t) * 3)
1385 + wep.nw_keylen;
1386 if (i == ic->ic_def_txkey)
1387 wep.nw_keyidx |= NDIS_80211_WEPKEY_TX;
1388 bcopy(ic->ic_nw_keys[i].wk_key,
1389 wep.nw_keydata, wep.nw_length);
1390 len = sizeof(wep);
1391 rval = ndis_set_info(sc,
1392 OID_802_11_ADD_WEP, &wep, &len);
1393 if (rval)
1394 device_printf(sc->ndis_dev,
1395 "set wepkey failed: %d\n", rval);
1396 }
1397 }
1398 arg = NDIS_80211_WEPSTAT_ENABLED;
1399 len = sizeof(arg);
1400 rval = ndis_set_info(sc, OID_802_11_WEP_STATUS, &arg, &len);
1401 if (rval)
1402 device_printf(sc->ndis_dev,
1403 "enable WEP failed: %d\n", rval);
1404 #ifndef IEEE80211_F_PRIVACY
1405 if (ic->ic_wep_mode != IEEE80211_WEP_8021X &&
1406 ic->ic_wep_mode != IEEE80211_WEP_ON)
1407 arg = NDIS_80211_PRIVFILT_ACCEPTALL;
1408 else
1409 #endif
1410 arg = NDIS_80211_PRIVFILT_8021XWEP;
1411 len = sizeof(arg);
1412 rval = ndis_set_info(sc, OID_802_11_PRIVACY_FILTER, &arg, &len);
1413 #ifdef IEEE80211_WEP_8021X /*IEEE80211_F_WEPON*/
1414 /* Accept that we only have "shared" and 802.1x modes. */
1415 if (rval == 0) {
1416 if (arg == NDIS_80211_PRIVFILT_ACCEPTALL)
1417 ic->ic_wep_mode = IEEE80211_WEP_MIXED;
1418 else
1419 ic->ic_wep_mode = IEEE80211_WEP_8021X;
1420 }
1421 #endif
1422 arg = NDIS_80211_AUTHMODE_OPEN;
1423 } else {
1424 arg = NDIS_80211_WEPSTAT_DISABLED;
1425 len = sizeof(arg);
1426 ndis_set_info(sc, OID_802_11_WEP_STATUS, &arg, &len);
1427 arg = NDIS_80211_AUTHMODE_OPEN;
1428 }
1429
1430 len = sizeof(arg);
1431 rval = ndis_set_info(sc, OID_802_11_AUTHENTICATION_MODE, &arg, &len);
1432
1433 #ifdef notyet
1434 if (rval)
1435 device_printf (sc->ndis_dev, "set auth failed: %d\n", rval);
1436 #endif
1437
1438 #ifdef notyet
1439 /* Set network type. */
1440
1441 arg = 0;
1442
1443 switch (ic->ic_curmode) {
1444 case IEEE80211_MODE_11A:
1445 arg = NDIS_80211_NETTYPE_11OFDM5;
1446 break;
1447 case IEEE80211_MODE_11B:
1448 arg = NDIS_80211_NETTYPE_11DS;
1449 break;
1450 case IEEE80211_MODE_11G:
1451 arg = NDIS_80211_NETTYPE_11OFDM24;
1452 break;
1453 default:
1454 device_printf(sc->ndis_dev, "unknown mode: %d\n",
1455 ic->ic_curmode);
1456 }
1457
1458 if (arg) {
1459 len = sizeof(arg);
1460 rval = ndis_set_info(sc, OID_802_11_NETWORK_TYPE_IN_USE,
1461 &arg, &len);
1462 if (rval)
1463 device_printf (sc->ndis_dev,
1464 "set nettype failed: %d\n", rval);
1465 }
1466 #endif
1467
1468 len = sizeof(config);
1469 bzero((char *)&config, len);
1470 config.nc_length = len;
1471 config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh);
1472 rval = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &len);
1473
1474 /*
1475 * Some drivers expect us to initialize these values, so
1476 * provide some defaults.
1477 */
1478 if (config.nc_beaconperiod == 0)
1479 config.nc_beaconperiod = 100;
1480 if (config.nc_atimwin == 0)
1481 config.nc_atimwin = 100;
1482 if (config.nc_fhconfig.ncf_dwelltime == 0)
1483 config.nc_fhconfig.ncf_dwelltime = 200;
1484
1485 if (rval == 0 && ic->ic_ibss_chan != IEEE80211_CHAN_ANYC) {
1486 int chan, chanflag;
1487
1488 chan = ieee80211_chan2ieee(ic, ic->ic_ibss_chan);
1489 chanflag = config.nc_dsconfig > 2500000 ? IEEE80211_CHAN_2GHZ :
1490 IEEE80211_CHAN_5GHZ;
1491 if (chan != ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0)) {
1492 config.nc_dsconfig =
1493 ic->ic_ibss_chan->ic_freq * 1000;
1494 ic->ic_bss->ni_chan = ic->ic_ibss_chan;
1495 len = sizeof(config);
1496 config.nc_length = len;
1497 config.nc_fhconfig.ncf_length =
1498 sizeof(ndis_80211_config_fh);
1499 rval = ndis_set_info(sc, OID_802_11_CONFIGURATION,
1500 &config, &len);
1501 if (rval)
1502 device_printf(sc->ndis_dev, "couldn't change "
1503 "DS config to %ukHz: %d\n",
1504 config.nc_dsconfig, rval);
1505 }
1506 } else if (rval)
1507 device_printf(sc->ndis_dev, "couldn't retrieve "
1508 "channel info: %d\n", rval);
1509
1510 /* Set SSID -- always do this last. */
1511
1512 len = sizeof(ssid);
1513 bzero((char *)&ssid, len);
1514 ssid.ns_ssidlen = ic->ic_des_esslen;
1515 if (ssid.ns_ssidlen == 0) {
1516 ssid.ns_ssidlen = 1;
1517 } else
1518 bcopy(ic->ic_des_essid, ssid.ns_ssid, ssid.ns_ssidlen);
1519 rval = ndis_set_info(sc, OID_802_11_SSID, &ssid, &len);
1520
1521 if (rval)
1522 device_printf (sc->ndis_dev, "set ssid failed: %d\n", rval);
1523 }
1524
1525 static void
1526 ndis_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1527 {
1528 struct ieee80211com *ic = (void *)ifp; /* XXX */
1529 struct ieee80211_node *ni = NULL;
1530
1531 imr->ifm_status = IFM_AVALID;
1532 imr->ifm_active = IFM_IEEE80211;
1533 if (ic->ic_state == IEEE80211_S_RUN)
1534 imr->ifm_status |= IFM_ACTIVE;
1535 imr->ifm_active |= IFM_AUTO;
1536 switch (ic->ic_opmode) {
1537 case IEEE80211_M_STA:
1538 ni = ic->ic_bss;
1539 /* calculate rate subtype */
1540 imr->ifm_active |= ieee80211_rate2media(ic,
1541 ni->ni_rates.rs_rates[ni->ni_txrate], ic->ic_curmode);
1542 break;
1543 case IEEE80211_M_IBSS:
1544 ni = ic->ic_bss;
1545 /* calculate rate subtype */
1546 imr->ifm_active |= ieee80211_rate2media(ic,
1547 ni->ni_rates.rs_rates[ni->ni_txrate], ic->ic_curmode);
1548 imr->ifm_active |= IFM_IEEE80211_ADHOC;
1549 break;
1550 case IEEE80211_M_AHDEMO:
1551 /* should not come here */
1552 break;
1553 case IEEE80211_M_HOSTAP:
1554 imr->ifm_active |= IFM_IEEE80211_HOSTAP;
1555 break;
1556 case IEEE80211_M_MONITOR:
1557 imr->ifm_active |= IFM_IEEE80211_MONITOR;
1558 break;
1559 }
1560 switch (ic->ic_curmode) {
1561 case IEEE80211_MODE_11A:
1562 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11A);
1563 break;
1564 case IEEE80211_MODE_11B:
1565 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11B);
1566 break;
1567 case IEEE80211_MODE_11G:
1568 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11G);
1569 break;
1570 case IEEE80211_MODE_TURBO_A:
1571 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11A)
1572 | IFM_IEEE80211_TURBO;
1573 break;
1574 }
1575 }
1576
1577 static int
1578 ndis_get_assoc(struct ndis_softc *sc, ndis_wlan_bssid_ex **assoc)
1579 {
1580 ndis_80211_bssid_list_ex *bl;
1581 ndis_wlan_bssid_ex *bs;
1582 ndis_80211_macaddr bssid;
1583 int i, len, error;
1584
1585 if (!sc->ndis_link)
1586 return(ENOENT);
1587
1588 len = sizeof(bssid);
1589 error = ndis_get_info(sc, OID_802_11_BSSID, &bssid, &len);
1590 if (error) {
1591 device_printf(sc->ndis_dev, "failed to get bssid\n");
1592 return(ENOENT);
1593 }
1594 len = 0;
1595 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, NULL, &len);
1596 if (error != ENOSPC) {
1597 device_printf(sc->ndis_dev, "bssid_list failed\n");
1598 return (error);
1599 }
1600
1601 bl = kmalloc(len, M_TEMP, M_NOWAIT|M_ZERO);
1602 if (bl == NULL)
1603 return (ENOMEM);
1604 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, bl, &len);
1605 if (error) {
1606 kfree(bl, M_TEMP);
1607 device_printf(sc->ndis_dev, "bssid_list failed\n");
1608 return (error);
1609 }
1610
1611 bs = (ndis_wlan_bssid_ex *)&bl->nblx_bssid[0];
1612 for (i = 0; i < bl->nblx_items; i++) {
1613 if (bcmp(bs->nwbx_macaddr, bssid, sizeof(bssid)) == 0) {
1614 *assoc = kmalloc(bs->nwbx_len, M_TEMP, M_NOWAIT);
1615 if (*assoc == NULL) {
1616 kfree(bl, M_TEMP);
1617 return(ENOMEM);
1618 }
1619 bcopy((char *)bs, (char *)*assoc, bs->nwbx_len);
1620 kfree(bl, M_TEMP);
1621 return(0);
1622 }
1623 bs = (ndis_wlan_bssid_ex *)((char *)bs + bs->nwbx_len);
1624 }
1625
1626 kfree(bl, M_TEMP);
1627 return(ENOENT);
1628 }
1629
1630 static void
1631 ndis_getstate_80211(struct ndis_softc *sc)
1632 {
1633 struct ieee80211com *ic;
1634 ndis_80211_ssid ssid;
1635 ndis_80211_config config;
1636 ndis_wlan_bssid_ex *bs;
1637 int rval, len, i = 0;
1638 uint32_t arg;
1639 struct ifnet *ifp;
1640
1641 ic = &sc->ic;
1642 ifp = &sc->ic.ic_ac.ac_if;
1643
1644 if (!NDIS_INITIALIZED(sc))
1645 return;
1646
1647 if (sc->ndis_link)
1648 ic->ic_state = IEEE80211_S_RUN;
1649 else
1650 ic->ic_state = IEEE80211_S_ASSOC;
1651
1652
1653 /*
1654 * If we're associated, retrieve info on the current bssid.
1655 */
1656 if ((rval = ndis_get_assoc(sc, &bs)) == 0) {
1657 switch(bs->nwbx_nettype) {
1658 case NDIS_80211_NETTYPE_11FH:
1659 case NDIS_80211_NETTYPE_11DS:
1660 ic->ic_curmode = IEEE80211_MODE_11B;
1661 break;
1662 case NDIS_80211_NETTYPE_11OFDM5:
1663 ic->ic_curmode = IEEE80211_MODE_11A;
1664 break;
1665 case NDIS_80211_NETTYPE_11OFDM24:
1666 ic->ic_curmode = IEEE80211_MODE_11G;
1667 break;
1668 default:
1669 device_printf(sc->ndis_dev,
1670 "unknown nettype %d\n", arg);
1671 break;
1672 }
1673 kfree(bs, M_TEMP);
1674 } else {
1675 return;
1676 }
1677
1678 len = sizeof(ssid);
1679 bzero((char *)&ssid, len);
1680 rval = ndis_get_info(sc, OID_802_11_SSID, &ssid, &len);
1681
1682 if (rval)
1683 device_printf (sc->ndis_dev, "get ssid failed: %d\n", rval);
1684 bcopy(ssid.ns_ssid, ic->ic_bss->ni_essid, ssid.ns_ssidlen);
1685 ic->ic_bss->ni_esslen = ssid.ns_ssidlen;
1686
1687 len = sizeof(arg);
1688 rval = ndis_get_info(sc, OID_GEN_LINK_SPEED, &arg, &len);
1689 if (rval)
1690 device_printf (sc->ndis_dev, "get link speed failed: %d\n",
1691 rval);
1692
1693 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11B)) {
1694 ic->ic_bss->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11B];
1695 for (i = 0; i < ic->ic_bss->ni_rates.rs_nrates; i++) {
1696 if ((ic->ic_bss->ni_rates.rs_rates[i] &
1697 IEEE80211_RATE_VAL) == arg / 5000)
1698 break;
1699 }
1700 }
1701
1702 if (i == ic->ic_bss->ni_rates.rs_nrates &&
1703 ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) {
1704 ic->ic_bss->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11G];
1705 for (i = 0; i < ic->ic_bss->ni_rates.rs_nrates; i++) {
1706 if ((ic->ic_bss->ni_rates.rs_rates[i] &
1707 IEEE80211_RATE_VAL) == arg / 5000)
1708 break;
1709 }
1710 }
1711
1712 if (i == ic->ic_bss->ni_rates.rs_nrates)
1713 device_printf(sc->ndis_dev, "no matching rate for: %d\n",
1714 arg / 5000);
1715 else
1716 ic->ic_bss->ni_txrate = i;
1717
1718 if (ic->ic_caps & IEEE80211_C_PMGT) {
1719 len = sizeof(arg);
1720 rval = ndis_get_info(sc, OID_802_11_POWER_MODE, &arg, &len);
1721
1722 if (rval)
1723 device_printf(sc->ndis_dev,
1724 "get power mode failed: %d\n", rval);
1725 if (arg == NDIS_80211_POWERMODE_CAM)
1726 ic->ic_flags &= ~IEEE80211_F_PMGTON;
1727 else
1728 ic->ic_flags |= IEEE80211_F_PMGTON;
1729 }
1730
1731 len = sizeof(config);
1732 bzero((char *)&config, len);
1733 config.nc_length = len;
1734 config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh);
1735 rval = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &len);
1736 if (rval == 0) {
1737 int chan;
1738
1739 chan = ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0);
1740 if (chan < 0 || chan >= IEEE80211_CHAN_MAX) {
1741 if (ifp->if_flags & IFF_DEBUG)
1742 device_printf(sc->ndis_dev, "current channel "
1743 "(%uMHz) out of bounds\n",
1744 config.nc_dsconfig / 1000);
1745 ic->ic_bss->ni_chan = &ic->ic_channels[1];
1746 } else
1747 ic->ic_bss->ni_chan = &ic->ic_channels[chan];
1748 } else
1749 device_printf(sc->ndis_dev, "couldn't retrieve "
1750 "channel info: %d\n", rval);
1751
1752 /*
1753 len = sizeof(arg);
1754 rval = ndis_get_info(sc, OID_802_11_WEP_STATUS, &arg, &len);
1755
1756 if (rval)
1757 device_printf (sc->ndis_dev,
1758 "get wep status failed: %d\n", rval);
1759
1760 if (arg == NDIS_80211_WEPSTAT_ENABLED)
1761 ic->ic_flags |= IEEE80211_F_WEPON;
1762 else
1763 ic->ic_flags &= ~IEEE80211_F_WEPON;
1764 */
1765 }
1766
1767 static int
1768 ndis_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
1769 {
1770 struct ndis_softc *sc = ifp->if_softc;
1771 struct ifreq *ifr = (struct ifreq *) data;
1772 int i, error = 0;
1773
1774 switch(command) {
1775 case SIOCSIFFLAGS:
1776 if (ifp->if_flags & IFF_UP) {
1777 if (ifp->if_flags & IFF_RUNNING &&
1778 ifp->if_flags & IFF_PROMISC &&
1779 !(sc->ndis_if_flags & IFF_PROMISC)) {
1780 sc->ndis_filter |=
1781 NDIS_PACKET_TYPE_PROMISCUOUS;
1782 i = sizeof(sc->ndis_filter);
1783 error = ndis_set_info(sc,
1784 OID_GEN_CURRENT_PACKET_FILTER,
1785 &sc->ndis_filter, &i);
1786 } else if (ifp->if_flags & IFF_RUNNING &&
1787 !(ifp->if_flags & IFF_PROMISC) &&
1788 sc->ndis_if_flags & IFF_PROMISC) {
1789 sc->ndis_filter &=
1790 ~NDIS_PACKET_TYPE_PROMISCUOUS;
1791 i = sizeof(sc->ndis_filter);
1792 error = ndis_set_info(sc,
1793 OID_GEN_CURRENT_PACKET_FILTER,
1794 &sc->ndis_filter, &i);
1795 } else
1796 ndis_init(sc);
1797 } else {
1798 if (ifp->if_flags & IFF_RUNNING)
1799 ndis_stop(sc);
1800 }
1801 sc->ndis_if_flags = ifp->if_flags;
1802 error = 0;
1803 break;
1804 case SIOCADDMULTI:
1805 case SIOCDELMULTI:
1806 ndis_setmulti(sc);
1807 error = 0;
1808 break;
1809 case SIOCGIFMEDIA:
1810 case SIOCSIFMEDIA:
1811 if (sc->ndis_80211) {
1812 error = ieee80211_ioctl(&sc->ic, command, data, cr);
1813 if (error == ENETRESET) {
1814 ndis_setstate_80211(sc);
1815 /*ndis_init(sc);*/
1816 error = 0;
1817 }
1818 } else
1819 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
1820 break;
1821 case SIOCSIFCAP:
1822 ifp->if_capenable = ifr->ifr_reqcap;
1823 if (ifp->if_capenable & IFCAP_TXCSUM)
1824 ifp->if_hwassist = sc->ndis_hwassist;
1825 else
1826 ifp->if_hwassist = 0;
1827 ndis_set_offload(sc);
1828 break;
1829 case SIOCGIFGENERIC:
1830 case SIOCSIFGENERIC:
1831 if (sc->ndis_80211 && NDIS_INITIALIZED(sc)) {
1832 if (command == SIOCGIFGENERIC)
1833 error = ndis_wi_ioctl_get(ifp, command, data);
1834 else
1835 error = ndis_wi_ioctl_set(ifp, command, data);
1836 } else
1837 error = ENOTTY;
1838 if (error != ENOTTY)
1839 break;
1840 default:
1841 sc->ndis_skip = 1;
1842 if (sc->ndis_80211) {
1843 error = ieee80211_ioctl(&sc->ic, command, data, cr);
1844 if (error == ENETRESET) {
1845 ndis_setstate_80211(sc);
1846 error = 0;
1847 }
1848 } else
1849 error = ether_ioctl(ifp, command, data);
1850 sc->ndis_skip = 0;
1851 break;
1852 }
1853 return(error);
1854 }
1855
1856 static int
1857 ndis_wi_ioctl_get(struct ifnet *ifp, u_long command, caddr_t data)
1858 {
1859 struct wi_req wreq;
1860 struct ifreq *ifr;
1861 struct ndis_softc *sc;
1862 ndis_80211_bssid_list_ex *bl;
1863 ndis_wlan_bssid_ex *wb;
1864 struct wi_apinfo *api;
1865 int error, i, j, len, maxaps;
1866
1867 sc = ifp->if_softc;
1868 ifr = (struct ifreq *)data;
1869 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq));
1870 if (error)
1871 return (error);
1872
1873 switch (wreq.wi_type) {
1874 case WI_RID_READ_APS:
1875 len = 0;
1876 error = ndis_set_info(sc, OID_802_11_BSSID_LIST_SCAN,
1877 NULL, &len);
1878 if (error == 0)
1879 tsleep(&error, PCATCH, "ssidscan", hz * 2);
1880 len = 0;
1881 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, NULL, &len);
1882 if (error != ENOSPC)
1883 break;
1884 bl = kmalloc(len, M_DEVBUF, M_WAITOK|M_ZERO);
1885 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, bl, &len);
1886 if (error) {
1887 kfree(bl, M_DEVBUF);
1888 break;
1889 }
1890 maxaps = (2 * wreq.wi_len - sizeof(int)) / sizeof(*api);
1891 maxaps = MIN(maxaps, bl->nblx_items);
1892 wreq.wi_len = (maxaps * sizeof(*api) + sizeof(int)) / 2;
1893 *(int *)&wreq.wi_val = maxaps;
1894 api = (struct wi_apinfo *)&((int *)&wreq.wi_val)[1];
1895 wb = bl->nblx_bssid;
1896 while (maxaps--) {
1897 bzero(api, sizeof(*api));
1898 bcopy(&wb->nwbx_macaddr, &api->bssid,
1899 sizeof(api->bssid));
1900 api->namelen = wb->nwbx_ssid.ns_ssidlen;
1901 bcopy(&wb->nwbx_ssid.ns_ssid, &api->name, api->namelen);
1902 if (wb->nwbx_privacy)
1903 api->capinfo |= IEEE80211_CAPINFO_PRIVACY;
1904 /* XXX Where can we get noise information? */
1905 api->signal = wb->nwbx_rssi + 149; /* XXX */
1906 api->quality = api->signal;
1907 api->channel =
1908 ieee80211_mhz2ieee(wb->nwbx_config.nc_dsconfig /
1909 1000, 0);
1910 /* In "auto" infrastructure mode, this is useless. */
1911 if (wb->nwbx_netinfra == NDIS_80211_NET_INFRA_IBSS)
1912 api->capinfo |= IEEE80211_CAPINFO_IBSS;
1913 if (wb->nwbx_len > sizeof(ndis_wlan_bssid)) {
1914 j = sizeof(ndis_80211_rates_ex);
1915 /* handle other extended things */
1916 } else
1917 j = sizeof(ndis_80211_rates);
1918 for (i = api->rate = 0; i < j; i++)
1919 api->rate = MAX(api->rate, 5 *
1920 (wb->nwbx_supportedrates[i] & 0x7f));
1921 api++;
1922 wb = (ndis_wlan_bssid_ex *)((char *)wb + wb->nwbx_len);
1923 }
1924 kfree(bl, M_DEVBUF);
1925 error = copyout(&wreq, ifr->ifr_data, sizeof(wreq));
1926 break;
1927 default:
1928 error = ENOTTY;
1929 break;
1930 }
1931 return (error);
1932 }
1933
1934 static int
1935 ndis_wi_ioctl_set(struct ifnet *ifp, u_long command, caddr_t data)
1936 {
1937 struct wi_req wreq;
1938 struct ifreq *ifr;
1939 struct ndis_softc *sc;
1940 uint32_t foo;
1941 int error, len;
1942
1943 error = priv_check(curthread, PRIV_ROOT);
1944 if (error)
1945 return (error);
1946
1947 sc = ifp->if_softc;
1948 ifr = (struct ifreq *)data;
1949 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq));
1950 if (error)
1951 return (error);
1952
1953 switch (wreq.wi_type) {
1954 case WI_RID_SCAN_APS:
1955 case WI_RID_SCAN_REQ: /* arguments ignored */
1956 len = sizeof(foo);
1957 foo = 0;
1958 error = ndis_set_info(sc, OID_802_11_BSSID_LIST_SCAN, &foo,
1959 &len);
1960 break;
1961 default:
1962 error = ENOTTY;
1963 break;
1964 }
1965 return (error);
1966 }
1967
1968 static void
1969 ndis_watchdog(struct ifnet *ifp)
1970 {
1971 struct ndis_softc *sc;
1972
1973 sc = ifp->if_softc;
1974
1975 ifp->if_oerrors++;
1976 device_printf(sc->ndis_dev, "watchdog timeout\n");
1977
1978 ndis_reset_nic(sc);
1979 ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE);
1980 }
1981
1982 /*
1983 * Stop the adapter and free any mbufs allocated to the
1984 * RX and TX lists.
1985 */
1986 static void
1987 ndis_stop(struct ndis_softc *sc)
1988 {
1989 struct ifnet *ifp;
1990
1991 ifp = &sc->arpcom.ac_if;
1992 callout_stop(&sc->ndis_stat_timer);
1993
1994 ndis_halt_nic(sc);
1995
1996 ifp->if_timer = 0;
1997 sc->ndis_link = 0;
1998 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1999 }
2000
2001 /*
2002 * Stop all chip I/O so that the kernel's probe routines don't
2003 * get confused by errant DMAs when rebooting.
2004 */
2005 void
2006 ndis_shutdown(device_t dev)
2007 {
2008 struct ndis_softc *sc;
2009 struct ifnet *ifp;
2010
2011 sc = device_get_softc(dev);
2012 ifp = &sc->arpcom.ac_if;
2013 lwkt_serialize_enter(ifp->if_serializer);
2014 ndis_shutdown_nic(sc);
2015 lwkt_serialize_exit(ifp->if_serializer);
2016 }
DragonFly BSD