1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "decl.h"
21#include "ioctl.h"
22#include "main.h"
23#include "wmm.h"
24#include "11n_aggr.h"
25#include "11n_rxreorder.h"
26
27static void mwifiex_uap_queue_bridged_pkt(struct mwifiex_private *priv,
28 struct sk_buff *skb)
29{
30 struct mwifiex_adapter *adapter = priv->adapter;
31 struct uap_rxpd *uap_rx_pd;
32 struct rx_packet_hdr *rx_pkt_hdr;
33 struct sk_buff *new_skb;
34 struct mwifiex_txinfo *tx_info;
35 int hdr_chop;
36 struct timeval tv;
37 u8 rfc1042_eth_hdr[ETH_ALEN] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
38
39 uap_rx_pd = (struct uap_rxpd *)(skb->data);
40 rx_pkt_hdr = (void *)uap_rx_pd + le16_to_cpu(uap_rx_pd->rx_pkt_offset);
41
42 if ((atomic_read(&adapter->pending_bridged_pkts) >=
43 MWIFIEX_BRIDGED_PKTS_THRESHOLD)) {
44 dev_err(priv->adapter->dev,
45 "Tx: Bridge packet limit reached. Drop packet!\n");
46 kfree_skb(skb);
47 return;
48 }
49
50 if (!memcmp(&rx_pkt_hdr->rfc1042_hdr,
51 rfc1042_eth_hdr, sizeof(rfc1042_eth_hdr)))
52
53
54
55 hdr_chop = (u8 *)eth_hdr - (u8 *)uap_rx_pd;
56 else
57
58 hdr_chop = (u8 *)&rx_pkt_hdr->eth803_hdr - (u8 *)uap_rx_pd;
59
60
61
62
63
64 skb_pull(skb, hdr_chop);
65
66 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
67 dev_dbg(priv->adapter->dev,
68 "data: Tx: insufficient skb headroom %d\n",
69 skb_headroom(skb));
70
71 new_skb =
72 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
73 if (unlikely(!new_skb)) {
74 dev_err(priv->adapter->dev,
75 "Tx: cannot allocate new_skb\n");
76 kfree_skb(skb);
77 priv->stats.tx_dropped++;
78 return;
79 }
80
81 kfree_skb(skb);
82 skb = new_skb;
83 dev_dbg(priv->adapter->dev, "info: new skb headroom %d\n",
84 skb_headroom(skb));
85 }
86
87 tx_info = MWIFIEX_SKB_TXCB(skb);
88 tx_info->bss_num = priv->bss_num;
89 tx_info->bss_type = priv->bss_type;
90 tx_info->flags |= MWIFIEX_BUF_FLAG_BRIDGED_PKT;
91
92 do_gettimeofday(&tv);
93 skb->tstamp = timeval_to_ktime(tv);
94 mwifiex_wmm_add_buf_txqueue(priv, skb);
95 atomic_inc(&adapter->tx_pending);
96 atomic_inc(&adapter->pending_bridged_pkts);
97
98 if ((atomic_read(&adapter->tx_pending) >= MAX_TX_PENDING)) {
99 mwifiex_set_trans_start(priv->netdev);
100 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
101 }
102 return;
103}
104
105
106
107
108
109
110
111
112
113
114
115
116int mwifiex_handle_uap_rx_forward(struct mwifiex_private *priv,
117 struct sk_buff *skb)
118{
119 struct mwifiex_adapter *adapter = priv->adapter;
120 struct uap_rxpd *uap_rx_pd;
121 struct rx_packet_hdr *rx_pkt_hdr;
122 u8 ra[ETH_ALEN];
123 struct sk_buff *skb_uap;
124
125 uap_rx_pd = (struct uap_rxpd *)(skb->data);
126 rx_pkt_hdr = (void *)uap_rx_pd + le16_to_cpu(uap_rx_pd->rx_pkt_offset);
127
128
129 if (!priv->media_connected) {
130 dev_err(adapter->dev, "drop packet in disconnected state.\n");
131 dev_kfree_skb_any(skb);
132 return 0;
133 }
134
135 memcpy(ra, rx_pkt_hdr->eth803_hdr.h_dest, ETH_ALEN);
136
137 if (is_multicast_ether_addr(ra)) {
138 skb_uap = skb_copy(skb, GFP_ATOMIC);
139 mwifiex_uap_queue_bridged_pkt(priv, skb_uap);
140 } else {
141 if (mwifiex_get_sta_entry(priv, ra)) {
142
143 mwifiex_uap_queue_bridged_pkt(priv, skb);
144 return 0;
145 }
146 }
147
148
149 return mwifiex_process_rx_packet(priv, skb);
150}
151
152
153
154
155
156
157
158
159
160
161
162int mwifiex_process_uap_rx_packet(struct mwifiex_private *priv,
163 struct sk_buff *skb)
164{
165 struct mwifiex_adapter *adapter = priv->adapter;
166 int ret;
167 struct uap_rxpd *uap_rx_pd;
168 struct rx_packet_hdr *rx_pkt_hdr;
169 u16 rx_pkt_type;
170 u8 ta[ETH_ALEN], pkt_type;
171 struct mwifiex_sta_node *node;
172
173 uap_rx_pd = (struct uap_rxpd *)(skb->data);
174 rx_pkt_type = le16_to_cpu(uap_rx_pd->rx_pkt_type);
175 rx_pkt_hdr = (void *)uap_rx_pd + le16_to_cpu(uap_rx_pd->rx_pkt_offset);
176
177 if ((le16_to_cpu(uap_rx_pd->rx_pkt_offset) +
178 le16_to_cpu(uap_rx_pd->rx_pkt_length)) > (u16) skb->len) {
179 dev_err(adapter->dev,
180 "wrong rx packet: len=%d, offset=%d, length=%d\n",
181 skb->len, le16_to_cpu(uap_rx_pd->rx_pkt_offset),
182 le16_to_cpu(uap_rx_pd->rx_pkt_length));
183 priv->stats.rx_dropped++;
184
185 if (adapter->if_ops.data_complete)
186 adapter->if_ops.data_complete(adapter, skb);
187 else
188 dev_kfree_skb_any(skb);
189
190 return 0;
191 }
192
193 if (le16_to_cpu(uap_rx_pd->rx_pkt_type) == PKT_TYPE_AMSDU) {
194 struct sk_buff_head list;
195 struct sk_buff *rx_skb;
196
197 __skb_queue_head_init(&list);
198 skb_pull(skb, le16_to_cpu(uap_rx_pd->rx_pkt_offset));
199 skb_trim(skb, le16_to_cpu(uap_rx_pd->rx_pkt_length));
200
201 ieee80211_amsdu_to_8023s(skb, &list, priv->curr_addr,
202 priv->wdev->iftype, 0, false);
203
204 while (!skb_queue_empty(&list)) {
205 rx_skb = __skb_dequeue(&list);
206 ret = mwifiex_recv_packet(priv, rx_skb);
207 if (ret)
208 dev_err(adapter->dev,
209 "AP:Rx A-MSDU failed");
210 }
211
212 return 0;
213 } else if (rx_pkt_type == PKT_TYPE_MGMT) {
214 ret = mwifiex_process_mgmt_packet(priv, skb);
215 if (ret)
216 dev_err(adapter->dev, "Rx of mgmt packet failed");
217 dev_kfree_skb_any(skb);
218 return ret;
219 }
220
221 memcpy(ta, rx_pkt_hdr->eth803_hdr.h_source, ETH_ALEN);
222
223 if (rx_pkt_type != PKT_TYPE_BAR && uap_rx_pd->priority < MAX_NUM_TID) {
224 node = mwifiex_get_sta_entry(priv, ta);
225 if (node)
226 node->rx_seq[uap_rx_pd->priority] =
227 le16_to_cpu(uap_rx_pd->seq_num);
228 }
229
230 if (!priv->ap_11n_enabled ||
231 (!mwifiex_11n_get_rx_reorder_tbl(priv, uap_rx_pd->priority, ta) &&
232 (le16_to_cpu(uap_rx_pd->rx_pkt_type) != PKT_TYPE_AMSDU))) {
233 ret = mwifiex_handle_uap_rx_forward(priv, skb);
234 return ret;
235 }
236
237
238 pkt_type = (u8)le16_to_cpu(uap_rx_pd->rx_pkt_type);
239 ret = mwifiex_11n_rx_reorder_pkt(priv, le16_to_cpu(uap_rx_pd->seq_num),
240 uap_rx_pd->priority, ta, pkt_type,
241 skb);
242
243 if (ret || (rx_pkt_type == PKT_TYPE_BAR)) {
244 if (adapter->if_ops.data_complete)
245 adapter->if_ops.data_complete(adapter, skb);
246 else
247 dev_kfree_skb_any(skb);
248 }
249
250 if (ret)
251 priv->stats.rx_dropped++;
252
253 return ret;
254}
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273void *mwifiex_process_uap_txpd(struct mwifiex_private *priv,
274 struct sk_buff *skb)
275{
276 struct mwifiex_adapter *adapter = priv->adapter;
277 struct uap_txpd *txpd;
278 struct mwifiex_txinfo *tx_info = MWIFIEX_SKB_TXCB(skb);
279 int pad, len;
280 u16 pkt_type;
281
282 if (!skb->len) {
283 dev_err(adapter->dev, "Tx: bad packet length: %d\n", skb->len);
284 tx_info->status_code = -1;
285 return skb->data;
286 }
287
288 pkt_type = mwifiex_is_skb_mgmt_frame(skb) ? PKT_TYPE_MGMT : 0;
289
290
291 pad = (4 - (((void *)skb->data - NULL) & 0x3)) % 4;
292
293 len = sizeof(*txpd) + pad;
294
295 BUG_ON(skb_headroom(skb) < len + INTF_HEADER_LEN);
296
297 skb_push(skb, len);
298
299 txpd = (struct uap_txpd *)skb->data;
300 memset(txpd, 0, sizeof(*txpd));
301 txpd->bss_num = priv->bss_num;
302 txpd->bss_type = priv->bss_type;
303 txpd->tx_pkt_length = cpu_to_le16((u16)(skb->len - len));
304
305 txpd->priority = (u8)skb->priority;
306 txpd->pkt_delay_2ms = mwifiex_wmm_compute_drv_pkt_delay(priv, skb);
307
308 if (txpd->priority < ARRAY_SIZE(priv->wmm.user_pri_pkt_tx_ctrl))
309
310
311
312
313 txpd->tx_control =
314 cpu_to_le32(priv->wmm.user_pri_pkt_tx_ctrl[txpd->priority]);
315
316
317 if (pkt_type == PKT_TYPE_MGMT) {
318
319 txpd->tx_pkt_type = cpu_to_le16(pkt_type);
320 len += MWIFIEX_MGMT_FRAME_HEADER_SIZE;
321 }
322
323 txpd->tx_pkt_offset = cpu_to_le16(len);
324
325
326 skb_push(skb, INTF_HEADER_LEN);
327
328 if (!txpd->tx_control)
329
330 txpd->tx_control = cpu_to_le32(priv->pkt_tx_ctrl);
331
332 return skb->data;
333}
334