| /****************************************************************************** |
| * |
| * Copyright(c) 2015 Intel Deutschland GmbH |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name Intel Corporation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| *****************************************************************************/ |
| #include "src/connectivity/wlan/drivers/third_party/intel/iwlwifi/fw/api/tof.h" |
| #include "src/connectivity/wlan/drivers/third_party/intel/iwlwifi/mvm/mvm.h" |
| |
| #define IWL_MVM_TOF_RANGE_REQ_MAX_ID 256 |
| |
| void iwl_mvm_tof_init(struct iwl_mvm* mvm) { |
| #if 0 // NEEDS_PORTING |
| struct iwl_mvm_tof_data* tof_data = &mvm->tof_data; |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT)) { return; } |
| |
| memset(tof_data, 0, sizeof(*tof_data)); |
| |
| tof_data->tof_cfg.sub_grp_cmd_id = cpu_to_le32(TOF_CONFIG_CMD); |
| |
| #ifdef CPTCFG_IWLWIFI_DEBUGFS |
| if (IWL_MVM_TOF_IS_RESPONDER) { |
| tof_data->responder_cfg.sub_grp_cmd_id = cpu_to_le32(TOF_RESPONDER_CONFIG_CMD); |
| tof_data->responder_cfg.sta_id = IWL_MVM_INVALID_STA; |
| } |
| #endif |
| |
| tof_data->range_req.sub_grp_cmd_id = cpu_to_le32(TOF_RANGE_REQ_CMD); |
| tof_data->range_req.req_timeout = 1; |
| tof_data->range_req.initiator = 1; |
| tof_data->range_req.report_policy = 3; |
| |
| tof_data->range_req_ext.sub_grp_cmd_id = cpu_to_le32(TOF_RANGE_REQ_EXT_CMD); |
| |
| mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID; |
| mvm->init_status |= IWL_MVM_INIT_STATUS_TOF_INIT_COMPLETE; |
| #endif // NEEDS_PORTING |
| } |
| |
| void iwl_mvm_tof_clean(struct iwl_mvm* mvm) { |
| struct iwl_mvm_tof_data* tof_data = &mvm->tof_data; |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT) || |
| !(mvm->init_status & IWL_MVM_INIT_STATUS_TOF_INIT_COMPLETE)) { |
| return; |
| } |
| |
| memset(tof_data, 0, sizeof(*tof_data)); |
| mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID; |
| mvm->init_status &= ~IWL_MVM_INIT_STATUS_TOF_INIT_COMPLETE; |
| } |
| |
| #if 0 // NEEDS_PORTING |
| static void iwl_tof_iterator(void* _data, uint8_t* mac, struct ieee80211_vif* vif) { |
| bool* enabled = _data; |
| |
| /* non bss vif exists */ |
| if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) { *enabled = false; } |
| } |
| |
| int iwl_mvm_tof_config_cmd(struct iwl_mvm* mvm) { |
| struct iwl_tof_config_cmd* cmd = &mvm->tof_data.tof_cfg; |
| bool enabled; |
| |
| lockdep_assert_held(&mvm->mutex); |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT)) { return -EINVAL; } |
| |
| ieee80211_iterate_active_interfaces_atomic(mvm->hw, IEEE80211_IFACE_ITER_NORMAL, |
| iwl_tof_iterator, &enabled); |
| if (!enabled) { |
| IWL_DEBUG_INFO(mvm, "ToF is not supported (non bss vif)\n"); |
| return -EINVAL; |
| } |
| |
| mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID; |
| return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD, IWL_ALWAYS_LONG_GROUP, 0), 0, sizeof(*cmd), |
| cmd); |
| } |
| |
| int iwl_mvm_tof_range_abort_cmd(struct iwl_mvm* mvm, uint8_t id) { |
| struct iwl_tof_range_abort_cmd cmd = { |
| .sub_grp_cmd_id = cpu_to_le32(TOF_RANGE_ABORT_CMD), |
| .request_id = id, |
| }; |
| |
| lockdep_assert_held(&mvm->mutex); |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT)) { return -EINVAL; } |
| |
| if (id != mvm->tof_data.active_range_request) { |
| IWL_ERR(mvm, "Invalid range request id %d (active %d)\n", id, |
| mvm->tof_data.active_range_request); |
| return -EINVAL; |
| } |
| |
| /* after abort is sent there's no active request anymore */ |
| mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID; |
| |
| return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD, IWL_ALWAYS_LONG_GROUP, 0), 0, sizeof(cmd), |
| &cmd); |
| } |
| |
| #ifdef CPTCFG_IWLWIFI_DEBUGFS |
| int iwl_mvm_tof_responder_cmd(struct iwl_mvm* mvm, struct ieee80211_vif* vif) { |
| struct iwl_tof_responder_config_cmd* cmd = &mvm->tof_data.responder_cfg; |
| struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif); |
| |
| lockdep_assert_held(&mvm->mutex); |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT)) { return -EINVAL; } |
| |
| if (vif->p2p || vif->type != NL80211_IFTYPE_AP || !mvmvif->ap_ibss_active) { |
| IWL_ERR(mvm, "Cannot start responder, not in AP mode\n"); |
| return -EIO; |
| } |
| |
| cmd->sta_id = mvmvif->bcast_sta.sta_id; |
| memcpy(cmd->bssid, vif->addr, ETH_ALEN); |
| return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD, IWL_ALWAYS_LONG_GROUP, 0), 0, sizeof(*cmd), |
| cmd); |
| } |
| #endif |
| |
| int iwl_mvm_tof_range_request_cmd(struct iwl_mvm* mvm, struct ieee80211_vif* vif) { |
| struct iwl_host_cmd cmd = { |
| .id = iwl_cmd_id(TOF_CMD, IWL_ALWAYS_LONG_GROUP, 0), |
| .len = |
| { |
| sizeof(mvm->tof_data.range_req), |
| }, |
| /* no copy because of the command size */ |
| .dataflags = |
| { |
| IWL_HCMD_DFL_NOCOPY, |
| }, |
| }; |
| |
| lockdep_assert_held(&mvm->mutex); |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT)) { return -EINVAL; } |
| |
| if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) { |
| IWL_ERR(mvm, "Cannot send range request, not STA mode\n"); |
| return -EIO; |
| } |
| |
| /* nesting of range requests is not supported in FW */ |
| if (mvm->tof_data.active_range_request != IWL_MVM_TOF_RANGE_REQ_MAX_ID) { |
| IWL_ERR(mvm, "Cannot send range req, already active req %d\n", |
| mvm->tof_data.active_range_request); |
| return -EIO; |
| } |
| |
| mvm->tof_data.active_range_request = mvm->tof_data.range_req.request_id; |
| |
| cmd.data[0] = &mvm->tof_data.range_req; |
| return iwl_mvm_send_cmd(mvm, &cmd); |
| } |
| |
| int iwl_mvm_tof_range_request_ext_cmd(struct iwl_mvm* mvm, struct ieee80211_vif* vif) { |
| lockdep_assert_held(&mvm->mutex); |
| |
| if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT)) { return -EINVAL; } |
| |
| if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) { |
| IWL_ERR(mvm, "Cannot send ext range req, not in STA mode\n"); |
| return -EIO; |
| } |
| |
| return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD, IWL_ALWAYS_LONG_GROUP, 0), 0, |
| sizeof(mvm->tof_data.range_req_ext), &mvm->tof_data.range_req_ext); |
| } |
| |
| static int iwl_mvm_tof_range_resp(struct iwl_mvm* mvm, void* data) { |
| struct iwl_tof_range_rsp_ntfy* resp = (void*)data; |
| |
| if (resp->request_id != mvm->tof_data.active_range_request) { |
| IWL_ERR(mvm, "Request id mismatch, got %d, active %d\n", resp->request_id, |
| mvm->tof_data.active_range_request); |
| return -EIO; |
| } |
| |
| memcpy(&mvm->tof_data.range_resp, resp, sizeof(struct iwl_tof_range_rsp_ntfy)); |
| mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID; |
| |
| return 0; |
| } |
| |
| static int iwl_mvm_tof_mcsi_notif(struct iwl_mvm* mvm, void* data) { |
| struct iwl_tof_mcsi_notif* resp = (struct iwl_tof_mcsi_notif*)data; |
| |
| IWL_DEBUG_INFO(mvm, "MCSI notification, token %d\n", resp->token); |
| return 0; |
| } |
| |
| static int iwl_mvm_tof_nb_report_notif(struct iwl_mvm* mvm, void* data) { |
| struct iwl_tof_neighbor_report* report = (struct iwl_tof_neighbor_report*)data; |
| |
| IWL_DEBUG_INFO(mvm, "NB report, bssid %pM, token %d, status 0x%x\n", report->bssid, |
| report->request_token, report->status); |
| return 0; |
| } |
| |
| void iwl_mvm_tof_resp_handler(struct iwl_mvm* mvm, struct iwl_rx_cmd_buffer* rxb) { |
| struct iwl_rx_packet* pkt = rxb_addr(rxb); |
| struct iwl_tof_gen_resp_cmd* resp = (void*)pkt->data; |
| |
| lockdep_assert_held(&mvm->mutex); |
| |
| switch (le32_to_cpu(resp->sub_grp_cmd_id)) { |
| case TOF_RANGE_RESPONSE_NOTIF: |
| iwl_mvm_tof_range_resp(mvm, resp->data); |
| break; |
| case TOF_MCSI_DEBUG_NOTIF: |
| iwl_mvm_tof_mcsi_notif(mvm, resp->data); |
| break; |
| case TOF_NEIGHBOR_REPORT_RSP_NOTIF: |
| iwl_mvm_tof_nb_report_notif(mvm, resp->data); |
| break; |
| default: |
| IWL_ERR(mvm, "Unknown sub-group command 0x%x\n", resp->sub_grp_cmd_id); |
| break; |
| } |
| } |
| #endif // NEEDS_PORTING |