projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'hwmon-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jdelv...
[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-sta.c
CommitLineData
6974e363
EG		 1/******************************************************************************
2 *
01f8162a 3 * Copyright(c) 2003 - 2009 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>
6974e363 32
3e0d4cb1 33#include "iwl-dev.h"
6974e363
EG		 34#include "iwl-core.h"
35#include "iwl-sta.h"
7a999bf0 36
24e5c401
EG		 37#define IWL_STA_DRIVER_ACTIVE BIT(0) /* driver entry is active */
38#define IWL_STA_UCODE_ACTIVE BIT(1) /* ucode entry is active */
7a999bf0 39
947b13a7
TW		 40u8 iwl_find_station(struct iwl_priv *priv, const u8 *addr)
41{
42 int i;
43 int start = 0;
44 int ret = IWL_INVALID_STATION;
45 unsigned long flags;
947b13a7 46
05c914fe
JB		 47 if ((priv->iw_mode == NL80211_IFTYPE_ADHOC) ||
48 (priv->iw_mode == NL80211_IFTYPE_AP))
947b13a7
TW		 49 start = IWL_STA_ID;
50
51 if (is_broadcast_ether_addr(addr))
52 return priv->hw_params.bcast_sta_id;
53
54 spin_lock_irqsave(&priv->sta_lock, flags);
55 for (i = start; i < priv->hw_params.max_stations; i++)
56 if (priv->stations[i].used &&
57 (!compare_ether_addr(priv->stations[i].sta.sta.addr,
58 addr))) {
59 ret = i;
60 goto out;
61 }
62
e1623446 63 IWL_DEBUG_ASSOC_LIMIT(priv, "can not find STA %pM total %d\n",
e174961c 64 addr, priv->num_stations);
947b13a7
TW		 65
66 out:
67 spin_unlock_irqrestore(&priv->sta_lock, flags);
68 return ret;
69}
70EXPORT_SYMBOL(iwl_find_station);
71
be1f3ab6
EG		 72int iwl_get_ra_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
73{
05c914fe 74 if (priv->iw_mode == NL80211_IFTYPE_STATION) {
be1f3ab6
EG		 75 return IWL_AP_ID;
76 } else {
77 u8 *da = ieee80211_get_DA(hdr);
c587de0b 78 return iwl_find_station(priv, da);
be1f3ab6
EG		 79 }
80}
81EXPORT_SYMBOL(iwl_get_ra_sta_id);
82
24e5c401
EG		 83static void iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id)
84{
85 unsigned long flags;
24e5c401
EG		 86
87 spin_lock_irqsave(&priv->sta_lock, flags);
88
c587de0b 89 if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE))
15b1687c
WT		 90 IWL_ERR(priv, "ACTIVATE a non DRIVER active station %d\n",
91 sta_id);
24e5c401
EG		 92
93 priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE;
e1623446 94 IWL_DEBUG_ASSOC(priv, "Added STA to Ucode: %pM\n",
e174961c 95 priv->stations[sta_id].sta.sta.addr);
24e5c401
EG		 96
97 spin_unlock_irqrestore(&priv->sta_lock, flags);
98}
99
42132bce
TW		 100static int iwl_add_sta_callback(struct iwl_priv *priv,
101 struct iwl_cmd *cmd, struct sk_buff *skb)
102{
103 struct iwl_rx_packet *res = NULL;
3257e5d4
TW		 104 struct iwl_addsta_cmd *addsta =
105 (struct iwl_addsta_cmd *)cmd->cmd.payload;
106 u8 sta_id = addsta->sta.sta_id;
42132bce
TW		 107
108 if (!skb) {
15b1687c 109 IWL_ERR(priv, "Error: Response NULL in REPLY_ADD_STA.\n");
42132bce
TW		 110 return 1;
111 }
112
113 res = (struct iwl_rx_packet *)skb->data;
114 if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
15b1687c 115 IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
42132bce
TW		 116 res->hdr.flags);
117 return 1;
118 }
119
120 switch (res->u.add_sta.status) {
121 case ADD_STA_SUCCESS_MSK:
24e5c401
EG		 122 iwl_sta_ucode_activate(priv, sta_id);
123 /* fall through */
42132bce 124 default:
e1623446 125 IWL_DEBUG_HC(priv, "Received REPLY_ADD_STA:(0x%08X)\n",
42132bce
TW		 126 res->u.add_sta.status);
127 break;
128 }
129
130 /* We didn't cache the SKB; let the caller free it */
131 return 1;
132}
133
17f841cd 134int iwl_send_add_sta(struct iwl_priv *priv,
133636de
TW		 135 struct iwl_addsta_cmd *sta, u8 flags)
136{
137 struct iwl_rx_packet *res = NULL;
138 int ret = 0;
139 u8 data[sizeof(*sta)];
140 struct iwl_host_cmd cmd = {
141 .id = REPLY_ADD_STA,
142 .meta.flags = flags,
143 .data = data,
144 };
145
42132bce
TW		 146 if (flags & CMD_ASYNC)
147 cmd.meta.u.callback = iwl_add_sta_callback;
148 else
133636de
TW		 149 cmd.meta.flags |= CMD_WANT_SKB;
150
151 cmd.len = priv->cfg->ops->utils->build_addsta_hcmd(sta, data);
152 ret = iwl_send_cmd(priv, &cmd);
153
154 if (ret || (flags & CMD_ASYNC))
155 return ret;
156
157 res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
158 if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
15b1687c 159 IWL_ERR(priv, "Bad return from REPLY_ADD_STA (0x%08X)\n",
133636de
TW		 160 res->hdr.flags);
161 ret = -EIO;
162 }
163
164 if (ret == 0) {
165 switch (res->u.add_sta.status) {
166 case ADD_STA_SUCCESS_MSK:
24e5c401 167 iwl_sta_ucode_activate(priv, sta->sta.sta_id);
e1623446 168 IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n");
133636de
TW		 169 break;
170 default:
171 ret = -EIO;
39aadf8c 172 IWL_WARN(priv, "REPLY_ADD_STA failed\n");
133636de
TW		 173 break;
174 }
175 }
176
177 priv->alloc_rxb_skb--;
178 dev_kfree_skb_any(cmd.meta.u.skb);
179
180 return ret;
181}
17f841cd 182EXPORT_SYMBOL(iwl_send_add_sta);
947b13a7 183
4f40e4d9 184static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index,
d9fe60de 185 struct ieee80211_sta_ht_cap *sta_ht_inf)
4f40e4d9
TW		 186{
187 __le32 sta_flags;
188 u8 mimo_ps_mode;
189
190 if (!sta_ht_inf || !sta_ht_inf->ht_supported)
191 goto done;
192
00c5ae2f 193 mimo_ps_mode = (sta_ht_inf->cap & IEEE80211_HT_CAP_SM_PS) >> 2;
4f40e4d9
TW		 194
195 sta_flags = priv->stations[index].sta.station_flags;
196
197 sta_flags &= ~(STA_FLG_RTS_MIMO_PROT_MSK | STA_FLG_MIMO_DIS_MSK);
198
199 switch (mimo_ps_mode) {
00c5ae2f 200 case WLAN_HT_CAP_SM_PS_STATIC:
4f40e4d9
TW		 201 sta_flags |= STA_FLG_MIMO_DIS_MSK;
202 break;
00c5ae2f 203 case WLAN_HT_CAP_SM_PS_DYNAMIC:
4f40e4d9
TW		 204 sta_flags |= STA_FLG_RTS_MIMO_PROT_MSK;
205 break;
00c5ae2f 206 case WLAN_HT_CAP_SM_PS_DISABLED:
4f40e4d9
TW		 207 break;
208 default:
39aadf8c 209 IWL_WARN(priv, "Invalid MIMO PS mode %d\n", mimo_ps_mode);
4f40e4d9
TW		 210 break;
211 }
212
213 sta_flags |= cpu_to_le32(
214 (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
215
216 sta_flags |= cpu_to_le32(
217 (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
218
219 if (iwl_is_fat_tx_allowed(priv, sta_ht_inf))
220 sta_flags |= STA_FLG_FAT_EN_MSK;
221 else
222 sta_flags &= ~STA_FLG_FAT_EN_MSK;
223
224 priv->stations[index].sta.station_flags = sta_flags;
225 done:
226 return;
227}
4f40e4d9
TW		 228
229/**
c587de0b 230 * iwl_add_station - Add station to tables in driver and device
4f40e4d9 231 */
c587de0b
TW		 232u8 iwl_add_station(struct iwl_priv *priv, const u8 *addr, bool is_ap, u8 flags,
233 struct ieee80211_sta_ht_cap *ht_info)
4f40e4d9 234{
4f40e4d9
TW		 235 struct iwl_station_entry *station;
236 unsigned long flags_spin;
c587de0b
TW		 237 int i;
238 int sta_id = IWL_INVALID_STATION;
239 u16 rate;
4f40e4d9
TW		 240
241 spin_lock_irqsave(&priv->sta_lock, flags_spin);
242 if (is_ap)
24e5c401 243 sta_id = IWL_AP_ID;
4f40e4d9 244 else if (is_broadcast_ether_addr(addr))
24e5c401 245 sta_id = priv->hw_params.bcast_sta_id;
4f40e4d9
TW		 246 else
247 for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++) {
248 if (!compare_ether_addr(priv->stations[i].sta.sta.addr,
249 addr)) {
24e5c401 250 sta_id = i;
4f40e4d9
TW		 251 break;
252 }
253
254 if (!priv->stations[i].used &&
24e5c401
EG		 255 sta_id == IWL_INVALID_STATION)
256 sta_id = i;
4f40e4d9
TW		 257 }
258
4f40e4d9 259 /* These two conditions have the same outcome, but keep them separate
24e5c401
EG		 260 since they have different meanings */
261 if (unlikely(sta_id == IWL_INVALID_STATION)) {
4f40e4d9 262 spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
24e5c401 263 return sta_id;
4f40e4d9
TW		 264 }
265
24e5c401
EG		 266 if (priv->stations[sta_id].used &&
267 !compare_ether_addr(priv->stations[sta_id].sta.sta.addr, addr)) {
4f40e4d9 268 spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
24e5c401 269 return sta_id;
4f40e4d9
TW		 270 }
271
272
24e5c401
EG		 273 station = &priv->stations[sta_id];
274 station->used = IWL_STA_DRIVER_ACTIVE;
e1623446 275 IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n",
e174961c 276 sta_id, addr);
4f40e4d9
TW		 277 priv->num_stations++;
278
279 /* Set up the REPLY_ADD_STA command to send to device */
280 memset(&station->sta, 0, sizeof(struct iwl_addsta_cmd));
281 memcpy(station->sta.sta.addr, addr, ETH_ALEN);
282 station->sta.mode = 0;
24e5c401 283 station->sta.sta.sta_id = sta_id;
4f40e4d9
TW		 284 station->sta.station_flags = 0;
285
286 /* BCAST station and IBSS stations do not work in HT mode */
24e5c401 287 if (sta_id != priv->hw_params.bcast_sta_id &&
05c914fe 288 priv->iw_mode != NL80211_IFTYPE_ADHOC)
24e5c401 289 iwl_set_ht_add_station(priv, sta_id, ht_info);
4f40e4d9 290
c587de0b
TW		 291 /* 3945 only */
292 rate = (priv->band == IEEE80211_BAND_5GHZ) ?
293 IWL_RATE_6M_PLCP : IWL_RATE_1M_PLCP;
294 /* Turn on both antennas for the station... */
295 station->sta.rate_n_flags = cpu_to_le16(rate | RATE_MCS_ANT_AB_MSK);
296
4f40e4d9
TW		 297 spin_unlock_irqrestore(&priv->sta_lock, flags_spin);
298
299 /* Add station to device's station table */
300 iwl_send_add_sta(priv, &station->sta, flags);
24e5c401 301 return sta_id;
4f40e4d9
TW		 302
303}
c587de0b 304EXPORT_SYMBOL(iwl_add_station);
4f40e4d9 305
24e5c401 306static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, const char *addr)
7a999bf0
TW		 307{
308 unsigned long flags;
c587de0b 309 u8 sta_id = iwl_find_station(priv, addr);
24e5c401
EG		 310
311 BUG_ON(sta_id == IWL_INVALID_STATION);
312
e1623446 313 IWL_DEBUG_ASSOC(priv, "Removed STA from Ucode: %pM\n", addr);
24e5c401
EG		 314
315 spin_lock_irqsave(&priv->sta_lock, flags);
316
317 /* Ucode must be active and driver must be non active */
318 if (priv->stations[sta_id].used != IWL_STA_UCODE_ACTIVE)
15b1687c 319 IWL_ERR(priv, "removed non active STA %d\n", sta_id);
24e5c401
EG		 320
321 priv->stations[sta_id].used &= ~IWL_STA_UCODE_ACTIVE;
322
323 memset(&priv->stations[sta_id], 0, sizeof(struct iwl_station_entry));
324 spin_unlock_irqrestore(&priv->sta_lock, flags);
7a999bf0
TW		 325}
326
327static int iwl_remove_sta_callback(struct iwl_priv *priv,
328 struct iwl_cmd *cmd, struct sk_buff *skb)
329{
330 struct iwl_rx_packet *res = NULL;
3257e5d4
TW		 331 struct iwl_rem_sta_cmd *rm_sta =
332 (struct iwl_rem_sta_cmd *)cmd->cmd.payload;
333 const char *addr = rm_sta->addr;
7a999bf0
TW		 334
335 if (!skb) {
15b1687c 336 IWL_ERR(priv, "Error: Response NULL in REPLY_REMOVE_STA.\n");
7a999bf0
TW		 337 return 1;
338 }
339
340 res = (struct iwl_rx_packet *)skb->data;
341 if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
15b1687c 342 IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
7a999bf0
TW		 343 res->hdr.flags);
344 return 1;
345 }
346
347 switch (res->u.rem_sta.status) {
348 case REM_STA_SUCCESS_MSK:
349 iwl_sta_ucode_deactivate(priv, addr);
350 break;
351 default:
15b1687c 352 IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
7a999bf0
TW		 353 break;
354 }
355
356 /* We didn't cache the SKB; let the caller free it */
357 return 1;
358}
359
360static int iwl_send_remove_station(struct iwl_priv *priv, const u8 *addr,
361 u8 flags)
362{
363 struct iwl_rx_packet *res = NULL;
364 int ret;
365
366 struct iwl_rem_sta_cmd rm_sta_cmd;
367
368 struct iwl_host_cmd cmd = {
369 .id = REPLY_REMOVE_STA,
370 .len = sizeof(struct iwl_rem_sta_cmd),
371 .meta.flags = flags,
372 .data = &rm_sta_cmd,
373 };
374
375 memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
376 rm_sta_cmd.num_sta = 1;
377 memcpy(&rm_sta_cmd.addr, addr , ETH_ALEN);
378
379 if (flags & CMD_ASYNC)
380 cmd.meta.u.callback = iwl_remove_sta_callback;
381 else
382 cmd.meta.flags |= CMD_WANT_SKB;
383 ret = iwl_send_cmd(priv, &cmd);
384
385 if (ret || (flags & CMD_ASYNC))
386 return ret;
387
388 res = (struct iwl_rx_packet *)cmd.meta.u.skb->data;
389 if (res->hdr.flags & IWL_CMD_FAILED_MSK) {
15b1687c 390 IWL_ERR(priv, "Bad return from REPLY_REMOVE_STA (0x%08X)\n",
7a999bf0
TW		 391 res->hdr.flags);
392 ret = -EIO;
393 }
394
395 if (!ret) {
396 switch (res->u.rem_sta.status) {
397 case REM_STA_SUCCESS_MSK:
398 iwl_sta_ucode_deactivate(priv, addr);
e1623446 399 IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
7a999bf0
TW		 400 break;
401 default:
402 ret = -EIO;
15b1687c 403 IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
7a999bf0
TW		 404 break;
405 }
406 }
407
408 priv->alloc_rxb_skb--;
409 dev_kfree_skb_any(cmd.meta.u.skb);
410
411 return ret;
412}
be1f3ab6 413
7a999bf0
TW		 414/**
415 * iwl_remove_station - Remove driver's knowledge of station.
7a999bf0 416 */
c587de0b 417int iwl_remove_station(struct iwl_priv *priv, const u8 *addr, bool is_ap)
7a999bf0 418{
24e5c401
EG		 419 int sta_id = IWL_INVALID_STATION;
420 int i, ret = -EINVAL;
7a999bf0
TW		 421 unsigned long flags;
422
423 spin_lock_irqsave(&priv->sta_lock, flags);
424
425 if (is_ap)
24e5c401 426 sta_id = IWL_AP_ID;
7a999bf0 427 else if (is_broadcast_ether_addr(addr))
24e5c401 428 sta_id = priv->hw_params.bcast_sta_id;
7a999bf0
TW		 429 else
430 for (i = IWL_STA_ID; i < priv->hw_params.max_stations; i++)
431 if (priv->stations[i].used &&
432 !compare_ether_addr(priv->stations[i].sta.sta.addr,
433 addr)) {
24e5c401 434 sta_id = i;
7a999bf0
TW		 435 break;
436 }
437
24e5c401 438 if (unlikely(sta_id == IWL_INVALID_STATION))
7a999bf0
TW		 439 goto out;
440
e1623446 441 IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d %pM\n",
e174961c 442 sta_id, addr);
24e5c401
EG		 443
444 if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
15b1687c 445 IWL_ERR(priv, "Removing %pM but non DRIVER active\n",
e174961c 446 addr);
24e5c401
EG		 447 goto out;
448 }
449
450 if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
15b1687c 451 IWL_ERR(priv, "Removing %pM but non UCODE active\n",
e174961c 452 addr);
24e5c401 453 goto out;
7a999bf0
TW		 454 }
455
24e5c401
EG		 456
457 priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
458
459 priv->num_stations--;
460
7a999bf0 461 BUG_ON(priv->num_stations < 0);
24e5c401 462
7a999bf0 463 spin_unlock_irqrestore(&priv->sta_lock, flags);
24e5c401
EG		 464
465 ret = iwl_send_remove_station(priv, addr, CMD_ASYNC);
466 return ret;
7a999bf0
TW		 467out:
468 spin_unlock_irqrestore(&priv->sta_lock, flags);
24e5c401 469 return ret;
7a999bf0
TW		 470}
471EXPORT_SYMBOL(iwl_remove_station);
24e5c401 472
83dde8c9
WT		 473/**
474 * iwl_clear_stations_table - Clear the driver's station table
475 *
476 * NOTE: This does not clear or otherwise alter the device's station table.
477 */
478void iwl_clear_stations_table(struct iwl_priv *priv)
479{
480 unsigned long flags;
48676eb3 481 int i;
83dde8c9
WT		 482
483 spin_lock_irqsave(&priv->sta_lock, flags);
484
485 if (iwl_is_alive(priv) &&
486 !test_bit(STATUS_EXIT_PENDING, &priv->status) &&
487 iwl_send_cmd_pdu_async(priv, REPLY_REMOVE_ALL_STA, 0, NULL, NULL))
15b1687c 488 IWL_ERR(priv, "Couldn't clear the station table\n");
83dde8c9
WT		 489
490 priv->num_stations = 0;
491 memset(priv->stations, 0, sizeof(priv->stations));
492
5e46882e
RC		 493 /* clean ucode key table bit map */
494 priv->ucode_key_table = 0;
495
48676eb3
MA		 496 /* keep track of static keys */
497 for (i = 0; i < WEP_KEYS_MAX ; i++) {
498 if (priv->wep_keys[i].key_size)
4e8e2c82 499 set_bit(i, &priv->ucode_key_table);
48676eb3
MA		 500 }
501
83dde8c9
WT		 502 spin_unlock_irqrestore(&priv->sta_lock, flags);
503}
504EXPORT_SYMBOL(iwl_clear_stations_table);
505
6e21f15c 506int iwl_get_free_ucode_key_index(struct iwl_priv *priv)
80fb47a1
EG		 507{
508 int i;
509
510 for (i = 0; i < STA_KEY_MAX_NUM; i++)
77bab602 511 if (!test_and_set_bit(i, &priv->ucode_key_table))
80fb47a1
EG		 512 return i;
513
40a9a829 514 return WEP_INVALID_OFFSET;
80fb47a1 515}
6e21f15c 516EXPORT_SYMBOL(iwl_get_free_ucode_key_index);
6974e363
EG		 517
518int iwl_send_static_wepkey_cmd(struct iwl_priv *priv, u8 send_if_empty)
519{
520 int i, not_empty = 0;
521 u8 buff[sizeof(struct iwl_wep_cmd) +
522 sizeof(struct iwl_wep_key) * WEP_KEYS_MAX];
523 struct iwl_wep_cmd *wep_cmd = (struct iwl_wep_cmd *)buff;
524 size_t cmd_size = sizeof(struct iwl_wep_cmd);
525 struct iwl_host_cmd cmd = {
526 .id = REPLY_WEPKEY,
527 .data = wep_cmd,
528 .meta.flags = CMD_ASYNC,
529 };
530
531 memset(wep_cmd, 0, cmd_size +
532 (sizeof(struct iwl_wep_key) * WEP_KEYS_MAX));
533
534 for (i = 0; i < WEP_KEYS_MAX ; i++) {
535 wep_cmd->key[i].key_index = i;
536 if (priv->wep_keys[i].key_size) {
537 wep_cmd->key[i].key_offset = i;
538 not_empty = 1;
539 } else {
540 wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
541 }
542
543 wep_cmd->key[i].key_size = priv->wep_keys[i].key_size;
544 memcpy(&wep_cmd->key[i].key[3], priv->wep_keys[i].key,
545 priv->wep_keys[i].key_size);
546 }
547
548 wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
549 wep_cmd->num_keys = WEP_KEYS_MAX;
550
551 cmd_size += sizeof(struct iwl_wep_key) * WEP_KEYS_MAX;
552
553 cmd.len = cmd_size;
554
555 if (not_empty || send_if_empty)
556 return iwl_send_cmd(priv, &cmd);
557 else
558 return 0;
559}
27aaba0c 560EXPORT_SYMBOL(iwl_send_static_wepkey_cmd);
6974e363
EG		 561
562int iwl_remove_default_wep_key(struct iwl_priv *priv,
80fb47a1 563 struct ieee80211_key_conf *keyconf)
6974e363
EG		 564{
565 int ret;
566 unsigned long flags;
567
568 spin_lock_irqsave(&priv->sta_lock, flags);
80fb47a1
EG		 569
570 if (!test_and_clear_bit(keyconf->keyidx, &priv->ucode_key_table))
15b1687c 571 IWL_ERR(priv, "index %d not used in uCode key table.\n",
80fb47a1
EG		 572 keyconf->keyidx);
573
6974e363 574 priv->default_wep_key--;
80fb47a1 575 memset(&priv->wep_keys[keyconf->keyidx], 0, sizeof(priv->wep_keys[0]));
6974e363 576 ret = iwl_send_static_wepkey_cmd(priv, 1);
e1623446 577 IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
4564ce8b 578 keyconf->keyidx, ret);
6974e363
EG		 579 spin_unlock_irqrestore(&priv->sta_lock, flags);
580
581 return ret;
582}
27aaba0c 583EXPORT_SYMBOL(iwl_remove_default_wep_key);
6974e363
EG		 584
585int iwl_set_default_wep_key(struct iwl_priv *priv,
586 struct ieee80211_key_conf *keyconf)
587{
588 int ret;
589 unsigned long flags;
590
4564ce8b
EG		 591 if (keyconf->keylen != WEP_KEY_LEN_128 &&
592 keyconf->keylen != WEP_KEY_LEN_64) {
e1623446 593 IWL_DEBUG_WEP(priv, "Bad WEP key length %d\n", keyconf->keylen);
4564ce8b
EG		 594 return -EINVAL;
595 }
596
6974e363 597 keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
ccc038ab 598 keyconf->hw_key_idx = HW_KEY_DEFAULT;
6974e363
EG		 599 priv->stations[IWL_AP_ID].keyinfo.alg = ALG_WEP;
600
601 spin_lock_irqsave(&priv->sta_lock, flags);
602 priv->default_wep_key++;
603
80fb47a1 604 if (test_and_set_bit(keyconf->keyidx, &priv->ucode_key_table))
15b1687c 605 IWL_ERR(priv, "index %d already used in uCode key table.\n",
80fb47a1
EG		 606 keyconf->keyidx);
607
6974e363
EG		 608 priv->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
609 memcpy(&priv->wep_keys[keyconf->keyidx].key, &keyconf->key,
610 keyconf->keylen);
611
612 ret = iwl_send_static_wepkey_cmd(priv, 0);
e1623446 613 IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
4564ce8b 614 keyconf->keylen, keyconf->keyidx, ret);
6974e363
EG		 615 spin_unlock_irqrestore(&priv->sta_lock, flags);
616
617 return ret;
618}
27aaba0c 619EXPORT_SYMBOL(iwl_set_default_wep_key);
6974e363 620
7480513f 621static int iwl_set_wep_dynamic_key_info(struct iwl_priv *priv,
0211ddda
EG		 622 struct ieee80211_key_conf *keyconf,
623 u8 sta_id)
624{
625 unsigned long flags;
626 __le16 key_flags = 0;
627 int ret;
628
629 keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
0211ddda
EG		 630
631 key_flags |= (STA_KEY_FLG_WEP | STA_KEY_FLG_MAP_KEY_MSK);
632 key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
633 key_flags &= ~STA_KEY_FLG_INVALID;
634
635 if (keyconf->keylen == WEP_KEY_LEN_128)
636 key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;
637
5425e490 638 if (sta_id == priv->hw_params.bcast_sta_id)
0211ddda
EG		 639 key_flags |= STA_KEY_MULTICAST_MSK;
640
641 spin_lock_irqsave(&priv->sta_lock, flags);
642
643 priv->stations[sta_id].keyinfo.alg = keyconf->alg;
644 priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
645 priv->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;
646
647 memcpy(priv->stations[sta_id].keyinfo.key,
648 keyconf->key, keyconf->keylen);
649
650 memcpy(&priv->stations[sta_id].sta.key.key[3],
651 keyconf->key, keyconf->keylen);
652
3ec47732
EG		 653 if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
654 == STA_KEY_FLG_NO_ENC)
655 priv->stations[sta_id].sta.key.key_offset =
80fb47a1 656 iwl_get_free_ucode_key_index(priv);
3ec47732
EG		 657 /* else, we are overriding an existing key => no need to allocated room
658 * in uCode. */
0211ddda 659
40a9a829 660 WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
e724b8fe 661 "no space for a new key");
40a9a829 662
3ec47732 663 priv->stations[sta_id].sta.key.key_flags = key_flags;
0211ddda
EG		 664 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
665 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
666
133636de 667 ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
0211ddda
EG		 668
669 spin_unlock_irqrestore(&priv->sta_lock, flags);
670
671 return ret;
672}
7480513f
EG		 673
674static int iwl_set_ccmp_dynamic_key_info(struct iwl_priv *priv,
675 struct ieee80211_key_conf *keyconf,
676 u8 sta_id)
677{
678 unsigned long flags;
679 __le16 key_flags = 0;
40a9a829 680 int ret;
7480513f
EG		 681
682 key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
683 key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
684 key_flags &= ~STA_KEY_FLG_INVALID;
685
5425e490 686 if (sta_id == priv->hw_params.bcast_sta_id)
7480513f
EG		 687 key_flags |= STA_KEY_MULTICAST_MSK;
688
689 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
7480513f
EG		 690
691 spin_lock_irqsave(&priv->sta_lock, flags);
692 priv->stations[sta_id].keyinfo.alg = keyconf->alg;
693 priv->stations[sta_id].keyinfo.keylen = keyconf->keylen;
694
695 memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key,
696 keyconf->keylen);
697
698 memcpy(priv->stations[sta_id].sta.key.key, keyconf->key,
699 keyconf->keylen);
700
3ec47732
EG		 701 if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
702 == STA_KEY_FLG_NO_ENC)
703 priv->stations[sta_id].sta.key.key_offset =
704 iwl_get_free_ucode_key_index(priv);
705 /* else, we are overriding an existing key => no need to allocated room
706 * in uCode. */
707
40a9a829 708 WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
e724b8fe 709 "no space for a new key");
40a9a829 710
7480513f
EG		 711 priv->stations[sta_id].sta.key.key_flags = key_flags;
712 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
713 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
714
40a9a829
TW		 715 ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
716
7480513f
EG		 717 spin_unlock_irqrestore(&priv->sta_lock, flags);
718
40a9a829 719 return ret;
7480513f
EG		 720}
721
722static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
723 struct ieee80211_key_conf *keyconf,
724 u8 sta_id)
725{
726 unsigned long flags;
727 int ret = 0;
299f5462
RC		 728 __le16 key_flags = 0;
729
730 key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
731 key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
732 key_flags &= ~STA_KEY_FLG_INVALID;
733
734 if (sta_id == priv->hw_params.bcast_sta_id)
735 key_flags |= STA_KEY_MULTICAST_MSK;
7480513f
EG		 736
737 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
738 keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
7480513f
EG		 739
740 spin_lock_irqsave(&priv->sta_lock, flags);
741
742 priv->stations[sta_id].keyinfo.alg = keyconf->alg;
7480513f 743 priv->stations[sta_id].keyinfo.keylen = 16;
3ec47732
EG		 744
745 if ((priv->stations[sta_id].sta.key.key_flags & STA_KEY_FLG_ENCRYPT_MSK)
746 == STA_KEY_FLG_NO_ENC)
747 priv->stations[sta_id].sta.key.key_offset =
77bab602 748 iwl_get_free_ucode_key_index(priv);
3ec47732
EG		 749 /* else, we are overriding an existing key => no need to allocated room
750 * in uCode. */
7480513f 751
40a9a829 752 WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
e724b8fe 753 "no space for a new key");
40a9a829 754
299f5462
RC		 755 priv->stations[sta_id].sta.key.key_flags = key_flags;
756
757
7480513f
EG		 758 /* This copy is acutally not needed: we get the key with each TX */
759 memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key, 16);
760
761 memcpy(priv->stations[sta_id].sta.key.key, keyconf->key, 16);
762
763 spin_unlock_irqrestore(&priv->sta_lock, flags);
764
765 return ret;
766}
767
9f58671e
TW		 768void iwl_update_tkip_key(struct iwl_priv *priv,
769 struct ieee80211_key_conf *keyconf,
770 const u8 *addr, u32 iv32, u16 *phase1key)
771{
772 u8 sta_id = IWL_INVALID_STATION;
773 unsigned long flags;
9f58671e 774 int i;
9f58671e 775
c587de0b 776 sta_id = iwl_find_station(priv, addr);
9f58671e 777 if (sta_id == IWL_INVALID_STATION) {
e1623446 778 IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
9f58671e
TW		 779 addr);
780 return;
781 }
782
783 if (iwl_scan_cancel(priv)) {
784 /* cancel scan failed, just live w/ bad key and rely
785 briefly on SW decryption */
786 return;
787 }
788
9f58671e
TW		 789 spin_lock_irqsave(&priv->sta_lock, flags);
790
9f58671e
TW		 791 priv->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;
792
793 for (i = 0; i < 5; i++)
794 priv->stations[sta_id].sta.key.tkip_rx_ttak[i] =
795 cpu_to_le16(phase1key[i]);
796
797 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
798 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
799
800 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
801
802 spin_unlock_irqrestore(&priv->sta_lock, flags);
803
804}
805EXPORT_SYMBOL(iwl_update_tkip_key);
806
3ec47732
EG		 807int iwl_remove_dynamic_key(struct iwl_priv *priv,
808 struct ieee80211_key_conf *keyconf,
809 u8 sta_id)
7480513f
EG		 810{
811 unsigned long flags;
3ec47732
EG		 812 int ret = 0;
813 u16 key_flags;
814 u8 keyidx;
7480513f 815
ccc038ab 816 priv->key_mapping_key--;
7480513f
EG		 817
818 spin_lock_irqsave(&priv->sta_lock, flags);
3ec47732
EG		 819 key_flags = le16_to_cpu(priv->stations[sta_id].sta.key.key_flags);
820 keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;
821
e1623446 822 IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
4564ce8b
EG		 823 keyconf->keyidx, sta_id);
824
3ec47732
EG		 825 if (keyconf->keyidx != keyidx) {
826 /* We need to remove a key with index different that the one
827 * in the uCode. This means that the key we need to remove has
828 * been replaced by another one with different index.
829 * Don't do anything and return ok
830 */
831 spin_unlock_irqrestore(&priv->sta_lock, flags);
832 return 0;
833 }
834
40a9a829 835 if (priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
39aadf8c 836 IWL_WARN(priv, "Removing wrong key %d 0x%x\n",
40a9a829
TW		 837 keyconf->keyidx, key_flags);
838 spin_unlock_irqrestore(&priv->sta_lock, flags);
839 return 0;
840 }
841
7480513f
EG		 842 if (!test_and_clear_bit(priv->stations[sta_id].sta.key.key_offset,
843 &priv->ucode_key_table))
15b1687c 844 IWL_ERR(priv, "index %d not used in uCode key table.\n",
7480513f
EG		 845 priv->stations[sta_id].sta.key.key_offset);
846 memset(&priv->stations[sta_id].keyinfo, 0,
6def9761 847 sizeof(struct iwl_hw_key));
7480513f
EG		 848 memset(&priv->stations[sta_id].sta.key, 0,
849 sizeof(struct iwl4965_keyinfo));
3ec47732
EG		 850 priv->stations[sta_id].sta.key.key_flags =
851 STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
852 priv->stations[sta_id].sta.key.key_offset = WEP_INVALID_OFFSET;
7480513f
EG		 853 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
854 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
7480513f 855
ccc038ab 856 ret = iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
3ec47732
EG		 857 spin_unlock_irqrestore(&priv->sta_lock, flags);
858 return ret;
7480513f 859}
27aaba0c 860EXPORT_SYMBOL(iwl_remove_dynamic_key);
7480513f
EG		 861
862int iwl_set_dynamic_key(struct iwl_priv *priv,
ccc038ab 863 struct ieee80211_key_conf *keyconf, u8 sta_id)
7480513f
EG		 864{
865 int ret;
866
ccc038ab
EG		 867 priv->key_mapping_key++;
868 keyconf->hw_key_idx = HW_KEY_DYNAMIC;
7480513f 869
ccc038ab 870 switch (keyconf->alg) {
7480513f 871 case ALG_CCMP:
ccc038ab 872 ret = iwl_set_ccmp_dynamic_key_info(priv, keyconf, sta_id);
7480513f
EG		 873 break;
874 case ALG_TKIP:
ccc038ab 875 ret = iwl_set_tkip_dynamic_key_info(priv, keyconf, sta_id);
7480513f
EG		 876 break;
877 case ALG_WEP:
ccc038ab 878 ret = iwl_set_wep_dynamic_key_info(priv, keyconf, sta_id);
7480513f
EG		 879 break;
880 default:
15b1687c
WT		 881 IWL_ERR(priv,
882 "Unknown alg: %s alg = %d\n", __func__, keyconf->alg);
7480513f
EG		 883 ret = -EINVAL;
884 }
885
e1623446 886 IWL_DEBUG_WEP(priv, "Set dynamic key: alg= %d len=%d idx=%d sta=%d ret=%d\n",
4564ce8b
EG		 887 keyconf->alg, keyconf->keylen, keyconf->keyidx,
888 sta_id, ret);
889
7480513f
EG		 890 return ret;
891}
27aaba0c 892EXPORT_SYMBOL(iwl_set_dynamic_key);
7480513f 893
66c73db7
TW		 894#ifdef CONFIG_IWLWIFI_DEBUG
895static void iwl_dump_lq_cmd(struct iwl_priv *priv,
896 struct iwl_link_quality_cmd *lq)
897{
898 int i;
e1623446
TW		 899 IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
900 IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
66c73db7
TW		 901 lq->general_params.single_stream_ant_msk,
902 lq->general_params.dual_stream_ant_msk);
903
904 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
e1623446 905 IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
66c73db7
TW		 906 i, lq->rs_table[i].rate_n_flags);
907}
908#else
909static inline void iwl_dump_lq_cmd(struct iwl_priv *priv,
910 struct iwl_link_quality_cmd *lq)
911{
912}
913#endif
914
915int iwl_send_lq_cmd(struct iwl_priv *priv,
916 struct iwl_link_quality_cmd *lq, u8 flags)
917{
918 struct iwl_host_cmd cmd = {
919 .id = REPLY_TX_LINK_QUALITY_CMD,
920 .len = sizeof(struct iwl_link_quality_cmd),
921 .meta.flags = flags,
922 .data = lq,
923 };
924
925 if ((lq->sta_id == 0xFF) &&
05c914fe 926 (priv->iw_mode == NL80211_IFTYPE_ADHOC))
66c73db7
TW		 927 return -EINVAL;
928
929 if (lq->sta_id == 0xFF)
930 lq->sta_id = IWL_AP_ID;
931
3ac7f146 932 iwl_dump_lq_cmd(priv, lq);
66c73db7 933
36e1f16e 934 if (iwl_is_associated(priv) && priv->assoc_station_added)
66c73db7
TW		 935 return iwl_send_cmd(priv, &cmd);
936
937 return 0;
938}
939EXPORT_SYMBOL(iwl_send_lq_cmd);
940
4f40e4d9
TW		 941/**
942 * iwl_sta_init_lq - Initialize a station's hardware rate table
943 *
944 * The uCode's station table contains a table of fallback rates
945 * for automatic fallback during transmission.
946 *
947 * NOTE: This sets up a default set of values. These will be replaced later
e227ceac 948 * if the driver's iwl-agn-rs rate scaling algorithm is used, instead of
4f40e4d9
TW		 949 * rc80211_simple.
950 *
951 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before
952 * calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,
953 * which requires station table entry to exist).
954 */
c587de0b 955static void iwl_sta_init_lq(struct iwl_priv *priv, const u8 *addr, bool is_ap)
4f40e4d9
TW		 956{
957 int i, r;
958 struct iwl_link_quality_cmd link_cmd = {
959 .reserved1 = 0,
960 };
5d664a41 961 u32 rate_flags;
4f40e4d9
TW		 962
963 /* Set up the rate scaling to start at selected rate, fall back
964 * all the way down to 1M in IEEE order, and then spin on 1M */
965 if (is_ap)
966 r = IWL_RATE_54M_INDEX;
967 else if (priv->band == IEEE80211_BAND_5GHZ)
968 r = IWL_RATE_6M_INDEX;
969 else
970 r = IWL_RATE_1M_INDEX;
971
972 for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
973 rate_flags = 0;
974 if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE)
975 rate_flags |= RATE_MCS_CCK_MSK;
976
5d664a41
TW		 977 rate_flags |= first_antenna(priv->hw_params.valid_tx_ant) <<
978 RATE_MCS_ANT_POS;
4f40e4d9
TW		 979
980 link_cmd.rs_table[i].rate_n_flags =
e7d326ac 981 iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags);
eb4779c4 982 r = iwl_get_prev_ieee_rate(r);
4f40e4d9
TW		 983 }
984
5d664a41
TW		 985 link_cmd.general_params.single_stream_ant_msk =
986 first_antenna(priv->hw_params.valid_tx_ant);
4f40e4d9 987 link_cmd.general_params.dual_stream_ant_msk = 3;
13c33a09
WYG		 988 link_cmd.agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
989 link_cmd.agg_params.agg_time_limit =
990 cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
4f40e4d9
TW		 991
992 /* Update the rate scaling for control frame Tx to AP */
993 link_cmd.sta_id = is_ap ? IWL_AP_ID : priv->hw_params.bcast_sta_id;
994
995 iwl_send_cmd_pdu_async(priv, REPLY_TX_LINK_QUALITY_CMD,
996 sizeof(link_cmd), &link_cmd, NULL);
997}
24e5c401 998
4f40e4d9
TW		 999/**
1000 * iwl_rxon_add_station - add station into station table.
1001 *
1002 * there is only one AP station with id= IWL_AP_ID
a96a27f9 1003 * NOTE: mutex must be held before calling this function
4f40e4d9 1004 */
c587de0b 1005int iwl_rxon_add_station(struct iwl_priv *priv, const u8 *addr, bool is_ap)
4f40e4d9 1006{
ae5eb026
JB		 1007 struct ieee80211_sta *sta;
1008 struct ieee80211_sta_ht_cap ht_config;
1009 struct ieee80211_sta_ht_cap *cur_ht_config = NULL;
4f40e4d9
TW		 1010 u8 sta_id;
1011
1012 /* Add station to device's station table */
ae5eb026
JB		 1013
1014 /*
1015 * XXX: This check is definitely not correct, if we're an AP
1016 * it'll always be false which is not what we want, but
1017 * it doesn't look like iwlagn is prepared to be an HT
1018 * AP anyway.
1019 */
1020 if (priv->current_ht_config.is_ht) {
1021 rcu_read_lock();
1022 sta = ieee80211_find_sta(priv->hw, addr);
1023 if (sta) {
1024 memcpy(&ht_config, &sta->ht_cap, sizeof(ht_config));
1025 cur_ht_config = &ht_config;
1026 }
1027 rcu_read_unlock();
1028 }
1029
c587de0b 1030 sta_id = iwl_add_station(priv, addr, is_ap, CMD_SYNC, cur_ht_config);
4f40e4d9
TW		 1031
1032 /* Set up default rate scaling table in device's station table */
1033 iwl_sta_init_lq(priv, addr, is_ap);
1034
1035 return sta_id;
1036}
1037EXPORT_SYMBOL(iwl_rxon_add_station);
1038
4f40e4d9
TW		 1039/**
1040 * iwl_get_sta_id - Find station's index within station table
1041 *
1042 * If new IBSS station, create new entry in station table
1043 */
1044int iwl_get_sta_id(struct iwl_priv *priv, struct ieee80211_hdr *hdr)
1045{
1046 int sta_id;
1047 u16 fc = le16_to_cpu(hdr->frame_control);
4f40e4d9
TW		 1048
1049 /* If this frame is broadcast or management, use broadcast station id */
1050 if (((fc & IEEE80211_FCTL_FTYPE) != IEEE80211_FTYPE_DATA) ||
1051 is_multicast_ether_addr(hdr->addr1))
1052 return priv->hw_params.bcast_sta_id;
1053
1054 switch (priv->iw_mode) {
1055
1056 /* If we are a client station in a BSS network, use the special
1057 * AP station entry (that's the only station we communicate with) */
05c914fe 1058 case NL80211_IFTYPE_STATION:
4f40e4d9
TW		 1059 return IWL_AP_ID;
1060
1061 /* If we are an AP, then find the station, or use BCAST */
05c914fe 1062 case NL80211_IFTYPE_AP:
c587de0b 1063 sta_id = iwl_find_station(priv, hdr->addr1);
4f40e4d9
TW		 1064 if (sta_id != IWL_INVALID_STATION)
1065 return sta_id;
1066 return priv->hw_params.bcast_sta_id;
1067
1068 /* If this frame is going out to an IBSS network, find the station,
1069 * or create a new station table entry */
05c914fe 1070 case NL80211_IFTYPE_ADHOC:
c587de0b 1071 sta_id = iwl_find_station(priv, hdr->addr1);
4f40e4d9
TW		 1072 if (sta_id != IWL_INVALID_STATION)
1073 return sta_id;
1074
1075 /* Create new station table entry */
c587de0b
TW		 1076 sta_id = iwl_add_station(priv, hdr->addr1, false,
1077 CMD_ASYNC, NULL);
4f40e4d9
TW		 1078
1079 if (sta_id != IWL_INVALID_STATION)
1080 return sta_id;
1081
e1623446 1082 IWL_DEBUG_DROP(priv, "Station %pM not in station map. "
4f40e4d9 1083 "Defaulting to broadcast...\n",
e174961c 1084 hdr->addr1);
4f40e4d9
TW		 1085 iwl_print_hex_dump(priv, IWL_DL_DROP, (u8 *) hdr, sizeof(*hdr));
1086 return priv->hw_params.bcast_sta_id;
1087
1088 default:
39aadf8c
WT		 1089 IWL_WARN(priv, "Unknown mode of operation: %d\n",
1090 priv->iw_mode);
4f40e4d9
TW		 1091 return priv->hw_params.bcast_sta_id;
1092 }
1093}
1094EXPORT_SYMBOL(iwl_get_sta_id);
1095
5083e563 1096/**
9f58671e 1097 * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
5083e563 1098 */
9f58671e 1099void iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
5083e563
TW		 1100{
1101 unsigned long flags;
1102
1103 /* Remove "disable" flag, to enable Tx for this TID */
1104 spin_lock_irqsave(&priv->sta_lock, flags);
1105 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
1106 priv->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
1107 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1108 spin_unlock_irqrestore(&priv->sta_lock, flags);
1109
1110 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
1111}
9f58671e
TW		 1112EXPORT_SYMBOL(iwl_sta_tx_modify_enable_tid);
1113
1114int iwl_sta_rx_agg_start(struct iwl_priv *priv,
1115 const u8 *addr, int tid, u16 ssn)
1116{
1117 unsigned long flags;
1118 int sta_id;
1119
c587de0b 1120 sta_id = iwl_find_station(priv, addr);
9f58671e
TW		 1121 if (sta_id == IWL_INVALID_STATION)
1122 return -ENXIO;
1123
1124 spin_lock_irqsave(&priv->sta_lock, flags);
1125 priv->stations[sta_id].sta.station_flags_msk = 0;
1126 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
1127 priv->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
1128 priv->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
1129 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1130 spin_unlock_irqrestore(&priv->sta_lock, flags);
1131
1132 return iwl_send_add_sta(priv, &priv->stations[sta_id].sta,
1133 CMD_ASYNC);
1134}
1135EXPORT_SYMBOL(iwl_sta_rx_agg_start);
1136
1137int iwl_sta_rx_agg_stop(struct iwl_priv *priv, const u8 *addr, int tid)
1138{
1139 unsigned long flags;
1140 int sta_id;
1141
c587de0b 1142 sta_id = iwl_find_station(priv, addr);
a2f1cbeb
WYG		 1143 if (sta_id == IWL_INVALID_STATION) {
1144 IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
9f58671e 1145 return -ENXIO;
a2f1cbeb 1146 }
9f58671e
TW		 1147
1148 spin_lock_irqsave(&priv->sta_lock, flags);
1149 priv->stations[sta_id].sta.station_flags_msk = 0;
1150 priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
1151 priv->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
1152 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1153 spin_unlock_irqrestore(&priv->sta_lock, flags);
1154
1155 return iwl_send_add_sta(priv, &priv->stations[sta_id].sta,
1156 CMD_ASYNC);
1157}
1158EXPORT_SYMBOL(iwl_sta_rx_agg_stop);
1159
1160static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
1161{
1162 unsigned long flags;
1163
1164 spin_lock_irqsave(&priv->sta_lock, flags);
1165 priv->stations[sta_id].sta.station_flags &= ~STA_FLG_PWR_SAVE_MSK;
1166 priv->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
1167 priv->stations[sta_id].sta.sta.modify_mask = 0;
1168 priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1169 spin_unlock_irqrestore(&priv->sta_lock, flags);
1170
1171 iwl_send_add_sta(priv, &priv->stations[sta_id].sta, CMD_ASYNC);
1172}
1173
1174void iwl_update_ps_mode(struct iwl_priv *priv, u16 ps_bit, u8 *addr)
1175{
1176 /* FIXME: need locking over ps_status ??? */
c587de0b 1177 u8 sta_id = iwl_find_station(priv, addr);
9f58671e
TW		 1178
1179 if (sta_id != IWL_INVALID_STATION) {
1180 u8 sta_awake = priv->stations[sta_id].
1181 ps_status == STA_PS_STATUS_WAKE;
1182
1183 if (sta_awake && ps_bit)
1184 priv->stations[sta_id].ps_status = STA_PS_STATUS_SLEEP;
1185 else if (!sta_awake && !ps_bit) {
1186 iwl_sta_modify_ps_wake(priv, sta_id);
1187 priv->stations[sta_id].ps_status = STA_PS_STATUS_WAKE;
1188 }
1189 }
1190}
5083e563 1191
Linux kernel - Deliverables
This page took 0.302327 seconds and 5 git commands to generate.