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