blob: b7551610f37eb314a8ff707b7c47ab913dd6bdb5 [file] [log] [blame]
Johannes Berg8ca151b2013-01-24 14:25:36 +01001/******************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
Emmanuel Grumbach51368bf2013-12-30 13:15:54 +02008 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
Johannes Berg8b4139d2014-07-24 14:05:26 +02009 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
Sara Sharonf92659a2016-02-03 15:04:49 +020010 * Copyright(c) 2016 Intel Deutschland GmbH
Johannes Berg8ca151b2013-01-24 14:25:36 +010011 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of version 2 of the GNU General Public License as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * USA
25 *
26 * The full GNU General Public License is included in this distribution
Emmanuel Grumbach410dc5a2013-02-18 09:22:28 +020027 * in the file called COPYING.
Johannes Berg8ca151b2013-01-24 14:25:36 +010028 *
29 * Contact Information:
Emmanuel Grumbachcb2f8272015-11-17 15:39:56 +020030 * Intel Linux Wireless <linuxwifi@intel.com>
Johannes Berg8ca151b2013-01-24 14:25:36 +010031 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
32 *
33 * BSD LICENSE
34 *
Emmanuel Grumbach51368bf2013-12-30 13:15:54 +020035 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
Johannes Berg8b4139d2014-07-24 14:05:26 +020036 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
Johannes Berg8ca151b2013-01-24 14:25:36 +010037 * All rights reserved.
38 *
39 * Redistribution and use in source and binary forms, with or without
40 * modification, are permitted provided that the following conditions
41 * are met:
42 *
43 * * Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * * Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in
47 * the documentation and/or other materials provided with the
48 * distribution.
49 * * Neither the name Intel Corporation nor the names of its
50 * contributors may be used to endorse or promote products derived
51 * from this software without specific prior written permission.
52 *
53 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
54 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
55 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
56 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
57 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
58 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
59 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
60 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
61 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
62 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
63 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64 *
65 *****************************************************************************/
66#include <linux/kernel.h>
67#include <linux/slab.h>
68#include <linux/skbuff.h>
69#include <linux/netdevice.h>
70#include <linux/etherdevice.h>
Johannes Bergf0c26462013-01-22 20:41:58 +010071#include <linux/ip.h>
Eliad Peller2ee8f022014-01-13 19:07:09 +020072#include <linux/if_arp.h>
Johannes Bergaadede62014-10-09 17:01:36 +020073#include <linux/devcoredump.h>
Golan Ben-Ami2f89a5d2015-10-27 19:17:14 +020074#include <linux/time.h>
Johannes Berg8ca151b2013-01-24 14:25:36 +010075#include <net/mac80211.h>
Emmanuel Grumbach7b1dd042014-02-04 15:32:43 +020076#include <net/ieee80211_radiotap.h>
Johannes Bergf0c26462013-01-22 20:41:58 +010077#include <net/tcp.h>
Johannes Berg8ca151b2013-01-24 14:25:36 +010078
79#include "iwl-op-mode.h"
80#include "iwl-io.h"
81#include "mvm.h"
82#include "sta.h"
83#include "time-event.h"
84#include "iwl-eeprom-parse.h"
Johannes Berg8ca151b2013-01-24 14:25:36 +010085#include "iwl-phy-db.h"
David Spinadel507cadf2013-07-31 18:07:21 +030086#include "testmode.h"
Emmanuel Grumbach655e6d62014-06-25 14:08:58 +030087#include "iwl-fw-error-dump.h"
88#include "iwl-prph.h"
Eran Harary363039b2014-12-02 15:19:22 +020089#include "iwl-csr.h"
Arik Nemtsov88931cc2014-03-05 12:26:15 +020090#include "iwl-nvm-parse.h"
Golan Ben-Ami2f89a5d2015-10-27 19:17:14 +020091#include "fw-dbg.h"
Johannes Berg8ca151b2013-01-24 14:25:36 +010092
93static const struct ieee80211_iface_limit iwl_mvm_limits[] = {
94 {
95 .max = 1,
Ilan Peer8eb38712013-06-01 20:17:18 +030096 .types = BIT(NL80211_IFTYPE_STATION),
Johannes Berg8ca151b2013-01-24 14:25:36 +010097 },
Johannes Berg3c15a0f2013-05-31 10:17:19 +020098 {
99 .max = 1,
Ilan Peer8eb38712013-06-01 20:17:18 +0300100 .types = BIT(NL80211_IFTYPE_AP) |
101 BIT(NL80211_IFTYPE_P2P_CLIENT) |
Johannes Berg3c15a0f2013-05-31 10:17:19 +0200102 BIT(NL80211_IFTYPE_P2P_GO),
103 },
104 {
105 .max = 1,
106 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
107 },
Johannes Berg8ca151b2013-01-24 14:25:36 +0100108};
109
110static const struct ieee80211_iface_combination iwl_mvm_iface_combinations[] = {
111 {
Emmanuel Grumbach2624a5c2014-12-16 13:02:03 +0200112 .num_different_channels = 2,
Johannes Berg8ca151b2013-01-24 14:25:36 +0100113 .max_interfaces = 3,
114 .limits = iwl_mvm_limits,
115 .n_limits = ARRAY_SIZE(iwl_mvm_limits),
116 },
117};
118
Johannes Bergf0c26462013-01-22 20:41:58 +0100119#ifdef CONFIG_PM_SLEEP
120static const struct nl80211_wowlan_tcp_data_token_feature
121iwl_mvm_wowlan_tcp_token_feature = {
122 .min_len = 0,
123 .max_len = 255,
124 .bufsize = IWL_WOWLAN_REMOTE_WAKE_MAX_TOKENS,
125};
126
127static const struct wiphy_wowlan_tcp_support iwl_mvm_wowlan_tcp_support = {
128 .tok = &iwl_mvm_wowlan_tcp_token_feature,
129 .data_payload_max = IWL_WOWLAN_TCP_MAX_PACKET_LEN -
130 sizeof(struct ethhdr) -
131 sizeof(struct iphdr) -
132 sizeof(struct tcphdr),
133 .data_interval_max = 65535, /* __le16 in API */
134 .wake_payload_max = IWL_WOWLAN_REMOTE_WAKE_MAX_PACKET_LEN -
135 sizeof(struct ethhdr) -
136 sizeof(struct iphdr) -
137 sizeof(struct tcphdr),
138 .seq = true,
139};
140#endif
141
Eliad Peller77736922014-01-14 12:35:49 +0200142#ifdef CONFIG_IWLWIFI_BCAST_FILTERING
Eliad Peller2ee8f022014-01-13 19:07:09 +0200143/*
144 * Use the reserved field to indicate magic values.
145 * these values will only be used internally by the driver,
146 * and won't make it to the fw (reserved will be 0).
147 * BC_FILTER_MAGIC_IP - configure the val of this attribute to
148 * be the vif's ip address. in case there is not a single
149 * ip address (0, or more than 1), this attribute will
150 * be skipped.
151 * BC_FILTER_MAGIC_MAC - set the val of this attribute to
152 * the LSB bytes of the vif's mac address
153 */
154enum {
155 BC_FILTER_MAGIC_NONE = 0,
156 BC_FILTER_MAGIC_IP,
157 BC_FILTER_MAGIC_MAC,
158};
159
Eliad Peller77736922014-01-14 12:35:49 +0200160static const struct iwl_fw_bcast_filter iwl_mvm_default_bcast_filters[] = {
161 {
162 /* arp */
163 .discard = 0,
164 .frame_type = BCAST_FILTER_FRAME_TYPE_ALL,
165 .attrs = {
166 {
167 /* frame type - arp, hw type - ethernet */
168 .offset_type =
169 BCAST_FILTER_OFFSET_PAYLOAD_START,
170 .offset = sizeof(rfc1042_header),
171 .val = cpu_to_be32(0x08060001),
172 .mask = cpu_to_be32(0xffffffff),
173 },
Eliad Peller2ee8f022014-01-13 19:07:09 +0200174 {
175 /* arp dest ip */
176 .offset_type =
177 BCAST_FILTER_OFFSET_PAYLOAD_START,
178 .offset = sizeof(rfc1042_header) + 2 +
179 sizeof(struct arphdr) +
180 ETH_ALEN + sizeof(__be32) +
181 ETH_ALEN,
182 .mask = cpu_to_be32(0xffffffff),
183 /* mark it as special field */
184 .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_IP),
185 },
186 },
187 },
188 {
189 /* dhcp offer bcast */
190 .discard = 0,
191 .frame_type = BCAST_FILTER_FRAME_TYPE_IPV4,
192 .attrs = {
193 {
194 /* udp dest port - 68 (bootp client)*/
195 .offset_type = BCAST_FILTER_OFFSET_IP_END,
196 .offset = offsetof(struct udphdr, dest),
197 .val = cpu_to_be32(0x00440000),
198 .mask = cpu_to_be32(0xffff0000),
199 },
200 {
201 /* dhcp - lsb bytes of client hw address */
202 .offset_type = BCAST_FILTER_OFFSET_IP_END,
203 .offset = 38,
204 .mask = cpu_to_be32(0xffffffff),
205 /* mark it as special field */
206 .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_MAC),
207 },
Eliad Peller77736922014-01-14 12:35:49 +0200208 },
209 },
210 /* last filter must be empty */
211 {},
212};
213#endif
214
Eliad Peller7498cf42014-01-16 17:10:44 +0200215void iwl_mvm_ref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
216{
Eliad Peller7bb426e2014-02-24 12:54:37 +0200217 if (!iwl_mvm_is_d0i3_supported(mvm))
Eliad Peller7498cf42014-01-16 17:10:44 +0200218 return;
219
220 IWL_DEBUG_RPM(mvm, "Take mvm reference - type %d\n", ref_type);
Eliad Peller576eeee2014-07-01 18:38:38 +0300221 spin_lock_bh(&mvm->refs_lock);
222 mvm->refs[ref_type]++;
223 spin_unlock_bh(&mvm->refs_lock);
Eliad Peller7498cf42014-01-16 17:10:44 +0200224 iwl_trans_ref(mvm->trans);
225}
226
227void iwl_mvm_unref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
228{
Eliad Peller7bb426e2014-02-24 12:54:37 +0200229 if (!iwl_mvm_is_d0i3_supported(mvm))
Eliad Peller7498cf42014-01-16 17:10:44 +0200230 return;
231
232 IWL_DEBUG_RPM(mvm, "Leave mvm reference - type %d\n", ref_type);
Eliad Peller576eeee2014-07-01 18:38:38 +0300233 spin_lock_bh(&mvm->refs_lock);
234 WARN_ON(!mvm->refs[ref_type]--);
235 spin_unlock_bh(&mvm->refs_lock);
Eliad Peller7498cf42014-01-16 17:10:44 +0200236 iwl_trans_unref(mvm->trans);
237}
238
Eliad Peller576eeee2014-07-01 18:38:38 +0300239static void iwl_mvm_unref_all_except(struct iwl_mvm *mvm,
240 enum iwl_mvm_ref_type except_ref)
Eliad Peller7498cf42014-01-16 17:10:44 +0200241{
Eliad Peller576eeee2014-07-01 18:38:38 +0300242 int i, j;
Eliad Peller7498cf42014-01-16 17:10:44 +0200243
Eliad Peller7bb426e2014-02-24 12:54:37 +0200244 if (!iwl_mvm_is_d0i3_supported(mvm))
Eliad Peller7498cf42014-01-16 17:10:44 +0200245 return;
246
Eliad Peller576eeee2014-07-01 18:38:38 +0300247 spin_lock_bh(&mvm->refs_lock);
248 for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
249 if (except_ref == i || !mvm->refs[i])
Eliad Peller7498cf42014-01-16 17:10:44 +0200250 continue;
251
Eliad Peller576eeee2014-07-01 18:38:38 +0300252 IWL_DEBUG_RPM(mvm, "Cleanup: remove mvm ref type %d (%d)\n",
253 i, mvm->refs[i]);
254 for (j = 0; j < mvm->refs[i]; j++)
255 iwl_trans_unref(mvm->trans);
256 mvm->refs[i] = 0;
Eliad Peller7498cf42014-01-16 17:10:44 +0200257 }
Eliad Peller576eeee2014-07-01 18:38:38 +0300258 spin_unlock_bh(&mvm->refs_lock);
Eliad Peller7498cf42014-01-16 17:10:44 +0200259}
260
Eliad Pellerf4cf8682014-11-04 16:57:06 +0200261bool iwl_mvm_ref_taken(struct iwl_mvm *mvm)
262{
263 int i;
264 bool taken = false;
265
266 if (!iwl_mvm_is_d0i3_supported(mvm))
267 return true;
268
269 spin_lock_bh(&mvm->refs_lock);
270 for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
271 if (mvm->refs[i]) {
272 taken = true;
273 break;
274 }
275 }
276 spin_unlock_bh(&mvm->refs_lock);
277
278 return taken;
279}
280
Eliad Peller576eeee2014-07-01 18:38:38 +0300281int iwl_mvm_ref_sync(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
Gregory Greenmand40fc482014-06-25 14:08:50 +0200282{
283 iwl_mvm_ref(mvm, ref_type);
284
285 if (!wait_event_timeout(mvm->d0i3_exit_waitq,
286 !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
287 HZ)) {
288 WARN_ON_ONCE(1);
289 iwl_mvm_unref(mvm, ref_type);
290 return -EIO;
291 }
292
293 return 0;
294}
295
Ilan Peerfe0f2de2013-03-21 10:23:52 +0200296static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm *mvm)
297{
298 int i;
299
300 memset(mvm->phy_ctxts, 0, sizeof(mvm->phy_ctxts));
301 for (i = 0; i < NUM_PHY_CTX; i++) {
302 mvm->phy_ctxts[i].id = i;
303 mvm->phy_ctxts[i].ref = 0;
304 }
305}
306
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200307struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy,
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200308 const char *alpha2,
Jonathan Doron47c8b152014-11-27 16:55:25 +0200309 enum iwl_mcc_source src_id,
310 bool *changed)
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200311{
312 struct ieee80211_regdomain *regd = NULL;
313 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
314 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
315 struct iwl_mcc_update_resp *resp;
316
317 IWL_DEBUG_LAR(mvm, "Getting regdomain data for %s from FW\n", alpha2);
318
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200319 lockdep_assert_held(&mvm->mutex);
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200320
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200321 resp = iwl_mvm_update_mcc(mvm, alpha2, src_id);
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200322 if (IS_ERR_OR_NULL(resp)) {
323 IWL_DEBUG_LAR(mvm, "Could not get update from FW %d\n",
Nicholas Krauseb8c474d2015-05-23 20:53:21 -0400324 PTR_ERR_OR_ZERO(resp));
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200325 goto out;
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200326 }
327
Jonathan Doron47c8b152014-11-27 16:55:25 +0200328 if (changed)
329 *changed = (resp->status == MCC_RESP_NEW_CHAN_PROFILE);
330
Arik Nemtsov162ee3c2014-06-10 11:25:35 +0300331 regd = iwl_parse_nvm_mcc_info(mvm->trans->dev, mvm->cfg,
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200332 __le32_to_cpu(resp->n_channels),
333 resp->channels,
334 __le16_to_cpu(resp->mcc));
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200335 /* Store the return source id */
336 src_id = resp->source_id;
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200337 kfree(resp);
338 if (IS_ERR_OR_NULL(regd)) {
339 IWL_DEBUG_LAR(mvm, "Could not get parse update from FW %d\n",
Nicholas Krauseb8c474d2015-05-23 20:53:21 -0400340 PTR_ERR_OR_ZERO(regd));
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200341 goto out;
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200342 }
343
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200344 IWL_DEBUG_LAR(mvm, "setting alpha2 from FW to %s (0x%x, 0x%x) src=%d\n",
345 regd->alpha2, regd->alpha2[0], regd->alpha2[1], src_id);
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200346 mvm->lar_regdom_set = true;
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200347 mvm->mcc_src = src_id;
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200348
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200349out:
Arik Nemtsov88931cc2014-03-05 12:26:15 +0200350 return regd;
351}
352
Jonathan Doron47c8b152014-11-27 16:55:25 +0200353void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm)
354{
355 bool changed;
356 struct ieee80211_regdomain *regd;
357
358 if (!iwl_mvm_is_lar_supported(mvm))
359 return;
360
361 regd = iwl_mvm_get_current_regdomain(mvm, &changed);
362 if (!IS_ERR_OR_NULL(regd)) {
363 /* only update the regulatory core if changed */
364 if (changed)
365 regulatory_set_wiphy_regd(mvm->hw->wiphy, regd);
366
367 kfree(regd);
368 }
369}
370
371struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm,
372 bool *changed)
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200373{
374 return iwl_mvm_get_regdomain(mvm->hw->wiphy, "ZZ",
375 iwl_mvm_is_wifi_mcc_supported(mvm) ?
376 MCC_SOURCE_GET_CURRENT :
Jonathan Doron47c8b152014-11-27 16:55:25 +0200377 MCC_SOURCE_OLD_FW, changed);
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200378}
379
380int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm)
381{
382 enum iwl_mcc_source used_src;
383 struct ieee80211_regdomain *regd;
Arik Nemtsovb6e160a2015-03-23 14:32:53 +0200384 int ret;
385 bool changed;
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200386 const struct ieee80211_regdomain *r =
387 rtnl_dereference(mvm->hw->wiphy->regd);
388
389 if (!r)
Arik Nemtsovb6e160a2015-03-23 14:32:53 +0200390 return -ENOENT;
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200391
392 /* save the last source in case we overwrite it below */
393 used_src = mvm->mcc_src;
394 if (iwl_mvm_is_wifi_mcc_supported(mvm)) {
395 /* Notify the firmware we support wifi location updates */
Jonathan Doron47c8b152014-11-27 16:55:25 +0200396 regd = iwl_mvm_get_current_regdomain(mvm, NULL);
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200397 if (!IS_ERR_OR_NULL(regd))
398 kfree(regd);
399 }
400
401 /* Now set our last stored MCC and source */
Arik Nemtsovb6e160a2015-03-23 14:32:53 +0200402 regd = iwl_mvm_get_regdomain(mvm->hw->wiphy, r->alpha2, used_src,
403 &changed);
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200404 if (IS_ERR_OR_NULL(regd))
405 return -EIO;
406
Arik Nemtsovb6e160a2015-03-23 14:32:53 +0200407 /* update cfg80211 if the regdomain was changed */
408 if (changed)
409 ret = regulatory_set_wiphy_regd_sync_rtnl(mvm->hw->wiphy, regd);
410 else
411 ret = 0;
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200412
Arik Nemtsovb6e160a2015-03-23 14:32:53 +0200413 kfree(regd);
414 return ret;
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200415}
416
Johannes Berg8ca151b2013-01-24 14:25:36 +0100417int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm)
418{
419 struct ieee80211_hw *hw = mvm->hw;
Ilan Peer831e85f2013-02-07 17:09:09 +0200420 int num_mac, ret, i;
Johannes Berg5f4c02e2015-05-20 16:51:28 +0200421 static const u32 mvm_ciphers[] = {
422 WLAN_CIPHER_SUITE_WEP40,
423 WLAN_CIPHER_SUITE_WEP104,
424 WLAN_CIPHER_SUITE_TKIP,
425 WLAN_CIPHER_SUITE_CCMP,
426 };
Johannes Berg8ca151b2013-01-24 14:25:36 +0100427
428 /* Tell mac80211 our characteristics */
Johannes Berg30686bf2015-06-02 21:39:54 +0200429 ieee80211_hw_set(hw, SIGNAL_DBM);
430 ieee80211_hw_set(hw, SPECTRUM_MGMT);
431 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
432 ieee80211_hw_set(hw, QUEUE_CONTROL);
433 ieee80211_hw_set(hw, WANT_MONITOR_VIF);
434 ieee80211_hw_set(hw, SUPPORTS_PS);
435 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
436 ieee80211_hw_set(hw, AMPDU_AGGREGATION);
437 ieee80211_hw_set(hw, TIMING_BEACON_ONLY);
438 ieee80211_hw_set(hw, CONNECTION_MONITOR);
439 ieee80211_hw_set(hw, CHANCTX_STA_CSA);
440 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
441 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
Johannes Berg909ddf02015-09-21 14:09:17 +0200442 ieee80211_hw_set(hw, SUPPORTS_AMSDU_IN_AMPDU);
Johannes Berg30433d32015-09-24 18:14:55 +0200443 ieee80211_hw_set(hw, NEEDS_UNIQUE_STA_ADDR);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100444
Johannes Berg2d7cf542015-04-17 16:39:12 +0200445 if (mvm->trans->max_skb_frags)
446 hw->netdev_features = NETIF_F_HIGHDMA | NETIF_F_SG;
447
Eytan Lifshitz19e737c2013-09-09 13:30:15 +0200448 hw->queues = mvm->first_agg_queue;
Ilan Peer398e8c62013-03-13 15:20:35 +0200449 hw->offchannel_tx_hw_queue = IWL_MVM_OFFCHANNEL_QUEUE;
Emmanuel Grumbach7b1dd042014-02-04 15:32:43 +0200450 hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FEC |
451 IEEE80211_RADIOTAP_MCS_HAVE_STBC;
Eyal Shapira339b3082014-11-18 16:43:55 +0200452 hw->radiotap_vht_details |= IEEE80211_RADIOTAP_VHT_KNOWN_STBC |
453 IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100454 hw->rate_control_algorithm = "iwl-mvm-rs";
Johannes Berg848955c2014-11-11 12:48:42 +0100455 hw->uapsd_queues = IWL_MVM_UAPSD_QUEUES;
456 hw->uapsd_max_sp_len = IWL_UAPSD_MAX_SP;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100457
Johannes Berg5f4c02e2015-05-20 16:51:28 +0200458 BUILD_BUG_ON(ARRAY_SIZE(mvm->ciphers) < ARRAY_SIZE(mvm_ciphers) + 2);
459 memcpy(mvm->ciphers, mvm_ciphers, sizeof(mvm_ciphers));
460 hw->wiphy->n_cipher_suites = ARRAY_SIZE(mvm_ciphers);
461 hw->wiphy->cipher_suites = mvm->ciphers;
462
Johannes Berg8ca151b2013-01-24 14:25:36 +0100463 /*
464 * Enable 11w if advertised by firmware and software crypto
465 * is not enabled (as the firmware will interpret some mgmt
466 * packets, so enabling it with software crypto isn't safe)
467 */
468 if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_MFP &&
Johannes Berg5f4c02e2015-05-20 16:51:28 +0200469 !iwlwifi_mod_params.sw_crypto) {
Johannes Berg30686bf2015-06-02 21:39:54 +0200470 ieee80211_hw_set(hw, MFP_CAPABLE);
Johannes Berg5f4c02e2015-05-20 16:51:28 +0200471 mvm->ciphers[hw->wiphy->n_cipher_suites] =
472 WLAN_CIPHER_SUITE_AES_CMAC;
473 hw->wiphy->n_cipher_suites++;
474 }
475
476 /* currently FW API supports only one optional cipher scheme */
477 if (mvm->fw->cs[0].cipher) {
478 mvm->hw->n_cipher_schemes = 1;
479 mvm->hw->cipher_schemes = &mvm->fw->cs[0];
480 mvm->ciphers[hw->wiphy->n_cipher_suites] =
481 mvm->fw->cs[0].cipher;
482 hw->wiphy->n_cipher_suites++;
483 }
Johannes Berg8ca151b2013-01-24 14:25:36 +0100484
Johannes Berg30686bf2015-06-02 21:39:54 +0200485 ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS);
Luciano Coelho1f940382015-02-10 13:03:38 +0200486 hw->wiphy->features |=
487 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
Johannes Berg3db93422015-05-06 14:56:51 +0200488 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR |
489 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
David Spinadelfb98be52014-05-04 12:51:10 +0300490
Johannes Berg8ca151b2013-01-24 14:25:36 +0100491 hw->sta_data_size = sizeof(struct iwl_mvm_sta);
492 hw->vif_data_size = sizeof(struct iwl_mvm_vif);
Ilan Peerfe0f2de2013-03-21 10:23:52 +0200493 hw->chanctx_data_size = sizeof(u16);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100494
495 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
Johannes Berg3c15a0f2013-05-31 10:17:19 +0200496 BIT(NL80211_IFTYPE_P2P_CLIENT) |
497 BIT(NL80211_IFTYPE_AP) |
498 BIT(NL80211_IFTYPE_P2P_GO) |
Emmanuel Grumbachc13b1722014-03-27 19:12:12 +0200499 BIT(NL80211_IFTYPE_P2P_DEVICE) |
500 BIT(NL80211_IFTYPE_ADHOC);
Johannes Berg5023d962013-07-31 14:07:43 +0200501
Luis R. Rodrigueza2f73b62013-11-11 22:15:29 +0100502 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
Eran Harary8ba2d7a2015-02-08 11:41:43 +0200503 hw->wiphy->regulatory_flags |= REGULATORY_ENABLE_RELAX_NO_IR;
504 if (iwl_mvm_is_lar_supported(mvm))
505 hw->wiphy->regulatory_flags |= REGULATORY_WIPHY_SELF_MANAGED;
506 else
507 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
508 REGULATORY_DISABLE_BEACON_HINTS;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100509
Johannes Berg3e56ead2013-02-15 22:23:18 +0100510 if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_GO_UAPSD)
511 hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
512
Emmanuel Grumbach94bbed72014-11-24 08:53:33 +0200513 hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +0200514
Johannes Berg8ca151b2013-01-24 14:25:36 +0100515 hw->wiphy->iface_combinations = iwl_mvm_iface_combinations;
516 hw->wiphy->n_iface_combinations =
517 ARRAY_SIZE(iwl_mvm_iface_combinations);
518
Ilan Peerc451e6d2013-02-20 08:41:54 +0200519 hw->wiphy->max_remain_on_channel_duration = 10000;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100520 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
Emmanuel Grumbachf1a68542014-12-16 12:31:13 +0200521 /* we can compensate an offset of up to 3 channels = 15 MHz */
522 hw->wiphy->max_adj_channel_rssi_comp = 3 * 5;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100523
524 /* Extract MAC address */
525 memcpy(mvm->addresses[0].addr, mvm->nvm_data->hw_addr, ETH_ALEN);
526 hw->wiphy->addresses = mvm->addresses;
527 hw->wiphy->n_addresses = 1;
Ilan Peer831e85f2013-02-07 17:09:09 +0200528
529 /* Extract additional MAC addresses if available */
530 num_mac = (mvm->nvm_data->n_hw_addrs > 1) ?
531 min(IWL_MVM_MAX_ADDRESSES, mvm->nvm_data->n_hw_addrs) : 1;
532
533 for (i = 1; i < num_mac; i++) {
534 memcpy(mvm->addresses[i].addr, mvm->addresses[i-1].addr,
Johannes Berg8ca151b2013-01-24 14:25:36 +0100535 ETH_ALEN);
Ilan Peer831e85f2013-02-07 17:09:09 +0200536 mvm->addresses[i].addr[5]++;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100537 hw->wiphy->n_addresses++;
538 }
539
Ilan Peerfe0f2de2013-03-21 10:23:52 +0200540 iwl_mvm_reset_phy_ctxts(mvm);
541
Luciano Coelho999d2562015-03-27 10:28:26 +0300542 hw->wiphy->max_scan_ie_len = iwl_mvm_max_scan_ie_len(mvm);
David Spinadel20f1a5d2013-08-21 09:14:27 +0300543
Johannes Berg8ca151b2013-01-24 14:25:36 +0100544 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
545
Luciano Coelhoc7d42482015-05-07 16:00:26 +0300546 BUILD_BUG_ON(IWL_MVM_SCAN_STOPPING_MASK & IWL_MVM_SCAN_MASK);
Luciano Coelho507e4cd2015-03-19 22:58:33 +0200547 BUILD_BUG_ON(IWL_MVM_MAX_UMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK) ||
548 IWL_MVM_MAX_LMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK));
549
Johannes Berg859d9142015-06-01 17:11:11 +0200550 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
Luciano Coelho507e4cd2015-03-19 22:58:33 +0200551 mvm->max_scans = IWL_MVM_MAX_UMAC_SCANS;
552 else
553 mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
554
Johannes Berg8ca151b2013-01-24 14:25:36 +0100555 if (mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels)
556 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
557 &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
Eyal Shapira3d44eeb2015-01-16 22:37:04 +0200558 if (mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels) {
Johannes Berg8ca151b2013-01-24 14:25:36 +0100559 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
560 &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
561
Johannes Berg859d9142015-06-01 17:11:11 +0200562 if (fw_has_capa(&mvm->fw->ucode_capa,
563 IWL_UCODE_TLV_CAPA_BEAMFORMER) &&
564 fw_has_api(&mvm->fw->ucode_capa,
565 IWL_UCODE_TLV_API_LQ_SS_PARAMS))
Eyal Shapira3d44eeb2015-01-16 22:37:04 +0200566 hw->wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap.cap |=
567 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
568 }
569
Johannes Berg8ca151b2013-01-24 14:25:36 +0100570 hw->wiphy->hw_version = mvm->trans->hw_id;
571
Alexander Bondarade50652013-04-03 16:28:47 +0300572 if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM)
Johannes Berg8ca151b2013-01-24 14:25:36 +0100573 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
574 else
575 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
576
Emmanuel Grumbach9954b372015-03-16 14:49:55 +0200577 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
578 hw->wiphy->max_sched_scan_ssids = PROBE_OPTION_MAX;
579 hw->wiphy->max_match_sets = IWL_SCAN_MAX_PROFILES;
580 /* we create the 802.11 header and zero length SSID IE. */
581 hw->wiphy->max_sched_scan_ie_len =
582 SCAN_OFFLOAD_PROBE_REQ_SIZE - 24 - 2;
Avraham Sterncd55cce2015-08-19 12:46:12 +0300583 hw->wiphy->max_sched_scan_plans = IWL_MAX_SCHED_SCAN_PLANS;
584 hw->wiphy->max_sched_scan_plan_interval = U16_MAX;
585
586 /*
587 * the firmware uses u8 for num of iterations, but 0xff is saved for
588 * infinite loop, so the maximum number of iterations is actually 254.
589 */
590 hw->wiphy->max_sched_scan_plan_iterations = 254;
David Spinadel35a000b2013-08-28 09:29:43 +0300591
Johannes Berg8ca151b2013-01-24 14:25:36 +0100592 hw->wiphy->features |= NL80211_FEATURE_P2P_GO_CTWIN |
Johannes Bergab480032014-06-04 10:13:50 +0200593 NL80211_FEATURE_LOW_PRIORITY_SCAN |
Eliad Peller0d8614b2014-09-10 14:07:36 +0300594 NL80211_FEATURE_P2P_GO_OPPPS |
595 NL80211_FEATURE_DYNAMIC_SMPS |
Emmanuel Grumbach9b5452f2014-10-07 10:38:53 +0300596 NL80211_FEATURE_STATIC_SMPS |
597 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100598
Johannes Berg859d9142015-06-01 17:11:11 +0200599 if (fw_has_capa(&mvm->fw->ucode_capa,
600 IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT))
Andrei Otcheretianskif1daa002014-07-01 12:54:25 +0300601 hw->wiphy->features |= NL80211_FEATURE_TX_POWER_INSERTION;
Johannes Berg859d9142015-06-01 17:11:11 +0200602 if (fw_has_capa(&mvm->fw->ucode_capa,
603 IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT))
Assaf Krauss226bcd42014-03-13 08:12:15 +0200604 hw->wiphy->features |= NL80211_FEATURE_QUIET;
Andrei Otcheretianskif1daa002014-07-01 12:54:25 +0300605
Johannes Berg859d9142015-06-01 17:11:11 +0200606 if (fw_has_capa(&mvm->fw->ucode_capa,
607 IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
Andrei Otcheretianski73897bd2014-07-09 18:59:14 +0300608 hw->wiphy->features |=
609 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES;
610
Johannes Berg859d9142015-06-01 17:11:11 +0200611 if (fw_has_capa(&mvm->fw->ucode_capa,
612 IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT))
Andrei Otcheretianski73897bd2014-07-09 18:59:14 +0300613 hw->wiphy->features |= NL80211_FEATURE_WFA_TPC_IE_IN_PROBES;
614
Johannes Berg8ca151b2013-01-24 14:25:36 +0100615 mvm->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
616
617#ifdef CONFIG_PM_SLEEP
Eliad Pellerd15a7472014-03-27 18:53:12 +0200618 if (iwl_mvm_is_d0i3_supported(mvm) &&
619 device_can_wakeup(mvm->trans->dev)) {
620 mvm->wowlan.flags = WIPHY_WOWLAN_ANY;
621 hw->wiphy->wowlan = &mvm->wowlan;
Eliad Peller91742442014-12-09 15:54:46 +0200622 }
623
624 if (mvm->fw->img[IWL_UCODE_WOWLAN].sec[0].len &&
Johannes Berg8ca151b2013-01-24 14:25:36 +0100625 mvm->trans->ops->d3_suspend &&
626 mvm->trans->ops->d3_resume &&
627 device_can_wakeup(mvm->trans->dev)) {
Eliad Peller91742442014-12-09 15:54:46 +0200628 mvm->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT |
629 WIPHY_WOWLAN_DISCONNECT |
630 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
631 WIPHY_WOWLAN_RFKILL_RELEASE |
632 WIPHY_WOWLAN_NET_DETECT;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100633 if (!iwlwifi_mod_params.sw_crypto)
Johannes Berg964dc9e2013-06-03 17:25:34 +0200634 mvm->wowlan.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
635 WIPHY_WOWLAN_GTK_REKEY_FAILURE |
636 WIPHY_WOWLAN_4WAY_HANDSHAKE;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100637
Johannes Berg964dc9e2013-06-03 17:25:34 +0200638 mvm->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS;
639 mvm->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN;
640 mvm->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN;
Luciano Coelhoc55385f2014-10-24 10:39:51 +0300641 mvm->wowlan.max_nd_match_sets = IWL_SCAN_MAX_PROFILES;
Johannes Berg964dc9e2013-06-03 17:25:34 +0200642 mvm->wowlan.tcp = &iwl_mvm_wowlan_tcp_support;
643 hw->wiphy->wowlan = &mvm->wowlan;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100644 }
645#endif
646
Eliad Peller77736922014-01-14 12:35:49 +0200647#ifdef CONFIG_IWLWIFI_BCAST_FILTERING
648 /* assign default bcast filtering configuration */
649 mvm->bcast_filters = iwl_mvm_default_bcast_filters;
650#endif
651
Johannes Berg8ca151b2013-01-24 14:25:36 +0100652 ret = iwl_mvm_leds_init(mvm);
653 if (ret)
654 return ret;
655
Johannes Berg859d9142015-06-01 17:11:11 +0200656 if (fw_has_capa(&mvm->fw->ucode_capa,
657 IWL_UCODE_TLV_CAPA_TDLS_SUPPORT)) {
Arik Nemtsovd8f1c512014-05-11 18:13:04 +0300658 IWL_DEBUG_TDLS(mvm, "TDLS supported\n");
659 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
Arik Nemtsov7c4f0842015-04-30 18:31:45 +0300660 ieee80211_hw_set(hw, TDLS_WIDER_BW);
Arik Nemtsovd8f1c512014-05-11 18:13:04 +0300661 }
662
Johannes Berg859d9142015-06-01 17:11:11 +0200663 if (fw_has_capa(&mvm->fw->ucode_capa,
664 IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH)) {
Arik Nemtsov1d3c3f62014-10-23 18:03:10 +0300665 IWL_DEBUG_TDLS(mvm, "TDLS channel switch supported\n");
666 hw->wiphy->features |= NL80211_FEATURE_TDLS_CHANNEL_SWITCH;
667 }
668
Avri Altman93190fb2014-12-27 09:09:47 +0200669 hw->netdev_features |= mvm->cfg->features;
670 if (!iwl_mvm_is_csum_supported(mvm))
671 hw->netdev_features &= ~NETIF_F_RXCSUM;
672
Emmanuel Grumbach41837ca92015-10-21 09:00:07 +0300673 if (IWL_MVM_SW_TX_CSUM_OFFLOAD)
Emmanuel Grumbacha3713f82015-10-14 14:16:35 +0300674 hw->netdev_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
675 NETIF_F_TSO | NETIF_F_TSO6;
Emmanuel Grumbach41837ca92015-10-21 09:00:07 +0300676
Emmanuel Grumbachb7327d82013-06-24 15:44:03 +0300677 ret = ieee80211_register_hw(mvm->hw);
678 if (ret)
679 iwl_mvm_leds_exit(mvm);
680
681 return ret;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100682}
683
Arik Nemtsovb2492502014-03-13 12:21:50 +0200684static bool iwl_mvm_defer_tx(struct iwl_mvm *mvm,
685 struct ieee80211_sta *sta,
686 struct sk_buff *skb)
687{
688 struct iwl_mvm_sta *mvmsta;
689 bool defer = false;
690
691 /*
692 * double check the IN_D0I3 flag both before and after
693 * taking the spinlock, in order to prevent taking
694 * the spinlock when not needed.
695 */
696 if (likely(!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status)))
697 return false;
698
699 spin_lock(&mvm->d0i3_tx_lock);
700 /*
701 * testing the flag again ensures the skb dequeue
702 * loop (on d0i3 exit) hasn't run yet.
703 */
704 if (!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status))
705 goto out;
706
707 mvmsta = iwl_mvm_sta_from_mac80211(sta);
708 if (mvmsta->sta_id == IWL_MVM_STATION_COUNT ||
709 mvmsta->sta_id != mvm->d0i3_ap_sta_id)
710 goto out;
711
712 __skb_queue_tail(&mvm->d0i3_tx, skb);
713 ieee80211_stop_queues(mvm->hw);
714
715 /* trigger wakeup */
716 iwl_mvm_ref(mvm, IWL_MVM_REF_TX);
717 iwl_mvm_unref(mvm, IWL_MVM_REF_TX);
718
719 defer = true;
720out:
721 spin_unlock(&mvm->d0i3_tx_lock);
722 return defer;
723}
724
Johannes Berg8ca151b2013-01-24 14:25:36 +0100725static void iwl_mvm_mac_tx(struct ieee80211_hw *hw,
726 struct ieee80211_tx_control *control,
727 struct sk_buff *skb)
728{
729 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Berg3e56ead2013-02-15 22:23:18 +0100730 struct ieee80211_sta *sta = control->sta;
731 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
732 struct ieee80211_hdr *hdr = (void *)skb->data;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100733
Eytan Lifshitz9ee718a2013-05-19 19:14:41 +0300734 if (iwl_mvm_is_radio_killed(mvm)) {
735 IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");
Johannes Berg8ca151b2013-01-24 14:25:36 +0100736 goto drop;
737 }
738
Ilan Peer398e8c62013-03-13 15:20:35 +0200739 if (IEEE80211_SKB_CB(skb)->hw_queue == IWL_MVM_OFFCHANNEL_QUEUE &&
Matti Gottlieba6cc5162014-09-29 11:46:04 +0300740 !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&
741 !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status))
Johannes Berg8ca151b2013-01-24 14:25:36 +0100742 goto drop;
743
Johannes Berg3e56ead2013-02-15 22:23:18 +0100744 /* treat non-bufferable MMPDUs as broadcast if sta is sleeping */
745 if (unlikely(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER &&
746 ieee80211_is_mgmt(hdr->frame_control) &&
747 !ieee80211_is_deauth(hdr->frame_control) &&
748 !ieee80211_is_disassoc(hdr->frame_control) &&
749 !ieee80211_is_action(hdr->frame_control)))
750 sta = NULL;
751
752 if (sta) {
Arik Nemtsovb2492502014-03-13 12:21:50 +0200753 if (iwl_mvm_defer_tx(mvm, sta, skb))
754 return;
Johannes Berg3e56ead2013-02-15 22:23:18 +0100755 if (iwl_mvm_tx_skb(mvm, skb, sta))
Johannes Berg8ca151b2013-01-24 14:25:36 +0100756 goto drop;
757 return;
758 }
759
760 if (iwl_mvm_tx_skb_non_sta(mvm, skb))
761 goto drop;
762 return;
763 drop:
764 ieee80211_free_txskb(hw, skb);
765}
766
Emmanuel Grumbach205e2212014-02-12 15:15:05 +0200767static inline bool iwl_enable_rx_ampdu(const struct iwl_cfg *cfg)
768{
769 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG)
770 return false;
771 return true;
772}
773
774static inline bool iwl_enable_tx_ampdu(const struct iwl_cfg *cfg)
775{
776 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG)
777 return false;
778 if (iwlwifi_mod_params.disable_11n & IWL_ENABLE_HT_TXAGG)
779 return true;
780
781 /* enabled by default */
782 return true;
783}
784
Emmanuel Grumbach42032632015-04-15 12:43:46 +0300785#define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...) \
786 do { \
787 if (!(le16_to_cpu(_tid_bm) & BIT(_tid))) \
788 break; \
789 iwl_mvm_fw_dbg_collect_trig(_mvm, _trig, _fmt); \
790 } while (0)
791
792static void
793iwl_mvm_ampdu_check_trigger(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
794 struct ieee80211_sta *sta, u16 tid, u16 rx_ba_ssn,
795 enum ieee80211_ampdu_mlme_action action)
796{
797 struct iwl_fw_dbg_trigger_tlv *trig;
798 struct iwl_fw_dbg_trigger_ba *ba_trig;
799
800 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
801 return;
802
803 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
804 ba_trig = (void *)trig->data;
805
806 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
807 return;
808
809 switch (action) {
810 case IEEE80211_AMPDU_TX_OPERATIONAL: {
811 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
812 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
813
814 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_start, tid,
815 "TX AGG START: MAC %pM tid %d ssn %d\n",
816 sta->addr, tid, tid_data->ssn);
817 break;
818 }
819 case IEEE80211_AMPDU_TX_STOP_CONT:
820 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_stop, tid,
821 "TX AGG STOP: MAC %pM tid %d\n",
822 sta->addr, tid);
823 break;
824 case IEEE80211_AMPDU_RX_START:
825 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_start, tid,
826 "RX AGG START: MAC %pM tid %d ssn %d\n",
827 sta->addr, tid, rx_ba_ssn);
828 break;
829 case IEEE80211_AMPDU_RX_STOP:
830 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_stop, tid,
831 "RX AGG STOP: MAC %pM tid %d\n",
832 sta->addr, tid);
833 break;
834 default:
835 break;
836 }
837}
838
Johannes Berg8ca151b2013-01-24 14:25:36 +0100839static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw *hw,
840 struct ieee80211_vif *vif,
Sara Sharon50ea05e2015-12-30 16:06:04 +0200841 struct ieee80211_ampdu_params *params)
Johannes Berg8ca151b2013-01-24 14:25:36 +0100842{
843 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
844 int ret;
Arik Nemtsovb2492502014-03-13 12:21:50 +0200845 bool tx_agg_ref = false;
Sara Sharon50ea05e2015-12-30 16:06:04 +0200846 struct ieee80211_sta *sta = params->sta;
847 enum ieee80211_ampdu_mlme_action action = params->action;
848 u16 tid = params->tid;
849 u16 *ssn = &params->ssn;
850 u8 buf_size = params->buf_size;
Emmanuel Grumbachbb81bb62015-10-26 16:00:29 +0200851 bool amsdu = params->amsdu;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100852
853 IWL_DEBUG_HT(mvm, "A-MPDU action on addr %pM tid %d: action %d\n",
854 sta->addr, tid, action);
855
856 if (!(mvm->nvm_data->sku_cap_11n_enable))
857 return -EACCES;
858
Arik Nemtsovb2492502014-03-13 12:21:50 +0200859 /* return from D0i3 before starting a new Tx aggregation */
Eliad Peller9256c202014-04-22 13:33:29 +0300860 switch (action) {
861 case IEEE80211_AMPDU_TX_START:
862 case IEEE80211_AMPDU_TX_STOP_CONT:
863 case IEEE80211_AMPDU_TX_STOP_FLUSH:
864 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
865 case IEEE80211_AMPDU_TX_OPERATIONAL:
Arik Nemtsovb2492502014-03-13 12:21:50 +0200866 /*
Eliad Peller9256c202014-04-22 13:33:29 +0300867 * for tx start, wait synchronously until D0i3 exit to
868 * get the correct sequence number for the tid.
869 * additionally, some other ampdu actions use direct
870 * target access, which is not handled automatically
871 * by the trans layer (unlike commands), so wait for
872 * d0i3 exit in these cases as well.
Arik Nemtsovb2492502014-03-13 12:21:50 +0200873 */
Gregory Greenmand40fc482014-06-25 14:08:50 +0200874 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_TX_AGG);
875 if (ret)
876 return ret;
877
878 tx_agg_ref = true;
Eliad Peller9256c202014-04-22 13:33:29 +0300879 break;
880 default:
881 break;
Arik Nemtsovb2492502014-03-13 12:21:50 +0200882 }
883
Johannes Berg8ca151b2013-01-24 14:25:36 +0100884 mutex_lock(&mvm->mutex);
885
886 switch (action) {
887 case IEEE80211_AMPDU_RX_START:
Emmanuel Grumbach205e2212014-02-12 15:15:05 +0200888 if (!iwl_enable_rx_ampdu(mvm->cfg)) {
Johannes Berg8ca151b2013-01-24 14:25:36 +0100889 ret = -EINVAL;
890 break;
891 }
Sara Sharon854c5702016-01-26 13:17:47 +0200892 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, *ssn, true, buf_size);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100893 break;
894 case IEEE80211_AMPDU_RX_STOP:
Sara Sharon854c5702016-01-26 13:17:47 +0200895 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, 0, false, buf_size);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100896 break;
897 case IEEE80211_AMPDU_TX_START:
Emmanuel Grumbach205e2212014-02-12 15:15:05 +0200898 if (!iwl_enable_tx_ampdu(mvm->cfg)) {
Emmanuel Grumbach5d158ef2013-02-19 14:39:58 +0200899 ret = -EINVAL;
900 break;
901 }
Johannes Berg8ca151b2013-01-24 14:25:36 +0100902 ret = iwl_mvm_sta_tx_agg_start(mvm, vif, sta, tid, ssn);
903 break;
904 case IEEE80211_AMPDU_TX_STOP_CONT:
Emmanuel Grumbache3d9e7c2013-02-19 16:13:53 +0200905 ret = iwl_mvm_sta_tx_agg_stop(mvm, vif, sta, tid);
906 break;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100907 case IEEE80211_AMPDU_TX_STOP_FLUSH:
908 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
Emmanuel Grumbache3d9e7c2013-02-19 16:13:53 +0200909 ret = iwl_mvm_sta_tx_agg_flush(mvm, vif, sta, tid);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100910 break;
911 case IEEE80211_AMPDU_TX_OPERATIONAL:
Emmanuel Grumbachbb81bb62015-10-26 16:00:29 +0200912 ret = iwl_mvm_sta_tx_agg_oper(mvm, vif, sta, tid,
913 buf_size, amsdu);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100914 break;
915 default:
916 WARN_ON_ONCE(1);
917 ret = -EINVAL;
918 break;
919 }
Emmanuel Grumbach42032632015-04-15 12:43:46 +0300920
921 if (!ret) {
922 u16 rx_ba_ssn = 0;
923
924 if (action == IEEE80211_AMPDU_RX_START)
925 rx_ba_ssn = *ssn;
926
927 iwl_mvm_ampdu_check_trigger(mvm, vif, sta, tid,
928 rx_ba_ssn, action);
929 }
Johannes Berg8ca151b2013-01-24 14:25:36 +0100930 mutex_unlock(&mvm->mutex);
931
Arik Nemtsovb2492502014-03-13 12:21:50 +0200932 /*
933 * If the tid is marked as started, we won't use it for offloaded
934 * traffic on the next D0i3 entry. It's safe to unref.
935 */
936 if (tx_agg_ref)
937 iwl_mvm_unref(mvm, IWL_MVM_REF_TX_AGG);
938
Johannes Berg8ca151b2013-01-24 14:25:36 +0100939 return ret;
940}
941
942static void iwl_mvm_cleanup_iterator(void *data, u8 *mac,
943 struct ieee80211_vif *vif)
944{
945 struct iwl_mvm *mvm = data;
946 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
947
948 mvmvif->uploaded = false;
949 mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
950
Johannes Berg8ca151b2013-01-24 14:25:36 +0100951 spin_lock_bh(&mvm->time_event_lock);
952 iwl_mvm_te_clear_data(mvm, &mvmvif->time_event_data);
953 spin_unlock_bh(&mvm->time_event_lock);
954
Ilan Peerfe0f2de2013-03-21 10:23:52 +0200955 mvmvif->phy_ctxt = NULL;
Emmanuel Grumbach8a275ba2014-07-13 09:12:11 +0300956 memset(&mvmvif->bf_data, 0, sizeof(mvmvif->bf_data));
Johannes Berg8ca151b2013-01-24 14:25:36 +0100957}
958
959static void iwl_mvm_restart_cleanup(struct iwl_mvm *mvm)
960{
Johannes Berg58629d92014-11-06 09:40:50 +0100961 /* clear the D3 reconfig, we only need it to avoid dumping a
962 * firmware coredump on reconfiguration, we shouldn't do that
963 * on D3->D0 transition
964 */
Emmanuel Grumbachb6eaa452015-01-29 14:58:20 +0200965 if (!test_and_clear_bit(IWL_MVM_STATUS_D3_RECONFIG, &mvm->status)) {
966 mvm->fw_dump_desc = &iwl_mvm_dump_desc_assert;
Johannes Berg58629d92014-11-06 09:40:50 +0100967 iwl_mvm_fw_error_dump(mvm);
Emmanuel Grumbachb6eaa452015-01-29 14:58:20 +0200968 }
Emmanuel Grumbach1bd3cbc2014-03-18 21:15:06 +0200969
Eliad Peller744cb692014-12-10 18:44:13 +0200970 /* cleanup all stale references (scan, roc), but keep the
971 * ucode_down ref until reconfig is complete
972 */
973 iwl_mvm_unref_all_except(mvm, IWL_MVM_REF_UCODE_DOWN);
974
Johannes Berg8ca151b2013-01-24 14:25:36 +0100975 iwl_trans_stop_device(mvm->trans);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100976
Luciano Coelho9af91f42015-02-10 10:42:26 +0200977 mvm->scan_status = 0;
Luciano Coelhob1873302014-08-08 17:12:07 +0300978 mvm->ps_disabled = false;
Emmanuel Grumbach31b8b342014-11-02 15:48:09 +0200979 mvm->calibrating = false;
Johannes Berg8ca151b2013-01-24 14:25:36 +0100980
981 /* just in case one was running */
Eliad Peller305d2362015-12-09 16:33:20 +0200982 iwl_mvm_cleanup_roc_te(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100983 ieee80211_remain_on_channel_expired(mvm->hw);
984
Arik Nemtsov737719f2015-02-23 14:42:41 +0200985 /*
986 * cleanup all interfaces, even inactive ones, as some might have
987 * gone down during the HW restart
988 */
989 ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +0100990
Ilan Peerfe0f2de2013-03-21 10:23:52 +0200991 mvm->p2p_device_vif = NULL;
Eliad Peller37577fe2013-12-05 17:19:39 +0200992 mvm->d0i3_ap_sta_id = IWL_MVM_STATION_COUNT;
Ilan Peerfe0f2de2013-03-21 10:23:52 +0200993
994 iwl_mvm_reset_phy_ctxts(mvm);
Luca Coelho9c3deeb2015-11-11 01:06:17 +0200995 memset(mvm->fw_key_table, 0, sizeof(mvm->fw_key_table));
Johannes Berg8ca151b2013-01-24 14:25:36 +0100996 memset(mvm->sta_drained, 0, sizeof(mvm->sta_drained));
Arik Nemtsova0f6bf22014-09-21 19:10:04 +0300997 memset(mvm->tfd_drained, 0, sizeof(mvm->tfd_drained));
Emmanuel Grumbach8a275ba2014-07-13 09:12:11 +0300998 memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
999 memset(&mvm->last_bt_notif_old, 0, sizeof(mvm->last_bt_notif_old));
1000 memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
1001 memset(&mvm->last_bt_ci_cmd_old, 0, sizeof(mvm->last_bt_ci_cmd_old));
1002 memset(&mvm->bt_ack_kill_msk, 0, sizeof(mvm->bt_ack_kill_msk));
1003 memset(&mvm->bt_cts_kill_msk, 0, sizeof(mvm->bt_cts_kill_msk));
Johannes Berg8ca151b2013-01-24 14:25:36 +01001004
1005 ieee80211_wake_queues(mvm->hw);
1006
Eliad Peller228670b2014-08-10 17:00:15 +03001007 /* clear any stale d0i3 state */
1008 clear_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status);
1009
Johannes Berg8ca151b2013-01-24 14:25:36 +01001010 mvm->vif_count = 0;
Emmanuel Grumbach113a0442013-07-02 14:16:38 +03001011 mvm->rx_ba_sessions = 0;
Emmanuel Grumbachd2709ad2015-01-29 14:58:06 +02001012 mvm->fw_dbg_conf = FW_DBG_INVALID;
Johannes Berg91a8bcd2015-01-14 18:12:41 +01001013
1014 /* keep statistics ticking */
1015 iwl_mvm_accu_radio_stats(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001016}
1017
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001018int __iwl_mvm_mac_start(struct iwl_mvm *mvm)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001019{
Johannes Berg8ca151b2013-01-24 14:25:36 +01001020 int ret;
1021
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001022 lockdep_assert_held(&mvm->mutex);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001023
Luca Coelhoa42b2af32015-11-25 22:15:32 +02001024 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1025 /* Clean up some internal and mac80211 state on restart */
Johannes Berg8ca151b2013-01-24 14:25:36 +01001026 iwl_mvm_restart_cleanup(mvm);
Luca Coelhoa42b2af32015-11-25 22:15:32 +02001027 } else {
1028 /* Hold the reference to prevent runtime suspend while
1029 * the start procedure runs. It's a bit confusing
1030 * that the UCODE_DOWN reference is taken, but it just
1031 * means "UCODE is not UP yet". ( TODO: rename this
1032 * reference).
1033 */
1034 iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
1035 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001036 ret = iwl_mvm_up(mvm);
Johannes Bergc47af222014-04-30 16:34:45 +02001037
1038 if (ret && test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1039 /* Something went wrong - we need to finish some cleanup
1040 * that normally iwl_mvm_mac_restart_complete() below
1041 * would do.
1042 */
1043 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
1044 iwl_mvm_d0i3_enable_tx(mvm, NULL);
1045 }
1046
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001047 return ret;
1048}
1049
1050static int iwl_mvm_mac_start(struct ieee80211_hw *hw)
1051{
1052 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1053 int ret;
1054
Eliad Peller37948fc2014-12-11 10:48:18 +02001055 /* Some hw restart cleanups must not hold the mutex */
1056 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1057 /*
1058 * Make sure we are out of d0i3. This is needed
1059 * to make sure the reference accounting is correct
1060 * (and there is no stale d0i3_exit_work).
1061 */
1062 wait_event_timeout(mvm->d0i3_exit_waitq,
1063 !test_bit(IWL_MVM_STATUS_IN_D0I3,
1064 &mvm->status),
1065 HZ);
1066 }
1067
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001068 mutex_lock(&mvm->mutex);
1069 ret = __iwl_mvm_mac_start(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001070 mutex_unlock(&mvm->mutex);
1071
1072 return ret;
1073}
1074
Eliad Pellercf2c92d2014-11-04 11:43:54 +02001075static void iwl_mvm_restart_complete(struct iwl_mvm *mvm)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001076{
Johannes Berg8ca151b2013-01-24 14:25:36 +01001077 int ret;
1078
1079 mutex_lock(&mvm->mutex);
1080
1081 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
Arik Nemtsovb2492502014-03-13 12:21:50 +02001082 iwl_mvm_d0i3_enable_tx(mvm, NULL);
Johannes Berge7afe892015-04-21 09:21:46 +02001083 ret = iwl_mvm_update_quotas(mvm, true, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001084 if (ret)
1085 IWL_ERR(mvm, "Failed to update quotas after restart (%d)\n",
1086 ret);
1087
Eliad Peller7498cf42014-01-16 17:10:44 +02001088 /* allow transport/FW low power modes */
1089 iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
1090
Arik Nemtsovcbd2ae22014-09-14 19:13:54 +03001091 /*
1092 * If we have TDLS peers, remove them. We don't know the last seqno/PN
1093 * of packets the FW sent out, so we must reconnect.
1094 */
1095 iwl_mvm_teardown_tdls_peers(mvm);
1096
Johannes Berg8ca151b2013-01-24 14:25:36 +01001097 mutex_unlock(&mvm->mutex);
1098}
1099
Eliad Peller088070a22014-10-20 18:42:58 +03001100static void iwl_mvm_resume_complete(struct iwl_mvm *mvm)
1101{
Luca Coelhob7282642015-09-17 23:44:14 +03001102 if (iwl_mvm_is_d0i3_supported(mvm) &&
1103 iwl_mvm_enter_d0i3_on_suspend(mvm))
1104 WARN_ONCE(!wait_event_timeout(mvm->d0i3_exit_waitq,
1105 !test_bit(IWL_MVM_STATUS_IN_D0I3,
1106 &mvm->status),
1107 HZ),
1108 "D0i3 exit on resume timed out\n");
Eliad Peller088070a22014-10-20 18:42:58 +03001109}
1110
Eliad Pellercf2c92d2014-11-04 11:43:54 +02001111static void
1112iwl_mvm_mac_reconfig_complete(struct ieee80211_hw *hw,
1113 enum ieee80211_reconfig_type reconfig_type)
1114{
1115 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1116
1117 switch (reconfig_type) {
1118 case IEEE80211_RECONFIG_TYPE_RESTART:
1119 iwl_mvm_restart_complete(mvm);
1120 break;
1121 case IEEE80211_RECONFIG_TYPE_SUSPEND:
Eliad Peller088070a22014-10-20 18:42:58 +03001122 iwl_mvm_resume_complete(mvm);
Eliad Pellercf2c92d2014-11-04 11:43:54 +02001123 break;
1124 }
1125}
1126
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001127void __iwl_mvm_mac_stop(struct iwl_mvm *mvm)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001128{
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001129 lockdep_assert_held(&mvm->mutex);
Eliad Peller7498cf42014-01-16 17:10:44 +02001130
Johannes Berg91a8bcd2015-01-14 18:12:41 +01001131 /* firmware counters are obviously reset now, but we shouldn't
1132 * partially track so also clear the fw_reset_accu counters.
1133 */
1134 memset(&mvm->accu_radio_stats, 0, sizeof(mvm->accu_radio_stats));
1135
Johannes Berg8ca151b2013-01-24 14:25:36 +01001136 /* async_handlers_wk is now blocked */
1137
1138 /*
1139 * The work item could be running or queued if the
1140 * ROC time event stops just as we get here.
1141 */
Eliad Pellerc7792732015-04-19 11:41:04 +03001142 flush_work(&mvm->roc_done_wk);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001143
1144 iwl_trans_stop_device(mvm->trans);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001145
1146 iwl_mvm_async_handlers_purge(mvm);
1147 /* async_handlers_list is empty and will stay empty: HW is stopped */
1148
1149 /* the fw is stopped, the aux sta is dead: clean up driver state */
Johannes Berg712b24a2014-08-04 14:14:14 +02001150 iwl_mvm_del_aux_sta(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001151
Eliad Peller0a79a0c02014-12-04 10:27:20 +02001152 /*
1153 * Clear IN_HW_RESTART flag when stopping the hw (as restart_complete()
1154 * won't be called in this case).
Arik Nemtsov8b2b9fb2015-03-04 13:16:03 +02001155 * But make sure to cleanup interfaces that have gone down before/during
1156 * HW restart was requested.
Eliad Peller0a79a0c02014-12-04 10:27:20 +02001157 */
Arik Nemtsov8b2b9fb2015-03-04 13:16:03 +02001158 if (test_and_clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1159 ieee80211_iterate_interfaces(mvm->hw, 0,
1160 iwl_mvm_cleanup_iterator, mvm);
Eliad Peller0a79a0c02014-12-04 10:27:20 +02001161
Alexander Bondar963221b2015-03-26 11:07:35 +02001162 /* We shouldn't have any UIDs still set. Loop over all the UIDs to
1163 * make sure there's nothing left there and warn if any is found.
1164 */
Johannes Berg859d9142015-06-01 17:11:11 +02001165 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
Alexander Bondar963221b2015-03-26 11:07:35 +02001166 int i;
1167
Luciano Coelho507e4cd2015-03-19 22:58:33 +02001168 for (i = 0; i < mvm->max_scans; i++) {
Luciano Coelho6185af2a2015-05-07 11:13:24 +03001169 if (WARN_ONCE(mvm->scan_uid_status[i],
1170 "UMAC scan UID %d status was not cleaned\n",
1171 i))
1172 mvm->scan_uid_status[i] = 0;
Alexander Bondar963221b2015-03-26 11:07:35 +02001173 }
1174 }
1175
Luciano Coelhobc448862014-08-20 11:49:11 +03001176 mvm->ucode_loaded = false;
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001177}
Luciano Coelhobc448862014-08-20 11:49:11 +03001178
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001179static void iwl_mvm_mac_stop(struct ieee80211_hw *hw)
1180{
1181 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1182
1183 flush_work(&mvm->d0i3_exit_work);
1184 flush_work(&mvm->async_handlers_wk);
Emmanuel Grumbachd2709ad2015-01-29 14:58:06 +02001185 cancel_delayed_work_sync(&mvm->fw_dump_wk);
Emmanuel Grumbachb6eaa452015-01-29 14:58:20 +02001186 iwl_mvm_free_fw_dump_desc(mvm);
Luciano Coelhoa0a09242014-09-04 12:29:15 +03001187
1188 mutex_lock(&mvm->mutex);
1189 __iwl_mvm_mac_stop(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001190 mutex_unlock(&mvm->mutex);
1191
1192 /*
1193 * The worker might have been waiting for the mutex, let it run and
1194 * discover that its list is now empty.
1195 */
1196 cancel_work_sync(&mvm->async_handlers_wk);
1197}
1198
Ilan Peerfe0f2de2013-03-21 10:23:52 +02001199static struct iwl_mvm_phy_ctxt *iwl_mvm_get_free_phy_ctxt(struct iwl_mvm *mvm)
1200{
1201 u16 i;
1202
1203 lockdep_assert_held(&mvm->mutex);
1204
1205 for (i = 0; i < NUM_PHY_CTX; i++)
1206 if (!mvm->phy_ctxts[i].ref)
1207 return &mvm->phy_ctxts[i];
1208
1209 IWL_ERR(mvm, "No available PHY context\n");
1210 return NULL;
1211}
1212
Avri Altmand44c3fe2015-04-18 22:16:42 +03001213static int iwl_mvm_set_tx_power(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1214 s16 tx_power)
1215{
1216 struct iwl_dev_tx_power_cmd cmd = {
Johannes Bergda03f022015-08-18 15:15:36 +02001217 .v2.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_MAC),
1218 .v2.mac_context_id =
Avri Altmand44c3fe2015-04-18 22:16:42 +03001219 cpu_to_le32(iwl_mvm_vif_from_mac80211(vif)->id),
Johannes Bergda03f022015-08-18 15:15:36 +02001220 .v2.pwr_restriction = cpu_to_le16(8 * tx_power),
Avri Altmand44c3fe2015-04-18 22:16:42 +03001221 };
Johannes Bergda03f022015-08-18 15:15:36 +02001222 int len = sizeof(cmd);
Avri Altmand44c3fe2015-04-18 22:16:42 +03001223
Avri Altmand44c3fe2015-04-18 22:16:42 +03001224 if (tx_power == IWL_DEFAULT_MAX_TX_POWER)
Johannes Bergda03f022015-08-18 15:15:36 +02001225 cmd.v2.pwr_restriction = cpu_to_le16(IWL_DEV_MAX_TX_POWER);
Avri Altmand44c3fe2015-04-18 22:16:42 +03001226
Johannes Bergda03f022015-08-18 15:15:36 +02001227 if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_TX_POWER_CHAIN))
1228 len = sizeof(cmd.v2);
1229
1230 return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
Avri Altmand44c3fe2015-04-18 22:16:42 +03001231}
1232
Johannes Berg8ca151b2013-01-24 14:25:36 +01001233static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw,
1234 struct ieee80211_vif *vif)
1235{
1236 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1237 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1238 int ret;
1239
Emmanuel Grumbachaa5e1832015-03-07 19:35:37 +02001240 mvmvif->mvm = mvm;
1241
Johannes Berg8ca151b2013-01-24 14:25:36 +01001242 /*
Gregory Greenmand40fc482014-06-25 14:08:50 +02001243 * make sure D0i3 exit is completed, otherwise a target access
1244 * during tx queue configuration could be done when still in
1245 * D0i3 state.
1246 */
1247 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_ADD_IF);
1248 if (ret)
1249 return ret;
1250
1251 /*
Johannes Berg8ca151b2013-01-24 14:25:36 +01001252 * Not much to do here. The stack will not allow interface
1253 * types or combinations that we didn't advertise, so we
1254 * don't really have to check the types.
1255 */
1256
1257 mutex_lock(&mvm->mutex);
1258
Johannes Berg33cef922015-01-21 21:41:29 +01001259 /* make sure that beacon statistics don't go backwards with FW reset */
1260 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1261 mvmvif->beacon_stats.accu_num_beacons +=
1262 mvmvif->beacon_stats.num_beacons;
1263
Eliad Pellere89044d2013-07-16 17:33:26 +03001264 /* Allocate resources for the MAC context, and add it to the fw */
Johannes Berg8ca151b2013-01-24 14:25:36 +01001265 ret = iwl_mvm_mac_ctxt_init(mvm, vif);
1266 if (ret)
1267 goto out_unlock;
1268
Alexander Bondar1c2abf72013-08-27 20:31:48 +03001269 /* Counting number of interfaces is needed for legacy PM */
Ilan Peerea183d02013-07-23 14:41:53 +03001270 if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
1271 mvm->vif_count++;
Ilan Peerea183d02013-07-23 14:41:53 +03001272
1273 /*
Johannes Berg8ca151b2013-01-24 14:25:36 +01001274 * The AP binding flow can be done only after the beacon
1275 * template is configured (which happens only in the mac80211
1276 * start_ap() flow), and adding the broadcast station can happen
1277 * only after the binding.
1278 * In addition, since modifying the MAC before adding a bcast
1279 * station is not allowed by the FW, delay the adding of MAC context to
1280 * the point where we can also add the bcast station.
1281 * In short: there's not much we can do at this point, other than
1282 * allocating resources :)
1283 */
Johannes Berg5023d962013-07-31 14:07:43 +02001284 if (vif->type == NL80211_IFTYPE_AP ||
1285 vif->type == NL80211_IFTYPE_ADHOC) {
Johannes Berg013290a2014-08-04 13:38:48 +02001286 ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001287 if (ret) {
1288 IWL_ERR(mvm, "Failed to allocate bcast sta\n");
1289 goto out_release;
1290 }
1291
Emmanuel Grumbach77740cb2013-06-26 23:51:41 +03001292 iwl_mvm_vif_dbgfs_register(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001293 goto out_unlock;
1294 }
1295
Avri Altman93190fb2014-12-27 09:09:47 +02001296 mvmvif->features |= hw->netdev_features;
1297
Johannes Berg8ca151b2013-01-24 14:25:36 +01001298 ret = iwl_mvm_mac_ctxt_add(mvm, vif);
1299 if (ret)
1300 goto out_release;
1301
Arik Nemtsov999609f2014-05-15 17:31:51 +03001302 ret = iwl_mvm_power_update_mac(mvm);
Emmanuel Grumbache5e7aa82014-01-27 16:57:33 +02001303 if (ret)
Luciano Coelhofd66fc12015-01-27 15:06:57 +02001304 goto out_remove_mac;
Johannes Berg8ca151b2013-01-24 14:25:36 +01001305
Hila Gonen7df15b12012-12-12 11:16:19 +02001306 /* beacon filtering */
Emmanuel Grumbacha1022922014-05-12 11:36:41 +03001307 ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
Eliad Pellerbd3351b2013-07-16 17:50:17 +03001308 if (ret)
1309 goto out_remove_mac;
1310
Hila Gonen7df15b12012-12-12 11:16:19 +02001311 if (!mvm->bf_allowed_vif &&
Emmanuel Grumbach73e5f2c2014-03-30 08:57:30 +03001312 vif->type == NL80211_IFTYPE_STATION && !vif->p2p) {
Hila Gonen7df15b12012-12-12 11:16:19 +02001313 mvm->bf_allowed_vif = mvmvif;
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001314 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
1315 IEEE80211_VIF_SUPPORTS_CQM_RSSI;
Hila Gonen7df15b12012-12-12 11:16:19 +02001316 }
1317
Johannes Berg8ca151b2013-01-24 14:25:36 +01001318 /*
1319 * P2P_DEVICE interface does not have a channel context assigned to it,
1320 * so a dedicated PHY context is allocated to it and the corresponding
1321 * MAC context is bound to it at this stage.
1322 */
1323 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
Johannes Berg8ca151b2013-01-24 14:25:36 +01001324
Ilan Peerfe0f2de2013-03-21 10:23:52 +02001325 mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
1326 if (!mvmvif->phy_ctxt) {
1327 ret = -ENOSPC;
Eliad Pellerbd3351b2013-07-16 17:50:17 +03001328 goto out_free_bf;
Ilan Peerfe0f2de2013-03-21 10:23:52 +02001329 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001330
Ilan Peer53a9d612013-04-28 11:55:08 +03001331 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001332 ret = iwl_mvm_binding_add_vif(mvm, vif);
1333 if (ret)
Ilan Peer53a9d612013-04-28 11:55:08 +03001334 goto out_unref_phy;
Johannes Berg8ca151b2013-01-24 14:25:36 +01001335
Johannes Berg013290a2014-08-04 13:38:48 +02001336 ret = iwl_mvm_add_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001337 if (ret)
1338 goto out_unbind;
1339
1340 /* Save a pointer to p2p device vif, so it can later be used to
1341 * update the p2p device MAC when a GO is started/stopped */
1342 mvm->p2p_device_vif = vif;
1343 }
1344
Johannes Berg63494372013-03-26 10:47:53 +01001345 iwl_mvm_vif_dbgfs_register(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001346 goto out_unlock;
1347
1348 out_unbind:
1349 iwl_mvm_binding_remove_vif(mvm, vif);
Ilan Peer53a9d612013-04-28 11:55:08 +03001350 out_unref_phy:
Ilan Peerfe0f2de2013-03-21 10:23:52 +02001351 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
Eliad Pellerbd3351b2013-07-16 17:50:17 +03001352 out_free_bf:
1353 if (mvm->bf_allowed_vif == mvmvif) {
1354 mvm->bf_allowed_vif = NULL;
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001355 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
1356 IEEE80211_VIF_SUPPORTS_CQM_RSSI);
Eliad Pellerbd3351b2013-07-16 17:50:17 +03001357 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001358 out_remove_mac:
1359 mvmvif->phy_ctxt = NULL;
1360 iwl_mvm_mac_ctxt_remove(mvm, vif);
1361 out_release:
Alexander Bondar5ee2b212013-03-05 10:16:40 +02001362 if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
1363 mvm->vif_count--;
Alexander Bondar1c2abf72013-08-27 20:31:48 +03001364
Johannes Berg8ca151b2013-01-24 14:25:36 +01001365 iwl_mvm_mac_ctxt_release(mvm, vif);
1366 out_unlock:
1367 mutex_unlock(&mvm->mutex);
1368
Gregory Greenmand40fc482014-06-25 14:08:50 +02001369 iwl_mvm_unref(mvm, IWL_MVM_REF_ADD_IF);
1370
Johannes Berg8ca151b2013-01-24 14:25:36 +01001371 return ret;
1372}
1373
Johannes Berg38a12b52013-02-22 14:07:56 +01001374static void iwl_mvm_prepare_mac_removal(struct iwl_mvm *mvm,
1375 struct ieee80211_vif *vif)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001376{
Arik Nemtsovd92b732e2014-09-21 19:00:42 +03001377 u32 tfd_msk = iwl_mvm_mac_get_queues_mask(vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001378
1379 if (tfd_msk) {
Emmanuel Grumbachfe92e322015-03-11 09:34:31 +02001380 /*
1381 * mac80211 first removes all the stations of the vif and
1382 * then removes the vif. When it removes a station it also
1383 * flushes the AMPDU session. So by now, all the AMPDU sessions
1384 * of all the stations of this vif are closed, and the queues
1385 * of these AMPDU sessions are properly closed.
1386 * We still need to take care of the shared queues of the vif.
1387 * Flush them here.
1388 */
Johannes Berg8ca151b2013-01-24 14:25:36 +01001389 mutex_lock(&mvm->mutex);
Luca Coelho5888a402015-10-06 09:54:57 +03001390 iwl_mvm_flush_tx_path(mvm, tfd_msk, 0);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001391 mutex_unlock(&mvm->mutex);
Emmanuel Grumbachfe92e322015-03-11 09:34:31 +02001392
1393 /*
1394 * There are transports that buffer a few frames in the host.
1395 * For these, the flush above isn't enough since while we were
1396 * flushing, the transport might have sent more frames to the
1397 * device. To solve this, wait here until the transport is
1398 * empty. Technically, this could have replaced the flush
1399 * above, but flush is much faster than draining. So flush
1400 * first, and drain to make sure we have no frames in the
1401 * transport anymore.
1402 * If a station still had frames on the shared queues, it is
1403 * already marked as draining, so to complete the draining, we
1404 * just need to wait until the transport is empty.
1405 */
1406 iwl_trans_wait_tx_queue_empty(mvm->trans, tfd_msk);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001407 }
1408
1409 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1410 /*
1411 * Flush the ROC worker which will flush the OFFCHANNEL queue.
1412 * We assume here that all the packets sent to the OFFCHANNEL
1413 * queue are sent in ROC session.
1414 */
1415 flush_work(&mvm->roc_done_wk);
1416 } else {
1417 /*
1418 * By now, all the AC queues are empty. The AGG queues are
1419 * empty too. We already got all the Tx responses for all the
1420 * packets in the queues. The drain work can have been
Emmanuel Grumbach0742a752013-06-10 14:10:33 +03001421 * triggered. Flush it.
Johannes Berg8ca151b2013-01-24 14:25:36 +01001422 */
1423 flush_work(&mvm->sta_drained_wk);
1424 }
Johannes Berg38a12b52013-02-22 14:07:56 +01001425}
1426
1427static void iwl_mvm_mac_remove_interface(struct ieee80211_hw *hw,
1428 struct ieee80211_vif *vif)
1429{
1430 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1431 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1432
1433 iwl_mvm_prepare_mac_removal(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001434
1435 mutex_lock(&mvm->mutex);
1436
Hila Gonen7df15b12012-12-12 11:16:19 +02001437 if (mvm->bf_allowed_vif == mvmvif) {
1438 mvm->bf_allowed_vif = NULL;
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001439 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
1440 IEEE80211_VIF_SUPPORTS_CQM_RSSI);
Hila Gonen7df15b12012-12-12 11:16:19 +02001441 }
1442
Johannes Berg63494372013-03-26 10:47:53 +01001443 iwl_mvm_vif_dbgfs_clean(mvm, vif);
1444
Johannes Berg8ca151b2013-01-24 14:25:36 +01001445 /*
1446 * For AP/GO interface, the tear down of the resources allocated to the
Johannes Berg38a12b52013-02-22 14:07:56 +01001447 * interface is be handled as part of the stop_ap flow.
Johannes Berg8ca151b2013-01-24 14:25:36 +01001448 */
Johannes Berg5023d962013-07-31 14:07:43 +02001449 if (vif->type == NL80211_IFTYPE_AP ||
1450 vif->type == NL80211_IFTYPE_ADHOC) {
David Spinadel507cadf2013-07-31 18:07:21 +03001451#ifdef CONFIG_NL80211_TESTMODE
1452 if (vif == mvm->noa_vif) {
1453 mvm->noa_vif = NULL;
1454 mvm->noa_duration = 0;
1455 }
1456#endif
Johannes Berg013290a2014-08-04 13:38:48 +02001457 iwl_mvm_dealloc_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001458 goto out_release;
1459 }
1460
1461 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1462 mvm->p2p_device_vif = NULL;
Johannes Berg013290a2014-08-04 13:38:48 +02001463 iwl_mvm_rm_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001464 iwl_mvm_binding_remove_vif(mvm, vif);
Ilan Peerfe0f2de2013-03-21 10:23:52 +02001465 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001466 mvmvif->phy_ctxt = NULL;
1467 }
1468
Alexander Bondar5ee2b212013-03-05 10:16:40 +02001469 if (mvm->vif_count && vif->type != NL80211_IFTYPE_P2P_DEVICE)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001470 mvm->vif_count--;
Alexander Bondar1c2abf72013-08-27 20:31:48 +03001471
Arik Nemtsov999609f2014-05-15 17:31:51 +03001472 iwl_mvm_power_update_mac(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001473 iwl_mvm_mac_ctxt_remove(mvm, vif);
1474
1475out_release:
1476 iwl_mvm_mac_ctxt_release(mvm, vif);
1477 mutex_unlock(&mvm->mutex);
1478}
1479
1480static int iwl_mvm_mac_config(struct ieee80211_hw *hw, u32 changed)
1481{
1482 return 0;
1483}
1484
Eliad Pellere59647e2013-11-28 14:08:50 +02001485struct iwl_mvm_mc_iter_data {
1486 struct iwl_mvm *mvm;
1487 int port_id;
1488};
1489
1490static void iwl_mvm_mc_iface_iterator(void *_data, u8 *mac,
1491 struct ieee80211_vif *vif)
1492{
1493 struct iwl_mvm_mc_iter_data *data = _data;
1494 struct iwl_mvm *mvm = data->mvm;
1495 struct iwl_mcast_filter_cmd *cmd = mvm->mcast_filter_cmd;
1496 int ret, len;
1497
1498 /* if we don't have free ports, mcast frames will be dropped */
1499 if (WARN_ON_ONCE(data->port_id >= MAX_PORT_ID_NUM))
1500 return;
1501
1502 if (vif->type != NL80211_IFTYPE_STATION ||
1503 !vif->bss_conf.assoc)
1504 return;
1505
1506 cmd->port_id = data->port_id++;
1507 memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
1508 len = roundup(sizeof(*cmd) + cmd->count * ETH_ALEN, 4);
1509
Emmanuel Grumbach1c4abec2014-05-08 09:48:10 +03001510 ret = iwl_mvm_send_cmd_pdu(mvm, MCAST_FILTER_CMD, CMD_ASYNC, len, cmd);
Eliad Pellere59647e2013-11-28 14:08:50 +02001511 if (ret)
1512 IWL_ERR(mvm, "mcast filter cmd error. ret=%d\n", ret);
1513}
1514
1515static void iwl_mvm_recalc_multicast(struct iwl_mvm *mvm)
1516{
1517 struct iwl_mvm_mc_iter_data iter_data = {
1518 .mvm = mvm,
1519 };
1520
1521 lockdep_assert_held(&mvm->mutex);
1522
1523 if (WARN_ON_ONCE(!mvm->mcast_filter_cmd))
1524 return;
1525
Emmanuel Grumbach1c4abec2014-05-08 09:48:10 +03001526 ieee80211_iterate_active_interfaces_atomic(
Eliad Pellere59647e2013-11-28 14:08:50 +02001527 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
1528 iwl_mvm_mc_iface_iterator, &iter_data);
1529}
1530
1531static u64 iwl_mvm_prepare_multicast(struct ieee80211_hw *hw,
1532 struct netdev_hw_addr_list *mc_list)
1533{
1534 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1535 struct iwl_mcast_filter_cmd *cmd;
1536 struct netdev_hw_addr *addr;
Max Stepanovf3bd58f2014-08-04 13:55:01 +03001537 int addr_count;
1538 bool pass_all;
Eliad Pellere59647e2013-11-28 14:08:50 +02001539 int len;
1540
Max Stepanovf3bd58f2014-08-04 13:55:01 +03001541 addr_count = netdev_hw_addr_list_count(mc_list);
1542 pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES ||
1543 IWL_MVM_FW_MCAST_FILTER_PASS_ALL;
1544 if (pass_all)
Eliad Pellere59647e2013-11-28 14:08:50 +02001545 addr_count = 0;
Eliad Pellere59647e2013-11-28 14:08:50 +02001546
1547 len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4);
1548 cmd = kzalloc(len, GFP_ATOMIC);
1549 if (!cmd)
1550 return 0;
1551
1552 if (pass_all) {
1553 cmd->pass_all = 1;
1554 return (u64)(unsigned long)cmd;
1555 }
1556
1557 netdev_hw_addr_list_for_each(addr, mc_list) {
1558 IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %pM\n",
1559 cmd->count, addr->addr);
1560 memcpy(&cmd->addr_list[cmd->count * ETH_ALEN],
1561 addr->addr, ETH_ALEN);
1562 cmd->count++;
1563 }
1564
1565 return (u64)(unsigned long)cmd;
1566}
1567
Johannes Berg8ca151b2013-01-24 14:25:36 +01001568static void iwl_mvm_configure_filter(struct ieee80211_hw *hw,
1569 unsigned int changed_flags,
1570 unsigned int *total_flags,
1571 u64 multicast)
1572{
Eliad Pellere59647e2013-11-28 14:08:50 +02001573 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1574 struct iwl_mcast_filter_cmd *cmd = (void *)(unsigned long)multicast;
1575
1576 mutex_lock(&mvm->mutex);
1577
1578 /* replace previous configuration */
1579 kfree(mvm->mcast_filter_cmd);
1580 mvm->mcast_filter_cmd = cmd;
1581
1582 if (!cmd)
1583 goto out;
1584
1585 iwl_mvm_recalc_multicast(mvm);
1586out:
1587 mutex_unlock(&mvm->mutex);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001588 *total_flags = 0;
1589}
1590
Andrei Otcheretianskieffd1922015-06-30 12:08:28 +03001591static void iwl_mvm_config_iface_filter(struct ieee80211_hw *hw,
1592 struct ieee80211_vif *vif,
1593 unsigned int filter_flags,
1594 unsigned int changed_flags)
1595{
1596 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1597
1598 /* We support only filter for probe requests */
1599 if (!(changed_flags & FIF_PROBE_REQ))
1600 return;
1601
1602 /* Supported only for p2p client interfaces */
1603 if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc ||
1604 !vif->p2p)
1605 return;
1606
1607 mutex_lock(&mvm->mutex);
1608 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
1609 mutex_unlock(&mvm->mutex);
1610}
1611
Eliad Pellerc87163b2014-01-08 10:11:11 +02001612#ifdef CONFIG_IWLWIFI_BCAST_FILTERING
1613struct iwl_bcast_iter_data {
1614 struct iwl_mvm *mvm;
1615 struct iwl_bcast_filter_cmd *cmd;
1616 u8 current_filter;
1617};
1618
1619static void
1620iwl_mvm_set_bcast_filter(struct ieee80211_vif *vif,
1621 const struct iwl_fw_bcast_filter *in_filter,
1622 struct iwl_fw_bcast_filter *out_filter)
1623{
1624 struct iwl_fw_bcast_filter_attr *attr;
1625 int i;
1626
1627 memcpy(out_filter, in_filter, sizeof(*out_filter));
1628
1629 for (i = 0; i < ARRAY_SIZE(out_filter->attrs); i++) {
1630 attr = &out_filter->attrs[i];
1631
1632 if (!attr->mask)
1633 break;
1634
Eliad Peller2ee8f022014-01-13 19:07:09 +02001635 switch (attr->reserved1) {
1636 case cpu_to_le16(BC_FILTER_MAGIC_IP):
1637 if (vif->bss_conf.arp_addr_cnt != 1) {
1638 attr->mask = 0;
1639 continue;
1640 }
1641
1642 attr->val = vif->bss_conf.arp_addr_list[0];
1643 break;
1644 case cpu_to_le16(BC_FILTER_MAGIC_MAC):
1645 attr->val = *(__be32 *)&vif->addr[2];
1646 break;
1647 default:
1648 break;
1649 }
1650 attr->reserved1 = 0;
Eliad Pellerc87163b2014-01-08 10:11:11 +02001651 out_filter->num_attrs++;
1652 }
1653}
1654
1655static void iwl_mvm_bcast_filter_iterator(void *_data, u8 *mac,
1656 struct ieee80211_vif *vif)
1657{
1658 struct iwl_bcast_iter_data *data = _data;
1659 struct iwl_mvm *mvm = data->mvm;
1660 struct iwl_bcast_filter_cmd *cmd = data->cmd;
1661 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1662 struct iwl_fw_bcast_mac *bcast_mac;
1663 int i;
1664
1665 if (WARN_ON(mvmvif->id >= ARRAY_SIZE(cmd->macs)))
1666 return;
1667
1668 bcast_mac = &cmd->macs[mvmvif->id];
1669
Ilan Peere48393e2014-05-22 11:19:02 +03001670 /*
1671 * enable filtering only for associated stations, but not for P2P
1672 * Clients
1673 */
1674 if (vif->type != NL80211_IFTYPE_STATION || vif->p2p ||
1675 !vif->bss_conf.assoc)
Eliad Pellerc87163b2014-01-08 10:11:11 +02001676 return;
1677
1678 bcast_mac->default_discard = 1;
1679
1680 /* copy all configured filters */
1681 for (i = 0; mvm->bcast_filters[i].attrs[0].mask; i++) {
1682 /*
1683 * Make sure we don't exceed our filters limit.
1684 * if there is still a valid filter to be configured,
1685 * be on the safe side and just allow bcast for this mac.
1686 */
1687 if (WARN_ON_ONCE(data->current_filter >=
1688 ARRAY_SIZE(cmd->filters))) {
1689 bcast_mac->default_discard = 0;
1690 bcast_mac->attached_filters = 0;
1691 break;
1692 }
1693
1694 iwl_mvm_set_bcast_filter(vif,
1695 &mvm->bcast_filters[i],
1696 &cmd->filters[data->current_filter]);
1697
1698 /* skip current filter if it contains no attributes */
1699 if (!cmd->filters[data->current_filter].num_attrs)
1700 continue;
1701
1702 /* attach the filter to current mac */
1703 bcast_mac->attached_filters |=
1704 cpu_to_le16(BIT(data->current_filter));
1705
1706 data->current_filter++;
1707 }
1708}
1709
Eliad Pellerde06a592014-01-08 10:11:12 +02001710bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm *mvm,
1711 struct iwl_bcast_filter_cmd *cmd)
Eliad Pellerc87163b2014-01-08 10:11:11 +02001712{
Eliad Pellerc87163b2014-01-08 10:11:11 +02001713 struct iwl_bcast_iter_data iter_data = {
1714 .mvm = mvm,
Eliad Pellerde06a592014-01-08 10:11:12 +02001715 .cmd = cmd,
Eliad Pellerc87163b2014-01-08 10:11:11 +02001716 };
1717
Max Stepanov3b8983b2014-10-15 11:27:16 +03001718 if (IWL_MVM_FW_BCAST_FILTER_PASS_ALL)
1719 return false;
1720
Eliad Pellerde06a592014-01-08 10:11:12 +02001721 memset(cmd, 0, sizeof(*cmd));
1722 cmd->max_bcast_filters = ARRAY_SIZE(cmd->filters);
1723 cmd->max_macs = ARRAY_SIZE(cmd->macs);
1724
1725#ifdef CONFIG_IWLWIFI_DEBUGFS
1726 /* use debugfs filters/macs if override is configured */
1727 if (mvm->dbgfs_bcast_filtering.override) {
1728 memcpy(cmd->filters, &mvm->dbgfs_bcast_filtering.cmd.filters,
1729 sizeof(cmd->filters));
1730 memcpy(cmd->macs, &mvm->dbgfs_bcast_filtering.cmd.macs,
1731 sizeof(cmd->macs));
1732 return true;
1733 }
1734#endif
Eliad Pellerc87163b2014-01-08 10:11:11 +02001735
1736 /* if no filters are configured, do nothing */
1737 if (!mvm->bcast_filters)
Eliad Pellerde06a592014-01-08 10:11:12 +02001738 return false;
Eliad Pellerc87163b2014-01-08 10:11:11 +02001739
1740 /* configure and attach these filters for each associated sta vif */
1741 ieee80211_iterate_active_interfaces(
1742 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
1743 iwl_mvm_bcast_filter_iterator, &iter_data);
1744
Eliad Pellerde06a592014-01-08 10:11:12 +02001745 return true;
1746}
Eliad Peller34672bb2015-12-03 16:10:07 +02001747
1748static int iwl_mvm_configure_bcast_filter(struct iwl_mvm *mvm)
Eliad Pellerde06a592014-01-08 10:11:12 +02001749{
1750 struct iwl_bcast_filter_cmd cmd;
1751
1752 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BCAST_FILTERING))
1753 return 0;
1754
1755 if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd))
1756 return 0;
1757
Emmanuel Grumbacha1022922014-05-12 11:36:41 +03001758 return iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0,
Eliad Pellerc87163b2014-01-08 10:11:11 +02001759 sizeof(cmd), &cmd);
1760}
1761#else
Eliad Peller34672bb2015-12-03 16:10:07 +02001762static inline int iwl_mvm_configure_bcast_filter(struct iwl_mvm *mvm)
Eliad Pellerc87163b2014-01-08 10:11:11 +02001763{
1764 return 0;
1765}
1766#endif
1767
Sara Sharona07a8f32015-11-15 11:11:59 +02001768static int iwl_mvm_update_mu_groups(struct iwl_mvm *mvm,
1769 struct ieee80211_vif *vif)
1770{
1771 struct iwl_mu_group_mgmt_cmd cmd = {};
1772
1773 memcpy(cmd.membership_status, vif->bss_conf.mu_group.membership,
1774 WLAN_MEMBERSHIP_LEN);
1775 memcpy(cmd.user_position, vif->bss_conf.mu_group.position,
1776 WLAN_USER_POSITION_LEN);
1777
1778 return iwl_mvm_send_cmd_pdu(mvm,
1779 WIDE_ID(DATA_PATH_GROUP,
1780 UPDATE_MU_GROUPS_CMD),
1781 0, sizeof(cmd), &cmd);
1782}
1783
Sara Sharonf92659a2016-02-03 15:04:49 +02001784static void iwl_mvm_mu_mimo_iface_iterator(void *_data, u8 *mac,
1785 struct ieee80211_vif *vif)
1786{
1787 if (vif->mu_mimo_owner) {
1788 struct iwl_mu_group_mgmt_notif *notif = _data;
1789
1790 /*
1791 * MU-MIMO Group Id action frame is little endian. We treat
1792 * the data received from firmware as if it came from the
1793 * action frame, so no conversion is needed.
1794 */
1795 ieee80211_update_mu_groups(vif,
1796 (u8 *)&notif->membership_status,
1797 (u8 *)&notif->user_position);
1798 }
1799}
1800
1801void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm *mvm,
1802 struct iwl_rx_cmd_buffer *rxb)
1803{
1804 struct iwl_rx_packet *pkt = rxb_addr(rxb);
1805 struct iwl_mu_group_mgmt_notif *notif = (void *)pkt->data;
1806
1807 ieee80211_iterate_active_interfaces_atomic(
1808 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
1809 iwl_mvm_mu_mimo_iface_iterator, notif);
1810}
1811
Johannes Berg8ca151b2013-01-24 14:25:36 +01001812static void iwl_mvm_bss_info_changed_station(struct iwl_mvm *mvm,
1813 struct ieee80211_vif *vif,
1814 struct ieee80211_bss_conf *bss_conf,
1815 u32 changes)
1816{
1817 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1818 int ret;
1819
Ilan Peer6e97b0d2013-12-23 22:18:02 +02001820 /*
1821 * Re-calculate the tsf id, as the master-slave relations depend on the
1822 * beacon interval, which was not known when the station interface was
1823 * added.
1824 */
1825 if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc)
1826 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
1827
Johannes Berg3dfd3a92014-08-11 21:37:30 +02001828 /*
1829 * If we're not associated yet, take the (new) BSSID before associating
1830 * so the firmware knows. If we're already associated, then use the old
1831 * BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
1832 * branch for disassociation below.
1833 */
1834 if (changes & BSS_CHANGED_BSSID && !mvmvif->associated)
1835 memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
1836
1837 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, mvmvif->bssid);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001838 if (ret)
1839 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
1840
Johannes Berg3dfd3a92014-08-11 21:37:30 +02001841 /* after sending it once, adopt mac80211 data */
1842 memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
1843 mvmvif->associated = bss_conf->assoc;
1844
Johannes Berg8ca151b2013-01-24 14:25:36 +01001845 if (changes & BSS_CHANGED_ASSOC) {
1846 if (bss_conf->assoc) {
Johannes Berg33cef922015-01-21 21:41:29 +01001847 /* clear statistics to get clean beacon counter */
1848 iwl_mvm_request_statistics(mvm, true);
1849 memset(&mvmvif->beacon_stats, 0,
1850 sizeof(mvmvif->beacon_stats));
1851
Johannes Berg8ca151b2013-01-24 14:25:36 +01001852 /* add quota for this interface */
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02001853 ret = iwl_mvm_update_quotas(mvm, true, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001854 if (ret) {
1855 IWL_ERR(mvm, "failed to update quotas\n");
1856 return;
1857 }
Johannes Berg016d27e2013-05-03 11:16:15 +02001858
1859 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART,
1860 &mvm->status)) {
1861 /*
1862 * If we're restarting then the firmware will
1863 * obviously have lost synchronisation with
1864 * the AP. It will attempt to synchronise by
1865 * itself, but we can make it more reliable by
1866 * scheduling a session protection time event.
1867 *
1868 * The firmware needs to receive a beacon to
1869 * catch up with synchronisation, use 110% of
1870 * the beacon interval.
1871 *
1872 * Set a large maximum delay to allow for more
1873 * than a single interface.
1874 */
1875 u32 dur = (11 * vif->bss_conf.beacon_int) / 10;
1876 iwl_mvm_protect_session(mvm, vif, dur, dur,
Liad Kaufmand20d37b2014-07-06 17:14:39 +03001877 5 * dur, false);
Johannes Berg016d27e2013-05-03 11:16:15 +02001878 }
Lilach Edelstein1f3b0ff2013-10-06 13:03:32 +02001879
1880 iwl_mvm_sf_update(mvm, vif, false);
Alexander Bondar175a70b2013-04-14 20:59:37 +03001881 iwl_mvm_power_vif_assoc(mvm, vif);
Emmanuel Grumbach697162a2014-07-30 15:56:42 +03001882 if (vif->p2p) {
Eliad Peller29a90a42013-11-05 14:06:29 +02001883 iwl_mvm_ref(mvm, IWL_MVM_REF_P2P_CLIENT);
Emmanuel Grumbach697162a2014-07-30 15:56:42 +03001884 iwl_mvm_update_smps(mvm, vif,
1885 IWL_MVM_SMPS_REQ_PROT,
1886 IEEE80211_SMPS_DYNAMIC);
1887 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001888 } else if (mvmvif->ap_sta_id != IWL_MVM_STATION_COUNT) {
Lilach Edelstein1f3b0ff2013-10-06 13:03:32 +02001889 /*
1890 * If update fails - SF might be running in associated
1891 * mode while disassociated - which is forbidden.
1892 */
1893 WARN_ONCE(iwl_mvm_sf_update(mvm, vif, false),
1894 "Failed to update SF upon disassociation\n");
1895
Johannes Berg8ca151b2013-01-24 14:25:36 +01001896 /* remove AP station now that the MAC is unassoc */
1897 ret = iwl_mvm_rm_sta_id(mvm, vif, mvmvif->ap_sta_id);
1898 if (ret)
1899 IWL_ERR(mvm, "failed to remove AP station\n");
Eliad Peller37577fe2013-12-05 17:19:39 +02001900
1901 if (mvm->d0i3_ap_sta_id == mvmvif->ap_sta_id)
1902 mvm->d0i3_ap_sta_id = IWL_MVM_STATION_COUNT;
Johannes Berg8ca151b2013-01-24 14:25:36 +01001903 mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
1904 /* remove quota for this interface */
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02001905 ret = iwl_mvm_update_quotas(mvm, false, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001906 if (ret)
1907 IWL_ERR(mvm, "failed to update quotas\n");
Eliad Peller29a90a42013-11-05 14:06:29 +02001908
1909 if (vif->p2p)
1910 iwl_mvm_unref(mvm, IWL_MVM_REF_P2P_CLIENT);
Johannes Berg3dfd3a92014-08-11 21:37:30 +02001911
1912 /* this will take the cleared BSSID from bss_conf */
1913 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
1914 if (ret)
1915 IWL_ERR(mvm,
1916 "failed to update MAC %pM (clear after unassoc)\n",
1917 vif->addr);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001918 }
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001919
Sara Sharona07a8f32015-11-15 11:11:59 +02001920 /*
1921 * The firmware tracks the MU-MIMO group on its own.
Sara Sharonf92659a2016-02-03 15:04:49 +02001922 * However, on HW restart we should restore this data.
Sara Sharona07a8f32015-11-15 11:11:59 +02001923 */
1924 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
Sara Sharonf92659a2016-02-03 15:04:49 +02001925 (changes & BSS_CHANGED_MU_GROUPS) && vif->mu_mimo_owner) {
Sara Sharona07a8f32015-11-15 11:11:59 +02001926 ret = iwl_mvm_update_mu_groups(mvm, vif);
1927 if (ret)
1928 IWL_ERR(mvm,
1929 "failed to update VHT MU_MIMO groups\n");
1930 }
1931
Eliad Pellere59647e2013-11-28 14:08:50 +02001932 iwl_mvm_recalc_multicast(mvm);
Eliad Peller34672bb2015-12-03 16:10:07 +02001933 iwl_mvm_configure_bcast_filter(mvm);
Eliad Pellere59647e2013-11-28 14:08:50 +02001934
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001935 /* reset rssi values */
1936 mvmvif->bf_data.ave_beacon_signal = 0;
1937
Emmanuel Grumbach8e484f02013-10-02 15:02:25 +03001938 iwl_mvm_bt_coex_vif_change(mvm);
Emmanuel Grumbachf94045e2014-01-06 13:38:55 +02001939 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT,
1940 IEEE80211_SMPS_AUTOMATIC);
Avraham Stern355346b2015-11-26 11:22:33 +02001941 if (fw_has_capa(&mvm->fw->ucode_capa,
1942 IWL_UCODE_TLV_CAPA_UMAC_SCAN))
1943 iwl_mvm_config_scan(mvm);
Alexander Bondar989c6502013-05-16 17:34:17 +03001944 } else if (changes & BSS_CHANGED_BEACON_INFO) {
Johannes Berg210a5442013-01-24 23:48:23 +01001945 /*
1946 * We received a beacon _after_ association so
1947 * remove the session protection.
1948 */
1949 iwl_mvm_remove_time_event(mvm, mvmvif,
1950 &mvmvif->time_event_data);
Johannes Berg8ca151b2013-01-24 14:25:36 +01001951 }
Eran Hararycc87d322014-07-15 14:04:23 +03001952
1953 if (changes & BSS_CHANGED_BEACON_INFO) {
1954 iwl_mvm_sf_update(mvm, vif, false);
1955 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
1956 }
1957
Johannes Berg1bc10d32014-08-26 14:25:46 +02001958 if (changes & (BSS_CHANGED_PS | BSS_CHANGED_P2P_PS | BSS_CHANGED_QOS)) {
1959 ret = iwl_mvm_power_update_mac(mvm);
1960 if (ret)
1961 IWL_ERR(mvm, "failed to update power mode\n");
1962 }
1963
Matti Gottlieb88f2fd72013-07-09 15:25:46 +03001964 if (changes & BSS_CHANGED_TXPOWER) {
1965 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n",
1966 bss_conf->txpower);
1967 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
1968 }
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001969
1970 if (changes & BSS_CHANGED_CQM) {
Johannes Berg3c6acb62014-05-07 11:47:53 +02001971 IWL_DEBUG_MAC80211(mvm, "cqm info_changed\n");
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001972 /* reset cqm events tracking */
1973 mvmvif->bf_data.last_cqm_event = 0;
Avri Altmanfa7b2e72014-05-20 08:03:24 +03001974 if (mvmvif->bf_data.bf_enabled) {
1975 ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
1976 if (ret)
1977 IWL_ERR(mvm,
1978 "failed to update CQM thresholds\n");
1979 }
Andrei Otcheretianskia20fd392013-07-21 17:23:59 +03001980 }
Eliad Peller2ee8f022014-01-13 19:07:09 +02001981
1982 if (changes & BSS_CHANGED_ARP_FILTER) {
Johannes Berg3c6acb62014-05-07 11:47:53 +02001983 IWL_DEBUG_MAC80211(mvm, "arp filter changed\n");
Eliad Peller34672bb2015-12-03 16:10:07 +02001984 iwl_mvm_configure_bcast_filter(mvm);
Eliad Peller2ee8f022014-01-13 19:07:09 +02001985 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01001986}
1987
Johannes Berg5023d962013-07-31 14:07:43 +02001988static int iwl_mvm_start_ap_ibss(struct ieee80211_hw *hw,
1989 struct ieee80211_vif *vif)
Johannes Berg8ca151b2013-01-24 14:25:36 +01001990{
1991 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1992 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1993 int ret;
1994
Eliad Peller576eeee2014-07-01 18:38:38 +03001995 /*
1996 * iwl_mvm_mac_ctxt_add() might read directly from the device
1997 * (the system time), so make sure it is available.
1998 */
1999 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_START_AP);
2000 if (ret)
2001 return ret;
2002
Johannes Berg8ca151b2013-01-24 14:25:36 +01002003 mutex_lock(&mvm->mutex);
2004
2005 /* Send the beacon template */
2006 ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif);
2007 if (ret)
2008 goto out_unlock;
2009
Ilan Peer6e97b0d2013-12-23 22:18:02 +02002010 /*
2011 * Re-calculate the tsf id, as the master-slave relations depend on the
2012 * beacon interval, which was not known when the AP interface was added.
2013 */
2014 if (vif->type == NL80211_IFTYPE_AP)
2015 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
2016
Gregory Greenman94939082015-08-24 14:38:35 +03002017 mvmvif->ap_assoc_sta_count = 0;
2018
Johannes Berg8ca151b2013-01-24 14:25:36 +01002019 /* Add the mac context */
2020 ret = iwl_mvm_mac_ctxt_add(mvm, vif);
2021 if (ret)
2022 goto out_unlock;
2023
2024 /* Perform the binding */
2025 ret = iwl_mvm_binding_add_vif(mvm, vif);
2026 if (ret)
2027 goto out_remove;
2028
Johannes Berg8ca151b2013-01-24 14:25:36 +01002029 /* Send the bcast station. At this stage the TBTT and DTIM time events
2030 * are added and applied to the scheduler */
Johannes Berg013290a2014-08-04 13:38:48 +02002031 ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002032 if (ret)
2033 goto out_unbind;
2034
Ilan Peer5691e212013-12-31 21:05:50 +02002035 /* must be set before quota calculations */
2036 mvmvif->ap_ibss_active = true;
2037
Ilan Peera11e1442013-12-31 21:19:55 +02002038 /* power updated needs to be done before quotas */
Arik Nemtsov999609f2014-05-15 17:31:51 +03002039 iwl_mvm_power_update_mac(mvm);
Ilan Peera11e1442013-12-31 21:19:55 +02002040
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02002041 ret = iwl_mvm_update_quotas(mvm, false, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002042 if (ret)
Ilan Peera11e1442013-12-31 21:19:55 +02002043 goto out_quota_failed;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002044
Johannes Berg5023d962013-07-31 14:07:43 +02002045 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
Johannes Berg8ca151b2013-01-24 14:25:36 +01002046 if (vif->p2p && mvm->p2p_device_vif)
Johannes Berg3dfd3a92014-08-11 21:37:30 +02002047 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002048
Eliad Peller29a90a42013-11-05 14:06:29 +02002049 iwl_mvm_ref(mvm, IWL_MVM_REF_AP_IBSS);
2050
Emmanuel Grumbach8e484f02013-10-02 15:02:25 +03002051 iwl_mvm_bt_coex_vif_change(mvm);
Emmanuel Grumbachdac94da2013-06-18 07:35:27 +03002052
Arik Nemtsovf6972672014-06-15 16:03:55 +03002053 /* we don't support TDLS during DCM */
2054 if (iwl_mvm_phy_ctx_count(mvm) > 1)
2055 iwl_mvm_teardown_tdls_peers(mvm);
2056
Arik Nemtsov939e4902015-03-08 12:19:42 +02002057 goto out_unlock;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002058
Ilan Peera11e1442013-12-31 21:19:55 +02002059out_quota_failed:
Arik Nemtsov999609f2014-05-15 17:31:51 +03002060 iwl_mvm_power_update_mac(mvm);
Ilan Peer5691e212013-12-31 21:05:50 +02002061 mvmvif->ap_ibss_active = false;
Johannes Berg013290a2014-08-04 13:38:48 +02002062 iwl_mvm_send_rm_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002063out_unbind:
2064 iwl_mvm_binding_remove_vif(mvm, vif);
2065out_remove:
2066 iwl_mvm_mac_ctxt_remove(mvm, vif);
2067out_unlock:
2068 mutex_unlock(&mvm->mutex);
Eliad Peller576eeee2014-07-01 18:38:38 +03002069 iwl_mvm_unref(mvm, IWL_MVM_REF_START_AP);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002070 return ret;
2071}
2072
Johannes Berg5023d962013-07-31 14:07:43 +02002073static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw,
2074 struct ieee80211_vif *vif)
Johannes Berg8ca151b2013-01-24 14:25:36 +01002075{
2076 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2077 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2078
Johannes Berg38a12b52013-02-22 14:07:56 +01002079 iwl_mvm_prepare_mac_removal(mvm, vif);
2080
Johannes Berg8ca151b2013-01-24 14:25:36 +01002081 mutex_lock(&mvm->mutex);
2082
Andrei Otcheretianski664322f2014-06-05 16:40:36 +03002083 /* Handle AP stop while in CSA */
Andrei Otcheretianski7f0a7c62014-05-04 11:48:12 +03002084 if (rcu_access_pointer(mvm->csa_vif) == vif) {
2085 iwl_mvm_remove_time_event(mvm, mvmvif,
2086 &mvmvif->time_event_data);
Andrei Otcheretianski664322f2014-06-05 16:40:36 +03002087 RCU_INIT_POINTER(mvm->csa_vif, NULL);
Avraham Sterne9cb0322015-08-31 11:08:27 +03002088 mvmvif->csa_countdown = false;
Andrei Otcheretianski7f0a7c62014-05-04 11:48:12 +03002089 }
Andrei Otcheretianski664322f2014-06-05 16:40:36 +03002090
Andrei Otcheretianski003e52362014-05-25 17:24:22 +03002091 if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {
2092 RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
2093 mvm->csa_tx_block_bcn_timeout = 0;
2094 }
2095
Johannes Berg5023d962013-07-31 14:07:43 +02002096 mvmvif->ap_ibss_active = false;
David Spinadel1c87bba2014-02-27 16:41:52 +02002097 mvm->ap_last_beacon_gp2 = 0;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002098
Emmanuel Grumbach8e484f02013-10-02 15:02:25 +03002099 iwl_mvm_bt_coex_vif_change(mvm);
Emmanuel Grumbachdac94da2013-06-18 07:35:27 +03002100
Eliad Peller29a90a42013-11-05 14:06:29 +02002101 iwl_mvm_unref(mvm, IWL_MVM_REF_AP_IBSS);
2102
Johannes Berg5023d962013-07-31 14:07:43 +02002103 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
Johannes Berg8ca151b2013-01-24 14:25:36 +01002104 if (vif->p2p && mvm->p2p_device_vif)
Johannes Berg3dfd3a92014-08-11 21:37:30 +02002105 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002106
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02002107 iwl_mvm_update_quotas(mvm, false, NULL);
Johannes Berg013290a2014-08-04 13:38:48 +02002108 iwl_mvm_send_rm_bcast_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002109 iwl_mvm_binding_remove_vif(mvm, vif);
Ilan Peera11e1442013-12-31 21:19:55 +02002110
Arik Nemtsov999609f2014-05-15 17:31:51 +03002111 iwl_mvm_power_update_mac(mvm);
Ilan Peera11e1442013-12-31 21:19:55 +02002112
Johannes Berg8ca151b2013-01-24 14:25:36 +01002113 iwl_mvm_mac_ctxt_remove(mvm, vif);
2114
2115 mutex_unlock(&mvm->mutex);
2116}
2117
Johannes Berg5023d962013-07-31 14:07:43 +02002118static void
2119iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm *mvm,
2120 struct ieee80211_vif *vif,
2121 struct ieee80211_bss_conf *bss_conf,
2122 u32 changes)
Johannes Berg8ca151b2013-01-24 14:25:36 +01002123{
Ilan Peerbe2056f2013-12-04 16:47:14 +02002124 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
Avri Altman8a5e3662013-11-12 19:16:03 +02002125
Ilan Peerbe2056f2013-12-04 16:47:14 +02002126 /* Changes will be applied when the AP/IBSS is started */
2127 if (!mvmvif->ap_ibss_active)
2128 return;
2129
Johannes Berg863230da2013-12-04 17:08:40 +01002130 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT |
Johannes Bergf7d8b702014-09-09 15:49:19 +02002131 BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS) &&
Johannes Berg3dfd3a92014-08-11 21:37:30 +02002132 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL))
Johannes Berg863230da2013-12-04 17:08:40 +01002133 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
Avri Altman8a5e3662013-11-12 19:16:03 +02002134
Johannes Berg8ca151b2013-01-24 14:25:36 +01002135 /* Need to send a new beacon template to the FW */
Johannes Berg863230da2013-12-04 17:08:40 +01002136 if (changes & BSS_CHANGED_BEACON &&
2137 iwl_mvm_mac_ctxt_beacon_changed(mvm, vif))
2138 IWL_WARN(mvm, "Failed updating beacon data\n");
Haim Dreyfuss79b7a692014-09-14 12:40:00 +03002139
2140 if (changes & BSS_CHANGED_TXPOWER) {
2141 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n",
2142 bss_conf->txpower);
2143 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
2144 }
2145
Johannes Berg8ca151b2013-01-24 14:25:36 +01002146}
2147
2148static void iwl_mvm_bss_info_changed(struct ieee80211_hw *hw,
2149 struct ieee80211_vif *vif,
2150 struct ieee80211_bss_conf *bss_conf,
2151 u32 changes)
2152{
2153 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2154
Eliad Peller576eeee2014-07-01 18:38:38 +03002155 /*
2156 * iwl_mvm_bss_info_changed_station() might call
2157 * iwl_mvm_protect_session(), which reads directly from
2158 * the device (the system time), so make sure it is available.
2159 */
2160 if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_BSS_CHANGED))
2161 return;
2162
Johannes Berg8ca151b2013-01-24 14:25:36 +01002163 mutex_lock(&mvm->mutex);
2164
David Spinadel723f02e2014-04-27 09:54:54 +03002165 if (changes & BSS_CHANGED_IDLE && !bss_conf->idle)
Luciano Coelhoc7d42482015-05-07 16:00:26 +03002166 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
David Spinadel723f02e2014-04-27 09:54:54 +03002167
Johannes Berg8ca151b2013-01-24 14:25:36 +01002168 switch (vif->type) {
2169 case NL80211_IFTYPE_STATION:
2170 iwl_mvm_bss_info_changed_station(mvm, vif, bss_conf, changes);
2171 break;
2172 case NL80211_IFTYPE_AP:
Johannes Berg5023d962013-07-31 14:07:43 +02002173 case NL80211_IFTYPE_ADHOC:
2174 iwl_mvm_bss_info_changed_ap_ibss(mvm, vif, bss_conf, changes);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002175 break;
2176 default:
2177 /* shouldn't happen */
2178 WARN_ON_ONCE(1);
2179 }
2180
2181 mutex_unlock(&mvm->mutex);
Eliad Peller576eeee2014-07-01 18:38:38 +03002182 iwl_mvm_unref(mvm, IWL_MVM_REF_BSS_CHANGED);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002183}
2184
2185static int iwl_mvm_mac_hw_scan(struct ieee80211_hw *hw,
2186 struct ieee80211_vif *vif,
David Spinadelc56ef672014-02-05 15:21:13 +02002187 struct ieee80211_scan_request *hw_req)
Johannes Berg8ca151b2013-01-24 14:25:36 +01002188{
2189 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2190 int ret;
2191
Luciano Coelho6749dd82015-03-20 15:51:36 +02002192 if (hw_req->req.n_channels == 0 ||
2193 hw_req->req.n_channels > mvm->fw->ucode_capa.n_scan_channels)
Johannes Berg8ca151b2013-01-24 14:25:36 +01002194 return -EINVAL;
2195
2196 mutex_lock(&mvm->mutex);
Luciano Coelho6749dd82015-03-20 15:51:36 +02002197 ret = iwl_mvm_reg_scan_start(mvm, vif, &hw_req->req, &hw_req->ies);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002198 mutex_unlock(&mvm->mutex);
Luciano Coelho6749dd82015-03-20 15:51:36 +02002199
Johannes Berg8ca151b2013-01-24 14:25:36 +01002200 return ret;
2201}
2202
2203static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw *hw,
2204 struct ieee80211_vif *vif)
2205{
2206 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2207
2208 mutex_lock(&mvm->mutex);
2209
Luciano Coelhoe7d3aba2015-02-06 10:19:05 +02002210 /* Due to a race condition, it's possible that mac80211 asks
2211 * us to stop a hw_scan when it's already stopped. This can
2212 * happen, for instance, if we stopped the scan ourselves,
2213 * called ieee80211_scan_completed() and the userspace called
2214 * cancel scan scan before ieee80211_scan_work() could run.
2215 * To handle that, simply return if the scan is not running.
2216 */
Luciano Coelho262888f2015-05-07 17:21:09 +03002217 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR)
Luciano Coelhoc7d42482015-05-07 16:00:26 +03002218 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002219
2220 mutex_unlock(&mvm->mutex);
2221}
2222
2223static void
2224iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw *hw,
Johannes Berg3e56ead2013-02-15 22:23:18 +01002225 struct ieee80211_sta *sta, u16 tids,
Johannes Berg8ca151b2013-01-24 14:25:36 +01002226 int num_frames,
2227 enum ieee80211_frame_release_type reason,
2228 bool more_data)
2229{
2230 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002231
Johannes Berg3e56ead2013-02-15 22:23:18 +01002232 /* Called when we need to transmit (a) frame(s) from mac80211 */
Johannes Berg8ca151b2013-01-24 14:25:36 +01002233
Johannes Berg3e56ead2013-02-15 22:23:18 +01002234 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
2235 tids, more_data, false);
2236}
2237
2238static void
2239iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw *hw,
2240 struct ieee80211_sta *sta, u16 tids,
2241 int num_frames,
2242 enum ieee80211_frame_release_type reason,
2243 bool more_data)
2244{
2245 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2246
2247 /* Called when we need to transmit (a) frame(s) from agg queue */
2248
2249 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
2250 tids, more_data, true);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002251}
2252
2253static void iwl_mvm_mac_sta_notify(struct ieee80211_hw *hw,
2254 struct ieee80211_vif *vif,
2255 enum sta_notify_cmd cmd,
2256 struct ieee80211_sta *sta)
2257{
2258 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Berg5b577a92013-11-14 18:20:04 +01002259 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
Emmanuel Grumbachc22b0ff2015-01-22 13:15:15 +02002260 unsigned long txqs = 0, tids = 0;
Johannes Berg3e56ead2013-02-15 22:23:18 +01002261 int tid;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002262
Emmanuel Grumbachc22b0ff2015-01-22 13:15:15 +02002263 spin_lock_bh(&mvmsta->lock);
2264 for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
2265 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
2266
2267 if (tid_data->state != IWL_AGG_ON &&
2268 tid_data->state != IWL_EMPTYING_HW_QUEUE_DELBA)
2269 continue;
2270
2271 __set_bit(tid_data->txq_id, &txqs);
2272
2273 if (iwl_mvm_tid_queued(tid_data) == 0)
2274 continue;
2275
2276 __set_bit(tid, &tids);
2277 }
2278
Johannes Berg8ca151b2013-01-24 14:25:36 +01002279 switch (cmd) {
2280 case STA_NOTIFY_SLEEP:
Emmanuel Grumbache3d4bc82013-05-07 14:08:24 +03002281 if (atomic_read(&mvm->pending_frames[mvmsta->sta_id]) > 0)
Johannes Berg8ca151b2013-01-24 14:25:36 +01002282 ieee80211_sta_block_awake(hw, sta, true);
Johannes Berg3e56ead2013-02-15 22:23:18 +01002283
Emmanuel Grumbachc22b0ff2015-01-22 13:15:15 +02002284 for_each_set_bit(tid, &tids, IWL_MAX_TID_COUNT)
Johannes Berg3e56ead2013-02-15 22:23:18 +01002285 ieee80211_sta_set_buffered(sta, tid, true);
Emmanuel Grumbachc22b0ff2015-01-22 13:15:15 +02002286
2287 if (txqs)
2288 iwl_trans_freeze_txq_timer(mvm->trans, txqs, true);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002289 /*
2290 * The fw updates the STA to be asleep. Tx packets on the Tx
2291 * queues to this station will not be transmitted. The fw will
2292 * send a Tx response with TX_STATUS_FAIL_DEST_PS.
2293 */
2294 break;
2295 case STA_NOTIFY_AWAKE:
Emmanuel Grumbach881acd82013-03-19 16:16:00 +02002296 if (WARN_ON(mvmsta->sta_id == IWL_MVM_STATION_COUNT))
Johannes Berg8ca151b2013-01-24 14:25:36 +01002297 break;
Emmanuel Grumbachc22b0ff2015-01-22 13:15:15 +02002298
2299 if (txqs)
2300 iwl_trans_freeze_txq_timer(mvm->trans, txqs, false);
Johannes Berg9cc40712013-02-15 22:47:48 +01002301 iwl_mvm_sta_modify_ps_wake(mvm, sta);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002302 break;
2303 default:
2304 break;
2305 }
Emmanuel Grumbachc22b0ff2015-01-22 13:15:15 +02002306 spin_unlock_bh(&mvmsta->lock);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002307}
2308
Johannes Berg1ddbbb02013-12-04 22:39:17 +01002309static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw *hw,
2310 struct ieee80211_vif *vif,
2311 struct ieee80211_sta *sta)
2312{
2313 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Berg9d8ce6a2014-12-23 16:02:40 +01002314 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
Johannes Berg1ddbbb02013-12-04 22:39:17 +01002315
2316 /*
2317 * This is called before mac80211 does RCU synchronisation,
2318 * so here we already invalidate our internal RCU-protected
2319 * station pointer. The rest of the code will thus no longer
2320 * be able to find the station this way, and we don't rely
2321 * on further RCU synchronisation after the sta_state()
2322 * callback deleted the station.
2323 */
2324 mutex_lock(&mvm->mutex);
2325 if (sta == rcu_access_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id]))
2326 rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id],
2327 ERR_PTR(-ENOENT));
Gregory Greenman94939082015-08-24 14:38:35 +03002328
Johannes Berg1ddbbb02013-12-04 22:39:17 +01002329 mutex_unlock(&mvm->mutex);
2330}
2331
Johannes Bergbd1ba662014-11-13 20:53:45 +01002332static void iwl_mvm_check_uapsd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2333 const u8 *bssid)
2334{
2335 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT))
2336 return;
2337
2338 if (iwlwifi_mod_params.uapsd_disable) {
2339 vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
2340 return;
2341 }
2342
2343 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
2344}
2345
Golan Ben-Ami1e8f1322015-08-23 17:57:33 +03002346static void
2347iwl_mvm_tdls_check_trigger(struct iwl_mvm *mvm,
2348 struct ieee80211_vif *vif, u8 *peer_addr,
2349 enum nl80211_tdls_operation action)
2350{
2351 struct iwl_fw_dbg_trigger_tlv *trig;
2352 struct iwl_fw_dbg_trigger_tdls *tdls_trig;
2353
2354 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_TDLS))
2355 return;
2356
2357 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TDLS);
2358 tdls_trig = (void *)trig->data;
2359 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
2360 return;
2361
2362 if (!(tdls_trig->action_bitmap & BIT(action)))
2363 return;
2364
2365 if (tdls_trig->peer_mode &&
2366 memcmp(tdls_trig->peer, peer_addr, ETH_ALEN) != 0)
2367 return;
2368
2369 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
2370 "TDLS event occurred, peer %pM, action %d",
2371 peer_addr, action);
2372}
2373
Johannes Berg8ca151b2013-01-24 14:25:36 +01002374static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw,
2375 struct ieee80211_vif *vif,
2376 struct ieee80211_sta *sta,
2377 enum ieee80211_sta_state old_state,
2378 enum ieee80211_sta_state new_state)
2379{
2380 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2381 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2382 int ret;
2383
2384 IWL_DEBUG_MAC80211(mvm, "station %pM state change %d->%d\n",
2385 sta->addr, old_state, new_state);
2386
2387 /* this would be a mac80211 bug ... but don't crash */
2388 if (WARN_ON_ONCE(!mvmvif->phy_ctxt))
2389 return -EINVAL;
2390
2391 /* if a STA is being removed, reuse its ID */
2392 flush_work(&mvm->sta_drained_wk);
2393
2394 mutex_lock(&mvm->mutex);
2395 if (old_state == IEEE80211_STA_NOTEXIST &&
2396 new_state == IEEE80211_STA_NONE) {
Johannes Berg48bc1302013-07-04 15:55:29 +02002397 /*
2398 * Firmware bug - it'll crash if the beacon interval is less
2399 * than 16. We can't avoid connecting at all, so refuse the
2400 * station state change, this will cause mac80211 to abandon
2401 * attempts to connect to this AP, and eventually wpa_s will
2402 * blacklist the AP...
2403 */
2404 if (vif->type == NL80211_IFTYPE_STATION &&
2405 vif->bss_conf.beacon_int < 16) {
2406 IWL_ERR(mvm,
2407 "AP %pM beacon interval is %d, refusing due to firmware bug!\n",
2408 sta->addr, vif->bss_conf.beacon_int);
2409 ret = -EINVAL;
2410 goto out_unlock;
2411 }
Arik Nemtsovcf7b4912014-05-15 11:44:40 +03002412
2413 if (sta->tdls &&
2414 (vif->p2p ||
Arik Nemtsovfa3d07e2014-05-15 18:59:32 +03002415 iwl_mvm_tdls_sta_count(mvm, NULL) ==
2416 IWL_MVM_TDLS_STA_COUNT ||
Arik Nemtsovcf7b4912014-05-15 11:44:40 +03002417 iwl_mvm_phy_ctx_count(mvm) > 1)) {
2418 IWL_DEBUG_MAC80211(mvm, "refusing TDLS sta\n");
2419 ret = -EBUSY;
2420 goto out_unlock;
2421 }
2422
Johannes Berg8ca151b2013-01-24 14:25:36 +01002423 ret = iwl_mvm_add_sta(mvm, vif, sta);
Golan Ben-Ami1e8f1322015-08-23 17:57:33 +03002424 if (sta->tdls && ret == 0) {
Arik Nemtsovfa3d07e2014-05-15 18:59:32 +03002425 iwl_mvm_recalc_tdls_state(mvm, vif, true);
Golan Ben-Ami1e8f1322015-08-23 17:57:33 +03002426 iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2427 NL80211_TDLS_SETUP);
2428 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01002429 } else if (old_state == IEEE80211_STA_NONE &&
2430 new_state == IEEE80211_STA_AUTH) {
Haim Dreyfusse820c2d2014-04-06 11:19:09 +03002431 /*
2432 * EBS may be disabled due to previous failures reported by FW.
2433 * Reset EBS status here assuming environment has been changed.
2434 */
2435 mvm->last_ebs_successful = true;
Johannes Bergbd1ba662014-11-13 20:53:45 +01002436 iwl_mvm_check_uapsd(mvm, vif, sta->addr);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002437 ret = 0;
2438 } else if (old_state == IEEE80211_STA_AUTH &&
2439 new_state == IEEE80211_STA_ASSOC) {
Ayala Beker8be30c12015-12-16 00:32:07 +02002440 if (vif->type == NL80211_IFTYPE_AP) {
2441 mvmvif->ap_assoc_sta_count++;
2442 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
2443 }
Johannes Berg7a453972013-02-12 13:10:44 +01002444 ret = iwl_mvm_update_sta(mvm, vif, sta);
2445 if (ret == 0)
2446 iwl_mvm_rs_rate_init(mvm, sta,
Eyal Shapirab87c2172013-11-09 23:37:55 +02002447 mvmvif->phy_ctxt->channel->band,
2448 true);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002449 } else if (old_state == IEEE80211_STA_ASSOC &&
2450 new_state == IEEE80211_STA_AUTHORIZED) {
Arik Nemtsovf59e0e3c2014-06-10 19:56:27 +03002451
2452 /* we don't support TDLS during DCM */
2453 if (iwl_mvm_phy_ctx_count(mvm) > 1)
2454 iwl_mvm_teardown_tdls_peers(mvm);
2455
Golan Ben-Ami1e8f1322015-08-23 17:57:33 +03002456 if (sta->tdls)
2457 iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2458 NL80211_TDLS_ENABLE_LINK);
2459
Hila Gonen7df15b12012-12-12 11:16:19 +02002460 /* enable beacon filtering */
Avri Altmanfa7b2e72014-05-20 08:03:24 +03002461 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
Johannes Berg8ca151b2013-01-24 14:25:36 +01002462 ret = 0;
2463 } else if (old_state == IEEE80211_STA_AUTHORIZED &&
2464 new_state == IEEE80211_STA_ASSOC) {
Hila Gonen7df15b12012-12-12 11:16:19 +02002465 /* disable beacon filtering */
Emmanuel Grumbacha1022922014-05-12 11:36:41 +03002466 WARN_ON(iwl_mvm_disable_beacon_filter(mvm, vif, 0));
Johannes Berg8ca151b2013-01-24 14:25:36 +01002467 ret = 0;
2468 } else if (old_state == IEEE80211_STA_ASSOC &&
2469 new_state == IEEE80211_STA_AUTH) {
Ayala Beker8be30c12015-12-16 00:32:07 +02002470 if (vif->type == NL80211_IFTYPE_AP) {
2471 mvmvif->ap_assoc_sta_count--;
2472 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
2473 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01002474 ret = 0;
2475 } else if (old_state == IEEE80211_STA_AUTH &&
2476 new_state == IEEE80211_STA_NONE) {
2477 ret = 0;
2478 } else if (old_state == IEEE80211_STA_NONE &&
2479 new_state == IEEE80211_STA_NOTEXIST) {
2480 ret = iwl_mvm_rm_sta(mvm, vif, sta);
Golan Ben-Ami1e8f1322015-08-23 17:57:33 +03002481 if (sta->tdls) {
Arik Nemtsovfa3d07e2014-05-15 18:59:32 +03002482 iwl_mvm_recalc_tdls_state(mvm, vif, false);
Golan Ben-Ami1e8f1322015-08-23 17:57:33 +03002483 iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2484 NL80211_TDLS_DISABLE_LINK);
2485 }
Johannes Berg8ca151b2013-01-24 14:25:36 +01002486 } else {
2487 ret = -EIO;
2488 }
Johannes Berg48bc1302013-07-04 15:55:29 +02002489 out_unlock:
Johannes Berg8ca151b2013-01-24 14:25:36 +01002490 mutex_unlock(&mvm->mutex);
2491
Liad Kaufman9c126cd2014-10-06 19:08:56 +02002492 if (sta->tdls && ret == 0) {
2493 if (old_state == IEEE80211_STA_NOTEXIST &&
2494 new_state == IEEE80211_STA_NONE)
2495 ieee80211_reserve_tid(sta, IWL_MVM_TDLS_FW_TID);
2496 else if (old_state == IEEE80211_STA_NONE &&
2497 new_state == IEEE80211_STA_NOTEXIST)
2498 ieee80211_unreserve_tid(sta, IWL_MVM_TDLS_FW_TID);
2499 }
2500
Johannes Berg8ca151b2013-01-24 14:25:36 +01002501 return ret;
2502}
2503
2504static int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2505{
2506 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2507
2508 mvm->rts_threshold = value;
2509
2510 return 0;
2511}
2512
Lilach Edelstein1f3b0ff2013-10-06 13:03:32 +02002513static void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw,
2514 struct ieee80211_vif *vif,
2515 struct ieee80211_sta *sta, u32 changed)
2516{
2517 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2518
2519 if (vif->type == NL80211_IFTYPE_STATION &&
2520 changed & IEEE80211_RC_NSS_CHANGED)
2521 iwl_mvm_sf_update(mvm, vif, false);
2522}
2523
Johannes Berg8ca151b2013-01-24 14:25:36 +01002524static int iwl_mvm_mac_conf_tx(struct ieee80211_hw *hw,
2525 struct ieee80211_vif *vif, u16 ac,
2526 const struct ieee80211_tx_queue_params *params)
2527{
2528 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2529 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2530
2531 mvmvif->queue_params[ac] = *params;
2532
2533 /*
2534 * No need to update right away, we'll get BSS_CHANGED_QOS
2535 * The exception is P2P_DEVICE interface which needs immediate update.
2536 */
2537 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
2538 int ret;
2539
2540 mutex_lock(&mvm->mutex);
Johannes Berg3dfd3a92014-08-11 21:37:30 +02002541 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002542 mutex_unlock(&mvm->mutex);
2543 return ret;
2544 }
2545 return 0;
2546}
2547
2548static void iwl_mvm_mac_mgd_prepare_tx(struct ieee80211_hw *hw,
2549 struct ieee80211_vif *vif)
2550{
2551 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2552 u32 duration = min(IWL_MVM_TE_SESSION_PROTECTION_MAX_TIME_MS,
2553 200 + vif->bss_conf.beacon_int);
2554 u32 min_duration = min(IWL_MVM_TE_SESSION_PROTECTION_MIN_TIME_MS,
2555 100 + vif->bss_conf.beacon_int);
2556
2557 if (WARN_ON_ONCE(vif->bss_conf.assoc))
2558 return;
2559
Eliad Peller576eeee2014-07-01 18:38:38 +03002560 /*
2561 * iwl_mvm_protect_session() reads directly from the device
2562 * (the system time), so make sure it is available.
2563 */
2564 if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PREPARE_TX))
2565 return;
2566
Johannes Berg8ca151b2013-01-24 14:25:36 +01002567 mutex_lock(&mvm->mutex);
2568 /* Try really hard to protect the session and hear a beacon */
Liad Kaufmand20d37b2014-07-06 17:14:39 +03002569 iwl_mvm_protect_session(mvm, vif, duration, min_duration, 500, false);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002570 mutex_unlock(&mvm->mutex);
Eliad Peller576eeee2014-07-01 18:38:38 +03002571
2572 iwl_mvm_unref(mvm, IWL_MVM_REF_PREPARE_TX);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002573}
2574
David Spinadel35a000b2013-08-28 09:29:43 +03002575static int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw *hw,
2576 struct ieee80211_vif *vif,
2577 struct cfg80211_sched_scan_request *req,
David Spinadel633e2712014-02-06 16:15:23 +02002578 struct ieee80211_scan_ies *ies)
David Spinadel35a000b2013-08-28 09:29:43 +03002579{
2580 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Luciano Coelho6749dd82015-03-20 15:51:36 +02002581
David Spinadel35a000b2013-08-28 09:29:43 +03002582 int ret;
2583
2584 mutex_lock(&mvm->mutex);
2585
Luciano Coelho1f940382015-02-10 13:03:38 +02002586 if (!vif->bss_conf.idle) {
David Spinadelbd5e4742014-04-24 13:15:29 +03002587 ret = -EBUSY;
2588 goto out;
2589 }
2590
Luciano Coelho19945df2015-03-20 16:11:28 +02002591 ret = iwl_mvm_sched_scan_start(mvm, vif, req, ies, IWL_MVM_SCAN_SCHED);
David Spinadeld2496222014-05-20 12:46:37 +03002592
David Spinadel35a000b2013-08-28 09:29:43 +03002593out:
2594 mutex_unlock(&mvm->mutex);
2595 return ret;
2596}
2597
Johannes Berg37e33082014-02-17 10:48:17 +01002598static int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw *hw,
2599 struct ieee80211_vif *vif)
David Spinadel35a000b2013-08-28 09:29:43 +03002600{
2601 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Arik Nemtsov33ea27f2014-02-10 15:34:29 +02002602 int ret;
David Spinadel35a000b2013-08-28 09:29:43 +03002603
2604 mutex_lock(&mvm->mutex);
Luciano Coelhoe7d3aba2015-02-06 10:19:05 +02002605
2606 /* Due to a race condition, it's possible that mac80211 asks
2607 * us to stop a sched_scan when it's already stopped. This
2608 * can happen, for instance, if we stopped the scan ourselves,
2609 * called ieee80211_sched_scan_stopped() and the userspace called
2610 * stop sched scan scan before ieee80211_sched_scan_stopped_work()
2611 * could run. To handle this, simply return if the scan is
2612 * not running.
2613 */
Luciano Coelho262888f2015-05-07 17:21:09 +03002614 if (!(mvm->scan_status & IWL_MVM_SCAN_SCHED)) {
Luciano Coelhoe7d3aba2015-02-06 10:19:05 +02002615 mutex_unlock(&mvm->mutex);
2616 return 0;
2617 }
2618
Luciano Coelhoc7d42482015-05-07 16:00:26 +03002619 ret = iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, false);
David Spinadel35a000b2013-08-28 09:29:43 +03002620 mutex_unlock(&mvm->mutex);
Arik Nemtsov33ea27f2014-02-10 15:34:29 +02002621 iwl_mvm_wait_for_async_handlers(mvm);
Johannes Berg37e33082014-02-17 10:48:17 +01002622
Arik Nemtsov33ea27f2014-02-10 15:34:29 +02002623 return ret;
David Spinadel35a000b2013-08-28 09:29:43 +03002624}
2625
Johannes Berg8ca151b2013-01-24 14:25:36 +01002626static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
2627 enum set_key_cmd cmd,
2628 struct ieee80211_vif *vif,
2629 struct ieee80211_sta *sta,
2630 struct ieee80211_key_conf *key)
2631{
2632 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Bergf5e28ea2015-12-06 14:58:08 +02002633 struct iwl_mvm_sta *mvmsta;
2634 struct iwl_mvm_key_pn *ptk_pn;
2635 int keyidx = key->keyidx;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002636 int ret;
Luca Coelhod6ee54a2015-11-10 22:13:43 +02002637 u8 key_offset;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002638
2639 if (iwlwifi_mod_params.sw_crypto) {
2640 IWL_DEBUG_MAC80211(mvm, "leave - hwcrypto disabled\n");
2641 return -EOPNOTSUPP;
2642 }
2643
2644 switch (key->cipher) {
2645 case WLAN_CIPHER_SUITE_TKIP:
2646 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
Eliad Peller1ad4f632016-02-14 13:56:36 +02002647 key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002648 break;
Johannes Bergca8c0f42015-04-20 17:54:54 +02002649 case WLAN_CIPHER_SUITE_CCMP:
2650 key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2651 break;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002652 case WLAN_CIPHER_SUITE_AES_CMAC:
Johannes Berg30686bf2015-06-02 21:39:54 +02002653 WARN_ON_ONCE(!ieee80211_hw_check(hw, MFP_CAPABLE));
Johannes Berg8ca151b2013-01-24 14:25:36 +01002654 break;
2655 case WLAN_CIPHER_SUITE_WEP40:
2656 case WLAN_CIPHER_SUITE_WEP104:
Johannes Bergba3943b2014-11-12 23:54:48 +01002657 /* For non-client mode, only use WEP keys for TX as we probably
2658 * don't have a station yet anyway and would then have to keep
2659 * track of the keys, linking them to each of the clients/peers
2660 * as they appear. For now, don't do that, for performance WEP
2661 * offload doesn't really matter much, but we need it for some
2662 * other offload features in client mode.
Johannes Berg8ca151b2013-01-24 14:25:36 +01002663 */
Johannes Bergba3943b2014-11-12 23:54:48 +01002664 if (vif->type != NL80211_IFTYPE_STATION)
2665 return 0;
2666 break;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002667 default:
Max Stepanove36e5432013-08-27 19:56:13 +03002668 /* currently FW supports only one optional cipher scheme */
2669 if (hw->n_cipher_schemes &&
2670 hw->cipher_schemes->cipher == key->cipher)
2671 key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2672 else
2673 return -EOPNOTSUPP;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002674 }
2675
2676 mutex_lock(&mvm->mutex);
2677
2678 switch (cmd) {
2679 case SET_KEY:
Johannes Berg5023d962013-07-31 14:07:43 +02002680 if ((vif->type == NL80211_IFTYPE_ADHOC ||
2681 vif->type == NL80211_IFTYPE_AP) && !sta) {
2682 /*
2683 * GTK on AP interface is a TX-only key, return 0;
2684 * on IBSS they're per-station and because we're lazy
2685 * we don't support them for RX, so do the same.
2686 */
Johannes Berg6caffd42013-03-06 13:15:21 +01002687 ret = 0;
2688 key->hw_key_idx = STA_KEY_IDX_INVALID;
2689 break;
2690 }
2691
Johannes Bergb546dcd2015-04-20 17:31:10 +02002692 /* During FW restart, in order to restore the state as it was,
2693 * don't try to reprogram keys we previously failed for.
2694 */
2695 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
2696 key->hw_key_idx == STA_KEY_IDX_INVALID) {
2697 IWL_DEBUG_MAC80211(mvm,
2698 "skip invalid idx key programming during restart\n");
2699 ret = 0;
2700 break;
2701 }
2702
Johannes Bergf5e28ea2015-12-06 14:58:08 +02002703 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
2704 sta && iwl_mvm_has_new_rx_api(mvm) &&
2705 key->flags & IEEE80211_KEY_FLAG_PAIRWISE &&
2706 (key->cipher == WLAN_CIPHER_SUITE_CCMP ||
2707 key->cipher == WLAN_CIPHER_SUITE_GCMP)) {
2708 struct ieee80211_key_seq seq;
2709 int tid, q;
2710
2711 mvmsta = iwl_mvm_sta_from_mac80211(sta);
2712 WARN_ON(rcu_access_pointer(mvmsta->ptk_pn[keyidx]));
2713 ptk_pn = kzalloc(sizeof(*ptk_pn) +
2714 mvm->trans->num_rx_queues *
2715 sizeof(ptk_pn->q[0]),
2716 GFP_KERNEL);
2717 if (!ptk_pn) {
2718 ret = -ENOMEM;
2719 break;
2720 }
2721
2722 for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
2723 ieee80211_get_key_rx_seq(key, tid, &seq);
2724 for (q = 0; q < mvm->trans->num_rx_queues; q++)
2725 memcpy(ptk_pn->q[q].pn[tid],
2726 seq.ccmp.pn,
2727 IEEE80211_CCMP_PN_LEN);
2728 }
2729
2730 rcu_assign_pointer(mvmsta->ptk_pn[keyidx], ptk_pn);
2731 }
2732
Luca Coelhod6ee54a2015-11-10 22:13:43 +02002733 /* in HW restart reuse the index, otherwise request a new one */
2734 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
2735 key_offset = key->hw_key_idx;
2736 else
2737 key_offset = STA_KEY_IDX_INVALID;
2738
Johannes Berg8ca151b2013-01-24 14:25:36 +01002739 IWL_DEBUG_MAC80211(mvm, "set hwcrypto key\n");
Luca Coelhod6ee54a2015-11-10 22:13:43 +02002740 ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002741 if (ret) {
2742 IWL_WARN(mvm, "set key failed\n");
2743 /*
2744 * can't add key for RX, but we don't need it
2745 * in the device for TX so still return 0
2746 */
Johannes Berg6caffd42013-03-06 13:15:21 +01002747 key->hw_key_idx = STA_KEY_IDX_INVALID;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002748 ret = 0;
2749 }
2750
2751 break;
2752 case DISABLE_KEY:
Johannes Berg6caffd42013-03-06 13:15:21 +01002753 if (key->hw_key_idx == STA_KEY_IDX_INVALID) {
2754 ret = 0;
2755 break;
2756 }
2757
Johannes Bergf5e28ea2015-12-06 14:58:08 +02002758 if (sta && iwl_mvm_has_new_rx_api(mvm) &&
2759 key->flags & IEEE80211_KEY_FLAG_PAIRWISE &&
2760 (key->cipher == WLAN_CIPHER_SUITE_CCMP ||
2761 key->cipher == WLAN_CIPHER_SUITE_GCMP)) {
2762 mvmsta = iwl_mvm_sta_from_mac80211(sta);
2763 ptk_pn = rcu_dereference_protected(
2764 mvmsta->ptk_pn[keyidx],
2765 lockdep_is_held(&mvm->mutex));
2766 RCU_INIT_POINTER(mvmsta->ptk_pn[keyidx], NULL);
2767 if (ptk_pn)
2768 kfree_rcu(ptk_pn, rcu_head);
2769 }
2770
Johannes Berg8ca151b2013-01-24 14:25:36 +01002771 IWL_DEBUG_MAC80211(mvm, "disable hwcrypto key\n");
2772 ret = iwl_mvm_remove_sta_key(mvm, vif, sta, key);
2773 break;
2774 default:
2775 ret = -EINVAL;
2776 }
2777
2778 mutex_unlock(&mvm->mutex);
2779 return ret;
2780}
2781
2782static void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw *hw,
2783 struct ieee80211_vif *vif,
2784 struct ieee80211_key_conf *keyconf,
2785 struct ieee80211_sta *sta,
2786 u32 iv32, u16 *phase1key)
2787{
2788 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2789
Johannes Berg5023d962013-07-31 14:07:43 +02002790 if (keyconf->hw_key_idx == STA_KEY_IDX_INVALID)
2791 return;
2792
Johannes Berg8ca151b2013-01-24 14:25:36 +01002793 iwl_mvm_update_tkip_key(mvm, vif, keyconf, sta, iv32, phase1key);
2794}
2795
2796
Ariej Marjiehb1128892014-07-16 21:11:12 +03002797static bool iwl_mvm_rx_aux_roc(struct iwl_notif_wait_data *notif_wait,
2798 struct iwl_rx_packet *pkt, void *data)
2799{
2800 struct iwl_mvm *mvm =
2801 container_of(notif_wait, struct iwl_mvm, notif_wait);
2802 struct iwl_hs20_roc_res *resp;
2803 int resp_len = iwl_rx_packet_payload_len(pkt);
2804 struct iwl_mvm_time_event_data *te_data = data;
2805
2806 if (WARN_ON(pkt->hdr.cmd != HOT_SPOT_CMD))
2807 return true;
2808
2809 if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
2810 IWL_ERR(mvm, "Invalid HOT_SPOT_CMD response\n");
2811 return true;
2812 }
2813
2814 resp = (void *)pkt->data;
2815
2816 IWL_DEBUG_TE(mvm,
2817 "Aux ROC: Recieved response from ucode: status=%d uid=%d\n",
2818 resp->status, resp->event_unique_id);
2819
2820 te_data->uid = le32_to_cpu(resp->event_unique_id);
2821 IWL_DEBUG_TE(mvm, "TIME_EVENT_CMD response - UID = 0x%x\n",
2822 te_data->uid);
2823
2824 spin_lock_bh(&mvm->time_event_lock);
2825 list_add_tail(&te_data->list, &mvm->aux_roc_te_list);
2826 spin_unlock_bh(&mvm->time_event_lock);
2827
2828 return true;
2829}
2830
Matti Gottliebdc28e122015-11-22 10:08:56 +02002831#define AUX_ROC_MIN_DURATION MSEC_TO_TU(100)
2832#define AUX_ROC_MIN_DELAY MSEC_TO_TU(200)
2833#define AUX_ROC_MAX_DELAY MSEC_TO_TU(600)
2834#define AUX_ROC_SAFETY_BUFFER MSEC_TO_TU(20)
2835#define AUX_ROC_MIN_SAFETY_BUFFER MSEC_TO_TU(10)
Ariej Marjiehb1128892014-07-16 21:11:12 +03002836static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm *mvm,
2837 struct ieee80211_channel *channel,
2838 struct ieee80211_vif *vif,
2839 int duration)
2840{
2841 int res, time_reg = DEVICE_SYSTEM_TIME_REG;
2842 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2843 struct iwl_mvm_time_event_data *te_data = &mvmvif->hs_time_event_data;
Sara Sharon6eb031d2015-07-13 14:50:47 +03002844 static const u16 time_event_response[] = { HOT_SPOT_CMD };
Ariej Marjiehb1128892014-07-16 21:11:12 +03002845 struct iwl_notification_wait wait_time_event;
Matti Gottliebdc28e122015-11-22 10:08:56 +02002846 u32 dtim_interval = vif->bss_conf.dtim_period *
2847 vif->bss_conf.beacon_int;
2848 u32 req_dur, delay;
Ariej Marjiehb1128892014-07-16 21:11:12 +03002849 struct iwl_hs20_roc_req aux_roc_req = {
2850 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
2851 .id_and_color =
2852 cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX, 0)),
2853 .sta_id_and_color = cpu_to_le32(mvm->aux_sta.sta_id),
2854 /* Set the channel info data */
2855 .channel_info.band = (channel->band == IEEE80211_BAND_2GHZ) ?
2856 PHY_BAND_24 : PHY_BAND_5,
2857 .channel_info.channel = channel->hw_value,
2858 .channel_info.width = PHY_VHT_CHANNEL_MODE20,
2859 /* Set the time and duration */
2860 .apply_time = cpu_to_le32(iwl_read_prph(mvm->trans, time_reg)),
Ariej Marjiehb1128892014-07-16 21:11:12 +03002861 };
2862
Matti Gottliebdc28e122015-11-22 10:08:56 +02002863 delay = AUX_ROC_MIN_DELAY;
2864 req_dur = MSEC_TO_TU(duration);
2865
2866 /*
2867 * If we are associated we want the delay time to be at least one
2868 * dtim interval so that the FW can wait until after the DTIM and
2869 * then start the time event, this will potentially allow us to
2870 * remain off-channel for the max duration.
2871 * Since we want to use almost a whole dtim interval we would also
2872 * like the delay to be for 2-3 dtim intervals, in case there are
2873 * other time events with higher priority.
2874 */
2875 if (vif->bss_conf.assoc) {
2876 delay = min_t(u32, dtim_interval * 3, AUX_ROC_MAX_DELAY);
2877 /* We cannot remain off-channel longer than the DTIM interval */
2878 if (dtim_interval <= req_dur) {
2879 req_dur = dtim_interval - AUX_ROC_SAFETY_BUFFER;
2880 if (req_dur <= AUX_ROC_MIN_DURATION)
2881 req_dur = dtim_interval -
2882 AUX_ROC_MIN_SAFETY_BUFFER;
2883 }
2884 }
2885
2886 aux_roc_req.duration = cpu_to_le32(req_dur);
2887 aux_roc_req.apply_time_max_delay = cpu_to_le32(delay);
2888
2889 IWL_DEBUG_TE(mvm,
2890 "ROC: Requesting to remain on channel %u for %ums (requested = %ums, max_delay = %ums, dtim_interval = %ums)\n",
2891 channel->hw_value, req_dur, duration, delay,
2892 dtim_interval);
Ariej Marjiehb1128892014-07-16 21:11:12 +03002893 /* Set the node address */
2894 memcpy(aux_roc_req.node_addr, vif->addr, ETH_ALEN);
2895
Matti Gottlieba6cc5162014-09-29 11:46:04 +03002896 lockdep_assert_held(&mvm->mutex);
2897
2898 spin_lock_bh(&mvm->time_event_lock);
2899
2900 if (WARN_ON(te_data->id == HOT_SPOT_CMD)) {
2901 spin_unlock_bh(&mvm->time_event_lock);
2902 return -EIO;
2903 }
2904
Ariej Marjiehb1128892014-07-16 21:11:12 +03002905 te_data->vif = vif;
2906 te_data->duration = duration;
2907 te_data->id = HOT_SPOT_CMD;
2908
Ariej Marjiehb1128892014-07-16 21:11:12 +03002909 spin_unlock_bh(&mvm->time_event_lock);
2910
2911 /*
2912 * Use a notification wait, which really just processes the
2913 * command response and doesn't wait for anything, in order
2914 * to be able to process the response and get the UID inside
2915 * the RX path. Using CMD_WANT_SKB doesn't work because it
2916 * stores the buffer and then wakes up this thread, by which
2917 * time another notification (that the time event started)
2918 * might already be processed unsuccessfully.
2919 */
2920 iwl_init_notification_wait(&mvm->notif_wait, &wait_time_event,
2921 time_event_response,
2922 ARRAY_SIZE(time_event_response),
2923 iwl_mvm_rx_aux_roc, te_data);
2924
2925 res = iwl_mvm_send_cmd_pdu(mvm, HOT_SPOT_CMD, 0, sizeof(aux_roc_req),
2926 &aux_roc_req);
2927
2928 if (res) {
2929 IWL_ERR(mvm, "Couldn't send HOT_SPOT_CMD: %d\n", res);
2930 iwl_remove_notification(&mvm->notif_wait, &wait_time_event);
2931 goto out_clear_te;
2932 }
2933
2934 /* No need to wait for anything, so just pass 1 (0 isn't valid) */
2935 res = iwl_wait_notification(&mvm->notif_wait, &wait_time_event, 1);
2936 /* should never fail */
2937 WARN_ON_ONCE(res);
2938
2939 if (res) {
2940 out_clear_te:
2941 spin_lock_bh(&mvm->time_event_lock);
2942 iwl_mvm_te_clear_data(mvm, te_data);
2943 spin_unlock_bh(&mvm->time_event_lock);
2944 }
2945
2946 return res;
2947}
2948
Johannes Berg8ca151b2013-01-24 14:25:36 +01002949static int iwl_mvm_roc(struct ieee80211_hw *hw,
2950 struct ieee80211_vif *vif,
2951 struct ieee80211_channel *channel,
Ilan Peerd339d5c2013-02-12 09:34:13 +02002952 int duration,
2953 enum ieee80211_roc_type type)
Johannes Berg8ca151b2013-01-24 14:25:36 +01002954{
2955 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Ilan Peerfe0f2de2013-03-21 10:23:52 +02002956 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002957 struct cfg80211_chan_def chandef;
Ilan Peer31d385a2013-04-02 10:25:46 +03002958 struct iwl_mvm_phy_ctxt *phy_ctxt;
2959 int ret, i;
2960
2961 IWL_DEBUG_MAC80211(mvm, "enter (%d, %d, %d)\n", channel->hw_value,
2962 duration, type);
Johannes Berg8ca151b2013-01-24 14:25:36 +01002963
Matti Gottlieb6ed13162015-03-30 16:50:07 +03002964 flush_work(&mvm->roc_done_wk);
2965
Matti Gottlieba6cc5162014-09-29 11:46:04 +03002966 mutex_lock(&mvm->mutex);
2967
Ariej Marjiehb1128892014-07-16 21:11:12 +03002968 switch (vif->type) {
2969 case NL80211_IFTYPE_STATION:
Johannes Berg859d9142015-06-01 17:11:11 +02002970 if (fw_has_capa(&mvm->fw->ucode_capa,
2971 IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT)) {
Luciano Coelho5ac6c722014-10-21 16:12:18 +03002972 /* Use aux roc framework (HS20) */
2973 ret = iwl_mvm_send_aux_roc_cmd(mvm, channel,
2974 vif, duration);
2975 goto out_unlock;
2976 }
2977 IWL_ERR(mvm, "hotspot not supported\n");
2978 ret = -EINVAL;
Matti Gottlieba6cc5162014-09-29 11:46:04 +03002979 goto out_unlock;
Ariej Marjiehb1128892014-07-16 21:11:12 +03002980 case NL80211_IFTYPE_P2P_DEVICE:
2981 /* handle below */
2982 break;
2983 default:
2984 IWL_ERR(mvm, "vif isn't P2P_DEVICE: %d\n", vif->type);
Matti Gottlieba6cc5162014-09-29 11:46:04 +03002985 ret = -EINVAL;
2986 goto out_unlock;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002987 }
2988
Ilan Peer31d385a2013-04-02 10:25:46 +03002989 for (i = 0; i < NUM_PHY_CTX; i++) {
2990 phy_ctxt = &mvm->phy_ctxts[i];
2991 if (phy_ctxt->ref == 0 || mvmvif->phy_ctxt == phy_ctxt)
2992 continue;
Johannes Berg8ca151b2013-01-24 14:25:36 +01002993
Ilan Peer31d385a2013-04-02 10:25:46 +03002994 if (phy_ctxt->ref && channel == phy_ctxt->channel) {
2995 /*
2996 * Unbind the P2P_DEVICE from the current PHY context,
2997 * and if the PHY context is not used remove it.
2998 */
2999 ret = iwl_mvm_binding_remove_vif(mvm, vif);
3000 if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
3001 goto out_unlock;
3002
3003 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
3004
3005 /* Bind the P2P_DEVICE to the current PHY Context */
3006 mvmvif->phy_ctxt = phy_ctxt;
3007
3008 ret = iwl_mvm_binding_add_vif(mvm, vif);
3009 if (WARN(ret, "Failed binding P2P_DEVICE\n"))
3010 goto out_unlock;
3011
3012 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
3013 goto schedule_time_event;
3014 }
3015 }
3016
3017 /* Need to update the PHY context only if the ROC channel changed */
3018 if (channel == mvmvif->phy_ctxt->channel)
3019 goto schedule_time_event;
3020
3021 cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);
3022
3023 /*
3024 * Change the PHY context configuration as it is currently referenced
3025 * only by the P2P Device MAC
3026 */
3027 if (mvmvif->phy_ctxt->ref == 1) {
3028 ret = iwl_mvm_phy_ctxt_changed(mvm, mvmvif->phy_ctxt,
3029 &chandef, 1, 1);
3030 if (ret)
3031 goto out_unlock;
3032 } else {
3033 /*
3034 * The PHY context is shared with other MACs. Need to remove the
3035 * P2P Device from the binding, allocate an new PHY context and
3036 * create a new binding
3037 */
3038 phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
3039 if (!phy_ctxt) {
3040 ret = -ENOSPC;
3041 goto out_unlock;
3042 }
3043
3044 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &chandef,
3045 1, 1);
3046 if (ret) {
3047 IWL_ERR(mvm, "Failed to change PHY context\n");
3048 goto out_unlock;
3049 }
3050
3051 /* Unbind the P2P_DEVICE from the current PHY context */
3052 ret = iwl_mvm_binding_remove_vif(mvm, vif);
3053 if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
3054 goto out_unlock;
3055
3056 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
3057
3058 /* Bind the P2P_DEVICE to the new allocated PHY context */
3059 mvmvif->phy_ctxt = phy_ctxt;
3060
3061 ret = iwl_mvm_binding_add_vif(mvm, vif);
3062 if (WARN(ret, "Failed binding P2P_DEVICE\n"))
3063 goto out_unlock;
3064
3065 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
3066 }
3067
3068schedule_time_event:
Johannes Berg8ca151b2013-01-24 14:25:36 +01003069 /* Schedule the time events */
Ilan Peere635c792013-02-13 11:05:18 +02003070 ret = iwl_mvm_start_p2p_roc(mvm, vif, duration, type);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003071
Ilan Peer31d385a2013-04-02 10:25:46 +03003072out_unlock:
Johannes Berg8ca151b2013-01-24 14:25:36 +01003073 mutex_unlock(&mvm->mutex);
3074 IWL_DEBUG_MAC80211(mvm, "leave\n");
Johannes Berg8ca151b2013-01-24 14:25:36 +01003075 return ret;
3076}
3077
3078static int iwl_mvm_cancel_roc(struct ieee80211_hw *hw)
3079{
3080 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3081
3082 IWL_DEBUG_MAC80211(mvm, "enter\n");
3083
3084 mutex_lock(&mvm->mutex);
Matti Gottliebbf5da872014-11-16 10:25:12 +02003085 iwl_mvm_stop_roc(mvm);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003086 mutex_unlock(&mvm->mutex);
3087
3088 IWL_DEBUG_MAC80211(mvm, "leave\n");
3089 return 0;
3090}
3091
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003092static int __iwl_mvm_add_chanctx(struct iwl_mvm *mvm,
3093 struct ieee80211_chanctx_conf *ctx)
Johannes Berg8ca151b2013-01-24 14:25:36 +01003094{
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003095 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3096 struct iwl_mvm_phy_ctxt *phy_ctxt;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003097 int ret;
3098
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003099 lockdep_assert_held(&mvm->mutex);
3100
Ilan Peer53a9d612013-04-28 11:55:08 +03003101 IWL_DEBUG_MAC80211(mvm, "Add channel context\n");
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003102
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003103 phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
3104 if (!phy_ctxt) {
3105 ret = -ENOSPC;
3106 goto out;
3107 }
3108
Eliad Pellerdcbc3e12013-10-31 14:31:25 +02003109 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &ctx->min_def,
Ilan Peer53a9d612013-04-28 11:55:08 +03003110 ctx->rx_chains_static,
3111 ctx->rx_chains_dynamic);
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003112 if (ret) {
3113 IWL_ERR(mvm, "Failed to add PHY context\n");
3114 goto out;
3115 }
3116
Ilan Peer53a9d612013-04-28 11:55:08 +03003117 iwl_mvm_phy_ctxt_ref(mvm, phy_ctxt);
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003118 *phy_ctxt_id = phy_ctxt->id;
3119out:
Johannes Berg8ca151b2013-01-24 14:25:36 +01003120 return ret;
3121}
3122
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003123static int iwl_mvm_add_chanctx(struct ieee80211_hw *hw,
3124 struct ieee80211_chanctx_conf *ctx)
3125{
3126 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3127 int ret;
3128
3129 mutex_lock(&mvm->mutex);
3130 ret = __iwl_mvm_add_chanctx(mvm, ctx);
3131 mutex_unlock(&mvm->mutex);
3132
3133 return ret;
3134}
3135
3136static void __iwl_mvm_remove_chanctx(struct iwl_mvm *mvm,
3137 struct ieee80211_chanctx_conf *ctx)
3138{
3139 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3140 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
3141
3142 lockdep_assert_held(&mvm->mutex);
3143
3144 iwl_mvm_phy_ctxt_unref(mvm, phy_ctxt);
3145}
3146
Johannes Berg8ca151b2013-01-24 14:25:36 +01003147static void iwl_mvm_remove_chanctx(struct ieee80211_hw *hw,
3148 struct ieee80211_chanctx_conf *ctx)
3149{
3150 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003151
3152 mutex_lock(&mvm->mutex);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003153 __iwl_mvm_remove_chanctx(mvm, ctx);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003154 mutex_unlock(&mvm->mutex);
3155}
3156
3157static void iwl_mvm_change_chanctx(struct ieee80211_hw *hw,
3158 struct ieee80211_chanctx_conf *ctx,
3159 u32 changed)
3160{
3161 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003162 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3163 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
Johannes Berg8ca151b2013-01-24 14:25:36 +01003164
Ilan Peer31d385a2013-04-02 10:25:46 +03003165 if (WARN_ONCE((phy_ctxt->ref > 1) &&
3166 (changed & ~(IEEE80211_CHANCTX_CHANGE_WIDTH |
3167 IEEE80211_CHANCTX_CHANGE_RX_CHAINS |
Arik Nemtsov2dceeda2013-12-29 17:57:53 +02003168 IEEE80211_CHANCTX_CHANGE_RADAR |
3169 IEEE80211_CHANCTX_CHANGE_MIN_WIDTH)),
Ilan Peer31d385a2013-04-02 10:25:46 +03003170 "Cannot change PHY. Ref=%d, changed=0x%X\n",
3171 phy_ctxt->ref, changed))
3172 return;
3173
Johannes Berg8ca151b2013-01-24 14:25:36 +01003174 mutex_lock(&mvm->mutex);
Emmanuel Grumbach4d664492014-04-30 18:09:59 +03003175 iwl_mvm_bt_coex_vif_change(mvm);
Eliad Pellerdcbc3e12013-10-31 14:31:25 +02003176 iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &ctx->min_def,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003177 ctx->rx_chains_static,
3178 ctx->rx_chains_dynamic);
3179 mutex_unlock(&mvm->mutex);
3180}
3181
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003182static int __iwl_mvm_assign_vif_chanctx(struct iwl_mvm *mvm,
3183 struct ieee80211_vif *vif,
Luciano Coelhof0c97782014-03-05 15:41:48 +02003184 struct ieee80211_chanctx_conf *ctx,
3185 bool switching_chanctx)
Johannes Berg8ca151b2013-01-24 14:25:36 +01003186{
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003187 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3188 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
Johannes Berg8ca151b2013-01-24 14:25:36 +01003189 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3190 int ret;
3191
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003192 lockdep_assert_held(&mvm->mutex);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003193
Ilan Peerfe0f2de2013-03-21 10:23:52 +02003194 mvmvif->phy_ctxt = phy_ctxt;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003195
3196 switch (vif->type) {
3197 case NL80211_IFTYPE_AP:
Luciano Coelho4741dd02014-11-10 11:10:13 +02003198 /* only needed if we're switching chanctx (i.e. during CSA) */
3199 if (switching_chanctx) {
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003200 mvmvif->ap_ibss_active = true;
3201 break;
3202 }
Johannes Berg5023d962013-07-31 14:07:43 +02003203 case NL80211_IFTYPE_ADHOC:
Johannes Berg8ca151b2013-01-24 14:25:36 +01003204 /*
3205 * The AP binding flow is handled as part of the start_ap flow
Johannes Berg5023d962013-07-31 14:07:43 +02003206 * (in bss_info_changed), similarly for IBSS.
Johannes Berg8ca151b2013-01-24 14:25:36 +01003207 */
3208 ret = 0;
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003209 goto out;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003210 case NL80211_IFTYPE_STATION:
Luciano Coelho2533edc2014-08-08 19:50:46 +03003211 break;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003212 case NL80211_IFTYPE_MONITOR:
Luciano Coelho2533edc2014-08-08 19:50:46 +03003213 /* always disable PS when a monitor interface is active */
3214 mvmvif->ps_disabled = true;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003215 break;
3216 default:
3217 ret = -EINVAL;
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003218 goto out;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003219 }
3220
3221 ret = iwl_mvm_binding_add_vif(mvm, vif);
3222 if (ret)
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003223 goto out;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003224
3225 /*
Alexander Bondar92d85562013-10-23 11:50:34 +02003226 * Power state must be updated before quotas,
3227 * otherwise fw will complain.
3228 */
Arik Nemtsov999609f2014-05-15 17:31:51 +03003229 iwl_mvm_power_update_mac(mvm);
Alexander Bondar92d85562013-10-23 11:50:34 +02003230
3231 /* Setting the quota at this stage is only required for monitor
Johannes Berg8ca151b2013-01-24 14:25:36 +01003232 * interfaces. For the other types, the bss_info changed flow
3233 * will handle quota settings.
3234 */
3235 if (vif->type == NL80211_IFTYPE_MONITOR) {
Ilan Peer1e1391c2013-03-13 14:52:04 +02003236 mvmvif->monitor_active = true;
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02003237 ret = iwl_mvm_update_quotas(mvm, false, NULL);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003238 if (ret)
3239 goto out_remove_binding;
Chaya Rachel Ivgi0e39eb02015-12-03 15:51:46 +02003240
3241 ret = iwl_mvm_add_snif_sta(mvm, vif);
3242 if (ret)
3243 goto out_remove_binding;
3244
Johannes Berg8ca151b2013-01-24 14:25:36 +01003245 }
3246
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003247 /* Handle binding during CSA */
Luciano Coelhoa57c6882014-11-10 11:10:16 +02003248 if (vif->type == NL80211_IFTYPE_AP) {
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02003249 iwl_mvm_update_quotas(mvm, false, NULL);
Johannes Berg3dfd3a92014-08-11 21:37:30 +02003250 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003251 }
3252
Luciano Coelho4741dd02014-11-10 11:10:13 +02003253 if (switching_chanctx && vif->type == NL80211_IFTYPE_STATION) {
Luciano Coelho686e7fe2014-11-10 11:10:21 +02003254 u32 duration = 2 * vif->bss_conf.beacon_int;
3255
3256 /* iwl_mvm_protect_session() reads directly from the
3257 * device (the system time), so make sure it is
3258 * available.
3259 */
3260 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PROTECT_CSA);
3261 if (ret)
3262 goto out_remove_binding;
3263
3264 /* Protect the session to make sure we hear the first
3265 * beacon on the new channel.
3266 */
3267 iwl_mvm_protect_session(mvm, vif, duration, duration,
3268 vif->bss_conf.beacon_int / 2,
3269 true);
3270
3271 iwl_mvm_unref(mvm, IWL_MVM_REF_PROTECT_CSA);
3272
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02003273 iwl_mvm_update_quotas(mvm, false, NULL);
Luciano Coelho0ce04ce2014-05-08 16:03:39 +03003274 }
3275
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003276 goto out;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003277
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003278out_remove_binding:
Johannes Berg8ca151b2013-01-24 14:25:36 +01003279 iwl_mvm_binding_remove_vif(mvm, vif);
Arik Nemtsov999609f2014-05-15 17:31:51 +03003280 iwl_mvm_power_update_mac(mvm);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003281out:
Johannes Berg8ca151b2013-01-24 14:25:36 +01003282 if (ret)
3283 mvmvif->phy_ctxt = NULL;
3284 return ret;
3285}
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003286static int iwl_mvm_assign_vif_chanctx(struct ieee80211_hw *hw,
3287 struct ieee80211_vif *vif,
3288 struct ieee80211_chanctx_conf *ctx)
Johannes Berg8ca151b2013-01-24 14:25:36 +01003289{
3290 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003291 int ret;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003292
3293 mutex_lock(&mvm->mutex);
Luciano Coelhof0c97782014-03-05 15:41:48 +02003294 ret = __iwl_mvm_assign_vif_chanctx(mvm, vif, ctx, false);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003295 mutex_unlock(&mvm->mutex);
3296
3297 return ret;
3298}
3299
3300static void __iwl_mvm_unassign_vif_chanctx(struct iwl_mvm *mvm,
3301 struct ieee80211_vif *vif,
Luciano Coelhof0c97782014-03-05 15:41:48 +02003302 struct ieee80211_chanctx_conf *ctx,
3303 bool switching_chanctx)
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003304{
3305 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
Luciano Coelhof0c97782014-03-05 15:41:48 +02003306 struct ieee80211_vif *disabled_vif = NULL;
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003307
3308 lockdep_assert_held(&mvm->mutex);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003309
3310 iwl_mvm_remove_time_event(mvm, mvmvif, &mvmvif->time_event_data);
3311
Johannes Berg8ca151b2013-01-24 14:25:36 +01003312 switch (vif->type) {
Johannes Berg5023d962013-07-31 14:07:43 +02003313 case NL80211_IFTYPE_ADHOC:
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003314 goto out;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003315 case NL80211_IFTYPE_MONITOR:
Ilan Peer1e1391c2013-03-13 14:52:04 +02003316 mvmvif->monitor_active = false;
Luciano Coelho2533edc2014-08-08 19:50:46 +03003317 mvmvif->ps_disabled = false;
Chaya Rachel Ivgi0e39eb02015-12-03 15:51:46 +02003318 iwl_mvm_rm_snif_sta(mvm, vif);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003319 break;
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003320 case NL80211_IFTYPE_AP:
3321 /* This part is triggered only during CSA */
Luciano Coelho4741dd02014-11-10 11:10:13 +02003322 if (!switching_chanctx || !mvmvif->ap_ibss_active)
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003323 goto out;
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003324
Andrei Otcheretianski7ef0aab2014-11-10 11:10:11 +02003325 mvmvif->csa_countdown = false;
3326
Andrei Otcheretianski003e52362014-05-25 17:24:22 +03003327 /* Set CS bit on all the stations */
3328 iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, true);
3329
3330 /* Save blocked iface, the timeout is set on the next beacon */
3331 rcu_assign_pointer(mvm->csa_tx_blocked_vif, vif);
3332
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003333 mvmvif->ap_ibss_active = false;
Luciano Coelhof0c97782014-03-05 15:41:48 +02003334 break;
3335 case NL80211_IFTYPE_STATION:
3336 if (!switching_chanctx)
3337 break;
3338
3339 disabled_vif = vif;
3340
Johannes Berg3dfd3a92014-08-11 21:37:30 +02003341 iwl_mvm_mac_ctxt_changed(mvm, vif, true, NULL);
Luciano Coelhof0c97782014-03-05 15:41:48 +02003342 break;
Johannes Berg8ca151b2013-01-24 14:25:36 +01003343 default:
3344 break;
3345 }
3346
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02003347 iwl_mvm_update_quotas(mvm, false, disabled_vif);
Ilan Peer1e1391c2013-03-13 14:52:04 +02003348 iwl_mvm_binding_remove_vif(mvm, vif);
Alexander Bondar1c2abf72013-08-27 20:31:48 +03003349
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003350out:
Ilan Peera11e1442013-12-31 21:19:55 +02003351 mvmvif->phy_ctxt = NULL;
Arik Nemtsov999609f2014-05-15 17:31:51 +03003352 iwl_mvm_power_update_mac(mvm);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003353}
3354
3355static void iwl_mvm_unassign_vif_chanctx(struct ieee80211_hw *hw,
3356 struct ieee80211_vif *vif,
3357 struct ieee80211_chanctx_conf *ctx)
3358{
3359 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3360
3361 mutex_lock(&mvm->mutex);
Luciano Coelhof0c97782014-03-05 15:41:48 +02003362 __iwl_mvm_unassign_vif_chanctx(mvm, vif, ctx, false);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003363 mutex_unlock(&mvm->mutex);
3364}
3365
Luciano Coelho50cc9572014-11-10 11:10:08 +02003366static int
3367iwl_mvm_switch_vif_chanctx_swap(struct iwl_mvm *mvm,
3368 struct ieee80211_vif_chanctx_switch *vifs)
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003369{
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003370 int ret;
3371
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003372 mutex_lock(&mvm->mutex);
Luciano Coelhof0c97782014-03-05 15:41:48 +02003373 __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003374 __iwl_mvm_remove_chanctx(mvm, vifs[0].old_ctx);
3375
3376 ret = __iwl_mvm_add_chanctx(mvm, vifs[0].new_ctx);
3377 if (ret) {
3378 IWL_ERR(mvm, "failed to add new_ctx during channel switch\n");
3379 goto out_reassign;
3380 }
3381
Luciano Coelhof0c97782014-03-05 15:41:48 +02003382 ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
3383 true);
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003384 if (ret) {
3385 IWL_ERR(mvm,
3386 "failed to assign new_ctx during channel switch\n");
3387 goto out_remove;
3388 }
3389
Arik Nemtsovf6972672014-06-15 16:03:55 +03003390 /* we don't support TDLS during DCM - can be caused by channel switch */
3391 if (iwl_mvm_phy_ctx_count(mvm) > 1)
3392 iwl_mvm_teardown_tdls_peers(mvm);
3393
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003394 goto out;
3395
3396out_remove:
3397 __iwl_mvm_remove_chanctx(mvm, vifs[0].new_ctx);
3398
3399out_reassign:
Luciano Coelho6fd1fb62014-11-10 11:10:10 +02003400 if (__iwl_mvm_add_chanctx(mvm, vifs[0].old_ctx)) {
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003401 IWL_ERR(mvm, "failed to add old_ctx back after failure.\n");
3402 goto out_restart;
3403 }
3404
Luciano Coelho6fd1fb62014-11-10 11:10:10 +02003405 if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
3406 true)) {
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003407 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
3408 goto out_restart;
3409 }
3410
3411 goto out;
3412
3413out_restart:
3414 /* things keep failing, better restart the hw */
3415 iwl_mvm_nic_restart(mvm, false);
3416
3417out:
3418 mutex_unlock(&mvm->mutex);
Luciano Coelho50cc9572014-11-10 11:10:08 +02003419
3420 return ret;
3421}
3422
Luciano Coelho48a256e2014-11-10 11:10:09 +02003423static int
3424iwl_mvm_switch_vif_chanctx_reassign(struct iwl_mvm *mvm,
3425 struct ieee80211_vif_chanctx_switch *vifs)
3426{
3427 int ret;
3428
3429 mutex_lock(&mvm->mutex);
3430 __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
3431
3432 ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
3433 true);
3434 if (ret) {
3435 IWL_ERR(mvm,
3436 "failed to assign new_ctx during channel switch\n");
3437 goto out_reassign;
3438 }
3439
3440 goto out;
3441
3442out_reassign:
3443 if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
3444 true)) {
3445 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
3446 goto out_restart;
3447 }
3448
3449 goto out;
3450
3451out_restart:
3452 /* things keep failing, better restart the hw */
3453 iwl_mvm_nic_restart(mvm, false);
3454
3455out:
3456 mutex_unlock(&mvm->mutex);
3457
3458 return ret;
3459}
3460
Luciano Coelho50cc9572014-11-10 11:10:08 +02003461static int iwl_mvm_switch_vif_chanctx(struct ieee80211_hw *hw,
3462 struct ieee80211_vif_chanctx_switch *vifs,
3463 int n_vifs,
3464 enum ieee80211_chanctx_switch_mode mode)
3465{
3466 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3467 int ret;
3468
3469 /* we only support a single-vif right now */
3470 if (n_vifs > 1)
3471 return -EOPNOTSUPP;
3472
3473 switch (mode) {
3474 case CHANCTX_SWMODE_SWAP_CONTEXTS:
3475 ret = iwl_mvm_switch_vif_chanctx_swap(mvm, vifs);
3476 break;
3477 case CHANCTX_SWMODE_REASSIGN_VIF:
Luciano Coelho48a256e2014-11-10 11:10:09 +02003478 ret = iwl_mvm_switch_vif_chanctx_reassign(mvm, vifs);
Luciano Coelho50cc9572014-11-10 11:10:08 +02003479 break;
3480 default:
3481 ret = -EOPNOTSUPP;
3482 break;
3483 }
3484
Luciano Coelhob08c1d92014-05-20 23:31:05 +03003485 return ret;
3486}
3487
Johannes Berg8ca151b2013-01-24 14:25:36 +01003488static int iwl_mvm_set_tim(struct ieee80211_hw *hw,
3489 struct ieee80211_sta *sta,
3490 bool set)
3491{
3492 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Johannes Berg9d8ce6a2014-12-23 16:02:40 +01003493 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
Johannes Berg8ca151b2013-01-24 14:25:36 +01003494
3495 if (!mvm_sta || !mvm_sta->vif) {
3496 IWL_ERR(mvm, "Station is not associated to a vif\n");
3497 return -EINVAL;
3498 }
3499
3500 return iwl_mvm_mac_ctxt_beacon_changed(mvm, mvm_sta->vif);
3501}
3502
David Spinadel507cadf2013-07-31 18:07:21 +03003503#ifdef CONFIG_NL80211_TESTMODE
3504static const struct nla_policy iwl_mvm_tm_policy[IWL_MVM_TM_ATTR_MAX + 1] = {
3505 [IWL_MVM_TM_ATTR_CMD] = { .type = NLA_U32 },
3506 [IWL_MVM_TM_ATTR_NOA_DURATION] = { .type = NLA_U32 },
Johannes Bergf6c6ad422013-08-01 14:17:15 +02003507 [IWL_MVM_TM_ATTR_BEACON_FILTER_STATE] = { .type = NLA_U32 },
David Spinadel507cadf2013-07-31 18:07:21 +03003508};
3509
3510static int __iwl_mvm_mac_testmode_cmd(struct iwl_mvm *mvm,
3511 struct ieee80211_vif *vif,
3512 void *data, int len)
3513{
3514 struct nlattr *tb[IWL_MVM_TM_ATTR_MAX + 1];
3515 int err;
3516 u32 noa_duration;
3517
3518 err = nla_parse(tb, IWL_MVM_TM_ATTR_MAX, data, len, iwl_mvm_tm_policy);
3519 if (err)
3520 return err;
3521
3522 if (!tb[IWL_MVM_TM_ATTR_CMD])
3523 return -EINVAL;
3524
3525 switch (nla_get_u32(tb[IWL_MVM_TM_ATTR_CMD])) {
3526 case IWL_MVM_TM_CMD_SET_NOA:
3527 if (!vif || vif->type != NL80211_IFTYPE_AP || !vif->p2p ||
3528 !vif->bss_conf.enable_beacon ||
3529 !tb[IWL_MVM_TM_ATTR_NOA_DURATION])
3530 return -EINVAL;
3531
3532 noa_duration = nla_get_u32(tb[IWL_MVM_TM_ATTR_NOA_DURATION]);
3533 if (noa_duration >= vif->bss_conf.beacon_int)
3534 return -EINVAL;
3535
3536 mvm->noa_duration = noa_duration;
3537 mvm->noa_vif = vif;
3538
Emmanuel Grumbach7754ae72015-02-26 15:14:35 +02003539 return iwl_mvm_update_quotas(mvm, false, NULL);
Johannes Bergf6c6ad422013-08-01 14:17:15 +02003540 case IWL_MVM_TM_CMD_SET_BEACON_FILTER:
3541 /* must be associated client vif - ignore authorized */
3542 if (!vif || vif->type != NL80211_IFTYPE_STATION ||
3543 !vif->bss_conf.assoc || !vif->bss_conf.dtim_period ||
3544 !tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE])
3545 return -EINVAL;
3546
3547 if (nla_get_u32(tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE]))
Emmanuel Grumbacha1022922014-05-12 11:36:41 +03003548 return iwl_mvm_enable_beacon_filter(mvm, vif, 0);
3549 return iwl_mvm_disable_beacon_filter(mvm, vif, 0);
David Spinadel507cadf2013-07-31 18:07:21 +03003550 }
3551
3552 return -EOPNOTSUPP;
3553}
3554
3555static int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw *hw,
3556 struct ieee80211_vif *vif,
3557 void *data, int len)
3558{
3559 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3560 int err;
3561
3562 mutex_lock(&mvm->mutex);
3563 err = __iwl_mvm_mac_testmode_cmd(mvm, vif, data, len);
3564 mutex_unlock(&mvm->mutex);
3565
3566 return err;
3567}
3568#endif
3569
Luciano Coelho622e3f92014-11-10 11:10:17 +02003570static void iwl_mvm_channel_switch(struct ieee80211_hw *hw,
3571 struct ieee80211_vif *vif,
3572 struct ieee80211_channel_switch *chsw)
3573{
3574 /* By implementing this operation, we prevent mac80211 from
3575 * starting its own channel switch timer, so that we can call
3576 * ieee80211_chswitch_done() ourselves at the right time
3577 * (which is when the absence time event starts).
3578 */
3579
3580 IWL_DEBUG_MAC80211(IWL_MAC80211_GET_MVM(hw),
3581 "dummy channel switch op\n");
3582}
3583
Luciano Coelhof0289052014-11-10 11:10:06 +02003584static int iwl_mvm_pre_channel_switch(struct ieee80211_hw *hw,
3585 struct ieee80211_vif *vif,
3586 struct ieee80211_channel_switch *chsw)
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003587{
3588 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
Andrei Otcheretianski664322f2014-06-05 16:40:36 +03003589 struct ieee80211_vif *csa_vif;
Luciano Coelhof6c34822014-11-10 11:10:12 +02003590 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
Luciano Coelhodc88b4b2014-11-10 11:10:14 +02003591 u32 apply_time;
Luciano Coelhof0289052014-11-10 11:10:06 +02003592 int ret;
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003593
3594 mutex_lock(&mvm->mutex);
Andrei Otcheretianski664322f2014-06-05 16:40:36 +03003595
Johannes Berg81d62d52015-03-10 14:44:00 +01003596 mvmvif->csa_failed = false;
3597
Luciano Coelho6b20d772014-11-10 11:10:07 +02003598 IWL_DEBUG_MAC80211(mvm, "pre CSA to freq %d\n",
Luciano Coelhof0289052014-11-10 11:10:06 +02003599 chsw->chandef.center_freq1);
Luciano Coelho6b20d772014-11-10 11:10:07 +02003600
Johannes Berg21023b12015-03-31 08:58:16 +02003601 iwl_fw_dbg_trigger_simple_stop(mvm, vif, FW_DBG_TRIGGER_CHANNEL_SWITCH);
Emmanuel Grumbachf35d9c52015-02-10 10:49:51 +02003602
Luciano Coelho6b20d772014-11-10 11:10:07 +02003603 switch (vif->type) {
3604 case NL80211_IFTYPE_AP:
3605 csa_vif =
3606 rcu_dereference_protected(mvm->csa_vif,
3607 lockdep_is_held(&mvm->mutex));
3608 if (WARN_ONCE(csa_vif && csa_vif->csa_active,
3609 "Another CSA is already in progress")) {
3610 ret = -EBUSY;
3611 goto out_unlock;
3612 }
3613
3614 rcu_assign_pointer(mvm->csa_vif, vif);
Andrei Otcheretianski7ef0aab2014-11-10 11:10:11 +02003615
Andrei Otcheretianski7ef0aab2014-11-10 11:10:11 +02003616 if (WARN_ONCE(mvmvif->csa_countdown,
3617 "Previous CSA countdown didn't complete")) {
3618 ret = -EBUSY;
3619 goto out_unlock;
3620 }
3621
Luciano Coelho6b20d772014-11-10 11:10:07 +02003622 break;
Luciano Coelhodc88b4b2014-11-10 11:10:14 +02003623 case NL80211_IFTYPE_STATION:
Luciano Coelho4500e132014-11-10 11:10:15 +02003624 /* Schedule the time event to a bit before beacon 1,
3625 * to make sure we're in the new channel when the
3626 * GO/AP arrives.
3627 */
3628 apply_time = chsw->device_timestamp +
3629 ((vif->bss_conf.beacon_int * (chsw->count - 1) -
3630 IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT) * 1024);
Luciano Coelhodc88b4b2014-11-10 11:10:14 +02003631
3632 if (chsw->block_tx)
3633 iwl_mvm_csa_client_absent(mvm, vif);
3634
Luciano Coelho4500e132014-11-10 11:10:15 +02003635 iwl_mvm_schedule_csa_period(mvm, vif, vif->bss_conf.beacon_int,
Luciano Coelhodc88b4b2014-11-10 11:10:14 +02003636 apply_time);
Luciano Coelhoc6e0a3e02014-11-10 11:10:18 +02003637 if (mvmvif->bf_data.bf_enabled) {
3638 ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
3639 if (ret)
3640 goto out_unlock;
3641 }
3642
Luciano Coelhodc88b4b2014-11-10 11:10:14 +02003643 break;
Luciano Coelho6b20d772014-11-10 11:10:07 +02003644 default:
3645 break;
3646 }
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003647
Luciano Coelhof6c34822014-11-10 11:10:12 +02003648 mvmvif->ps_disabled = true;
3649
3650 ret = iwl_mvm_power_update_ps(mvm);
3651 if (ret)
3652 goto out_unlock;
Luciano Coelhof0289052014-11-10 11:10:06 +02003653
Arik Nemtsove198f5e2014-09-14 19:13:54 +03003654 /* we won't be on this channel any longer */
3655 iwl_mvm_teardown_tdls_peers(mvm);
3656
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003657out_unlock:
3658 mutex_unlock(&mvm->mutex);
Luciano Coelhof0289052014-11-10 11:10:06 +02003659
3660 return ret;
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02003661}
3662
Luciano Coelhof6c34822014-11-10 11:10:12 +02003663static int iwl_mvm_post_channel_switch(struct ieee80211_hw *hw,
3664 struct ieee80211_vif *vif)
3665{
3666 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3667 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3668 int ret;
3669
3670 mutex_lock(&mvm->mutex);
3671
Johannes Berg81d62d52015-03-10 14:44:00 +01003672 if (mvmvif->csa_failed) {
3673 mvmvif->csa_failed = false;
3674 ret = -EIO;
3675 goto out_unlock;
3676 }
3677
Luciano Coelhoa57c6882014-11-10 11:10:16 +02003678 if (vif->type == NL80211_IFTYPE_STATION) {
3679 struct iwl_mvm_sta *mvmsta;
3680
3681 mvmsta = iwl_mvm_sta_from_staid_protected(mvm,
3682 mvmvif->ap_sta_id);
3683
3684 if (WARN_ON(!mvmsta)) {
3685 ret = -EIO;
3686 goto out_unlock;
3687 }
3688
3689 iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, false);
3690
3691 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
Luciano Coelhoc6e0a3e02014-11-10 11:10:18 +02003692
3693 ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
3694 if (ret)
3695 goto out_unlock;
Luciano Coelho686e7fe2014-11-10 11:10:21 +02003696
3697 iwl_mvm_stop_session_protection(mvm, vif);
Luciano Coelhoa57c6882014-11-10 11:10:16 +02003698 }
3699
Luciano Coelhof6c34822014-11-10 11:10:12 +02003700 mvmvif->ps_disabled = false;
3701
3702 ret = iwl_mvm_power_update_ps(mvm);
3703
Luciano Coelhoa57c6882014-11-10 11:10:16 +02003704out_unlock:
Luciano Coelhof6c34822014-11-10 11:10:12 +02003705 mutex_unlock(&mvm->mutex);
3706
3707 return ret;
3708}
3709
Emmanuel Grumbachc5b0e7c2014-03-24 12:08:53 +02003710static void iwl_mvm_mac_flush(struct ieee80211_hw *hw,
3711 struct ieee80211_vif *vif, u32 queues, bool drop)
3712{
3713 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3714 struct iwl_mvm_vif *mvmvif;
3715 struct iwl_mvm_sta *mvmsta;
Arik Nemtsova0f6bf22014-09-21 19:10:04 +03003716 struct ieee80211_sta *sta;
3717 int i;
3718 u32 msk = 0;
Emmanuel Grumbachc5b0e7c2014-03-24 12:08:53 +02003719
3720 if (!vif || vif->type != NL80211_IFTYPE_STATION)
3721 return;
3722
3723 mutex_lock(&mvm->mutex);
3724 mvmvif = iwl_mvm_vif_from_mac80211(vif);
Emmanuel Grumbachc5b0e7c2014-03-24 12:08:53 +02003725
Arik Nemtsova0f6bf22014-09-21 19:10:04 +03003726 /* flush the AP-station and all TDLS peers */
3727 for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
3728 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
3729 lockdep_is_held(&mvm->mutex));
3730 if (IS_ERR_OR_NULL(sta))
3731 continue;
3732
3733 mvmsta = iwl_mvm_sta_from_mac80211(sta);
3734 if (mvmsta->vif != vif)
3735 continue;
3736
3737 /* make sure only TDLS peers or the AP are flushed */
3738 WARN_ON(i != mvmvif->ap_sta_id && !sta->tdls);
3739
3740 msk |= mvmsta->tfd_queue_msk;
Johannes Berg480acbc2014-10-10 08:59:27 +02003741 }
Emmanuel Grumbachc5b0e7c2014-03-24 12:08:53 +02003742
Emmanuel Grumbach6d440b22015-01-20 09:25:19 +02003743 if (drop) {
Luca Coelho5888a402015-10-06 09:54:57 +03003744 if (iwl_mvm_flush_tx_path(mvm, msk, 0))
Emmanuel Grumbach6d440b22015-01-20 09:25:19 +02003745 IWL_ERR(mvm, "flush request fail\n");
3746 mutex_unlock(&mvm->mutex);
3747 } else {
3748 mutex_unlock(&mvm->mutex);
Johannes Berg480acbc2014-10-10 08:59:27 +02003749
Emmanuel Grumbach6d440b22015-01-20 09:25:19 +02003750 /* this can take a while, and we may need/want other operations
3751 * to succeed while doing this, so do it without the mutex held
3752 */
3753 iwl_trans_wait_tx_queue_empty(mvm->trans, msk);
3754 }
Emmanuel Grumbachc5b0e7c2014-03-24 12:08:53 +02003755}
3756
Johannes Berg91a8bcd2015-01-14 18:12:41 +01003757static int iwl_mvm_mac_get_survey(struct ieee80211_hw *hw, int idx,
3758 struct survey_info *survey)
3759{
3760 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3761 int ret;
3762
3763 memset(survey, 0, sizeof(*survey));
3764
3765 /* only support global statistics right now */
3766 if (idx != 0)
3767 return -ENOENT;
3768
Johannes Berg859d9142015-06-01 17:11:11 +02003769 if (fw_has_capa(&mvm->fw->ucode_capa,
Johannes Berg91a8bcd2015-01-14 18:12:41 +01003770 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
3771 return -ENOENT;
3772
3773 mutex_lock(&mvm->mutex);
3774
3775 if (mvm->ucode_loaded) {
Johannes Berg33cef922015-01-21 21:41:29 +01003776 ret = iwl_mvm_request_statistics(mvm, false);
Johannes Berg91a8bcd2015-01-14 18:12:41 +01003777 if (ret)
3778 goto out;
3779 }
3780
3781 survey->filled = SURVEY_INFO_TIME |
3782 SURVEY_INFO_TIME_RX |
3783 SURVEY_INFO_TIME_TX |
3784 SURVEY_INFO_TIME_SCAN;
3785 survey->time = mvm->accu_radio_stats.on_time_rf +
3786 mvm->radio_stats.on_time_rf;
3787 do_div(survey->time, USEC_PER_MSEC);
3788
3789 survey->time_rx = mvm->accu_radio_stats.rx_time +
3790 mvm->radio_stats.rx_time;
3791 do_div(survey->time_rx, USEC_PER_MSEC);
3792
3793 survey->time_tx = mvm->accu_radio_stats.tx_time +
3794 mvm->radio_stats.tx_time;
3795 do_div(survey->time_tx, USEC_PER_MSEC);
3796
3797 survey->time_scan = mvm->accu_radio_stats.on_time_scan +
3798 mvm->radio_stats.on_time_scan;
3799 do_div(survey->time_scan, USEC_PER_MSEC);
3800
Johannes Berg10a7c0282015-04-01 10:00:31 +02003801 ret = 0;
Johannes Berg91a8bcd2015-01-14 18:12:41 +01003802 out:
3803 mutex_unlock(&mvm->mutex);
3804 return ret;
3805}
3806
Johannes Berg33cef922015-01-21 21:41:29 +01003807static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw *hw,
3808 struct ieee80211_vif *vif,
3809 struct ieee80211_sta *sta,
3810 struct station_info *sinfo)
3811{
3812 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3813 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3814 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
3815
Johannes Berg859d9142015-06-01 17:11:11 +02003816 if (fw_has_capa(&mvm->fw->ucode_capa,
3817 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
Johannes Berg33cef922015-01-21 21:41:29 +01003818 return;
3819
3820 /* if beacon filtering isn't on mac80211 does it anyway */
3821 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER))
3822 return;
3823
3824 if (!vif->bss_conf.assoc)
3825 return;
3826
3827 mutex_lock(&mvm->mutex);
3828
3829 if (mvmvif->ap_sta_id != mvmsta->sta_id)
3830 goto unlock;
3831
3832 if (iwl_mvm_request_statistics(mvm, false))
3833 goto unlock;
3834
3835 sinfo->rx_beacon = mvmvif->beacon_stats.num_beacons +
3836 mvmvif->beacon_stats.accu_num_beacons;
3837 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_RX);
3838 if (mvmvif->beacon_stats.avg_signal) {
3839 /* firmware only reports a value after RXing a few beacons */
3840 sinfo->rx_beacon_signal_avg = mvmvif->beacon_stats.avg_signal;
3841 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
3842 }
3843 unlock:
3844 mutex_unlock(&mvm->mutex);
3845}
3846
Emmanuel Grumbach42032632015-04-15 12:43:46 +03003847static void iwl_mvm_event_mlme_callback(struct iwl_mvm *mvm,
3848 struct ieee80211_vif *vif,
3849 const struct ieee80211_event *event)
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003850{
Johannes Berg5d4f9292015-03-31 09:12:54 +02003851#define CHECK_MLME_TRIGGER(_mvm, _trig, _buf, _cnt, _fmt...) \
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003852 do { \
3853 if ((_cnt) && --(_cnt)) \
3854 break; \
Johannes Berg5d4f9292015-03-31 09:12:54 +02003855 iwl_mvm_fw_dbg_collect_trig(_mvm, _trig, _fmt);\
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003856 } while (0)
3857
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003858 struct iwl_fw_dbg_trigger_tlv *trig;
3859 struct iwl_fw_dbg_trigger_mlme *trig_mlme;
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003860
3861 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_MLME))
3862 return;
3863
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003864 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_MLME);
3865 trig_mlme = (void *)trig->data;
3866 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
3867 return;
3868
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02003869 if (event->u.mlme.data == ASSOC_EVENT) {
3870 if (event->u.mlme.status == MLME_DENIED)
3871 CHECK_MLME_TRIGGER(mvm, trig, buf,
3872 trig_mlme->stop_assoc_denied,
3873 "DENIED ASSOC: reason %d",
3874 event->u.mlme.reason);
3875 else if (event->u.mlme.status == MLME_TIMEOUT)
3876 CHECK_MLME_TRIGGER(mvm, trig, buf,
3877 trig_mlme->stop_assoc_timeout,
3878 "ASSOC TIMEOUT");
3879 } else if (event->u.mlme.data == AUTH_EVENT) {
3880 if (event->u.mlme.status == MLME_DENIED)
3881 CHECK_MLME_TRIGGER(mvm, trig, buf,
3882 trig_mlme->stop_auth_denied,
3883 "DENIED AUTH: reason %d",
3884 event->u.mlme.reason);
3885 else if (event->u.mlme.status == MLME_TIMEOUT)
3886 CHECK_MLME_TRIGGER(mvm, trig, buf,
3887 trig_mlme->stop_auth_timeout,
3888 "AUTH TIMEOUT");
3889 } else if (event->u.mlme.data == DEAUTH_RX_EVENT) {
3890 CHECK_MLME_TRIGGER(mvm, trig, buf,
3891 trig_mlme->stop_rx_deauth,
3892 "DEAUTH RX %d", event->u.mlme.reason);
3893 } else if (event->u.mlme.data == DEAUTH_TX_EVENT) {
3894 CHECK_MLME_TRIGGER(mvm, trig, buf,
3895 trig_mlme->stop_tx_deauth,
3896 "DEAUTH TX %d", event->u.mlme.reason);
3897 }
3898#undef CHECK_MLME_TRIGGER
3899}
3900
Emmanuel Grumbach42032632015-04-15 12:43:46 +03003901static void iwl_mvm_event_bar_rx_callback(struct iwl_mvm *mvm,
3902 struct ieee80211_vif *vif,
3903 const struct ieee80211_event *event)
3904{
3905 struct iwl_fw_dbg_trigger_tlv *trig;
3906 struct iwl_fw_dbg_trigger_ba *ba_trig;
3907
3908 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
3909 return;
3910
3911 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
3912 ba_trig = (void *)trig->data;
3913 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
3914 return;
3915
3916 if (!(le16_to_cpu(ba_trig->rx_bar) & BIT(event->u.ba.tid)))
3917 return;
3918
3919 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
3920 "BAR received from %pM, tid %d, ssn %d",
3921 event->u.ba.sta->addr, event->u.ba.tid,
3922 event->u.ba.ssn);
3923}
3924
3925static void
3926iwl_mvm_event_frame_timeout_callback(struct iwl_mvm *mvm,
3927 struct ieee80211_vif *vif,
3928 const struct ieee80211_event *event)
3929{
3930 struct iwl_fw_dbg_trigger_tlv *trig;
3931 struct iwl_fw_dbg_trigger_ba *ba_trig;
3932
3933 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
3934 return;
3935
3936 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
3937 ba_trig = (void *)trig->data;
3938 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
3939 return;
3940
3941 if (!(le16_to_cpu(ba_trig->frame_timeout) & BIT(event->u.ba.tid)))
3942 return;
3943
3944 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
3945 "Frame from %pM timed out, tid %d",
3946 event->u.ba.sta->addr, event->u.ba.tid);
3947}
3948
3949static void iwl_mvm_mac_event_callback(struct ieee80211_hw *hw,
3950 struct ieee80211_vif *vif,
3951 const struct ieee80211_event *event)
3952{
3953 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3954
3955 switch (event->type) {
3956 case MLME_EVENT:
3957 iwl_mvm_event_mlme_callback(mvm, vif, event);
3958 break;
3959 case BAR_RX_EVENT:
3960 iwl_mvm_event_bar_rx_callback(mvm, vif, event);
3961 break;
3962 case BA_FRAME_TIMEOUT:
3963 iwl_mvm_event_frame_timeout_callback(mvm, vif, event);
3964 break;
3965 default:
3966 break;
3967 }
3968}
3969
Johannes Berge5209262014-01-20 23:38:59 +01003970const struct ieee80211_ops iwl_mvm_hw_ops = {
Johannes Berg8ca151b2013-01-24 14:25:36 +01003971 .tx = iwl_mvm_mac_tx,
3972 .ampdu_action = iwl_mvm_mac_ampdu_action,
3973 .start = iwl_mvm_mac_start,
Eliad Pellercf2c92d2014-11-04 11:43:54 +02003974 .reconfig_complete = iwl_mvm_mac_reconfig_complete,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003975 .stop = iwl_mvm_mac_stop,
3976 .add_interface = iwl_mvm_mac_add_interface,
3977 .remove_interface = iwl_mvm_mac_remove_interface,
3978 .config = iwl_mvm_mac_config,
Eliad Pellere59647e2013-11-28 14:08:50 +02003979 .prepare_multicast = iwl_mvm_prepare_multicast,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003980 .configure_filter = iwl_mvm_configure_filter,
Andrei Otcheretianskieffd1922015-06-30 12:08:28 +03003981 .config_iface_filter = iwl_mvm_config_iface_filter,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003982 .bss_info_changed = iwl_mvm_bss_info_changed,
3983 .hw_scan = iwl_mvm_mac_hw_scan,
3984 .cancel_hw_scan = iwl_mvm_mac_cancel_hw_scan,
Johannes Berg1ddbbb02013-12-04 22:39:17 +01003985 .sta_pre_rcu_remove = iwl_mvm_sta_pre_rcu_remove,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003986 .sta_state = iwl_mvm_mac_sta_state,
3987 .sta_notify = iwl_mvm_mac_sta_notify,
3988 .allow_buffered_frames = iwl_mvm_mac_allow_buffered_frames,
Johannes Berg3e56ead2013-02-15 22:23:18 +01003989 .release_buffered_frames = iwl_mvm_mac_release_buffered_frames,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003990 .set_rts_threshold = iwl_mvm_mac_set_rts_threshold,
Lilach Edelstein1f3b0ff2013-10-06 13:03:32 +02003991 .sta_rc_update = iwl_mvm_sta_rc_update,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003992 .conf_tx = iwl_mvm_mac_conf_tx,
3993 .mgd_prepare_tx = iwl_mvm_mac_mgd_prepare_tx,
Arik Nemtsov07ecd892014-05-20 18:16:42 +03003994 .mgd_protect_tdls_discover = iwl_mvm_mac_mgd_protect_tdls_discover,
Emmanuel Grumbachc5b0e7c2014-03-24 12:08:53 +02003995 .flush = iwl_mvm_mac_flush,
David Spinadel35a000b2013-08-28 09:29:43 +03003996 .sched_scan_start = iwl_mvm_mac_sched_scan_start,
3997 .sched_scan_stop = iwl_mvm_mac_sched_scan_stop,
Johannes Berg8ca151b2013-01-24 14:25:36 +01003998 .set_key = iwl_mvm_mac_set_key,
3999 .update_tkip_key = iwl_mvm_mac_update_tkip_key,
4000 .remain_on_channel = iwl_mvm_roc,
4001 .cancel_remain_on_channel = iwl_mvm_cancel_roc,
Johannes Berg8ca151b2013-01-24 14:25:36 +01004002 .add_chanctx = iwl_mvm_add_chanctx,
4003 .remove_chanctx = iwl_mvm_remove_chanctx,
4004 .change_chanctx = iwl_mvm_change_chanctx,
4005 .assign_vif_chanctx = iwl_mvm_assign_vif_chanctx,
4006 .unassign_vif_chanctx = iwl_mvm_unassign_vif_chanctx,
Luciano Coelhob08c1d92014-05-20 23:31:05 +03004007 .switch_vif_chanctx = iwl_mvm_switch_vif_chanctx,
Johannes Berg8ca151b2013-01-24 14:25:36 +01004008
Johannes Berg5023d962013-07-31 14:07:43 +02004009 .start_ap = iwl_mvm_start_ap_ibss,
4010 .stop_ap = iwl_mvm_stop_ap_ibss,
4011 .join_ibss = iwl_mvm_start_ap_ibss,
4012 .leave_ibss = iwl_mvm_stop_ap_ibss,
Johannes Berg8ca151b2013-01-24 14:25:36 +01004013
4014 .set_tim = iwl_mvm_set_tim,
4015
Luciano Coelho622e3f92014-11-10 11:10:17 +02004016 .channel_switch = iwl_mvm_channel_switch,
Luciano Coelhof0289052014-11-10 11:10:06 +02004017 .pre_channel_switch = iwl_mvm_pre_channel_switch,
Luciano Coelhof6c34822014-11-10 11:10:12 +02004018 .post_channel_switch = iwl_mvm_post_channel_switch,
Andrei Otcheretianskibd3398e2013-10-22 05:01:12 +02004019
Arik Nemtsov1d3c3f62014-10-23 18:03:10 +03004020 .tdls_channel_switch = iwl_mvm_tdls_channel_switch,
4021 .tdls_cancel_channel_switch = iwl_mvm_tdls_cancel_channel_switch,
4022 .tdls_recv_channel_switch = iwl_mvm_tdls_recv_channel_switch,
4023
Emmanuel Grumbachd42f5352015-02-10 14:29:48 +02004024 .event_callback = iwl_mvm_mac_event_callback,
4025
David Spinadel507cadf2013-07-31 18:07:21 +03004026 CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd)
4027
Johannes Berg8ca151b2013-01-24 14:25:36 +01004028#ifdef CONFIG_PM_SLEEP
4029 /* look at d3.c */
4030 .suspend = iwl_mvm_suspend,
4031 .resume = iwl_mvm_resume,
4032 .set_wakeup = iwl_mvm_set_wakeup,
4033 .set_rekey_data = iwl_mvm_set_rekey_data,
4034#if IS_ENABLED(CONFIG_IPV6)
4035 .ipv6_addr_change = iwl_mvm_ipv6_addr_change,
4036#endif
4037 .set_default_unicast_key = iwl_mvm_set_default_unicast_key,
4038#endif
Johannes Berg91a8bcd2015-01-14 18:12:41 +01004039 .get_survey = iwl_mvm_mac_get_survey,
Johannes Berg33cef922015-01-21 21:41:29 +01004040 .sta_statistics = iwl_mvm_mac_sta_statistics,
Johannes Berg8ca151b2013-01-24 14:25:36 +01004041};