iwlagn: remove un-necessary "_agn" (898ed67b) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/net/wireless/iwlwifi/iwl-agn-calib.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -889,7 +889,7 @@ static void iwlagn_gain_computation(struct iwl_priv *priv,
		memset(&cmd, 0, sizeof(cmd));

		iwl_set_calib_hdr(&cmd.hdr,
		priv->_agn.phy_calib_chain_noise_gain_cmd);
		priv->phy_calib_chain_noise_gain_cmd);
		cmd.delta_gain_1 = data->delta_gain_code[1];
		cmd.delta_gain_2 = data->delta_gain_code[2];
		trans_send_cmd_pdu(&priv->trans, REPLY_PHY_CALIBRATION_CMD,

drivers/net/wireless/iwlwifi/iwl-agn-lib.c

+49 −49

Original line number	Diff line number	Diff line
		@@ -53,73 +53,73 @@ static void iwlagn_count_tx_err_status(struct iwl_priv *priv, u16 status)

		switch (status) {
		case TX_STATUS_POSTPONE_DELAY:
		priv->_agn.reply_tx_stats.pp_delay++;
		priv->reply_tx_stats.pp_delay++;
		break;
		case TX_STATUS_POSTPONE_FEW_BYTES:
		priv->_agn.reply_tx_stats.pp_few_bytes++;
		priv->reply_tx_stats.pp_few_bytes++;
		break;
		case TX_STATUS_POSTPONE_BT_PRIO:
		priv->_agn.reply_tx_stats.pp_bt_prio++;
		priv->reply_tx_stats.pp_bt_prio++;
		break;
		case TX_STATUS_POSTPONE_QUIET_PERIOD:
		priv->_agn.reply_tx_stats.pp_quiet_period++;
		priv->reply_tx_stats.pp_quiet_period++;
		break;
		case TX_STATUS_POSTPONE_CALC_TTAK:
		priv->_agn.reply_tx_stats.pp_calc_ttak++;
		priv->reply_tx_stats.pp_calc_ttak++;
		break;
		case TX_STATUS_FAIL_INTERNAL_CROSSED_RETRY:
		priv->_agn.reply_tx_stats.int_crossed_retry++;
		priv->reply_tx_stats.int_crossed_retry++;
		break;
		case TX_STATUS_FAIL_SHORT_LIMIT:
		priv->_agn.reply_tx_stats.short_limit++;
		priv->reply_tx_stats.short_limit++;
		break;
		case TX_STATUS_FAIL_LONG_LIMIT:
		priv->_agn.reply_tx_stats.long_limit++;
		priv->reply_tx_stats.long_limit++;
		break;
		case TX_STATUS_FAIL_FIFO_UNDERRUN:
		priv->_agn.reply_tx_stats.fifo_underrun++;
		priv->reply_tx_stats.fifo_underrun++;
		break;
		case TX_STATUS_FAIL_DRAIN_FLOW:
		priv->_agn.reply_tx_stats.drain_flow++;
		priv->reply_tx_stats.drain_flow++;
		break;
		case TX_STATUS_FAIL_RFKILL_FLUSH:
		priv->_agn.reply_tx_stats.rfkill_flush++;
		priv->reply_tx_stats.rfkill_flush++;
		break;
		case TX_STATUS_FAIL_LIFE_EXPIRE:
		priv->_agn.reply_tx_stats.life_expire++;
		priv->reply_tx_stats.life_expire++;
		break;
		case TX_STATUS_FAIL_DEST_PS:
		priv->_agn.reply_tx_stats.dest_ps++;
		priv->reply_tx_stats.dest_ps++;
		break;
		case TX_STATUS_FAIL_HOST_ABORTED:
		priv->_agn.reply_tx_stats.host_abort++;
		priv->reply_tx_stats.host_abort++;
		break;
		case TX_STATUS_FAIL_BT_RETRY:
		priv->_agn.reply_tx_stats.bt_retry++;
		priv->reply_tx_stats.bt_retry++;
		break;
		case TX_STATUS_FAIL_STA_INVALID:
		priv->_agn.reply_tx_stats.sta_invalid++;
		priv->reply_tx_stats.sta_invalid++;
		break;
		case TX_STATUS_FAIL_FRAG_DROPPED:
		priv->_agn.reply_tx_stats.frag_drop++;
		priv->reply_tx_stats.frag_drop++;
		break;
		case TX_STATUS_FAIL_TID_DISABLE:
		priv->_agn.reply_tx_stats.tid_disable++;
		priv->reply_tx_stats.tid_disable++;
		break;
		case TX_STATUS_FAIL_FIFO_FLUSHED:
		priv->_agn.reply_tx_stats.fifo_flush++;
		priv->reply_tx_stats.fifo_flush++;
		break;
		case TX_STATUS_FAIL_INSUFFICIENT_CF_POLL:
		priv->_agn.reply_tx_stats.insuff_cf_poll++;
		priv->reply_tx_stats.insuff_cf_poll++;
		break;
		case TX_STATUS_FAIL_PASSIVE_NO_RX:
		priv->_agn.reply_tx_stats.fail_hw_drop++;
		priv->reply_tx_stats.fail_hw_drop++;
		break;
		case TX_STATUS_FAIL_NO_BEACON_ON_RADAR:
		priv->_agn.reply_tx_stats.sta_color_mismatch++;
		priv->reply_tx_stats.sta_color_mismatch++;
		break;
		default:
		priv->_agn.reply_tx_stats.unknown++;
		priv->reply_tx_stats.unknown++;
		break;
		}
		}
		@@ -130,43 +130,43 @@ static void iwlagn_count_agg_tx_err_status(struct iwl_priv *priv, u16 status)

		switch (status) {
		case AGG_TX_STATE_UNDERRUN_MSK:
		priv->_agn.reply_agg_tx_stats.underrun++;
		priv->reply_agg_tx_stats.underrun++;
		break;
		case AGG_TX_STATE_BT_PRIO_MSK:
		priv->_agn.reply_agg_tx_stats.bt_prio++;
		priv->reply_agg_tx_stats.bt_prio++;
		break;
		case AGG_TX_STATE_FEW_BYTES_MSK:
		priv->_agn.reply_agg_tx_stats.few_bytes++;
		priv->reply_agg_tx_stats.few_bytes++;
		break;
		case AGG_TX_STATE_ABORT_MSK:
		priv->_agn.reply_agg_tx_stats.abort++;
		priv->reply_agg_tx_stats.abort++;
		break;
		case AGG_TX_STATE_LAST_SENT_TTL_MSK:
		priv->_agn.reply_agg_tx_stats.last_sent_ttl++;
		priv->reply_agg_tx_stats.last_sent_ttl++;
		break;
		case AGG_TX_STATE_LAST_SENT_TRY_CNT_MSK:
		priv->_agn.reply_agg_tx_stats.last_sent_try++;
		priv->reply_agg_tx_stats.last_sent_try++;
		break;
		case AGG_TX_STATE_LAST_SENT_BT_KILL_MSK:
		priv->_agn.reply_agg_tx_stats.last_sent_bt_kill++;
		priv->reply_agg_tx_stats.last_sent_bt_kill++;
		break;
		case AGG_TX_STATE_SCD_QUERY_MSK:
		priv->_agn.reply_agg_tx_stats.scd_query++;
		priv->reply_agg_tx_stats.scd_query++;
		break;
		case AGG_TX_STATE_TEST_BAD_CRC32_MSK:
		priv->_agn.reply_agg_tx_stats.bad_crc32++;
		priv->reply_agg_tx_stats.bad_crc32++;
		break;
		case AGG_TX_STATE_RESPONSE_MSK:
		priv->_agn.reply_agg_tx_stats.response++;
		priv->reply_agg_tx_stats.response++;
		break;
		case AGG_TX_STATE_DUMP_TX_MSK:
		priv->_agn.reply_agg_tx_stats.dump_tx++;
		priv->reply_agg_tx_stats.dump_tx++;
		break;
		case AGG_TX_STATE_DELAY_TX_MSK:
		priv->_agn.reply_agg_tx_stats.delay_tx++;
		priv->reply_agg_tx_stats.delay_tx++;
		break;
		default:
		priv->_agn.reply_agg_tx_stats.unknown++;
		priv->reply_agg_tx_stats.unknown++;
		break;
		}
		}
		@@ -749,7 +749,7 @@ static int iwl_get_channels_for_scan(struct iwl_priv *priv,

		static int iwl_fill_offch_tx(struct iwl_priv priv, void data, size_t maxlen)
		{
		struct sk_buff *skb = priv->_agn.offchan_tx_skb;
		struct sk_buff *skb = priv->offchan_tx_skb;

		if (skb->len < maxlen)
		maxlen = skb->len;
		@@ -835,7 +835,7 @@ int iwlagn_request_scan(struct iwl_priv priv, struct ieee80211_vif vif)
		} else if (priv->scan_type == IWL_SCAN_OFFCH_TX) {
		scan->suspend_time = 0;
		scan->max_out_time =
		cpu_to_le32(1024 * priv->_agn.offchan_tx_timeout);
		cpu_to_le32(1024 * priv->offchan_tx_timeout);
		}

		switch (priv->scan_type) {
		@@ -1023,9 +1023,9 @@ int iwlagn_request_scan(struct iwl_priv priv, struct ieee80211_vif vif)
		scan_ch = (void *)&scan->data[cmd_len];
		scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;
		scan_ch->channel =
		cpu_to_le16(priv->_agn.offchan_tx_chan->hw_value);
		cpu_to_le16(priv->offchan_tx_chan->hw_value);
		scan_ch->active_dwell =
		cpu_to_le16(priv->_agn.offchan_tx_timeout);
		cpu_to_le16(priv->offchan_tx_timeout);
		scan_ch->passive_dwell = 0;

		/* Set txpower levels to defaults */
		@@ -1035,7 +1035,7 @@ int iwlagn_request_scan(struct iwl_priv priv, struct ieee80211_vif vif)
		* power level:
		* scan_ch->tx_gain = ((1 << 5) \| (2 << 3)) \| 3;
		*/
		if (priv->_agn.offchan_tx_chan->band == IEEE80211_BAND_5GHZ)
		if (priv->offchan_tx_chan->band == IEEE80211_BAND_5GHZ)
		scan_ch->tx_gain = ((1 << 5) \| (3 << 3)) \| 3;
		else
		scan_ch->tx_gain = ((1 << 5) \| (5 << 3));
		@@ -2004,9 +2004,9 @@ void iwlagn_init_notification_wait(struct iwl_priv *priv,
		wait_entry->triggered = false;
		wait_entry->aborted = false;

		spin_lock_bh(&priv->_agn.notif_wait_lock);
		list_add(&wait_entry->list, &priv->_agn.notif_waits);
		spin_unlock_bh(&priv->_agn.notif_wait_lock);
		spin_lock_bh(&priv->notif_wait_lock);
		list_add(&wait_entry->list, &priv->notif_waits);
		spin_unlock_bh(&priv->notif_wait_lock);
		}

		int iwlagn_wait_notification(struct iwl_priv *priv,
		@@ -2015,13 +2015,13 @@ int iwlagn_wait_notification(struct iwl_priv *priv,
		{
		int ret;

		ret = wait_event_timeout(priv->_agn.notif_waitq,
		ret = wait_event_timeout(priv->notif_waitq,
		wait_entry->triggered \|\| wait_entry->aborted,
		timeout);

		spin_lock_bh(&priv->_agn.notif_wait_lock);
		spin_lock_bh(&priv->notif_wait_lock);
		list_del(&wait_entry->list);
		spin_unlock_bh(&priv->_agn.notif_wait_lock);
		spin_unlock_bh(&priv->notif_wait_lock);

		if (wait_entry->aborted)
		return -EIO;
		@@ -2035,7 +2035,7 @@ int iwlagn_wait_notification(struct iwl_priv *priv,
		void iwlagn_remove_notification(struct iwl_priv *priv,
		struct iwl_notification_wait *wait_entry)
		{
		spin_lock_bh(&priv->_agn.notif_wait_lock);
		spin_lock_bh(&priv->notif_wait_lock);
		list_del(&wait_entry->list);
		spin_unlock_bh(&priv->_agn.notif_wait_lock);
		spin_unlock_bh(&priv->notif_wait_lock);
		}

drivers/net/wireless/iwlwifi/iwl-agn-rxon.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -337,9 +337,9 @@ int iwlagn_set_pan_params(struct iwl_priv *priv)
		cmd.slots[0].type = 0; /* BSS */
		cmd.slots[1].type = 1; /* PAN */

		if (priv->_agn.hw_roc_channel) {
		if (priv->hw_roc_channel) {
		/* both contexts must be used for this to happen */
		slot1 = priv->_agn.hw_roc_duration;
		slot1 = priv->hw_roc_duration;
		slot0 = IWL_MIN_SLOT_TIME;
		} else if (ctx_bss->vif && ctx_pan->vif) {
		int bcnint = ctx_pan->vif->bss_conf.beacon_int;
		@@ -438,8 +438,8 @@ int iwlagn_commit_rxon(struct iwl_priv priv, struct iwl_rxon_context ctx)
		/* always get timestamp with Rx frame */
		ctx->staging.flags \|= RXON_FLG_TSF2HOST_MSK;

		if (ctx->ctxid == IWL_RXON_CTX_PAN && priv->_agn.hw_roc_channel) {
		struct ieee80211_channel *chan = priv->_agn.hw_roc_channel;
		if (ctx->ctxid == IWL_RXON_CTX_PAN && priv->hw_roc_channel) {
		struct ieee80211_channel *chan = priv->hw_roc_channel;

		iwl_set_rxon_channel(priv, chan, ctx);
		iwl_set_flags_for_band(priv, ctx, chan->band, NULL);
		@@ -787,7 +787,7 @@ static void iwlagn_chain_noise_reset(struct iwl_priv *priv)

		memset(&cmd, 0, sizeof(cmd));
		iwl_set_calib_hdr(&cmd.hdr,
		priv->_agn.phy_calib_chain_noise_reset_cmd);
		priv->phy_calib_chain_noise_reset_cmd);
		ret = trans_send_cmd_pdu(&priv->trans,
		REPLY_PHY_CALIBRATION_CMD,
		CMD_SYNC, sizeof(cmd), &cmd);

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

+45 −45

Original line number	Diff line number	Diff line
		@@ -1103,20 +1103,20 @@ static void iwl_ucode_callback(const struct firmware ucode_raw, void context)
		* for each event, which is of mode 1 (including timestamp) for all
		* new microcodes that include this information.
		*/
		priv->_agn.init_evtlog_ptr = pieces.init_evtlog_ptr;
		priv->init_evtlog_ptr = pieces.init_evtlog_ptr;
		if (pieces.init_evtlog_size)
		priv->_agn.init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
		priv->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
		else
		priv->_agn.init_evtlog_size =
		priv->init_evtlog_size =
		priv->cfg->base_params->max_event_log_size;
		priv->_agn.init_errlog_ptr = pieces.init_errlog_ptr;
		priv->_agn.inst_evtlog_ptr = pieces.inst_evtlog_ptr;
		priv->init_errlog_ptr = pieces.init_errlog_ptr;
		priv->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
		if (pieces.inst_evtlog_size)
		priv->_agn.inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
		priv->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
		else
		priv->_agn.inst_evtlog_size =
		priv->inst_evtlog_size =
		priv->cfg->base_params->max_event_log_size;
		priv->_agn.inst_errlog_ptr = pieces.inst_errlog_ptr;
		priv->inst_errlog_ptr = pieces.inst_errlog_ptr;

		priv->new_scan_threshold_behaviour =
		!!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
		@@ -1142,9 +1142,9 @@ static void iwl_ucode_callback(const struct firmware ucode_raw, void context)
		ucode_capa.standard_phy_calibration_size =
		IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;

		priv->_agn.phy_calib_chain_noise_reset_cmd =
		priv->phy_calib_chain_noise_reset_cmd =
		ucode_capa.standard_phy_calibration_size;
		priv->_agn.phy_calib_chain_noise_gain_cmd =
		priv->phy_calib_chain_noise_gain_cmd =
		ucode_capa.standard_phy_calibration_size + 1;

		/**************************************************
		@@ -1169,7 +1169,7 @@ static void iwl_ucode_callback(const struct firmware ucode_raw, void context)

		/* We have our copies now, allow OS release its copies */
		release_firmware(ucode_raw);
		complete(&priv->_agn.firmware_loading_complete);
		complete(&priv->firmware_loading_complete);
		return;

		try_again:
		@@ -1183,7 +1183,7 @@ static void iwl_ucode_callback(const struct firmware ucode_raw, void context)
		IWL_ERR(priv, "failed to allocate pci memory\n");
		iwl_dealloc_ucode(priv);
		out_unbind:
		complete(&priv->_agn.firmware_loading_complete);
		complete(&priv->firmware_loading_complete);
		device_release_driver(priv->bus->dev);
		release_firmware(ucode_raw);
		}
		@@ -1265,10 +1265,10 @@ void iwl_dump_nic_error_log(struct iwl_priv *priv)
		base = priv->device_pointers.error_event_table;
		if (priv->ucode_type == IWL_UCODE_INIT) {
		if (!base)
		base = priv->_agn.init_errlog_ptr;
		base = priv->init_errlog_ptr;
		} else {
		if (!base)
		base = priv->_agn.inst_errlog_ptr;
		base = priv->inst_errlog_ptr;
		}

		if (!iwlagn_hw_valid_rtc_data_addr(base)) {
		@@ -1341,10 +1341,10 @@ static int iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
		base = priv->device_pointers.log_event_table;
		if (priv->ucode_type == IWL_UCODE_INIT) {
		if (!base)
		base = priv->_agn.init_evtlog_ptr;
		base = priv->init_evtlog_ptr;
		} else {
		if (!base)
		base = priv->_agn.inst_evtlog_ptr;
		base = priv->inst_evtlog_ptr;
		}

		if (mode == 0)
		@@ -1453,13 +1453,13 @@ int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,

		base = priv->device_pointers.log_event_table;
		if (priv->ucode_type == IWL_UCODE_INIT) {
		logsize = priv->_agn.init_evtlog_size;
		logsize = priv->init_evtlog_size;
		if (!base)
		base = priv->_agn.init_evtlog_ptr;
		base = priv->init_evtlog_ptr;
		} else {
		logsize = priv->_agn.inst_evtlog_size;
		logsize = priv->inst_evtlog_size;
		if (!base)
		base = priv->_agn.inst_evtlog_ptr;
		base = priv->inst_evtlog_ptr;
		}

		if (!iwlagn_hw_valid_rtc_data_addr(base)) {
		@@ -1964,7 +1964,7 @@ static int iwl_mac_offchannel_tx(struct ieee80211_hw hw, struct sk_buff skb,

		/* TODO: queue up if scanning? */
		if (test_bit(STATUS_SCANNING, &priv->status) \|\|
		priv->_agn.offchan_tx_skb) {
		priv->offchan_tx_skb) {
		ret = -EBUSY;
		goto out;
		}
		@@ -1978,14 +1978,14 @@ static int iwl_mac_offchannel_tx(struct ieee80211_hw hw, struct sk_buff skb,
		goto out;
		}

		priv->_agn.offchan_tx_skb = skb;
		priv->_agn.offchan_tx_timeout = wait;
		priv->_agn.offchan_tx_chan = chan;
		priv->offchan_tx_skb = skb;
		priv->offchan_tx_timeout = wait;
		priv->offchan_tx_chan = chan;

		ret = iwl_scan_initiate(priv, priv->contexts[IWL_RXON_CTX_PAN].vif,
		IWL_SCAN_OFFCH_TX, chan->band);
		if (ret)
		priv->_agn.offchan_tx_skb = NULL;
		priv->offchan_tx_skb = NULL;
		out:
		mutex_unlock(&priv->mutex);
		free:
		@@ -2002,12 +2002,12 @@ static int iwl_mac_offchannel_tx_cancel_wait(struct ieee80211_hw *hw)

		mutex_lock(&priv->mutex);

		if (!priv->_agn.offchan_tx_skb) {
		if (!priv->offchan_tx_skb) {
		ret = -EINVAL;
		goto unlock;
		}

		priv->_agn.offchan_tx_skb = NULL;
		priv->offchan_tx_skb = NULL;

		ret = iwl_scan_cancel_timeout(priv, 200);
		if (ret)
		@@ -2380,18 +2380,18 @@ static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
		IWL_DEBUG_HT(priv, "start Tx\n");
		ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
		if (ret == 0) {
		priv->_agn.agg_tids_count++;
		IWL_DEBUG_HT(priv, "priv->_agn.agg_tids_count = %u\n",
		priv->_agn.agg_tids_count);
		priv->agg_tids_count++;
		IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
		priv->agg_tids_count);
		}
		break;
		case IEEE80211_AMPDU_TX_STOP:
		IWL_DEBUG_HT(priv, "stop Tx\n");
		ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
		if ((ret == 0) && (priv->_agn.agg_tids_count > 0)) {
		priv->_agn.agg_tids_count--;
		IWL_DEBUG_HT(priv, "priv->_agn.agg_tids_count = %u\n",
		priv->_agn.agg_tids_count);
		if ((ret == 0) && (priv->agg_tids_count > 0)) {
		priv->agg_tids_count--;
		IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
		priv->agg_tids_count);
		}
		if (test_bit(STATUS_EXIT_PENDING, &priv->status))
		ret = 0;
		@@ -2698,7 +2698,7 @@ static void iwlagn_disable_roc(struct iwl_priv *priv)
		iwl_set_rxon_channel(priv, chan, ctx);
		iwl_set_flags_for_band(priv, ctx, chan->band, NULL);

		priv->_agn.hw_roc_channel = NULL;
		priv->hw_roc_channel = NULL;

		iwlagn_commit_rxon(priv, ctx);

		@@ -2708,7 +2708,7 @@ static void iwlagn_disable_roc(struct iwl_priv *priv)
		static void iwlagn_bg_roc_done(struct work_struct *work)
		{
		struct iwl_priv *priv = container_of(work, struct iwl_priv,
		_agn.hw_roc_work.work);
		hw_roc_work.work);

		mutex_lock(&priv->mutex);
		ieee80211_remain_on_channel_expired(priv->hw);
		@@ -2740,11 +2740,11 @@ static int iwl_mac_remain_on_channel(struct ieee80211_hw *hw,
		}

		priv->contexts[IWL_RXON_CTX_PAN].is_active = true;
		priv->_agn.hw_roc_channel = channel;
		priv->_agn.hw_roc_chantype = channel_type;
		priv->_agn.hw_roc_duration = DIV_ROUND_UP(duration * 1000, 1024);
		priv->hw_roc_channel = channel;
		priv->hw_roc_chantype = channel_type;
		priv->hw_roc_duration = DIV_ROUND_UP(duration * 1000, 1024);
		iwlagn_commit_rxon(priv, &priv->contexts[IWL_RXON_CTX_PAN]);
		queue_delayed_work(priv->workqueue, &priv->_agn.hw_roc_work,
		queue_delayed_work(priv->workqueue, &priv->hw_roc_work,
		msecs_to_jiffies(duration + 20));

		msleep(IWL_MIN_SLOT_TIME); /* TU is almost ms */
		@@ -2763,7 +2763,7 @@ static int iwl_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
		if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
		return -EOPNOTSUPP;

		cancel_delayed_work_sync(&priv->_agn.hw_roc_work);
		cancel_delayed_work_sync(&priv->hw_roc_work);

		mutex_lock(&priv->mutex);
		iwlagn_disable_roc(priv);
		@@ -2790,7 +2790,7 @@ 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->_agn.hw_roc_work, iwlagn_bg_roc_done);
		INIT_DELAYED_WORK(&priv->hw_roc_work, iwlagn_bg_roc_done);

		iwl_setup_scan_deferred_work(priv);

		@@ -2864,7 +2864,7 @@ static int iwl_init_drv(struct iwl_priv *priv)
		priv->iw_mode = NL80211_IFTYPE_STATION;
		priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
		priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
		priv->_agn.agg_tids_count = 0;
		priv->agg_tids_count = 0;

		/* initialize force reset */
		priv->force_reset[IWL_RF_RESET].reset_duration =
		@@ -3247,7 +3247,7 @@ int iwl_probe(struct iwl_bus bus, struct iwl_cfg cfg)
		iwl_power_initialize(priv);
		iwl_tt_initialize(priv);

		init_completion(&priv->_agn.firmware_loading_complete);
		init_completion(&priv->firmware_loading_complete);

		err = iwl_request_firmware(priv, true);
		if (err)
		@@ -3274,7 +3274,7 @@ void __devexit iwl_remove(struct iwl_priv * priv)
		{
		unsigned long flags;

		wait_for_completion(&priv->_agn.firmware_loading_complete);
		wait_for_completion(&priv->firmware_loading_complete);

		IWL_DEBUG_INFO(priv, "* UNLOAD DRIVER *\n");

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

+4 −4

Original line number	Diff line number	Diff line
		@@ -840,12 +840,12 @@ static void iwlagn_abort_notification_waits(struct iwl_priv *priv)
		unsigned long flags;
		struct iwl_notification_wait *wait_entry;

		spin_lock_irqsave(&priv->_agn.notif_wait_lock, flags);
		list_for_each_entry(wait_entry, &priv->_agn.notif_waits, list)
		spin_lock_irqsave(&priv->notif_wait_lock, flags);
		list_for_each_entry(wait_entry, &priv->notif_waits, list)
		wait_entry->aborted = true;
		spin_unlock_irqrestore(&priv->_agn.notif_wait_lock, flags);
		spin_unlock_irqrestore(&priv->notif_wait_lock, flags);

		wake_up_all(&priv->_agn.notif_waitq);
		wake_up_all(&priv->notif_waitq);
		}

		void iwlagn_fw_error(struct iwl_priv *priv, bool ondemand)