Commit | Line | Data |
---|---|---|
6974e363 EG |
1 | /****************************************************************************** |
2 | * | |
1f447808 | 3 | * Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved. |
6974e363 EG |
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: | |
759ef89f | 25 | * Intel Linux Wireless <ilw@linux.intel.com> |
6974e363 EG |
26 | * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 |
27 | * | |
28 | *****************************************************************************/ | |
29 | ||
30 | #include <net/mac80211.h> | |
947b13a7 | 31 | #include <linux/etherdevice.h> |
fe6b23dd | 32 | #include <linux/sched.h> |
4620fefa | 33 | #include <linux/lockdep.h> |
6974e363 | 34 | |
3e0d4cb1 | 35 | #include "iwl-dev.h" |
6974e363 EG |
36 | #include "iwl-core.h" |
37 | #include "iwl-sta.h" | |
7a999bf0 | 38 | |
1fa97aae | 39 | /* priv->sta_lock must be held */ |
24e5c401 EG |
40 | static void iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id) |
41 | { | |
24e5c401 | 42 | |
c587de0b | 43 | if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) |
1fa97aae RC |
44 | IWL_ERR(priv, "ACTIVATE a non DRIVER active station id %u addr %pM\n", |
45 | sta_id, priv->stations[sta_id].sta.sta.addr); | |
24e5c401 | 46 | |
1fa97aae RC |
47 | if (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) { |
48 | IWL_DEBUG_ASSOC(priv, | |
49 | "STA id %u addr %pM already present in uCode (according to driver)\n", | |
50 | sta_id, priv->stations[sta_id].sta.sta.addr); | |
51 | } else { | |
52 | priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE; | |
53 | IWL_DEBUG_ASSOC(priv, "Added STA id %u addr %pM to uCode\n", | |
54 | sta_id, priv->stations[sta_id].sta.sta.addr); | |
55 | } | |
24e5c401 EG |
56 | } |
57 | ||
09034cb7 JB |
58 | static int iwl_process_add_sta_resp(struct iwl_priv *priv, |
59 | struct iwl_addsta_cmd *addsta, | |
60 | struct iwl_rx_packet *pkt, | |
61 | bool sync) | |
42132bce | 62 | { |
3257e5d4 | 63 | u8 sta_id = addsta->sta.sta_id; |
1fa97aae | 64 | unsigned long flags; |
09034cb7 | 65 | int ret = -EIO; |
42132bce | 66 | |
2f301227 | 67 | if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) { |
15b1687c | 68 | IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n", |
1fa97aae | 69 | pkt->hdr.flags); |
09034cb7 | 70 | return ret; |
42132bce TW |
71 | } |
72 | ||
1fa97aae RC |
73 | IWL_DEBUG_INFO(priv, "Processing response for adding station %u\n", |
74 | sta_id); | |
75 | ||
76 | spin_lock_irqsave(&priv->sta_lock, flags); | |
77 | ||
2f301227 | 78 | switch (pkt->u.add_sta.status) { |
42132bce | 79 | case ADD_STA_SUCCESS_MSK: |
1fa97aae | 80 | IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n"); |
24e5c401 | 81 | iwl_sta_ucode_activate(priv, sta_id); |
09034cb7 | 82 | ret = 0; |
1fa97aae RC |
83 | break; |
84 | case ADD_STA_NO_ROOM_IN_TABLE: | |
85 | IWL_ERR(priv, "Adding station %d failed, no room in table.\n", | |
86 | sta_id); | |
87 | break; | |
88 | case ADD_STA_NO_BLOCK_ACK_RESOURCE: | |
89 | IWL_ERR(priv, "Adding station %d failed, no block ack resource.\n", | |
90 | sta_id); | |
91 | break; | |
92 | case ADD_STA_MODIFY_NON_EXIST_STA: | |
91dd6c27 | 93 | IWL_ERR(priv, "Attempting to modify non-existing station %d\n", |
1fa97aae RC |
94 | sta_id); |
95 | break; | |
42132bce | 96 | default: |
1fa97aae RC |
97 | IWL_DEBUG_ASSOC(priv, "Received REPLY_ADD_STA:(0x%08X)\n", |
98 | pkt->u.add_sta.status); | |
42132bce TW |
99 | break; |
100 | } | |
1fa97aae RC |
101 | |
102 | IWL_DEBUG_INFO(priv, "%s station id %u addr %pM\n", | |
103 | priv->stations[sta_id].sta.mode == | |
104 | STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", | |
105 | sta_id, priv->stations[sta_id].sta.sta.addr); | |
106 | ||
107 | /* | |
108 | * XXX: The MAC address in the command buffer is often changed from | |
109 | * the original sent to the device. That is, the MAC address | |
110 | * written to the command buffer often is not the same MAC adress | |
111 | * read from the command buffer when the command returns. This | |
112 | * issue has not yet been resolved and this debugging is left to | |
113 | * observe the problem. | |
114 | */ | |
115 | IWL_DEBUG_INFO(priv, "%s station according to cmd buffer %pM\n", | |
116 | priv->stations[sta_id].sta.mode == | |
117 | STA_CONTROL_MODIFY_MSK ? "Modified" : "Added", | |
118 | addsta->sta.addr); | |
1fa97aae | 119 | spin_unlock_irqrestore(&priv->sta_lock, flags); |
09034cb7 JB |
120 | |
121 | return ret; | |
1fa97aae RC |
122 | } |
123 | ||
124 | static void iwl_add_sta_callback(struct iwl_priv *priv, | |
125 | struct iwl_device_cmd *cmd, | |
126 | struct iwl_rx_packet *pkt) | |
127 | { | |
128 | struct iwl_addsta_cmd *addsta = | |
129 | (struct iwl_addsta_cmd *)cmd->cmd.payload; | |
130 | ||
131 | iwl_process_add_sta_resp(priv, addsta, pkt, false); | |
132 | ||
42132bce TW |
133 | } |
134 | ||
17f841cd | 135 | int iwl_send_add_sta(struct iwl_priv *priv, |
133636de TW |
136 | struct iwl_addsta_cmd *sta, u8 flags) |
137 | { | |
2f301227 | 138 | struct iwl_rx_packet *pkt = NULL; |
133636de TW |
139 | int ret = 0; |
140 | u8 data[sizeof(*sta)]; | |
141 | struct iwl_host_cmd cmd = { | |
142 | .id = REPLY_ADD_STA, | |
c2acea8e | 143 | .flags = flags, |
133636de TW |
144 | .data = data, |
145 | }; | |
f875f518 | 146 | u8 sta_id __maybe_unused = sta->sta.sta_id; |
fe6b23dd RC |
147 | |
148 | IWL_DEBUG_INFO(priv, "Adding sta %u (%pM) %ssynchronously\n", | |
149 | sta_id, sta->sta.addr, flags & CMD_ASYNC ? "a" : ""); | |
133636de | 150 | |
42132bce | 151 | if (flags & CMD_ASYNC) |
c2acea8e | 152 | cmd.callback = iwl_add_sta_callback; |
4620fefa | 153 | else { |
c2acea8e | 154 | cmd.flags |= CMD_WANT_SKB; |
4620fefa JB |
155 | might_sleep(); |
156 | } | |
133636de TW |
157 | |
158 | cmd.len = priv->cfg->ops->utils->build_addsta_hcmd(sta, data); | |
159 | ret = iwl_send_cmd(priv, &cmd); | |
160 | ||
161 | if (ret || (flags & CMD_ASYNC)) | |
162 | return ret; | |
163 | ||
133636de | 164 | if (ret == 0) { |
1fa97aae | 165 | pkt = (struct iwl_rx_packet *)cmd.reply_page; |
09034cb7 | 166 | ret = iwl_process_add_sta_resp(priv, sta, pkt, true); |
133636de | 167 | } |
64a76b50 | 168 | iwl_free_pages(priv, cmd.reply_page); |
133636de TW |
169 | |
170 | return ret; | |
171 | } | |
17f841cd | 172 | EXPORT_SYMBOL(iwl_send_add_sta); |
947b13a7 | 173 | |
4f40e4d9 | 174 | static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index, |
7e6a5886 JB |
175 | struct ieee80211_sta *sta, |
176 | struct iwl_rxon_context *ctx) | |
4f40e4d9 | 177 | { |
238d781d | 178 | struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->ht_cap; |
4f40e4d9 TW |
179 | __le32 sta_flags; |
180 | u8 mimo_ps_mode; | |
181 | ||
238d781d | 182 | if (!sta || !sta_ht_inf->ht_supported) |
4f40e4d9 TW |
183 | goto done; |
184 | ||
00c5ae2f | 185 | mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2; |
3f3e0376 WYG |
186 | IWL_DEBUG_ASSOC(priv, "spatial multiplexing power save mode: %s\n", |
187 | (mimo_ps_mode == WLAN_HT_CAP_SM_PS_STATIC) ? | |
188 | "static" : | |
189 | (mimo_ps_mode == WLAN_HT_CAP_SM_PS_DYNAMIC) ? | |
190 | "dynamic" : "disabled"); | |
4f40e4d9 TW |
191 | |
192 | sta_flags = priv->stations[index].sta.station_flags; | |
193 | ||
194 | sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK); | |
195 | ||
196 | switch (mimo_ps_mode) { | |
00c5ae2f | 197 | case WLAN_HT_CAP_SM_PS_STATIC: |
4f40e4d9 TW |
198 | sta_flags |= STA_FLG_MIMO_DIS_MSK; |
199 | break; | |
00c5ae2f | 200 | case WLAN_HT_CAP_SM_PS_DYNAMIC: |
4f40e4d9 TW |
201 | sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK; |
202 | break; | |
00c5ae2f | 203 | case WLAN_HT_CAP_SM_PS_DISABLED: |
4f40e4d9 TW |
204 | break; |
205 | default: | |
39aadf8c | 206 | IWL_WARN(priv, "Invalid MIMO PS mode %d\n", mimo_ps_mode); |
4f40e4d9 TW |
207 | break; |
208 | } | |
209 | ||
210 | sta_flags |= cpu_to_le32( | |
211 | (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS); | |
212 | ||
213 | sta_flags |= cpu_to_le32( | |
214 | (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS); | |
215 | ||
7e6a5886 | 216 | if (iwl_is_ht40_tx_allowed(priv, ctx, &sta->ht_cap)) |
7aafef1c | 217 | sta_flags |= STA_FLG_HT40_EN_MSK; |
4f40e4d9 | 218 | else |
7aafef1c | 219 | sta_flags &= ~STA_FLG_HT40_EN_MSK; |
4f40e4d9 TW |
220 | |
221 | priv->stations[index].sta.station_flags = sta_flags; | |
222 | done: | |
223 | return; | |
224 | } | |
4f40e4d9 TW |
225 | |
226 | /** | |
fe6b23dd RC |
227 | * iwl_prep_station - Prepare station information for addition |
228 | * | |
229 | * should be called with sta_lock held | |
4f40e4d9 | 230 | */ |
a30e3112 JB |
231 | u8 iwl_prep_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx, |
232 | const u8 *addr, bool is_ap, struct ieee80211_sta *sta) | |
4f40e4d9 | 233 | { |
4f40e4d9 | 234 | struct iwl_station_entry *station; |
c587de0b | 235 | int i; |
fe6b23dd | 236 | u8 sta_id = IWL_INVALID_STATION; |
c587de0b | 237 | u16 rate; |
4f40e4d9 | 238 | |
4f40e4d9 | 239 | if (is_ap) |
2995bafa | 240 | sta_id = ctx->ap_sta_id; |
4f40e4d9 | 241 | else if (is_broadcast_ether_addr(addr)) |
a194e324 | 242 | sta_id = ctx->bcast_sta_id; |
4f40e4d9 TW |
243 | else |
244 | for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) { | |
245 | if (!compare_ether_addr(priv->stations[i].sta.sta.addr, | |
246 | addr)) { | |
24e5c401 | 247 | sta_id = i; |
4f40e4d9 TW |
248 | break; |
249 | } | |
250 | ||
251 | if (!priv->stations[i].used && | |
24e5c401 EG |
252 | sta_id == IWL_INVALID_STATION) |
253 | sta_id = i; | |
4f40e4d9 TW |
254 | } |
255 | ||
fe6b23dd RC |
256 | /* |
257 | * These two conditions have the same outcome, but keep them | |
258 | * separate | |
259 | */ | |
260 | if (unlikely(sta_id == IWL_INVALID_STATION)) | |
261 | return sta_id; | |
262 | ||
263 | /* | |
264 | * uCode is not able to deal with multiple requests to add a | |
265 | * station. Keep track if one is in progress so that we do not send | |
266 | * another. | |
267 | */ | |
268 | if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) { | |
269 | IWL_DEBUG_INFO(priv, "STA %d already in process of being added.\n", | |
270 | sta_id); | |
24e5c401 | 271 | return sta_id; |
4f40e4d9 TW |
272 | } |
273 | ||
fe6b23dd RC |
274 | if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) && |
275 | (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) && | |
24e5c401 | 276 | !compare_ether_addr(priv->stations[sta_id].sta.sta.addr, addr)) { |
fe6b23dd RC |
277 | IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not adding again.\n", |
278 | sta_id, addr); | |
24e5c401 | 279 | return sta_id; |
4f40e4d9 TW |
280 | } |
281 | ||
24e5c401 EG |
282 | station = &priv->stations[sta_id]; |
283 | station->used = IWL_STA_DRIVER_ACTIVE; | |
e1623446 | 284 | IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n", |
e174961c | 285 | sta_id, addr); |
4f40e4d9 TW |
286 | priv->num_stations++; |
287 | ||
288 | /* Set up the REPLY_ADD_STA command to send to device */ | |
289 | memset(&station->sta, 0, sizeof(struct iwl_addsta_cmd)); | |
290 | memcpy(station->sta.sta.addr, addr, ETH_ALEN); | |
291 | station->sta.mode = 0; | |
24e5c401 | 292 | station->sta.sta.sta_id = sta_id; |
770e13bd | 293 | station->sta.station_flags = ctx->station_flags; |
dcef732c | 294 | station->ctxid = ctx->ctxid; |
4f40e4d9 | 295 | |
238d781d JB |
296 | if (sta) { |
297 | struct iwl_station_priv_common *sta_priv; | |
298 | ||
299 | sta_priv = (void *)sta->drv_priv; | |
300 | sta_priv->ctx = ctx; | |
301 | } | |
302 | ||
63d41769 JB |
303 | /* |
304 | * OK to call unconditionally, since local stations (IBSS BSSID | |
238d781d | 305 | * STA and broadcast STA) pass in a NULL sta, and mac80211 |
63d41769 JB |
306 | * doesn't allow HT IBSS. |
307 | */ | |
7e6a5886 | 308 | iwl_set_ht_add_station(priv, sta_id, sta, ctx); |
4f40e4d9 | 309 | |
c587de0b TW |
310 | /* 3945 only */ |
311 | rate = (priv->band == IEEE80211_BAND_5GHZ) ? | |
312 | IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP; | |
313 | /* Turn on both antennas for the station... */ | |
314 | station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK); | |
315 | ||
fe6b23dd RC |
316 | return sta_id; |
317 | ||
318 | } | |
a30e3112 | 319 | EXPORT_SYMBOL_GPL(iwl_prep_station); |
fe6b23dd RC |
320 | |
321 | #define STA_WAIT_TIMEOUT (HZ/2) | |
322 | ||
323 | /** | |
324 | * iwl_add_station_common - | |
325 | */ | |
a194e324 JB |
326 | int iwl_add_station_common(struct iwl_priv *priv, struct iwl_rxon_context *ctx, |
327 | const u8 *addr, bool is_ap, | |
238d781d | 328 | struct ieee80211_sta *sta, u8 *sta_id_r) |
fe6b23dd | 329 | { |
fe6b23dd RC |
330 | unsigned long flags_spin; |
331 | int ret = 0; | |
332 | u8 sta_id; | |
9c5ac091 | 333 | struct iwl_addsta_cmd sta_cmd; |
fe6b23dd RC |
334 | |
335 | *sta_id_r = 0; | |
336 | spin_lock_irqsave(&priv->sta_lock, flags_spin); | |
238d781d | 337 | sta_id = iwl_prep_station(priv, ctx, addr, is_ap, sta); |
fe6b23dd RC |
338 | if (sta_id == IWL_INVALID_STATION) { |
339 | IWL_ERR(priv, "Unable to prepare station %pM for addition\n", | |
340 | addr); | |
341 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
342 | return -EINVAL; | |
343 | } | |
344 | ||
345 | /* | |
346 | * uCode is not able to deal with multiple requests to add a | |
347 | * station. Keep track if one is in progress so that we do not send | |
348 | * another. | |
349 | */ | |
350 | if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) { | |
351 | IWL_DEBUG_INFO(priv, "STA %d already in process of being added.\n", | |
352 | sta_id); | |
353 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
354 | return -EEXIST; | |
355 | } | |
356 | ||
357 | if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) && | |
358 | (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) { | |
359 | IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not adding again.\n", | |
360 | sta_id, addr); | |
361 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
362 | return -EEXIST; | |
363 | } | |
364 | ||
365 | priv->stations[sta_id].used |= IWL_STA_UCODE_INPROGRESS; | |
9c5ac091 | 366 | memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd)); |
4f40e4d9 TW |
367 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); |
368 | ||
369 | /* Add station to device's station table */ | |
9c5ac091 | 370 | ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC); |
fe6b23dd | 371 | if (ret) { |
fe6b23dd | 372 | spin_lock_irqsave(&priv->sta_lock, flags_spin); |
9c5ac091 RC |
373 | IWL_ERR(priv, "Adding station %pM failed.\n", |
374 | priv->stations[sta_id].sta.sta.addr); | |
fe6b23dd RC |
375 | priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE; |
376 | priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS; | |
377 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
378 | } | |
379 | *sta_id_r = sta_id; | |
380 | return ret; | |
4f40e4d9 | 381 | } |
fe6b23dd | 382 | EXPORT_SYMBOL(iwl_add_station_common); |
4f40e4d9 | 383 | |
fe6b23dd RC |
384 | /** |
385 | * iwl_sta_ucode_deactivate - deactivate ucode status for a station | |
386 | * | |
387 | * priv->sta_lock must be held | |
388 | */ | |
389 | static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, u8 sta_id) | |
390 | { | |
391 | /* Ucode must be active and driver must be non active */ | |
d2e210ae RC |
392 | if ((priv->stations[sta_id].used & |
393 | (IWL_STA_UCODE_ACTIVE | IWL_STA_DRIVER_ACTIVE)) != IWL_STA_UCODE_ACTIVE) | |
fe6b23dd RC |
394 | IWL_ERR(priv, "removed non active STA %u\n", sta_id); |
395 | ||
396 | priv->stations[sta_id].used &= ~IWL_STA_UCODE_ACTIVE; | |
397 | ||
398 | memset(&priv->stations[sta_id], 0, sizeof(struct iwl_station_entry)); | |
399 | IWL_DEBUG_ASSOC(priv, "Removed STA %u\n", sta_id); | |
7a999bf0 TW |
400 | } |
401 | ||
fe6b23dd | 402 | static int iwl_send_remove_station(struct iwl_priv *priv, |
2b5f7a67 JB |
403 | const u8 *addr, int sta_id, |
404 | bool temporary) | |
7a999bf0 | 405 | { |
2f301227 | 406 | struct iwl_rx_packet *pkt; |
7a999bf0 TW |
407 | int ret; |
408 | ||
fe6b23dd | 409 | unsigned long flags_spin; |
7a999bf0 TW |
410 | struct iwl_rem_sta_cmd rm_sta_cmd; |
411 | ||
412 | struct iwl_host_cmd cmd = { | |
413 | .id = REPLY_REMOVE_STA, | |
414 | .len = sizeof(struct iwl_rem_sta_cmd), | |
fe6b23dd | 415 | .flags = CMD_SYNC, |
7a999bf0 TW |
416 | .data = &rm_sta_cmd, |
417 | }; | |
418 | ||
419 | memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd)); | |
420 | rm_sta_cmd.num_sta = 1; | |
9c5ac091 | 421 | memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN); |
fe6b23dd RC |
422 | |
423 | cmd.flags |= CMD_WANT_SKB; | |
7a999bf0 | 424 | |
7a999bf0 TW |
425 | ret = iwl_send_cmd(priv, &cmd); |
426 | ||
fe6b23dd | 427 | if (ret) |
7a999bf0 TW |
428 | return ret; |
429 | ||
2f301227 ZY |
430 | pkt = (struct iwl_rx_packet *)cmd.reply_page; |
431 | if (pkt->hdr.flags & IWL_CMD_FAILED_MSK) { | |
15b1687c | 432 | IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n", |
2f301227 | 433 | pkt->hdr.flags); |
7a999bf0 TW |
434 | ret = -EIO; |
435 | } | |
436 | ||
437 | if (!ret) { | |
2f301227 | 438 | switch (pkt->u.rem_sta.status) { |
7a999bf0 | 439 | case REM_STA_SUCCESS_MSK: |
2b5f7a67 JB |
440 | if (!temporary) { |
441 | spin_lock_irqsave(&priv->sta_lock, flags_spin); | |
442 | iwl_sta_ucode_deactivate(priv, sta_id); | |
443 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
444 | } | |
e1623446 | 445 | IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n"); |
7a999bf0 TW |
446 | break; |
447 | default: | |
448 | ret = -EIO; | |
15b1687c | 449 | IWL_ERR(priv, "REPLY_REMOVE_STA failed\n"); |
7a999bf0 TW |
450 | break; |
451 | } | |
452 | } | |
64a76b50 | 453 | iwl_free_pages(priv, cmd.reply_page); |
7a999bf0 TW |
454 | |
455 | return ret; | |
456 | } | |
be1f3ab6 | 457 | |
7a999bf0 TW |
458 | /** |
459 | * iwl_remove_station - Remove driver's knowledge of station. | |
7a999bf0 | 460 | */ |
fd1af15d JB |
461 | int iwl_remove_station(struct iwl_priv *priv, const u8 sta_id, |
462 | const u8 *addr) | |
7a999bf0 | 463 | { |
fd1af15d | 464 | unsigned long flags; |
fe6b23dd RC |
465 | |
466 | if (!iwl_is_ready(priv)) { | |
467 | IWL_DEBUG_INFO(priv, | |
91dd6c27 | 468 | "Unable to remove station %pM, device not ready.\n", |
c0222df8 | 469 | addr); |
fe6b23dd RC |
470 | /* |
471 | * It is typical for stations to be removed when we are | |
472 | * going down. Return success since device will be down | |
473 | * soon anyway | |
474 | */ | |
475 | return 0; | |
476 | } | |
7a999bf0 | 477 | |
fd1af15d JB |
478 | IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d %pM\n", |
479 | sta_id, addr); | |
7a999bf0 | 480 | |
fd1af15d JB |
481 | if (WARN_ON(sta_id == IWL_INVALID_STATION)) |
482 | return -EINVAL; | |
7a999bf0 | 483 | |
fd1af15d | 484 | spin_lock_irqsave(&priv->sta_lock, flags); |
24e5c401 EG |
485 | |
486 | if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) { | |
fe6b23dd | 487 | IWL_DEBUG_INFO(priv, "Removing %pM but non DRIVER active\n", |
c0222df8 | 488 | addr); |
fd1af15d | 489 | goto out_err; |
24e5c401 EG |
490 | } |
491 | ||
492 | if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) { | |
fe6b23dd | 493 | IWL_DEBUG_INFO(priv, "Removing %pM but non UCODE active\n", |
c0222df8 | 494 | addr); |
fd1af15d | 495 | goto out_err; |
7a999bf0 TW |
496 | } |
497 | ||
1fa61b2e JB |
498 | if (priv->stations[sta_id].used & IWL_STA_LOCAL) { |
499 | kfree(priv->stations[sta_id].lq); | |
500 | priv->stations[sta_id].lq = NULL; | |
501 | } | |
24e5c401 EG |
502 | |
503 | priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE; | |
504 | ||
505 | priv->num_stations--; | |
506 | ||
7a999bf0 | 507 | BUG_ON(priv->num_stations < 0); |
24e5c401 | 508 | |
7a999bf0 | 509 | spin_unlock_irqrestore(&priv->sta_lock, flags); |
24e5c401 | 510 | |
2b5f7a67 | 511 | return iwl_send_remove_station(priv, addr, sta_id, false); |
fd1af15d | 512 | out_err: |
7a999bf0 | 513 | spin_unlock_irqrestore(&priv->sta_lock, flags); |
fd1af15d | 514 | return -EINVAL; |
7a999bf0 | 515 | } |
1fa61b2e | 516 | EXPORT_SYMBOL_GPL(iwl_remove_station); |
24e5c401 | 517 | |
83dde8c9 | 518 | /** |
2c810ccd JB |
519 | * iwl_clear_ucode_stations - clear ucode station table bits |
520 | * | |
521 | * This function clears all the bits in the driver indicating | |
522 | * which stations are active in the ucode. Call when something | |
523 | * other than explicit station management would cause this in | |
524 | * the ucode, e.g. unassociated RXON. | |
83dde8c9 | 525 | */ |
dcef732c JB |
526 | void iwl_clear_ucode_stations(struct iwl_priv *priv, |
527 | struct iwl_rxon_context *ctx) | |
83dde8c9 | 528 | { |
48676eb3 | 529 | int i; |
7e246191 RC |
530 | unsigned long flags_spin; |
531 | bool cleared = false; | |
532 | ||
2c810ccd | 533 | IWL_DEBUG_INFO(priv, "Clearing ucode stations in driver\n"); |
83dde8c9 | 534 | |
7e246191 | 535 | spin_lock_irqsave(&priv->sta_lock, flags_spin); |
2c810ccd | 536 | for (i = 0; i < priv->hw_params.max_stations; i++) { |
dcef732c JB |
537 | if (ctx && ctx->ctxid != priv->stations[i].ctxid) |
538 | continue; | |
539 | ||
2c810ccd JB |
540 | if (priv->stations[i].used & IWL_STA_UCODE_ACTIVE) { |
541 | IWL_DEBUG_INFO(priv, "Clearing ucode active for station %d\n", i); | |
542 | priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE; | |
543 | cleared = true; | |
7e246191 RC |
544 | } |
545 | } | |
546 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
547 | ||
548 | if (!cleared) | |
549 | IWL_DEBUG_INFO(priv, "No active stations found to be cleared\n"); | |
550 | } | |
551 | EXPORT_SYMBOL(iwl_clear_ucode_stations); | |
83dde8c9 | 552 | |
7e246191 RC |
553 | /** |
554 | * iwl_restore_stations() - Restore driver known stations to device | |
555 | * | |
556 | * All stations considered active by driver, but not present in ucode, is | |
557 | * restored. | |
fe6b23dd RC |
558 | * |
559 | * Function sleeps. | |
7e246191 | 560 | */ |
dcef732c | 561 | void iwl_restore_stations(struct iwl_priv *priv, struct iwl_rxon_context *ctx) |
7e246191 | 562 | { |
9c5ac091 RC |
563 | struct iwl_addsta_cmd sta_cmd; |
564 | struct iwl_link_quality_cmd lq; | |
7e246191 RC |
565 | unsigned long flags_spin; |
566 | int i; | |
567 | bool found = false; | |
fe6b23dd | 568 | int ret; |
9c5ac091 | 569 | bool send_lq; |
83dde8c9 | 570 | |
7e246191 RC |
571 | if (!iwl_is_ready(priv)) { |
572 | IWL_DEBUG_INFO(priv, "Not ready yet, not restoring any stations.\n"); | |
573 | return; | |
574 | } | |
83dde8c9 | 575 | |
7e246191 RC |
576 | IWL_DEBUG_ASSOC(priv, "Restoring all known stations ... start.\n"); |
577 | spin_lock_irqsave(&priv->sta_lock, flags_spin); | |
578 | for (i = 0; i < priv->hw_params.max_stations; i++) { | |
dcef732c JB |
579 | if (ctx->ctxid != priv->stations[i].ctxid) |
580 | continue; | |
7e246191 RC |
581 | if ((priv->stations[i].used & IWL_STA_DRIVER_ACTIVE) && |
582 | !(priv->stations[i].used & IWL_STA_UCODE_ACTIVE)) { | |
583 | IWL_DEBUG_ASSOC(priv, "Restoring sta %pM\n", | |
584 | priv->stations[i].sta.sta.addr); | |
585 | priv->stations[i].sta.mode = 0; | |
586 | priv->stations[i].used |= IWL_STA_UCODE_INPROGRESS; | |
587 | found = true; | |
588 | } | |
589 | } | |
5e46882e | 590 | |
7e246191 RC |
591 | for (i = 0; i < priv->hw_params.max_stations; i++) { |
592 | if ((priv->stations[i].used & IWL_STA_UCODE_INPROGRESS)) { | |
9c5ac091 RC |
593 | memcpy(&sta_cmd, &priv->stations[i].sta, |
594 | sizeof(struct iwl_addsta_cmd)); | |
595 | send_lq = false; | |
596 | if (priv->stations[i].lq) { | |
597 | memcpy(&lq, priv->stations[i].lq, | |
598 | sizeof(struct iwl_link_quality_cmd)); | |
599 | send_lq = true; | |
600 | } | |
fe6b23dd | 601 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); |
9c5ac091 | 602 | ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC); |
fe6b23dd | 603 | if (ret) { |
fe6b23dd | 604 | spin_lock_irqsave(&priv->sta_lock, flags_spin); |
9c5ac091 RC |
605 | IWL_ERR(priv, "Adding station %pM failed.\n", |
606 | priv->stations[i].sta.sta.addr); | |
fe6b23dd RC |
607 | priv->stations[i].used &= ~IWL_STA_DRIVER_ACTIVE; |
608 | priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS; | |
609 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
610 | } | |
611 | /* | |
612 | * Rate scaling has already been initialized, send | |
613 | * current LQ command | |
614 | */ | |
9c5ac091 | 615 | if (send_lq) |
7e6a5886 | 616 | iwl_send_lq_cmd(priv, ctx, &lq, CMD_SYNC, true); |
fe6b23dd | 617 | spin_lock_irqsave(&priv->sta_lock, flags_spin); |
7e246191 RC |
618 | priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS; |
619 | } | |
48676eb3 MA |
620 | } |
621 | ||
7e246191 RC |
622 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); |
623 | if (!found) | |
624 | IWL_DEBUG_INFO(priv, "Restoring all known stations .... no stations to be restored.\n"); | |
625 | else | |
fe6b23dd | 626 | IWL_DEBUG_INFO(priv, "Restoring all known stations .... complete.\n"); |
83dde8c9 | 627 | } |
7e246191 | 628 | EXPORT_SYMBOL(iwl_restore_stations); |
83dde8c9 | 629 | |
2b5f7a67 JB |
630 | void iwl_reprogram_ap_sta(struct iwl_priv *priv, struct iwl_rxon_context *ctx) |
631 | { | |
632 | unsigned long flags; | |
633 | int sta_id = ctx->ap_sta_id; | |
634 | int ret; | |
635 | struct iwl_addsta_cmd sta_cmd; | |
636 | struct iwl_link_quality_cmd lq; | |
637 | bool active; | |
638 | ||
639 | spin_lock_irqsave(&priv->sta_lock, flags); | |
640 | if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) { | |
641 | spin_unlock_irqrestore(&priv->sta_lock, flags); | |
642 | return; | |
643 | } | |
644 | ||
645 | memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd)); | |
646 | sta_cmd.mode = 0; | |
647 | memcpy(&lq, priv->stations[sta_id].lq, sizeof(lq)); | |
648 | ||
649 | active = priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE; | |
40b97c2f | 650 | priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE; |
2b5f7a67 JB |
651 | spin_unlock_irqrestore(&priv->sta_lock, flags); |
652 | ||
653 | if (active) { | |
654 | ret = iwl_send_remove_station( | |
655 | priv, priv->stations[sta_id].sta.sta.addr, | |
656 | sta_id, true); | |
657 | if (ret) | |
658 | IWL_ERR(priv, "failed to remove STA %pM (%d)\n", | |
659 | priv->stations[sta_id].sta.sta.addr, ret); | |
660 | } | |
40b97c2f WYG |
661 | spin_lock_irqsave(&priv->sta_lock, flags); |
662 | priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE; | |
663 | spin_unlock_irqrestore(&priv->sta_lock, flags); | |
664 | ||
2b5f7a67 JB |
665 | ret = iwl_send_add_sta(priv, &sta_cmd, CMD_SYNC); |
666 | if (ret) | |
667 | IWL_ERR(priv, "failed to re-add STA %pM (%d)\n", | |
668 | priv->stations[sta_id].sta.sta.addr, ret); | |
669 | iwl_send_lq_cmd(priv, ctx, &lq, CMD_SYNC, true); | |
670 | } | |
671 | EXPORT_SYMBOL(iwl_reprogram_ap_sta); | |
672 | ||
6e21f15c | 673 | int iwl_get_free_ucode_key_index(struct iwl_priv *priv) |
80fb47a1 EG |
674 | { |
675 | int i; | |
676 | ||
c10afb6e | 677 | for (i = 0; i < priv->sta_key_max_num; i++) |
77bab602 | 678 | if (!test_and_set_bit(i, &priv->ucode_key_table)) |
80fb47a1 EG |
679 | return i; |
680 | ||
40a9a829 | 681 | return WEP_INVALID_OFFSET; |
80fb47a1 | 682 | } |
6e21f15c | 683 | EXPORT_SYMBOL(iwl_get_free_ucode_key_index); |
6974e363 | 684 | |
a30e3112 | 685 | void iwl_dealloc_bcast_stations(struct iwl_priv *priv) |
9f58671e | 686 | { |
9f58671e | 687 | unsigned long flags; |
9f58671e | 688 | int i; |
9f58671e | 689 | |
7480513f | 690 | spin_lock_irqsave(&priv->sta_lock, flags); |
a30e3112 JB |
691 | for (i = 0; i < priv->hw_params.max_stations; i++) { |
692 | if (!(priv->stations[i].used & IWL_STA_BCAST)) | |
693 | continue; | |
40a9a829 | 694 | |
a30e3112 JB |
695 | priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE; |
696 | priv->num_stations--; | |
697 | BUG_ON(priv->num_stations < 0); | |
698 | kfree(priv->stations[i].lq); | |
699 | priv->stations[i].lq = NULL; | |
2d1bb9e5 | 700 | } |
3ec47732 | 701 | spin_unlock_irqrestore(&priv->sta_lock, flags); |
7480513f | 702 | } |
a30e3112 | 703 | EXPORT_SYMBOL_GPL(iwl_dealloc_bcast_stations); |
7480513f | 704 | |
66c73db7 TW |
705 | #ifdef CONFIG_IWLWIFI_DEBUG |
706 | static void iwl_dump_lq_cmd(struct iwl_priv *priv, | |
707 | struct iwl_link_quality_cmd *lq) | |
708 | { | |
709 | int i; | |
e1623446 TW |
710 | IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id); |
711 | IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n", | |
66c73db7 TW |
712 | lq->general_params.single_stream_ant_msk, |
713 | lq->general_params.dual_stream_ant_msk); | |
714 | ||
715 | for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) | |
e1623446 | 716 | IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n", |
66c73db7 TW |
717 | i, lq->rs_table[i].rate_n_flags); |
718 | } | |
719 | #else | |
720 | static inline void iwl_dump_lq_cmd(struct iwl_priv *priv, | |
721 | struct iwl_link_quality_cmd *lq) | |
722 | { | |
723 | } | |
724 | #endif | |
725 | ||
3bce6066 RC |
726 | /** |
727 | * is_lq_table_valid() - Test one aspect of LQ cmd for validity | |
728 | * | |
729 | * It sometimes happens when a HT rate has been in use and we | |
730 | * loose connectivity with AP then mac80211 will first tell us that the | |
731 | * current channel is not HT anymore before removing the station. In such a | |
732 | * scenario the RXON flags will be updated to indicate we are not | |
733 | * communicating HT anymore, but the LQ command may still contain HT rates. | |
734 | * Test for this to prevent driver from sending LQ command between the time | |
735 | * RXON flags are updated and when LQ command is updated. | |
736 | */ | |
737 | static bool is_lq_table_valid(struct iwl_priv *priv, | |
7e6a5886 | 738 | struct iwl_rxon_context *ctx, |
3bce6066 RC |
739 | struct iwl_link_quality_cmd *lq) |
740 | { | |
741 | int i; | |
3bce6066 | 742 | |
7e6a5886 | 743 | if (ctx->ht.enabled) |
3bce6066 RC |
744 | return true; |
745 | ||
746 | IWL_DEBUG_INFO(priv, "Channel %u is not an HT channel\n", | |
246ed355 | 747 | ctx->active.channel); |
3bce6066 RC |
748 | for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) { |
749 | if (le32_to_cpu(lq->rs_table[i].rate_n_flags) & RATE_MCS_HT_MSK) { | |
750 | IWL_DEBUG_INFO(priv, | |
751 | "index %d of LQ expects HT channel\n", | |
752 | i); | |
753 | return false; | |
754 | } | |
755 | } | |
756 | return true; | |
757 | } | |
758 | ||
fe6b23dd RC |
759 | /** |
760 | * iwl_send_lq_cmd() - Send link quality command | |
761 | * @init: This command is sent as part of station initialization right | |
762 | * after station has been added. | |
763 | * | |
764 | * The link quality command is sent as the last step of station creation. | |
765 | * This is the special case in which init is set and we call a callback in | |
766 | * this case to clear the state indicating that station creation is in | |
767 | * progress. | |
768 | */ | |
7e6a5886 | 769 | int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx, |
fe6b23dd | 770 | struct iwl_link_quality_cmd *lq, u8 flags, bool init) |
66c73db7 | 771 | { |
fe6b23dd RC |
772 | int ret = 0; |
773 | unsigned long flags_spin; | |
774 | ||
66c73db7 TW |
775 | struct iwl_host_cmd cmd = { |
776 | .id = REPLY_TX_LINK_QUALITY_CMD, | |
777 | .len = sizeof(struct iwl_link_quality_cmd), | |
c2acea8e | 778 | .flags = flags, |
66c73db7 TW |
779 | .data = lq, |
780 | }; | |
781 | ||
76c3c698 | 782 | if (WARN_ON(lq->sta_id == IWL_INVALID_STATION)) |
66c73db7 TW |
783 | return -EINVAL; |
784 | ||
40b97c2f WYG |
785 | |
786 | spin_lock_irqsave(&priv->sta_lock, flags_spin); | |
787 | if (!(priv->stations[lq->sta_id].used & IWL_STA_DRIVER_ACTIVE)) { | |
788 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
789 | return -EINVAL; | |
790 | } | |
791 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
792 | ||
3ac7f146 | 793 | iwl_dump_lq_cmd(priv, lq); |
fe6b23dd | 794 | BUG_ON(init && (cmd.flags & CMD_ASYNC)); |
66c73db7 | 795 | |
7e6a5886 | 796 | if (is_lq_table_valid(priv, ctx, lq)) |
3bce6066 RC |
797 | ret = iwl_send_cmd(priv, &cmd); |
798 | else | |
799 | ret = -EINVAL; | |
d2e210ae RC |
800 | |
801 | if (cmd.flags & CMD_ASYNC) | |
fe6b23dd | 802 | return ret; |
66c73db7 | 803 | |
fe6b23dd | 804 | if (init) { |
91dd6c27 | 805 | IWL_DEBUG_INFO(priv, "init LQ command complete, clearing sta addition status for sta %d\n", |
fe6b23dd RC |
806 | lq->sta_id); |
807 | spin_lock_irqsave(&priv->sta_lock, flags_spin); | |
808 | priv->stations[lq->sta_id].used &= ~IWL_STA_UCODE_INPROGRESS; | |
809 | spin_unlock_irqrestore(&priv->sta_lock, flags_spin); | |
810 | } | |
d2e210ae | 811 | return ret; |
66c73db7 TW |
812 | } |
813 | EXPORT_SYMBOL(iwl_send_lq_cmd); | |
814 | ||
fe6b23dd | 815 | int iwl_mac_sta_remove(struct ieee80211_hw *hw, |
fd1af15d JB |
816 | struct ieee80211_vif *vif, |
817 | struct ieee80211_sta *sta) | |
fe6b23dd | 818 | { |
fe6b23dd | 819 | struct iwl_priv *priv = hw->priv; |
fd1af15d JB |
820 | struct iwl_station_priv_common *sta_common = (void *)sta->drv_priv; |
821 | int ret; | |
822 | ||
fe6b23dd RC |
823 | IWL_DEBUG_INFO(priv, "received request to remove station %pM\n", |
824 | sta->addr); | |
da5ae1cf RC |
825 | mutex_lock(&priv->mutex); |
826 | IWL_DEBUG_INFO(priv, "proceeding to remove station %pM\n", | |
827 | sta->addr); | |
fd1af15d | 828 | ret = iwl_remove_station(priv, sta_common->sta_id, sta->addr); |
fe6b23dd RC |
829 | if (ret) |
830 | IWL_ERR(priv, "Error removing station %pM\n", | |
831 | sta->addr); | |
da5ae1cf | 832 | mutex_unlock(&priv->mutex); |
fe6b23dd RC |
833 | return ret; |
834 | } | |
835 | EXPORT_SYMBOL(iwl_mac_sta_remove); |