1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This file contains the handling of RX in wlan driver. 4 */ 5 6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 7 8 #include <linux/etherdevice.h> 9 #include <linux/hardirq.h> 10 #include <linux/slab.h> 11 #include <linux/types.h> 12 #include <linux/export.h> 13 #include <net/cfg80211.h> 14 15 #include "defs.h" 16 #include "host.h" 17 #include "radiotap.h" 18 #include "decl.h" 19 #include "dev.h" 20 #include "mesh.h" 21 22 struct eth803hdr { 23 u8 dest_addr[6]; 24 u8 src_addr[6]; 25 u16 h803_len; 26 } __packed; 27 28 struct rfc1042hdr { 29 u8 llc_dsap; 30 u8 llc_ssap; 31 u8 llc_ctrl; 32 u8 snap_oui[3]; 33 u16 snap_type; 34 } __packed; 35 36 struct rxpackethdr { 37 struct eth803hdr eth803_hdr; 38 struct rfc1042hdr rfc1042_hdr; 39 } __packed; 40 41 struct rx80211packethdr { 42 struct rxpd rx_pd; 43 void *eth80211_hdr; 44 } __packed; 45 46 static int process_rxed_802_11_packet(struct lbs_private *priv, 47 struct sk_buff *skb); 48 49 /** 50 * lbs_process_rxed_packet - processes received packet and forwards it 51 * to kernel/upper layer 52 * 53 * @priv: A pointer to &struct lbs_private 54 * @skb: A pointer to skb which includes the received packet 55 * returns: 0 or -1 56 */ 57 int lbs_process_rxed_packet(struct lbs_private *priv, struct sk_buff *skb) 58 { 59 int ret = 0; 60 struct net_device *dev = priv->dev; 61 struct rxpackethdr *p_rx_pkt; 62 struct rxpd *p_rx_pd; 63 int hdrchop; 64 struct ethhdr *p_ethhdr; 65 66 BUG_ON(!skb); 67 68 skb->ip_summed = CHECKSUM_NONE; 69 70 if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR) { 71 ret = process_rxed_802_11_packet(priv, skb); 72 goto done; 73 } 74 75 p_rx_pd = (struct rxpd *) skb->data; 76 p_rx_pkt = (struct rxpackethdr *) ((u8 *)p_rx_pd + 77 le32_to_cpu(p_rx_pd->pkt_ptr)); 78 79 dev = lbs_mesh_set_dev(priv, dev, p_rx_pd); 80 81 lbs_deb_hex(LBS_DEB_RX, "RX Data: Before chop rxpd", skb->data, 82 min_t(unsigned int, skb->len, 100)); 83 84 if (skb->len < (ETH_HLEN + 8 + sizeof(struct rxpd))) { 85 lbs_deb_rx("rx err: frame received with bad length\n"); 86 dev->stats.rx_length_errors++; 87 ret = -EINVAL; 88 dev_kfree_skb(skb); 89 goto done; 90 } 91 92 lbs_deb_rx("rx data: skb->len - pkt_ptr = %d-%zd = %zd\n", 93 skb->len, (size_t)le32_to_cpu(p_rx_pd->pkt_ptr), 94 skb->len - (size_t)le32_to_cpu(p_rx_pd->pkt_ptr)); 95 96 lbs_deb_hex(LBS_DEB_RX, "RX Data: Dest", p_rx_pkt->eth803_hdr.dest_addr, 97 sizeof(p_rx_pkt->eth803_hdr.dest_addr)); 98 lbs_deb_hex(LBS_DEB_RX, "RX Data: Src", p_rx_pkt->eth803_hdr.src_addr, 99 sizeof(p_rx_pkt->eth803_hdr.src_addr)); 100 101 if (memcmp(&p_rx_pkt->rfc1042_hdr, 102 rfc1042_header, sizeof(rfc1042_header)) == 0) { 103 /* 104 * Replace the 803 header and rfc1042 header (llc/snap) with an 105 * EthernetII header, keep the src/dst and snap_type (ethertype) 106 * 107 * The firmware only passes up SNAP frames converting 108 * all RX Data from 802.11 to 802.2/LLC/SNAP frames. 109 * 110 * To create the Ethernet II, just move the src, dst address right 111 * before the snap_type. 112 */ 113 p_ethhdr = (struct ethhdr *) 114 ((u8 *) &p_rx_pkt->eth803_hdr 115 + sizeof(p_rx_pkt->eth803_hdr) + sizeof(p_rx_pkt->rfc1042_hdr) 116 - sizeof(p_rx_pkt->eth803_hdr.dest_addr) 117 - sizeof(p_rx_pkt->eth803_hdr.src_addr) 118 - sizeof(p_rx_pkt->rfc1042_hdr.snap_type)); 119 120 memcpy(p_ethhdr->h_source, p_rx_pkt->eth803_hdr.src_addr, 121 sizeof(p_ethhdr->h_source)); 122 memcpy(p_ethhdr->h_dest, p_rx_pkt->eth803_hdr.dest_addr, 123 sizeof(p_ethhdr->h_dest)); 124 125 /* Chop off the rxpd + the excess memory from the 802.2/llc/snap header 126 * that was removed 127 */ 128 hdrchop = (u8 *)p_ethhdr - (u8 *)p_rx_pd; 129 } else { 130 lbs_deb_hex(LBS_DEB_RX, "RX Data: LLC/SNAP", 131 (u8 *) &p_rx_pkt->rfc1042_hdr, 132 sizeof(p_rx_pkt->rfc1042_hdr)); 133 134 /* Chop off the rxpd */ 135 hdrchop = (u8 *)&p_rx_pkt->eth803_hdr - (u8 *)p_rx_pd; 136 } 137 138 /* Chop off the leading header bytes so the skb points to the start of 139 * either the reconstructed EthII frame or the 802.2/llc/snap frame 140 */ 141 skb_pull(skb, hdrchop); 142 143 priv->cur_rate = lbs_fw_index_to_data_rate(p_rx_pd->rx_rate); 144 145 lbs_deb_rx("rx data: size of actual packet %d\n", skb->len); 146 dev->stats.rx_bytes += skb->len; 147 dev->stats.rx_packets++; 148 149 skb->protocol = eth_type_trans(skb, dev); 150 netif_rx(skb); 151 152 ret = 0; 153 done: 154 return ret; 155 } 156 EXPORT_SYMBOL_GPL(lbs_process_rxed_packet); 157 158 /** 159 * convert_mv_rate_to_radiotap - converts Tx/Rx rates from Marvell WLAN format 160 * (see Table 2 in Section 3.1) to IEEE80211_RADIOTAP_RATE units (500 Kb/s) 161 * 162 * @rate: Input rate 163 * returns: Output Rate (0 if invalid) 164 */ 165 static u8 convert_mv_rate_to_radiotap(u8 rate) 166 { 167 switch (rate) { 168 case 0: /* 1 Mbps */ 169 return 2; 170 case 1: /* 2 Mbps */ 171 return 4; 172 case 2: /* 5.5 Mbps */ 173 return 11; 174 case 3: /* 11 Mbps */ 175 return 22; 176 /* case 4: reserved */ 177 case 5: /* 6 Mbps */ 178 return 12; 179 case 6: /* 9 Mbps */ 180 return 18; 181 case 7: /* 12 Mbps */ 182 return 24; 183 case 8: /* 18 Mbps */ 184 return 36; 185 case 9: /* 24 Mbps */ 186 return 48; 187 case 10: /* 36 Mbps */ 188 return 72; 189 case 11: /* 48 Mbps */ 190 return 96; 191 case 12: /* 54 Mbps */ 192 return 108; 193 } 194 pr_alert("Invalid Marvell WLAN rate %i\n", rate); 195 return 0; 196 } 197 198 /** 199 * process_rxed_802_11_packet - processes a received 802.11 packet and forwards 200 * it to kernel/upper layer 201 * 202 * @priv: A pointer to &struct lbs_private 203 * @skb: A pointer to skb which includes the received packet 204 * returns: 0 or -1 205 */ 206 static int process_rxed_802_11_packet(struct lbs_private *priv, 207 struct sk_buff *skb) 208 { 209 int ret = 0; 210 struct net_device *dev = priv->dev; 211 struct rx80211packethdr *p_rx_pkt; 212 struct rxpd *prxpd; 213 struct rx_radiotap_hdr radiotap_hdr; 214 struct rx_radiotap_hdr *pradiotap_hdr; 215 216 p_rx_pkt = (struct rx80211packethdr *) skb->data; 217 prxpd = &p_rx_pkt->rx_pd; 218 219 /* lbs_deb_hex(LBS_DEB_RX, "RX Data: Before chop rxpd", skb->data, min(skb->len, 100)); */ 220 221 if (skb->len < (ETH_HLEN + 8 + sizeof(struct rxpd))) { 222 lbs_deb_rx("rx err: frame received with bad length\n"); 223 dev->stats.rx_length_errors++; 224 ret = -EINVAL; 225 kfree_skb(skb); 226 goto done; 227 } 228 229 lbs_deb_rx("rx data: skb->len-sizeof(RxPd) = %d-%zd = %zd\n", 230 skb->len, sizeof(struct rxpd), skb->len - sizeof(struct rxpd)); 231 232 /* create the exported radio header */ 233 234 /* radiotap header */ 235 memset(&radiotap_hdr, 0, sizeof(radiotap_hdr)); 236 /* XXX must check radiotap_hdr.hdr.it_pad for pad */ 237 radiotap_hdr.hdr.it_len = cpu_to_le16 (sizeof(struct rx_radiotap_hdr)); 238 radiotap_hdr.hdr.it_present = cpu_to_le32 (RX_RADIOTAP_PRESENT); 239 radiotap_hdr.rate = convert_mv_rate_to_radiotap(prxpd->rx_rate); 240 /* XXX must check no carryout */ 241 radiotap_hdr.antsignal = prxpd->snr + prxpd->nf; 242 243 /* chop the rxpd */ 244 skb_pull(skb, sizeof(struct rxpd)); 245 246 /* add space for the new radio header */ 247 if ((skb_headroom(skb) < sizeof(struct rx_radiotap_hdr)) && 248 pskb_expand_head(skb, sizeof(struct rx_radiotap_hdr), 0, GFP_ATOMIC)) { 249 netdev_alert(dev, "%s: couldn't pskb_expand_head\n", __func__); 250 ret = -ENOMEM; 251 kfree_skb(skb); 252 goto done; 253 } 254 255 pradiotap_hdr = skb_push(skb, sizeof(struct rx_radiotap_hdr)); 256 memcpy(pradiotap_hdr, &radiotap_hdr, sizeof(struct rx_radiotap_hdr)); 257 258 priv->cur_rate = lbs_fw_index_to_data_rate(prxpd->rx_rate); 259 260 lbs_deb_rx("rx data: size of actual packet %d\n", skb->len); 261 dev->stats.rx_bytes += skb->len; 262 dev->stats.rx_packets++; 263 264 skb->protocol = eth_type_trans(skb, priv->dev); 265 netif_rx(skb); 266 267 ret = 0; 268 269 done: 270 return ret; 271 } 272