2 * This file contains the handling of RX in wlan driver.
4 #include <linux/etherdevice.h>
5 #include <linux/slab.h>
6 #include <linux/types.h>
18 } __attribute__ ((packed
));
26 } __attribute__ ((packed
));
29 struct eth803hdr eth803_hdr
;
30 struct rfc1042hdr rfc1042_hdr
;
31 } __attribute__ ((packed
));
33 struct rx80211packethdr
{
36 } __attribute__ ((packed
));
38 static int process_rxed_802_11_packet(struct lbs_private
*priv
,
42 * @brief This function computes the avgSNR .
44 * @param priv A pointer to struct lbs_private structure
47 static u8
lbs_getavgsnr(struct lbs_private
*priv
)
51 if (priv
->numSNRNF
== 0)
53 for (i
= 0; i
< priv
->numSNRNF
; i
++)
54 temp
+= priv
->rawSNR
[i
];
55 return (u8
) (temp
/ priv
->numSNRNF
);
60 * @brief This function computes the AvgNF
62 * @param priv A pointer to struct lbs_private structure
65 static u8
lbs_getavgnf(struct lbs_private
*priv
)
69 if (priv
->numSNRNF
== 0)
71 for (i
= 0; i
< priv
->numSNRNF
; i
++)
72 temp
+= priv
->rawNF
[i
];
73 return (u8
) (temp
/ priv
->numSNRNF
);
78 * @brief This function save the raw SNR/NF to our internel buffer
80 * @param priv A pointer to struct lbs_private structure
81 * @param prxpd A pointer to rxpd structure of received packet
84 static void lbs_save_rawSNRNF(struct lbs_private
*priv
, struct rxpd
*p_rx_pd
)
86 if (priv
->numSNRNF
< DEFAULT_DATA_AVG_FACTOR
)
88 priv
->rawSNR
[priv
->nextSNRNF
] = p_rx_pd
->snr
;
89 priv
->rawNF
[priv
->nextSNRNF
] = p_rx_pd
->nf
;
91 if (priv
->nextSNRNF
>= DEFAULT_DATA_AVG_FACTOR
)
97 * @brief This function computes the RSSI in received packet.
99 * @param priv A pointer to struct lbs_private structure
100 * @param prxpd A pointer to rxpd structure of received packet
103 static void lbs_compute_rssi(struct lbs_private
*priv
, struct rxpd
*p_rx_pd
)
106 lbs_deb_enter(LBS_DEB_RX
);
108 lbs_deb_rx("rxpd: SNR %d, NF %d\n", p_rx_pd
->snr
, p_rx_pd
->nf
);
109 lbs_deb_rx("before computing SNR: SNR-avg = %d, NF-avg = %d\n",
110 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
,
111 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
);
113 priv
->SNR
[TYPE_RXPD
][TYPE_NOAVG
] = p_rx_pd
->snr
;
114 priv
->NF
[TYPE_RXPD
][TYPE_NOAVG
] = p_rx_pd
->nf
;
115 lbs_save_rawSNRNF(priv
, p_rx_pd
);
117 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] = lbs_getavgsnr(priv
) * AVG_SCALE
;
118 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] = lbs_getavgnf(priv
) * AVG_SCALE
;
119 lbs_deb_rx("after computing SNR: SNR-avg = %d, NF-avg = %d\n",
120 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
,
121 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
);
123 priv
->RSSI
[TYPE_RXPD
][TYPE_NOAVG
] =
124 CAL_RSSI(priv
->SNR
[TYPE_RXPD
][TYPE_NOAVG
],
125 priv
->NF
[TYPE_RXPD
][TYPE_NOAVG
]);
127 priv
->RSSI
[TYPE_RXPD
][TYPE_AVG
] =
128 CAL_RSSI(priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
,
129 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
);
131 lbs_deb_leave(LBS_DEB_RX
);
135 * @brief This function processes received packet and forwards it
136 * to kernel/upper layer
138 * @param priv A pointer to struct lbs_private
139 * @param skb A pointer to skb which includes the received packet
142 int lbs_process_rxed_packet(struct lbs_private
*priv
, struct sk_buff
*skb
)
145 struct net_device
*dev
= priv
->dev
;
146 struct rxpackethdr
*p_rx_pkt
;
147 struct rxpd
*p_rx_pd
;
149 struct ethhdr
*p_ethhdr
;
150 const u8 rfc1042_eth_hdr
[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
152 lbs_deb_enter(LBS_DEB_RX
);
156 skb
->ip_summed
= CHECKSUM_NONE
;
158 if (priv
->monitormode
)
159 return process_rxed_802_11_packet(priv
, skb
);
161 p_rx_pd
= (struct rxpd
*) skb
->data
;
162 p_rx_pkt
= (struct rxpackethdr
*) ((u8
*)p_rx_pd
+
163 le32_to_cpu(p_rx_pd
->pkt_ptr
));
165 dev
= lbs_mesh_set_dev(priv
, dev
, p_rx_pd
);
167 lbs_deb_hex(LBS_DEB_RX
, "RX Data: Before chop rxpd", skb
->data
,
168 min_t(unsigned int, skb
->len
, 100));
170 if (skb
->len
< (ETH_HLEN
+ 8 + sizeof(struct rxpd
))) {
171 lbs_deb_rx("rx err: frame received with bad length\n");
172 dev
->stats
.rx_length_errors
++;
178 lbs_deb_rx("rx data: skb->len - pkt_ptr = %d-%zd = %zd\n",
179 skb
->len
, (size_t)le32_to_cpu(p_rx_pd
->pkt_ptr
),
180 skb
->len
- (size_t)le32_to_cpu(p_rx_pd
->pkt_ptr
));
182 lbs_deb_hex(LBS_DEB_RX
, "RX Data: Dest", p_rx_pkt
->eth803_hdr
.dest_addr
,
183 sizeof(p_rx_pkt
->eth803_hdr
.dest_addr
));
184 lbs_deb_hex(LBS_DEB_RX
, "RX Data: Src", p_rx_pkt
->eth803_hdr
.src_addr
,
185 sizeof(p_rx_pkt
->eth803_hdr
.src_addr
));
187 if (memcmp(&p_rx_pkt
->rfc1042_hdr
,
188 rfc1042_eth_hdr
, sizeof(rfc1042_eth_hdr
)) == 0) {
190 * Replace the 803 header and rfc1042 header (llc/snap) with an
191 * EthernetII header, keep the src/dst and snap_type (ethertype)
193 * The firmware only passes up SNAP frames converting
194 * all RX Data from 802.11 to 802.2/LLC/SNAP frames.
196 * To create the Ethernet II, just move the src, dst address right
197 * before the snap_type.
199 p_ethhdr
= (struct ethhdr
*)
200 ((u8
*) & p_rx_pkt
->eth803_hdr
201 + sizeof(p_rx_pkt
->eth803_hdr
) + sizeof(p_rx_pkt
->rfc1042_hdr
)
202 - sizeof(p_rx_pkt
->eth803_hdr
.dest_addr
)
203 - sizeof(p_rx_pkt
->eth803_hdr
.src_addr
)
204 - sizeof(p_rx_pkt
->rfc1042_hdr
.snap_type
));
206 memcpy(p_ethhdr
->h_source
, p_rx_pkt
->eth803_hdr
.src_addr
,
207 sizeof(p_ethhdr
->h_source
));
208 memcpy(p_ethhdr
->h_dest
, p_rx_pkt
->eth803_hdr
.dest_addr
,
209 sizeof(p_ethhdr
->h_dest
));
211 /* Chop off the rxpd + the excess memory from the 802.2/llc/snap header
214 hdrchop
= (u8
*)p_ethhdr
- (u8
*)p_rx_pd
;
216 lbs_deb_hex(LBS_DEB_RX
, "RX Data: LLC/SNAP",
217 (u8
*) & p_rx_pkt
->rfc1042_hdr
,
218 sizeof(p_rx_pkt
->rfc1042_hdr
));
220 /* Chop off the rxpd */
221 hdrchop
= (u8
*)&p_rx_pkt
->eth803_hdr
- (u8
*)p_rx_pd
;
224 /* Chop off the leading header bytes so the skb points to the start of
225 * either the reconstructed EthII frame or the 802.2/llc/snap frame
227 skb_pull(skb
, hdrchop
);
229 /* Take the data rate from the rxpd structure
230 * only if the rate is auto
232 if (priv
->enablehwauto
)
233 priv
->cur_rate
= lbs_fw_index_to_data_rate(p_rx_pd
->rx_rate
);
235 lbs_compute_rssi(priv
, p_rx_pd
);
237 lbs_deb_rx("rx data: size of actual packet %d\n", skb
->len
);
238 dev
->stats
.rx_bytes
+= skb
->len
;
239 dev
->stats
.rx_packets
++;
241 skb
->protocol
= eth_type_trans(skb
, dev
);
249 lbs_deb_leave_args(LBS_DEB_RX
, "ret %d", ret
);
252 EXPORT_SYMBOL_GPL(lbs_process_rxed_packet
);
255 * @brief This function converts Tx/Rx rates from the Marvell WLAN format
256 * (see Table 2 in Section 3.1) to IEEE80211_RADIOTAP_RATE units (500 Kb/s)
258 * @param rate Input rate
259 * @return Output Rate (0 if invalid)
261 static u8
convert_mv_rate_to_radiotap(u8 rate
)
268 case 2: /* 5.5 Mbps */
270 case 3: /* 11 Mbps */
272 /* case 4: reserved */
277 case 7: /* 12 Mbps */
279 case 8: /* 18 Mbps */
281 case 9: /* 24 Mbps */
283 case 10: /* 36 Mbps */
285 case 11: /* 48 Mbps */
287 case 12: /* 54 Mbps */
290 lbs_pr_alert("Invalid Marvell WLAN rate %i\n", rate
);
295 * @brief This function processes a received 802.11 packet and forwards it
296 * to kernel/upper layer
298 * @param priv A pointer to struct lbs_private
299 * @param skb A pointer to skb which includes the received packet
302 static int process_rxed_802_11_packet(struct lbs_private
*priv
,
306 struct net_device
*dev
= priv
->dev
;
307 struct rx80211packethdr
*p_rx_pkt
;
309 struct rx_radiotap_hdr radiotap_hdr
;
310 struct rx_radiotap_hdr
*pradiotap_hdr
;
312 lbs_deb_enter(LBS_DEB_RX
);
314 p_rx_pkt
= (struct rx80211packethdr
*) skb
->data
;
315 prxpd
= &p_rx_pkt
->rx_pd
;
317 // lbs_deb_hex(LBS_DEB_RX, "RX Data: Before chop rxpd", skb->data, min(skb->len, 100));
319 if (skb
->len
< (ETH_HLEN
+ 8 + sizeof(struct rxpd
))) {
320 lbs_deb_rx("rx err: frame received with bad length\n");
321 dev
->stats
.rx_length_errors
++;
327 lbs_deb_rx("rx data: skb->len-sizeof(RxPd) = %d-%zd = %zd\n",
328 skb
->len
, sizeof(struct rxpd
), skb
->len
- sizeof(struct rxpd
));
330 /* create the exported radio header */
332 /* radiotap header */
333 radiotap_hdr
.hdr
.it_version
= 0;
334 /* XXX must check this value for pad */
335 radiotap_hdr
.hdr
.it_pad
= 0;
336 radiotap_hdr
.hdr
.it_len
= cpu_to_le16 (sizeof(struct rx_radiotap_hdr
));
337 radiotap_hdr
.hdr
.it_present
= cpu_to_le32 (RX_RADIOTAP_PRESENT
);
338 radiotap_hdr
.rate
= convert_mv_rate_to_radiotap(prxpd
->rx_rate
);
339 /* XXX must check no carryout */
340 radiotap_hdr
.antsignal
= prxpd
->snr
+ prxpd
->nf
;
343 skb_pull(skb
, sizeof(struct rxpd
));
345 /* add space for the new radio header */
346 if ((skb_headroom(skb
) < sizeof(struct rx_radiotap_hdr
)) &&
347 pskb_expand_head(skb
, sizeof(struct rx_radiotap_hdr
), 0, GFP_ATOMIC
)) {
348 lbs_pr_alert("%s: couldn't pskb_expand_head\n", __func__
);
354 pradiotap_hdr
= (void *)skb_push(skb
, sizeof(struct rx_radiotap_hdr
));
355 memcpy(pradiotap_hdr
, &radiotap_hdr
, sizeof(struct rx_radiotap_hdr
));
357 /* Take the data rate from the rxpd structure
358 * only if the rate is auto
360 if (priv
->enablehwauto
)
361 priv
->cur_rate
= lbs_fw_index_to_data_rate(prxpd
->rx_rate
);
363 lbs_compute_rssi(priv
, prxpd
);
365 lbs_deb_rx("rx data: size of actual packet %d\n", skb
->len
);
366 dev
->stats
.rx_bytes
+= skb
->len
;
367 dev
->stats
.rx_packets
++;
369 skb
->protocol
= eth_type_trans(skb
, priv
->rtap_net_dev
);
375 lbs_deb_leave_args(LBS_DEB_RX
, "ret %d", ret
);