Since it is used by all the layers, it needs to move to iwl_shared.
Signed-off-by: Emmanuel Grumbach <emmanuel.grumbach@intel.com>
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
        if (frame_count == 1 && status == TX_STATUS_FAIL_RFKILL_FLUSH) {
                IWL_ERR(priv, "Tx flush command to flush out all frames\n");
                if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
-                       queue_work(priv->workqueue, &priv->tx_flush);
+                       queue_work(priv->shrd->workqueue, &priv->tx_flush);
        }
 }
 
                priv->kill_cts_mask = bt_kill_cts_msg[kill_msk];
 
                /* schedule to send runtime bt_config */
-               queue_work(priv->workqueue, &priv->bt_runtime_config);
+               queue_work(priv->shrd->workqueue, &priv->bt_runtime_config);
        }
 }
 
                                        IWL_BT_COEX_TRAFFIC_LOAD_NONE;
                        }
                        priv->bt_status = coex->bt_status;
-                       queue_work(priv->workqueue,
+                       queue_work(priv->shrd->workqueue,
                                   &priv->bt_traffic_change_work);
                }
        }
 
                rs_fill_link_cmd(priv, lq_sta, tbl->current_rate);
                iwl_send_lq_cmd(priv, ctx, &lq_sta->lq, CMD_ASYNC, false);
 
-               queue_work(priv->workqueue, &priv->bt_full_concurrency);
+               queue_work(priv->shrd->workqueue, &priv->bt_full_concurrency);
        }
 }
 
 
                return;
 
        IWL_DEBUG_TEMP(priv, "Queueing critical temperature enter.\n");
-       queue_work(priv->workqueue, &priv->ct_enter);
+       queue_work(priv->shrd->workqueue, &priv->ct_enter);
 }
 
 void iwl_tt_exit_ct_kill(struct iwl_priv *priv)
                return;
 
        IWL_DEBUG_TEMP(priv, "Queueing critical temperature exit.\n");
-       queue_work(priv->workqueue, &priv->ct_exit);
+       queue_work(priv->shrd->workqueue, &priv->ct_exit);
 }
 
 static void iwl_bg_tt_work(struct work_struct *work)
                return;
 
        IWL_DEBUG_TEMP(priv, "Queueing thermal throttling work.\n");
-       queue_work(priv->workqueue, &priv->tt_work);
+       queue_work(priv->shrd->workqueue, &priv->tt_work);
 }
 
 /* Thermal throttling initialization
 
 
        iwl_down(priv);
 
-       flush_workqueue(priv->workqueue);
+       flush_workqueue(priv->shrd->workqueue);
 
        /* User space software may expect getting rfkill changes
         * even if interface is down */
 
 static void iwl_setup_deferred_work(struct iwl_priv *priv)
 {
-       priv->workqueue = create_singlethread_workqueue(DRV_NAME);
+       priv->shrd->workqueue = create_singlethread_workqueue(DRV_NAME);
 
        init_waitqueue_head(&priv->wait_command_queue);
 
        return 0;
 
 out_destroy_workqueue:
-       destroy_workqueue(priv->workqueue);
-       priv->workqueue = NULL;
+       destroy_workqueue(priv->shrd->workqueue);
+       priv->shrd->workqueue = NULL;
        iwl_uninit_drv(priv);
 out_free_eeprom:
        iwl_eeprom_free(priv);
        iwl_eeprom_free(priv);
 
        /*netif_stop_queue(dev); */
-       flush_workqueue(priv->workqueue);
+       flush_workqueue(priv->shrd->workqueue);
 
        /* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
-        * priv->workqueue... so we can't take down the workqueue
+        * priv->shrd->workqueue... so we can't take down the workqueue
         * until now... */
-       destroy_workqueue(priv->workqueue);
-       priv->workqueue = NULL;
+       destroy_workqueue(priv->shrd->workqueue);
+       priv->shrd->workqueue = NULL;
        iwl_free_traffic_mem(priv);
 
        trans_free(&priv->trans);
 
                if (iwlagn_mod_params.restart_fw) {
                        IWL_DEBUG(priv, IWL_DL_FW_ERRORS,
                                  "Restarting adapter due to uCode error.\n");
-                       queue_work(priv->workqueue, &priv->restart);
+                       queue_work(priv->shrd->workqueue, &priv->restart);
                } else
                        IWL_DEBUG(priv, IWL_DL_FW_ERRORS,
                                  "Detected FW error, but not restarting\n");
 
 
        u32 inta_mask;
 
-       struct workqueue_struct *workqueue;
-
        struct work_struct restart;
        struct work_struct scan_completed;
        struct work_struct rx_replenish;
 
        priv->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
 
        if (!test_bit(STATUS_EXIT_PENDING, &priv->status))
-               queue_work(priv->workqueue, &priv->beacon_update);
+               queue_work(priv->shrd->workqueue, &priv->beacon_update);
 }
 
 /* the threshold ratio of actual_ack_cnt to expected_ack_cnt in percent */
        if (unlikely(!test_bit(STATUS_SCANNING, &priv->status)) &&
            (pkt->hdr.cmd == STATISTICS_NOTIFICATION)) {
                iwl_rx_calc_noise(priv);
-               queue_work(priv->workqueue, &priv->run_time_calib_work);
+               queue_work(priv->shrd->workqueue, &priv->run_time_calib_work);
        }
        if (priv->cfg->lib->temperature && change)
                priv->cfg->lib->temperature(priv);
 
 int iwl_scan_cancel(struct iwl_priv *priv)
 {
        IWL_DEBUG_SCAN(priv, "Queuing abort scan\n");
-       queue_work(priv->workqueue, &priv->abort_scan);
+       queue_work(priv->shrd->workqueue, &priv->abort_scan);
        return 0;
 }
 
                       (priv->scan_band == IEEE80211_BAND_2GHZ) ? "2.4" : "5.2",
                       jiffies_to_msecs(jiffies - priv->scan_start));
 
-       queue_work(priv->workqueue, &priv->scan_completed);
+       queue_work(priv->shrd->workqueue, &priv->scan_completed);
 
        if (priv->iw_mode != NL80211_IFTYPE_ADHOC &&
            iwl_advanced_bt_coexist(priv) &&
                                IWL_BT_COEX_TRAFFIC_LOAD_NONE;
                }
                priv->bt_status = scan_notif->bt_status;
-               queue_work(priv->workqueue, &priv->bt_traffic_change_work);
+               queue_work(priv->shrd->workqueue,
+                          &priv->bt_traffic_change_work);
        }
 }
 
                return ret;
        }
 
-       queue_delayed_work(priv->workqueue, &priv->scan_check,
+       queue_delayed_work(priv->shrd->workqueue, &priv->scan_check,
                           IWL_SCAN_CHECK_WATCHDOG);
 
        return 0;
  */
 void iwl_internal_short_hw_scan(struct iwl_priv *priv)
 {
-       queue_work(priv->workqueue, &priv->start_internal_scan);
+       queue_work(priv->shrd->workqueue, &priv->start_internal_scan);
 }
 
 static void iwl_bg_start_internal_scan(struct work_struct *work)
 
  * @bus: pointer to the bus layer data
  * @priv: pointer to the upper layer data
  * @hw_params: see struct iwl_hw_params
+ * @workqueue: the workqueue used by all the layers of the driver
  */
 struct iwl_shared {
 #ifdef CONFIG_IWLWIFI_DEBUG
        struct iwl_bus *bus;
        struct iwl_priv *priv;
        struct iwl_hw_params hw_params;
+
+       struct workqueue_struct *workqueue;
 };
 
 /*Whatever _m is (iwl_trans, iwl_priv, iwl_bus, these macros will work */
 
        /* If the pre-allocated buffer pool is dropping low, schedule to
         * refill it */
        if (rxq->free_count <= RX_LOW_WATERMARK)
-               queue_work(priv->workqueue, &priv->rx_replenish);
+               queue_work(priv->shrd->workqueue, &priv->rx_replenish);
 
 
        /* If we've added more space for the firmware to place data, tell it.