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