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
)
96 * @brief This function computes the RSSI in received packet.
98 * @param priv A pointer to struct lbs_private structure
99 * @param prxpd A pointer to rxpd structure of received packet
102 static void lbs_compute_rssi(struct lbs_private
*priv
, struct rxpd
*p_rx_pd
)
105 lbs_deb_enter(LBS_DEB_RX
);
107 lbs_deb_rx("rxpd: SNR %d, NF %d\n", p_rx_pd
->snr
, p_rx_pd
->nf
);
108 lbs_deb_rx("before computing SNR: SNR-avg = %d, NF-avg = %d\n",
109 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
,
110 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
);
112 priv
->SNR
[TYPE_RXPD
][TYPE_NOAVG
] = p_rx_pd
->snr
;
113 priv
->NF
[TYPE_RXPD
][TYPE_NOAVG
] = p_rx_pd
->nf
;
114 lbs_save_rawSNRNF(priv
, p_rx_pd
);
116 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] = lbs_getavgsnr(priv
) * AVG_SCALE
;
117 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] = lbs_getavgnf(priv
) * AVG_SCALE
;
118 lbs_deb_rx("after computing SNR: SNR-avg = %d, NF-avg = %d\n",
119 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
,
120 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
);
122 priv
->RSSI
[TYPE_RXPD
][TYPE_NOAVG
] =
123 CAL_RSSI(priv
->SNR
[TYPE_RXPD
][TYPE_NOAVG
],
124 priv
->NF
[TYPE_RXPD
][TYPE_NOAVG
]);
126 priv
->RSSI
[TYPE_RXPD
][TYPE_AVG
] =
127 CAL_RSSI(priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
,
128 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] / AVG_SCALE
);
130 lbs_deb_leave(LBS_DEB_RX
);
134 * @brief This function processes received packet and forwards it
135 * to kernel/upper layer
137 * @param priv A pointer to struct lbs_private
138 * @param skb A pointer to skb which includes the received packet
141 int lbs_process_rxed_packet(struct lbs_private
*priv
, struct sk_buff
*skb
)
144 struct net_device
*dev
= priv
->dev
;
145 struct rxpackethdr
*p_rx_pkt
;
146 struct rxpd
*p_rx_pd
;
148 struct ethhdr
*p_ethhdr
;
149 const u8 rfc1042_eth_hdr
[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
151 lbs_deb_enter(LBS_DEB_RX
);
155 skb
->ip_summed
= CHECKSUM_NONE
;
157 if (priv
->monitormode
)
158 return process_rxed_802_11_packet(priv
, skb
);
160 p_rx_pd
= (struct rxpd
*) skb
->data
;
161 p_rx_pkt
= (struct rxpackethdr
*) ((u8
*)p_rx_pd
+
162 le32_to_cpu(p_rx_pd
->pkt_ptr
));
164 dev
= lbs_mesh_set_dev(priv
, dev
, p_rx_pd
);
166 lbs_deb_hex(LBS_DEB_RX
, "RX Data: Before chop rxpd", skb
->data
,
167 min_t(unsigned int, skb
->len
, 100));
169 if (skb
->len
< (ETH_HLEN
+ 8 + sizeof(struct rxpd
))) {
170 lbs_deb_rx("rx err: frame received with bad length\n");
171 dev
->stats
.rx_length_errors
++;
177 lbs_deb_rx("rx data: skb->len - pkt_ptr = %d-%zd = %zd\n",
178 skb
->len
, (size_t)le32_to_cpu(p_rx_pd
->pkt_ptr
),
179 skb
->len
- (size_t)le32_to_cpu(p_rx_pd
->pkt_ptr
));
181 lbs_deb_hex(LBS_DEB_RX
, "RX Data: Dest", p_rx_pkt
->eth803_hdr
.dest_addr
,
182 sizeof(p_rx_pkt
->eth803_hdr
.dest_addr
));
183 lbs_deb_hex(LBS_DEB_RX
, "RX Data: Src", p_rx_pkt
->eth803_hdr
.src_addr
,
184 sizeof(p_rx_pkt
->eth803_hdr
.src_addr
));
186 if (memcmp(&p_rx_pkt
->rfc1042_hdr
,
187 rfc1042_eth_hdr
, sizeof(rfc1042_eth_hdr
)) == 0) {
189 * Replace the 803 header and rfc1042 header (llc/snap) with an
190 * EthernetII header, keep the src/dst and snap_type (ethertype)
192 * The firmware only passes up SNAP frames converting
193 * all RX Data from 802.11 to 802.2/LLC/SNAP frames.
195 * To create the Ethernet II, just move the src, dst address right
196 * before the snap_type.
198 p_ethhdr
= (struct ethhdr
*)
199 ((u8
*) &p_rx_pkt
->eth803_hdr
200 + sizeof(p_rx_pkt
->eth803_hdr
) + sizeof(p_rx_pkt
->rfc1042_hdr
)
201 - sizeof(p_rx_pkt
->eth803_hdr
.dest_addr
)
202 - sizeof(p_rx_pkt
->eth803_hdr
.src_addr
)
203 - sizeof(p_rx_pkt
->rfc1042_hdr
.snap_type
));
205 memcpy(p_ethhdr
->h_source
, p_rx_pkt
->eth803_hdr
.src_addr
,
206 sizeof(p_ethhdr
->h_source
));
207 memcpy(p_ethhdr
->h_dest
, p_rx_pkt
->eth803_hdr
.dest_addr
,
208 sizeof(p_ethhdr
->h_dest
));
210 /* Chop off the rxpd + the excess memory from the 802.2/llc/snap header
213 hdrchop
= (u8
*)p_ethhdr
- (u8
*)p_rx_pd
;
215 lbs_deb_hex(LBS_DEB_RX
, "RX Data: LLC/SNAP",
216 (u8
*) &p_rx_pkt
->rfc1042_hdr
,
217 sizeof(p_rx_pkt
->rfc1042_hdr
));
219 /* Chop off the rxpd */
220 hdrchop
= (u8
*)&p_rx_pkt
->eth803_hdr
- (u8
*)p_rx_pd
;
223 /* Chop off the leading header bytes so the skb points to the start of
224 * either the reconstructed EthII frame or the 802.2/llc/snap frame
226 skb_pull(skb
, hdrchop
);
228 /* Take the data rate from the rxpd structure
229 * only if the rate is auto
231 if (priv
->enablehwauto
)
232 priv
->cur_rate
= lbs_fw_index_to_data_rate(p_rx_pd
->rx_rate
);
234 lbs_compute_rssi(priv
, p_rx_pd
);
236 lbs_deb_rx("rx data: size of actual packet %d\n", skb
->len
);
237 dev
->stats
.rx_bytes
+= skb
->len
;
238 dev
->stats
.rx_packets
++;
240 skb
->protocol
= eth_type_trans(skb
, dev
);
248 lbs_deb_leave_args(LBS_DEB_RX
, "ret %d", ret
);
251 EXPORT_SYMBOL_GPL(lbs_process_rxed_packet
);
254 * @brief This function converts Tx/Rx rates from the Marvell WLAN format
255 * (see Table 2 in Section 3.1) to IEEE80211_RADIOTAP_RATE units (500 Kb/s)
257 * @param rate Input rate
258 * @return Output Rate (0 if invalid)
260 static u8
convert_mv_rate_to_radiotap(u8 rate
)
267 case 2: /* 5.5 Mbps */
269 case 3: /* 11 Mbps */
271 /* case 4: reserved */
276 case 7: /* 12 Mbps */
278 case 8: /* 18 Mbps */
280 case 9: /* 24 Mbps */
282 case 10: /* 36 Mbps */
284 case 11: /* 48 Mbps */
286 case 12: /* 54 Mbps */
289 lbs_pr_alert("Invalid Marvell WLAN rate %i\n", rate
);
294 * @brief This function processes a received 802.11 packet and forwards it
295 * to kernel/upper layer
297 * @param priv A pointer to struct lbs_private
298 * @param skb A pointer to skb which includes the received packet
301 static int process_rxed_802_11_packet(struct lbs_private
*priv
,
305 struct net_device
*dev
= priv
->dev
;
306 struct rx80211packethdr
*p_rx_pkt
;
308 struct rx_radiotap_hdr radiotap_hdr
;
309 struct rx_radiotap_hdr
*pradiotap_hdr
;
311 lbs_deb_enter(LBS_DEB_RX
);
313 p_rx_pkt
= (struct rx80211packethdr
*) skb
->data
;
314 prxpd
= &p_rx_pkt
->rx_pd
;
316 /* lbs_deb_hex(LBS_DEB_RX, "RX Data: Before chop rxpd", skb->data, min(skb->len, 100)); */
318 if (skb
->len
< (ETH_HLEN
+ 8 + sizeof(struct rxpd
))) {
319 lbs_deb_rx("rx err: frame received with bad length\n");
320 dev
->stats
.rx_length_errors
++;
326 lbs_deb_rx("rx data: skb->len-sizeof(RxPd) = %d-%zd = %zd\n",
327 skb
->len
, sizeof(struct rxpd
), skb
->len
- sizeof(struct rxpd
));
329 /* create the exported radio header */
331 /* radiotap header */
332 radiotap_hdr
.hdr
.it_version
= 0;
333 /* XXX must check this value for pad */
334 radiotap_hdr
.hdr
.it_pad
= 0;
335 radiotap_hdr
.hdr
.it_len
= cpu_to_le16 (sizeof(struct rx_radiotap_hdr
));
336 radiotap_hdr
.hdr
.it_present
= cpu_to_le32 (RX_RADIOTAP_PRESENT
);
337 radiotap_hdr
.rate
= convert_mv_rate_to_radiotap(prxpd
->rx_rate
);
338 /* XXX must check no carryout */
339 radiotap_hdr
.antsignal
= prxpd
->snr
+ prxpd
->nf
;
342 skb_pull(skb
, sizeof(struct rxpd
));
344 /* add space for the new radio header */
345 if ((skb_headroom(skb
) < sizeof(struct rx_radiotap_hdr
)) &&
346 pskb_expand_head(skb
, sizeof(struct rx_radiotap_hdr
), 0, GFP_ATOMIC
)) {
347 lbs_pr_alert("%s: couldn't pskb_expand_head\n", __func__
);
353 pradiotap_hdr
= (void *)skb_push(skb
, sizeof(struct rx_radiotap_hdr
));
354 memcpy(pradiotap_hdr
, &radiotap_hdr
, sizeof(struct rx_radiotap_hdr
));
356 /* Take the data rate from the rxpd structure
357 * only if the rate is auto
359 if (priv
->enablehwauto
)
360 priv
->cur_rate
= lbs_fw_index_to_data_rate(prxpd
->rx_rate
);
362 lbs_compute_rssi(priv
, prxpd
);
364 lbs_deb_rx("rx data: size of actual packet %d\n", skb
->len
);
365 dev
->stats
.rx_bytes
+= skb
->len
;
366 dev
->stats
.rx_packets
++;
368 skb
->protocol
= eth_type_trans(skb
, priv
->rtap_net_dev
);
374 lbs_deb_leave_args(LBS_DEB_RX
, "ret %d", ret
);