git.oblomov.eu Git - linux-2.6/blob - drivers/staging/wlan-ng/p80211netdev.c

   1 /* src/p80211/p80211knetdev.c
   2 *
   3 * Linux Kernel net device interface
   4 *
   5 * Copyright (C) 1999 AbsoluteValue Systems, Inc.  All Rights Reserved.
   6 * --------------------------------------------------------------------
   7 *
   8 * linux-wlan
   9 *
  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/
  14 *
  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.
  19 *
  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.
  30 *
  31 * --------------------------------------------------------------------
  32 *
  33 * Inquiries regarding the linux-wlan Open Source project can be
  34 * made directly to:
  35 *
  36 * AbsoluteValue Systems Inc.
  37 * info@linux-wlan.com
  38 * http://www.linux-wlan.com
  39 *
  40 * --------------------------------------------------------------------
  41 *
  42 * Portions of the development of this software were funded by
  43 * Intersil Corporation as part of PRISM(R) chipset product development.
  44 *
  45 * --------------------------------------------------------------------
  46 *
  47 * The functions required for a Linux network device are defined here.
  48 *
  49 * --------------------------------------------------------------------
  50 */
  51
  52
  53 /*================================================================*/
  54 /* System Includes */
  55
  56
  57 #include <linux/version.h>
  58
  59 #include <linux/module.h>
  60 #include <linux/kernel.h>
  61 #include <linux/sched.h>
  62 #include <linux/types.h>
  63 #include <linux/skbuff.h>
  64 #include <linux/slab.h>
  65 #include <linux/proc_fs.h>
  66 #include <linux/interrupt.h>
  67 #include <linux/netdevice.h>
  68 #include <linux/kmod.h>
  69 #include <linux/if_arp.h>
  70 #include <linux/wireless.h>
  71 #include <linux/sockios.h>
  72 #include <linux/etherdevice.h>
  73
  74 #include <asm/bitops.h>
  75 #include <asm/uaccess.h>
  76 #include <asm/byteorder.h>
  77
  78 #ifdef SIOCETHTOOL
  79 #include <linux/ethtool.h>
  80 #endif
  81
  82 #if WIRELESS_EXT > 12
  83 #include <net/iw_handler.h>
  84 #endif
  85 #include <net/net_namespace.h>
  86
  87 /*================================================================*/
  88 /* Project Includes */
  89
  90 #include "version.h"
  91 #include "wlan_compat.h"
  92 #include "p80211types.h"
  93 #include "p80211hdr.h"
  94 #include "p80211conv.h"
  95 #include "p80211mgmt.h"
  96 #include "p80211msg.h"
  97 #include "p80211netdev.h"
  98 #include "p80211ioctl.h"
  99 #include "p80211req.h"
 100 #include "p80211metastruct.h"
 101 #include "p80211metadef.h"
 102
 103 /*================================================================*/
 104 /* Local Constants */
 105
 106 /*================================================================*/
 107 /* Local Macros */
 108
 109
 110 /*================================================================*/
 111 /* Local Types */
 112
 113 /*================================================================*/
 114 /* Local Static Definitions */
 115
 116 #define __NO_VERSION__          /* prevent the static definition */
 117
 118 #ifdef CONFIG_PROC_FS
 119 static struct proc_dir_entry    *proc_p80211;
 120 #endif
 121
 122 /*================================================================*/
 123 /* Local Function Declarations */
 124
 125 /* Support functions */
 126 static void p80211netdev_rx_bh(unsigned long arg);
 127
 128 /* netdevice method functions */
 129 static int p80211knetdev_init( netdevice_t *netdev);
 130 static struct net_device_stats* p80211knetdev_get_stats(netdevice_t *netdev);
 131 static int p80211knetdev_open( netdevice_t *netdev);
 132 static int p80211knetdev_stop( netdevice_t *netdev );
 133 static int p80211knetdev_hard_start_xmit( struct sk_buff *skb, netdevice_t *netdev);
 134 static void p80211knetdev_set_multicast_list(netdevice_t *dev);
 135 static int p80211knetdev_do_ioctl(netdevice_t *dev, struct ifreq *ifr, int cmd);
 136 static int p80211knetdev_set_mac_address(netdevice_t *dev, void *addr);
 137 static void p80211knetdev_tx_timeout(netdevice_t *netdev);
 138 static int p80211_rx_typedrop( wlandevice_t *wlandev, UINT16 fc);
 139
 140 #ifdef CONFIG_PROC_FS
 141 static int
 142 p80211netdev_proc_read(
 143         char    *page,
 144         char    **start,
 145         off_t   offset,
 146         int     count,
 147         int     *eof,
 148         void    *data);
 149 #endif
 150
 151 /*================================================================*/
 152 /* Function Definitions */
 153
 154 /*----------------------------------------------------------------
 155 * p80211knetdev_startup
 156 *
 157 * Initialize the wlandevice/netdevice part of 802.11 services at
 158 * load time.
 159 *
 160 * Arguments:
 161 *       none
 162 *
 163 * Returns:
 164 *       nothing
 165 ----------------------------------------------------------------*/
 166 void p80211netdev_startup(void)
 167 {
 168         DBFENTER;
 169
 170 #ifdef CONFIG_PROC_FS
 171         if (init_net.proc_net != NULL) {
 172                 proc_p80211 = create_proc_entry(
 173                                 "p80211",
 174                                 (S_IFDIR|S_IRUGO|S_IXUGO),
 175                                 init_net.proc_net);
 176         }
 177 #endif
 178         DBFEXIT;
 179         return;
 180 }
 181
 182 /*----------------------------------------------------------------
 183 * p80211knetdev_shutdown
 184 *
 185 * Shutdown the wlandevice/netdevice part of 802.11 services at
 186 * unload time.
 187 *
 188 * Arguments:
 189 *       none
 190 *
 191 * Returns:
 192 *       nothing
 193 ----------------------------------------------------------------*/
 194 void
 195 p80211netdev_shutdown(void)
 196 {
 197         DBFENTER;
 198 #ifdef CONFIG_PROC_FS
 199         if (proc_p80211 != NULL) {
 200                 remove_proc_entry("p80211", init_net.proc_net);
 201         }
 202 #endif
 203         DBFEXIT;
 204 }
 205
 206 /*----------------------------------------------------------------
 207 * p80211knetdev_init
 208 *
 209 * Init method for a Linux netdevice.  Called in response to
 210 * register_netdev.
 211 *
 212 * Arguments:
 213 *       none
 214 *
 215 * Returns:
 216 *       nothing
 217 ----------------------------------------------------------------*/
 218 static int p80211knetdev_init( netdevice_t *netdev)
 219 {
 220         DBFENTER;
 221         /* Called in response to register_netdev */
 222         /* This is usually the probe function, but the probe has */
 223         /* already been done by the MSD and the create_kdev */
 224         /* function.  All we do here is return success */
 225         DBFEXIT;
 226         return 0;
 227 }
 228
 229
 230 /*----------------------------------------------------------------
 231 * p80211knetdev_get_stats
 232 *
 233 * Statistics retrieval for linux netdevices.  Here we're reporting
 234 * the Linux i/f level statistics.  Hence, for the primary numbers,
 235 * we don't want to report the numbers from the MIB.  Eventually,
 236 * it might be useful to collect some of the error counters though.
 237 *
 238 * Arguments:
 239 *       netdev          Linux netdevice
 240 *
 241 * Returns:
 242 *       the address of the statistics structure
 243 ----------------------------------------------------------------*/
 244 static struct net_device_stats*
 245 p80211knetdev_get_stats(netdevice_t *netdev)
 246 {
 247         wlandevice_t    *wlandev = netdev->ml_priv;
 248         DBFENTER;
 249
 250         /* TODO: review the MIB stats for items that correspond to
 251                 linux stats */
 252
 253         DBFEXIT;
 254         return &(wlandev->linux_stats);
 255 }
 256
 257
 258 /*----------------------------------------------------------------
 259 * p80211knetdev_open
 260 *
 261 * Linux netdevice open method.  Following a successful call here,
 262 * the device is supposed to be ready for tx and rx.  In our
 263 * situation that may not be entirely true due to the state of the
 264 * MAC below.
 265 *
 266 * Arguments:
 267 *       netdev          Linux network device structure
 268 *
 269 * Returns:
 270 *       zero on success, non-zero otherwise
 271 ----------------------------------------------------------------*/
 272 static int p80211knetdev_open( netdevice_t *netdev )
 273 {
 274         int             result = 0; /* success */
 275         wlandevice_t    *wlandev = netdev->ml_priv;
 276
 277         DBFENTER;
 278
 279         /* Check to make sure the MSD is running */
 280         if ( wlandev->msdstate != WLAN_MSD_RUNNING ) {
 281                 return -ENODEV;
 282         }
 283
 284         /* Tell the MSD to open */
 285         if ( wlandev->open != NULL) {
 286                 result = wlandev->open(wlandev);
 287                 if ( result == 0 ) {
 288 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,3,43) )
 289                         netdev->interrupt = 0;
 290 #endif
 291                         p80211netdev_start_queue(wlandev);
 292                         wlandev->state = WLAN_DEVICE_OPEN;
 293                 }
 294         } else {
 295                 result = -EAGAIN;
 296         }
 297
 298         DBFEXIT;
 299         return result;
 300 }
 301
 302
 303 /*----------------------------------------------------------------
 304 * p80211knetdev_stop
 305 *
 306 * Linux netdevice stop (close) method.  Following this call,
 307 * no frames should go up or down through this interface.
 308 *
 309 * Arguments:
 310 *       netdev          Linux network device structure
 311 *
 312 * Returns:
 313 *       zero on success, non-zero otherwise
 314 ----------------------------------------------------------------*/
 315 static int p80211knetdev_stop( netdevice_t *netdev )
 316 {
 317         int             result = 0;
 318         wlandevice_t    *wlandev = netdev->ml_priv;
 319
 320         DBFENTER;
 321
 322         if ( wlandev->close != NULL ) {
 323                 result = wlandev->close(wlandev);
 324         }
 325
 326         p80211netdev_stop_queue(wlandev);
 327         wlandev->state = WLAN_DEVICE_CLOSED;
 328
 329         DBFEXIT;
 330         return result;
 331 }
 332
 333 /*----------------------------------------------------------------
 334 * p80211netdev_rx
 335 *
 336 * Frame receive function called by the mac specific driver.
 337 *
 338 * Arguments:
 339 *       wlandev         WLAN network device structure
 340 *       skb             skbuff containing a full 802.11 frame.
 341 * Returns:
 342 *       nothing
 343 * Side effects:
 344 *
 345 ----------------------------------------------------------------*/
 346 void
 347 p80211netdev_rx(wlandevice_t *wlandev, struct sk_buff *skb )
 348 {
 349         DBFENTER;
 350
 351         /* Enqueue for post-irq processing */
 352         skb_queue_tail(&wlandev->nsd_rxq, skb);
 353
 354         tasklet_schedule(&wlandev->rx_bh);
 355
 356         DBFEXIT;
 357         return;
 358 }
 359
 360 /*----------------------------------------------------------------
 361 * p80211netdev_rx_bh
 362 *
 363 * Deferred processing of all received frames.
 364 *
 365 * Arguments:
 366 *       wlandev         WLAN network device structure
 367 *       skb             skbuff containing a full 802.11 frame.
 368 * Returns:
 369 *       nothing
 370 * Side effects:
 371 *
 372 ----------------------------------------------------------------*/
 373 static void p80211netdev_rx_bh(unsigned long arg)
 374 {
 375         wlandevice_t *wlandev = (wlandevice_t *) arg;
 376         struct sk_buff *skb = NULL;
 377         netdevice_t     *dev = wlandev->netdev;
 378         p80211_hdr_a3_t *hdr;
 379         UINT16 fc;
 380
 381         DBFENTER;
 382
 383         /* Let's empty our our queue */
 384         while ( (skb = skb_dequeue(&wlandev->nsd_rxq)) ) {
 385                 if (wlandev->state == WLAN_DEVICE_OPEN) {
 386
 387                         if (dev->type != ARPHRD_ETHER) {
 388                                 /* RAW frame; we shouldn't convert it */
 389                                 // XXX Append the Prism Header here instead.
 390
 391                                 /* set up various data fields */
 392                                 skb->dev = dev;
 393                                 skb_reset_mac_header(skb);
 394                                 skb->ip_summed = CHECKSUM_NONE;
 395                                 skb->pkt_type = PACKET_OTHERHOST;
 396                                 skb->protocol = htons(ETH_P_80211_RAW);
 397                                 dev->last_rx = jiffies;
 398
 399                                 wlandev->linux_stats.rx_packets++;
 400                                 wlandev->linux_stats.rx_bytes += skb->len;
 401                                 netif_rx_ni(skb);
 402                                 continue;
 403                         } else {
 404                                 hdr = (p80211_hdr_a3_t *)skb->data;
 405                                 fc = ieee2host16(hdr->fc);
 406                                 if (p80211_rx_typedrop(wlandev, fc)) {
 407                                         dev_kfree_skb(skb);
 408                                         continue;
 409                                 }
 410
 411                                 /* perform mcast filtering */
 412                                 if (wlandev->netdev->flags & IFF_ALLMULTI) {
 413                                         /* allow my local address through */
 414                                         if (memcmp(hdr->a1, wlandev->netdev->dev_addr, WLAN_ADDR_LEN) != 0) {
 415                                                 /* but reject anything else that isn't multicast */
 416                                                 if (!(hdr->a1[0] & 0x01)) {
 417                                                         dev_kfree_skb(skb);
 418                                                         continue;
 419                                                 }
 420                                         }
 421                                 }
 422
 423                                 if ( skb_p80211_to_ether(wlandev, wlandev->ethconv, skb) == 0 ) {
 424                                         skb->dev->last_rx = jiffies;
 425                                         wlandev->linux_stats.rx_packets++;
 426                                         wlandev->linux_stats.rx_bytes += skb->len;
 427                                         netif_rx_ni(skb);
 428                                         continue;
 429                                 }
 430                                 WLAN_LOG_DEBUG(1, "p80211_to_ether failed.\n");
 431                         }
 432                 }
 433                 dev_kfree_skb(skb);
 434         }
 435
 436         DBFEXIT;
 437 }
 438
 439
 440 /*----------------------------------------------------------------
 441 * p80211knetdev_hard_start_xmit
 442 *
 443 * Linux netdevice method for transmitting a frame.
 444 *
 445 * Arguments:
 446 *       skb     Linux sk_buff containing the frame.
 447 *       netdev  Linux netdevice.
 448 *
 449 * Side effects:
 450 *       If the lower layers report that buffers are full. netdev->tbusy
 451 *       will be set to prevent higher layers from sending more traffic.
 452 *
 453 *       Note: If this function returns non-zero, higher layers retain
 454 *             ownership of the skb.
 455 *
 456 * Returns:
 457 *       zero on success, non-zero on failure.
 458 ----------------------------------------------------------------*/
 459 static int p80211knetdev_hard_start_xmit( struct sk_buff *skb, netdevice_t *netdev)
 460 {
 461         int             result = 0;
 462         int             txresult = -1;
 463         wlandevice_t    *wlandev = netdev->ml_priv;
 464         p80211_hdr_t    p80211_hdr;
 465         p80211_metawep_t p80211_wep;
 466
 467         DBFENTER;
 468
 469         if (skb == NULL) {
 470                 return 0;
 471         }
 472
 473         if (wlandev->state != WLAN_DEVICE_OPEN) {
 474                 result = 1;
 475                 goto failed;
 476         }
 477
 478         memset(&p80211_hdr, 0, sizeof(p80211_hdr_t));
 479         memset(&p80211_wep, 0, sizeof(p80211_metawep_t));
 480
 481 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,38) )
 482         if ( test_and_set_bit(0, (void*)&(netdev->tbusy)) != 0 ) {
 483                 /* We've been called w/ tbusy set, has the tx */
 484                 /* path stalled?   */
 485                 WLAN_LOG_DEBUG(1, "called when tbusy set\n");
 486                 result = 1;
 487                 goto failed;
 488         }
 489 #else
 490         if ( netif_queue_stopped(netdev) ) {
 491                 WLAN_LOG_DEBUG(1, "called when queue stopped.\n");
 492                 result = 1;
 493                 goto failed;
 494         }
 495
 496         netif_stop_queue(netdev);
 497
 498         /* No timeout handling here, 2.3.38+ kernels call the
 499          * timeout function directly.
 500          * TODO: Add timeout handling.
 501         */
 502 #endif
 503
 504         /* Check to see that a valid mode is set */
 505         switch( wlandev->macmode ) {
 506         case WLAN_MACMODE_IBSS_STA:
 507         case WLAN_MACMODE_ESS_STA:
 508         case WLAN_MACMODE_ESS_AP:
 509                 break;
 510         default:
 511                 /* Mode isn't set yet, just drop the frame
 512                  * and return success .
 513                  * TODO: we need a saner way to handle this
 514                  */
 515                 if(skb->protocol != ETH_P_80211_RAW) {
 516                         p80211netdev_start_queue(wlandev);
 517                         WLAN_LOG_NOTICE(
 518                                 "Tx attempt prior to association, frame dropped.\n");
 519                         wlandev->linux_stats.tx_dropped++;
 520                         result = 0;
 521                         goto failed;
 522                 }
 523                 break;
 524         }
 525
 526         /* Check for raw transmits */
 527         if(skb->protocol == ETH_P_80211_RAW) {
 528                 if (!capable(CAP_NET_ADMIN)) {
 529                         result = 1;
 530                         goto failed;
 531                 }
 532                 /* move the header over */
 533                 memcpy(&p80211_hdr, skb->data, sizeof(p80211_hdr_t));
 534                 skb_pull(skb, sizeof(p80211_hdr_t));
 535         } else {
 536                 if ( skb_ether_to_p80211(wlandev, wlandev->ethconv, skb, &p80211_hdr, &p80211_wep) != 0 ) {
 537                         /* convert failed */
 538                         WLAN_LOG_DEBUG(1, "ether_to_80211(%d) failed.\n",
 539                                         wlandev->ethconv);
 540                         result = 1;
 541                         goto failed;
 542                 }
 543         }
 544         if ( wlandev->txframe == NULL ) {
 545                 result = 1;
 546                 goto failed;
 547         }
 548
 549         netdev->trans_start = jiffies;
 550
 551         wlandev->linux_stats.tx_packets++;
 552         /* count only the packet payload */
 553         wlandev->linux_stats.tx_bytes += skb->len;
 554
 555         txresult = wlandev->txframe(wlandev, skb, &p80211_hdr, &p80211_wep);
 556
 557         if ( txresult == 0) {
 558                 /* success and more buf */
 559                 /* avail, re: hw_txdata */
 560                 p80211netdev_wake_queue(wlandev);
 561                 result = 0;
 562         } else if ( txresult == 1 ) {
 563                 /* success, no more avail */
 564                 WLAN_LOG_DEBUG(3, "txframe success, no more bufs\n");
 565                 /* netdev->tbusy = 1;  don't set here, irqhdlr */
 566                 /*   may have already cleared it */
 567                 result = 0;
 568         } else if ( txresult == 2 ) {
 569                 /* alloc failure, drop frame */
 570                 WLAN_LOG_DEBUG(3, "txframe returned alloc_fail\n");
 571                 result = 1;
 572         } else {
 573                 /* buffer full or queue busy, drop frame. */
 574                 WLAN_LOG_DEBUG(3, "txframe returned full or busy\n");
 575                 result = 1;
 576         }
 577
 578  failed:
 579         /* Free up the WEP buffer if it's not the same as the skb */
 580         if ((p80211_wep.data) && (p80211_wep.data != skb->data))
 581                 kfree(p80211_wep.data);
 582
 583         /* we always free the skb here, never in a lower level. */
 584         if (!result)
 585                 dev_kfree_skb(skb);
 586
 587         DBFEXIT;
 588         return result;
 589 }
 590
 591
 592 /*----------------------------------------------------------------
 593 * p80211knetdev_set_multicast_list
 594 *
 595 * Called from higher lavers whenever there's a need to set/clear
 596 * promiscuous mode or rewrite the multicast list.
 597 *
 598 * Arguments:
 599 *       none
 600 *
 601 * Returns:
 602 *       nothing
 603 ----------------------------------------------------------------*/
 604 static void p80211knetdev_set_multicast_list(netdevice_t *dev)
 605 {
 606         wlandevice_t    *wlandev = dev->ml_priv;
 607
 608         DBFENTER;
 609
 610         /* TODO:  real multicast support as well */
 611
 612         if (wlandev->set_multicast_list)
 613                 wlandev->set_multicast_list(wlandev, dev);
 614
 615         DBFEXIT;
 616 }
 617
 618 #ifdef SIOCETHTOOL
 619
 620 static int p80211netdev_ethtool(wlandevice_t *wlandev, void __user *useraddr)
 621 {
 622         UINT32 ethcmd;
 623         struct ethtool_drvinfo info;
 624         struct ethtool_value edata;
 625
 626         memset(&info, 0, sizeof(info));
 627         memset(&edata, 0, sizeof(edata));
 628
 629         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
 630                 return -EFAULT;
 631
 632         switch (ethcmd) {
 633         case ETHTOOL_GDRVINFO:
 634                 info.cmd = ethcmd;
 635                 snprintf(info.driver, sizeof(info.driver), "p80211_%s",
 636                          wlandev->nsdname);
 637                 snprintf(info.version, sizeof(info.version), "%s",
 638                          WLAN_RELEASE);
 639
 640                 // info.fw_version
 641                 // info.bus_info
 642
 643                 if (copy_to_user(useraddr, &info, sizeof(info)))
 644                         return -EFAULT;
 645                 return 0;
 646 #ifdef ETHTOOL_GLINK
 647         case ETHTOOL_GLINK:
 648                 edata.cmd = ethcmd;
 649
 650                 if (wlandev->linkstatus &&
 651                     (wlandev->macmode != WLAN_MACMODE_NONE)) {
 652                         edata.data = 1;
 653                 } else {
 654                         edata.data = 0;
 655                 }
 656
 657                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
 658                         return -EFAULT;
 659                 return 0;
 660         }
 661 #endif
 662
 663         return -EOPNOTSUPP;
 664 }
 665
 666 #endif
 667
 668 /*----------------------------------------------------------------
 669 * p80211knetdev_do_ioctl
 670 *
 671 * Handle an ioctl call on one of our devices.  Everything Linux
 672 * ioctl specific is done here.  Then we pass the contents of the
 673 * ifr->data to the request message handler.
 674 *
 675 * Arguments:
 676 *       dev     Linux kernel netdevice
 677 *       ifr     Our private ioctl request structure, typed for the
 678 *               generic struct ifreq so we can use ptr to func
 679 *               w/o cast.
 680 *
 681 * Returns:
 682 *       zero on success, a negative errno on failure.  Possible values:
 683 *               -ENETDOWN Device isn't up.
 684 *               -EBUSY  cmd already in progress
 685 *               -ETIME  p80211 cmd timed out (MSD may have its own timers)
 686 *               -EFAULT memory fault copying msg from user buffer
 687 *               -ENOMEM unable to allocate kernel msg buffer
 688 *               -ENOSYS bad magic, it the cmd really for us?
 689 *               -EINTR  sleeping on cmd, awakened by signal, cmd cancelled.
 690 *
 691 * Call Context:
 692 *       Process thread (ioctl caller).  TODO: SMP support may require
 693 *       locks.
 694 ----------------------------------------------------------------*/
 695 static int p80211knetdev_do_ioctl(netdevice_t *dev, struct ifreq *ifr, int cmd)
 696 {
 697         int                     result = 0;
 698         p80211ioctl_req_t       *req = (p80211ioctl_req_t*)ifr;
 699         wlandevice_t            *wlandev = dev->ml_priv;
 700         UINT8                   *msgbuf;
 701         DBFENTER;
 702
 703         WLAN_LOG_DEBUG(2, "rx'd ioctl, cmd=%d, len=%d\n", cmd, req->len);
 704
 705 #if WIRELESS_EXT < 13
 706         /* Is this a wireless extensions ioctl? */
 707         if ((cmd >= SIOCIWFIRST) && (cmd <= SIOCIWLAST)) {
 708                 if ((result = p80211wext_support_ioctl(dev, ifr, cmd))
 709                     != (-EOPNOTSUPP)) {
 710                         goto bail;
 711                 }
 712         }
 713 #endif
 714
 715 #ifdef SIOCETHTOOL
 716         if (cmd == SIOCETHTOOL) {
 717                 result = p80211netdev_ethtool(wlandev, (void __user *) ifr->ifr_data);
 718                 goto bail;
 719         }
 720 #endif
 721
 722         /* Test the magic, assume ifr is good if it's there */
 723         if ( req->magic != P80211_IOCTL_MAGIC ) {
 724                 result = -ENOSYS;
 725                 goto bail;
 726         }
 727
 728         if ( cmd == P80211_IFTEST ) {
 729                 result = 0;
 730                 goto bail;
 731         } else if ( cmd != P80211_IFREQ ) {
 732                 result = -ENOSYS;
 733                 goto bail;
 734         }
 735
 736         /* Allocate a buf of size req->len */
 737         if ((msgbuf = kmalloc( req->len, GFP_KERNEL))) {
 738                 if ( copy_from_user( msgbuf, (void __user *) req->data, req->len) ) {
 739                         result = -EFAULT;
 740                 } else {
 741                         result = p80211req_dorequest( wlandev, msgbuf);
 742                 }
 743
 744                 if ( result == 0 ) {
 745                         if ( copy_to_user( (void __user *) req->data, msgbuf, req->len)) {
 746                                 result = -EFAULT;
 747                         }
 748                 }
 749                 kfree(msgbuf);
 750         } else {
 751                 result = -ENOMEM;
 752         }
 753 bail:
 754         DBFEXIT;
 755
 756         return result; /* If allocate,copyfrom or copyto fails, return errno */
 757 }
 758
 759 /*----------------------------------------------------------------
 760 * p80211knetdev_set_mac_address
 761 *
 762 * Handles the ioctl for changing the MACAddress of a netdevice
 763 *
 764 * references: linux/netdevice.h and drivers/net/net_init.c
 765 *
 766 * NOTE: [MSM] We only prevent address changes when the netdev is
 767 * up.  We don't control anything based on dot11 state.  If the
 768 * address is changed on a STA that's currently associated, you
 769 * will probably lose the ability to send and receive data frames.
 770 * Just be aware.  Therefore, this should usually only be done
 771 * prior to scan/join/auth/assoc.
 772 *
 773 * Arguments:
 774 *       dev     netdevice struct
 775 *       addr    the new MACAddress (a struct)
 776 *
 777 * Returns:
 778 *       zero on success, a negative errno on failure.  Possible values:
 779 *               -EBUSY  device is bussy (cmd not possible)
 780 *               -and errors returned by: p80211req_dorequest(..)
 781 *
 782 * by: Collin R. Mulliner <collin@mulliner.org>
 783 ----------------------------------------------------------------*/
 784 static int p80211knetdev_set_mac_address(netdevice_t *dev, void *addr)
 785 {
 786         struct sockaddr                 *new_addr = addr;
 787         p80211msg_dot11req_mibset_t     dot11req;
 788         p80211item_unk392_t             *mibattr;
 789         p80211item_pstr6_t              *macaddr;
 790         p80211item_uint32_t             *resultcode;
 791         int result = 0;
 792
 793         DBFENTER;
 794         /* If we're running, we don't allow MAC address changes */
 795 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,38) )
 796         if ( dev->start) {
 797                 return -EBUSY;
 798         }
 799 #else
 800         if (netif_running(dev)) {
 801                 return -EBUSY;
 802         }
 803 #endif
 804
 805         /* Set up some convenience pointers. */
 806         mibattr = &dot11req.mibattribute;
 807         macaddr = (p80211item_pstr6_t*)&mibattr->data;
 808         resultcode = &dot11req.resultcode;
 809
 810         /* Set up a dot11req_mibset */
 811         memset(&dot11req, 0, sizeof(p80211msg_dot11req_mibset_t));
 812         dot11req.msgcode = DIDmsg_dot11req_mibset;
 813         dot11req.msglen = sizeof(p80211msg_dot11req_mibset_t);
 814         memcpy(dot11req.devname,
 815                 ((wlandevice_t *)dev->ml_priv)->name,
 816                 WLAN_DEVNAMELEN_MAX - 1);
 817
 818         /* Set up the mibattribute argument */
 819         mibattr->did = DIDmsg_dot11req_mibset_mibattribute;
 820         mibattr->status = P80211ENUM_msgitem_status_data_ok;
 821         mibattr->len = sizeof(mibattr->data);
 822
 823         macaddr->did = DIDmib_dot11mac_dot11OperationTable_dot11MACAddress;
 824         macaddr->status = P80211ENUM_msgitem_status_data_ok;
 825         macaddr->len = sizeof(macaddr->data);
 826         macaddr->data.len = WLAN_ADDR_LEN;
 827         memcpy(&macaddr->data.data, new_addr->sa_data, WLAN_ADDR_LEN);
 828
 829         /* Set up the resultcode argument */
 830         resultcode->did = DIDmsg_dot11req_mibset_resultcode;
 831         resultcode->status = P80211ENUM_msgitem_status_no_value;
 832         resultcode->len = sizeof(resultcode->data);
 833         resultcode->data = 0;
 834
 835         /* now fire the request */
 836         result = p80211req_dorequest(dev->ml_priv, (UINT8 *)&dot11req);
 837
 838         /* If the request wasn't successful, report an error and don't
 839          * change the netdev address
 840          */
 841         if ( result != 0 || resultcode->data != P80211ENUM_resultcode_success) {
 842                 WLAN_LOG_ERROR(
 843                 "Low-level driver failed dot11req_mibset(dot11MACAddress).\n");
 844                 result = -EADDRNOTAVAIL;
 845         } else {
 846                 /* everything's ok, change the addr in netdev */
 847                 memcpy(dev->dev_addr, new_addr->sa_data, dev->addr_len);
 848         }
 849
 850         DBFEXIT;
 851         return result;
 852 }
 853
 854 static int wlan_change_mtu(netdevice_t *dev, int new_mtu)
 855 {
 856         DBFENTER;
 857         // 2312 is max 802.11 payload, 20 is overhead, (ether + llc +snap)
 858         // and another 8 for wep.
 859         if ( (new_mtu < 68) || (new_mtu > (2312 - 20 - 8)))
 860                 return -EINVAL;
 861
 862         dev->mtu = new_mtu;
 863
 864         DBFEXIT;
 865
 866         return 0;
 867 }
 868
 869
 870
 871 /*----------------------------------------------------------------
 872 * wlan_setup
 873 *
 874 * Roughly matches the functionality of ether_setup.  Here
 875 * we set up any members of the wlandevice structure that are common
 876 * to all devices.  Additionally, we allocate a linux 'struct device'
 877 * and perform the same setup as ether_setup.
 878 *
 879 * Note: It's important that the caller have setup the wlandev->name
 880 *       ptr prior to calling this function.
 881 *
 882 * Arguments:
 883 *       wlandev         ptr to the wlandev structure for the
 884 *                       interface.
 885 * Returns:
 886 *       zero on success, non-zero otherwise.
 887 * Call Context:
 888 *       Should be process thread.  We'll assume it might be
 889 *       interrupt though.  When we add support for statically
 890 *       compiled drivers, this function will be called in the
 891 *       context of the kernel startup code.
 892 ----------------------------------------------------------------*/
 893 int wlan_setup(wlandevice_t *wlandev)
 894 {
 895         int             result = 0;
 896         netdevice_t     *dev;
 897
 898         DBFENTER;
 899
 900         /* Set up the wlandev */
 901         wlandev->state = WLAN_DEVICE_CLOSED;
 902         wlandev->ethconv = WLAN_ETHCONV_8021h;
 903         wlandev->macmode = WLAN_MACMODE_NONE;
 904
 905         /* Set up the rx queue */
 906         skb_queue_head_init(&wlandev->nsd_rxq);
 907         tasklet_init(&wlandev->rx_bh,
 908                      p80211netdev_rx_bh,
 909                      (unsigned long)wlandev);
 910
 911         /* Allocate and initialize the struct device */
 912         dev = kmalloc(sizeof(netdevice_t), GFP_ATOMIC);
 913         if ( dev == NULL ) {
 914                 WLAN_LOG_ERROR("Failed to alloc netdev.\n");
 915                 result = 1;
 916         } else {
 917                 memset( dev, 0, sizeof(netdevice_t));
 918                 ether_setup(dev);
 919                 wlandev->netdev = dev;
 920                 dev->ml_priv = wlandev;
 921                 dev->hard_start_xmit =  p80211knetdev_hard_start_xmit;
 922                 dev->get_stats =        p80211knetdev_get_stats;
 923 #ifdef HAVE_PRIVATE_IOCTL
 924                 dev->do_ioctl =         p80211knetdev_do_ioctl;
 925 #endif
 926 #ifdef HAVE_MULTICAST
 927                 dev->set_multicast_list = p80211knetdev_set_multicast_list;
 928 #endif
 929                 dev->init =             p80211knetdev_init;
 930                 dev->open =             p80211knetdev_open;
 931                 dev->stop =             p80211knetdev_stop;
 932
 933 #ifdef CONFIG_NET_WIRELESS
 934 #if ((WIRELESS_EXT < 17) && (WIRELESS_EXT < 21))
 935                 dev->get_wireless_stats = p80211wext_get_wireless_stats;
 936 #endif
 937 #if WIRELESS_EXT > 12
 938                 dev->wireless_handlers = &p80211wext_handler_def;
 939 #endif
 940 #endif
 941
 942 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,38) )
 943                 dev->tbusy = 1;
 944                 dev->start = 0;
 945 #else
 946                 netif_stop_queue(dev);
 947 #endif
 948 #ifdef HAVE_CHANGE_MTU
 949                 dev->change_mtu = wlan_change_mtu;
 950 #endif
 951 #ifdef HAVE_SET_MAC_ADDR
 952                 dev->set_mac_address =  p80211knetdev_set_mac_address;
 953 #endif
 954 #ifdef HAVE_TX_TIMEOUT
 955                 dev->tx_timeout      =  &p80211knetdev_tx_timeout;
 956                 dev->watchdog_timeo  =  (wlan_watchdog * HZ) / 1000;
 957 #endif
 958                 netif_carrier_off(dev);
 959         }
 960
 961         DBFEXIT;
 962         return result;
 963 }
 964
 965 /*----------------------------------------------------------------
 966 * wlan_unsetup
 967 *
 968 * This function is paired with the wlan_setup routine.  It should
 969 * be called after unregister_wlandev.  Basically, all it does is
 970 * free the 'struct device' that's associated with the wlandev.
 971 * We do it here because the 'struct device' isn't allocated
 972 * explicitly in the driver code, it's done in wlan_setup.  To
 973 * do the free in the driver might seem like 'magic'.
 974 *
 975 * Arguments:
 976 *       wlandev         ptr to the wlandev structure for the
 977 *                       interface.
 978 * Returns:
 979 *       zero on success, non-zero otherwise.
 980 * Call Context:
 981 *       Should be process thread.  We'll assume it might be
 982 *       interrupt though.  When we add support for statically
 983 *       compiled drivers, this function will be called in the
 984 *       context of the kernel startup code.
 985 ----------------------------------------------------------------*/
 986 int wlan_unsetup(wlandevice_t *wlandev)
 987 {
 988         int             result = 0;
 989
 990         DBFENTER;
 991
 992         tasklet_kill(&wlandev->rx_bh);
 993
 994         if (wlandev->netdev == NULL ) {
 995                 WLAN_LOG_ERROR("called without wlandev->netdev set.\n");
 996                 result = 1;
 997         } else {
 998                 free_netdev(wlandev->netdev);
 999                 wlandev->netdev = NULL;
1000         }
1001
1002         DBFEXIT;
1003         return 0;
1004 }
1005
1006
1007
1008 /*----------------------------------------------------------------
1009 * register_wlandev
1010 *
1011 * Roughly matches the functionality of register_netdev.  This function
1012 * is called after the driver has successfully probed and set up the
1013 * resources for the device.  It's now ready to become a named device
1014 * in the Linux system.
1015 *
1016 * First we allocate a name for the device (if not already set), then
1017 * we call the Linux function register_netdevice.
1018 *
1019 * Arguments:
1020 *       wlandev         ptr to the wlandev structure for the
1021 *                       interface.
1022 * Returns:
1023 *       zero on success, non-zero otherwise.
1024 * Call Context:
1025 *       Can be either interrupt or not.
1026 ----------------------------------------------------------------*/
1027 int register_wlandev(wlandevice_t *wlandev)
1028 {
1029         int             i = 0;
1030         netdevice_t     *dev = wlandev->netdev;
1031
1032         DBFENTER;
1033
1034         i = dev_alloc_name(wlandev->netdev, "wlan%d");
1035         if (i >= 0) {
1036                 i = register_netdev(wlandev->netdev);
1037         }
1038         if (i != 0) {
1039                 return -EIO;
1040         }
1041
1042 #if ( LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0) )
1043         dev->name = wlandev->name;
1044 #else
1045         strcpy(wlandev->name, dev->name);
1046 #endif
1047
1048 #ifdef CONFIG_PROC_FS
1049         if (proc_p80211) {
1050                 wlandev->procdir = proc_mkdir(wlandev->name, proc_p80211);
1051                 if ( wlandev->procdir )
1052                         wlandev->procwlandev =
1053                                 create_proc_read_entry("wlandev", 0,
1054                                                        wlandev->procdir,
1055                                                        p80211netdev_proc_read,
1056                                                        wlandev);
1057                 if (wlandev->nsd_proc_read)
1058                         create_proc_read_entry("nsd", 0,
1059                                                wlandev->procdir,
1060                                                wlandev->nsd_proc_read,
1061                                                wlandev);
1062         }
1063 #endif
1064
1065 #ifdef CONFIG_HOTPLUG
1066         p80211_run_sbin_hotplug(wlandev, WLAN_HOTPLUG_REGISTER);
1067 #endif
1068
1069         DBFEXIT;
1070         return 0;
1071 }
1072
1073
1074 /*----------------------------------------------------------------
1075 * unregister_wlandev
1076 *
1077 * Roughly matches the functionality of unregister_netdev.  This
1078 * function is called to remove a named device from the system.
1079 *
1080 * First we tell linux that the device should no longer exist.
1081 * Then we remove it from the list of known wlan devices.
1082 *
1083 * Arguments:
1084 *       wlandev         ptr to the wlandev structure for the
1085 *                       interface.
1086 * Returns:
1087 *       zero on success, non-zero otherwise.
1088 * Call Context:
1089 *       Can be either interrupt or not.
1090 ----------------------------------------------------------------*/
1091 int unregister_wlandev(wlandevice_t *wlandev)
1092 {
1093         struct sk_buff *skb;
1094
1095         DBFENTER;
1096
1097 #ifdef CONFIG_HOTPLUG
1098         p80211_run_sbin_hotplug(wlandev, WLAN_HOTPLUG_REMOVE);
1099 #endif
1100
1101 #ifdef CONFIG_PROC_FS
1102         if ( wlandev->procwlandev ) {
1103                 remove_proc_entry("wlandev", wlandev->procdir);
1104         }
1105         if ( wlandev->nsd_proc_read ) {
1106                 remove_proc_entry("nsd", wlandev->procdir);
1107         }
1108         if (wlandev->procdir) {
1109                 remove_proc_entry(wlandev->name, proc_p80211);
1110         }
1111 #endif
1112
1113         unregister_netdev(wlandev->netdev);
1114
1115         /* Now to clean out the rx queue */
1116         while ( (skb = skb_dequeue(&wlandev->nsd_rxq)) ) {
1117                 dev_kfree_skb(skb);
1118         }
1119
1120         DBFEXIT;
1121         return 0;
1122 }
1123
1124 #ifdef CONFIG_PROC_FS
1125 /*----------------------------------------------------------------
1126 * proc_read
1127 *
1128 * Read function for /proc/net/p80211/<device>/wlandev
1129 *
1130 * Arguments:
1131 *       buf
1132 *       start
1133 *       offset
1134 *       count
1135 *       eof
1136 *       data
1137 * Returns:
1138 *       zero on success, non-zero otherwise.
1139 * Call Context:
1140 *       Can be either interrupt or not.
1141 ----------------------------------------------------------------*/
1142 static int
1143 p80211netdev_proc_read(
1144         char    *page,
1145         char    **start,
1146         off_t   offset,
1147         int     count,
1148         int     *eof,
1149         void    *data)
1150 {
1151         char     *p = page;
1152         wlandevice_t *wlandev = (wlandevice_t *) data;
1153
1154         DBFENTER;
1155         if (offset != 0) {
1156                 *eof = 1;
1157                 goto exit;
1158         }
1159
1160         p += sprintf(p, "p80211 version: %s (%s)\n\n",
1161                      WLAN_RELEASE, WLAN_BUILD_DATE);
1162         p += sprintf(p, "name       : %s\n", wlandev->name);
1163         p += sprintf(p, "nsd name   : %s\n", wlandev->nsdname);
1164         p += sprintf(p, "address    : %02x:%02x:%02x:%02x:%02x:%02x\n",
1165                      wlandev->netdev->dev_addr[0], wlandev->netdev->dev_addr[1], wlandev->netdev->dev_addr[2],
1166                      wlandev->netdev->dev_addr[3], wlandev->netdev->dev_addr[4], wlandev->netdev->dev_addr[5]);
1167         p += sprintf(p, "nsd caps   : %s%s%s%s%s%s%s%s%s%s\n",
1168                      (wlandev->nsdcaps & P80211_NSDCAP_HARDWAREWEP) ? "wep_hw " : "",
1169                      (wlandev->nsdcaps & P80211_NSDCAP_TIEDWEP) ? "wep_tied " : "",
1170                      (wlandev->nsdcaps & P80211_NSDCAP_NOHOSTWEP) ? "wep_hw_only " : "",
1171                      (wlandev->nsdcaps & P80211_NSDCAP_PBCC) ? "pbcc " : "",
1172                      (wlandev->nsdcaps & P80211_NSDCAP_SHORT_PREAMBLE) ? "short_preamble " : "",
1173                      (wlandev->nsdcaps & P80211_NSDCAP_AGILITY) ? "agility " : "",
1174                      (wlandev->nsdcaps & P80211_NSDCAP_AP_RETRANSMIT) ? "ap_retransmit " : "",
1175                      (wlandev->nsdcaps & P80211_NSDCAP_HWFRAGMENT) ? "hw_frag " : "",
1176                      (wlandev->nsdcaps & P80211_NSDCAP_AUTOJOIN) ? "autojoin " : "",
1177                      (wlandev->nsdcaps & P80211_NSDCAP_NOSCAN) ? "" : "scan ");
1178
1179
1180         p += sprintf(p, "bssid      : %02x:%02x:%02x:%02x:%02x:%02x\n",
1181                      wlandev->bssid[0], wlandev->bssid[1], wlandev->bssid[2],
1182                      wlandev->bssid[3], wlandev->bssid[4], wlandev->bssid[5]);
1183
1184         p += sprintf(p, "Enabled    : %s%s\n",
1185                      (wlandev->shortpreamble) ? "short_preamble " : "",
1186                      (wlandev->hostwep & HOSTWEP_PRIVACYINVOKED) ? "privacy" : "");
1187
1188
1189  exit:
1190         DBFEXIT;
1191         return (p - page);
1192 }
1193 #endif
1194
1195 /*----------------------------------------------------------------
1196 * p80211netdev_hwremoved
1197 *
1198 * Hardware removed notification. This function should be called
1199 * immediately after an MSD has detected that the underlying hardware
1200 * has been yanked out from under us.  The primary things we need
1201 * to do are:
1202 *   - Mark the wlandev
1203 *   - Prevent any further traffic from the knetdev i/f
1204 *   - Prevent any further requests from mgmt i/f
1205 *   - If there are any waitq'd mgmt requests or mgmt-frame exchanges,
1206 *     shut them down.
1207 *   - Call the MSD hwremoved function.
1208 *
1209 * The remainder of the cleanup will be handled by unregister().
1210 * Our primary goal here is to prevent as much tickling of the MSD
1211 * as possible since the MSD is already in a 'wounded' state.
1212 *
1213 * TODO: As new features are added, this function should be
1214 *       updated.
1215 *
1216 * Arguments:
1217 *       wlandev         WLAN network device structure
1218 * Returns:
1219 *       nothing
1220 * Side effects:
1221 *
1222 * Call context:
1223 *       Usually interrupt.
1224 ----------------------------------------------------------------*/
1225 void p80211netdev_hwremoved(wlandevice_t *wlandev)
1226 {
1227         DBFENTER;
1228         wlandev->hwremoved = 1;
1229         if ( wlandev->state == WLAN_DEVICE_OPEN) {
1230                 p80211netdev_stop_queue(wlandev);
1231         }
1232
1233         netif_device_detach(wlandev->netdev);
1234
1235         DBFEXIT;
1236 }
1237
1238
1239 /*----------------------------------------------------------------
1240 * p80211_rx_typedrop
1241 *
1242 * Classifies the frame, increments the appropriate counter, and
1243 * returns 0|1|2 indicating whether the driver should handle, ignore, or
1244 * drop the frame
1245 *
1246 * Arguments:
1247 *       wlandev         wlan device structure
1248 *       fc              frame control field
1249 *
1250 * Returns:
1251 *       zero if the frame should be handled by the driver,
1252 *       one if the frame should be ignored
1253 *       anything else means we drop it.
1254 *
1255 * Side effects:
1256 *
1257 * Call context:
1258 *       interrupt
1259 ----------------------------------------------------------------*/
1260 static int p80211_rx_typedrop( wlandevice_t *wlandev, UINT16 fc)
1261 {
1262         UINT16  ftype;
1263         UINT16  fstype;
1264         int     drop = 0;
1265         /* Classify frame, increment counter */
1266         ftype = WLAN_GET_FC_FTYPE(fc);
1267         fstype = WLAN_GET_FC_FSTYPE(fc);
1268 #if 0
1269         WLAN_LOG_DEBUG(4,
1270                 "rx_typedrop : ftype=%d fstype=%d.\n", ftype, fstype);
1271 #endif
1272         switch ( ftype ) {
1273         case WLAN_FTYPE_MGMT:
1274                 if ((wlandev->netdev->flags & IFF_PROMISC) ||
1275                         (wlandev->netdev->flags & IFF_ALLMULTI)) {
1276                         drop = 1;
1277                         break;
1278                 }
1279                 WLAN_LOG_DEBUG(3, "rx'd mgmt:\n");
1280                 wlandev->rx.mgmt++;
1281                 switch( fstype ) {
1282                 case WLAN_FSTYPE_ASSOCREQ:
1283                         /* printk("assocreq"); */
1284                         wlandev->rx.assocreq++;
1285                         break;
1286                 case WLAN_FSTYPE_ASSOCRESP:
1287                         /* printk("assocresp"); */
1288                         wlandev->rx.assocresp++;
1289                         break;
1290                 case WLAN_FSTYPE_REASSOCREQ:
1291                         /* printk("reassocreq"); */
1292                         wlandev->rx.reassocreq++;
1293                         break;
1294                 case WLAN_FSTYPE_REASSOCRESP:
1295                         /* printk("reassocresp"); */
1296                         wlandev->rx.reassocresp++;
1297                         break;
1298                 case WLAN_FSTYPE_PROBEREQ:
1299                         /* printk("probereq"); */
1300                         wlandev->rx.probereq++;
1301                         break;
1302                 case WLAN_FSTYPE_PROBERESP:
1303                         /* printk("proberesp"); */
1304                         wlandev->rx.proberesp++;
1305                         break;
1306                 case WLAN_FSTYPE_BEACON:
1307                         /* printk("beacon"); */
1308                         wlandev->rx.beacon++;
1309                         break;
1310                 case WLAN_FSTYPE_ATIM:
1311                         /* printk("atim"); */
1312                         wlandev->rx.atim++;
1313                         break;
1314                 case WLAN_FSTYPE_DISASSOC:
1315                         /* printk("disassoc"); */
1316                         wlandev->rx.disassoc++;
1317                         break;
1318                 case WLAN_FSTYPE_AUTHEN:
1319                         /* printk("authen"); */
1320                         wlandev->rx.authen++;
1321                         break;
1322                 case WLAN_FSTYPE_DEAUTHEN:
1323                         /* printk("deauthen"); */
1324                         wlandev->rx.deauthen++;
1325                         break;
1326                 default:
1327                         /* printk("unknown"); */
1328                         wlandev->rx.mgmt_unknown++;
1329                         break;
1330                 }
1331                 /* printk("\n"); */
1332                 drop = 2;
1333                 break;
1334
1335         case WLAN_FTYPE_CTL:
1336                 if ((wlandev->netdev->flags & IFF_PROMISC) ||
1337                         (wlandev->netdev->flags & IFF_ALLMULTI)) {
1338                         drop = 1;
1339                         break;
1340                 }
1341                 WLAN_LOG_DEBUG(3, "rx'd ctl:\n");
1342                 wlandev->rx.ctl++;
1343                 switch( fstype ) {
1344                 case WLAN_FSTYPE_PSPOLL:
1345                         /* printk("pspoll"); */
1346                         wlandev->rx.pspoll++;
1347                         break;
1348                 case WLAN_FSTYPE_RTS:
1349                         /* printk("rts"); */
1350                         wlandev->rx.rts++;
1351                         break;
1352                 case WLAN_FSTYPE_CTS:
1353                         /* printk("cts"); */
1354                         wlandev->rx.cts++;
1355                         break;
1356                 case WLAN_FSTYPE_ACK:
1357                         /* printk("ack"); */
1358                         wlandev->rx.ack++;
1359                         break;
1360                 case WLAN_FSTYPE_CFEND:
1361                         /* printk("cfend"); */
1362                         wlandev->rx.cfend++;
1363                         break;
1364                 case WLAN_FSTYPE_CFENDCFACK:
1365                         /* printk("cfendcfack"); */
1366                         wlandev->rx.cfendcfack++;
1367                         break;
1368                 default:
1369                         /* printk("unknown"); */
1370                         wlandev->rx.ctl_unknown++;
1371                         break;
1372                 }
1373                 /* printk("\n"); */
1374                 drop = 2;
1375                 break;
1376
1377         case WLAN_FTYPE_DATA:
1378                 wlandev->rx.data++;
1379                 switch( fstype ) {
1380                 case WLAN_FSTYPE_DATAONLY:
1381                         wlandev->rx.dataonly++;
1382                         break;
1383                 case WLAN_FSTYPE_DATA_CFACK:
1384                         wlandev->rx.data_cfack++;
1385                         break;
1386                 case WLAN_FSTYPE_DATA_CFPOLL:
1387                         wlandev->rx.data_cfpoll++;
1388                         break;
1389                 case WLAN_FSTYPE_DATA_CFACK_CFPOLL:
1390                         wlandev->rx.data__cfack_cfpoll++;
1391                         break;
1392                 case WLAN_FSTYPE_NULL:
1393                         WLAN_LOG_DEBUG(3, "rx'd data:null\n");
1394                         wlandev->rx.null++;
1395                         break;
1396                 case WLAN_FSTYPE_CFACK:
1397                         WLAN_LOG_DEBUG(3, "rx'd data:cfack\n");
1398                         wlandev->rx.cfack++;
1399                         break;
1400                 case WLAN_FSTYPE_CFPOLL:
1401                         WLAN_LOG_DEBUG(3, "rx'd data:cfpoll\n");
1402                         wlandev->rx.cfpoll++;
1403                         break;
1404                 case WLAN_FSTYPE_CFACK_CFPOLL:
1405                         WLAN_LOG_DEBUG(3, "rx'd data:cfack_cfpoll\n");
1406                         wlandev->rx.cfack_cfpoll++;
1407                         break;
1408                 default:
1409                         /* printk("unknown"); */
1410                         wlandev->rx.data_unknown++;
1411                         break;
1412                 }
1413
1414                 break;
1415         }
1416         return drop;
1417 }
1418
1419 #ifdef CONFIG_HOTPLUG
1420 /* Notify userspace when a netdevice event occurs,
1421  * by running '/sbin/hotplug net' with certain
1422  * environment variables set.
1423  */
1424 int p80211_run_sbin_hotplug(wlandevice_t *wlandev, char *action)
1425 {
1426         char *argv[3], *envp[7], ifname[12 + IFNAMSIZ], action_str[32];
1427         char nsdname[32], wlan_wext[32];
1428         int i;
1429
1430         if (wlandev) {
1431                 sprintf(ifname, "INTERFACE=%s", wlandev->name);
1432                 sprintf(nsdname, "NSDNAME=%s", wlandev->nsdname);
1433         } else {
1434                 sprintf(ifname, "INTERFACE=null");
1435                 sprintf(nsdname, "NSDNAME=null");
1436         }
1437
1438         sprintf(wlan_wext, "WLAN_WEXT=%s", wlan_wext_write ? "y" : "");
1439         sprintf(action_str, "ACTION=%s", action);
1440
1441         i = 0;
1442         argv[i++] = hotplug_path;
1443         argv[i++] = "wlan";
1444         argv[i] = NULL;
1445
1446         i = 0;
1447         /* minimal command environment */
1448         envp [i++] = "HOME=/";
1449         envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
1450         envp [i++] = ifname;
1451         envp [i++] = action_str;
1452         envp [i++] = nsdname;
1453         envp [i++] = wlan_wext;
1454         envp [i] = NULL;
1455
1456 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,62))
1457         return call_usermodehelper(argv [0], argv, envp);
1458 #else
1459         return call_usermodehelper(argv [0], argv, envp, 0);
1460 #endif
1461 }
1462
1463 #endif
1464
1465
1466 void    p80211_suspend(wlandevice_t *wlandev)
1467 {
1468         DBFENTER;
1469
1470 #ifdef CONFIG_HOTPLUG
1471         p80211_run_sbin_hotplug(wlandev, WLAN_HOTPLUG_SUSPEND);
1472 #endif
1473
1474         DBFEXIT;
1475 }
1476
1477 void    p80211_resume(wlandevice_t *wlandev)
1478 {
1479         DBFENTER;
1480
1481 #ifdef CONFIG_HOTPLUG
1482         p80211_run_sbin_hotplug(wlandev, WLAN_HOTPLUG_RESUME);
1483 #endif
1484
1485         DBFEXIT;
1486 }
1487
1488 static void p80211knetdev_tx_timeout( netdevice_t *netdev)
1489 {
1490         wlandevice_t    *wlandev = netdev->ml_priv;
1491         DBFENTER;
1492
1493         if (wlandev->tx_timeout) {
1494                 wlandev->tx_timeout(wlandev);
1495         } else {
1496                 WLAN_LOG_WARNING("Implement tx_timeout for %s\n",
1497                                  wlandev->nsdname);
1498                 p80211netdev_wake_queue(wlandev);
1499         }
1500
1501         DBFEXIT;
1502 }