aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/iwlegacy
diff options
context:
space:
mode:
authorJohn W. Linville <linville@tuxdriver.com>2011-06-24 15:25:51 -0400
committerJohn W. Linville <linville@tuxdriver.com>2011-06-24 15:25:51 -0400
commit36099365c7cc64e5184b66b6eb094950a13f540c (patch)
treec91b9f3719f94864a62f2d15a71aaecd54c56711 /drivers/net/wireless/iwlegacy
parent22c8c9343258feda9ea9ebb9e5f8cbb727b69454 (diff)
parentf70490e6078abe1182437e629f67a7f0b6f08cd4 (diff)
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wireless-next-2.6 into for-davem
Conflicts: drivers/net/wireless/rtlwifi/pci.c include/linux/netlink.h
Diffstat (limited to 'drivers/net/wireless/iwlegacy')
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-3945.c4
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-4965-lib.c79
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-4965-rx.c78
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-4965.c4
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-commands.h7
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-core.c91
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-core.h15
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-debugfs.c192
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-dev.h60
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-devtrace.c3
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-devtrace.h60
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-helpers.h9
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-rx.c21
-rw-r--r--drivers/net/wireless/iwlegacy/iwl-scan.c92
-rw-r--r--drivers/net/wireless/iwlegacy/iwl3945-base.c301
-rw-r--r--drivers/net/wireless/iwlegacy/iwl4965-base.c463
16 files changed, 147 insertions, 1332 deletions
diff --git a/drivers/net/wireless/iwlegacy/iwl-3945.c b/drivers/net/wireless/iwlegacy/iwl-3945.c
index d096dc28204d..dab67a12d73b 100644
--- a/drivers/net/wireless/iwlegacy/iwl-3945.c
+++ b/drivers/net/wireless/iwlegacy/iwl-3945.c
@@ -408,7 +408,6 @@ void iwl3945_hw_rx_statistics(struct iwl_priv *priv,
408#ifdef CONFIG_IWLWIFI_LEGACY_DEBUGFS 408#ifdef CONFIG_IWLWIFI_LEGACY_DEBUGFS
409 iwl3945_accumulative_statistics(priv, (__le32 *)&pkt->u.raw); 409 iwl3945_accumulative_statistics(priv, (__le32 *)&pkt->u.raw);
410#endif 410#endif
411 iwl_legacy_recover_from_statistics(priv, pkt);
412 411
413 memcpy(&priv->_3945.statistics, pkt->u.raw, sizeof(priv->_3945.statistics)); 412 memcpy(&priv->_3945.statistics, pkt->u.raw, sizeof(priv->_3945.statistics));
414} 413}
@@ -2640,7 +2639,6 @@ static struct iwl_lib_ops iwl3945_lib = {
2640 .txq_free_tfd = iwl3945_hw_txq_free_tfd, 2639 .txq_free_tfd = iwl3945_hw_txq_free_tfd,
2641 .txq_init = iwl3945_hw_tx_queue_init, 2640 .txq_init = iwl3945_hw_tx_queue_init,
2642 .load_ucode = iwl3945_load_bsm, 2641 .load_ucode = iwl3945_load_bsm,
2643 .dump_nic_event_log = iwl3945_dump_nic_event_log,
2644 .dump_nic_error_log = iwl3945_dump_nic_error_log, 2642 .dump_nic_error_log = iwl3945_dump_nic_error_log,
2645 .apm_ops = { 2643 .apm_ops = {
2646 .init = iwl3945_apm_init, 2644 .init = iwl3945_apm_init,
@@ -2698,9 +2696,7 @@ static struct iwl_base_params iwl3945_base_params = {
2698 .set_l0s = false, 2696 .set_l0s = false,
2699 .use_bsm = true, 2697 .use_bsm = true,
2700 .led_compensation = 64, 2698 .led_compensation = 64,
2701 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF,
2702 .wd_timeout = IWL_DEF_WD_TIMEOUT, 2699 .wd_timeout = IWL_DEF_WD_TIMEOUT,
2703 .max_event_log_size = 512,
2704}; 2700};
2705 2701
2706static struct iwl_cfg iwl3945_bg_cfg = { 2702static struct iwl_cfg iwl3945_bg_cfg = {
diff --git a/drivers/net/wireless/iwlegacy/iwl-4965-lib.c b/drivers/net/wireless/iwlegacy/iwl-4965-lib.c
index a7a4739880dc..2be6d9e3b019 100644
--- a/drivers/net/wireless/iwlegacy/iwl-4965-lib.c
+++ b/drivers/net/wireless/iwlegacy/iwl-4965-lib.c
@@ -694,47 +694,6 @@ void iwl4965_rx_reply_rx_phy(struct iwl_priv *priv,
694 sizeof(struct iwl_rx_phy_res)); 694 sizeof(struct iwl_rx_phy_res));
695} 695}
696 696
697static int iwl4965_get_single_channel_for_scan(struct iwl_priv *priv,
698 struct ieee80211_vif *vif,
699 enum ieee80211_band band,
700 struct iwl_scan_channel *scan_ch)
701{
702 const struct ieee80211_supported_band *sband;
703 u16 passive_dwell = 0;
704 u16 active_dwell = 0;
705 int added = 0;
706 u16 channel = 0;
707
708 sband = iwl_get_hw_mode(priv, band);
709 if (!sband) {
710 IWL_ERR(priv, "invalid band\n");
711 return added;
712 }
713
714 active_dwell = iwl_legacy_get_active_dwell_time(priv, band, 0);
715 passive_dwell = iwl_legacy_get_passive_dwell_time(priv, band, vif);
716
717 if (passive_dwell <= active_dwell)
718 passive_dwell = active_dwell + 1;
719
720 channel = iwl_legacy_get_single_channel_number(priv, band);
721 if (channel) {
722 scan_ch->channel = cpu_to_le16(channel);
723 scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
724 scan_ch->active_dwell = cpu_to_le16(active_dwell);
725 scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
726 /* Set txpower levels to defaults */
727 scan_ch->dsp_atten = 110;
728 if (band == IEEE80211_BAND_5GHZ)
729 scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
730 else
731 scan_ch->tx_gain = ((1 << 5) | (5 << 3));
732 added++;
733 } else
734 IWL_ERR(priv, "no valid channel found\n");
735 return added;
736}
737
738static int iwl4965_get_channels_for_scan(struct iwl_priv *priv, 697static int iwl4965_get_channels_for_scan(struct iwl_priv *priv,
739 struct ieee80211_vif *vif, 698 struct ieee80211_vif *vif,
740 enum ieee80211_band band, 699 enum ieee80211_band band,
@@ -858,16 +817,13 @@ int iwl4965_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
858 scan->quiet_time = IWL_ACTIVE_QUIET_TIME; 817 scan->quiet_time = IWL_ACTIVE_QUIET_TIME;
859 818
860 if (iwl_legacy_is_any_associated(priv)) { 819 if (iwl_legacy_is_any_associated(priv)) {
861 u16 interval = 0; 820 u16 interval;
862 u32 extra; 821 u32 extra;
863 u32 suspend_time = 100; 822 u32 suspend_time = 100;
864 u32 scan_suspend_time = 100; 823 u32 scan_suspend_time = 100;
865 824
866 IWL_DEBUG_INFO(priv, "Scanning while associated...\n"); 825 IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
867 if (priv->is_internal_short_scan) 826 interval = vif->bss_conf.beacon_int;
868 interval = 0;
869 else
870 interval = vif->bss_conf.beacon_int;
871 827
872 scan->suspend_time = 0; 828 scan->suspend_time = 0;
873 scan->max_out_time = cpu_to_le32(200 * 1024); 829 scan->max_out_time = cpu_to_le32(200 * 1024);
@@ -882,9 +838,7 @@ int iwl4965_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
882 scan_suspend_time, interval); 838 scan_suspend_time, interval);
883 } 839 }
884 840
885 if (priv->is_internal_short_scan) { 841 if (priv->scan_request->n_ssids) {
886 IWL_DEBUG_SCAN(priv, "Start internal passive scan.\n");
887 } else if (priv->scan_request->n_ssids) {
888 int i, p = 0; 842 int i, p = 0;
889 IWL_DEBUG_SCAN(priv, "Kicking off active scan\n"); 843 IWL_DEBUG_SCAN(priv, "Kicking off active scan\n");
890 for (i = 0; i < priv->scan_request->n_ssids; i++) { 844 for (i = 0; i < priv->scan_request->n_ssids; i++) {
@@ -981,38 +935,21 @@ int iwl4965_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
981 rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS; 935 rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS;
982 rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS; 936 rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS;
983 scan->rx_chain = cpu_to_le16(rx_chain); 937 scan->rx_chain = cpu_to_le16(rx_chain);
984 if (!priv->is_internal_short_scan) { 938
985 cmd_len = iwl_legacy_fill_probe_req(priv, 939 cmd_len = iwl_legacy_fill_probe_req(priv,
986 (struct ieee80211_mgmt *)scan->data, 940 (struct ieee80211_mgmt *)scan->data,
987 vif->addr, 941 vif->addr,
988 priv->scan_request->ie, 942 priv->scan_request->ie,
989 priv->scan_request->ie_len, 943 priv->scan_request->ie_len,
990 IWL_MAX_SCAN_SIZE - sizeof(*scan)); 944 IWL_MAX_SCAN_SIZE - sizeof(*scan));
991 } else {
992 /* use bcast addr, will not be transmitted but must be valid */
993 cmd_len = iwl_legacy_fill_probe_req(priv,
994 (struct ieee80211_mgmt *)scan->data,
995 iwlegacy_bcast_addr, NULL, 0,
996 IWL_MAX_SCAN_SIZE - sizeof(*scan));
997
998 }
999 scan->tx_cmd.len = cpu_to_le16(cmd_len); 945 scan->tx_cmd.len = cpu_to_le16(cmd_len);
1000 946
1001 scan->filter_flags |= (RXON_FILTER_ACCEPT_GRP_MSK | 947 scan->filter_flags |= (RXON_FILTER_ACCEPT_GRP_MSK |
1002 RXON_FILTER_BCON_AWARE_MSK); 948 RXON_FILTER_BCON_AWARE_MSK);
1003 949
1004 if (priv->is_internal_short_scan) { 950 scan->channel_count = iwl4965_get_channels_for_scan(priv, vif, band,
1005 scan->channel_count = 951 is_active, n_probes,
1006 iwl4965_get_single_channel_for_scan(priv, vif, band, 952 (void *)&scan->data[cmd_len]);
1007 (void *)&scan->data[le16_to_cpu(
1008 scan->tx_cmd.len)]);
1009 } else {
1010 scan->channel_count =
1011 iwl4965_get_channels_for_scan(priv, vif, band,
1012 is_active, n_probes,
1013 (void *)&scan->data[le16_to_cpu(
1014 scan->tx_cmd.len)]);
1015 }
1016 if (scan->channel_count == 0) { 953 if (scan->channel_count == 0) {
1017 IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count); 954 IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
1018 return -EIO; 955 return -EIO;
diff --git a/drivers/net/wireless/iwlegacy/iwl-4965-rx.c b/drivers/net/wireless/iwlegacy/iwl-4965-rx.c
index b9fa2f6411a7..2b144bbfc3c5 100644
--- a/drivers/net/wireless/iwlegacy/iwl-4965-rx.c
+++ b/drivers/net/wireless/iwlegacy/iwl-4965-rx.c
@@ -151,81 +151,6 @@ static void iwl4965_accumulative_statistics(struct iwl_priv *priv,
151 151
152#define REG_RECALIB_PERIOD (60) 152#define REG_RECALIB_PERIOD (60)
153 153
154/**
155 * iwl4965_good_plcp_health - checks for plcp error.
156 *
157 * When the plcp error is exceeding the thresholds, reset the radio
158 * to improve the throughput.
159 */
160bool iwl4965_good_plcp_health(struct iwl_priv *priv,
161 struct iwl_rx_packet *pkt)
162{
163 bool rc = true;
164 int combined_plcp_delta;
165 unsigned int plcp_msec;
166 unsigned long plcp_received_jiffies;
167
168 if (priv->cfg->base_params->plcp_delta_threshold ==
169 IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE) {
170 IWL_DEBUG_RADIO(priv, "plcp_err check disabled\n");
171 return rc;
172 }
173
174 /*
175 * check for plcp_err and trigger radio reset if it exceeds
176 * the plcp error threshold plcp_delta.
177 */
178 plcp_received_jiffies = jiffies;
179 plcp_msec = jiffies_to_msecs((long) plcp_received_jiffies -
180 (long) priv->plcp_jiffies);
181 priv->plcp_jiffies = plcp_received_jiffies;
182 /*
183 * check to make sure plcp_msec is not 0 to prevent division
184 * by zero.
185 */
186 if (plcp_msec) {
187 struct statistics_rx_phy *ofdm;
188 struct statistics_rx_ht_phy *ofdm_ht;
189
190 ofdm = &pkt->u.stats.rx.ofdm;
191 ofdm_ht = &pkt->u.stats.rx.ofdm_ht;
192 combined_plcp_delta =
193 (le32_to_cpu(ofdm->plcp_err) -
194 le32_to_cpu(priv->_4965.statistics.
195 rx.ofdm.plcp_err)) +
196 (le32_to_cpu(ofdm_ht->plcp_err) -
197 le32_to_cpu(priv->_4965.statistics.
198 rx.ofdm_ht.plcp_err));
199
200 if ((combined_plcp_delta > 0) &&
201 ((combined_plcp_delta * 100) / plcp_msec) >
202 priv->cfg->base_params->plcp_delta_threshold) {
203 /*
204 * if plcp_err exceed the threshold,
205 * the following data is printed in csv format:
206 * Text: plcp_err exceeded %d,
207 * Received ofdm.plcp_err,
208 * Current ofdm.plcp_err,
209 * Received ofdm_ht.plcp_err,
210 * Current ofdm_ht.plcp_err,
211 * combined_plcp_delta,
212 * plcp_msec
213 */
214 IWL_DEBUG_RADIO(priv, "plcp_err exceeded %u, "
215 "%u, %u, %u, %u, %d, %u mSecs\n",
216 priv->cfg->base_params->plcp_delta_threshold,
217 le32_to_cpu(ofdm->plcp_err),
218 le32_to_cpu(ofdm->plcp_err),
219 le32_to_cpu(ofdm_ht->plcp_err),
220 le32_to_cpu(ofdm_ht->plcp_err),
221 combined_plcp_delta, plcp_msec);
222
223 rc = false;
224 }
225 }
226 return rc;
227}
228
229void iwl4965_rx_statistics(struct iwl_priv *priv, 154void iwl4965_rx_statistics(struct iwl_priv *priv,
230 struct iwl_rx_mem_buffer *rxb) 155 struct iwl_rx_mem_buffer *rxb)
231{ 156{
@@ -248,8 +173,7 @@ void iwl4965_rx_statistics(struct iwl_priv *priv,
248 iwl4965_accumulative_statistics(priv, (__le32 *)&pkt->u.stats); 173 iwl4965_accumulative_statistics(priv, (__le32 *)&pkt->u.stats);
249#endif 174#endif
250 175
251 iwl_legacy_recover_from_statistics(priv, pkt); 176 /* TODO: reading some of statistics is unneeded */
252
253 memcpy(&priv->_4965.statistics, &pkt->u.stats, 177 memcpy(&priv->_4965.statistics, &pkt->u.stats,
254 sizeof(priv->_4965.statistics)); 178 sizeof(priv->_4965.statistics));
255 179
diff --git a/drivers/net/wireless/iwlegacy/iwl-4965.c b/drivers/net/wireless/iwlegacy/iwl-4965.c
index 9cf96cb51712..bd4b000733f7 100644
--- a/drivers/net/wireless/iwlegacy/iwl-4965.c
+++ b/drivers/net/wireless/iwlegacy/iwl-4965.c
@@ -2069,7 +2069,6 @@ static struct iwl_lib_ops iwl4965_lib = {
2069 .is_valid_rtc_data_addr = iwl4965_hw_valid_rtc_data_addr, 2069 .is_valid_rtc_data_addr = iwl4965_hw_valid_rtc_data_addr,
2070 .init_alive_start = iwl4965_init_alive_start, 2070 .init_alive_start = iwl4965_init_alive_start,
2071 .load_ucode = iwl4965_load_bsm, 2071 .load_ucode = iwl4965_load_bsm,
2072 .dump_nic_event_log = iwl4965_dump_nic_event_log,
2073 .dump_nic_error_log = iwl4965_dump_nic_error_log, 2072 .dump_nic_error_log = iwl4965_dump_nic_error_log,
2074 .dump_fh = iwl4965_dump_fh, 2073 .dump_fh = iwl4965_dump_fh,
2075 .set_channel_switch = iwl4965_hw_channel_switch, 2074 .set_channel_switch = iwl4965_hw_channel_switch,
@@ -2100,7 +2099,6 @@ static struct iwl_lib_ops iwl4965_lib = {
2100 .tx_stats_read = iwl4965_ucode_tx_stats_read, 2099 .tx_stats_read = iwl4965_ucode_tx_stats_read,
2101 .general_stats_read = iwl4965_ucode_general_stats_read, 2100 .general_stats_read = iwl4965_ucode_general_stats_read,
2102 }, 2101 },
2103 .check_plcp_health = iwl4965_good_plcp_health,
2104}; 2102};
2105 2103
2106static const struct iwl_legacy_ops iwl4965_legacy_ops = { 2104static const struct iwl_legacy_ops iwl4965_legacy_ops = {
@@ -2150,10 +2148,8 @@ static struct iwl_base_params iwl4965_base_params = {
2150 .use_bsm = true, 2148 .use_bsm = true,
2151 .led_compensation = 61, 2149 .led_compensation = 61,
2152 .chain_noise_num_beacons = IWL4965_CAL_NUM_BEACONS, 2150 .chain_noise_num_beacons = IWL4965_CAL_NUM_BEACONS,
2153 .plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
2154 .wd_timeout = IWL_DEF_WD_TIMEOUT, 2151 .wd_timeout = IWL_DEF_WD_TIMEOUT,
2155 .temperature_kelvin = true, 2152 .temperature_kelvin = true,
2156 .max_event_log_size = 512,
2157 .ucode_tracing = true, 2153 .ucode_tracing = true,
2158 .sensitivity_calib_by_driver = true, 2154 .sensitivity_calib_by_driver = true,
2159 .chain_noise_calib_by_driver = true, 2155 .chain_noise_calib_by_driver = true,
diff --git a/drivers/net/wireless/iwlegacy/iwl-commands.h b/drivers/net/wireless/iwlegacy/iwl-commands.h
index 17a1d504348e..ee21210bea9c 100644
--- a/drivers/net/wireless/iwlegacy/iwl-commands.h
+++ b/drivers/net/wireless/iwlegacy/iwl-commands.h
@@ -2297,14 +2297,7 @@ struct iwl_spectrum_notification {
2297#define IWL_POWER_VEC_SIZE 5 2297#define IWL_POWER_VEC_SIZE 5
2298 2298
2299#define IWL_POWER_DRIVER_ALLOW_SLEEP_MSK cpu_to_le16(BIT(0)) 2299#define IWL_POWER_DRIVER_ALLOW_SLEEP_MSK cpu_to_le16(BIT(0))
2300#define IWL_POWER_POWER_SAVE_ENA_MSK cpu_to_le16(BIT(0))
2301#define IWL_POWER_POWER_MANAGEMENT_ENA_MSK cpu_to_le16(BIT(1))
2302#define IWL_POWER_SLEEP_OVER_DTIM_MSK cpu_to_le16(BIT(2))
2303#define IWL_POWER_PCI_PM_MSK cpu_to_le16(BIT(3)) 2300#define IWL_POWER_PCI_PM_MSK cpu_to_le16(BIT(3))
2304#define IWL_POWER_FAST_PD cpu_to_le16(BIT(4))
2305#define IWL_POWER_BEACON_FILTERING cpu_to_le16(BIT(5))
2306#define IWL_POWER_SHADOW_REG_ENA cpu_to_le16(BIT(6))
2307#define IWL_POWER_CT_KILL_SET cpu_to_le16(BIT(7))
2308 2301
2309struct iwl3945_powertable_cmd { 2302struct iwl3945_powertable_cmd {
2310 __le16 flags; 2303 __le16 flags;
diff --git a/drivers/net/wireless/iwlegacy/iwl-core.c b/drivers/net/wireless/iwlegacy/iwl-core.c
index 3be76bd5499a..35cd2537e7fd 100644
--- a/drivers/net/wireless/iwlegacy/iwl-core.c
+++ b/drivers/net/wireless/iwlegacy/iwl-core.c
@@ -931,7 +931,6 @@ void iwl_legacy_irq_handle_error(struct iwl_priv *priv)
931 priv->cfg->ops->lib->dump_nic_error_log(priv); 931 priv->cfg->ops->lib->dump_nic_error_log(priv);
932 if (priv->cfg->ops->lib->dump_fh) 932 if (priv->cfg->ops->lib->dump_fh)
933 priv->cfg->ops->lib->dump_fh(priv, NULL, false); 933 priv->cfg->ops->lib->dump_fh(priv, NULL, false);
934 priv->cfg->ops->lib->dump_nic_event_log(priv, false, NULL, false);
935#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG 934#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
936 if (iwl_legacy_get_debug_level(priv) & IWL_DL_FW_ERRORS) 935 if (iwl_legacy_get_debug_level(priv) & IWL_DL_FW_ERRORS)
937 iwl_legacy_print_rx_config_cmd(priv, 936 iwl_legacy_print_rx_config_cmd(priv,
@@ -1707,41 +1706,14 @@ iwl_legacy_update_stats(struct iwl_priv *priv, bool is_tx, __le16 fc, u16 len)
1707EXPORT_SYMBOL(iwl_legacy_update_stats); 1706EXPORT_SYMBOL(iwl_legacy_update_stats);
1708#endif 1707#endif
1709 1708
1710static void _iwl_legacy_force_rf_reset(struct iwl_priv *priv) 1709int iwl_legacy_force_reset(struct iwl_priv *priv, bool external)
1711{
1712 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
1713 return;
1714
1715 if (!iwl_legacy_is_any_associated(priv)) {
1716 IWL_DEBUG_SCAN(priv, "force reset rejected: not associated\n");
1717 return;
1718 }
1719 /*
1720 * There is no easy and better way to force reset the radio,
1721 * the only known method is switching channel which will force to
1722 * reset and tune the radio.
1723 * Use internal short scan (single channel) operation to should
1724 * achieve this objective.
1725 * Driver should reset the radio when number of consecutive missed
1726 * beacon, or any other uCode error condition detected.
1727 */
1728 IWL_DEBUG_INFO(priv, "perform radio reset.\n");
1729 iwl_legacy_internal_short_hw_scan(priv);
1730}
1731
1732
1733int iwl_legacy_force_reset(struct iwl_priv *priv, int mode, bool external)
1734{ 1710{
1735 struct iwl_force_reset *force_reset; 1711 struct iwl_force_reset *force_reset;
1736 1712
1737 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) 1713 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
1738 return -EINVAL; 1714 return -EINVAL;
1739 1715
1740 if (mode >= IWL_MAX_FORCE_RESET) { 1716 force_reset = &priv->force_reset;
1741 IWL_DEBUG_INFO(priv, "invalid reset request.\n");
1742 return -EINVAL;
1743 }
1744 force_reset = &priv->force_reset[mode];
1745 force_reset->reset_request_count++; 1717 force_reset->reset_request_count++;
1746 if (!external) { 1718 if (!external) {
1747 if (force_reset->last_force_reset_jiffies && 1719 if (force_reset->last_force_reset_jiffies &&
@@ -1754,37 +1726,34 @@ int iwl_legacy_force_reset(struct iwl_priv *priv, int mode, bool external)
1754 } 1726 }
1755 force_reset->reset_success_count++; 1727 force_reset->reset_success_count++;
1756 force_reset->last_force_reset_jiffies = jiffies; 1728 force_reset->last_force_reset_jiffies = jiffies;
1757 IWL_DEBUG_INFO(priv, "perform force reset (%d)\n", mode); 1729
1758 switch (mode) { 1730 /*
1759 case IWL_RF_RESET: 1731 * if the request is from external(ex: debugfs),
1760 _iwl_legacy_force_rf_reset(priv); 1732 * then always perform the request in regardless the module
1761 break; 1733 * parameter setting
1762 case IWL_FW_RESET: 1734 * if the request is from internal (uCode error or driver
1763 /* 1735 * detect failure), then fw_restart module parameter
1764 * if the request is from external(ex: debugfs), 1736 * need to be check before performing firmware reload
1765 * then always perform the request in regardless the module 1737 */
1766 * parameter setting 1738
1767 * if the request is from internal (uCode error or driver 1739 if (!external && !priv->cfg->mod_params->restart_fw) {
1768 * detect failure), then fw_restart module parameter 1740 IWL_DEBUG_INFO(priv, "Cancel firmware reload based on "
1769 * need to be check before performing firmware reload 1741 "module parameter setting\n");
1770 */ 1742 return 0;
1771 if (!external && !priv->cfg->mod_params->restart_fw) {
1772 IWL_DEBUG_INFO(priv, "Cancel firmware reload based on "
1773 "module parameter setting\n");
1774 break;
1775 }
1776 IWL_ERR(priv, "On demand firmware reload\n");
1777 /* Set the FW error flag -- cleared on iwl_down */
1778 set_bit(STATUS_FW_ERROR, &priv->status);
1779 wake_up_interruptible(&priv->wait_command_queue);
1780 /*
1781 * Keep the restart process from trying to send host
1782 * commands by clearing the INIT status bit
1783 */
1784 clear_bit(STATUS_READY, &priv->status);
1785 queue_work(priv->workqueue, &priv->restart);
1786 break;
1787 } 1743 }
1744
1745 IWL_ERR(priv, "On demand firmware reload\n");
1746
1747 /* Set the FW error flag -- cleared on iwl_down */
1748 set_bit(STATUS_FW_ERROR, &priv->status);
1749 wake_up_interruptible(&priv->wait_command_queue);
1750 /*
1751 * Keep the restart process from trying to send host
1752 * commands by clearing the INIT status bit
1753 */
1754 clear_bit(STATUS_READY, &priv->status);
1755 queue_work(priv->workqueue, &priv->restart);
1756
1788 return 0; 1757 return 0;
1789} 1758}
1790 1759
@@ -1879,7 +1848,7 @@ static int iwl_legacy_check_stuck_queue(struct iwl_priv *priv, int cnt)
1879 if (time_after(jiffies, timeout)) { 1848 if (time_after(jiffies, timeout)) {
1880 IWL_ERR(priv, "Queue %d stuck for %u ms.\n", 1849 IWL_ERR(priv, "Queue %d stuck for %u ms.\n",
1881 q->id, priv->cfg->base_params->wd_timeout); 1850 q->id, priv->cfg->base_params->wd_timeout);
1882 ret = iwl_legacy_force_reset(priv, IWL_FW_RESET, false); 1851 ret = iwl_legacy_force_reset(priv, false);
1883 return (ret == -EAGAIN) ? 0 : 1; 1852 return (ret == -EAGAIN) ? 0 : 1;
1884 } 1853 }
1885 1854
diff --git a/drivers/net/wireless/iwlegacy/iwl-core.h b/drivers/net/wireless/iwlegacy/iwl-core.h
index c5fbda0760de..a2de7e991706 100644
--- a/drivers/net/wireless/iwlegacy/iwl-core.h
+++ b/drivers/net/wireless/iwlegacy/iwl-core.h
@@ -143,8 +143,7 @@ struct iwl_lib_ops {
143 int (*is_valid_rtc_data_addr)(u32 addr); 143 int (*is_valid_rtc_data_addr)(u32 addr);
144 /* 1st ucode load */ 144 /* 1st ucode load */
145 int (*load_ucode)(struct iwl_priv *priv); 145 int (*load_ucode)(struct iwl_priv *priv);
146 int (*dump_nic_event_log)(struct iwl_priv *priv, 146
147 bool full_log, char **buf, bool display);
148 void (*dump_nic_error_log)(struct iwl_priv *priv); 147 void (*dump_nic_error_log)(struct iwl_priv *priv);
149 int (*dump_fh)(struct iwl_priv *priv, char **buf, bool display); 148 int (*dump_fh)(struct iwl_priv *priv, char **buf, bool display);
150 int (*set_channel_switch)(struct iwl_priv *priv, 149 int (*set_channel_switch)(struct iwl_priv *priv,
@@ -161,9 +160,6 @@ struct iwl_lib_ops {
161 160
162 /* temperature */ 161 /* temperature */
163 struct iwl_temp_ops temp_ops; 162 struct iwl_temp_ops temp_ops;
164 /* check for plcp health */
165 bool (*check_plcp_health)(struct iwl_priv *priv,
166 struct iwl_rx_packet *pkt);
167 163
168 struct iwl_debugfs_ops debugfs_ops; 164 struct iwl_debugfs_ops debugfs_ops;
169 165
@@ -207,11 +203,8 @@ struct iwl_mod_params {
207 * to the deviation to achieve the desired led frequency. 203 * to the deviation to achieve the desired led frequency.
208 * The detail algorithm is described in iwl-led.c 204 * The detail algorithm is described in iwl-led.c
209 * @chain_noise_num_beacons: number of beacons used to compute chain noise 205 * @chain_noise_num_beacons: number of beacons used to compute chain noise
210 * @plcp_delta_threshold: plcp error rate threshold used to trigger
211 * radio tuning when there is a high receiving plcp error rate
212 * @wd_timeout: TX queues watchdog timeout 206 * @wd_timeout: TX queues watchdog timeout
213 * @temperature_kelvin: temperature report by uCode in kelvin 207 * @temperature_kelvin: temperature report by uCode in kelvin
214 * @max_event_log_size: size of event log buffer size for ucode event logging
215 * @ucode_tracing: support ucode continuous tracing 208 * @ucode_tracing: support ucode continuous tracing
216 * @sensitivity_calib_by_driver: driver has the capability to perform 209 * @sensitivity_calib_by_driver: driver has the capability to perform
217 * sensitivity calibration operation 210 * sensitivity calibration operation
@@ -229,10 +222,8 @@ struct iwl_base_params {
229 222
230 u16 led_compensation; 223 u16 led_compensation;
231 int chain_noise_num_beacons; 224 int chain_noise_num_beacons;
232 u8 plcp_delta_threshold;
233 unsigned int wd_timeout; 225 unsigned int wd_timeout;
234 bool temperature_kelvin; 226 bool temperature_kelvin;
235 u32 max_event_log_size;
236 const bool ucode_tracing; 227 const bool ucode_tracing;
237 const bool sensitivity_calib_by_driver; 228 const bool sensitivity_calib_by_driver;
238 const bool chain_noise_calib_by_driver; 229 const bool chain_noise_calib_by_driver;
@@ -441,7 +432,7 @@ int iwl_legacy_mac_hw_scan(struct ieee80211_hw *hw,
441 struct ieee80211_vif *vif, 432 struct ieee80211_vif *vif,
442 struct cfg80211_scan_request *req); 433 struct cfg80211_scan_request *req);
443void iwl_legacy_internal_short_hw_scan(struct iwl_priv *priv); 434void iwl_legacy_internal_short_hw_scan(struct iwl_priv *priv);
444int iwl_legacy_force_reset(struct iwl_priv *priv, int mode, bool external); 435int iwl_legacy_force_reset(struct iwl_priv *priv, bool external);
445u16 iwl_legacy_fill_probe_req(struct iwl_priv *priv, 436u16 iwl_legacy_fill_probe_req(struct iwl_priv *priv,
446 struct ieee80211_mgmt *frame, 437 struct ieee80211_mgmt *frame,
447 const u8 *ta, const u8 *ie, int ie_len, int left); 438 const u8 *ta, const u8 *ie, int ie_len, int left);
@@ -521,8 +512,6 @@ extern const struct dev_pm_ops iwl_legacy_pm_ops;
521* Error Handling Debugging 512* Error Handling Debugging
522******************************************************/ 513******************************************************/
523void iwl4965_dump_nic_error_log(struct iwl_priv *priv); 514void iwl4965_dump_nic_error_log(struct iwl_priv *priv);
524int iwl4965_dump_nic_event_log(struct iwl_priv *priv,
525 bool full_log, char **buf, bool display);
526#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG 515#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
527void iwl_legacy_print_rx_config_cmd(struct iwl_priv *priv, 516void iwl_legacy_print_rx_config_cmd(struct iwl_priv *priv,
528 struct iwl_rxon_context *ctx); 517 struct iwl_rxon_context *ctx);
diff --git a/drivers/net/wireless/iwlegacy/iwl-debugfs.c b/drivers/net/wireless/iwlegacy/iwl-debugfs.c
index 2d32438b4cb8..996996a71657 100644
--- a/drivers/net/wireless/iwlegacy/iwl-debugfs.c
+++ b/drivers/net/wireless/iwlegacy/iwl-debugfs.c
@@ -391,48 +391,6 @@ static ssize_t iwl_legacy_dbgfs_nvm_read(struct file *file,
391 return ret; 391 return ret;
392} 392}
393 393
394static ssize_t iwl_legacy_dbgfs_log_event_read(struct file *file,
395 char __user *user_buf,
396 size_t count, loff_t *ppos)
397{
398 struct iwl_priv *priv = file->private_data;
399 char *buf;
400 int pos = 0;
401 ssize_t ret = -ENOMEM;
402
403 ret = pos = priv->cfg->ops->lib->dump_nic_event_log(
404 priv, true, &buf, true);
405 if (buf) {
406 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos);
407 kfree(buf);
408 }
409 return ret;
410}
411
412static ssize_t iwl_legacy_dbgfs_log_event_write(struct file *file,
413 const char __user *user_buf,
414 size_t count, loff_t *ppos)
415{
416 struct iwl_priv *priv = file->private_data;
417 u32 event_log_flag;
418 char buf[8];
419 int buf_size;
420
421 memset(buf, 0, sizeof(buf));
422 buf_size = min(count, sizeof(buf) - 1);
423 if (copy_from_user(buf, user_buf, buf_size))
424 return -EFAULT;
425 if (sscanf(buf, "%d", &event_log_flag) != 1)
426 return -EFAULT;
427 if (event_log_flag == 1)
428 priv->cfg->ops->lib->dump_nic_event_log(priv, true,
429 NULL, false);
430
431 return count;
432}
433
434
435
436static ssize_t 394static ssize_t
437iwl_legacy_dbgfs_channels_read(struct file *file, char __user *user_buf, 395iwl_legacy_dbgfs_channels_read(struct file *file, char __user *user_buf,
438 size_t count, loff_t *ppos) 396 size_t count, loff_t *ppos)
@@ -706,7 +664,6 @@ static ssize_t iwl_legacy_dbgfs_disable_ht40_read(struct file *file,
706} 664}
707 665
708DEBUGFS_READ_WRITE_FILE_OPS(sram); 666DEBUGFS_READ_WRITE_FILE_OPS(sram);
709DEBUGFS_READ_WRITE_FILE_OPS(log_event);
710DEBUGFS_READ_FILE_OPS(nvm); 667DEBUGFS_READ_FILE_OPS(nvm);
711DEBUGFS_READ_FILE_OPS(stations); 668DEBUGFS_READ_FILE_OPS(stations);
712DEBUGFS_READ_FILE_OPS(channels); 669DEBUGFS_READ_FILE_OPS(channels);
@@ -1098,56 +1055,6 @@ static ssize_t iwl_legacy_dbgfs_clear_ucode_statistics_write(struct file *file,
1098 return count; 1055 return count;
1099} 1056}
1100 1057
1101static ssize_t iwl_legacy_dbgfs_ucode_tracing_read(struct file *file,
1102 char __user *user_buf,
1103 size_t count, loff_t *ppos) {
1104
1105 struct iwl_priv *priv = file->private_data;
1106 int pos = 0;
1107 char buf[128];
1108 const size_t bufsz = sizeof(buf);
1109
1110 pos += scnprintf(buf + pos, bufsz - pos, "ucode trace timer is %s\n",
1111 priv->event_log.ucode_trace ? "On" : "Off");
1112 pos += scnprintf(buf + pos, bufsz - pos, "non_wraps_count:\t\t %u\n",
1113 priv->event_log.non_wraps_count);
1114 pos += scnprintf(buf + pos, bufsz - pos, "wraps_once_count:\t\t %u\n",
1115 priv->event_log.wraps_once_count);
1116 pos += scnprintf(buf + pos, bufsz - pos, "wraps_more_count:\t\t %u\n",
1117 priv->event_log.wraps_more_count);
1118
1119 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1120}
1121
1122static ssize_t iwl_legacy_dbgfs_ucode_tracing_write(struct file *file,
1123 const char __user *user_buf,
1124 size_t count, loff_t *ppos)
1125{
1126 struct iwl_priv *priv = file->private_data;
1127 char buf[8];
1128 int buf_size;
1129 int trace;
1130
1131 memset(buf, 0, sizeof(buf));
1132 buf_size = min(count, sizeof(buf) - 1);
1133 if (copy_from_user(buf, user_buf, buf_size))
1134 return -EFAULT;
1135 if (sscanf(buf, "%d", &trace) != 1)
1136 return -EFAULT;
1137
1138 if (trace) {
1139 priv->event_log.ucode_trace = true;
1140 /* schedule the ucode timer to occur in UCODE_TRACE_PERIOD */
1141 mod_timer(&priv->ucode_trace,
1142 jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
1143 } else {
1144 priv->event_log.ucode_trace = false;
1145 del_timer_sync(&priv->ucode_trace);
1146 }
1147
1148 return count;
1149}
1150
1151static ssize_t iwl_legacy_dbgfs_rxon_flags_read(struct file *file, 1058static ssize_t iwl_legacy_dbgfs_rxon_flags_read(struct file *file,
1152 char __user *user_buf, 1059 char __user *user_buf,
1153 size_t count, loff_t *ppos) { 1060 size_t count, loff_t *ppos) {
@@ -1236,72 +1143,31 @@ static ssize_t iwl_legacy_dbgfs_missed_beacon_write(struct file *file,
1236 return count; 1143 return count;
1237} 1144}
1238 1145
1239static ssize_t iwl_legacy_dbgfs_plcp_delta_read(struct file *file,
1240 char __user *user_buf,
1241 size_t count, loff_t *ppos) {
1242
1243 struct iwl_priv *priv = file->private_data;
1244 int pos = 0;
1245 char buf[12];
1246 const size_t bufsz = sizeof(buf);
1247
1248 pos += scnprintf(buf + pos, bufsz - pos, "%u\n",
1249 priv->cfg->base_params->plcp_delta_threshold);
1250
1251 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1252}
1253
1254static ssize_t iwl_legacy_dbgfs_plcp_delta_write(struct file *file,
1255 const char __user *user_buf,
1256 size_t count, loff_t *ppos) {
1257
1258 struct iwl_priv *priv = file->private_data;
1259 char buf[8];
1260 int buf_size;
1261 int plcp;
1262
1263 memset(buf, 0, sizeof(buf));
1264 buf_size = min(count, sizeof(buf) - 1);
1265 if (copy_from_user(buf, user_buf, buf_size))
1266 return -EFAULT;
1267 if (sscanf(buf, "%d", &plcp) != 1)
1268 return -EINVAL;
1269 if ((plcp < IWL_MAX_PLCP_ERR_THRESHOLD_MIN) ||
1270 (plcp > IWL_MAX_PLCP_ERR_THRESHOLD_MAX))
1271 priv->cfg->base_params->plcp_delta_threshold =
1272 IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE;
1273 else
1274 priv->cfg->base_params->plcp_delta_threshold = plcp;
1275 return count;
1276}
1277
1278static ssize_t iwl_legacy_dbgfs_force_reset_read(struct file *file, 1146static ssize_t iwl_legacy_dbgfs_force_reset_read(struct file *file,
1279 char __user *user_buf, 1147 char __user *user_buf,
1280 size_t count, loff_t *ppos) { 1148 size_t count, loff_t *ppos) {
1281 1149
1282 struct iwl_priv *priv = file->private_data; 1150 struct iwl_priv *priv = file->private_data;
1283 int i, pos = 0; 1151 int pos = 0;
1284 char buf[300]; 1152 char buf[300];
1285 const size_t bufsz = sizeof(buf); 1153 const size_t bufsz = sizeof(buf);
1286 struct iwl_force_reset *force_reset; 1154 struct iwl_force_reset *force_reset;
1287 1155
1288 for (i = 0; i < IWL_MAX_FORCE_RESET; i++) { 1156 force_reset = &priv->force_reset;
1289 force_reset = &priv->force_reset[i]; 1157
1290 pos += scnprintf(buf + pos, bufsz - pos, 1158 pos += scnprintf(buf + pos, bufsz - pos,
1291 "Force reset method %d\n", i); 1159 "\tnumber of reset request: %d\n",
1292 pos += scnprintf(buf + pos, bufsz - pos, 1160 force_reset->reset_request_count);
1293 "\tnumber of reset request: %d\n", 1161 pos += scnprintf(buf + pos, bufsz - pos,
1294 force_reset->reset_request_count); 1162 "\tnumber of reset request success: %d\n",
1295 pos += scnprintf(buf + pos, bufsz - pos, 1163 force_reset->reset_success_count);
1296 "\tnumber of reset request success: %d\n", 1164 pos += scnprintf(buf + pos, bufsz - pos,
1297 force_reset->reset_success_count); 1165 "\tnumber of reset request reject: %d\n",
1298 pos += scnprintf(buf + pos, bufsz - pos, 1166 force_reset->reset_reject_count);
1299 "\tnumber of reset request reject: %d\n", 1167 pos += scnprintf(buf + pos, bufsz - pos,
1300 force_reset->reset_reject_count); 1168 "\treset duration: %lu\n",
1301 pos += scnprintf(buf + pos, bufsz - pos, 1169 force_reset->reset_duration);
1302 "\treset duration: %lu\n", 1170
1303 force_reset->reset_duration);
1304 }
1305 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 1171 return simple_read_from_buffer(user_buf, count, ppos, buf, pos);
1306} 1172}
1307 1173
@@ -1309,25 +1175,11 @@ static ssize_t iwl_legacy_dbgfs_force_reset_write(struct file *file,
1309 const char __user *user_buf, 1175 const char __user *user_buf,
1310 size_t count, loff_t *ppos) { 1176 size_t count, loff_t *ppos) {
1311 1177
1178 int ret;
1312 struct iwl_priv *priv = file->private_data; 1179 struct iwl_priv *priv = file->private_data;
1313 char buf[8];
1314 int buf_size;
1315 int reset, ret;
1316 1180
1317 memset(buf, 0, sizeof(buf)); 1181 ret = iwl_legacy_force_reset(priv, true);
1318 buf_size = min(count, sizeof(buf) - 1); 1182
1319 if (copy_from_user(buf, user_buf, buf_size))
1320 return -EFAULT;
1321 if (sscanf(buf, "%d", &reset) != 1)
1322 return -EINVAL;
1323 switch (reset) {
1324 case IWL_RF_RESET:
1325 case IWL_FW_RESET:
1326 ret = iwl_legacy_force_reset(priv, reset, true);
1327 break;
1328 default:
1329 return -EINVAL;
1330 }
1331 return ret ? ret : count; 1183 return ret ? ret : count;
1332} 1184}
1333 1185
@@ -1367,10 +1219,8 @@ DEBUGFS_READ_FILE_OPS(chain_noise);
1367DEBUGFS_READ_FILE_OPS(power_save_status); 1219DEBUGFS_READ_FILE_OPS(power_save_status);
1368DEBUGFS_WRITE_FILE_OPS(clear_ucode_statistics); 1220DEBUGFS_WRITE_FILE_OPS(clear_ucode_statistics);
1369DEBUGFS_WRITE_FILE_OPS(clear_traffic_statistics); 1221DEBUGFS_WRITE_FILE_OPS(clear_traffic_statistics);
1370DEBUGFS_READ_WRITE_FILE_OPS(ucode_tracing);
1371DEBUGFS_READ_FILE_OPS(fh_reg); 1222DEBUGFS_READ_FILE_OPS(fh_reg);
1372DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon); 1223DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon);
1373DEBUGFS_READ_WRITE_FILE_OPS(plcp_delta);
1374DEBUGFS_READ_WRITE_FILE_OPS(force_reset); 1224DEBUGFS_READ_WRITE_FILE_OPS(force_reset);
1375DEBUGFS_READ_FILE_OPS(rxon_flags); 1225DEBUGFS_READ_FILE_OPS(rxon_flags);
1376DEBUGFS_READ_FILE_OPS(rxon_filter_flags); 1226DEBUGFS_READ_FILE_OPS(rxon_filter_flags);
@@ -1403,7 +1253,6 @@ int iwl_legacy_dbgfs_register(struct iwl_priv *priv, const char *name)
1403 1253
1404 DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR); 1254 DEBUGFS_ADD_FILE(nvm, dir_data, S_IRUSR);
1405 DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR); 1255 DEBUGFS_ADD_FILE(sram, dir_data, S_IWUSR | S_IRUSR);
1406 DEBUGFS_ADD_FILE(log_event, dir_data, S_IWUSR | S_IRUSR);
1407 DEBUGFS_ADD_FILE(stations, dir_data, S_IRUSR); 1256 DEBUGFS_ADD_FILE(stations, dir_data, S_IRUSR);
1408 DEBUGFS_ADD_FILE(channels, dir_data, S_IRUSR); 1257 DEBUGFS_ADD_FILE(channels, dir_data, S_IRUSR);
1409 DEBUGFS_ADD_FILE(status, dir_data, S_IRUSR); 1258 DEBUGFS_ADD_FILE(status, dir_data, S_IRUSR);
@@ -1420,7 +1269,6 @@ int iwl_legacy_dbgfs_register(struct iwl_priv *priv, const char *name)
1420 DEBUGFS_ADD_FILE(clear_traffic_statistics, dir_debug, S_IWUSR); 1269 DEBUGFS_ADD_FILE(clear_traffic_statistics, dir_debug, S_IWUSR);
1421 DEBUGFS_ADD_FILE(fh_reg, dir_debug, S_IRUSR); 1270 DEBUGFS_ADD_FILE(fh_reg, dir_debug, S_IRUSR);
1422 DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR); 1271 DEBUGFS_ADD_FILE(missed_beacon, dir_debug, S_IWUSR);
1423 DEBUGFS_ADD_FILE(plcp_delta, dir_debug, S_IWUSR | S_IRUSR);
1424 DEBUGFS_ADD_FILE(force_reset, dir_debug, S_IWUSR | S_IRUSR); 1272 DEBUGFS_ADD_FILE(force_reset, dir_debug, S_IWUSR | S_IRUSR);
1425 DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, S_IRUSR); 1273 DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, S_IRUSR);
1426 DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, S_IRUSR); 1274 DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, S_IRUSR);
@@ -1430,8 +1278,6 @@ int iwl_legacy_dbgfs_register(struct iwl_priv *priv, const char *name)
1430 DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR); 1278 DEBUGFS_ADD_FILE(sensitivity, dir_debug, S_IRUSR);
1431 if (priv->cfg->base_params->chain_noise_calib_by_driver) 1279 if (priv->cfg->base_params->chain_noise_calib_by_driver)
1432 DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR); 1280 DEBUGFS_ADD_FILE(chain_noise, dir_debug, S_IRUSR);
1433 if (priv->cfg->base_params->ucode_tracing)
1434 DEBUGFS_ADD_FILE(ucode_tracing, dir_debug, S_IWUSR | S_IRUSR);
1435 DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR); 1281 DEBUGFS_ADD_FILE(rxon_flags, dir_debug, S_IWUSR);
1436 DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR); 1282 DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, S_IWUSR);
1437 DEBUGFS_ADD_FILE(wd_timeout, dir_debug, S_IWUSR); 1283 DEBUGFS_ADD_FILE(wd_timeout, dir_debug, S_IWUSR);
diff --git a/drivers/net/wireless/iwlegacy/iwl-dev.h b/drivers/net/wireless/iwlegacy/iwl-dev.h
index 0a8d07fdc0e7..9c786edf56fd 100644
--- a/drivers/net/wireless/iwlegacy/iwl-dev.h
+++ b/drivers/net/wireless/iwlegacy/iwl-dev.h
@@ -856,32 +856,6 @@ struct traffic_stats {
856}; 856};
857 857
858/* 858/*
859 * schedule the timer to wake up every UCODE_TRACE_PERIOD milliseconds
860 * to perform continuous uCode event logging operation if enabled
861 */
862#define UCODE_TRACE_PERIOD (100)
863
864/*
865 * iwl_event_log: current uCode event log position
866 *
867 * @ucode_trace: enable/disable ucode continuous trace timer
868 * @num_wraps: how many times the event buffer wraps
869 * @next_entry: the entry just before the next one that uCode would fill
870 * @non_wraps_count: counter for no wrap detected when dump ucode events
871 * @wraps_once_count: counter for wrap once detected when dump ucode events
872 * @wraps_more_count: counter for wrap more than once detected
873 * when dump ucode events
874 */
875struct iwl_event_log {
876 bool ucode_trace;
877 u32 num_wraps;
878 u32 next_entry;
879 int non_wraps_count;
880 int wraps_once_count;
881 int wraps_more_count;
882};
883
884/*
885 * host interrupt timeout value 859 * host interrupt timeout value
886 * used with setting interrupt coalescing timer 860 * used with setting interrupt coalescing timer
887 * the CSR_INT_COALESCING is an 8 bit register in 32-usec unit 861 * the CSR_INT_COALESCING is an 8 bit register in 32-usec unit
@@ -896,18 +870,6 @@ struct iwl_event_log {
896#define IWL_HOST_INT_CALIB_TIMEOUT_DEF (0x10) 870#define IWL_HOST_INT_CALIB_TIMEOUT_DEF (0x10)
897#define IWL_HOST_INT_CALIB_TIMEOUT_MIN (0x0) 871#define IWL_HOST_INT_CALIB_TIMEOUT_MIN (0x0)
898 872
899/*
900 * This is the threshold value of plcp error rate per 100mSecs. It is
901 * used to set and check for the validity of plcp_delta.
902 */
903#define IWL_MAX_PLCP_ERR_THRESHOLD_MIN (1)
904#define IWL_MAX_PLCP_ERR_THRESHOLD_DEF (50)
905#define IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF (100)
906#define IWL_MAX_PLCP_ERR_EXT_LONG_THRESHOLD_DEF (200)
907#define IWL_MAX_PLCP_ERR_THRESHOLD_MAX (255)
908#define IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE (0)
909
910#define IWL_DELAY_NEXT_FORCE_RF_RESET (HZ*3)
911#define IWL_DELAY_NEXT_FORCE_FW_RELOAD (HZ*5) 873#define IWL_DELAY_NEXT_FORCE_FW_RELOAD (HZ*5)
912 874
913/* TX queue watchdog timeouts in mSecs */ 875/* TX queue watchdog timeouts in mSecs */
@@ -915,12 +877,6 @@ struct iwl_event_log {
915#define IWL_LONG_WD_TIMEOUT (10000) 877#define IWL_LONG_WD_TIMEOUT (10000)
916#define IWL_MAX_WD_TIMEOUT (120000) 878#define IWL_MAX_WD_TIMEOUT (120000)
917 879
918enum iwl_reset {
919 IWL_RF_RESET = 0,
920 IWL_FW_RESET,
921 IWL_MAX_FORCE_RESET,
922};
923
924struct iwl_force_reset { 880struct iwl_force_reset {
925 int reset_request_count; 881 int reset_request_count;
926 int reset_success_count; 882 int reset_success_count;
@@ -1033,11 +989,8 @@ struct iwl_priv {
1033 /* track IBSS manager (last beacon) status */ 989 /* track IBSS manager (last beacon) status */
1034 u32 ibss_manager; 990 u32 ibss_manager;
1035 991
1036 /* storing the jiffies when the plcp error rate is received */
1037 unsigned long plcp_jiffies;
1038
1039 /* force reset */ 992 /* force reset */
1040 struct iwl_force_reset force_reset[IWL_MAX_FORCE_RESET]; 993 struct iwl_force_reset force_reset;
1041 994
1042 /* we allocate array of iwl_channel_info for NIC's valid channels. 995 /* we allocate array of iwl_channel_info for NIC's valid channels.
1043 * Access via channel # using indirect index array */ 996 * Access via channel # using indirect index array */
@@ -1058,7 +1011,6 @@ struct iwl_priv {
1058 enum ieee80211_band scan_band; 1011 enum ieee80211_band scan_band;
1059 struct cfg80211_scan_request *scan_request; 1012 struct cfg80211_scan_request *scan_request;
1060 struct ieee80211_vif *scan_vif; 1013 struct ieee80211_vif *scan_vif;
1061 bool is_internal_short_scan;
1062 u8 scan_tx_ant[IEEE80211_NUM_BANDS]; 1014 u8 scan_tx_ant[IEEE80211_NUM_BANDS];
1063 u8 mgmt_tx_ant; 1015 u8 mgmt_tx_ant;
1064 1016
@@ -1213,12 +1165,6 @@ struct iwl_priv {
1213#endif 1165#endif
1214#if defined(CONFIG_IWL4965) || defined(CONFIG_IWL4965_MODULE) 1166#if defined(CONFIG_IWL4965) || defined(CONFIG_IWL4965_MODULE)
1215 struct { 1167 struct {
1216 /*
1217 * reporting the number of tids has AGG on. 0 means
1218 * no AGGREGATION
1219 */
1220 u8 agg_tids_count;
1221
1222 struct iwl_rx_phy_res last_phy_res; 1168 struct iwl_rx_phy_res last_phy_res;
1223 bool last_phy_res_valid; 1169 bool last_phy_res_valid;
1224 1170
@@ -1257,7 +1203,6 @@ struct iwl_priv {
1257 struct iwl_rxon_context *beacon_ctx; 1203 struct iwl_rxon_context *beacon_ctx;
1258 struct sk_buff *beacon_skb; 1204 struct sk_buff *beacon_skb;
1259 1205
1260 struct work_struct start_internal_scan;
1261 struct work_struct tx_flush; 1206 struct work_struct tx_flush;
1262 1207
1263 struct tasklet_struct irq_tasklet; 1208 struct tasklet_struct irq_tasklet;
@@ -1294,12 +1239,9 @@ struct iwl_priv {
1294 u32 disable_tx_power_cal; 1239 u32 disable_tx_power_cal;
1295 struct work_struct run_time_calib_work; 1240 struct work_struct run_time_calib_work;
1296 struct timer_list statistics_periodic; 1241 struct timer_list statistics_periodic;
1297 struct timer_list ucode_trace;
1298 struct timer_list watchdog; 1242 struct timer_list watchdog;
1299 bool hw_ready; 1243 bool hw_ready;
1300 1244
1301 struct iwl_event_log event_log;
1302
1303 struct led_classdev led; 1245 struct led_classdev led;
1304 unsigned long blink_on, blink_off; 1246 unsigned long blink_on, blink_off;
1305 bool led_registered; 1247 bool led_registered;
diff --git a/drivers/net/wireless/iwlegacy/iwl-devtrace.c b/drivers/net/wireless/iwlegacy/iwl-devtrace.c
index 080b852b33bd..acec99197ce0 100644
--- a/drivers/net/wireless/iwlegacy/iwl-devtrace.c
+++ b/drivers/net/wireless/iwlegacy/iwl-devtrace.c
@@ -38,8 +38,5 @@ EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_ioread32);
38EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_iowrite32); 38EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_iowrite32);
39EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_rx); 39EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_rx);
40EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_tx); 40EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_tx);
41EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_ucode_event);
42EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_ucode_error); 41EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_ucode_error);
43EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_ucode_cont_event);
44EXPORT_TRACEPOINT_SYMBOL(iwlwifi_legacy_dev_ucode_wrap_event);
45#endif 42#endif
diff --git a/drivers/net/wireless/iwlegacy/iwl-devtrace.h b/drivers/net/wireless/iwlegacy/iwl-devtrace.h
index 9612aa0f6ec4..a443725ba6be 100644
--- a/drivers/net/wireless/iwlegacy/iwl-devtrace.h
+++ b/drivers/net/wireless/iwlegacy/iwl-devtrace.h
@@ -96,47 +96,6 @@ TRACE_EVENT(iwlwifi_legacy_dev_iowrite32,
96#undef TRACE_SYSTEM 96#undef TRACE_SYSTEM
97#define TRACE_SYSTEM iwlwifi_legacy_ucode 97#define TRACE_SYSTEM iwlwifi_legacy_ucode
98 98
99TRACE_EVENT(iwlwifi_legacy_dev_ucode_cont_event,
100 TP_PROTO(struct iwl_priv *priv, u32 time, u32 data, u32 ev),
101 TP_ARGS(priv, time, data, ev),
102 TP_STRUCT__entry(
103 PRIV_ENTRY
104
105 __field(u32, time)
106 __field(u32, data)
107 __field(u32, ev)
108 ),
109 TP_fast_assign(
110 PRIV_ASSIGN;
111 __entry->time = time;
112 __entry->data = data;
113 __entry->ev = ev;
114 ),
115 TP_printk("[%p] EVT_LOGT:%010u:0x%08x:%04u",
116 __entry->priv, __entry->time, __entry->data, __entry->ev)
117);
118
119TRACE_EVENT(iwlwifi_legacy_dev_ucode_wrap_event,
120 TP_PROTO(struct iwl_priv *priv, u32 wraps, u32 n_entry, u32 p_entry),
121 TP_ARGS(priv, wraps, n_entry, p_entry),
122 TP_STRUCT__entry(
123 PRIV_ENTRY
124
125 __field(u32, wraps)
126 __field(u32, n_entry)
127 __field(u32, p_entry)
128 ),
129 TP_fast_assign(
130 PRIV_ASSIGN;
131 __entry->wraps = wraps;
132 __entry->n_entry = n_entry;
133 __entry->p_entry = p_entry;
134 ),
135 TP_printk("[%p] wraps=#%02d n=0x%X p=0x%X",
136 __entry->priv, __entry->wraps, __entry->n_entry,
137 __entry->p_entry)
138);
139
140#undef TRACE_SYSTEM 99#undef TRACE_SYSTEM
141#define TRACE_SYSTEM iwlwifi 100#define TRACE_SYSTEM iwlwifi
142 101
@@ -242,25 +201,6 @@ TRACE_EVENT(iwlwifi_legacy_dev_ucode_error,
242 __entry->blink2, __entry->ilink1, __entry->ilink2) 201 __entry->blink2, __entry->ilink1, __entry->ilink2)
243); 202);
244 203
245TRACE_EVENT(iwlwifi_legacy_dev_ucode_event,
246 TP_PROTO(struct iwl_priv *priv, u32 time, u32 data, u32 ev),
247 TP_ARGS(priv, time, data, ev),
248 TP_STRUCT__entry(
249 PRIV_ENTRY
250
251 __field(u32, time)
252 __field(u32, data)
253 __field(u32, ev)
254 ),
255 TP_fast_assign(
256 PRIV_ASSIGN;
257 __entry->time = time;
258 __entry->data = data;
259 __entry->ev = ev;
260 ),
261 TP_printk("[%p] EVT_LOGT:%010u:0x%08x:%04u",
262 __entry->priv, __entry->time, __entry->data, __entry->ev)
263);
264#endif /* __IWLWIFI_DEVICE_TRACE */ 204#endif /* __IWLWIFI_DEVICE_TRACE */
265 205
266#undef TRACE_INCLUDE_PATH 206#undef TRACE_INCLUDE_PATH
diff --git a/drivers/net/wireless/iwlegacy/iwl-helpers.h b/drivers/net/wireless/iwlegacy/iwl-helpers.h
index a6effdae63f9..5cf23eaecbbb 100644
--- a/drivers/net/wireless/iwlegacy/iwl-helpers.h
+++ b/drivers/net/wireless/iwlegacy/iwl-helpers.h
@@ -132,7 +132,16 @@ static inline void iwl_legacy_stop_queue(struct iwl_priv *priv,
132 ieee80211_stop_queue(priv->hw, ac); 132 ieee80211_stop_queue(priv->hw, ac);
133} 133}
134 134
135#ifdef ieee80211_stop_queue
136#undef ieee80211_stop_queue
137#endif
138
135#define ieee80211_stop_queue DO_NOT_USE_ieee80211_stop_queue 139#define ieee80211_stop_queue DO_NOT_USE_ieee80211_stop_queue
140
141#ifdef ieee80211_wake_queue
142#undef ieee80211_wake_queue
143#endif
144
136#define ieee80211_wake_queue DO_NOT_USE_ieee80211_wake_queue 145#define ieee80211_wake_queue DO_NOT_USE_ieee80211_wake_queue
137 146
138static inline void iwl_legacy_disable_interrupts(struct iwl_priv *priv) 147static inline void iwl_legacy_disable_interrupts(struct iwl_priv *priv)
diff --git a/drivers/net/wireless/iwlegacy/iwl-rx.c b/drivers/net/wireless/iwlegacy/iwl-rx.c
index 654cf233a384..9b5d0abe8be9 100644
--- a/drivers/net/wireless/iwlegacy/iwl-rx.c
+++ b/drivers/net/wireless/iwlegacy/iwl-rx.c
@@ -227,27 +227,6 @@ void iwl_legacy_rx_spectrum_measure_notif(struct iwl_priv *priv,
227} 227}
228EXPORT_SYMBOL(iwl_legacy_rx_spectrum_measure_notif); 228EXPORT_SYMBOL(iwl_legacy_rx_spectrum_measure_notif);
229 229
230void iwl_legacy_recover_from_statistics(struct iwl_priv *priv,
231 struct iwl_rx_packet *pkt)
232{
233 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
234 return;
235 if (iwl_legacy_is_any_associated(priv)) {
236 if (priv->cfg->ops->lib->check_plcp_health) {
237 if (!priv->cfg->ops->lib->check_plcp_health(
238 priv, pkt)) {
239 /*
240 * high plcp error detected
241 * reset Radio
242 */
243 iwl_legacy_force_reset(priv,
244 IWL_RF_RESET, false);
245 }
246 }
247 }
248}
249EXPORT_SYMBOL(iwl_legacy_recover_from_statistics);
250
251/* 230/*
252 * returns non-zero if packet should be dropped 231 * returns non-zero if packet should be dropped
253 */ 232 */
diff --git a/drivers/net/wireless/iwlegacy/iwl-scan.c b/drivers/net/wireless/iwlegacy/iwl-scan.c
index 353234a02c6d..a6b5222fc59e 100644
--- a/drivers/net/wireless/iwlegacy/iwl-scan.c
+++ b/drivers/net/wireless/iwlegacy/iwl-scan.c
@@ -101,7 +101,6 @@ static void iwl_legacy_complete_scan(struct iwl_priv *priv, bool aborted)
101 ieee80211_scan_completed(priv->hw, aborted); 101 ieee80211_scan_completed(priv->hw, aborted);
102 } 102 }
103 103
104 priv->is_internal_short_scan = false;
105 priv->scan_vif = NULL; 104 priv->scan_vif = NULL;
106 priv->scan_request = NULL; 105 priv->scan_request = NULL;
107} 106}
@@ -329,10 +328,8 @@ void iwl_legacy_init_scan_params(struct iwl_priv *priv)
329} 328}
330EXPORT_SYMBOL(iwl_legacy_init_scan_params); 329EXPORT_SYMBOL(iwl_legacy_init_scan_params);
331 330
332static int __must_check iwl_legacy_scan_initiate(struct iwl_priv *priv, 331static int iwl_legacy_scan_initiate(struct iwl_priv *priv,
333 struct ieee80211_vif *vif, 332 struct ieee80211_vif *vif)
334 bool internal,
335 enum ieee80211_band band)
336{ 333{
337 int ret; 334 int ret;
338 335
@@ -359,18 +356,14 @@ static int __must_check iwl_legacy_scan_initiate(struct iwl_priv *priv,
359 return -EBUSY; 356 return -EBUSY;
360 } 357 }
361 358
362 IWL_DEBUG_SCAN(priv, "Starting %sscan...\n", 359 IWL_DEBUG_SCAN(priv, "Starting scan...\n");
363 internal ? "internal short " : "");
364 360
365 set_bit(STATUS_SCANNING, &priv->status); 361 set_bit(STATUS_SCANNING, &priv->status);
366 priv->is_internal_short_scan = internal;
367 priv->scan_start = jiffies; 362 priv->scan_start = jiffies;
368 priv->scan_band = band;
369 363
370 ret = priv->cfg->ops->utils->request_scan(priv, vif); 364 ret = priv->cfg->ops->utils->request_scan(priv, vif);
371 if (ret) { 365 if (ret) {
372 clear_bit(STATUS_SCANNING, &priv->status); 366 clear_bit(STATUS_SCANNING, &priv->status);
373 priv->is_internal_short_scan = false;
374 return ret; 367 return ret;
375 } 368 }
376 369
@@ -394,8 +387,7 @@ int iwl_legacy_mac_hw_scan(struct ieee80211_hw *hw,
394 387
395 mutex_lock(&priv->mutex); 388 mutex_lock(&priv->mutex);
396 389
397 if (test_bit(STATUS_SCANNING, &priv->status) && 390 if (test_bit(STATUS_SCANNING, &priv->status)) {
398 !priv->is_internal_short_scan) {
399 IWL_DEBUG_SCAN(priv, "Scan already in progress.\n"); 391 IWL_DEBUG_SCAN(priv, "Scan already in progress.\n");
400 ret = -EAGAIN; 392 ret = -EAGAIN;
401 goto out_unlock; 393 goto out_unlock;
@@ -404,17 +396,9 @@ int iwl_legacy_mac_hw_scan(struct ieee80211_hw *hw,
404 /* mac80211 will only ask for one band at a time */ 396 /* mac80211 will only ask for one band at a time */
405 priv->scan_request = req; 397 priv->scan_request = req;
406 priv->scan_vif = vif; 398 priv->scan_vif = vif;
399 priv->scan_band = req->channels[0]->band;
407 400
408 /* 401 ret = iwl_legacy_scan_initiate(priv, vif);
409 * If an internal scan is in progress, just set
410 * up the scan_request as per above.
411 */
412 if (priv->is_internal_short_scan) {
413 IWL_DEBUG_SCAN(priv, "SCAN request during internal scan\n");
414 ret = 0;
415 } else
416 ret = iwl_legacy_scan_initiate(priv, vif, false,
417 req->channels[0]->band);
418 402
419 IWL_DEBUG_MAC80211(priv, "leave\n"); 403 IWL_DEBUG_MAC80211(priv, "leave\n");
420 404
@@ -425,40 +409,6 @@ out_unlock:
425} 409}
426EXPORT_SYMBOL(iwl_legacy_mac_hw_scan); 410EXPORT_SYMBOL(iwl_legacy_mac_hw_scan);
427 411
428/*
429 * internal short scan, this function should only been called while associated.
430 * It will reset and tune the radio to prevent possible RF related problem
431 */
432void iwl_legacy_internal_short_hw_scan(struct iwl_priv *priv)
433{
434 queue_work(priv->workqueue, &priv->start_internal_scan);
435}
436
437static void iwl_legacy_bg_start_internal_scan(struct work_struct *work)
438{
439 struct iwl_priv *priv =
440 container_of(work, struct iwl_priv, start_internal_scan);
441
442 IWL_DEBUG_SCAN(priv, "Start internal scan\n");
443
444 mutex_lock(&priv->mutex);
445
446 if (priv->is_internal_short_scan == true) {
447 IWL_DEBUG_SCAN(priv, "Internal scan already in progress\n");
448 goto unlock;
449 }
450
451 if (test_bit(STATUS_SCANNING, &priv->status)) {
452 IWL_DEBUG_SCAN(priv, "Scan already in progress.\n");
453 goto unlock;
454 }
455
456 if (iwl_legacy_scan_initiate(priv, NULL, true, priv->band))
457 IWL_DEBUG_SCAN(priv, "failed to start internal short scan\n");
458 unlock:
459 mutex_unlock(&priv->mutex);
460}
461
462static void iwl_legacy_bg_scan_check(struct work_struct *data) 412static void iwl_legacy_bg_scan_check(struct work_struct *data)
463{ 413{
464 struct iwl_priv *priv = 414 struct iwl_priv *priv =
@@ -542,8 +492,7 @@ static void iwl_legacy_bg_scan_completed(struct work_struct *work)
542 container_of(work, struct iwl_priv, scan_completed); 492 container_of(work, struct iwl_priv, scan_completed);
543 bool aborted; 493 bool aborted;
544 494
545 IWL_DEBUG_SCAN(priv, "Completed %sscan.\n", 495 IWL_DEBUG_SCAN(priv, "Completed scan.\n");
546 priv->is_internal_short_scan ? "internal short " : "");
547 496
548 cancel_delayed_work(&priv->scan_check); 497 cancel_delayed_work(&priv->scan_check);
549 498
@@ -558,27 +507,6 @@ static void iwl_legacy_bg_scan_completed(struct work_struct *work)
558 goto out_settings; 507 goto out_settings;
559 } 508 }
560 509
561 if (priv->is_internal_short_scan && !aborted) {
562 int err;
563
564 /* Check if mac80211 requested scan during our internal scan */
565 if (priv->scan_request == NULL)
566 goto out_complete;
567
568 /* If so request a new scan */
569 err = iwl_legacy_scan_initiate(priv, priv->scan_vif, false,
570 priv->scan_request->channels[0]->band);
571 if (err) {
572 IWL_DEBUG_SCAN(priv,
573 "failed to initiate pending scan: %d\n", err);
574 aborted = true;
575 goto out_complete;
576 }
577
578 goto out;
579 }
580
581out_complete:
582 iwl_legacy_complete_scan(priv, aborted); 510 iwl_legacy_complete_scan(priv, aborted);
583 511
584out_settings: 512out_settings:
@@ -590,8 +518,7 @@ out_settings:
590 * We do not commit power settings while scan is pending, 518 * We do not commit power settings while scan is pending,
591 * do it now if the settings changed. 519 * do it now if the settings changed.
592 */ 520 */
593 iwl_legacy_power_set_mode(priv, &priv->power_data.sleep_cmd_next, 521 iwl_legacy_power_set_mode(priv, &priv->power_data.sleep_cmd_next, false);
594 false);
595 iwl_legacy_set_tx_power(priv, priv->tx_power_next, false); 522 iwl_legacy_set_tx_power(priv, priv->tx_power_next, false);
596 523
597 priv->cfg->ops->utils->post_scan(priv); 524 priv->cfg->ops->utils->post_scan(priv);
@@ -604,15 +531,12 @@ void iwl_legacy_setup_scan_deferred_work(struct iwl_priv *priv)
604{ 531{
605 INIT_WORK(&priv->scan_completed, iwl_legacy_bg_scan_completed); 532 INIT_WORK(&priv->scan_completed, iwl_legacy_bg_scan_completed);
606 INIT_WORK(&priv->abort_scan, iwl_legacy_bg_abort_scan); 533 INIT_WORK(&priv->abort_scan, iwl_legacy_bg_abort_scan);
607 INIT_WORK(&priv->start_internal_scan,
608 iwl_legacy_bg_start_internal_scan);
609 INIT_DELAYED_WORK(&priv->scan_check, iwl_legacy_bg_scan_check); 534 INIT_DELAYED_WORK(&priv->scan_check, iwl_legacy_bg_scan_check);
610} 535}
611EXPORT_SYMBOL(iwl_legacy_setup_scan_deferred_work); 536EXPORT_SYMBOL(iwl_legacy_setup_scan_deferred_work);
612 537
613void iwl_legacy_cancel_scan_deferred_work(struct iwl_priv *priv) 538void iwl_legacy_cancel_scan_deferred_work(struct iwl_priv *priv)
614{ 539{
615 cancel_work_sync(&priv->start_internal_scan);
616 cancel_work_sync(&priv->abort_scan); 540 cancel_work_sync(&priv->abort_scan);
617 cancel_work_sync(&priv->scan_completed); 541 cancel_work_sync(&priv->scan_completed);
618 542
diff --git a/drivers/net/wireless/iwlegacy/iwl3945-base.c b/drivers/net/wireless/iwlegacy/iwl3945-base.c
index 0ee6be6a9c5d..795826a014ed 100644
--- a/drivers/net/wireless/iwlegacy/iwl3945-base.c
+++ b/drivers/net/wireless/iwlegacy/iwl3945-base.c
@@ -1409,212 +1409,6 @@ void iwl3945_dump_nic_error_log(struct iwl_priv *priv)
1409 } 1409 }
1410} 1410}
1411 1411
1412#define EVENT_START_OFFSET (6 * sizeof(u32))
1413
1414/**
1415 * iwl3945_print_event_log - Dump error event log to syslog
1416 *
1417 */
1418static int iwl3945_print_event_log(struct iwl_priv *priv, u32 start_idx,
1419 u32 num_events, u32 mode,
1420 int pos, char **buf, size_t bufsz)
1421{
1422 u32 i;
1423 u32 base; /* SRAM byte address of event log header */
1424 u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
1425 u32 ptr; /* SRAM byte address of log data */
1426 u32 ev, time, data; /* event log data */
1427 unsigned long reg_flags;
1428
1429 if (num_events == 0)
1430 return pos;
1431
1432 base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
1433
1434 if (mode == 0)
1435 event_size = 2 * sizeof(u32);
1436 else
1437 event_size = 3 * sizeof(u32);
1438
1439 ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
1440
1441 /* Make sure device is powered up for SRAM reads */
1442 spin_lock_irqsave(&priv->reg_lock, reg_flags);
1443 iwl_grab_nic_access(priv);
1444
1445 /* Set starting address; reads will auto-increment */
1446 _iwl_legacy_write_direct32(priv, HBUS_TARG_MEM_RADDR, ptr);
1447 rmb();
1448
1449 /* "time" is actually "data" for mode 0 (no timestamp).
1450 * place event id # at far right for easier visual parsing. */
1451 for (i = 0; i < num_events; i++) {
1452 ev = _iwl_legacy_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1453 time = _iwl_legacy_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1454 if (mode == 0) {
1455 /* data, ev */
1456 if (bufsz) {
1457 pos += scnprintf(*buf + pos, bufsz - pos,
1458 "0x%08x:%04u\n",
1459 time, ev);
1460 } else {
1461 IWL_ERR(priv, "0x%08x\t%04u\n", time, ev);
1462 trace_iwlwifi_legacy_dev_ucode_event(priv, 0,
1463 time, ev);
1464 }
1465 } else {
1466 data = _iwl_legacy_read_direct32(priv,
1467 HBUS_TARG_MEM_RDAT);
1468 if (bufsz) {
1469 pos += scnprintf(*buf + pos, bufsz - pos,
1470 "%010u:0x%08x:%04u\n",
1471 time, data, ev);
1472 } else {
1473 IWL_ERR(priv, "%010u\t0x%08x\t%04u\n",
1474 time, data, ev);
1475 trace_iwlwifi_legacy_dev_ucode_event(priv, time,
1476 data, ev);
1477 }
1478 }
1479 }
1480
1481 /* Allow device to power down */
1482 iwl_release_nic_access(priv);
1483 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
1484 return pos;
1485}
1486
1487/**
1488 * iwl3945_print_last_event_logs - Dump the newest # of event log to syslog
1489 */
1490static int iwl3945_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
1491 u32 num_wraps, u32 next_entry,
1492 u32 size, u32 mode,
1493 int pos, char **buf, size_t bufsz)
1494{
1495 /*
1496 * display the newest DEFAULT_LOG_ENTRIES entries
1497 * i.e the entries just before the next ont that uCode would fill.
1498 */
1499 if (num_wraps) {
1500 if (next_entry < size) {
1501 pos = iwl3945_print_event_log(priv,
1502 capacity - (size - next_entry),
1503 size - next_entry, mode,
1504 pos, buf, bufsz);
1505 pos = iwl3945_print_event_log(priv, 0,
1506 next_entry, mode,
1507 pos, buf, bufsz);
1508 } else
1509 pos = iwl3945_print_event_log(priv, next_entry - size,
1510 size, mode,
1511 pos, buf, bufsz);
1512 } else {
1513 if (next_entry < size)
1514 pos = iwl3945_print_event_log(priv, 0,
1515 next_entry, mode,
1516 pos, buf, bufsz);
1517 else
1518 pos = iwl3945_print_event_log(priv, next_entry - size,
1519 size, mode,
1520 pos, buf, bufsz);
1521 }
1522 return pos;
1523}
1524
1525#define DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES (20)
1526
1527int iwl3945_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
1528 char **buf, bool display)
1529{
1530 u32 base; /* SRAM byte address of event log header */
1531 u32 capacity; /* event log capacity in # entries */
1532 u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
1533 u32 num_wraps; /* # times uCode wrapped to top of log */
1534 u32 next_entry; /* index of next entry to be written by uCode */
1535 u32 size; /* # entries that we'll print */
1536 int pos = 0;
1537 size_t bufsz = 0;
1538
1539 base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
1540 if (!iwl3945_hw_valid_rtc_data_addr(base)) {
1541 IWL_ERR(priv, "Invalid event log pointer 0x%08X\n", base);
1542 return -EINVAL;
1543 }
1544
1545 /* event log header */
1546 capacity = iwl_legacy_read_targ_mem(priv, base);
1547 mode = iwl_legacy_read_targ_mem(priv, base + (1 * sizeof(u32)));
1548 num_wraps = iwl_legacy_read_targ_mem(priv, base + (2 * sizeof(u32)));
1549 next_entry = iwl_legacy_read_targ_mem(priv, base + (3 * sizeof(u32)));
1550
1551 if (capacity > priv->cfg->base_params->max_event_log_size) {
1552 IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
1553 capacity, priv->cfg->base_params->max_event_log_size);
1554 capacity = priv->cfg->base_params->max_event_log_size;
1555 }
1556
1557 if (next_entry > priv->cfg->base_params->max_event_log_size) {
1558 IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
1559 next_entry, priv->cfg->base_params->max_event_log_size);
1560 next_entry = priv->cfg->base_params->max_event_log_size;
1561 }
1562
1563 size = num_wraps ? capacity : next_entry;
1564
1565 /* bail out if nothing in log */
1566 if (size == 0) {
1567 IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
1568 return pos;
1569 }
1570
1571#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
1572 if (!(iwl_legacy_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
1573 size = (size > DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES)
1574 ? DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES : size;
1575#else
1576 size = (size > DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES)
1577 ? DEFAULT_IWL3945_DUMP_EVENT_LOG_ENTRIES : size;
1578#endif
1579
1580 IWL_ERR(priv, "Start IWL Event Log Dump: display last %d count\n",
1581 size);
1582
1583#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
1584 if (display) {
1585 if (full_log)
1586 bufsz = capacity * 48;
1587 else
1588 bufsz = size * 48;
1589 *buf = kmalloc(bufsz, GFP_KERNEL);
1590 if (!*buf)
1591 return -ENOMEM;
1592 }
1593 if ((iwl_legacy_get_debug_level(priv) & IWL_DL_FW_ERRORS) || full_log) {
1594 /* if uCode has wrapped back to top of log,
1595 * start at the oldest entry,
1596 * i.e the next one that uCode would fill.
1597 */
1598 if (num_wraps)
1599 pos = iwl3945_print_event_log(priv, next_entry,
1600 capacity - next_entry, mode,
1601 pos, buf, bufsz);
1602
1603 /* (then/else) start at top of log */
1604 pos = iwl3945_print_event_log(priv, 0, next_entry, mode,
1605 pos, buf, bufsz);
1606 } else
1607 pos = iwl3945_print_last_event_logs(priv, capacity, num_wraps,
1608 next_entry, size, mode,
1609 pos, buf, bufsz);
1610#else
1611 pos = iwl3945_print_last_event_logs(priv, capacity, num_wraps,
1612 next_entry, size, mode,
1613 pos, buf, bufsz);
1614#endif
1615 return pos;
1616}
1617
1618static void iwl3945_irq_tasklet(struct iwl_priv *priv) 1412static void iwl3945_irq_tasklet(struct iwl_priv *priv)
1619{ 1413{
1620 u32 inta, handled = 0; 1414 u32 inta, handled = 0;
@@ -1762,49 +1556,6 @@ static void iwl3945_irq_tasklet(struct iwl_priv *priv)
1762#endif 1556#endif
1763} 1557}
1764 1558
1765static int iwl3945_get_single_channel_for_scan(struct iwl_priv *priv,
1766 struct ieee80211_vif *vif,
1767 enum ieee80211_band band,
1768 struct iwl3945_scan_channel *scan_ch)
1769{
1770 const struct ieee80211_supported_band *sband;
1771 u16 passive_dwell = 0;
1772 u16 active_dwell = 0;
1773 int added = 0;
1774 u8 channel = 0;
1775
1776 sband = iwl_get_hw_mode(priv, band);
1777 if (!sband) {
1778 IWL_ERR(priv, "invalid band\n");
1779 return added;
1780 }
1781
1782 active_dwell = iwl_legacy_get_active_dwell_time(priv, band, 0);
1783 passive_dwell = iwl_legacy_get_passive_dwell_time(priv, band, vif);
1784
1785 if (passive_dwell <= active_dwell)
1786 passive_dwell = active_dwell + 1;
1787
1788
1789 channel = iwl_legacy_get_single_channel_number(priv, band);
1790
1791 if (channel) {
1792 scan_ch->channel = channel;
1793 scan_ch->type = 0; /* passive */
1794 scan_ch->active_dwell = cpu_to_le16(active_dwell);
1795 scan_ch->passive_dwell = cpu_to_le16(passive_dwell);
1796 /* Set txpower levels to defaults */
1797 scan_ch->tpc.dsp_atten = 110;
1798 if (band == IEEE80211_BAND_5GHZ)
1799 scan_ch->tpc.tx_gain = ((1 << 5) | (3 << 3)) | 3;
1800 else
1801 scan_ch->tpc.tx_gain = ((1 << 5) | (5 << 3));
1802 added++;
1803 } else
1804 IWL_ERR(priv, "no valid channel found\n");
1805 return added;
1806}
1807
1808static int iwl3945_get_channels_for_scan(struct iwl_priv *priv, 1559static int iwl3945_get_channels_for_scan(struct iwl_priv *priv,
1809 enum ieee80211_band band, 1560 enum ieee80211_band band,
1810 u8 is_active, u8 n_probes, 1561 u8 is_active, u8 n_probes,
@@ -2816,6 +2567,7 @@ int iwl3945_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
2816 enum ieee80211_band band; 2567 enum ieee80211_band band;
2817 bool is_active = false; 2568 bool is_active = false;
2818 int ret; 2569 int ret;
2570 u16 len;
2819 2571
2820 lockdep_assert_held(&priv->mutex); 2572 lockdep_assert_held(&priv->mutex);
2821 2573
@@ -2834,17 +2586,14 @@ int iwl3945_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
2834 scan->quiet_time = IWL_ACTIVE_QUIET_TIME; 2586 scan->quiet_time = IWL_ACTIVE_QUIET_TIME;
2835 2587
2836 if (iwl_legacy_is_associated(priv, IWL_RXON_CTX_BSS)) { 2588 if (iwl_legacy_is_associated(priv, IWL_RXON_CTX_BSS)) {
2837 u16 interval = 0; 2589 u16 interval;
2838 u32 extra; 2590 u32 extra;
2839 u32 suspend_time = 100; 2591 u32 suspend_time = 100;
2840 u32 scan_suspend_time = 100; 2592 u32 scan_suspend_time = 100;
2841 2593
2842 IWL_DEBUG_INFO(priv, "Scanning while associated...\n"); 2594 IWL_DEBUG_INFO(priv, "Scanning while associated...\n");
2843 2595
2844 if (priv->is_internal_short_scan) 2596 interval = vif->bss_conf.beacon_int;
2845 interval = 0;
2846 else
2847 interval = vif->bss_conf.beacon_int;
2848 2597
2849 scan->suspend_time = 0; 2598 scan->suspend_time = 0;
2850 scan->max_out_time = cpu_to_le32(200 * 1024); 2599 scan->max_out_time = cpu_to_le32(200 * 1024);
@@ -2866,9 +2615,7 @@ int iwl3945_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
2866 scan_suspend_time, interval); 2615 scan_suspend_time, interval);
2867 } 2616 }
2868 2617
2869 if (priv->is_internal_short_scan) { 2618 if (priv->scan_request->n_ssids) {
2870 IWL_DEBUG_SCAN(priv, "Start internal passive scan.\n");
2871 } else if (priv->scan_request->n_ssids) {
2872 int i, p = 0; 2619 int i, p = 0;
2873 IWL_DEBUG_SCAN(priv, "Kicking off active scan\n"); 2620 IWL_DEBUG_SCAN(priv, "Kicking off active scan\n");
2874 for (i = 0; i < priv->scan_request->n_ssids; i++) { 2621 for (i = 0; i < priv->scan_request->n_ssids; i++) {
@@ -2919,36 +2666,17 @@ int iwl3945_request_scan(struct iwl_priv *priv, struct ieee80211_vif *vif)
2919 scan->good_CRC_th = is_active ? IWL_GOOD_CRC_TH_DEFAULT : 2666 scan->good_CRC_th = is_active ? IWL_GOOD_CRC_TH_DEFAULT :
2920 IWL_GOOD_CRC_TH_DISABLED; 2667 IWL_GOOD_CRC_TH_DISABLED;
2921 2668
2922 if (!priv->is_internal_short_scan) { 2669 len = iwl_legacy_fill_probe_req(priv, (struct ieee80211_mgmt *)scan->data,
2923 scan->tx_cmd.len = cpu_to_le16( 2670 vif->addr, priv->scan_request->ie,
2924 iwl_legacy_fill_probe_req(priv, 2671 priv->scan_request->ie_len,
2925 (struct ieee80211_mgmt *)scan->data, 2672 IWL_MAX_SCAN_SIZE - sizeof(*scan));
2926 vif->addr, 2673 scan->tx_cmd.len = cpu_to_le16(len);
2927 priv->scan_request->ie, 2674
2928 priv->scan_request->ie_len,
2929 IWL_MAX_SCAN_SIZE - sizeof(*scan)));
2930 } else {
2931 /* use bcast addr, will not be transmitted but must be valid */
2932 scan->tx_cmd.len = cpu_to_le16(
2933 iwl_legacy_fill_probe_req(priv,
2934 (struct ieee80211_mgmt *)scan->data,
2935 iwlegacy_bcast_addr, NULL, 0,
2936 IWL_MAX_SCAN_SIZE - sizeof(*scan)));
2937 }
2938 /* select Rx antennas */ 2675 /* select Rx antennas */
2939 scan->flags |= iwl3945_get_antenna_flags(priv); 2676 scan->flags |= iwl3945_get_antenna_flags(priv);
2940 2677
2941 if (priv->is_internal_short_scan) { 2678 scan->channel_count = iwl3945_get_channels_for_scan(priv, band, is_active, n_probes,
2942 scan->channel_count = 2679 (void *)&scan->data[len], vif);
2943 iwl3945_get_single_channel_for_scan(priv, vif, band,
2944 (void *)&scan->data[le16_to_cpu(
2945 scan->tx_cmd.len)]);
2946 } else {
2947 scan->channel_count =
2948 iwl3945_get_channels_for_scan(priv, band, is_active, n_probes,
2949 (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)], vif);
2950 }
2951
2952 if (scan->channel_count == 0) { 2680 if (scan->channel_count == 0) {
2953 IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count); 2681 IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count);
2954 return -EIO; 2682 return -EIO;
@@ -3824,10 +3552,7 @@ static int iwl3945_init_drv(struct iwl_priv *priv)
3824 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF; 3552 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
3825 3553
3826 /* initialize force reset */ 3554 /* initialize force reset */
3827 priv->force_reset[IWL_RF_RESET].reset_duration = 3555 priv->force_reset.reset_duration = IWL_DELAY_NEXT_FORCE_FW_RELOAD;
3828 IWL_DELAY_NEXT_FORCE_RF_RESET;
3829 priv->force_reset[IWL_FW_RESET].reset_duration =
3830 IWL_DELAY_NEXT_FORCE_FW_RELOAD;
3831 3556
3832 if (eeprom->version < EEPROM_3945_EEPROM_VERSION) { 3557 if (eeprom->version < EEPROM_3945_EEPROM_VERSION) {
3833 IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n", 3558 IWL_WARN(priv, "Unsupported EEPROM version: 0x%04X\n",
diff --git a/drivers/net/wireless/iwlegacy/iwl4965-base.c b/drivers/net/wireless/iwlegacy/iwl4965-base.c
index 7157ba529680..46242d2aa5ad 100644
--- a/drivers/net/wireless/iwlegacy/iwl4965-base.c
+++ b/drivers/net/wireless/iwlegacy/iwl4965-base.c
@@ -488,134 +488,6 @@ static void iwl4965_bg_statistics_periodic(unsigned long data)
488 iwl_legacy_send_statistics_request(priv, CMD_ASYNC, false); 488 iwl_legacy_send_statistics_request(priv, CMD_ASYNC, false);
489} 489}
490 490
491
492static void iwl4965_print_cont_event_trace(struct iwl_priv *priv, u32 base,
493 u32 start_idx, u32 num_events,
494 u32 mode)
495{
496 u32 i;
497 u32 ptr; /* SRAM byte address of log data */
498 u32 ev, time, data; /* event log data */
499 unsigned long reg_flags;
500
501 if (mode == 0)
502 ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32));
503 else
504 ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32));
505
506 /* Make sure device is powered up for SRAM reads */
507 spin_lock_irqsave(&priv->reg_lock, reg_flags);
508 if (iwl_grab_nic_access(priv)) {
509 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
510 return;
511 }
512
513 /* Set starting address; reads will auto-increment */
514 _iwl_legacy_write_direct32(priv, HBUS_TARG_MEM_RADDR, ptr);
515 rmb();
516
517 /*
518 * "time" is actually "data" for mode 0 (no timestamp).
519 * place event id # at far right for easier visual parsing.
520 */
521 for (i = 0; i < num_events; i++) {
522 ev = _iwl_legacy_read_direct32(priv, HBUS_TARG_MEM_RDAT);
523 time = _iwl_legacy_read_direct32(priv, HBUS_TARG_MEM_RDAT);
524 if (mode == 0) {
525 trace_iwlwifi_legacy_dev_ucode_cont_event(priv,
526 0, time, ev);
527 } else {
528 data = _iwl_legacy_read_direct32(priv,
529 HBUS_TARG_MEM_RDAT);
530 trace_iwlwifi_legacy_dev_ucode_cont_event(priv,
531 time, data, ev);
532 }
533 }
534 /* Allow device to power down */
535 iwl_release_nic_access(priv);
536 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
537}
538
539static void iwl4965_continuous_event_trace(struct iwl_priv *priv)
540{
541 u32 capacity; /* event log capacity in # entries */
542 u32 base; /* SRAM byte address of event log header */
543 u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
544 u32 num_wraps; /* # times uCode wrapped to top of log */
545 u32 next_entry; /* index of next entry to be written by uCode */
546
547 if (priv->ucode_type == UCODE_INIT)
548 base = le32_to_cpu(priv->card_alive_init.error_event_table_ptr);
549 else
550 base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
551 if (priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
552 capacity = iwl_legacy_read_targ_mem(priv, base);
553 num_wraps = iwl_legacy_read_targ_mem(priv,
554 base + (2 * sizeof(u32)));
555 mode = iwl_legacy_read_targ_mem(priv, base + (1 * sizeof(u32)));
556 next_entry = iwl_legacy_read_targ_mem(priv,
557 base + (3 * sizeof(u32)));
558 } else
559 return;
560
561 if (num_wraps == priv->event_log.num_wraps) {
562 iwl4965_print_cont_event_trace(priv,
563 base, priv->event_log.next_entry,
564 next_entry - priv->event_log.next_entry,
565 mode);
566 priv->event_log.non_wraps_count++;
567 } else {
568 if ((num_wraps - priv->event_log.num_wraps) > 1)
569 priv->event_log.wraps_more_count++;
570 else
571 priv->event_log.wraps_once_count++;
572 trace_iwlwifi_legacy_dev_ucode_wrap_event(priv,
573 num_wraps - priv->event_log.num_wraps,
574 next_entry, priv->event_log.next_entry);
575 if (next_entry < priv->event_log.next_entry) {
576 iwl4965_print_cont_event_trace(priv, base,
577 priv->event_log.next_entry,
578 capacity - priv->event_log.next_entry,
579 mode);
580
581 iwl4965_print_cont_event_trace(priv, base, 0,
582 next_entry, mode);
583 } else {
584 iwl4965_print_cont_event_trace(priv, base,
585 next_entry, capacity - next_entry,
586 mode);
587
588 iwl4965_print_cont_event_trace(priv, base, 0,
589 next_entry, mode);
590 }
591 }
592 priv->event_log.num_wraps = num_wraps;
593 priv->event_log.next_entry = next_entry;
594}
595
596/**
597 * iwl4965_bg_ucode_trace - Timer callback to log ucode event
598 *
599 * The timer is continually set to execute every
600 * UCODE_TRACE_PERIOD milliseconds after the last timer expired
601 * this function is to perform continuous uCode event logging operation
602 * if enabled
603 */
604static void iwl4965_bg_ucode_trace(unsigned long data)
605{
606 struct iwl_priv *priv = (struct iwl_priv *)data;
607
608 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
609 return;
610
611 if (priv->event_log.ucode_trace) {
612 iwl4965_continuous_event_trace(priv);
613 /* Reschedule the timer to occur in UCODE_TRACE_PERIOD */
614 mod_timer(&priv->ucode_trace,
615 jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
616 }
617}
618
619static void iwl4965_rx_beacon_notif(struct iwl_priv *priv, 491static void iwl4965_rx_beacon_notif(struct iwl_priv *priv,
620 struct iwl_rx_mem_buffer *rxb) 492 struct iwl_rx_mem_buffer *rxb)
621{ 493{
@@ -1711,209 +1583,6 @@ void iwl4965_dump_nic_error_log(struct iwl_priv *priv)
1711 pc, blink1, blink2, ilink1, ilink2, hcmd); 1583 pc, blink1, blink2, ilink1, ilink2, hcmd);
1712} 1584}
1713 1585
1714#define EVENT_START_OFFSET (4 * sizeof(u32))
1715
1716/**
1717 * iwl4965_print_event_log - Dump error event log to syslog
1718 *
1719 */
1720static int iwl4965_print_event_log(struct iwl_priv *priv, u32 start_idx,
1721 u32 num_events, u32 mode,
1722 int pos, char **buf, size_t bufsz)
1723{
1724 u32 i;
1725 u32 base; /* SRAM byte address of event log header */
1726 u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
1727 u32 ptr; /* SRAM byte address of log data */
1728 u32 ev, time, data; /* event log data */
1729 unsigned long reg_flags;
1730
1731 if (num_events == 0)
1732 return pos;
1733
1734 if (priv->ucode_type == UCODE_INIT) {
1735 base = le32_to_cpu(priv->card_alive_init.log_event_table_ptr);
1736 } else {
1737 base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
1738 }
1739
1740 if (mode == 0)
1741 event_size = 2 * sizeof(u32);
1742 else
1743 event_size = 3 * sizeof(u32);
1744
1745 ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
1746
1747 /* Make sure device is powered up for SRAM reads */
1748 spin_lock_irqsave(&priv->reg_lock, reg_flags);
1749 iwl_grab_nic_access(priv);
1750
1751 /* Set starting address; reads will auto-increment */
1752 _iwl_legacy_write_direct32(priv, HBUS_TARG_MEM_RADDR, ptr);
1753 rmb();
1754
1755 /* "time" is actually "data" for mode 0 (no timestamp).
1756 * place event id # at far right for easier visual parsing. */
1757 for (i = 0; i < num_events; i++) {
1758 ev = _iwl_legacy_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1759 time = _iwl_legacy_read_direct32(priv, HBUS_TARG_MEM_RDAT);
1760 if (mode == 0) {
1761 /* data, ev */
1762 if (bufsz) {
1763 pos += scnprintf(*buf + pos, bufsz - pos,
1764 "EVT_LOG:0x%08x:%04u\n",
1765 time, ev);
1766 } else {
1767 trace_iwlwifi_legacy_dev_ucode_event(priv, 0,
1768 time, ev);
1769 IWL_ERR(priv, "EVT_LOG:0x%08x:%04u\n",
1770 time, ev);
1771 }
1772 } else {
1773 data = _iwl_legacy_read_direct32(priv,
1774 HBUS_TARG_MEM_RDAT);
1775 if (bufsz) {
1776 pos += scnprintf(*buf + pos, bufsz - pos,
1777 "EVT_LOGT:%010u:0x%08x:%04u\n",
1778 time, data, ev);
1779 } else {
1780 IWL_ERR(priv, "EVT_LOGT:%010u:0x%08x:%04u\n",
1781 time, data, ev);
1782 trace_iwlwifi_legacy_dev_ucode_event(priv, time,
1783 data, ev);
1784 }
1785 }
1786 }
1787
1788 /* Allow device to power down */
1789 iwl_release_nic_access(priv);
1790 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
1791 return pos;
1792}
1793
1794/**
1795 * iwl4965_print_last_event_logs - Dump the newest # of event log to syslog
1796 */
1797static int iwl4965_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
1798 u32 num_wraps, u32 next_entry,
1799 u32 size, u32 mode,
1800 int pos, char **buf, size_t bufsz)
1801{
1802 /*
1803 * display the newest DEFAULT_LOG_ENTRIES entries
1804 * i.e the entries just before the next ont that uCode would fill.
1805 */
1806 if (num_wraps) {
1807 if (next_entry < size) {
1808 pos = iwl4965_print_event_log(priv,
1809 capacity - (size - next_entry),
1810 size - next_entry, mode,
1811 pos, buf, bufsz);
1812 pos = iwl4965_print_event_log(priv, 0,
1813 next_entry, mode,
1814 pos, buf, bufsz);
1815 } else
1816 pos = iwl4965_print_event_log(priv, next_entry - size,
1817 size, mode, pos, buf, bufsz);
1818 } else {
1819 if (next_entry < size) {
1820 pos = iwl4965_print_event_log(priv, 0, next_entry,
1821 mode, pos, buf, bufsz);
1822 } else {
1823 pos = iwl4965_print_event_log(priv, next_entry - size,
1824 size, mode, pos, buf, bufsz);
1825 }
1826 }
1827 return pos;
1828}
1829
1830#define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
1831
1832int iwl4965_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
1833 char **buf, bool display)
1834{
1835 u32 base; /* SRAM byte address of event log header */
1836 u32 capacity; /* event log capacity in # entries */
1837 u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
1838 u32 num_wraps; /* # times uCode wrapped to top of log */
1839 u32 next_entry; /* index of next entry to be written by uCode */
1840 u32 size; /* # entries that we'll print */
1841 int pos = 0;
1842 size_t bufsz = 0;
1843
1844 if (priv->ucode_type == UCODE_INIT) {
1845 base = le32_to_cpu(priv->card_alive_init.log_event_table_ptr);
1846 } else {
1847 base = le32_to_cpu(priv->card_alive.log_event_table_ptr);
1848 }
1849
1850 if (!priv->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
1851 IWL_ERR(priv,
1852 "Invalid event log pointer 0x%08X for %s uCode\n",
1853 base, (priv->ucode_type == UCODE_INIT) ? "Init" : "RT");
1854 return -EINVAL;
1855 }
1856
1857 /* event log header */
1858 capacity = iwl_legacy_read_targ_mem(priv, base);
1859 mode = iwl_legacy_read_targ_mem(priv, base + (1 * sizeof(u32)));
1860 num_wraps = iwl_legacy_read_targ_mem(priv, base + (2 * sizeof(u32)));
1861 next_entry = iwl_legacy_read_targ_mem(priv, base + (3 * sizeof(u32)));
1862
1863 size = num_wraps ? capacity : next_entry;
1864
1865 /* bail out if nothing in log */
1866 if (size == 0) {
1867 IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
1868 return pos;
1869 }
1870
1871#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
1872 if (!(iwl_legacy_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
1873 size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
1874 ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
1875#else
1876 size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
1877 ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
1878#endif
1879 IWL_ERR(priv, "Start IWL Event Log Dump: display last %u entries\n",
1880 size);
1881
1882#ifdef CONFIG_IWLWIFI_LEGACY_DEBUG
1883 if (display) {
1884 if (full_log)
1885 bufsz = capacity * 48;
1886 else
1887 bufsz = size * 48;
1888 *buf = kmalloc(bufsz, GFP_KERNEL);
1889 if (!*buf)
1890 return -ENOMEM;
1891 }
1892 if ((iwl_legacy_get_debug_level(priv) & IWL_DL_FW_ERRORS) || full_log) {
1893 /*
1894 * if uCode has wrapped back to top of log,
1895 * start at the oldest entry,
1896 * i.e the next one that uCode would fill.
1897 */
1898 if (num_wraps)
1899 pos = iwl4965_print_event_log(priv, next_entry,
1900 capacity - next_entry, mode,
1901 pos, buf, bufsz);
1902 /* (then/else) start at top of log */
1903 pos = iwl4965_print_event_log(priv, 0,
1904 next_entry, mode, pos, buf, bufsz);
1905 } else
1906 pos = iwl4965_print_last_event_logs(priv, capacity, num_wraps,
1907 next_entry, size, mode,
1908 pos, buf, bufsz);
1909#else
1910 pos = iwl4965_print_last_event_logs(priv, capacity, num_wraps,
1911 next_entry, size, mode,
1912 pos, buf, bufsz);
1913#endif
1914 return pos;
1915}
1916
1917static void iwl4965_rf_kill_ct_config(struct iwl_priv *priv) 1586static void iwl4965_rf_kill_ct_config(struct iwl_priv *priv)
1918{ 1587{
1919 struct iwl_ct_kill_config cmd; 1588 struct iwl_ct_kill_config cmd;
@@ -2773,20 +2442,10 @@ int iwl4965_mac_ampdu_action(struct ieee80211_hw *hw,
2773 case IEEE80211_AMPDU_TX_START: 2442 case IEEE80211_AMPDU_TX_START:
2774 IWL_DEBUG_HT(priv, "start Tx\n"); 2443 IWL_DEBUG_HT(priv, "start Tx\n");
2775 ret = iwl4965_tx_agg_start(priv, vif, sta, tid, ssn); 2444 ret = iwl4965_tx_agg_start(priv, vif, sta, tid, ssn);
2776 if (ret == 0) {
2777 priv->_4965.agg_tids_count++;
2778 IWL_DEBUG_HT(priv, "priv->_4965.agg_tids_count = %u\n",
2779 priv->_4965.agg_tids_count);
2780 }
2781 break; 2445 break;
2782 case IEEE80211_AMPDU_TX_STOP: 2446 case IEEE80211_AMPDU_TX_STOP:
2783 IWL_DEBUG_HT(priv, "stop Tx\n"); 2447 IWL_DEBUG_HT(priv, "stop Tx\n");
2784 ret = iwl4965_tx_agg_stop(priv, vif, sta, tid); 2448 ret = iwl4965_tx_agg_stop(priv, vif, sta, tid);
2785 if ((ret == 0) && (priv->_4965.agg_tids_count > 0)) {
2786 priv->_4965.agg_tids_count--;
2787 IWL_DEBUG_HT(priv, "priv->_4965.agg_tids_count = %u\n",
2788 priv->_4965.agg_tids_count);
2789 }
2790 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) 2449 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2791 ret = 0; 2450 ret = 0;
2792 break; 2451 break;
@@ -2851,7 +2510,6 @@ void iwl4965_mac_channel_switch(struct ieee80211_hw *hw,
2851 2510
2852 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS]; 2511 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2853 u16 ch; 2512 u16 ch;
2854 unsigned long flags = 0;
2855 2513
2856 IWL_DEBUG_MAC80211(priv, "enter\n"); 2514 IWL_DEBUG_MAC80211(priv, "enter\n");
2857 2515
@@ -2868,64 +2526,64 @@ void iwl4965_mac_channel_switch(struct ieee80211_hw *hw,
2868 if (!iwl_legacy_is_associated_ctx(ctx)) 2526 if (!iwl_legacy_is_associated_ctx(ctx))
2869 goto out; 2527 goto out;
2870 2528
2871 if (priv->cfg->ops->lib->set_channel_switch) { 2529 if (!priv->cfg->ops->lib->set_channel_switch)
2530 goto out;
2872 2531
2873 ch = channel->hw_value; 2532 ch = channel->hw_value;
2874 if (le16_to_cpu(ctx->active.channel) != ch) { 2533 if (le16_to_cpu(ctx->active.channel) == ch)
2875 ch_info = iwl_legacy_get_channel_info(priv, 2534 goto out;
2876 channel->band, 2535
2877 ch); 2536 ch_info = iwl_legacy_get_channel_info(priv, channel->band, ch);
2878 if (!iwl_legacy_is_channel_valid(ch_info)) { 2537 if (!iwl_legacy_is_channel_valid(ch_info)) {
2879 IWL_DEBUG_MAC80211(priv, "invalid channel\n"); 2538 IWL_DEBUG_MAC80211(priv, "invalid channel\n");
2880 goto out; 2539 goto out;
2881 } 2540 }
2882 spin_lock_irqsave(&priv->lock, flags); 2541
2883 2542 spin_lock_irq(&priv->lock);
2884 priv->current_ht_config.smps = conf->smps_mode; 2543
2885 2544 priv->current_ht_config.smps = conf->smps_mode;
2886 /* Configure HT40 channels */ 2545
2887 ctx->ht.enabled = conf_is_ht(conf); 2546 /* Configure HT40 channels */
2888 if (ctx->ht.enabled) { 2547 ctx->ht.enabled = conf_is_ht(conf);
2889 if (conf_is_ht40_minus(conf)) { 2548 if (ctx->ht.enabled) {
2890 ctx->ht.extension_chan_offset = 2549 if (conf_is_ht40_minus(conf)) {
2891 IEEE80211_HT_PARAM_CHA_SEC_BELOW; 2550 ctx->ht.extension_chan_offset =
2892 ctx->ht.is_40mhz = true; 2551 IEEE80211_HT_PARAM_CHA_SEC_BELOW;
2893 } else if (conf_is_ht40_plus(conf)) { 2552 ctx->ht.is_40mhz = true;
2894 ctx->ht.extension_chan_offset = 2553 } else if (conf_is_ht40_plus(conf)) {
2895 IEEE80211_HT_PARAM_CHA_SEC_ABOVE; 2554 ctx->ht.extension_chan_offset =
2896 ctx->ht.is_40mhz = true; 2555 IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
2897 } else { 2556 ctx->ht.is_40mhz = true;
2898 ctx->ht.extension_chan_offset = 2557 } else {
2899 IEEE80211_HT_PARAM_CHA_SEC_NONE; 2558 ctx->ht.extension_chan_offset =
2900 ctx->ht.is_40mhz = false; 2559 IEEE80211_HT_PARAM_CHA_SEC_NONE;
2901 } 2560 ctx->ht.is_40mhz = false;
2902 } else
2903 ctx->ht.is_40mhz = false;
2904
2905 if ((le16_to_cpu(ctx->staging.channel) != ch))
2906 ctx->staging.flags = 0;
2907
2908 iwl_legacy_set_rxon_channel(priv, channel, ctx);
2909 iwl_legacy_set_rxon_ht(priv, ht_conf);
2910 iwl_legacy_set_flags_for_band(priv, ctx, channel->band,
2911 ctx->vif);
2912 spin_unlock_irqrestore(&priv->lock, flags);
2913
2914 iwl_legacy_set_rate(priv);
2915 /*
2916 * at this point, staging_rxon has the
2917 * configuration for channel switch
2918 */
2919 set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
2920 priv->switch_channel = cpu_to_le16(ch);
2921 if (priv->cfg->ops->lib->set_channel_switch(priv, ch_switch)) {
2922 clear_bit(STATUS_CHANNEL_SWITCH_PENDING,
2923 &priv->status);
2924 priv->switch_channel = 0;
2925 ieee80211_chswitch_done(ctx->vif, false);
2926 }
2927 } 2561 }
2562 } else
2563 ctx->ht.is_40mhz = false;
2564
2565 if ((le16_to_cpu(ctx->staging.channel) != ch))
2566 ctx->staging.flags = 0;
2567
2568 iwl_legacy_set_rxon_channel(priv, channel, ctx);
2569 iwl_legacy_set_rxon_ht(priv, ht_conf);
2570 iwl_legacy_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
2571
2572 spin_unlock_irq(&priv->lock);
2573
2574 iwl_legacy_set_rate(priv);
2575 /*
2576 * at this point, staging_rxon has the
2577 * configuration for channel switch
2578 */
2579 set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
2580 priv->switch_channel = cpu_to_le16(ch);
2581 if (priv->cfg->ops->lib->set_channel_switch(priv, ch_switch)) {
2582 clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
2583 priv->switch_channel = 0;
2584 ieee80211_chswitch_done(ctx->vif, false);
2928 } 2585 }
2586
2929out: 2587out:
2930 mutex_unlock(&priv->mutex); 2588 mutex_unlock(&priv->mutex);
2931 IWL_DEBUG_MAC80211(priv, "leave\n"); 2589 IWL_DEBUG_MAC80211(priv, "leave\n");
@@ -3034,10 +2692,6 @@ static void iwl4965_setup_deferred_work(struct iwl_priv *priv)
3034 priv->statistics_periodic.data = (unsigned long)priv; 2692 priv->statistics_periodic.data = (unsigned long)priv;
3035 priv->statistics_periodic.function = iwl4965_bg_statistics_periodic; 2693 priv->statistics_periodic.function = iwl4965_bg_statistics_periodic;
3036 2694
3037 init_timer(&priv->ucode_trace);
3038 priv->ucode_trace.data = (unsigned long)priv;
3039 priv->ucode_trace.function = iwl4965_bg_ucode_trace;
3040
3041 init_timer(&priv->watchdog); 2695 init_timer(&priv->watchdog);
3042 priv->watchdog.data = (unsigned long)priv; 2696 priv->watchdog.data = (unsigned long)priv;
3043 priv->watchdog.function = iwl_legacy_bg_watchdog; 2697 priv->watchdog.function = iwl_legacy_bg_watchdog;
@@ -3056,7 +2710,6 @@ static void iwl4965_cancel_deferred_work(struct iwl_priv *priv)
3056 iwl_legacy_cancel_scan_deferred_work(priv); 2710 iwl_legacy_cancel_scan_deferred_work(priv);
3057 2711
3058 del_timer_sync(&priv->statistics_periodic); 2712 del_timer_sync(&priv->statistics_periodic);
3059 del_timer_sync(&priv->ucode_trace);
3060} 2713}
3061 2714
3062static void iwl4965_init_hw_rates(struct iwl_priv *priv, 2715static void iwl4965_init_hw_rates(struct iwl_priv *priv,
@@ -3132,13 +2785,9 @@ static int iwl4965_init_drv(struct iwl_priv *priv)
3132 priv->iw_mode = NL80211_IFTYPE_STATION; 2785 priv->iw_mode = NL80211_IFTYPE_STATION;
3133 priv->current_ht_config.smps = IEEE80211_SMPS_STATIC; 2786 priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
3134 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF; 2787 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
3135 priv->_4965.agg_tids_count = 0;
3136 2788
3137 /* initialize force reset */ 2789 /* initialize force reset */
3138 priv->force_reset[IWL_RF_RESET].reset_duration = 2790 priv->force_reset.reset_duration = IWL_DELAY_NEXT_FORCE_FW_RELOAD;
3139 IWL_DELAY_NEXT_FORCE_RF_RESET;
3140 priv->force_reset[IWL_FW_RESET].reset_duration =
3141 IWL_DELAY_NEXT_FORCE_FW_RELOAD;
3142 2791
3143 /* Choose which receivers/antennas to use */ 2792 /* Choose which receivers/antennas to use */
3144 if (priv->cfg->ops->hcmd->set_rxon_chain) 2793 if (priv->cfg->ops->hcmd->set_rxon_chain)
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-24 23:15:12 -0400