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
306 if (!(hdr->a1[0] & 0x01)) {
313 if (skb_p80211_to_ether
314 (wlandev, wlandev->ethconv, skb) == 0) {
315 skb->dev->last_rx = jiffies;
316 wlandev->linux_stats.rx_packets++;
317 wlandev->linux_stats.rx_bytes +=
322 pr_debug("p80211_to_ether failed.\n");
329 /*----------------------------------------------------------------
330 * p80211knetdev_hard_start_xmit
332 * Linux netdevice method for transmitting a frame.
335 * skb Linux sk_buff containing the frame.
336 * netdev Linux netdevice.
339 * If the lower layers report that buffers are full. netdev->tbusy
340 * will be set to prevent higher layers from sending more traffic.
342 * Note: If this function returns non-zero, higher layers retain
343 * ownership of the skb.
346 * zero on success, non-zero on failure.
347 ----------------------------------------------------------------*/
348 static int p80211knetdev_hard_start_xmit(struct sk_buff *skb,
353 wlandevice_t *wlandev = netdev->ml_priv;
354 union p80211_hdr p80211_hdr;
355 struct p80211_metawep p80211_wep;
360 if (wlandev->state != WLAN_DEVICE_OPEN) {
365 memset(&p80211_hdr, 0, sizeof(union p80211_hdr));
366 memset(&p80211_wep, 0, sizeof(struct p80211_metawep));
368 if (netif_queue_stopped(netdev)) {
369 pr_debug("called when queue stopped.\n");
374 netif_stop_queue(netdev);
376 /* Check to see that a valid mode is set */
377 switch (wlandev->macmode) {
378 case WLAN_MACMODE_IBSS_STA:
379 case WLAN_MACMODE_ESS_STA:
380 case WLAN_MACMODE_ESS_AP:
383 /* Mode isn't set yet, just drop the frame
384 * and return success .
385 * TODO: we need a saner way to handle this
387 if (skb->protocol != ETH_P_80211_RAW) {
388 netif_start_queue(wlandev->netdev);
390 "Tx attempt prior to association, frame dropped.\n");
391 wlandev->linux_stats.tx_dropped++;
398 /* Check for raw transmits */
399 if (skb->protocol == ETH_P_80211_RAW) {
400 if (!capable(CAP_NET_ADMIN)) {
404 /* move the header over */
405 memcpy(&p80211_hdr, skb->data, sizeof(union p80211_hdr));
406 skb_pull(skb, sizeof(union p80211_hdr));
408 if (skb_ether_to_p80211
409 (wlandev, wlandev->ethconv, skb, &p80211_hdr,
412 pr_debug("ether_to_80211(%d) failed.\n",
418 if (wlandev->txframe == NULL) {
423 netdev->trans_start = jiffies;
425 wlandev->linux_stats.tx_packets++;
426 /* count only the packet payload */
427 wlandev->linux_stats.tx_bytes += skb->len;
429 txresult = wlandev->txframe(wlandev, skb, &p80211_hdr, &p80211_wep);
432 /* success and more buf */
433 /* avail, re: hw_txdata */
434 netif_wake_queue(wlandev->netdev);
435 result = NETDEV_TX_OK;
436 } else if (txresult == 1) {
437 /* success, no more avail */
438 pr_debug("txframe success, no more bufs\n");
439 /* netdev->tbusy = 1; don't set here, irqhdlr */
440 /* may have already cleared it */
441 result = NETDEV_TX_OK;
442 } else if (txresult == 2) {
443 /* alloc failure, drop frame */
444 pr_debug("txframe returned alloc_fail\n");
445 result = NETDEV_TX_BUSY;
447 /* buffer full or queue busy, drop frame. */
448 pr_debug("txframe returned full or busy\n");
449 result = NETDEV_TX_BUSY;
453 /* Free up the WEP buffer if it's not the same as the skb */
454 if ((p80211_wep.data) && (p80211_wep.data != skb->data))
455 kzfree(p80211_wep.data);
457 /* we always free the skb here, never in a lower level. */
464 /*----------------------------------------------------------------
465 * p80211knetdev_set_multicast_list
467 * Called from higher lavers whenever there's a need to set/clear
468 * promiscuous mode or rewrite the multicast list.
475 ----------------------------------------------------------------*/
476 static void p80211knetdev_set_multicast_list(netdevice_t *dev)
478 wlandevice_t *wlandev = dev->ml_priv;
480 /* TODO: real multicast support as well */
482 if (wlandev->set_multicast_list)
483 wlandev->set_multicast_list(wlandev, dev);
489 static int p80211netdev_ethtool(wlandevice_t *wlandev, void __user *useraddr)
492 struct ethtool_drvinfo info;
493 struct ethtool_value edata;
495 memset(&info, 0, sizeof(info));
496 memset(&edata, 0, sizeof(edata));
498 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
502 case ETHTOOL_GDRVINFO:
504 snprintf(info.driver, sizeof(info.driver), "p80211_%s",
506 snprintf(info.version, sizeof(info.version), "%s",
509 if (copy_to_user(useraddr, &info, sizeof(info)))
516 if (wlandev->linkstatus &&
517 (wlandev->macmode != WLAN_MACMODE_NONE)) {
523 if (copy_to_user(useraddr, &edata, sizeof(edata)))
534 /*----------------------------------------------------------------
535 * p80211knetdev_do_ioctl
537 * Handle an ioctl call on one of our devices. Everything Linux
538 * ioctl specific is done here. Then we pass the contents of the
539 * ifr->data to the request message handler.
542 * dev Linux kernel netdevice
543 * ifr Our private ioctl request structure, typed for the
544 * generic struct ifreq so we can use ptr to func
548 * zero on success, a negative errno on failure. Possible values:
549 * -ENETDOWN Device isn't up.
550 * -EBUSY cmd already in progress
551 * -ETIME p80211 cmd timed out (MSD may have its own timers)
552 * -EFAULT memory fault copying msg from user buffer
553 * -ENOMEM unable to allocate kernel msg buffer
554 * -ENOSYS bad magic, it the cmd really for us?
555 * -EintR sleeping on cmd, awakened by signal, cmd cancelled.
558 * Process thread (ioctl caller). TODO: SMP support may require
560 ----------------------------------------------------------------*/
561 static int p80211knetdev_do_ioctl(netdevice_t *dev, struct ifreq *ifr, int cmd)
564 struct p80211ioctl_req *req = (struct p80211ioctl_req *) ifr;
565 wlandevice_t *wlandev = dev->ml_priv;
568 pr_debug("rx'd ioctl, cmd=%d, len=%d\n", cmd, req->len);
571 if (cmd == SIOCETHTOOL) {
573 p80211netdev_ethtool(wlandev, (void __user *)ifr->ifr_data);
578 /* Test the magic, assume ifr is good if it's there */
579 if (req->magic != P80211_IOCTL_MAGIC) {
584 if (cmd == P80211_IFTEST) {
587 } else if (cmd != P80211_IFREQ) {
592 /* Allocate a buf of size req->len */
593 msgbuf = kmalloc(req->len, GFP_KERNEL);
595 if (copy_from_user(msgbuf, (void __user *)req->data, req->len))
598 result = p80211req_dorequest(wlandev, msgbuf);
602 ((void __user *)req->data, msgbuf, req->len)) {
611 /* If allocate,copyfrom or copyto fails, return errno */
615 /*----------------------------------------------------------------
616 * p80211knetdev_set_mac_address
618 * Handles the ioctl for changing the MACAddress of a netdevice
620 * references: linux/netdevice.h and drivers/net/net_init.c
622 * NOTE: [MSM] We only prevent address changes when the netdev is
623 * up. We don't control anything based on dot11 state. If the
624 * address is changed on a STA that's currently associated, you
625 * will probably lose the ability to send and receive data frames.
626 * Just be aware. Therefore, this should usually only be done
627 * prior to scan/join/auth/assoc.
630 * dev netdevice struct
631 * addr the new MACAddress (a struct)
634 * zero on success, a negative errno on failure. Possible values:
635 * -EBUSY device is bussy (cmd not possible)
636 * -and errors returned by: p80211req_dorequest(..)
638 * by: Collin R. Mulliner <collin@mulliner.org>
639 ----------------------------------------------------------------*/
640 static int p80211knetdev_set_mac_address(netdevice_t *dev, void *addr)
642 struct sockaddr *new_addr = addr;
643 struct p80211msg_dot11req_mibset dot11req;
644 p80211item_unk392_t *mibattr;
645 p80211item_pstr6_t *macaddr;
646 p80211item_uint32_t *resultcode;
649 /* If we're running, we don't allow MAC address changes */
650 if (netif_running(dev))
653 /* Set up some convenience pointers. */
654 mibattr = &dot11req.mibattribute;
655 macaddr = (p80211item_pstr6_t *) &mibattr->data;
656 resultcode = &dot11req.resultcode;
658 /* Set up a dot11req_mibset */
659 memset(&dot11req, 0, sizeof(struct p80211msg_dot11req_mibset));
660 dot11req.msgcode = DIDmsg_dot11req_mibset;
661 dot11req.msglen = sizeof(struct p80211msg_dot11req_mibset);
662 memcpy(dot11req.devname,
663 ((wlandevice_t *) dev->ml_priv)->name, WLAN_DEVNAMELEN_MAX - 1);
665 /* Set up the mibattribute argument */
666 mibattr->did = DIDmsg_dot11req_mibset_mibattribute;
667 mibattr->status = P80211ENUM_msgitem_status_data_ok;
668 mibattr->len = sizeof(mibattr->data);
670 macaddr->did = DIDmib_dot11mac_dot11OperationTable_dot11MACAddress;
671 macaddr->status = P80211ENUM_msgitem_status_data_ok;
672 macaddr->len = sizeof(macaddr->data);
673 macaddr->data.len = ETH_ALEN;
674 memcpy(&macaddr->data.data, new_addr->sa_data, ETH_ALEN);
676 /* Set up the resultcode argument */
677 resultcode->did = DIDmsg_dot11req_mibset_resultcode;
678 resultcode->status = P80211ENUM_msgitem_status_no_value;
679 resultcode->len = sizeof(resultcode->data);
680 resultcode->data = 0;
682 /* now fire the request */
683 result = p80211req_dorequest(dev->ml_priv, (u8 *) &dot11req);
685 /* If the request wasn't successful, report an error and don't
686 * change the netdev address
688 if (result != 0 || resultcode->data != P80211ENUM_resultcode_success) {
690 "Low-level driver failed dot11req_mibset(dot11MACAddress).\n");
691 result = -EADDRNOTAVAIL;
693 /* everything's ok, change the addr in netdev */
694 memcpy(dev->dev_addr, new_addr->sa_data, dev->addr_len);
700 static int wlan_change_mtu(netdevice_t *dev, int new_mtu)
702 /* 2312 is max 802.11 payload, 20 is overhead, (ether + llc +snap)
703 and another 8 for wep. */
704 if ((new_mtu < 68) || (new_mtu > (2312 - 20 - 8)))
712 static const struct net_device_ops p80211_netdev_ops = {
713 .ndo_init = p80211knetdev_init,
714 .ndo_open = p80211knetdev_open,
715 .ndo_stop = p80211knetdev_stop,
716 .ndo_get_stats = p80211knetdev_get_stats,
717 .ndo_start_xmit = p80211knetdev_hard_start_xmit,
718 .ndo_set_multicast_list = p80211knetdev_set_multicast_list,
719 .ndo_do_ioctl = p80211knetdev_do_ioctl,
720 .ndo_set_mac_address = p80211knetdev_set_mac_address,
721 .ndo_tx_timeout = p80211knetdev_tx_timeout,
722 .ndo_change_mtu = wlan_change_mtu,
723 .ndo_validate_addr = eth_validate_addr,
726 /*----------------------------------------------------------------
729 * Roughly matches the functionality of ether_setup. Here
730 * we set up any members of the wlandevice structure that are common
731 * to all devices. Additionally, we allocate a linux 'struct device'
732 * and perform the same setup as ether_setup.
734 * Note: It's important that the caller have setup the wlandev->name
735 * ptr prior to calling this function.
738 * wlandev ptr to the wlandev structure for the
740 * physdev ptr to usb device
742 * zero on success, non-zero otherwise.
744 * Should be process thread. We'll assume it might be
745 * interrupt though. When we add support for statically
746 * compiled drivers, this function will be called in the
747 * context of the kernel startup code.
748 ----------------------------------------------------------------*/
749 int wlan_setup(wlandevice_t *wlandev, struct device *physdev)
754 struct wireless_dev *wdev;
756 /* Set up the wlandev */
757 wlandev->state = WLAN_DEVICE_CLOSED;
758 wlandev->ethconv = WLAN_ETHCONV_8021h;
759 wlandev->macmode = WLAN_MACMODE_NONE;
761 /* Set up the rx queue */
762 skb_queue_head_init(&wlandev->nsd_rxq);
763 tasklet_init(&wlandev->rx_bh,
764 p80211netdev_rx_bh, (unsigned long)wlandev);
766 /* Allocate and initialize the wiphy struct */
767 wiphy = wlan_create_wiphy(physdev, wlandev);
769 printk(KERN_ERR "Failed to alloc wiphy.\n");
773 /* Allocate and initialize the struct device */
774 netdev = alloc_netdev(sizeof(struct wireless_dev), "wlan%d",
776 if (netdev == NULL) {
777 printk(KERN_ERR "Failed to alloc netdev.\n");
778 wlan_free_wiphy(wiphy);
781 wlandev->netdev = netdev;
782 netdev->ml_priv = wlandev;
783 netdev->netdev_ops = &p80211_netdev_ops;
784 wdev = netdev_priv(netdev);
786 wdev->iftype = NL80211_IFTYPE_STATION;
787 netdev->ieee80211_ptr = wdev;
789 netif_stop_queue(netdev);
790 netif_carrier_off(netdev);
796 /*----------------------------------------------------------------
799 * This function is paired with the wlan_setup routine. It should
800 * be called after unregister_wlandev. Basically, all it does is
801 * free the 'struct device' that's associated with the wlandev.
802 * We do it here because the 'struct device' isn't allocated
803 * explicitly in the driver code, it's done in wlan_setup. To
804 * do the free in the driver might seem like 'magic'.
807 * wlandev ptr to the wlandev structure for the
810 * zero on success, non-zero otherwise.
812 * Should be process thread. We'll assume it might be
813 * interrupt though. When we add support for statically
814 * compiled drivers, this function will be called in the
815 * context of the kernel startup code.
816 ----------------------------------------------------------------*/
817 int wlan_unsetup(wlandevice_t *wlandev)
819 struct wireless_dev *wdev;
821 tasklet_kill(&wlandev->rx_bh);
823 if (wlandev->netdev) {
824 wdev = netdev_priv(wlandev->netdev);
826 wlan_free_wiphy(wdev->wiphy);
827 free_netdev(wlandev->netdev);
828 wlandev->netdev = NULL;
834 /*----------------------------------------------------------------
837 * Roughly matches the functionality of register_netdev. This function
838 * is called after the driver has successfully probed and set up the
839 * resources for the device. It's now ready to become a named device
840 * in the Linux system.
842 * First we allocate a name for the device (if not already set), then
843 * we call the Linux function register_netdevice.
846 * wlandev ptr to the wlandev structure for the
849 * zero on success, non-zero otherwise.
851 * Can be either interrupt or not.
852 ----------------------------------------------------------------*/
853 int register_wlandev(wlandevice_t *wlandev)
857 i = register_netdev(wlandev->netdev);
864 /*----------------------------------------------------------------
867 * Roughly matches the functionality of unregister_netdev. This
868 * function is called to remove a named device from the system.
870 * First we tell linux that the device should no longer exist.
871 * Then we remove it from the list of known wlan devices.
874 * wlandev ptr to the wlandev structure for the
877 * zero on success, non-zero otherwise.
879 * Can be either interrupt or not.
880 ----------------------------------------------------------------*/
881 int unregister_wlandev(wlandevice_t *wlandev)
885 unregister_netdev(wlandev->netdev);
887 /* Now to clean out the rx queue */
888 while ((skb = skb_dequeue(&wlandev->nsd_rxq)))
894 /*----------------------------------------------------------------
895 * p80211netdev_hwremoved
897 * Hardware removed notification. This function should be called
898 * immediately after an MSD has detected that the underlying hardware
899 * has been yanked out from under us. The primary things we need
902 * - Prevent any further traffic from the knetdev i/f
903 * - Prevent any further requests from mgmt i/f
904 * - If there are any waitq'd mgmt requests or mgmt-frame exchanges,
906 * - Call the MSD hwremoved function.
908 * The remainder of the cleanup will be handled by unregister().
909 * Our primary goal here is to prevent as much tickling of the MSD
910 * as possible since the MSD is already in a 'wounded' state.
912 * TODO: As new features are added, this function should be
916 * wlandev WLAN network device structure
923 ----------------------------------------------------------------*/
924 void p80211netdev_hwremoved(wlandevice_t *wlandev)
926 wlandev->hwremoved = 1;
927 if (wlandev->state == WLAN_DEVICE_OPEN)
928 netif_stop_queue(wlandev->netdev);
930 netif_device_detach(wlandev->netdev);
933 /*----------------------------------------------------------------
936 * Classifies the frame, increments the appropriate counter, and
937 * returns 0|1|2 indicating whether the driver should handle, ignore, or
941 * wlandev wlan device structure
942 * fc frame control field
945 * zero if the frame should be handled by the driver,
946 * one if the frame should be ignored
947 * anything else means we drop it.
953 ----------------------------------------------------------------*/
954 static int p80211_rx_typedrop(wlandevice_t *wlandev, u16 fc)
959 /* Classify frame, increment counter */
960 ftype = WLAN_GET_FC_FTYPE(fc);
961 fstype = WLAN_GET_FC_FSTYPE(fc);
963 pr_debug("rx_typedrop : ftype=%d fstype=%d.\n", ftype, fstype);
966 case WLAN_FTYPE_MGMT:
967 if ((wlandev->netdev->flags & IFF_PROMISC) ||
968 (wlandev->netdev->flags & IFF_ALLMULTI)) {
972 pr_debug("rx'd mgmt:\n");
975 case WLAN_FSTYPE_ASSOCREQ:
976 /* printk("assocreq"); */
977 wlandev->rx.assocreq++;
979 case WLAN_FSTYPE_ASSOCRESP:
980 /* printk("assocresp"); */
981 wlandev->rx.assocresp++;
983 case WLAN_FSTYPE_REASSOCREQ:
984 /* printk("reassocreq"); */
985 wlandev->rx.reassocreq++;
987 case WLAN_FSTYPE_REASSOCRESP:
988 /* printk("reassocresp"); */
989 wlandev->rx.reassocresp++;
991 case WLAN_FSTYPE_PROBEREQ:
992 /* printk("probereq"); */
993 wlandev->rx.probereq++;
995 case WLAN_FSTYPE_PROBERESP:
996 /* printk("proberesp"); */
997 wlandev->rx.proberesp++;
999 case WLAN_FSTYPE_BEACON:
1000 /* printk("beacon"); */
1001 wlandev->rx.beacon++;
1003 case WLAN_FSTYPE_ATIM:
1004 /* printk("atim"); */
1007 case WLAN_FSTYPE_DISASSOC:
1008 /* printk("disassoc"); */
1009 wlandev->rx.disassoc++;
1011 case WLAN_FSTYPE_AUTHEN:
1012 /* printk("authen"); */
1013 wlandev->rx.authen++;
1015 case WLAN_FSTYPE_DEAUTHEN:
1016 /* printk("deauthen"); */
1017 wlandev->rx.deauthen++;
1020 /* printk("unknown"); */
1021 wlandev->rx.mgmt_unknown++;
1028 case WLAN_FTYPE_CTL:
1029 if ((wlandev->netdev->flags & IFF_PROMISC) ||
1030 (wlandev->netdev->flags & IFF_ALLMULTI)) {
1034 pr_debug("rx'd ctl:\n");
1037 case WLAN_FSTYPE_PSPOLL:
1038 /* printk("pspoll"); */
1039 wlandev->rx.pspoll++;
1041 case WLAN_FSTYPE_RTS:
1042 /* printk("rts"); */
1045 case WLAN_FSTYPE_CTS:
1046 /* printk("cts"); */
1049 case WLAN_FSTYPE_ACK:
1050 /* printk("ack"); */
1053 case WLAN_FSTYPE_CFEND:
1054 /* printk("cfend"); */
1055 wlandev->rx.cfend++;
1057 case WLAN_FSTYPE_CFENDCFACK:
1058 /* printk("cfendcfack"); */
1059 wlandev->rx.cfendcfack++;
1062 /* printk("unknown"); */
1063 wlandev->rx.ctl_unknown++;
1070 case WLAN_FTYPE_DATA:
1073 case WLAN_FSTYPE_DATAONLY:
1074 wlandev->rx.dataonly++;
1076 case WLAN_FSTYPE_DATA_CFACK:
1077 wlandev->rx.data_cfack++;
1079 case WLAN_FSTYPE_DATA_CFPOLL:
1080 wlandev->rx.data_cfpoll++;
1082 case WLAN_FSTYPE_DATA_CFACK_CFPOLL:
1083 wlandev->rx.data__cfack_cfpoll++;
1085 case WLAN_FSTYPE_NULL:
1086 pr_debug("rx'd data:null\n");
1089 case WLAN_FSTYPE_CFACK:
1090 pr_debug("rx'd data:cfack\n");
1091 wlandev->rx.cfack++;
1093 case WLAN_FSTYPE_CFPOLL:
1094 pr_debug("rx'd data:cfpoll\n");
1095 wlandev->rx.cfpoll++;
1097 case WLAN_FSTYPE_CFACK_CFPOLL:
1098 pr_debug("rx'd data:cfack_cfpoll\n");
1099 wlandev->rx.cfack_cfpoll++;
1102 /* printk("unknown"); */
1103 wlandev->rx.data_unknown++;
1112 static void p80211knetdev_tx_timeout(netdevice_t *netdev)
1114 wlandevice_t *wlandev = netdev->ml_priv;
1116 if (wlandev->tx_timeout) {
1117 wlandev->tx_timeout(wlandev);
1119 printk(KERN_WARNING "Implement tx_timeout for %s\n",
1121 netif_wake_queue(wlandev->netdev);