[deliverable/linux.git] / drivers / net / wireless / iwlwifi / mvm / bt-coex.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) 2013 Intel Corporation. All rights reserved.
 *
 * 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 <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2013 Intel Corporation. All rights reserved.
 * 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 "fw-api-bt-coex.h"
#include "iwl-modparams.h"
#include "mvm.h"
#include "iwl-debug.h"

#define EVENT_PRIO_ANT(_evt, _prio, _shrd_ant)			\
	[(_evt)] = (((_prio) << BT_COEX_PRIO_TBL_PRIO_POS) |	\
		   ((_shrd_ant) << BT_COEX_PRIO_TBL_SHRD_ANT_POS))

static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB1,
		       BT_COEX_PRIO_TBL_PRIO_BYPASS, 0),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB2,
		       BT_COEX_PRIO_TBL_PRIO_BYPASS, 1),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW1,
		       BT_COEX_PRIO_TBL_PRIO_LOW, 0),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW2,
		       BT_COEX_PRIO_TBL_PRIO_LOW, 1),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH1,
		       BT_COEX_PRIO_TBL_PRIO_HIGH, 0),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH2,
		       BT_COEX_PRIO_TBL_PRIO_HIGH, 1),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_DTIM,
		       BT_COEX_PRIO_TBL_DISABLED, 0),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN52,
		       BT_COEX_PRIO_TBL_PRIO_COEX_OFF, 0),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN24,
		       BT_COEX_PRIO_TBL_PRIO_COEX_ON, 0),
	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_IDLE,
		       BT_COEX_PRIO_TBL_PRIO_COEX_IDLE, 0),
	0, 0, 0, 0, 0, 0,
};

#undef EVENT_PRIO_ANT

int iwl_send_bt_prio_tbl(struct iwl_mvm *mvm)
{
	return iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PRIO_TABLE, CMD_SYNC,
				    sizeof(struct iwl_bt_coex_prio_tbl_cmd),
				    &iwl_bt_prio_tbl);
}

static int iwl_send_bt_env(struct iwl_mvm *mvm, u8 action, u8 type)
{
	struct iwl_bt_coex_prot_env_cmd env_cmd;
	int ret;

	env_cmd.action = action;
	env_cmd.type = type;
	ret = iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PROT_ENV, CMD_SYNC,
				   sizeof(env_cmd), &env_cmd);
	if (ret)
		IWL_ERR(mvm, "failed to send BT env command\n");
	return ret;
}

enum iwl_bt_kill_msk {
	BT_KILL_MSK_DEFAULT,
	BT_KILL_MSK_SCO_HID_A2DP,
	BT_KILL_MSK_REDUCED_TXPOW,
	BT_KILL_MSK_MAX,
};

static const u32 iwl_bt_ack_kill_msk[BT_KILL_MSK_MAX] = {
	0xffffffff,
	0xfffffc00,
	0,
};

static const u32 iwl_bt_cts_kill_msk[BT_KILL_MSK_MAX] = {
	0xffffffff,
	0xfffffc00,
	0,
};

#define IWL_BT_DEFAULT_BOOST (0xf0f0f0f0)

/* Tight Coex */
static const __le32 iwl_tight_lookup[BT_COEX_LUT_SIZE] = {
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaeaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xcc00ff28),
	cpu_to_le32(0x0000aaaa),
	cpu_to_le32(0xcc00aaaa),
	cpu_to_le32(0x0000aaaa),
	cpu_to_le32(0xc0004000),
	cpu_to_le32(0x00000000),
	cpu_to_le32(0xf0005000),
	cpu_to_le32(0xf0005000),
};

/* Loose Coex */
static const __le32 iwl_loose_lookup[BT_COEX_LUT_SIZE] = {
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaeaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xcc00ff28),
	cpu_to_le32(0x0000aaaa),
	cpu_to_le32(0xcc00aaaa),
	cpu_to_le32(0x0000aaaa),
	cpu_to_le32(0x00000000),
	cpu_to_le32(0x00000000),
	cpu_to_le32(0xf0005000),
	cpu_to_le32(0xf0005000),
};

/* Full concurrency */
static const __le32 iwl_concurrent_lookup[BT_COEX_LUT_SIZE] = {
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0xaaaaaaaa),
	cpu_to_le32(0x00000000),
	cpu_to_le32(0x00000000),
	cpu_to_le32(0x00000000),
	cpu_to_le32(0x00000000),
};

/* BT Antenna Coupling Threshold (dB) */
#define IWL_BT_ANTENNA_COUPLING_THRESHOLD	(35)

int iwl_send_bt_init_conf(struct iwl_mvm *mvm)
{
	struct iwl_bt_coex_cmd cmd = {
		.max_kill = 5,
		.bt3_time_t7_value = 1,
		.bt3_prio_sample_time = 2,
		.bt3_timer_t2_value = 0xc,
	};
	int ret;

	cmd.flags = iwlwifi_mod_params.bt_coex_active ?
			BT_COEX_NW : BT_COEX_DISABLE;
	cmd.flags |= iwlwifi_mod_params.bt_ch_announce ?
			BT_CH_PRIMARY_EN | BT_CH_SECONDARY_EN : 0;
	cmd.flags |= BT_SYNC_2_BT_DISABLE;

	cmd.valid_bit_msk = cpu_to_le16(BT_VALID_ENABLE |
					BT_VALID_BT_PRIO_BOOST |
					BT_VALID_MAX_KILL |
					BT_VALID_3W_TMRS |
					BT_VALID_KILL_ACK |
					BT_VALID_KILL_CTS |
					BT_VALID_REDUCED_TX_POWER |
					BT_VALID_LUT);

	if (iwlwifi_mod_params.ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD)
		memcpy(&cmd.decision_lut, iwl_loose_lookup,
		       sizeof(iwl_tight_lookup));
	else
		memcpy(&cmd.decision_lut, iwl_tight_lookup,
		       sizeof(iwl_tight_lookup));

	cmd.bt_prio_boost = cpu_to_le32(IWL_BT_DEFAULT_BOOST);
	cmd.kill_ack_msk =
		cpu_to_le32(iwl_bt_ack_kill_msk[BT_KILL_MSK_DEFAULT]);
	cmd.kill_cts_msk =
		cpu_to_le32(iwl_bt_cts_kill_msk[BT_KILL_MSK_DEFAULT]);

	/* go to CALIB state in internal BT-Coex state machine */
	ret = iwl_send_bt_env(mvm, BT_COEX_ENV_OPEN,
			      BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
	if (ret)
		return ret;

	ret  = iwl_send_bt_env(mvm, BT_COEX_ENV_CLOSE,
			       BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
	if (ret)
		return ret;

	return iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, CMD_SYNC,
				    sizeof(cmd), &cmd);
}

int iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
			     struct iwl_rx_cmd_buffer *rxb,
			     struct iwl_device_cmd *dev_cmd)
{
	struct iwl_rx_packet *pkt = rxb_addr(rxb);
	struct iwl_bt_coex_profile_notif *notif = (void *)pkt->data;
	struct iwl_bt_coex_cmd cmd = {};
	enum iwl_bt_kill_msk bt_kill_msk;

	IWL_DEBUG_COEX(mvm, "BT Coex Notification received\n");
	IWL_DEBUG_COEX(mvm, "\tBT %salive\n", notif->bt_status ? "" : "not ");
	IWL_DEBUG_COEX(mvm, "\tBT open conn %d\n", notif->bt_open_conn);
	IWL_DEBUG_COEX(mvm, "\tBT traffic load %d\n", notif->bt_traffic_load);
	IWL_DEBUG_COEX(mvm, "\tBT agg traffic load %d\n",
		       notif->bt_agg_traffic_load);
	IWL_DEBUG_COEX(mvm, "\tBT ci compliance %d\n", notif->bt_ci_compliance);

	/* Low latency BT profile is active: give higher prio to BT */
	if (BT_MBOX_MSG(notif, 3, SCO_STATE)  ||
	    BT_MBOX_MSG(notif, 3, A2DP_STATE) ||
	    BT_MBOX_MSG(notif, 3, SNIFF_STATE))
		bt_kill_msk = BT_KILL_MSK_SCO_HID_A2DP;
	else
		bt_kill_msk = BT_KILL_MSK_DEFAULT;

	/* Don't send HCMD if there is no update */
	if (bt_kill_msk == mvm->bt_kill_msk)
		return 0;

	IWL_DEBUG_COEX(mvm,
		       "Udpate kill_msk: %d\n\t SCO %sactive A2DP %sactive SNIFF %sactive\n",
		       bt_kill_msk,
		       BT_MBOX_MSG(notif, 3, SCO_STATE) ? "" : "in",
		       BT_MBOX_MSG(notif, 3, A2DP_STATE) ? "" : "in",
		       BT_MBOX_MSG(notif, 3, SNIFF_STATE) ? "" : "in");

	mvm->bt_kill_msk = bt_kill_msk;
	cmd.kill_ack_msk = cpu_to_le32(iwl_bt_ack_kill_msk[bt_kill_msk]);
	cmd.kill_cts_msk = cpu_to_le32(iwl_bt_cts_kill_msk[bt_kill_msk]);

	cmd.valid_bit_msk = cpu_to_le16(BT_VALID_KILL_ACK | BT_VALID_KILL_CTS);

	if (iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, CMD_SYNC, sizeof(cmd), &cmd))
		IWL_ERR(mvm, "Failed to sent BT Coex CMD\n");

	/* This handler is ASYNC */
	return 0;
}
Commit	Line	Data
931d4160 EG	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) 2013 Intel Corporation. All rights reserved.
	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:
	28	* Intel Linux Wireless <ilw@linux.intel.com>
	29	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	30	*
	31	* BSD LICENSE
	32	*
	33	* Copyright(c) 2013 Intel Corporation. All rights reserved.
	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
	64	#include "fw-api-bt-coex.h"
65	#include "iwl-modparams.h"
66	#include "mvm.h"
f421f9c3	67	#include "iwl-debug.h"
931d4160 EG	68
	69	#define EVENT_PRIO_ANT(_evt, _prio, _shrd_ant) \
	70	[(_evt)] = (((_prio) << BT_COEX_PRIO_TBL_PRIO_POS) \| \
	71	((_shrd_ant) << BT_COEX_PRIO_TBL_SHRD_ANT_POS))
	72
	73	static const u8 iwl_bt_prio_tbl[BT_COEX_PRIO_TBL_EVT_MAX] = {
	74	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB1,
	75	BT_COEX_PRIO_TBL_PRIO_BYPASS, 0),
	76	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_INIT_CALIB2,
	77	BT_COEX_PRIO_TBL_PRIO_BYPASS, 1),
	78	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW1,
	79	BT_COEX_PRIO_TBL_PRIO_LOW, 0),
	80	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_LOW2,
	81	BT_COEX_PRIO_TBL_PRIO_LOW, 1),
	82	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH1,
	83	BT_COEX_PRIO_TBL_PRIO_HIGH, 0),
	84	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_PERIODIC_CALIB_HIGH2,
	85	BT_COEX_PRIO_TBL_PRIO_HIGH, 1),
	86	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_DTIM,
	87	BT_COEX_PRIO_TBL_DISABLED, 0),
	88	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN52,
	89	BT_COEX_PRIO_TBL_PRIO_COEX_OFF, 0),
	90	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_SCAN24,
	91	BT_COEX_PRIO_TBL_PRIO_COEX_ON, 0),
	92	EVENT_PRIO_ANT(BT_COEX_PRIO_TBL_EVT_IDLE,
	93	BT_COEX_PRIO_TBL_PRIO_COEX_IDLE, 0),
	94	0, 0, 0, 0, 0, 0,
	95	};
	96
	97	#undef EVENT_PRIO_ANT
	98
	99	int iwl_send_bt_prio_tbl(struct iwl_mvm *mvm)
	100	{
	101	return iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PRIO_TABLE, CMD_SYNC,
	102	sizeof(struct iwl_bt_coex_prio_tbl_cmd),
	103	&iwl_bt_prio_tbl);
	104	}
	105
	106	static int iwl_send_bt_env(struct iwl_mvm *mvm, u8 action, u8 type)
	107	{
	108	struct iwl_bt_coex_prot_env_cmd env_cmd;
	109	int ret;
	110
	111	env_cmd.action = action;
	112	env_cmd.type = type;
	113	ret = iwl_mvm_send_cmd_pdu(mvm, BT_COEX_PROT_ENV, CMD_SYNC,
	114	sizeof(env_cmd), &env_cmd);
	115	if (ret)
	116	IWL_ERR(mvm, "failed to send BT env command\n");
	117	return ret;
	118	}
	119
	120	enum iwl_bt_kill_msk {
	121	BT_KILL_MSK_DEFAULT,
	122	BT_KILL_MSK_SCO_HID_A2DP,
	123	BT_KILL_MSK_REDUCED_TXPOW,
	124	BT_KILL_MSK_MAX,
	125	};
	126
	127	static const u32 iwl_bt_ack_kill_msk[BT_KILL_MSK_MAX] = {
	128	0xffffffff,
	129	0xfffffc00,
	130	0,
	131	};
132
133	static const u32 iwl_bt_cts_kill_msk[BT_KILL_MSK_MAX] = {
134	0xffffffff,
135	0xfffffc00,
136	0,
137	};
138
139	#define IWL_BT_DEFAULT_BOOST (0xf0f0f0f0)
140
141	/* Tight Coex */
142	static const __le32 iwl_tight_lookup[BT_COEX_LUT_SIZE] = {
143	cpu_to_le32(0xaaaaaaaa),
144	cpu_to_le32(0xaaaaaaaa),
145	cpu_to_le32(0xaeaaaaaa),
146	cpu_to_le32(0xaaaaaaaa),
147	cpu_to_le32(0xcc00ff28),
148	cpu_to_le32(0x0000aaaa),
149	cpu_to_le32(0xcc00aaaa),
150	cpu_to_le32(0x0000aaaa),
151	cpu_to_le32(0xc0004000),
152	cpu_to_le32(0x00000000),
153	cpu_to_le32(0xf0005000),
154	cpu_to_le32(0xf0005000),
155	};
156
157	/* Loose Coex */
158	static const __le32 iwl_loose_lookup[BT_COEX_LUT_SIZE] = {
159	cpu_to_le32(0xaaaaaaaa),
160	cpu_to_le32(0xaaaaaaaa),
161	cpu_to_le32(0xaeaaaaaa),
162	cpu_to_le32(0xaaaaaaaa),
163	cpu_to_le32(0xcc00ff28),
164	cpu_to_le32(0x0000aaaa),
165	cpu_to_le32(0xcc00aaaa),
166	cpu_to_le32(0x0000aaaa),
167	cpu_to_le32(0x00000000),
168	cpu_to_le32(0x00000000),
169	cpu_to_le32(0xf0005000),
170	cpu_to_le32(0xf0005000),
171	};
172
173	/* Full concurrency */
174	static const __le32 iwl_concurrent_lookup[BT_COEX_LUT_SIZE] = {
175	cpu_to_le32(0xaaaaaaaa),
176	cpu_to_le32(0xaaaaaaaa),
177	cpu_to_le32(0xaaaaaaaa),
178	cpu_to_le32(0xaaaaaaaa),
179	cpu_to_le32(0xaaaaaaaa),
180	cpu_to_le32(0xaaaaaaaa),
181	cpu_to_le32(0xaaaaaaaa),
182	cpu_to_le32(0xaaaaaaaa),
183	cpu_to_le32(0x00000000),
184	cpu_to_le32(0x00000000),
185	cpu_to_le32(0x00000000),
186	cpu_to_le32(0x00000000),
187	};
188
189	/* BT Antenna Coupling Threshold (dB) */
190	#define IWL_BT_ANTENNA_COUPLING_THRESHOLD (35)
191
192	int iwl_send_bt_init_conf(struct iwl_mvm *mvm)
193	{
194	struct iwl_bt_coex_cmd cmd = {
195	.max_kill = 5,
196	.bt3_time_t7_value = 1,
197	.bt3_prio_sample_time = 2,
198	.bt3_timer_t2_value = 0xc,
199	};
200	int ret;
201
202	cmd.flags = iwlwifi_mod_params.bt_coex_active ?
203	BT_COEX_NW : BT_COEX_DISABLE;
204	cmd.flags \|= iwlwifi_mod_params.bt_ch_announce ?
205	BT_CH_PRIMARY_EN \| BT_CH_SECONDARY_EN : 0;
206	cmd.flags \|= BT_SYNC_2_BT_DISABLE;
207
208	cmd.valid_bit_msk = cpu_to_le16(BT_VALID_ENABLE \|
209	BT_VALID_BT_PRIO_BOOST \|
210	BT_VALID_MAX_KILL \|
211	BT_VALID_3W_TMRS \|
212	BT_VALID_KILL_ACK \|
213	BT_VALID_KILL_CTS \|
214	BT_VALID_REDUCED_TX_POWER \|
215	BT_VALID_LUT);
216
217	if (iwlwifi_mod_params.ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD)
218	memcpy(&cmd.decision_lut, iwl_loose_lookup,
219	sizeof(iwl_tight_lookup));
220	else
221	memcpy(&cmd.decision_lut, iwl_tight_lookup,
222	sizeof(iwl_tight_lookup));
223
224	cmd.bt_prio_boost = cpu_to_le32(IWL_BT_DEFAULT_BOOST);
225	cmd.kill_ack_msk =
226	cpu_to_le32(iwl_bt_ack_kill_msk[BT_KILL_MSK_DEFAULT]);
227	cmd.kill_cts_msk =
228	cpu_to_le32(iwl_bt_cts_kill_msk[BT_KILL_MSK_DEFAULT]);
229
230	/* go to CALIB state in internal BT-Coex state machine */
231	ret = iwl_send_bt_env(mvm, BT_COEX_ENV_OPEN,
232	BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
233	if (ret)
234	return ret;
235
236	ret = iwl_send_bt_env(mvm, BT_COEX_ENV_CLOSE,
237	BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
238	if (ret)
239	return ret;
240
241	return iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, CMD_SYNC,
242	sizeof(cmd), &cmd);
243	}
f421f9c3 EG	244
	245	int iwl_mvm_rx_bt_coex_notif(struct iwl_mvm *mvm,
	246	struct iwl_rx_cmd_buffer *rxb,
	247	struct iwl_device_cmd *dev_cmd)
	248	{
	249	struct iwl_rx_packet *pkt = rxb_addr(rxb);
	250	struct iwl_bt_coex_profile_notif notif = (void )pkt->data;
	251	struct iwl_bt_coex_cmd cmd = {};
	252	enum iwl_bt_kill_msk bt_kill_msk;
	253
	254	IWL_DEBUG_COEX(mvm, "BT Coex Notification received\n");
	255	IWL_DEBUG_COEX(mvm, "\tBT %salive\n", notif->bt_status ? "" : "not ");
	256	IWL_DEBUG_COEX(mvm, "\tBT open conn %d\n", notif->bt_open_conn);
	257	IWL_DEBUG_COEX(mvm, "\tBT traffic load %d\n", notif->bt_traffic_load);
	258	IWL_DEBUG_COEX(mvm, "\tBT agg traffic load %d\n",
	259	notif->bt_agg_traffic_load);
	260	IWL_DEBUG_COEX(mvm, "\tBT ci compliance %d\n", notif->bt_ci_compliance);
	261
	262	/* Low latency BT profile is active: give higher prio to BT */
	263	if (BT_MBOX_MSG(notif, 3, SCO_STATE) \|\|
	264	BT_MBOX_MSG(notif, 3, A2DP_STATE) \|\|
	265	BT_MBOX_MSG(notif, 3, SNIFF_STATE))
	266	bt_kill_msk = BT_KILL_MSK_SCO_HID_A2DP;
	267	else
	268	bt_kill_msk = BT_KILL_MSK_DEFAULT;
	269
	270	/* Don't send HCMD if there is no update */
	271	if (bt_kill_msk == mvm->bt_kill_msk)
	272	return 0;
	273
	274	IWL_DEBUG_COEX(mvm,
	275	"Udpate kill_msk: %d\n\t SCO %sactive A2DP %sactive SNIFF %sactive\n",
	276	bt_kill_msk,
	277	BT_MBOX_MSG(notif, 3, SCO_STATE) ? "" : "in",
	278	BT_MBOX_MSG(notif, 3, A2DP_STATE) ? "" : "in",
	279	BT_MBOX_MSG(notif, 3, SNIFF_STATE) ? "" : "in");
	280
	281	mvm->bt_kill_msk = bt_kill_msk;
	282	cmd.kill_ack_msk = cpu_to_le32(iwl_bt_ack_kill_msk[bt_kill_msk]);
	283	cmd.kill_cts_msk = cpu_to_le32(iwl_bt_cts_kill_msk[bt_kill_msk]);
	284
	285	cmd.valid_bit_msk = cpu_to_le16(BT_VALID_KILL_ACK \| BT_VALID_KILL_CTS);
	286
	287	if (iwl_mvm_send_cmd_pdu(mvm, BT_CONFIG, CMD_SYNC, sizeof(cmd), &cmd))
	288	IWL_ERR(mvm, "Failed to sent BT Coex CMD\n");
	289
	290	/* This handler is ASYNC */
	291	return 0;
	292	}