Commit | Line | Data |
---|---|---|
5e6e3a92 BZ |
1 | /* |
2 | * Marvell Wireless LAN device driver: station RX data handling | |
3 | * | |
65da33f5 | 4 | * Copyright (C) 2011-2014, Marvell International Ltd. |
5e6e3a92 BZ |
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; | |
f8eb5ee5 | 39 | struct ethhdr *eth; |
587b36d3 AP |
40 | struct ipv6hdr *ipv6; |
41 | struct icmp6hdr *icmpv6; | |
42 | ||
f8eb5ee5 BZ |
43 | eth = (struct ethhdr *)skb->data; |
44 | switch (ntohs(eth->h_proto)) { | |
587b36d3 AP |
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; | |
f8eb5ee5 | 90 | struct ethhdr *eth; |
5f2caaf3 AP |
91 | u16 rx_pkt_off, rx_pkt_len; |
92 | u8 *offset; | |
5e6e3a92 BZ |
93 | |
94 | local_rx_pd = (struct rxpd *) (skb->data); | |
95 | ||
5f2caaf3 AP |
96 | rx_pkt_off = le16_to_cpu(local_rx_pd->rx_pkt_offset); |
97 | rx_pkt_len = le16_to_cpu(local_rx_pd->rx_pkt_length); | |
98 | rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_off; | |
5e6e3a92 | 99 | |
c613d16f AK |
100 | if ((!memcmp(&rx_pkt_hdr->rfc1042_hdr, bridge_tunnel_header, |
101 | sizeof(bridge_tunnel_header))) || | |
102 | (!memcmp(&rx_pkt_hdr->rfc1042_hdr, rfc1042_header, | |
103 | sizeof(rfc1042_header)) && | |
104 | ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_AARP && | |
105 | ntohs(rx_pkt_hdr->rfc1042_hdr.snap_type) != ETH_P_IPX)) { | |
5e6e3a92 BZ |
106 | /* |
107 | * Replace the 803 header and rfc1042 header (llc/snap) with an | |
108 | * EthernetII header, keep the src/dst and snap_type | |
109 | * (ethertype). | |
110 | * The firmware only passes up SNAP frames converting | |
111 | * all RX Data from 802.11 to 802.2/LLC/SNAP frames. | |
112 | * To create the Ethernet II, just move the src, dst address | |
113 | * right before the snap_type. | |
114 | */ | |
f8eb5ee5 | 115 | eth = (struct ethhdr *) |
5e6e3a92 BZ |
116 | ((u8 *) &rx_pkt_hdr->eth803_hdr |
117 | + sizeof(rx_pkt_hdr->eth803_hdr) + | |
118 | sizeof(rx_pkt_hdr->rfc1042_hdr) | |
119 | - sizeof(rx_pkt_hdr->eth803_hdr.h_dest) | |
120 | - sizeof(rx_pkt_hdr->eth803_hdr.h_source) | |
121 | - sizeof(rx_pkt_hdr->rfc1042_hdr.snap_type)); | |
122 | ||
f8eb5ee5 BZ |
123 | memcpy(eth->h_source, rx_pkt_hdr->eth803_hdr.h_source, |
124 | sizeof(eth->h_source)); | |
125 | memcpy(eth->h_dest, rx_pkt_hdr->eth803_hdr.h_dest, | |
126 | sizeof(eth->h_dest)); | |
5e6e3a92 BZ |
127 | |
128 | /* Chop off the rxpd + the excess memory from the 802.2/llc/snap | |
129 | header that was removed. */ | |
f8eb5ee5 | 130 | hdr_chop = (u8 *) eth - (u8 *) local_rx_pd; |
5e6e3a92 BZ |
131 | } else { |
132 | /* Chop off the rxpd */ | |
133 | hdr_chop = (u8 *) &rx_pkt_hdr->eth803_hdr - | |
134 | (u8 *) local_rx_pd; | |
135 | } | |
136 | ||
137 | /* Chop off the leading header bytes so the it points to the start of | |
138 | either the reconstructed EthII frame or the 802.2/llc/snap frame */ | |
139 | skb_pull(skb, hdr_chop); | |
140 | ||
587b36d3 AP |
141 | if (priv->hs2_enabled && |
142 | mwifiex_discard_gratuitous_arp(priv, skb)) { | |
143 | dev_dbg(priv->adapter->dev, "Bypassed Gratuitous ARP\n"); | |
144 | dev_kfree_skb_any(skb); | |
145 | return 0; | |
146 | } | |
147 | ||
5f2caaf3 AP |
148 | if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && |
149 | ntohs(rx_pkt_hdr->eth803_hdr.h_proto) == ETH_P_TDLS) { | |
150 | offset = (u8 *)local_rx_pd + rx_pkt_off; | |
151 | mwifiex_process_tdls_action_frame(priv, offset, rx_pkt_len); | |
152 | } | |
153 | ||
5e6e3a92 BZ |
154 | priv->rxpd_rate = local_rx_pd->rx_rate; |
155 | ||
156 | priv->rxpd_htinfo = local_rx_pd->ht_info; | |
157 | ||
f3b369e4 | 158 | ret = mwifiex_recv_packet(priv, skb); |
5e6e3a92 | 159 | if (ret == -1) |
f3b369e4 | 160 | dev_err(priv->adapter->dev, "recv packet failed\n"); |
5e6e3a92 BZ |
161 | |
162 | return ret; | |
163 | } | |
164 | ||
165 | /* | |
166 | * This function processes the received buffer. | |
167 | * | |
168 | * The function looks into the RxPD and performs sanity tests on the | |
169 | * received buffer to ensure its a valid packet, before processing it | |
170 | * further. If the packet is determined to be aggregated, it is | |
171 | * de-aggregated accordingly. Non-unicast packets are sent directly to | |
172 | * the kernel/upper layers. Unicast packets are handed over to the | |
173 | * Rx reordering routine if 11n is enabled. | |
174 | * | |
175 | * The completion callback is called after processing in complete. | |
176 | */ | |
f3b369e4 | 177 | int mwifiex_process_sta_rx_packet(struct mwifiex_private *priv, |
5e6e3a92 BZ |
178 | struct sk_buff *skb) |
179 | { | |
f3b369e4 | 180 | struct mwifiex_adapter *adapter = priv->adapter; |
5e6e3a92 BZ |
181 | int ret = 0; |
182 | struct rxpd *local_rx_pd; | |
5e6e3a92 BZ |
183 | struct rx_packet_hdr *rx_pkt_hdr; |
184 | u8 ta[ETH_ALEN]; | |
ed1ea6f4 | 185 | u16 rx_pkt_type, rx_pkt_offset, rx_pkt_length, seq_num; |
09869495 | 186 | struct mwifiex_sta_node *sta_ptr; |
8ed13033 | 187 | |
5e6e3a92 | 188 | local_rx_pd = (struct rxpd *) (skb->data); |
ed1ea6f4 AK |
189 | rx_pkt_type = le16_to_cpu(local_rx_pd->rx_pkt_type); |
190 | rx_pkt_offset = le16_to_cpu(local_rx_pd->rx_pkt_offset); | |
191 | rx_pkt_length = le16_to_cpu(local_rx_pd->rx_pkt_length); | |
192 | seq_num = le16_to_cpu(local_rx_pd->seq_num); | |
5e6e3a92 | 193 | |
ed1ea6f4 | 194 | rx_pkt_hdr = (void *)local_rx_pd + rx_pkt_offset; |
5e6e3a92 | 195 | |
ed1ea6f4 AK |
196 | if ((rx_pkt_offset + rx_pkt_length) > (u16) skb->len) { |
197 | dev_err(adapter->dev, | |
198 | "wrong rx packet: len=%d, rx_pkt_offset=%d, rx_pkt_length=%d\n", | |
199 | skb->len, rx_pkt_offset, rx_pkt_length); | |
5e6e3a92 | 200 | priv->stats.rx_dropped++; |
ca8d6dfc | 201 | dev_kfree_skb_any(skb); |
5e6e3a92 BZ |
202 | return ret; |
203 | } | |
3b8ab88a | 204 | |
4c9f9fb2 | 205 | if (rx_pkt_type == PKT_TYPE_MGMT) { |
f3b369e4 | 206 | ret = mwifiex_process_mgmt_packet(priv, skb); |
2dbaf751 SP |
207 | if (ret) |
208 | dev_err(adapter->dev, "Rx of mgmt packet failed"); | |
209 | dev_kfree_skb_any(skb); | |
210 | return ret; | |
5e6e3a92 | 211 | } |
3b8ab88a | 212 | |
5e6e3a92 BZ |
213 | /* |
214 | * If the packet is not an unicast packet then send the packet | |
215 | * directly to os. Don't pass thru rx reordering | |
216 | */ | |
09869495 AP |
217 | if ((!IS_11N_ENABLED(priv) && |
218 | !(ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && | |
219 | !(local_rx_pd->flags & MWIFIEX_RXPD_FLAGS_TDLS_PACKET))) || | |
fcad7668 | 220 | !ether_addr_equal_unaligned(priv->curr_addr, rx_pkt_hdr->eth803_hdr.h_dest)) { |
f3b369e4 | 221 | mwifiex_process_rx_packet(priv, skb); |
5e6e3a92 BZ |
222 | return ret; |
223 | } | |
224 | ||
09869495 AP |
225 | if (mwifiex_queuing_ra_based(priv) || |
226 | (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) && | |
227 | local_rx_pd->flags & MWIFIEX_RXPD_FLAGS_TDLS_PACKET)) { | |
5e6e3a92 | 228 | memcpy(ta, rx_pkt_hdr->eth803_hdr.h_source, ETH_ALEN); |
09869495 AP |
229 | if (local_rx_pd->flags & MWIFIEX_RXPD_FLAGS_TDLS_PACKET && |
230 | local_rx_pd->priority < MAX_NUM_TID) { | |
231 | sta_ptr = mwifiex_get_sta_entry(priv, ta); | |
232 | if (sta_ptr) | |
233 | sta_ptr->rx_seq[local_rx_pd->priority] = | |
234 | le16_to_cpu(local_rx_pd->seq_num); | |
235 | } | |
5e6e3a92 BZ |
236 | } else { |
237 | if (rx_pkt_type != PKT_TYPE_BAR) | |
ed1ea6f4 | 238 | priv->rx_seq[local_rx_pd->priority] = seq_num; |
5e6e3a92 BZ |
239 | memcpy(ta, priv->curr_bss_params.bss_descriptor.mac_address, |
240 | ETH_ALEN); | |
241 | } | |
242 | ||
243 | /* Reorder and send to OS */ | |
ed1ea6f4 AK |
244 | ret = mwifiex_11n_rx_reorder_pkt(priv, seq_num, local_rx_pd->priority, |
245 | ta, (u8) rx_pkt_type, skb); | |
5e6e3a92 | 246 | |
ca8d6dfc UR |
247 | if (ret || (rx_pkt_type == PKT_TYPE_BAR)) |
248 | dev_kfree_skb_any(skb); | |
8ed13033 YAP |
249 | |
250 | if (ret) | |
251 | priv->stats.rx_dropped++; | |
5e6e3a92 BZ |
252 | |
253 | return ret; | |
254 | } |