tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

Merge tag 'ath-next-20260202' of git://git.kernel.org/pub/scm/linux/kernel/git/ath/ath

Jeff Johnson says:
==================
ath.git patches for v6.20/v7.0 (#3)

A set of small features and cleanups for the next merge window.
==================

Signed-off-by: Johannes Berg <johannes.berg@intel.com>

Johannes Berg 19dd0cc3 0d95280a

+730 -12
+1
Documentation/devicetree/bindings/net/wireless/qcom,ath11k-pci.yaml
··· 37 37 38 38 firmware-name: 39 39 maxItems: 1 40 + deprecated: true 40 41 description: 41 42 If present, a board or platform specific string used to lookup 42 43 usecase-specific firmware files for the device.
+6
drivers/net/wireless/ath/ath10k/sdio.c
··· 2487 2487 if (fast_dump) 2488 2488 ath10k_bmi_start(ar); 2489 2489 2490 + mutex_lock(&ar->dump_mutex); 2491 + 2492 + spin_lock_bh(&ar->data_lock); 2490 2493 ar->stats.fw_crash_counter++; 2494 + spin_unlock_bh(&ar->data_lock); 2491 2495 2492 2496 ath10k_sdio_disable_intrs(ar); 2493 2497 ··· 2508 2504 ath10k_sdio_dump_memory(ar, crash_data, fast_dump); 2509 2505 2510 2506 ath10k_sdio_enable_intrs(ar); 2507 + 2508 + mutex_unlock(&ar->dump_mutex); 2511 2509 2512 2510 ath10k_core_start_recovery(ar); 2513 2511 }
+50 -3
drivers/net/wireless/ath/ath10k/snoc.c
··· 1 1 // SPDX-License-Identifier: ISC 2 2 /* 3 3 * Copyright (c) 2018 The Linux Foundation. All rights reserved. 4 + * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 4 5 */ 5 6 6 7 #include <linux/bits.h> ··· 12 11 #include <linux/of_device.h> 13 12 #include <linux/platform_device.h> 14 13 #include <linux/property.h> 14 + #include <linux/pwrseq/consumer.h> 15 15 #include <linux/regulator/consumer.h> 16 16 #include <linux/remoteproc/qcom_rproc.h> 17 17 #include <linux/of_reserved_mem.h> ··· 1025 1023 1026 1024 ath10k_dbg(ar, ATH10K_DBG_SNOC, "soc power on\n"); 1027 1025 1028 - ret = regulator_bulk_enable(ar_snoc->num_vregs, ar_snoc->vregs); 1026 + ret = pwrseq_power_on(ar_snoc->pwrseq); 1029 1027 if (ret) 1030 1028 return ret; 1029 + 1030 + ret = regulator_bulk_enable(ar_snoc->num_vregs, ar_snoc->vregs); 1031 + if (ret) 1032 + goto pwrseq_off; 1031 1033 1032 1034 ret = clk_bulk_prepare_enable(ar_snoc->num_clks, ar_snoc->clks); 1033 1035 if (ret) ··· 1041 1035 1042 1036 vreg_off: 1043 1037 regulator_bulk_disable(ar_snoc->num_vregs, ar_snoc->vregs); 1038 + pwrseq_off: 1039 + pwrseq_power_off(ar_snoc->pwrseq); 1040 + 1044 1041 return ret; 1045 1042 } 1046 1043 1047 1044 static int ath10k_hw_power_off(struct ath10k *ar) 1048 1045 { 1049 1046 struct ath10k_snoc *ar_snoc = ath10k_snoc_priv(ar); 1047 + int ret_seq = 0; 1048 + int ret_vreg; 1050 1049 1051 1050 ath10k_dbg(ar, ATH10K_DBG_SNOC, "soc power off\n"); 1052 1051 1053 1052 clk_bulk_disable_unprepare(ar_snoc->num_clks, ar_snoc->clks); 1054 1053 1055 - return regulator_bulk_disable(ar_snoc->num_vregs, ar_snoc->vregs); 1054 + ret_vreg = regulator_bulk_disable(ar_snoc->num_vregs, ar_snoc->vregs); 1055 + 1056 + if (ar_snoc->pwrseq) 1057 + ret_seq = pwrseq_power_off(ar_snoc->pwrseq); 1058 + 1059 + return ret_vreg ? : ret_seq; 1056 1060 } 1057 1061 1058 1062 static void ath10k_snoc_wlan_disable(struct ath10k *ar) ··· 1778 1762 goto err_release_resource; 1779 1763 } 1780 1764 1781 - ar_snoc->num_vregs = ARRAY_SIZE(ath10k_regulators); 1765 + /* 1766 + * devm_pwrseq_get() can return -EPROBE_DEFER in two cases: 1767 + * - it is not supposed to be used 1768 + * - it is supposed to be used, but the driver hasn't probed yet. 1769 + * 1770 + * There is no simple way to distinguish between these two cases, but: 1771 + * - if it is not supposed to be used, then regulator_bulk_get() will 1772 + * return all regulators as expected, continuing the probe 1773 + * - if it is supposed to be used, but wasn't probed yet, we will get 1774 + * -EPROBE_DEFER from regulator_bulk_get() too. 1775 + * 1776 + * For backwards compatibility with DTs specifying regulators directly 1777 + * rather than using the PMU device, ignore the defer error from 1778 + * pwrseq. 1779 + */ 1780 + ar_snoc->pwrseq = devm_pwrseq_get(&pdev->dev, "wlan"); 1781 + if (IS_ERR(ar_snoc->pwrseq)) { 1782 + ret = PTR_ERR(ar_snoc->pwrseq); 1783 + ar_snoc->pwrseq = NULL; 1784 + if (ret != -EPROBE_DEFER) 1785 + goto err_free_irq; 1786 + 1787 + ar_snoc->num_vregs = ARRAY_SIZE(ath10k_regulators); 1788 + } else { 1789 + /* 1790 + * The first regulator (vdd-0.8-cx-mx) is used to power on part 1791 + * of the SoC rather than the PMU on WCN399x, the rest are 1792 + * handled via pwrseq. 1793 + */ 1794 + ar_snoc->num_vregs = 1; 1795 + } 1796 + 1782 1797 ar_snoc->vregs = devm_kcalloc(&pdev->dev, ar_snoc->num_vregs, 1783 1798 sizeof(*ar_snoc->vregs), GFP_KERNEL); 1784 1799 if (!ar_snoc->vregs) {
+3
drivers/net/wireless/ath/ath10k/snoc.h
··· 1 1 /* SPDX-License-Identifier: ISC */ 2 2 /* 3 3 * Copyright (c) 2018 The Linux Foundation. All rights reserved. 4 + * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 4 5 */ 5 6 6 7 #ifndef _SNOC_H_ ··· 54 53 }; 55 54 56 55 struct clk_bulk_data; 56 + struct pwrseq_desc; 57 57 struct regulator_bulk_data; 58 58 59 59 struct ath10k_snoc { ··· 75 73 struct ath10k_snoc_ce_irq ce_irqs[CE_COUNT_MAX]; 76 74 struct ath10k_ce ce; 77 75 struct timer_list rx_post_retry; 76 + struct pwrseq_desc *pwrseq; 78 77 struct regulator_bulk_data *vregs; 79 78 size_t num_vregs; 80 79 struct clk_bulk_data *clks;
+2 -2
drivers/net/wireless/ath/ath10k/wmi.c
··· 5289 5289 struct ath10k_sta *arsta; 5290 5290 u8 peer_addr[ETH_ALEN]; 5291 5291 5292 - lockdep_assert_held(&ar->data_lock); 5293 - 5294 5292 ev = (struct wmi_peer_sta_ps_state_chg_event *)skb->data; 5295 5293 ether_addr_copy(peer_addr, ev->peer_macaddr.addr); 5296 5294 ··· 5303 5305 } 5304 5306 5305 5307 arsta = (struct ath10k_sta *)sta->drv_priv; 5308 + spin_lock_bh(&ar->data_lock); 5306 5309 arsta->peer_ps_state = __le32_to_cpu(ev->peer_ps_state); 5310 + spin_unlock_bh(&ar->data_lock); 5307 5311 5308 5312 exit: 5309 5313 rcu_read_unlock();
+27
drivers/net/wireless/ath/ath11k/core.c
··· 1044 1044 {} 1045 1045 }; 1046 1046 1047 + static const struct __ath11k_core_usecase_firmware_table { 1048 + u32 hw_rev; 1049 + const char *compatible; 1050 + const char *firmware_name; 1051 + } ath11k_core_usecase_firmware_table[] = { 1052 + { ATH11K_HW_WCN6855_HW21, "qcom,lemans-evk", "nfa765"}, 1053 + { ATH11K_HW_WCN6855_HW21, "qcom,monaco-evk", "nfa765"}, 1054 + { ATH11K_HW_WCN6855_HW21, "qcom,hamoa-iot-evk", "nfa765"}, 1055 + { /* Sentinel */ } 1056 + }; 1057 + 1058 + const char *ath11k_core_get_usecase_firmware(struct ath11k_base *ab) 1059 + { 1060 + const struct __ath11k_core_usecase_firmware_table *entry = NULL; 1061 + 1062 + entry = ath11k_core_usecase_firmware_table; 1063 + while (entry->compatible) { 1064 + if (ab->hw_rev == entry->hw_rev && 1065 + of_machine_is_compatible(entry->compatible)) 1066 + return entry->firmware_name; 1067 + entry++; 1068 + } 1069 + 1070 + return NULL; 1071 + } 1072 + EXPORT_SYMBOL(ath11k_core_get_usecase_firmware); 1073 + 1047 1074 void ath11k_fw_stats_pdevs_free(struct list_head *head) 1048 1075 { 1049 1076 struct ath11k_fw_stats_pdev *i, *tmp;
+4
drivers/net/wireless/ath/ath11k/core.h
··· 1292 1292 1293 1293 const struct firmware *ath11k_core_firmware_request(struct ath11k_base *ab, 1294 1294 const char *filename); 1295 + const char *ath11k_core_get_usecase_firmware(struct ath11k_base *ab); 1295 1296 1296 1297 static inline const char *ath11k_scan_state_str(enum ath11k_scan_state state) 1297 1298 { ··· 1346 1345 const char *fw_name = NULL; 1347 1346 1348 1347 of_property_read_string(ab->dev->of_node, "firmware-name", &fw_name); 1348 + 1349 + if (!fw_name) 1350 + fw_name = ath11k_core_get_usecase_firmware(ab); 1349 1351 1350 1352 if (fw_name && strncmp(filename, "board", 5)) 1351 1353 snprintf(buf, buf_len, "%s/%s/%s/%s", ATH11K_FW_DIR,
+194 -3
drivers/net/wireless/ath/ath12k/debugfs_htt_stats.c
··· 1 1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 2 /* 3 3 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 4 - * Copyright (c) 2021-2025 Qualcomm Innovation Center, Inc. All rights reserved. 4 + * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. 5 5 */ 6 6 7 7 #include <linux/vmalloc.h> ··· 29 29 " %u:%u,", stats_index++, le32_to_cpu(array[i])); 30 30 } 31 31 /* To overwrite the last trailing comma */ 32 - index--; 33 - *(buf + offset + index) = '\0'; 32 + if (array_len > 0) { 33 + index--; 34 + *(buf + offset + index) = '\0'; 35 + } 34 36 35 37 if (footer) { 36 38 index += scnprintf(buf + offset + index, ··· 5539 5537 stats_req->buf_len = len; 5540 5538 } 5541 5539 5540 + static void 5541 + ath12k_htt_print_rx_pdev_fw_stats_tlv(const void *tag_buf, u16 tag_len, 5542 + struct debug_htt_stats_req *stats_req) 5543 + { 5544 + const struct htt_rx_pdev_fw_stats_tlv *htt_stats_buf = tag_buf; 5545 + u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5546 + u32 len = stats_req->buf_len; 5547 + u8 *buf = stats_req->buf; 5548 + 5549 + if (tag_len < sizeof(*htt_stats_buf)) 5550 + return; 5551 + 5552 + len += scnprintf(buf + len, buf_len - len, "HTT_RX_PDEV_FW_STATS_TLV:\n"); 5553 + len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 5554 + le32_to_cpu(htt_stats_buf->mac_id__word) & 0xFF); 5555 + len += scnprintf(buf + len, buf_len - len, "ppdu_recvd = %u\n", 5556 + le32_to_cpu(htt_stats_buf->ppdu_recvd)); 5557 + len += scnprintf(buf + len, buf_len - len, "mpdu_cnt_fcs_ok = %u\n", 5558 + le32_to_cpu(htt_stats_buf->mpdu_cnt_fcs_ok)); 5559 + len += scnprintf(buf + len, buf_len - len, "mpdu_cnt_fcs_err = %u\n", 5560 + le32_to_cpu(htt_stats_buf->mpdu_cnt_fcs_err)); 5561 + len += scnprintf(buf + len, buf_len - len, "tcp_msdu_cnt = %u\n", 5562 + le32_to_cpu(htt_stats_buf->tcp_msdu_cnt)); 5563 + len += scnprintf(buf + len, buf_len - len, "tcp_ack_msdu_cnt = %u\n", 5564 + le32_to_cpu(htt_stats_buf->tcp_ack_msdu_cnt)); 5565 + len += scnprintf(buf + len, buf_len - len, "udp_msdu_cnt = %u\n", 5566 + le32_to_cpu(htt_stats_buf->udp_msdu_cnt)); 5567 + len += scnprintf(buf + len, buf_len - len, "other_msdu_cnt = %u\n", 5568 + le32_to_cpu(htt_stats_buf->other_msdu_cnt)); 5569 + len += scnprintf(buf + len, buf_len - len, "fw_ring_mpdu_ind = %u\n", 5570 + le32_to_cpu(htt_stats_buf->fw_ring_mpdu_ind)); 5571 + len += print_array_to_buf(buf, len, "fw_ring_mgmt_subtype", 5572 + htt_stats_buf->fw_ring_mgmt_subtype, 5573 + ATH12K_HTT_STATS_SUBTYPE_MAX, "\n"); 5574 + len += print_array_to_buf(buf, len, "fw_ring_ctrl_subtype", 5575 + htt_stats_buf->fw_ring_ctrl_subtype, 5576 + ATH12K_HTT_STATS_SUBTYPE_MAX, "\n"); 5577 + len += scnprintf(buf + len, buf_len - len, "fw_ring_mcast_data_msdu = %u\n", 5578 + le32_to_cpu(htt_stats_buf->fw_ring_mcast_data_msdu)); 5579 + len += scnprintf(buf + len, buf_len - len, "fw_ring_bcast_data_msdu = %u\n", 5580 + le32_to_cpu(htt_stats_buf->fw_ring_bcast_data_msdu)); 5581 + len += scnprintf(buf + len, buf_len - len, "fw_ring_ucast_data_msdu = %u\n", 5582 + le32_to_cpu(htt_stats_buf->fw_ring_ucast_data_msdu)); 5583 + len += scnprintf(buf + len, buf_len - len, "fw_ring_null_data_msdu = %u\n", 5584 + le32_to_cpu(htt_stats_buf->fw_ring_null_data_msdu)); 5585 + len += scnprintf(buf + len, buf_len - len, "fw_ring_mpdu_drop = %u\n", 5586 + le32_to_cpu(htt_stats_buf->fw_ring_mpdu_drop)); 5587 + len += scnprintf(buf + len, buf_len - len, "ofld_local_data_ind_cnt = %u\n", 5588 + le32_to_cpu(htt_stats_buf->ofld_local_data_ind_cnt)); 5589 + len += scnprintf(buf + len, buf_len - len, 5590 + "ofld_local_data_buf_recycle_cnt = %u\n", 5591 + le32_to_cpu(htt_stats_buf->ofld_local_data_buf_recycle_cnt)); 5592 + len += scnprintf(buf + len, buf_len - len, "drx_local_data_ind_cnt = %u\n", 5593 + le32_to_cpu(htt_stats_buf->drx_local_data_ind_cnt)); 5594 + len += scnprintf(buf + len, buf_len - len, 5595 + "drx_local_data_buf_recycle_cnt = %u\n", 5596 + le32_to_cpu(htt_stats_buf->drx_local_data_buf_recycle_cnt)); 5597 + len += scnprintf(buf + len, buf_len - len, "local_nondata_ind_cnt = %u\n", 5598 + le32_to_cpu(htt_stats_buf->local_nondata_ind_cnt)); 5599 + len += scnprintf(buf + len, buf_len - len, "local_nondata_buf_recycle_cnt = %u\n", 5600 + le32_to_cpu(htt_stats_buf->local_nondata_buf_recycle_cnt)); 5601 + len += scnprintf(buf + len, buf_len - len, "fw_status_buf_ring_refill_cnt = %u\n", 5602 + le32_to_cpu(htt_stats_buf->fw_status_buf_ring_refill_cnt)); 5603 + len += scnprintf(buf + len, buf_len - len, "fw_status_buf_ring_empty_cnt = %u\n", 5604 + le32_to_cpu(htt_stats_buf->fw_status_buf_ring_empty_cnt)); 5605 + len += scnprintf(buf + len, buf_len - len, "fw_pkt_buf_ring_refill_cnt = %u\n", 5606 + le32_to_cpu(htt_stats_buf->fw_pkt_buf_ring_refill_cnt)); 5607 + len += scnprintf(buf + len, buf_len - len, "fw_pkt_buf_ring_empty_cnt = %u\n", 5608 + le32_to_cpu(htt_stats_buf->fw_pkt_buf_ring_empty_cnt)); 5609 + len += scnprintf(buf + len, buf_len - len, "fw_link_buf_ring_refill_cnt = %u\n", 5610 + le32_to_cpu(htt_stats_buf->fw_link_buf_ring_refill_cnt)); 5611 + len += scnprintf(buf + len, buf_len - len, "fw_link_buf_ring_empty_cnt = %u\n", 5612 + le32_to_cpu(htt_stats_buf->fw_link_buf_ring_empty_cnt)); 5613 + len += scnprintf(buf + len, buf_len - len, "host_pkt_buf_ring_refill_cnt = %u\n", 5614 + le32_to_cpu(htt_stats_buf->host_pkt_buf_ring_refill_cnt)); 5615 + len += scnprintf(buf + len, buf_len - len, "host_pkt_buf_ring_empty_cnt = %u\n", 5616 + le32_to_cpu(htt_stats_buf->host_pkt_buf_ring_empty_cnt)); 5617 + len += scnprintf(buf + len, buf_len - len, "mon_pkt_buf_ring_refill_cnt = %u\n", 5618 + le32_to_cpu(htt_stats_buf->mon_pkt_buf_ring_refill_cnt)); 5619 + len += scnprintf(buf + len, buf_len - len, "mon_pkt_buf_ring_empty_cnt = %u\n", 5620 + le32_to_cpu(htt_stats_buf->mon_pkt_buf_ring_empty_cnt)); 5621 + len += scnprintf(buf + len, buf_len - len, 5622 + "mon_status_buf_ring_refill_cnt = %u\n", 5623 + le32_to_cpu(htt_stats_buf->mon_status_buf_ring_refill_cnt)); 5624 + len += scnprintf(buf + len, buf_len - len, "mon_status_buf_ring_empty_cnt = %u\n", 5625 + le32_to_cpu(htt_stats_buf->mon_status_buf_ring_empty_cnt)); 5626 + len += scnprintf(buf + len, buf_len - len, "mon_desc_buf_ring_refill_cnt = %u\n", 5627 + le32_to_cpu(htt_stats_buf->mon_desc_buf_ring_refill_cnt)); 5628 + len += scnprintf(buf + len, buf_len - len, "mon_desc_buf_ring_empty_cnt = %u\n", 5629 + le32_to_cpu(htt_stats_buf->mon_desc_buf_ring_empty_cnt)); 5630 + len += scnprintf(buf + len, buf_len - len, "mon_dest_ring_update_cnt = %u\n", 5631 + le32_to_cpu(htt_stats_buf->mon_dest_ring_update_cnt)); 5632 + len += scnprintf(buf + len, buf_len - len, "mon_dest_ring_full_cnt = %u\n", 5633 + le32_to_cpu(htt_stats_buf->mon_dest_ring_full_cnt)); 5634 + len += scnprintf(buf + len, buf_len - len, "rx_suspend_cnt = %u\n", 5635 + le32_to_cpu(htt_stats_buf->rx_suspend_cnt)); 5636 + len += scnprintf(buf + len, buf_len - len, "rx_suspend_fail_cnt = %u\n", 5637 + le32_to_cpu(htt_stats_buf->rx_suspend_fail_cnt)); 5638 + len += scnprintf(buf + len, buf_len - len, "rx_resume_cnt = %u\n", 5639 + le32_to_cpu(htt_stats_buf->rx_resume_cnt)); 5640 + len += scnprintf(buf + len, buf_len - len, "rx_resume_fail_cnt = %u\n", 5641 + le32_to_cpu(htt_stats_buf->rx_resume_fail_cnt)); 5642 + len += scnprintf(buf + len, buf_len - len, "rx_ring_switch_cnt = %u\n", 5643 + le32_to_cpu(htt_stats_buf->rx_ring_switch_cnt)); 5644 + len += scnprintf(buf + len, buf_len - len, "rx_ring_restore_cnt = %u\n", 5645 + le32_to_cpu(htt_stats_buf->rx_ring_restore_cnt)); 5646 + len += scnprintf(buf + len, buf_len - len, "rx_flush_cnt = %u\n", 5647 + le32_to_cpu(htt_stats_buf->rx_flush_cnt)); 5648 + len += scnprintf(buf + len, buf_len - len, "rx_recovery_reset_cnt = %u\n", 5649 + le32_to_cpu(htt_stats_buf->rx_recovery_reset_cnt)); 5650 + len += scnprintf(buf + len, buf_len - len, "rx_lwm_prom_filter_dis = %u\n", 5651 + le32_to_cpu(htt_stats_buf->rx_lwm_prom_filter_dis)); 5652 + len += scnprintf(buf + len, buf_len - len, "rx_hwm_prom_filter_en = %u\n", 5653 + le32_to_cpu(htt_stats_buf->rx_hwm_prom_filter_en)); 5654 + len += scnprintf(buf + len, buf_len - len, "bytes_received_low_32 = %u\n", 5655 + le32_to_cpu(htt_stats_buf->bytes_received_low_32)); 5656 + len += scnprintf(buf + len, buf_len - len, "bytes_received_high_32 = %u\n", 5657 + le32_to_cpu(htt_stats_buf->bytes_received_high_32)); 5658 + 5659 + stats_req->buf_len = len; 5660 + } 5661 + 5662 + static void 5663 + ath12k_htt_print_tx_hwq_stats_cmn_tlv(const void *tag_buf, u16 tag_len, 5664 + struct debug_htt_stats_req *stats_req) 5665 + { 5666 + const struct htt_tx_hwq_stats_cmn_tlv *htt_stats_buf = tag_buf; 5667 + u32 buf_len = ATH12K_HTT_STATS_BUF_SIZE; 5668 + u32 len = stats_req->buf_len; 5669 + u8 *buf = stats_req->buf; 5670 + 5671 + if (tag_len < sizeof(*htt_stats_buf)) 5672 + return; 5673 + 5674 + len += scnprintf(buf + len, buf_len - len, "HTT_TX_HWQ_STATS_CMN_TLV:\n"); 5675 + len += scnprintf(buf + len, buf_len - len, "mac_id = %u\n", 5676 + le32_to_cpu(htt_stats_buf->mac_id__hwq_id__word) & 0xFF); 5677 + len += scnprintf(buf + len, buf_len - len, "hwq_id = %u\n", 5678 + (le32_to_cpu(htt_stats_buf->mac_id__hwq_id__word) & 0xFF00) >> 8); 5679 + len += scnprintf(buf + len, buf_len - len, "xretry = %u\n", 5680 + le32_to_cpu(htt_stats_buf->xretry)); 5681 + len += scnprintf(buf + len, buf_len - len, "underrun_cnt = %u\n", 5682 + le32_to_cpu(htt_stats_buf->underrun_cnt)); 5683 + len += scnprintf(buf + len, buf_len - len, "flush_cnt = %u\n", 5684 + le32_to_cpu(htt_stats_buf->flush_cnt)); 5685 + len += scnprintf(buf + len, buf_len - len, "filt_cnt = %u\n", 5686 + le32_to_cpu(htt_stats_buf->filt_cnt)); 5687 + len += scnprintf(buf + len, buf_len - len, "null_mpdu_bmap = %u\n", 5688 + le32_to_cpu(htt_stats_buf->null_mpdu_bmap)); 5689 + len += scnprintf(buf + len, buf_len - len, "user_ack_failure = %u\n", 5690 + le32_to_cpu(htt_stats_buf->user_ack_failure)); 5691 + len += scnprintf(buf + len, buf_len - len, "ack_tlv_proc = %u\n", 5692 + le32_to_cpu(htt_stats_buf->ack_tlv_proc)); 5693 + len += scnprintf(buf + len, buf_len - len, "sched_id_proc = %u\n", 5694 + le32_to_cpu(htt_stats_buf->sched_id_proc)); 5695 + len += scnprintf(buf + len, buf_len - len, "null_mpdu_tx_count = %u\n", 5696 + le32_to_cpu(htt_stats_buf->null_mpdu_tx_count)); 5697 + len += scnprintf(buf + len, buf_len - len, "mpdu_bmap_not_recvd = %u\n", 5698 + le32_to_cpu(htt_stats_buf->mpdu_bmap_not_recvd)); 5699 + len += scnprintf(buf + len, buf_len - len, "num_bar = %u\n", 5700 + le32_to_cpu(htt_stats_buf->num_bar)); 5701 + len += scnprintf(buf + len, buf_len - len, "rts = %u\n", 5702 + le32_to_cpu(htt_stats_buf->rts)); 5703 + len += scnprintf(buf + len, buf_len - len, "cts2self = %u\n", 5704 + le32_to_cpu(htt_stats_buf->cts2self)); 5705 + len += scnprintf(buf + len, buf_len - len, "qos_null = %u\n", 5706 + le32_to_cpu(htt_stats_buf->qos_null)); 5707 + len += scnprintf(buf + len, buf_len - len, "mpdu_tried_cnt = %u\n", 5708 + le32_to_cpu(htt_stats_buf->mpdu_tried_cnt)); 5709 + len += scnprintf(buf + len, buf_len - len, "mpdu_queued_cnt = %u\n", 5710 + le32_to_cpu(htt_stats_buf->mpdu_queued_cnt)); 5711 + len += scnprintf(buf + len, buf_len - len, "mpdu_ack_fail_cnt = %u\n", 5712 + le32_to_cpu(htt_stats_buf->mpdu_ack_fail_cnt)); 5713 + len += scnprintf(buf + len, buf_len - len, "mpdu_filt_cnt = %u\n", 5714 + le32_to_cpu(htt_stats_buf->mpdu_filt_cnt)); 5715 + len += scnprintf(buf + len, buf_len - len, "false_mpdu_ack_count = %u\n", 5716 + le32_to_cpu(htt_stats_buf->false_mpdu_ack_count)); 5717 + len += scnprintf(buf + len, buf_len - len, "txq_timeout = %u\n", 5718 + le32_to_cpu(htt_stats_buf->txq_timeout)); 5719 + 5720 + stats_req->buf_len = len; 5721 + } 5722 + 5542 5723 static int ath12k_dbg_htt_ext_stats_parse(struct ath12k_base *ab, 5543 5724 u16 tag, u16 len, const void *tag_buf, 5544 5725 void *user_data) ··· 5875 5690 case HTT_STATS_SFM_CLIENT_USER_TAG: 5876 5691 ath12k_htt_print_sfm_client_user_tlv(tag_buf, len, stats_req); 5877 5692 break; 5693 + case HTT_STATS_RX_PDEV_FW_STATS_TAG: 5694 + ath12k_htt_print_rx_pdev_fw_stats_tlv(tag_buf, len, stats_req); 5695 + break; 5878 5696 case HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG: 5879 5697 ath12k_htt_print_tx_pdev_mu_mimo_sch_stats_tlv(tag_buf, len, stats_req); 5880 5698 break; ··· 6020 5832 break; 6021 5833 case HTT_STATS_PDEV_RTT_TBR_CMD_RESULT_STATS_TAG: 6022 5834 ath12k_htt_print_pdev_rtt_tbr_cmd_res_stats_tlv(tag_buf, len, stats_req); 5835 + break; 5836 + case HTT_STATS_TX_HWQ_CMN_TAG: 5837 + ath12k_htt_print_tx_hwq_stats_cmn_tlv(tag_buf, len, stats_req); 6023 5838 break; 6024 5839 default: 6025 5840 break;
+81
drivers/net/wireless/ath/ath12k/debugfs_htt_stats.h
··· 127 127 enum ath12k_dbg_htt_ext_stats_type { 128 128 ATH12K_DBG_HTT_EXT_STATS_RESET = 0, 129 129 ATH12K_DBG_HTT_EXT_STATS_PDEV_TX = 1, 130 + ATH12K_DBG_HTT_EXT_STATS_PDEV_RX = 2, 131 + ATH12K_DBG_HTT_EXT_STATS_PDEV_TX_HWQ = 3, 130 132 ATH12K_DBG_HTT_EXT_STATS_PDEV_TX_SCHED = 4, 131 133 ATH12K_DBG_HTT_EXT_STATS_PDEV_ERROR = 5, 132 134 ATH12K_DBG_HTT_EXT_STATS_PDEV_TQM = 6, ··· 175 173 HTT_STATS_TX_PDEV_SIFS_TAG = 2, 176 174 HTT_STATS_TX_PDEV_FLUSH_TAG = 3, 177 175 HTT_STATS_STRING_TAG = 5, 176 + HTT_STATS_TX_HWQ_CMN_TAG = 6, 178 177 HTT_STATS_TX_TQM_GEN_MPDU_TAG = 11, 179 178 HTT_STATS_TX_TQM_LIST_MPDU_TAG = 12, 180 179 HTT_STATS_TX_TQM_LIST_MPDU_CNT_TAG = 13, ··· 191 188 HTT_STATS_TX_PDEV_MU_MIMO_STATS_TAG = 25, 192 189 HTT_STATS_SFM_CMN_TAG = 26, 193 190 HTT_STATS_SRING_STATS_TAG = 27, 191 + HTT_STATS_RX_PDEV_FW_STATS_TAG = 28, 194 192 HTT_STATS_TX_PDEV_RATE_STATS_TAG = 34, 195 193 HTT_STATS_RX_PDEV_RATE_STATS_TAG = 35, 196 194 HTT_STATS_TX_PDEV_SCHEDULER_TXQ_STATS_TAG = 36, ··· 2077 2073 __le32 tbr_num_sch_cmd_result_buckets; 2078 2074 __le32 su_res[ATH12K_HTT_FTYPE_MAX][ATH12K_HTT_MAX_SCH_CMD_RESULT]; 2079 2075 __le32 mu_res[ATH12K_HTT_FTYPE_MAX][ATH12K_HTT_MAX_SCH_CMD_RESULT]; 2076 + } __packed; 2077 + 2078 + struct htt_rx_pdev_fw_stats_tlv { 2079 + __le32 mac_id__word; 2080 + __le32 ppdu_recvd; 2081 + __le32 mpdu_cnt_fcs_ok; 2082 + __le32 mpdu_cnt_fcs_err; 2083 + __le32 tcp_msdu_cnt; 2084 + __le32 tcp_ack_msdu_cnt; 2085 + __le32 udp_msdu_cnt; 2086 + __le32 other_msdu_cnt; 2087 + __le32 fw_ring_mpdu_ind; 2088 + __le32 fw_ring_mgmt_subtype[ATH12K_HTT_STATS_SUBTYPE_MAX]; 2089 + __le32 fw_ring_ctrl_subtype[ATH12K_HTT_STATS_SUBTYPE_MAX]; 2090 + __le32 fw_ring_mcast_data_msdu; 2091 + __le32 fw_ring_bcast_data_msdu; 2092 + __le32 fw_ring_ucast_data_msdu; 2093 + __le32 fw_ring_null_data_msdu; 2094 + __le32 fw_ring_mpdu_drop; 2095 + __le32 ofld_local_data_ind_cnt; 2096 + __le32 ofld_local_data_buf_recycle_cnt; 2097 + __le32 drx_local_data_ind_cnt; 2098 + __le32 drx_local_data_buf_recycle_cnt; 2099 + __le32 local_nondata_ind_cnt; 2100 + __le32 local_nondata_buf_recycle_cnt; 2101 + __le32 fw_status_buf_ring_refill_cnt; 2102 + __le32 fw_status_buf_ring_empty_cnt; 2103 + __le32 fw_pkt_buf_ring_refill_cnt; 2104 + __le32 fw_pkt_buf_ring_empty_cnt; 2105 + __le32 fw_link_buf_ring_refill_cnt; 2106 + __le32 fw_link_buf_ring_empty_cnt; 2107 + __le32 host_pkt_buf_ring_refill_cnt; 2108 + __le32 host_pkt_buf_ring_empty_cnt; 2109 + __le32 mon_pkt_buf_ring_refill_cnt; 2110 + __le32 mon_pkt_buf_ring_empty_cnt; 2111 + __le32 mon_status_buf_ring_refill_cnt; 2112 + __le32 mon_status_buf_ring_empty_cnt; 2113 + __le32 mon_desc_buf_ring_refill_cnt; 2114 + __le32 mon_desc_buf_ring_empty_cnt; 2115 + __le32 mon_dest_ring_update_cnt; 2116 + __le32 mon_dest_ring_full_cnt; 2117 + __le32 rx_suspend_cnt; 2118 + __le32 rx_suspend_fail_cnt; 2119 + __le32 rx_resume_cnt; 2120 + __le32 rx_resume_fail_cnt; 2121 + __le32 rx_ring_switch_cnt; 2122 + __le32 rx_ring_restore_cnt; 2123 + __le32 rx_flush_cnt; 2124 + __le32 rx_recovery_reset_cnt; 2125 + __le32 rx_lwm_prom_filter_dis; 2126 + __le32 rx_hwm_prom_filter_en; 2127 + __le32 bytes_received_low_32; 2128 + __le32 bytes_received_high_32; 2129 + } __packed; 2130 + 2131 + struct htt_tx_hwq_stats_cmn_tlv { 2132 + __le32 mac_id__hwq_id__word; 2133 + __le32 xretry; 2134 + __le32 underrun_cnt; 2135 + __le32 flush_cnt; 2136 + __le32 filt_cnt; 2137 + __le32 null_mpdu_bmap; 2138 + __le32 user_ack_failure; 2139 + __le32 ack_tlv_proc; 2140 + __le32 sched_id_proc; 2141 + __le32 null_mpdu_tx_count; 2142 + __le32 mpdu_bmap_not_recvd; 2143 + __le32 num_bar; 2144 + __le32 rts; 2145 + __le32 cts2self; 2146 + __le32 qos_null; 2147 + __le32 mpdu_tried_cnt; 2148 + __le32 mpdu_queued_cnt; 2149 + __le32 mpdu_ack_fail_cnt; 2150 + __le32 mpdu_filt_cnt; 2151 + __le32 false_mpdu_ack_count; 2152 + __le32 txq_timeout; 2080 2153 } __packed; 2081 2154 2082 2155 #endif
+170 -4
drivers/net/wireless/ath/ath12k/mac.c
··· 4281 4281 if (WARN_ON(!arvif)) 4282 4282 return -EINVAL; 4283 4283 4284 - if (!arvif->is_created) 4284 + if (!arvif->is_created) { 4285 + ath12k_mac_unassign_link_vif(arvif); 4285 4286 continue; 4287 + } 4286 4288 4287 4289 if (WARN_ON(!arvif->ar)) 4288 4290 return -EINVAL; ··· 4505 4503 if (ret) 4506 4504 ath12k_warn(ar->ab, "failed to bring vdev up %d: %d\n", 4507 4505 arvif->vdev_id, ret); 4506 + } 4507 + 4508 + static int ath12k_mac_config_obss_pd(struct ath12k_link_vif *arvif, 4509 + const struct ieee80211_he_obss_pd *he_obss_pd) 4510 + { 4511 + struct ath12k_wmi_obss_pd_arg obss_pd_arg = {}; 4512 + u32 srg_bitmap[2], non_srg_bitmap[2]; 4513 + struct ath12k *ar = arvif->ar; 4514 + u32 param_id, pdev_id; 4515 + u32 param_val; 4516 + int ret; 4517 + 4518 + if (ar->ab->hw_params->single_pdev_only) 4519 + pdev_id = ath12k_mac_get_target_pdev_id_from_vif(arvif); 4520 + else 4521 + pdev_id = ar->pdev->pdev_id; 4522 + 4523 + /* Set and enable SRG/non-SRG OBSS PD threshold */ 4524 + param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD; 4525 + if (ar->monitor_started || !he_obss_pd->enable) { 4526 + ret = ath12k_wmi_pdev_set_param(ar, param_id, 0, pdev_id); 4527 + if (ret) 4528 + ath12k_warn(ar->ab, 4529 + "failed to set OBSS PD threshold for pdev %u: %d\n", 4530 + pdev_id, ret); 4531 + return ret; 4532 + } 4533 + 4534 + /* 4535 + * This service flag indicates firmware support for SRG/SRP-based 4536 + * spatial reuse. It also specifies whether OBSS PD threshold values 4537 + * should be interpreted as dB (offset) or dBm (absolute) units. 4538 + */ 4539 + obss_pd_arg.srp_support = test_bit(WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT, 4540 + ar->ab->wmi_ab.svc_map); 4541 + 4542 + if (!(he_obss_pd->sr_ctrl & 4543 + IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED)) { 4544 + if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT) 4545 + obss_pd_arg.non_srg_th = ATH12K_OBSS_PD_MAX_THRESHOLD + 4546 + he_obss_pd->non_srg_max_offset; 4547 + else 4548 + obss_pd_arg.non_srg_th = ATH12K_OBSS_PD_NON_SRG_MAX_THRESHOLD; 4549 + 4550 + if (!obss_pd_arg.srp_support) 4551 + obss_pd_arg.non_srg_th -= ATH12K_DEFAULT_NOISE_FLOOR; 4552 + 4553 + obss_pd_arg.non_srg_enabled = true; 4554 + } 4555 + 4556 + if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT) { 4557 + obss_pd_arg.srg_th = ATH12K_OBSS_PD_MAX_THRESHOLD + 4558 + he_obss_pd->max_offset; 4559 + obss_pd_arg.srg_enabled = true; 4560 + } 4561 + 4562 + ath12k_dbg(ar->ab, ATH12K_DBG_MAC, 4563 + "pdev %u OBSS PD sr_ctrl 0x%x srg_th %d dBm non_srg_th %d dBm\n", 4564 + pdev_id, he_obss_pd->sr_ctrl, 4565 + obss_pd_arg.srg_th, obss_pd_arg.non_srg_th); 4566 + 4567 + param_val = ath12k_wmi_build_obss_pd(&obss_pd_arg); 4568 + ret = ath12k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 4569 + if (ret) { 4570 + ath12k_warn(ar->ab, 4571 + "failed to set OBSS PD threshold for pdev %u: %d\n", 4572 + pdev_id, ret); 4573 + return ret; 4574 + } 4575 + 4576 + /* Enable OBSS PD for all access category */ 4577 + param_id = WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC; 4578 + param_val = 0xf; 4579 + ret = ath12k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 4580 + if (ret) { 4581 + ath12k_warn(ar->ab, 4582 + "failed to set OBSS PD per ac for pdev %u: %d\n", 4583 + pdev_id, ret); 4584 + return ret; 4585 + } 4586 + 4587 + /* Set SR prohibit */ 4588 + param_id = WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT; 4589 + param_val = !!(he_obss_pd->sr_ctrl & 4590 + IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED); 4591 + ret = ath12k_wmi_pdev_set_param(ar, param_id, param_val, pdev_id); 4592 + if (ret) { 4593 + ath12k_warn(ar->ab, "failed to set SR prohibit for pdev %u: %d\n", 4594 + pdev_id, ret); 4595 + return ret; 4596 + } 4597 + 4598 + if (!obss_pd_arg.srp_support) 4599 + return 0; 4600 + 4601 + memcpy(srg_bitmap, he_obss_pd->bss_color_bitmap, sizeof(srg_bitmap)); 4602 + /* Set SRG BSS color bitmap */ 4603 + ret = ath12k_wmi_pdev_set_srg_bss_color_bitmap(ar, pdev_id, srg_bitmap); 4604 + if (ret) { 4605 + ath12k_warn(ar->ab, 4606 + "failed to set SRG bss color bitmap for pdev %u: %d\n", 4607 + pdev_id, ret); 4608 + return ret; 4609 + } 4610 + 4611 + /* Enable BSS colors for SRG */ 4612 + ret = ath12k_wmi_pdev_srg_obss_color_enable_bitmap(ar, pdev_id, srg_bitmap); 4613 + if (ret) { 4614 + ath12k_warn(ar->ab, 4615 + "failed to enable SRG bss color bitmap pdev %u: %d\n", 4616 + pdev_id, ret); 4617 + return ret; 4618 + } 4619 + 4620 + memcpy(srg_bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(srg_bitmap)); 4621 + /* Set SRG partial bssid bitmap */ 4622 + ret = ath12k_wmi_pdev_set_srg_partial_bssid_bitmap(ar, pdev_id, srg_bitmap); 4623 + if (ret) { 4624 + ath12k_warn(ar->ab, 4625 + "failed to set SRG partial bssid bitmap for pdev %u: %d\n", 4626 + pdev_id, ret); 4627 + return ret; 4628 + } 4629 + 4630 + /* Enable partial bssid mask for SRG */ 4631 + ret = ath12k_wmi_pdev_srg_obss_bssid_enable_bitmap(ar, pdev_id, srg_bitmap); 4632 + if (ret) { 4633 + ath12k_warn(ar->ab, 4634 + "failed to enable SRG bssid bitmap pdev %u: %d\n", 4635 + pdev_id, ret); 4636 + return ret; 4637 + } 4638 + 4639 + /* 4640 + * No explicit non-SRG bitmap from mac80211; enable all colors/bssids 4641 + * as non-SRG candidates. Actual SRG members are filtered by SRG bitmaps. 4642 + */ 4643 + memset(non_srg_bitmap, 0xff, sizeof(non_srg_bitmap)); 4644 + 4645 + /* Enable BSS colors for non-SRG */ 4646 + ret = ath12k_wmi_pdev_non_srg_obss_color_enable_bitmap(ar, pdev_id, 4647 + non_srg_bitmap); 4648 + if (ret) { 4649 + ath12k_warn(ar->ab, 4650 + "failed to enable non SRG color bitmap pdev %u: %d\n", 4651 + pdev_id, ret); 4652 + return ret; 4653 + } 4654 + 4655 + /* Enable partial bssid mask for non-SRG */ 4656 + ret = ath12k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(ar, pdev_id, 4657 + non_srg_bitmap); 4658 + if (ret) { 4659 + ath12k_warn(ar->ab, 4660 + "failed to enable non SRG bssid bitmap pdev %u: %d\n", 4661 + pdev_id, ret); 4662 + return ret; 4663 + } 4664 + 4665 + return 0; 4508 4666 } 4509 4667 4510 4668 static void ath12k_mac_bss_info_changed(struct ath12k *ar, ··· 4958 4796 ath12k_wmi_send_twt_disable_cmd(ar, ar->pdev->pdev_id); 4959 4797 } 4960 4798 4961 - if (changed & BSS_CHANGED_HE_OBSS_PD) 4962 - ath12k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 4963 - &info->he_obss_pd); 4799 + if (changed & BSS_CHANGED_HE_OBSS_PD) { 4800 + if (vif->type == NL80211_IFTYPE_AP) 4801 + ath12k_mac_config_obss_pd(arvif, &info->he_obss_pd); 4802 + else 4803 + ath12k_wmi_send_obss_spr_cmd(ar, arvif->vdev_id, 4804 + &info->he_obss_pd); 4805 + } 4964 4806 4965 4807 if (changed & BSS_CHANGED_HE_BSS_COLOR) { 4966 4808 if (vif->type == NL80211_IFTYPE_AP) {
+3
drivers/net/wireless/ath/ath12k/mac.h
··· 138 138 struct ath12k_chan_power_info chan_power_info[ATH12K_NUM_PWR_LEVELS]; 139 139 }; 140 140 141 + #define ATH12K_OBSS_PD_MAX_THRESHOLD -82 142 + #define ATH12K_OBSS_PD_NON_SRG_MAX_THRESHOLD -62 143 + 141 144 extern const struct htt_rx_ring_tlv_filter ath12k_mac_mon_status_filter_default; 142 145 143 146 #define ATH12K_SCAN_11D_INTERVAL 600000
+142
drivers/net/wireless/ath/ath12k/wmi.c
··· 126 126 bool frame_buf_done; 127 127 }; 128 128 129 + struct wmi_pdev_set_obss_bitmap_arg { 130 + u32 tlv_tag; 131 + u32 pdev_id; 132 + u32 cmd_id; 133 + const u32 *bitmap; 134 + const char *label; 135 + }; 136 + 129 137 static const struct ath12k_wmi_tlv_policy ath12k_wmi_tlv_policies[] = { 130 138 [WMI_TAG_ARRAY_BYTE] = { .min_len = 0 }, 131 139 [WMI_TAG_ARRAY_UINT32] = { .min_len = 0 }, ··· 3566 3558 dev_kfree_skb(skb); 3567 3559 } 3568 3560 return ret; 3561 + } 3562 + 3563 + u32 ath12k_wmi_build_obss_pd(const struct ath12k_wmi_obss_pd_arg *arg) 3564 + { 3565 + u32 param_val = 0; 3566 + 3567 + param_val |= u32_encode_bits((u8)arg->srg_th, GENMASK(15, 8)); 3568 + param_val |= u32_encode_bits((u8)arg->non_srg_th, GENMASK(7, 0)); 3569 + 3570 + if (arg->srp_support) 3571 + param_val |= ATH12K_OBSS_PD_THRESHOLD_IN_DBM; 3572 + 3573 + if (arg->srg_enabled && arg->srp_support) 3574 + param_val |= ATH12K_OBSS_PD_SRG_EN; 3575 + 3576 + if (arg->non_srg_enabled) 3577 + param_val |= ATH12K_OBSS_PD_NON_SRG_EN; 3578 + 3579 + return param_val; 3580 + } 3581 + 3582 + static int ath12k_wmi_pdev_set_obss_bitmap(struct ath12k *ar, 3583 + const struct wmi_pdev_set_obss_bitmap_arg *arg) 3584 + { 3585 + struct wmi_pdev_obss_pd_bitmap_cmd *cmd; 3586 + struct ath12k_wmi_pdev *wmi = ar->wmi; 3587 + const int len = sizeof(*cmd); 3588 + struct sk_buff *skb; 3589 + int ret; 3590 + 3591 + skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, len); 3592 + if (!skb) 3593 + return -ENOMEM; 3594 + 3595 + cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data; 3596 + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(arg->tlv_tag, len); 3597 + cmd->pdev_id = cpu_to_le32(arg->pdev_id); 3598 + memcpy(cmd->bitmap, arg->bitmap, sizeof(cmd->bitmap)); 3599 + 3600 + ath12k_dbg(ar->ab, ATH12K_DBG_WMI, 3601 + "wmi set pdev %u %s %08x %08x\n", 3602 + arg->pdev_id, arg->label, arg->bitmap[0], arg->bitmap[1]); 3603 + 3604 + ret = ath12k_wmi_cmd_send(wmi, skb, arg->cmd_id); 3605 + if (ret) { 3606 + ath12k_warn(ar->ab, "failed to send %s: %d\n", arg->label, ret); 3607 + dev_kfree_skb(skb); 3608 + } 3609 + 3610 + return ret; 3611 + } 3612 + 3613 + int ath12k_wmi_pdev_set_srg_bss_color_bitmap(struct ath12k *ar, 3614 + u32 pdev_id, const u32 *bitmap) 3615 + { 3616 + struct wmi_pdev_set_obss_bitmap_arg arg = { 3617 + .tlv_tag = WMI_TAG_PDEV_SRG_BSS_COLOR_BITMAP_CMD, 3618 + .pdev_id = pdev_id, 3619 + .cmd_id = WMI_PDEV_SET_SRG_BSS_COLOR_BITMAP_CMDID, 3620 + .bitmap = bitmap, 3621 + .label = "SRG bss color bitmap", 3622 + }; 3623 + 3624 + return ath12k_wmi_pdev_set_obss_bitmap(ar, &arg); 3625 + } 3626 + 3627 + int ath12k_wmi_pdev_set_srg_partial_bssid_bitmap(struct ath12k *ar, 3628 + u32 pdev_id, const u32 *bitmap) 3629 + { 3630 + struct wmi_pdev_set_obss_bitmap_arg arg = { 3631 + .tlv_tag = WMI_TAG_PDEV_SRG_PARTIAL_BSSID_BITMAP_CMD, 3632 + .pdev_id = pdev_id, 3633 + .cmd_id = WMI_PDEV_SET_SRG_PARTIAL_BSSID_BITMAP_CMDID, 3634 + .bitmap = bitmap, 3635 + .label = "SRG partial bssid bitmap", 3636 + }; 3637 + 3638 + return ath12k_wmi_pdev_set_obss_bitmap(ar, &arg); 3639 + } 3640 + 3641 + int ath12k_wmi_pdev_srg_obss_color_enable_bitmap(struct ath12k *ar, 3642 + u32 pdev_id, const u32 *bitmap) 3643 + { 3644 + struct wmi_pdev_set_obss_bitmap_arg arg = { 3645 + .tlv_tag = WMI_TAG_PDEV_SRG_OBSS_COLOR_ENABLE_BITMAP_CMD, 3646 + .pdev_id = pdev_id, 3647 + .cmd_id = WMI_PDEV_SET_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID, 3648 + .bitmap = bitmap, 3649 + .label = "SRG obss color enable bitmap", 3650 + }; 3651 + 3652 + return ath12k_wmi_pdev_set_obss_bitmap(ar, &arg); 3653 + } 3654 + 3655 + int ath12k_wmi_pdev_srg_obss_bssid_enable_bitmap(struct ath12k *ar, 3656 + u32 pdev_id, const u32 *bitmap) 3657 + { 3658 + struct wmi_pdev_set_obss_bitmap_arg arg = { 3659 + .tlv_tag = WMI_TAG_PDEV_SRG_OBSS_BSSID_ENABLE_BITMAP_CMD, 3660 + .pdev_id = pdev_id, 3661 + .cmd_id = WMI_PDEV_SET_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID, 3662 + .bitmap = bitmap, 3663 + .label = "SRG obss bssid enable bitmap", 3664 + }; 3665 + 3666 + return ath12k_wmi_pdev_set_obss_bitmap(ar, &arg); 3667 + } 3668 + 3669 + int ath12k_wmi_pdev_non_srg_obss_color_enable_bitmap(struct ath12k *ar, 3670 + u32 pdev_id, const u32 *bitmap) 3671 + { 3672 + struct wmi_pdev_set_obss_bitmap_arg arg = { 3673 + .tlv_tag = WMI_TAG_PDEV_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMD, 3674 + .pdev_id = pdev_id, 3675 + .cmd_id = WMI_PDEV_SET_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID, 3676 + .bitmap = bitmap, 3677 + .label = "non SRG obss color enable bitmap", 3678 + }; 3679 + 3680 + return ath12k_wmi_pdev_set_obss_bitmap(ar, &arg); 3681 + } 3682 + 3683 + int ath12k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(struct ath12k *ar, 3684 + u32 pdev_id, const u32 *bitmap) 3685 + { 3686 + struct wmi_pdev_set_obss_bitmap_arg arg = { 3687 + .tlv_tag = WMI_TAG_PDEV_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMD, 3688 + .pdev_id = pdev_id, 3689 + .cmd_id = WMI_PDEV_SET_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID, 3690 + .bitmap = bitmap, 3691 + .label = "non SRG obss bssid enable bitmap", 3692 + }; 3693 + 3694 + return ath12k_wmi_pdev_set_obss_bitmap(ar, &arg); 3569 3695 } 3570 3696 3571 3697 int ath12k_wmi_obss_color_cfg_cmd(struct ath12k *ar, u32 vdev_id,
+47
drivers/net/wireless/ath/ath12k/wmi.h
··· 374 374 WMI_PDEV_DMA_RING_CFG_REQ_CMDID, 375 375 WMI_PDEV_HE_TB_ACTION_FRM_CMDID, 376 376 WMI_PDEV_PKTLOG_FILTER_CMDID, 377 + WMI_PDEV_SET_SRG_BSS_COLOR_BITMAP_CMDID = 0x403b, 378 + WMI_PDEV_SET_SRG_PARTIAL_BSSID_BITMAP_CMDID, 379 + WMI_PDEV_SET_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID, 380 + WMI_PDEV_SET_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID, 381 + WMI_PDEV_SET_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID, 382 + WMI_PDEV_SET_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID, 377 383 WMI_PDEV_SET_BIOS_SAR_TABLE_CMDID = 0x4044, 378 384 WMI_PDEV_SET_BIOS_GEO_TABLE_CMDID = 0x4045, 379 385 WMI_PDEV_SET_BIOS_INTERFACE_CMDID = 0x404A, ··· 1082 1076 WMI_PDEV_PARAM_RADIO_CHAN_STATS_ENABLE, 1083 1077 WMI_PDEV_PARAM_RADIO_DIAGNOSIS_ENABLE, 1084 1078 WMI_PDEV_PARAM_MESH_MCAST_ENABLE, 1079 + WMI_PDEV_PARAM_SET_CMD_OBSS_PD_THRESHOLD = 0xbc, 1080 + WMI_PDEV_PARAM_SET_CMD_OBSS_PD_PER_AC = 0xbe, 1081 + WMI_PDEV_PARAM_ENABLE_SR_PROHIBIT = 0xc6, 1085 1082 }; 1086 1083 1087 1084 enum wmi_tlv_vdev_param { ··· 1996 1987 WMI_TAG_SERVICE_READY_EXT2_EVENT = 0x334, 1997 1988 WMI_TAG_FILS_DISCOVERY_TMPL_CMD = 0x344, 1998 1989 WMI_TAG_MAC_PHY_CAPABILITIES_EXT = 0x36F, 1990 + WMI_TAG_PDEV_SRG_BSS_COLOR_BITMAP_CMD = 0x37b, 1991 + WMI_TAG_PDEV_SRG_PARTIAL_BSSID_BITMAP_CMD, 1992 + WMI_TAG_PDEV_SRG_OBSS_COLOR_ENABLE_BITMAP_CMD = 0x381, 1993 + WMI_TAG_PDEV_SRG_OBSS_BSSID_ENABLE_BITMAP_CMD, 1994 + WMI_TAG_PDEV_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMD, 1995 + WMI_TAG_PDEV_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMD, 1999 1996 WMI_TAG_REGULATORY_RULE_EXT_STRUCT = 0x3A9, 2000 1997 WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT, 2001 1998 WMI_TAG_TPC_STATS_GET_CMD = 0x38B, ··· 2259 2244 WMI_TLV_SERVICE_FREQINFO_IN_METADATA = 219, 2260 2245 WMI_TLV_SERVICE_EXT2_MSG = 220, 2261 2246 WMI_TLV_SERVICE_BEACON_PROTECTION_SUPPORT = 244, 2247 + WMI_TLV_SERVICE_SRG_SRP_SPATIAL_REUSE_SUPPORT = 249, 2262 2248 WMI_TLV_SERVICE_MBSS_PARAM_IN_VDEV_START_SUPPORT = 253, 2263 2249 2264 2250 WMI_MAX_EXT_SERVICE = 256, ··· 4941 4925 __le32 vdev_id; 4942 4926 } __packed; 4943 4927 4928 + struct wmi_pdev_obss_pd_bitmap_cmd { 4929 + __le32 tlv_header; 4930 + __le32 pdev_id; 4931 + __le32 bitmap[2]; 4932 + } __packed; 4933 + 4944 4934 #define ATH12K_BSS_COLOR_COLLISION_SCAN_PERIOD_MS 200 4945 4935 #define ATH12K_OBSS_COLOR_COLLISION_DETECTION_DISABLE 0 4946 4936 #define ATH12K_OBSS_COLOR_COLLISION_DETECTION 1 ··· 6351 6329 /* each WMI cmd can hold 58 channel entries at most */ 6352 6330 #define ATH12K_WMI_MAX_NUM_CHAN_PER_CMD 58 6353 6331 6332 + #define ATH12K_OBSS_PD_THRESHOLD_IN_DBM BIT(29) 6333 + #define ATH12K_OBSS_PD_SRG_EN BIT(30) 6334 + #define ATH12K_OBSS_PD_NON_SRG_EN BIT(31) 6335 + 6336 + struct ath12k_wmi_obss_pd_arg { 6337 + bool srp_support; 6338 + bool srg_enabled; 6339 + bool non_srg_enabled; 6340 + s8 srg_th; 6341 + s8 non_srg_th; 6342 + }; 6343 + 6354 6344 int ath12k_wmi_cmd_send(struct ath12k_wmi_pdev *wmi, struct sk_buff *skb, 6355 6345 u32 cmd_id); 6356 6346 struct sk_buff *ath12k_wmi_alloc_skb(struct ath12k_wmi_base *wmi_sc, u32 len); ··· 6466 6432 int ath12k_wmi_send_twt_disable_cmd(struct ath12k *ar, u32 pdev_id); 6467 6433 int ath12k_wmi_send_obss_spr_cmd(struct ath12k *ar, u32 vdev_id, 6468 6434 struct ieee80211_he_obss_pd *he_obss_pd); 6435 + u32 ath12k_wmi_build_obss_pd(const struct ath12k_wmi_obss_pd_arg *arg); 6436 + int ath12k_wmi_pdev_set_srg_bss_color_bitmap(struct ath12k *ar, u32 pdev_id, 6437 + const u32 *bitmap); 6438 + int ath12k_wmi_pdev_set_srg_partial_bssid_bitmap(struct ath12k *ar, u32 pdev_id, 6439 + const u32 *bitmap); 6440 + int ath12k_wmi_pdev_srg_obss_color_enable_bitmap(struct ath12k *ar, u32 pdev_id, 6441 + const u32 *bitmap); 6442 + int ath12k_wmi_pdev_srg_obss_bssid_enable_bitmap(struct ath12k *ar, u32 pdev_id, 6443 + const u32 *bitmap); 6444 + int ath12k_wmi_pdev_non_srg_obss_color_enable_bitmap(struct ath12k *ar, u32 pdev_id, 6445 + const u32 *bitmap); 6446 + int ath12k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(struct ath12k *ar, u32 pdev_id, 6447 + const u32 *bitmap); 6469 6448 int ath12k_wmi_obss_color_cfg_cmd(struct ath12k *ar, u32 vdev_id, 6470 6449 u8 bss_color, u32 period, 6471 6450 bool enable);