1 /* 2 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 /** 18 * DOC: osif_dp_txrx.c 19 * This file contains DP component's TX/RX osif API implementation 20 */ 21 #include "os_if_dp.h" 22 #include "os_if_dp_lro.h" 23 #include <wlan_dp_public_struct.h> 24 #include <wlan_objmgr_vdev_obj.h> 25 #include "osif_sync.h" 26 #include <linux/netdevice.h> 27 #include <linux/skbuff.h> 28 #include <linux/etherdevice.h> 29 #include <linux/if_ether.h> 30 #include <linux/inetdevice.h> 31 #include <linux/wireless.h> 32 #include <linux/rtnetlink.h> 33 #include <net/cfg80211.h> 34 #include <cdp_txrx_cmn.h> 35 #include <cdp_txrx_peer_ops.h> 36 #include <cdp_txrx_misc.h> 37 #include <net/tcp.h> 38 #include <ol_defines.h> 39 #include <hif_napi.h> 40 #include <hif.h> 41 #include <wlan_hdd_main.h> 42 #include "wlan_hdd_wmm.h" 43 44 /** 45 * osif_dp_classify_pkt() - classify packet 46 * @skb: sk buff 47 * 48 * Return: none 49 */ osif_dp_classify_pkt(struct sk_buff * skb)50 void osif_dp_classify_pkt(struct sk_buff *skb) 51 { 52 struct ethhdr *eh = (struct ethhdr *)skb->data; 53 54 qdf_mem_zero(skb->cb, sizeof(skb->cb)); 55 56 /* check destination mac address is broadcast/multicast */ 57 if (is_broadcast_ether_addr((uint8_t *)eh)) 58 QDF_NBUF_CB_GET_IS_BCAST(skb) = true; 59 else if (is_multicast_ether_addr((uint8_t *)eh)) 60 QDF_NBUF_CB_GET_IS_MCAST(skb) = true; 61 62 if (qdf_nbuf_is_ipv4_arp_pkt(skb)) 63 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 64 QDF_NBUF_CB_PACKET_TYPE_ARP; 65 else if (qdf_nbuf_is_ipv4_dhcp_pkt(skb)) 66 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 67 QDF_NBUF_CB_PACKET_TYPE_DHCP; 68 else if (qdf_nbuf_is_ipv4_eapol_pkt(skb)) 69 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 70 QDF_NBUF_CB_PACKET_TYPE_EAPOL; 71 else if (qdf_nbuf_is_ipv4_wapi_pkt(skb)) 72 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 73 QDF_NBUF_CB_PACKET_TYPE_WAPI; 74 else if (qdf_nbuf_is_icmp_pkt(skb)) 75 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 76 QDF_NBUF_CB_PACKET_TYPE_ICMP; 77 else if (qdf_nbuf_is_icmpv6_pkt(skb)) 78 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 79 QDF_NBUF_CB_PACKET_TYPE_ICMPv6; 80 } 81 82 /** 83 * osif_dp_mark_critical_pkt() - Identify and mark critical packets 84 * @skb: skb ptr 85 * 86 * Return: None 87 */ osif_dp_mark_critical_pkt(struct sk_buff * skb)88 static void osif_dp_mark_critical_pkt(struct sk_buff *skb) 89 { 90 if (qdf_nbuf_is_ipv4_eapol_pkt(skb)) { 91 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 92 QDF_NBUF_CB_PACKET_TYPE_EAPOL; 93 } else if (qdf_nbuf_is_ipv4_arp_pkt(skb)) { 94 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 95 QDF_NBUF_CB_PACKET_TYPE_ARP; 96 } else if (qdf_nbuf_is_ipv4_dhcp_pkt(skb)) { 97 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 98 QDF_NBUF_CB_PACKET_TYPE_DHCP; 99 } else if (qdf_nbuf_is_ipv6_dhcp_pkt(skb)) { 100 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 101 QDF_NBUF_CB_PACKET_TYPE_DHCPV6; 102 } else if (qdf_nbuf_is_icmpv6_pkt(skb)) { 103 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 104 QDF_NBUF_CB_PACKET_TYPE_ICMPv6; 105 } 106 107 QDF_NBUF_CB_TX_EXTRA_IS_CRITICAL(skb) = true; 108 } 109 110 #ifdef DP_TX_PACKET_INSPECT_FOR_ILP 111 /** 112 * osif_dp_mark_pkt_type_by_priority() - mark packet type to skb->cb 113 * by type from priority of skb 114 * @skb: network buffer 115 * 116 * Return: true - packet type marked, false - not marked 117 */ 118 static inline osif_dp_mark_pkt_type_by_priority(struct sk_buff * skb)119 bool osif_dp_mark_pkt_type_by_priority(struct sk_buff *skb) 120 { 121 bool type_marked = false; 122 uint32_t pkt_type = 123 qdf_nbuf_get_priority_pkt_type(skb); 124 125 if (qdf_unlikely(pkt_type == QDF_NBUF_PRIORITY_PKT_TCP_ACK)) { 126 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 127 QDF_NBUF_CB_PACKET_TYPE_TCP_ACK; 128 type_marked = true; 129 } 130 /* cleanup the packet type in priority */ 131 qdf_nbuf_remove_priority_pkt_type(skb); 132 133 return type_marked; 134 } 135 #else 136 static inline osif_dp_mark_pkt_type_by_priority(struct sk_buff * skb)137 bool osif_dp_mark_pkt_type_by_priority(struct sk_buff *skb) 138 { 139 return false; 140 } 141 #endif 142 143 /** 144 * osif_dp_mark_non_critical_pkt() - Identify and mark non-critical packets 145 * @skb: skb ptr 146 * 147 * Return: None 148 */ osif_dp_mark_non_critical_pkt(struct sk_buff * skb)149 static void osif_dp_mark_non_critical_pkt(struct sk_buff *skb) 150 { 151 /* check if packet type is marked from skb->priority already */ 152 if (osif_dp_mark_pkt_type_by_priority(skb)) 153 return; 154 155 if (qdf_nbuf_is_icmp_pkt(skb)) 156 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 157 QDF_NBUF_CB_PACKET_TYPE_ICMP; 158 else if (qdf_nbuf_is_ipv4_wapi_pkt(skb)) 159 QDF_NBUF_CB_GET_PACKET_TYPE(skb) = 160 QDF_NBUF_CB_PACKET_TYPE_WAPI; 161 } 162 osif_dp_mark_pkt_type(struct sk_buff * skb)163 void osif_dp_mark_pkt_type(struct sk_buff *skb) 164 { 165 struct ethhdr *eh = (struct ethhdr *)skb->data; 166 167 /* 168 * Zero out CB before accessing it. Expectation is that cb is accessed 169 * for the first time here on TX path in hard_start_xmit. 170 */ 171 qdf_mem_zero(skb->cb, sizeof(skb->cb)); 172 173 /* check destination mac address is broadcast/multicast */ 174 if (is_broadcast_ether_addr((uint8_t *)eh)) 175 QDF_NBUF_CB_GET_IS_BCAST(skb) = true; 176 else if (is_multicast_ether_addr((uint8_t *)eh)) 177 QDF_NBUF_CB_GET_IS_MCAST(skb) = true; 178 179 /* 180 * TX Packets in the HI_PRIO queue are assumed to be critical and 181 * marked accordingly. 182 */ 183 if (skb->queue_mapping == TX_GET_QUEUE_IDX(HDD_LINUX_AC_HI_PRIO, 0)) 184 osif_dp_mark_critical_pkt(skb); 185 else 186 osif_dp_mark_non_critical_pkt(skb); 187 } 188 189 /* 190 * When bus bandwidth is idle, if RX data is delivered with 191 * napi_gro_receive, to reduce RX delay related with GRO, 192 * check gro_result returned from napi_gro_receive to determine 193 * is extra GRO flush still necessary. 194 */ 195 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)) 196 #define DP_IS_EXTRA_GRO_FLUSH_NECESSARY(_gro_ret) true 197 #define GRO_DROP_UPDATE_STATUS(gro_ret, status) 198 #else 199 #define GRO_DROP_UPDATE_STATUS(gro_ret, status) \ 200 if ((gro_ret) == GRO_DROP) ((status) = QDF_STATUS_E_GRO_DROP) 201 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0)) 202 #define DP_IS_EXTRA_GRO_FLUSH_NECESSARY(_gro_ret) \ 203 ((_gro_ret) != GRO_DROP) 204 #else 205 #define DP_IS_EXTRA_GRO_FLUSH_NECESSARY(_gro_ret) \ 206 ((_gro_ret) != GRO_DROP && (_gro_ret) != GRO_NORMAL) 207 #endif 208 #endif 209 210 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0)) 211 /** 212 * osif_dp_rx_thread_napi_gro_flush() - do gro flush 213 * @napi: napi used to do gro flush 214 * @flush_code: flush_code differentiating low_tput_flush and normal_flush 215 * 216 * if there is RX GRO_NORMAL packets pending in napi 217 * rx_list, flush them manually right after napi_gro_flush. 218 * 219 * Return: none 220 */ 221 static inline osif_dp_rx_thread_napi_gro_flush(struct napi_struct * napi,enum dp_rx_gro_flush_code flush_code)222 void osif_dp_rx_thread_napi_gro_flush(struct napi_struct *napi, 223 enum dp_rx_gro_flush_code flush_code) 224 { 225 if (napi->poll) { 226 /* Skipping GRO flush in low TPUT */ 227 if (flush_code != DP_RX_GRO_LOW_TPUT_FLUSH) 228 napi_gro_flush(napi, false); 229 230 if (napi->rx_count) { 231 netif_receive_skb_list(&napi->rx_list); 232 qdf_init_list_head(&napi->rx_list); 233 napi->rx_count = 0; 234 } 235 } 236 } 237 #else 238 static inline osif_dp_rx_thread_napi_gro_flush(struct napi_struct * napi,enum dp_rx_gro_flush_code flush_code)239 void osif_dp_rx_thread_napi_gro_flush(struct napi_struct *napi, 240 enum dp_rx_gro_flush_code flush_code) 241 { 242 if (napi->poll) { 243 /* Skipping GRO flush in low TPUT */ 244 if (flush_code != DP_RX_GRO_LOW_TPUT_FLUSH) 245 napi_gro_flush(napi, false); 246 } 247 } 248 #endif 249 250 /** 251 * osif_dp_rx_napi_gro_flush() - GRO RX/flush function. 252 * @napi_to_use: napi to be used to give packets to the stack, gro flush 253 * @nbuf: pointer to n/w buff 254 * @low_tput_force_flush: Is force flush required in low tput 255 * 256 * Function calls napi_gro_receive for the skb. If the skb indicates that a 257 * flush needs to be done (set by the lower DP layer), the function also calls 258 * napi_gro_flush. Local softirqs are disabled (and later enabled) while making 259 * napi_gro__ calls. 260 * 261 * Return: QDF_STATUS_SUCCESS if not dropped by napi_gro_receive or 262 * QDF error code. 263 */ 264 265 static QDF_STATUS osif_dp_rx_napi_gro_flush(qdf_napi_struct * napi_to_use,qdf_nbuf_t nbuf,uint8_t * low_tput_force_flush)266 osif_dp_rx_napi_gro_flush(qdf_napi_struct *napi_to_use, 267 qdf_nbuf_t nbuf, 268 uint8_t *low_tput_force_flush) 269 { 270 QDF_STATUS status = QDF_STATUS_SUCCESS; 271 gro_result_t gro_ret; 272 273 skb_set_hash(nbuf, QDF_NBUF_CB_RX_FLOW_ID(nbuf), PKT_HASH_TYPE_L4); 274 275 local_bh_disable(); 276 gro_ret = napi_gro_receive((struct napi_struct *)napi_to_use, nbuf); 277 278 if (DP_IS_EXTRA_GRO_FLUSH_NECESSARY(gro_ret)) { 279 *low_tput_force_flush = 1; 280 osif_dp_rx_thread_napi_gro_flush((struct napi_struct *)napi_to_use, 281 DP_RX_GRO_NORMAL_FLUSH); 282 } 283 284 local_bh_enable(); 285 GRO_DROP_UPDATE_STATUS(gro_ret, status); 286 287 return status; 288 } 289 290 /** 291 * osif_dp_rx_napi_gro_receive() - GRO RX receive function. 292 * @napi_to_use: napi to be used to give packets to the stack 293 * @nbuf: pointer to n/w buff 294 * 295 * Function calls napi_gro_receive for the skb. 296 * napi_gro_flush. Local softirqs are disabled (and later enabled) while making 297 * napi_gro__ calls. 298 * 299 * Return: QDF_STATUS_SUCCESS if not dropped by napi_gro_receive or 300 * QDF error code. 301 */ 302 static QDF_STATUS osif_dp_rx_napi_gro_receive(qdf_napi_struct * napi_to_use,qdf_nbuf_t nbuf)303 osif_dp_rx_napi_gro_receive(qdf_napi_struct *napi_to_use, 304 qdf_nbuf_t nbuf) 305 { 306 QDF_STATUS status = QDF_STATUS_SUCCESS; 307 gro_result_t gro_ret; 308 309 skb_set_hash(nbuf, QDF_NBUF_CB_RX_FLOW_ID(nbuf), PKT_HASH_TYPE_L4); 310 311 local_bh_disable(); 312 gro_ret = napi_gro_receive((struct napi_struct *)napi_to_use, nbuf); 313 314 local_bh_enable(); 315 GRO_DROP_UPDATE_STATUS(gro_ret, status); 316 317 return status; 318 } 319 320 #ifdef RECEIVE_OFFLOAD 321 /** 322 * osif_dp_rxthread_napi_normal_gro_flush() - GRO flush cbk for NAPI+Rx_Thread 323 * Rx mode 324 * @data: hif NAPI context 325 * 326 * Return: none 327 */ osif_dp_rxthread_napi_normal_gro_flush(void * data)328 static void osif_dp_rxthread_napi_normal_gro_flush(void *data) 329 { 330 struct qca_napi_info *qca_napi = (struct qca_napi_info *)data; 331 332 local_bh_disable(); 333 /* 334 * As we are breaking context in Rxthread mode, there is rx_thread NAPI 335 * corresponds each hif_napi. 336 */ 337 osif_dp_rx_thread_napi_gro_flush(&qca_napi->rx_thread_napi, 338 DP_RX_GRO_NORMAL_FLUSH); 339 local_bh_enable(); 340 } 341 342 /** 343 * osif_dp_hif_napi_gro_flush() - GRO flush callback for NAPI Rx mode 344 * @data: hif NAPI context 345 * 346 * Return: none 347 */ osif_dp_hif_napi_gro_flush(void * data)348 static void osif_dp_hif_napi_gro_flush(void *data) 349 { 350 struct qca_napi_info *qca_napi = (struct qca_napi_info *)data; 351 352 local_bh_disable(); 353 napi_gro_flush(&qca_napi->napi, false); 354 local_bh_enable(); 355 } 356 #endif 357 358 #ifdef FEATURE_LRO 359 /** 360 * osif_dp_qdf_lro_flush() - LRO flush wrapper 361 * @data: hif NAPI context 362 * 363 * Return: none 364 */ osif_dp_qdf_lro_flush(void * data)365 static void osif_dp_qdf_lro_flush(void *data) 366 { 367 struct qca_napi_info *qca_napii = (struct qca_napi_info *)data; 368 qdf_lro_ctx_t qdf_lro_ctx = qca_napii->lro_ctx; 369 370 qdf_lro_flush(qdf_lro_ctx); 371 } 372 #elif defined(RECEIVE_OFFLOAD) osif_dp_qdf_lro_flush(void * data)373 static void osif_dp_qdf_lro_flush(void *data) 374 { 375 } 376 #endif 377 378 #ifdef WLAN_FEATURE_DYNAMIC_RX_AGGREGATION 379 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 4, 0)) 380 static enum qdisc_filter_status __osif_check_for_prio_filter_in_clsact_qdisc(struct tcf_block * block,uint32_t prio)381 __osif_check_for_prio_filter_in_clsact_qdisc(struct tcf_block *block, 382 uint32_t prio) 383 { 384 struct tcf_chain *chain; 385 struct tcf_proto *tp; 386 struct tcf_proto *tp_next; 387 enum qdisc_filter_status ret = QDISC_FILTER_PRIO_MISMATCH; 388 389 mutex_lock(&block->lock); 390 list_for_each_entry(chain, &block->chain_list, list) { 391 mutex_lock(&chain->filter_chain_lock); 392 tp = tcf_chain_dereference(chain->filter_chain, chain); 393 while (tp) { 394 tp_next = rtnl_dereference(tp->next); 395 if (tp->prio == (prio << 16)) { 396 ret = QDISC_FILTER_PRIO_MATCH; 397 break; 398 } 399 tp = tp_next; 400 } 401 mutex_unlock(&chain->filter_chain_lock); 402 403 if (ret == QDISC_FILTER_PRIO_MATCH) 404 break; 405 } 406 mutex_unlock(&block->lock); 407 408 return ret; 409 } 410 #else 411 static enum qdisc_filter_status __osif_check_for_prio_filter_in_clsact_qdisc(struct tcf_block * block,uint32_t prio)412 __osif_check_for_prio_filter_in_clsact_qdisc(struct tcf_block *block, 413 uint32_t prio) 414 { 415 struct tcf_chain *chain; 416 struct tcf_proto *tp; 417 enum qdisc_filter_status ret = QDISC_FILTER_PRIO_MISMATCH; 418 419 if (!rtnl_trylock()) 420 return QDISC_FILTER_RTNL_LOCK_FAIL; 421 422 list_for_each_entry(chain, &block->chain_list, list) { 423 for (tp = rtnl_dereference(chain->filter_chain); tp; 424 tp = rtnl_dereference(tp->next)) { 425 if (tp->prio == (prio << 16)) 426 ret = QDISC_FILTER_PRIO_MATCH; 427 } 428 } 429 rtnl_unlock(); 430 431 return ret; 432 } 433 #endif 434 435 /** 436 * osif_check_for_prio_filter_in_clsact_qdisc() - Check if priority 3 filter 437 * is configured in the ingress clsact qdisc 438 * @qdisc: pointer to clsact qdisc 439 * @prio: traffic priority 440 * 441 * Return: qdisc filter status 442 */ 443 static enum qdisc_filter_status osif_check_for_prio_filter_in_clsact_qdisc(struct Qdisc * qdisc,uint32_t prio)444 osif_check_for_prio_filter_in_clsact_qdisc(struct Qdisc *qdisc, uint32_t prio) 445 { 446 const struct Qdisc_class_ops *cops; 447 struct tcf_block *ingress_block; 448 449 cops = qdisc->ops->cl_ops; 450 if (qdf_unlikely(!cops || !cops->tcf_block)) 451 return QDISC_FILTER_PRIO_MISMATCH; 452 453 ingress_block = cops->tcf_block(qdisc, TC_H_MIN_INGRESS, NULL); 454 if (qdf_unlikely(!ingress_block)) 455 return QDISC_FILTER_PRIO_MISMATCH; 456 457 return __osif_check_for_prio_filter_in_clsact_qdisc(ingress_block, 458 prio); 459 } 460 461 /** 462 * osif_dp_rx_check_qdisc_configured() - Check if any ingress qdisc 463 * configured for given netdev 464 * @ndev: pointer to netdev 465 * @prio: traffic priority 466 * 467 * The function checks if ingress qdisc is registered for a given 468 * net device. 469 * 470 * Return: None 471 */ 472 static QDF_STATUS osif_dp_rx_check_qdisc_configured(qdf_netdev_t ndev,uint32_t prio)473 osif_dp_rx_check_qdisc_configured(qdf_netdev_t ndev, uint32_t prio) 474 { 475 struct netdev_queue *ingress_q; 476 struct Qdisc *ingress_qdisc; 477 struct net_device *dev = (struct net_device *)ndev; 478 bool disable_gro = false; 479 enum qdisc_filter_status status; 480 481 if (!dev->ingress_queue) 482 goto reset_wl; 483 484 if (!rtnl_trylock()) 485 return QDF_STATUS_E_AGAIN; 486 487 ingress_q = rtnl_dereference(dev->ingress_queue); 488 if (qdf_unlikely(!ingress_q)) 489 goto reset; 490 491 ingress_qdisc = rtnl_dereference(ingress_q->qdisc); 492 if (qdf_unlikely(!ingress_qdisc)) 493 goto reset; 494 495 if (qdf_str_eq(ingress_qdisc->ops->id, "ingress")) { 496 disable_gro = true; 497 } else if (qdf_str_eq(ingress_qdisc->ops->id, "clsact")) { 498 status = osif_check_for_prio_filter_in_clsact_qdisc( 499 ingress_qdisc, 500 prio); 501 502 if (status == QDISC_FILTER_PRIO_MISMATCH) 503 goto reset; 504 505 disable_gro = true; 506 } 507 508 if (disable_gro) { 509 rtnl_unlock(); 510 return QDF_STATUS_SUCCESS; 511 } 512 513 reset: 514 rtnl_unlock(); 515 516 reset_wl: 517 return QDF_STATUS_E_NOSUPPORT; 518 } 519 520 #else 521 static QDF_STATUS osif_dp_rx_check_qdisc_configured(qdf_netdev_t ndev,uint32_t prio)522 osif_dp_rx_check_qdisc_configured(qdf_netdev_t ndev, uint32_t prio) 523 { 524 return QDF_STATUS_E_NOSUPPORT; 525 } 526 #endif 527 528 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 6, 0)) 529 static void osif_dp_register_arp_unsolicited_cbk(struct wlan_dp_psoc_callbacks * cb_obj)530 osif_dp_register_arp_unsolicited_cbk(struct wlan_dp_psoc_callbacks *cb_obj) 531 { 532 cb_obj->dp_is_gratuitous_arp_unsolicited_na = NULL; 533 } 534 #else osif_dp_is_gratuitous_arp_unsolicited_na(qdf_nbuf_t nbuf)535 static bool osif_dp_is_gratuitous_arp_unsolicited_na(qdf_nbuf_t nbuf) 536 { 537 return cfg80211_is_gratuitous_arp_unsolicited_na((struct sk_buff *)nbuf); 538 } 539 540 static void osif_dp_register_arp_unsolicited_cbk(struct wlan_dp_psoc_callbacks * cb_obj)541 osif_dp_register_arp_unsolicited_cbk(struct wlan_dp_psoc_callbacks *cb_obj) 542 { 543 cb_obj->dp_is_gratuitous_arp_unsolicited_na = 544 osif_dp_is_gratuitous_arp_unsolicited_na; 545 } 546 #endif 547 548 #if defined(CFG80211_CTRL_FRAME_SRC_ADDR_TA_ADDR) 549 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 15, 41)) 550 static osif_dp_cfg80211_rx_control_port(qdf_netdev_t dev,u8 * ta_addr,qdf_nbuf_t nbuf,bool unencrypted)551 bool osif_dp_cfg80211_rx_control_port(qdf_netdev_t dev, u8 *ta_addr, 552 qdf_nbuf_t nbuf, bool unencrypted) 553 { 554 return cfg80211_rx_control_port((struct net_device *)dev, 555 (struct sk_buff *)nbuf, 556 unencrypted, -1); 557 } 558 559 #else 560 static osif_dp_cfg80211_rx_control_port(qdf_netdev_t dev,u8 * ta_addr,qdf_nbuf_t nbuf,bool unencrypted)561 bool osif_dp_cfg80211_rx_control_port(qdf_netdev_t dev, u8 *ta_addr, 562 qdf_nbuf_t nbuf, bool unencrypted) 563 { 564 return cfg80211_rx_control_port((struct net_device *)dev, 565 ta_addr, (struct sk_buff *)nbuf, 566 unencrypted); 567 } 568 #endif 569 570 static void osif_dp_register_send_rx_pkt_over_nl(struct wlan_dp_psoc_callbacks * cb_obj)571 osif_dp_register_send_rx_pkt_over_nl(struct wlan_dp_psoc_callbacks *cb_obj) 572 { 573 cb_obj->dp_send_rx_pkt_over_nl = osif_dp_cfg80211_rx_control_port; 574 } 575 576 #else 577 static void osif_dp_register_send_rx_pkt_over_nl(struct wlan_dp_psoc_callbacks * cb_obj)578 osif_dp_register_send_rx_pkt_over_nl(struct wlan_dp_psoc_callbacks *cb_obj) 579 { 580 cb_obj->dp_send_rx_pkt_over_nl = NULL; 581 } 582 #endif 583 584 #ifdef RECEIVE_OFFLOAD 585 static osif_dp_register_rx_offld_flush_cb(enum dp_rx_offld_flush_cb cb_type)586 void osif_dp_register_rx_offld_flush_cb(enum dp_rx_offld_flush_cb cb_type) 587 { 588 void *soc = cds_get_context(QDF_MODULE_ID_SOC); 589 590 if (cb_type == DP_RX_FLUSH_LRO) 591 cdp_register_rx_offld_flush_cb(soc, osif_dp_qdf_lro_flush); 592 else if (cb_type == DP_RX_FLUSH_THREAD) 593 cdp_register_rx_offld_flush_cb(soc, 594 osif_dp_rxthread_napi_normal_gro_flush); 595 else if (cb_type == DP_RX_FLUSH_NAPI) 596 cdp_register_rx_offld_flush_cb(soc, 597 osif_dp_hif_napi_gro_flush); 598 } 599 #else 600 601 static osif_dp_register_rx_offld_flush_cb(enum dp_rx_offld_flush_cb cb_type)602 void osif_dp_register_rx_offld_flush_cb(enum dp_rx_offld_flush_cb cb_type) { } 603 #endif 604 605 static osif_dp_rx_pkt_to_nw(qdf_nbuf_t nbuf,enum dp_nbuf_push_type type)606 QDF_STATUS osif_dp_rx_pkt_to_nw(qdf_nbuf_t nbuf, enum dp_nbuf_push_type type) 607 { 608 int netif_status; 609 610 if (type == DP_NBUF_PUSH_BH_DISABLE) { 611 local_bh_disable(); 612 netif_status = netif_receive_skb(nbuf); 613 local_bh_enable(); 614 } else if (type == DP_NBUF_PUSH_NI) { 615 netif_status = netif_rx_ni(nbuf); 616 } else if (type == DP_NBUF_PUSH_NAPI) { 617 netif_status = netif_receive_skb(nbuf); 618 } else { 619 netif_status = netif_rx(nbuf); 620 } 621 622 if (qdf_likely(netif_status == NET_RX_SUCCESS)) 623 return QDF_STATUS_SUCCESS; 624 625 return QDF_STATUS_E_FAILURE; 626 } 627 os_if_dp_register_txrx_callbacks(struct wlan_dp_psoc_callbacks * cb_obj)628 void os_if_dp_register_txrx_callbacks(struct wlan_dp_psoc_callbacks *cb_obj) 629 { 630 cb_obj->dp_nbuf_push_pkt = osif_dp_rx_pkt_to_nw; 631 cb_obj->dp_rx_napi_gro_flush = osif_dp_rx_napi_gro_flush; 632 cb_obj->dp_rx_napi_gro_receive = osif_dp_rx_napi_gro_receive; 633 cb_obj->dp_rx_thread_napi_gro_flush = osif_dp_rx_thread_napi_gro_flush; 634 cb_obj->dp_lro_rx_cb = osif_dp_lro_rx; 635 cb_obj->dp_register_rx_offld_flush_cb = 636 osif_dp_register_rx_offld_flush_cb; 637 cb_obj->dp_rx_check_qdisc_configured = 638 osif_dp_rx_check_qdisc_configured; 639 640 osif_dp_register_arp_unsolicited_cbk(cb_obj); 641 642 osif_dp_register_send_rx_pkt_over_nl(cb_obj); 643 } 644