1 files changed, 136 insertions, 136 deletions

diff --git a/drivers/net/wireless/iwlegacy/iwl-scan.c b/drivers/net/wireless/iwlegacy/iwl-scan.c
index 93e939cc9bc..0184d5bf04e 100644
--- a/drivers/net/wireless/iwlegacy/iwl-scan.c
+++ b/drivers/net/wireless/iwlegacy/iwl-scan.c
@@ -54,7 +54,7 @@
 #define IL_PASSIVE_DWELL_BASE      (100)
 #define IL_CHANNEL_TUNE_TIME       5
 
-static int il_send_scan_abort(struct il_priv *priv)
+static int il_send_scan_abort(struct il_priv *il)
 {
 	int ret;
 	struct il_rx_packet *pkt;
@@ -66,14 +66,14 @@ static int il_send_scan_abort(struct il_priv *priv)
 	/* Exit instantly with error when device is not ready
 	 * to receive scan abort command or it does not perform
 	 * hardware scan currently */
-	if (!test_bit(STATUS_READY, &priv->status) ||
-	    !test_bit(STATUS_GEO_CONFIGURED, &priv->status) ||
-	    !test_bit(STATUS_SCAN_HW, &priv->status) ||
-	    test_bit(STATUS_FW_ERROR, &priv->status) ||
-	    test_bit(STATUS_EXIT_PENDING, &priv->status))
+	if (!test_bit(STATUS_READY, &il->status) ||
+	    !test_bit(STATUS_GEO_CONFIGURED, &il->status) ||
+	    !test_bit(STATUS_SCAN_HW, &il->status) ||
+	    test_bit(STATUS_FW_ERROR, &il->status) ||
+	    test_bit(STATUS_EXIT_PENDING, &il->status))
 		return -EIO;
 
-	ret = il_send_cmd_sync(priv, &cmd);
+	ret = il_send_cmd_sync(il, &cmd);
 	if (ret)
 		return ret;
 
@@ -85,73 +85,73 @@ static int il_send_scan_abort(struct il_priv *priv)
 		 * can occur if we send the scan abort before we
 		 * the microcode has notified us that a scan is
 		 * completed. */
-		IL_DEBUG_SCAN(priv, "SCAN_ABORT ret %d.\n", pkt->u.status);
+		IL_DEBUG_SCAN(il, "SCAN_ABORT ret %d.\n", pkt->u.status);
 		ret = -EIO;
 	}
 
-	il_free_pages(priv, cmd.reply_page);
+	il_free_pages(il, cmd.reply_page);
 	return ret;
 }
 
-static void il_complete_scan(struct il_priv *priv, bool aborted)
+static void il_complete_scan(struct il_priv *il, bool aborted)
 {
 	/* check if scan was requested from mac80211 */
-	if (priv->scan_request) {
-		IL_DEBUG_SCAN(priv, "Complete scan in mac80211\n");
-		ieee80211_scan_completed(priv->hw, aborted);
+	if (il->scan_request) {
+		IL_DEBUG_SCAN(il, "Complete scan in mac80211\n");
+		ieee80211_scan_completed(il->hw, aborted);
 	}
 
-	priv->scan_vif = NULL;
-	priv->scan_request = NULL;
+	il->scan_vif = NULL;
+	il->scan_request = NULL;
 }
 
-void il_force_scan_end(struct il_priv *priv)
+void il_force_scan_end(struct il_priv *il)
 {
-	lockdep_assert_held(&priv->mutex);
+	lockdep_assert_held(&il->mutex);
 
-	if (!test_bit(STATUS_SCANNING, &priv->status)) {
-		IL_DEBUG_SCAN(priv, "Forcing scan end while not scanning\n");
+	if (!test_bit(STATUS_SCANNING, &il->status)) {
+		IL_DEBUG_SCAN(il, "Forcing scan end while not scanning\n");
 		return;
 	}
 
-	IL_DEBUG_SCAN(priv, "Forcing scan end\n");
-	clear_bit(STATUS_SCANNING, &priv->status);
-	clear_bit(STATUS_SCAN_HW, &priv->status);
-	clear_bit(STATUS_SCAN_ABORTING, &priv->status);
-	il_complete_scan(priv, true);
+	IL_DEBUG_SCAN(il, "Forcing scan end\n");
+	clear_bit(STATUS_SCANNING, &il->status);
+	clear_bit(STATUS_SCAN_HW, &il->status);
+	clear_bit(STATUS_SCAN_ABORTING, &il->status);
+	il_complete_scan(il, true);
 }
 
-static void il_do_scan_abort(struct il_priv *priv)
+static void il_do_scan_abort(struct il_priv *il)
 {
 	int ret;
 
-	lockdep_assert_held(&priv->mutex);
+	lockdep_assert_held(&il->mutex);
 
-	if (!test_bit(STATUS_SCANNING, &priv->status)) {
-		IL_DEBUG_SCAN(priv, "Not performing scan to abort\n");
+	if (!test_bit(STATUS_SCANNING, &il->status)) {
+		IL_DEBUG_SCAN(il, "Not performing scan to abort\n");
 		return;
 	}
 
-	if (test_and_set_bit(STATUS_SCAN_ABORTING, &priv->status)) {
-		IL_DEBUG_SCAN(priv, "Scan abort in progress\n");
+	if (test_and_set_bit(STATUS_SCAN_ABORTING, &il->status)) {
+		IL_DEBUG_SCAN(il, "Scan abort in progress\n");
 		return;
 	}
 
-	ret = il_send_scan_abort(priv);
+	ret = il_send_scan_abort(il);
 	if (ret) {
-		IL_DEBUG_SCAN(priv, "Send scan abort failed %d\n", ret);
-		il_force_scan_end(priv);
+		IL_DEBUG_SCAN(il, "Send scan abort failed %d\n", ret);
+		il_force_scan_end(il);
 	} else
-		IL_DEBUG_SCAN(priv, "Successfully send scan abort\n");
+		IL_DEBUG_SCAN(il, "Successfully send scan abort\n");
 }
 
 /**
  * il_scan_cancel - Cancel any currently executing HW scan
  */
-int il_scan_cancel(struct il_priv *priv)
+int il_scan_cancel(struct il_priv *il)
 {
-	IL_DEBUG_SCAN(priv, "Queuing abort scan\n");
-	queue_work(priv->workqueue, &priv->abort_scan);
+	IL_DEBUG_SCAN(il, "Queuing abort scan\n");
+	queue_work(il->workqueue, &il->abort_scan);
 	return 0;
 }
 EXPORT_SYMBOL(il_scan_cancel);
@@ -161,28 +161,28 @@ EXPORT_SYMBOL(il_scan_cancel);
  * @ms: amount of time to wait (in milliseconds) for scan to abort
  *
  */
-int il_scan_cancel_timeout(struct il_priv *priv, unsigned long ms)
+int il_scan_cancel_timeout(struct il_priv *il, unsigned long ms)
 {
 	unsigned long timeout = jiffies + msecs_to_jiffies(ms);
 
-	lockdep_assert_held(&priv->mutex);
+	lockdep_assert_held(&il->mutex);
 
-	IL_DEBUG_SCAN(priv, "Scan cancel timeout\n");
+	IL_DEBUG_SCAN(il, "Scan cancel timeout\n");
 
-	il_do_scan_abort(priv);
+	il_do_scan_abort(il);
 
 	while (time_before_eq(jiffies, timeout)) {
-		if (!test_bit(STATUS_SCAN_HW, &priv->status))
+		if (!test_bit(STATUS_SCAN_HW, &il->status))
 			break;
 		msleep(20);
 	}
 
-	return test_bit(STATUS_SCAN_HW, &priv->status);
+	return test_bit(STATUS_SCAN_HW, &il->status);
 }
 EXPORT_SYMBOL(il_scan_cancel_timeout);
 
 /* Service response to REPLY_SCAN_CMD (0x80) */
-static void il_rx_reply_scan(struct il_priv *priv,
+static void il_rx_reply_scan(struct il_priv *il,
 			      struct il_rx_mem_buffer *rxb)
 {
 #ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
@@ -190,19 +190,19 @@ static void il_rx_reply_scan(struct il_priv *priv,
 	struct il_scanreq_notification *notif =
 	    (struct il_scanreq_notification *)pkt->u.raw;
 
-	IL_DEBUG_SCAN(priv, "Scan request status = 0x%x\n", notif->status);
+	IL_DEBUG_SCAN(il, "Scan request status = 0x%x\n", notif->status);
 #endif
 }
 
 /* Service SCAN_START_NOTIFICATION (0x82) */
-static void il_rx_scan_start_notif(struct il_priv *priv,
+static void il_rx_scan_start_notif(struct il_priv *il,
 				    struct il_rx_mem_buffer *rxb)
 {
 	struct il_rx_packet *pkt = rxb_addr(rxb);
 	struct il_scanstart_notification *notif =
 	    (struct il_scanstart_notification *)pkt->u.raw;
-	priv->scan_start_tsf = le32_to_cpu(notif->tsf_low);
-	IL_DEBUG_SCAN(priv, "Scan start: "
+	il->scan_start_tsf = le32_to_cpu(notif->tsf_low);
+	IL_DEBUG_SCAN(il, "Scan start: "
 		       "%d [802.11%s] "
 		       "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n",
 		       notif->channel,
@@ -213,7 +213,7 @@ static void il_rx_scan_start_notif(struct il_priv *priv,
 }
 
 /* Service SCAN_RESULTS_NOTIFICATION (0x83) */
-static void il_rx_scan_results_notif(struct il_priv *priv,
+static void il_rx_scan_results_notif(struct il_priv *il,
 				      struct il_rx_mem_buffer *rxb)
 {
 #ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
@@ -221,7 +221,7 @@ static void il_rx_scan_results_notif(struct il_priv *priv,
 	struct il_scanresults_notification *notif =
 	    (struct il_scanresults_notification *)pkt->u.raw;
 
-	IL_DEBUG_SCAN(priv, "Scan ch.res: "
+	IL_DEBUG_SCAN(il, "Scan ch.res: "
 		       "%d [802.11%s] "
 		       "(TSF: 0x%08X:%08X) - %d "
 		       "elapsed=%lu usec\n",
@@ -230,12 +230,12 @@ static void il_rx_scan_results_notif(struct il_priv *priv,
 		       le32_to_cpu(notif->tsf_high),
 		       le32_to_cpu(notif->tsf_low),
 		       le32_to_cpu(notif->statistics[0]),
-		       le32_to_cpu(notif->tsf_low) - priv->scan_start_tsf);
+		       le32_to_cpu(notif->tsf_low) - il->scan_start_tsf);
 #endif
 }
 
 /* Service SCAN_COMPLETE_NOTIFICATION (0x84) */
-static void il_rx_scan_complete_notif(struct il_priv *priv,
+static void il_rx_scan_complete_notif(struct il_priv *il,
 				       struct il_rx_mem_buffer *rxb)
 {
 
@@ -244,36 +244,36 @@ static void il_rx_scan_complete_notif(struct il_priv *priv,
 	struct il_scancomplete_notification *scan_notif = (void *)pkt->u.raw;
 #endif
 
-	IL_DEBUG_SCAN(priv,
+	IL_DEBUG_SCAN(il,
 			"Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
 		       scan_notif->scanned_channels,
 		       scan_notif->tsf_low,
 		       scan_notif->tsf_high, scan_notif->status);
 
 	/* The HW is no longer scanning */
-	clear_bit(STATUS_SCAN_HW, &priv->status);
+	clear_bit(STATUS_SCAN_HW, &il->status);
 
-	IL_DEBUG_SCAN(priv, "Scan on %sGHz took %dms\n",
-		       (priv->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
-		       jiffies_to_msecs(jiffies - priv->scan_start));
+	IL_DEBUG_SCAN(il, "Scan on %sGHz took %dms\n",
+		       (il->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
+		       jiffies_to_msecs(jiffies - il->scan_start));
 
-	queue_work(priv->workqueue, &priv->scan_completed);
+	queue_work(il->workqueue, &il->scan_completed);
 }
 
-void il_setup_rx_scan_handlers(struct il_priv *priv)
+void il_setup_rx_scan_handlers(struct il_priv *il)
 {
 	/* scan handlers */
-	priv->rx_handlers[REPLY_SCAN_CMD] = il_rx_reply_scan;
-	priv->rx_handlers[SCAN_START_NOTIFICATION] =
+	il->rx_handlers[REPLY_SCAN_CMD] = il_rx_reply_scan;
+	il->rx_handlers[SCAN_START_NOTIFICATION] =
 					il_rx_scan_start_notif;
-	priv->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
+	il->rx_handlers[SCAN_RESULTS_NOTIFICATION] =
 					il_rx_scan_results_notif;
-	priv->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
+	il->rx_handlers[SCAN_COMPLETE_NOTIFICATION] =
 					il_rx_scan_complete_notif;
 }
 EXPORT_SYMBOL(il_setup_rx_scan_handlers);
 
-inline u16 il_get_active_dwell_time(struct il_priv *priv,
+inline u16 il_get_active_dwell_time(struct il_priv *il,
 				     enum ieee80211_band band,
 				     u8 n_probes)
 {
@@ -286,7 +286,7 @@ inline u16 il_get_active_dwell_time(struct il_priv *priv,
 }
 EXPORT_SYMBOL(il_get_active_dwell_time);
 
-u16 il_get_passive_dwell_time(struct il_priv *priv,
+u16 il_get_passive_dwell_time(struct il_priv *il,
 			       enum ieee80211_band band,
 			       struct ieee80211_vif *vif)
 {
@@ -295,13 +295,13 @@ u16 il_get_passive_dwell_time(struct il_priv *priv,
 	    IL_PASSIVE_DWELL_BASE + IL_PASSIVE_DWELL_TIME_24 :
 	    IL_PASSIVE_DWELL_BASE + IL_PASSIVE_DWELL_TIME_52;
 
-	if (il_is_any_associated(priv)) {
+	if (il_is_any_associated(il)) {
 		/*
 		 * If we're associated, we clamp the maximum passive
 		 * dwell time to be 98% of the smallest beacon interval
 		 * (minus 2 * channel tune time)
 		 */
-		for_each_context(priv, ctx) {
+		for_each_context(il, ctx) {
 			u16 value;
 
 			if (!il_is_associated_ctx(ctx))
@@ -318,56 +318,56 @@ u16 il_get_passive_dwell_time(struct il_priv *priv,
 }
 EXPORT_SYMBOL(il_get_passive_dwell_time);
 
-void il_init_scan_params(struct il_priv *priv)
+void il_init_scan_params(struct il_priv *il)
 {
-	u8 ant_idx = fls(priv->hw_params.valid_tx_ant) - 1;
-	if (!priv->scan_tx_ant[IEEE80211_BAND_5GHZ])
-		priv->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
-	if (!priv->scan_tx_ant[IEEE80211_BAND_2GHZ])
-		priv->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
+	u8 ant_idx = fls(il->hw_params.valid_tx_ant) - 1;
+	if (!il->scan_tx_ant[IEEE80211_BAND_5GHZ])
+		il->scan_tx_ant[IEEE80211_BAND_5GHZ] = ant_idx;
+	if (!il->scan_tx_ant[IEEE80211_BAND_2GHZ])
+		il->scan_tx_ant[IEEE80211_BAND_2GHZ] = ant_idx;
 }
 EXPORT_SYMBOL(il_init_scan_params);
 
-static int il_scan_initiate(struct il_priv *priv,
+static int il_scan_initiate(struct il_priv *il,
 				    struct ieee80211_vif *vif)
 {
 	int ret;
 
-	lockdep_assert_held(&priv->mutex);
+	lockdep_assert_held(&il->mutex);
 
-	if (WARN_ON(!priv->cfg->ops->utils->request_scan))
+	if (WARN_ON(!il->cfg->ops->utils->request_scan))
 		return -EOPNOTSUPP;
 
-	cancel_delayed_work(&priv->scan_check);
+	cancel_delayed_work(&il->scan_check);
 
-	if (!il_is_ready_rf(priv)) {
-		IL_WARN(priv, "Request scan called when driver not ready.\n");
+	if (!il_is_ready_rf(il)) {
+		IL_WARN(il, "Request scan called when driver not ready.\n");
 		return -EIO;
 	}
 
-	if (test_bit(STATUS_SCAN_HW, &priv->status)) {
-		IL_DEBUG_SCAN(priv,
+	if (test_bit(STATUS_SCAN_HW, &il->status)) {
+		IL_DEBUG_SCAN(il,
 			"Multiple concurrent scan requests in parallel.\n");
 		return -EBUSY;
 	}
 
-	if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) {
-		IL_DEBUG_SCAN(priv, "Scan request while abort pending.\n");
+	if (test_bit(STATUS_SCAN_ABORTING, &il->status)) {
+		IL_DEBUG_SCAN(il, "Scan request while abort pending.\n");
 		return -EBUSY;
 	}
 
-	IL_DEBUG_SCAN(priv, "Starting scan...\n");
+	IL_DEBUG_SCAN(il, "Starting scan...\n");
 
-	set_bit(STATUS_SCANNING, &priv->status);
-	priv->scan_start = jiffies;
+	set_bit(STATUS_SCANNING, &il->status);
+	il->scan_start = jiffies;
 
-	ret = priv->cfg->ops->utils->request_scan(priv, vif);
+	ret = il->cfg->ops->utils->request_scan(il, vif);
 	if (ret) {
-		clear_bit(STATUS_SCANNING, &priv->status);
+		clear_bit(STATUS_SCANNING, &il->status);
 		return ret;
 	}
 
-	queue_delayed_work(priv->workqueue, &priv->scan_check,
+	queue_delayed_work(il->workqueue, &il->scan_check,
 			   IL_SCAN_CHECK_WATCHDOG);
 
 	return 0;
@@ -377,33 +377,33 @@ int il_mac_hw_scan(struct ieee80211_hw *hw,
 		    struct ieee80211_vif *vif,
 		    struct cfg80211_scan_request *req)
 {
-	struct il_priv *priv = hw->priv;
+	struct il_priv *il = hw->priv;
 	int ret;
 
-	IL_DEBUG_MAC80211(priv, "enter\n");
+	IL_DEBUG_MAC80211(il, "enter\n");
 
 	if (req->n_channels == 0)
 		return -EINVAL;
 
-	mutex_lock(&priv->mutex);
+	mutex_lock(&il->mutex);
 
-	if (test_bit(STATUS_SCANNING, &priv->status)) {
-		IL_DEBUG_SCAN(priv, "Scan already in progress.\n");
+	if (test_bit(STATUS_SCANNING, &il->status)) {
+		IL_DEBUG_SCAN(il, "Scan already in progress.\n");
 		ret = -EAGAIN;
 		goto out_unlock;
 	}
 
 	/* mac80211 will only ask for one band at a time */
-	priv->scan_request = req;
-	priv->scan_vif = vif;
-	priv->scan_band = req->channels[0]->band;
+	il->scan_request = req;
+	il->scan_vif = vif;
+	il->scan_band = req->channels[0]->band;
 
-	ret = il_scan_initiate(priv, vif);
+	ret = il_scan_initiate(il, vif);
 
-	IL_DEBUG_MAC80211(priv, "leave\n");
+	IL_DEBUG_MAC80211(il, "leave\n");
 
 out_unlock:
-	mutex_unlock(&priv->mutex);
+	mutex_unlock(&il->mutex);
 
 	return ret;
 }
@@ -411,17 +411,17 @@ EXPORT_SYMBOL(il_mac_hw_scan);
 
 static void il_bg_scan_check(struct work_struct *data)
 {
-	struct il_priv *priv =
+	struct il_priv *il =
 	    container_of(data, struct il_priv, scan_check.work);
 
-	IL_DEBUG_SCAN(priv, "Scan check work\n");
+	IL_DEBUG_SCAN(il, "Scan check work\n");
 
 	/* Since we are here firmware does not finish scan and
 	 * most likely is in bad shape, so we don't bother to
 	 * send abort command, just force scan complete to mac80211 */
-	mutex_lock(&priv->mutex);
-	il_force_scan_end(priv);
-	mutex_unlock(&priv->mutex);
+	mutex_lock(&il->mutex);
+	il_force_scan_end(il);
+	mutex_unlock(&il->mutex);
 }
 
 /**
@@ -429,7 +429,7 @@ static void il_bg_scan_check(struct work_struct *data)
  */
 
 u16
-il_fill_probe_req(struct il_priv *priv, struct ieee80211_mgmt *frame,
+il_fill_probe_req(struct il_priv *il, struct ieee80211_mgmt *frame,
 		       const u8 *ta, const u8 *ies, int ie_len, int left)
 {
 	int len = 0;
@@ -475,75 +475,75 @@ EXPORT_SYMBOL(il_fill_probe_req);
 
 static void il_bg_abort_scan(struct work_struct *work)
 {
-	struct il_priv *priv = container_of(work, struct il_priv, abort_scan);
+	struct il_priv *il = container_of(work, struct il_priv, abort_scan);
 
-	IL_DEBUG_SCAN(priv, "Abort scan work\n");
+	IL_DEBUG_SCAN(il, "Abort scan work\n");
 
 	/* We keep scan_check work queued in case when firmware will not
 	 * report back scan completed notification */
-	mutex_lock(&priv->mutex);
-	il_scan_cancel_timeout(priv, 200);
-	mutex_unlock(&priv->mutex);
+	mutex_lock(&il->mutex);
+	il_scan_cancel_timeout(il, 200);
+	mutex_unlock(&il->mutex);
 }
 
 static void il_bg_scan_completed(struct work_struct *work)
 {
-	struct il_priv *priv =
+	struct il_priv *il =
 	    container_of(work, struct il_priv, scan_completed);
 	bool aborted;
 
-	IL_DEBUG_SCAN(priv, "Completed scan.\n");
+	IL_DEBUG_SCAN(il, "Completed scan.\n");
 
-	cancel_delayed_work(&priv->scan_check);
+	cancel_delayed_work(&il->scan_check);
 
-	mutex_lock(&priv->mutex);
+	mutex_lock(&il->mutex);
 
-	aborted = test_and_clear_bit(STATUS_SCAN_ABORTING, &priv->status);
+	aborted = test_and_clear_bit(STATUS_SCAN_ABORTING, &il->status);
 	if (aborted)
-		IL_DEBUG_SCAN(priv, "Aborted scan completed.\n");
+		IL_DEBUG_SCAN(il, "Aborted scan completed.\n");
 
-	if (!test_and_clear_bit(STATUS_SCANNING, &priv->status)) {
-		IL_DEBUG_SCAN(priv, "Scan already completed.\n");
+	if (!test_and_clear_bit(STATUS_SCANNING, &il->status)) {
+		IL_DEBUG_SCAN(il, "Scan already completed.\n");
 		goto out_settings;
 	}
 
-	il_complete_scan(priv, aborted);
+	il_complete_scan(il, aborted);
 
 out_settings:
 	/* Can we still talk to firmware ? */
-	if (!il_is_ready_rf(priv))
+	if (!il_is_ready_rf(il))
 		goto out;
 
 	/*
 	 * We do not commit power settings while scan is pending,
 	 * do it now if the settings changed.
 	 */
-	il_power_set_mode(priv, &priv->power_data.sleep_cmd_next, false);
-	il_set_tx_power(priv, priv->tx_power_next, false);
+	il_power_set_mode(il, &il->power_data.sleep_cmd_next, false);
+	il_set_tx_power(il, il->tx_power_next, false);
 
-	priv->cfg->ops->utils->post_scan(priv);
+	il->cfg->ops->utils->post_scan(il);
 
 out:
-	mutex_unlock(&priv->mutex);
+	mutex_unlock(&il->mutex);
 }
 
-void il_setup_scan_deferred_work(struct il_priv *priv)
+void il_setup_scan_deferred_work(struct il_priv *il)
 {
-	INIT_WORK(&priv->scan_completed, il_bg_scan_completed);
-	INIT_WORK(&priv->abort_scan, il_bg_abort_scan);
-	INIT_DELAYED_WORK(&priv->scan_check, il_bg_scan_check);
+	INIT_WORK(&il->scan_completed, il_bg_scan_completed);
+	INIT_WORK(&il->abort_scan, il_bg_abort_scan);
+	INIT_DELAYED_WORK(&il->scan_check, il_bg_scan_check);
 }
 EXPORT_SYMBOL(il_setup_scan_deferred_work);
 
-void il_cancel_scan_deferred_work(struct il_priv *priv)
+void il_cancel_scan_deferred_work(struct il_priv *il)
 {
-	cancel_work_sync(&priv->abort_scan);
-	cancel_work_sync(&priv->scan_completed);
+	cancel_work_sync(&il->abort_scan);
+	cancel_work_sync(&il->scan_completed);
 
-	if (cancel_delayed_work_sync(&priv->scan_check)) {
-		mutex_lock(&priv->mutex);
-		il_force_scan_end(priv);
-		mutex_unlock(&priv->mutex);
+	if (cancel_delayed_work_sync(&il->scan_check)) {
+		mutex_lock(&il->mutex);
+		il_force_scan_end(il);
+		mutex_unlock(&il->mutex);
 	}
 }
 EXPORT_SYMBOL(il_cancel_scan_deferred_work);