1 /* src/p80211/p80211knetdev.c
3 * Linux Kernel net device interface
5 * Copyright (C) 1999 AbsoluteValue Systems, Inc. All Rights Reserved.
6 * --------------------------------------------------------------------
10 * The contents of this file are subject to the Mozilla Public
11 * License Version 1.1 (the "License"); you may not use this file
12 * except in compliance with the License. You may obtain a copy of
13 * the License at http://www.mozilla.org/MPL/
15 * Software distributed under the License is distributed on an "AS
16 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17 * implied. See the License for the specific language governing
18 * rights and limitations under the License.
20 * Alternatively, the contents of this file may be used under the
21 * terms of the GNU Public License version 2 (the "GPL"), in which
22 * case the provisions of the GPL are applicable instead of the
23 * above. If you wish to allow the use of your version of this file
24 * only under the terms of the GPL and not to allow others to use
25 * your version of this file under the MPL, indicate your decision
26 * by deleting the provisions above and replace them with the notice
27 * and other provisions required by the GPL. If you do not delete
28 * the provisions above, a recipient may use your version of this
29 * file under either the MPL or the GPL.
31 * --------------------------------------------------------------------
33 * Inquiries regarding the linux-wlan Open Source project can be
36 * AbsoluteValue Systems Inc.
38 * http://www.linux-wlan.com
40 * --------------------------------------------------------------------
42 * Portions of the development of this software were funded by
43 * Intersil Corporation as part of PRISM(R) chipset product development.
45 * --------------------------------------------------------------------
47 * The functions required for a Linux network device are defined here.
49 * --------------------------------------------------------------------
52 #include <linux/module.h>
53 #include <linux/kernel.h>
54 #include <linux/sched.h>
55 #include <linux/types.h>
56 #include <linux/skbuff.h>
57 #include <linux/slab.h>
58 #include <linux/proc_fs.h>
59 #include <linux/interrupt.h>
60 #include <linux/netdevice.h>
61 #include <linux/kmod.h>
62 #include <linux/if_arp.h>
63 #include <linux/wireless.h>
64 #include <linux/sockios.h>
65 #include <linux/etherdevice.h>
66 #include <linux/if_ether.h>
67 #include <linux/byteorder/generic.h>
68 #include <linux/bitops.h>
69 #include <linux/uaccess.h>
70 #include <asm/byteorder.h>
73 #include <linux/ethtool.h>
76 #include <net/iw_handler.h>
77 #include <net/net_namespace.h>
78 #include <net/cfg80211.h>
80 #include "p80211types.h"
81 #include "p80211hdr.h"
82 #include "p80211conv.h"
83 #include "p80211mgmt.h"
84 #include "p80211msg.h"
85 #include "p80211netdev.h"
86 #include "p80211ioctl.h"
87 #include "p80211req.h"
88 #include "p80211metastruct.h"
89 #include "p80211metadef.h"
93 /* Support functions */
94 static void p80211netdev_rx_bh(unsigned long arg
);
96 /* netdevice method functions */
97 static int p80211knetdev_init(netdevice_t
*netdev
);
98 static struct net_device_stats
*p80211knetdev_get_stats(netdevice_t
*netdev
);
99 static int p80211knetdev_open(netdevice_t
*netdev
);
100 static int p80211knetdev_stop(netdevice_t
*netdev
);
101 static int p80211knetdev_hard_start_xmit(struct sk_buff
*skb
,
102 netdevice_t
*netdev
);
103 static void p80211knetdev_set_multicast_list(netdevice_t
*dev
);
104 static int p80211knetdev_do_ioctl(netdevice_t
*dev
, struct ifreq
*ifr
,
106 static int p80211knetdev_set_mac_address(netdevice_t
*dev
, void *addr
);
107 static void p80211knetdev_tx_timeout(netdevice_t
*netdev
);
108 static int p80211_rx_typedrop(wlandevice_t
*wlandev
, u16 fc
);
110 int wlan_watchdog
= 5000;
111 module_param(wlan_watchdog
, int, 0644);
112 MODULE_PARM_DESC(wlan_watchdog
, "transmit timeout in milliseconds");
114 int wlan_wext_write
= 1;
115 module_param(wlan_wext_write
, int, 0644);
116 MODULE_PARM_DESC(wlan_wext_write
, "enable write wireless extensions");
118 /*----------------------------------------------------------------
121 * Init method for a Linux netdevice. Called in response to
129 ----------------------------------------------------------------*/
130 static int p80211knetdev_init(netdevice_t
*netdev
)
132 /* Called in response to register_netdev */
133 /* This is usually the probe function, but the probe has */
134 /* already been done by the MSD and the create_kdev */
135 /* function. All we do here is return success */
139 /*----------------------------------------------------------------
140 * p80211knetdev_get_stats
142 * Statistics retrieval for linux netdevices. Here we're reporting
143 * the Linux i/f level statistics. Hence, for the primary numbers,
144 * we don't want to report the numbers from the MIB. Eventually,
145 * it might be useful to collect some of the error counters though.
148 * netdev Linux netdevice
151 * the address of the statistics structure
152 ----------------------------------------------------------------*/
153 static struct net_device_stats
*p80211knetdev_get_stats(netdevice_t
* netdev
)
155 wlandevice_t
*wlandev
= netdev
->ml_priv
;
157 /* TODO: review the MIB stats for items that correspond to
160 return &(wlandev
->linux_stats
);
163 /*----------------------------------------------------------------
166 * Linux netdevice open method. Following a successful call here,
167 * the device is supposed to be ready for tx and rx. In our
168 * situation that may not be entirely true due to the state of the
172 * netdev Linux network device structure
175 * zero on success, non-zero otherwise
176 ----------------------------------------------------------------*/
177 static int p80211knetdev_open(netdevice_t
*netdev
)
179 int result
= 0; /* success */
180 wlandevice_t
*wlandev
= netdev
->ml_priv
;
182 /* Check to make sure the MSD is running */
183 if (wlandev
->msdstate
!= WLAN_MSD_RUNNING
)
186 /* Tell the MSD to open */
187 if (wlandev
->open
!= NULL
) {
188 result
= wlandev
->open(wlandev
);
190 netif_start_queue(wlandev
->netdev
);
191 wlandev
->state
= WLAN_DEVICE_OPEN
;
200 /*----------------------------------------------------------------
203 * Linux netdevice stop (close) method. Following this call,
204 * no frames should go up or down through this interface.
207 * netdev Linux network device structure
210 * zero on success, non-zero otherwise
211 ----------------------------------------------------------------*/
212 static int p80211knetdev_stop(netdevice_t
*netdev
)
215 wlandevice_t
*wlandev
= netdev
->ml_priv
;
217 if (wlandev
->close
!= NULL
)
218 result
= wlandev
->close(wlandev
);
220 netif_stop_queue(wlandev
->netdev
);
221 wlandev
->state
= WLAN_DEVICE_CLOSED
;
226 /*----------------------------------------------------------------
229 * Frame receive function called by the mac specific driver.
232 * wlandev WLAN network device structure
233 * skb skbuff containing a full 802.11 frame.
238 ----------------------------------------------------------------*/
239 void p80211netdev_rx(wlandevice_t
*wlandev
, struct sk_buff
*skb
)
241 /* Enqueue for post-irq processing */
242 skb_queue_tail(&wlandev
->nsd_rxq
, skb
);
244 tasklet_schedule(&wlandev
->rx_bh
);
249 /*----------------------------------------------------------------
252 * Deferred processing of all received frames.
255 * wlandev WLAN network device structure
256 * skb skbuff containing a full 802.11 frame.
261 ----------------------------------------------------------------*/
262 static void p80211netdev_rx_bh(unsigned long arg
)
264 wlandevice_t
*wlandev
= (wlandevice_t
*) arg
;
265 struct sk_buff
*skb
= NULL
;
266 netdevice_t
*dev
= wlandev
->netdev
;
267 struct p80211_hdr_a3
*hdr
;
270 /* Let's empty our our queue */
271 while ((skb
= skb_dequeue(&wlandev
->nsd_rxq
))) {
272 if (wlandev
->state
== WLAN_DEVICE_OPEN
) {
274 if (dev
->type
!= ARPHRD_ETHER
) {
275 /* RAW frame; we shouldn't convert it */
276 /* XXX Append the Prism Header here instead. */
278 /* set up various data fields */
280 skb_reset_mac_header(skb
);
281 skb
->ip_summed
= CHECKSUM_NONE
;
282 skb
->pkt_type
= PACKET_OTHERHOST
;
283 skb
->protocol
= htons(ETH_P_80211_RAW
);
284 dev
->last_rx
= jiffies
;
286 wlandev
->linux_stats
.rx_packets
++;
287 wlandev
->linux_stats
.rx_bytes
+= skb
->len
;
291 hdr
= (struct p80211_hdr_a3
*) skb
->data
;
292 fc
= le16_to_cpu(hdr
->fc
);
293 if (p80211_rx_typedrop(wlandev
, fc
)) {
298 /* perform mcast filtering */
299 if (wlandev
->netdev
->flags
& IFF_ALLMULTI
) {
300 /* allow my local address through */
302 (hdr
->a1
, wlandev
->netdev
->dev_addr
,
304 /* but reject anything else that isn't multicast */
305 if (!(hdr
->a1
[0] & 0x01)) {
312 if (skb_p80211_to_ether
313 (wlandev
, wlandev
->ethconv
, skb
) == 0) {
314 skb
->dev
->last_rx
= jiffies
;
315 wlandev
->linux_stats
.rx_packets
++;
316 wlandev
->linux_stats
.rx_bytes
+=
321 pr_debug("p80211_to_ether failed.\n");
328 /*----------------------------------------------------------------
329 * p80211knetdev_hard_start_xmit
331 * Linux netdevice method for transmitting a frame.
334 * skb Linux sk_buff containing the frame.
335 * netdev Linux netdevice.
338 * If the lower layers report that buffers are full. netdev->tbusy
339 * will be set to prevent higher layers from sending more traffic.
341 * Note: If this function returns non-zero, higher layers retain
342 * ownership of the skb.
345 * zero on success, non-zero on failure.
346 ----------------------------------------------------------------*/
347 static int p80211knetdev_hard_start_xmit(struct sk_buff
*skb
,
352 wlandevice_t
*wlandev
= netdev
->ml_priv
;
353 union p80211_hdr p80211_hdr
;
354 struct p80211_metawep p80211_wep
;
359 if (wlandev
->state
!= WLAN_DEVICE_OPEN
) {
364 memset(&p80211_hdr
, 0, sizeof(union p80211_hdr
));
365 memset(&p80211_wep
, 0, sizeof(struct p80211_metawep
));
367 if (netif_queue_stopped(netdev
)) {
368 pr_debug("called when queue stopped.\n");
373 netif_stop_queue(netdev
);
375 /* Check to see that a valid mode is set */
376 switch (wlandev
->macmode
) {
377 case WLAN_MACMODE_IBSS_STA
:
378 case WLAN_MACMODE_ESS_STA
:
379 case WLAN_MACMODE_ESS_AP
:
382 /* Mode isn't set yet, just drop the frame
383 * and return success .
384 * TODO: we need a saner way to handle this
386 if (skb
->protocol
!= ETH_P_80211_RAW
) {
387 netif_start_queue(wlandev
->netdev
);
389 "Tx attempt prior to association, frame dropped.\n");
390 wlandev
->linux_stats
.tx_dropped
++;
397 /* Check for raw transmits */
398 if (skb
->protocol
== ETH_P_80211_RAW
) {
399 if (!capable(CAP_NET_ADMIN
)) {
403 /* move the header over */
404 memcpy(&p80211_hdr
, skb
->data
, sizeof(union p80211_hdr
));
405 skb_pull(skb
, sizeof(union p80211_hdr
));
407 if (skb_ether_to_p80211
408 (wlandev
, wlandev
->ethconv
, skb
, &p80211_hdr
,
411 pr_debug("ether_to_80211(%d) failed.\n",
417 if (wlandev
->txframe
== NULL
) {
422 netdev
->trans_start
= jiffies
;
424 wlandev
->linux_stats
.tx_packets
++;
425 /* count only the packet payload */
426 wlandev
->linux_stats
.tx_bytes
+= skb
->len
;
428 txresult
= wlandev
->txframe(wlandev
, skb
, &p80211_hdr
, &p80211_wep
);
431 /* success and more buf */
432 /* avail, re: hw_txdata */
433 netif_wake_queue(wlandev
->netdev
);
434 result
= NETDEV_TX_OK
;
435 } else if (txresult
== 1) {
436 /* success, no more avail */
437 pr_debug("txframe success, no more bufs\n");
438 /* netdev->tbusy = 1; don't set here, irqhdlr */
439 /* may have already cleared it */
440 result
= NETDEV_TX_OK
;
441 } else if (txresult
== 2) {
442 /* alloc failure, drop frame */
443 pr_debug("txframe returned alloc_fail\n");
444 result
= NETDEV_TX_BUSY
;
446 /* buffer full or queue busy, drop frame. */
447 pr_debug("txframe returned full or busy\n");
448 result
= NETDEV_TX_BUSY
;
452 /* Free up the WEP buffer if it's not the same as the skb */
453 if ((p80211_wep
.data
) && (p80211_wep
.data
!= skb
->data
))
454 kzfree(p80211_wep
.data
);
456 /* we always free the skb here, never in a lower level. */
463 /*----------------------------------------------------------------
464 * p80211knetdev_set_multicast_list
466 * Called from higher lavers whenever there's a need to set/clear
467 * promiscuous mode or rewrite the multicast list.
474 ----------------------------------------------------------------*/
475 static void p80211knetdev_set_multicast_list(netdevice_t
*dev
)
477 wlandevice_t
*wlandev
= dev
->ml_priv
;
479 /* TODO: real multicast support as well */
481 if (wlandev
->set_multicast_list
)
482 wlandev
->set_multicast_list(wlandev
, dev
);
488 static int p80211netdev_ethtool(wlandevice_t
*wlandev
, void __user
*useraddr
)
491 struct ethtool_drvinfo info
;
492 struct ethtool_value edata
;
494 memset(&info
, 0, sizeof(info
));
495 memset(&edata
, 0, sizeof(edata
));
497 if (copy_from_user(ðcmd
, useraddr
, sizeof(ethcmd
)))
501 case ETHTOOL_GDRVINFO
:
503 snprintf(info
.driver
, sizeof(info
.driver
), "p80211_%s",
505 snprintf(info
.version
, sizeof(info
.version
), "%s",
508 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
515 if (wlandev
->linkstatus
&&
516 (wlandev
->macmode
!= WLAN_MACMODE_NONE
)) {
522 if (copy_to_user(useraddr
, &edata
, sizeof(edata
)))
533 /*----------------------------------------------------------------
534 * p80211knetdev_do_ioctl
536 * Handle an ioctl call on one of our devices. Everything Linux
537 * ioctl specific is done here. Then we pass the contents of the
538 * ifr->data to the request message handler.
541 * dev Linux kernel netdevice
542 * ifr Our private ioctl request structure, typed for the
543 * generic struct ifreq so we can use ptr to func
547 * zero on success, a negative errno on failure. Possible values:
548 * -ENETDOWN Device isn't up.
549 * -EBUSY cmd already in progress
550 * -ETIME p80211 cmd timed out (MSD may have its own timers)
551 * -EFAULT memory fault copying msg from user buffer
552 * -ENOMEM unable to allocate kernel msg buffer
553 * -ENOSYS bad magic, it the cmd really for us?
554 * -EintR sleeping on cmd, awakened by signal, cmd cancelled.
557 * Process thread (ioctl caller). TODO: SMP support may require
559 ----------------------------------------------------------------*/
560 static int p80211knetdev_do_ioctl(netdevice_t
*dev
, struct ifreq
*ifr
, int cmd
)
563 p80211ioctl_req_t
*req
= (p80211ioctl_req_t
*) ifr
;
564 wlandevice_t
*wlandev
= dev
->ml_priv
;
567 pr_debug("rx'd ioctl, cmd=%d, len=%d\n", cmd
, req
->len
);
570 if (cmd
== SIOCETHTOOL
) {
572 p80211netdev_ethtool(wlandev
, (void __user
*)ifr
->ifr_data
);
577 /* Test the magic, assume ifr is good if it's there */
578 if (req
->magic
!= P80211_IOCTL_MAGIC
) {
583 if (cmd
== P80211_IFTEST
) {
586 } else if (cmd
!= P80211_IFREQ
) {
591 /* Allocate a buf of size req->len */
592 msgbuf
= kmalloc(req
->len
, GFP_KERNEL
);
594 if (copy_from_user(msgbuf
, (void __user
*)req
->data
, req
->len
))
597 result
= p80211req_dorequest(wlandev
, msgbuf
);
601 ((void __user
*)req
->data
, msgbuf
, req
->len
)) {
610 return result
; /* If allocate,copyfrom or copyto fails, return errno */
613 /*----------------------------------------------------------------
614 * p80211knetdev_set_mac_address
616 * Handles the ioctl for changing the MACAddress of a netdevice
618 * references: linux/netdevice.h and drivers/net/net_init.c
620 * NOTE: [MSM] We only prevent address changes when the netdev is
621 * up. We don't control anything based on dot11 state. If the
622 * address is changed on a STA that's currently associated, you
623 * will probably lose the ability to send and receive data frames.
624 * Just be aware. Therefore, this should usually only be done
625 * prior to scan/join/auth/assoc.
628 * dev netdevice struct
629 * addr the new MACAddress (a struct)
632 * zero on success, a negative errno on failure. Possible values:
633 * -EBUSY device is bussy (cmd not possible)
634 * -and errors returned by: p80211req_dorequest(..)
636 * by: Collin R. Mulliner <collin@mulliner.org>
637 ----------------------------------------------------------------*/
638 static int p80211knetdev_set_mac_address(netdevice_t
*dev
, void *addr
)
640 struct sockaddr
*new_addr
= addr
;
641 p80211msg_dot11req_mibset_t dot11req
;
642 p80211item_unk392_t
*mibattr
;
643 p80211item_pstr6_t
*macaddr
;
644 p80211item_uint32_t
*resultcode
;
647 /* If we're running, we don't allow MAC address changes */
648 if (netif_running(dev
))
651 /* Set up some convenience pointers. */
652 mibattr
= &dot11req
.mibattribute
;
653 macaddr
= (p80211item_pstr6_t
*) &mibattr
->data
;
654 resultcode
= &dot11req
.resultcode
;
656 /* Set up a dot11req_mibset */
657 memset(&dot11req
, 0, sizeof(p80211msg_dot11req_mibset_t
));
658 dot11req
.msgcode
= DIDmsg_dot11req_mibset
;
659 dot11req
.msglen
= sizeof(p80211msg_dot11req_mibset_t
);
660 memcpy(dot11req
.devname
,
661 ((wlandevice_t
*) dev
->ml_priv
)->name
, WLAN_DEVNAMELEN_MAX
- 1);
663 /* Set up the mibattribute argument */
664 mibattr
->did
= DIDmsg_dot11req_mibset_mibattribute
;
665 mibattr
->status
= P80211ENUM_msgitem_status_data_ok
;
666 mibattr
->len
= sizeof(mibattr
->data
);
668 macaddr
->did
= DIDmib_dot11mac_dot11OperationTable_dot11MACAddress
;
669 macaddr
->status
= P80211ENUM_msgitem_status_data_ok
;
670 macaddr
->len
= sizeof(macaddr
->data
);
671 macaddr
->data
.len
= ETH_ALEN
;
672 memcpy(&macaddr
->data
.data
, new_addr
->sa_data
, ETH_ALEN
);
674 /* Set up the resultcode argument */
675 resultcode
->did
= DIDmsg_dot11req_mibset_resultcode
;
676 resultcode
->status
= P80211ENUM_msgitem_status_no_value
;
677 resultcode
->len
= sizeof(resultcode
->data
);
678 resultcode
->data
= 0;
680 /* now fire the request */
681 result
= p80211req_dorequest(dev
->ml_priv
, (u8
*) &dot11req
);
683 /* If the request wasn't successful, report an error and don't
684 * change the netdev address
686 if (result
!= 0 || resultcode
->data
!= P80211ENUM_resultcode_success
) {
688 "Low-level driver failed dot11req_mibset(dot11MACAddress).\n");
689 result
= -EADDRNOTAVAIL
;
691 /* everything's ok, change the addr in netdev */
692 memcpy(dev
->dev_addr
, new_addr
->sa_data
, dev
->addr_len
);
698 static int wlan_change_mtu(netdevice_t
*dev
, int new_mtu
)
700 /* 2312 is max 802.11 payload, 20 is overhead, (ether + llc +snap)
701 and another 8 for wep. */
702 if ((new_mtu
< 68) || (new_mtu
> (2312 - 20 - 8)))
710 static const struct net_device_ops p80211_netdev_ops
= {
711 .ndo_init
= p80211knetdev_init
,
712 .ndo_open
= p80211knetdev_open
,
713 .ndo_stop
= p80211knetdev_stop
,
714 .ndo_get_stats
= p80211knetdev_get_stats
,
715 .ndo_start_xmit
= p80211knetdev_hard_start_xmit
,
716 .ndo_set_multicast_list
= p80211knetdev_set_multicast_list
,
717 .ndo_do_ioctl
= p80211knetdev_do_ioctl
,
718 .ndo_set_mac_address
= p80211knetdev_set_mac_address
,
719 .ndo_tx_timeout
= p80211knetdev_tx_timeout
,
720 .ndo_change_mtu
= wlan_change_mtu
,
721 .ndo_validate_addr
= eth_validate_addr
,
724 /*----------------------------------------------------------------
727 * Roughly matches the functionality of ether_setup. Here
728 * we set up any members of the wlandevice structure that are common
729 * to all devices. Additionally, we allocate a linux 'struct device'
730 * and perform the same setup as ether_setup.
732 * Note: It's important that the caller have setup the wlandev->name
733 * ptr prior to calling this function.
736 * wlandev ptr to the wlandev structure for the
738 * physdev ptr to usb device
740 * zero on success, non-zero otherwise.
742 * Should be process thread. We'll assume it might be
743 * interrupt though. When we add support for statically
744 * compiled drivers, this function will be called in the
745 * context of the kernel startup code.
746 ----------------------------------------------------------------*/
747 int wlan_setup(wlandevice_t
*wlandev
, struct device
*physdev
)
752 struct wireless_dev
*wdev
;
754 /* Set up the wlandev */
755 wlandev
->state
= WLAN_DEVICE_CLOSED
;
756 wlandev
->ethconv
= WLAN_ETHCONV_8021h
;
757 wlandev
->macmode
= WLAN_MACMODE_NONE
;
759 /* Set up the rx queue */
760 skb_queue_head_init(&wlandev
->nsd_rxq
);
761 tasklet_init(&wlandev
->rx_bh
,
762 p80211netdev_rx_bh
, (unsigned long)wlandev
);
764 /* Allocate and initialize the wiphy struct */
765 wiphy
= wlan_create_wiphy(physdev
, wlandev
);
767 printk(KERN_ERR
"Failed to alloc wiphy.\n");
771 /* Allocate and initialize the struct device */
772 netdev
= alloc_netdev(sizeof(struct wireless_dev
), "wlan%d", ether_setup
);
773 if (netdev
== NULL
) {
774 printk(KERN_ERR
"Failed to alloc netdev.\n");
775 wlan_free_wiphy(wiphy
);
778 wlandev
->netdev
= netdev
;
779 netdev
->ml_priv
= wlandev
;
780 netdev
->netdev_ops
= &p80211_netdev_ops
;
781 wdev
= netdev_priv(netdev
);
783 wdev
->iftype
= NL80211_IFTYPE_STATION
;
784 netdev
->ieee80211_ptr
= wdev
;
786 netif_stop_queue(netdev
);
787 netif_carrier_off(netdev
);
793 /*----------------------------------------------------------------
796 * This function is paired with the wlan_setup routine. It should
797 * be called after unregister_wlandev. Basically, all it does is
798 * free the 'struct device' that's associated with the wlandev.
799 * We do it here because the 'struct device' isn't allocated
800 * explicitly in the driver code, it's done in wlan_setup. To
801 * do the free in the driver might seem like 'magic'.
804 * wlandev ptr to the wlandev structure for the
807 * zero on success, non-zero otherwise.
809 * Should be process thread. We'll assume it might be
810 * interrupt though. When we add support for statically
811 * compiled drivers, this function will be called in the
812 * context of the kernel startup code.
813 ----------------------------------------------------------------*/
814 int wlan_unsetup(wlandevice_t
*wlandev
)
816 struct wireless_dev
*wdev
;
818 tasklet_kill(&wlandev
->rx_bh
);
820 if (wlandev
->netdev
) {
821 wdev
= netdev_priv(wlandev
->netdev
);
823 wlan_free_wiphy(wdev
->wiphy
);
824 free_netdev(wlandev
->netdev
);
825 wlandev
->netdev
= NULL
;
831 /*----------------------------------------------------------------
834 * Roughly matches the functionality of register_netdev. This function
835 * is called after the driver has successfully probed and set up the
836 * resources for the device. It's now ready to become a named device
837 * in the Linux system.
839 * First we allocate a name for the device (if not already set), then
840 * we call the Linux function register_netdevice.
843 * wlandev ptr to the wlandev structure for the
846 * zero on success, non-zero otherwise.
848 * Can be either interrupt or not.
849 ----------------------------------------------------------------*/
850 int register_wlandev(wlandevice_t
*wlandev
)
854 i
= register_netdev(wlandev
->netdev
);
861 /*----------------------------------------------------------------
864 * Roughly matches the functionality of unregister_netdev. This
865 * function is called to remove a named device from the system.
867 * First we tell linux that the device should no longer exist.
868 * Then we remove it from the list of known wlan devices.
871 * wlandev ptr to the wlandev structure for the
874 * zero on success, non-zero otherwise.
876 * Can be either interrupt or not.
877 ----------------------------------------------------------------*/
878 int unregister_wlandev(wlandevice_t
*wlandev
)
882 unregister_netdev(wlandev
->netdev
);
884 /* Now to clean out the rx queue */
885 while ((skb
= skb_dequeue(&wlandev
->nsd_rxq
)))
891 /*----------------------------------------------------------------
892 * p80211netdev_hwremoved
894 * Hardware removed notification. This function should be called
895 * immediately after an MSD has detected that the underlying hardware
896 * has been yanked out from under us. The primary things we need
899 * - Prevent any further traffic from the knetdev i/f
900 * - Prevent any further requests from mgmt i/f
901 * - If there are any waitq'd mgmt requests or mgmt-frame exchanges,
903 * - Call the MSD hwremoved function.
905 * The remainder of the cleanup will be handled by unregister().
906 * Our primary goal here is to prevent as much tickling of the MSD
907 * as possible since the MSD is already in a 'wounded' state.
909 * TODO: As new features are added, this function should be
913 * wlandev WLAN network device structure
920 ----------------------------------------------------------------*/
921 void p80211netdev_hwremoved(wlandevice_t
*wlandev
)
923 wlandev
->hwremoved
= 1;
924 if (wlandev
->state
== WLAN_DEVICE_OPEN
)
925 netif_stop_queue(wlandev
->netdev
);
927 netif_device_detach(wlandev
->netdev
);
930 /*----------------------------------------------------------------
933 * Classifies the frame, increments the appropriate counter, and
934 * returns 0|1|2 indicating whether the driver should handle, ignore, or
938 * wlandev wlan device structure
939 * fc frame control field
942 * zero if the frame should be handled by the driver,
943 * one if the frame should be ignored
944 * anything else means we drop it.
950 ----------------------------------------------------------------*/
951 static int p80211_rx_typedrop(wlandevice_t
*wlandev
, u16 fc
)
956 /* Classify frame, increment counter */
957 ftype
= WLAN_GET_FC_FTYPE(fc
);
958 fstype
= WLAN_GET_FC_FSTYPE(fc
);
960 pr_debug("rx_typedrop : ftype=%d fstype=%d.\n", ftype
, fstype
);
963 case WLAN_FTYPE_MGMT
:
964 if ((wlandev
->netdev
->flags
& IFF_PROMISC
) ||
965 (wlandev
->netdev
->flags
& IFF_ALLMULTI
)) {
969 pr_debug("rx'd mgmt:\n");
972 case WLAN_FSTYPE_ASSOCREQ
:
973 /* printk("assocreq"); */
974 wlandev
->rx
.assocreq
++;
976 case WLAN_FSTYPE_ASSOCRESP
:
977 /* printk("assocresp"); */
978 wlandev
->rx
.assocresp
++;
980 case WLAN_FSTYPE_REASSOCREQ
:
981 /* printk("reassocreq"); */
982 wlandev
->rx
.reassocreq
++;
984 case WLAN_FSTYPE_REASSOCRESP
:
985 /* printk("reassocresp"); */
986 wlandev
->rx
.reassocresp
++;
988 case WLAN_FSTYPE_PROBEREQ
:
989 /* printk("probereq"); */
990 wlandev
->rx
.probereq
++;
992 case WLAN_FSTYPE_PROBERESP
:
993 /* printk("proberesp"); */
994 wlandev
->rx
.proberesp
++;
996 case WLAN_FSTYPE_BEACON
:
997 /* printk("beacon"); */
998 wlandev
->rx
.beacon
++;
1000 case WLAN_FSTYPE_ATIM
:
1001 /* printk("atim"); */
1004 case WLAN_FSTYPE_DISASSOC
:
1005 /* printk("disassoc"); */
1006 wlandev
->rx
.disassoc
++;
1008 case WLAN_FSTYPE_AUTHEN
:
1009 /* printk("authen"); */
1010 wlandev
->rx
.authen
++;
1012 case WLAN_FSTYPE_DEAUTHEN
:
1013 /* printk("deauthen"); */
1014 wlandev
->rx
.deauthen
++;
1017 /* printk("unknown"); */
1018 wlandev
->rx
.mgmt_unknown
++;
1025 case WLAN_FTYPE_CTL
:
1026 if ((wlandev
->netdev
->flags
& IFF_PROMISC
) ||
1027 (wlandev
->netdev
->flags
& IFF_ALLMULTI
)) {
1031 pr_debug("rx'd ctl:\n");
1034 case WLAN_FSTYPE_PSPOLL
:
1035 /* printk("pspoll"); */
1036 wlandev
->rx
.pspoll
++;
1038 case WLAN_FSTYPE_RTS
:
1039 /* printk("rts"); */
1042 case WLAN_FSTYPE_CTS
:
1043 /* printk("cts"); */
1046 case WLAN_FSTYPE_ACK
:
1047 /* printk("ack"); */
1050 case WLAN_FSTYPE_CFEND
:
1051 /* printk("cfend"); */
1052 wlandev
->rx
.cfend
++;
1054 case WLAN_FSTYPE_CFENDCFACK
:
1055 /* printk("cfendcfack"); */
1056 wlandev
->rx
.cfendcfack
++;
1059 /* printk("unknown"); */
1060 wlandev
->rx
.ctl_unknown
++;
1067 case WLAN_FTYPE_DATA
:
1070 case WLAN_FSTYPE_DATAONLY
:
1071 wlandev
->rx
.dataonly
++;
1073 case WLAN_FSTYPE_DATA_CFACK
:
1074 wlandev
->rx
.data_cfack
++;
1076 case WLAN_FSTYPE_DATA_CFPOLL
:
1077 wlandev
->rx
.data_cfpoll
++;
1079 case WLAN_FSTYPE_DATA_CFACK_CFPOLL
:
1080 wlandev
->rx
.data__cfack_cfpoll
++;
1082 case WLAN_FSTYPE_NULL
:
1083 pr_debug("rx'd data:null\n");
1086 case WLAN_FSTYPE_CFACK
:
1087 pr_debug("rx'd data:cfack\n");
1088 wlandev
->rx
.cfack
++;
1090 case WLAN_FSTYPE_CFPOLL
:
1091 pr_debug("rx'd data:cfpoll\n");
1092 wlandev
->rx
.cfpoll
++;
1094 case WLAN_FSTYPE_CFACK_CFPOLL
:
1095 pr_debug("rx'd data:cfack_cfpoll\n");
1096 wlandev
->rx
.cfack_cfpoll
++;
1099 /* printk("unknown"); */
1100 wlandev
->rx
.data_unknown
++;
1109 static void p80211knetdev_tx_timeout(netdevice_t
*netdev
)
1111 wlandevice_t
*wlandev
= netdev
->ml_priv
;
1113 if (wlandev
->tx_timeout
) {
1114 wlandev
->tx_timeout(wlandev
);
1116 printk(KERN_WARNING
"Implement tx_timeout for %s\n",
1118 netif_wake_queue(wlandev
->netdev
);