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