Commit da4f87f0 authored by Johannes Berg's avatar Johannes Berg
Browse files

iwlwifi: dvm: remove P2P support 



We're not planning to support P2P on older devices, so
remove the Kconfig option and associated code for it.

Reviewed-by: default avatarEmmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: default avatarJohannes Berg <johannes.berg@intel.com>
parent 03e304e4

drivers/net/wireless/iwlwifi/Kconfig

+0 −17
Original line number Diff line number Diff line
@@ -127,20 +127,3 @@ config IWLWIFI_DEVICE_TRACING 
	  If unsure, say Y so we can help you better when problems

	  occur.

endmenu
 


config IWLWIFI_P2P

	def_bool y

	bool "iwlwifi experimental P2P support"

	depends on IWLWIFI

	help

	  This option enables experimental P2P support for some devices

	  based on microcode support. Since P2P support is still under

	  development, this option may even enable it for some devices

	  now that turn out to not support it in the future due to

	  microcode restrictions.



	  To determine if your microcode supports the experimental P2P

	  offered by this option, check if the driver advertises AP

	  support when it is loaded.



	  Say Y only if you want to experiment with P2P.

drivers/net/wireless/iwlwifi/dvm/agn.h

+0 −6
Original line number Diff line number Diff line
@@ -106,7 +106,6 @@ extern const struct iwl_dvm_cfg iwl_dvm_6030_cfg; 
#define STATUS_CHANNEL_SWITCH_PENDING 11

#define STATUS_SCAN_COMPLETE	12

#define STATUS_POWER_PMI	13

#define STATUS_SCAN_ROC_EXPIRED 14



struct iwl_ucode_capabilities;
@@ -250,7 +249,6 @@ u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant_idx, u8 valid); 


/* scan */

void iwlagn_post_scan(struct iwl_priv *priv);

void iwlagn_disable_roc(struct iwl_priv *priv);

int iwl_force_rf_reset(struct iwl_priv *priv, bool external);

void iwl_init_scan_params(struct iwl_priv *priv);

int iwl_scan_cancel(struct iwl_priv *priv);
@@ -265,10 +263,6 @@ int __must_check iwl_scan_initiate(struct iwl_priv *priv, 
				   enum iwl_scan_type scan_type,

				   enum ieee80211_band band);



void iwl_scan_roc_expired(struct iwl_priv *priv);

void iwl_scan_offchannel_skb(struct iwl_priv *priv);

void iwl_scan_offchannel_skb_status(struct iwl_priv *priv);



/* For faster active scanning, scan will move to the next channel if fewer than

 * PLCP_QUIET_THRESH packets are heard on this channel within

 * ACTIVE_QUIET_TIME after sending probe request.  This shortens the dwell

drivers/net/wireless/iwlwifi/dvm/dev.h

+0 −7
Original line number Diff line number Diff line
@@ -540,7 +540,6 @@ struct iwl_rxon_context { 
enum iwl_scan_type {

	IWL_SCAN_NORMAL,

	IWL_SCAN_RADIO_RESET,

	IWL_SCAN_ROC,

};



/**
@@ -825,12 +824,6 @@ struct iwl_priv { 
	struct reply_tx_error_statistics reply_tx_stats;

	struct reply_agg_tx_error_statistics reply_agg_tx_stats;



	/* remain-on-channel offload support */

	struct ieee80211_channel *hw_roc_channel;

	struct delayed_work hw_roc_disable_work;

	int hw_roc_duration;

	bool hw_roc_setup, hw_roc_start_notified;



	/* bt coex */

	u8 bt_enable_flag;

	u8 bt_status;

drivers/net/wireless/iwlwifi/dvm/mac80211.c

+1 −171
Original line number Diff line number Diff line
@@ -76,29 +76,6 @@ static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = { 
	},

};



static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {

	{

		.max = 1,

		.types = BIT(NL80211_IFTYPE_STATION),

	},

	{

		.max = 1,

		.types = BIT(NL80211_IFTYPE_P2P_GO) |

			 BIT(NL80211_IFTYPE_AP),

	},

};



static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {

	{

		.max = 2,

		.types = BIT(NL80211_IFTYPE_STATION),

	},

	{

		.max = 1,

		.types = BIT(NL80211_IFTYPE_P2P_CLIENT),

	},

};



static const struct ieee80211_iface_combination

iwlagn_iface_combinations_dualmode[] = {

	{ .num_different_channels = 1,
@@ -114,21 +91,6 @@ iwlagn_iface_combinations_dualmode[] = { 
	},

};



static const struct ieee80211_iface_combination

iwlagn_iface_combinations_p2p[] = {

	{ .num_different_channels = 1,

	  .max_interfaces = 2,

	  .beacon_int_infra_match = true,

	  .limits = iwlagn_p2p_sta_go_limits,

	  .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),

	},

	{ .num_different_channels = 1,

	  .max_interfaces = 2,

	  .limits = iwlagn_p2p_2sta_limits,

	  .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),

	},

};



/*

 * Not a mac80211 entry point function, but it fits in with all the

 * other mac80211 functions grouped here.
@@ -186,19 +148,13 @@ int iwlagn_mac_setup_register(struct iwl_priv *priv, 


	BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);



	if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {

		hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;

		hw->wiphy->n_iface_combinations =

			ARRAY_SIZE(iwlagn_iface_combinations_p2p);

	} else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {

	if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {

		hw->wiphy->iface_combinations =

			iwlagn_iface_combinations_dualmode;

		hw->wiphy->n_iface_combinations =

			ARRAY_SIZE(iwlagn_iface_combinations_dualmode);

	}



	hw->wiphy->max_remain_on_channel_duration = 500;



	hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |

			    WIPHY_FLAG_DISABLE_BEACON_HINTS |

			    WIPHY_FLAG_IBSS_RSN;
@@ -1156,126 +1112,6 @@ done: 
	IWL_DEBUG_MAC80211(priv, "leave\n");

}



static int iwlagn_mac_remain_on_channel(struct ieee80211_hw *hw,

				     struct ieee80211_vif *vif,

				     struct ieee80211_channel *channel,

				     int duration,

				     enum ieee80211_roc_type type)

{

	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);

	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];

	int err = 0;



	if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))

		return -EOPNOTSUPP;



	if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)))

		return -EOPNOTSUPP;



	IWL_DEBUG_MAC80211(priv, "enter\n");

	mutex_lock(&priv->mutex);



	if (test_bit(STATUS_SCAN_HW, &priv->status)) {

		/* mac80211 should not scan while ROC or ROC while scanning */

		if (WARN_ON_ONCE(priv->scan_type != IWL_SCAN_RADIO_RESET)) {

			err = -EBUSY;

			goto out;

		}



		iwl_scan_cancel_timeout(priv, 100);



		if (test_bit(STATUS_SCAN_HW, &priv->status)) {

			err = -EBUSY;

			goto out;

		}

	}



	priv->hw_roc_channel = channel;

	/* convert from ms to TU */

	priv->hw_roc_duration = DIV_ROUND_UP(1000 * duration, 1024);

	priv->hw_roc_start_notified = false;

	cancel_delayed_work(&priv->hw_roc_disable_work);



	if (!ctx->is_active) {

		static const struct iwl_qos_info default_qos_data = {

			.def_qos_parm = {

				.ac[0] = {

					.cw_min = cpu_to_le16(3),

					.cw_max = cpu_to_le16(7),

					.aifsn = 2,

					.edca_txop = cpu_to_le16(1504),

				},

				.ac[1] = {

					.cw_min = cpu_to_le16(7),

					.cw_max = cpu_to_le16(15),

					.aifsn = 2,

					.edca_txop = cpu_to_le16(3008),

				},

				.ac[2] = {

					.cw_min = cpu_to_le16(15),

					.cw_max = cpu_to_le16(1023),

					.aifsn = 3,

				},

				.ac[3] = {

					.cw_min = cpu_to_le16(15),

					.cw_max = cpu_to_le16(1023),

					.aifsn = 7,

				},

			},

		};



		ctx->is_active = true;

		ctx->qos_data = default_qos_data;

		ctx->staging.dev_type = RXON_DEV_TYPE_P2P;

		memcpy(ctx->staging.node_addr,

		       priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,

		       ETH_ALEN);

		memcpy(ctx->staging.bssid_addr,

		       priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,

		       ETH_ALEN);

		err = iwlagn_commit_rxon(priv, ctx);

		if (err)

			goto out;

		ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK |

					     RXON_FILTER_PROMISC_MSK |

					     RXON_FILTER_CTL2HOST_MSK;



		err = iwlagn_commit_rxon(priv, ctx);

		if (err) {

			iwlagn_disable_roc(priv);

			goto out;

		}

		priv->hw_roc_setup = true;

	}



	err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band);

	if (err)

		iwlagn_disable_roc(priv);



 out:

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "leave\n");



	return err;

}



static int iwlagn_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)

{

	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);



	if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))

		return -EOPNOTSUPP;



	IWL_DEBUG_MAC80211(priv, "enter\n");

	mutex_lock(&priv->mutex);

	iwl_scan_cancel_timeout(priv, priv->hw_roc_duration);

	iwlagn_disable_roc(priv);

	mutex_unlock(&priv->mutex);

	IWL_DEBUG_MAC80211(priv, "leave\n");



	return 0;

}



static void iwlagn_mac_rssi_callback(struct ieee80211_hw *hw,

				     struct ieee80211_vif *vif,

				     enum ieee80211_rssi_event rssi_event)
@@ -1431,12 +1267,8 @@ static int iwlagn_mac_add_interface(struct ieee80211_hw *hw, 
	IWL_DEBUG_MAC80211(priv, "enter: type %d, addr %pM\n",

			   viftype, vif->addr);



	cancel_delayed_work_sync(&priv->hw_roc_disable_work);



	mutex_lock(&priv->mutex);



	iwlagn_disable_roc(priv);



	if (!iwl_is_ready_rf(priv)) {

		IWL_WARN(priv, "Try to add interface when device not ready\n");

		err = -EINVAL;
@@ -1763,8 +1595,6 @@ struct ieee80211_ops iwlagn_hw_ops = { 
	.channel_switch = iwlagn_mac_channel_switch,

	.flush = iwlagn_mac_flush,

	.tx_last_beacon = iwlagn_mac_tx_last_beacon,

	.remain_on_channel = iwlagn_mac_remain_on_channel,

	.cancel_remain_on_channel = iwlagn_mac_cancel_remain_on_channel,

	.rssi_callback = iwlagn_mac_rssi_callback,

	.set_tim = iwlagn_mac_set_tim,

};

drivers/net/wireless/iwlwifi/dvm/main.c

+0 −62
Original line number Diff line number Diff line
@@ -587,11 +587,6 @@ static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags) 
	priv->contexts[IWL_RXON_CTX_PAN].interface_modes =

		BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);



	if (ucode_flags & IWL_UCODE_TLV_FLAGS_P2P)

		priv->contexts[IWL_RXON_CTX_PAN].interface_modes |=

			BIT(NL80211_IFTYPE_P2P_CLIENT) |

			BIT(NL80211_IFTYPE_P2P_GO);



	priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;

	priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;

	priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
@@ -854,14 +849,6 @@ void iwl_down(struct iwl_priv *priv) 


	iwl_scan_cancel_timeout(priv, 200);



	/*

	 * If active, scanning won't cancel it, so say it expired.

	 * No race since we hold the mutex here and a new one

	 * can't come in at this time.

	 */

	if (priv->ucode_loaded && priv->cur_ucode != IWL_UCODE_INIT)

		ieee80211_remain_on_channel_expired(priv->hw);



	exit_pending =

		test_and_set_bit(STATUS_EXIT_PENDING, &priv->status);
@@ -1002,41 +989,6 @@ static void iwl_bg_restart(struct work_struct *data) 
	}

}









void iwlagn_disable_roc(struct iwl_priv *priv)

{

	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];



	lockdep_assert_held(&priv->mutex);



	if (!priv->hw_roc_setup)

		return;



	ctx->staging.dev_type = RXON_DEV_TYPE_P2P;

	ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;



	priv->hw_roc_channel = NULL;



	memset(ctx->staging.node_addr, 0, ETH_ALEN);



	iwlagn_commit_rxon(priv, ctx);



	ctx->is_active = false;

	priv->hw_roc_setup = false;

}



static void iwlagn_disable_roc_work(struct work_struct *work)

{

	struct iwl_priv *priv = container_of(work, struct iwl_priv,

					     hw_roc_disable_work.work);



	mutex_lock(&priv->mutex);

	iwlagn_disable_roc(priv);

	mutex_unlock(&priv->mutex);

}



/*****************************************************************************

 *

 * driver setup and teardown
@@ -1053,8 +1005,6 @@ static void iwl_setup_deferred_work(struct iwl_priv *priv) 
	INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);

	INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);

	INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);

	INIT_DELAYED_WORK(&priv->hw_roc_disable_work,

			  iwlagn_disable_roc_work);



	iwl_setup_scan_deferred_work(priv);
@@ -1082,7 +1032,6 @@ void iwl_cancel_deferred_work(struct iwl_priv *priv) 


	cancel_work_sync(&priv->bt_full_concurrency);

	cancel_work_sync(&priv->bt_runtime_config);

	cancel_delayed_work_sync(&priv->hw_roc_disable_work);



	del_timer_sync(&priv->statistics_periodic);

	del_timer_sync(&priv->ucode_trace);
@@ -1169,12 +1118,6 @@ static void iwl_option_config(struct iwl_priv *priv) 
#else

	IWL_INFO(priv, "CONFIG_IWLWIFI_DEVICE_TRACING disabled\n");

#endif



#ifdef CONFIG_IWLWIFI_P2P

	IWL_INFO(priv, "CONFIG_IWLWIFI_P2P enabled\n");

#else

	IWL_INFO(priv, "CONFIG_IWLWIFI_P2P disabled\n");

#endif

}



static int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
@@ -1315,10 +1258,6 @@ static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans, 


	ucode_flags = fw->ucode_capa.flags;



#ifndef CONFIG_IWLWIFI_P2P

	ucode_flags &= ~IWL_UCODE_TLV_FLAGS_P2P;

#endif



	if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN) {

		priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;

		trans_cfg.cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
@@ -1413,7 +1352,6 @@ static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans, 
		 * if not PAN, then don't support P2P -- might be a uCode

		 * packaging bug or due to the eeprom check above

		 */

		ucode_flags &= ~IWL_UCODE_TLV_FLAGS_P2P;

		priv->sta_key_max_num = STA_KEY_MAX_NUM;

		trans_cfg.cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;

CRA Git | Maintained and supported by SUSTech CRA and CCSE