[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-agn-hcmd.c

/******************************************************************************
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2008 - 2010 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 LICENSE.GPL.
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>

#include "iwl-dev.h"
#include "iwl-core.h"
#include "iwl-io.h"
#include "iwl-agn.h"

int iwlagn_send_rxon_assoc(struct iwl_priv *priv,
			   struct iwl_rxon_context *ctx)
{
	int ret = 0;
	struct iwl5000_rxon_assoc_cmd rxon_assoc;
	const struct iwl_rxon_cmd *rxon1 = &ctx->staging;
	const struct iwl_rxon_cmd *rxon2 = &ctx->active;

	if ((rxon1->flags == rxon2->flags) &&
	    (rxon1->filter_flags == rxon2->filter_flags) &&
	    (rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
	    (rxon1->ofdm_ht_single_stream_basic_rates ==
	     rxon2->ofdm_ht_single_stream_basic_rates) &&
	    (rxon1->ofdm_ht_dual_stream_basic_rates ==
	     rxon2->ofdm_ht_dual_stream_basic_rates) &&
	    (rxon1->ofdm_ht_triple_stream_basic_rates ==
	     rxon2->ofdm_ht_triple_stream_basic_rates) &&
	    (rxon1->acquisition_data == rxon2->acquisition_data) &&
	    (rxon1->rx_chain == rxon2->rx_chain) &&
	    (rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
		IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC.  Not resending.\n");
		return 0;
	}

	rxon_assoc.flags = ctx->staging.flags;
	rxon_assoc.filter_flags = ctx->staging.filter_flags;
	rxon_assoc.ofdm_basic_rates = ctx->staging.ofdm_basic_rates;
	rxon_assoc.cck_basic_rates = ctx->staging.cck_basic_rates;
	rxon_assoc.reserved1 = 0;
	rxon_assoc.reserved2 = 0;
	rxon_assoc.reserved3 = 0;
	rxon_assoc.ofdm_ht_single_stream_basic_rates =
	    ctx->staging.ofdm_ht_single_stream_basic_rates;
	rxon_assoc.ofdm_ht_dual_stream_basic_rates =
	    ctx->staging.ofdm_ht_dual_stream_basic_rates;
	rxon_assoc.rx_chain_select_flags = ctx->staging.rx_chain;
	rxon_assoc.ofdm_ht_triple_stream_basic_rates =
		 ctx->staging.ofdm_ht_triple_stream_basic_rates;
	rxon_assoc.acquisition_data = ctx->staging.acquisition_data;

	ret = iwl_send_cmd_pdu_async(priv, ctx->rxon_assoc_cmd,
				     sizeof(rxon_assoc), &rxon_assoc, NULL);
	if (ret)
		return ret;

	return ret;
}

int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
{
	struct iwl_tx_ant_config_cmd tx_ant_cmd = {
	  .valid = cpu_to_le32(valid_tx_ant),
	};

	if (IWL_UCODE_API(priv->ucode_ver) > 1) {
		IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
		return iwl_send_cmd_pdu(priv, TX_ANT_CONFIGURATION_CMD,
					sizeof(struct iwl_tx_ant_config_cmd),
					&tx_ant_cmd);
	} else {
		IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
		return -EOPNOTSUPP;
	}
}

/* Currently this is the superset of everything */
static u16 iwlagn_get_hcmd_size(u8 cmd_id, u16 len)
{
	return len;
}

static u16 iwlagn_build_addsta_hcmd(const struct iwl_addsta_cmd *cmd, u8 *data)
{
	u16 size = (u16)sizeof(struct iwl_addsta_cmd);
	struct iwl_addsta_cmd *addsta = (struct iwl_addsta_cmd *)data;
	memcpy(addsta, cmd, size);
	/* resrved in 5000 */
	addsta->rate_n_flags = cpu_to_le16(0);
	return size;
}

static void iwlagn_gain_computation(struct iwl_priv *priv,
		u32 average_noise[NUM_RX_CHAINS],
		u16 min_average_noise_antenna_i,
		u32 min_average_noise,
		u8 default_chain)
{
	int i;
	s32 delta_g;
	struct iwl_chain_noise_data *data = &priv->chain_noise_data;

	/*
	 * Find Gain Code for the chains based on "default chain"
	 */
	for (i = default_chain + 1; i < NUM_RX_CHAINS; i++) {
		if ((data->disconn_array[i])) {
			data->delta_gain_code[i] = 0;
			continue;
		}

		delta_g = (priv->cfg->chain_noise_scale *
			((s32)average_noise[default_chain] -
			(s32)average_noise[i])) / 1500;

		/* bound gain by 2 bits value max, 3rd bit is sign */
		data->delta_gain_code[i] =
			min(abs(delta_g), (long) CHAIN_NOISE_MAX_DELTA_GAIN_CODE);

		if (delta_g < 0)
			/*
			 * set negative sign ...
			 * note to Intel developers:  This is uCode API format,
			 *   not the format of any internal device registers.
			 *   Do not change this format for e.g. 6050 or similar
			 *   devices.  Change format only if more resolution
			 *   (i.e. more than 2 bits magnitude) is needed.
			 */
			data->delta_gain_code[i] |= (1 << 2);
	}

	IWL_DEBUG_CALIB(priv, "Delta gains: ANT_B = %d  ANT_C = %d\n",
			data->delta_gain_code[1], data->delta_gain_code[2]);

	if (!data->radio_write) {
		struct iwl_calib_chain_noise_gain_cmd cmd;

		memset(&cmd, 0, sizeof(cmd));

		cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_gain_cmd;
		cmd.hdr.first_group = 0;
		cmd.hdr.groups_num = 1;
		cmd.hdr.data_valid = 1;
		cmd.delta_gain_1 = data->delta_gain_code[1];
		cmd.delta_gain_2 = data->delta_gain_code[2];
		iwl_send_cmd_pdu_async(priv, REPLY_PHY_CALIBRATION_CMD,
			sizeof(cmd), &cmd, NULL);

		data->radio_write = 1;
		data->state = IWL_CHAIN_NOISE_CALIBRATED;
	}
}

static void iwlagn_chain_noise_reset(struct iwl_priv *priv)
{
	struct iwl_chain_noise_data *data = &priv->chain_noise_data;
	int ret;

	if ((data->state == IWL_CHAIN_NOISE_ALIVE) &&
	    iwl_is_any_associated(priv)) {
		struct iwl_calib_chain_noise_reset_cmd cmd;

		/* clear data for chain noise calibration algorithm */
		data->chain_noise_a = 0;
		data->chain_noise_b = 0;
		data->chain_noise_c = 0;
		data->chain_signal_a = 0;
		data->chain_signal_b = 0;
		data->chain_signal_c = 0;
		data->beacon_count = 0;

		memset(&cmd, 0, sizeof(cmd));
		cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_reset_cmd;
		cmd.hdr.first_group = 0;
		cmd.hdr.groups_num = 1;
		cmd.hdr.data_valid = 1;
		ret = iwl_send_cmd_pdu(priv, REPLY_PHY_CALIBRATION_CMD,
					sizeof(cmd), &cmd);
		if (ret)
			IWL_ERR(priv,
				"Could not send REPLY_PHY_CALIBRATION_CMD\n");
		data->state = IWL_CHAIN_NOISE_ACCUMULATE;
		IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n");
	}
}

static void iwlagn_tx_cmd_protection(struct iwl_priv *priv,
				     struct ieee80211_tx_info *info,
				     __le16 fc, __le32 *tx_flags)
{
	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS ||
	    info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
		*tx_flags |= TX_CMD_FLG_PROT_REQUIRE_MSK;
		return;
	}

	if (priv->cfg->use_rts_for_aggregation &&
	    info->flags & IEEE80211_TX_CTL_AMPDU) {
		*tx_flags |= TX_CMD_FLG_PROT_REQUIRE_MSK;
		return;
	}
}

/* Calc max signal level (dBm) among 3 possible receivers */
static int iwlagn_calc_rssi(struct iwl_priv *priv,
			     struct iwl_rx_phy_res *rx_resp)
{
	/* data from PHY/DSP regarding signal strength, etc.,
	 *   contents are always there, not configurable by host
	 */
	struct iwlagn_non_cfg_phy *ncphy =
		(struct iwlagn_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
	u32 val, rssi_a, rssi_b, rssi_c, max_rssi;
	u8 agc;

	val  = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_AGC_IDX]);
	agc = (val & IWLAGN_OFDM_AGC_MSK) >> IWLAGN_OFDM_AGC_BIT_POS;

	/* Find max rssi among 3 possible receivers.
	 * These values are measured by the digital signal processor (DSP).
	 * They should stay fairly constant even as the signal strength varies,
	 *   if the radio's automatic gain control (AGC) is working right.
	 * AGC value (see below) will provide the "interesting" info.
	 */
	val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_AB_IDX]);
	rssi_a = (val & IWLAGN_OFDM_RSSI_INBAND_A_BITMSK) >>
		IWLAGN_OFDM_RSSI_A_BIT_POS;
	rssi_b = (val & IWLAGN_OFDM_RSSI_INBAND_B_BITMSK) >>
		IWLAGN_OFDM_RSSI_B_BIT_POS;
	val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_C_IDX]);
	rssi_c = (val & IWLAGN_OFDM_RSSI_INBAND_C_BITMSK) >>
		IWLAGN_OFDM_RSSI_C_BIT_POS;

	max_rssi = max_t(u32, rssi_a, rssi_b);
	max_rssi = max_t(u32, max_rssi, rssi_c);

	IWL_DEBUG_STATS(priv, "Rssi In A %d B %d C %d Max %d AGC dB %d\n",
		rssi_a, rssi_b, rssi_c, max_rssi, agc);

	/* dBm = max_rssi dB - agc dB - constant.
	 * Higher AGC (higher radio gain) means lower signal. */
	return max_rssi - agc - IWLAGN_RSSI_OFFSET;
}

static int iwlagn_set_pan_params(struct iwl_priv *priv)
{
	struct iwl_wipan_params_cmd cmd;
	struct iwl_rxon_context *ctx_bss, *ctx_pan;
	int slot0 = 300, slot1 = 0;
	int ret;

	if (priv->valid_contexts == BIT(IWL_RXON_CTX_BSS))
		return 0;

	BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);

	lockdep_assert_held(&priv->mutex);

	ctx_bss = &priv->contexts[IWL_RXON_CTX_BSS];
	ctx_pan = &priv->contexts[IWL_RXON_CTX_PAN];

	/*
	 * If the PAN context is inactive, then we don't need
	 * to update the PAN parameters, the last thing we'll
	 * have done before it goes inactive is making the PAN
	 * parameters be WLAN-only.
	 */
	if (!ctx_pan->is_active)
		return 0;

	memset(&cmd, 0, sizeof(cmd));

	/* only 2 slots are currently allowed */
	cmd.num_slots = 2;

	cmd.slots[0].type = 0; /* BSS */
	cmd.slots[1].type = 1; /* PAN */

	if (ctx_bss->vif && ctx_pan->vif) {
		int bcnint = ctx_pan->vif->bss_conf.beacon_int;

		/* should be set, but seems unused?? */
		cmd.flags |= cpu_to_le16(IWL_WIPAN_PARAMS_FLG_SLOTTED_MODE);

		if (ctx_pan->vif->type == NL80211_IFTYPE_AP &&
		    bcnint &&
		    bcnint != ctx_bss->vif->bss_conf.beacon_int) {
			IWL_ERR(priv,
				"beacon intervals don't match (%d, %d)\n",
				ctx_bss->vif->bss_conf.beacon_int,
				ctx_pan->vif->bss_conf.beacon_int);
		} else
			bcnint = max_t(int, bcnint,
				       ctx_bss->vif->bss_conf.beacon_int);
		if (!bcnint)
			bcnint = DEFAULT_BEACON_INTERVAL;
		slot0 = bcnint / 2;
		slot1 = bcnint - slot0;

		if (test_bit(STATUS_SCAN_HW, &priv->status) ||
		    (!ctx_bss->vif->bss_conf.idle &&
		     !ctx_bss->vif->bss_conf.assoc)) {
			slot0 = bcnint * 3 - 20;
			slot1 = 20;
		} else if (!ctx_pan->vif->bss_conf.idle &&
                           !ctx_pan->vif->bss_conf.assoc) {
			slot1 = bcnint * 3 - 20;
			slot0 = 20;
		}
	} else if (ctx_pan->vif) {
		slot0 = 0;
		slot1 = max_t(int, 1, ctx_pan->vif->bss_conf.dtim_period) *
					ctx_pan->vif->bss_conf.beacon_int;
		slot1 = max_t(int, DEFAULT_BEACON_INTERVAL, slot1);

		if (test_bit(STATUS_SCAN_HW, &priv->status)) {
			slot0 = slot1 * 3 - 20;
			slot1 = 20;
		}
	}

	cmd.slots[0].width = cpu_to_le16(slot0);
	cmd.slots[1].width = cpu_to_le16(slot1);

	ret = iwl_send_cmd_pdu(priv, REPLY_WIPAN_PARAMS, sizeof(cmd), &cmd);
	if (ret)
		IWL_ERR(priv, "Error setting PAN parameters (%d)\n", ret);

	return ret;
}

struct iwl_hcmd_ops iwlagn_hcmd = {
	.rxon_assoc = iwlagn_send_rxon_assoc,
	.commit_rxon = iwl_commit_rxon,
	.set_rxon_chain = iwl_set_rxon_chain,
	.set_tx_ant = iwlagn_send_tx_ant_config,
	.send_bt_config = iwl_send_bt_config,
	.set_pan_params = iwlagn_set_pan_params,
};

struct iwl_hcmd_ops iwlagn_bt_hcmd = {
	.rxon_assoc = iwlagn_send_rxon_assoc,
	.commit_rxon = iwl_commit_rxon,
	.set_rxon_chain = iwl_set_rxon_chain,
	.set_tx_ant = iwlagn_send_tx_ant_config,
	.send_bt_config = iwlagn_send_advance_bt_config,
	.set_pan_params = iwlagn_set_pan_params,
};

struct iwl_hcmd_utils_ops iwlagn_hcmd_utils = {
	.get_hcmd_size = iwlagn_get_hcmd_size,
	.build_addsta_hcmd = iwlagn_build_addsta_hcmd,
	.gain_computation = iwlagn_gain_computation,
	.chain_noise_reset = iwlagn_chain_noise_reset,
	.tx_cmd_protection = iwlagn_tx_cmd_protection,
	.calc_rssi = iwlagn_calc_rssi,
	.request_scan = iwlagn_request_scan,
};
Commit	Line	Data
7dc77dba WYG	1	/******************************************************************************
	2	*
	3	* GPL LICENSE SUMMARY
	4	*
	5	* Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of version 2 of the GNU General Public License as
	9	* published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
	19	* USA
	20	*
	21	* The full GNU General Public License is included in this distribution
	22	* in the file called LICENSE.GPL.
	23	*
	24	* Contact Information:
	25	* Intel Linux Wireless <ilw@linux.intel.com>
	26	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	27	*
	28	*****************************************************************************/
	29
	30	#include <linux/kernel.h>
	31	#include <linux/module.h>
	32	#include <linux/init.h>
	33	#include <linux/sched.h>
	34
	35	#include "iwl-dev.h"
	36	#include "iwl-core.h"
	37	#include "iwl-io.h"
510cb791	38	#include "iwl-agn.h"
7dc77dba	39
246ed355 JB	40	int iwlagn_send_rxon_assoc(struct iwl_priv *priv,
246ed355 JB	41	struct iwl_rxon_context *ctx)
7dc77dba WYG	42	{
	43	int ret = 0;
	44	struct iwl5000_rxon_assoc_cmd rxon_assoc;
246ed355 JB	45	const struct iwl_rxon_cmd *rxon1 = &ctx->staging;
246ed355 JB	46	const struct iwl_rxon_cmd *rxon2 = &ctx->active;
7dc77dba WYG	47
	48	if ((rxon1->flags == rxon2->flags) &&
	49	(rxon1->filter_flags == rxon2->filter_flags) &&
	50	(rxon1->cck_basic_rates == rxon2->cck_basic_rates) &&
	51	(rxon1->ofdm_ht_single_stream_basic_rates ==
	52	rxon2->ofdm_ht_single_stream_basic_rates) &&
	53	(rxon1->ofdm_ht_dual_stream_basic_rates ==
	54	rxon2->ofdm_ht_dual_stream_basic_rates) &&
	55	(rxon1->ofdm_ht_triple_stream_basic_rates ==
	56	rxon2->ofdm_ht_triple_stream_basic_rates) &&
	57	(rxon1->acquisition_data == rxon2->acquisition_data) &&
	58	(rxon1->rx_chain == rxon2->rx_chain) &&
	59	(rxon1->ofdm_basic_rates == rxon2->ofdm_basic_rates)) {
	60	IWL_DEBUG_INFO(priv, "Using current RXON_ASSOC. Not resending.\n");
	61	return 0;
	62	}
	63
246ed355 JB	64	rxon_assoc.flags = ctx->staging.flags;
	65	rxon_assoc.filter_flags = ctx->staging.filter_flags;
	66	rxon_assoc.ofdm_basic_rates = ctx->staging.ofdm_basic_rates;
	67	rxon_assoc.cck_basic_rates = ctx->staging.cck_basic_rates;
7dc77dba WYG	68	rxon_assoc.reserved1 = 0;
	69	rxon_assoc.reserved2 = 0;
	70	rxon_assoc.reserved3 = 0;
	71	rxon_assoc.ofdm_ht_single_stream_basic_rates =
246ed355	72	ctx->staging.ofdm_ht_single_stream_basic_rates;
7dc77dba	73	rxon_assoc.ofdm_ht_dual_stream_basic_rates =
246ed355 JB	74	ctx->staging.ofdm_ht_dual_stream_basic_rates;
246ed355 JB	75	rxon_assoc.rx_chain_select_flags = ctx->staging.rx_chain;
7dc77dba	76	rxon_assoc.ofdm_ht_triple_stream_basic_rates =
246ed355 JB	77	ctx->staging.ofdm_ht_triple_stream_basic_rates;
246ed355 JB	78	rxon_assoc.acquisition_data = ctx->staging.acquisition_data;
7dc77dba	79
8f2d3d2a	80	ret = iwl_send_cmd_pdu_async(priv, ctx->rxon_assoc_cmd,
7dc77dba WYG	81	sizeof(rxon_assoc), &rxon_assoc, NULL);
	82	if (ret)
	83	return ret;
	84
	85	return ret;
	86	}
	87
1808972f	88	int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
7dc77dba WYG	89	{
	90	struct iwl_tx_ant_config_cmd tx_ant_cmd = {
	91	.valid = cpu_to_le32(valid_tx_ant),
	92	};
	93
	94	if (IWL_UCODE_API(priv->ucode_ver) > 1) {
	95	IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
	96	return iwl_send_cmd_pdu(priv, TX_ANT_CONFIGURATION_CMD,
	97	sizeof(struct iwl_tx_ant_config_cmd),
	98	&tx_ant_cmd);
	99	} else {
	100	IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
	101	return -EOPNOTSUPP;
	102	}
	103	}
	104
	105	/* Currently this is the superset of everything */
	106	static u16 iwlagn_get_hcmd_size(u8 cmd_id, u16 len)
	107	{
	108	return len;
	109	}
	110
	111	static u16 iwlagn_build_addsta_hcmd(const struct iwl_addsta_cmd cmd, u8 data)
	112	{
	113	u16 size = (u16)sizeof(struct iwl_addsta_cmd);
	114	struct iwl_addsta_cmd addsta = (struct iwl_addsta_cmd )data;
	115	memcpy(addsta, cmd, size);
	116	/* resrved in 5000 */
	117	addsta->rate_n_flags = cpu_to_le16(0);
	118	return size;
	119	}
	120
	121	static void iwlagn_gain_computation(struct iwl_priv *priv,
	122	u32 average_noise[NUM_RX_CHAINS],
	123	u16 min_average_noise_antenna_i,
	124	u32 min_average_noise,
	125	u8 default_chain)
	126	{
	127	int i;
	128	s32 delta_g;
	129	struct iwl_chain_noise_data *data = &priv->chain_noise_data;
	130
	131	/*
	132	* Find Gain Code for the chains based on "default chain"
	133	*/
	134	for (i = default_chain + 1; i < NUM_RX_CHAINS; i++) {
	135	if ((data->disconn_array[i])) {
	136	data->delta_gain_code[i] = 0;
	137	continue;
	138	}
	139
	140	delta_g = (priv->cfg->chain_noise_scale *
	141	((s32)average_noise[default_chain] -
	142	(s32)average_noise[i])) / 1500;
	143
	144	/* bound gain by 2 bits value max, 3rd bit is sign */
	145	data->delta_gain_code[i] =
	146	min(abs(delta_g), (long) CHAIN_NOISE_MAX_DELTA_GAIN_CODE);
	147
	148	if (delta_g < 0)
	149	/*
	150	* set negative sign ...
	151	* note to Intel developers: This is uCode API format,
	152	* not the format of any internal device registers.
153	* Do not change this format for e.g. 6050 or similar
154	* devices. Change format only if more resolution
155	* (i.e. more than 2 bits magnitude) is needed.
156	*/
157	data->delta_gain_code[i] \|= (1 << 2);
158	}
159
160	IWL_DEBUG_CALIB(priv, "Delta gains: ANT_B = %d ANT_C = %d\n",
161	data->delta_gain_code[1], data->delta_gain_code[2]);
162
163	if (!data->radio_write) {
164	struct iwl_calib_chain_noise_gain_cmd cmd;
165
166	memset(&cmd, 0, sizeof(cmd));
167
6a822d06	168	cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_gain_cmd;
7dc77dba WYG	169	cmd.hdr.first_group = 0;
	170	cmd.hdr.groups_num = 1;
	171	cmd.hdr.data_valid = 1;
	172	cmd.delta_gain_1 = data->delta_gain_code[1];
	173	cmd.delta_gain_2 = data->delta_gain_code[2];
	174	iwl_send_cmd_pdu_async(priv, REPLY_PHY_CALIBRATION_CMD,
	175	sizeof(cmd), &cmd, NULL);
	176
	177	data->radio_write = 1;
	178	data->state = IWL_CHAIN_NOISE_CALIBRATED;
	179	}
7dc77dba WYG	180	}
	181
	182	static void iwlagn_chain_noise_reset(struct iwl_priv *priv)
	183	{
	184	struct iwl_chain_noise_data *data = &priv->chain_noise_data;
	185	int ret;
	186
f4308449	187	if ((data->state == IWL_CHAIN_NOISE_ALIVE) &&
246ed355	188	iwl_is_any_associated(priv)) {
7dc77dba	189	struct iwl_calib_chain_noise_reset_cmd cmd;
7dc77dba	190
f4308449 SZ	191	/* clear data for chain noise calibration algorithm */
	192	data->chain_noise_a = 0;
	193	data->chain_noise_b = 0;
	194	data->chain_noise_c = 0;
	195	data->chain_signal_a = 0;
	196	data->chain_signal_b = 0;
	197	data->chain_signal_c = 0;
	198	data->beacon_count = 0;
	199
	200	memset(&cmd, 0, sizeof(cmd));
6a822d06	201	cmd.hdr.op_code = priv->_agn.phy_calib_chain_noise_reset_cmd;
7dc77dba WYG	202	cmd.hdr.first_group = 0;
	203	cmd.hdr.groups_num = 1;
	204	cmd.hdr.data_valid = 1;
	205	ret = iwl_send_cmd_pdu(priv, REPLY_PHY_CALIBRATION_CMD,
	206	sizeof(cmd), &cmd);
	207	if (ret)
	208	IWL_ERR(priv,
	209	"Could not send REPLY_PHY_CALIBRATION_CMD\n");
	210	data->state = IWL_CHAIN_NOISE_ACCUMULATE;
	211	IWL_DEBUG_CALIB(priv, "Run chain_noise_calibrate\n");
	212	}
	213	}
	214
94597ab2 JB	215	static void iwlagn_tx_cmd_protection(struct iwl_priv *priv,
	216	struct ieee80211_tx_info *info,
	217	__le16 fc, __le32 *tx_flags)
7dc77dba	218	{
94597ab2 JB	219	if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS \|\|
	220	info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
	221	*tx_flags \|= TX_CMD_FLG_PROT_REQUIRE_MSK;
	222	return;
	223	}
	224
	225	if (priv->cfg->use_rts_for_aggregation &&
	226	info->flags & IEEE80211_TX_CTL_AMPDU) {
	227	*tx_flags \|= TX_CMD_FLG_PROT_REQUIRE_MSK;
	228	return;
	229	}
7dc77dba WYG	230	}
	231
	232	/* Calc max signal level (dBm) among 3 possible receivers */
	233	static int iwlagn_calc_rssi(struct iwl_priv *priv,
	234	struct iwl_rx_phy_res *rx_resp)
	235	{
	236	/* data from PHY/DSP regarding signal strength, etc.,
	237	* contents are always there, not configurable by host
	238	*/
7ccc896f WYG	239	struct iwlagn_non_cfg_phy *ncphy =
7ccc896f WYG	240	(struct iwlagn_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
7dc77dba WYG	241	u32 val, rssi_a, rssi_b, rssi_c, max_rssi;
	242	u8 agc;
	243
7ccc896f WYG	244	val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_AGC_IDX]);
7ccc896f WYG	245	agc = (val & IWLAGN_OFDM_AGC_MSK) >> IWLAGN_OFDM_AGC_BIT_POS;
7dc77dba WYG	246
	247	/* Find max rssi among 3 possible receivers.
	248	* These values are measured by the digital signal processor (DSP).
	249	* They should stay fairly constant even as the signal strength varies,
	250	* if the radio's automatic gain control (AGC) is working right.
	251	* AGC value (see below) will provide the "interesting" info.
	252	*/
7ccc896f WYG	253	val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_AB_IDX]);
	254	rssi_a = (val & IWLAGN_OFDM_RSSI_INBAND_A_BITMSK) >>
	255	IWLAGN_OFDM_RSSI_A_BIT_POS;
	256	rssi_b = (val & IWLAGN_OFDM_RSSI_INBAND_B_BITMSK) >>
	257	IWLAGN_OFDM_RSSI_B_BIT_POS;
	258	val = le32_to_cpu(ncphy->non_cfg_phy[IWLAGN_RX_RES_RSSI_C_IDX]);
	259	rssi_c = (val & IWLAGN_OFDM_RSSI_INBAND_C_BITMSK) >>
	260	IWLAGN_OFDM_RSSI_C_BIT_POS;
7dc77dba WYG	261
	262	max_rssi = max_t(u32, rssi_a, rssi_b);
	263	max_rssi = max_t(u32, max_rssi, rssi_c);
	264
	265	IWL_DEBUG_STATS(priv, "Rssi In A %d B %d C %d Max %d AGC dB %d\n",
	266	rssi_a, rssi_b, rssi_c, max_rssi, agc);
	267
	268	/* dBm = max_rssi dB - agc dB - constant.
	269	* Higher AGC (higher radio gain) means lower signal. */
b744cb79	270	return max_rssi - agc - IWLAGN_RSSI_OFFSET;
7dc77dba WYG	271	}
7dc77dba WYG	272
52a02d15 JB	273	static int iwlagn_set_pan_params(struct iwl_priv *priv)
	274	{
	275	struct iwl_wipan_params_cmd cmd;
	276	struct iwl_rxon_context ctx_bss, ctx_pan;
	277	int slot0 = 300, slot1 = 0;
	278	int ret;
	279
	280	if (priv->valid_contexts == BIT(IWL_RXON_CTX_BSS))
	281	return 0;
	282
	283	BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
	284
	285	lockdep_assert_held(&priv->mutex);
	286
	287	ctx_bss = &priv->contexts[IWL_RXON_CTX_BSS];
	288	ctx_pan = &priv->contexts[IWL_RXON_CTX_PAN];
	289
763cc3bf JB	290	/*
	291	* If the PAN context is inactive, then we don't need
	292	* to update the PAN parameters, the last thing we'll
	293	* have done before it goes inactive is making the PAN
	294	* parameters be WLAN-only.
	295	*/
	296	if (!ctx_pan->is_active)
	297	return 0;
	298
52a02d15 JB	299	memset(&cmd, 0, sizeof(cmd));
	300
	301	/* only 2 slots are currently allowed */
	302	cmd.num_slots = 2;
	303
	304	cmd.slots[0].type = 0; /* BSS */
	305	cmd.slots[1].type = 1; /* PAN */
	306
	307	if (ctx_bss->vif && ctx_pan->vif) {
	308	int bcnint = ctx_pan->vif->bss_conf.beacon_int;
	309
	310	/* should be set, but seems unused?? */
	311	cmd.flags \|= cpu_to_le16(IWL_WIPAN_PARAMS_FLG_SLOTTED_MODE);
	312
	313	if (ctx_pan->vif->type == NL80211_IFTYPE_AP &&
	314	bcnint &&
	315	bcnint != ctx_bss->vif->bss_conf.beacon_int) {
	316	IWL_ERR(priv,
	317	"beacon intervals don't match (%d, %d)\n",
	318	ctx_bss->vif->bss_conf.beacon_int,
	319	ctx_pan->vif->bss_conf.beacon_int);
	320	} else
	321	bcnint = max_t(int, bcnint,
	322	ctx_bss->vif->bss_conf.beacon_int);
	323	if (!bcnint)
ea196fdb	324	bcnint = DEFAULT_BEACON_INTERVAL;
52a02d15 JB	325	slot0 = bcnint / 2;
	326	slot1 = bcnint - slot0;
	327
	328	if (test_bit(STATUS_SCAN_HW, &priv->status) \|\|
	329	(!ctx_bss->vif->bss_conf.idle &&
	330	!ctx_bss->vif->bss_conf.assoc)) {
	331	slot0 = bcnint * 3 - 20;
	332	slot1 = 20;
	333	} else if (!ctx_pan->vif->bss_conf.idle &&
	334	!ctx_pan->vif->bss_conf.assoc) {
	335	slot1 = bcnint * 3 - 20;
	336	slot0 = 20;
	337	}
	338	} else if (ctx_pan->vif) {
	339	slot0 = 0;
	340	slot1 = max_t(int, 1, ctx_pan->vif->bss_conf.dtim_period) *
	341	ctx_pan->vif->bss_conf.beacon_int;
ea196fdb	342	slot1 = max_t(int, DEFAULT_BEACON_INTERVAL, slot1);
27eafdda JB	343
	344	if (test_bit(STATUS_SCAN_HW, &priv->status)) {
	345	slot0 = slot1 * 3 - 20;
	346	slot1 = 20;
	347	}
52a02d15 JB	348	}
	349
	350	cmd.slots[0].width = cpu_to_le16(slot0);
	351	cmd.slots[1].width = cpu_to_le16(slot1);
	352
	353	ret = iwl_send_cmd_pdu(priv, REPLY_WIPAN_PARAMS, sizeof(cmd), &cmd);
	354	if (ret)
	355	IWL_ERR(priv, "Error setting PAN parameters (%d)\n", ret);
	356
	357	return ret;
	358	}
	359
7dc77dba WYG	360	struct iwl_hcmd_ops iwlagn_hcmd = {
	361	.rxon_assoc = iwlagn_send_rxon_assoc,
	362	.commit_rxon = iwl_commit_rxon,
	363	.set_rxon_chain = iwl_set_rxon_chain,
	364	.set_tx_ant = iwlagn_send_tx_ant_config,
65b52bde	365	.send_bt_config = iwl_send_bt_config,
52a02d15	366	.set_pan_params = iwlagn_set_pan_params,
7dc77dba WYG	367	};
7dc77dba WYG	368
b6e116e8 WYG	369	struct iwl_hcmd_ops iwlagn_bt_hcmd = {
	370	.rxon_assoc = iwlagn_send_rxon_assoc,
	371	.commit_rxon = iwl_commit_rxon,
	372	.set_rxon_chain = iwl_set_rxon_chain,
	373	.set_tx_ant = iwlagn_send_tx_ant_config,
	374	.send_bt_config = iwlagn_send_advance_bt_config,
52a02d15	375	.set_pan_params = iwlagn_set_pan_params,
b6e116e8 WYG	376	};
b6e116e8 WYG	377
7dc77dba WYG	378	struct iwl_hcmd_utils_ops iwlagn_hcmd_utils = {
	379	.get_hcmd_size = iwlagn_get_hcmd_size,
	380	.build_addsta_hcmd = iwlagn_build_addsta_hcmd,
	381	.gain_computation = iwlagn_gain_computation,
	382	.chain_noise_reset = iwlagn_chain_noise_reset,
94597ab2	383	.tx_cmd_protection = iwlagn_tx_cmd_protection,
7dc77dba	384	.calc_rssi = iwlagn_calc_rssi,
b6e4c55a	385	.request_scan = iwlagn_request_scan,
7dc77dba	386	};