Re: [PATCH 46/50] wifi: ath12k: add wmi.c

Kalle Valo
2022-11-08T15:40:20Z

Ping-Ke Shih <pkshih@realtek.com> writes:

>> -----Original Message-----
>> From: Kalle Valo <kvalo@kernel.org>
>> Sent: Saturday, August 13, 2022 12:10 AM
>> To: linux-wireless@vger.kernel.org
>> Cc: ath12k@lists.infradead.org
>> Subject: [PATCH 46/50] wifi: ath12k: add wmi.c
>>
>> From: Kalle Valo <quic_kvalo@quicinc.com>
>>
>> (Patches split into one patch per file for easier review, but the final
>> commit will be one big patch. See the cover letter for more info.)
>>
>> Signed-off-by: Kalle Valo <quic_kvalo@quicinc.com>
>> ---
>> drivers/net/wireless/ath/ath12k/wmi.c | 6558 +++++++++++++++++++++++++++++++++
>> 1 file changed, 6558 insertions(+)
>>
>> diff --git a/drivers/net/wireless/ath/ath12k/wmi.c
>> b/drivers/net/wireless/ath/ath12k/wmi.c
>> new file mode 100644
>> index 000000000000..82aaedb5d0af
>> --- /dev/null
>> +++ b/drivers/net/wireless/ath/ath12k/wmi.c
>> @@ -0,0 +1,6558 @@
>
> [...]
>
>> +
>> +static int ath12k_pull_svc_ready_ext(struct ath12k_wmi_pdev *wmi_handle,
>> + const void *ptr,
>> + struct ath12k_wmi_service_ext_arg *arg)
>> +{
>> + const struct wmi_service_ready_ext_event *ev = ptr;
>> +
>> + if (!ev)
>> + return -EINVAL;
>> +
>> + /* Move this to host based bitmap */
>> + arg->default_conc_scan_config_bits =
>> + le32_to_cpu(ev->default_conc_scan_config_bits);
>> + arg->default_fw_config_bits = le32_to_cpu(ev->default_fw_config_bits);
>> + arg->he_cap_info = le32_to_cpu(ev->he_cap_info);
>> + arg->mpdu_density = le32_to_cpu(ev->mpdu_density);
>> + arg->max_bssid_rx_filters = le32_to_cpu(ev->max_bssid_rx_filters);
>> + memcpy(&arg->ppet, &ev->ppet, sizeof(arg->ppet));
>
> Originally, I would like to say the memcpy() statement can be replaced by
> arg->ppet = ev->ppet;
>
> But I found the struct(s) are different:
>
> arg->ppet is
>
> struct ath12k_wmi_ppe_threshold_arg {
> u32 numss_m1;
> u32 ru_bit_mask;
> u32 ppet16_ppet8_ru3_ru0[PSOC_HOST_MAX_NUM_SS];
> };
>
> ev->ppet is
>
> struct ath12k_wmi_ppe_threshold_params {
> __le32 numss_m1; /** NSS - 1*/
> union {
> __le32 ru_count;
> __le32 ru_mask;
> } __packed;
> __le32 ppet16_ppet8_ru3_ru0[WMI_MAX_NUM_SS];
> } __packed;
>
> Then, using memcpy() doesn't work on big-endian machine.

This is now fixed like this:

arg->ppet.numss_m1 = le32_to_cpu(ev->ppet.numss_m1);
arg->ppet.ru_bit_mask = le32_to_cpu(ev->ppet.ru_info);

for (i = 0; i < PSOC_HOST_MAX_NUM_SS; i++)
arg->ppet.ppet16_ppet8_ru3_ru0[i] =
le32_to_cpu(ev->ppet.ppet16_ppet8_ru3_ru0[i]);

But now the code assumes that both PSOC_HOST_MAX_NUM_SS and
WMI_MAX_NUM_SS are 8, which is not a safe assumption without a proper
check. I think the best would be to remove PSOC_HOST_MAX_NUM_SS and use
MAX_HE_NSS everywhere. I added that to the todo list.

>> +static int
>> +ath12k_pull_mac_phy_cap_svc_ready_ext(struct ath12k_wmi_pdev *wmi_handle,
>> + struct ath12k_wmi_svc_rdy_ext_parse *svc,
>> + u8 hw_mode_id, u8 phy_id,
>> + struct ath12k_pdev *pdev)
>> +{
>> + const struct ath12k_wmi_mac_phy_caps_params *mac_phy_caps;
>> + const struct ath12k_wmi_soc_mac_phy_hw_mode_caps_params *hw_caps =
>> svc->hw_caps;
>> + const struct ath12k_wmi_hw_mode_cap_params *wmi_hw_mode_caps =
>> svc->hw_mode_caps;
>> + const struct ath12k_wmi_mac_phy_caps_params *wmi_mac_phy_caps =
>> svc->mac_phy_caps;
>> + struct ath12k_band_cap *cap_band;
>> + struct ath12k_pdev_cap *pdev_cap = &pdev->cap;
>> + u32 phy_map;
>> + u32 hw_idx, phy_idx = 0;
>> +
>> + if (!hw_caps || !wmi_hw_mode_caps || !svc->soc_hal_reg_caps)
>> + return -EINVAL;
>> +
>> + for (hw_idx = 0; hw_idx < le32_to_cpu(hw_caps->num_hw_modes); hw_idx++) {
>> + if (hw_mode_id == le32_to_cpu(wmi_hw_mode_caps[hw_idx].hw_mode_id))
>> + break;
>> +
>> + phy_map = le32_to_cpu(wmi_hw_mode_caps[hw_idx].phy_id_map);
>> + while (phy_map) {
>> + phy_map >>= 1;
>> + phy_idx++;
>> + }
>
> phy_idx = fls(phy_map)

Fixed.

>> + if (le32_to_cpu(mac_phy_caps->supported_bands) & WMI_HOST_WLAN_2G_CAP) {
>> + cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
>> + cap_band->phy_id = le32_to_cpu(mac_phy_caps->phy_id);
>> + cap_band->max_bw_supported =
>> + le32_to_cpu(mac_phy_caps->max_bw_supported_2g);
>> + cap_band->ht_cap_info = le32_to_cpu(mac_phy_caps->ht_cap_info_2g);
>> + cap_band->he_cap_info[0] = le32_to_cpu(mac_phy_caps->he_cap_info_2g);
>> + cap_band->he_cap_info[1] =
>> le32_to_cpu(mac_phy_caps->he_cap_info_2g_ext);
>> + cap_band->he_mcs = le32_to_cpu(mac_phy_caps->he_supp_mcs_2g);
>> + memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_2g,
>> + sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
>> + memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet2g,
>> + sizeof(struct ath12k_wmi_ppe_threshold_arg));
>
> These two copy __le32 to u32.

These are now replaced with a loop using le32_to_cpu().

>> + if (le32_to_cpu(mac_phy_caps->supported_bands) & WMI_HOST_WLAN_5G_CAP) {
>> + cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
>> + cap_band->phy_id = le32_to_cpu(mac_phy_caps->phy_id);
>> + cap_band->max_bw_supported =
>> + le32_to_cpu(mac_phy_caps->max_bw_supported_5g);
>> + cap_band->ht_cap_info = le32_to_cpu(mac_phy_caps->ht_cap_info_5g);
>> + cap_band->he_cap_info[0] = le32_to_cpu(mac_phy_caps->he_cap_info_5g);
>> + cap_band->he_cap_info[1] =
>> le32_to_cpu(mac_phy_caps->he_cap_info_5g_ext);
>> + cap_band->he_mcs = le32_to_cpu(mac_phy_caps->he_supp_mcs_5g);
>> + memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g,
>> + sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
>> + memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet5g,
>> + sizeof(struct ath12k_wmi_ppe_threshold_arg));
>
> copy __le32 to u32

This is also fixed.

>> +
>> + cap_band = &pdev_cap->band[NL80211_BAND_6GHZ];
>> + cap_band->max_bw_supported =
>> + le32_to_cpu(mac_phy_caps->max_bw_supported_5g);
>> + cap_band->ht_cap_info = le32_to_cpu(mac_phy_caps->ht_cap_info_5g);
>> + cap_band->he_cap_info[0] = le32_to_cpu(mac_phy_caps->he_cap_info_5g);
>> + cap_band->he_cap_info[1] =
>> le32_to_cpu(mac_phy_caps->he_cap_info_5g_ext);
>> + cap_band->he_mcs = le32_to_cpu(mac_phy_caps->he_supp_mcs_5g);
>> + memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g,
>> + sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
>> + memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet5g,
>> + sizeof(struct ath12k_wmi_ppe_threshold_arg));
>
> and, these two.

And this is fixed as well.

> It seems like we don't have a simple way to convert struct with __le32 to
> another struct with cpu order. The only way is to convert fields of struct
> one by one.

Yeah, at least I can't think of any other solution.

>> +int ath12k_wmi_mgmt_send(struct ath12k *ar, u32 vdev_id, u32 buf_id,
>> + struct sk_buff *frame)
>> +{
>> + struct ath12k_wmi_pdev *wmi = ar->wmi;
>> + struct wmi_mgmt_send_cmd *cmd;
>> + struct wmi_tlv *frame_tlv;
>> + struct sk_buff *skb;
>> + u32 buf_len;
>> + int ret, len;
>> +
>> + buf_len = frame->len < WMI_MGMT_SEND_DOWNLD_LEN ?
>> + frame->len : WMI_MGMT_SEND_DOWNLD_LEN;
>
> buf_len = min(frame->len, WMI_MGMT_SEND_DOWNLD_LEN);

Fixed.

>> +int ath12k_wmi_vdev_install_key(struct ath12k *ar,
>> + struct wmi_vdev_install_key_arg *arg)
>> +{
>> + struct ath12k_wmi_pdev *wmi = ar->wmi;
>> + struct wmi_vdev_install_key_cmd *cmd;
>> + struct wmi_tlv *tlv;
>> + struct sk_buff *skb;
>> + int ret, len;
>> + int key_len_aligned = roundup(arg->key_len, sizeof(uint32_t));
>
> Not sure why 'uint32_t'? Maybe, just '4' like other wmi functions.

Yeah, we changed that to '4'.

> mac80211 defines
> struct ieee80211_key_conf {
> u8 key[];
> };
>
> And, this driver defines
> struct wmi_vdev_install_key_arg {
> const void *key_data;
> };
>
>> +
>> + len = sizeof(*cmd) + TLV_HDR_SIZE + key_len_aligned;
>> +
>> + skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, len);
>> + if (!skb)
>> + return -ENOMEM;
>> +
>> + cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
>> + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_VDEV_INSTALL_KEY_CMD,
>> + sizeof(*cmd));
>> + cmd->vdev_id = cpu_to_le32(arg->vdev_id);
>> + ether_addr_copy(cmd->peer_macaddr.addr, arg->macaddr);
>> + cmd->key_idx = cpu_to_le32(arg->key_idx);
>> + cmd->key_flags = cpu_to_le32(arg->key_flags);
>> + cmd->key_cipher = cpu_to_le32(arg->key_cipher);
>> + cmd->key_len = cpu_to_le32(arg->key_len);
>> + cmd->key_txmic_len = cpu_to_le32(arg->key_txmic_len);
>> + cmd->key_rxmic_len = cpu_to_le32(arg->key_rxmic_len);
>> +
>> + if (arg->key_rsc_counter)
>> + cmd->key_rsc_counter = cpu_to_le64(arg->key_rsc_counter);
>> +
>> + tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
>> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_BYTE, key_len_aligned);
>> + memcpy(tlv->value, arg->key_data, key_len_aligned);
>
> If arg->key_len wasn't align of 4, this could access out of range of arg->key_data.

Yeah, this doesn't look right. Added this to the todo list.

>> +int ath12k_wmi_send_peer_assoc_cmd(struct ath12k *ar,
>> + struct ath12k_wmi_peer_assoc_arg *arg)
>> +{
>> + struct ath12k_wmi_pdev *wmi = ar->wmi;
>> + struct wmi_peer_assoc_complete_cmd *cmd;
>> + struct ath12k_wmi_vht_rate_set_params *mcs;
>> + struct ath12k_wmi_he_rate_set_params *he_mcs;
>> + struct sk_buff *skb;
>> + struct wmi_tlv *tlv;
>> + void *ptr;
>> + u32 peer_legacy_rates_align;
>> + u32 peer_ht_rates_align;
>> + int i, ret, len;
>> +
>> + peer_legacy_rates_align = roundup(arg->peer_legacy_rates.num_rates,
>> + sizeof(u32));
>> + peer_ht_rates_align = roundup(arg->peer_ht_rates.num_rates,
>> + sizeof(u32));
>> +
>> + len = sizeof(*cmd) +
>> + TLV_HDR_SIZE + (peer_legacy_rates_align * sizeof(u8)) +
>> + TLV_HDR_SIZE + (peer_ht_rates_align * sizeof(u8)) +
>> + sizeof(*mcs) + TLV_HDR_SIZE +
>> + (sizeof(*he_mcs) * arg->peer_he_mcs_count);
>> +
>> + skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, len);
>> + if (!skb)
>> + return -ENOMEM;
>> +
>> + ptr = skb->data;
>> +
>> + cmd = ptr;
>> + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_PEER_ASSOC_COMPLETE_CMD,
>> + sizeof(*cmd));
>> +
>> + cmd->vdev_id = cpu_to_le32(arg->vdev_id);
>> +
>> + cmd->peer_new_assoc = cpu_to_le32(arg->peer_new_assoc);
>> + cmd->peer_associd = cpu_to_le32(arg->peer_associd);
>> +
>> + ath12k_wmi_copy_peer_flags(cmd, arg,
>> + test_bit(ATH12K_FLAG_HW_CRYPTO_DISABLED,
>> + &ar->ab->dev_flags));
>> +
>> + ether_addr_copy(cmd->peer_macaddr.addr, arg->peer_mac);
>> +
>> + cmd->peer_rate_caps = cpu_to_le32(arg->peer_rate_caps);
>> + cmd->peer_caps = cpu_to_le32(arg->peer_caps);
>> + cmd->peer_listen_intval = cpu_to_le32(arg->peer_listen_intval);
>> + cmd->peer_ht_caps = cpu_to_le32(arg->peer_ht_caps);
>> + cmd->peer_max_mpdu = cpu_to_le32(arg->peer_max_mpdu);
>> + cmd->peer_mpdu_density = cpu_to_le32(arg->peer_mpdu_density);
>> + cmd->peer_vht_caps = cpu_to_le32(arg->peer_vht_caps);
>> + cmd->peer_phymode = cpu_to_le32(arg->peer_phymode);
>> +
>> + /* Update 11ax capabilities */
>> + cmd->peer_he_cap_info = cpu_to_le32(arg->peer_he_cap_macinfo[0]);
>> + cmd->peer_he_cap_info_ext = cpu_to_le32(arg->peer_he_cap_macinfo[1]);
>> + cmd->peer_he_cap_info_internal =
>> cpu_to_le32(arg->peer_he_cap_macinfo_internal);
>> + cmd->peer_he_caps_6ghz = cpu_to_le32(arg->peer_he_caps_6ghz);
>> + cmd->peer_he_ops = cpu_to_le32(arg->peer_he_ops);
>> + memcpy(&cmd->peer_he_cap_phy, &arg->peer_he_cap_phyinfo,
>> + sizeof(arg->peer_he_cap_phyinfo));
>> + memcpy(&cmd->peer_ppet, &arg->peer_ppet,
>> + sizeof(arg->peer_ppet));
>
> copy u32 to __le32

Fixed.

>> +int ath12k_wmi_send_scan_start_cmd(struct ath12k *ar,
>> + struct ath12k_wmi_scan_req_arg *arg)
>> +{
>> + struct ath12k_wmi_pdev *wmi = ar->wmi;
>> + struct wmi_start_scan_cmd *cmd;
>> + struct ath12k_wmi_ssid_params *ssid = NULL;
>> + struct ath12k_wmi_mac_addr_params *bssid;
>> + struct sk_buff *skb;
>> + struct wmi_tlv *tlv;
>> + void *ptr;
>> + int i, ret, len;
>> + u32 *tmp_ptr;
>> + u8 extraie_len_with_pad = 0;
>> + struct ath12k_wmi_hint_short_ssid_arg *s_ssid = NULL;
>> + struct ath12k_wmi_hint_bssid_arg *hint_bssid = NULL;
>> +
>> + len = sizeof(*cmd);
>> +
>> + len += TLV_HDR_SIZE;
>> + if (arg->num_chan)
>> + len += arg->num_chan * sizeof(u32);
>> +
>> + len += TLV_HDR_SIZE;
>> + if (arg->num_ssids)
>> + len += arg->num_ssids * sizeof(*ssid);
>> +
>> + len += TLV_HDR_SIZE;
>> + if (arg->num_bssid)
>> + len += sizeof(*bssid) * arg->num_bssid;
>> +
>> + len += TLV_HDR_SIZE;
>> + if (arg->extraie.len)
>> + extraie_len_with_pad =
>> + roundup(arg->extraie.len, sizeof(u32));
>> + len += extraie_len_with_pad;
>> +
>> + if (arg->num_hint_bssid)
>> + len += TLV_HDR_SIZE +
>> + arg->num_hint_bssid * sizeof(*hint_bssid);
>> +
>> + if (arg->num_hint_s_ssid)
>> + len += TLV_HDR_SIZE +
>> + arg->num_hint_s_ssid * sizeof(*s_ssid);
>> +
>> + skb = ath12k_wmi_alloc_skb(wmi->wmi_ab, len);
>> + if (!skb)
>> + return -ENOMEM;
>> +
>> + ptr = skb->data;
>> +
>> + cmd = ptr;
>> + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_START_SCAN_CMD,
>> + sizeof(*cmd));
>> +
>> + cmd->scan_id = cpu_to_le32(arg->scan_id);
>> + cmd->scan_req_id = cpu_to_le32(arg->scan_req_id);
>> + cmd->vdev_id = cpu_to_le32(arg->vdev_id);
>> + cmd->scan_priority = cpu_to_le32(arg->scan_priority);
>> + cmd->notify_scan_events = cpu_to_le32(arg->notify_scan_events);
>> +
>> + ath12k_wmi_copy_scan_event_cntrl_flags(cmd, arg);
>> +
>> + cmd->dwell_time_active = cpu_to_le32(arg->dwell_time_active);
>> + cmd->dwell_time_active_2g = cpu_to_le32(arg->dwell_time_active_2g);
>> + cmd->dwell_time_passive = cpu_to_le32(arg->dwell_time_passive);
>> + cmd->dwell_time_active_6g = cpu_to_le32(arg->dwell_time_active_6g);
>> + cmd->dwell_time_passive_6g = cpu_to_le32(arg->dwell_time_passive_6g);
>> + cmd->min_rest_time = cpu_to_le32(arg->min_rest_time);
>> + cmd->max_rest_time = cpu_to_le32(arg->max_rest_time);
>> + cmd->repeat_probe_time = cpu_to_le32(arg->repeat_probe_time);
>> + cmd->probe_spacing_time = cpu_to_le32(arg->probe_spacing_time);
>> + cmd->idle_time = cpu_to_le32(arg->idle_time);
>> + cmd->max_scan_time = cpu_to_le32(arg->max_scan_time);
>> + cmd->probe_delay = cpu_to_le32(arg->probe_delay);
>> + cmd->burst_duration = cpu_to_le32(arg->burst_duration);
>> + cmd->num_chan = cpu_to_le32(arg->num_chan);
>> + cmd->num_bssid = cpu_to_le32(arg->num_bssid);
>> + cmd->num_ssids = cpu_to_le32(arg->num_ssids);
>> + cmd->ie_len = cpu_to_le32(arg->extraie.len);
>> + cmd->n_probes = cpu_to_le32(arg->n_probes);
>> +
>> + ptr += sizeof(*cmd);
>> +
>> + len = arg->num_chan * sizeof(u32);
>> +
>> + tlv = ptr;
>> + tlv->header = ath12k_wmi_tlv_hdr(WMI_TAG_ARRAY_UINT32, len);
>> + ptr += TLV_HDR_SIZE;
>> + tmp_ptr = (u32 *)ptr;
>> +
>> + for (i = 0; i < arg->num_chan; ++i)
>> + tmp_ptr[i] = arg->chan_list[i];
>
> nit.
> memcpy(tmp_ptr, arg->chan_list, arg->num_chan);

Heh, indeed. But we added '* 4':

memcpy(tmp_ptr, arg->chan_list, arg->num_chan * 4)

>> +int ath12k_wmi_send_scan_chan_list_cmd(struct ath12k *ar,
>> + struct ath12k_wmi_scan_chan_list_arg *arg)
>> +{
>> + struct ath12k_wmi_pdev *wmi = ar->wmi;
>> + struct wmi_scan_chan_list_cmd *cmd;
>> + struct sk_buff *skb;
>> + struct ath12k_wmi_channel_params *chan_info;
>> + struct ath12k_wmi_channel_arg *channel_arg;
>> + struct wmi_tlv *tlv;
>> + void *ptr;
>> + int i, ret, len;
>> + u16 num_send_chans, num_sends = 0, max_chan_limit = 0;
>> + __le32 *reg1, *reg2;
>> +
>> + channel_arg = &arg->channel[0];
>> + while (arg->nallchans) {
>> + len = sizeof(*cmd) + TLV_HDR_SIZE;
>> + max_chan_limit = (wmi->wmi_ab->max_msg_len[ar->pdev_idx] - len) /
>> + sizeof(*chan_info);
>> +
>> + if (arg->nallchans > max_chan_limit)
>> + num_send_chans = max_chan_limit;
>> + else
>> + num_send_chans = arg->nallchans;
>
> num_send_chans = min(arg->nallchans, max_chan_limit);

Fixed.

>> +static void
>> +ath12k_wmi_copy_resource_config(struct ath12k_wmi_resource_config_params *wmi_cfg,
>> + struct ath12k_wmi_resource_config_arg *tg_cfg)
>> +{
>> + wmi_cfg->num_vdevs = cpu_to_le32(tg_cfg->num_vdevs);
>> + wmi_cfg->num_peers = cpu_to_le32(tg_cfg->num_peers);
>> + wmi_cfg->num_offload_peers = cpu_to_le32(tg_cfg->num_offload_peers);
>> + wmi_cfg->num_offload_reorder_buffs =
>> + cpu_to_le32(tg_cfg->num_offload_reorder_buffs);
>> + wmi_cfg->num_peer_keys = cpu_to_le32(tg_cfg->num_peer_keys);
>> + wmi_cfg->num_tids = cpu_to_le32(tg_cfg->num_tids);
>> + wmi_cfg->ast_skid_limit = cpu_to_le32(tg_cfg->ast_skid_limit);
>> + wmi_cfg->tx_chain_mask = cpu_to_le32(tg_cfg->tx_chain_mask);
>> + wmi_cfg->rx_chain_mask = cpu_to_le32(tg_cfg->rx_chain_mask);
>> + wmi_cfg->rx_timeout_pri[0] = cpu_to_le32(tg_cfg->rx_timeout_pri[0]);
>> + wmi_cfg->rx_timeout_pri[1] = cpu_to_le32(tg_cfg->rx_timeout_pri[1]);
>> + wmi_cfg->rx_timeout_pri[2] = cpu_to_le32(tg_cfg->rx_timeout_pri[2]);
>> + wmi_cfg->rx_timeout_pri[3] = cpu_to_le32(tg_cfg->rx_timeout_pri[3]);
>> + wmi_cfg->rx_decap_mode = cpu_to_le32(tg_cfg->rx_decap_mode);
>> + wmi_cfg->scan_max_pending_req = cpu_to_le32(tg_cfg->scan_max_pending_req);
>> + wmi_cfg->bmiss_offload_max_vdev = cpu_to_le32(tg_cfg->bmiss_offload_max_vdev);
>> + wmi_cfg->roam_offload_max_vdev = cpu_to_le32(tg_cfg->roam_offload_max_vdev);
>> + wmi_cfg->roam_offload_max_ap_profiles =
>> + cpu_to_le32(tg_cfg->roam_offload_max_ap_profiles);
>> + wmi_cfg->num_mcast_groups = cpu_to_le32(tg_cfg->num_mcast_groups);
>> + wmi_cfg->num_mcast_table_elems = cpu_to_le32(tg_cfg->num_mcast_table_elems);
>> + wmi_cfg->mcast2ucast_mode = cpu_to_le32(tg_cfg->mcast2ucast_mode);
>> + wmi_cfg->tx_dbg_log_size = cpu_to_le32(tg_cfg->tx_dbg_log_size);
>> + wmi_cfg->num_wds_entries = cpu_to_le32(tg_cfg->num_wds_entries);
>> + wmi_cfg->dma_burst_size = cpu_to_le32(tg_cfg->dma_burst_size);
>> + wmi_cfg->mac_aggr_delim = cpu_to_le32(tg_cfg->mac_aggr_delim);
>> + wmi_cfg->rx_skip_defrag_timeout_dup_detection_check =
>> + cpu_to_le32(tg_cfg->rx_skip_defrag_timeout_dup_detection_check);
>> + wmi_cfg->vow_config = cpu_to_le32(tg_cfg->vow_config);
>> + wmi_cfg->gtk_offload_max_vdev = cpu_to_le32(tg_cfg->gtk_offload_max_vdev);
>> + wmi_cfg->num_msdu_desc = cpu_to_le32(tg_cfg->num_msdu_desc);
>> + wmi_cfg->max_frag_entries = cpu_to_le32(tg_cfg->max_frag_entries);
>> + wmi_cfg->num_tdls_vdevs = cpu_to_le32(tg_cfg->num_tdls_vdevs);
>> + wmi_cfg->num_tdls_conn_table_entries =
>> + cpu_to_le32(tg_cfg->num_tdls_conn_table_entries);
>> + wmi_cfg->beacon_tx_offload_max_vdev =
>> + cpu_to_le32(tg_cfg->beacon_tx_offload_max_vdev);
>> + wmi_cfg->num_multicast_filter_entries =
>> + cpu_to_le32(tg_cfg->num_multicast_filter_entries);
>> + wmi_cfg->num_wow_filters = cpu_to_le32(tg_cfg->num_wow_filters);
>> + wmi_cfg->num_keep_alive_pattern = cpu_to_le32(tg_cfg->num_keep_alive_pattern);
>> + wmi_cfg->keep_alive_pattern_size =
>> cpu_to_le32(tg_cfg->keep_alive_pattern_size);
>> + wmi_cfg->max_tdls_concurrent_sleep_sta =
>> + cpu_to_le32(tg_cfg->max_tdls_concurrent_sleep_sta);
>> + wmi_cfg->max_tdls_concurrent_buffer_sta =
>> + cpu_to_le32(tg_cfg->max_tdls_concurrent_buffer_sta);
>> + wmi_cfg->wmi_send_separate = cpu_to_le32(tg_cfg->wmi_send_separate);
>> + wmi_cfg->num_ocb_vdevs = cpu_to_le32(tg_cfg->num_ocb_vdevs);
>> + wmi_cfg->num_ocb_channels = cpu_to_le32(tg_cfg->num_ocb_channels);
>> + wmi_cfg->num_ocb_schedules = cpu_to_le32(tg_cfg->num_ocb_schedules);
>> + wmi_cfg->bpf_instruction_size = cpu_to_le32(tg_cfg->bpf_instruction_size);
>> + wmi_cfg->max_bssid_rx_filters = cpu_to_le32(tg_cfg->max_bssid_rx_filters);
>> + wmi_cfg->use_pdev_id = cpu_to_le32(tg_cfg->use_pdev_id);
>> + wmi_cfg->flag1 = cpu_to_le32(tg_cfg->atf_config);
>> + wmi_cfg->peer_map_unmap_version = cpu_to_le32(tg_cfg->peer_map_unmap_version);
>> + wmi_cfg->sched_params = cpu_to_le32(tg_cfg->sched_params);
>> + wmi_cfg->twt_ap_pdev_count = cpu_to_le32(tg_cfg->twt_ap_pdev_count);
>> + wmi_cfg->twt_ap_sta_count = cpu_to_le32(tg_cfg->twt_ap_sta_count);
>> + wmi_cfg->host_service_flags |=
>> + cpu_to_le32(1 << WMI_RSRC_CFG_HOST_SVC_FLAG_REG_CC_EXT_SUPPORT_BIT);
>
> Why not just '=' instead of '|=' ?

Fixed.

>> +int ath12k_wmi_pdev_lro_cfg(struct ath12k *ar,
>> + int pdev_id)
>> +{
>> + struct ath12k_wmi_pdev_lro_config_cmd *cmd;
>> + struct sk_buff *skb;
>> + int ret;
>> +
>> + skb = ath12k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
>> + if (!skb)
>> + return -ENOMEM;
>> +
>> + cmd = (struct ath12k_wmi_pdev_lro_config_cmd *)skb->data;
>> + cmd->tlv_header = ath12k_wmi_tlv_cmd_hdr(WMI_TAG_LRO_INFO_CMD,
>> + sizeof(*cmd));
>> +
>> + get_random_bytes(cmd->th_4, sizeof(uint32_t) * ATH12K_IPV4_TH_SEED_SIZE);
>> + get_random_bytes(cmd->th_6, sizeof(uint32_t) * ATH12K_IPV6_TH_SEED_SIZE);
>
> get_random_bytes(cmd->th_4, sizeof(cmd->th_4));
> get_random_bytes(cmd->th_6, sizeof(cmd->th_6));

Fixed.

>> +static int ath12k_wmi_hw_mode_caps_parse(struct ath12k_base *soc,
>> + u16 tag, u16 len,
>> + const void *ptr, void *data)
>> +{
>> + struct ath12k_wmi_svc_rdy_ext_parse *svc_rdy_ext = data;
>> + struct ath12k_wmi_hw_mode_cap_params *hw_mode_cap;
>> + u32 phy_map = 0;
>> +
>> + if (tag != WMI_TAG_HW_MODE_CAPABILITIES)
>> + return -EPROTO;
>> +
>> + if (svc_rdy_ext->n_hw_mode_caps >= svc_rdy_ext->arg.num_hw_modes)
>> + return -ENOBUFS;
>> +
>> + hw_mode_cap = container_of(ptr, struct ath12k_wmi_hw_mode_cap_params,
>> + hw_mode_id);
>> + svc_rdy_ext->n_hw_mode_caps++;
>> +
>> + phy_map = le32_to_cpu(hw_mode_cap->phy_id_map);
>> + while (phy_map) {
>> + svc_rdy_ext->tot_phy_id++;
>> + phy_map = phy_map >> 1;
>> + }
>
> svc_rdy_ext->tot_phy_id = fls(phy_map);
> or
> svc_rdy_ext->tot_phy_id += fls(phy_map);

We chose the latter:

phy_map = le32_to_cpu(hw_mode_cap->phy_id_map);
svc_rdy_ext->tot_phy_id += fls(phy_map);

>> +static int ath12k_wmi_hw_mode_caps(struct ath12k_base *soc,
>> + u16 len, const void *ptr, void *data)
>> +{
>> + struct ath12k_wmi_svc_rdy_ext_parse *svc_rdy_ext = data;
>> + const struct ath12k_wmi_hw_mode_cap_params *hw_mode_caps;
>> + enum wmi_host_hw_mode_config_type mode, pref;
>> + u32 i;
>> + int ret;
>> +
>> + svc_rdy_ext->n_hw_mode_caps = 0;
>> + svc_rdy_ext->hw_mode_caps = ptr;
>> +
>> + ret = ath12k_wmi_tlv_iter(soc, ptr, len,
>> + ath12k_wmi_hw_mode_caps_parse,
>> + svc_rdy_ext);
>> + if (ret) {
>> + ath12k_warn(soc, "failed to parse tlv %d\n", ret);
>> + return ret;
>> + }
>> +
>> + i = 0;
>> + while (i < svc_rdy_ext->n_hw_mode_caps) {
>
> for (i = 0; i < svc_rdy_ext->n_hw_mode_caps; i++) {

Fixed.

>> + hw_mode_caps = &svc_rdy_ext->hw_mode_caps[i];
>> + mode = le32_to_cpu(hw_mode_caps->hw_mode_id);
>> + pref = soc->wmi_ab.preferred_hw_mode;
>> +
>> + if (ath12k_hw_mode_pri_map[mode] < ath12k_hw_mode_pri_map[pref]) {
>> + svc_rdy_ext->pref_hw_mode_caps = *hw_mode_caps;
>> + soc->wmi_ab.preferred_hw_mode = mode;
>> + }
>> + i++;
>
> With 'for', remove this i++.

Done.

>> +static int ath12k_wmi_ext_hal_reg_caps(struct ath12k_base *soc,
>> + u16 len, const void *ptr, void *data)
>> +{
>> + struct ath12k_wmi_pdev *wmi_handle = &soc->wmi_ab.wmi[0];
>> + struct ath12k_wmi_svc_rdy_ext_parse *svc_rdy_ext = data;
>> + struct ath12k_wmi_hal_reg_capabilities_ext_arg reg_cap;
>> + int ret;
>> + u32 i;
>> +
>> + svc_rdy_ext->n_ext_hal_reg_caps = 0;
>> + svc_rdy_ext->ext_hal_reg_caps = ptr;
>> + ret = ath12k_wmi_tlv_iter(soc, ptr, len,
>> + ath12k_wmi_ext_hal_reg_caps_parse,
>> + svc_rdy_ext);
>> + if (ret) {
>> + ath12k_warn(soc, "failed to parse tlv %d\n", ret);
>> + return ret;
>> + }
>> +
>> + for (i = 0; i < svc_rdy_ext->arg.num_phy; i++) {
>> + ret = ath12k_pull_reg_cap_svc_rdy_ext(wmi_handle,
>> + svc_rdy_ext->soc_hal_reg_caps,
>> + svc_rdy_ext->ext_hal_reg_caps, i,
>> + &reg_cap);
>> + if (ret) {
>> + ath12k_warn(soc, "failed to extract reg cap %d\n", i);
>> + return ret;
>> + }
>> +
>> + memcpy(&soc->hal_reg_cap[reg_cap.phy_id],
>> + &reg_cap, sizeof(reg_cap));
>
> soc->hal_reg_cap[reg_cap.phy_id] = reg_cap;

Fixed.

>> +static int ath12k_reg_chan_list_event(struct ath12k_base *ab, struct sk_buff *skb)
>> +{
>
> [...]
>
>> +
>> + /* Avoid multiple overwrites to default regd, during core
>> + * stop-start after mac registration.
>> + */
>> + if (ab->default_regd[pdev_idx] && !ab->new_regd[pdev_idx] &&
>> + !memcmp((char *)ab->default_regd[pdev_idx]->alpha2,
>> + (char *)reg_info->alpha2, 2))
>
> cast "(char *)" is unnecessary.

Fixed.

>> + goto mem_free;
>> +
>> + /* Intersect new rules with default regd if a new country setting was
>> + * requested, i.e a default regd was already set during initialization
>> + * and the regd coming from this event has a valid country info.
>> + */
>
> [...]
>
>> +
>> +static void ath12k_mgmt_rx_event(struct ath12k_base *ab, struct sk_buff *skb)
>> +{
>
> [...]
>
>> +
>> + if ((test_bit(ATH12K_CAC_RUNNING, &ar->dev_flags)) ||
>> + (rx_ev.status & (WMI_RX_STATUS_ERR_DECRYPT |
>> + WMI_RX_STATUS_ERR_KEY_CACHE_MISS | WMI_RX_STATUS_ERR_CRC))) {
>
> nit: coding style
>
> if ((test_bit(ATH12K_CAC_RUNNING, &ar->dev_flags)) ||
> (rx_ev.status & (WMI_RX_STATUS_ERR_DECRYPT |
> WMI_RX_STATUS_ERR_KEY_CACHE_MISS |
> WMI_RX_STATUS_ERR_CRC))) {

Fixed.

>> +static int ath12k_connect_pdev_htc_service(struct ath12k_base *ab,
>> + u32 pdev_idx)
>> +{
>> + int status;
>> + u32 svc_id[] = { ATH12K_HTC_SVC_ID_WMI_CONTROL,
>> + ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1,
>> + ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC2 };
>> +
>
> nit.
> coding style: no blank line within declaration.

Fixed.

Thank you very much for the good comments!

--