14273a380SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2e705c121SKalle Valo /******************************************************************************
3e705c121SKalle Valo *
4261ce887SBenjamin Berg * Copyright(c) 2003 - 2014, 2022 Intel Corporation. All rights reserved.
5e705c121SKalle Valo *
6e705c121SKalle Valo * Portions of this file are derived from the ipw3945 project, as well
7e705c121SKalle Valo * as portions of the ieee80211 subsystem header files.
8e705c121SKalle Valo *****************************************************************************/
9e705c121SKalle Valo #include <linux/etherdevice.h>
10e705c121SKalle Valo #include <net/mac80211.h>
11e705c121SKalle Valo #include "iwl-trans.h"
12e705c121SKalle Valo #include "dev.h"
13e705c121SKalle Valo #include "agn.h"
14e705c121SKalle Valo
15e705c121SKalle Valo const u8 iwl_bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
16e705c121SKalle Valo
iwl_sta_ucode_activate(struct iwl_priv * priv,u8 sta_id)17e705c121SKalle Valo static int iwl_sta_ucode_activate(struct iwl_priv *priv, u8 sta_id)
18e705c121SKalle Valo {
19e705c121SKalle Valo lockdep_assert_held(&priv->sta_lock);
20e705c121SKalle Valo
21e705c121SKalle Valo if (sta_id >= IWLAGN_STATION_COUNT) {
22e705c121SKalle Valo IWL_ERR(priv, "invalid sta_id %u\n", sta_id);
23e705c121SKalle Valo return -EINVAL;
24e705c121SKalle Valo }
25e705c121SKalle Valo if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE))
26e705c121SKalle Valo IWL_ERR(priv, "ACTIVATE a non DRIVER active station id %u "
27e705c121SKalle Valo "addr %pM\n",
28e705c121SKalle Valo sta_id, priv->stations[sta_id].sta.sta.addr);
29e705c121SKalle Valo
30e705c121SKalle Valo if (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) {
31e705c121SKalle Valo IWL_DEBUG_ASSOC(priv,
32e705c121SKalle Valo "STA id %u addr %pM already present in uCode "
33e705c121SKalle Valo "(according to driver)\n",
34e705c121SKalle Valo sta_id, priv->stations[sta_id].sta.sta.addr);
35e705c121SKalle Valo } else {
36e705c121SKalle Valo priv->stations[sta_id].used |= IWL_STA_UCODE_ACTIVE;
37e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Added STA id %u addr %pM to uCode\n",
38e705c121SKalle Valo sta_id, priv->stations[sta_id].sta.sta.addr);
39e705c121SKalle Valo }
40e705c121SKalle Valo return 0;
41e705c121SKalle Valo }
42e705c121SKalle Valo
iwl_process_add_sta_resp(struct iwl_priv * priv,struct iwl_rx_packet * pkt)43e705c121SKalle Valo static void iwl_process_add_sta_resp(struct iwl_priv *priv,
44e705c121SKalle Valo struct iwl_rx_packet *pkt)
45e705c121SKalle Valo {
46e705c121SKalle Valo struct iwl_add_sta_resp *add_sta_resp = (void *)pkt->data;
47e705c121SKalle Valo
48e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Processing response for adding station\n");
49e705c121SKalle Valo
50e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
51e705c121SKalle Valo
52e705c121SKalle Valo switch (add_sta_resp->status) {
53e705c121SKalle Valo case ADD_STA_SUCCESS_MSK:
54e705c121SKalle Valo IWL_DEBUG_INFO(priv, "REPLY_ADD_STA PASSED\n");
55e705c121SKalle Valo break;
56e705c121SKalle Valo case ADD_STA_NO_ROOM_IN_TABLE:
57e705c121SKalle Valo IWL_ERR(priv, "Adding station failed, no room in table.\n");
58e705c121SKalle Valo break;
59e705c121SKalle Valo case ADD_STA_NO_BLOCK_ACK_RESOURCE:
60e705c121SKalle Valo IWL_ERR(priv,
61e705c121SKalle Valo "Adding station failed, no block ack resource.\n");
62e705c121SKalle Valo break;
63e705c121SKalle Valo case ADD_STA_MODIFY_NON_EXIST_STA:
64e705c121SKalle Valo IWL_ERR(priv, "Attempting to modify non-existing station\n");
65e705c121SKalle Valo break;
66e705c121SKalle Valo default:
67e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Received REPLY_ADD_STA:(0x%08X)\n",
68e705c121SKalle Valo add_sta_resp->status);
69e705c121SKalle Valo break;
70e705c121SKalle Valo }
71e705c121SKalle Valo
72e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
73e705c121SKalle Valo }
74e705c121SKalle Valo
iwl_add_sta_callback(struct iwl_priv * priv,struct iwl_rx_cmd_buffer * rxb)75e705c121SKalle Valo void iwl_add_sta_callback(struct iwl_priv *priv, struct iwl_rx_cmd_buffer *rxb)
76e705c121SKalle Valo {
77e705c121SKalle Valo struct iwl_rx_packet *pkt = rxb_addr(rxb);
78e705c121SKalle Valo
79e705c121SKalle Valo iwl_process_add_sta_resp(priv, pkt);
80e705c121SKalle Valo }
81e705c121SKalle Valo
iwl_send_add_sta(struct iwl_priv * priv,struct iwl_addsta_cmd * sta,u8 flags)82e705c121SKalle Valo int iwl_send_add_sta(struct iwl_priv *priv,
83e705c121SKalle Valo struct iwl_addsta_cmd *sta, u8 flags)
84e705c121SKalle Valo {
85e705c121SKalle Valo int ret = 0;
86e705c121SKalle Valo struct iwl_host_cmd cmd = {
87e705c121SKalle Valo .id = REPLY_ADD_STA,
88e705c121SKalle Valo .flags = flags,
89e705c121SKalle Valo .data = { sta, },
90e705c121SKalle Valo .len = { sizeof(*sta), },
91e705c121SKalle Valo };
92e705c121SKalle Valo u8 sta_id __maybe_unused = sta->sta.sta_id;
93e705c121SKalle Valo struct iwl_rx_packet *pkt;
94e705c121SKalle Valo struct iwl_add_sta_resp *add_sta_resp;
95e705c121SKalle Valo
96e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Adding sta %u (%pM) %ssynchronously\n",
97e705c121SKalle Valo sta_id, sta->sta.addr, flags & CMD_ASYNC ? "a" : "");
98e705c121SKalle Valo
99e705c121SKalle Valo if (!(flags & CMD_ASYNC)) {
100e705c121SKalle Valo cmd.flags |= CMD_WANT_SKB;
101e705c121SKalle Valo might_sleep();
102e705c121SKalle Valo }
103e705c121SKalle Valo
104e705c121SKalle Valo ret = iwl_dvm_send_cmd(priv, &cmd);
105e705c121SKalle Valo
106e705c121SKalle Valo if (ret || (flags & CMD_ASYNC))
107e705c121SKalle Valo return ret;
108e705c121SKalle Valo
109e705c121SKalle Valo pkt = cmd.resp_pkt;
110e705c121SKalle Valo add_sta_resp = (void *)pkt->data;
111e705c121SKalle Valo
112e705c121SKalle Valo /* debug messages are printed in the handler */
113e705c121SKalle Valo if (add_sta_resp->status == ADD_STA_SUCCESS_MSK) {
114e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
115e705c121SKalle Valo ret = iwl_sta_ucode_activate(priv, sta_id);
116e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
117e705c121SKalle Valo } else {
118e705c121SKalle Valo ret = -EIO;
119e705c121SKalle Valo }
120e705c121SKalle Valo
121e705c121SKalle Valo iwl_free_resp(&cmd);
122e705c121SKalle Valo
123e705c121SKalle Valo return ret;
124e705c121SKalle Valo }
125e705c121SKalle Valo
iwl_is_ht40_tx_allowed(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct ieee80211_sta * sta)126e705c121SKalle Valo bool iwl_is_ht40_tx_allowed(struct iwl_priv *priv,
127e705c121SKalle Valo struct iwl_rxon_context *ctx,
128e705c121SKalle Valo struct ieee80211_sta *sta)
129e705c121SKalle Valo {
130e705c121SKalle Valo if (!ctx->ht.enabled || !ctx->ht.is_40mhz)
131e705c121SKalle Valo return false;
132e705c121SKalle Valo
133e705c121SKalle Valo #ifdef CONFIG_IWLWIFI_DEBUGFS
134e705c121SKalle Valo if (priv->disable_ht40)
135e705c121SKalle Valo return false;
136e705c121SKalle Valo #endif
137e705c121SKalle Valo
138e705c121SKalle Valo /* special case for RXON */
139e705c121SKalle Valo if (!sta)
140e705c121SKalle Valo return true;
141e705c121SKalle Valo
142046d2e7cSSriram R return sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40;
143e705c121SKalle Valo }
144e705c121SKalle Valo
iwl_sta_calc_ht_flags(struct iwl_priv * priv,struct ieee80211_sta * sta,struct iwl_rxon_context * ctx,__le32 * flags,__le32 * mask)145e705c121SKalle Valo static void iwl_sta_calc_ht_flags(struct iwl_priv *priv,
146e705c121SKalle Valo struct ieee80211_sta *sta,
147e705c121SKalle Valo struct iwl_rxon_context *ctx,
148e705c121SKalle Valo __le32 *flags, __le32 *mask)
149e705c121SKalle Valo {
150046d2e7cSSriram R struct ieee80211_sta_ht_cap *sta_ht_inf = &sta->deflink.ht_cap;
151e705c121SKalle Valo
152e705c121SKalle Valo *mask = STA_FLG_RTS_MIMO_PROT_MSK |
153e705c121SKalle Valo STA_FLG_MIMO_DIS_MSK |
154e705c121SKalle Valo STA_FLG_HT40_EN_MSK |
155e705c121SKalle Valo STA_FLG_MAX_AGG_SIZE_MSK |
156e705c121SKalle Valo STA_FLG_AGG_MPDU_DENSITY_MSK;
157e705c121SKalle Valo *flags = 0;
158e705c121SKalle Valo
159e705c121SKalle Valo if (!sta || !sta_ht_inf->ht_supported)
160e705c121SKalle Valo return;
161e705c121SKalle Valo
162e705c121SKalle Valo IWL_DEBUG_INFO(priv, "STA %pM SM PS mode: %s\n",
163e705c121SKalle Valo sta->addr,
164261ce887SBenjamin Berg (sta->deflink.smps_mode == IEEE80211_SMPS_STATIC) ?
165e705c121SKalle Valo "static" :
166261ce887SBenjamin Berg (sta->deflink.smps_mode == IEEE80211_SMPS_DYNAMIC) ?
167e705c121SKalle Valo "dynamic" : "disabled");
168e705c121SKalle Valo
169261ce887SBenjamin Berg switch (sta->deflink.smps_mode) {
170e705c121SKalle Valo case IEEE80211_SMPS_STATIC:
171e705c121SKalle Valo *flags |= STA_FLG_MIMO_DIS_MSK;
172e705c121SKalle Valo break;
173e705c121SKalle Valo case IEEE80211_SMPS_DYNAMIC:
174e705c121SKalle Valo *flags |= STA_FLG_RTS_MIMO_PROT_MSK;
175e705c121SKalle Valo break;
176e705c121SKalle Valo case IEEE80211_SMPS_OFF:
177e705c121SKalle Valo break;
178e705c121SKalle Valo default:
179261ce887SBenjamin Berg IWL_WARN(priv, "Invalid MIMO PS mode %d\n", sta->deflink.smps_mode);
180e705c121SKalle Valo break;
181e705c121SKalle Valo }
182e705c121SKalle Valo
183e705c121SKalle Valo *flags |= cpu_to_le32(
184e705c121SKalle Valo (u32)sta_ht_inf->ampdu_factor << STA_FLG_MAX_AGG_SIZE_POS);
185e705c121SKalle Valo
186e705c121SKalle Valo *flags |= cpu_to_le32(
187e705c121SKalle Valo (u32)sta_ht_inf->ampdu_density << STA_FLG_AGG_MPDU_DENSITY_POS);
188e705c121SKalle Valo
189e705c121SKalle Valo if (iwl_is_ht40_tx_allowed(priv, ctx, sta))
190e705c121SKalle Valo *flags |= STA_FLG_HT40_EN_MSK;
191e705c121SKalle Valo }
192e705c121SKalle Valo
iwl_sta_update_ht(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct ieee80211_sta * sta)193e705c121SKalle Valo int iwl_sta_update_ht(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
194e705c121SKalle Valo struct ieee80211_sta *sta)
195e705c121SKalle Valo {
196e705c121SKalle Valo u8 sta_id = iwl_sta_id(sta);
197e705c121SKalle Valo __le32 flags, mask;
198e705c121SKalle Valo struct iwl_addsta_cmd cmd;
199e705c121SKalle Valo
200e705c121SKalle Valo if (WARN_ON_ONCE(sta_id == IWL_INVALID_STATION))
201e705c121SKalle Valo return -EINVAL;
202e705c121SKalle Valo
203e705c121SKalle Valo iwl_sta_calc_ht_flags(priv, sta, ctx, &flags, &mask);
204e705c121SKalle Valo
205e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
206e705c121SKalle Valo priv->stations[sta_id].sta.station_flags &= ~mask;
207e705c121SKalle Valo priv->stations[sta_id].sta.station_flags |= flags;
208e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
209e705c121SKalle Valo
210e705c121SKalle Valo memset(&cmd, 0, sizeof(cmd));
211e705c121SKalle Valo cmd.mode = STA_CONTROL_MODIFY_MSK;
212e705c121SKalle Valo cmd.station_flags_msk = mask;
213e705c121SKalle Valo cmd.station_flags = flags;
214e705c121SKalle Valo cmd.sta.sta_id = sta_id;
215e705c121SKalle Valo
216e705c121SKalle Valo return iwl_send_add_sta(priv, &cmd, 0);
217e705c121SKalle Valo }
218e705c121SKalle Valo
iwl_set_ht_add_station(struct iwl_priv * priv,u8 index,struct ieee80211_sta * sta,struct iwl_rxon_context * ctx)219e705c121SKalle Valo static void iwl_set_ht_add_station(struct iwl_priv *priv, u8 index,
220e705c121SKalle Valo struct ieee80211_sta *sta,
221e705c121SKalle Valo struct iwl_rxon_context *ctx)
222e705c121SKalle Valo {
223e705c121SKalle Valo __le32 flags, mask;
224e705c121SKalle Valo
225e705c121SKalle Valo iwl_sta_calc_ht_flags(priv, sta, ctx, &flags, &mask);
226e705c121SKalle Valo
227e705c121SKalle Valo lockdep_assert_held(&priv->sta_lock);
228e705c121SKalle Valo priv->stations[index].sta.station_flags &= ~mask;
229e705c121SKalle Valo priv->stations[index].sta.station_flags |= flags;
230e705c121SKalle Valo }
231e705c121SKalle Valo
2328f7ed7bfSLee Jones /*
233e705c121SKalle Valo * iwl_prep_station - Prepare station information for addition
234e705c121SKalle Valo *
235e705c121SKalle Valo * should be called with sta_lock held
236e705c121SKalle Valo */
iwl_prep_station(struct iwl_priv * priv,struct iwl_rxon_context * ctx,const u8 * addr,bool is_ap,struct ieee80211_sta * sta)237e705c121SKalle Valo u8 iwl_prep_station(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
238e705c121SKalle Valo const u8 *addr, bool is_ap, struct ieee80211_sta *sta)
239e705c121SKalle Valo {
240e705c121SKalle Valo struct iwl_station_entry *station;
241e705c121SKalle Valo int i;
242e705c121SKalle Valo u8 sta_id = IWL_INVALID_STATION;
243e705c121SKalle Valo
244e705c121SKalle Valo if (is_ap)
245e705c121SKalle Valo sta_id = ctx->ap_sta_id;
246e705c121SKalle Valo else if (is_broadcast_ether_addr(addr))
247e705c121SKalle Valo sta_id = ctx->bcast_sta_id;
248e705c121SKalle Valo else
249e705c121SKalle Valo for (i = IWL_STA_ID; i < IWLAGN_STATION_COUNT; i++) {
250e705c121SKalle Valo if (ether_addr_equal(priv->stations[i].sta.sta.addr,
251e705c121SKalle Valo addr)) {
252e705c121SKalle Valo sta_id = i;
253e705c121SKalle Valo break;
254e705c121SKalle Valo }
255e705c121SKalle Valo
256e705c121SKalle Valo if (!priv->stations[i].used &&
257e705c121SKalle Valo sta_id == IWL_INVALID_STATION)
258e705c121SKalle Valo sta_id = i;
259e705c121SKalle Valo }
260e705c121SKalle Valo
261e705c121SKalle Valo /*
262e705c121SKalle Valo * These two conditions have the same outcome, but keep them
263e705c121SKalle Valo * separate
264e705c121SKalle Valo */
265e705c121SKalle Valo if (unlikely(sta_id == IWL_INVALID_STATION))
266e705c121SKalle Valo return sta_id;
267e705c121SKalle Valo
268e705c121SKalle Valo /*
269e705c121SKalle Valo * uCode is not able to deal with multiple requests to add a
270e705c121SKalle Valo * station. Keep track if one is in progress so that we do not send
271e705c121SKalle Valo * another.
272e705c121SKalle Valo */
273e705c121SKalle Valo if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
274e705c121SKalle Valo IWL_DEBUG_INFO(priv, "STA %d already in process of being "
275e705c121SKalle Valo "added.\n", sta_id);
276e705c121SKalle Valo return sta_id;
277e705c121SKalle Valo }
278e705c121SKalle Valo
279e705c121SKalle Valo if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
280e705c121SKalle Valo (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE) &&
281e705c121SKalle Valo ether_addr_equal(priv->stations[sta_id].sta.sta.addr, addr)) {
282e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not "
283e705c121SKalle Valo "adding again.\n", sta_id, addr);
284e705c121SKalle Valo return sta_id;
285e705c121SKalle Valo }
286e705c121SKalle Valo
287e705c121SKalle Valo station = &priv->stations[sta_id];
288e705c121SKalle Valo station->used = IWL_STA_DRIVER_ACTIVE;
289e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Add STA to driver ID %d: %pM\n",
290e705c121SKalle Valo sta_id, addr);
291e705c121SKalle Valo priv->num_stations++;
292e705c121SKalle Valo
293e705c121SKalle Valo /* Set up the REPLY_ADD_STA command to send to device */
294e705c121SKalle Valo memset(&station->sta, 0, sizeof(struct iwl_addsta_cmd));
295e705c121SKalle Valo memcpy(station->sta.sta.addr, addr, ETH_ALEN);
296e705c121SKalle Valo station->sta.mode = 0;
297e705c121SKalle Valo station->sta.sta.sta_id = sta_id;
298e705c121SKalle Valo station->sta.station_flags = ctx->station_flags;
299e705c121SKalle Valo station->ctxid = ctx->ctxid;
300e705c121SKalle Valo
301e705c121SKalle Valo if (sta) {
302e705c121SKalle Valo struct iwl_station_priv *sta_priv;
303e705c121SKalle Valo
304e705c121SKalle Valo sta_priv = (void *)sta->drv_priv;
305e705c121SKalle Valo sta_priv->ctx = ctx;
306e705c121SKalle Valo }
307e705c121SKalle Valo
308e705c121SKalle Valo /*
309e705c121SKalle Valo * OK to call unconditionally, since local stations (IBSS BSSID
310e705c121SKalle Valo * STA and broadcast STA) pass in a NULL sta, and mac80211
311e705c121SKalle Valo * doesn't allow HT IBSS.
312e705c121SKalle Valo */
313e705c121SKalle Valo iwl_set_ht_add_station(priv, sta_id, sta, ctx);
314e705c121SKalle Valo
315e705c121SKalle Valo return sta_id;
316e705c121SKalle Valo
317e705c121SKalle Valo }
318e705c121SKalle Valo
319e705c121SKalle Valo #define STA_WAIT_TIMEOUT (HZ/2)
320e705c121SKalle Valo
3218f7ed7bfSLee Jones /*
322e705c121SKalle Valo * iwl_add_station_common -
323e705c121SKalle Valo */
iwl_add_station_common(struct iwl_priv * priv,struct iwl_rxon_context * ctx,const u8 * addr,bool is_ap,struct ieee80211_sta * sta,u8 * sta_id_r)324e705c121SKalle Valo int iwl_add_station_common(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
325e705c121SKalle Valo const u8 *addr, bool is_ap,
326e705c121SKalle Valo struct ieee80211_sta *sta, u8 *sta_id_r)
327e705c121SKalle Valo {
328e705c121SKalle Valo int ret = 0;
329e705c121SKalle Valo u8 sta_id;
330e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
331e705c121SKalle Valo
332e705c121SKalle Valo *sta_id_r = 0;
333e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
334e705c121SKalle Valo sta_id = iwl_prep_station(priv, ctx, addr, is_ap, sta);
335e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION) {
336e705c121SKalle Valo IWL_ERR(priv, "Unable to prepare station %pM for addition\n",
337e705c121SKalle Valo addr);
338e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
339e705c121SKalle Valo return -EINVAL;
340e705c121SKalle Valo }
341e705c121SKalle Valo
342e705c121SKalle Valo /*
343e705c121SKalle Valo * uCode is not able to deal with multiple requests to add a
344e705c121SKalle Valo * station. Keep track if one is in progress so that we do not send
345e705c121SKalle Valo * another.
346e705c121SKalle Valo */
347e705c121SKalle Valo if (priv->stations[sta_id].used & IWL_STA_UCODE_INPROGRESS) {
348e705c121SKalle Valo IWL_DEBUG_INFO(priv, "STA %d already in process of being "
349e705c121SKalle Valo "added.\n", sta_id);
350e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
351e705c121SKalle Valo return -EEXIST;
352e705c121SKalle Valo }
353e705c121SKalle Valo
354e705c121SKalle Valo if ((priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE) &&
355e705c121SKalle Valo (priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
356e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "STA %d (%pM) already added, not "
357e705c121SKalle Valo "adding again.\n", sta_id, addr);
358e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
359e705c121SKalle Valo return -EEXIST;
360e705c121SKalle Valo }
361e705c121SKalle Valo
362e705c121SKalle Valo priv->stations[sta_id].used |= IWL_STA_UCODE_INPROGRESS;
363e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[sta_id].sta,
364e705c121SKalle Valo sizeof(struct iwl_addsta_cmd));
365e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
366e705c121SKalle Valo
367e705c121SKalle Valo /* Add station to device's station table */
368e705c121SKalle Valo ret = iwl_send_add_sta(priv, &sta_cmd, 0);
369e705c121SKalle Valo if (ret) {
370e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
371e705c121SKalle Valo IWL_ERR(priv, "Adding station %pM failed.\n",
372e705c121SKalle Valo priv->stations[sta_id].sta.sta.addr);
373e705c121SKalle Valo priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
374e705c121SKalle Valo priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
375e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
376e705c121SKalle Valo }
377e705c121SKalle Valo *sta_id_r = sta_id;
378e705c121SKalle Valo return ret;
379e705c121SKalle Valo }
380e705c121SKalle Valo
3818f7ed7bfSLee Jones /*
382e705c121SKalle Valo * iwl_sta_ucode_deactivate - deactivate ucode status for a station
383e705c121SKalle Valo */
iwl_sta_ucode_deactivate(struct iwl_priv * priv,u8 sta_id)384e705c121SKalle Valo static void iwl_sta_ucode_deactivate(struct iwl_priv *priv, u8 sta_id)
385e705c121SKalle Valo {
386e705c121SKalle Valo lockdep_assert_held(&priv->sta_lock);
387e705c121SKalle Valo
388e705c121SKalle Valo /* Ucode must be active and driver must be non active */
389e705c121SKalle Valo if ((priv->stations[sta_id].used &
390e705c121SKalle Valo (IWL_STA_UCODE_ACTIVE | IWL_STA_DRIVER_ACTIVE)) !=
391e705c121SKalle Valo IWL_STA_UCODE_ACTIVE)
392e705c121SKalle Valo IWL_ERR(priv, "removed non active STA %u\n", sta_id);
393e705c121SKalle Valo
394e705c121SKalle Valo priv->stations[sta_id].used &= ~IWL_STA_UCODE_ACTIVE;
395e705c121SKalle Valo
396e705c121SKalle Valo memset(&priv->stations[sta_id], 0, sizeof(struct iwl_station_entry));
397e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Removed STA %u\n", sta_id);
398e705c121SKalle Valo }
399e705c121SKalle Valo
iwl_send_remove_station(struct iwl_priv * priv,const u8 * addr,int sta_id,bool temporary)400e705c121SKalle Valo static int iwl_send_remove_station(struct iwl_priv *priv,
401e705c121SKalle Valo const u8 *addr, int sta_id,
402e705c121SKalle Valo bool temporary)
403e705c121SKalle Valo {
404e705c121SKalle Valo struct iwl_rx_packet *pkt;
405e705c121SKalle Valo int ret;
406e705c121SKalle Valo struct iwl_rem_sta_cmd rm_sta_cmd;
407e705c121SKalle Valo struct iwl_rem_sta_resp *rem_sta_resp;
408e705c121SKalle Valo
409e705c121SKalle Valo struct iwl_host_cmd cmd = {
410e705c121SKalle Valo .id = REPLY_REMOVE_STA,
411e705c121SKalle Valo .len = { sizeof(struct iwl_rem_sta_cmd), },
412e705c121SKalle Valo .data = { &rm_sta_cmd, },
413e705c121SKalle Valo };
414e705c121SKalle Valo
415e705c121SKalle Valo memset(&rm_sta_cmd, 0, sizeof(rm_sta_cmd));
416e705c121SKalle Valo rm_sta_cmd.num_sta = 1;
417e705c121SKalle Valo memcpy(&rm_sta_cmd.addr, addr, ETH_ALEN);
418e705c121SKalle Valo
419e705c121SKalle Valo cmd.flags |= CMD_WANT_SKB;
420e705c121SKalle Valo
421e705c121SKalle Valo ret = iwl_dvm_send_cmd(priv, &cmd);
422e705c121SKalle Valo
423e705c121SKalle Valo if (ret)
424e705c121SKalle Valo return ret;
425e705c121SKalle Valo
426e705c121SKalle Valo pkt = cmd.resp_pkt;
427e705c121SKalle Valo rem_sta_resp = (void *)pkt->data;
428e705c121SKalle Valo
429e705c121SKalle Valo switch (rem_sta_resp->status) {
430e705c121SKalle Valo case REM_STA_SUCCESS_MSK:
431e705c121SKalle Valo if (!temporary) {
432e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
433e705c121SKalle Valo iwl_sta_ucode_deactivate(priv, sta_id);
434e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
435e705c121SKalle Valo }
436e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "REPLY_REMOVE_STA PASSED\n");
437e705c121SKalle Valo break;
438e705c121SKalle Valo default:
439e705c121SKalle Valo ret = -EIO;
440e705c121SKalle Valo IWL_ERR(priv, "REPLY_REMOVE_STA failed\n");
441e705c121SKalle Valo break;
442e705c121SKalle Valo }
443e705c121SKalle Valo
444e705c121SKalle Valo iwl_free_resp(&cmd);
445e705c121SKalle Valo
446e705c121SKalle Valo return ret;
447e705c121SKalle Valo }
448e705c121SKalle Valo
4498f7ed7bfSLee Jones /*
450e705c121SKalle Valo * iwl_remove_station - Remove driver's knowledge of station.
451e705c121SKalle Valo */
iwl_remove_station(struct iwl_priv * priv,const u8 sta_id,const u8 * addr)452e705c121SKalle Valo int iwl_remove_station(struct iwl_priv *priv, const u8 sta_id,
453e705c121SKalle Valo const u8 *addr)
454e705c121SKalle Valo {
455e705c121SKalle Valo u8 tid;
456e705c121SKalle Valo
457e705c121SKalle Valo if (!iwl_is_ready(priv)) {
458e705c121SKalle Valo IWL_DEBUG_INFO(priv,
459e705c121SKalle Valo "Unable to remove station %pM, device not ready.\n",
460e705c121SKalle Valo addr);
461e705c121SKalle Valo /*
462e705c121SKalle Valo * It is typical for stations to be removed when we are
463e705c121SKalle Valo * going down. Return success since device will be down
464e705c121SKalle Valo * soon anyway
465e705c121SKalle Valo */
466e705c121SKalle Valo return 0;
467e705c121SKalle Valo }
468e705c121SKalle Valo
469e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Removing STA from driver:%d %pM\n",
470e705c121SKalle Valo sta_id, addr);
471e705c121SKalle Valo
472e705c121SKalle Valo if (WARN_ON(sta_id == IWL_INVALID_STATION))
473e705c121SKalle Valo return -EINVAL;
474e705c121SKalle Valo
475e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
476e705c121SKalle Valo
477e705c121SKalle Valo if (!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
478e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Removing %pM but non DRIVER active\n",
479e705c121SKalle Valo addr);
480e705c121SKalle Valo goto out_err;
481e705c121SKalle Valo }
482e705c121SKalle Valo
483e705c121SKalle Valo if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE)) {
484e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Removing %pM but non UCODE active\n",
485e705c121SKalle Valo addr);
486e705c121SKalle Valo goto out_err;
487e705c121SKalle Valo }
488e705c121SKalle Valo
489e705c121SKalle Valo if (priv->stations[sta_id].used & IWL_STA_LOCAL) {
490e705c121SKalle Valo kfree(priv->stations[sta_id].lq);
491e705c121SKalle Valo priv->stations[sta_id].lq = NULL;
492e705c121SKalle Valo }
493e705c121SKalle Valo
494e705c121SKalle Valo for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++)
495e705c121SKalle Valo memset(&priv->tid_data[sta_id][tid], 0,
496e705c121SKalle Valo sizeof(priv->tid_data[sta_id][tid]));
497e705c121SKalle Valo
498e705c121SKalle Valo priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
499e705c121SKalle Valo
500e705c121SKalle Valo priv->num_stations--;
501e705c121SKalle Valo
502e705c121SKalle Valo if (WARN_ON(priv->num_stations < 0))
503e705c121SKalle Valo priv->num_stations = 0;
504e705c121SKalle Valo
505e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
506e705c121SKalle Valo
507e705c121SKalle Valo return iwl_send_remove_station(priv, addr, sta_id, false);
508e705c121SKalle Valo out_err:
509e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
510e705c121SKalle Valo return -EINVAL;
511e705c121SKalle Valo }
512e705c121SKalle Valo
iwl_deactivate_station(struct iwl_priv * priv,const u8 sta_id,const u8 * addr)513e705c121SKalle Valo void iwl_deactivate_station(struct iwl_priv *priv, const u8 sta_id,
514e705c121SKalle Valo const u8 *addr)
515e705c121SKalle Valo {
516e705c121SKalle Valo u8 tid;
517e705c121SKalle Valo
518e705c121SKalle Valo if (!iwl_is_ready(priv)) {
519e705c121SKalle Valo IWL_DEBUG_INFO(priv,
520e705c121SKalle Valo "Unable to remove station %pM, device not ready.\n",
521e705c121SKalle Valo addr);
522e705c121SKalle Valo return;
523e705c121SKalle Valo }
524e705c121SKalle Valo
525e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Deactivating STA: %pM (%d)\n", addr, sta_id);
526e705c121SKalle Valo
527e705c121SKalle Valo if (WARN_ON_ONCE(sta_id == IWL_INVALID_STATION))
528e705c121SKalle Valo return;
529e705c121SKalle Valo
530e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
531e705c121SKalle Valo
532e705c121SKalle Valo WARN_ON_ONCE(!(priv->stations[sta_id].used & IWL_STA_DRIVER_ACTIVE));
533e705c121SKalle Valo
534e705c121SKalle Valo for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++)
535e705c121SKalle Valo memset(&priv->tid_data[sta_id][tid], 0,
536e705c121SKalle Valo sizeof(priv->tid_data[sta_id][tid]));
537e705c121SKalle Valo
538e705c121SKalle Valo priv->stations[sta_id].used &= ~IWL_STA_DRIVER_ACTIVE;
539e705c121SKalle Valo priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
540e705c121SKalle Valo
541e705c121SKalle Valo priv->num_stations--;
542e705c121SKalle Valo
543e705c121SKalle Valo if (WARN_ON_ONCE(priv->num_stations < 0))
544e705c121SKalle Valo priv->num_stations = 0;
545e705c121SKalle Valo
546e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
547e705c121SKalle Valo }
548e705c121SKalle Valo
iwl_sta_fill_lq(struct iwl_priv * priv,struct iwl_rxon_context * ctx,u8 sta_id,struct iwl_link_quality_cmd * link_cmd)549e705c121SKalle Valo static void iwl_sta_fill_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
550e705c121SKalle Valo u8 sta_id, struct iwl_link_quality_cmd *link_cmd)
551e705c121SKalle Valo {
552e705c121SKalle Valo int i, r;
553e705c121SKalle Valo u32 rate_flags = 0;
554e705c121SKalle Valo __le32 rate_n_flags;
555e705c121SKalle Valo
556e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
557e705c121SKalle Valo
558e705c121SKalle Valo memset(link_cmd, 0, sizeof(*link_cmd));
559e705c121SKalle Valo
560e705c121SKalle Valo /* Set up the rate scaling to start at selected rate, fall back
561e705c121SKalle Valo * all the way down to 1M in IEEE order, and then spin on 1M */
56257fbcce3SJohannes Berg if (priv->band == NL80211_BAND_5GHZ)
563e705c121SKalle Valo r = IWL_RATE_6M_INDEX;
564e705c121SKalle Valo else if (ctx && ctx->vif && ctx->vif->p2p)
565e705c121SKalle Valo r = IWL_RATE_6M_INDEX;
566e705c121SKalle Valo else
567e705c121SKalle Valo r = IWL_RATE_1M_INDEX;
568e705c121SKalle Valo
569e705c121SKalle Valo if (r >= IWL_FIRST_CCK_RATE && r <= IWL_LAST_CCK_RATE)
570e705c121SKalle Valo rate_flags |= RATE_MCS_CCK_MSK;
571e705c121SKalle Valo
572e705c121SKalle Valo rate_flags |= first_antenna(priv->nvm_data->valid_tx_ant) <<
573e705c121SKalle Valo RATE_MCS_ANT_POS;
574e705c121SKalle Valo rate_n_flags = iwl_hw_set_rate_n_flags(iwl_rates[r].plcp, rate_flags);
575e705c121SKalle Valo for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
576e705c121SKalle Valo link_cmd->rs_table[i].rate_n_flags = rate_n_flags;
577e705c121SKalle Valo
578e705c121SKalle Valo link_cmd->general_params.single_stream_ant_msk =
579e705c121SKalle Valo first_antenna(priv->nvm_data->valid_tx_ant);
580e705c121SKalle Valo
581e705c121SKalle Valo link_cmd->general_params.dual_stream_ant_msk =
582e705c121SKalle Valo priv->nvm_data->valid_tx_ant &
583e705c121SKalle Valo ~first_antenna(priv->nvm_data->valid_tx_ant);
584e705c121SKalle Valo if (!link_cmd->general_params.dual_stream_ant_msk) {
585e705c121SKalle Valo link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
586e705c121SKalle Valo } else if (num_of_ant(priv->nvm_data->valid_tx_ant) == 2) {
587e705c121SKalle Valo link_cmd->general_params.dual_stream_ant_msk =
588e705c121SKalle Valo priv->nvm_data->valid_tx_ant;
589e705c121SKalle Valo }
590e705c121SKalle Valo
591e705c121SKalle Valo link_cmd->agg_params.agg_dis_start_th =
592e705c121SKalle Valo LINK_QUAL_AGG_DISABLE_START_DEF;
593e705c121SKalle Valo link_cmd->agg_params.agg_time_limit =
594e705c121SKalle Valo cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
595e705c121SKalle Valo
596e705c121SKalle Valo link_cmd->sta_id = sta_id;
597e705c121SKalle Valo }
598e705c121SKalle Valo
5998f7ed7bfSLee Jones /*
600e705c121SKalle Valo * iwl_clear_ucode_stations - clear ucode station table bits
601e705c121SKalle Valo *
602e705c121SKalle Valo * This function clears all the bits in the driver indicating
603e705c121SKalle Valo * which stations are active in the ucode. Call when something
604e705c121SKalle Valo * other than explicit station management would cause this in
605e705c121SKalle Valo * the ucode, e.g. unassociated RXON.
606e705c121SKalle Valo */
iwl_clear_ucode_stations(struct iwl_priv * priv,struct iwl_rxon_context * ctx)607e705c121SKalle Valo void iwl_clear_ucode_stations(struct iwl_priv *priv,
608e705c121SKalle Valo struct iwl_rxon_context *ctx)
609e705c121SKalle Valo {
610e705c121SKalle Valo int i;
611e705c121SKalle Valo bool cleared = false;
612e705c121SKalle Valo
613e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Clearing ucode stations in driver\n");
614e705c121SKalle Valo
615e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
616e705c121SKalle Valo for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
617e705c121SKalle Valo if (ctx && ctx->ctxid != priv->stations[i].ctxid)
618e705c121SKalle Valo continue;
619e705c121SKalle Valo
620e705c121SKalle Valo if (priv->stations[i].used & IWL_STA_UCODE_ACTIVE) {
621e705c121SKalle Valo IWL_DEBUG_INFO(priv,
622e705c121SKalle Valo "Clearing ucode active for station %d\n", i);
623e705c121SKalle Valo priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
624e705c121SKalle Valo cleared = true;
625e705c121SKalle Valo }
626e705c121SKalle Valo }
627e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
628e705c121SKalle Valo
629e705c121SKalle Valo if (!cleared)
630e705c121SKalle Valo IWL_DEBUG_INFO(priv,
631e705c121SKalle Valo "No active stations found to be cleared\n");
632e705c121SKalle Valo }
633e705c121SKalle Valo
6348f7ed7bfSLee Jones /*
635e705c121SKalle Valo * iwl_restore_stations() - Restore driver known stations to device
636e705c121SKalle Valo *
637e705c121SKalle Valo * All stations considered active by driver, but not present in ucode, is
638e705c121SKalle Valo * restored.
639e705c121SKalle Valo *
640e705c121SKalle Valo * Function sleeps.
641e705c121SKalle Valo */
iwl_restore_stations(struct iwl_priv * priv,struct iwl_rxon_context * ctx)642e705c121SKalle Valo void iwl_restore_stations(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
643e705c121SKalle Valo {
644e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
645e705c121SKalle Valo static const struct iwl_link_quality_cmd zero_lq = {};
646e705c121SKalle Valo struct iwl_link_quality_cmd lq;
647e705c121SKalle Valo int i;
648e705c121SKalle Valo bool found = false;
649e705c121SKalle Valo int ret;
650e705c121SKalle Valo bool send_lq;
651e705c121SKalle Valo
652e705c121SKalle Valo if (!iwl_is_ready(priv)) {
653e705c121SKalle Valo IWL_DEBUG_INFO(priv,
654e705c121SKalle Valo "Not ready yet, not restoring any stations.\n");
655e705c121SKalle Valo return;
656e705c121SKalle Valo }
657e705c121SKalle Valo
658e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Restoring all known stations ... start.\n");
659e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
660e705c121SKalle Valo for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
661e705c121SKalle Valo if (ctx->ctxid != priv->stations[i].ctxid)
662e705c121SKalle Valo continue;
663e705c121SKalle Valo if ((priv->stations[i].used & IWL_STA_DRIVER_ACTIVE) &&
664e705c121SKalle Valo !(priv->stations[i].used & IWL_STA_UCODE_ACTIVE)) {
665e705c121SKalle Valo IWL_DEBUG_ASSOC(priv, "Restoring sta %pM\n",
666e705c121SKalle Valo priv->stations[i].sta.sta.addr);
667e705c121SKalle Valo priv->stations[i].sta.mode = 0;
668e705c121SKalle Valo priv->stations[i].used |= IWL_STA_UCODE_INPROGRESS;
669e705c121SKalle Valo found = true;
670e705c121SKalle Valo }
671e705c121SKalle Valo }
672e705c121SKalle Valo
673e705c121SKalle Valo for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
674e705c121SKalle Valo if ((priv->stations[i].used & IWL_STA_UCODE_INPROGRESS)) {
675e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[i].sta,
676e705c121SKalle Valo sizeof(struct iwl_addsta_cmd));
677e705c121SKalle Valo send_lq = false;
678e705c121SKalle Valo if (priv->stations[i].lq) {
679e705c121SKalle Valo if (priv->wowlan)
680e705c121SKalle Valo iwl_sta_fill_lq(priv, ctx, i, &lq);
681e705c121SKalle Valo else
682e705c121SKalle Valo memcpy(&lq, priv->stations[i].lq,
683e705c121SKalle Valo sizeof(struct iwl_link_quality_cmd));
684e705c121SKalle Valo
685e705c121SKalle Valo if (memcmp(&lq, &zero_lq, sizeof(lq)))
686e705c121SKalle Valo send_lq = true;
687e705c121SKalle Valo }
688e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
689e705c121SKalle Valo ret = iwl_send_add_sta(priv, &sta_cmd, 0);
690e705c121SKalle Valo if (ret) {
691e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
692e705c121SKalle Valo IWL_ERR(priv, "Adding station %pM failed.\n",
693e705c121SKalle Valo priv->stations[i].sta.sta.addr);
694e705c121SKalle Valo priv->stations[i].used &=
695e705c121SKalle Valo ~IWL_STA_DRIVER_ACTIVE;
696e705c121SKalle Valo priv->stations[i].used &=
697e705c121SKalle Valo ~IWL_STA_UCODE_INPROGRESS;
698e705c121SKalle Valo continue;
699e705c121SKalle Valo }
700e705c121SKalle Valo /*
701e705c121SKalle Valo * Rate scaling has already been initialized, send
702e705c121SKalle Valo * current LQ command
703e705c121SKalle Valo */
704e705c121SKalle Valo if (send_lq)
705e705c121SKalle Valo iwl_send_lq_cmd(priv, ctx, &lq, 0, true);
706e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
707e705c121SKalle Valo priv->stations[i].used &= ~IWL_STA_UCODE_INPROGRESS;
708e705c121SKalle Valo }
709e705c121SKalle Valo }
710e705c121SKalle Valo
711e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
712e705c121SKalle Valo if (!found)
713e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Restoring all known stations .... "
714e705c121SKalle Valo "no stations to be restored.\n");
715e705c121SKalle Valo else
716e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Restoring all known stations .... "
717e705c121SKalle Valo "complete.\n");
718e705c121SKalle Valo }
719e705c121SKalle Valo
iwl_get_free_ucode_key_offset(struct iwl_priv * priv)720e705c121SKalle Valo int iwl_get_free_ucode_key_offset(struct iwl_priv *priv)
721e705c121SKalle Valo {
722e705c121SKalle Valo int i;
723e705c121SKalle Valo
724e705c121SKalle Valo for (i = 0; i < priv->sta_key_max_num; i++)
725e705c121SKalle Valo if (!test_and_set_bit(i, &priv->ucode_key_table))
726e705c121SKalle Valo return i;
727e705c121SKalle Valo
728e705c121SKalle Valo return WEP_INVALID_OFFSET;
729e705c121SKalle Valo }
730e705c121SKalle Valo
iwl_dealloc_bcast_stations(struct iwl_priv * priv)731e705c121SKalle Valo void iwl_dealloc_bcast_stations(struct iwl_priv *priv)
732e705c121SKalle Valo {
733e705c121SKalle Valo int i;
734e705c121SKalle Valo
735e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
736e705c121SKalle Valo for (i = 0; i < IWLAGN_STATION_COUNT; i++) {
737e705c121SKalle Valo if (!(priv->stations[i].used & IWL_STA_BCAST))
738e705c121SKalle Valo continue;
739e705c121SKalle Valo
740e705c121SKalle Valo priv->stations[i].used &= ~IWL_STA_UCODE_ACTIVE;
741e705c121SKalle Valo priv->num_stations--;
742e705c121SKalle Valo if (WARN_ON(priv->num_stations < 0))
743e705c121SKalle Valo priv->num_stations = 0;
744e705c121SKalle Valo kfree(priv->stations[i].lq);
745e705c121SKalle Valo priv->stations[i].lq = NULL;
746e705c121SKalle Valo }
747e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
748e705c121SKalle Valo }
749e705c121SKalle Valo
750e705c121SKalle Valo #ifdef CONFIG_IWLWIFI_DEBUG
iwl_dump_lq_cmd(struct iwl_priv * priv,struct iwl_link_quality_cmd * lq)751e705c121SKalle Valo static void iwl_dump_lq_cmd(struct iwl_priv *priv,
752e705c121SKalle Valo struct iwl_link_quality_cmd *lq)
753e705c121SKalle Valo {
754e705c121SKalle Valo int i;
755e705c121SKalle Valo IWL_DEBUG_RATE(priv, "lq station id 0x%x\n", lq->sta_id);
756e705c121SKalle Valo IWL_DEBUG_RATE(priv, "lq ant 0x%X 0x%X\n",
757e705c121SKalle Valo lq->general_params.single_stream_ant_msk,
758e705c121SKalle Valo lq->general_params.dual_stream_ant_msk);
759e705c121SKalle Valo
760e705c121SKalle Valo for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
761e705c121SKalle Valo IWL_DEBUG_RATE(priv, "lq index %d 0x%X\n",
762e705c121SKalle Valo i, lq->rs_table[i].rate_n_flags);
763e705c121SKalle Valo }
764e705c121SKalle Valo #else
iwl_dump_lq_cmd(struct iwl_priv * priv,struct iwl_link_quality_cmd * lq)765e705c121SKalle Valo static inline void iwl_dump_lq_cmd(struct iwl_priv *priv,
766e705c121SKalle Valo struct iwl_link_quality_cmd *lq)
767e705c121SKalle Valo {
768e705c121SKalle Valo }
769e705c121SKalle Valo #endif
770e705c121SKalle Valo
7718f7ed7bfSLee Jones /*
772e705c121SKalle Valo * is_lq_table_valid() - Test one aspect of LQ cmd for validity
773e705c121SKalle Valo *
774e705c121SKalle Valo * It sometimes happens when a HT rate has been in use and we
775e705c121SKalle Valo * loose connectivity with AP then mac80211 will first tell us that the
776e705c121SKalle Valo * current channel is not HT anymore before removing the station. In such a
777e705c121SKalle Valo * scenario the RXON flags will be updated to indicate we are not
778e705c121SKalle Valo * communicating HT anymore, but the LQ command may still contain HT rates.
779e705c121SKalle Valo * Test for this to prevent driver from sending LQ command between the time
780e705c121SKalle Valo * RXON flags are updated and when LQ command is updated.
781e705c121SKalle Valo */
is_lq_table_valid(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct iwl_link_quality_cmd * lq)782e705c121SKalle Valo static bool is_lq_table_valid(struct iwl_priv *priv,
783e705c121SKalle Valo struct iwl_rxon_context *ctx,
784e705c121SKalle Valo struct iwl_link_quality_cmd *lq)
785e705c121SKalle Valo {
786e705c121SKalle Valo int i;
787e705c121SKalle Valo
788e705c121SKalle Valo if (ctx->ht.enabled)
789e705c121SKalle Valo return true;
790e705c121SKalle Valo
791e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Channel %u is not an HT channel\n",
792e705c121SKalle Valo ctx->active.channel);
793e705c121SKalle Valo for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
794e705c121SKalle Valo if (le32_to_cpu(lq->rs_table[i].rate_n_flags) &
795e705c121SKalle Valo RATE_MCS_HT_MSK) {
796e705c121SKalle Valo IWL_DEBUG_INFO(priv,
797e705c121SKalle Valo "index %d of LQ expects HT channel\n",
798e705c121SKalle Valo i);
799e705c121SKalle Valo return false;
800e705c121SKalle Valo }
801e705c121SKalle Valo }
802e705c121SKalle Valo return true;
803e705c121SKalle Valo }
804e705c121SKalle Valo
8058f7ed7bfSLee Jones /*
806e705c121SKalle Valo * iwl_send_lq_cmd() - Send link quality command
807e705c121SKalle Valo * @init: This command is sent as part of station initialization right
808e705c121SKalle Valo * after station has been added.
809e705c121SKalle Valo *
810e705c121SKalle Valo * The link quality command is sent as the last step of station creation.
811e705c121SKalle Valo * This is the special case in which init is set and we call a callback in
812e705c121SKalle Valo * this case to clear the state indicating that station creation is in
813e705c121SKalle Valo * progress.
814e705c121SKalle Valo */
iwl_send_lq_cmd(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct iwl_link_quality_cmd * lq,u8 flags,bool init)815e705c121SKalle Valo int iwl_send_lq_cmd(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
816e705c121SKalle Valo struct iwl_link_quality_cmd *lq, u8 flags, bool init)
817e705c121SKalle Valo {
818e705c121SKalle Valo int ret = 0;
819e705c121SKalle Valo struct iwl_host_cmd cmd = {
820e705c121SKalle Valo .id = REPLY_TX_LINK_QUALITY_CMD,
821e705c121SKalle Valo .len = { sizeof(struct iwl_link_quality_cmd), },
822e705c121SKalle Valo .flags = flags,
823e705c121SKalle Valo .data = { lq, },
824e705c121SKalle Valo };
825e705c121SKalle Valo
826e705c121SKalle Valo if (WARN_ON(lq->sta_id == IWL_INVALID_STATION))
827e705c121SKalle Valo return -EINVAL;
828e705c121SKalle Valo
829e705c121SKalle Valo
830e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
831e705c121SKalle Valo if (!(priv->stations[lq->sta_id].used & IWL_STA_DRIVER_ACTIVE)) {
832e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
833e705c121SKalle Valo return -EINVAL;
834e705c121SKalle Valo }
835e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
836e705c121SKalle Valo
837e705c121SKalle Valo iwl_dump_lq_cmd(priv, lq);
838e705c121SKalle Valo if (WARN_ON(init && (cmd.flags & CMD_ASYNC)))
839e705c121SKalle Valo return -EINVAL;
840e705c121SKalle Valo
841e705c121SKalle Valo if (is_lq_table_valid(priv, ctx, lq))
842e705c121SKalle Valo ret = iwl_dvm_send_cmd(priv, &cmd);
843e705c121SKalle Valo else
844e705c121SKalle Valo ret = -EINVAL;
845e705c121SKalle Valo
846e705c121SKalle Valo if (cmd.flags & CMD_ASYNC)
847e705c121SKalle Valo return ret;
848e705c121SKalle Valo
849e705c121SKalle Valo if (init) {
850e705c121SKalle Valo IWL_DEBUG_INFO(priv, "init LQ command complete, "
851e705c121SKalle Valo "clearing sta addition status for sta %d\n",
852e705c121SKalle Valo lq->sta_id);
853e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
854e705c121SKalle Valo priv->stations[lq->sta_id].used &= ~IWL_STA_UCODE_INPROGRESS;
855e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
856e705c121SKalle Valo }
857e705c121SKalle Valo return ret;
858e705c121SKalle Valo }
859e705c121SKalle Valo
860e705c121SKalle Valo
861e705c121SKalle Valo static struct iwl_link_quality_cmd *
iwl_sta_alloc_lq(struct iwl_priv * priv,struct iwl_rxon_context * ctx,u8 sta_id)862e705c121SKalle Valo iwl_sta_alloc_lq(struct iwl_priv *priv, struct iwl_rxon_context *ctx,
863e705c121SKalle Valo u8 sta_id)
864e705c121SKalle Valo {
865e705c121SKalle Valo struct iwl_link_quality_cmd *link_cmd;
866e705c121SKalle Valo
867e705c121SKalle Valo link_cmd = kzalloc(sizeof(struct iwl_link_quality_cmd), GFP_KERNEL);
868e705c121SKalle Valo if (!link_cmd) {
869e705c121SKalle Valo IWL_ERR(priv, "Unable to allocate memory for LQ cmd.\n");
870e705c121SKalle Valo return NULL;
871e705c121SKalle Valo }
872e705c121SKalle Valo
873e705c121SKalle Valo iwl_sta_fill_lq(priv, ctx, sta_id, link_cmd);
874e705c121SKalle Valo
875e705c121SKalle Valo return link_cmd;
876e705c121SKalle Valo }
877e705c121SKalle Valo
878e705c121SKalle Valo /*
879e705c121SKalle Valo * iwlagn_add_bssid_station - Add the special IBSS BSSID station
880e705c121SKalle Valo *
881e705c121SKalle Valo * Function sleeps.
882e705c121SKalle Valo */
iwlagn_add_bssid_station(struct iwl_priv * priv,struct iwl_rxon_context * ctx,const u8 * addr,u8 * sta_id_r)883e705c121SKalle Valo int iwlagn_add_bssid_station(struct iwl_priv *priv,
884e705c121SKalle Valo struct iwl_rxon_context *ctx,
885e705c121SKalle Valo const u8 *addr, u8 *sta_id_r)
886e705c121SKalle Valo {
887e705c121SKalle Valo int ret;
888e705c121SKalle Valo u8 sta_id;
889e705c121SKalle Valo struct iwl_link_quality_cmd *link_cmd;
890e705c121SKalle Valo
891e705c121SKalle Valo if (sta_id_r)
892e705c121SKalle Valo *sta_id_r = IWL_INVALID_STATION;
893e705c121SKalle Valo
894e705c121SKalle Valo ret = iwl_add_station_common(priv, ctx, addr, 0, NULL, &sta_id);
895e705c121SKalle Valo if (ret) {
896e705c121SKalle Valo IWL_ERR(priv, "Unable to add station %pM\n", addr);
897e705c121SKalle Valo return ret;
898e705c121SKalle Valo }
899e705c121SKalle Valo
900e705c121SKalle Valo if (sta_id_r)
901e705c121SKalle Valo *sta_id_r = sta_id;
902e705c121SKalle Valo
903e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
904e705c121SKalle Valo priv->stations[sta_id].used |= IWL_STA_LOCAL;
905e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
906e705c121SKalle Valo
907e705c121SKalle Valo /* Set up default rate scaling table in device's station table */
908e705c121SKalle Valo link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
909e705c121SKalle Valo if (!link_cmd) {
910e705c121SKalle Valo IWL_ERR(priv,
911e705c121SKalle Valo "Unable to initialize rate scaling for station %pM.\n",
912e705c121SKalle Valo addr);
913e705c121SKalle Valo return -ENOMEM;
914e705c121SKalle Valo }
915e705c121SKalle Valo
916e705c121SKalle Valo ret = iwl_send_lq_cmd(priv, ctx, link_cmd, 0, true);
917e705c121SKalle Valo if (ret)
918e705c121SKalle Valo IWL_ERR(priv, "Link quality command failed (%d)\n", ret);
919e705c121SKalle Valo
920e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
921e705c121SKalle Valo priv->stations[sta_id].lq = link_cmd;
922e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
923e705c121SKalle Valo
924e705c121SKalle Valo return 0;
925e705c121SKalle Valo }
926e705c121SKalle Valo
927e705c121SKalle Valo /*
928e705c121SKalle Valo * static WEP keys
929e705c121SKalle Valo *
930e705c121SKalle Valo * For each context, the device has a table of 4 static WEP keys
931e705c121SKalle Valo * (one for each key index) that is updated with the following
932e705c121SKalle Valo * commands.
933e705c121SKalle Valo */
934e705c121SKalle Valo
iwl_send_static_wepkey_cmd(struct iwl_priv * priv,struct iwl_rxon_context * ctx,bool send_if_empty)935e705c121SKalle Valo static int iwl_send_static_wepkey_cmd(struct iwl_priv *priv,
936e705c121SKalle Valo struct iwl_rxon_context *ctx,
937e705c121SKalle Valo bool send_if_empty)
938e705c121SKalle Valo {
939e705c121SKalle Valo int i, not_empty = 0;
940e705c121SKalle Valo u8 buff[sizeof(struct iwl_wep_cmd) +
941e705c121SKalle Valo sizeof(struct iwl_wep_key) * WEP_KEYS_MAX];
942e705c121SKalle Valo struct iwl_wep_cmd *wep_cmd = (struct iwl_wep_cmd *)buff;
943e705c121SKalle Valo size_t cmd_size = sizeof(struct iwl_wep_cmd);
944e705c121SKalle Valo struct iwl_host_cmd cmd = {
945e705c121SKalle Valo .id = ctx->wep_key_cmd,
946e705c121SKalle Valo .data = { wep_cmd, },
947e705c121SKalle Valo };
948e705c121SKalle Valo
949e705c121SKalle Valo might_sleep();
950e705c121SKalle Valo
951e705c121SKalle Valo memset(wep_cmd, 0, cmd_size +
952e705c121SKalle Valo (sizeof(struct iwl_wep_key) * WEP_KEYS_MAX));
953e705c121SKalle Valo
954e705c121SKalle Valo for (i = 0; i < WEP_KEYS_MAX ; i++) {
955e705c121SKalle Valo wep_cmd->key[i].key_index = i;
956e705c121SKalle Valo if (ctx->wep_keys[i].key_size) {
957e705c121SKalle Valo wep_cmd->key[i].key_offset = i;
958e705c121SKalle Valo not_empty = 1;
959e705c121SKalle Valo } else {
960e705c121SKalle Valo wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
961e705c121SKalle Valo }
962e705c121SKalle Valo
963e705c121SKalle Valo wep_cmd->key[i].key_size = ctx->wep_keys[i].key_size;
964e705c121SKalle Valo memcpy(&wep_cmd->key[i].key[3], ctx->wep_keys[i].key,
965e705c121SKalle Valo ctx->wep_keys[i].key_size);
966e705c121SKalle Valo }
967e705c121SKalle Valo
968e705c121SKalle Valo wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
969e705c121SKalle Valo wep_cmd->num_keys = WEP_KEYS_MAX;
970e705c121SKalle Valo
971e705c121SKalle Valo cmd_size += sizeof(struct iwl_wep_key) * WEP_KEYS_MAX;
972e705c121SKalle Valo
973e705c121SKalle Valo cmd.len[0] = cmd_size;
974e705c121SKalle Valo
975e705c121SKalle Valo if (not_empty || send_if_empty)
976e705c121SKalle Valo return iwl_dvm_send_cmd(priv, &cmd);
977e705c121SKalle Valo else
978e705c121SKalle Valo return 0;
979e705c121SKalle Valo }
980e705c121SKalle Valo
iwl_restore_default_wep_keys(struct iwl_priv * priv,struct iwl_rxon_context * ctx)981e705c121SKalle Valo int iwl_restore_default_wep_keys(struct iwl_priv *priv,
982e705c121SKalle Valo struct iwl_rxon_context *ctx)
983e705c121SKalle Valo {
984e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
985e705c121SKalle Valo
986e705c121SKalle Valo return iwl_send_static_wepkey_cmd(priv, ctx, false);
987e705c121SKalle Valo }
988e705c121SKalle Valo
iwl_remove_default_wep_key(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct ieee80211_key_conf * keyconf)989e705c121SKalle Valo int iwl_remove_default_wep_key(struct iwl_priv *priv,
990e705c121SKalle Valo struct iwl_rxon_context *ctx,
991e705c121SKalle Valo struct ieee80211_key_conf *keyconf)
992e705c121SKalle Valo {
993e705c121SKalle Valo int ret;
994e705c121SKalle Valo
995e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
996e705c121SKalle Valo
997e705c121SKalle Valo IWL_DEBUG_WEP(priv, "Removing default WEP key: idx=%d\n",
998e705c121SKalle Valo keyconf->keyidx);
999e705c121SKalle Valo
1000e705c121SKalle Valo memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));
1001e705c121SKalle Valo if (iwl_is_rfkill(priv)) {
1002e705c121SKalle Valo IWL_DEBUG_WEP(priv,
1003e705c121SKalle Valo "Not sending REPLY_WEPKEY command due to RFKILL.\n");
1004e705c121SKalle Valo /* but keys in device are clear anyway so return success */
1005e705c121SKalle Valo return 0;
1006e705c121SKalle Valo }
1007e705c121SKalle Valo ret = iwl_send_static_wepkey_cmd(priv, ctx, 1);
1008e705c121SKalle Valo IWL_DEBUG_WEP(priv, "Remove default WEP key: idx=%d ret=%d\n",
1009e705c121SKalle Valo keyconf->keyidx, ret);
1010e705c121SKalle Valo
1011e705c121SKalle Valo return ret;
1012e705c121SKalle Valo }
1013e705c121SKalle Valo
iwl_set_default_wep_key(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct ieee80211_key_conf * keyconf)1014e705c121SKalle Valo int iwl_set_default_wep_key(struct iwl_priv *priv,
1015e705c121SKalle Valo struct iwl_rxon_context *ctx,
1016e705c121SKalle Valo struct ieee80211_key_conf *keyconf)
1017e705c121SKalle Valo {
1018e705c121SKalle Valo int ret;
1019e705c121SKalle Valo
1020e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
1021e705c121SKalle Valo
1022e705c121SKalle Valo if (keyconf->keylen != WEP_KEY_LEN_128 &&
1023e705c121SKalle Valo keyconf->keylen != WEP_KEY_LEN_64) {
1024e705c121SKalle Valo IWL_DEBUG_WEP(priv,
1025e705c121SKalle Valo "Bad WEP key length %d\n", keyconf->keylen);
1026e705c121SKalle Valo return -EINVAL;
1027e705c121SKalle Valo }
1028e705c121SKalle Valo
1029e705c121SKalle Valo keyconf->hw_key_idx = IWLAGN_HW_KEY_DEFAULT;
1030e705c121SKalle Valo
1031e705c121SKalle Valo ctx->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
1032e705c121SKalle Valo memcpy(&ctx->wep_keys[keyconf->keyidx].key, &keyconf->key,
1033e705c121SKalle Valo keyconf->keylen);
1034e705c121SKalle Valo
1035e705c121SKalle Valo ret = iwl_send_static_wepkey_cmd(priv, ctx, false);
1036e705c121SKalle Valo IWL_DEBUG_WEP(priv, "Set default WEP key: len=%d idx=%d ret=%d\n",
1037e705c121SKalle Valo keyconf->keylen, keyconf->keyidx, ret);
1038e705c121SKalle Valo
1039e705c121SKalle Valo return ret;
1040e705c121SKalle Valo }
1041e705c121SKalle Valo
1042e705c121SKalle Valo /*
1043e705c121SKalle Valo * dynamic (per-station) keys
1044e705c121SKalle Valo *
1045e705c121SKalle Valo * The dynamic keys are a little more complicated. The device has
1046e705c121SKalle Valo * a key cache of up to STA_KEY_MAX_NUM/STA_KEY_MAX_NUM_PAN keys.
1047e705c121SKalle Valo * These are linked to stations by a table that contains an index
1048e705c121SKalle Valo * into the key table for each station/key index/{mcast,unicast},
1049e705c121SKalle Valo * i.e. it's basically an array of pointers like this:
1050e705c121SKalle Valo * key_offset_t key_mapping[NUM_STATIONS][4][2];
1051e705c121SKalle Valo * (it really works differently, but you can think of it as such)
1052e705c121SKalle Valo *
1053e705c121SKalle Valo * The key uploading and linking happens in the same command, the
1054e705c121SKalle Valo * add station command with STA_MODIFY_KEY_MASK.
1055e705c121SKalle Valo */
1056e705c121SKalle Valo
iwlagn_key_sta_id(struct iwl_priv * priv,struct ieee80211_vif * vif,struct ieee80211_sta * sta)1057e705c121SKalle Valo static u8 iwlagn_key_sta_id(struct iwl_priv *priv,
1058e705c121SKalle Valo struct ieee80211_vif *vif,
1059e705c121SKalle Valo struct ieee80211_sta *sta)
1060e705c121SKalle Valo {
1061e705c121SKalle Valo struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
1062e705c121SKalle Valo
1063e705c121SKalle Valo if (sta)
1064e705c121SKalle Valo return iwl_sta_id(sta);
1065e705c121SKalle Valo
1066e705c121SKalle Valo /*
1067e705c121SKalle Valo * The device expects GTKs for station interfaces to be
1068e705c121SKalle Valo * installed as GTKs for the AP station. If we have no
1069e705c121SKalle Valo * station ID, then use the ap_sta_id in that case.
1070e705c121SKalle Valo */
1071e705c121SKalle Valo if (vif->type == NL80211_IFTYPE_STATION && vif_priv->ctx)
1072e705c121SKalle Valo return vif_priv->ctx->ap_sta_id;
1073e705c121SKalle Valo
1074e705c121SKalle Valo return IWL_INVALID_STATION;
1075e705c121SKalle Valo }
1076e705c121SKalle Valo
iwlagn_send_sta_key(struct iwl_priv * priv,struct ieee80211_key_conf * keyconf,u8 sta_id,u32 tkip_iv32,u16 * tkip_p1k,u32 cmd_flags)1077e705c121SKalle Valo static int iwlagn_send_sta_key(struct iwl_priv *priv,
1078e705c121SKalle Valo struct ieee80211_key_conf *keyconf,
1079e705c121SKalle Valo u8 sta_id, u32 tkip_iv32, u16 *tkip_p1k,
1080e705c121SKalle Valo u32 cmd_flags)
1081e705c121SKalle Valo {
1082e705c121SKalle Valo __le16 key_flags;
1083e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
1084*ef167996SHans de Goede size_t to_copy;
1085e705c121SKalle Valo int i;
1086e705c121SKalle Valo
1087e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1088e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
1089e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1090e705c121SKalle Valo
1091e705c121SKalle Valo key_flags = cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
1092e705c121SKalle Valo key_flags |= STA_KEY_FLG_MAP_KEY_MSK;
1093e705c121SKalle Valo
1094e705c121SKalle Valo switch (keyconf->cipher) {
1095e705c121SKalle Valo case WLAN_CIPHER_SUITE_CCMP:
1096e705c121SKalle Valo key_flags |= STA_KEY_FLG_CCMP;
1097e705c121SKalle Valo memcpy(sta_cmd.key.key, keyconf->key, keyconf->keylen);
1098e705c121SKalle Valo break;
1099e705c121SKalle Valo case WLAN_CIPHER_SUITE_TKIP:
1100e705c121SKalle Valo key_flags |= STA_KEY_FLG_TKIP;
1101e705c121SKalle Valo sta_cmd.key.tkip_rx_tsc_byte2 = tkip_iv32;
1102e705c121SKalle Valo for (i = 0; i < 5; i++)
1103e705c121SKalle Valo sta_cmd.key.tkip_rx_ttak[i] = cpu_to_le16(tkip_p1k[i]);
1104*ef167996SHans de Goede /* keyconf may contain MIC rx/tx keys which iwl does not use */
1105*ef167996SHans de Goede to_copy = min_t(size_t, sizeof(sta_cmd.key.key), keyconf->keylen);
1106*ef167996SHans de Goede memcpy(sta_cmd.key.key, keyconf->key, to_copy);
1107e705c121SKalle Valo break;
1108e705c121SKalle Valo case WLAN_CIPHER_SUITE_WEP104:
1109e705c121SKalle Valo key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;
1110ff08b536SGustavo A. R. Silva fallthrough;
1111e705c121SKalle Valo case WLAN_CIPHER_SUITE_WEP40:
1112e705c121SKalle Valo key_flags |= STA_KEY_FLG_WEP;
1113e705c121SKalle Valo memcpy(&sta_cmd.key.key[3], keyconf->key, keyconf->keylen);
1114e705c121SKalle Valo break;
1115e705c121SKalle Valo default:
1116e705c121SKalle Valo WARN_ON(1);
1117e705c121SKalle Valo return -EINVAL;
1118e705c121SKalle Valo }
1119e705c121SKalle Valo
1120e705c121SKalle Valo if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1121e705c121SKalle Valo key_flags |= STA_KEY_MULTICAST_MSK;
1122e705c121SKalle Valo
1123e705c121SKalle Valo /* key pointer (offset) */
1124e705c121SKalle Valo sta_cmd.key.key_offset = keyconf->hw_key_idx;
1125e705c121SKalle Valo
1126e705c121SKalle Valo sta_cmd.key.key_flags = key_flags;
1127e705c121SKalle Valo sta_cmd.mode = STA_CONTROL_MODIFY_MSK;
1128e705c121SKalle Valo sta_cmd.sta.modify_mask = STA_MODIFY_KEY_MASK;
1129e705c121SKalle Valo
1130e705c121SKalle Valo return iwl_send_add_sta(priv, &sta_cmd, cmd_flags);
1131e705c121SKalle Valo }
1132e705c121SKalle Valo
iwl_update_tkip_key(struct iwl_priv * priv,struct ieee80211_vif * vif,struct ieee80211_key_conf * keyconf,struct ieee80211_sta * sta,u32 iv32,u16 * phase1key)1133e705c121SKalle Valo void iwl_update_tkip_key(struct iwl_priv *priv,
1134e705c121SKalle Valo struct ieee80211_vif *vif,
1135e705c121SKalle Valo struct ieee80211_key_conf *keyconf,
1136e705c121SKalle Valo struct ieee80211_sta *sta, u32 iv32, u16 *phase1key)
1137e705c121SKalle Valo {
1138e705c121SKalle Valo u8 sta_id = iwlagn_key_sta_id(priv, vif, sta);
1139e705c121SKalle Valo
1140e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION)
1141e705c121SKalle Valo return;
1142e705c121SKalle Valo
1143e705c121SKalle Valo if (iwl_scan_cancel(priv)) {
1144e705c121SKalle Valo /* cancel scan failed, just live w/ bad key and rely
1145e705c121SKalle Valo briefly on SW decryption */
1146e705c121SKalle Valo return;
1147e705c121SKalle Valo }
1148e705c121SKalle Valo
1149e705c121SKalle Valo iwlagn_send_sta_key(priv, keyconf, sta_id,
1150e705c121SKalle Valo iv32, phase1key, CMD_ASYNC);
1151e705c121SKalle Valo }
1152e705c121SKalle Valo
iwl_remove_dynamic_key(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct ieee80211_key_conf * keyconf,struct ieee80211_sta * sta)1153e705c121SKalle Valo int iwl_remove_dynamic_key(struct iwl_priv *priv,
1154e705c121SKalle Valo struct iwl_rxon_context *ctx,
1155e705c121SKalle Valo struct ieee80211_key_conf *keyconf,
1156e705c121SKalle Valo struct ieee80211_sta *sta)
1157e705c121SKalle Valo {
1158e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
1159e705c121SKalle Valo u8 sta_id = iwlagn_key_sta_id(priv, ctx->vif, sta);
1160e705c121SKalle Valo __le16 key_flags;
1161e705c121SKalle Valo
1162e705c121SKalle Valo /* if station isn't there, neither is the key */
1163e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION)
1164e705c121SKalle Valo return -ENOENT;
1165e705c121SKalle Valo
1166e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1167e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(sta_cmd));
1168e705c121SKalle Valo if (!(priv->stations[sta_id].used & IWL_STA_UCODE_ACTIVE))
1169e705c121SKalle Valo sta_id = IWL_INVALID_STATION;
1170e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1171e705c121SKalle Valo
1172e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION)
1173e705c121SKalle Valo return 0;
1174e705c121SKalle Valo
1175e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
1176e705c121SKalle Valo
1177e705c121SKalle Valo ctx->key_mapping_keys--;
1178e705c121SKalle Valo
1179e705c121SKalle Valo IWL_DEBUG_WEP(priv, "Remove dynamic key: idx=%d sta=%d\n",
1180e705c121SKalle Valo keyconf->keyidx, sta_id);
1181e705c121SKalle Valo
1182e705c121SKalle Valo if (!test_and_clear_bit(keyconf->hw_key_idx, &priv->ucode_key_table))
1183e705c121SKalle Valo IWL_ERR(priv, "offset %d not used in uCode key table.\n",
1184e705c121SKalle Valo keyconf->hw_key_idx);
1185e705c121SKalle Valo
1186e705c121SKalle Valo key_flags = cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
1187e705c121SKalle Valo key_flags |= STA_KEY_FLG_MAP_KEY_MSK | STA_KEY_FLG_NO_ENC |
1188e705c121SKalle Valo STA_KEY_FLG_INVALID;
1189e705c121SKalle Valo
1190e705c121SKalle Valo if (!(keyconf->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1191e705c121SKalle Valo key_flags |= STA_KEY_MULTICAST_MSK;
1192e705c121SKalle Valo
1193e705c121SKalle Valo sta_cmd.key.key_flags = key_flags;
1194e705c121SKalle Valo sta_cmd.key.key_offset = keyconf->hw_key_idx;
1195e705c121SKalle Valo sta_cmd.sta.modify_mask = STA_MODIFY_KEY_MASK;
1196e705c121SKalle Valo sta_cmd.mode = STA_CONTROL_MODIFY_MSK;
1197e705c121SKalle Valo
1198e705c121SKalle Valo return iwl_send_add_sta(priv, &sta_cmd, 0);
1199e705c121SKalle Valo }
1200e705c121SKalle Valo
iwl_set_dynamic_key(struct iwl_priv * priv,struct iwl_rxon_context * ctx,struct ieee80211_key_conf * keyconf,struct ieee80211_sta * sta)1201e705c121SKalle Valo int iwl_set_dynamic_key(struct iwl_priv *priv,
1202e705c121SKalle Valo struct iwl_rxon_context *ctx,
1203e705c121SKalle Valo struct ieee80211_key_conf *keyconf,
1204e705c121SKalle Valo struct ieee80211_sta *sta)
1205e705c121SKalle Valo {
1206e705c121SKalle Valo struct ieee80211_key_seq seq;
1207e705c121SKalle Valo u16 p1k[5];
1208e705c121SKalle Valo int ret;
1209e705c121SKalle Valo u8 sta_id = iwlagn_key_sta_id(priv, ctx->vif, sta);
1210e705c121SKalle Valo const u8 *addr;
1211e705c121SKalle Valo
1212e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION)
1213e705c121SKalle Valo return -EINVAL;
1214e705c121SKalle Valo
1215e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
1216e705c121SKalle Valo
1217e705c121SKalle Valo keyconf->hw_key_idx = iwl_get_free_ucode_key_offset(priv);
1218e705c121SKalle Valo if (keyconf->hw_key_idx == WEP_INVALID_OFFSET)
1219e705c121SKalle Valo return -ENOSPC;
1220e705c121SKalle Valo
1221e705c121SKalle Valo ctx->key_mapping_keys++;
1222e705c121SKalle Valo
1223e705c121SKalle Valo switch (keyconf->cipher) {
1224e705c121SKalle Valo case WLAN_CIPHER_SUITE_TKIP:
1225e705c121SKalle Valo if (sta)
1226e705c121SKalle Valo addr = sta->addr;
1227e705c121SKalle Valo else /* station mode case only */
1228e705c121SKalle Valo addr = ctx->active.bssid_addr;
1229e705c121SKalle Valo
1230e705c121SKalle Valo /* pre-fill phase 1 key into device cache */
1231e705c121SKalle Valo ieee80211_get_key_rx_seq(keyconf, 0, &seq);
1232e705c121SKalle Valo ieee80211_get_tkip_rx_p1k(keyconf, addr, seq.tkip.iv32, p1k);
1233e705c121SKalle Valo ret = iwlagn_send_sta_key(priv, keyconf, sta_id,
1234e705c121SKalle Valo seq.tkip.iv32, p1k, 0);
1235e705c121SKalle Valo break;
1236e705c121SKalle Valo case WLAN_CIPHER_SUITE_CCMP:
1237e705c121SKalle Valo case WLAN_CIPHER_SUITE_WEP40:
1238e705c121SKalle Valo case WLAN_CIPHER_SUITE_WEP104:
1239e705c121SKalle Valo ret = iwlagn_send_sta_key(priv, keyconf, sta_id,
1240e705c121SKalle Valo 0, NULL, 0);
1241e705c121SKalle Valo break;
1242e705c121SKalle Valo default:
1243e705c121SKalle Valo IWL_ERR(priv, "Unknown cipher %x\n", keyconf->cipher);
1244e705c121SKalle Valo ret = -EINVAL;
1245e705c121SKalle Valo }
1246e705c121SKalle Valo
1247e705c121SKalle Valo if (ret) {
1248e705c121SKalle Valo ctx->key_mapping_keys--;
1249e705c121SKalle Valo clear_bit(keyconf->hw_key_idx, &priv->ucode_key_table);
1250e705c121SKalle Valo }
1251e705c121SKalle Valo
1252e705c121SKalle Valo IWL_DEBUG_WEP(priv, "Set dynamic key: cipher=%x len=%d idx=%d sta=%pM ret=%d\n",
1253e705c121SKalle Valo keyconf->cipher, keyconf->keylen, keyconf->keyidx,
1254e705c121SKalle Valo sta ? sta->addr : NULL, ret);
1255e705c121SKalle Valo
1256e705c121SKalle Valo return ret;
1257e705c121SKalle Valo }
1258e705c121SKalle Valo
12598f7ed7bfSLee Jones /*
1260e705c121SKalle Valo * iwlagn_alloc_bcast_station - add broadcast station into driver's station table.
1261e705c121SKalle Valo *
1262e705c121SKalle Valo * This adds the broadcast station into the driver's station table
1263e705c121SKalle Valo * and marks it driver active, so that it will be restored to the
1264e705c121SKalle Valo * device at the next best time.
1265e705c121SKalle Valo */
iwlagn_alloc_bcast_station(struct iwl_priv * priv,struct iwl_rxon_context * ctx)1266e705c121SKalle Valo int iwlagn_alloc_bcast_station(struct iwl_priv *priv,
1267e705c121SKalle Valo struct iwl_rxon_context *ctx)
1268e705c121SKalle Valo {
1269e705c121SKalle Valo struct iwl_link_quality_cmd *link_cmd;
1270e705c121SKalle Valo u8 sta_id;
1271e705c121SKalle Valo
1272e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1273e705c121SKalle Valo sta_id = iwl_prep_station(priv, ctx, iwl_bcast_addr, false, NULL);
1274e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION) {
1275e705c121SKalle Valo IWL_ERR(priv, "Unable to prepare broadcast station\n");
1276e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1277e705c121SKalle Valo
1278e705c121SKalle Valo return -EINVAL;
1279e705c121SKalle Valo }
1280e705c121SKalle Valo
1281e705c121SKalle Valo priv->stations[sta_id].used |= IWL_STA_DRIVER_ACTIVE;
1282e705c121SKalle Valo priv->stations[sta_id].used |= IWL_STA_BCAST;
1283e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1284e705c121SKalle Valo
1285e705c121SKalle Valo link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
1286e705c121SKalle Valo if (!link_cmd) {
1287e705c121SKalle Valo IWL_ERR(priv,
1288e705c121SKalle Valo "Unable to initialize rate scaling for bcast station.\n");
1289e705c121SKalle Valo return -ENOMEM;
1290e705c121SKalle Valo }
1291e705c121SKalle Valo
1292e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1293e705c121SKalle Valo priv->stations[sta_id].lq = link_cmd;
1294e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1295e705c121SKalle Valo
1296e705c121SKalle Valo return 0;
1297e705c121SKalle Valo }
1298e705c121SKalle Valo
12998f7ed7bfSLee Jones /*
1300e705c121SKalle Valo * iwl_update_bcast_station - update broadcast station's LQ command
1301e705c121SKalle Valo *
1302e705c121SKalle Valo * Only used by iwlagn. Placed here to have all bcast station management
1303e705c121SKalle Valo * code together.
1304e705c121SKalle Valo */
iwl_update_bcast_station(struct iwl_priv * priv,struct iwl_rxon_context * ctx)1305e705c121SKalle Valo int iwl_update_bcast_station(struct iwl_priv *priv,
1306e705c121SKalle Valo struct iwl_rxon_context *ctx)
1307e705c121SKalle Valo {
1308e705c121SKalle Valo struct iwl_link_quality_cmd *link_cmd;
1309e705c121SKalle Valo u8 sta_id = ctx->bcast_sta_id;
1310e705c121SKalle Valo
1311e705c121SKalle Valo link_cmd = iwl_sta_alloc_lq(priv, ctx, sta_id);
1312e705c121SKalle Valo if (!link_cmd) {
1313e705c121SKalle Valo IWL_ERR(priv, "Unable to initialize rate scaling for bcast station.\n");
1314e705c121SKalle Valo return -ENOMEM;
1315e705c121SKalle Valo }
1316e705c121SKalle Valo
1317e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1318e705c121SKalle Valo if (priv->stations[sta_id].lq)
1319e705c121SKalle Valo kfree(priv->stations[sta_id].lq);
1320e705c121SKalle Valo else
1321e705c121SKalle Valo IWL_DEBUG_INFO(priv, "Bcast station rate scaling has not been initialized yet.\n");
1322e705c121SKalle Valo priv->stations[sta_id].lq = link_cmd;
1323e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1324e705c121SKalle Valo
1325e705c121SKalle Valo return 0;
1326e705c121SKalle Valo }
1327e705c121SKalle Valo
iwl_update_bcast_stations(struct iwl_priv * priv)1328e705c121SKalle Valo int iwl_update_bcast_stations(struct iwl_priv *priv)
1329e705c121SKalle Valo {
1330e705c121SKalle Valo struct iwl_rxon_context *ctx;
1331e705c121SKalle Valo int ret = 0;
1332e705c121SKalle Valo
1333e705c121SKalle Valo for_each_context(priv, ctx) {
1334e705c121SKalle Valo ret = iwl_update_bcast_station(priv, ctx);
1335e705c121SKalle Valo if (ret)
1336e705c121SKalle Valo break;
1337e705c121SKalle Valo }
1338e705c121SKalle Valo
1339e705c121SKalle Valo return ret;
1340e705c121SKalle Valo }
1341e705c121SKalle Valo
13428f7ed7bfSLee Jones /*
1343e705c121SKalle Valo * iwl_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
1344e705c121SKalle Valo */
iwl_sta_tx_modify_enable_tid(struct iwl_priv * priv,int sta_id,int tid)1345e705c121SKalle Valo int iwl_sta_tx_modify_enable_tid(struct iwl_priv *priv, int sta_id, int tid)
1346e705c121SKalle Valo {
1347e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
1348e705c121SKalle Valo
1349e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
1350e705c121SKalle Valo
1351e705c121SKalle Valo /* Remove "disable" flag, to enable Tx for this TID */
1352e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1353e705c121SKalle Valo priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
1354e705c121SKalle Valo priv->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
1355e705c121SKalle Valo priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1356e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
1357e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1358e705c121SKalle Valo
1359e705c121SKalle Valo return iwl_send_add_sta(priv, &sta_cmd, 0);
1360e705c121SKalle Valo }
1361e705c121SKalle Valo
iwl_sta_rx_agg_start(struct iwl_priv * priv,struct ieee80211_sta * sta,int tid,u16 ssn)1362e705c121SKalle Valo int iwl_sta_rx_agg_start(struct iwl_priv *priv, struct ieee80211_sta *sta,
1363e705c121SKalle Valo int tid, u16 ssn)
1364e705c121SKalle Valo {
1365e705c121SKalle Valo int sta_id;
1366e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
1367e705c121SKalle Valo
1368e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
1369e705c121SKalle Valo
1370e705c121SKalle Valo sta_id = iwl_sta_id(sta);
1371e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION)
1372e705c121SKalle Valo return -ENXIO;
1373e705c121SKalle Valo
1374e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1375e705c121SKalle Valo priv->stations[sta_id].sta.station_flags_msk = 0;
1376e705c121SKalle Valo priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
1377e705c121SKalle Valo priv->stations[sta_id].sta.add_immediate_ba_tid = (u8)tid;
1378e705c121SKalle Valo priv->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
1379e705c121SKalle Valo priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1380e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
1381e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1382e705c121SKalle Valo
1383e705c121SKalle Valo return iwl_send_add_sta(priv, &sta_cmd, 0);
1384e705c121SKalle Valo }
1385e705c121SKalle Valo
iwl_sta_rx_agg_stop(struct iwl_priv * priv,struct ieee80211_sta * sta,int tid)1386e705c121SKalle Valo int iwl_sta_rx_agg_stop(struct iwl_priv *priv, struct ieee80211_sta *sta,
1387e705c121SKalle Valo int tid)
1388e705c121SKalle Valo {
1389e705c121SKalle Valo int sta_id;
1390e705c121SKalle Valo struct iwl_addsta_cmd sta_cmd;
1391e705c121SKalle Valo
1392e705c121SKalle Valo lockdep_assert_held(&priv->mutex);
1393e705c121SKalle Valo
1394e705c121SKalle Valo sta_id = iwl_sta_id(sta);
1395e705c121SKalle Valo if (sta_id == IWL_INVALID_STATION) {
1396e705c121SKalle Valo IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
1397e705c121SKalle Valo return -ENXIO;
1398e705c121SKalle Valo }
1399e705c121SKalle Valo
1400e705c121SKalle Valo spin_lock_bh(&priv->sta_lock);
1401e705c121SKalle Valo priv->stations[sta_id].sta.station_flags_msk = 0;
1402e705c121SKalle Valo priv->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
1403e705c121SKalle Valo priv->stations[sta_id].sta.remove_immediate_ba_tid = (u8)tid;
1404e705c121SKalle Valo priv->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
1405e705c121SKalle Valo memcpy(&sta_cmd, &priv->stations[sta_id].sta, sizeof(struct iwl_addsta_cmd));
1406e705c121SKalle Valo spin_unlock_bh(&priv->sta_lock);
1407e705c121SKalle Valo
1408e705c121SKalle Valo return iwl_send_add_sta(priv, &sta_cmd, 0);
1409e705c121SKalle Valo }
1410e705c121SKalle Valo
1411e705c121SKalle Valo
1412e705c121SKalle Valo
iwl_sta_modify_sleep_tx_count(struct iwl_priv * priv,int sta_id,int cnt)1413e705c121SKalle Valo void iwl_sta_modify_sleep_tx_count(struct iwl_priv *priv, int sta_id, int cnt)
1414e705c121SKalle Valo {
1415e705c121SKalle Valo struct iwl_addsta_cmd cmd = {
1416e705c121SKalle Valo .mode = STA_CONTROL_MODIFY_MSK,
1417e705c121SKalle Valo .station_flags = STA_FLG_PWR_SAVE_MSK,
1418e705c121SKalle Valo .station_flags_msk = STA_FLG_PWR_SAVE_MSK,
1419e705c121SKalle Valo .sta.sta_id = sta_id,
1420e705c121SKalle Valo .sta.modify_mask = STA_MODIFY_SLEEP_TX_COUNT_MSK,
1421e705c121SKalle Valo .sleep_tx_count = cpu_to_le16(cnt),
1422e705c121SKalle Valo };
1423e705c121SKalle Valo
1424e705c121SKalle Valo iwl_send_add_sta(priv, &cmd, CMD_ASYNC);
1425e705c121SKalle Valo }
1426