iwlwifi: cleans up scanning code (f53696de) · Commits · e / devices / android_kernel_xiaomi_nabu

drivers/net/wireless/iwlwifi/iwl-commands.h

+3 −11

Original line number	Diff line number	Diff line
		@@ -281,16 +281,7 @@ struct iwl_cmd_header {
		#define RATE_MCS_ANT_C_MSK 0x10000
		#define RATE_MCS_ANT_ABC_MSK 0x1C000


		/**
		* struct iwl4965_tx_power - txpower format used in REPLY_SCAN_CMD
		*
		* Scan uses only one transmitter, so only one analog/dsp gain pair is needed.
		*/
		struct iwl4965_tx_power {
		u8 tx_gain; /* gain for analog radio */
		u8 dsp_atten; /* gain for DSP */
		} __attribute__ ((packed));
		#define RATE_MCS_ANT_INIT_IND 1

		#define POWER_TABLE_NUM_ENTRIES 33
		#define POWER_TABLE_NUM_HT_OFDM_ENTRIES 32
		@@ -2128,7 +2119,8 @@ struct iwl_scan_channel {
		*/
		u8 type;
		u8 channel; /* band is selected by iwl4965_scan_cmd "flags" field */
		struct iwl4965_tx_power tpc;
		u8 tx_gain; /* gain for analog radio */
		u8 dsp_atten; /* gain for DSP */
		__le16 active_dwell; /* in 1024-uSec TU (time units), typ 5-50 */
		__le16 passive_dwell; /* in 1024-uSec TU (time units), typ 20-500 */
		} __attribute__ ((packed));

drivers/net/wireless/iwlwifi/iwl-core.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -874,6 +874,7 @@ int iwl_init_drv(struct iwl_priv *priv)

		/* Choose which receivers/antennas to use */
		iwl_set_rxon_chain(priv);
		iwl_init_scan_params(priv);

		if (priv->cfg->mod_params->enable_qos)
		priv->qos_data.qos_enable = 1;

drivers/net/wireless/iwlwifi/iwl-core.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -267,6 +267,7 @@ static inline __le32 iwl_hw_set_rate_n_flags(u8 rate, u32 flags)
		/*******************************************************************************
		* Scanning
		******************************************************************************/
		void iwl_init_scan_params(struct iwl_priv *priv);
		int iwl_scan_cancel(struct iwl_priv *priv);
		int iwl_scan_cancel_timeout(struct iwl_priv *priv, unsigned long ms);
		const char iwl_escape_essid(const char essid, u8 essid_len);

drivers/net/wireless/iwlwifi/iwl-dev.h

+1 −32

Original line number	Diff line number	Diff line
		@@ -157,35 +157,11 @@ struct iwl4965_channel_tgh_info {
		s64 last_radar_time;
		};

		/* current Tx power values to use, one for each rate for each channel.
		* requested power is limited by:
		* -- regulatory EEPROM limits for this channel
		* -- hardware capabilities (clip-powers)
		* -- spectrum management
		* -- user preference (e.g. iwconfig)
		* when requested power is set, base power index must also be set. */
		struct iwl4965_channel_power_info {
		struct iwl4965_tx_power tpc; /* actual radio and DSP gain settings */
		s8 power_table_index; /* actual (compenst'd) index into gain table */
		s8 base_power_index; /* gain index for power at factory temp. */
		s8 requested_power; /* power (dBm) requested for this chnl/rate */
		};

		/* current scan Tx power values to use, one for each scan rate for each
		* channel. */
		struct iwl4965_scan_power_info {
		struct iwl4965_tx_power tpc; /* actual radio and DSP gain settings */
		s8 power_table_index; /* actual (compenst'd) index into gain table */
		s8 requested_power; /* scan pwr (dBm) requested for chnl/rate */
		};

		/*
		* One for each channel, holds all channel setup data
		* Some of the fields (e.g. eeprom and flags/max_power_avg) are redundant
		* with one another!
		*/
		#define IWL4965_MAX_RATE (33)

		struct iwl_channel_info {
		struct iwl4965_channel_tgd_info tgd;
		struct iwl4965_channel_tgh_info tgh;
		@@ -204,11 +180,6 @@ struct iwl_channel_info {
		u8 band_index; /* 0-4, maps channel to band1/2/3/4/5 */
		enum ieee80211_band band;

		/* Radio/DSP gain settings for each "normal" data Tx rate.
		* These include, in addition to RF and DSP gain, a few fields for
		* remembering/modifying gain settings (indexes). */
		struct iwl4965_channel_power_info power_info[IWL4965_MAX_RATE];

		/* FAT channel info */
		s8 fat_max_power_avg; /* (dBm) regul. eeprom, normal Tx, any rate */
		s8 fat_curr_txpow; /* (dBm) regulatory/spectrum/user (not h/w) */
		@@ -216,9 +187,6 @@ struct iwl_channel_info {
		s8 fat_scan_power; /* (dBm) eeprom, direct scans, any rate */
		u8 fat_flags; /* flags copied from EEPROM */
		u8 fat_extension_channel; /* HT_IE_EXT_CHANNEL_* */

		/* Radio/DSP gain settings for each scan rate, for directed scans. */
		struct iwl4965_scan_power_info scan_pwr_info[IWL_NUM_SCAN_RATES];
		};

		struct iwl4965_clip_group {
		@@ -974,6 +942,7 @@ struct iwl_priv {
		u8 direct_ssid_len;
		u8 direct_ssid[IW_ESSID_MAX_SIZE];
		struct iwl_scan_cmd *scan;
		u32 scan_tx_ant[IEEE80211_NUM_BANDS];

		/* spinlock */
		spinlock_t lock; /* protect general shared data */

drivers/net/wireless/iwlwifi/iwl-scan.c

+101 −77

Original line number	Diff line number	Diff line
		@@ -58,7 +58,9 @@
		#define IWL_PASSIVE_DWELL_BASE (100)
		#define IWL_CHANNEL_TUNE_TIME 5


		static int scan_tx_ant[3] = {
		RATE_MCS_ANT_A_MSK, RATE_MCS_ANT_B_MSK, RATE_MCS_ANT_C_MSK
		};

		static int iwl_is_empty_essid(const char *essid, int essid_len)
		{
		@@ -385,8 +387,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
		scan_ch->channel =
		ieee80211_frequency_to_channel(channels[i].center_freq);

		ch_info = iwl_get_channel_info(priv, band,
		scan_ch->channel);
		ch_info = iwl_get_channel_info(priv, band, scan_ch->channel);
		if (!is_channel_valid(ch_info)) {
		IWL_DEBUG_SCAN("Channel %d is INVALID for this SKU.\n",
		scan_ch->channel);
		@@ -395,9 +396,9 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,

		if (!is_active \|\| is_channel_passive(ch_info) \|\|
		(channels[i].flags & IEEE80211_CHAN_PASSIVE_SCAN))
		scan_ch->type = 0; /* passive */
		scan_ch->type = 0;
		else
		scan_ch->type = 1; /* active */
		scan_ch->type = 1;

		if (scan_ch->type & 1)
		scan_ch->type \|= (direct_mask << 1);
		@@ -406,17 +407,15 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
		scan_ch->passive_dwell = cpu_to_le16(passive_dwell);

		/* Set txpower levels to defaults */
		scan_ch->tpc.dsp_atten = 110;
		/* scan_pwr_info->tpc.dsp_atten; */
		scan_ch->dsp_atten = 110;

		/scan_pwr_info->tpc.tx_gain; /
		if (band == IEEE80211_BAND_5GHZ)
		scan_ch->tpc.tx_gain = ((1 << 5) \| (3 << 3)) \| 3;
		scan_ch->tx_gain = ((1 << 5) \| (3 << 3)) \| 3;
		else {
		scan_ch->tpc.tx_gain = ((1 << 5) \| (5 << 3));
		scan_ch->tx_gain = ((1 << 5) \| (5 << 3));
		/* NOTE: if we were doing 6Mb OFDM for scans we'd use
		* power level:
		* scan_ch->tpc.tx_gain = ((1 << 5) \| (2 << 3)) \| 3;
		* scan_ch->tx_gain = ((1 << 5) \| (2 << 3)) \| 3;
		*/
		}

		@@ -434,6 +433,14 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,
		return added;
		}

		void iwl_init_scan_params(struct iwl_priv *priv)
		{
		if (!priv->scan_tx_ant[IEEE80211_BAND_5GHZ])
		priv->scan_tx_ant[IEEE80211_BAND_5GHZ] = RATE_MCS_ANT_INIT_IND;
		if (!priv->scan_tx_ant[IEEE80211_BAND_2GHZ])
		priv->scan_tx_ant[IEEE80211_BAND_2GHZ] = RATE_MCS_ANT_INIT_IND;
		}

		int iwl_scan_initiate(struct iwl_priv *priv)
		{
		if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
		@@ -547,10 +554,11 @@ static void iwl_ht_cap_to_ie(const struct ieee80211_supported_band *sband,
		/**
		* iwl_fill_probe_req - fill in all required fields and IE for probe request
		*/

		static u16 iwl_fill_probe_req(struct iwl_priv *priv,
		enum ieee80211_band band,
		struct ieee80211_mgmt *frame,
		int left, int is_direct)
		int left)
		{
		int len = 0;
		u8 *pos = NULL;
		@@ -558,12 +566,12 @@ static u16 iwl_fill_probe_req(struct iwl_priv *priv,
		const struct ieee80211_supported_band *sband =
		iwl_get_hw_mode(priv, band);


		/* Make sure there is enough space for the probe request,
		* two mandatory IEs and the data */
		left -= 24;
		if (left < 0)
		return 0;
		len += 24;

		frame->frame_control = cpu_to_le16(IEEE80211_STYPE_PROBE_REQ);
		memcpy(frame->da, iwl_bcast_addr, ETH_ALEN);
		@@ -571,38 +579,25 @@ static u16 iwl_fill_probe_req(struct iwl_priv *priv,
		memcpy(frame->bssid, iwl_bcast_addr, ETH_ALEN);
		frame->seq_ctrl = 0;

		/* fill in our indirect SSID IE */
		len += 24;

		/* ...next IE... */
		pos = &frame->u.probe_req.variable[0];

		/* fill in our indirect SSID IE */
		left -= 2;
		if (left < 0)
		return 0;
		len += 2;
		pos = &(frame->u.probe_req.variable[0]);
		*pos++ = WLAN_EID_SSID;
		*pos++ = 0;

		/* fill in our direct SSID IE... */
		if (is_direct) {
		/* ...next IE... */
		left -= 2 + priv->essid_len;
		if (left < 0)
		return 0;
		/* ... fill it in... */
		*pos++ = WLAN_EID_SSID;
		*pos++ = priv->essid_len;
		memcpy(pos, priv->essid, priv->essid_len);
		pos += priv->essid_len;
		len += 2 + priv->essid_len;
		}
		len += 2;

		/* fill in supported rate */
		/* ...next IE... */
		left -= 2;
		if (left < 0)
		return 0;

		/* ... fill it in... */
		*pos++ = WLAN_EID_SUPP_RATES;
		*pos = 0;

		@@ -623,6 +618,7 @@ static u16 iwl_fill_probe_req(struct iwl_priv *priv,

		len += 2 + *pos;
		pos += (*pos) + 1;

		if (active_rates == 0)
		goto fill_end;

		@@ -634,27 +630,46 @@ static u16 iwl_fill_probe_req(struct iwl_priv *priv,
		/* ... fill it in... */
		*pos++ = WLAN_EID_EXT_SUPP_RATES;
		*pos = 0;
		iwl_supported_rate_to_ie(pos, active_rates,
		active_rate_basic, &left);
		if (*pos > 0)
		iwl_supported_rate_to_ie(pos, active_rates, active_rate_basic, &left);
		if (*pos > 0) {
		len += 2 + *pos;
		pos += (*pos) + 1;
		} else {
		pos--;
		}

		fill_end:
		/* fill in HT IE */

		left -= 2;
		if (left < 0)
		return 0;

		*pos++ = WLAN_EID_HT_CAPABILITY;
		*pos = 0;

		iwl_ht_cap_to_ie(sband, pos, &left);

		if (*pos > 0)
		len += 2 + *pos;

		return (u16)len;
		}

		static u32 iwl_scan_tx_ant(struct iwl_priv *priv, enum ieee80211_band band)
		{
		int i, ind;

		ind = priv->scan_tx_ant[band];
		for (i = 0; i < priv->hw_params.tx_chains_num; i++) {
		ind = (ind+1) >= priv->hw_params.tx_chains_num ? 0 : ind+1;
		if (priv->hw_params.valid_tx_ant & (1 << ind)) {
		priv->scan_tx_ant[band] = ind;
		break;
		}
		}

		return scan_tx_ant[ind];
		}


		static void iwl_bg_request_scan(struct work_struct *data)
		{
		struct iwl_priv *priv =
		@@ -666,10 +681,12 @@ static void iwl_bg_request_scan(struct work_struct *data)
		};
		struct iwl_scan_cmd *scan;
		struct ieee80211_conf *conf = NULL;
		int ret = 0;
		u32 tx_ant;
		u16 cmd_len;
		enum ieee80211_band band;
		u8 direct_mask;
		int ret = 0;
		u8 rx_chain = 0x7; /* bitmap: ABC chains */

		conf = ieee80211_get_hw_conf(priv->hw);

		@@ -761,8 +778,7 @@ static void iwl_bg_request_scan(struct work_struct *data)

		/* We should add the ability for user to lock to PASSIVE ONLY */
		if (priv->one_direct_scan) {
		IWL_DEBUG_SCAN
		("Kicking off one direct scan for '%s'\n",
		IWL_DEBUG_SCAN("Start direct scan for '%s'\n",
		iwl_escape_essid(priv->direct_ssid,
		priv->direct_ssid_len));
		scan->direct_scan[0].id = WLAN_EID_SSID;
		@@ -771,15 +787,14 @@ static void iwl_bg_request_scan(struct work_struct *data)
		priv->direct_ssid, priv->direct_ssid_len);
		direct_mask = 1;
		} else if (!iwl_is_associated(priv) && priv->essid_len) {
		IWL_DEBUG_SCAN
		("Kicking off one direct scan for '%s' when not associated\n",
		IWL_DEBUG_SCAN("Start direct scan for '%s' (not associated)\n",
		iwl_escape_essid(priv->essid, priv->essid_len));
		scan->direct_scan[0].id = WLAN_EID_SSID;
		scan->direct_scan[0].len = priv->essid_len;
		memcpy(scan->direct_scan[0].ssid, priv->essid, priv->essid_len);
		direct_mask = 1;
		} else {
		IWL_DEBUG_SCAN("Kicking off one indirect scan.\n");
		IWL_DEBUG_SCAN("Start indirect scan.\n");
		direct_mask = 0;
		}

		@@ -790,64 +805,73 @@ static void iwl_bg_request_scan(struct work_struct *data)

		switch (priv->scan_bands) {
		case 2:
		band = IEEE80211_BAND_2GHZ;
		scan->flags = RXON_FLG_BAND_24G_MSK \| RXON_FLG_AUTO_DETECT_MSK;
		tx_ant = iwl_scan_tx_ant(priv, band);
		if (priv->active_rxon.flags & RXON_FLG_CHANNEL_MODE_PURE_40_MSK)
		scan->tx_cmd.rate_n_flags =
		iwl_hw_set_rate_n_flags(IWL_RATE_6M_PLCP,
		tx_ant);
		else
		scan->tx_cmd.rate_n_flags =
		iwl_hw_set_rate_n_flags(IWL_RATE_1M_PLCP,
		RATE_MCS_ANT_B_MSK\|
		tx_ant \|
		RATE_MCS_CCK_MSK);

		scan->good_CRC_th = 0;
		band = IEEE80211_BAND_2GHZ;
		break;

		case 1:
		band = IEEE80211_BAND_5GHZ;
		tx_ant = iwl_scan_tx_ant(priv, band);
		scan->tx_cmd.rate_n_flags =
		iwl_hw_set_rate_n_flags(IWL_RATE_6M_PLCP,
		RATE_MCS_ANT_B_MSK);
		tx_ant);
		scan->good_CRC_th = IWL_GOOD_CRC_TH;
		band = IEEE80211_BAND_5GHZ;
		break;

		/* Force use of chains B and C (0x6) for scan Rx for 4965
		* Avoid A (0x1) because of its off-channel reception on A-band.
		* MIMO is not used here, but value is required */
		if ((priv->hw_rev & CSR_HW_REV_TYPE_MSK) == CSR_HW_REV_TYPE_4965)
		rx_chain = 0x6;

		break;
		default:
		IWL_WARNING("Invalid scan band count\n");
		goto done;
		}

		/* We don't build a direct scan probe request; the uCode will do
		* that based on the direct_mask added to each channel entry */
		scan->rx_chain = RXON_RX_CHAIN_DRIVER_FORCE_MSK \|
		cpu_to_le16((0x7 << RXON_RX_CHAIN_VALID_POS) \|
		(rx_chain << RXON_RX_CHAIN_FORCE_SEL_POS) \|
		(0x7 << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS));

		cmd_len = iwl_fill_probe_req(priv, band,
		(struct ieee80211_mgmt *)scan->data,
		IWL_MAX_SCAN_SIZE - sizeof(*scan), 0);
		IWL_MAX_SCAN_SIZE - sizeof(*scan));

		scan->tx_cmd.len = cpu_to_le16(cmd_len);
		/* select Rx chains */

		/* Force use of chains B and C (0x6) for scan Rx.
		* Avoid A (0x1) because of its off-channel reception on A-band.
		* MIMO is not used here, but value is required to make uCode happy. */
		scan->rx_chain = RXON_RX_CHAIN_DRIVER_FORCE_MSK \|
		cpu_to_le16((0x7 << RXON_RX_CHAIN_VALID_POS) \|
		(0x6 << RXON_RX_CHAIN_FORCE_SEL_POS) \|
		(0x7 << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS));

		if (priv->iw_mode == IEEE80211_IF_TYPE_MNTR)
		scan->filter_flags = RXON_FILTER_PROMISC_MSK;

		scan->filter_flags \|= (RXON_FILTER_ACCEPT_GRP_MSK \|
		RXON_FILTER_BCON_AWARE_MSK);

		if (direct_mask)
		scan->channel_count =
		iwl_get_channels_for_scan(
		priv, band, 1, /* active */
		iwl_get_channels_for_scan(priv, band, 1, /* active */
		direct_mask,
		(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
		else
		scan->channel_count =
		iwl_get_channels_for_scan(
		priv, band, 0, /* passive */
		iwl_get_channels_for_scan(priv, band, 0, /* passive */
		direct_mask,
		(void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]);
		if (scan->channel_count == 0) {
		IWL_DEBUG_SCAN("channel count %d\n", scan->channel_count);
		goto done;
		}

		scan->filter_flags \|= (RXON_FILTER_ACCEPT_GRP_MSK \|
		RXON_FILTER_BCON_AWARE_MSK);
		cmd.len += le16_to_cpu(scan->tx_cmd.len) +
		scan->channel_count * sizeof(struct iwl_scan_channel);
		cmd.data = scan;