diff options
author | Stanislaw Gruszka <sgruszka@redhat.com> | 2011-12-23 02:13:41 -0500 |
---|---|---|
committer | John W. Linville <linville@tuxdriver.com> | 2012-01-04 14:30:43 -0500 |
commit | 2b20920d639da3ee275fcc691431b5b3daa9a3e7 (patch) | |
tree | 3666a980006570ff6134eac6d0965f1ccef75584 | |
parent | f6e8cb72ad4b0381d79df4575ec1f5c5df2e73b9 (diff) |
iwlegacy: remove iwl-sta.c
I forgot to remove this file before.
Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
-rw-r--r-- | drivers/net/wireless/iwlegacy/iwl-sta.c | 817 |
1 files changed, 0 insertions, 817 deletions
diff --git a/drivers/net/wireless/iwlegacy/iwl-sta.c b/drivers/net/wireless/iwlegacy/iwl-sta.c deleted file mode 100644 index 75fe315f66b..00000000000 --- a/drivers/net/wireless/iwlegacy/iwl-sta.c +++ /dev/null | |||
@@ -1,817 +0,0 @@ | |||
1 | /****************************************************************************** | ||
2 | * | ||
3 | * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved. | ||
4 | * | ||
5 | * Portions of this file are derived from the ipw3945 project, as well | ||
6 | * as portions of the ieee80211 subsystem header files. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify it | ||
9 | * under the terms of version 2 of the GNU General Public License as | ||
10 | * published by the Free Software Foundation. | ||
11 | * | ||
12 | * This program is distributed in the hope that it will be useful, but WITHOUT | ||
13 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
14 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | ||
15 | * more details. | ||
16 | * | ||
17 | * You should have received a copy of the GNU General Public License along with | ||
18 | * this program; if not, write to the Free Software Foundation, Inc., | ||
19 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA | ||
20 | * | ||
21 | * The full GNU General Public License is included in this distribution in the | ||
22 | * file called LICENSE. | ||
23 | * | ||
24 | * Contact Information: | ||
25 | * Intel Linux Wireless <ilw@linux.intel.com> | ||
26 | * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 | ||
27 | * | ||
28 | *****************************************************************************/ | ||
29 | |||
30 | #include <net/mac80211.h> | ||
31 | #include <linux/etherdevice.h> | ||
32 | #include <linux/sched.h> | ||
33 | #include <linux/lockdep.h> | ||
34 | #include <linux/export.h> | ||
35 | |||
36 | #include "iwl-dev.h" | ||
37 | #include "iwl-core.h" | ||
38 | #include "iwl-sta.h" | ||
39 | |||
40 | /* il->sta_lock must be held */ | ||
41 | static void il_sta_ucode_activate(struct il_priv *il, u8 sta_id) | ||
42 | { | ||
43 | |||
44 | if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE)) | ||
45 | IL_ERR( | ||
46 | "ACTIVATE a non DRIVER active station id %u addr %pM\n", | ||
47 | sta_id, il->stations[sta_id].sta.sta.addr); | ||
48 | |||
49 | if (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) { | ||
50 | D_ASSOC( | ||
51 | "STA id %u addr %pM already present" | ||
52 | " in uCode (according to driver)\n", | ||
53 | sta_id, il->stations[sta_id].sta.sta.addr); | ||
54 | } else { | ||
55 | il->stations[sta_id].used |= IL_STA_UCODE_ACTIVE; | ||
56 | D_ASSOC("Added STA id %u addr %pM to uCode\n", | ||
57 | sta_id, il->stations[sta_id].sta.sta.addr); | ||
58 | } | ||
59 | } | ||
60 | |||
61 | static int il_process_add_sta_resp(struct il_priv *il, | ||
62 | struct il_addsta_cmd *addsta, | ||
63 | struct il_rx_pkt *pkt, | ||
64 | bool sync) | ||
65 | { | ||
66 | u8 sta_id = addsta->sta.sta_id; | ||
67 | unsigned long flags; | ||
68 | int ret = -EIO; | ||
69 | |||
70 | if (pkt->hdr.flags & IL_CMD_FAILED_MSK) { | ||
71 | IL_ERR("Bad return from C_ADD_STA (0x%08X)\n", | ||
72 | pkt->hdr.flags); | ||
73 | return ret; | ||
74 | } | ||
75 | |||
76 | D_INFO("Processing response for adding station %u\n", | ||
77 | sta_id); | ||
78 | |||
79 | spin_lock_irqsave(&il->sta_lock, flags); | ||
80 | |||
81 | switch (pkt->u.add_sta.status) { | ||
82 | case ADD_STA_SUCCESS_MSK: | ||
83 | D_INFO("C_ADD_STA PASSED\n"); | ||
84 | il_sta_ucode_activate(il, sta_id); | ||
85 | ret = 0; | ||
86 | break; | ||
87 | case ADD_STA_NO_ROOM_IN_TBL: | ||
88 | IL_ERR("Adding station %d failed, no room in table.\n", | ||
89 | sta_id); | ||
90 | break; | ||
91 | case ADD_STA_NO_BLOCK_ACK_RESOURCE: | ||
92 | IL_ERR( | ||
93 | "Adding station %d failed, no block ack resource.\n", | ||
94 | sta_id); | ||
95 | break; | ||
96 | case ADD_STA_MODIFY_NON_EXIST_STA: | ||
97 | IL_ERR("Attempting to modify non-existing station %d\n", | ||
98 | sta_id); | ||
99 | break; | ||
100 | default: | ||
101 | D_ASSOC("Received C_ADD_STA:(0x%08X)\n", | ||
102 | pkt->u.add_sta.status); | ||
103 | break; | ||
104 | } | ||
105 | |||
106 | D_INFO("%s station id %u addr %pM\n", | ||
107 | il->stations[sta_id].sta.mode == | ||
108 | STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", | ||
109 | sta_id, il->stations[sta_id].sta.sta.addr); | ||
110 | |||
111 | /* | ||
112 | * XXX: The MAC address in the command buffer is often changed from | ||
113 | * the original sent to the device. That is, the MAC address | ||
114 | * written to the command buffer often is not the same MAC address | ||
115 | * read from the command buffer when the command returns. This | ||
116 | * issue has not yet been resolved and this debugging is left to | ||
117 | * observe the problem. | ||
118 | */ | ||
119 | D_INFO("%s station according to cmd buffer %pM\n", | ||
120 | il->stations[sta_id].sta.mode == | ||
121 | STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", | ||
122 | addsta->sta.addr); | ||
123 | spin_unlock_irqrestore(&il->sta_lock, flags); | ||
124 | |||
125 | return ret; | ||
126 | } | ||
127 | |||
128 | static void il_add_sta_callback(struct il_priv *il, | ||
129 | struct il_device_cmd *cmd, | ||
130 | struct il_rx_pkt *pkt) | ||
131 | { | ||
132 | struct il_addsta_cmd *addsta = | ||
133 | (struct il_addsta_cmd *)cmd->cmd.payload; | ||
134 | |||
135 | il_process_add_sta_resp(il, addsta, pkt, false); | ||
136 | |||
137 | } | ||
138 | |||
139 | int il_send_add_sta(struct il_priv *il, | ||
140 | struct il_addsta_cmd *sta, u8 flags) | ||
141 | { | ||
142 | struct il_rx_pkt *pkt = NULL; | ||
143 | int ret = 0; | ||
144 | u8 data[sizeof(*sta)]; | ||
145 | struct il_host_cmd cmd = { | ||
146 | .id = C_ADD_STA, | ||
147 | .flags = flags, | ||
148 | .data = data, | ||
149 | }; | ||
150 | u8 sta_id __maybe_unused = sta->sta.sta_id; | ||
151 | |||
152 | D_INFO("Adding sta %u (%pM) %ssynchronously\n", | ||
153 | sta_id, sta->sta.addr, flags & CMD_ASYNC ? "a" : ""); | ||
154 | |||
155 | if (flags & CMD_ASYNC) | ||
156 | cmd.callback = il_add_sta_callback; | ||
157 | else { | ||
158 | cmd.flags |= CMD_WANT_SKB; | ||
159 | might_sleep(); | ||
160 | } | ||
161 | |||
162 | cmd.len = il->cfg->ops->utils->build_addsta_hcmd(sta, data); | ||
163 | ret = il_send_cmd(il, &cmd); | ||
164 | |||
165 | if (ret || (flags & CMD_ASYNC)) | ||
166 | return ret; | ||
167 | |||
168 | if (ret == 0) { | ||
169 | pkt = (struct il_rx_pkt *)cmd.reply_page; | ||
170 | ret = il_process_add_sta_resp(il, sta, pkt, true); | ||
171 | } | ||
172 | il_free_pages(il, cmd.reply_page); | ||
173 | |||
174 | return ret; | ||
175 | } | ||
176 | EXPORT_SYMBOL(il_send_add_sta); | ||
177 | |||
178 | static void il_set_ht_add_station(struct il_priv *il, u8 idx, | ||
179 | struct ieee80211_sta *sta, | ||
180 | struct il_rxon_context *ctx) | ||
181 | { | ||
182 | struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap; | ||
183 | __le32 sta_flags; | ||
184 | u8 mimo_ps_mode; | ||
185 | |||
186 | if (!sta || !sta_ht_inf->ht_supported) | ||
187 | goto done; | ||
188 | |||
189 | mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2; | ||
190 | D_ASSOC("spatial multiplexing power save mode: %s\n", | ||
191 | (mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ? | ||
192 | "static" : | ||
193 | (mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ? | ||
194 | "dynamic" : "disabled"); | ||
195 | |||
196 | sta_flags = il->stations[idx].sta.station_flags; | ||
197 | |||
198 | sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK); | ||
199 | |||
200 | switch (mimo_ps_mode) { | ||
201 | case WLAN_HT_CAP_SM_PS_STATIC: | ||
202 | sta_flags |= STA_FLG_MIMO_DIS_MSK; | ||
203 | break; | ||
204 | case WLAN_HT_CAP_SM_PS_DYNAMIC: | ||
205 | sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK; | ||
206 | break; | ||
207 | case WLAN_HT_CAP_SM_PS_DISABLED: | ||
208 | break; | ||
209 | default: | ||
210 | IL_WARN("Invalid MIMO PS mode %d\n", mimo_ps_mode); | ||
211 | break; | ||
212 | } | ||
213 | |||
214 | sta_flags |= cpu_to_le32( | ||
215 | (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS); | ||
216 | |||
217 | sta_flags |= cpu_to_le32( | ||
218 | (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS); | ||
219 | |||
220 | if (il_is_ht40_tx_allowed(il, ctx, &sta->ht_cap)) | ||
221 | sta_flags |= STA_FLG_HT40_EN_MSK; | ||
222 | else | ||
223 | sta_flags &= ~STA_FLG_HT40_EN_MSK; | ||
224 | |||
225 | il->stations[idx].sta.station_flags = sta_flags; | ||
226 | done: | ||
227 | return; | ||
228 | } | ||
229 | |||
230 | /** | ||
231 | * il_prep_station - Prepare station information for addition | ||
232 | * | ||
233 | * should be called with sta_lock held | ||
234 | */ | ||
235 | u8 il_prep_station(struct il_priv *il, struct il_rxon_context *ctx, | ||
236 | const u8 *addr, bool is_ap, struct ieee80211_sta *sta) | ||
237 | { | ||
238 | struct il_station_entry *station; | ||
239 | int i; | ||
240 | u8 sta_id = IL_INVALID_STATION; | ||
241 | u16 rate; | ||
242 | |||
243 | if (is_ap) | ||
244 | sta_id = ctx->ap_sta_id; | ||
245 | else if (is_broadcast_ether_addr(addr)) | ||
246 | sta_id = ctx->bcast_sta_id; | ||
247 | else | ||
248 | for (i = IL_STA_ID; i < il->hw_params.max_stations; i++) { | ||
249 | if (!compare_ether_addr(il->stations[i].sta.sta.addr, | ||
250 | addr)) { | ||
251 | sta_id = i; | ||
252 | break; | ||
253 | } | ||
254 | |||
255 | if (!il->stations[i].used && | ||
256 | sta_id == IL_INVALID_STATION) | ||
257 | sta_id = i; | ||
258 | } | ||
259 | |||
260 | /* | ||
261 | * These two conditions have the same outcome, but keep them | ||
262 | * separate | ||
263 | */ | ||
264 | if (unlikely(sta_id == IL_INVALID_STATION)) | ||
265 | return sta_id; | ||
266 | |||
267 | /* | ||
268 | * uCode is not able to deal with multiple requests to add a | ||
269 | * station. Keep track if one is in progress so that we do not send | ||
270 | * another. | ||
271 | */ | ||
272 | if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) { | ||
273 | D_INFO( | ||
274 | "STA %d already in process of being added.\n", | ||
275 | sta_id); | ||
276 | return sta_id; | ||
277 | } | ||
278 | |||
279 | if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) && | ||
280 | (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE) && | ||
281 | !compare_ether_addr(il->stations[sta_id].sta.sta.addr, addr)) { | ||
282 | D_ASSOC( | ||
283 | "STA %d (%pM) already added, not adding again.\n", | ||
284 | sta_id, addr); | ||
285 | return sta_id; | ||
286 | } | ||
287 | |||
288 | station = &il->stations[sta_id]; | ||
289 | station->used = IL_STA_DRIVER_ACTIVE; | ||
290 | D_ASSOC("Add STA to driver ID %d: %pM\n", | ||
291 | sta_id, addr); | ||
292 | il->num_stations++; | ||
293 | |||
294 | /* Set up the C_ADD_STA command to send to device */ | ||
295 | memset(&station->sta, 0, sizeof(struct il_addsta_cmd)); | ||
296 | memcpy(station->sta.sta.addr, addr, ETH_ALEN); | ||
297 | station->sta.mode = 0; | ||
298 | station->sta.sta.sta_id = sta_id; | ||
299 | station->sta.station_flags = ctx->station_flags; | ||
300 | station->ctxid = ctx->ctxid; | ||
301 | |||
302 | if (sta) { | ||
303 | struct il_station_priv_common *sta_priv; | ||
304 | |||
305 | sta_priv = (void *)sta->drv_priv; | ||
306 | sta_priv->ctx = ctx; | ||
307 | } | ||
308 | |||
309 | /* | ||
310 | * OK to call unconditionally, since local stations (IBSS BSSID | ||
311 | * STA and broadcast STA) pass in a NULL sta, and mac80211 | ||
312 | * doesn't allow HT IBSS. | ||
313 | */ | ||
314 | il_set_ht_add_station(il, sta_id, sta, ctx); | ||
315 | |||
316 | /* 3945 only */ | ||
317 | rate = (il->band == IEEE80211_BAND_5GHZ) ? | ||
318 | RATE_6M_PLCP : RATE_1M_PLCP; | ||
319 | /* Turn on both antennas for the station... */ | ||
320 | station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK); | ||
321 | |||
322 | return sta_id; | ||
323 | |||
324 | } | ||
325 | EXPORT_SYMBOL_GPL(il_prep_station); | ||
326 | |||
327 | #define STA_WAIT_TIMEOUT (HZ/2) | ||
328 | |||
329 | /** | ||
330 | * il_add_station_common - | ||
331 | */ | ||
332 | int | ||
333 | il_add_station_common(struct il_priv *il, | ||
334 | struct il_rxon_context *ctx, | ||
335 | const u8 *addr, bool is_ap, | ||
336 | struct ieee80211_sta *sta, u8 *sta_id_r) | ||
337 | { | ||
338 | unsigned long flags_spin; | ||
339 | int ret = 0; | ||
340 | u8 sta_id; | ||
341 | struct il_addsta_cmd sta_cmd; | ||
342 | |||
343 | *sta_id_r = 0; | ||
344 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
345 | sta_id = il_prep_station(il, ctx, addr, is_ap, sta); | ||
346 | if (sta_id == IL_INVALID_STATION) { | ||
347 | IL_ERR("Unable to prepare station %pM for addition\n", | ||
348 | addr); | ||
349 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
350 | return -EINVAL; | ||
351 | } | ||
352 | |||
353 | /* | ||
354 | * uCode is not able to deal with multiple requests to add a | ||
355 | * station. Keep track if one is in progress so that we do not send | ||
356 | * another. | ||
357 | */ | ||
358 | if (il->stations[sta_id].used & IL_STA_UCODE_INPROGRESS) { | ||
359 | D_INFO( | ||
360 | "STA %d already in process of being added.\n", | ||
361 | sta_id); | ||
362 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
363 | return -EEXIST; | ||
364 | } | ||
365 | |||
366 | if ((il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE) && | ||
367 | (il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) { | ||
368 | D_ASSOC( | ||
369 | "STA %d (%pM) already added, not adding again.\n", | ||
370 | sta_id, addr); | ||
371 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
372 | return -EEXIST; | ||
373 | } | ||
374 | |||
375 | il->stations[sta_id].used |= IL_STA_UCODE_INPROGRESS; | ||
376 | memcpy(&sta_cmd, &il->stations[sta_id].sta, | ||
377 | sizeof(struct il_addsta_cmd)); | ||
378 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
379 | |||
380 | /* Add station to device's station table */ | ||
381 | ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC); | ||
382 | if (ret) { | ||
383 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
384 | IL_ERR("Adding station %pM failed.\n", | ||
385 | il->stations[sta_id].sta.sta.addr); | ||
386 | il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE; | ||
387 | il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS; | ||
388 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
389 | } | ||
390 | *sta_id_r = sta_id; | ||
391 | return ret; | ||
392 | } | ||
393 | EXPORT_SYMBOL(il_add_station_common); | ||
394 | |||
395 | /** | ||
396 | * il_sta_ucode_deactivate - deactivate ucode status for a station | ||
397 | * | ||
398 | * il->sta_lock must be held | ||
399 | */ | ||
400 | static void il_sta_ucode_deactivate(struct il_priv *il, u8 sta_id) | ||
401 | { | ||
402 | /* Ucode must be active and driver must be non active */ | ||
403 | if ((il->stations[sta_id].used & | ||
404 | (IL_STA_UCODE_ACTIVE | IL_STA_DRIVER_ACTIVE)) != | ||
405 | IL_STA_UCODE_ACTIVE) | ||
406 | IL_ERR("removed non active STA %u\n", sta_id); | ||
407 | |||
408 | il->stations[sta_id].used &= ~IL_STA_UCODE_ACTIVE; | ||
409 | |||
410 | memset(&il->stations[sta_id], 0, sizeof(struct il_station_entry)); | ||
411 | D_ASSOC("Removed STA %u\n", sta_id); | ||
412 | } | ||
413 | |||
414 | static int il_send_remove_station(struct il_priv *il, | ||
415 | const u8 *addr, int sta_id, | ||
416 | bool temporary) | ||
417 | { | ||
418 | struct il_rx_pkt *pkt; | ||
419 | int ret; | ||
420 | |||
421 | unsigned long flags_spin; | ||
422 | struct il_rem_sta_cmd rm_sta_cmd; | ||
423 | |||
424 | struct il_host_cmd cmd = { | ||
425 | .id = C_REM_STA, | ||
426 | .len = sizeof(struct il_rem_sta_cmd), | ||
427 | .flags = CMD_SYNC, | ||
428 | .data = &rm_sta_cmd, | ||
429 | }; | ||
430 | |||
431 | memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd)); | ||
432 | rm_sta_cmd.num_sta = 1; | ||
433 | memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN); | ||
434 | |||
435 | cmd.flags |= CMD_WANT_SKB; | ||
436 | |||
437 | ret = il_send_cmd(il, &cmd); | ||
438 | |||
439 | if (ret) | ||
440 | return ret; | ||
441 | |||
442 | pkt = (struct il_rx_pkt *)cmd.reply_page; | ||
443 | if (pkt->hdr.flags & IL_CMD_FAILED_MSK) { | ||
444 | IL_ERR("Bad return from C_REM_STA (0x%08X)\n", | ||
445 | pkt->hdr.flags); | ||
446 | ret = -EIO; | ||
447 | } | ||
448 | |||
449 | if (!ret) { | ||
450 | switch (pkt->u.rem_sta.status) { | ||
451 | case REM_STA_SUCCESS_MSK: | ||
452 | if (!temporary) { | ||
453 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
454 | il_sta_ucode_deactivate(il, sta_id); | ||
455 | spin_unlock_irqrestore(&il->sta_lock, | ||
456 | flags_spin); | ||
457 | } | ||
458 | D_ASSOC("C_REM_STA PASSED\n"); | ||
459 | break; | ||
460 | default: | ||
461 | ret = -EIO; | ||
462 | IL_ERR("C_REM_STA failed\n"); | ||
463 | break; | ||
464 | } | ||
465 | } | ||
466 | il_free_pages(il, cmd.reply_page); | ||
467 | |||
468 | return ret; | ||
469 | } | ||
470 | |||
471 | /** | ||
472 | * il_remove_station - Remove driver's knowledge of station. | ||
473 | */ | ||
474 | int il_remove_station(struct il_priv *il, const u8 sta_id, | ||
475 | const u8 *addr) | ||
476 | { | ||
477 | unsigned long flags; | ||
478 | |||
479 | if (!il_is_ready(il)) { | ||
480 | D_INFO( | ||
481 | "Unable to remove station %pM, device not ready.\n", | ||
482 | addr); | ||
483 | /* | ||
484 | * It is typical for stations to be removed when we are | ||
485 | * going down. Return success since device will be down | ||
486 | * soon anyway | ||
487 | */ | ||
488 | return 0; | ||
489 | } | ||
490 | |||
491 | D_ASSOC("Removing STA from driver:%d %pM\n", | ||
492 | sta_id, addr); | ||
493 | |||
494 | if (WARN_ON(sta_id == IL_INVALID_STATION)) | ||
495 | return -EINVAL; | ||
496 | |||
497 | spin_lock_irqsave(&il->sta_lock, flags); | ||
498 | |||
499 | if (!(il->stations[sta_id].used & IL_STA_DRIVER_ACTIVE)) { | ||
500 | D_INFO("Removing %pM but non DRIVER active\n", | ||
501 | addr); | ||
502 | goto out_err; | ||
503 | } | ||
504 | |||
505 | if (!(il->stations[sta_id].used & IL_STA_UCODE_ACTIVE)) { | ||
506 | D_INFO("Removing %pM but non UCODE active\n", | ||
507 | addr); | ||
508 | goto out_err; | ||
509 | } | ||
510 | |||
511 | if (il->stations[sta_id].used & IL_STA_LOCAL) { | ||
512 | kfree(il->stations[sta_id].lq); | ||
513 | il->stations[sta_id].lq = NULL; | ||
514 | } | ||
515 | |||
516 | il->stations[sta_id].used &= ~IL_STA_DRIVER_ACTIVE; | ||
517 | |||
518 | il->num_stations--; | ||
519 | |||
520 | BUG_ON(il->num_stations < 0); | ||
521 | |||
522 | spin_unlock_irqrestore(&il->sta_lock, flags); | ||
523 | |||
524 | return il_send_remove_station(il, addr, sta_id, false); | ||
525 | out_err: | ||
526 | spin_unlock_irqrestore(&il->sta_lock, flags); | ||
527 | return -EINVAL; | ||
528 | } | ||
529 | EXPORT_SYMBOL_GPL(il_remove_station); | ||
530 | |||
531 | /** | ||
532 | * il_clear_ucode_stations - clear ucode station table bits | ||
533 | * | ||
534 | * This function clears all the bits in the driver indicating | ||
535 | * which stations are active in the ucode. Call when something | ||
536 | * other than explicit station management would cause this in | ||
537 | * the ucode, e.g. unassociated RXON. | ||
538 | */ | ||
539 | void il_clear_ucode_stations(struct il_priv *il, | ||
540 | struct il_rxon_context *ctx) | ||
541 | { | ||
542 | int i; | ||
543 | unsigned long flags_spin; | ||
544 | bool cleared = false; | ||
545 | |||
546 | D_INFO("Clearing ucode stations in driver\n"); | ||
547 | |||
548 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
549 | for (i = 0; i < il->hw_params.max_stations; i++) { | ||
550 | if (ctx && ctx->ctxid != il->stations[i].ctxid) | ||
551 | continue; | ||
552 | |||
553 | if (il->stations[i].used & IL_STA_UCODE_ACTIVE) { | ||
554 | D_INFO( | ||
555 | "Clearing ucode active for station %d\n", i); | ||
556 | il->stations[i].used &= ~IL_STA_UCODE_ACTIVE; | ||
557 | cleared = true; | ||
558 | } | ||
559 | } | ||
560 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
561 | |||
562 | if (!cleared) | ||
563 | D_INFO( | ||
564 | "No active stations found to be cleared\n"); | ||
565 | } | ||
566 | EXPORT_SYMBOL(il_clear_ucode_stations); | ||
567 | |||
568 | /** | ||
569 | * il_restore_stations() - Restore driver known stations to device | ||
570 | * | ||
571 | * All stations considered active by driver, but not present in ucode, is | ||
572 | * restored. | ||
573 | * | ||
574 | * Function sleeps. | ||
575 | */ | ||
576 | void | ||
577 | il_restore_stations(struct il_priv *il, struct il_rxon_context *ctx) | ||
578 | { | ||
579 | struct il_addsta_cmd sta_cmd; | ||
580 | struct il_link_quality_cmd lq; | ||
581 | unsigned long flags_spin; | ||
582 | int i; | ||
583 | bool found = false; | ||
584 | int ret; | ||
585 | bool send_lq; | ||
586 | |||
587 | if (!il_is_ready(il)) { | ||
588 | D_INFO( | ||
589 | "Not ready yet, not restoring any stations.\n"); | ||
590 | return; | ||
591 | } | ||
592 | |||
593 | D_ASSOC("Restoring all known stations ... start.\n"); | ||
594 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
595 | for (i = 0; i < il->hw_params.max_stations; i++) { | ||
596 | if (ctx->ctxid != il->stations[i].ctxid) | ||
597 | continue; | ||
598 | if ((il->stations[i].used & IL_STA_DRIVER_ACTIVE) && | ||
599 | !(il->stations[i].used & IL_STA_UCODE_ACTIVE)) { | ||
600 | D_ASSOC("Restoring sta %pM\n", | ||
601 | il->stations[i].sta.sta.addr); | ||
602 | il->stations[i].sta.mode = 0; | ||
603 | il->stations[i].used |= IL_STA_UCODE_INPROGRESS; | ||
604 | found = true; | ||
605 | } | ||
606 | } | ||
607 | |||
608 | for (i = 0; i < il->hw_params.max_stations; i++) { | ||
609 | if ((il->stations[i].used & IL_STA_UCODE_INPROGRESS)) { | ||
610 | memcpy(&sta_cmd, &il->stations[i].sta, | ||
611 | sizeof(struct il_addsta_cmd)); | ||
612 | send_lq = false; | ||
613 | if (il->stations[i].lq) { | ||
614 | memcpy(&lq, il->stations[i].lq, | ||
615 | sizeof(struct il_link_quality_cmd)); | ||
616 | send_lq = true; | ||
617 | } | ||
618 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
619 | ret = il_send_add_sta(il, &sta_cmd, CMD_SYNC); | ||
620 | if (ret) { | ||
621 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
622 | IL_ERR("Adding station %pM failed.\n", | ||
623 | il->stations[i].sta.sta.addr); | ||
624 | il->stations[i].used &= | ||
625 | ~IL_STA_DRIVER_ACTIVE; | ||
626 | il->stations[i].used &= | ||
627 | ~IL_STA_UCODE_INPROGRESS; | ||
628 | spin_unlock_irqrestore(&il->sta_lock, | ||
629 | flags_spin); | ||
630 | } | ||
631 | /* | ||
632 | * Rate scaling has already been initialized, send | ||
633 | * current LQ command | ||
634 | */ | ||
635 | if (send_lq) | ||
636 | il_send_lq_cmd(il, ctx, &lq, | ||
637 | CMD_SYNC, true); | ||
638 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
639 | il->stations[i].used &= ~IL_STA_UCODE_INPROGRESS; | ||
640 | } | ||
641 | } | ||
642 | |||
643 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
644 | if (!found) | ||
645 | D_INFO("Restoring all known stations" | ||
646 | " .... no stations to be restored.\n"); | ||
647 | else | ||
648 | D_INFO("Restoring all known stations" | ||
649 | " .... complete.\n"); | ||
650 | } | ||
651 | EXPORT_SYMBOL(il_restore_stations); | ||
652 | |||
653 | int il_get_free_ucode_key_idx(struct il_priv *il) | ||
654 | { | ||
655 | int i; | ||
656 | |||
657 | for (i = 0; i < il->sta_key_max_num; i++) | ||
658 | if (!test_and_set_bit(i, &il->ucode_key_table)) | ||
659 | return i; | ||
660 | |||
661 | return WEP_INVALID_OFFSET; | ||
662 | } | ||
663 | EXPORT_SYMBOL(il_get_free_ucode_key_idx); | ||
664 | |||
665 | void il_dealloc_bcast_stations(struct il_priv *il) | ||
666 | { | ||
667 | unsigned long flags; | ||
668 | int i; | ||
669 | |||
670 | spin_lock_irqsave(&il->sta_lock, flags); | ||
671 | for (i = 0; i < il->hw_params.max_stations; i++) { | ||
672 | if (!(il->stations[i].used & IL_STA_BCAST)) | ||
673 | continue; | ||
674 | |||
675 | il->stations[i].used &= ~IL_STA_UCODE_ACTIVE; | ||
676 | il->num_stations--; | ||
677 | BUG_ON(il->num_stations < 0); | ||
678 | kfree(il->stations[i].lq); | ||
679 | il->stations[i].lq = NULL; | ||
680 | } | ||
681 | spin_unlock_irqrestore(&il->sta_lock, flags); | ||
682 | } | ||
683 | EXPORT_SYMBOL_GPL(il_dealloc_bcast_stations); | ||
684 | |||
685 | #ifdef CONFIG_IWLEGACY_DEBUG | ||
686 | static void il_dump_lq_cmd(struct il_priv *il, | ||
687 | struct il_link_quality_cmd *lq) | ||
688 | { | ||
689 | int i; | ||
690 | D_RATE("lq station id 0x%x\n", lq->sta_id); | ||
691 | D_RATE("lq ant 0x%X 0x%X\n", | ||
692 | lq->general_params.single_stream_ant_msk, | ||
693 | lq->general_params.dual_stream_ant_msk); | ||
694 | |||
695 | for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) | ||
696 | D_RATE("lq idx %d 0x%X\n", | ||
697 | i, lq->rs_table[i].rate_n_flags); | ||
698 | } | ||
699 | #else | ||
700 | static inline void il_dump_lq_cmd(struct il_priv *il, | ||
701 | struct il_link_quality_cmd *lq) | ||
702 | { | ||
703 | } | ||
704 | #endif | ||
705 | |||
706 | /** | ||
707 | * il_is_lq_table_valid() - Test one aspect of LQ cmd for validity | ||
708 | * | ||
709 | * It sometimes happens when a HT rate has been in use and we | ||
710 | * loose connectivity with AP then mac80211 will first tell us that the | ||
711 | * current channel is not HT anymore before removing the station. In such a | ||
712 | * scenario the RXON flags will be updated to indicate we are not | ||
713 | * communicating HT anymore, but the LQ command may still contain HT rates. | ||
714 | * Test for this to prevent driver from sending LQ command between the time | ||
715 | * RXON flags are updated and when LQ command is updated. | ||
716 | */ | ||
717 | static bool il_is_lq_table_valid(struct il_priv *il, | ||
718 | struct il_rxon_context *ctx, | ||
719 | struct il_link_quality_cmd *lq) | ||
720 | { | ||
721 | int i; | ||
722 | |||
723 | if (ctx->ht.enabled) | ||
724 | return true; | ||
725 | |||
726 | D_INFO("Channel %u is not an HT channel\n", | ||
727 | ctx->active.channel); | ||
728 | for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) { | ||
729 | if (le32_to_cpu(lq->rs_table[i].rate_n_flags) & | ||
730 | RATE_MCS_HT_MSK) { | ||
731 | D_INFO( | ||
732 | "idx %d of LQ expects HT channel\n", | ||
733 | i); | ||
734 | return false; | ||
735 | } | ||
736 | } | ||
737 | return true; | ||
738 | } | ||
739 | |||
740 | /** | ||
741 | * il_send_lq_cmd() - Send link quality command | ||
742 | * @init: This command is sent as part of station initialization right | ||
743 | * after station has been added. | ||
744 | * | ||
745 | * The link quality command is sent as the last step of station creation. | ||
746 | * This is the special case in which init is set and we call a callback in | ||
747 | * this case to clear the state indicating that station creation is in | ||
748 | * progress. | ||
749 | */ | ||
750 | int il_send_lq_cmd(struct il_priv *il, struct il_rxon_context *ctx, | ||
751 | struct il_link_quality_cmd *lq, u8 flags, bool init) | ||
752 | { | ||
753 | int ret = 0; | ||
754 | unsigned long flags_spin; | ||
755 | |||
756 | struct il_host_cmd cmd = { | ||
757 | .id = C_TX_LINK_QUALITY_CMD, | ||
758 | .len = sizeof(struct il_link_quality_cmd), | ||
759 | .flags = flags, | ||
760 | .data = lq, | ||
761 | }; | ||
762 | |||
763 | if (WARN_ON(lq->sta_id == IL_INVALID_STATION)) | ||
764 | return -EINVAL; | ||
765 | |||
766 | |||
767 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
768 | if (!(il->stations[lq->sta_id].used & IL_STA_DRIVER_ACTIVE)) { | ||
769 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
770 | return -EINVAL; | ||
771 | } | ||
772 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
773 | |||
774 | il_dump_lq_cmd(il, lq); | ||
775 | BUG_ON(init && (cmd.flags & CMD_ASYNC)); | ||
776 | |||
777 | if (il_is_lq_table_valid(il, ctx, lq)) | ||
778 | ret = il_send_cmd(il, &cmd); | ||
779 | else | ||
780 | ret = -EINVAL; | ||
781 | |||
782 | if (cmd.flags & CMD_ASYNC) | ||
783 | return ret; | ||
784 | |||
785 | if (init) { | ||
786 | D_INFO("init LQ command complete," | ||
787 | " clearing sta addition status for sta %d\n", | ||
788 | lq->sta_id); | ||
789 | spin_lock_irqsave(&il->sta_lock, flags_spin); | ||
790 | il->stations[lq->sta_id].used &= ~IL_STA_UCODE_INPROGRESS; | ||
791 | spin_unlock_irqrestore(&il->sta_lock, flags_spin); | ||
792 | } | ||
793 | return ret; | ||
794 | } | ||
795 | EXPORT_SYMBOL(il_send_lq_cmd); | ||
796 | |||
797 | int il_mac_sta_remove(struct ieee80211_hw *hw, | ||
798 | struct ieee80211_vif *vif, | ||
799 | struct ieee80211_sta *sta) | ||
800 | { | ||
801 | struct il_priv *il = hw->priv; | ||
802 | struct il_station_priv_common *sta_common = (void *)sta->drv_priv; | ||
803 | int ret; | ||
804 | |||
805 | D_INFO("received request to remove station %pM\n", | ||
806 | sta->addr); | ||
807 | mutex_lock(&il->mutex); | ||
808 | D_INFO("proceeding to remove station %pM\n", | ||
809 | sta->addr); | ||
810 | ret = il_remove_station(il, sta_common->sta_id, sta->addr); | ||
811 | if (ret) | ||
812 | IL_ERR("Error removing station %pM\n", | ||
813 | sta->addr); | ||
814 | mutex_unlock(&il->mutex); | ||
815 | return ret; | ||
816 | } | ||
817 | EXPORT_SYMBOL(il_mac_sta_remove); | ||