drivers/staging/wlan-ng/p80211netdev.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MPL-1.1)
   2 /* src/p80211/p80211knetdev.c
   3  *
   4  * Linux Kernel net device interface
   5  *
   6  * Copyright (C) 1999 AbsoluteValue Systems, Inc.  All Rights Reserved.
   7  * --------------------------------------------------------------------
   8  *
   9  * linux-wlan
  10  *
  11  *   The contents of this file are subject to the Mozilla Public
  12  *   License Version 1.1 (the "License"); you may not use this file
  13  *   except in compliance with the License. You may obtain a copy of
  14  *   the License at http://www.mozilla.org/MPL/
  15  *
  16  *   Software distributed under the License is distributed on an "AS
  17  *   IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  18  *   implied. See the License for the specific language governing
  19  *   rights and limitations under the License.
  20  *
  21  *   Alternatively, the contents of this file may be used under the
  22  *   terms of the GNU Public License version 2 (the "GPL"), in which
  23  *   case the provisions of the GPL are applicable instead of the
  24  *   above.  If you wish to allow the use of your version of this file
  25  *   only under the terms of the GPL and not to allow others to use
  26  *   your version of this file under the MPL, indicate your decision
  27  *   by deleting the provisions above and replace them with the notice
  28  *   and other provisions required by the GPL.  If you do not delete
  29  *   the provisions above, a recipient may use your version of this
  30  *   file under either the MPL or the GPL.
  31  *
  32  * --------------------------------------------------------------------
  33  *
  34  * Inquiries regarding the linux-wlan Open Source project can be
  35  * made directly to:
  36  *
  37  * AbsoluteValue Systems Inc.
  38  * info@linux-wlan.com
  39  * http://www.linux-wlan.com
  40  *
  41  * --------------------------------------------------------------------
  42  *
  43  * Portions of the development of this software were funded by
  44  * Intersil Corporation as part of PRISM(R) chipset product development.
  45  *
  46  * --------------------------------------------------------------------
  47  *
  48  * The functions required for a Linux network device are defined here.
  49  *
  50  * --------------------------------------------------------------------
  51  */
  52
  53 #include <linux/module.h>
  54 #include <linux/kernel.h>
  55 #include <linux/sched.h>
  56 #include <linux/types.h>
  57 #include <linux/skbuff.h>
  58 #include <linux/slab.h>
  59 #include <linux/proc_fs.h>
  60 #include <linux/interrupt.h>
  61 #include <linux/netdevice.h>
  62 #include <linux/kmod.h>
  63 #include <linux/if_arp.h>
  64 #include <linux/wireless.h>
  65 #include <linux/sockios.h>
  66 #include <linux/etherdevice.h>
  67 #include <linux/if_ether.h>
  68 #include <linux/byteorder/generic.h>
  69 #include <linux/bitops.h>
  70 #include <linux/uaccess.h>
  71 #include <asm/byteorder.h>
  72
  73 #ifdef SIOCETHTOOL
  74 #include <linux/ethtool.h>
  75 #endif
  76
  77 #include <net/iw_handler.h>
  78 #include <net/net_namespace.h>
  79 #include <net/cfg80211.h>
  80
  81 #include "p80211types.h"
  82 #include "p80211hdr.h"
  83 #include "p80211conv.h"
  84 #include "p80211mgmt.h"
  85 #include "p80211msg.h"
  86 #include "p80211netdev.h"
  87 #include "p80211ioctl.h"
  88 #include "p80211req.h"
  89 #include "p80211metastruct.h"
  90 #include "p80211metadef.h"
  91
  92 #include "cfg80211.c"
  93
  94 /* netdevice method functions */
  95 static int p80211knetdev_init(struct net_device *netdev);
  96 static int p80211knetdev_open(struct net_device *netdev);
  97 static int p80211knetdev_stop(struct net_device *netdev);
  98 static netdev_tx_t p80211knetdev_hard_start_xmit(struct sk_buff *skb,
  99                                                  struct net_device *netdev);
 100 static void p80211knetdev_set_multicast_list(struct net_device *dev);
 101 static int p80211knetdev_do_ioctl(struct net_device *dev, struct ifreq *ifr,
 102                                   int cmd);
 103 static int p80211knetdev_set_mac_address(struct net_device *dev, void *addr);
 104 static void p80211knetdev_tx_timeout(struct net_device *netdev);
 105 static int p80211_rx_typedrop(struct wlandevice *wlandev, u16 fc);
 106
 107 int wlan_watchdog = 5000;
 108 module_param(wlan_watchdog, int, 0644);
 109 MODULE_PARM_DESC(wlan_watchdog, "transmit timeout in milliseconds");
 110
 111 int wlan_wext_write = 1;
 112 module_param(wlan_wext_write, int, 0644);
 113 MODULE_PARM_DESC(wlan_wext_write, "enable write wireless extensions");
 114
 115 /*----------------------------------------------------------------
 116  * p80211knetdev_init
 117  *
 118  * Init method for a Linux netdevice.  Called in response to
 119  * register_netdev.
 120  *
 121  * Arguments:
 122  *      none
 123  *
 124  * Returns:
 125  *      nothing
 126  *----------------------------------------------------------------
 127  */
 128 static int p80211knetdev_init(struct net_device *netdev)
 129 {
 130         /* Called in response to register_netdev */
 131         /* This is usually the probe function, but the probe has */
 132         /* already been done by the MSD and the create_kdev */
 133         /* function.  All we do here is return success */
 134         return 0;
 135 }
 136
 137 /*----------------------------------------------------------------
 138  * p80211knetdev_open
 139  *
 140  * Linux netdevice open method.  Following a successful call here,
 141  * the device is supposed to be ready for tx and rx.  In our
 142  * situation that may not be entirely true due to the state of the
 143  * MAC below.
 144  *
 145  * Arguments:
 146  *      netdev          Linux network device structure
 147  *
 148  * Returns:
 149  *      zero on success, non-zero otherwise
 150  *----------------------------------------------------------------
 151  */
 152 static int p80211knetdev_open(struct net_device *netdev)
 153 {
 154         int result = 0;         /* success */
 155         struct wlandevice *wlandev = netdev->ml_priv;
 156
 157         /* Check to make sure the MSD is running */
 158         if (wlandev->msdstate != WLAN_MSD_RUNNING)
 159                 return -ENODEV;
 160
 161         /* Tell the MSD to open */
 162         if (wlandev->open) {
 163                 result = wlandev->open(wlandev);
 164                 if (result == 0) {
 165                         netif_start_queue(wlandev->netdev);
 166                         wlandev->state = WLAN_DEVICE_OPEN;
 167                 }
 168         } else {
 169                 result = -EAGAIN;
 170         }
 171
 172         return result;
 173 }
 174
 175 /*----------------------------------------------------------------
 176  * p80211knetdev_stop
 177  *
 178  * Linux netdevice stop (close) method.  Following this call,
 179  * no frames should go up or down through this interface.
 180  *
 181  * Arguments:
 182  *      netdev          Linux network device structure
 183  *
 184  * Returns:
 185  *      zero on success, non-zero otherwise
 186  *----------------------------------------------------------------
 187  */
 188 static int p80211knetdev_stop(struct net_device *netdev)
 189 {
 190         int result = 0;
 191         struct wlandevice *wlandev = netdev->ml_priv;
 192
 193         if (wlandev->close)
 194                 result = wlandev->close(wlandev);
 195
 196         netif_stop_queue(wlandev->netdev);
 197         wlandev->state = WLAN_DEVICE_CLOSED;
 198
 199         return result;
 200 }
 201
 202 /*----------------------------------------------------------------
 203  * p80211netdev_rx
 204  *
 205  * Frame receive function called by the mac specific driver.
 206  *
 207  * Arguments:
 208  *      wlandev         WLAN network device structure
 209  *      skb             skbuff containing a full 802.11 frame.
 210  * Returns:
 211  *      nothing
 212  * Side effects:
 213  *
 214  *----------------------------------------------------------------
 215  */
 216 void p80211netdev_rx(struct wlandevice *wlandev, struct sk_buff *skb)
 217 {
 218         /* Enqueue for post-irq processing */
 219         skb_queue_tail(&wlandev->nsd_rxq, skb);
 220         tasklet_schedule(&wlandev->rx_bh);
 221 }
 222
 223 #define CONV_TO_ETHER_SKIPPED   0x01
 224 #define CONV_TO_ETHER_FAILED    0x02
 225
 226 /**
 227  * p80211_convert_to_ether - conversion from 802.11 frame to ethernet frame
 228  * @wlandev: pointer to WLAN device
 229  * @skb: pointer to socket buffer
 230  *
 231  * Returns: 0 if conversion succeeded
 232  *          CONV_TO_ETHER_FAILED if conversion failed
 233  *          CONV_TO_ETHER_SKIPPED if frame is ignored
 234  */
 235 static int p80211_convert_to_ether(struct wlandevice *wlandev,
 236                                    struct sk_buff *skb)
 237 {
 238         struct p80211_hdr_a3 *hdr;
 239
 240         hdr = (struct p80211_hdr_a3 *)skb->data;
 241         if (p80211_rx_typedrop(wlandev, le16_to_cpu(hdr->fc)))
 242                 return CONV_TO_ETHER_SKIPPED;
 243
 244         /* perform mcast filtering: allow my local address through but reject
 245          * anything else that isn't multicast
 246          */
 247         if (wlandev->netdev->flags & IFF_ALLMULTI) {
 248                 if (!ether_addr_equal_unaligned(wlandev->netdev->dev_addr,
 249                                                 hdr->a1)) {
 250                         if (!is_multicast_ether_addr(hdr->a1))
 251                                 return CONV_TO_ETHER_SKIPPED;
 252                 }
 253         }
 254
 255         if (skb_p80211_to_ether(wlandev, wlandev->ethconv, skb) == 0) {
 256                 wlandev->netdev->stats.rx_packets++;
 257                 wlandev->netdev->stats.rx_bytes += skb->len;
 258                 netif_rx_ni(skb);
 259                 return 0;
 260         }
 261
 262         netdev_dbg(wlandev->netdev, "%s failed.\n", __func__);
 263         return CONV_TO_ETHER_FAILED;
 264 }
 265
 266 /**
 267  * p80211netdev_rx_bh - deferred processing of all received frames
 268  *
 269  * @arg: pointer to WLAN network device structure (cast to unsigned long)
 270  */
 271 static void p80211netdev_rx_bh(unsigned long arg)
 272 {
 273         struct wlandevice *wlandev = (struct wlandevice *)arg;
 274         struct sk_buff *skb = NULL;
 275         struct net_device *dev = wlandev->netdev;
 276
 277         /* Let's empty our our queue */
 278         while ((skb = skb_dequeue(&wlandev->nsd_rxq))) {
 279                 if (wlandev->state == WLAN_DEVICE_OPEN) {
 280                         if (dev->type != ARPHRD_ETHER) {
 281                                 /* RAW frame; we shouldn't convert it */
 282                                 /* XXX Append the Prism Header here instead. */
 283
 284                                 /* set up various data fields */
 285                                 skb->dev = dev;
 286                                 skb_reset_mac_header(skb);
 287                                 skb->ip_summed = CHECKSUM_NONE;
 288                                 skb->pkt_type = PACKET_OTHERHOST;
 289                                 skb->protocol = htons(ETH_P_80211_RAW);
 290
 291                                 dev->stats.rx_packets++;
 292                                 dev->stats.rx_bytes += skb->len;
 293                                 netif_rx_ni(skb);
 294                                 continue;
 295                         } else {
 296                                 if (!p80211_convert_to_ether(wlandev, skb))
 297                                         continue;
 298                         }
 299                 }
 300                 dev_kfree_skb(skb);
 301         }
 302 }
 303
 304 /*----------------------------------------------------------------
 305  * p80211knetdev_hard_start_xmit
 306  *
 307  * Linux netdevice method for transmitting a frame.
 308  *
 309  * Arguments:
 310  *      skb     Linux sk_buff containing the frame.
 311  *      netdev  Linux netdevice.
 312  *
 313  * Side effects:
 314  *      If the lower layers report that buffers are full. netdev->tbusy
 315  *      will be set to prevent higher layers from sending more traffic.
 316  *
 317  *      Note: If this function returns non-zero, higher layers retain
 318  *            ownership of the skb.
 319  *
 320  * Returns:
 321  *      zero on success, non-zero on failure.
 322  *----------------------------------------------------------------
 323  */
 324 static netdev_tx_t p80211knetdev_hard_start_xmit(struct sk_buff *skb,
 325                                                  struct net_device *netdev)
 326 {
 327         int result = 0;
 328         int txresult = -1;
 329         struct wlandevice *wlandev = netdev->ml_priv;
 330         union p80211_hdr p80211_hdr;
 331         struct p80211_metawep p80211_wep;
 332
 333         p80211_wep.data = NULL;
 334
 335         if (!skb)
 336                 return NETDEV_TX_OK;
 337
 338         if (wlandev->state != WLAN_DEVICE_OPEN) {
 339                 result = 1;
 340                 goto failed;
 341         }
 342
 343         memset(&p80211_hdr, 0, sizeof(p80211_hdr));
 344         memset(&p80211_wep, 0, sizeof(p80211_wep));
 345
 346         if (netif_queue_stopped(netdev)) {
 347                 netdev_dbg(netdev, "called when queue stopped.\n");
 348                 result = 1;
 349                 goto failed;
 350         }
 351
 352         netif_stop_queue(netdev);
 353
 354         /* Check to see that a valid mode is set */
 355         switch (wlandev->macmode) {
 356         case WLAN_MACMODE_IBSS_STA:
 357         case WLAN_MACMODE_ESS_STA:
 358         case WLAN_MACMODE_ESS_AP:
 359                 break;
 360         default:
 361                 /* Mode isn't set yet, just drop the frame
 362                  * and return success .
 363                  * TODO: we need a saner way to handle this
 364                  */
 365                 if (be16_to_cpu(skb->protocol) != ETH_P_80211_RAW) {
 366                         netif_start_queue(wlandev->netdev);
 367                         netdev_notice(netdev, "Tx attempt prior to association, frame dropped.\n");
 368                         netdev->stats.tx_dropped++;
 369                         result = 0;
 370                         goto failed;
 371                 }
 372                 break;
 373         }
 374
 375         /* Check for raw transmits */
 376         if (be16_to_cpu(skb->protocol) == ETH_P_80211_RAW) {
 377                 if (!capable(CAP_NET_ADMIN)) {
 378                         result = 1;
 379                         goto failed;
 380                 }
 381                 /* move the header over */
 382                 memcpy(&p80211_hdr, skb->data, sizeof(p80211_hdr));
 383                 skb_pull(skb, sizeof(p80211_hdr));
 384         } else {
 385                 if (skb_ether_to_p80211
 386                     (wlandev, wlandev->ethconv, skb, &p80211_hdr,
 387                      &p80211_wep) != 0) {
 388                         /* convert failed */
 389                         netdev_dbg(netdev, "ether_to_80211(%d) failed.\n",
 390                                    wlandev->ethconv);
 391                         result = 1;
 392                         goto failed;
 393                 }
 394         }
 395         if (!wlandev->txframe) {
 396                 result = 1;
 397                 goto failed;
 398         }
 399
 400         netif_trans_update(netdev);
 401
 402         netdev->stats.tx_packets++;
 403         /* count only the packet payload */
 404         netdev->stats.tx_bytes += skb->len;
 405
 406         txresult = wlandev->txframe(wlandev, skb, &p80211_hdr, &p80211_wep);
 407
 408         if (txresult == 0) {
 409                 /* success and more buf */
 410                 /* avail, re: hw_txdata */
 411                 netif_wake_queue(wlandev->netdev);
 412                 result = NETDEV_TX_OK;
 413         } else if (txresult == 1) {
 414                 /* success, no more avail */
 415                 netdev_dbg(netdev, "txframe success, no more bufs\n");
 416                 /* netdev->tbusy = 1;  don't set here, irqhdlr */
 417                 /*   may have already cleared it */
 418                 result = NETDEV_TX_OK;
 419         } else if (txresult == 2) {
 420                 /* alloc failure, drop frame */
 421                 netdev_dbg(netdev, "txframe returned alloc_fail\n");
 422                 result = NETDEV_TX_BUSY;
 423         } else {
 424                 /* buffer full or queue busy, drop frame. */
 425                 netdev_dbg(netdev, "txframe returned full or busy\n");
 426                 result = NETDEV_TX_BUSY;
 427         }
 428
 429 failed:
 430         /* Free up the WEP buffer if it's not the same as the skb */
 431         if ((p80211_wep.data) && (p80211_wep.data != skb->data))
 432                 kzfree(p80211_wep.data);
 433
 434         /* we always free the skb here, never in a lower level. */
 435         if (!result)
 436                 dev_kfree_skb(skb);
 437
 438         return result;
 439 }
 440
 441 /*----------------------------------------------------------------
 442  * p80211knetdev_set_multicast_list
 443  *
 444  * Called from higher layers whenever there's a need to set/clear
 445  * promiscuous mode or rewrite the multicast list.
 446  *
 447  * Arguments:
 448  *      none
 449  *
 450  * Returns:
 451  *      nothing
 452  *----------------------------------------------------------------
 453  */
 454 static void p80211knetdev_set_multicast_list(struct net_device *dev)
 455 {
 456         struct wlandevice *wlandev = dev->ml_priv;
 457
 458         /* TODO:  real multicast support as well */
 459
 460         if (wlandev->set_multicast_list)
 461                 wlandev->set_multicast_list(wlandev, dev);
 462 }
 463
 464 #ifdef SIOCETHTOOL
 465
 466 static int p80211netdev_ethtool(struct wlandevice *wlandev,
 467                                 void __user *useraddr)
 468 {
 469         u32 ethcmd;
 470         struct ethtool_drvinfo info;
 471         struct ethtool_value edata;
 472
 473         memset(&info, 0, sizeof(info));
 474         memset(&edata, 0, sizeof(edata));
 475
 476         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
 477                 return -EFAULT;
 478
 479         switch (ethcmd) {
 480         case ETHTOOL_GDRVINFO:
 481                 info.cmd = ethcmd;
 482                 snprintf(info.driver, sizeof(info.driver), "p80211_%s",
 483                          wlandev->nsdname);
 484                 snprintf(info.version, sizeof(info.version), "%s",
 485                          WLAN_RELEASE);
 486
 487                 if (copy_to_user(useraddr, &info, sizeof(info)))
 488                         return -EFAULT;
 489                 return 0;
 490 #ifdef ETHTOOL_GLINK
 491         case ETHTOOL_GLINK:
 492                 edata.cmd = ethcmd;
 493
 494                 if (wlandev->linkstatus &&
 495                     (wlandev->macmode != WLAN_MACMODE_NONE)) {
 496                         edata.data = 1;
 497                 } else {
 498                         edata.data = 0;
 499                 }
 500
 501                 if (copy_to_user(useraddr, &edata, sizeof(edata)))
 502                         return -EFAULT;
 503                 return 0;
 504 #endif
 505         }
 506
 507         return -EOPNOTSUPP;
 508 }
 509
 510 #endif
 511
 512 /*----------------------------------------------------------------
 513  * p80211knetdev_do_ioctl
 514  *
 515  * Handle an ioctl call on one of our devices.  Everything Linux
 516  * ioctl specific is done here.  Then we pass the contents of the
 517  * ifr->data to the request message handler.
 518  *
 519  * Arguments:
 520  *      dev     Linux kernel netdevice
 521  *      ifr     Our private ioctl request structure, typed for the
 522  *              generic struct ifreq so we can use ptr to func
 523  *              w/o cast.
 524  *
 525  * Returns:
 526  *      zero on success, a negative errno on failure.  Possible values:
 527  *              -ENETDOWN Device isn't up.
 528  *              -EBUSY  cmd already in progress
 529  *              -ETIME  p80211 cmd timed out (MSD may have its own timers)
 530  *              -EFAULT memory fault copying msg from user buffer
 531  *              -ENOMEM unable to allocate kernel msg buffer
 532  *              -EINVAL bad magic, it the cmd really for us?
 533  *              -EintR  sleeping on cmd, awakened by signal, cmd cancelled.
 534  *
 535  * Call Context:
 536  *      Process thread (ioctl caller).  TODO: SMP support may require
 537  *      locks.
 538  *----------------------------------------------------------------
 539  */
 540 static int p80211knetdev_do_ioctl(struct net_device *dev,
 541                                   struct ifreq *ifr, int cmd)
 542 {
 543         int result = 0;
 544         struct p80211ioctl_req *req = (struct p80211ioctl_req *)ifr;
 545         struct wlandevice *wlandev = dev->ml_priv;
 546         u8 *msgbuf;
 547
 548         netdev_dbg(dev, "rx'd ioctl, cmd=%d, len=%d\n", cmd, req->len);
 549
 550 #ifdef SIOCETHTOOL
 551         if (cmd == SIOCETHTOOL) {
 552                 result =
 553                     p80211netdev_ethtool(wlandev, (void __user *)ifr->ifr_data);
 554                 goto bail;
 555         }
 556 #endif
 557
 558         /* Test the magic, assume ifr is good if it's there */
 559         if (req->magic != P80211_IOCTL_MAGIC) {
 560                 result = -EINVAL;
 561                 goto bail;
 562         }
 563
 564         if (cmd == P80211_IFTEST) {
 565                 result = 0;
 566                 goto bail;
 567         } else if (cmd != P80211_IFREQ) {
 568                 result = -EINVAL;
 569                 goto bail;
 570         }
 571
 572         /* Allocate a buf of size req->len */
 573         msgbuf = kmalloc(req->len, GFP_KERNEL);
 574         if (msgbuf) {
 575                 if (copy_from_user(msgbuf, (void __user *)req->data, req->len))
 576                         result = -EFAULT;
 577                 else
 578                         result = p80211req_dorequest(wlandev, msgbuf);
 579
 580                 if (result == 0) {
 581                         if (copy_to_user
 582                             ((void __user *)req->data, msgbuf, req->len)) {
 583                                 result = -EFAULT;
 584                         }
 585                 }
 586                 kfree(msgbuf);
 587         } else {
 588                 result = -ENOMEM;
 589         }
 590 bail:
 591         /* If allocate,copyfrom or copyto fails, return errno */
 592         return result;
 593 }
 594
 595 /*----------------------------------------------------------------
 596  * p80211knetdev_set_mac_address
 597  *
 598  * Handles the ioctl for changing the MACAddress of a netdevice
 599  *
 600  * references: linux/netdevice.h and drivers/net/net_init.c
 601  *
 602  * NOTE: [MSM] We only prevent address changes when the netdev is
 603  * up.  We don't control anything based on dot11 state.  If the
 604  * address is changed on a STA that's currently associated, you
 605  * will probably lose the ability to send and receive data frames.
 606  * Just be aware.  Therefore, this should usually only be done
 607  * prior to scan/join/auth/assoc.
 608  *
 609  * Arguments:
 610  *      dev     netdevice struct
 611  *      addr    the new MACAddress (a struct)
 612  *
 613  * Returns:
 614  *      zero on success, a negative errno on failure.  Possible values:
 615  *              -EBUSY  device is bussy (cmd not possible)
 616  *              -and errors returned by: p80211req_dorequest(..)
 617  *
 618  * by: Collin R. Mulliner <collin@mulliner.org>
 619  *----------------------------------------------------------------
 620  */
 621 static int p80211knetdev_set_mac_address(struct net_device *dev, void *addr)
 622 {
 623         struct sockaddr *new_addr = addr;
 624         struct p80211msg_dot11req_mibset dot11req;
 625         struct p80211item_unk392 *mibattr;
 626         struct p80211item_pstr6 *macaddr;
 627         struct p80211item_uint32 *resultcode;
 628         int result;
 629
 630         /* If we're running, we don't allow MAC address changes */
 631         if (netif_running(dev))
 632                 return -EBUSY;
 633
 634         /* Set up some convenience pointers. */
 635         mibattr = &dot11req.mibattribute;
 636         macaddr = (struct p80211item_pstr6 *)&mibattr->data;
 637         resultcode = &dot11req.resultcode;
 638
 639         /* Set up a dot11req_mibset */
 640         memset(&dot11req, 0, sizeof(dot11req));
 641         dot11req.msgcode = DIDmsg_dot11req_mibset;
 642         dot11req.msglen = sizeof(dot11req);
 643         memcpy(dot11req.devname,
 644                ((struct wlandevice *)dev->ml_priv)->name,
 645                WLAN_DEVNAMELEN_MAX - 1);
 646
 647         /* Set up the mibattribute argument */
 648         mibattr->did = DIDmsg_dot11req_mibset_mibattribute;
 649         mibattr->status = P80211ENUM_msgitem_status_data_ok;
 650         mibattr->len = sizeof(mibattr->data);
 651
 652         macaddr->did = DIDmib_dot11mac_dot11OperationTable_dot11MACAddress;
 653         macaddr->status = P80211ENUM_msgitem_status_data_ok;
 654         macaddr->len = sizeof(macaddr->data);
 655         macaddr->data.len = ETH_ALEN;
 656         memcpy(&macaddr->data.data, new_addr->sa_data, ETH_ALEN);
 657
 658         /* Set up the resultcode argument */
 659         resultcode->did = DIDmsg_dot11req_mibset_resultcode;
 660         resultcode->status = P80211ENUM_msgitem_status_no_value;
 661         resultcode->len = sizeof(resultcode->data);
 662         resultcode->data = 0;
 663
 664         /* now fire the request */
 665         result = p80211req_dorequest(dev->ml_priv, (u8 *)&dot11req);
 666
 667         /* If the request wasn't successful, report an error and don't
 668          * change the netdev address
 669          */
 670         if (result != 0 || resultcode->data != P80211ENUM_resultcode_success) {
 671                 netdev_err(dev, "Low-level driver failed dot11req_mibset(dot11MACAddress).\n");
 672                 result = -EADDRNOTAVAIL;
 673         } else {
 674                 /* everything's ok, change the addr in netdev */
 675                 memcpy(dev->dev_addr, new_addr->sa_data, dev->addr_len);
 676         }
 677
 678         return result;
 679 }
 680
 681 static const struct net_device_ops p80211_netdev_ops = {
 682         .ndo_init = p80211knetdev_init,
 683         .ndo_open = p80211knetdev_open,
 684         .ndo_stop = p80211knetdev_stop,
 685         .ndo_start_xmit = p80211knetdev_hard_start_xmit,
 686         .ndo_set_rx_mode = p80211knetdev_set_multicast_list,
 687         .ndo_do_ioctl = p80211knetdev_do_ioctl,
 688         .ndo_set_mac_address = p80211knetdev_set_mac_address,
 689         .ndo_tx_timeout = p80211knetdev_tx_timeout,
 690         .ndo_validate_addr = eth_validate_addr,
 691 };
 692
 693 /*----------------------------------------------------------------
 694  * wlan_setup
 695  *
 696  * Roughly matches the functionality of ether_setup.  Here
 697  * we set up any members of the wlandevice structure that are common
 698  * to all devices.  Additionally, we allocate a linux 'struct device'
 699  * and perform the same setup as ether_setup.
 700  *
 701  * Note: It's important that the caller have setup the wlandev->name
 702  *      ptr prior to calling this function.
 703  *
 704  * Arguments:
 705  *      wlandev         ptr to the wlandev structure for the
 706  *                      interface.
 707  *      physdev         ptr to usb device
 708  * Returns:
 709  *      zero on success, non-zero otherwise.
 710  * Call Context:
 711  *      Should be process thread.  We'll assume it might be
 712  *      interrupt though.  When we add support for statically
 713  *      compiled drivers, this function will be called in the
 714  *      context of the kernel startup code.
 715  *----------------------------------------------------------------
 716  */
 717 int wlan_setup(struct wlandevice *wlandev, struct device *physdev)
 718 {
 719         int result = 0;
 720         struct net_device *netdev;
 721         struct wiphy *wiphy;
 722         struct wireless_dev *wdev;
 723
 724         /* Set up the wlandev */
 725         wlandev->state = WLAN_DEVICE_CLOSED;
 726         wlandev->ethconv = WLAN_ETHCONV_8021h;
 727         wlandev->macmode = WLAN_MACMODE_NONE;
 728
 729         /* Set up the rx queue */
 730         skb_queue_head_init(&wlandev->nsd_rxq);
 731         tasklet_init(&wlandev->rx_bh,
 732                      p80211netdev_rx_bh, (unsigned long)wlandev);
 733
 734         /* Allocate and initialize the wiphy struct */
 735         wiphy = wlan_create_wiphy(physdev, wlandev);
 736         if (!wiphy) {
 737                 dev_err(physdev, "Failed to alloc wiphy.\n");
 738                 return 1;
 739         }
 740
 741         /* Allocate and initialize the struct device */
 742         netdev = alloc_netdev(sizeof(struct wireless_dev), "wlan%d",
 743                               NET_NAME_UNKNOWN, ether_setup);
 744         if (!netdev) {
 745                 dev_err(physdev, "Failed to alloc netdev.\n");
 746                 wlan_free_wiphy(wiphy);
 747                 result = 1;
 748         } else {
 749                 wlandev->netdev = netdev;
 750                 netdev->ml_priv = wlandev;
 751                 netdev->netdev_ops = &p80211_netdev_ops;
 752                 wdev = netdev_priv(netdev);
 753                 wdev->wiphy = wiphy;
 754                 wdev->iftype = NL80211_IFTYPE_STATION;
 755                 netdev->ieee80211_ptr = wdev;
 756                 netdev->min_mtu = 68;
 757                 /* 2312 is max 802.11 payload, 20 is overhead,
 758                  * (ether + llc + snap) and another 8 for wep.
 759                  */
 760                 netdev->max_mtu = (2312 - 20 - 8);
 761
 762                 netif_stop_queue(netdev);
 763                 netif_carrier_off(netdev);
 764         }
 765
 766         return result;
 767 }
 768
 769 /*----------------------------------------------------------------
 770  * wlan_unsetup
 771  *
 772  * This function is paired with the wlan_setup routine.  It should
 773  * be called after unregister_wlandev.  Basically, all it does is
 774  * free the 'struct device' that's associated with the wlandev.
 775  * We do it here because the 'struct device' isn't allocated
 776  * explicitly in the driver code, it's done in wlan_setup.  To
 777  * do the free in the driver might seem like 'magic'.
 778  *
 779  * Arguments:
 780  *      wlandev         ptr to the wlandev structure for the
 781  *                      interface.
 782  * Call Context:
 783  *      Should be process thread.  We'll assume it might be
 784  *      interrupt though.  When we add support for statically
 785  *      compiled drivers, this function will be called in the
 786  *      context of the kernel startup code.
 787  *----------------------------------------------------------------
 788  */
 789 void wlan_unsetup(struct wlandevice *wlandev)
 790 {
 791         struct wireless_dev *wdev;
 792
 793         tasklet_kill(&wlandev->rx_bh);
 794
 795         if (wlandev->netdev) {
 796                 wdev = netdev_priv(wlandev->netdev);
 797                 if (wdev->wiphy)
 798                         wlan_free_wiphy(wdev->wiphy);
 799                 free_netdev(wlandev->netdev);
 800                 wlandev->netdev = NULL;
 801         }
 802 }
 803
 804 /*----------------------------------------------------------------
 805  * register_wlandev
 806  *
 807  * Roughly matches the functionality of register_netdev.  This function
 808  * is called after the driver has successfully probed and set up the
 809  * resources for the device.  It's now ready to become a named device
 810  * in the Linux system.
 811  *
 812  * First we allocate a name for the device (if not already set), then
 813  * we call the Linux function register_netdevice.
 814  *
 815  * Arguments:
 816  *      wlandev         ptr to the wlandev structure for the
 817  *                      interface.
 818  * Returns:
 819  *      zero on success, non-zero otherwise.
 820  * Call Context:
 821  *      Can be either interrupt or not.
 822  *----------------------------------------------------------------
 823  */
 824 int register_wlandev(struct wlandevice *wlandev)
 825 {
 826         return register_netdev(wlandev->netdev);
 827 }
 828
 829 /*----------------------------------------------------------------
 830  * unregister_wlandev
 831  *
 832  * Roughly matches the functionality of unregister_netdev.  This
 833  * function is called to remove a named device from the system.
 834  *
 835  * First we tell linux that the device should no longer exist.
 836  * Then we remove it from the list of known wlan devices.
 837  *
 838  * Arguments:
 839  *      wlandev         ptr to the wlandev structure for the
 840  *                      interface.
 841  * Returns:
 842  *      zero on success, non-zero otherwise.
 843  * Call Context:
 844  *      Can be either interrupt or not.
 845  *----------------------------------------------------------------
 846  */
 847 int unregister_wlandev(struct wlandevice *wlandev)
 848 {
 849         struct sk_buff *skb;
 850
 851         unregister_netdev(wlandev->netdev);
 852
 853         /* Now to clean out the rx queue */
 854         while ((skb = skb_dequeue(&wlandev->nsd_rxq)))
 855                 dev_kfree_skb(skb);
 856
 857         return 0;
 858 }
 859
 860 /*----------------------------------------------------------------
 861  * p80211netdev_hwremoved
 862  *
 863  * Hardware removed notification. This function should be called
 864  * immediately after an MSD has detected that the underlying hardware
 865  * has been yanked out from under us.  The primary things we need
 866  * to do are:
 867  *   - Mark the wlandev
 868  *   - Prevent any further traffic from the knetdev i/f
 869  *   - Prevent any further requests from mgmt i/f
 870  *   - If there are any waitq'd mgmt requests or mgmt-frame exchanges,
 871  *     shut them down.
 872  *   - Call the MSD hwremoved function.
 873  *
 874  * The remainder of the cleanup will be handled by unregister().
 875  * Our primary goal here is to prevent as much tickling of the MSD
 876  * as possible since the MSD is already in a 'wounded' state.
 877  *
 878  * TODO: As new features are added, this function should be
 879  *       updated.
 880  *
 881  * Arguments:
 882  *      wlandev         WLAN network device structure
 883  * Returns:
 884  *      nothing
 885  * Side effects:
 886  *
 887  * Call context:
 888  *      Usually interrupt.
 889  *----------------------------------------------------------------
 890  */
 891 void p80211netdev_hwremoved(struct wlandevice *wlandev)
 892 {
 893         wlandev->hwremoved = 1;
 894         if (wlandev->state == WLAN_DEVICE_OPEN)
 895                 netif_stop_queue(wlandev->netdev);
 896
 897         netif_device_detach(wlandev->netdev);
 898 }
 899
 900 /*----------------------------------------------------------------
 901  * p80211_rx_typedrop
 902  *
 903  * Classifies the frame, increments the appropriate counter, and
 904  * returns 0|1|2 indicating whether the driver should handle, ignore, or
 905  * drop the frame
 906  *
 907  * Arguments:
 908  *      wlandev         wlan device structure
 909  *      fc              frame control field
 910  *
 911  * Returns:
 912  *      zero if the frame should be handled by the driver,
 913  *       one if the frame should be ignored
 914  *       anything else means we drop it.
 915  *
 916  * Side effects:
 917  *
 918  * Call context:
 919  *      interrupt
 920  *----------------------------------------------------------------
 921  */
 922 static int p80211_rx_typedrop(struct wlandevice *wlandev, u16 fc)
 923 {
 924         u16 ftype;
 925         u16 fstype;
 926         int drop = 0;
 927         /* Classify frame, increment counter */
 928         ftype = WLAN_GET_FC_FTYPE(fc);
 929         fstype = WLAN_GET_FC_FSTYPE(fc);
 930 #if 0
 931         netdev_dbg(wlandev->netdev, "rx_typedrop : ftype=%d fstype=%d.\n",
 932                    ftype, fstype);
 933 #endif
 934         switch (ftype) {
 935         case WLAN_FTYPE_MGMT:
 936                 if ((wlandev->netdev->flags & IFF_PROMISC) ||
 937                     (wlandev->netdev->flags & IFF_ALLMULTI)) {
 938                         drop = 1;
 939                         break;
 940                 }
 941                 netdev_dbg(wlandev->netdev, "rx'd mgmt:\n");
 942                 wlandev->rx.mgmt++;
 943                 switch (fstype) {
 944                 case WLAN_FSTYPE_ASSOCREQ:
 945                         /* printk("assocreq"); */
 946                         wlandev->rx.assocreq++;
 947                         break;
 948                 case WLAN_FSTYPE_ASSOCRESP:
 949                         /* printk("assocresp"); */
 950                         wlandev->rx.assocresp++;
 951                         break;
 952                 case WLAN_FSTYPE_REASSOCREQ:
 953                         /* printk("reassocreq"); */
 954                         wlandev->rx.reassocreq++;
 955                         break;
 956                 case WLAN_FSTYPE_REASSOCRESP:
 957                         /* printk("reassocresp"); */
 958                         wlandev->rx.reassocresp++;
 959                         break;
 960                 case WLAN_FSTYPE_PROBEREQ:
 961                         /* printk("probereq"); */
 962                         wlandev->rx.probereq++;
 963                         break;
 964                 case WLAN_FSTYPE_PROBERESP:
 965                         /* printk("proberesp"); */
 966                         wlandev->rx.proberesp++;
 967                         break;
 968                 case WLAN_FSTYPE_BEACON:
 969                         /* printk("beacon"); */
 970                         wlandev->rx.beacon++;
 971                         break;
 972                 case WLAN_FSTYPE_ATIM:
 973                         /* printk("atim"); */
 974                         wlandev->rx.atim++;
 975                         break;
 976                 case WLAN_FSTYPE_DISASSOC:
 977                         /* printk("disassoc"); */
 978                         wlandev->rx.disassoc++;
 979                         break;
 980                 case WLAN_FSTYPE_AUTHEN:
 981                         /* printk("authen"); */
 982                         wlandev->rx.authen++;
 983                         break;
 984                 case WLAN_FSTYPE_DEAUTHEN:
 985                         /* printk("deauthen"); */
 986                         wlandev->rx.deauthen++;
 987                         break;
 988                 default:
 989                         /* printk("unknown"); */
 990                         wlandev->rx.mgmt_unknown++;
 991                         break;
 992                 }
 993                 /* printk("\n"); */
 994                 drop = 2;
 995                 break;
 996
 997         case WLAN_FTYPE_CTL:
 998                 if ((wlandev->netdev->flags & IFF_PROMISC) ||
 999                     (wlandev->netdev->flags & IFF_ALLMULTI)) {
1000                         drop = 1;
1001                         break;
1002                 }
1003                 netdev_dbg(wlandev->netdev, "rx'd ctl:\n");
1004                 wlandev->rx.ctl++;
1005                 switch (fstype) {
1006                 case WLAN_FSTYPE_PSPOLL:
1007                         /* printk("pspoll"); */
1008                         wlandev->rx.pspoll++;
1009                         break;
1010                 case WLAN_FSTYPE_RTS:
1011                         /* printk("rts"); */
1012                         wlandev->rx.rts++;
1013                         break;
1014                 case WLAN_FSTYPE_CTS:
1015                         /* printk("cts"); */
1016                         wlandev->rx.cts++;
1017                         break;
1018                 case WLAN_FSTYPE_ACK:
1019                         /* printk("ack"); */
1020                         wlandev->rx.ack++;
1021                         break;
1022                 case WLAN_FSTYPE_CFEND:
1023                         /* printk("cfend"); */
1024                         wlandev->rx.cfend++;
1025                         break;
1026                 case WLAN_FSTYPE_CFENDCFACK:
1027                         /* printk("cfendcfack"); */
1028                         wlandev->rx.cfendcfack++;
1029                         break;
1030                 default:
1031                         /* printk("unknown"); */
1032                         wlandev->rx.ctl_unknown++;
1033                         break;
1034                 }
1035                 /* printk("\n"); */
1036                 drop = 2;
1037                 break;
1038
1039         case WLAN_FTYPE_DATA:
1040                 wlandev->rx.data++;
1041                 switch (fstype) {
1042                 case WLAN_FSTYPE_DATAONLY:
1043                         wlandev->rx.dataonly++;
1044                         break;
1045                 case WLAN_FSTYPE_DATA_CFACK:
1046                         wlandev->rx.data_cfack++;
1047                         break;
1048                 case WLAN_FSTYPE_DATA_CFPOLL:
1049                         wlandev->rx.data_cfpoll++;
1050                         break;
1051                 case WLAN_FSTYPE_DATA_CFACK_CFPOLL:
1052                         wlandev->rx.data__cfack_cfpoll++;
1053                         break;
1054                 case WLAN_FSTYPE_NULL:
1055                         netdev_dbg(wlandev->netdev, "rx'd data:null\n");
1056                         wlandev->rx.null++;
1057                         break;
1058                 case WLAN_FSTYPE_CFACK:
1059                         netdev_dbg(wlandev->netdev, "rx'd data:cfack\n");
1060                         wlandev->rx.cfack++;
1061                         break;
1062                 case WLAN_FSTYPE_CFPOLL:
1063                         netdev_dbg(wlandev->netdev, "rx'd data:cfpoll\n");
1064                         wlandev->rx.cfpoll++;
1065                         break;
1066                 case WLAN_FSTYPE_CFACK_CFPOLL:
1067                         netdev_dbg(wlandev->netdev, "rx'd data:cfack_cfpoll\n");
1068                         wlandev->rx.cfack_cfpoll++;
1069                         break;
1070                 default:
1071                         /* printk("unknown"); */
1072                         wlandev->rx.data_unknown++;
1073                         break;
1074                 }
1075
1076                 break;
1077         }
1078         return drop;
1079 }
1080
1081 static void p80211knetdev_tx_timeout(struct net_device *netdev)
1082 {
1083         struct wlandevice *wlandev = netdev->ml_priv;
1084
1085         if (wlandev->tx_timeout) {
1086                 wlandev->tx_timeout(wlandev);
1087         } else {
1088                 netdev_warn(netdev, "Implement tx_timeout for %s\n",
1089                             wlandev->nsdname);
1090                 netif_wake_queue(wlandev->netdev);
1091         }
1092 }