| 1 |
// SPDX-License-Identifier: BSD-3-Clause-Clear |
| 2 |
/* |
| 3 |
* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. |
| 4 |
* Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. |
| 5 |
*/ |
| 6 |
|
| 7 |
#include <linux/ieee80211.h> |
| 8 |
#include <linux/kernel.h> |
| 9 |
#include <linux/skbuff.h> |
| 10 |
#include <crypto/hash.h> |
| 11 |
#include "core.h" |
| 12 |
#include "debug.h" |
| 13 |
#include "hw.h" |
| 14 |
#include "dp_rx.h" |
| 15 |
#include "dp_tx.h" |
| 16 |
#include "peer.h" |
| 17 |
#include "dp_mon.h" |
| 18 |
#include "debugfs_htt_stats.h" |
| 19 |
|
| 20 |
static int ath12k_dp_rx_tid_delete_handler(struct ath12k_base *ab, |
| 21 |
struct ath12k_dp_rx_tid_rxq *rx_tid); |
| 22 |
|
| 23 |
static size_t ath12k_dp_list_cut_nodes(struct list_head *list, |
| 24 |
struct list_head *head, |
| 25 |
size_t count) |
| 26 |
{ |
| 27 |
struct list_head *cur; |
| 28 |
struct ath12k_rx_desc_info *rx_desc; |
| 29 |
size_t nodes = 0; |
| 30 |
|
| 31 |
if (!count) { |
| 32 |
INIT_LIST_HEAD(list); |
| 33 |
goto out; |
| 34 |
} |
| 35 |
|
| 36 |
list_for_each(cur, head) { |
| 37 |
if (!count) |
| 38 |
break; |
| 39 |
|
| 40 |
rx_desc = list_entry(cur, struct ath12k_rx_desc_info, list); |
| 41 |
rx_desc->in_use = true; |
| 42 |
|
| 43 |
count--; |
| 44 |
nodes++; |
| 45 |
} |
| 46 |
|
| 47 |
list_cut_before(list, head, cur); |
| 48 |
out: |
| 49 |
return nodes; |
| 50 |
} |
| 51 |
|
| 52 |
static void ath12k_dp_rx_enqueue_free(struct ath12k_dp *dp, |
| 53 |
struct list_head *used_list) |
| 54 |
{ |
| 55 |
struct ath12k_rx_desc_info *rx_desc, *safe; |
| 56 |
|
| 57 |
/* Reset the use flag */ |
| 58 |
list_for_each_entry_safe(rx_desc, safe, used_list, list) |
| 59 |
rx_desc->in_use = false; |
| 60 |
|
| 61 |
spin_lock_bh(&dp->rx_desc_lock); |
| 62 |
list_splice_tail(used_list, &dp->rx_desc_free_list); |
| 63 |
spin_unlock_bh(&dp->rx_desc_lock); |
| 64 |
} |
| 65 |
|
| 66 |
/* Returns number of Rx buffers replenished */ |
| 67 |
int ath12k_dp_rx_bufs_replenish(struct ath12k_dp *dp, |
| 68 |
struct dp_rxdma_ring *rx_ring, |
| 69 |
struct list_head *used_list, |
| 70 |
int req_entries) |
| 71 |
{ |
| 72 |
struct ath12k_base *ab = dp->ab; |
| 73 |
struct ath12k_buffer_addr *desc; |
| 74 |
struct hal_srng *srng; |
| 75 |
struct sk_buff *skb; |
| 76 |
int num_free; |
| 77 |
int num_remain; |
| 78 |
u32 cookie; |
| 79 |
dma_addr_t paddr; |
| 80 |
struct ath12k_rx_desc_info *rx_desc; |
| 81 |
enum hal_rx_buf_return_buf_manager mgr = dp->hal->hal_params->rx_buf_rbm; |
| 82 |
|
| 83 |
req_entries = min(req_entries, rx_ring->bufs_max); |
| 84 |
|
| 85 |
srng = &dp->hal->srng_list[rx_ring->refill_buf_ring.ring_id]; |
| 86 |
|
| 87 |
spin_lock_bh(&srng->lock); |
| 88 |
|
| 89 |
ath12k_hal_srng_access_begin(ab, srng); |
| 90 |
|
| 91 |
num_free = ath12k_hal_srng_src_num_free(ab, srng, true); |
| 92 |
if (!req_entries && (num_free > (rx_ring->bufs_max * 3) / 4)) |
| 93 |
req_entries = num_free; |
| 94 |
|
| 95 |
req_entries = min(num_free, req_entries); |
| 96 |
num_remain = req_entries; |
| 97 |
|
| 98 |
if (!num_remain) |
| 99 |
goto out; |
| 100 |
|
| 101 |
/* Get the descriptor from free list */ |
| 102 |
if (list_empty(used_list)) { |
| 103 |
spin_lock_bh(&dp->rx_desc_lock); |
| 104 |
req_entries = ath12k_dp_list_cut_nodes(used_list, |
| 105 |
&dp->rx_desc_free_list, |
| 106 |
num_remain); |
| 107 |
spin_unlock_bh(&dp->rx_desc_lock); |
| 108 |
num_remain = req_entries; |
| 109 |
} |
| 110 |
|
| 111 |
while (num_remain > 0) { |
| 112 |
skb = dev_alloc_skb(DP_RX_BUFFER_SIZE + |
| 113 |
DP_RX_BUFFER_ALIGN_SIZE); |
| 114 |
if (!skb) |
| 115 |
break; |
| 116 |
|
| 117 |
if (!IS_ALIGNED((unsigned long)skb->data, |
| 118 |
DP_RX_BUFFER_ALIGN_SIZE)) { |
| 119 |
skb_pull(skb, |
| 120 |
PTR_ALIGN(skb->data, DP_RX_BUFFER_ALIGN_SIZE) - |
| 121 |
skb->data); |
| 122 |
} |
| 123 |
|
| 124 |
paddr = dma_map_single(dp->dev, skb->data, |
| 125 |
skb->len + skb_tailroom(skb), |
| 126 |
DMA_FROM_DEVICE); |
| 127 |
if (dma_mapping_error(dp->dev, paddr)) |
| 128 |
goto fail_free_skb; |
| 129 |
|
| 130 |
rx_desc = list_first_entry_or_null(used_list, |
| 131 |
struct ath12k_rx_desc_info, |
| 132 |
list); |
| 133 |
if (!rx_desc) |
| 134 |
goto fail_dma_unmap; |
| 135 |
|
| 136 |
rx_desc->skb = skb; |
| 137 |
cookie = rx_desc->cookie; |
| 138 |
|
| 139 |
desc = ath12k_hal_srng_src_get_next_entry(ab, srng); |
| 140 |
if (!desc) |
| 141 |
goto fail_dma_unmap; |
| 142 |
|
| 143 |
list_del(&rx_desc->list); |
| 144 |
ATH12K_SKB_RXCB(skb)->paddr = paddr; |
| 145 |
|
| 146 |
num_remain--; |
| 147 |
|
| 148 |
ath12k_hal_rx_buf_addr_info_set(dp->hal, desc, paddr, cookie, |
| 149 |
mgr); |
| 150 |
} |
| 151 |
|
| 152 |
goto out; |
| 153 |
|
| 154 |
fail_dma_unmap: |
| 155 |
dma_unmap_single(dp->dev, paddr, skb->len + skb_tailroom(skb), |
| 156 |
DMA_FROM_DEVICE); |
| 157 |
fail_free_skb: |
| 158 |
dev_kfree_skb_any(skb); |
| 159 |
out: |
| 160 |
ath12k_hal_srng_access_end(ab, srng); |
| 161 |
|
| 162 |
if (!list_empty(used_list)) |
| 163 |
ath12k_dp_rx_enqueue_free(dp, used_list); |
| 164 |
|
| 165 |
spin_unlock_bh(&srng->lock); |
| 166 |
|
| 167 |
return req_entries - num_remain; |
| 168 |
} |
| 169 |
EXPORT_SYMBOL(ath12k_dp_rx_bufs_replenish); |
| 170 |
|
| 171 |
static int ath12k_dp_rxdma_mon_buf_ring_free(struct ath12k_base *ab, |
| 172 |
struct dp_rxdma_mon_ring *rx_ring) |
| 173 |
{ |
| 174 |
struct sk_buff *skb; |
| 175 |
int buf_id; |
| 176 |
|
| 177 |
spin_lock_bh(&rx_ring->idr_lock); |
| 178 |
idr_for_each_entry(&rx_ring->bufs_idr, skb, buf_id) { |
| 179 |
idr_remove(&rx_ring->bufs_idr, buf_id); |
| 180 |
/* TODO: Understand where internal driver does this dma_unmap |
| 181 |
* of rxdma_buffer. |
| 182 |
*/ |
| 183 |
dma_unmap_single(ab->dev, ATH12K_SKB_RXCB(skb)->paddr, |
| 184 |
skb->len + skb_tailroom(skb), DMA_FROM_DEVICE); |
| 185 |
dev_kfree_skb_any(skb); |
| 186 |
} |
| 187 |
|
| 188 |
idr_destroy(&rx_ring->bufs_idr); |
| 189 |
spin_unlock_bh(&rx_ring->idr_lock); |
| 190 |
|
| 191 |
return 0; |
| 192 |
} |
| 193 |
|
| 194 |
static int ath12k_dp_rxdma_buf_free(struct ath12k_base *ab) |
| 195 |
{ |
| 196 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 197 |
int i; |
| 198 |
|
| 199 |
ath12k_dp_rxdma_mon_buf_ring_free(ab, &dp->rxdma_mon_buf_ring); |
| 200 |
|
| 201 |
if (ab->hw_params->rxdma1_enable) |
| 202 |
return 0; |
| 203 |
|
| 204 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) |
| 205 |
ath12k_dp_rxdma_mon_buf_ring_free(ab, |
| 206 |
&dp->rx_mon_status_refill_ring[i]); |
| 207 |
|
| 208 |
return 0; |
| 209 |
} |
| 210 |
|
| 211 |
static int ath12k_dp_rxdma_mon_ring_buf_setup(struct ath12k_base *ab, |
| 212 |
struct dp_rxdma_mon_ring *rx_ring, |
| 213 |
u32 ringtype) |
| 214 |
{ |
| 215 |
int num_entries; |
| 216 |
|
| 217 |
num_entries = rx_ring->refill_buf_ring.size / |
| 218 |
ath12k_hal_srng_get_entrysize(ab, ringtype); |
| 219 |
|
| 220 |
rx_ring->bufs_max = num_entries; |
| 221 |
|
| 222 |
if (ringtype == HAL_RXDMA_MONITOR_STATUS) |
| 223 |
ath12k_dp_mon_status_bufs_replenish(ab, rx_ring, |
| 224 |
num_entries); |
| 225 |
else |
| 226 |
ath12k_dp_mon_buf_replenish(ab, rx_ring, num_entries); |
| 227 |
|
| 228 |
return 0; |
| 229 |
} |
| 230 |
|
| 231 |
static int ath12k_dp_rxdma_ring_buf_setup(struct ath12k_base *ab, |
| 232 |
struct dp_rxdma_ring *rx_ring) |
| 233 |
{ |
| 234 |
LIST_HEAD(list); |
| 235 |
|
| 236 |
rx_ring->bufs_max = rx_ring->refill_buf_ring.size / |
| 237 |
ath12k_hal_srng_get_entrysize(ab, HAL_RXDMA_BUF); |
| 238 |
|
| 239 |
ath12k_dp_rx_bufs_replenish(ath12k_ab_to_dp(ab), rx_ring, &list, 0); |
| 240 |
|
| 241 |
return 0; |
| 242 |
} |
| 243 |
|
| 244 |
static int ath12k_dp_rxdma_buf_setup(struct ath12k_base *ab) |
| 245 |
{ |
| 246 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 247 |
struct dp_rxdma_mon_ring *mon_ring; |
| 248 |
int ret, i; |
| 249 |
|
| 250 |
ret = ath12k_dp_rxdma_ring_buf_setup(ab, &dp->rx_refill_buf_ring); |
| 251 |
if (ret) { |
| 252 |
ath12k_warn(ab, |
| 253 |
"failed to setup HAL_RXDMA_BUF\n"); |
| 254 |
return ret; |
| 255 |
} |
| 256 |
|
| 257 |
if (ab->hw_params->rxdma1_enable) { |
| 258 |
ret = ath12k_dp_rxdma_mon_ring_buf_setup(ab, |
| 259 |
&dp->rxdma_mon_buf_ring, |
| 260 |
HAL_RXDMA_MONITOR_BUF); |
| 261 |
if (ret) |
| 262 |
ath12k_warn(ab, |
| 263 |
"failed to setup HAL_RXDMA_MONITOR_BUF\n"); |
| 264 |
return ret; |
| 265 |
} |
| 266 |
|
| 267 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 268 |
mon_ring = &dp->rx_mon_status_refill_ring[i]; |
| 269 |
ret = ath12k_dp_rxdma_mon_ring_buf_setup(ab, mon_ring, |
| 270 |
HAL_RXDMA_MONITOR_STATUS); |
| 271 |
if (ret) { |
| 272 |
ath12k_warn(ab, |
| 273 |
"failed to setup HAL_RXDMA_MONITOR_STATUS\n"); |
| 274 |
return ret; |
| 275 |
} |
| 276 |
} |
| 277 |
|
| 278 |
return 0; |
| 279 |
} |
| 280 |
|
| 281 |
static void ath12k_dp_rx_pdev_srng_free(struct ath12k *ar) |
| 282 |
{ |
| 283 |
struct ath12k_pdev_dp *dp = &ar->dp; |
| 284 |
struct ath12k_base *ab = ar->ab; |
| 285 |
int i; |
| 286 |
|
| 287 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) |
| 288 |
ath12k_dp_srng_cleanup(ab, &dp->rxdma_mon_dst_ring[i]); |
| 289 |
} |
| 290 |
|
| 291 |
void ath12k_dp_rx_pdev_reo_cleanup(struct ath12k_base *ab) |
| 292 |
{ |
| 293 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 294 |
int i; |
| 295 |
|
| 296 |
for (i = 0; i < DP_REO_DST_RING_MAX; i++) |
| 297 |
ath12k_dp_srng_cleanup(ab, &dp->reo_dst_ring[i]); |
| 298 |
} |
| 299 |
|
| 300 |
int ath12k_dp_rx_pdev_reo_setup(struct ath12k_base *ab) |
| 301 |
{ |
| 302 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 303 |
int ret; |
| 304 |
int i; |
| 305 |
|
| 306 |
for (i = 0; i < DP_REO_DST_RING_MAX; i++) { |
| 307 |
ret = ath12k_dp_srng_setup(ab, &dp->reo_dst_ring[i], |
| 308 |
HAL_REO_DST, i, 0, |
| 309 |
DP_REO_DST_RING_SIZE); |
| 310 |
if (ret) { |
| 311 |
ath12k_warn(ab, "failed to setup reo_dst_ring\n"); |
| 312 |
goto err_reo_cleanup; |
| 313 |
} |
| 314 |
} |
| 315 |
|
| 316 |
return 0; |
| 317 |
|
| 318 |
err_reo_cleanup: |
| 319 |
ath12k_dp_rx_pdev_reo_cleanup(ab); |
| 320 |
|
| 321 |
return ret; |
| 322 |
} |
| 323 |
|
| 324 |
static int ath12k_dp_rx_pdev_srng_alloc(struct ath12k *ar) |
| 325 |
{ |
| 326 |
struct ath12k_pdev_dp *dp = &ar->dp; |
| 327 |
struct ath12k_base *ab = ar->ab; |
| 328 |
int i; |
| 329 |
int ret; |
| 330 |
u32 mac_id = dp->mac_id; |
| 331 |
|
| 332 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 333 |
ret = ath12k_dp_srng_setup(ar->ab, |
| 334 |
&dp->rxdma_mon_dst_ring[i], |
| 335 |
HAL_RXDMA_MONITOR_DST, |
| 336 |
0, mac_id + i, |
| 337 |
DP_RXDMA_MONITOR_DST_RING_SIZE(ab)); |
| 338 |
if (ret) { |
| 339 |
ath12k_warn(ar->ab, |
| 340 |
"failed to setup HAL_RXDMA_MONITOR_DST\n"); |
| 341 |
return ret; |
| 342 |
} |
| 343 |
} |
| 344 |
|
| 345 |
return 0; |
| 346 |
} |
| 347 |
|
| 348 |
void ath12k_dp_init_rx_tid_rxq(struct ath12k_dp_rx_tid_rxq *rx_tid_rxq, |
| 349 |
struct ath12k_dp_rx_tid *rx_tid, |
| 350 |
bool active) |
| 351 |
{ |
| 352 |
rx_tid_rxq->tid = rx_tid->tid; |
| 353 |
rx_tid_rxq->active = active; |
| 354 |
rx_tid_rxq->qbuf = rx_tid->qbuf; |
| 355 |
} |
| 356 |
EXPORT_SYMBOL(ath12k_dp_init_rx_tid_rxq); |
| 357 |
|
| 358 |
static void ath12k_dp_rx_tid_cleanup(struct ath12k_base *ab, |
| 359 |
struct ath12k_reoq_buf *tid_qbuf) |
| 360 |
{ |
| 361 |
if (tid_qbuf->vaddr) { |
| 362 |
dma_unmap_single(ab->dev, tid_qbuf->paddr_aligned, |
| 363 |
tid_qbuf->size, DMA_BIDIRECTIONAL); |
| 364 |
kfree(tid_qbuf->vaddr); |
| 365 |
tid_qbuf->vaddr = NULL; |
| 366 |
} |
| 367 |
} |
| 368 |
|
| 369 |
void ath12k_dp_rx_reo_cmd_list_cleanup(struct ath12k_base *ab) |
| 370 |
{ |
| 371 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 372 |
struct ath12k_dp_rx_reo_cmd *cmd, *tmp; |
| 373 |
struct ath12k_dp_rx_reo_cache_flush_elem *cmd_cache, *tmp_cache; |
| 374 |
struct dp_reo_update_rx_queue_elem *cmd_queue, *tmp_queue; |
| 375 |
|
| 376 |
spin_lock_bh(&dp->reo_rxq_flush_lock); |
| 377 |
list_for_each_entry_safe(cmd_queue, tmp_queue, &dp->reo_cmd_update_rx_queue_list, |
| 378 |
list) { |
| 379 |
list_del(&cmd_queue->list); |
| 380 |
ath12k_dp_rx_tid_cleanup(ab, &cmd_queue->rx_tid.qbuf); |
| 381 |
kfree(cmd_queue); |
| 382 |
} |
| 383 |
list_for_each_entry_safe(cmd_cache, tmp_cache, |
| 384 |
&dp->reo_cmd_cache_flush_list, list) { |
| 385 |
list_del(&cmd_cache->list); |
| 386 |
dp->reo_cmd_cache_flush_count--; |
| 387 |
ath12k_dp_rx_tid_cleanup(ab, &cmd_cache->data.qbuf); |
| 388 |
kfree(cmd_cache); |
| 389 |
} |
| 390 |
spin_unlock_bh(&dp->reo_rxq_flush_lock); |
| 391 |
|
| 392 |
spin_lock_bh(&dp->reo_cmd_lock); |
| 393 |
list_for_each_entry_safe(cmd, tmp, &dp->reo_cmd_list, list) { |
| 394 |
list_del(&cmd->list); |
| 395 |
ath12k_dp_rx_tid_cleanup(ab, &cmd->data.qbuf); |
| 396 |
kfree(cmd); |
| 397 |
} |
| 398 |
spin_unlock_bh(&dp->reo_cmd_lock); |
| 399 |
} |
| 400 |
|
| 401 |
void ath12k_dp_reo_cmd_free(struct ath12k_dp *dp, void *ctx, |
| 402 |
enum hal_reo_cmd_status status) |
| 403 |
{ |
| 404 |
struct ath12k_dp_rx_tid_rxq *rx_tid = ctx; |
| 405 |
|
| 406 |
if (status != HAL_REO_CMD_SUCCESS) |
| 407 |
ath12k_warn(dp->ab, "failed to flush rx tid hw desc, tid %d status %d\n", |
| 408 |
rx_tid->tid, status); |
| 409 |
|
| 410 |
ath12k_dp_rx_tid_cleanup(dp->ab, &rx_tid->qbuf); |
| 411 |
} |
| 412 |
EXPORT_SYMBOL(ath12k_dp_reo_cmd_free); |
| 413 |
|
| 414 |
void ath12k_dp_rx_process_reo_cmd_update_rx_queue_list(struct ath12k_dp *dp) |
| 415 |
{ |
| 416 |
struct ath12k_base *ab = dp->ab; |
| 417 |
struct dp_reo_update_rx_queue_elem *elem, *tmp; |
| 418 |
|
| 419 |
spin_lock_bh(&dp->reo_rxq_flush_lock); |
| 420 |
|
| 421 |
list_for_each_entry_safe(elem, tmp, &dp->reo_cmd_update_rx_queue_list, list) { |
| 422 |
if (elem->rx_tid.active) |
| 423 |
continue; |
| 424 |
|
| 425 |
if (ath12k_dp_rx_tid_delete_handler(ab, &elem->rx_tid)) |
| 426 |
break; |
| 427 |
|
| 428 |
ath12k_dp_arch_peer_rx_tid_qref_reset(dp, |
| 429 |
elem->is_ml_peer ? |
| 430 |
elem->ml_peer_id : elem->peer_id, |
| 431 |
elem->rx_tid.tid); |
| 432 |
|
| 433 |
if (ab->hw_params->reoq_lut_support) |
| 434 |
ath12k_hal_reo_shared_qaddr_cache_clear(ab); |
| 435 |
|
| 436 |
list_del(&elem->list); |
| 437 |
kfree(elem); |
| 438 |
} |
| 439 |
|
| 440 |
spin_unlock_bh(&dp->reo_rxq_flush_lock); |
| 441 |
} |
| 442 |
EXPORT_SYMBOL(ath12k_dp_rx_process_reo_cmd_update_rx_queue_list); |
| 443 |
|
| 444 |
void ath12k_dp_rx_tid_del_func(struct ath12k_dp *dp, void *ctx, |
| 445 |
enum hal_reo_cmd_status status) |
| 446 |
{ |
| 447 |
struct ath12k_base *ab = dp->ab; |
| 448 |
struct ath12k_dp_rx_tid_rxq *rx_tid = ctx; |
| 449 |
struct ath12k_dp_rx_reo_cache_flush_elem *elem, *tmp; |
| 450 |
|
| 451 |
if (status == HAL_REO_CMD_DRAIN) { |
| 452 |
goto free_desc; |
| 453 |
} else if (status != HAL_REO_CMD_SUCCESS) { |
| 454 |
/* Shouldn't happen! Cleanup in case of other failure? */ |
| 455 |
ath12k_warn(ab, "failed to delete rx tid %d hw descriptor %d\n", |
| 456 |
rx_tid->tid, status); |
| 457 |
return; |
| 458 |
} |
| 459 |
|
| 460 |
/* Retry the HAL_REO_CMD_UPDATE_RX_QUEUE command for entries |
| 461 |
* in the pending queue list marked TID as inactive |
| 462 |
*/ |
| 463 |
spin_lock_bh(&dp->dp_lock); |
| 464 |
ath12k_dp_rx_process_reo_cmd_update_rx_queue_list(dp); |
| 465 |
spin_unlock_bh(&dp->dp_lock); |
| 466 |
|
| 467 |
elem = kzalloc_obj(*elem, GFP_ATOMIC); |
| 468 |
if (!elem) |
| 469 |
goto free_desc; |
| 470 |
|
| 471 |
elem->ts = jiffies; |
| 472 |
memcpy(&elem->data, rx_tid, sizeof(*rx_tid)); |
| 473 |
|
| 474 |
spin_lock_bh(&dp->reo_rxq_flush_lock); |
| 475 |
list_add_tail(&elem->list, &dp->reo_cmd_cache_flush_list); |
| 476 |
dp->reo_cmd_cache_flush_count++; |
| 477 |
|
| 478 |
/* Flush and invalidate aged REO desc from HW cache */ |
| 479 |
list_for_each_entry_safe(elem, tmp, &dp->reo_cmd_cache_flush_list, |
| 480 |
list) { |
| 481 |
if (dp->reo_cmd_cache_flush_count > ATH12K_DP_RX_REO_DESC_FREE_THRES || |
| 482 |
time_after(jiffies, elem->ts + |
| 483 |
msecs_to_jiffies(ATH12K_DP_RX_REO_DESC_FREE_TIMEOUT_MS))) { |
| 484 |
/* The reo_cmd_cache_flush_list is used in only two contexts, |
| 485 |
* one is in this function called from napi and the |
| 486 |
* other in ath12k_dp_free during core destroy. |
| 487 |
* If cache command sent is success, delete the element in |
| 488 |
* the cache list. ath12k_dp_rx_reo_cmd_list_cleanup |
| 489 |
* will be called during core destroy. |
| 490 |
*/ |
| 491 |
|
| 492 |
if (ath12k_dp_arch_reo_cache_flush(dp, &elem->data)) |
| 493 |
break; |
| 494 |
|
| 495 |
list_del(&elem->list); |
| 496 |
dp->reo_cmd_cache_flush_count--; |
| 497 |
|
| 498 |
kfree(elem); |
| 499 |
} |
| 500 |
} |
| 501 |
spin_unlock_bh(&dp->reo_rxq_flush_lock); |
| 502 |
|
| 503 |
return; |
| 504 |
free_desc: |
| 505 |
ath12k_dp_rx_tid_cleanup(ab, &rx_tid->qbuf); |
| 506 |
} |
| 507 |
EXPORT_SYMBOL(ath12k_dp_rx_tid_del_func); |
| 508 |
|
| 509 |
static int ath12k_dp_rx_tid_delete_handler(struct ath12k_base *ab, |
| 510 |
struct ath12k_dp_rx_tid_rxq *rx_tid) |
| 511 |
{ |
| 512 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 513 |
|
| 514 |
return ath12k_dp_arch_rx_tid_delete_handler(dp, rx_tid); |
| 515 |
} |
| 516 |
|
| 517 |
void ath12k_dp_mark_tid_as_inactive(struct ath12k_dp *dp, int peer_id, u8 tid) |
| 518 |
{ |
| 519 |
struct dp_reo_update_rx_queue_elem *elem; |
| 520 |
struct ath12k_dp_rx_tid_rxq *rx_tid; |
| 521 |
|
| 522 |
spin_lock_bh(&dp->reo_rxq_flush_lock); |
| 523 |
list_for_each_entry(elem, &dp->reo_cmd_update_rx_queue_list, list) { |
| 524 |
if (elem->peer_id == peer_id) { |
| 525 |
rx_tid = &elem->rx_tid; |
| 526 |
if (rx_tid->tid == tid) { |
| 527 |
rx_tid->active = false; |
| 528 |
break; |
| 529 |
} |
| 530 |
} |
| 531 |
} |
| 532 |
spin_unlock_bh(&dp->reo_rxq_flush_lock); |
| 533 |
} |
| 534 |
EXPORT_SYMBOL(ath12k_dp_mark_tid_as_inactive); |
| 535 |
|
| 536 |
void ath12k_dp_rx_peer_tid_cleanup(struct ath12k *ar, struct ath12k_dp_link_peer *peer) |
| 537 |
{ |
| 538 |
struct ath12k_dp_rx_tid *rx_tid; |
| 539 |
int i; |
| 540 |
struct ath12k_base *ab = ar->ab; |
| 541 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 542 |
|
| 543 |
lockdep_assert_held(&dp->dp_lock); |
| 544 |
|
| 545 |
if (!peer->primary_link) |
| 546 |
return; |
| 547 |
|
| 548 |
for (i = 0; i <= IEEE80211_NUM_TIDS; i++) { |
| 549 |
rx_tid = &peer->dp_peer->rx_tid[i]; |
| 550 |
|
| 551 |
ath12k_dp_arch_rx_peer_tid_delete(dp, peer, i); |
| 552 |
ath12k_dp_arch_rx_frags_cleanup(dp, rx_tid, true); |
| 553 |
|
| 554 |
spin_unlock_bh(&dp->dp_lock); |
| 555 |
timer_delete_sync(&rx_tid->frag_timer); |
| 556 |
spin_lock_bh(&dp->dp_lock); |
| 557 |
} |
| 558 |
} |
| 559 |
|
| 560 |
static int ath12k_dp_prepare_reo_update_elem(struct ath12k_dp *dp, |
| 561 |
struct ath12k_dp_link_peer *peer, |
| 562 |
struct ath12k_dp_rx_tid *rx_tid) |
| 563 |
{ |
| 564 |
struct dp_reo_update_rx_queue_elem *elem; |
| 565 |
|
| 566 |
lockdep_assert_held(&dp->dp_lock); |
| 567 |
|
| 568 |
elem = kzalloc_obj(*elem, GFP_ATOMIC); |
| 569 |
if (!elem) |
| 570 |
return -ENOMEM; |
| 571 |
|
| 572 |
elem->peer_id = peer->peer_id; |
| 573 |
elem->is_ml_peer = peer->mlo; |
| 574 |
elem->ml_peer_id = peer->ml_id; |
| 575 |
|
| 576 |
ath12k_dp_init_rx_tid_rxq(&elem->rx_tid, rx_tid, |
| 577 |
(peer->rx_tid_active_bitmask & (1 << rx_tid->tid))); |
| 578 |
|
| 579 |
spin_lock_bh(&dp->reo_rxq_flush_lock); |
| 580 |
list_add_tail(&elem->list, &dp->reo_cmd_update_rx_queue_list); |
| 581 |
spin_unlock_bh(&dp->reo_rxq_flush_lock); |
| 582 |
|
| 583 |
return 0; |
| 584 |
} |
| 585 |
|
| 586 |
int ath12k_dp_rx_peer_tid_setup(struct ath12k *ar, const u8 *peer_mac, int vdev_id, |
| 587 |
u8 tid, u32 ba_win_sz, u16 ssn, |
| 588 |
enum hal_pn_type pn_type) |
| 589 |
{ |
| 590 |
struct ath12k_base *ab = ar->ab; |
| 591 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 592 |
struct ath12k_dp_link_peer *peer; |
| 593 |
struct ath12k_dp_rx_tid *rx_tid; |
| 594 |
dma_addr_t paddr_aligned; |
| 595 |
int ret; |
| 596 |
|
| 597 |
spin_lock_bh(&dp->dp_lock); |
| 598 |
|
| 599 |
peer = ath12k_dp_link_peer_find_by_vdev_and_addr(dp, vdev_id, peer_mac); |
| 600 |
if (!peer || !peer->dp_peer) { |
| 601 |
spin_unlock_bh(&dp->dp_lock); |
| 602 |
ath12k_warn(ab, "failed to find the peer to set up rx tid\n"); |
| 603 |
return -ENOENT; |
| 604 |
} |
| 605 |
|
| 606 |
if (ab->hw_params->dp_primary_link_only && |
| 607 |
!peer->primary_link) { |
| 608 |
spin_unlock_bh(&dp->dp_lock); |
| 609 |
return 0; |
| 610 |
} |
| 611 |
|
| 612 |
if (ab->hw_params->reoq_lut_support && |
| 613 |
(!dp->reoq_lut.vaddr || !dp->ml_reoq_lut.vaddr)) { |
| 614 |
spin_unlock_bh(&dp->dp_lock); |
| 615 |
ath12k_warn(ab, "reo qref table is not setup\n"); |
| 616 |
return -EINVAL; |
| 617 |
} |
| 618 |
|
| 619 |
if (peer->peer_id > DP_MAX_PEER_ID || tid > IEEE80211_NUM_TIDS) { |
| 620 |
ath12k_warn(ab, "peer id of peer %d or tid %d doesn't allow reoq setup\n", |
| 621 |
peer->peer_id, tid); |
| 622 |
spin_unlock_bh(&dp->dp_lock); |
| 623 |
return -EINVAL; |
| 624 |
} |
| 625 |
|
| 626 |
rx_tid = &peer->dp_peer->rx_tid[tid]; |
| 627 |
/* Update the tid queue if it is already setup */ |
| 628 |
if (peer->rx_tid_active_bitmask & (1 << tid)) { |
| 629 |
ret = ath12k_dp_arch_peer_rx_tid_reo_update(dp, peer, rx_tid, |
| 630 |
ba_win_sz, ssn, true); |
| 631 |
spin_unlock_bh(&dp->dp_lock); |
| 632 |
if (ret) { |
| 633 |
ath12k_warn(ab, "failed to update reo for rx tid %d\n", tid); |
| 634 |
return ret; |
| 635 |
} |
| 636 |
|
| 637 |
if (!ab->hw_params->reoq_lut_support) { |
| 638 |
paddr_aligned = rx_tid->qbuf.paddr_aligned; |
| 639 |
ret = ath12k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id, |
| 640 |
peer_mac, |
| 641 |
paddr_aligned, tid, |
| 642 |
1, ba_win_sz); |
| 643 |
if (ret) { |
| 644 |
ath12k_warn(ab, "failed to setup peer rx reorder queuefor tid %d: %d\n", |
| 645 |
tid, ret); |
| 646 |
return ret; |
| 647 |
} |
| 648 |
} |
| 649 |
|
| 650 |
return 0; |
| 651 |
} |
| 652 |
|
| 653 |
rx_tid->tid = tid; |
| 654 |
|
| 655 |
rx_tid->ba_win_sz = ba_win_sz; |
| 656 |
|
| 657 |
ret = ath12k_dp_arch_rx_assign_reoq(dp, peer->dp_peer, rx_tid, ssn, pn_type); |
| 658 |
if (ret) { |
| 659 |
spin_unlock_bh(&dp->dp_lock); |
| 660 |
ath12k_warn(ab, "failed to assign reoq buf for rx tid %u\n", tid); |
| 661 |
return ret; |
| 662 |
} |
| 663 |
|
| 664 |
peer->rx_tid_active_bitmask |= (1 << tid); |
| 665 |
|
| 666 |
/* Pre-allocate the update_rxq_list for the corresponding tid |
| 667 |
* This will be used during the tid delete. The reason we are not |
| 668 |
* allocating during tid delete is that, if any alloc fail in update_rxq_list |
| 669 |
* we may not be able to delete the tid vaddr/paddr and may lead to leak |
| 670 |
*/ |
| 671 |
ret = ath12k_dp_prepare_reo_update_elem(dp, peer, rx_tid); |
| 672 |
if (ret) { |
| 673 |
ath12k_warn(ab, "failed to alloc update_rxq_list for rx tid %u\n", tid); |
| 674 |
ath12k_dp_rx_tid_cleanup(ab, &rx_tid->qbuf); |
| 675 |
spin_unlock_bh(&dp->dp_lock); |
| 676 |
return ret; |
| 677 |
} |
| 678 |
|
| 679 |
paddr_aligned = rx_tid->qbuf.paddr_aligned; |
| 680 |
if (ab->hw_params->reoq_lut_support) { |
| 681 |
/* Update the REO queue LUT at the corresponding peer id |
| 682 |
* and tid with qaddr. |
| 683 |
*/ |
| 684 |
if (peer->mlo) |
| 685 |
ath12k_dp_arch_peer_rx_tid_qref_setup(dp, peer->ml_id, tid, |
| 686 |
paddr_aligned); |
| 687 |
else |
| 688 |
ath12k_dp_arch_peer_rx_tid_qref_setup(dp, peer->peer_id, tid, |
| 689 |
paddr_aligned); |
| 690 |
|
| 691 |
spin_unlock_bh(&dp->dp_lock); |
| 692 |
} else { |
| 693 |
spin_unlock_bh(&dp->dp_lock); |
| 694 |
ret = ath12k_wmi_peer_rx_reorder_queue_setup(ar, vdev_id, peer_mac, |
| 695 |
paddr_aligned, tid, 1, |
| 696 |
ba_win_sz); |
| 697 |
} |
| 698 |
|
| 699 |
return ret; |
| 700 |
} |
| 701 |
|
| 702 |
int ath12k_dp_rx_ampdu_start(struct ath12k *ar, |
| 703 |
struct ieee80211_ampdu_params *params, |
| 704 |
u8 link_id) |
| 705 |
{ |
| 706 |
struct ath12k_base *ab = ar->ab; |
| 707 |
struct ath12k_sta *ahsta = ath12k_sta_to_ahsta(params->sta); |
| 708 |
struct ath12k_link_sta *arsta; |
| 709 |
int vdev_id; |
| 710 |
int ret; |
| 711 |
|
| 712 |
lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); |
| 713 |
|
| 714 |
arsta = wiphy_dereference(ath12k_ar_to_hw(ar)->wiphy, |
| 715 |
ahsta->link[link_id]); |
| 716 |
if (!arsta) |
| 717 |
return -ENOLINK; |
| 718 |
|
| 719 |
vdev_id = arsta->arvif->vdev_id; |
| 720 |
|
| 721 |
ret = ath12k_dp_rx_peer_tid_setup(ar, arsta->addr, vdev_id, |
| 722 |
params->tid, params->buf_size, |
| 723 |
params->ssn, arsta->ahsta->pn_type); |
| 724 |
if (ret) |
| 725 |
ath12k_warn(ab, "failed to setup rx tid %d\n", ret); |
| 726 |
|
| 727 |
return ret; |
| 728 |
} |
| 729 |
|
| 730 |
int ath12k_dp_rx_ampdu_stop(struct ath12k *ar, |
| 731 |
struct ieee80211_ampdu_params *params, |
| 732 |
u8 link_id) |
| 733 |
{ |
| 734 |
struct ath12k_base *ab = ar->ab; |
| 735 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 736 |
struct ath12k_dp_link_peer *peer; |
| 737 |
struct ath12k_sta *ahsta = ath12k_sta_to_ahsta(params->sta); |
| 738 |
struct ath12k_dp_rx_tid *rx_tid; |
| 739 |
struct ath12k_link_sta *arsta; |
| 740 |
int vdev_id; |
| 741 |
bool active; |
| 742 |
int ret; |
| 743 |
|
| 744 |
lockdep_assert_wiphy(ath12k_ar_to_hw(ar)->wiphy); |
| 745 |
|
| 746 |
arsta = wiphy_dereference(ath12k_ar_to_hw(ar)->wiphy, |
| 747 |
ahsta->link[link_id]); |
| 748 |
if (!arsta) |
| 749 |
return -ENOLINK; |
| 750 |
|
| 751 |
vdev_id = arsta->arvif->vdev_id; |
| 752 |
|
| 753 |
spin_lock_bh(&dp->dp_lock); |
| 754 |
|
| 755 |
peer = ath12k_dp_link_peer_find_by_vdev_and_addr(dp, vdev_id, arsta->addr); |
| 756 |
if (!peer || !peer->dp_peer) { |
| 757 |
spin_unlock_bh(&dp->dp_lock); |
| 758 |
ath12k_warn(ab, "failed to find the peer to stop rx aggregation\n"); |
| 759 |
return -ENOENT; |
| 760 |
} |
| 761 |
|
| 762 |
if (ab->hw_params->dp_primary_link_only && |
| 763 |
!peer->primary_link) { |
| 764 |
spin_unlock_bh(&dp->dp_lock); |
| 765 |
return 0; |
| 766 |
} |
| 767 |
|
| 768 |
active = peer->rx_tid_active_bitmask & (1 << params->tid); |
| 769 |
if (!active) { |
| 770 |
spin_unlock_bh(&dp->dp_lock); |
| 771 |
return 0; |
| 772 |
} |
| 773 |
|
| 774 |
rx_tid = &peer->dp_peer->rx_tid[params->tid]; |
| 775 |
ret = ath12k_dp_arch_peer_rx_tid_reo_update(dp, peer, rx_tid, |
| 776 |
1, 0, false); |
| 777 |
spin_unlock_bh(&dp->dp_lock); |
| 778 |
if (ret) { |
| 779 |
ath12k_warn(ab, "failed to update reo for rx tid %d: %d\n", |
| 780 |
params->tid, ret); |
| 781 |
return ret; |
| 782 |
} |
| 783 |
|
| 784 |
return ret; |
| 785 |
} |
| 786 |
|
| 787 |
int ath12k_dp_rx_peer_pn_replay_config(struct ath12k_link_vif *arvif, |
| 788 |
const u8 *peer_addr, |
| 789 |
enum set_key_cmd key_cmd, |
| 790 |
struct ieee80211_key_conf *key) |
| 791 |
{ |
| 792 |
struct ath12k *ar = arvif->ar; |
| 793 |
struct ath12k_base *ab = ar->ab; |
| 794 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 795 |
struct ath12k_hal_reo_cmd cmd = {}; |
| 796 |
struct ath12k_dp_link_peer *peer; |
| 797 |
struct ath12k_dp_rx_tid *rx_tid; |
| 798 |
struct ath12k_dp_rx_tid_rxq rx_tid_rxq; |
| 799 |
u8 tid; |
| 800 |
int ret = 0; |
| 801 |
|
| 802 |
/* NOTE: Enable PN/TSC replay check offload only for unicast frames. |
| 803 |
* We use mac80211 PN/TSC replay check functionality for bcast/mcast |
| 804 |
* for now. |
| 805 |
*/ |
| 806 |
if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) |
| 807 |
return 0; |
| 808 |
|
| 809 |
spin_lock_bh(&dp->dp_lock); |
| 810 |
|
| 811 |
peer = ath12k_dp_link_peer_find_by_vdev_and_addr(dp, arvif->vdev_id, |
| 812 |
peer_addr); |
| 813 |
if (!peer || !peer->dp_peer) { |
| 814 |
spin_unlock_bh(&dp->dp_lock); |
| 815 |
ath12k_warn(ab, "failed to find the peer %pM to configure pn replay detection\n", |
| 816 |
peer_addr); |
| 817 |
return -ENOENT; |
| 818 |
} |
| 819 |
|
| 820 |
for (tid = 0; tid <= IEEE80211_NUM_TIDS; tid++) { |
| 821 |
if (!(peer->rx_tid_active_bitmask & (1 << tid))) |
| 822 |
continue; |
| 823 |
|
| 824 |
rx_tid = &peer->dp_peer->rx_tid[tid]; |
| 825 |
ath12k_dp_init_rx_tid_rxq(&rx_tid_rxq, rx_tid, |
| 826 |
(peer->rx_tid_active_bitmask & (1 << tid))); |
| 827 |
ath12k_dp_arch_setup_pn_check_reo_cmd(dp, &cmd, rx_tid, key->cipher, |
| 828 |
key_cmd); |
| 829 |
ret = ath12k_dp_arch_reo_cmd_send(dp, &rx_tid_rxq, |
| 830 |
HAL_REO_CMD_UPDATE_RX_QUEUE, |
| 831 |
&cmd, NULL); |
| 832 |
if (ret) { |
| 833 |
ath12k_warn(ab, "failed to configure rx tid %d queue of peer %pM for pn replay detection %d\n", |
| 834 |
tid, peer_addr, ret); |
| 835 |
break; |
| 836 |
} |
| 837 |
} |
| 838 |
|
| 839 |
spin_unlock_bh(&dp->dp_lock); |
| 840 |
|
| 841 |
return ret; |
| 842 |
} |
| 843 |
EXPORT_SYMBOL(ath12k_dp_rx_get_msdu_last_buf); |
| 844 |
|
| 845 |
struct sk_buff *ath12k_dp_rx_get_msdu_last_buf(struct sk_buff_head *msdu_list, |
| 846 |
struct sk_buff *first) |
| 847 |
{ |
| 848 |
struct sk_buff *skb; |
| 849 |
struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(first); |
| 850 |
|
| 851 |
if (!rxcb->is_continuation) |
| 852 |
return first; |
| 853 |
|
| 854 |
skb_queue_walk(msdu_list, skb) { |
| 855 |
rxcb = ATH12K_SKB_RXCB(skb); |
| 856 |
if (!rxcb->is_continuation) |
| 857 |
return skb; |
| 858 |
} |
| 859 |
|
| 860 |
return NULL; |
| 861 |
} |
| 862 |
|
| 863 |
int ath12k_dp_rx_crypto_mic_len(struct ath12k_dp *dp, enum hal_encrypt_type enctype) |
| 864 |
{ |
| 865 |
switch (enctype) { |
| 866 |
case HAL_ENCRYPT_TYPE_OPEN: |
| 867 |
case HAL_ENCRYPT_TYPE_TKIP_NO_MIC: |
| 868 |
case HAL_ENCRYPT_TYPE_TKIP_MIC: |
| 869 |
return 0; |
| 870 |
case HAL_ENCRYPT_TYPE_CCMP_128: |
| 871 |
return IEEE80211_CCMP_MIC_LEN; |
| 872 |
case HAL_ENCRYPT_TYPE_CCMP_256: |
| 873 |
return IEEE80211_CCMP_256_MIC_LEN; |
| 874 |
case HAL_ENCRYPT_TYPE_GCMP_128: |
| 875 |
case HAL_ENCRYPT_TYPE_AES_GCMP_256: |
| 876 |
return IEEE80211_GCMP_MIC_LEN; |
| 877 |
case HAL_ENCRYPT_TYPE_WEP_40: |
| 878 |
case HAL_ENCRYPT_TYPE_WEP_104: |
| 879 |
case HAL_ENCRYPT_TYPE_WEP_128: |
| 880 |
case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4: |
| 881 |
case HAL_ENCRYPT_TYPE_WAPI: |
| 882 |
break; |
| 883 |
} |
| 884 |
|
| 885 |
ath12k_warn(dp->ab, "unsupported encryption type %d for mic len\n", enctype); |
| 886 |
return 0; |
| 887 |
} |
| 888 |
|
| 889 |
static int ath12k_dp_rx_crypto_param_len(struct ath12k_pdev_dp *dp_pdev, |
| 890 |
enum hal_encrypt_type enctype) |
| 891 |
{ |
| 892 |
switch (enctype) { |
| 893 |
case HAL_ENCRYPT_TYPE_OPEN: |
| 894 |
return 0; |
| 895 |
case HAL_ENCRYPT_TYPE_TKIP_NO_MIC: |
| 896 |
case HAL_ENCRYPT_TYPE_TKIP_MIC: |
| 897 |
return IEEE80211_TKIP_IV_LEN; |
| 898 |
case HAL_ENCRYPT_TYPE_CCMP_128: |
| 899 |
return IEEE80211_CCMP_HDR_LEN; |
| 900 |
case HAL_ENCRYPT_TYPE_CCMP_256: |
| 901 |
return IEEE80211_CCMP_256_HDR_LEN; |
| 902 |
case HAL_ENCRYPT_TYPE_GCMP_128: |
| 903 |
case HAL_ENCRYPT_TYPE_AES_GCMP_256: |
| 904 |
return IEEE80211_GCMP_HDR_LEN; |
| 905 |
case HAL_ENCRYPT_TYPE_WEP_40: |
| 906 |
case HAL_ENCRYPT_TYPE_WEP_104: |
| 907 |
case HAL_ENCRYPT_TYPE_WEP_128: |
| 908 |
case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4: |
| 909 |
case HAL_ENCRYPT_TYPE_WAPI: |
| 910 |
break; |
| 911 |
} |
| 912 |
|
| 913 |
ath12k_warn(dp_pdev->dp->ab, "unsupported encryption type %d\n", enctype); |
| 914 |
return 0; |
| 915 |
} |
| 916 |
|
| 917 |
static int ath12k_dp_rx_crypto_icv_len(struct ath12k_pdev_dp *dp_pdev, |
| 918 |
enum hal_encrypt_type enctype) |
| 919 |
{ |
| 920 |
switch (enctype) { |
| 921 |
case HAL_ENCRYPT_TYPE_OPEN: |
| 922 |
case HAL_ENCRYPT_TYPE_CCMP_128: |
| 923 |
case HAL_ENCRYPT_TYPE_CCMP_256: |
| 924 |
case HAL_ENCRYPT_TYPE_GCMP_128: |
| 925 |
case HAL_ENCRYPT_TYPE_AES_GCMP_256: |
| 926 |
return 0; |
| 927 |
case HAL_ENCRYPT_TYPE_TKIP_NO_MIC: |
| 928 |
case HAL_ENCRYPT_TYPE_TKIP_MIC: |
| 929 |
return IEEE80211_TKIP_ICV_LEN; |
| 930 |
case HAL_ENCRYPT_TYPE_WEP_40: |
| 931 |
case HAL_ENCRYPT_TYPE_WEP_104: |
| 932 |
case HAL_ENCRYPT_TYPE_WEP_128: |
| 933 |
case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4: |
| 934 |
case HAL_ENCRYPT_TYPE_WAPI: |
| 935 |
break; |
| 936 |
} |
| 937 |
|
| 938 |
ath12k_warn(dp_pdev->dp->ab, "unsupported encryption type %d\n", enctype); |
| 939 |
return 0; |
| 940 |
} |
| 941 |
|
| 942 |
static void ath12k_dp_rx_h_undecap_nwifi(struct ath12k_pdev_dp *dp_pdev, |
| 943 |
struct sk_buff *msdu, |
| 944 |
enum hal_encrypt_type enctype, |
| 945 |
struct hal_rx_desc_data *rx_info) |
| 946 |
{ |
| 947 |
struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu); |
| 948 |
u8 decap_hdr[DP_MAX_NWIFI_HDR_LEN]; |
| 949 |
struct ieee80211_hdr *hdr; |
| 950 |
size_t hdr_len; |
| 951 |
u8 *crypto_hdr; |
| 952 |
u16 qos_ctl; |
| 953 |
|
| 954 |
/* pull decapped header */ |
| 955 |
hdr = (struct ieee80211_hdr *)msdu->data; |
| 956 |
hdr_len = ieee80211_hdrlen(hdr->frame_control); |
| 957 |
skb_pull(msdu, hdr_len); |
| 958 |
|
| 959 |
/* Rebuild qos header */ |
| 960 |
hdr->frame_control |= __cpu_to_le16(IEEE80211_STYPE_QOS_DATA); |
| 961 |
|
| 962 |
/* Reset the order bit as the HT_Control header is stripped */ |
| 963 |
hdr->frame_control &= ~(__cpu_to_le16(IEEE80211_FCTL_ORDER)); |
| 964 |
|
| 965 |
qos_ctl = rxcb->tid; |
| 966 |
|
| 967 |
if (rx_info->mesh_ctrl_present) |
| 968 |
qos_ctl |= IEEE80211_QOS_CTL_MESH_CONTROL_PRESENT; |
| 969 |
|
| 970 |
/* TODO: Add other QoS ctl fields when required */ |
| 971 |
|
| 972 |
/* copy decap header before overwriting for reuse below */ |
| 973 |
memcpy(decap_hdr, hdr, hdr_len); |
| 974 |
|
| 975 |
/* Rebuild crypto header for mac80211 use */ |
| 976 |
if (!(rx_info->rx_status->flag & RX_FLAG_IV_STRIPPED)) { |
| 977 |
crypto_hdr = skb_push(msdu, |
| 978 |
ath12k_dp_rx_crypto_param_len(dp_pdev, enctype)); |
| 979 |
ath12k_dp_rx_desc_get_crypto_header(dp_pdev->dp->hal, |
| 980 |
rxcb->rx_desc, crypto_hdr, |
| 981 |
enctype); |
| 982 |
} |
| 983 |
|
| 984 |
memcpy(skb_push(msdu, |
| 985 |
IEEE80211_QOS_CTL_LEN), &qos_ctl, |
| 986 |
IEEE80211_QOS_CTL_LEN); |
| 987 |
memcpy(skb_push(msdu, hdr_len), decap_hdr, hdr_len); |
| 988 |
} |
| 989 |
|
| 990 |
static void ath12k_dp_rx_h_undecap_raw(struct ath12k_pdev_dp *dp_pdev, |
| 991 |
struct sk_buff *msdu, |
| 992 |
enum hal_encrypt_type enctype, |
| 993 |
struct ieee80211_rx_status *status, |
| 994 |
bool decrypted) |
| 995 |
{ |
| 996 |
struct ath12k_dp *dp = dp_pdev->dp; |
| 997 |
struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu); |
| 998 |
struct ieee80211_hdr *hdr; |
| 999 |
size_t hdr_len; |
| 1000 |
size_t crypto_len; |
| 1001 |
|
| 1002 |
if (!rxcb->is_first_msdu || |
| 1003 |
!(rxcb->is_first_msdu && rxcb->is_last_msdu)) { |
| 1004 |
WARN_ON_ONCE(1); |
| 1005 |
return; |
| 1006 |
} |
| 1007 |
|
| 1008 |
skb_trim(msdu, msdu->len - FCS_LEN); |
| 1009 |
|
| 1010 |
if (!decrypted) |
| 1011 |
return; |
| 1012 |
|
| 1013 |
hdr = (void *)msdu->data; |
| 1014 |
|
| 1015 |
/* Tail */ |
| 1016 |
if (status->flag & RX_FLAG_IV_STRIPPED) { |
| 1017 |
skb_trim(msdu, msdu->len - |
| 1018 |
ath12k_dp_rx_crypto_mic_len(dp, enctype)); |
| 1019 |
|
| 1020 |
skb_trim(msdu, msdu->len - |
| 1021 |
ath12k_dp_rx_crypto_icv_len(dp_pdev, enctype)); |
| 1022 |
} else { |
| 1023 |
/* MIC */ |
| 1024 |
if (status->flag & RX_FLAG_MIC_STRIPPED) |
| 1025 |
skb_trim(msdu, msdu->len - |
| 1026 |
ath12k_dp_rx_crypto_mic_len(dp, enctype)); |
| 1027 |
|
| 1028 |
/* ICV */ |
| 1029 |
if (status->flag & RX_FLAG_ICV_STRIPPED) |
| 1030 |
skb_trim(msdu, msdu->len - |
| 1031 |
ath12k_dp_rx_crypto_icv_len(dp_pdev, enctype)); |
| 1032 |
} |
| 1033 |
|
| 1034 |
/* MMIC */ |
| 1035 |
if ((status->flag & RX_FLAG_MMIC_STRIPPED) && |
| 1036 |
!ieee80211_has_morefrags(hdr->frame_control) && |
| 1037 |
enctype == HAL_ENCRYPT_TYPE_TKIP_MIC) |
| 1038 |
skb_trim(msdu, msdu->len - IEEE80211_CCMP_MIC_LEN); |
| 1039 |
|
| 1040 |
/* Head */ |
| 1041 |
if (status->flag & RX_FLAG_IV_STRIPPED) { |
| 1042 |
hdr_len = ieee80211_hdrlen(hdr->frame_control); |
| 1043 |
crypto_len = ath12k_dp_rx_crypto_param_len(dp_pdev, enctype); |
| 1044 |
|
| 1045 |
memmove(msdu->data + crypto_len, msdu->data, hdr_len); |
| 1046 |
skb_pull(msdu, crypto_len); |
| 1047 |
} |
| 1048 |
} |
| 1049 |
|
| 1050 |
static void ath12k_get_dot11_hdr_from_rx_desc(struct ath12k_pdev_dp *dp_pdev, |
| 1051 |
struct sk_buff *msdu, |
| 1052 |
struct ath12k_skb_rxcb *rxcb, |
| 1053 |
enum hal_encrypt_type enctype, |
| 1054 |
struct hal_rx_desc_data *rx_info) |
| 1055 |
{ |
| 1056 |
struct hal_rx_desc *rx_desc = rxcb->rx_desc; |
| 1057 |
struct ath12k_dp *dp = dp_pdev->dp; |
| 1058 |
struct ath12k_hal *hal = dp->hal; |
| 1059 |
size_t hdr_len, crypto_len; |
| 1060 |
struct ieee80211_hdr hdr; |
| 1061 |
__le16 qos_ctl; |
| 1062 |
u8 *crypto_hdr; |
| 1063 |
|
| 1064 |
ath12k_dp_rx_desc_get_dot11_hdr(hal, rx_desc, &hdr); |
| 1065 |
hdr_len = ieee80211_hdrlen(hdr.frame_control); |
| 1066 |
|
| 1067 |
if (!(rx_info->rx_status->flag & RX_FLAG_IV_STRIPPED)) { |
| 1068 |
crypto_len = ath12k_dp_rx_crypto_param_len(dp_pdev, enctype); |
| 1069 |
crypto_hdr = skb_push(msdu, crypto_len); |
| 1070 |
ath12k_dp_rx_desc_get_crypto_header(dp->hal, rx_desc, crypto_hdr, |
| 1071 |
enctype); |
| 1072 |
} |
| 1073 |
|
| 1074 |
skb_push(msdu, hdr_len); |
| 1075 |
memcpy(msdu->data, &hdr, min(hdr_len, sizeof(hdr))); |
| 1076 |
|
| 1077 |
if (rxcb->is_mcbc) |
| 1078 |
rx_info->rx_status->flag &= ~RX_FLAG_PN_VALIDATED; |
| 1079 |
|
| 1080 |
/* Add QOS header */ |
| 1081 |
if (ieee80211_is_data_qos(hdr.frame_control)) { |
| 1082 |
struct ieee80211_hdr *qos_ptr = (struct ieee80211_hdr *)msdu->data; |
| 1083 |
|
| 1084 |
qos_ctl = cpu_to_le16(rxcb->tid & IEEE80211_QOS_CTL_TID_MASK); |
| 1085 |
if (rx_info->mesh_ctrl_present) |
| 1086 |
qos_ctl |= cpu_to_le16(IEEE80211_QOS_CTL_MESH_CONTROL_PRESENT); |
| 1087 |
|
| 1088 |
memcpy(ieee80211_get_qos_ctl(qos_ptr), &qos_ctl, IEEE80211_QOS_CTL_LEN); |
| 1089 |
} |
| 1090 |
} |
| 1091 |
|
| 1092 |
static void ath12k_dp_rx_h_undecap_eth(struct ath12k_pdev_dp *dp_pdev, |
| 1093 |
struct sk_buff *msdu, |
| 1094 |
enum hal_encrypt_type enctype, |
| 1095 |
struct hal_rx_desc_data *rx_info) |
| 1096 |
{ |
| 1097 |
struct ieee80211_hdr *hdr; |
| 1098 |
struct ethhdr *eth; |
| 1099 |
u8 da[ETH_ALEN]; |
| 1100 |
u8 sa[ETH_ALEN]; |
| 1101 |
struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu); |
| 1102 |
struct ath12k_dp_rx_rfc1042_hdr rfc = {0xaa, 0xaa, 0x03, {0x00, 0x00, 0x00}}; |
| 1103 |
|
| 1104 |
eth = (struct ethhdr *)msdu->data; |
| 1105 |
ether_addr_copy(da, eth->h_dest); |
| 1106 |
ether_addr_copy(sa, eth->h_source); |
| 1107 |
rfc.snap_type = eth->h_proto; |
| 1108 |
skb_pull(msdu, sizeof(*eth)); |
| 1109 |
memcpy(skb_push(msdu, sizeof(rfc)), &rfc, |
| 1110 |
sizeof(rfc)); |
| 1111 |
ath12k_get_dot11_hdr_from_rx_desc(dp_pdev, msdu, rxcb, enctype, rx_info); |
| 1112 |
|
| 1113 |
/* original 802.11 header has a different DA and in |
| 1114 |
* case of 4addr it may also have different SA |
| 1115 |
*/ |
| 1116 |
hdr = (struct ieee80211_hdr *)msdu->data; |
| 1117 |
ether_addr_copy(ieee80211_get_DA(hdr), da); |
| 1118 |
ether_addr_copy(ieee80211_get_SA(hdr), sa); |
| 1119 |
} |
| 1120 |
|
| 1121 |
void ath12k_dp_rx_h_undecap(struct ath12k_pdev_dp *dp_pdev, struct sk_buff *msdu, |
| 1122 |
struct hal_rx_desc *rx_desc, |
| 1123 |
enum hal_encrypt_type enctype, |
| 1124 |
bool decrypted, |
| 1125 |
struct hal_rx_desc_data *rx_info) |
| 1126 |
{ |
| 1127 |
struct ethhdr *ehdr; |
| 1128 |
|
| 1129 |
switch (rx_info->decap_type) { |
| 1130 |
case DP_RX_DECAP_TYPE_NATIVE_WIFI: |
| 1131 |
ath12k_dp_rx_h_undecap_nwifi(dp_pdev, msdu, enctype, rx_info); |
| 1132 |
break; |
| 1133 |
case DP_RX_DECAP_TYPE_RAW: |
| 1134 |
ath12k_dp_rx_h_undecap_raw(dp_pdev, msdu, enctype, rx_info->rx_status, |
| 1135 |
decrypted); |
| 1136 |
break; |
| 1137 |
case DP_RX_DECAP_TYPE_ETHERNET2_DIX: |
| 1138 |
ehdr = (struct ethhdr *)msdu->data; |
| 1139 |
|
| 1140 |
/* mac80211 allows fast path only for authorized STA */ |
| 1141 |
if (ehdr->h_proto == cpu_to_be16(ETH_P_PAE)) { |
| 1142 |
ATH12K_SKB_RXCB(msdu)->is_eapol = true; |
| 1143 |
ath12k_dp_rx_h_undecap_eth(dp_pdev, msdu, enctype, rx_info); |
| 1144 |
break; |
| 1145 |
} |
| 1146 |
|
| 1147 |
/* PN for mcast packets will be validated in mac80211; |
| 1148 |
* remove eth header and add 802.11 header. |
| 1149 |
*/ |
| 1150 |
if (ATH12K_SKB_RXCB(msdu)->is_mcbc && decrypted) |
| 1151 |
ath12k_dp_rx_h_undecap_eth(dp_pdev, msdu, enctype, rx_info); |
| 1152 |
break; |
| 1153 |
case DP_RX_DECAP_TYPE_8023: |
| 1154 |
/* TODO: Handle undecap for these formats */ |
| 1155 |
break; |
| 1156 |
} |
| 1157 |
} |
| 1158 |
EXPORT_SYMBOL(ath12k_dp_rx_h_undecap); |
| 1159 |
|
| 1160 |
struct ath12k_dp_link_peer * |
| 1161 |
ath12k_dp_rx_h_find_link_peer(struct ath12k_pdev_dp *dp_pdev, struct sk_buff *msdu, |
| 1162 |
struct hal_rx_desc_data *rx_info) |
| 1163 |
{ |
| 1164 |
struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu); |
| 1165 |
struct ath12k_dp_link_peer *peer = NULL; |
| 1166 |
struct ath12k_dp *dp = dp_pdev->dp; |
| 1167 |
|
| 1168 |
lockdep_assert_held(&dp->dp_lock); |
| 1169 |
|
| 1170 |
if (rxcb->peer_id) |
| 1171 |
peer = ath12k_dp_link_peer_find_by_peerid(dp_pdev, rxcb->peer_id); |
| 1172 |
|
| 1173 |
if (peer) |
| 1174 |
return peer; |
| 1175 |
|
| 1176 |
if (rx_info->addr2_present) |
| 1177 |
peer = ath12k_dp_link_peer_find_by_addr(dp, rx_info->addr2); |
| 1178 |
|
| 1179 |
return peer; |
| 1180 |
} |
| 1181 |
|
| 1182 |
static void ath12k_dp_rx_h_rate(struct ath12k_pdev_dp *dp_pdev, |
| 1183 |
struct hal_rx_desc_data *rx_info) |
| 1184 |
{ |
| 1185 |
struct ath12k_dp *dp = dp_pdev->dp; |
| 1186 |
struct ieee80211_supported_band *sband; |
| 1187 |
struct ieee80211_rx_status *rx_status = rx_info->rx_status; |
| 1188 |
enum rx_msdu_start_pkt_type pkt_type = rx_info->pkt_type; |
| 1189 |
u8 bw = rx_info->bw, sgi = rx_info->sgi; |
| 1190 |
u8 rate_mcs = rx_info->rate_mcs, nss = rx_info->nss; |
| 1191 |
bool is_cck; |
| 1192 |
struct ath12k *ar; |
| 1193 |
|
| 1194 |
switch (pkt_type) { |
| 1195 |
case RX_MSDU_START_PKT_TYPE_11A: |
| 1196 |
case RX_MSDU_START_PKT_TYPE_11B: |
| 1197 |
ar = ath12k_pdev_dp_to_ar(dp_pdev); |
| 1198 |
is_cck = (pkt_type == RX_MSDU_START_PKT_TYPE_11B); |
| 1199 |
sband = &ar->mac.sbands[rx_status->band]; |
| 1200 |
rx_status->rate_idx = ath12k_mac_hw_rate_to_idx(sband, rate_mcs, |
| 1201 |
is_cck); |
| 1202 |
break; |
| 1203 |
case RX_MSDU_START_PKT_TYPE_11N: |
| 1204 |
rx_status->encoding = RX_ENC_HT; |
| 1205 |
if (rate_mcs > ATH12K_HT_MCS_MAX) { |
| 1206 |
ath12k_warn(dp->ab, |
| 1207 |
"Received with invalid mcs in HT mode %d\n", |
| 1208 |
rate_mcs); |
| 1209 |
break; |
| 1210 |
} |
| 1211 |
rx_status->rate_idx = rate_mcs + (8 * (nss - 1)); |
| 1212 |
if (sgi) |
| 1213 |
rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; |
| 1214 |
rx_status->bw = ath12k_mac_bw_to_mac80211_bw(bw); |
| 1215 |
break; |
| 1216 |
case RX_MSDU_START_PKT_TYPE_11AC: |
| 1217 |
rx_status->encoding = RX_ENC_VHT; |
| 1218 |
rx_status->rate_idx = rate_mcs; |
| 1219 |
if (rate_mcs > ATH12K_VHT_MCS_MAX) { |
| 1220 |
ath12k_warn(dp->ab, |
| 1221 |
"Received with invalid mcs in VHT mode %d\n", |
| 1222 |
rate_mcs); |
| 1223 |
break; |
| 1224 |
} |
| 1225 |
rx_status->nss = nss; |
| 1226 |
if (sgi) |
| 1227 |
rx_status->enc_flags |= RX_ENC_FLAG_SHORT_GI; |
| 1228 |
rx_status->bw = ath12k_mac_bw_to_mac80211_bw(bw); |
| 1229 |
break; |
| 1230 |
case RX_MSDU_START_PKT_TYPE_11AX: |
| 1231 |
rx_status->rate_idx = rate_mcs; |
| 1232 |
if (rate_mcs > ATH12K_HE_MCS_MAX) { |
| 1233 |
ath12k_warn(dp->ab, |
| 1234 |
"Received with invalid mcs in HE mode %d\n", |
| 1235 |
rate_mcs); |
| 1236 |
break; |
| 1237 |
} |
| 1238 |
rx_status->encoding = RX_ENC_HE; |
| 1239 |
rx_status->nss = nss; |
| 1240 |
rx_status->he_gi = ath12k_he_gi_to_nl80211_he_gi(sgi); |
| 1241 |
rx_status->bw = ath12k_mac_bw_to_mac80211_bw(bw); |
| 1242 |
break; |
| 1243 |
case RX_MSDU_START_PKT_TYPE_11BE: |
| 1244 |
rx_status->rate_idx = rate_mcs; |
| 1245 |
|
| 1246 |
if (rate_mcs > ATH12K_EHT_MCS_MAX) { |
| 1247 |
ath12k_warn(dp->ab, |
| 1248 |
"Received with invalid mcs in EHT mode %d\n", |
| 1249 |
rate_mcs); |
| 1250 |
break; |
| 1251 |
} |
| 1252 |
|
| 1253 |
rx_status->encoding = RX_ENC_EHT; |
| 1254 |
rx_status->nss = nss; |
| 1255 |
rx_status->eht.gi = ath12k_mac_eht_gi_to_nl80211_eht_gi(sgi); |
| 1256 |
rx_status->bw = ath12k_mac_bw_to_mac80211_bw(bw); |
| 1257 |
break; |
| 1258 |
default: |
| 1259 |
break; |
| 1260 |
} |
| 1261 |
} |
| 1262 |
|
| 1263 |
void ath12k_dp_rx_h_ppdu(struct ath12k_pdev_dp *dp_pdev, |
| 1264 |
struct hal_rx_desc_data *rx_info) |
| 1265 |
{ |
| 1266 |
struct ieee80211_rx_status *rx_status = rx_info->rx_status; |
| 1267 |
u8 channel_num; |
| 1268 |
u32 center_freq, meta_data; |
| 1269 |
struct ieee80211_channel *channel; |
| 1270 |
|
| 1271 |
rx_status->freq = 0; |
| 1272 |
rx_status->rate_idx = 0; |
| 1273 |
rx_status->nss = 0; |
| 1274 |
rx_status->encoding = RX_ENC_LEGACY; |
| 1275 |
rx_status->bw = RATE_INFO_BW_20; |
| 1276 |
rx_status->enc_flags = 0; |
| 1277 |
|
| 1278 |
rx_status->flag |= RX_FLAG_NO_SIGNAL_VAL; |
| 1279 |
|
| 1280 |
meta_data = rx_info->phy_meta_data; |
| 1281 |
channel_num = meta_data; |
| 1282 |
center_freq = meta_data >> 16; |
| 1283 |
|
| 1284 |
rx_status->band = NUM_NL80211_BANDS; |
| 1285 |
|
| 1286 |
if (center_freq >= ATH12K_MIN_6GHZ_FREQ && |
| 1287 |
center_freq <= ATH12K_MAX_6GHZ_FREQ) { |
| 1288 |
rx_status->band = NL80211_BAND_6GHZ; |
| 1289 |
rx_status->freq = center_freq; |
| 1290 |
} else if (channel_num >= 1 && channel_num <= 14) { |
| 1291 |
rx_status->band = NL80211_BAND_2GHZ; |
| 1292 |
} else if (channel_num >= 36 && channel_num <= 173) { |
| 1293 |
rx_status->band = NL80211_BAND_5GHZ; |
| 1294 |
} |
| 1295 |
|
| 1296 |
if (unlikely(rx_status->band == NUM_NL80211_BANDS || |
| 1297 |
!ath12k_pdev_dp_to_hw(dp_pdev)->wiphy->bands[rx_status->band])) { |
| 1298 |
struct ath12k *ar = ath12k_pdev_dp_to_ar(dp_pdev); |
| 1299 |
|
| 1300 |
ath12k_warn(ar->ab, "sband is NULL for status band %d channel_num %d center_freq %d pdev_id %d\n", |
| 1301 |
rx_status->band, channel_num, center_freq, ar->pdev_idx); |
| 1302 |
|
| 1303 |
spin_lock_bh(&ar->data_lock); |
| 1304 |
channel = ar->rx_channel; |
| 1305 |
if (channel) { |
| 1306 |
rx_status->band = channel->band; |
| 1307 |
channel_num = |
| 1308 |
ieee80211_frequency_to_channel(channel->center_freq); |
| 1309 |
rx_status->freq = ieee80211_channel_to_frequency(channel_num, |
| 1310 |
rx_status->band); |
| 1311 |
} else { |
| 1312 |
ath12k_err(ar->ab, "unable to determine channel, band for rx packet"); |
| 1313 |
} |
| 1314 |
spin_unlock_bh(&ar->data_lock); |
| 1315 |
goto h_rate; |
| 1316 |
} |
| 1317 |
|
| 1318 |
if (rx_status->band != NL80211_BAND_6GHZ) |
| 1319 |
rx_status->freq = ieee80211_channel_to_frequency(channel_num, |
| 1320 |
rx_status->band); |
| 1321 |
|
| 1322 |
h_rate: |
| 1323 |
ath12k_dp_rx_h_rate(dp_pdev, rx_info); |
| 1324 |
} |
| 1325 |
EXPORT_SYMBOL(ath12k_dp_rx_h_ppdu); |
| 1326 |
|
| 1327 |
void ath12k_dp_rx_deliver_msdu(struct ath12k_pdev_dp *dp_pdev, struct napi_struct *napi, |
| 1328 |
struct sk_buff *msdu, |
| 1329 |
struct hal_rx_desc_data *rx_info) |
| 1330 |
{ |
| 1331 |
struct ath12k_dp *dp = dp_pdev->dp; |
| 1332 |
struct ieee80211_rx_status *rx_status; |
| 1333 |
struct ieee80211_sta *pubsta; |
| 1334 |
struct ath12k_dp_peer *peer; |
| 1335 |
struct ath12k_skb_rxcb *rxcb = ATH12K_SKB_RXCB(msdu); |
| 1336 |
struct ieee80211_rx_status *status = rx_info->rx_status; |
| 1337 |
u8 decap = rx_info->decap_type; |
| 1338 |
bool is_mcbc = rxcb->is_mcbc; |
| 1339 |
bool is_eapol = rxcb->is_eapol; |
| 1340 |
|
| 1341 |
peer = ath12k_dp_peer_find_by_peerid(dp_pdev, rx_info->peer_id); |
| 1342 |
|
| 1343 |
pubsta = peer ? peer->sta : NULL; |
| 1344 |
|
| 1345 |
if (pubsta && pubsta->valid_links) { |
| 1346 |
status->link_valid = 1; |
| 1347 |
status->link_id = peer->hw_links[rxcb->hw_link_id]; |
| 1348 |
} |
| 1349 |
|
| 1350 |
ath12k_dbg(dp->ab, ATH12K_DBG_DATA, |
| 1351 |
"rx skb %p len %u peer %pM %d %s sn %u %s%s%s%s%s%s%s%s%s%s rate_idx %u vht_nss %u freq %u band %u flag 0x%x fcs-err %i mic-err %i amsdu-more %i\n", |
| 1352 |
msdu, |
| 1353 |
msdu->len, |
| 1354 |
peer ? peer->addr : NULL, |
| 1355 |
rxcb->tid, |
| 1356 |
is_mcbc ? "mcast" : "ucast", |
| 1357 |
rx_info->seq_no, |
| 1358 |
(status->encoding == RX_ENC_LEGACY) ? "legacy" : "", |
| 1359 |
(status->encoding == RX_ENC_HT) ? "ht" : "", |
| 1360 |
(status->encoding == RX_ENC_VHT) ? "vht" : "", |
| 1361 |
(status->encoding == RX_ENC_HE) ? "he" : "", |
| 1362 |
(status->encoding == RX_ENC_EHT) ? "eht" : "", |
| 1363 |
(status->bw == RATE_INFO_BW_40) ? "40" : "", |
| 1364 |
(status->bw == RATE_INFO_BW_80) ? "80" : "", |
| 1365 |
(status->bw == RATE_INFO_BW_160) ? "160" : "", |
| 1366 |
(status->bw == RATE_INFO_BW_320) ? "320" : "", |
| 1367 |
status->enc_flags & RX_ENC_FLAG_SHORT_GI ? "sgi " : "", |
| 1368 |
status->rate_idx, |
| 1369 |
status->nss, |
| 1370 |
status->freq, |
| 1371 |
status->band, status->flag, |
| 1372 |
!!(status->flag & RX_FLAG_FAILED_FCS_CRC), |
| 1373 |
!!(status->flag & RX_FLAG_MMIC_ERROR), |
| 1374 |
!!(status->flag & RX_FLAG_AMSDU_MORE)); |
| 1375 |
|
| 1376 |
ath12k_dbg_dump(dp->ab, ATH12K_DBG_DP_RX, NULL, "dp rx msdu: ", |
| 1377 |
msdu->data, msdu->len); |
| 1378 |
|
| 1379 |
rx_status = IEEE80211_SKB_RXCB(msdu); |
| 1380 |
*rx_status = *status; |
| 1381 |
|
| 1382 |
/* TODO: trace rx packet */ |
| 1383 |
|
| 1384 |
/* PN for multicast packets are not validate in HW, |
| 1385 |
* so skip 802.3 rx path |
| 1386 |
* Also, fast_rx expects the STA to be authorized, hence |
| 1387 |
* eapol packets are sent in slow path. |
| 1388 |
*/ |
| 1389 |
if (decap == DP_RX_DECAP_TYPE_ETHERNET2_DIX && !is_eapol && |
| 1390 |
!(is_mcbc && rx_status->flag & RX_FLAG_DECRYPTED)) |
| 1391 |
rx_status->flag |= RX_FLAG_8023; |
| 1392 |
|
| 1393 |
ieee80211_rx_napi(ath12k_pdev_dp_to_hw(dp_pdev), pubsta, msdu, napi); |
| 1394 |
} |
| 1395 |
EXPORT_SYMBOL(ath12k_dp_rx_deliver_msdu); |
| 1396 |
|
| 1397 |
bool ath12k_dp_rx_check_nwifi_hdr_len_valid(struct ath12k_dp *dp, |
| 1398 |
struct hal_rx_desc *rx_desc, |
| 1399 |
struct sk_buff *msdu, |
| 1400 |
struct hal_rx_desc_data *rx_info) |
| 1401 |
{ |
| 1402 |
struct ieee80211_hdr *hdr; |
| 1403 |
u32 hdr_len; |
| 1404 |
|
| 1405 |
if (rx_info->decap_type != DP_RX_DECAP_TYPE_NATIVE_WIFI) |
| 1406 |
return true; |
| 1407 |
|
| 1408 |
hdr = (struct ieee80211_hdr *)msdu->data; |
| 1409 |
hdr_len = ieee80211_hdrlen(hdr->frame_control); |
| 1410 |
|
| 1411 |
if ((likely(hdr_len <= DP_MAX_NWIFI_HDR_LEN))) |
| 1412 |
return true; |
| 1413 |
|
| 1414 |
dp->device_stats.invalid_rbm++; |
| 1415 |
WARN_ON_ONCE(1); |
| 1416 |
return false; |
| 1417 |
} |
| 1418 |
EXPORT_SYMBOL(ath12k_dp_rx_check_nwifi_hdr_len_valid); |
| 1419 |
|
| 1420 |
static void ath12k_dp_rx_frag_timer(struct timer_list *timer) |
| 1421 |
{ |
| 1422 |
struct ath12k_dp_rx_tid *rx_tid = timer_container_of(rx_tid, timer, |
| 1423 |
frag_timer); |
| 1424 |
|
| 1425 |
spin_lock_bh(&rx_tid->dp->dp_lock); |
| 1426 |
if (rx_tid->last_frag_no && |
| 1427 |
rx_tid->rx_frag_bitmap == GENMASK(rx_tid->last_frag_no, 0)) { |
| 1428 |
spin_unlock_bh(&rx_tid->dp->dp_lock); |
| 1429 |
return; |
| 1430 |
} |
| 1431 |
ath12k_dp_arch_rx_frags_cleanup(rx_tid->dp, rx_tid, true); |
| 1432 |
spin_unlock_bh(&rx_tid->dp->dp_lock); |
| 1433 |
} |
| 1434 |
|
| 1435 |
int ath12k_dp_rx_peer_frag_setup(struct ath12k *ar, const u8 *peer_mac, int vdev_id) |
| 1436 |
{ |
| 1437 |
struct ath12k_base *ab = ar->ab; |
| 1438 |
struct crypto_shash *tfm; |
| 1439 |
struct ath12k_dp_link_peer *peer; |
| 1440 |
struct ath12k_dp_rx_tid *rx_tid; |
| 1441 |
int i; |
| 1442 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 1443 |
|
| 1444 |
tfm = crypto_alloc_shash("michael_mic", 0, 0); |
| 1445 |
if (IS_ERR(tfm)) |
| 1446 |
return PTR_ERR(tfm); |
| 1447 |
|
| 1448 |
spin_lock_bh(&dp->dp_lock); |
| 1449 |
|
| 1450 |
peer = ath12k_dp_link_peer_find_by_vdev_and_addr(dp, vdev_id, peer_mac); |
| 1451 |
if (!peer || !peer->dp_peer) { |
| 1452 |
spin_unlock_bh(&dp->dp_lock); |
| 1453 |
crypto_free_shash(tfm); |
| 1454 |
ath12k_warn(ab, "failed to find the peer to set up fragment info\n"); |
| 1455 |
return -ENOENT; |
| 1456 |
} |
| 1457 |
|
| 1458 |
if (!peer->primary_link) { |
| 1459 |
spin_unlock_bh(&dp->dp_lock); |
| 1460 |
crypto_free_shash(tfm); |
| 1461 |
return 0; |
| 1462 |
} |
| 1463 |
|
| 1464 |
for (i = 0; i <= IEEE80211_NUM_TIDS; i++) { |
| 1465 |
rx_tid = &peer->dp_peer->rx_tid[i]; |
| 1466 |
rx_tid->dp = dp; |
| 1467 |
timer_setup(&rx_tid->frag_timer, ath12k_dp_rx_frag_timer, 0); |
| 1468 |
skb_queue_head_init(&rx_tid->rx_frags); |
| 1469 |
} |
| 1470 |
|
| 1471 |
peer->dp_peer->tfm_mmic = tfm; |
| 1472 |
peer->dp_peer->dp_setup_done = true; |
| 1473 |
spin_unlock_bh(&dp->dp_lock); |
| 1474 |
|
| 1475 |
return 0; |
| 1476 |
} |
| 1477 |
|
| 1478 |
int ath12k_dp_rx_h_michael_mic(struct crypto_shash *tfm, u8 *key, |
| 1479 |
struct ieee80211_hdr *hdr, u8 *data, |
| 1480 |
size_t data_len, u8 *mic) |
| 1481 |
{ |
| 1482 |
SHASH_DESC_ON_STACK(desc, tfm); |
| 1483 |
u8 mic_hdr[16] = {}; |
| 1484 |
u8 tid = 0; |
| 1485 |
int ret; |
| 1486 |
|
| 1487 |
if (!tfm) |
| 1488 |
return -EINVAL; |
| 1489 |
|
| 1490 |
desc->tfm = tfm; |
| 1491 |
|
| 1492 |
ret = crypto_shash_setkey(tfm, key, 8); |
| 1493 |
if (ret) |
| 1494 |
goto out; |
| 1495 |
|
| 1496 |
ret = crypto_shash_init(desc); |
| 1497 |
if (ret) |
| 1498 |
goto out; |
| 1499 |
|
| 1500 |
/* TKIP MIC header */ |
| 1501 |
memcpy(mic_hdr, ieee80211_get_DA(hdr), ETH_ALEN); |
| 1502 |
memcpy(mic_hdr + ETH_ALEN, ieee80211_get_SA(hdr), ETH_ALEN); |
| 1503 |
if (ieee80211_is_data_qos(hdr->frame_control)) |
| 1504 |
tid = ieee80211_get_tid(hdr); |
| 1505 |
mic_hdr[12] = tid; |
| 1506 |
|
| 1507 |
ret = crypto_shash_update(desc, mic_hdr, 16); |
| 1508 |
if (ret) |
| 1509 |
goto out; |
| 1510 |
ret = crypto_shash_update(desc, data, data_len); |
| 1511 |
if (ret) |
| 1512 |
goto out; |
| 1513 |
ret = crypto_shash_final(desc, mic); |
| 1514 |
out: |
| 1515 |
shash_desc_zero(desc); |
| 1516 |
return ret; |
| 1517 |
} |
| 1518 |
EXPORT_SYMBOL(ath12k_dp_rx_h_michael_mic); |
| 1519 |
|
| 1520 |
void ath12k_dp_rx_h_undecap_frag(struct ath12k_pdev_dp *dp_pdev, struct sk_buff *msdu, |
| 1521 |
enum hal_encrypt_type enctype, u32 flags) |
| 1522 |
{ |
| 1523 |
struct ath12k_dp *dp = dp_pdev->dp; |
| 1524 |
struct ieee80211_hdr *hdr; |
| 1525 |
size_t hdr_len; |
| 1526 |
size_t crypto_len; |
| 1527 |
u32 hal_rx_desc_sz = dp->ab->hal.hal_desc_sz; |
| 1528 |
|
| 1529 |
if (!flags) |
| 1530 |
return; |
| 1531 |
|
| 1532 |
hdr = (struct ieee80211_hdr *)(msdu->data + hal_rx_desc_sz); |
| 1533 |
|
| 1534 |
if (flags & RX_FLAG_MIC_STRIPPED) |
| 1535 |
skb_trim(msdu, msdu->len - |
| 1536 |
ath12k_dp_rx_crypto_mic_len(dp, enctype)); |
| 1537 |
|
| 1538 |
if (flags & RX_FLAG_ICV_STRIPPED) |
| 1539 |
skb_trim(msdu, msdu->len - |
| 1540 |
ath12k_dp_rx_crypto_icv_len(dp_pdev, enctype)); |
| 1541 |
|
| 1542 |
if (flags & RX_FLAG_IV_STRIPPED) { |
| 1543 |
hdr_len = ieee80211_hdrlen(hdr->frame_control); |
| 1544 |
crypto_len = ath12k_dp_rx_crypto_param_len(dp_pdev, enctype); |
| 1545 |
|
| 1546 |
memmove(msdu->data + hal_rx_desc_sz + crypto_len, |
| 1547 |
msdu->data + hal_rx_desc_sz, hdr_len); |
| 1548 |
skb_pull(msdu, crypto_len); |
| 1549 |
} |
| 1550 |
} |
| 1551 |
EXPORT_SYMBOL(ath12k_dp_rx_h_undecap_frag); |
| 1552 |
|
| 1553 |
static int ath12k_dp_rx_h_cmp_frags(struct ath12k_hal *hal, |
| 1554 |
struct sk_buff *a, struct sk_buff *b) |
| 1555 |
{ |
| 1556 |
int frag1, frag2; |
| 1557 |
|
| 1558 |
frag1 = ath12k_dp_rx_h_frag_no(hal, a); |
| 1559 |
frag2 = ath12k_dp_rx_h_frag_no(hal, b); |
| 1560 |
|
| 1561 |
return frag1 - frag2; |
| 1562 |
} |
| 1563 |
|
| 1564 |
void ath12k_dp_rx_h_sort_frags(struct ath12k_hal *hal, |
| 1565 |
struct sk_buff_head *frag_list, |
| 1566 |
struct sk_buff *cur_frag) |
| 1567 |
{ |
| 1568 |
struct sk_buff *skb; |
| 1569 |
int cmp; |
| 1570 |
|
| 1571 |
skb_queue_walk(frag_list, skb) { |
| 1572 |
cmp = ath12k_dp_rx_h_cmp_frags(hal, skb, cur_frag); |
| 1573 |
if (cmp < 0) |
| 1574 |
continue; |
| 1575 |
__skb_queue_before(frag_list, skb, cur_frag); |
| 1576 |
return; |
| 1577 |
} |
| 1578 |
__skb_queue_tail(frag_list, cur_frag); |
| 1579 |
} |
| 1580 |
EXPORT_SYMBOL(ath12k_dp_rx_h_sort_frags); |
| 1581 |
|
| 1582 |
u64 ath12k_dp_rx_h_get_pn(struct ath12k_dp *dp, struct sk_buff *skb) |
| 1583 |
{ |
| 1584 |
struct ieee80211_hdr *hdr; |
| 1585 |
u64 pn = 0; |
| 1586 |
u8 *ehdr; |
| 1587 |
u32 hal_rx_desc_sz = dp->ab->hal.hal_desc_sz; |
| 1588 |
|
| 1589 |
hdr = (struct ieee80211_hdr *)(skb->data + hal_rx_desc_sz); |
| 1590 |
ehdr = skb->data + hal_rx_desc_sz + ieee80211_hdrlen(hdr->frame_control); |
| 1591 |
|
| 1592 |
pn = ehdr[0]; |
| 1593 |
pn |= (u64)ehdr[1] << 8; |
| 1594 |
pn |= (u64)ehdr[4] << 16; |
| 1595 |
pn |= (u64)ehdr[5] << 24; |
| 1596 |
pn |= (u64)ehdr[6] << 32; |
| 1597 |
pn |= (u64)ehdr[7] << 40; |
| 1598 |
|
| 1599 |
return pn; |
| 1600 |
} |
| 1601 |
EXPORT_SYMBOL(ath12k_dp_rx_h_get_pn); |
| 1602 |
|
| 1603 |
void ath12k_dp_rx_free(struct ath12k_base *ab) |
| 1604 |
{ |
| 1605 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 1606 |
struct dp_srng *srng; |
| 1607 |
int i; |
| 1608 |
|
| 1609 |
ath12k_dp_srng_cleanup(ab, &dp->rx_refill_buf_ring.refill_buf_ring); |
| 1610 |
|
| 1611 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1612 |
if (ab->hw_params->rx_mac_buf_ring) |
| 1613 |
ath12k_dp_srng_cleanup(ab, &dp->rx_mac_buf_ring[i]); |
| 1614 |
if (!ab->hw_params->rxdma1_enable) { |
| 1615 |
srng = &dp->rx_mon_status_refill_ring[i].refill_buf_ring; |
| 1616 |
ath12k_dp_srng_cleanup(ab, srng); |
| 1617 |
} |
| 1618 |
} |
| 1619 |
|
| 1620 |
for (i = 0; i < ab->hw_params->num_rxdma_dst_ring; i++) |
| 1621 |
ath12k_dp_srng_cleanup(ab, &dp->rxdma_err_dst_ring[i]); |
| 1622 |
|
| 1623 |
ath12k_dp_srng_cleanup(ab, &dp->rxdma_mon_buf_ring.refill_buf_ring); |
| 1624 |
|
| 1625 |
ath12k_dp_rxdma_buf_free(ab); |
| 1626 |
} |
| 1627 |
|
| 1628 |
void ath12k_dp_rx_pdev_free(struct ath12k_base *ab, int mac_id) |
| 1629 |
{ |
| 1630 |
struct ath12k *ar = ab->pdevs[mac_id].ar; |
| 1631 |
|
| 1632 |
ath12k_dp_rx_pdev_srng_free(ar); |
| 1633 |
} |
| 1634 |
|
| 1635 |
int ath12k_dp_rx_htt_setup(struct ath12k_base *ab) |
| 1636 |
{ |
| 1637 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 1638 |
u32 ring_id; |
| 1639 |
int i, ret; |
| 1640 |
|
| 1641 |
/* TODO: Need to verify the HTT setup for QCN9224 */ |
| 1642 |
ring_id = dp->rx_refill_buf_ring.refill_buf_ring.ring_id; |
| 1643 |
ret = ath12k_dp_tx_htt_srng_setup(ab, ring_id, 0, HAL_RXDMA_BUF); |
| 1644 |
if (ret) { |
| 1645 |
ath12k_warn(ab, "failed to configure rx_refill_buf_ring %d\n", |
| 1646 |
ret); |
| 1647 |
return ret; |
| 1648 |
} |
| 1649 |
|
| 1650 |
if (ab->hw_params->rx_mac_buf_ring) { |
| 1651 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1652 |
ring_id = dp->rx_mac_buf_ring[i].ring_id; |
| 1653 |
ret = ath12k_dp_tx_htt_srng_setup(ab, ring_id, |
| 1654 |
i, HAL_RXDMA_BUF); |
| 1655 |
if (ret) { |
| 1656 |
ath12k_warn(ab, "failed to configure rx_mac_buf_ring%d %d\n", |
| 1657 |
i, ret); |
| 1658 |
return ret; |
| 1659 |
} |
| 1660 |
} |
| 1661 |
} |
| 1662 |
|
| 1663 |
for (i = 0; i < ab->hw_params->num_rxdma_dst_ring; i++) { |
| 1664 |
ring_id = dp->rxdma_err_dst_ring[i].ring_id; |
| 1665 |
ret = ath12k_dp_tx_htt_srng_setup(ab, ring_id, |
| 1666 |
i, HAL_RXDMA_DST); |
| 1667 |
if (ret) { |
| 1668 |
ath12k_warn(ab, "failed to configure rxdma_err_dest_ring%d %d\n", |
| 1669 |
i, ret); |
| 1670 |
return ret; |
| 1671 |
} |
| 1672 |
} |
| 1673 |
|
| 1674 |
if (ab->hw_params->rxdma1_enable) { |
| 1675 |
ring_id = dp->rxdma_mon_buf_ring.refill_buf_ring.ring_id; |
| 1676 |
ret = ath12k_dp_tx_htt_srng_setup(ab, ring_id, |
| 1677 |
0, HAL_RXDMA_MONITOR_BUF); |
| 1678 |
if (ret) { |
| 1679 |
ath12k_warn(ab, "failed to configure rxdma_mon_buf_ring %d\n", |
| 1680 |
ret); |
| 1681 |
return ret; |
| 1682 |
} |
| 1683 |
} else { |
| 1684 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1685 |
ring_id = |
| 1686 |
dp->rx_mon_status_refill_ring[i].refill_buf_ring.ring_id; |
| 1687 |
ret = ath12k_dp_tx_htt_srng_setup(ab, ring_id, i, |
| 1688 |
HAL_RXDMA_MONITOR_STATUS); |
| 1689 |
if (ret) { |
| 1690 |
ath12k_warn(ab, |
| 1691 |
"failed to configure mon_status_refill_ring%d %d\n", |
| 1692 |
i, ret); |
| 1693 |
return ret; |
| 1694 |
} |
| 1695 |
} |
| 1696 |
} |
| 1697 |
|
| 1698 |
ret = ab->hw_params->hw_ops->rxdma_ring_sel_config(ab); |
| 1699 |
if (ret) { |
| 1700 |
ath12k_warn(ab, "failed to setup rxdma ring selection config\n"); |
| 1701 |
return ret; |
| 1702 |
} |
| 1703 |
|
| 1704 |
return 0; |
| 1705 |
} |
| 1706 |
|
| 1707 |
int ath12k_dp_rx_alloc(struct ath12k_base *ab) |
| 1708 |
{ |
| 1709 |
struct ath12k_dp *dp = ath12k_ab_to_dp(ab); |
| 1710 |
struct dp_srng *srng; |
| 1711 |
int i, ret; |
| 1712 |
|
| 1713 |
idr_init(&dp->rxdma_mon_buf_ring.bufs_idr); |
| 1714 |
spin_lock_init(&dp->rxdma_mon_buf_ring.idr_lock); |
| 1715 |
|
| 1716 |
ret = ath12k_dp_srng_setup(ab, |
| 1717 |
&dp->rx_refill_buf_ring.refill_buf_ring, |
| 1718 |
HAL_RXDMA_BUF, 0, 0, |
| 1719 |
DP_RXDMA_BUF_RING_SIZE); |
| 1720 |
if (ret) { |
| 1721 |
ath12k_warn(ab, "failed to setup rx_refill_buf_ring\n"); |
| 1722 |
return ret; |
| 1723 |
} |
| 1724 |
|
| 1725 |
if (ab->hw_params->rx_mac_buf_ring) { |
| 1726 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1727 |
ret = ath12k_dp_srng_setup(ab, |
| 1728 |
&dp->rx_mac_buf_ring[i], |
| 1729 |
HAL_RXDMA_BUF, 1, |
| 1730 |
i, DP_RX_MAC_BUF_RING_SIZE); |
| 1731 |
if (ret) { |
| 1732 |
ath12k_warn(ab, "failed to setup rx_mac_buf_ring %d\n", |
| 1733 |
i); |
| 1734 |
return ret; |
| 1735 |
} |
| 1736 |
} |
| 1737 |
} |
| 1738 |
|
| 1739 |
for (i = 0; i < ab->hw_params->num_rxdma_dst_ring; i++) { |
| 1740 |
ret = ath12k_dp_srng_setup(ab, &dp->rxdma_err_dst_ring[i], |
| 1741 |
HAL_RXDMA_DST, 0, i, |
| 1742 |
DP_RXDMA_ERR_DST_RING_SIZE); |
| 1743 |
if (ret) { |
| 1744 |
ath12k_warn(ab, "failed to setup rxdma_err_dst_ring %d\n", i); |
| 1745 |
return ret; |
| 1746 |
} |
| 1747 |
} |
| 1748 |
|
| 1749 |
if (ab->hw_params->rxdma1_enable) { |
| 1750 |
ret = ath12k_dp_srng_setup(ab, |
| 1751 |
&dp->rxdma_mon_buf_ring.refill_buf_ring, |
| 1752 |
HAL_RXDMA_MONITOR_BUF, 0, 0, |
| 1753 |
DP_RXDMA_MONITOR_BUF_RING_SIZE(ab)); |
| 1754 |
if (ret) { |
| 1755 |
ath12k_warn(ab, "failed to setup HAL_RXDMA_MONITOR_BUF\n"); |
| 1756 |
return ret; |
| 1757 |
} |
| 1758 |
} else { |
| 1759 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1760 |
idr_init(&dp->rx_mon_status_refill_ring[i].bufs_idr); |
| 1761 |
spin_lock_init(&dp->rx_mon_status_refill_ring[i].idr_lock); |
| 1762 |
} |
| 1763 |
|
| 1764 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1765 |
srng = &dp->rx_mon_status_refill_ring[i].refill_buf_ring; |
| 1766 |
ret = ath12k_dp_srng_setup(ab, srng, |
| 1767 |
HAL_RXDMA_MONITOR_STATUS, 0, i, |
| 1768 |
DP_RXDMA_MON_STATUS_RING_SIZE); |
| 1769 |
if (ret) { |
| 1770 |
ath12k_warn(ab, "failed to setup mon status ring %d\n", |
| 1771 |
i); |
| 1772 |
return ret; |
| 1773 |
} |
| 1774 |
} |
| 1775 |
} |
| 1776 |
|
| 1777 |
ret = ath12k_dp_rxdma_buf_setup(ab); |
| 1778 |
if (ret) { |
| 1779 |
ath12k_warn(ab, "failed to setup rxdma ring\n"); |
| 1780 |
return ret; |
| 1781 |
} |
| 1782 |
|
| 1783 |
return 0; |
| 1784 |
} |
| 1785 |
|
| 1786 |
int ath12k_dp_rx_pdev_alloc(struct ath12k_base *ab, int mac_id) |
| 1787 |
{ |
| 1788 |
struct ath12k *ar = ab->pdevs[mac_id].ar; |
| 1789 |
struct ath12k_pdev_dp *dp = &ar->dp; |
| 1790 |
u32 ring_id; |
| 1791 |
int i; |
| 1792 |
int ret; |
| 1793 |
|
| 1794 |
if (!ab->hw_params->rxdma1_enable) |
| 1795 |
goto out; |
| 1796 |
|
| 1797 |
ret = ath12k_dp_rx_pdev_srng_alloc(ar); |
| 1798 |
if (ret) { |
| 1799 |
ath12k_warn(ab, "failed to setup rx srngs\n"); |
| 1800 |
return ret; |
| 1801 |
} |
| 1802 |
|
| 1803 |
for (i = 0; i < ab->hw_params->num_rxdma_per_pdev; i++) { |
| 1804 |
ring_id = dp->rxdma_mon_dst_ring[i].ring_id; |
| 1805 |
ret = ath12k_dp_tx_htt_srng_setup(ab, ring_id, |
| 1806 |
mac_id + i, |
| 1807 |
HAL_RXDMA_MONITOR_DST); |
| 1808 |
if (ret) { |
| 1809 |
ath12k_warn(ab, |
| 1810 |
"failed to configure rxdma_mon_dst_ring %d %d\n", |
| 1811 |
i, ret); |
| 1812 |
return ret; |
| 1813 |
} |
| 1814 |
} |
| 1815 |
out: |
| 1816 |
return 0; |
| 1817 |
} |
| 1818 |
|
| 1819 |
static int ath12k_dp_rx_pdev_mon_status_attach(struct ath12k *ar) |
| 1820 |
{ |
| 1821 |
struct ath12k_pdev_dp *dp = &ar->dp; |
| 1822 |
struct ath12k_mon_data *pmon = (struct ath12k_mon_data *)&dp->mon_data; |
| 1823 |
|
| 1824 |
skb_queue_head_init(&pmon->rx_status_q); |
| 1825 |
|
| 1826 |
pmon->mon_ppdu_status = DP_PPDU_STATUS_START; |
| 1827 |
|
| 1828 |
memset(&pmon->rx_mon_stats, 0, |
| 1829 |
sizeof(pmon->rx_mon_stats)); |
| 1830 |
return 0; |
| 1831 |
} |
| 1832 |
|
| 1833 |
int ath12k_dp_rx_pdev_mon_attach(struct ath12k *ar) |
| 1834 |
{ |
| 1835 |
struct ath12k_pdev_dp *dp = &ar->dp; |
| 1836 |
struct ath12k_mon_data *pmon = &dp->mon_data; |
| 1837 |
int ret = 0; |
| 1838 |
|
| 1839 |
ret = ath12k_dp_rx_pdev_mon_status_attach(ar); |
| 1840 |
if (ret) { |
| 1841 |
ath12k_warn(ar->ab, "pdev_mon_status_attach() failed"); |
| 1842 |
return ret; |
| 1843 |
} |
| 1844 |
|
| 1845 |
pmon->mon_last_linkdesc_paddr = 0; |
| 1846 |
pmon->mon_last_buf_cookie = DP_RX_DESC_COOKIE_MAX + 1; |
| 1847 |
spin_lock_init(&pmon->mon_lock); |
| 1848 |
|
| 1849 |
if (!ar->ab->hw_params->rxdma1_enable) |
| 1850 |
return 0; |
| 1851 |
|
| 1852 |
INIT_LIST_HEAD(&pmon->dp_rx_mon_mpdu_list); |
| 1853 |
pmon->mon_mpdu = NULL; |
| 1854 |
|
| 1855 |
return 0; |
| 1856 |
} |