1 /* 2 * Copyright (c) 2005-2011 Atheros Communications Inc. 3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 #include "core.h" 19 #include "txrx.h" 20 #include "htt.h" 21 #include "mac.h" 22 #include "debug.h" 23 24 static void ath10k_report_offchan_tx(struct ath10k *ar, struct sk_buff *skb) 25 { 26 if (!ATH10K_SKB_CB(skb)->htt.is_offchan) 27 return; 28 29 /* If the original wait_for_completion() timed out before 30 * {data,mgmt}_tx_completed() was called then we could complete 31 * offchan_tx_completed for a different skb. Prevent this by using 32 * offchan_tx_skb. */ 33 spin_lock_bh(&ar->data_lock); 34 if (ar->offchan_tx_skb != skb) { 35 ath10k_warn("completed old offchannel frame\n"); 36 goto out; 37 } 38 39 complete(&ar->offchan_tx_completed); 40 ar->offchan_tx_skb = NULL; /* just for sanity */ 41 42 ath10k_dbg(ATH10K_DBG_HTT, "completed offchannel skb %p\n", skb); 43 out: 44 spin_unlock_bh(&ar->data_lock); 45 } 46 47 void ath10k_txrx_tx_unref(struct ath10k_htt *htt, 48 const struct htt_tx_done *tx_done) 49 { 50 struct device *dev = htt->ar->dev; 51 struct ieee80211_tx_info *info; 52 struct ath10k_skb_cb *skb_cb; 53 struct sk_buff *msdu; 54 int ret; 55 56 ath10k_dbg(ATH10K_DBG_HTT, "htt tx completion msdu_id %u discard %d no_ack %d\n", 57 tx_done->msdu_id, !!tx_done->discard, !!tx_done->no_ack); 58 59 if (tx_done->msdu_id >= htt->max_num_pending_tx) { 60 ath10k_warn("warning: msdu_id %d too big, ignoring\n", 61 tx_done->msdu_id); 62 return; 63 } 64 65 msdu = htt->pending_tx[tx_done->msdu_id]; 66 skb_cb = ATH10K_SKB_CB(msdu); 67 68 ret = ath10k_skb_unmap(dev, msdu); 69 if (ret) 70 ath10k_warn("data skb unmap failed (%d)\n", ret); 71 72 if (skb_cb->htt.frag_len) 73 skb_pull(msdu, skb_cb->htt.frag_len + skb_cb->htt.pad_len); 74 75 ath10k_report_offchan_tx(htt->ar, msdu); 76 77 info = IEEE80211_SKB_CB(msdu); 78 79 if (tx_done->discard) { 80 ieee80211_free_txskb(htt->ar->hw, msdu); 81 goto exit; 82 } 83 84 if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) 85 info->flags |= IEEE80211_TX_STAT_ACK; 86 87 if (tx_done->no_ack) 88 info->flags &= ~IEEE80211_TX_STAT_ACK; 89 90 ieee80211_tx_status(htt->ar->hw, msdu); 91 /* we do not own the msdu anymore */ 92 93 exit: 94 spin_lock_bh(&htt->tx_lock); 95 htt->pending_tx[tx_done->msdu_id] = NULL; 96 ath10k_htt_tx_free_msdu_id(htt, tx_done->msdu_id); 97 __ath10k_htt_tx_dec_pending(htt); 98 if (htt->num_pending_tx == 0) 99 wake_up(&htt->empty_tx_wq); 100 spin_unlock_bh(&htt->tx_lock); 101 } 102 103 static const u8 rx_legacy_rate_idx[] = { 104 3, /* 0x00 - 11Mbps */ 105 2, /* 0x01 - 5.5Mbps */ 106 1, /* 0x02 - 2Mbps */ 107 0, /* 0x03 - 1Mbps */ 108 3, /* 0x04 - 11Mbps */ 109 2, /* 0x05 - 5.5Mbps */ 110 1, /* 0x06 - 2Mbps */ 111 0, /* 0x07 - 1Mbps */ 112 10, /* 0x08 - 48Mbps */ 113 8, /* 0x09 - 24Mbps */ 114 6, /* 0x0A - 12Mbps */ 115 4, /* 0x0B - 6Mbps */ 116 11, /* 0x0C - 54Mbps */ 117 9, /* 0x0D - 36Mbps */ 118 7, /* 0x0E - 18Mbps */ 119 5, /* 0x0F - 9Mbps */ 120 }; 121 122 static void process_rx_rates(struct ath10k *ar, struct htt_rx_info *info, 123 enum ieee80211_band band, 124 struct ieee80211_rx_status *status) 125 { 126 u8 cck, rate, rate_idx, bw, sgi, mcs, nss; 127 u8 info0 = info->rate.info0; 128 u32 info1 = info->rate.info1; 129 u32 info2 = info->rate.info2; 130 u8 preamble = 0; 131 132 /* Check if valid fields */ 133 if (!(info0 & HTT_RX_INDICATION_INFO0_START_VALID)) 134 return; 135 136 preamble = MS(info1, HTT_RX_INDICATION_INFO1_PREAMBLE_TYPE); 137 138 switch (preamble) { 139 case HTT_RX_LEGACY: 140 cck = info0 & HTT_RX_INDICATION_INFO0_LEGACY_RATE_CCK; 141 rate = MS(info0, HTT_RX_INDICATION_INFO0_LEGACY_RATE); 142 rate_idx = 0; 143 144 if (rate < 0x08 || rate > 0x0F) 145 break; 146 147 switch (band) { 148 case IEEE80211_BAND_2GHZ: 149 if (cck) 150 rate &= ~BIT(3); 151 rate_idx = rx_legacy_rate_idx[rate]; 152 break; 153 case IEEE80211_BAND_5GHZ: 154 rate_idx = rx_legacy_rate_idx[rate]; 155 /* We are using same rate table registering 156 HW - ath10k_rates[]. In case of 5GHz skip 157 CCK rates, so -4 here */ 158 rate_idx -= 4; 159 break; 160 default: 161 break; 162 } 163 164 status->rate_idx = rate_idx; 165 break; 166 case HTT_RX_HT: 167 case HTT_RX_HT_WITH_TXBF: 168 /* HT-SIG - Table 20-11 in info1 and info2 */ 169 mcs = info1 & 0x1F; 170 nss = mcs >> 3; 171 bw = (info1 >> 7) & 1; 172 sgi = (info2 >> 7) & 1; 173 174 status->rate_idx = mcs; 175 status->flag |= RX_FLAG_HT; 176 if (sgi) 177 status->flag |= RX_FLAG_SHORT_GI; 178 if (bw) 179 status->flag |= RX_FLAG_40MHZ; 180 break; 181 case HTT_RX_VHT: 182 case HTT_RX_VHT_WITH_TXBF: 183 /* VHT-SIG-A1 in info 1, VHT-SIG-A2 in info2 184 TODO check this */ 185 mcs = (info2 >> 4) & 0x0F; 186 nss = (info1 >> 10) & 0x07; 187 bw = info1 & 3; 188 sgi = info2 & 1; 189 190 status->rate_idx = mcs; 191 status->vht_nss = nss; 192 193 if (sgi) 194 status->flag |= RX_FLAG_SHORT_GI; 195 196 switch (bw) { 197 /* 20MHZ */ 198 case 0: 199 break; 200 /* 40MHZ */ 201 case 1: 202 status->flag |= RX_FLAG_40MHZ; 203 break; 204 /* 80MHZ */ 205 case 2: 206 status->flag |= RX_FLAG_80MHZ; 207 } 208 209 status->flag |= RX_FLAG_VHT; 210 break; 211 default: 212 break; 213 } 214 } 215 216 void ath10k_process_rx(struct ath10k *ar, struct htt_rx_info *info) 217 { 218 struct ieee80211_rx_status *status; 219 struct ieee80211_channel *ch; 220 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)info->skb->data; 221 222 status = IEEE80211_SKB_RXCB(info->skb); 223 memset(status, 0, sizeof(*status)); 224 225 if (info->encrypt_type != HTT_RX_MPDU_ENCRYPT_NONE) { 226 status->flag |= RX_FLAG_DECRYPTED | RX_FLAG_IV_STRIPPED | 227 RX_FLAG_MMIC_STRIPPED; 228 hdr->frame_control = __cpu_to_le16( 229 __le16_to_cpu(hdr->frame_control) & 230 ~IEEE80211_FCTL_PROTECTED); 231 } 232 233 if (info->status == HTT_RX_IND_MPDU_STATUS_TKIP_MIC_ERR) 234 status->flag |= RX_FLAG_MMIC_ERROR; 235 236 if (info->fcs_err) 237 status->flag |= RX_FLAG_FAILED_FCS_CRC; 238 239 status->signal = info->signal; 240 241 spin_lock_bh(&ar->data_lock); 242 ch = ar->scan_channel; 243 if (!ch) 244 ch = ar->rx_channel; 245 spin_unlock_bh(&ar->data_lock); 246 247 if (!ch) { 248 ath10k_warn("no channel configured; ignoring frame!\n"); 249 dev_kfree_skb_any(info->skb); 250 return; 251 } 252 253 process_rx_rates(ar, info, ch->band, status); 254 status->band = ch->band; 255 status->freq = ch->center_freq; 256 257 ath10k_dbg(ATH10K_DBG_DATA, 258 "rx skb %p len %u %s%s%s%s%s %srate_idx %u vht_nss %u freq %u band %u\n", 259 info->skb, 260 info->skb->len, 261 status->flag == 0 ? "legacy" : "", 262 status->flag & RX_FLAG_HT ? "ht" : "", 263 status->flag & RX_FLAG_VHT ? "vht" : "", 264 status->flag & RX_FLAG_40MHZ ? "40" : "", 265 status->flag & RX_FLAG_80MHZ ? "80" : "", 266 status->flag & RX_FLAG_SHORT_GI ? "sgi " : "", 267 status->rate_idx, 268 status->vht_nss, 269 status->freq, 270 status->band); 271 ath10k_dbg_dump(ATH10K_DBG_HTT_DUMP, NULL, "rx skb: ", 272 info->skb->data, info->skb->len); 273 274 ieee80211_rx(ar->hw, info->skb); 275 } 276 277 struct ath10k_peer *ath10k_peer_find(struct ath10k *ar, int vdev_id, 278 const u8 *addr) 279 { 280 struct ath10k_peer *peer; 281 282 lockdep_assert_held(&ar->data_lock); 283 284 list_for_each_entry(peer, &ar->peers, list) { 285 if (peer->vdev_id != vdev_id) 286 continue; 287 if (memcmp(peer->addr, addr, ETH_ALEN)) 288 continue; 289 290 return peer; 291 } 292 293 return NULL; 294 } 295 296 static struct ath10k_peer *ath10k_peer_find_by_id(struct ath10k *ar, 297 int peer_id) 298 { 299 struct ath10k_peer *peer; 300 301 lockdep_assert_held(&ar->data_lock); 302 303 list_for_each_entry(peer, &ar->peers, list) 304 if (test_bit(peer_id, peer->peer_ids)) 305 return peer; 306 307 return NULL; 308 } 309 310 static int ath10k_wait_for_peer_common(struct ath10k *ar, int vdev_id, 311 const u8 *addr, bool expect_mapped) 312 { 313 int ret; 314 315 ret = wait_event_timeout(ar->peer_mapping_wq, ({ 316 bool mapped; 317 318 spin_lock_bh(&ar->data_lock); 319 mapped = !!ath10k_peer_find(ar, vdev_id, addr); 320 spin_unlock_bh(&ar->data_lock); 321 322 mapped == expect_mapped; 323 }), 3*HZ); 324 325 if (ret <= 0) 326 return -ETIMEDOUT; 327 328 return 0; 329 } 330 331 int ath10k_wait_for_peer_created(struct ath10k *ar, int vdev_id, const u8 *addr) 332 { 333 return ath10k_wait_for_peer_common(ar, vdev_id, addr, true); 334 } 335 336 int ath10k_wait_for_peer_deleted(struct ath10k *ar, int vdev_id, const u8 *addr) 337 { 338 return ath10k_wait_for_peer_common(ar, vdev_id, addr, false); 339 } 340 341 void ath10k_peer_map_event(struct ath10k_htt *htt, 342 struct htt_peer_map_event *ev) 343 { 344 struct ath10k *ar = htt->ar; 345 struct ath10k_peer *peer; 346 347 spin_lock_bh(&ar->data_lock); 348 peer = ath10k_peer_find(ar, ev->vdev_id, ev->addr); 349 if (!peer) { 350 peer = kzalloc(sizeof(*peer), GFP_ATOMIC); 351 if (!peer) 352 goto exit; 353 354 peer->vdev_id = ev->vdev_id; 355 memcpy(peer->addr, ev->addr, ETH_ALEN); 356 list_add(&peer->list, &ar->peers); 357 wake_up(&ar->peer_mapping_wq); 358 } 359 360 ath10k_dbg(ATH10K_DBG_HTT, "htt peer map vdev %d peer %pM id %d\n", 361 ev->vdev_id, ev->addr, ev->peer_id); 362 363 set_bit(ev->peer_id, peer->peer_ids); 364 exit: 365 spin_unlock_bh(&ar->data_lock); 366 } 367 368 void ath10k_peer_unmap_event(struct ath10k_htt *htt, 369 struct htt_peer_unmap_event *ev) 370 { 371 struct ath10k *ar = htt->ar; 372 struct ath10k_peer *peer; 373 374 spin_lock_bh(&ar->data_lock); 375 peer = ath10k_peer_find_by_id(ar, ev->peer_id); 376 if (!peer) { 377 ath10k_warn("unknown peer id %d\n", ev->peer_id); 378 goto exit; 379 } 380 381 ath10k_dbg(ATH10K_DBG_HTT, "htt peer unmap vdev %d peer %pM id %d\n", 382 peer->vdev_id, peer->addr, ev->peer_id); 383 384 clear_bit(ev->peer_id, peer->peer_ids); 385 386 if (bitmap_empty(peer->peer_ids, ATH10K_MAX_NUM_PEER_IDS)) { 387 list_del(&peer->list); 388 kfree(peer); 389 wake_up(&ar->peer_mapping_wq); 390 } 391 392 exit: 393 spin_unlock_bh(&ar->data_lock); 394 } 395