diff options
author | Johannes Berg <johannes.berg@intel.com> | 2010-04-06 07:12:42 -0400 |
---|---|---|
committer | Reinette Chatre <reinette.chatre@intel.com> | 2010-04-16 16:47:37 -0400 |
commit | b6e4c55aaee4fd40526a6816e60c68dd62e565c4 (patch) | |
tree | 64bbff3fc159290e41173d0a227375eafe941943 | |
parent | 811ecc995b18eb58067ffa75b961ece3b84a1f03 (diff) |
iwlwifi: trigger scan synchronously
Scan requesting doesn't need to be asynchronous
since all code paths leading up to it can sleep.
Make the scan request a new util operation that
is hw-specific (to account for 3945 vs. agn)
and call it right in place.
This patch moves a lot of code into iwlagn as
it need not be in iwlcore.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-3945.c | 1 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-3945.h | 3 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-4965.c | 1 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c | 1 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-agn-lib.c | 395 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-agn.h | 3 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-core.h | 2 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-dev.h | 1 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl-scan.c | 418 | ||||
-rw-r--r-- | drivers/net/wireless/iwlwifi/iwl3945-base.c | 10 |
10 files changed, 416 insertions, 419 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c index 15de649888d8..51f18950f077 100644 --- a/drivers/net/wireless/iwlwifi/iwl-3945.c +++ b/drivers/net/wireless/iwlwifi/iwl-3945.c | |||
@@ -2740,6 +2740,7 @@ static struct iwl_hcmd_utils_ops iwl3945_hcmd_utils = { | |||
2740 | .get_hcmd_size = iwl3945_get_hcmd_size, | 2740 | .get_hcmd_size = iwl3945_get_hcmd_size, |
2741 | .build_addsta_hcmd = iwl3945_build_addsta_hcmd, | 2741 | .build_addsta_hcmd = iwl3945_build_addsta_hcmd, |
2742 | .rts_tx_cmd_flag = iwlcore_rts_tx_cmd_flag, | 2742 | .rts_tx_cmd_flag = iwlcore_rts_tx_cmd_flag, |
2743 | .request_scan = iwl3945_request_scan, | ||
2743 | }; | 2744 | }; |
2744 | 2745 | ||
2745 | static const struct iwl_ops iwl3945_ops = { | 2746 | static const struct iwl_ops iwl3945_ops = { |
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.h b/drivers/net/wireless/iwlwifi/iwl-3945.h index b89219573b91..e9674f0a1e94 100644 --- a/drivers/net/wireless/iwlwifi/iwl-3945.h +++ b/drivers/net/wireless/iwlwifi/iwl-3945.h | |||
@@ -294,6 +294,9 @@ extern const struct iwl_channel_info *iwl3945_get_channel_info( | |||
294 | 294 | ||
295 | extern int iwl3945_rs_next_rate(struct iwl_priv *priv, int rate); | 295 | extern int iwl3945_rs_next_rate(struct iwl_priv *priv, int rate); |
296 | 296 | ||
297 | /* scanning */ | ||
298 | void iwl3945_request_scan(struct iwl_priv *priv); | ||
299 | |||
297 | /* Requires full declaration of iwl_priv before including */ | 300 | /* Requires full declaration of iwl_priv before including */ |
298 | #include "iwl-io.h" | 301 | #include "iwl-io.h" |
299 | 302 | ||
diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c index 2e3cda75f3ad..0a5f21e14882 100644 --- a/drivers/net/wireless/iwlwifi/iwl-4965.c +++ b/drivers/net/wireless/iwlwifi/iwl-4965.c | |||
@@ -2162,6 +2162,7 @@ static struct iwl_hcmd_utils_ops iwl4965_hcmd_utils = { | |||
2162 | .gain_computation = iwl4965_gain_computation, | 2162 | .gain_computation = iwl4965_gain_computation, |
2163 | .rts_tx_cmd_flag = iwlcore_rts_tx_cmd_flag, | 2163 | .rts_tx_cmd_flag = iwlcore_rts_tx_cmd_flag, |
2164 | .calc_rssi = iwl4965_calc_rssi, | 2164 | .calc_rssi = iwl4965_calc_rssi, |
2165 | .request_scan = iwlagn_request_scan, | ||
2165 | }; | 2166 | }; |
2166 | 2167 | ||
2167 | static struct iwl_lib_ops iwl4965_lib = { | 2168 | static struct iwl_lib_ops iwl4965_lib = { |
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c b/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c index 28bc8f8ba981..231d0e67e6fc 100644 --- a/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c +++ b/drivers/net/wireless/iwlwifi/iwl-agn-hcmd.c | |||
@@ -271,4 +271,5 @@ struct iwl_hcmd_utils_ops iwlagn_hcmd_utils = { | |||
271 | .chain_noise_reset = iwlagn_chain_noise_reset, | 271 | .chain_noise_reset = iwlagn_chain_noise_reset, |
272 | .rts_tx_cmd_flag = iwlagn_rts_tx_cmd_flag, | 272 | .rts_tx_cmd_flag = iwlagn_rts_tx_cmd_flag, |
273 | .calc_rssi = iwlagn_calc_rssi, | 273 | .calc_rssi = iwlagn_calc_rssi, |
274 | .request_scan = iwlagn_request_scan, | ||
274 | }; | 275 | }; |
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-lib.c b/drivers/net/wireless/iwlwifi/iwl-agn-lib.c index c465c8590833..048c6156d3be 100644 --- a/drivers/net/wireless/iwlwifi/iwl-agn-lib.c +++ b/drivers/net/wireless/iwlwifi/iwl-agn-lib.c | |||
@@ -1111,3 +1111,398 @@ void iwlagn_rx_reply_rx_phy(struct iwl_priv *priv, | |||
1111 | memcpy(&priv->_agn.last_phy_res, pkt->u.raw, | 1111 | memcpy(&priv->_agn.last_phy_res, pkt->u.raw, |
1112 | sizeof(struct iwl_rx_phy_res)); | 1112 | sizeof(struct iwl_rx_phy_res)); |
1113 | } | 1113 | } |
1114 | |||
1115 | static int iwl_get_single_channel_for_scan(struct iwl_priv *priv, | ||
1116 | enum ieee80211_band band, | ||
1117 | struct iwl_scan_channel *scan_ch) | ||
1118 | { | ||
1119 | const struct ieee80211_supported_band *sband; | ||
1120 | const struct iwl_channel_info *ch_info; | ||
1121 | u16 passive_dwell = 0; | ||
1122 | u16 active_dwell = 0; | ||
1123 | int i, added = 0; | ||
1124 | u16 channel = 0; | ||
1125 | |||
1126 | sband = iwl_get_hw_mode(priv, band); | ||
1127 | if (!sband) { | ||
1128 | IWL_ERR(priv, "invalid band\n"); | ||
1129 | return added; | ||
1130 | } | ||
1131 | |||
1132 | active_dwell = iwl_get_active_dwell_time(priv, band, 0); | ||
1133 | passive_dwell = iwl_get_passive_dwell_time(priv, band); | ||
1134 | |||
1135 | if (passive_dwell <= active_dwell) | ||
1136 | passive_dwell = active_dwell + 1; | ||
1137 | |||
1138 | /* only scan single channel, good enough to reset the RF */ | ||
1139 | /* pick the first valid not in-use channel */ | ||
1140 | if (band == IEEE80211_BAND_5GHZ) { | ||
1141 | for (i = 14; i < priv->channel_count; i++) { | ||
1142 | if (priv->channel_info[i].channel != | ||
1143 | le16_to_cpu(priv->staging_rxon.channel)) { | ||
1144 | channel = priv->channel_info[i].channel; | ||
1145 | ch_info = iwl_get_channel_info(priv, | ||
1146 | band, channel); | ||
1147 | if (is_channel_valid(ch_info)) | ||
1148 | break; | ||
1149 | } | ||
1150 | } | ||
1151 | } else { | ||
1152 | for (i = 0; i < 14; i++) { | ||
1153 | if (priv->channel_info[i].channel != | ||
1154 | le16_to_cpu(priv->staging_rxon.channel)) { | ||
1155 | channel = | ||
1156 | priv->channel_info[i].channel; | ||
1157 | ch_info = iwl_get_channel_info(priv, | ||
1158 | band, channel); | ||
1159 | if (is_channel_valid(ch_info)) | ||
1160 | break; | ||
1161 | } | ||
1162 | } | ||
1163 | } | ||
1164 | if (channel) { | ||
1165 | scan_ch->channel = cpu_to_le16(channel); | ||
1166 | scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE; | ||
1167 | scan_ch->active_dwell = cpu_to_le16(active_dwell); | ||
1168 | scan_ch->passive_dwell = cpu_to_le16(passive_dwell); | ||
1169 | /* Set txpower levels to defaults */ | ||
1170 | scan_ch->dsp_atten = 110; | ||
1171 | if (band == IEEE80211_BAND_5GHZ) | ||
1172 | scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3; | ||
1173 | else | ||
1174 | scan_ch->tx_gain = ((1 << 5) | (5 << 3)); | ||
1175 | added++; | ||
1176 | } else | ||
1177 | IWL_ERR(priv, "no valid channel found\n"); | ||
1178 | return added; | ||
1179 | } | ||
1180 | |||
1181 | static int iwl_get_channels_for_scan(struct iwl_priv *priv, | ||
1182 | enum ieee80211_band band, | ||
1183 | u8 is_active, u8 n_probes, | ||
1184 | struct iwl_scan_channel *scan_ch) | ||
1185 | { | ||
1186 | struct ieee80211_channel *chan; | ||
1187 | const struct ieee80211_supported_band *sband; | ||
1188 | const struct iwl_channel_info *ch_info; | ||
1189 | u16 passive_dwell = 0; | ||
1190 | u16 active_dwell = 0; | ||
1191 | int added, i; | ||
1192 | u16 channel; | ||
1193 | |||
1194 | sband = iwl_get_hw_mode(priv, band); | ||
1195 | if (!sband) | ||
1196 | return 0; | ||
1197 | |||
1198 | active_dwell = iwl_get_active_dwell_time(priv, band, n_probes); | ||
1199 | passive_dwell = iwl_get_passive_dwell_time(priv, band); | ||
1200 | |||
1201 | if (passive_dwell <= active_dwell) | ||
1202 | passive_dwell = active_dwell + 1; | ||
1203 | |||
1204 | for (i = 0, added = 0; i < priv->scan_request->n_channels; i++) { | ||
1205 | chan = priv->scan_request->channels[i]; | ||
1206 | |||
1207 | if (chan->band != band) | ||
1208 | continue; | ||
1209 | |||
1210 | channel = ieee80211_frequency_to_channel(chan->center_freq); | ||
1211 | scan_ch->channel = cpu_to_le16(channel); | ||
1212 | |||
1213 | ch_info = iwl_get_channel_info(priv, band, channel); | ||
1214 | if (!is_channel_valid(ch_info)) { | ||
1215 | IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n", | ||
1216 | channel); | ||
1217 | continue; | ||
1218 | } | ||
1219 | |||
1220 | if (!is_active || is_channel_passive(ch_info) || | ||
1221 | (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) | ||
1222 | scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE; | ||
1223 | else | ||
1224 | scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE; | ||
1225 | |||
1226 | if (n_probes) | ||
1227 | scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes); | ||
1228 | |||
1229 | scan_ch->active_dwell = cpu_to_le16(active_dwell); | ||
1230 | scan_ch->passive_dwell = cpu_to_le16(passive_dwell); | ||
1231 | |||
1232 | /* Set txpower levels to defaults */ | ||
1233 | scan_ch->dsp_atten = 110; | ||
1234 | |||
1235 | /* NOTE: if we were doing 6Mb OFDM for scans we'd use | ||
1236 | * power level: | ||
1237 | * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3; | ||
1238 | */ | ||
1239 | if (band == IEEE80211_BAND_5GHZ) | ||
1240 | scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3; | ||
1241 | else | ||
1242 | scan_ch->tx_gain = ((1 << 5) | (5 << 3)); | ||
1243 | |||
1244 | IWL_DEBUG_SCAN(priv, "Scanning ch=%d prob=0x%X [%s %d]\n", | ||
1245 | channel, le32_to_cpu(scan_ch->type), | ||
1246 | (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ? | ||
1247 | "ACTIVE" : "PASSIVE", | ||
1248 | (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ? | ||
1249 | active_dwell : passive_dwell); | ||
1250 | |||
1251 | scan_ch++; | ||
1252 | added++; | ||
1253 | } | ||
1254 | |||
1255 | IWL_DEBUG_SCAN(priv, "total channels to scan %d\n", added); | ||
1256 | return added; | ||
1257 | } | ||
1258 | |||
1259 | void iwlagn_request_scan(struct iwl_priv *priv) | ||
1260 | { | ||
1261 | struct iwl_host_cmd cmd = { | ||
1262 | .id = REPLY_SCAN_CMD, | ||
1263 | .len = sizeof(struct iwl_scan_cmd), | ||
1264 | .flags = CMD_SIZE_HUGE, | ||
1265 | }; | ||
1266 | struct iwl_scan_cmd *scan; | ||
1267 | struct ieee80211_conf *conf = NULL; | ||
1268 | u32 rate_flags = 0; | ||
1269 | u16 cmd_len; | ||
1270 | u16 rx_chain = 0; | ||
1271 | enum ieee80211_band band; | ||
1272 | u8 n_probes = 0; | ||
1273 | u8 rx_ant = priv->hw_params.valid_rx_ant; | ||
1274 | u8 rate; | ||
1275 | bool is_active = false; | ||
1276 | int chan_mod; | ||
1277 | u8 active_chains; | ||
1278 | |||
1279 | conf = ieee80211_get_hw_conf(priv->hw); | ||
1280 | |||
1281 | cancel_delayed_work(&priv->scan_check); | ||
1282 | |||
1283 | if (!iwl_is_ready(priv)) { | ||
1284 | IWL_WARN(priv, "request scan called when driver not ready.\n"); | ||
1285 | goto done; | ||
1286 | } | ||
1287 | |||
1288 | /* Make sure the scan wasn't canceled before this queued work | ||
1289 | * was given the chance to run... */ | ||
1290 | if (!test_bit(STATUS_SCANNING, &priv->status)) | ||
1291 | goto done; | ||
1292 | |||
1293 | /* This should never be called or scheduled if there is currently | ||
1294 | * a scan active in the hardware. */ | ||
1295 | if (test_bit(STATUS_SCAN_HW, &priv->status)) { | ||
1296 | IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests in parallel. " | ||
1297 | "Ignoring second request.\n"); | ||
1298 | goto done; | ||
1299 | } | ||
1300 | |||
1301 | if (test_bit(STATUS_EXIT_PENDING, &priv->status)) { | ||
1302 | IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n"); | ||
1303 | goto done; | ||
1304 | } | ||
1305 | |||
1306 | if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { | ||
1307 | IWL_DEBUG_HC(priv, "Scan request while abort pending. Queuing.\n"); | ||
1308 | goto done; | ||
1309 | } | ||
1310 | |||
1311 | if (iwl_is_rfkill(priv)) { | ||
1312 | IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n"); | ||
1313 | goto done; | ||
1314 | } | ||
1315 | |||
1316 | if (!test_bit(STATUS_READY, &priv->status)) { | ||
1317 | IWL_DEBUG_HC(priv, "Scan request while uninitialized. Queuing.\n"); | ||
1318 | goto done; | ||
1319 | } | ||
1320 | |||
1321 | if (!priv->scan_cmd) { | ||
1322 | priv->scan_cmd = kmalloc(sizeof(struct iwl_scan_cmd) + | ||
1323 | IWL_MAX_SCAN_SIZE, GFP_KERNEL); | ||
1324 | if (!priv->scan_cmd) { | ||
1325 | IWL_DEBUG_SCAN(priv, | ||
1326 | "fail to allocate memory for scan\n"); | ||
1327 | goto done; | ||
1328 | } | ||
1329 | } | ||
1330 | scan = priv->scan_cmd; | ||
1331 | memset(scan, 0, sizeof(struct iwl_scan_cmd) + IWL_MAX_SCAN_SIZE); | ||
1332 | |||
1333 | scan->quiet_plcp_th = IWL_PLCP_QUIET_THRESH; | ||
1334 | scan->quiet_time = IWL_ACTIVE_QUIET_TIME; | ||
1335 | |||
1336 | if (iwl_is_associated(priv)) { | ||
1337 | u16 interval = 0; | ||
1338 | u32 extra; | ||
1339 | u32 suspend_time = 100; | ||
1340 | u32 scan_suspend_time = 100; | ||
1341 | unsigned long flags; | ||
1342 | |||
1343 | IWL_DEBUG_INFO(priv, "Scanning while associated...\n"); | ||
1344 | spin_lock_irqsave(&priv->lock, flags); | ||
1345 | interval = priv->beacon_int; | ||
1346 | spin_unlock_irqrestore(&priv->lock, flags); | ||
1347 | |||
1348 | scan->suspend_time = 0; | ||
1349 | scan->max_out_time = cpu_to_le32(200 * 1024); | ||
1350 | if (!interval) | ||
1351 | interval = suspend_time; | ||
1352 | |||
1353 | extra = (suspend_time / interval) << 22; | ||
1354 | scan_suspend_time = (extra | | ||
1355 | ((suspend_time % interval) * 1024)); | ||
1356 | scan->suspend_time = cpu_to_le32(scan_suspend_time); | ||
1357 | IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n", | ||
1358 | scan_suspend_time, interval); | ||
1359 | } | ||
1360 | |||
1361 | if (priv->is_internal_short_scan) { | ||
1362 | IWL_DEBUG_SCAN(priv, "Start internal passive scan.\n"); | ||
1363 | } else if (priv->scan_request->n_ssids) { | ||
1364 | int i, p = 0; | ||
1365 | IWL_DEBUG_SCAN(priv, "Kicking off active scan\n"); | ||
1366 | for (i = 0; i < priv->scan_request->n_ssids; i++) { | ||
1367 | /* always does wildcard anyway */ | ||
1368 | if (!priv->scan_request->ssids[i].ssid_len) | ||
1369 | continue; | ||
1370 | scan->direct_scan[p].id = WLAN_EID_SSID; | ||
1371 | scan->direct_scan[p].len = | ||
1372 | priv->scan_request->ssids[i].ssid_len; | ||
1373 | memcpy(scan->direct_scan[p].ssid, | ||
1374 | priv->scan_request->ssids[i].ssid, | ||
1375 | priv->scan_request->ssids[i].ssid_len); | ||
1376 | n_probes++; | ||
1377 | p++; | ||
1378 | } | ||
1379 | is_active = true; | ||
1380 | } else | ||
1381 | IWL_DEBUG_SCAN(priv, "Start passive scan.\n"); | ||
1382 | |||
1383 | scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK; | ||
1384 | scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id; | ||
1385 | scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE; | ||
1386 | |||
1387 | switch (priv->scan_band) { | ||
1388 | case IEEE80211_BAND_2GHZ: | ||
1389 | scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK; | ||
1390 | chan_mod = le32_to_cpu(priv->active_rxon.flags & RXON_FLG_CHANNEL_MODE_MSK) | ||
1391 | >> RXON_FLG_CHANNEL_MODE_POS; | ||
1392 | if (chan_mod == CHANNEL_MODE_PURE_40) { | ||
1393 | rate = IWL_RATE_6M_PLCP; | ||
1394 | } else { | ||
1395 | rate = IWL_RATE_1M_PLCP; | ||
1396 | rate_flags = RATE_MCS_CCK_MSK; | ||
1397 | } | ||
1398 | scan->good_CRC_th = 0; | ||
1399 | break; | ||
1400 | case IEEE80211_BAND_5GHZ: | ||
1401 | rate = IWL_RATE_6M_PLCP; | ||
1402 | /* | ||
1403 | * If active scaning is requested but a certain channel | ||
1404 | * is marked passive, we can do active scanning if we | ||
1405 | * detect transmissions. | ||
1406 | */ | ||
1407 | scan->good_CRC_th = is_active ? IWL_GOOD_CRC_TH : 0; | ||
1408 | |||
1409 | /* Force use of chains B and C (0x6) for scan Rx | ||
1410 | * Avoid A (0x1) for the device has off-channel reception | ||
1411 | * on A-band. | ||
1412 | */ | ||
1413 | if (priv->cfg->off_channel_workaround) | ||
1414 | rx_ant = ANT_BC; | ||
1415 | break; | ||
1416 | default: | ||
1417 | IWL_WARN(priv, "Invalid scan band count\n"); | ||
1418 | goto done; | ||
1419 | } | ||
1420 | |||
1421 | band = priv->scan_band; | ||
1422 | |||
1423 | priv->scan_tx_ant[band] = | ||
1424 | iwl_toggle_tx_ant(priv, priv->scan_tx_ant[band]); | ||
1425 | rate_flags |= iwl_ant_idx_to_flags(priv->scan_tx_ant[band]); | ||
1426 | scan->tx_cmd.rate_n_flags = iwl_hw_set_rate_n_flags(rate, rate_flags); | ||
1427 | |||
1428 | /* In power save mode use one chain, otherwise use all chains */ | ||
1429 | if (test_bit(STATUS_POWER_PMI, &priv->status)) { | ||
1430 | /* rx_ant has been set to all valid chains previously */ | ||
1431 | active_chains = rx_ant & | ||
1432 | ((u8)(priv->chain_noise_data.active_chains)); | ||
1433 | if (!active_chains) | ||
1434 | active_chains = rx_ant; | ||
1435 | |||
1436 | IWL_DEBUG_SCAN(priv, "chain_noise_data.active_chains: %u\n", | ||
1437 | priv->chain_noise_data.active_chains); | ||
1438 | |||
1439 | rx_ant = first_antenna(active_chains); | ||
1440 | } | ||
1441 | /* MIMO is not used here, but value is required */ | ||
1442 | rx_chain |= priv->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS; | ||
1443 | rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS; | ||
1444 | rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS; | ||
1445 | rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS; | ||
1446 | scan->rx_chain = cpu_to_le16(rx_chain); | ||
1447 | if (!priv->is_internal_short_scan) { | ||
1448 | cmd_len = iwl_fill_probe_req(priv, | ||
1449 | (struct ieee80211_mgmt *)scan->data, | ||
1450 | priv->scan_request->ie, | ||
1451 | priv->scan_request->ie_len, | ||
1452 | IWL_MAX_SCAN_SIZE - sizeof(*scan)); | ||
1453 | } else { | ||
1454 | cmd_len = iwl_fill_probe_req(priv, | ||
1455 | (struct ieee80211_mgmt *)scan->data, | ||
1456 | NULL, 0, | ||
1457 | IWL_MAX_SCAN_SIZE - sizeof(*scan)); | ||
1458 | |||
1459 | } | ||
1460 | scan->tx_cmd.len = cpu_to_le16(cmd_len); | ||
1461 | if (iwl_is_monitor_mode(priv)) | ||
1462 | scan->filter_flags = RXON_FILTER_PROMISC_MSK; | ||
1463 | |||
1464 | scan->filter_flags |= (RXON_FILTER_ACCEPT_GRP_MSK | | ||
1465 | RXON_FILTER_BCON_AWARE_MSK); | ||
1466 | |||
1467 | if (priv->is_internal_short_scan) { | ||
1468 | scan->channel_count = | ||
1469 | iwl_get_single_channel_for_scan(priv, band, | ||
1470 | (void *)&scan->data[le16_to_cpu( | ||
1471 | scan->tx_cmd.len)]); | ||
1472 | } else { | ||
1473 | scan->channel_count = | ||
1474 | iwl_get_channels_for_scan(priv, band, | ||
1475 | is_active, n_probes, | ||
1476 | (void *)&scan->data[le16_to_cpu( | ||
1477 | scan->tx_cmd.len)]); | ||
1478 | } | ||
1479 | if (scan->channel_count == 0) { | ||
1480 | IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count); | ||
1481 | goto done; | ||
1482 | } | ||
1483 | |||
1484 | cmd.len += le16_to_cpu(scan->tx_cmd.len) + | ||
1485 | scan->channel_count * sizeof(struct iwl_scan_channel); | ||
1486 | cmd.data = scan; | ||
1487 | scan->len = cpu_to_le16(cmd.len); | ||
1488 | |||
1489 | set_bit(STATUS_SCAN_HW, &priv->status); | ||
1490 | if (iwl_send_cmd_sync(priv, &cmd)) | ||
1491 | goto done; | ||
1492 | |||
1493 | queue_delayed_work(priv->workqueue, &priv->scan_check, | ||
1494 | IWL_SCAN_CHECK_WATCHDOG); | ||
1495 | |||
1496 | return; | ||
1497 | |||
1498 | done: | ||
1499 | /* Cannot perform scan. Make sure we clear scanning | ||
1500 | * bits from status so next scan request can be performed. | ||
1501 | * If we don't clear scanning status bit here all next scan | ||
1502 | * will fail | ||
1503 | */ | ||
1504 | clear_bit(STATUS_SCAN_HW, &priv->status); | ||
1505 | clear_bit(STATUS_SCANNING, &priv->status); | ||
1506 | /* inform mac80211 scan aborted */ | ||
1507 | queue_work(priv->workqueue, &priv->scan_completed); | ||
1508 | } | ||
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.h b/drivers/net/wireless/iwlwifi/iwl-agn.h index 5d3142287e14..cfee9994383e 100644 --- a/drivers/net/wireless/iwlwifi/iwl-agn.h +++ b/drivers/net/wireless/iwlwifi/iwl-agn.h | |||
@@ -171,4 +171,7 @@ static inline bool iwl_is_tx_success(u32 status) | |||
171 | (status == TX_STATUS_DIRECT_DONE); | 171 | (status == TX_STATUS_DIRECT_DONE); |
172 | } | 172 | } |
173 | 173 | ||
174 | /* scan */ | ||
175 | void iwlagn_request_scan(struct iwl_priv *priv); | ||
176 | |||
174 | #endif /* __iwl_agn_h__ */ | 177 | #endif /* __iwl_agn_h__ */ |
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.h b/drivers/net/wireless/iwlwifi/iwl-core.h index 6c3f0127f743..1d91ffdd4203 100644 --- a/drivers/net/wireless/iwlwifi/iwl-core.h +++ b/drivers/net/wireless/iwlwifi/iwl-core.h | |||
@@ -105,6 +105,7 @@ struct iwl_hcmd_utils_ops { | |||
105 | __le32 *tx_flags); | 105 | __le32 *tx_flags); |
106 | int (*calc_rssi)(struct iwl_priv *priv, | 106 | int (*calc_rssi)(struct iwl_priv *priv, |
107 | struct iwl_rx_phy_res *rx_resp); | 107 | struct iwl_rx_phy_res *rx_resp); |
108 | void (*request_scan)(struct iwl_priv *priv); | ||
108 | }; | 109 | }; |
109 | 110 | ||
110 | struct iwl_apm_ops { | 111 | struct iwl_apm_ops { |
@@ -526,6 +527,7 @@ void iwl_setup_scan_deferred_work(struct iwl_priv *priv); | |||
526 | #define IWL_ACTIVE_QUIET_TIME cpu_to_le16(10) /* msec */ | 527 | #define IWL_ACTIVE_QUIET_TIME cpu_to_le16(10) /* msec */ |
527 | #define IWL_PLCP_QUIET_THRESH cpu_to_le16(1) /* packets */ | 528 | #define IWL_PLCP_QUIET_THRESH cpu_to_le16(1) /* packets */ |
528 | 529 | ||
530 | #define IWL_SCAN_CHECK_WATCHDOG (HZ * 7) | ||
529 | 531 | ||
530 | /******************************************************************************* | 532 | /******************************************************************************* |
531 | * Calibrations - implemented in iwl-calib.c | 533 | * Calibrations - implemented in iwl-calib.c |
diff --git a/drivers/net/wireless/iwlwifi/iwl-dev.h b/drivers/net/wireless/iwlwifi/iwl-dev.h index 4007b5785275..dc9d8ae7e26d 100644 --- a/drivers/net/wireless/iwlwifi/iwl-dev.h +++ b/drivers/net/wireless/iwlwifi/iwl-dev.h | |||
@@ -1257,7 +1257,6 @@ struct iwl_priv { | |||
1257 | struct work_struct scan_completed; | 1257 | struct work_struct scan_completed; |
1258 | struct work_struct rx_replenish; | 1258 | struct work_struct rx_replenish; |
1259 | struct work_struct abort_scan; | 1259 | struct work_struct abort_scan; |
1260 | struct work_struct request_scan; | ||
1261 | struct work_struct beacon_update; | 1260 | struct work_struct beacon_update; |
1262 | struct work_struct tt_work; | 1261 | struct work_struct tt_work; |
1263 | struct work_struct ct_enter; | 1262 | struct work_struct ct_enter; |
diff --git a/drivers/net/wireless/iwlwifi/iwl-scan.c b/drivers/net/wireless/iwlwifi/iwl-scan.c index 18b89d3bd88d..92115f59ab85 100644 --- a/drivers/net/wireless/iwlwifi/iwl-scan.c +++ b/drivers/net/wireless/iwlwifi/iwl-scan.c | |||
@@ -284,150 +284,6 @@ u16 iwl_get_passive_dwell_time(struct iwl_priv *priv, | |||
284 | } | 284 | } |
285 | EXPORT_SYMBOL(iwl_get_passive_dwell_time); | 285 | EXPORT_SYMBOL(iwl_get_passive_dwell_time); |
286 | 286 | ||
287 | static int iwl_get_single_channel_for_scan(struct iwl_priv *priv, | ||
288 | enum ieee80211_band band, | ||
289 | struct iwl_scan_channel *scan_ch) | ||
290 | { | ||
291 | const struct ieee80211_supported_band *sband; | ||
292 | const struct iwl_channel_info *ch_info; | ||
293 | u16 passive_dwell = 0; | ||
294 | u16 active_dwell = 0; | ||
295 | int i, added = 0; | ||
296 | u16 channel = 0; | ||
297 | |||
298 | sband = iwl_get_hw_mode(priv, band); | ||
299 | if (!sband) { | ||
300 | IWL_ERR(priv, "invalid band\n"); | ||
301 | return added; | ||
302 | } | ||
303 | |||
304 | active_dwell = iwl_get_active_dwell_time(priv, band, 0); | ||
305 | passive_dwell = iwl_get_passive_dwell_time(priv, band); | ||
306 | |||
307 | if (passive_dwell <= active_dwell) | ||
308 | passive_dwell = active_dwell + 1; | ||
309 | |||
310 | /* only scan single channel, good enough to reset the RF */ | ||
311 | /* pick the first valid not in-use channel */ | ||
312 | if (band == IEEE80211_BAND_5GHZ) { | ||
313 | for (i = 14; i < priv->channel_count; i++) { | ||
314 | if (priv->channel_info[i].channel != | ||
315 | le16_to_cpu(priv->staging_rxon.channel)) { | ||
316 | channel = priv->channel_info[i].channel; | ||
317 | ch_info = iwl_get_channel_info(priv, | ||
318 | band, channel); | ||
319 | if (is_channel_valid(ch_info)) | ||
320 | break; | ||
321 | } | ||
322 | } | ||
323 | } else { | ||
324 | for (i = 0; i < 14; i++) { | ||
325 | if (priv->channel_info[i].channel != | ||
326 | le16_to_cpu(priv->staging_rxon.channel)) { | ||
327 | channel = | ||
328 | priv->channel_info[i].channel; | ||
329 | ch_info = iwl_get_channel_info(priv, | ||
330 | band, channel); | ||
331 | if (is_channel_valid(ch_info)) | ||
332 | break; | ||
333 | } | ||
334 | } | ||
335 | } | ||
336 | if (channel) { | ||
337 | scan_ch->channel = cpu_to_le16(channel); | ||
338 | scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE; | ||
339 | scan_ch->active_dwell = cpu_to_le16(active_dwell); | ||
340 | scan_ch->passive_dwell = cpu_to_le16(passive_dwell); | ||
341 | /* Set txpower levels to defaults */ | ||
342 | scan_ch->dsp_atten = 110; | ||
343 | if (band == IEEE80211_BAND_5GHZ) | ||
344 | scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3; | ||
345 | else | ||
346 | scan_ch->tx_gain = ((1 << 5) | (5 << 3)); | ||
347 | added++; | ||
348 | } else | ||
349 | IWL_ERR(priv, "no valid channel found\n"); | ||
350 | return added; | ||
351 | } | ||
352 | |||
353 | static int iwl_get_channels_for_scan(struct iwl_priv *priv, | ||
354 | enum ieee80211_band band, | ||
355 | u8 is_active, u8 n_probes, | ||
356 | struct iwl_scan_channel *scan_ch) | ||
357 | { | ||
358 | struct ieee80211_channel *chan; | ||
359 | const struct ieee80211_supported_band *sband; | ||
360 | const struct iwl_channel_info *ch_info; | ||
361 | u16 passive_dwell = 0; | ||
362 | u16 active_dwell = 0; | ||
363 | int added, i; | ||
364 | u16 channel; | ||
365 | |||
366 | sband = iwl_get_hw_mode(priv, band); | ||
367 | if (!sband) | ||
368 | return 0; | ||
369 | |||
370 | active_dwell = iwl_get_active_dwell_time(priv, band, n_probes); | ||
371 | passive_dwell = iwl_get_passive_dwell_time(priv, band); | ||
372 | |||
373 | if (passive_dwell <= active_dwell) | ||
374 | passive_dwell = active_dwell + 1; | ||
375 | |||
376 | for (i = 0, added = 0; i < priv->scan_request->n_channels; i++) { | ||
377 | chan = priv->scan_request->channels[i]; | ||
378 | |||
379 | if (chan->band != band) | ||
380 | continue; | ||
381 | |||
382 | channel = ieee80211_frequency_to_channel(chan->center_freq); | ||
383 | scan_ch->channel = cpu_to_le16(channel); | ||
384 | |||
385 | ch_info = iwl_get_channel_info(priv, band, channel); | ||
386 | if (!is_channel_valid(ch_info)) { | ||
387 | IWL_DEBUG_SCAN(priv, "Channel %d is INVALID for this band.\n", | ||
388 | channel); | ||
389 | continue; | ||
390 | } | ||
391 | |||
392 | if (!is_active || is_channel_passive(ch_info) || | ||
393 | (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)) | ||
394 | scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE; | ||
395 | else | ||
396 | scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE; | ||
397 | |||
398 | if (n_probes) | ||
399 | scan_ch->type |= IWL_SCAN_PROBE_MASK(n_probes); | ||
400 | |||
401 | scan_ch->active_dwell = cpu_to_le16(active_dwell); | ||
402 | scan_ch->passive_dwell = cpu_to_le16(passive_dwell); | ||
403 | |||
404 | /* Set txpower levels to defaults */ | ||
405 | scan_ch->dsp_atten = 110; | ||
406 | |||
407 | /* NOTE: if we were doing 6Mb OFDM for scans we'd use | ||
408 | * power level: | ||
409 | * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3; | ||
410 | */ | ||
411 | if (band == IEEE80211_BAND_5GHZ) | ||
412 | scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3; | ||
413 | else | ||
414 | scan_ch->tx_gain = ((1 << 5) | (5 << 3)); | ||
415 | |||
416 | IWL_DEBUG_SCAN(priv, "Scanning ch=%d prob=0x%X [%s %d]\n", | ||
417 | channel, le32_to_cpu(scan_ch->type), | ||
418 | (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ? | ||
419 | "ACTIVE" : "PASSIVE", | ||
420 | (scan_ch->type & SCAN_CHANNEL_TYPE_ACTIVE) ? | ||
421 | active_dwell : passive_dwell); | ||
422 | |||
423 | scan_ch++; | ||
424 | added++; | ||
425 | } | ||
426 | |||
427 | IWL_DEBUG_SCAN(priv, "total channels to scan %d\n", added); | ||
428 | return added; | ||
429 | } | ||
430 | |||
431 | void iwl_init_scan_params(struct iwl_priv *priv) | 287 | void iwl_init_scan_params(struct iwl_priv *priv) |
432 | { | 288 | { |
433 | u8 ant_idx = fls(priv->hw_params.valid_tx_ant) - 1; | 289 | u8 ant_idx = fls(priv->hw_params.valid_tx_ant) - 1; |
@@ -447,7 +303,10 @@ static int iwl_scan_initiate(struct iwl_priv *priv) | |||
447 | priv->is_internal_short_scan = false; | 303 | priv->is_internal_short_scan = false; |
448 | priv->scan_start = jiffies; | 304 | priv->scan_start = jiffies; |
449 | 305 | ||
450 | queue_work(priv->workqueue, &priv->request_scan); | 306 | if (WARN_ON(!priv->cfg->ops->utils->request_scan)) |
307 | return -EOPNOTSUPP; | ||
308 | |||
309 | priv->cfg->ops->utils->request_scan(priv); | ||
451 | 310 | ||
452 | return 0; | 311 | return 0; |
453 | } | 312 | } |
@@ -455,7 +314,6 @@ static int iwl_scan_initiate(struct iwl_priv *priv) | |||
455 | int iwl_mac_hw_scan(struct ieee80211_hw *hw, | 314 | int iwl_mac_hw_scan(struct ieee80211_hw *hw, |
456 | struct cfg80211_scan_request *req) | 315 | struct cfg80211_scan_request *req) |
457 | { | 316 | { |
458 | unsigned long flags; | ||
459 | struct iwl_priv *priv = hw->priv; | 317 | struct iwl_priv *priv = hw->priv; |
460 | int ret; | 318 | int ret; |
461 | 319 | ||
@@ -465,7 +323,6 @@ int iwl_mac_hw_scan(struct ieee80211_hw *hw, | |||
465 | return -EINVAL; | 323 | return -EINVAL; |
466 | 324 | ||
467 | mutex_lock(&priv->mutex); | 325 | mutex_lock(&priv->mutex); |
468 | spin_lock_irqsave(&priv->lock, flags); | ||
469 | 326 | ||
470 | if (!iwl_is_ready_rf(priv)) { | 327 | if (!iwl_is_ready_rf(priv)) { |
471 | ret = -EIO; | 328 | ret = -EIO; |
@@ -494,7 +351,6 @@ int iwl_mac_hw_scan(struct ieee80211_hw *hw, | |||
494 | IWL_DEBUG_MAC80211(priv, "leave\n"); | 351 | IWL_DEBUG_MAC80211(priv, "leave\n"); |
495 | 352 | ||
496 | out_unlock: | 353 | out_unlock: |
497 | spin_unlock_irqrestore(&priv->lock, flags); | ||
498 | mutex_unlock(&priv->mutex); | 354 | mutex_unlock(&priv->mutex); |
499 | 355 | ||
500 | return ret; | 356 | return ret; |
@@ -537,13 +393,15 @@ static void iwl_bg_start_internal_scan(struct work_struct *work) | |||
537 | IWL_DEBUG_SCAN(priv, "Start internal short scan...\n"); | 393 | IWL_DEBUG_SCAN(priv, "Start internal short scan...\n"); |
538 | set_bit(STATUS_SCANNING, &priv->status); | 394 | set_bit(STATUS_SCANNING, &priv->status); |
539 | priv->is_internal_short_scan = true; | 395 | priv->is_internal_short_scan = true; |
540 | queue_work(priv->workqueue, &priv->request_scan); | 396 | |
397 | if (WARN_ON(!priv->cfg->ops->utils->request_scan)) | ||
398 | goto unlock; | ||
399 | |||
400 | priv->cfg->ops->utils->request_scan(priv); | ||
541 | unlock: | 401 | unlock: |
542 | mutex_unlock(&priv->mutex); | 402 | mutex_unlock(&priv->mutex); |
543 | } | 403 | } |
544 | 404 | ||
545 | #define IWL_SCAN_CHECK_WATCHDOG (7 * HZ) | ||
546 | |||
547 | void iwl_bg_scan_check(struct work_struct *data) | 405 | void iwl_bg_scan_check(struct work_struct *data) |
548 | { | 406 | { |
549 | struct iwl_priv *priv = | 407 | struct iwl_priv *priv = |
@@ -614,263 +472,6 @@ u16 iwl_fill_probe_req(struct iwl_priv *priv, struct ieee80211_mgmt *frame, | |||
614 | } | 472 | } |
615 | EXPORT_SYMBOL(iwl_fill_probe_req); | 473 | EXPORT_SYMBOL(iwl_fill_probe_req); |
616 | 474 | ||
617 | static void iwl_bg_request_scan(struct work_struct *data) | ||
618 | { | ||
619 | struct iwl_priv *priv = | ||
620 | container_of(data, struct iwl_priv, request_scan); | ||
621 | struct iwl_host_cmd cmd = { | ||
622 | .id = REPLY_SCAN_CMD, | ||
623 | .len = sizeof(struct iwl_scan_cmd), | ||
624 | .flags = CMD_SIZE_HUGE, | ||
625 | }; | ||
626 | struct iwl_scan_cmd *scan; | ||
627 | struct ieee80211_conf *conf = NULL; | ||
628 | u32 rate_flags = 0; | ||
629 | u16 cmd_len; | ||
630 | u16 rx_chain = 0; | ||
631 | enum ieee80211_band band; | ||
632 | u8 n_probes = 0; | ||
633 | u8 rx_ant = priv->hw_params.valid_rx_ant; | ||
634 | u8 rate; | ||
635 | bool is_active = false; | ||
636 | int chan_mod; | ||
637 | u8 active_chains; | ||
638 | |||
639 | conf = ieee80211_get_hw_conf(priv->hw); | ||
640 | |||
641 | mutex_lock(&priv->mutex); | ||
642 | |||
643 | cancel_delayed_work(&priv->scan_check); | ||
644 | |||
645 | if (!iwl_is_ready(priv)) { | ||
646 | IWL_WARN(priv, "request scan called when driver not ready.\n"); | ||
647 | goto done; | ||
648 | } | ||
649 | |||
650 | /* Make sure the scan wasn't canceled before this queued work | ||
651 | * was given the chance to run... */ | ||
652 | if (!test_bit(STATUS_SCANNING, &priv->status)) | ||
653 | goto done; | ||
654 | |||
655 | /* This should never be called or scheduled if there is currently | ||
656 | * a scan active in the hardware. */ | ||
657 | if (test_bit(STATUS_SCAN_HW, &priv->status)) { | ||
658 | IWL_DEBUG_INFO(priv, "Multiple concurrent scan requests in parallel. " | ||
659 | "Ignoring second request.\n"); | ||
660 | goto done; | ||
661 | } | ||
662 | |||
663 | if (test_bit(STATUS_EXIT_PENDING, &priv->status)) { | ||
664 | IWL_DEBUG_SCAN(priv, "Aborting scan due to device shutdown\n"); | ||
665 | goto done; | ||
666 | } | ||
667 | |||
668 | if (test_bit(STATUS_SCAN_ABORTING, &priv->status)) { | ||
669 | IWL_DEBUG_HC(priv, "Scan request while abort pending. Queuing.\n"); | ||
670 | goto done; | ||
671 | } | ||
672 | |||
673 | if (iwl_is_rfkill(priv)) { | ||
674 | IWL_DEBUG_HC(priv, "Aborting scan due to RF Kill activation\n"); | ||
675 | goto done; | ||
676 | } | ||
677 | |||
678 | if (!test_bit(STATUS_READY, &priv->status)) { | ||
679 | IWL_DEBUG_HC(priv, "Scan request while uninitialized. Queuing.\n"); | ||
680 | goto done; | ||
681 | } | ||
682 | |||
683 | if (!priv->scan_cmd) { | ||
684 | priv->scan_cmd = kmalloc(sizeof(struct iwl_scan_cmd) + | ||
685 | IWL_MAX_SCAN_SIZE, GFP_KERNEL); | ||
686 | if (!priv->scan_cmd) { | ||
687 | IWL_DEBUG_SCAN(priv, | ||
688 | "fail to allocate memory for scan\n"); | ||
689 | goto done; | ||
690 | } | ||
691 | } | ||
692 | scan = priv->scan_cmd; | ||
693 | memset(scan, 0, sizeof(struct iwl_scan_cmd) + IWL_MAX_SCAN_SIZE); | ||
694 | |||
695 | scan->quiet_plcp_th = IWL_PLCP_QUIET_THRESH; | ||
696 | scan->quiet_time = IWL_ACTIVE_QUIET_TIME; | ||
697 | |||
698 | if (iwl_is_associated(priv)) { | ||
699 | u16 interval = 0; | ||
700 | u32 extra; | ||
701 | u32 suspend_time = 100; | ||
702 | u32 scan_suspend_time = 100; | ||
703 | unsigned long flags; | ||
704 | |||
705 | IWL_DEBUG_INFO(priv, "Scanning while associated...\n"); | ||
706 | spin_lock_irqsave(&priv->lock, flags); | ||
707 | interval = priv->beacon_int; | ||
708 | spin_unlock_irqrestore(&priv->lock, flags); | ||
709 | |||
710 | scan->suspend_time = 0; | ||
711 | scan->max_out_time = cpu_to_le32(200 * 1024); | ||
712 | if (!interval) | ||
713 | interval = suspend_time; | ||
714 | |||
715 | extra = (suspend_time / interval) << 22; | ||
716 | scan_suspend_time = (extra | | ||
717 | ((suspend_time % interval) * 1024)); | ||
718 | scan->suspend_time = cpu_to_le32(scan_suspend_time); | ||
719 | IWL_DEBUG_SCAN(priv, "suspend_time 0x%X beacon interval %d\n", | ||
720 | scan_suspend_time, interval); | ||
721 | } | ||
722 | |||
723 | if (priv->is_internal_short_scan) { | ||
724 | IWL_DEBUG_SCAN(priv, "Start internal passive scan.\n"); | ||
725 | } else if (priv->scan_request->n_ssids) { | ||
726 | int i, p = 0; | ||
727 | IWL_DEBUG_SCAN(priv, "Kicking off active scan\n"); | ||
728 | for (i = 0; i < priv->scan_request->n_ssids; i++) { | ||
729 | /* always does wildcard anyway */ | ||
730 | if (!priv->scan_request->ssids[i].ssid_len) | ||
731 | continue; | ||
732 | scan->direct_scan[p].id = WLAN_EID_SSID; | ||
733 | scan->direct_scan[p].len = | ||
734 | priv->scan_request->ssids[i].ssid_len; | ||
735 | memcpy(scan->direct_scan[p].ssid, | ||
736 | priv->scan_request->ssids[i].ssid, | ||
737 | priv->scan_request->ssids[i].ssid_len); | ||
738 | n_probes++; | ||
739 | p++; | ||
740 | } | ||
741 | is_active = true; | ||
742 | } else | ||
743 | IWL_DEBUG_SCAN(priv, "Start passive scan.\n"); | ||
744 | |||
745 | scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK; | ||
746 | scan->tx_cmd.sta_id = priv->hw_params.bcast_sta_id; | ||
747 | scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE; | ||
748 | |||
749 | switch (priv->scan_band) { | ||
750 | case IEEE80211_BAND_2GHZ: | ||
751 | scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK; | ||
752 | chan_mod = le32_to_cpu(priv->active_rxon.flags & RXON_FLG_CHANNEL_MODE_MSK) | ||
753 | >> RXON_FLG_CHANNEL_MODE_POS; | ||
754 | if (chan_mod == CHANNEL_MODE_PURE_40) { | ||
755 | rate = IWL_RATE_6M_PLCP; | ||
756 | } else { | ||
757 | rate = IWL_RATE_1M_PLCP; | ||
758 | rate_flags = RATE_MCS_CCK_MSK; | ||
759 | } | ||
760 | scan->good_CRC_th = 0; | ||
761 | break; | ||
762 | case IEEE80211_BAND_5GHZ: | ||
763 | rate = IWL_RATE_6M_PLCP; | ||
764 | /* | ||
765 | * If active scaning is requested but a certain channel | ||
766 | * is marked passive, we can do active scanning if we | ||
767 | * detect transmissions. | ||
768 | */ | ||
769 | scan->good_CRC_th = is_active ? IWL_GOOD_CRC_TH : 0; | ||
770 | |||
771 | /* Force use of chains B and C (0x6) for scan Rx | ||
772 | * Avoid A (0x1) for the device has off-channel reception | ||
773 | * on A-band. | ||
774 | */ | ||
775 | if (priv->cfg->off_channel_workaround) | ||
776 | rx_ant = ANT_BC; | ||
777 | break; | ||
778 | default: | ||
779 | IWL_WARN(priv, "Invalid scan band count\n"); | ||
780 | goto done; | ||
781 | } | ||
782 | |||
783 | band = priv->scan_band; | ||
784 | |||
785 | priv->scan_tx_ant[band] = | ||
786 | iwl_toggle_tx_ant(priv, priv->scan_tx_ant[band]); | ||
787 | rate_flags |= iwl_ant_idx_to_flags(priv->scan_tx_ant[band]); | ||
788 | scan->tx_cmd.rate_n_flags = iwl_hw_set_rate_n_flags(rate, rate_flags); | ||
789 | |||
790 | /* In power save mode use one chain, otherwise use all chains */ | ||
791 | if (test_bit(STATUS_POWER_PMI, &priv->status)) { | ||
792 | /* rx_ant has been set to all valid chains previously */ | ||
793 | active_chains = rx_ant & | ||
794 | ((u8)(priv->chain_noise_data.active_chains)); | ||
795 | if (!active_chains) | ||
796 | active_chains = rx_ant; | ||
797 | |||
798 | IWL_DEBUG_SCAN(priv, "chain_noise_data.active_chains: %u\n", | ||
799 | priv->chain_noise_data.active_chains); | ||
800 | |||
801 | rx_ant = first_antenna(active_chains); | ||
802 | } | ||
803 | /* MIMO is not used here, but value is required */ | ||
804 | rx_chain |= priv->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS; | ||
805 | rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS; | ||
806 | rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS; | ||
807 | rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS; | ||
808 | scan->rx_chain = cpu_to_le16(rx_chain); | ||
809 | if (!priv->is_internal_short_scan) { | ||
810 | cmd_len = iwl_fill_probe_req(priv, | ||
811 | (struct ieee80211_mgmt *)scan->data, | ||
812 | priv->scan_request->ie, | ||
813 | priv->scan_request->ie_len, | ||
814 | IWL_MAX_SCAN_SIZE - sizeof(*scan)); | ||
815 | } else { | ||
816 | cmd_len = iwl_fill_probe_req(priv, | ||
817 | (struct ieee80211_mgmt *)scan->data, | ||
818 | NULL, 0, | ||
819 | IWL_MAX_SCAN_SIZE - sizeof(*scan)); | ||
820 | |||
821 | } | ||
822 | scan->tx_cmd.len = cpu_to_le16(cmd_len); | ||
823 | if (iwl_is_monitor_mode(priv)) | ||
824 | scan->filter_flags = RXON_FILTER_PROMISC_MSK; | ||
825 | |||
826 | scan->filter_flags |= (RXON_FILTER_ACCEPT_GRP_MSK | | ||
827 | RXON_FILTER_BCON_AWARE_MSK); | ||
828 | |||
829 | if (priv->is_internal_short_scan) { | ||
830 | scan->channel_count = | ||
831 | iwl_get_single_channel_for_scan(priv, band, | ||
832 | (void *)&scan->data[le16_to_cpu( | ||
833 | scan->tx_cmd.len)]); | ||
834 | } else { | ||
835 | scan->channel_count = | ||
836 | iwl_get_channels_for_scan(priv, band, | ||
837 | is_active, n_probes, | ||
838 | (void *)&scan->data[le16_to_cpu( | ||
839 | scan->tx_cmd.len)]); | ||
840 | } | ||
841 | if (scan->channel_count == 0) { | ||
842 | IWL_DEBUG_SCAN(priv, "channel count %d\n", scan->channel_count); | ||
843 | goto done; | ||
844 | } | ||
845 | |||
846 | cmd.len += le16_to_cpu(scan->tx_cmd.len) + | ||
847 | scan->channel_count * sizeof(struct iwl_scan_channel); | ||
848 | cmd.data = scan; | ||
849 | scan->len = cpu_to_le16(cmd.len); | ||
850 | |||
851 | set_bit(STATUS_SCAN_HW, &priv->status); | ||
852 | if (iwl_send_cmd_sync(priv, &cmd)) | ||
853 | goto done; | ||
854 | |||
855 | queue_delayed_work(priv->workqueue, &priv->scan_check, | ||
856 | IWL_SCAN_CHECK_WATCHDOG); | ||
857 | |||
858 | mutex_unlock(&priv->mutex); | ||
859 | return; | ||
860 | |||
861 | done: | ||
862 | /* Cannot perform scan. Make sure we clear scanning | ||
863 | * bits from status so next scan request can be performed. | ||
864 | * If we don't clear scanning status bit here all next scan | ||
865 | * will fail | ||
866 | */ | ||
867 | clear_bit(STATUS_SCAN_HW, &priv->status); | ||
868 | clear_bit(STATUS_SCANNING, &priv->status); | ||
869 | /* inform mac80211 scan aborted */ | ||
870 | queue_work(priv->workqueue, &priv->scan_completed); | ||
871 | mutex_unlock(&priv->mutex); | ||
872 | } | ||
873 | |||
874 | void iwl_bg_abort_scan(struct work_struct *work) | 475 | void iwl_bg_abort_scan(struct work_struct *work) |
875 | { | 476 | { |
876 | struct iwl_priv *priv = container_of(work, struct iwl_priv, abort_scan); | 477 | struct iwl_priv *priv = container_of(work, struct iwl_priv, abort_scan); |
@@ -918,7 +519,6 @@ EXPORT_SYMBOL(iwl_bg_scan_completed); | |||
918 | void iwl_setup_scan_deferred_work(struct iwl_priv *priv) | 519 | void iwl_setup_scan_deferred_work(struct iwl_priv *priv) |
919 | { | 520 | { |
920 | INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed); | 521 | INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed); |
921 | INIT_WORK(&priv->request_scan, iwl_bg_request_scan); | ||
922 | INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan); | 522 | INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan); |
923 | INIT_WORK(&priv->start_internal_scan, iwl_bg_start_internal_scan); | 523 | INIT_WORK(&priv->start_internal_scan, iwl_bg_start_internal_scan); |
924 | INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check); | 524 | INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check); |
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c index 0f773973a4e5..06004d03f20b 100644 --- a/drivers/net/wireless/iwlwifi/iwl3945-base.c +++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c | |||
@@ -2790,11 +2790,8 @@ static void iwl3945_rfkill_poll(struct work_struct *data) | |||
2790 | 2790 | ||
2791 | } | 2791 | } |
2792 | 2792 | ||
2793 | #define IWL_SCAN_CHECK_WATCHDOG (7 * HZ) | 2793 | void iwl3945_request_scan(struct iwl_priv *priv) |
2794 | static void iwl3945_bg_request_scan(struct work_struct *data) | ||
2795 | { | 2794 | { |
2796 | struct iwl_priv *priv = | ||
2797 | container_of(data, struct iwl_priv, request_scan); | ||
2798 | struct iwl_host_cmd cmd = { | 2795 | struct iwl_host_cmd cmd = { |
2799 | .id = REPLY_SCAN_CMD, | 2796 | .id = REPLY_SCAN_CMD, |
2800 | .len = sizeof(struct iwl3945_scan_cmd), | 2797 | .len = sizeof(struct iwl3945_scan_cmd), |
@@ -2808,8 +2805,6 @@ static void iwl3945_bg_request_scan(struct work_struct *data) | |||
2808 | 2805 | ||
2809 | conf = ieee80211_get_hw_conf(priv->hw); | 2806 | conf = ieee80211_get_hw_conf(priv->hw); |
2810 | 2807 | ||
2811 | mutex_lock(&priv->mutex); | ||
2812 | |||
2813 | cancel_delayed_work(&priv->scan_check); | 2808 | cancel_delayed_work(&priv->scan_check); |
2814 | 2809 | ||
2815 | if (!iwl_is_ready(priv)) { | 2810 | if (!iwl_is_ready(priv)) { |
@@ -2992,7 +2987,6 @@ static void iwl3945_bg_request_scan(struct work_struct *data) | |||
2992 | queue_delayed_work(priv->workqueue, &priv->scan_check, | 2987 | queue_delayed_work(priv->workqueue, &priv->scan_check, |
2993 | IWL_SCAN_CHECK_WATCHDOG); | 2988 | IWL_SCAN_CHECK_WATCHDOG); |
2994 | 2989 | ||
2995 | mutex_unlock(&priv->mutex); | ||
2996 | return; | 2990 | return; |
2997 | 2991 | ||
2998 | done: | 2992 | done: |
@@ -3006,7 +3000,6 @@ static void iwl3945_bg_request_scan(struct work_struct *data) | |||
3006 | 3000 | ||
3007 | /* inform mac80211 scan aborted */ | 3001 | /* inform mac80211 scan aborted */ |
3008 | queue_work(priv->workqueue, &priv->scan_completed); | 3002 | queue_work(priv->workqueue, &priv->scan_completed); |
3009 | mutex_unlock(&priv->mutex); | ||
3010 | } | 3003 | } |
3011 | 3004 | ||
3012 | static void iwl3945_bg_restart(struct work_struct *data) | 3005 | static void iwl3945_bg_restart(struct work_struct *data) |
@@ -3785,7 +3778,6 @@ static void iwl3945_setup_deferred_work(struct iwl_priv *priv) | |||
3785 | INIT_DELAYED_WORK(&priv->alive_start, iwl3945_bg_alive_start); | 3778 | INIT_DELAYED_WORK(&priv->alive_start, iwl3945_bg_alive_start); |
3786 | INIT_DELAYED_WORK(&priv->_3945.rfkill_poll, iwl3945_rfkill_poll); | 3779 | INIT_DELAYED_WORK(&priv->_3945.rfkill_poll, iwl3945_rfkill_poll); |
3787 | INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed); | 3780 | INIT_WORK(&priv->scan_completed, iwl_bg_scan_completed); |
3788 | INIT_WORK(&priv->request_scan, iwl3945_bg_request_scan); | ||
3789 | INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan); | 3781 | INIT_WORK(&priv->abort_scan, iwl_bg_abort_scan); |
3790 | INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check); | 3782 | INIT_DELAYED_WORK(&priv->scan_check, iwl_bg_scan_check); |
3791 | 3783 | ||