[linux-block.git] / drivers / net / wireless / intel / iwlwifi / mvm / tof.c

/******************************************************************************
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2015 Intel Deutschland GmbH
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called COPYING.
 *
 * Contact Information:
 * Intel Linux Wireless <linuxwifi@intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * 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 "mvm.h"
#include "fw-api-tof.h"

#define IWL_MVM_TOF_RANGE_REQ_MAX_ID 256

void iwl_mvm_tof_init(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))
		return;

	memset(tof_data, 0, sizeof(*tof_data));

	tof_data->tof_cfg.sub_grp_cmd_id = cpu_to_le32(TOF_CONFIG_CMD);

#ifdef CONFIG_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;
}

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))
		return;

	memset(tof_data, 0, sizeof(*tof_data));
	mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID;
}

static void iwl_tof_iterator(void *_data, u8 *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, u8 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 CONFIG_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;
	}
}
Commit	Line	Data
ce792918 GG	1	/******************************************************************************
	2	*
	3	* This file is provided under a dual BSD/GPLv2 license. When using or
	4	* redistributing this file, you may do so under either license.
	5	*
	6	* GPL LICENSE SUMMARY
	7	*
	8	* Copyright(c) 2015 Intel Deutschland GmbH
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of version 2 of the GNU General Public License as
	12	* published by the Free Software Foundation.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
	22	* USA
	23	*
	24	* The full GNU General Public License is included in this distribution
	25	* in the file called COPYING.
	26	*
	27	* Contact Information:
cb2f8277	28	* Intel Linux Wireless <linuxwifi@intel.com>
ce792918 GG	29	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	30	*
	31	* BSD LICENSE
	32	*
	33	* Copyright(c) 2015 Intel Deutschland GmbH
	34	* All rights reserved.
	35	*
	36	* Redistribution and use in source and binary forms, with or without
	37	* modification, are permitted provided that the following conditions
	38	* are met:
	39	*
	40	* * Redistributions of source code must retain the above copyright
	41	* notice, this list of conditions and the following disclaimer.
	42	* * Redistributions in binary form must reproduce the above copyright
	43	* notice, this list of conditions and the following disclaimer in
	44	* the documentation and/or other materials provided with the
	45	* distribution.
	46	* * Neither the name Intel Corporation nor the names of its
	47	* contributors may be used to endorse or promote products derived
	48	* from this software without specific prior written permission.
	49	*
	50	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	51	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	52	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	53	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	54	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	55	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	56	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	57	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	58	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	59	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	60	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	61	*
	62	*****************************************************************************/
	63	#include "mvm.h"
	64	#include "fw-api-tof.h"
	65
	66	#define IWL_MVM_TOF_RANGE_REQ_MAX_ID 256
	67
	68	void iwl_mvm_tof_init(struct iwl_mvm *mvm)
	69	{
	70	struct iwl_mvm_tof_data *tof_data = &mvm->tof_data;
	71
	72	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	73	return;
	74
	75	memset(tof_data, 0, sizeof(*tof_data));
	76
ce792918 GG	77	tof_data->tof_cfg.sub_grp_cmd_id = cpu_to_le32(TOF_CONFIG_CMD);
	78
	79	#ifdef CONFIG_IWLWIFI_DEBUGFS
	80	if (IWL_MVM_TOF_IS_RESPONDER) {
ce792918 GG	81	tof_data->responder_cfg.sub_grp_cmd_id =
ce792918 GG	82	cpu_to_le32(TOF_RESPONDER_CONFIG_CMD);
0ae98812	83	tof_data->responder_cfg.sta_id = IWL_MVM_INVALID_STA;
ce792918 GG	84	}
	85	#endif
	86
ce792918 GG	87	tof_data->range_req.sub_grp_cmd_id = cpu_to_le32(TOF_RANGE_REQ_CMD);
	88	tof_data->range_req.req_timeout = 1;
	89	tof_data->range_req.initiator = 1;
	90	tof_data->range_req.report_policy = 3;
	91
ce792918 GG	92	tof_data->range_req_ext.sub_grp_cmd_id =
	93	cpu_to_le32(TOF_RANGE_REQ_EXT_CMD);
	94
	95	mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID;
	96	}
	97
	98	void iwl_mvm_tof_clean(struct iwl_mvm *mvm)
	99	{
	100	struct iwl_mvm_tof_data *tof_data = &mvm->tof_data;
	101
	102	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	103	return;
	104
	105	memset(tof_data, 0, sizeof(*tof_data));
	106	mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID;
	107	}
	108
	109	static void iwl_tof_iterator(void _data, u8 mac,
	110	struct ieee80211_vif *vif)
	111	{
	112	bool *enabled = _data;
	113
	114	/* non bss vif exists */
	115	if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION)
	116	*enabled = false;
	117	}
	118
	119	int iwl_mvm_tof_config_cmd(struct iwl_mvm *mvm)
	120	{
	121	struct iwl_tof_config_cmd *cmd = &mvm->tof_data.tof_cfg;
	122	bool enabled;
	123
	124	lockdep_assert_held(&mvm->mutex);
	125
	126	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	127	return -EINVAL;
	128
	129	ieee80211_iterate_active_interfaces_atomic(mvm->hw,
	130	IEEE80211_IFACE_ITER_NORMAL,
	131	iwl_tof_iterator, &enabled);
	132	if (!enabled) {
	133	IWL_DEBUG_INFO(mvm, "ToF is not supported (non bss vif)\n");
	134	return -EINVAL;
	135	}
	136
	137	mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID;
88742c9e JB	138	return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD,
	139	IWL_ALWAYS_LONG_GROUP, 0),
	140	0, sizeof(*cmd), cmd);
ce792918 GG	141	}
	142
	143	int iwl_mvm_tof_range_abort_cmd(struct iwl_mvm *mvm, u8 id)
	144	{
	145	struct iwl_tof_range_abort_cmd cmd = {
	146	.sub_grp_cmd_id = cpu_to_le32(TOF_RANGE_ABORT_CMD),
ce792918 GG	147	.request_id = id,
	148	};
	149
	150	lockdep_assert_held(&mvm->mutex);
	151
	152	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	153	return -EINVAL;
	154
	155	if (id != mvm->tof_data.active_range_request) {
	156	IWL_ERR(mvm, "Invalid range request id %d (active %d)\n",
	157	id, mvm->tof_data.active_range_request);
	158	return -EINVAL;
	159	}
	160
	161	/* after abort is sent there's no active request anymore */
	162	mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID;
	163
88742c9e JB	164	return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD,
	165	IWL_ALWAYS_LONG_GROUP, 0),
	166	0, sizeof(cmd), &cmd);
ce792918 GG	167	}
	168
	169	#ifdef CONFIG_IWLWIFI_DEBUGFS
	170	int iwl_mvm_tof_responder_cmd(struct iwl_mvm *mvm,
	171	struct ieee80211_vif *vif)
	172	{
	173	struct iwl_tof_responder_config_cmd *cmd = &mvm->tof_data.responder_cfg;
	174	struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
	175
	176	lockdep_assert_held(&mvm->mutex);
	177
	178	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	179	return -EINVAL;
	180
da583fdf JB	181	if (vif->p2p \|\| vif->type != NL80211_IFTYPE_AP \|\|
da583fdf JB	182	!mvmvif->ap_ibss_active) {
ce792918 GG	183	IWL_ERR(mvm, "Cannot start responder, not in AP mode\n");
	184	return -EIO;
	185	}
	186
	187	cmd->sta_id = mvmvif->bcast_sta.sta_id;
9ef2b8be	188	memcpy(cmd->bssid, vif->addr, ETH_ALEN);
88742c9e JB	189	return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD,
	190	IWL_ALWAYS_LONG_GROUP, 0),
	191	0, sizeof(*cmd), cmd);
ce792918 GG	192	}
	193	#endif
	194
	195	int iwl_mvm_tof_range_request_cmd(struct iwl_mvm *mvm,
	196	struct ieee80211_vif *vif)
	197	{
	198	struct iwl_host_cmd cmd = {
eed6e971	199	.id = iwl_cmd_id(TOF_CMD, IWL_ALWAYS_LONG_GROUP, 0),
ce792918 GG	200	.len = { sizeof(mvm->tof_data.range_req), },
	201	/* no copy because of the command size */
	202	.dataflags = { IWL_HCMD_DFL_NOCOPY, },
	203	};
	204
	205	lockdep_assert_held(&mvm->mutex);
	206
	207	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	208	return -EINVAL;
	209
	210	if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) {
	211	IWL_ERR(mvm, "Cannot send range request, not STA mode\n");
	212	return -EIO;
	213	}
	214
	215	/* nesting of range requests is not supported in FW */
	216	if (mvm->tof_data.active_range_request !=
	217	IWL_MVM_TOF_RANGE_REQ_MAX_ID) {
	218	IWL_ERR(mvm, "Cannot send range req, already active req %d\n",
	219	mvm->tof_data.active_range_request);
	220	return -EIO;
	221	}
	222
	223	mvm->tof_data.active_range_request = mvm->tof_data.range_req.request_id;
	224
	225	cmd.data[0] = &mvm->tof_data.range_req;
	226	return iwl_mvm_send_cmd(mvm, &cmd);
	227	}
	228
	229	int iwl_mvm_tof_range_request_ext_cmd(struct iwl_mvm *mvm,
	230	struct ieee80211_vif *vif)
	231	{
	232	lockdep_assert_held(&mvm->mutex);
	233
	234	if (!fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TOF_SUPPORT))
	235	return -EINVAL;
	236
	237	if (ieee80211_vif_type_p2p(vif) != NL80211_IFTYPE_STATION) {
	238	IWL_ERR(mvm, "Cannot send ext range req, not in STA mode\n");
	239	return -EIO;
	240	}
	241
88742c9e JB	242	return iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(TOF_CMD,
	243	IWL_ALWAYS_LONG_GROUP, 0),
	244	0, sizeof(mvm->tof_data.range_req_ext),
ce792918 GG	245	&mvm->tof_data.range_req_ext);
	246	}
	247
	248	static int iwl_mvm_tof_range_resp(struct iwl_mvm mvm, void data)
	249	{
	250	struct iwl_tof_range_rsp_ntfy resp = (void )data;
	251
	252	if (resp->request_id != mvm->tof_data.active_range_request) {
	253	IWL_ERR(mvm, "Request id mismatch, got %d, active %d\n",
	254	resp->request_id, mvm->tof_data.active_range_request);
	255	return -EIO;
	256	}
	257
	258	memcpy(&mvm->tof_data.range_resp, resp,
	259	sizeof(struct iwl_tof_range_rsp_ntfy));
	260	mvm->tof_data.active_range_request = IWL_MVM_TOF_RANGE_REQ_MAX_ID;
	261
	262	return 0;
	263	}
	264
	265	static int iwl_mvm_tof_mcsi_notif(struct iwl_mvm mvm, void data)
	266	{
	267	struct iwl_tof_mcsi_notif resp = (struct iwl_tof_mcsi_notif )data;
	268
	269	IWL_DEBUG_INFO(mvm, "MCSI notification, token %d\n", resp->token);
	270	return 0;
	271	}
	272
	273	static int iwl_mvm_tof_nb_report_notif(struct iwl_mvm mvm, void data)
	274	{
	275	struct iwl_tof_neighbor_report *report =
	276	(struct iwl_tof_neighbor_report *)data;
	277
	278	IWL_DEBUG_INFO(mvm, "NB report, bssid %pM, token %d, status 0x%x\n",
	279	report->bssid, report->request_token, report->status);
	280	return 0;
	281	}
	282
	283	void iwl_mvm_tof_resp_handler(struct iwl_mvm *mvm,
	284	struct iwl_rx_cmd_buffer *rxb)
	285	{
	286	struct iwl_rx_packet *pkt = rxb_addr(rxb);
	287	struct iwl_tof_gen_resp_cmd resp = (void )pkt->data;
	288
	289	lockdep_assert_held(&mvm->mutex);
	290
	291	switch (le32_to_cpu(resp->sub_grp_cmd_id)) {
	292	case TOF_RANGE_RESPONSE_NOTIF:
	293	iwl_mvm_tof_range_resp(mvm, resp->data);
	294	break;
	295	case TOF_MCSI_DEBUG_NOTIF:
	296	iwl_mvm_tof_mcsi_notif(mvm, resp->data);
	297	break;
	298	case TOF_NEIGHBOR_REPORT_RSP_NOTIF:
	299	iwl_mvm_tof_nb_report_notif(mvm, resp->data);
	300	break;
	301	default:
	302	IWL_ERR(mvm, "Unknown sub-group command 0x%x\n",
	303	resp->sub_grp_cmd_id);
	304	break;
	305	}
	306	}