SAFE public projects git trees. - safe/jmp/linux-2.6/blob - net/ieee80211/ieee80211_tx.c

   1 /******************************************************************************
   2
   3   Copyright(c) 2003 - 2005 Intel Corporation. All rights reserved.
   4
   5   This program is free software; you can redistribute it and/or modify it
   6   under the terms of version 2 of the GNU General Public License as
   7   published by the Free Software Foundation.
   8
   9   This program is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12   more details.
  13
  14   You should have received a copy of the GNU General Public License along with
  15   this program; if not, write to the Free Software Foundation, Inc., 59
  16   Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17
  18   The full GNU General Public License is included in this distribution in the
  19   file called LICENSE.
  20
  21   Contact Information:
  22   James P. Ketrenos <ipw2100-admin@linux.intel.com>
  23   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  24
  25 ******************************************************************************/
  26 #include <linux/compiler.h>
  27 #include <linux/config.h>
  28 #include <linux/errno.h>
  29 #include <linux/if_arp.h>
  30 #include <linux/in6.h>
  31 #include <linux/in.h>
  32 #include <linux/ip.h>
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/netdevice.h>
  36 #include <linux/proc_fs.h>
  37 #include <linux/skbuff.h>
  38 #include <linux/slab.h>
  39 #include <linux/tcp.h>
  40 #include <linux/types.h>
  41 #include <linux/version.h>
  42 #include <linux/wireless.h>
  43 #include <linux/etherdevice.h>
  44 #include <asm/uaccess.h>
  45
  46 #include <net/ieee80211.h>
  47
  48 /*
  49
  50 802.11 Data Frame
  51
  52       ,-------------------------------------------------------------------.
  53 Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
  54       |------|------|---------|---------|---------|------|---------|------|
  55 Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  Frame  |  fcs |
  56       |      | tion | (BSSID) |         |         | ence |  data   |      |
  57       `--------------------------------------------------|         |------'
  58 Total: 28 non-data bytes                                 `----.----'
  59                                                               |
  60        .- 'Frame data' expands to <---------------------------'
  61        |
  62        V
  63       ,---------------------------------------------------.
  64 Bytes |  1   |  1   |    1    |    3     |  2   |  0-2304 |
  65       |------|------|---------|----------|------|---------|
  66 Desc. | SNAP | SNAP | Control |Eth Tunnel| Type | IP      |
  67       | DSAP | SSAP |         |          |      | Packet  |
  68       | 0xAA | 0xAA |0x03 (UI)|0x00-00-F8|      |         |
  69       `-----------------------------------------|         |
  70 Total: 8 non-data bytes                         `----.----'
  71                                                      |
  72        .- 'IP Packet' expands, if WEP enabled, to <--'
  73        |
  74        V
  75       ,-----------------------.
  76 Bytes |  4  |   0-2296  |  4  |
  77       |-----|-----------|-----|
  78 Desc. | IV  | Encrypted | ICV |
  79       |     | IP Packet |     |
  80       `-----------------------'
  81 Total: 8 non-data bytes
  82
  83 802.3 Ethernet Data Frame
  84
  85       ,-----------------------------------------.
  86 Bytes |   6   |   6   |  2   |  Variable |   4  |
  87       |-------|-------|------|-----------|------|
  88 Desc. | Dest. | Source| Type | IP Packet |  fcs |
  89       |  MAC  |  MAC  |      |           |      |
  90       `-----------------------------------------'
  91 Total: 18 non-data bytes
  92
  93 In the event that fragmentation is required, the incoming payload is split into
  94 N parts of size ieee->fts.  The first fragment contains the SNAP header and the
  95 remaining packets are just data.
  96
  97 If encryption is enabled, each fragment payload size is reduced by enough space
  98 to add the prefix and postfix (IV and ICV totalling 8 bytes in the case of WEP)
  99 So if you have 1500 bytes of payload with ieee->fts set to 500 without
 100 encryption it will take 3 frames.  With WEP it will take 4 frames as the
 101 payload of each frame is reduced to 492 bytes.
 102
 103 * SKB visualization
 104 *
 105 *  ,- skb->data
 106 * |
 107 * |    ETHERNET HEADER        ,-<-- PAYLOAD
 108 * |                           |     14 bytes from skb->data
 109 * |  2 bytes for Type --> ,T. |     (sizeof ethhdr)
 110 * |                       | | |
 111 * |,-Dest.--. ,--Src.---. | | |
 112 * |  6 bytes| | 6 bytes | | | |
 113 * v         | |         | | | |
 114 * 0         | v       1 | v | v           2
 115 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
 116 *     ^     | ^         | ^ |
 117 *     |     | |         | | |
 118 *     |     | |         | `T' <---- 2 bytes for Type
 119 *     |     | |         |
 120 *     |     | '---SNAP--' <-------- 6 bytes for SNAP
 121 *     |     |
 122 *     `-IV--' <-------------------- 4 bytes for IV (WEP)
 123 *
 124 *      SNAP HEADER
 125 *
 126 */
 127
 128 static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
 129 static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
 130
 131 static inline int ieee80211_copy_snap(u8 * data, u16 h_proto)
 132 {
 133         struct ieee80211_snap_hdr *snap;
 134         u8 *oui;
 135
 136         snap = (struct ieee80211_snap_hdr *)data;
 137         snap->dsap = 0xaa;
 138         snap->ssap = 0xaa;
 139         snap->ctrl = 0x03;
 140
 141         if (h_proto == 0x8137 || h_proto == 0x80f3)
 142                 oui = P802_1H_OUI;
 143         else
 144                 oui = RFC1042_OUI;
 145         snap->oui[0] = oui[0];
 146         snap->oui[1] = oui[1];
 147         snap->oui[2] = oui[2];
 148
 149         *(u16 *) (data + SNAP_SIZE) = htons(h_proto);
 150
 151         return SNAP_SIZE + sizeof(u16);
 152 }
 153
 154 static inline int ieee80211_encrypt_fragment(struct ieee80211_device *ieee,
 155                                              struct sk_buff *frag, int hdr_len)
 156 {
 157         struct ieee80211_crypt_data *crypt = ieee->crypt[ieee->tx_keyidx];
 158         int res;
 159
 160         if (crypt == NULL)
 161                 return -1;
 162
 163         /* To encrypt, frame format is:
 164          * IV (4 bytes), clear payload (including SNAP), ICV (4 bytes) */
 165         atomic_inc(&crypt->refcnt);
 166         res = 0;
 167         if (crypt->ops && crypt->ops->encrypt_mpdu)
 168                 res = crypt->ops->encrypt_mpdu(frag, hdr_len, crypt->priv);
 169
 170         atomic_dec(&crypt->refcnt);
 171         if (res < 0) {
 172                 printk(KERN_INFO "%s: Encryption failed: len=%d.\n",
 173                        ieee->dev->name, frag->len);
 174                 ieee->ieee_stats.tx_discards++;
 175                 return -1;
 176         }
 177
 178         return 0;
 179 }
 180
 181 void ieee80211_txb_free(struct ieee80211_txb *txb)
 182 {
 183         int i;
 184         if (unlikely(!txb))
 185                 return;
 186         for (i = 0; i < txb->nr_frags; i++)
 187                 if (txb->fragments[i])
 188                         dev_kfree_skb_any(txb->fragments[i]);
 189         kfree(txb);
 190 }
 191
 192 static struct ieee80211_txb *ieee80211_alloc_txb(int nr_frags, int txb_size,
 193                                                  int headroom, gfp_t gfp_mask)
 194 {
 195         struct ieee80211_txb *txb;
 196         int i;
 197         txb = kmalloc(sizeof(struct ieee80211_txb) + (sizeof(u8 *) * nr_frags),
 198                       gfp_mask);
 199         if (!txb)
 200                 return NULL;
 201
 202         memset(txb, 0, sizeof(struct ieee80211_txb));
 203         txb->nr_frags = nr_frags;
 204         txb->frag_size = txb_size;
 205
 206         for (i = 0; i < nr_frags; i++) {
 207                 txb->fragments[i] = __dev_alloc_skb(txb_size + headroom,
 208                                                     gfp_mask);
 209                 if (unlikely(!txb->fragments[i])) {
 210                         i--;
 211                         break;
 212                 }
 213                 skb_reserve(txb->fragments[i], headroom);
 214         }
 215         if (unlikely(i != nr_frags)) {
 216                 while (i >= 0)
 217                         dev_kfree_skb_any(txb->fragments[i--]);
 218                 kfree(txb);
 219                 return NULL;
 220         }
 221         return txb;
 222 }
 223
 224 /* Incoming skb is converted to a txb which consists of
 225  * a block of 802.11 fragment packets (stored as skbs) */
 226 int ieee80211_xmit(struct sk_buff *skb, struct net_device *dev)
 227 {
 228         struct ieee80211_device *ieee = netdev_priv(dev);
 229         struct ieee80211_txb *txb = NULL;
 230         struct ieee80211_hdr_3addr *frag_hdr;
 231         int i, bytes_per_frag, nr_frags, bytes_last_frag, frag_size,
 232             rts_required;
 233         unsigned long flags;
 234         struct net_device_stats *stats = &ieee->stats;
 235         int ether_type, encrypt, host_encrypt, host_encrypt_msdu, host_build_iv;
 236         int bytes, fc, hdr_len;
 237         struct sk_buff *skb_frag;
 238         struct ieee80211_hdr_3addr header = {   /* Ensure zero initialized */
 239                 .duration_id = 0,
 240                 .seq_ctl = 0
 241         };
 242         u8 dest[ETH_ALEN], src[ETH_ALEN];
 243         struct ieee80211_crypt_data *crypt;
 244         int priority = skb->priority;
 245         int snapped = 0;
 246
 247         if (ieee->is_queue_full && (*ieee->is_queue_full) (dev, priority))
 248                 return NETDEV_TX_BUSY;
 249
 250         spin_lock_irqsave(&ieee->lock, flags);
 251
 252         /* If there is no driver handler to take the TXB, dont' bother
 253          * creating it... */
 254         if (!ieee->hard_start_xmit) {
 255                 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
 256                 goto success;
 257         }
 258
 259         if (unlikely(skb->len < SNAP_SIZE + sizeof(u16))) {
 260                 printk(KERN_WARNING "%s: skb too small (%d).\n",
 261                        ieee->dev->name, skb->len);
 262                 goto success;
 263         }
 264
 265         ether_type = ntohs(((struct ethhdr *)skb->data)->h_proto);
 266
 267         crypt = ieee->crypt[ieee->tx_keyidx];
 268
 269         encrypt = !(ether_type == ETH_P_PAE && ieee->ieee802_1x) &&
 270             ieee->sec.encrypt;
 271
 272         host_encrypt = ieee->host_encrypt && encrypt && crypt;
 273         host_encrypt_msdu = ieee->host_encrypt_msdu && encrypt && crypt;
 274         host_build_iv = ieee->host_build_iv && encrypt && crypt;
 275
 276         if (!encrypt && ieee->ieee802_1x &&
 277             ieee->drop_unencrypted && ether_type != ETH_P_PAE) {
 278                 stats->tx_dropped++;
 279                 goto success;
 280         }
 281
 282         /* Save source and destination addresses */
 283         memcpy(dest, skb->data, ETH_ALEN);
 284         memcpy(src, skb->data + ETH_ALEN, ETH_ALEN);
 285
 286         /* Advance the SKB to the start of the payload */
 287         skb_pull(skb, sizeof(struct ethhdr));
 288
 289         /* Determine total amount of storage required for TXB packets */
 290         bytes = skb->len + SNAP_SIZE + sizeof(u16);
 291
 292         if (host_encrypt)
 293                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
 294                     IEEE80211_FCTL_PROTECTED;
 295         else
 296                 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA;
 297
 298         if (ieee->iw_mode == IW_MODE_INFRA) {
 299                 fc |= IEEE80211_FCTL_TODS;
 300                 /* To DS: Addr1 = BSSID, Addr2 = SA, Addr3 = DA */
 301                 memcpy(header.addr1, ieee->bssid, ETH_ALEN);
 302                 memcpy(header.addr2, src, ETH_ALEN);
 303                 memcpy(header.addr3, dest, ETH_ALEN);
 304         } else if (ieee->iw_mode == IW_MODE_ADHOC) {
 305                 /* not From/To DS: Addr1 = DA, Addr2 = SA, Addr3 = BSSID */
 306                 memcpy(header.addr1, dest, ETH_ALEN);
 307                 memcpy(header.addr2, src, ETH_ALEN);
 308                 memcpy(header.addr3, ieee->bssid, ETH_ALEN);
 309         }
 310         header.frame_ctl = cpu_to_le16(fc);
 311         hdr_len = IEEE80211_3ADDR_LEN;
 312
 313         /* Encrypt msdu first on the whole data packet. */
 314         if ((host_encrypt || host_encrypt_msdu) &&
 315             crypt && crypt->ops && crypt->ops->encrypt_msdu) {
 316                 int res = 0;
 317                 int len = bytes + hdr_len + crypt->ops->extra_msdu_prefix_len +
 318                     crypt->ops->extra_msdu_postfix_len;
 319                 struct sk_buff *skb_new = dev_alloc_skb(len);
 320
 321                 if (unlikely(!skb_new))
 322                         goto failed;
 323
 324                 skb_reserve(skb_new, crypt->ops->extra_msdu_prefix_len);
 325                 memcpy(skb_put(skb_new, hdr_len), &header, hdr_len);
 326                 snapped = 1;
 327                 ieee80211_copy_snap(skb_put(skb_new, SNAP_SIZE + sizeof(u16)),
 328                                     ether_type);
 329                 memcpy(skb_put(skb_new, skb->len), skb->data, skb->len);
 330                 res = crypt->ops->encrypt_msdu(skb_new, hdr_len, crypt->priv);
 331                 if (res < 0) {
 332                         IEEE80211_ERROR("msdu encryption failed\n");
 333                         dev_kfree_skb_any(skb_new);
 334                         goto failed;
 335                 }
 336                 dev_kfree_skb_any(skb);
 337                 skb = skb_new;
 338                 bytes += crypt->ops->extra_msdu_prefix_len +
 339                     crypt->ops->extra_msdu_postfix_len;
 340                 skb_pull(skb, hdr_len);
 341         }
 342
 343         if (host_encrypt || ieee->host_open_frag) {
 344                 /* Determine fragmentation size based on destination (multicast
 345                  * and broadcast are not fragmented) */
 346                 if (is_multicast_ether_addr(dest) ||
 347                     is_broadcast_ether_addr(dest))
 348                         frag_size = MAX_FRAG_THRESHOLD;
 349                 else
 350                         frag_size = ieee->fts;
 351
 352                 /* Determine amount of payload per fragment.  Regardless of if
 353                  * this stack is providing the full 802.11 header, one will
 354                  * eventually be affixed to this fragment -- so we must account
 355                  * for it when determining the amount of payload space. */
 356                 bytes_per_frag = frag_size - IEEE80211_3ADDR_LEN;
 357                 if (ieee->config &
 358                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 359                         bytes_per_frag -= IEEE80211_FCS_LEN;
 360
 361                 /* Each fragment may need to have room for encryptiong
 362                  * pre/postfix */
 363                 if (host_encrypt)
 364                         bytes_per_frag -= crypt->ops->extra_mpdu_prefix_len +
 365                             crypt->ops->extra_mpdu_postfix_len;
 366
 367                 /* Number of fragments is the total
 368                  * bytes_per_frag / payload_per_fragment */
 369                 nr_frags = bytes / bytes_per_frag;
 370                 bytes_last_frag = bytes % bytes_per_frag;
 371                 if (bytes_last_frag)
 372                         nr_frags++;
 373                 else
 374                         bytes_last_frag = bytes_per_frag;
 375         } else {
 376                 nr_frags = 1;
 377                 bytes_per_frag = bytes_last_frag = bytes;
 378                 frag_size = bytes + IEEE80211_3ADDR_LEN;
 379         }
 380
 381         rts_required = (frag_size > ieee->rts
 382                         && ieee->config & CFG_IEEE80211_RTS);
 383         if (rts_required)
 384                 nr_frags++;
 385
 386         /* When we allocate the TXB we allocate enough space for the reserve
 387          * and full fragment bytes (bytes_per_frag doesn't include prefix,
 388          * postfix, header, FCS, etc.) */
 389         txb = ieee80211_alloc_txb(nr_frags, frag_size,
 390                                   ieee->tx_headroom, GFP_ATOMIC);
 391         if (unlikely(!txb)) {
 392                 printk(KERN_WARNING "%s: Could not allocate TXB\n",
 393                        ieee->dev->name);
 394                 goto failed;
 395         }
 396         txb->encrypted = encrypt;
 397         if (host_encrypt)
 398                 txb->payload_size = frag_size * (nr_frags - 1) +
 399                     bytes_last_frag;
 400         else
 401                 txb->payload_size = bytes;
 402
 403         if (rts_required) {
 404                 skb_frag = txb->fragments[0];
 405                 frag_hdr =
 406                     (struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
 407
 408                 /*
 409                  * Set header frame_ctl to the RTS.
 410                  */
 411                 header.frame_ctl =
 412                     cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
 413                 memcpy(frag_hdr, &header, hdr_len);
 414
 415                 /*
 416                  * Restore header frame_ctl to the original data setting.
 417                  */
 418                 header.frame_ctl = cpu_to_le16(fc);
 419
 420                 if (ieee->config &
 421                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 422                         skb_put(skb_frag, 4);
 423
 424                 txb->rts_included = 1;
 425                 i = 1;
 426         } else
 427                 i = 0;
 428
 429         for (; i < nr_frags; i++) {
 430                 skb_frag = txb->fragments[i];
 431
 432                 if (host_encrypt || host_build_iv)
 433                         skb_reserve(skb_frag,
 434                                     crypt->ops->extra_mpdu_prefix_len);
 435
 436                 frag_hdr =
 437                     (struct ieee80211_hdr_3addr *)skb_put(skb_frag, hdr_len);
 438                 memcpy(frag_hdr, &header, hdr_len);
 439
 440                 /* If this is not the last fragment, then add the MOREFRAGS
 441                  * bit to the frame control */
 442                 if (i != nr_frags - 1) {
 443                         frag_hdr->frame_ctl =
 444                             cpu_to_le16(fc | IEEE80211_FCTL_MOREFRAGS);
 445                         bytes = bytes_per_frag;
 446                 } else {
 447                         /* The last fragment takes the remaining length */
 448                         bytes = bytes_last_frag;
 449                 }
 450
 451                 if (i == 0 && !snapped) {
 452                         ieee80211_copy_snap(skb_put
 453                                             (skb_frag, SNAP_SIZE + sizeof(u16)),
 454                                             ether_type);
 455                         bytes -= SNAP_SIZE + sizeof(u16);
 456                 }
 457
 458                 memcpy(skb_put(skb_frag, bytes), skb->data, bytes);
 459
 460                 /* Advance the SKB... */
 461                 skb_pull(skb, bytes);
 462
 463                 /* Encryption routine will move the header forward in order
 464                  * to insert the IV between the header and the payload */
 465                 if (host_encrypt)
 466                         ieee80211_encrypt_fragment(ieee, skb_frag, hdr_len);
 467                 else if (host_build_iv) {
 468                         struct ieee80211_crypt_data *crypt;
 469
 470                         crypt = ieee->crypt[ieee->tx_keyidx];
 471                         atomic_inc(&crypt->refcnt);
 472                         if (crypt->ops->build_iv)
 473                                 crypt->ops->build_iv(skb_frag, hdr_len,
 474                                                      crypt->priv);
 475                         atomic_dec(&crypt->refcnt);
 476                 }
 477
 478                 if (ieee->config &
 479                     (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 480                         skb_put(skb_frag, 4);
 481         }
 482
 483       success:
 484         spin_unlock_irqrestore(&ieee->lock, flags);
 485
 486         dev_kfree_skb_any(skb);
 487
 488         if (txb) {
 489                 int ret = (*ieee->hard_start_xmit) (txb, dev, priority);
 490                 if (ret == 0) {
 491                         stats->tx_packets++;
 492                         stats->tx_bytes += txb->payload_size;
 493                         return 0;
 494                 }
 495
 496                 if (ret == NETDEV_TX_BUSY) {
 497                         printk(KERN_ERR "%s: NETDEV_TX_BUSY returned; "
 498                                "driver should report queue full via "
 499                                "ieee_device->is_queue_full.\n",
 500                                ieee->dev->name);
 501                 }
 502
 503                 ieee80211_txb_free(txb);
 504         }
 505
 506         return 0;
 507
 508       failed:
 509         spin_unlock_irqrestore(&ieee->lock, flags);
 510         netif_stop_queue(dev);
 511         stats->tx_errors++;
 512         return 1;
 513 }
 514
 515 /* Incoming 802.11 strucure is converted to a TXB
 516  * a block of 802.11 fragment packets (stored as skbs) */
 517 int ieee80211_tx_frame(struct ieee80211_device *ieee,
 518                        struct ieee80211_hdr *frame, int len)
 519 {
 520         struct ieee80211_txb *txb = NULL;
 521         unsigned long flags;
 522         struct net_device_stats *stats = &ieee->stats;
 523         struct sk_buff *skb_frag;
 524         int priority = -1;
 525
 526         spin_lock_irqsave(&ieee->lock, flags);
 527
 528         /* If there is no driver handler to take the TXB, dont' bother
 529          * creating it... */
 530         if (!ieee->hard_start_xmit) {
 531                 printk(KERN_WARNING "%s: No xmit handler.\n", ieee->dev->name);
 532                 goto success;
 533         }
 534
 535         if (unlikely(len < 24)) {
 536                 printk(KERN_WARNING "%s: skb too small (%d).\n",
 537                        ieee->dev->name, len);
 538                 goto success;
 539         }
 540
 541         /* When we allocate the TXB we allocate enough space for the reserve
 542          * and full fragment bytes (bytes_per_frag doesn't include prefix,
 543          * postfix, header, FCS, etc.) */
 544         txb = ieee80211_alloc_txb(1, len, ieee->tx_headroom, GFP_ATOMIC);
 545         if (unlikely(!txb)) {
 546                 printk(KERN_WARNING "%s: Could not allocate TXB\n",
 547                        ieee->dev->name);
 548                 goto failed;
 549         }
 550         txb->encrypted = 0;
 551         txb->payload_size = len;
 552
 553         skb_frag = txb->fragments[0];
 554
 555         memcpy(skb_put(skb_frag, len), frame, len);
 556
 557         if (ieee->config &
 558             (CFG_IEEE80211_COMPUTE_FCS | CFG_IEEE80211_RESERVE_FCS))
 559                 skb_put(skb_frag, 4);
 560
 561       success:
 562         spin_unlock_irqrestore(&ieee->lock, flags);
 563
 564         if (txb) {
 565                 if ((*ieee->hard_start_xmit) (txb, ieee->dev, priority) == 0) {
 566                         stats->tx_packets++;
 567                         stats->tx_bytes += txb->payload_size;
 568                         return 0;
 569                 }
 570                 ieee80211_txb_free(txb);
 571         }
 572         return 0;
 573
 574       failed:
 575         spin_unlock_irqrestore(&ieee->lock, flags);
 576         stats->tx_errors++;
 577         return 1;
 578 }
 579
 580 EXPORT_SYMBOL(ieee80211_tx_frame);
 581 EXPORT_SYMBOL(ieee80211_txb_free);