]>
Commit | Line | Data |
---|---|---|
5e6e3a92 BZ |
1 | /* |
2 | * Marvell Wireless LAN device driver: station RX data handling | |
3 | * | |
4 | * Copyright (C) 2011, Marvell International Ltd. | |
5 | * | |
6 | * This software file (the "File") is distributed by Marvell International | |
7 | * Ltd. under the terms of the GNU General Public License Version 2, June 1991 | |
8 | * (the "License"). You may use, redistribute and/or modify this File in | |
9 | * accordance with the terms and conditions of the License, a copy of which | |
10 | * is available by writing to the Free Software Foundation, Inc., | |
11 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the | |
12 | * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt. | |
13 | * | |
14 | * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE | |
15 | * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE | |
16 | * ARE EXPRESSLY DISCLAIMED. The License provides additional details about | |
17 | * this warranty disclaimer. | |
18 | */ | |
19 | ||
587b36d3 AP |
20 | #include <uapi/linux/ipv6.h> |
21 | #include <net/ndisc.h> | |
5e6e3a92 BZ |
22 | #include "decl.h" |
23 | #include "ioctl.h" | |
24 | #include "util.h" | |
25 | #include "fw.h" | |
26 | #include "main.h" | |
27 | #include "11n_aggr.h" | |
28 | #include "11n_rxreorder.h" | |
29 | ||
587b36d3 AP |
30 | /* This function checks if a frame is IPv4 ARP or IPv6 Neighbour advertisement |
31 | * frame. If frame has both source and destination mac address as same, this | |
32 | * function drops such gratuitous frames. | |
33 | */ | |
34 | static bool | |
35 | mwifiex_discard_gratuitous_arp(struct mwifiex_private *priv, | |
36 | struct sk_buff *skb) | |
37 | { | |
38 | const struct mwifiex_arp_eth_header *arp; | |
39 | struct ethhdr *eth_hdr; | |
40 | struct ipv6hdr *ipv6; | |
41 | struct icmp6hdr *icmpv6; | |
42 | ||
43 | eth_hdr = (struct ethhdr *)skb->data; | |
44 | switch (ntohs(eth_hdr->h_proto)) { | |
45 | case ETH_P_ARP: | |
46 | arp = (void *)(skb->data + sizeof(struct ethhdr)); | |
47 | if (arp->hdr.ar_op == htons(ARPOP_REPLY) || | |
48 | arp->hdr.ar_op == htons(ARPOP_REQUEST)) { | |
49 | if (!memcmp(arp->ar_sip, arp->ar_tip, 4)) | |
50 | return true; | |
51 | } | |
52 | break; | |
53 | case ETH_P_IPV6: | |
54 | ipv6 = (void *)(skb->data + sizeof(struct ethhdr)); | |
55 | icmpv6 = (void *)(skb->data + sizeof(struct ethhdr) + | |
56 | sizeof(struct ipv6hdr)); | |
57 | if (NDISC_NEIGHBOUR_ADVERTISEMENT == icmpv6->icmp6_type) { | |
58 | if (!memcmp(&ipv6->saddr, &ipv6->daddr, | |
59 | sizeof(struct in6_addr))) | |
60 | return true; | |
61 | } | |
62 | break; | |
63 | default: | |
64 | break; | |
65 | } | |
66 | ||
67 | return false; | |
68 | } | |
69 | ||
5e6e3a92 BZ |
70 | /* |
71 | * This function processes the received packet and forwards it | |
72 | * to kernel/upper layer. | |
73 | * | |
74 | * This function parses through the received packet and determines | |
75 | * if it is a debug packet or normal packet. | |
76 | * | |
77 | * For non-debug packets, the function chops off unnecessary leading | |
78 | * header bytes, reconstructs the packet as an ethernet frame or | |
79 | * 802.2/llc/snap frame as required, and sends it to kernel/upper layer. | |
80 | * | |
81 | * The completion callback is called after processing in complete. | |
82 | */ | |
f3b369e4 | 83 | int mwifiex_process_rx_packet(struct mwifiex_private *priv, |
5e6e3a92 BZ |
84 | struct sk_buff *skb) |
85 | { | |
270e58e8 | 86 | int ret; |
5e6e3a92 BZ |
87 | struct rx_packet_hdr *rx_pkt_hdr; |
88 | struct rxpd *local_rx_pd; | |
89 | int hdr_chop; | |
90 | struct ethhdr *eth_hdr; | |
5e6e3a92 BZ |
91 | |
92 | local_rx_pd = (struct rxpd *) (skb->data); | |
93 | ||
ed1ea6f4 AK |
94 | rx_pkt_hdr = (void *)local_rx_pd + |
95 | le16_to_cpu(local_rx_pd->rx_pkt_offset); | |
5e6e3a92 | 96 | |
c613d16f AK |
97 | if ((!memcmp(&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header, |
98 | sizeof(bridge_tunnel_header))) || | |
99 | (!memcmp(&rx_pkt_hdr->rfc1042_hdr, rfc1042_header, | |
100 | sizeof(rfc1042_header)) && | |
101 | ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_AARP && | |
102 | ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_IPX)) { | |
5e6e3a92 BZ |
103 | /* |
104 | * Replace the 803 header and rfc1042 header (llc/snap) with an | |
105 | * EthernetII header, keep the src/dst and snap_type | |
106 | * (ethertype). | |
107 | * The firmware only passes up SNAP frames converting | |
108 | * all RX Data from 802.11 to 802.2/LLC/SNAP frames. | |
109 | * To create the Ethernet II, just move the src, dst address | |
110 | * right before the snap_type. | |
111 | */ | |
112 | eth_hdr = (struct ethhdr *) | |
113 | ((u8 *) &rx_pkt_hdr->eth803_hdr | |
114 | + sizeof(rx_pkt_hdr->eth803_hdr) + | |
115 | sizeof(rx_pkt_hdr->rfc1042_hdr) | |
116 | - sizeof(rx_pkt_hdr->eth803_hdr.h_dest) | |
117 | - sizeof(rx_pkt_hdr->eth803_hdr.h_source) | |
118 | - sizeof(rx_pkt_hdr->rfc1042_hdr.snap_type)); | |
119 | ||
120 | memcpy(eth_hdr->h_source, rx_pkt_hdr->eth803_hdr.h_source, | |
121 | sizeof(eth_hdr->h_source)); | |
122 | memcpy(eth_hdr->h_dest, rx_pkt_hdr->eth803_hdr.h_dest, | |
123 | sizeof(eth_hdr->h_dest)); | |
124 | ||
125 | /* Chop off the rxpd + the excess memory from the 802.2/llc/snap | |
126 | header that was removed. */ | |
127 | hdr_chop = (u8 *) eth_hdr - (u8 *) local_rx_pd; | |
128 | } else { | |
129 | /* Chop off the rxpd */ | |
130 | hdr_chop = (u8 *) &rx_pkt_hdr->eth803_hdr - | |
131 | (u8 *) local_rx_pd; | |
132 | } | |
133 | ||
134 | /* Chop off the leading header bytes so the it points to the start of | |
135 | either the reconstructed EthII frame or the 802.2/llc/snap frame */ | |
136 | skb_pull(skb, hdr_chop); | |
137 | ||
587b36d3 AP |
138 | if (priv->hs2_enabled && |
139 | mwifiex_discard_gratuitous_arp(priv, skb)) { | |
140 | dev_dbg(priv->adapter->dev, "Bypassed Gratuitous ARP\n"); | |
141 | dev_kfree_skb_any(skb); | |
142 | return 0; | |
143 | } | |
144 | ||
5e6e3a92 BZ |
145 | priv->rxpd_rate = local_rx_pd->rx_rate; |
146 | ||
147 | priv->rxpd_htinfo = local_rx_pd->ht_info; | |
148 | ||
f3b369e4 | 149 | ret = mwifiex_recv_packet(priv, skb); |
5e6e3a92 | 150 | if (ret == -1) |
f3b369e4 | 151 | dev_err(priv->adapter->dev, "recv packet failed\n"); |
5e6e3a92 BZ |
152 | |
153 | return ret; | |
154 | } | |
155 | ||
156 | /* | |
157 | * This function processes the received buffer. | |
158 | * | |
159 | * The function looks into the RxPD and performs sanity tests on the | |
160 | * received buffer to ensure its a valid packet, before processing it | |
161 | * further. If the packet is determined to be aggregated, it is | |
162 | * de-aggregated accordingly. Non-unicast packets are sent directly to | |
163 | * the kernel/upper layers. Unicast packets are handed over to the | |
164 | * Rx reordering routine if 11n is enabled. | |
165 | * | |
166 | * The completion callback is called after processing in complete. | |
167 | */ | |
f3b369e4 | 168 | int mwifiex_process_sta_rx_packet(struct mwifiex_private *priv, |
5e6e3a92 BZ |
169 | struct sk_buff *skb) |
170 | { | |
f3b369e4 | 171 | struct mwifiex_adapter *adapter = priv->adapter; |
5e6e3a92 BZ |
172 | int ret = 0; |
173 | struct rxpd *local_rx_pd; | |
5e6e3a92 BZ |
174 | struct rx_packet_hdr *rx_pkt_hdr; |
175 | u8 ta[ETH_ALEN]; | |
ed1ea6f4 | 176 | u16 rx_pkt_type, rx_pkt_offset, rx_pkt_length, seq_num; |
8ed13033 | 177 | |
5e6e3a92 | 178 | local_rx_pd = (struct rxpd *) (skb->data); |
ed1ea6f4 AK |
179 | rx_pkt_type = le16_to_cpu(local_rx_pd->rx_pkt_type); |
180 | rx_pkt_offset = le16_to_cpu(local_rx_pd->rx_pkt_offset); | |
181 | rx_pkt_length = le16_to_cpu(local_rx_pd->rx_pkt_length); | |
182 | seq_num = le16_to_cpu(local_rx_pd->seq_num); | |
5e6e3a92 | 183 | |
ed1ea6f4 | 184 | rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_offset; |
5e6e3a92 | 185 | |
ed1ea6f4 AK |
186 | if ((rx_pkt_offset + rx_pkt_length) > (u16) skb->len) { |
187 | dev_err(adapter->dev, | |
188 | "wrong rx packet: len=%d, rx_pkt_offset=%d, rx_pkt_length=%d\n", | |
189 | skb->len, rx_pkt_offset, rx_pkt_length); | |
5e6e3a92 | 190 | priv->stats.rx_dropped++; |
4daffe35 AK |
191 | |
192 | if (adapter->if_ops.data_complete) | |
193 | adapter->if_ops.data_complete(adapter, skb); | |
194 | else | |
195 | dev_kfree_skb_any(skb); | |
196 | ||
5e6e3a92 BZ |
197 | return ret; |
198 | } | |
3b8ab88a | 199 | |
ed1ea6f4 | 200 | if (rx_pkt_type == PKT_TYPE_AMSDU) { |
3b8ab88a YAP |
201 | struct sk_buff_head list; |
202 | struct sk_buff *rx_skb; | |
203 | ||
204 | __skb_queue_head_init(&list); | |
205 | ||
ed1ea6f4 AK |
206 | skb_pull(skb, rx_pkt_offset); |
207 | skb_trim(skb, rx_pkt_length); | |
3b8ab88a YAP |
208 | |
209 | ieee80211_amsdu_to_8023s(skb, &list, priv->curr_addr, | |
c65a30f3 | 210 | priv->wdev->iftype, 0, false); |
3b8ab88a YAP |
211 | |
212 | while (!skb_queue_empty(&list)) { | |
213 | rx_skb = __skb_dequeue(&list); | |
f3b369e4 | 214 | ret = mwifiex_recv_packet(priv, rx_skb); |
3b8ab88a YAP |
215 | if (ret == -1) |
216 | dev_err(adapter->dev, "Rx of A-MSDU failed"); | |
217 | } | |
218 | return 0; | |
2dbaf751 | 219 | } else if (rx_pkt_type == PKT_TYPE_MGMT) { |
f3b369e4 | 220 | ret = mwifiex_process_mgmt_packet(priv, skb); |
2dbaf751 SP |
221 | if (ret) |
222 | dev_err(adapter->dev, "Rx of mgmt packet failed"); | |
223 | dev_kfree_skb_any(skb); | |
224 | return ret; | |
5e6e3a92 | 225 | } |
3b8ab88a | 226 | |
5e6e3a92 BZ |
227 | /* |
228 | * If the packet is not an unicast packet then send the packet | |
229 | * directly to os. Don't pass thru rx reordering | |
230 | */ | |
231 | if (!IS_11N_ENABLED(priv) || | |
232 | memcmp(priv->curr_addr, rx_pkt_hdr->eth803_hdr.h_dest, ETH_ALEN)) { | |
f3b369e4 | 233 | mwifiex_process_rx_packet(priv, skb); |
5e6e3a92 BZ |
234 | return ret; |
235 | } | |
236 | ||
237 | if (mwifiex_queuing_ra_based(priv)) { | |
238 | memcpy(ta, rx_pkt_hdr->eth803_hdr.h_source, ETH_ALEN); | |
239 | } else { | |
240 | if (rx_pkt_type != PKT_TYPE_BAR) | |
ed1ea6f4 | 241 | priv->rx_seq[local_rx_pd->priority] = seq_num; |
5e6e3a92 BZ |
242 | memcpy(ta, priv->curr_bss_params.bss_descriptor.mac_address, |
243 | ETH_ALEN); | |
244 | } | |
245 | ||
246 | /* Reorder and send to OS */ | |
ed1ea6f4 AK |
247 | ret = mwifiex_11n_rx_reorder_pkt(priv, seq_num, local_rx_pd->priority, |
248 | ta, (u8) rx_pkt_type, skb); | |
5e6e3a92 | 249 | |
4daffe35 AK |
250 | if (ret || (rx_pkt_type == PKT_TYPE_BAR)) { |
251 | if (adapter->if_ops.data_complete) | |
252 | adapter->if_ops.data_complete(adapter, skb); | |
253 | else | |
254 | dev_kfree_skb_any(skb); | |
255 | } | |
8ed13033 YAP |
256 | |
257 | if (ret) | |
258 | priv->stats.rx_dropped++; | |
5e6e3a92 BZ |
259 | |
260 | return ret; | |
261 | } |