3 * Bill Paul <wpaul@windriver.com>. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by Bill Paul.
16 * 4. Neither the name of the author nor the names of any co-contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
32 * $FreeBSD: 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.20 2007/01/03 14:12:52 swildner Exp $
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/sockio.h>
40 #include <sys/malloc.h>
41 #include <sys/kernel.h>
42 #include <sys/socket.h>
43 #include <sys/queue.h>
45 #include <sys/sysctl.h>
48 #include <sys/serialize.h>
49 #include <sys/thread2.h>
52 #include <net/ifq_var.h>
53 #include <net/if_arp.h>
54 #include <net/ethernet.h>
55 #include <net/if_dl.h>
56 #include <net/if_media.h>
57 #include <net/route.h>
61 #include <netproto/802_11/ieee80211_var.h>
62 #include <netproto/802_11/ieee80211_ioctl.h>
64 #include <netproto/802_11/if_wavelan_ieee.h>
66 #include <bus/pci/pcireg.h>
67 #include <bus/pci/pcivar.h>
69 #include <emulation/ndis/regcall.h>
70 #include <emulation/ndis/pe_var.h>
71 #include <emulation/ndis/resource_var.h>
72 #include <emulation/ndis/ntoskrnl_var.h>
73 #include <emulation/ndis/hal_var.h>
74 #include <emulation/ndis/ndis_var.h>
75 #include <emulation/ndis/cfg_var.h>
76 #include "if_ndisvar.h"
81 #include "ndis_driver_data.h"
83 int ndis_attach (device_t);
84 int ndis_detach (device_t);
85 int ndis_suspend (device_t);
86 int ndis_resume (device_t);
87 void ndis_shutdown (device_t);
89 static __stdcall void ndis_txeof (ndis_handle,
90 ndis_packet *, ndis_status);
91 static __stdcall void ndis_rxeof (ndis_handle,
92 ndis_packet **, uint32_t);
93 static __stdcall void ndis_linksts (ndis_handle,
94 ndis_status, void *, uint32_t);
95 static __stdcall void ndis_linksts_done (ndis_handle);
97 static void ndis_intr (void *);
98 static void ndis_intrtask (void *);
99 static void ndis_tick (void *);
100 static void ndis_ticktask (void *);
101 static void ndis_start (struct ifnet *);
102 static void ndis_starttask (void *);
103 static int ndis_ioctl (struct ifnet *, u_long, caddr_t, struct ucred *);
104 static int ndis_wi_ioctl_get (struct ifnet *, u_long, caddr_t);
105 static int ndis_wi_ioctl_set (struct ifnet *, u_long, caddr_t);
106 static void ndis_init (void *);
107 static void ndis_stop (struct ndis_softc *);
108 static void ndis_watchdog (struct ifnet *);
109 static int ndis_ifmedia_upd (struct ifnet *);
110 static void ndis_ifmedia_sts (struct ifnet *, struct ifmediareq *);
111 static int ndis_get_assoc (struct ndis_softc *, ndis_wlan_bssid_ex **);
112 static int ndis_probe_offload (struct ndis_softc *);
113 static int ndis_set_offload (struct ndis_softc *);
114 static void ndis_getstate_80211 (struct ndis_softc *);
115 static void ndis_setstate_80211 (struct ndis_softc *);
116 static void ndis_media_status (struct ifnet *, struct ifmediareq *);
118 static void ndis_setmulti (struct ndis_softc *);
119 static void ndis_map_sclist (void *, bus_dma_segment_t *,
120 int, bus_size_t, int);
123 * Program the 64-bit multicast hash filter.
126 ndis_setmulti(struct ndis_softc *sc)
129 struct ifmultiaddr *ifma;
130 int len, mclistsz, error;
133 ifp = &sc->arpcom.ac_if;
135 if (!NDIS_INITIALIZED(sc))
138 if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
139 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
140 len = sizeof(sc->ndis_filter);
141 error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER,
142 &sc->ndis_filter, &len);
144 device_printf (sc->ndis_dev,
145 "set filter failed: %d\n", error);
149 if (LIST_EMPTY(&ifp->if_multiaddrs))
152 len = sizeof(mclistsz);
153 ndis_get_info(sc, OID_802_3_MAXIMUM_LIST_SIZE, &mclistsz, &len);
155 mclist = kmalloc(ETHER_ADDR_LEN * mclistsz, M_TEMP, M_NOWAIT|M_ZERO);
157 if (mclist == NULL) {
158 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
162 sc->ndis_filter |= NDIS_PACKET_TYPE_MULTICAST;
165 LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
166 if (ifma->ifma_addr->sa_family != AF_LINK)
168 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
169 mclist + (ETHER_ADDR_LEN * len), ETHER_ADDR_LEN);
171 if (len > mclistsz) {
172 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
173 sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST;
178 len = len * ETHER_ADDR_LEN;
179 error = ndis_set_info(sc, OID_802_3_MULTICAST_LIST, mclist, &len);
181 device_printf (sc->ndis_dev, "set mclist failed: %d\n", error);
182 sc->ndis_filter |= NDIS_PACKET_TYPE_ALL_MULTICAST;
183 sc->ndis_filter &= ~NDIS_PACKET_TYPE_MULTICAST;
187 kfree(mclist, M_TEMP);
189 len = sizeof(sc->ndis_filter);
190 error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER,
191 &sc->ndis_filter, &len);
193 device_printf (sc->ndis_dev, "set filter failed: %d\n", error);
197 ndis_set_offload(struct ndis_softc *sc)
199 ndis_task_offload *nto;
200 ndis_task_offload_hdr *ntoh;
201 ndis_task_tcpip_csum *nttc;
205 ifp = &sc->arpcom.ac_if;
207 if (!NDIS_INITIALIZED(sc))
210 /* See if there's anything to set. */
212 error = ndis_probe_offload(sc);
216 if (sc->ndis_hwassist == 0 && ifp->if_capabilities == 0)
219 len = sizeof(ndis_task_offload_hdr) + sizeof(ndis_task_offload) +
220 sizeof(ndis_task_tcpip_csum);
222 ntoh = kmalloc(len, M_TEMP, M_NOWAIT|M_ZERO);
227 ntoh->ntoh_vers = NDIS_TASK_OFFLOAD_VERSION;
228 ntoh->ntoh_len = sizeof(ndis_task_offload_hdr);
229 ntoh->ntoh_offset_firsttask = sizeof(ndis_task_offload_hdr);
230 ntoh->ntoh_encapfmt.nef_encaphdrlen = sizeof(struct ether_header);
231 ntoh->ntoh_encapfmt.nef_encap = NDIS_ENCAP_IEEE802_3;
232 ntoh->ntoh_encapfmt.nef_flags = NDIS_ENCAPFLAG_FIXEDHDRLEN;
234 nto = (ndis_task_offload *)((char *)ntoh +
235 ntoh->ntoh_offset_firsttask);
237 nto->nto_vers = NDIS_TASK_OFFLOAD_VERSION;
238 nto->nto_len = sizeof(ndis_task_offload);
239 nto->nto_task = NDIS_TASK_TCPIP_CSUM;
240 nto->nto_offset_nexttask = 0;
241 nto->nto_taskbuflen = sizeof(ndis_task_tcpip_csum);
243 nttc = (ndis_task_tcpip_csum *)nto->nto_taskbuf;
245 if (ifp->if_capenable & IFCAP_TXCSUM)
246 nttc->nttc_v4tx = sc->ndis_v4tx;
248 if (ifp->if_capenable & IFCAP_RXCSUM)
249 nttc->nttc_v4rx = sc->ndis_v4rx;
251 error = ndis_set_info(sc, OID_TCP_TASK_OFFLOAD, ntoh, &len);
258 ndis_probe_offload(struct ndis_softc *sc)
260 ndis_task_offload *nto;
261 ndis_task_offload_hdr *ntoh;
262 ndis_task_tcpip_csum *nttc = NULL;
264 int len, error, dummy;
266 ifp = &sc->arpcom.ac_if;
269 error = ndis_get_info(sc, OID_TCP_TASK_OFFLOAD, &dummy, &len);
274 ntoh = kmalloc(len, M_TEMP, M_NOWAIT|M_ZERO);
279 ntoh->ntoh_vers = NDIS_TASK_OFFLOAD_VERSION;
280 ntoh->ntoh_len = sizeof(ndis_task_offload_hdr);
281 ntoh->ntoh_encapfmt.nef_encaphdrlen = sizeof(struct ether_header);
282 ntoh->ntoh_encapfmt.nef_encap = NDIS_ENCAP_IEEE802_3;
283 ntoh->ntoh_encapfmt.nef_flags = NDIS_ENCAPFLAG_FIXEDHDRLEN;
285 error = ndis_get_info(sc, OID_TCP_TASK_OFFLOAD, ntoh, &len);
292 if (ntoh->ntoh_vers != NDIS_TASK_OFFLOAD_VERSION) {
297 nto = (ndis_task_offload *)((char *)ntoh +
298 ntoh->ntoh_offset_firsttask);
301 switch (nto->nto_task) {
302 case NDIS_TASK_TCPIP_CSUM:
303 nttc = (ndis_task_tcpip_csum *)nto->nto_taskbuf;
305 /* Don't handle these yet. */
306 case NDIS_TASK_IPSEC:
307 case NDIS_TASK_TCP_LARGESEND:
311 if (nto->nto_offset_nexttask == 0)
313 nto = (ndis_task_offload *)((char *)nto +
314 nto->nto_offset_nexttask);
322 sc->ndis_v4tx = nttc->nttc_v4tx;
323 sc->ndis_v4rx = nttc->nttc_v4rx;
325 if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_IP_CSUM)
326 sc->ndis_hwassist |= CSUM_IP;
327 if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_TCP_CSUM)
328 sc->ndis_hwassist |= CSUM_TCP;
329 if (nttc->nttc_v4tx & NDIS_TCPSUM_FLAGS_UDP_CSUM)
330 sc->ndis_hwassist |= CSUM_UDP;
332 if (sc->ndis_hwassist)
333 ifp->if_capabilities |= IFCAP_TXCSUM;
335 if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_IP_CSUM)
336 ifp->if_capabilities |= IFCAP_RXCSUM;
337 if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_TCP_CSUM)
338 ifp->if_capabilities |= IFCAP_RXCSUM;
339 if (nttc->nttc_v4rx & NDIS_TCPSUM_FLAGS_UDP_CSUM)
340 ifp->if_capabilities |= IFCAP_RXCSUM;
347 * Attach the interface. Allocate softc structures, do ifmedia
348 * setup and ethernet/BPF attach.
351 ndis_attach(device_t dev)
353 u_char eaddr[ETHER_ADDR_LEN];
354 struct ndis_softc *sc;
360 sc = device_get_softc(dev);
362 callout_init(&sc->ndis_stat_timer);
364 sc->ndis_regvals = ndis_regvals;
366 #if __FreeBSD_version < 502113
367 sysctl_ctx_init(&sc->ndis_ctx);
370 /* Create sysctl registry nodes */
371 ndis_create_sysctls(sc);
373 /* Set up driver image in memory. */
375 ndis_load_driver((vm_offset_t)img, sc);
377 /* Tell the user what version of the API the driver is using. */
378 device_printf(dev, "NDIS API version: %d.%d\n",
379 sc->ndis_chars.nmc_version_major,
380 sc->ndis_chars.nmc_version_minor);
382 /* Do resource conversion. */
383 ndis_convert_res(sc);
385 /* Install our RX and TX interrupt handlers. */
386 sc->ndis_block.nmb_senddone_func = ndis_txeof;
387 sc->ndis_block.nmb_pktind_func = ndis_rxeof;
389 /* Call driver's init routine. */
390 if (ndis_init_nic(sc)) {
391 device_printf (dev, "init handler failed\n");
397 * Get station address from the driver.
400 ndis_get_info(sc, OID_802_3_CURRENT_ADDRESS, &eaddr, &len);
402 bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
405 * Figure out of we're allowed to use multipacket sends
406 * with this driver, and if so, how many.
409 if (sc->ndis_chars.nmc_sendsingle_func &&
410 sc->ndis_chars.nmc_sendmulti_func == NULL) {
411 sc->ndis_maxpkts = 1;
413 len = sizeof(sc->ndis_maxpkts);
414 ndis_get_info(sc, OID_GEN_MAXIMUM_SEND_PACKETS,
415 &sc->ndis_maxpkts, &len);
418 sc->ndis_txarray = kmalloc(sizeof(ndis_packet *) *
419 sc->ndis_maxpkts, M_DEVBUF, M_WAITOK|M_ZERO);
421 sc->ndis_txpending = sc->ndis_maxpkts;
424 /* Get supported oid list. */
425 ndis_get_supported_oids(sc, &sc->ndis_oids, &sc->ndis_oidcnt);
427 /* If the NDIS module requested scatter/gather, init maps. */
432 * See if the OID_802_11_CONFIGURATION OID is
433 * supported by this driver. If it is, then this an 802.11
434 * wireless driver, and we should set up media for wireless.
436 for (i = 0; i < sc->ndis_oidcnt; i++) {
437 if (sc->ndis_oids[i] == OID_802_11_CONFIGURATION) {
443 /* Check for task offload support. */
444 ndis_probe_offload(sc);
446 ifp = &sc->arpcom.ac_if;
448 if_initname(ifp, device_get_name(dev), device_get_unit(dev));
449 ifp->if_mtu = ETHERMTU;
450 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
451 ifp->if_ioctl = ndis_ioctl;
452 ifp->if_start = ndis_start;
453 ifp->if_watchdog = ndis_watchdog;
454 ifp->if_init = ndis_init;
455 ifp->if_baudrate = 10000000;
456 ifq_set_maxlen(&ifp->if_snd, 50);
457 ifq_set_ready(&ifp->if_snd);
458 ifp->if_capenable = ifp->if_capabilities;
459 ifp->if_hwassist = sc->ndis_hwassist;
462 if (sc->ndis_80211) {
463 struct ieee80211com *ic = (void *)ifp;
464 ndis_80211_rates_ex rates;
465 struct ndis_80211_nettype_list *ntl;
469 ic->ic_phytype = IEEE80211_T_DS;
470 ic->ic_opmode = IEEE80211_M_STA;
471 ic->ic_caps = IEEE80211_C_IBSS;
472 ic->ic_state = IEEE80211_S_ASSOC;
473 ic->ic_modecaps = (1<<IEEE80211_MODE_AUTO);
475 r = ndis_get_info(sc, OID_802_11_NETWORK_TYPES_SUPPORTED,
479 ntl = kmalloc(len, M_DEVBUF, M_WAITOK|M_ZERO);
480 r = ndis_get_info(sc, OID_802_11_NETWORK_TYPES_SUPPORTED,
483 kfree(ntl, M_DEVBUF);
487 for (i = 0; i < ntl->ntl_items; i++) {
488 switch (ntl->ntl_type[i]) {
489 case NDIS_80211_NETTYPE_11FH:
490 case NDIS_80211_NETTYPE_11DS:
491 ic->ic_modecaps |= (1<<IEEE80211_MODE_11B);
493 case NDIS_80211_NETTYPE_11OFDM5:
494 ic->ic_modecaps |= (1<<IEEE80211_MODE_11A);
496 case NDIS_80211_NETTYPE_11OFDM24:
497 ic->ic_modecaps |= (1<<IEEE80211_MODE_11G);
503 kfree(ntl, M_DEVBUF);
506 bzero((char *)&rates, len);
507 r = ndis_get_info(sc, OID_802_11_SUPPORTED_RATES,
508 (void *)rates, &len);
510 device_printf (dev, "get rates failed: 0x%x\n", r);
512 * Since the supported rates only up to 8 can be supported,
513 * if this is not 802.11b we're just going to be faking it
517 #define TESTSETRATE(x, y) \
520 for (i = 0; i < ic->ic_sup_rates[x].rs_nrates; i++) { \
521 if (ic->ic_sup_rates[x].rs_rates[i] == (y)) \
524 if (i == ic->ic_sup_rates[x].rs_nrates) { \
525 ic->ic_sup_rates[x].rs_rates[i] = (y); \
526 ic->ic_sup_rates[x].rs_nrates++; \
530 #define SETRATE(x, y) \
531 ic->ic_sup_rates[x].rs_rates[ic->ic_sup_rates[x].rs_nrates] = (y)
533 ic->ic_sup_rates[x].rs_nrates++
535 ic->ic_curmode = IEEE80211_MODE_AUTO;
536 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11A))
537 ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates = 0;
538 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11B))
539 ic->ic_sup_rates[IEEE80211_MODE_11B].rs_nrates = 0;
540 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G))
541 ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates = 0;
542 for (i = 0; i < len; i++) {
543 switch (rates[i] & IEEE80211_RATE_VAL) {
549 if (!(ic->ic_modecaps &
550 (1<<IEEE80211_MODE_11B))) {
551 /* Lazy-init 802.11b. */
553 (1<<IEEE80211_MODE_11B);
554 ic->ic_sup_rates[IEEE80211_MODE_11B].
557 SETRATE(IEEE80211_MODE_11B, rates[i]);
558 INCRATE(IEEE80211_MODE_11B);
561 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11A)) {
562 SETRATE(IEEE80211_MODE_11A, rates[i]);
563 INCRATE(IEEE80211_MODE_11A);
565 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) {
566 SETRATE(IEEE80211_MODE_11G, rates[i]);
567 INCRATE(IEEE80211_MODE_11G);
574 * If the hardware supports 802.11g, it most
575 * likely supports 802.11b and all of the
576 * 802.11b and 802.11g speeds, so maybe we can
577 * just cheat here. Just how in the heck do
578 * we detect turbo modes, though?
580 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11B)) {
581 TESTSETRATE(IEEE80211_MODE_11B,
582 IEEE80211_RATE_BASIC|2);
583 TESTSETRATE(IEEE80211_MODE_11B,
584 IEEE80211_RATE_BASIC|4);
585 TESTSETRATE(IEEE80211_MODE_11B,
586 IEEE80211_RATE_BASIC|11);
587 TESTSETRATE(IEEE80211_MODE_11B,
588 IEEE80211_RATE_BASIC|22);
590 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) {
591 TESTSETRATE(IEEE80211_MODE_11G, 47);
592 TESTSETRATE(IEEE80211_MODE_11G, 72);
593 TESTSETRATE(IEEE80211_MODE_11G, 96);
594 TESTSETRATE(IEEE80211_MODE_11G, 108);
596 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11A)) {
597 TESTSETRATE(IEEE80211_MODE_11A, 47);
598 TESTSETRATE(IEEE80211_MODE_11A, 72);
599 TESTSETRATE(IEEE80211_MODE_11A, 96);
600 TESTSETRATE(IEEE80211_MODE_11A, 108);
605 * Taking yet more guesses here.
607 for (i = 1; i < IEEE80211_CHAN_MAX; i++) {
610 if (ic->ic_sup_rates[IEEE80211_MODE_11G].rs_nrates)
611 chanflag |= IEEE80211_CHAN_G;
613 chanflag |= IEEE80211_CHAN_B;
614 if (ic->ic_sup_rates[IEEE80211_MODE_11A].rs_nrates &&
616 chanflag = IEEE80211_CHAN_A;
619 ic->ic_channels[i].ic_freq =
620 ieee80211_ieee2mhz(i, chanflag);
621 ic->ic_channels[i].ic_flags = chanflag;
625 r = ndis_get_info(sc, OID_802_11_WEP_STATUS, &arg, &i);
626 if (arg != NDIS_80211_WEPSTAT_NOTSUPPORTED)
627 ic->ic_caps |= IEEE80211_C_WEP;
629 r = ndis_get_info(sc, OID_802_11_POWER_MODE, &arg, &i);
631 ic->ic_caps |= IEEE80211_C_PMGT;
632 bcopy(eaddr, &ic->ic_myaddr, sizeof(eaddr));
633 ieee80211_ifattach(ic);
634 ieee80211_media_init(ic, ieee80211_media_change,
636 ic->ic_ibss_chan = IEEE80211_CHAN_ANYC;
637 ic->ic_bss->ni_chan = ic->ic_ibss_chan;
639 ifmedia_init(&sc->ifmedia, IFM_IMASK, ndis_ifmedia_upd,
641 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
642 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
643 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_100_TX, 0, NULL);
644 ifmedia_add(&sc->ifmedia,
645 IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL);
646 ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_AUTO, 0, NULL);
647 ifmedia_set(&sc->ifmedia, IFM_ETHER|IFM_AUTO);
648 ether_ifattach(ifp, eaddr, NULL);
652 error = bus_setup_intr(dev, sc->ndis_irq, INTR_NETSAFE,
657 device_printf(dev, "couldn't set up irq\n");
663 /* Override the status handler so we can detect link changes. */
664 sc->ndis_block.nmb_status_func = ndis_linksts;
665 sc->ndis_block.nmb_statusdone_func = ndis_linksts_done;
670 /* We're done talking to the NIC for now; halt it. */
677 * Shutdown hardware and free up resources. This can be called any
678 * time after the mutex has been initialized. It is called in both
679 * the error case in attach and the normal detach case so it needs
680 * to be careful about only freeing resources that have actually been
684 ndis_detach(device_t dev)
686 struct ndis_softc *sc;
689 sc = device_get_softc(dev);
690 ifp = &sc->arpcom.ac_if;
692 ifp->if_flags &= ~IFF_UP;
694 if (device_is_attached(dev)) {
695 lwkt_serialize_enter(ifp->if_serializer);
697 bus_teardown_intr(dev, sc->ndis_irq, sc->ndis_intrhand);
698 lwkt_serialize_exit(ifp->if_serializer);
701 ieee80211_ifdetach(&sc->ic);
705 bus_generic_detach(dev);
708 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->ndis_irq);
710 bus_release_resource(dev, SYS_RES_IOPORT,
711 sc->ndis_io_rid, sc->ndis_res_io);
712 if (sc->ndis_res_mem)
713 bus_release_resource(dev, SYS_RES_MEMORY,
714 sc->ndis_mem_rid, sc->ndis_res_mem);
715 if (sc->ndis_res_altmem)
716 bus_release_resource(dev, SYS_RES_MEMORY,
717 sc->ndis_altmem_rid, sc->ndis_res_altmem);
720 ndis_destroy_dma(sc);
722 ndis_unload_driver((void *)ifp);
724 if (sc->ndis_iftype == PCIBus)
725 bus_dma_tag_destroy(sc->ndis_parent_tag);
727 #if __FreeBSD_version < 502113
728 sysctl_ctx_free(&sc->ndis_ctx);
734 ndis_suspend(device_t dev)
736 struct ndis_softc *sc;
739 sc = device_get_softc(dev);
740 ifp = &sc->arpcom.ac_if;
741 lwkt_serialize_enter(ifp->if_serializer);
744 if (NDIS_INITIALIZED(sc))
747 lwkt_serialize_exit(ifp->if_serializer);
752 ndis_resume(device_t dev)
754 struct ndis_softc *sc;
757 sc = device_get_softc(dev);
758 ifp = &sc->arpcom.ac_if;
760 lwkt_serialize_enter(ifp->if_serializer);
761 if (NDIS_INITIALIZED(sc))
763 lwkt_serialize_exit(ifp->if_serializer);
769 * A frame has been uploaded: pass the resulting mbuf chain up to
770 * the higher level protocols.
772 * When handling received NDIS packets, the 'status' field in the
773 * out-of-band portion of the ndis_packet has special meaning. In the
774 * most common case, the underlying NDIS driver will set this field
775 * to NDIS_STATUS_SUCCESS, which indicates that it's ok for us to
776 * take posession of it. We then change the status field to
777 * NDIS_STATUS_PENDING to tell the driver that we now own the packet,
778 * and that we will return it at some point in the future via the
779 * return packet handler.
781 * If the driver hands us a packet with a status of NDIS_STATUS_RESOURCES,
782 * this means the driver is running out of packet/buffer resources and
783 * wants to maintain ownership of the packet. In this case, we have to
784 * copy the packet data into local storage and let the driver keep the
787 __stdcall static void
788 ndis_rxeof(ndis_handle adapter, ndis_packet **packets, uint32_t pktcnt)
790 struct ndis_softc *sc;
791 ndis_miniport_block *block;
794 ndis_tcpip_csum *csum;
799 block = (ndis_miniport_block *)adapter;
800 sc = (struct ndis_softc *)(block->nmb_ifp);
801 ifp = block->nmb_ifp;
803 for (i = 0; i < pktcnt; i++) {
805 /* Stash the softc here so ptom can use it. */
807 if (ndis_ptom(&m0, p)) {
808 device_printf (sc->ndis_dev, "ptom failed\n");
809 if (p->np_oob.npo_status == NDIS_STATUS_SUCCESS)
810 ndis_return_packet(sc, p);
812 if (p->np_oob.npo_status == NDIS_STATUS_RESOURCES) {
813 m = m_dup(m0, MB_DONTWAIT);
815 * NOTE: we want to destroy the mbuf here, but
816 * we don't actually want to return it to the
817 * driver via the return packet handler. By
818 * bumping np_refcnt, we can prevent the
819 * ndis_return_packet() routine from actually
829 p->np_oob.npo_status = NDIS_STATUS_PENDING;
830 m0->m_pkthdr.rcvif = ifp;
833 /* Deal with checksum offload. */
835 if (ifp->if_capenable & IFCAP_RXCSUM &&
836 p->np_ext.npe_info[ndis_tcpipcsum_info] != NULL) {
838 p->np_ext.npe_info[ndis_tcpipcsum_info];
839 csum = (ndis_tcpip_csum *)&s;
840 if (csum->u.ntc_rxflags &
841 NDIS_RXCSUM_IP_PASSED)
842 m0->m_pkthdr.csum_flags |=
843 CSUM_IP_CHECKED|CSUM_IP_VALID;
844 if (csum->u.ntc_rxflags &
845 (NDIS_RXCSUM_TCP_PASSED |
846 NDIS_RXCSUM_UDP_PASSED)) {
847 m0->m_pkthdr.csum_flags |=
848 CSUM_DATA_VALID|CSUM_PSEUDO_HDR;
849 m0->m_pkthdr.csum_data = 0xFFFF;
853 ifp->if_input(ifp, m0);
859 * A frame was downloaded to the chip. It's safe for us to clean up
862 __stdcall static void
863 ndis_txeof(ndis_handle adapter, ndis_packet *packet, ndis_status status)
865 struct ndis_softc *sc;
866 ndis_miniport_block *block;
871 block = (ndis_miniport_block *)adapter;
872 sc = (struct ndis_softc *)block->nmb_ifp;
873 ifp = block->nmb_ifp;
876 idx = packet->np_txidx;
878 bus_dmamap_unload(sc->ndis_ttag, sc->ndis_tmaps[idx]);
880 ndis_free_packet(packet);
883 sc->ndis_txarray[idx] = NULL;
884 sc->ndis_txpending++;
886 if (status == NDIS_STATUS_SUCCESS)
891 ifp->if_flags &= ~IFF_OACTIVE;
893 ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE);
896 __stdcall static void
897 ndis_linksts(ndis_handle adapter, ndis_status status, void *sbuf, uint32_t slen)
899 ndis_miniport_block *block;
902 block->nmb_getstat = status;
905 __stdcall static void
906 ndis_linksts_done(ndis_handle adapter)
908 ndis_miniport_block *block;
909 struct ndis_softc *sc;
913 ifp = block->nmb_ifp;
916 if (!NDIS_INITIALIZED(sc))
919 switch (block->nmb_getstat) {
920 case NDIS_STATUS_MEDIA_CONNECT:
921 ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE);
922 ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE);
924 case NDIS_STATUS_MEDIA_DISCONNECT:
926 ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE);
934 ndis_intrtask(void *arg)
936 struct ndis_softc *sc;
941 ifp = &sc->arpcom.ac_if;
943 lwkt_serialize_enter(ifp->if_serializer);
944 irql = FASTCALL1(hal_raise_irql, DISPATCH_LEVEL);
946 FASTCALL1(hal_lower_irql, irql);
947 ndis_enable_intr(sc);
948 lwkt_serialize_exit(ifp->if_serializer);
954 struct ndis_softc *sc;
960 ifp = &sc->arpcom.ac_if;
962 if (sc->ndis_block.nmb_miniportadapterctx == NULL)
965 if (sc->ndis_block.nmb_interrupt->ni_isrreq == TRUE)
966 ndis_isr(sc, &is_our_intr, &call_isr);
968 ndis_disable_intr(sc);
972 if ((is_our_intr || call_isr))
973 ndis_sched(ndis_intrtask, ifp, NDIS_SWI);
979 struct ndis_softc *sc;
983 ndis_sched(ndis_ticktask, sc, NDIS_TASKQUEUE);
984 callout_reset(&sc->ndis_stat_timer,
985 hz *sc->ndis_block.nmb_checkforhangsecs, ndis_tick, sc);
989 ndis_ticktask(void *xsc)
991 struct ndis_softc *sc;
993 __stdcall ndis_checkforhang_handler hangfunc;
995 ndis_media_state linkstate;
999 ifp = &sc->arpcom.ac_if;
1001 lwkt_serialize_enter(ifp->if_serializer);
1002 hangfunc = sc->ndis_chars.nmc_checkhang_func;
1004 if (hangfunc != NULL) {
1005 rval = hangfunc(sc->ndis_block.nmb_miniportadapterctx);
1008 lwkt_serialize_exit(ifp->if_serializer);
1013 len = sizeof(linkstate);
1014 error = ndis_get_info(sc, OID_GEN_MEDIA_CONNECT_STATUS,
1015 (void *)&linkstate, &len);
1017 if (sc->ndis_link == 0 && linkstate == nmc_connected) {
1018 device_printf(sc->ndis_dev, "link up\n");
1021 ndis_getstate_80211(sc);
1022 #ifdef LINK_STATE_UP
1023 sc->arpcom.ac_if.if_link_state = LINK_STATE_UP;
1024 rt_ifmsg(&(sc->arpcom.ac_if));
1025 #endif /* LINK_STATE_UP */
1028 if (sc->ndis_link == 1 && linkstate == nmc_disconnected) {
1029 device_printf(sc->ndis_dev, "link down\n");
1031 #ifdef LINK_STATE_DOWN
1032 sc->arpcom.ac_if.if_link_state = LINK_STATE_DOWN;
1033 rt_ifmsg(&(sc->arpcom.ac_if));
1034 #endif /* LINK_STATE_DOWN */
1037 lwkt_serialize_exit(ifp->if_serializer);
1041 ndis_map_sclist(void *arg, bus_dma_segment_t *segs, int nseg,
1042 bus_size_t mapsize, int error)
1044 struct ndis_sc_list *sclist;
1047 if (error || arg == NULL)
1052 sclist->nsl_frags = nseg;
1054 for (i = 0; i < nseg; i++) {
1055 sclist->nsl_elements[i].nse_addr.np_quad = segs[i].ds_addr;
1056 sclist->nsl_elements[i].nse_len = segs[i].ds_len;
1061 ndis_starttask(void *arg)
1066 if (!ifq_is_empty(&ifp->if_snd))
1071 * Main transmit routine. To make NDIS drivers happy, we need to
1072 * transform mbuf chains into NDIS packets and feed them to the
1073 * send packet routines. Most drivers allow you to send several
1074 * packets at once (up to the maxpkts limit). Unfortunately, rather
1075 * that accepting them in the form of a linked list, they expect
1076 * a contiguous array of pointers to packets.
1078 * For those drivers which use the NDIS scatter/gather DMA mechanism,
1079 * we need to perform busdma work here. Those that use map registers
1080 * will do the mapping themselves on a buffer by buffer basis.
1084 ndis_start(struct ifnet *ifp)
1086 struct ndis_softc *sc;
1087 struct mbuf *m = NULL;
1088 ndis_packet **p0 = NULL, *p = NULL;
1089 ndis_tcpip_csum *csum;
1094 if (!sc->ndis_link || ifp->if_flags & IFF_OACTIVE) {
1098 p0 = &sc->ndis_txarray[sc->ndis_txidx];
1100 while(sc->ndis_txpending) {
1101 m = ifq_poll(&ifp->if_snd);
1105 sc->ndis_txarray[sc->ndis_txidx] = NULL;
1107 if (ndis_mtop(m, &sc->ndis_txarray[sc->ndis_txidx])) {
1110 ifq_dequeue(&ifp->if_snd, m);
1113 * Save pointer to original mbuf
1114 * so we can free it later.
1117 p = sc->ndis_txarray[sc->ndis_txidx];
1118 p->np_txidx = sc->ndis_txidx;
1120 p->np_oob.npo_status = NDIS_STATUS_PENDING;
1123 * Do scatter/gather processing, if driver requested it.
1126 bus_dmamap_load_mbuf(sc->ndis_ttag,
1127 sc->ndis_tmaps[sc->ndis_txidx], m,
1128 ndis_map_sclist, &p->np_sclist, BUS_DMA_NOWAIT);
1129 bus_dmamap_sync(sc->ndis_ttag,
1130 sc->ndis_tmaps[sc->ndis_txidx],
1131 BUS_DMASYNC_PREREAD);
1132 p->np_ext.npe_info[ndis_sclist_info] = &p->np_sclist;
1135 /* Handle checksum offload. */
1137 if (ifp->if_capenable & IFCAP_TXCSUM &&
1138 m->m_pkthdr.csum_flags) {
1139 csum = (ndis_tcpip_csum *)
1140 &p->np_ext.npe_info[ndis_tcpipcsum_info];
1141 csum->u.ntc_txflags = NDIS_TXCSUM_DO_IPV4;
1142 if (m->m_pkthdr.csum_flags & CSUM_IP)
1143 csum->u.ntc_txflags |= NDIS_TXCSUM_DO_IP;
1144 if (m->m_pkthdr.csum_flags & CSUM_TCP)
1145 csum->u.ntc_txflags |= NDIS_TXCSUM_DO_TCP;
1146 if (m->m_pkthdr.csum_flags & CSUM_UDP)
1147 csum->u.ntc_txflags |= NDIS_TXCSUM_DO_UDP;
1148 p->np_private.npp_flags = NDIS_PROTOCOL_ID_TCP_IP;
1152 sc->ndis_txpending--;
1157 * If there's a BPF listener, bounce a copy of this frame
1164 * The array that p0 points to must appear contiguous,
1165 * so we must not wrap past the end of sc->ndis_txarray[].
1166 * If it looks like we're about to wrap, break out here
1167 * so the this batch of packets can be transmitted, then
1168 * wait for txeof to ask us to send the rest.
1171 if (sc->ndis_txidx == 0)
1179 if (sc->ndis_txpending == 0)
1180 ifp->if_flags |= IFF_OACTIVE;
1183 * Set a timeout in case the chip goes out to lunch.
1187 if (sc->ndis_maxpkts == 1)
1188 ndis_send_packet(sc, p);
1190 ndis_send_packets(sc, p0, pcnt);
1194 ndis_init(void *xsc)
1196 struct ndis_softc *sc = xsc;
1197 struct ifnet *ifp = &sc->arpcom.ac_if;
1201 * Avoid reintializing the link unnecessarily.
1202 * This should be dealt with in a better way by
1203 * fixing the upper layer modules so they don't
1204 * call ifp->if_init() quite as often.
1206 if (sc->ndis_link && sc->ndis_skip)
1210 * Cancel pending I/O and free all RX/TX buffers.
1213 if (ndis_init_nic(sc))
1216 /* Init our MAC address */
1218 /* Program the packet filter */
1220 sc->ndis_filter = NDIS_PACKET_TYPE_DIRECTED;
1222 if (ifp->if_flags & IFF_BROADCAST)
1223 sc->ndis_filter |= NDIS_PACKET_TYPE_BROADCAST;
1225 if (ifp->if_flags & IFF_PROMISC)
1226 sc->ndis_filter |= NDIS_PACKET_TYPE_PROMISCUOUS;
1228 i = sizeof(sc->ndis_filter);
1230 error = ndis_set_info(sc, OID_GEN_CURRENT_PACKET_FILTER,
1231 &sc->ndis_filter, &i);
1234 device_printf (sc->ndis_dev, "set filter failed: %d\n", error);
1237 * Program the multicast filter, if necessary.
1241 /* Setup task offload. */
1242 ndis_set_offload(sc);
1244 /* Enable interrupts. */
1245 ndis_enable_intr(sc);
1248 ndis_setstate_80211(sc);
1251 sc->ndis_txpending = sc->ndis_maxpkts;
1254 ifp->if_flags |= IFF_RUNNING;
1255 ifp->if_flags &= ~IFF_OACTIVE;
1258 * Some drivers don't set this value. The NDIS spec says
1259 * the default checkforhang timeout is "approximately 2
1260 * seconds." We use 3 seconds, because it seems for some
1261 * drivers, exactly 2 seconds is too fast.
1264 if (sc->ndis_block.nmb_checkforhangsecs == 0)
1265 sc->ndis_block.nmb_checkforhangsecs = 3;
1267 callout_reset(&sc->ndis_stat_timer,
1268 hz * sc->ndis_block.nmb_checkforhangsecs, ndis_tick, sc);
1272 * Set media options.
1275 ndis_ifmedia_upd(struct ifnet *ifp)
1277 struct ndis_softc *sc;
1281 if (NDIS_INITIALIZED(sc))
1288 * Report current media status.
1291 ndis_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
1293 struct ndis_softc *sc;
1294 uint32_t media_info;
1295 ndis_media_state linkstate;
1298 ifmr->ifm_status = IFM_AVALID;
1299 ifmr->ifm_active = IFM_ETHER;
1302 if (!NDIS_INITIALIZED(sc))
1305 len = sizeof(linkstate);
1306 error = ndis_get_info(sc, OID_GEN_MEDIA_CONNECT_STATUS,
1307 (void *)&linkstate, &len);
1309 len = sizeof(media_info);
1310 error = ndis_get_info(sc, OID_GEN_LINK_SPEED,
1311 (void *)&media_info, &len);
1313 if (linkstate == nmc_connected)
1314 ifmr->ifm_status |= IFM_ACTIVE;
1316 switch(media_info) {
1318 ifmr->ifm_active |= IFM_10_T;
1321 ifmr->ifm_active |= IFM_100_TX;
1324 ifmr->ifm_active |= IFM_1000_T;
1327 device_printf(sc->ndis_dev, "unknown speed: %d\n", media_info);
1333 ndis_setstate_80211(struct ndis_softc *sc)
1335 struct ieee80211com *ic;
1336 ndis_80211_ssid ssid;
1337 ndis_80211_config config;
1339 int i, rval = 0, len;
1344 ifp = &sc->ic.ic_ac.ac_if;
1346 if (!NDIS_INITIALIZED(sc))
1349 /* Set network infrastructure mode. */
1352 if (ic->ic_opmode == IEEE80211_M_IBSS)
1353 arg = NDIS_80211_NET_INFRA_IBSS;
1355 arg = NDIS_80211_NET_INFRA_BSS;
1357 rval = ndis_set_info(sc, OID_802_11_INFRASTRUCTURE_MODE, &arg, &len);
1360 device_printf (sc->ndis_dev, "set infra failed: %d\n", rval);
1364 #ifdef IEEE80211_F_PRIVACY
1365 if (ic->ic_flags & IEEE80211_F_PRIVACY) {
1367 if (ic->ic_wep_mode >= IEEE80211_WEP_ON) {
1369 for (i = 0; i < IEEE80211_WEP_NKID; i++) {
1370 if (ic->ic_nw_keys[i].wk_keylen) {
1371 bzero((char *)&wep, sizeof(wep));
1372 wep.nw_keylen = ic->ic_nw_keys[i].wk_keylen;
1374 /* 5 and 13 are the only valid key lengths */
1375 if (ic->ic_nw_keys[i].wk_len < 5)
1377 else if (ic->ic_nw_keys[i].wk_len > 5 &&
1378 ic->ic_nw_keys[i].wk_len < 13)
1382 wep.nw_length = (sizeof(uint32_t) * 3)
1384 if (i == ic->ic_def_txkey)
1385 wep.nw_keyidx |= NDIS_80211_WEPKEY_TX;
1386 bcopy(ic->ic_nw_keys[i].wk_key,
1387 wep.nw_keydata, wep.nw_length);
1389 rval = ndis_set_info(sc,
1390 OID_802_11_ADD_WEP, &wep, &len);
1392 device_printf(sc->ndis_dev,
1393 "set wepkey failed: %d\n", rval);
1396 arg = NDIS_80211_WEPSTAT_ENABLED;
1398 rval = ndis_set_info(sc, OID_802_11_WEP_STATUS, &arg, &len);
1400 device_printf(sc->ndis_dev,
1401 "enable WEP failed: %d\n", rval);
1402 #ifndef IEEE80211_F_PRIVACY
1403 if (ic->ic_wep_mode != IEEE80211_WEP_8021X &&
1404 ic->ic_wep_mode != IEEE80211_WEP_ON)
1405 arg = NDIS_80211_PRIVFILT_ACCEPTALL;
1408 arg = NDIS_80211_PRIVFILT_8021XWEP;
1410 rval = ndis_set_info(sc, OID_802_11_PRIVACY_FILTER, &arg, &len);
1411 #ifdef IEEE80211_WEP_8021X /*IEEE80211_F_WEPON*/
1412 /* Accept that we only have "shared" and 802.1x modes. */
1414 if (arg == NDIS_80211_PRIVFILT_ACCEPTALL)
1415 ic->ic_wep_mode = IEEE80211_WEP_MIXED;
1417 ic->ic_wep_mode = IEEE80211_WEP_8021X;
1420 arg = NDIS_80211_AUTHMODE_OPEN;
1422 arg = NDIS_80211_WEPSTAT_DISABLED;
1424 ndis_set_info(sc, OID_802_11_WEP_STATUS, &arg, &len);
1425 arg = NDIS_80211_AUTHMODE_OPEN;
1429 rval = ndis_set_info(sc, OID_802_11_AUTHENTICATION_MODE, &arg, &len);
1433 device_printf (sc->ndis_dev, "set auth failed: %d\n", rval);
1437 /* Set network type. */
1441 switch (ic->ic_curmode) {
1442 case IEEE80211_MODE_11A:
1443 arg = NDIS_80211_NETTYPE_11OFDM5;
1445 case IEEE80211_MODE_11B:
1446 arg = NDIS_80211_NETTYPE_11DS;
1448 case IEEE80211_MODE_11G:
1449 arg = NDIS_80211_NETTYPE_11OFDM24;
1452 device_printf(sc->ndis_dev, "unknown mode: %d\n",
1458 rval = ndis_set_info(sc, OID_802_11_NETWORK_TYPE_IN_USE,
1461 device_printf (sc->ndis_dev,
1462 "set nettype failed: %d\n", rval);
1466 len = sizeof(config);
1467 bzero((char *)&config, len);
1468 config.nc_length = len;
1469 config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh);
1470 rval = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &len);
1473 * Some drivers expect us to initialize these values, so
1474 * provide some defaults.
1476 if (config.nc_beaconperiod == 0)
1477 config.nc_beaconperiod = 100;
1478 if (config.nc_atimwin == 0)
1479 config.nc_atimwin = 100;
1480 if (config.nc_fhconfig.ncf_dwelltime == 0)
1481 config.nc_fhconfig.ncf_dwelltime = 200;
1483 if (rval == 0 && ic->ic_ibss_chan != IEEE80211_CHAN_ANYC) {
1486 chan = ieee80211_chan2ieee(ic, ic->ic_ibss_chan);
1487 chanflag = config.nc_dsconfig > 2500000 ? IEEE80211_CHAN_2GHZ :
1488 IEEE80211_CHAN_5GHZ;
1489 if (chan != ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0)) {
1490 config.nc_dsconfig =
1491 ic->ic_ibss_chan->ic_freq * 1000;
1492 ic->ic_bss->ni_chan = ic->ic_ibss_chan;
1493 len = sizeof(config);
1494 config.nc_length = len;
1495 config.nc_fhconfig.ncf_length =
1496 sizeof(ndis_80211_config_fh);
1497 rval = ndis_set_info(sc, OID_802_11_CONFIGURATION,
1500 device_printf(sc->ndis_dev, "couldn't change "
1501 "DS config to %ukHz: %d\n",
1502 config.nc_dsconfig, rval);
1505 device_printf(sc->ndis_dev, "couldn't retrieve "
1506 "channel info: %d\n", rval);
1508 /* Set SSID -- always do this last. */
1511 bzero((char *)&ssid, len);
1512 ssid.ns_ssidlen = ic->ic_des_esslen;
1513 if (ssid.ns_ssidlen == 0) {
1514 ssid.ns_ssidlen = 1;
1516 bcopy(ic->ic_des_essid, ssid.ns_ssid, ssid.ns_ssidlen);
1517 rval = ndis_set_info(sc, OID_802_11_SSID, &ssid, &len);
1520 device_printf (sc->ndis_dev, "set ssid failed: %d\n", rval);
1524 ndis_media_status(struct ifnet *ifp, struct ifmediareq *imr)
1526 struct ieee80211com *ic = (void *)ifp; /* XXX */
1527 struct ieee80211_node *ni = NULL;
1529 imr->ifm_status = IFM_AVALID;
1530 imr->ifm_active = IFM_IEEE80211;
1531 if (ic->ic_state == IEEE80211_S_RUN)
1532 imr->ifm_status |= IFM_ACTIVE;
1533 imr->ifm_active |= IFM_AUTO;
1534 switch (ic->ic_opmode) {
1535 case IEEE80211_M_STA:
1537 /* calculate rate subtype */
1538 imr->ifm_active |= ieee80211_rate2media(ic,
1539 ni->ni_rates.rs_rates[ni->ni_txrate], ic->ic_curmode);
1541 case IEEE80211_M_IBSS:
1543 /* calculate rate subtype */
1544 imr->ifm_active |= ieee80211_rate2media(ic,
1545 ni->ni_rates.rs_rates[ni->ni_txrate], ic->ic_curmode);
1546 imr->ifm_active |= IFM_IEEE80211_ADHOC;
1548 case IEEE80211_M_AHDEMO:
1549 /* should not come here */
1551 case IEEE80211_M_HOSTAP:
1552 imr->ifm_active |= IFM_IEEE80211_HOSTAP;
1554 case IEEE80211_M_MONITOR:
1555 imr->ifm_active |= IFM_IEEE80211_MONITOR;
1558 switch (ic->ic_curmode) {
1559 case IEEE80211_MODE_11A:
1560 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11A);
1562 case IEEE80211_MODE_11B:
1563 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11B);
1565 case IEEE80211_MODE_11G:
1566 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11G);
1568 case IEEE80211_MODE_TURBO_A:
1569 imr->ifm_active |= IFM_MAKEMODE(IFM_IEEE80211_11A)
1570 | IFM_IEEE80211_TURBO;
1576 ndis_get_assoc(struct ndis_softc *sc, ndis_wlan_bssid_ex **assoc)
1578 ndis_80211_bssid_list_ex *bl;
1579 ndis_wlan_bssid_ex *bs;
1580 ndis_80211_macaddr bssid;
1586 len = sizeof(bssid);
1587 error = ndis_get_info(sc, OID_802_11_BSSID, &bssid, &len);
1589 device_printf(sc->ndis_dev, "failed to get bssid\n");
1593 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, NULL, &len);
1594 if (error != ENOSPC) {
1595 device_printf(sc->ndis_dev, "bssid_list failed\n");
1599 bl = kmalloc(len, M_TEMP, M_NOWAIT|M_ZERO);
1602 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, bl, &len);
1605 device_printf(sc->ndis_dev, "bssid_list failed\n");
1609 bs = (ndis_wlan_bssid_ex *)&bl->nblx_bssid[0];
1610 for (i = 0; i < bl->nblx_items; i++) {
1611 if (bcmp(bs->nwbx_macaddr, bssid, sizeof(bssid)) == 0) {
1612 *assoc = kmalloc(bs->nwbx_len, M_TEMP, M_NOWAIT);
1613 if (*assoc == NULL) {
1617 bcopy((char *)bs, (char *)*assoc, bs->nwbx_len);
1621 bs = (ndis_wlan_bssid_ex *)((char *)bs + bs->nwbx_len);
1629 ndis_getstate_80211(struct ndis_softc *sc)
1631 struct ieee80211com *ic;
1632 ndis_80211_ssid ssid;
1633 ndis_80211_config config;
1634 ndis_wlan_bssid_ex *bs;
1635 int rval, len, i = 0;
1640 ifp = &sc->ic.ic_ac.ac_if;
1642 if (!NDIS_INITIALIZED(sc))
1646 ic->ic_state = IEEE80211_S_RUN;
1648 ic->ic_state = IEEE80211_S_ASSOC;
1652 * If we're associated, retrieve info on the current bssid.
1654 if ((rval = ndis_get_assoc(sc, &bs)) == 0) {
1655 switch(bs->nwbx_nettype) {
1656 case NDIS_80211_NETTYPE_11FH:
1657 case NDIS_80211_NETTYPE_11DS:
1658 ic->ic_curmode = IEEE80211_MODE_11B;
1660 case NDIS_80211_NETTYPE_11OFDM5:
1661 ic->ic_curmode = IEEE80211_MODE_11A;
1663 case NDIS_80211_NETTYPE_11OFDM24:
1664 ic->ic_curmode = IEEE80211_MODE_11G;
1667 device_printf(sc->ndis_dev,
1668 "unknown nettype %d\n", arg);
1677 bzero((char *)&ssid, len);
1678 rval = ndis_get_info(sc, OID_802_11_SSID, &ssid, &len);
1681 device_printf (sc->ndis_dev, "get ssid failed: %d\n", rval);
1682 bcopy(ssid.ns_ssid, ic->ic_bss->ni_essid, ssid.ns_ssidlen);
1683 ic->ic_bss->ni_esslen = ssid.ns_ssidlen;
1686 rval = ndis_get_info(sc, OID_GEN_LINK_SPEED, &arg, &len);
1688 device_printf (sc->ndis_dev, "get link speed failed: %d\n",
1691 if (ic->ic_modecaps & (1<<IEEE80211_MODE_11B)) {
1692 ic->ic_bss->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11B];
1693 for (i = 0; i < ic->ic_bss->ni_rates.rs_nrates; i++) {
1694 if ((ic->ic_bss->ni_rates.rs_rates[i] &
1695 IEEE80211_RATE_VAL) == arg / 5000)
1700 if (i == ic->ic_bss->ni_rates.rs_nrates &&
1701 ic->ic_modecaps & (1<<IEEE80211_MODE_11G)) {
1702 ic->ic_bss->ni_rates = ic->ic_sup_rates[IEEE80211_MODE_11G];
1703 for (i = 0; i < ic->ic_bss->ni_rates.rs_nrates; i++) {
1704 if ((ic->ic_bss->ni_rates.rs_rates[i] &
1705 IEEE80211_RATE_VAL) == arg / 5000)
1710 if (i == ic->ic_bss->ni_rates.rs_nrates)
1711 device_printf(sc->ndis_dev, "no matching rate for: %d\n",
1714 ic->ic_bss->ni_txrate = i;
1716 if (ic->ic_caps & IEEE80211_C_PMGT) {
1718 rval = ndis_get_info(sc, OID_802_11_POWER_MODE, &arg, &len);
1721 device_printf(sc->ndis_dev,
1722 "get power mode failed: %d\n", rval);
1723 if (arg == NDIS_80211_POWERMODE_CAM)
1724 ic->ic_flags &= ~IEEE80211_F_PMGTON;
1726 ic->ic_flags |= IEEE80211_F_PMGTON;
1729 len = sizeof(config);
1730 bzero((char *)&config, len);
1731 config.nc_length = len;
1732 config.nc_fhconfig.ncf_length = sizeof(ndis_80211_config_fh);
1733 rval = ndis_get_info(sc, OID_802_11_CONFIGURATION, &config, &len);
1737 chan = ieee80211_mhz2ieee(config.nc_dsconfig / 1000, 0);
1738 if (chan < 0 || chan >= IEEE80211_CHAN_MAX) {
1739 if (ifp->if_flags & IFF_DEBUG)
1740 device_printf(sc->ndis_dev, "current channel "
1741 "(%uMHz) out of bounds\n",
1742 config.nc_dsconfig / 1000);
1743 ic->ic_bss->ni_chan = &ic->ic_channels[1];
1745 ic->ic_bss->ni_chan = &ic->ic_channels[chan];
1747 device_printf(sc->ndis_dev, "couldn't retrieve "
1748 "channel info: %d\n", rval);
1752 rval = ndis_get_info(sc, OID_802_11_WEP_STATUS, &arg, &len);
1755 device_printf (sc->ndis_dev,
1756 "get wep status failed: %d\n", rval);
1758 if (arg == NDIS_80211_WEPSTAT_ENABLED)
1759 ic->ic_flags |= IEEE80211_F_WEPON;
1761 ic->ic_flags &= ~IEEE80211_F_WEPON;
1766 ndis_ioctl(struct ifnet *ifp, u_long command, caddr_t data, struct ucred *cr)
1768 struct ndis_softc *sc = ifp->if_softc;
1769 struct ifreq *ifr = (struct ifreq *) data;
1774 if (ifp->if_flags & IFF_UP) {
1775 if (ifp->if_flags & IFF_RUNNING &&
1776 ifp->if_flags & IFF_PROMISC &&
1777 !(sc->ndis_if_flags & IFF_PROMISC)) {
1779 NDIS_PACKET_TYPE_PROMISCUOUS;
1780 i = sizeof(sc->ndis_filter);
1781 error = ndis_set_info(sc,
1782 OID_GEN_CURRENT_PACKET_FILTER,
1783 &sc->ndis_filter, &i);
1784 } else if (ifp->if_flags & IFF_RUNNING &&
1785 !(ifp->if_flags & IFF_PROMISC) &&
1786 sc->ndis_if_flags & IFF_PROMISC) {
1788 ~NDIS_PACKET_TYPE_PROMISCUOUS;
1789 i = sizeof(sc->ndis_filter);
1790 error = ndis_set_info(sc,
1791 OID_GEN_CURRENT_PACKET_FILTER,
1792 &sc->ndis_filter, &i);
1796 if (ifp->if_flags & IFF_RUNNING)
1799 sc->ndis_if_flags = ifp->if_flags;
1809 if (sc->ndis_80211) {
1810 error = ieee80211_ioctl(&sc->ic, command, data, cr);
1811 if (error == ENETRESET) {
1812 ndis_setstate_80211(sc);
1817 error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
1820 ifp->if_capenable = ifr->ifr_reqcap;
1821 if (ifp->if_capenable & IFCAP_TXCSUM)
1822 ifp->if_hwassist = sc->ndis_hwassist;
1824 ifp->if_hwassist = 0;
1825 ndis_set_offload(sc);
1827 case SIOCGIFGENERIC:
1828 case SIOCSIFGENERIC:
1829 if (sc->ndis_80211 && NDIS_INITIALIZED(sc)) {
1830 if (command == SIOCGIFGENERIC)
1831 error = ndis_wi_ioctl_get(ifp, command, data);
1833 error = ndis_wi_ioctl_set(ifp, command, data);
1836 if (error != ENOTTY)
1840 if (sc->ndis_80211) {
1841 error = ieee80211_ioctl(&sc->ic, command, data, cr);
1842 if (error == ENETRESET) {
1843 ndis_setstate_80211(sc);
1847 error = ether_ioctl(ifp, command, data);
1855 ndis_wi_ioctl_get(struct ifnet *ifp, u_long command, caddr_t data)
1859 struct ndis_softc *sc;
1860 ndis_80211_bssid_list_ex *bl;
1861 ndis_wlan_bssid_ex *wb;
1862 struct wi_apinfo *api;
1863 int error, i, j, len, maxaps;
1866 ifr = (struct ifreq *)data;
1867 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq));
1871 switch (wreq.wi_type) {
1872 case WI_RID_READ_APS:
1874 error = ndis_set_info(sc, OID_802_11_BSSID_LIST_SCAN,
1877 tsleep(&error, PCATCH, "ssidscan", hz * 2);
1879 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, NULL, &len);
1880 if (error != ENOSPC)
1882 bl = kmalloc(len, M_DEVBUF, M_WAITOK|M_ZERO);
1883 error = ndis_get_info(sc, OID_802_11_BSSID_LIST, bl, &len);
1885 kfree(bl, M_DEVBUF);
1888 maxaps = (2 * wreq.wi_len - sizeof(int)) / sizeof(*api);
1889 maxaps = MIN(maxaps, bl->nblx_items);
1890 wreq.wi_len = (maxaps * sizeof(*api) + sizeof(int)) / 2;
1891 *(int *)&wreq.wi_val = maxaps;
1892 api = (struct wi_apinfo *)&((int *)&wreq.wi_val)[1];
1893 wb = bl->nblx_bssid;
1895 bzero(api, sizeof(*api));
1896 bcopy(&wb->nwbx_macaddr, &api->bssid,
1897 sizeof(api->bssid));
1898 api->namelen = wb->nwbx_ssid.ns_ssidlen;
1899 bcopy(&wb->nwbx_ssid.ns_ssid, &api->name, api->namelen);
1900 if (wb->nwbx_privacy)
1901 api->capinfo |= IEEE80211_CAPINFO_PRIVACY;
1902 /* XXX Where can we get noise information? */
1903 api->signal = wb->nwbx_rssi + 149; /* XXX */
1904 api->quality = api->signal;
1906 ieee80211_mhz2ieee(wb->nwbx_config.nc_dsconfig /
1908 /* In "auto" infrastructure mode, this is useless. */
1909 if (wb->nwbx_netinfra == NDIS_80211_NET_INFRA_IBSS)
1910 api->capinfo |= IEEE80211_CAPINFO_IBSS;
1911 if (wb->nwbx_len > sizeof(ndis_wlan_bssid)) {
1912 j = sizeof(ndis_80211_rates_ex);
1913 /* handle other extended things */
1915 j = sizeof(ndis_80211_rates);
1916 for (i = api->rate = 0; i < j; i++)
1917 api->rate = MAX(api->rate, 5 *
1918 (wb->nwbx_supportedrates[i] & 0x7f));
1920 wb = (ndis_wlan_bssid_ex *)((char *)wb + wb->nwbx_len);
1922 kfree(bl, M_DEVBUF);
1923 error = copyout(&wreq, ifr->ifr_data, sizeof(wreq));
1933 ndis_wi_ioctl_set(struct ifnet *ifp, u_long command, caddr_t data)
1937 struct ndis_softc *sc;
1941 error = suser(curthread);
1946 ifr = (struct ifreq *)data;
1947 error = copyin(ifr->ifr_data, &wreq, sizeof(wreq));
1951 switch (wreq.wi_type) {
1952 case WI_RID_SCAN_APS:
1953 case WI_RID_SCAN_REQ: /* arguments ignored */
1956 error = ndis_set_info(sc, OID_802_11_BSSID_LIST_SCAN, &foo,
1967 ndis_watchdog(struct ifnet *ifp)
1969 struct ndis_softc *sc;
1974 device_printf(sc->ndis_dev, "watchdog timeout\n");
1977 ndis_sched(ndis_starttask, ifp, NDIS_TASKQUEUE);
1981 * Stop the adapter and free any mbufs allocated to the
1985 ndis_stop(struct ndis_softc *sc)
1989 ifp = &sc->arpcom.ac_if;
1990 callout_stop(&sc->ndis_stat_timer);
1996 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
2000 * Stop all chip I/O so that the kernel's probe routines don't
2001 * get confused by errant DMAs when rebooting.
2004 ndis_shutdown(device_t dev)
2006 struct ndis_softc *sc;
2009 sc = device_get_softc(dev);
2010 ifp = &sc->arpcom.ac_if;
2011 lwkt_serialize_enter(ifp->if_serializer);
2012 ndis_shutdown_nic(sc);
2013 lwkt_serialize_exit(ifp->if_serializer);