]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/wireless/iwlwifi/iwl-agn.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iwlagn: move ucode files out of the iwl_priv structure
[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / iwlwifi / iwl-agn.c
CommitLineData
b481de9c
ZY		 1/******************************************************************************
2 *
901069c7 3 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
b481de9c
ZY		 4 *
5 * Portions of this file are derived from the ipw3945 project, as well
6 * as portions of the ieee80211 subsystem header files.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of version 2 of the GNU General Public License as
10 * published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 *
21 * The full GNU General Public License is included in this distribution in the
22 * file called LICENSE.
23 *
24 * Contact Information:
759ef89f 25 * Intel Linux Wireless <ilw@linux.intel.com>
b481de9c
ZY		 26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *
28 *****************************************************************************/
b481de9c
ZY		 29#include <linux/kernel.h>
30#include <linux/module.h>
b481de9c 31#include <linux/init.h>
5a0e3ad6 32#include <linux/slab.h>
b481de9c 33#include <linux/delay.h>
d43c36dc 34#include <linux/sched.h>
b481de9c
ZY		 35#include <linux/skbuff.h>
36#include <linux/netdevice.h>
b481de9c 37#include <linux/firmware.h>
b481de9c
ZY		 38#include <linux/etherdevice.h>
39#include <linux/if_arp.h>
40
b481de9c
ZY		 41#include <net/mac80211.h>
42
43#include <asm/div64.h>
44
6bc913bd 45#include "iwl-eeprom.h"
3e0d4cb1 46#include "iwl-dev.h"
fee1247a 47#include "iwl-core.h"
3395f6e9 48#include "iwl-io.h"
0de76736 49#include "iwl-agn-calib.h"
a1175124 50#include "iwl-agn.h"
48f20d35 51#include "iwl-shared.h"
d5934110 52#include "iwl-bus.h"
c85eb619 53#include "iwl-trans.h"
416e1438 54
b481de9c
ZY		 55/******************************************************************************
56 *
57 * module boiler plate
58 *
59 ******************************************************************************/
60
b481de9c
ZY		 61/*
62 * module name, copyright, version, etc.
b481de9c 63 */
d783b061 64#define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
b481de9c 65
0a6857e7 66#ifdef CONFIG_IWLWIFI_DEBUG
b481de9c
ZY		 67#define VD "d"
68#else
69#define VD
70#endif
71
81963d68 72#define DRV_VERSION IWLWIFI_VERSION VD
b481de9c 73
b481de9c
ZY		 74
75MODULE_DESCRIPTION(DRV_DESCRIPTION);
76MODULE_VERSION(DRV_VERSION);
a7b75207 77MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
b481de9c 78MODULE_LICENSE("GPL");
3c607d27 79MODULE_ALIAS("iwlagn");
b481de9c 80
5b9f8cd3 81void iwl_update_chain_flags(struct iwl_priv *priv)
5da4b55f 82{
246ed355 83 struct iwl_rxon_context *ctx;
5da4b55f 84
e3f10cea
WYG		 85 for_each_context(priv, ctx) {
86 iwlagn_set_rxon_chain(priv, ctx);
87 if (ctx->active.rx_chain != ctx->staging.rx_chain)
88 iwlagn_commit_rxon(priv, ctx);
246ed355 89 }
5da4b55f
MA		 90}
91
47ff65c4
DH		 92/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
93static void iwl_set_beacon_tim(struct iwl_priv *priv,
77834543
JB		 94 struct iwl_tx_beacon_cmd *tx_beacon_cmd,
95 u8 *beacon, u32 frame_size)
47ff65c4
DH		 96{
97 u16 tim_idx;
98 struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
99
100 /*
101 * The index is relative to frame start but we start looking at the
102 * variable-length part of the beacon.
103 */
104 tim_idx = mgmt->u.beacon.variable - beacon;
105
106 /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
107 while ((tim_idx < (frame_size - 2)) &&
108 (beacon[tim_idx] != WLAN_EID_TIM))
109 tim_idx += beacon[tim_idx+1] + 2;
110
111 /* If TIM field was found, set variables */
112 if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
113 tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
114 tx_beacon_cmd->tim_size = beacon[tim_idx+1];
115 } else
116 IWL_WARN(priv, "Unable to find TIM Element in beacon\n");
117}
118
8a98d49e 119int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
4bf64efd
TW		 120{
121 struct iwl_tx_beacon_cmd *tx_beacon_cmd;
8a98d49e
JB		 122 struct iwl_host_cmd cmd = {
123 .id = REPLY_TX_BEACON,
e419d62d 124 .flags = CMD_SYNC,
8a98d49e 125 };
0b5b3ff1 126 struct ieee80211_tx_info *info;
47ff65c4
DH		 127 u32 frame_size;
128 u32 rate_flags;
129 u32 rate;
8a98d49e 130
47ff65c4
DH		 131 /*
132 * We have to set up the TX command, the TX Beacon command, and the
133 * beacon contents.
134 */
4bf64efd 135
6ac2f839 136 lockdep_assert_held(&priv->shrd->mutex);
76d04815
JB		 137
138 if (!priv->beacon_ctx) {
139 IWL_ERR(priv, "trying to build beacon w/o beacon context!\n");
950094cb 140 return 0;
76d04815
JB		 141 }
142
8a98d49e
JB		 143 if (WARN_ON(!priv->beacon_skb))
144 return -EINVAL;
145
4ce7cc2b
JB		 146 /* Allocate beacon command */
147 if (!priv->beacon_cmd)
148 priv->beacon_cmd = kzalloc(sizeof(*tx_beacon_cmd), GFP_KERNEL);
149 tx_beacon_cmd = priv->beacon_cmd;
8a98d49e
JB		 150 if (!tx_beacon_cmd)
151 return -ENOMEM;
152
153 frame_size = priv->beacon_skb->len;
4bf64efd 154
47ff65c4 155 /* Set up TX command fields */
4bf64efd 156 tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
76d04815 157 tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
47ff65c4
DH		 158 tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
159 tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
160 TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK;
4bf64efd 161
47ff65c4 162 /* Set up TX beacon command fields */
4ce7cc2b 163 iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data,
77834543 164 frame_size);
4bf64efd 165
47ff65c4 166 /* Set up packet rate and flags */
0b5b3ff1
JB		 167 info = IEEE80211_SKB_CB(priv->beacon_skb);
168
169 /*
170 * Let's set up the rate at least somewhat correctly;
171 * it will currently not actually be used by the uCode,
172 * it uses the broadcast station's rate instead.
173 */
174 if (info->control.rates[0].idx < 0 ||
175 info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
176 rate = 0;
177 else
178 rate = info->control.rates[0].idx;
179
0e1654fa 180 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
d6189124 181 hw_params(priv).valid_tx_ant);
47ff65c4 182 rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
0b5b3ff1
JB		 183
184 /* In mac80211, rates for 5 GHz start at 0 */
185 if (info->band == IEEE80211_BAND_5GHZ)
186 rate += IWL_FIRST_OFDM_RATE;
187 else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE)
47ff65c4 188 rate_flags |= RATE_MCS_CCK_MSK;
0b5b3ff1
JB		 189
190 tx_beacon_cmd->tx.rate_n_flags =
191 iwl_hw_set_rate_n_flags(rate, rate_flags);
4bf64efd 192
8a98d49e 193 /* Submit command */
4ce7cc2b 194 cmd.len[0] = sizeof(*tx_beacon_cmd);
3fa50738 195 cmd.data[0] = tx_beacon_cmd;
4ce7cc2b
JB		 196 cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
197 cmd.len[1] = frame_size;
198 cmd.data[1] = priv->beacon_skb->data;
199 cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
7aaa1d79 200
e6bb4c9c 201 return iwl_trans_send_cmd(trans(priv), &cmd);
a8e74e27
SO		 202}
203
5b9f8cd3 204static void iwl_bg_beacon_update(struct work_struct *work)
b481de9c 205{
c79dd5b5
TW		 206 struct iwl_priv *priv =
207 container_of(work, struct iwl_priv, beacon_update);
b481de9c
ZY		 208 struct sk_buff *beacon;
209
6ac2f839 210 mutex_lock(&priv->shrd->mutex);
76d04815
JB		 211 if (!priv->beacon_ctx) {
212 IWL_ERR(priv, "updating beacon w/o beacon context!\n");
213 goto out;
214 }
b481de9c 215
60744f62
JB		 216 if (priv->beacon_ctx->vif->type != NL80211_IFTYPE_AP) {
217 /*
218 * The ucode will send beacon notifications even in
219 * IBSS mode, but we don't want to process them. But
220 * we need to defer the type check to here due to
221 * requiring locking around the beacon_ctx access.
222 */
223 goto out;
224 }
225
76d04815
JB		 226 /* Pull updated AP beacon from mac80211. will fail if not in AP mode */
227 beacon = ieee80211_beacon_get(priv->hw, priv->beacon_ctx->vif);
b481de9c 228 if (!beacon) {
77834543 229 IWL_ERR(priv, "update beacon failed -- keeping old\n");
76d04815 230 goto out;
b481de9c
ZY		 231 }
232
b481de9c 233 /* new beacon skb is allocated every time; dispose previous.*/
77834543 234 dev_kfree_skb(priv->beacon_skb);
b481de9c 235
12e934dc 236 priv->beacon_skb = beacon;
b481de9c 237
2295c66b 238 iwlagn_send_beacon_cmd(priv);
76d04815 239 out:
6ac2f839 240 mutex_unlock(&priv->shrd->mutex);
b481de9c
ZY		 241}
242
fbba9410
WYG		 243static void iwl_bg_bt_runtime_config(struct work_struct *work)
244{
245 struct iwl_priv *priv =
246 container_of(work, struct iwl_priv, bt_runtime_config);
247
63013ae3 248 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
fbba9410
WYG		 249 return;
250
251 /* dont send host command if rf-kill is on */
845a9c0d 252 if (!iwl_is_ready_rf(priv->shrd))
fbba9410 253 return;
e55b517c 254 iwlagn_send_advance_bt_config(priv);
fbba9410
WYG		 255}
256
bee008b7
WYG		 257static void iwl_bg_bt_full_concurrency(struct work_struct *work)
258{
259 struct iwl_priv *priv =
260 container_of(work, struct iwl_priv, bt_full_concurrency);
246ed355 261 struct iwl_rxon_context *ctx;
bee008b7 262
6ac2f839 263 mutex_lock(&priv->shrd->mutex);
dc1a4068 264
63013ae3 265 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
dc1a4068 266 goto out;
bee008b7
WYG		 267
268 /* dont send host command if rf-kill is on */
845a9c0d 269 if (!iwl_is_ready_rf(priv->shrd))
dc1a4068 270 goto out;
bee008b7
WYG		 271
272 IWL_DEBUG_INFO(priv, "BT coex in %s mode\n",
273 priv->bt_full_concurrent ?
274 "full concurrency" : "3-wire");
275
276 /*
277 * LQ & RXON updated cmds must be sent before BT Config cmd
278 * to avoid 3-wire collisions
279 */
246ed355 280 for_each_context(priv, ctx) {
e3f10cea 281 iwlagn_set_rxon_chain(priv, ctx);
805a3b81 282 iwlagn_commit_rxon(priv, ctx);
246ed355 283 }
bee008b7 284
e55b517c 285 iwlagn_send_advance_bt_config(priv);
dc1a4068 286out:
6ac2f839 287 mutex_unlock(&priv->shrd->mutex);
bee008b7
WYG		 288}
289
4e39317d 290/**
5b9f8cd3 291 * iwl_bg_statistics_periodic - Timer callback to queue statistics
4e39317d
EG		 292 *
293 * This callback is provided in order to send a statistics request.
294 *
295 * This timer function is continually reset to execute within
296 * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
297 * was received. We need to ensure we receive the statistics in order
298 * to update the temperature used for calibrating the TXPOWER.
299 */
5b9f8cd3 300static void iwl_bg_statistics_periodic(unsigned long data)
4e39317d
EG		 301{
302 struct iwl_priv *priv = (struct iwl_priv *)data;
303
63013ae3 304 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
4e39317d
EG		 305 return;
306
61780ee3 307 /* dont send host command if rf-kill is on */
845a9c0d 308 if (!iwl_is_ready_rf(priv->shrd))
61780ee3
MA		 309 return;
310
ef8d5529 311 iwl_send_statistics_request(priv, CMD_ASYNC, false);
4e39317d
EG		 312}
313
a9e1cb6a
WYG		 314
315static void iwl_print_cont_event_trace(struct iwl_priv *priv, u32 base,
316 u32 start_idx, u32 num_events,
317 u32 mode)
318{
319 u32 i;
320 u32 ptr; /* SRAM byte address of log data */
321 u32 ev, time, data; /* event log data */
322 unsigned long reg_flags;
323
324 if (mode == 0)
325 ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32));
326 else
327 ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32));
328
329 /* Make sure device is powered up for SRAM reads */
83ed9015
EG		 330 spin_lock_irqsave(&bus(priv)->reg_lock, reg_flags);
331 if (iwl_grab_nic_access(bus(priv))) {
332 spin_unlock_irqrestore(&bus(priv)->reg_lock, reg_flags);
a9e1cb6a
WYG		 333 return;
334 }
335
336 /* Set starting address; reads will auto-increment */
83ed9015 337 iwl_write32(bus(priv), HBUS_TARG_MEM_RADDR, ptr);
a9e1cb6a
WYG		 338 rmb();
339
340 /*
341 * "time" is actually "data" for mode 0 (no timestamp).
342 * place event id # at far right for easier visual parsing.
343 */
344 for (i = 0; i < num_events; i++) {
83ed9015
EG		 345 ev = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT);
346 time = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT);
a9e1cb6a
WYG		 347 if (mode == 0) {
348 trace_iwlwifi_dev_ucode_cont_event(priv,
349 0, time, ev);
350 } else {
83ed9015 351 data = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT);
a9e1cb6a
WYG		 352 trace_iwlwifi_dev_ucode_cont_event(priv,
353 time, data, ev);
354 }
355 }
356 /* Allow device to power down */
83ed9015
EG		 357 iwl_release_nic_access(bus(priv));
358 spin_unlock_irqrestore(&bus(priv)->reg_lock, reg_flags);
a9e1cb6a
WYG		 359}
360
875295f1 361static void iwl_continuous_event_trace(struct iwl_priv *priv)
a9e1cb6a
WYG		 362{
363 u32 capacity; /* event log capacity in # entries */
364 u32 base; /* SRAM byte address of event log header */
365 u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
366 u32 num_wraps; /* # times uCode wrapped to top of log */
367 u32 next_entry; /* index of next entry to be written by uCode */
368
d7d5783c 369 base = priv->device_pointers.error_event_table;
4caab328 370 if (iwlagn_hw_valid_rtc_data_addr(base)) {
83ed9015
EG		 371 capacity = iwl_read_targ_mem(bus(priv), base);
372 num_wraps = iwl_read_targ_mem(bus(priv),
373 base + (2 * sizeof(u32)));
374 mode = iwl_read_targ_mem(bus(priv), base + (1 * sizeof(u32)));
375 next_entry = iwl_read_targ_mem(bus(priv),
376 base + (3 * sizeof(u32)));
a9e1cb6a
WYG		 377 } else
378 return;
379
380 if (num_wraps == priv->event_log.num_wraps) {
381 iwl_print_cont_event_trace(priv,
382 base, priv->event_log.next_entry,
383 next_entry - priv->event_log.next_entry,
384 mode);
385 priv->event_log.non_wraps_count++;
386 } else {
387 if ((num_wraps - priv->event_log.num_wraps) > 1)
388 priv->event_log.wraps_more_count++;
389 else
390 priv->event_log.wraps_once_count++;
391 trace_iwlwifi_dev_ucode_wrap_event(priv,
392 num_wraps - priv->event_log.num_wraps,
393 next_entry, priv->event_log.next_entry);
394 if (next_entry < priv->event_log.next_entry) {
395 iwl_print_cont_event_trace(priv, base,
396 priv->event_log.next_entry,
397 capacity - priv->event_log.next_entry,
398 mode);
399
400 iwl_print_cont_event_trace(priv, base, 0,
401 next_entry, mode);
402 } else {
403 iwl_print_cont_event_trace(priv, base,
404 next_entry, capacity - next_entry,
405 mode);
406
407 iwl_print_cont_event_trace(priv, base, 0,
408 next_entry, mode);
409 }
410 }
411 priv->event_log.num_wraps = num_wraps;
412 priv->event_log.next_entry = next_entry;
413}
414
415/**
416 * iwl_bg_ucode_trace - Timer callback to log ucode event
417 *
418 * The timer is continually set to execute every
419 * UCODE_TRACE_PERIOD milliseconds after the last timer expired
420 * this function is to perform continuous uCode event logging operation
421 * if enabled
422 */
423static void iwl_bg_ucode_trace(unsigned long data)
424{
425 struct iwl_priv *priv = (struct iwl_priv *)data;
426
63013ae3 427 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
a9e1cb6a
WYG		 428 return;
429
430 if (priv->event_log.ucode_trace) {
431 iwl_continuous_event_trace(priv);
432 /* Reschedule the timer to occur in UCODE_TRACE_PERIOD */
433 mod_timer(&priv->ucode_trace,
434 jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
435 }
436}
437
65550636
WYG		 438static void iwl_bg_tx_flush(struct work_struct *work)
439{
440 struct iwl_priv *priv =
441 container_of(work, struct iwl_priv, tx_flush);
442
63013ae3 443 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
65550636
WYG		 444 return;
445
446 /* do nothing if rf-kill is on */
845a9c0d 447 if (!iwl_is_ready_rf(priv->shrd))
65550636
WYG		 448 return;
449
c68744fb
WYG		 450 IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
451 iwlagn_dev_txfifo_flush(priv, IWL_DROP_ALL);
65550636
WYG		 452}
453
4d2a5d0e
JB		 454static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags)
455{
4d2a5d0e
JB		 456 int i;
457
458 /*
459 * The default context is always valid,
460 * the PAN context depends on uCode.
461 */
7a10e3e4 462 priv->shrd->valid_contexts = BIT(IWL_RXON_CTX_BSS);
4d2a5d0e 463 if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN)
7a10e3e4 464 priv->shrd->valid_contexts |= BIT(IWL_RXON_CTX_PAN);
4d2a5d0e
JB		 465
466 for (i = 0; i < NUM_IWL_RXON_CTX; i++)
467 priv->contexts[i].ctxid = i;
468
469 priv->contexts[IWL_RXON_CTX_BSS].always_active = true;
470 priv->contexts[IWL_RXON_CTX_BSS].is_active = true;
471 priv->contexts[IWL_RXON_CTX_BSS].rxon_cmd = REPLY_RXON;
472 priv->contexts[IWL_RXON_CTX_BSS].rxon_timing_cmd = REPLY_RXON_TIMING;
473 priv->contexts[IWL_RXON_CTX_BSS].rxon_assoc_cmd = REPLY_RXON_ASSOC;
474 priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM;
475 priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID;
476 priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY;
4d2a5d0e
JB		 477 priv->contexts[IWL_RXON_CTX_BSS].exclusive_interface_modes =
478 BIT(NL80211_IFTYPE_ADHOC);
479 priv->contexts[IWL_RXON_CTX_BSS].interface_modes =
480 BIT(NL80211_IFTYPE_STATION);
481 priv->contexts[IWL_RXON_CTX_BSS].ap_devtype = RXON_DEV_TYPE_AP;
482 priv->contexts[IWL_RXON_CTX_BSS].ibss_devtype = RXON_DEV_TYPE_IBSS;
483 priv->contexts[IWL_RXON_CTX_BSS].station_devtype = RXON_DEV_TYPE_ESS;
484 priv->contexts[IWL_RXON_CTX_BSS].unused_devtype = RXON_DEV_TYPE_ESS;
485
486 priv->contexts[IWL_RXON_CTX_PAN].rxon_cmd = REPLY_WIPAN_RXON;
487 priv->contexts[IWL_RXON_CTX_PAN].rxon_timing_cmd =
488 REPLY_WIPAN_RXON_TIMING;
489 priv->contexts[IWL_RXON_CTX_PAN].rxon_assoc_cmd =
490 REPLY_WIPAN_RXON_ASSOC;
491 priv->contexts[IWL_RXON_CTX_PAN].qos_cmd = REPLY_WIPAN_QOS_PARAM;
492 priv->contexts[IWL_RXON_CTX_PAN].ap_sta_id = IWL_AP_ID_PAN;
493 priv->contexts[IWL_RXON_CTX_PAN].wep_key_cmd = REPLY_WIPAN_WEPKEY;
494 priv->contexts[IWL_RXON_CTX_PAN].bcast_sta_id = IWLAGN_PAN_BCAST_ID;
495 priv->contexts[IWL_RXON_CTX_PAN].station_flags = STA_FLG_PAN_STATION;
4d2a5d0e
JB		 496 priv->contexts[IWL_RXON_CTX_PAN].interface_modes =
497 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
c6baf7fb
JB		 498
499 if (ucode_flags & IWL_UCODE_TLV_FLAGS_P2P)
500 priv->contexts[IWL_RXON_CTX_PAN].interface_modes |=
501 BIT(NL80211_IFTYPE_P2P_CLIENT) |
502 BIT(NL80211_IFTYPE_P2P_GO);
503
4d2a5d0e
JB		 504 priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;
505 priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;
506 priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
507
508 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
509}
510
511
dd7a2509
JB		 512struct iwlagn_ucode_capabilities {
513 u32 max_probe_length;
6a822d06 514 u32 standard_phy_calibration_size;
3997ff39 515 u32 flags;
dd7a2509 516};
edcdf8b2 517
b08dfd04 518static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
ade4c649 519static int iwlagn_mac_setup_register(struct iwl_priv *priv,
dd7a2509 520 struct iwlagn_ucode_capabilities *capa);
b08dfd04 521
39396085
JS		 522#define UCODE_EXPERIMENTAL_INDEX 100
523#define UCODE_EXPERIMENTAL_TAG "exp"
524
b08dfd04
JB		 525static int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first)
526{
527 const char *name_pre = priv->cfg->fw_name_pre;
39396085 528 char tag[8];
b08dfd04 529
39396085
JS		 530 if (first) {
531#ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
532 priv->fw_index = UCODE_EXPERIMENTAL_INDEX;
533 strcpy(tag, UCODE_EXPERIMENTAL_TAG);
534 } else if (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
535#endif
b08dfd04 536 priv->fw_index = priv->cfg->ucode_api_max;
39396085
JS		 537 sprintf(tag, "%d", priv->fw_index);
538 } else {
b08dfd04 539 priv->fw_index--;
39396085
JS		 540 sprintf(tag, "%d", priv->fw_index);
541 }
b08dfd04
JB		 542
543 if (priv->fw_index < priv->cfg->ucode_api_min) {
544 IWL_ERR(priv, "no suitable firmware found!\n");
545 return -ENOENT;
546 }
547
39396085 548 sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
b08dfd04 549
39396085
JS		 550 IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
551 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
552 ? "EXPERIMENTAL " : "",
b08dfd04
JB		 553 priv->firmware_name);
554
555 return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name,
26bfc0cf 556 bus(priv)->dev,
3599d39a 557 GFP_KERNEL, priv, iwl_ucode_callback);
b08dfd04
JB		 558}
559
0e9a44dc 560struct iwlagn_firmware_pieces {
c8ac61cf
JB		 561 const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data;
562 size_t inst_size, data_size, init_size, init_data_size,
563 wowlan_inst_size, wowlan_data_size;
0e9a44dc
JB		 564
565 u32 build;
b2e640d4
JB		 566
567 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
568 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
0e9a44dc
JB		 569};
570
571static int iwlagn_load_legacy_firmware(struct iwl_priv *priv,
572 const struct firmware *ucode_raw,
573 struct iwlagn_firmware_pieces *pieces)
574{
575 struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
576 u32 api_ver, hdr_size;
577 const u8 *src;
578
579 priv->ucode_ver = le32_to_cpu(ucode->ver);
580 api_ver = IWL_UCODE_API(priv->ucode_ver);
581
582 switch (api_ver) {
583 default:
f7d046f9
WYG		 584 hdr_size = 28;
585 if (ucode_raw->size < hdr_size) {
586 IWL_ERR(priv, "File size too small!\n");
587 return -EINVAL;
0e9a44dc 588 }
f7d046f9
WYG		 589 pieces->build = le32_to_cpu(ucode->u.v2.build);
590 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
591 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
592 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
593 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
f7d046f9
WYG		 594 src = ucode->u.v2.data;
595 break;
0e9a44dc
JB		 596 case 0:
597 case 1:
598 case 2:
599 hdr_size = 24;
600 if (ucode_raw->size < hdr_size) {
601 IWL_ERR(priv, "File size too small!\n");
602 return -EINVAL;
603 }
604 pieces->build = 0;
605 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
606 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
607 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
608 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
0e9a44dc
JB		 609 src = ucode->u.v1.data;
610 break;
611 }
612
613 /* Verify size of file vs. image size info in file's header */
614 if (ucode_raw->size != hdr_size + pieces->inst_size +
615 pieces->data_size + pieces->init_size +
1fc35276 616 pieces->init_data_size) {
0e9a44dc
JB		 617
618 IWL_ERR(priv,
619 "uCode file size %d does not match expected size\n",
620 (int)ucode_raw->size);
621 return -EINVAL;
622 }
623
624 pieces->inst = src;
625 src += pieces->inst_size;
626 pieces->data = src;
627 src += pieces->data_size;
628 pieces->init = src;
629 src += pieces->init_size;
630 pieces->init_data = src;
631 src += pieces->init_data_size;
0e9a44dc
JB		 632
633 return 0;
634}
635
dd7a2509
JB		 636static int iwlagn_load_firmware(struct iwl_priv *priv,
637 const struct firmware *ucode_raw,
638 struct iwlagn_firmware_pieces *pieces,
639 struct iwlagn_ucode_capabilities *capa)
640{
641 struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
642 struct iwl_ucode_tlv *tlv;
643 size_t len = ucode_raw->size;
644 const u8 *data;
48f20d35
EG		 645 int wanted_alternative = iwlagn_mod_params.wanted_ucode_alternative;
646 int tmp;
dd7a2509 647 u64 alternatives;
ad8d8333
WYG		 648 u32 tlv_len;
649 enum iwl_ucode_tlv_type tlv_type;
650 const u8 *tlv_data;
dd7a2509 651
ad8d8333
WYG		 652 if (len < sizeof(*ucode)) {
653 IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
dd7a2509 654 return -EINVAL;
ad8d8333 655 }
dd7a2509 656
ad8d8333
WYG		 657 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
658 IWL_ERR(priv, "invalid uCode magic: 0X%x\n",
659 le32_to_cpu(ucode->magic));
dd7a2509 660 return -EINVAL;
ad8d8333 661 }
dd7a2509
JB		 662
663 /*
664 * Check which alternatives are present, and "downgrade"
665 * when the chosen alternative is not present, warning
666 * the user when that happens. Some files may not have
667 * any alternatives, so don't warn in that case.
668 */
669 alternatives = le64_to_cpu(ucode->alternatives);
670 tmp = wanted_alternative;
671 if (wanted_alternative > 63)
672 wanted_alternative = 63;
673 while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
674 wanted_alternative--;
675 if (wanted_alternative && wanted_alternative != tmp)
676 IWL_WARN(priv,
677 "uCode alternative %d not available, choosing %d\n",
678 tmp, wanted_alternative);
679
680 priv->ucode_ver = le32_to_cpu(ucode->ver);
681 pieces->build = le32_to_cpu(ucode->build);
682 data = ucode->data;
683
684 len -= sizeof(*ucode);
685
704da534 686 while (len >= sizeof(*tlv)) {
dd7a2509 687 u16 tlv_alt;
dd7a2509
JB		 688
689 len -= sizeof(*tlv);
690 tlv = (void *)data;
691
692 tlv_len = le32_to_cpu(tlv->length);
693 tlv_type = le16_to_cpu(tlv->type);
694 tlv_alt = le16_to_cpu(tlv->alternative);
695 tlv_data = tlv->data;
696
ad8d8333
WYG		 697 if (len < tlv_len) {
698 IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
699 len, tlv_len);
dd7a2509 700 return -EINVAL;
ad8d8333 701 }
dd7a2509
JB		 702 len -= ALIGN(tlv_len, 4);
703 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
704
705 /*
706 * Alternative 0 is always valid.
707 *
708 * Skip alternative TLVs that are not selected.
709 */
710 if (tlv_alt != 0 && tlv_alt != wanted_alternative)
711 continue;
712
713 switch (tlv_type) {
714 case IWL_UCODE_TLV_INST:
715 pieces->inst = tlv_data;
716 pieces->inst_size = tlv_len;
717 break;
718 case IWL_UCODE_TLV_DATA:
719 pieces->data = tlv_data;
720 pieces->data_size = tlv_len;
721 break;
722 case IWL_UCODE_TLV_INIT:
723 pieces->init = tlv_data;
724 pieces->init_size = tlv_len;
725 break;
726 case IWL_UCODE_TLV_INIT_DATA:
727 pieces->init_data = tlv_data;
728 pieces->init_data_size = tlv_len;
729 break;
730 case IWL_UCODE_TLV_BOOT:
1fc35276 731 IWL_ERR(priv, "Found unexpected BOOT ucode\n");
dd7a2509
JB		 732 break;
733 case IWL_UCODE_TLV_PROBE_MAX_LEN:
704da534
JB		 734 if (tlv_len != sizeof(u32))
735 goto invalid_tlv_len;
736 capa->max_probe_length =
ad8d8333 737 le32_to_cpup((__le32 *)tlv_data);
dd7a2509 738 break;
ece9c4ee
JB		 739 case IWL_UCODE_TLV_PAN:
740 if (tlv_len)
741 goto invalid_tlv_len;
3997ff39
JB		 742 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
743 break;
744 case IWL_UCODE_TLV_FLAGS:
745 /* must be at least one u32 */
746 if (tlv_len < sizeof(u32))
747 goto invalid_tlv_len;
748 /* and a proper number of u32s */
749 if (tlv_len % sizeof(u32))
750 goto invalid_tlv_len;
751 /*
752 * This driver only reads the first u32 as
753 * right now no more features are defined,
754 * if that changes then either the driver
755 * will not work with the new firmware, or
756 * it'll not take advantage of new features.
757 */
758 capa->flags = le32_to_cpup((__le32 *)tlv_data);
ece9c4ee 759 break;
b2e640d4 760 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
704da534
JB		 761 if (tlv_len != sizeof(u32))
762 goto invalid_tlv_len;
763 pieces->init_evtlog_ptr =
ad8d8333 764 le32_to_cpup((__le32 *)tlv_data);
b2e640d4
JB		 765 break;
766 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
704da534
JB		 767 if (tlv_len != sizeof(u32))
768 goto invalid_tlv_len;
769 pieces->init_evtlog_size =
ad8d8333 770 le32_to_cpup((__le32 *)tlv_data);
b2e640d4
JB		 771 break;
772 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
704da534
JB		 773 if (tlv_len != sizeof(u32))
774 goto invalid_tlv_len;
775 pieces->init_errlog_ptr =
ad8d8333 776 le32_to_cpup((__le32 *)tlv_data);
b2e640d4
JB		 777 break;
778 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
704da534
JB		 779 if (tlv_len != sizeof(u32))
780 goto invalid_tlv_len;
781 pieces->inst_evtlog_ptr =
ad8d8333 782 le32_to_cpup((__le32 *)tlv_data);
b2e640d4
JB		 783 break;
784 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
704da534
JB		 785 if (tlv_len != sizeof(u32))
786 goto invalid_tlv_len;
787 pieces->inst_evtlog_size =
ad8d8333 788 le32_to_cpup((__le32 *)tlv_data);
b2e640d4
JB		 789 break;
790 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
704da534
JB		 791 if (tlv_len != sizeof(u32))
792 goto invalid_tlv_len;
793 pieces->inst_errlog_ptr =
ad8d8333 794 le32_to_cpup((__le32 *)tlv_data);
b2e640d4 795 break;
c8312fac
WYG		 796 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
797 if (tlv_len)
704da534
JB		 798 goto invalid_tlv_len;
799 priv->enhance_sensitivity_table = true;
c8312fac 800 break;
c8ac61cf
JB		 801 case IWL_UCODE_TLV_WOWLAN_INST:
802 pieces->wowlan_inst = tlv_data;
803 pieces->wowlan_inst_size = tlv_len;
804 break;
805 case IWL_UCODE_TLV_WOWLAN_DATA:
806 pieces->wowlan_data = tlv_data;
807 pieces->wowlan_data_size = tlv_len;
808 break;
6a822d06 809 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
704da534
JB		 810 if (tlv_len != sizeof(u32))
811 goto invalid_tlv_len;
812 capa->standard_phy_calibration_size =
6a822d06
WYG		 813 le32_to_cpup((__le32 *)tlv_data);
814 break;
dd7a2509 815 default:
6fc3ba99 816 IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type);
dd7a2509
JB		 817 break;
818 }
819 }
820
ad8d8333
WYG		 821 if (len) {
822 IWL_ERR(priv, "invalid TLV after parsing: %zd\n", len);
823 iwl_print_hex_dump(priv, IWL_DL_FW, (u8 *)data, len);
704da534 824 return -EINVAL;
ad8d8333 825 }
dd7a2509 826
704da534
JB		 827 return 0;
828
829 invalid_tlv_len:
830 IWL_ERR(priv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
831 iwl_print_hex_dump(priv, IWL_DL_FW, tlv_data, tlv_len);
832
833 return -EINVAL;
dd7a2509
JB		 834}
835
b481de9c 836/**
b08dfd04 837 * iwl_ucode_callback - callback when firmware was loaded
b481de9c 838 *
b08dfd04
JB		 839 * If loaded successfully, copies the firmware into buffers
840 * for the card to fetch (via DMA).
b481de9c 841 */
b08dfd04 842static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
b481de9c 843{
b08dfd04 844 struct iwl_priv *priv = context;
cc0f555d 845 struct iwl_ucode_header *ucode;
0e9a44dc
JB		 846 int err;
847 struct iwlagn_firmware_pieces pieces;
a0987a8d 848 const unsigned int api_max = priv->cfg->ucode_api_max;
5d7969bf 849 unsigned int api_ok = priv->cfg->ucode_api_ok;
a0987a8d 850 const unsigned int api_min = priv->cfg->ucode_api_min;
0e9a44dc 851 u32 api_ver;
3e4de761 852 char buildstr[25];
0e9a44dc 853 u32 build;
dd7a2509
JB		 854 struct iwlagn_ucode_capabilities ucode_capa = {
855 .max_probe_length = 200,
6a822d06 856 .standard_phy_calibration_size =
642454cc 857 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE,
dd7a2509 858 };
0e9a44dc 859
5d7969bf
JB		 860 if (!api_ok)
861 api_ok = api_max;
862
0e9a44dc 863 memset(&pieces, 0, sizeof(pieces));
b481de9c 864
b08dfd04 865 if (!ucode_raw) {
5d7969bf 866 if (priv->fw_index <= api_ok)
39396085
JS		 867 IWL_ERR(priv,
868 "request for firmware file '%s' failed.\n",
869 priv->firmware_name);
b08dfd04 870 goto try_again;
b481de9c
ZY		 871 }
872
b08dfd04
JB		 873 IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
874 priv->firmware_name, ucode_raw->size);
b481de9c 875
22adba2a
JB		 876 /* Make sure that we got at least the API version number */
877 if (ucode_raw->size < 4) {
15b1687c 878 IWL_ERR(priv, "File size way too small!\n");
b08dfd04 879 goto try_again;
b481de9c
ZY		 880 }
881
882 /* Data from ucode file: header followed by uCode images */
cc0f555d 883 ucode = (struct iwl_ucode_header *)ucode_raw->data;
b481de9c 884
0e9a44dc
JB		 885 if (ucode->ver)
886 err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
887 else
dd7a2509
JB		 888 err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
889 &ucode_capa);
22adba2a 890
0e9a44dc
JB		 891 if (err)
892 goto try_again;
b481de9c 893
a0987a8d 894 api_ver = IWL_UCODE_API(priv->ucode_ver);
0e9a44dc 895 build = pieces.build;
a0987a8d 896
0e9a44dc
JB		 897 /*
898 * api_ver should match the api version forming part of the
899 * firmware filename ... but we don't check for that and only rely
900 * on the API version read from firmware header from here on forward
901 */
65cccfb0
WYG		 902 /* no api version check required for experimental uCode */
903 if (priv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
904 if (api_ver < api_min || api_ver > api_max) {
905 IWL_ERR(priv,
906 "Driver unable to support your firmware API. "
907 "Driver supports v%u, firmware is v%u.\n",
908 api_max, api_ver);
909 goto try_again;
910 }
b08dfd04 911
5d7969bf
JB		 912 if (api_ver < api_ok) {
913 if (api_ok != api_max)
914 IWL_ERR(priv, "Firmware has old API version, "
915 "expected v%u through v%u, got v%u.\n",
916 api_ok, api_max, api_ver);
917 else
918 IWL_ERR(priv, "Firmware has old API version, "
919 "expected v%u, got v%u.\n",
920 api_max, api_ver);
921 IWL_ERR(priv, "New firmware can be obtained from "
922 "http://www.intellinuxwireless.org/.\n");
923 }
65cccfb0 924 }
a0987a8d 925
3e4de761 926 if (build)
39396085
JS		 927 sprintf(buildstr, " build %u%s", build,
928 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
929 ? " (EXP)" : "");
3e4de761
JB		 930 else
931 buildstr[0] = '\0';
932
933 IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u%s\n",
934 IWL_UCODE_MAJOR(priv->ucode_ver),
935 IWL_UCODE_MINOR(priv->ucode_ver),
936 IWL_UCODE_API(priv->ucode_ver),
937 IWL_UCODE_SERIAL(priv->ucode_ver),
938 buildstr);
a0987a8d 939
5ebeb5a6
RC		 940 snprintf(priv->hw->wiphy->fw_version,
941 sizeof(priv->hw->wiphy->fw_version),
3e4de761 942 "%u.%u.%u.%u%s",
5ebeb5a6
RC		 943 IWL_UCODE_MAJOR(priv->ucode_ver),
944 IWL_UCODE_MINOR(priv->ucode_ver),
945 IWL_UCODE_API(priv->ucode_ver),
3e4de761
JB		 946 IWL_UCODE_SERIAL(priv->ucode_ver),
947 buildstr);
b481de9c 948
b08dfd04
JB		 949 /*
950 * For any of the failures below (before allocating pci memory)
951 * we will try to load a version with a smaller API -- maybe the
952 * user just got a corrupted version of the latest API.
953 */
954
0e9a44dc
JB		 955 IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
956 priv->ucode_ver);
957 IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %Zd\n",
958 pieces.inst_size);
959 IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %Zd\n",
960 pieces.data_size);
961 IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %Zd\n",
962 pieces.init_size);
963 IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %Zd\n",
964 pieces.init_data_size);
b481de9c
ZY		 965
966 /* Verify that uCode images will fit in card's SRAM */
d6189124 967 if (pieces.inst_size > hw_params(priv).max_inst_size) {
0e9a44dc
JB		 968 IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n",
969 pieces.inst_size);
b08dfd04 970 goto try_again;
b481de9c
ZY		 971 }
972
d6189124 973 if (pieces.data_size > hw_params(priv).max_data_size) {
0e9a44dc
JB		 974 IWL_ERR(priv, "uCode data len %Zd too large to fit in\n",
975 pieces.data_size);
b08dfd04 976 goto try_again;
b481de9c 977 }
0e9a44dc 978
d6189124 979 if (pieces.init_size > hw_params(priv).max_inst_size) {
0e9a44dc
JB		 980 IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n",
981 pieces.init_size);
b08dfd04 982 goto try_again;
b481de9c 983 }
0e9a44dc 984
d6189124 985 if (pieces.init_data_size > hw_params(priv).max_data_size) {
0e9a44dc
JB		 986 IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n",
987 pieces.init_data_size);
b08dfd04 988 goto try_again;
b481de9c 989 }
0e9a44dc 990
b481de9c
ZY		 991 /* Allocate ucode buffers for card's bus-master loading ... */
992
993 /* Runtime instructions and 2 copies of data:
994 * 1) unmodified from disk
995 * 2) backup cache for save/restore during power-downs */
de7f5f92 996 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_rt.code,
dbf28e21
JB		 997 pieces.inst, pieces.inst_size))
998 goto err_pci_alloc;
de7f5f92 999 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_rt.data,
dbf28e21 1000 pieces.data, pieces.data_size))
1f304e4e
ZY		 1001 goto err_pci_alloc;
1002
b481de9c 1003 /* Initialization instructions and data */
0e9a44dc 1004 if (pieces.init_size && pieces.init_data_size) {
de7f5f92 1005 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_init.code,
dbf28e21
JB		 1006 pieces.init, pieces.init_size))
1007 goto err_pci_alloc;
de7f5f92 1008 if (iwl_alloc_fw_desc(bus(priv), &trans(priv)->ucode_init.data,
dbf28e21 1009 pieces.init_data, pieces.init_data_size))
90e759d1
TW		 1010 goto err_pci_alloc;
1011 }
b481de9c 1012
c8ac61cf
JB		 1013 /* WoWLAN instructions and data */
1014 if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
de7f5f92
DF		 1015 if (iwl_alloc_fw_desc(bus(priv),
1016 &trans(priv)->ucode_wowlan.code,
c8ac61cf
JB		 1017 pieces.wowlan_inst,
1018 pieces.wowlan_inst_size))
1019 goto err_pci_alloc;
de7f5f92
DF		 1020 if (iwl_alloc_fw_desc(bus(priv),
1021 &trans(priv)->ucode_wowlan.data,
c8ac61cf
JB		 1022 pieces.wowlan_data,
1023 pieces.wowlan_data_size))
1024 goto err_pci_alloc;
1025 }
1026
b2e640d4
JB		 1027 /* Now that we can no longer fail, copy information */
1028
1029 /*
1030 * The (size - 16) / 12 formula is based on the information recorded
1031 * for each event, which is of mode 1 (including timestamp) for all
1032 * new microcodes that include this information.
1033 */
898ed67b 1034 priv->init_evtlog_ptr = pieces.init_evtlog_ptr;
b2e640d4 1035 if (pieces.init_evtlog_size)
898ed67b 1036 priv->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
b2e640d4 1037 else
898ed67b 1038 priv->init_evtlog_size =
7cb1b088 1039 priv->cfg->base_params->max_event_log_size;
898ed67b
WYG		 1040 priv->init_errlog_ptr = pieces.init_errlog_ptr;
1041 priv->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
b2e640d4 1042 if (pieces.inst_evtlog_size)
898ed67b 1043 priv->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
b2e640d4 1044 else
898ed67b 1045 priv->inst_evtlog_size =
7cb1b088 1046 priv->cfg->base_params->max_event_log_size;
898ed67b 1047 priv->inst_errlog_ptr = pieces.inst_errlog_ptr;
b2e640d4 1048
d2690c0d
JB		 1049 priv->new_scan_threshold_behaviour =
1050 !!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
1051
4d2a5d0e
JB		 1052 if (!(priv->cfg->sku & EEPROM_SKU_CAP_IPAN_ENABLE))
1053 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
c10afb6e 1054
c6baf7fb
JB		 1055 /*
1056 * if not PAN, then don't support P2P -- might be a uCode
1057 * packaging bug or due to the eeprom check above
1058 */
1059 if (!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN))
1060 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_P2P;
1061
4d2a5d0e
JB		 1062 if (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN) {
1063 priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
cefeaa5f 1064 priv->shrd->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
4d2a5d0e
JB		 1065 } else {
1066 priv->sta_key_max_num = STA_KEY_MAX_NUM;
cefeaa5f 1067 priv->shrd->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
4d2a5d0e 1068 }
17445b8c 1069
6a822d06
WYG		 1070 /*
1071 * figure out the offset of chain noise reset and gain commands
1072 * base on the size of standard phy calibration commands table size
1073 */
1074 if (ucode_capa.standard_phy_calibration_size >
1075 IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1076 ucode_capa.standard_phy_calibration_size =
1077 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1078
898ed67b 1079 priv->phy_calib_chain_noise_reset_cmd =
6a822d06 1080 ucode_capa.standard_phy_calibration_size;
898ed67b 1081 priv->phy_calib_chain_noise_gain_cmd =
6a822d06
WYG		 1082 ucode_capa.standard_phy_calibration_size + 1;
1083
4d2a5d0e
JB		 1084 /* initialize all valid contexts */
1085 iwl_init_context(priv, ucode_capa.flags);
1086
b08dfd04
JB		 1087 /**************************************************
1088 * This is still part of probe() in a sense...
1089 *
1090 * 9. Setup and register with mac80211 and debugfs
1091 **************************************************/
ade4c649 1092 err = iwlagn_mac_setup_register(priv, &ucode_capa);
b08dfd04
JB		 1093 if (err)
1094 goto out_unbind;
1095
1096 err = iwl_dbgfs_register(priv, DRV_NAME);
1097 if (err)
1098 IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);
1099
b481de9c
ZY		 1100 /* We have our copies now, allow OS release its copies */
1101 release_firmware(ucode_raw);
898ed67b 1102 complete(&priv->firmware_loading_complete);
b08dfd04
JB		 1103 return;
1104
1105 try_again:
1106 /* try next, if any */
1107 if (iwl_request_firmware(priv, false))
1108 goto out_unbind;
1109 release_firmware(ucode_raw);
1110 return;
b481de9c
ZY		 1111
1112 err_pci_alloc:
15b1687c 1113 IWL_ERR(priv, "failed to allocate pci memory\n");
de7f5f92 1114 iwl_dealloc_ucode(trans(priv));
b08dfd04 1115 out_unbind:
898ed67b 1116 complete(&priv->firmware_loading_complete);
26bfc0cf 1117 device_release_driver(bus(priv)->dev);
b481de9c 1118 release_firmware(ucode_raw);
b481de9c
ZY		 1119}
1120
0975cc8f
WYG		 1121static void iwl_rf_kill_ct_config(struct iwl_priv *priv)
1122{
1123 struct iwl_ct_kill_config cmd;
1124 struct iwl_ct_kill_throttling_config adv_cmd;
1125 unsigned long flags;
1126 int ret = 0;
1127
10b15e6f 1128 spin_lock_irqsave(&priv->shrd->lock, flags);
83ed9015 1129 iwl_write32(bus(priv), CSR_UCODE_DRV_GP1_CLR,
0975cc8f 1130 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
10b15e6f 1131 spin_unlock_irqrestore(&priv->shrd->lock, flags);
0975cc8f
WYG		 1132 priv->thermal_throttle.ct_kill_toggle = false;
1133
7cb1b088 1134 if (priv->cfg->base_params->support_ct_kill_exit) {
0975cc8f 1135 adv_cmd.critical_temperature_enter =
d6189124 1136 cpu_to_le32(hw_params(priv).ct_kill_threshold);
0975cc8f 1137 adv_cmd.critical_temperature_exit =
d6189124 1138 cpu_to_le32(hw_params(priv).ct_kill_exit_threshold);
0975cc8f 1139
e6bb4c9c 1140 ret = iwl_trans_send_cmd_pdu(trans(priv),
e419d62d
EG		 1141 REPLY_CT_KILL_CONFIG_CMD,
1142 CMD_SYNC, sizeof(adv_cmd), &adv_cmd);
0975cc8f
WYG		 1143 if (ret)
1144 IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
1145 else
1146 IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
d6189124
EG		 1147 "succeeded, critical temperature enter is %d,"
1148 "exit is %d\n",
1149 hw_params(priv).ct_kill_threshold,
1150 hw_params(priv).ct_kill_exit_threshold);
0975cc8f
WYG		 1151 } else {
1152 cmd.critical_temperature_R =
d6189124 1153 cpu_to_le32(hw_params(priv).ct_kill_threshold);
0975cc8f 1154
e6bb4c9c 1155 ret = iwl_trans_send_cmd_pdu(trans(priv),
e419d62d
EG		 1156 REPLY_CT_KILL_CONFIG_CMD,
1157 CMD_SYNC, sizeof(cmd), &cmd);
0975cc8f
WYG		 1158 if (ret)
1159 IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
1160 else
1161 IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
d6189124
EG		 1162 "succeeded, "
1163 "critical temperature is %d\n",
1164 hw_params(priv).ct_kill_threshold);
0975cc8f
WYG		 1165 }
1166}
1167
6d6a1afd
SZ		 1168static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg)
1169{
1170 struct iwl_calib_cfg_cmd calib_cfg_cmd;
1171 struct iwl_host_cmd cmd = {
1172 .id = CALIBRATION_CFG_CMD,
3fa50738
JB		 1173 .len = { sizeof(struct iwl_calib_cfg_cmd), },
1174 .data = { &calib_cfg_cmd, },
6d6a1afd
SZ		 1175 };
1176
1177 memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
af4dc88c 1178 calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_RT_CFG_ALL;
7cb1b088 1179 calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
6d6a1afd 1180
e6bb4c9c 1181 return iwl_trans_send_cmd(trans(priv), &cmd);
6d6a1afd
SZ		 1182}
1183
1184
e505c433
WYG		 1185static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
1186{
1187 struct iwl_tx_ant_config_cmd tx_ant_cmd = {
1188 .valid = cpu_to_le32(valid_tx_ant),
1189 };
1190
1191 if (IWL_UCODE_API(priv->ucode_ver) > 1) {
1192 IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
e6bb4c9c 1193 return iwl_trans_send_cmd_pdu(trans(priv),
e505c433
WYG		 1194 TX_ANT_CONFIGURATION_CMD,
1195 CMD_SYNC,
1196 sizeof(struct iwl_tx_ant_config_cmd),
1197 &tx_ant_cmd);
1198 } else {
1199 IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
1200 return -EOPNOTSUPP;
1201 }
1202}
1203
b481de9c 1204/**
4a4a9e81 1205 * iwl_alive_start - called after REPLY_ALIVE notification received
b481de9c 1206 * from protocol/runtime uCode (initialization uCode's
4a4a9e81 1207 * Alive gets handled by iwl_init_alive_start()).
b481de9c 1208 */
4613e72d 1209int iwl_alive_start(struct iwl_priv *priv)
b481de9c 1210{
57aab75a 1211 int ret = 0;
246ed355 1212 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
b481de9c 1213
1a361cd8 1214 /*TODO: this should go to the transport layer */
6bb78847 1215 iwl_reset_ict(trans(priv));
b481de9c 1216
ca7966c8 1217 IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
6d6a1afd 1218
5b9f8cd3 1219 /* After the ALIVE response, we can send host commands to the uCode */
63013ae3 1220 set_bit(STATUS_ALIVE, &priv->shrd->status);
b481de9c 1221
22de94de
SG		 1222 /* Enable watchdog to monitor the driver tx queues */
1223 iwl_setup_watchdog(priv);
b74e31a9 1224
845a9c0d 1225 if (iwl_is_rfkill(priv->shrd))
ca7966c8 1226 return -ERFKILL;
b481de9c 1227
bc795df1 1228 /* download priority table before any calibration request */
7cb1b088
WYG		 1229 if (priv->cfg->bt_params &&
1230 priv->cfg->bt_params->advanced_bt_coexist) {
f7322f8f 1231 /* Configure Bluetooth device coexistence support */
207ecc5e
MV		 1232 if (priv->cfg->bt_params->bt_sco_disable)
1233 priv->bt_enable_pspoll = false;
1234 else
1235 priv->bt_enable_pspoll = true;
1236
f7322f8f
WYG		 1237 priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
1238 priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
1239 priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
e55b517c 1240 iwlagn_send_advance_bt_config(priv);
f7322f8f 1241 priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
207ecc5e
MV		 1242 priv->cur_rssi_ctx = NULL;
1243
a5901cbb 1244 iwlagn_send_prio_tbl(priv);
f7322f8f
WYG		 1245
1246 /* FIXME: w/a to force change uCode BT state machine */
ca7966c8
JB		 1247 ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
1248 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
1249 if (ret)
1250 return ret;
1251 ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
1252 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
1253 if (ret)
1254 return ret;
e55b517c
WYG		 1255 } else {
1256 /*
1257 * default is 2-wire BT coexexistence support
1258 */
1259 iwl_send_bt_config(priv);
f7322f8f 1260 }
e55b517c 1261
d6189124
EG		 1262 if (hw_params(priv).calib_rt_cfg)
1263 iwlagn_send_calib_cfg_rt(priv,
1264 hw_params(priv).calib_rt_cfg);
bc795df1 1265
36d6825b 1266 ieee80211_wake_queues(priv->hw);
b481de9c 1267
470ab2dd 1268 priv->active_rate = IWL_RATES_MASK;
b481de9c 1269
2f748dec 1270 /* Configure Tx antenna selection based on H/W config */
e3f10cea 1271 iwlagn_send_tx_ant_config(priv, priv->cfg->valid_tx_ant);
2f748dec 1272
57210f7c 1273 if (iwl_is_associated_ctx(ctx) && !priv->shrd->wowlan) {
c1adf9fb 1274 struct iwl_rxon_cmd *active_rxon =
246ed355 1275 (struct iwl_rxon_cmd *)&ctx->active;
019fb97d 1276 /* apply any changes in staging */
246ed355 1277 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
b481de9c
ZY		 1278 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
1279 } else {
d0fe478c 1280 struct iwl_rxon_context *tmp;
b481de9c 1281 /* Initialize our rx_config data */
d0fe478c
JB		 1282 for_each_context(priv, tmp)
1283 iwl_connection_init_rx_config(priv, tmp);
45823531 1284
e3f10cea 1285 iwlagn_set_rxon_chain(priv, ctx);
b481de9c
ZY		 1286 }
1287
57210f7c 1288 if (!priv->shrd->wowlan) {
c8ac61cf
JB		 1289 /* WoWLAN ucode will not reply in the same way, skip it */
1290 iwl_reset_run_time_calib(priv);
1291 }
4a4a9e81 1292
63013ae3 1293 set_bit(STATUS_READY, &priv->shrd->status);
9e2e7422 1294
b481de9c 1295 /* Configure the adapter for unassociated operation */
805a3b81 1296 ret = iwlagn_commit_rxon(priv, ctx);
ca7966c8
JB		 1297 if (ret)
1298 return ret;
b481de9c
ZY		 1299
1300 /* At this point, the NIC is initialized and operational */
47f4a587 1301 iwl_rf_kill_ct_config(priv);
5a66926a 1302
e1623446 1303 IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
c46fbefa 1304
ca7966c8 1305 return iwl_power_update_mode(priv, true);
b481de9c
ZY		 1306}
1307
4e39317d 1308static void iwl_cancel_deferred_work(struct iwl_priv *priv);
b481de9c 1309
5b9f8cd3 1310static void __iwl_down(struct iwl_priv *priv)
b481de9c 1311{
22dd2fd2 1312 int exit_pending;
b481de9c 1313
e1623446 1314 IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
b481de9c 1315
d745d472
SG		 1316 iwl_scan_cancel_timeout(priv, 200);
1317
c6baf7fb
JB		 1318 /*
1319 * If active, scanning won't cancel it, so say it expired.
1320 * No race since we hold the mutex here and a new one
1321 * can't come in at this time.
1322 */
1323 ieee80211_remain_on_channel_expired(priv->hw);
1324
63013ae3
EG		 1325 exit_pending =
1326 test_and_set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
b481de9c 1327
b62177a0
SG		 1328 /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
1329 * to prevent rearm timer */
22de94de 1330 del_timer_sync(&priv->watchdog);
b62177a0 1331
dcef732c 1332 iwl_clear_ucode_stations(priv, NULL);
a194e324 1333 iwl_dealloc_bcast_stations(priv);
db125c78 1334 iwl_clear_driver_stations(priv);
b481de9c 1335
a1174138 1336 /* reset BT coex data */
da5dbb97 1337 priv->bt_status = 0;
207ecc5e
MV		 1338 priv->cur_rssi_ctx = NULL;
1339 priv->bt_is_sco = 0;
7cb1b088
WYG		 1340 if (priv->cfg->bt_params)
1341 priv->bt_traffic_load =
1342 priv->cfg->bt_params->bt_init_traffic_load;
1343 else
1344 priv->bt_traffic_load = 0;
bee008b7
WYG		 1345 priv->bt_full_concurrent = false;
1346 priv->bt_ci_compliance = 0;
a1174138 1347
b481de9c
ZY		 1348 /* Wipe out the EXIT_PENDING status bit if we are not actually
1349 * exiting the module */
1350 if (!exit_pending)
63013ae3 1351 clear_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
b481de9c 1352
859cfb0a 1353 if (priv->mac80211_registered)
b481de9c
ZY		 1354 ieee80211_stop_queues(priv->hw);
1355
909e9b23
EG		 1356 iwl_trans_stop_device(trans(priv));
1357
1a10f433 1358 /* Clear out all status bits but a few that are stable across reset */
63013ae3
EG		 1359 priv->shrd->status &=
1360 test_bit(STATUS_RF_KILL_HW, &priv->shrd->status) <<
b481de9c 1361 STATUS_RF_KILL_HW |
63013ae3 1362 test_bit(STATUS_GEO_CONFIGURED, &priv->shrd->status) <<
9788864e 1363 STATUS_GEO_CONFIGURED |
63013ae3 1364 test_bit(STATUS_FW_ERROR, &priv->shrd->status) <<
052ec3f1 1365 STATUS_FW_ERROR |
63013ae3 1366 test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) <<
052ec3f1 1367 STATUS_EXIT_PENDING;
b481de9c 1368
77834543 1369 dev_kfree_skb(priv->beacon_skb);
12e934dc 1370 priv->beacon_skb = NULL;
b481de9c
ZY		 1371}
1372
5b9f8cd3 1373static void iwl_down(struct iwl_priv *priv)
b481de9c 1374{
6ac2f839 1375 mutex_lock(&priv->shrd->mutex);
5b9f8cd3 1376 __iwl_down(priv);
6ac2f839 1377 mutex_unlock(&priv->shrd->mutex);
b24d22b1 1378
4e39317d 1379 iwl_cancel_deferred_work(priv);
b481de9c
ZY		 1380}
1381
1382#define MAX_HW_RESTARTS 5
1383
5b9f8cd3 1384static int __iwl_up(struct iwl_priv *priv)
b481de9c 1385{
a194e324 1386 struct iwl_rxon_context *ctx;
57aab75a 1387 int ret;
b481de9c 1388
6ac2f839 1389 lockdep_assert_held(&priv->shrd->mutex);
ca7966c8 1390
63013ae3 1391 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) {
39aadf8c 1392 IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
b481de9c
ZY		 1393 return -EIO;
1394 }
1395
a194e324 1396 for_each_context(priv, ctx) {
a30e3112 1397 ret = iwlagn_alloc_bcast_station(priv, ctx);
a194e324
JB		 1398 if (ret) {
1399 iwl_dealloc_bcast_stations(priv);
1400 return ret;
1401 }
1402 }
2c810ccd 1403
ca7966c8
JB		 1404 ret = iwlagn_run_init_ucode(priv);
1405 if (ret) {
1406 IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
1407 goto error;
1408 }
b481de9c 1409
8929c24b 1410 ret = iwlagn_load_ucode_wait_alive(priv, IWL_UCODE_REGULAR);
ca7966c8
JB		 1411 if (ret) {
1412 IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
1413 goto error;
b481de9c
ZY		 1414 }
1415
ca7966c8
JB		 1416 ret = iwl_alive_start(priv);
1417 if (ret)
1418 goto error;
1419 return 0;
1420
1421 error:
63013ae3 1422 set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
5b9f8cd3 1423 __iwl_down(priv);
63013ae3 1424 clear_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
b481de9c 1425
ca7966c8
JB		 1426 IWL_ERR(priv, "Unable to initialize device.\n");
1427 return ret;
b481de9c
ZY		 1428}
1429
1430
1431/*****************************************************************************
1432 *
1433 * Workqueue callbacks
1434 *
1435 *****************************************************************************/
1436
16e727e8
EG		 1437static void iwl_bg_run_time_calib_work(struct work_struct *work)
1438{
1439 struct iwl_priv *priv = container_of(work, struct iwl_priv,
1440 run_time_calib_work);
1441
6ac2f839 1442 mutex_lock(&priv->shrd->mutex);
16e727e8 1443
63013ae3
EG		 1444 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) ||
1445 test_bit(STATUS_SCANNING, &priv->shrd->status)) {
6ac2f839 1446 mutex_unlock(&priv->shrd->mutex);
16e727e8
EG		 1447 return;
1448 }
1449
1450 if (priv->start_calib) {
0da0e5bf
JB		 1451 iwl_chain_noise_calibration(priv);
1452 iwl_sensitivity_calibration(priv);
16e727e8
EG		 1453 }
1454
6ac2f839 1455 mutex_unlock(&priv->shrd->mutex);
16e727e8
EG		 1456}
1457
e43e85c4
JB		 1458static void iwlagn_prepare_restart(struct iwl_priv *priv)
1459{
1460 struct iwl_rxon_context *ctx;
1461 bool bt_full_concurrent;
1462 u8 bt_ci_compliance;
1463 u8 bt_load;
1464 u8 bt_status;
207ecc5e 1465 bool bt_is_sco;
e43e85c4 1466
6ac2f839 1467 lockdep_assert_held(&priv->shrd->mutex);
e43e85c4
JB		 1468
1469 for_each_context(priv, ctx)
1470 ctx->vif = NULL;
1471 priv->is_open = 0;
1472
1473 /*
1474 * __iwl_down() will clear the BT status variables,
1475 * which is correct, but when we restart we really
1476 * want to keep them so restore them afterwards.
1477 *
1478 * The restart process will later pick them up and
1479 * re-configure the hw when we reconfigure the BT
1480 * command.
1481 */
1482 bt_full_concurrent = priv->bt_full_concurrent;
1483 bt_ci_compliance = priv->bt_ci_compliance;
1484 bt_load = priv->bt_traffic_load;
1485 bt_status = priv->bt_status;
207ecc5e 1486 bt_is_sco = priv->bt_is_sco;
e43e85c4
JB		 1487
1488 __iwl_down(priv);
1489
1490 priv->bt_full_concurrent = bt_full_concurrent;
1491 priv->bt_ci_compliance = bt_ci_compliance;
1492 priv->bt_traffic_load = bt_load;
1493 priv->bt_status = bt_status;
207ecc5e 1494 priv->bt_is_sco = bt_is_sco;
e43e85c4
JB		 1495}
1496
5b9f8cd3 1497static void iwl_bg_restart(struct work_struct *data)
b481de9c 1498{
c79dd5b5 1499 struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
b481de9c 1500
63013ae3 1501 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
b481de9c
ZY		 1502 return;
1503
63013ae3 1504 if (test_and_clear_bit(STATUS_FW_ERROR, &priv->shrd->status)) {
6ac2f839 1505 mutex_lock(&priv->shrd->mutex);
e43e85c4 1506 iwlagn_prepare_restart(priv);
6ac2f839 1507 mutex_unlock(&priv->shrd->mutex);
a1174138 1508 iwl_cancel_deferred_work(priv);
19cc1087
JB		 1509 ieee80211_restart_hw(priv->hw);
1510 } else {
ca7966c8 1511 WARN_ON(1);
19cc1087 1512 }
b481de9c
ZY		 1513}
1514
b481de9c
ZY		 1515/*****************************************************************************
1516 *
1517 * mac80211 entry point functions
1518 *
1519 *****************************************************************************/
1520
0fd09502
JB		 1521static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
1522 {
1523 .max = 1,
1524 .types = BIT(NL80211_IFTYPE_STATION),
1525 },
1526 {
1527 .max = 1,
1528 .types = BIT(NL80211_IFTYPE_AP),
1529 },
1530};
1531
1532static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
1533 {
1534 .max = 2,
1535 .types = BIT(NL80211_IFTYPE_STATION),
1536 },
1537};
1538
1539static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {
1540 {
1541 .max = 1,
1542 .types = BIT(NL80211_IFTYPE_STATION),
1543 },
1544 {
1545 .max = 1,
1546 .types = BIT(NL80211_IFTYPE_P2P_GO) |
1547 BIT(NL80211_IFTYPE_AP),
1548 },
1549};
1550
1551static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {
1552 {
1553 .max = 2,
1554 .types = BIT(NL80211_IFTYPE_STATION),
1555 },
1556 {
1557 .max = 1,
1558 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
1559 },
1560};
1561
1562static const struct ieee80211_iface_combination
1563iwlagn_iface_combinations_dualmode[] = {
1564 { .num_different_channels = 1,
1565 .max_interfaces = 2,
1566 .beacon_int_infra_match = true,
1567 .limits = iwlagn_sta_ap_limits,
1568 .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
1569 },
1570 { .num_different_channels = 1,
1571 .max_interfaces = 2,
1572 .limits = iwlagn_2sta_limits,
1573 .n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
1574 },
1575};
1576
1577static const struct ieee80211_iface_combination
1578iwlagn_iface_combinations_p2p[] = {
1579 { .num_different_channels = 1,
1580 .max_interfaces = 2,
1581 .beacon_int_infra_match = true,
1582 .limits = iwlagn_p2p_sta_go_limits,
1583 .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),
1584 },
1585 { .num_different_channels = 1,
1586 .max_interfaces = 2,
1587 .limits = iwlagn_p2p_2sta_limits,
1588 .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),
1589 },
1590};
1591
f0b6e2e8
RC		 1592/*
1593 * Not a mac80211 entry point function, but it fits in with all the
1594 * other mac80211 functions grouped here.
1595 */
ade4c649 1596static int iwlagn_mac_setup_register(struct iwl_priv *priv,
dd7a2509 1597 struct iwlagn_ucode_capabilities *capa)
f0b6e2e8
RC		 1598{
1599 int ret;
1600 struct ieee80211_hw *hw = priv->hw;
d0fe478c
JB		 1601 struct iwl_rxon_context *ctx;
1602
f0b6e2e8
RC		 1603 hw->rate_control_algorithm = "iwl-agn-rs";
1604
1605 /* Tell mac80211 our characteristics */
1606 hw->flags = IEEE80211_HW_SIGNAL_DBM |
f0b6e2e8 1607 IEEE80211_HW_AMPDU_AGGREGATION |
2491fa42 1608 IEEE80211_HW_NEED_DTIM_PERIOD |
6fb5511a
JB		 1609 IEEE80211_HW_SPECTRUM_MGMT |
1610 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
f0b6e2e8 1611
2249b011
DF		 1612 /*
1613 * Including the following line will crash some AP's. This
1614 * workaround removes the stimulus which causes the crash until
1615 * the AP software can be fixed.
9b768832 1616 hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2249b011 1617 */
9b768832 1618
23c0fcc6
WYG		 1619 hw->flags |= IEEE80211_HW_SUPPORTS_PS |
1620 IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
f0b6e2e8 1621
88950758 1622 if (priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE)
ba37a3d0
JB		 1623 hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
1624 IEEE80211_HW_SUPPORTS_STATIC_SMPS;
1625
3997ff39
JB		 1626 if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
1627 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
1628
8d9698b3 1629 hw->sta_data_size = sizeof(struct iwl_station_priv);
fd1af15d
JB		 1630 hw->vif_data_size = sizeof(struct iwl_vif_priv);
1631
d0fe478c
JB		 1632 for_each_context(priv, ctx) {
1633 hw->wiphy->interface_modes |= ctx->interface_modes;
1634 hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
1635 }
f0b6e2e8 1636
0fd09502
JB		 1637 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
1638
f35490f9 1639 if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
0fd09502
JB		 1640 hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
1641 hw->wiphy->n_iface_combinations =
1642 ARRAY_SIZE(iwlagn_iface_combinations_p2p);
f35490f9 1643 } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
0fd09502
JB		 1644 hw->wiphy->iface_combinations = iwlagn_iface_combinations_dualmode;
1645 hw->wiphy->n_iface_combinations =
1646 ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
1647 }
1648
9b9190d9
JB		 1649 hw->wiphy->max_remain_on_channel_duration = 1000;
1650
f6c8f152 1651 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
274102a8
JB		 1652 WIPHY_FLAG_DISABLE_BEACON_HINTS |
1653 WIPHY_FLAG_IBSS_RSN;
f0b6e2e8 1654
de7f5f92
DF		 1655 if (trans(priv)->ucode_wowlan.code.len &&
1656 device_can_wakeup(bus(priv)->dev)) {
c8ac61cf
JB		 1657 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
1658 WIPHY_WOWLAN_DISCONNECT |
1659 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
1660 WIPHY_WOWLAN_RFKILL_RELEASE;
1661 if (!iwlagn_mod_params.sw_crypto)
1662 hw->wiphy->wowlan.flags |=
1663 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
1664 WIPHY_WOWLAN_GTK_REKEY_FAILURE;
1665
1666 hw->wiphy->wowlan.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS;
1667 hw->wiphy->wowlan.pattern_min_len =
1668 IWLAGN_WOWLAN_MIN_PATTERN_LEN;
1669 hw->wiphy->wowlan.pattern_max_len =
1670 IWLAGN_WOWLAN_MAX_PATTERN_LEN;
1671 }
1672
0172b029
WYG		 1673 if (iwlagn_mod_params.power_save)
1674 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
1675 else
1676 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
f0b6e2e8 1677
1382c71c 1678 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
f0b6e2e8 1679 /* we create the 802.11 header and a zero-length SSID element */
dd7a2509 1680 hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
f0b6e2e8
RC		 1681
1682 /* Default value; 4 EDCA QOS priorities */
1683 hw->queues = 4;
1684
1685 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
1686
1687 if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
1688 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1689 &priv->bands[IEEE80211_BAND_2GHZ];
1690 if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
1691 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1692 &priv->bands[IEEE80211_BAND_5GHZ];
1693
5ed540ae
WYG		 1694 iwl_leds_init(priv);
1695
f0b6e2e8
RC		 1696 ret = ieee80211_register_hw(priv->hw);
1697 if (ret) {
1698 IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
1699 return ret;
1700 }
859cfb0a 1701 priv->mac80211_registered = 1;
f0b6e2e8
RC		 1702
1703 return 0;
1704}
1705
1706
2dedbf58 1707static int iwlagn_mac_start(struct ieee80211_hw *hw)
b481de9c 1708{
c79dd5b5 1709 struct iwl_priv *priv = hw->priv;
5a66926a 1710 int ret;
b481de9c 1711
e1623446 1712 IWL_DEBUG_MAC80211(priv, "enter\n");
b481de9c
ZY		 1713
1714 /* we should be verifying the device is ready to be opened */
6ac2f839 1715 mutex_lock(&priv->shrd->mutex);
5b9f8cd3 1716 ret = __iwl_up(priv);
6ac2f839 1717 mutex_unlock(&priv->shrd->mutex);
e655b9f0 1718 if (ret)
6cd0b1cb 1719 return ret;
e655b9f0 1720
e1623446 1721 IWL_DEBUG_INFO(priv, "Start UP work done.\n");
e655b9f0 1722
ca7966c8 1723 /* Now we should be done, and the READY bit should be set. */
63013ae3 1724 if (WARN_ON(!test_bit(STATUS_READY, &priv->shrd->status)))
ca7966c8 1725 ret = -EIO;
0a078ffa 1726
5ed540ae 1727 iwlagn_led_enable(priv);
e932a609 1728
0a078ffa 1729 priv->is_open = 1;
e1623446 1730 IWL_DEBUG_MAC80211(priv, "leave\n");
b481de9c
ZY		 1731 return 0;
1732}
1733
2dedbf58 1734static void iwlagn_mac_stop(struct ieee80211_hw *hw)
b481de9c 1735{
c79dd5b5 1736 struct iwl_priv *priv = hw->priv;
b481de9c 1737
e1623446 1738 IWL_DEBUG_MAC80211(priv, "enter\n");
948c171c 1739
19cc1087 1740 if (!priv->is_open)
e655b9f0 1741 return;
e655b9f0 1742
b481de9c 1743 priv->is_open = 0;
5a66926a 1744
5b9f8cd3 1745 iwl_down(priv);
5a66926a 1746
74e28e44 1747 flush_workqueue(priv->shrd->workqueue);
6cd0b1cb 1748
554d1d02
SG		 1749 /* User space software may expect getting rfkill changes
1750 * even if interface is down */
83ed9015 1751 iwl_write32(bus(priv), CSR_INT, 0xFFFFFFFF);
554d1d02 1752 iwl_enable_rfkill_int(priv);
948c171c 1753
e1623446 1754 IWL_DEBUG_MAC80211(priv, "leave\n");
b481de9c
ZY		 1755}
1756
c01a4047 1757#ifdef CONFIG_PM_SLEEP
c8ac61cf
JB		 1758static int iwlagn_send_patterns(struct iwl_priv *priv,
1759 struct cfg80211_wowlan *wowlan)
1760{
1761 struct iwlagn_wowlan_patterns_cmd *pattern_cmd;
1762 struct iwl_host_cmd cmd = {
1763 .id = REPLY_WOWLAN_PATTERNS,
1764 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
1765 .flags = CMD_SYNC,
1766 };
1767 int i, err;
1768
1769 if (!wowlan->n_patterns)
1770 return 0;
1771
1772 cmd.len[0] = sizeof(*pattern_cmd) +
1773 wowlan->n_patterns * sizeof(struct iwlagn_wowlan_pattern);
1774
1775 pattern_cmd = kmalloc(cmd.len[0], GFP_KERNEL);
1776 if (!pattern_cmd)
1777 return -ENOMEM;
1778
1779 pattern_cmd->n_patterns = cpu_to_le32(wowlan->n_patterns);
1780
1781 for (i = 0; i < wowlan->n_patterns; i++) {
1782 int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
1783
1784 memcpy(&pattern_cmd->patterns[i].mask,
1785 wowlan->patterns[i].mask, mask_len);
1786 memcpy(&pattern_cmd->patterns[i].pattern,
1787 wowlan->patterns[i].pattern,
1788 wowlan->patterns[i].pattern_len);
1789 pattern_cmd->patterns[i].mask_size = mask_len;
1790 pattern_cmd->patterns[i].pattern_size =
1791 wowlan->patterns[i].pattern_len;
1792 }
1793
1794 cmd.data[0] = pattern_cmd;
e6bb4c9c 1795 err = iwl_trans_send_cmd(trans(priv), &cmd);
c8ac61cf
JB		 1796 kfree(pattern_cmd);
1797 return err;
1798}
26293133 1799#endif
c8ac61cf
JB		 1800
1801static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw,
1802 struct ieee80211_vif *vif,
1803 struct cfg80211_gtk_rekey_data *data)
1804{
1805 struct iwl_priv *priv = hw->priv;
1806
1807 if (iwlagn_mod_params.sw_crypto)
1808 return;
1809
770c72c4 1810 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 1811 mutex_lock(&priv->shrd->mutex);
c8ac61cf
JB		 1812
1813 if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif)
1814 goto out;
1815
1816 memcpy(priv->kek, data->kek, NL80211_KEK_LEN);
1817 memcpy(priv->kck, data->kck, NL80211_KCK_LEN);
1818 priv->replay_ctr = cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
1819 priv->have_rekey_data = true;
1820
1821 out:
6ac2f839 1822 mutex_unlock(&priv->shrd->mutex);
770c72c4 1823 IWL_DEBUG_MAC80211(priv, "leave\n");
c8ac61cf
JB		 1824}
1825
1826struct wowlan_key_data {
1827 struct iwl_rxon_context *ctx;
1828 struct iwlagn_wowlan_rsc_tsc_params_cmd *rsc_tsc;
1829 struct iwlagn_wowlan_tkip_params_cmd *tkip;
1830 const u8 *bssid;
1831 bool error, use_rsc_tsc, use_tkip;
1832};
1833
c01a4047 1834#ifdef CONFIG_PM_SLEEP
c8ac61cf
JB		 1835static void iwlagn_convert_p1k(u16 *p1k, __le16 *out)
1836{
1837 int i;
1838
1839 for (i = 0; i < IWLAGN_P1K_SIZE; i++)
1840 out[i] = cpu_to_le16(p1k[i]);
1841}
1842
1843static void iwlagn_wowlan_program_keys(struct ieee80211_hw *hw,
1844 struct ieee80211_vif *vif,
1845 struct ieee80211_sta *sta,
1846 struct ieee80211_key_conf *key,
1847 void *_data)
1848{
1849 struct iwl_priv *priv = hw->priv;
1850 struct wowlan_key_data *data = _data;
1851 struct iwl_rxon_context *ctx = data->ctx;
1852 struct aes_sc *aes_sc, *aes_tx_sc = NULL;
1853 struct tkip_sc *tkip_sc, *tkip_tx_sc = NULL;
1854 struct iwlagn_p1k_cache *rx_p1ks;
1855 u8 *rx_mic_key;
1856 struct ieee80211_key_seq seq;
1857 u32 cur_rx_iv32 = 0;
1858 u16 p1k[IWLAGN_P1K_SIZE];
1859 int ret, i;
1860
6ac2f839 1861 mutex_lock(&priv->shrd->mutex);
c8ac61cf
JB		 1862
1863 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
1864 key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
1865 !sta && !ctx->key_mapping_keys)
1866 ret = iwl_set_default_wep_key(priv, ctx, key);
1867 else
1868 ret = iwl_set_dynamic_key(priv, ctx, key, sta);
1869
1870 if (ret) {
1871 IWL_ERR(priv, "Error setting key during suspend!\n");
1872 data->error = true;
1873 }
1874
1875 switch (key->cipher) {
1876 case WLAN_CIPHER_SUITE_TKIP:
1877 if (sta) {
1878 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.unicast_rsc;
1879 tkip_tx_sc = &data->rsc_tsc->all_tsc_rsc.tkip.tsc;
1880
1881 rx_p1ks = data->tkip->rx_uni;
1882
1883 ieee80211_get_key_tx_seq(key, &seq);
1884 tkip_tx_sc->iv16 = cpu_to_le16(seq.tkip.iv16);
1885 tkip_tx_sc->iv32 = cpu_to_le32(seq.tkip.iv32);
1886
1887 ieee80211_get_tkip_p1k_iv(key, seq.tkip.iv32, p1k);
1888 iwlagn_convert_p1k(p1k, data->tkip->tx.p1k);
1889
1890 memcpy(data->tkip->mic_keys.tx,
1891 &key->key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
1892 IWLAGN_MIC_KEY_SIZE);
1893
1894 rx_mic_key = data->tkip->mic_keys.rx_unicast;
1895 } else {
1896 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.multicast_rsc;
1897 rx_p1ks = data->tkip->rx_multi;
1898 rx_mic_key = data->tkip->mic_keys.rx_mcast;
1899 }
1900
1901 /*
1902 * For non-QoS this relies on the fact that both the uCode and
1903 * mac80211 use TID 0 (as they need to to avoid replay attacks)
1904 * for checking the IV in the frames.
1905 */
1906 for (i = 0; i < IWLAGN_NUM_RSC; i++) {
1907 ieee80211_get_key_rx_seq(key, i, &seq);
1908 tkip_sc[i].iv16 = cpu_to_le16(seq.tkip.iv16);
1909 tkip_sc[i].iv32 = cpu_to_le32(seq.tkip.iv32);
1910 /* wrapping isn't allowed, AP must rekey */
1911 if (seq.tkip.iv32 > cur_rx_iv32)
1912 cur_rx_iv32 = seq.tkip.iv32;
1913 }
1914
1915 ieee80211_get_tkip_rx_p1k(key, data->bssid, cur_rx_iv32, p1k);
1916 iwlagn_convert_p1k(p1k, rx_p1ks[0].p1k);
1917 ieee80211_get_tkip_rx_p1k(key, data->bssid,
1918 cur_rx_iv32 + 1, p1k);
1919 iwlagn_convert_p1k(p1k, rx_p1ks[1].p1k);
1920
1921 memcpy(rx_mic_key,
1922 &key->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
1923 IWLAGN_MIC_KEY_SIZE);
1924
1925 data->use_tkip = true;
1926 data->use_rsc_tsc = true;
1927 break;
1928 case WLAN_CIPHER_SUITE_CCMP:
1929 if (sta) {
1930 u8 *pn = seq.ccmp.pn;
1931
1932 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.unicast_rsc;
1933 aes_tx_sc = &data->rsc_tsc->all_tsc_rsc.aes.tsc;
1934
1935 ieee80211_get_key_tx_seq(key, &seq);
1936 aes_tx_sc->pn = cpu_to_le64(
1937 (u64)pn[5] |
1938 ((u64)pn[4] << 8) |
1939 ((u64)pn[3] << 16) |
1940 ((u64)pn[2] << 24) |
1941 ((u64)pn[1] << 32) |
1942 ((u64)pn[0] << 40));
1943 } else
1944 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.multicast_rsc;
1945
1946 /*
1947 * For non-QoS this relies on the fact that both the uCode and
1948 * mac80211 use TID 0 for checking the IV in the frames.
1949 */
1950 for (i = 0; i < IWLAGN_NUM_RSC; i++) {
1951 u8 *pn = seq.ccmp.pn;
1952
1953 ieee80211_get_key_rx_seq(key, i, &seq);
1954 aes_sc->pn = cpu_to_le64(
1955 (u64)pn[5] |
1956 ((u64)pn[4] << 8) |
1957 ((u64)pn[3] << 16) |
1958 ((u64)pn[2] << 24) |
1959 ((u64)pn[1] << 32) |
1960 ((u64)pn[0] << 40));
1961 }
1962 data->use_rsc_tsc = true;
1963 break;
1964 }
1965
6ac2f839 1966 mutex_unlock(&priv->shrd->mutex);
c8ac61cf
JB		 1967}
1968
1969static int iwlagn_mac_suspend(struct ieee80211_hw *hw,
1970 struct cfg80211_wowlan *wowlan)
1971{
1972 struct iwl_priv *priv = hw->priv;
1973 struct iwlagn_wowlan_wakeup_filter_cmd wakeup_filter_cmd;
1974 struct iwl_rxon_cmd rxon;
1975 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
1976 struct iwlagn_wowlan_kek_kck_material_cmd kek_kck_cmd;
1977 struct iwlagn_wowlan_tkip_params_cmd tkip_cmd = {};
1978 struct wowlan_key_data key_data = {
1979 .ctx = ctx,
1980 .bssid = ctx->active.bssid_addr,
1981 .use_rsc_tsc = false,
1982 .tkip = &tkip_cmd,
1983 .use_tkip = false,
1984 };
56012409 1985 struct iwlagn_d3_config_cmd d3_cfg_cmd = {};
c8ac61cf
JB		 1986 int ret, i;
1987 u16 seq;
1988
1989 if (WARN_ON(!wowlan))
1990 return -EINVAL;
1991
770c72c4 1992 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 1993 mutex_lock(&priv->shrd->mutex);
c8ac61cf
JB		 1994
1995 /* Don't attempt WoWLAN when not associated, tear down instead. */
1996 if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION ||
1997 !iwl_is_associated_ctx(ctx)) {
1998 ret = 1;
1999 goto out;
2000 }
2001
2002 key_data.rsc_tsc = kzalloc(sizeof(*key_data.rsc_tsc), GFP_KERNEL);
2003 if (!key_data.rsc_tsc) {
2004 ret = -ENOMEM;
2005 goto out;
2006 }
2007
2008 memset(&wakeup_filter_cmd, 0, sizeof(wakeup_filter_cmd));
2009
2010 /*
2011 * We know the last used seqno, and the uCode expects to know that
2012 * one, it will increment before TX.
2013 */
2014 seq = le16_to_cpu(priv->last_seq_ctl) & IEEE80211_SCTL_SEQ;
2015 wakeup_filter_cmd.non_qos_seq = cpu_to_le16(seq);
2016
2017 /*
2018 * For QoS counters, we store the one to use next, so subtract 0x10
2019 * since the uCode will add 0x10 before using the value.
2020 */
2021 for (i = 0; i < 8; i++) {
5f85a789 2022 seq = priv->shrd->tid_data[IWL_AP_ID][i].seq_number;
c8ac61cf
JB		 2023 seq -= 0x10;
2024 wakeup_filter_cmd.qos_seq[i] = cpu_to_le16(seq);
2025 }
2026
2027 if (wowlan->disconnect)
2028 wakeup_filter_cmd.enabled |=
2029 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_BEACON_MISS |
2030 IWLAGN_WOWLAN_WAKEUP_LINK_CHANGE);
2031 if (wowlan->magic_pkt)
2032 wakeup_filter_cmd.enabled |=
2033 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_MAGIC_PACKET);
2034 if (wowlan->gtk_rekey_failure)
2035 wakeup_filter_cmd.enabled |=
2036 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_GTK_REKEY_FAIL);
2037 if (wowlan->eap_identity_req)
2038 wakeup_filter_cmd.enabled |=
2039 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_EAP_IDENT_REQ);
2040 if (wowlan->four_way_handshake)
2041 wakeup_filter_cmd.enabled |=
2042 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_4WAY_HANDSHAKE);
c8ac61cf
JB		 2043 if (wowlan->n_patterns)
2044 wakeup_filter_cmd.enabled |=
2045 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_PATTERN_MATCH);
2046
56012409
JB		 2047 if (wowlan->rfkill_release)
2048 d3_cfg_cmd.wakeup_flags |=
2049 cpu_to_le32(IWLAGN_D3_WAKEUP_RFKILL);
2050
c8ac61cf
JB		 2051 iwl_scan_cancel_timeout(priv, 200);
2052
2053 memcpy(&rxon, &ctx->active, sizeof(rxon));
2054
e6bb4c9c 2055 iwl_trans_stop_device(trans(priv));
c8ac61cf 2056
57210f7c 2057 priv->shrd->wowlan = true;
c8ac61cf 2058
8929c24b 2059 ret = iwlagn_load_ucode_wait_alive(priv, IWL_UCODE_WOWLAN);
c8ac61cf
JB		 2060 if (ret)
2061 goto error;
2062
2063 /* now configure WoWLAN ucode */
2064 ret = iwl_alive_start(priv);
2065 if (ret)
2066 goto error;
2067
2068 memcpy(&ctx->staging, &rxon, sizeof(rxon));
2069 ret = iwlagn_commit_rxon(priv, ctx);
2070 if (ret)
2071 goto error;
2072
2073 ret = iwl_power_update_mode(priv, true);
2074 if (ret)
2075 goto error;
2076
2077 if (!iwlagn_mod_params.sw_crypto) {
2078 /* mark all keys clear */
2079 priv->ucode_key_table = 0;
2080 ctx->key_mapping_keys = 0;
2081
2082 /*
2083 * This needs to be unlocked due to lock ordering
2084 * constraints. Since we're in the suspend path
2085 * that isn't really a problem though.
2086 */
6ac2f839 2087 mutex_unlock(&priv->shrd->mutex);
c8ac61cf
JB		 2088 ieee80211_iter_keys(priv->hw, ctx->vif,
2089 iwlagn_wowlan_program_keys,
2090 &key_data);
6ac2f839 2091 mutex_lock(&priv->shrd->mutex);
c8ac61cf
JB		 2092 if (key_data.error) {
2093 ret = -EIO;
2094 goto error;
2095 }
2096
2097 if (key_data.use_rsc_tsc) {
2098 struct iwl_host_cmd rsc_tsc_cmd = {
2099 .id = REPLY_WOWLAN_TSC_RSC_PARAMS,
2100 .flags = CMD_SYNC,
2101 .data[0] = key_data.rsc_tsc,
2102 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
2103 .len[0] = sizeof(*key_data.rsc_tsc),
2104 };
2105
e6bb4c9c 2106 ret = iwl_trans_send_cmd(trans(priv), &rsc_tsc_cmd);
c8ac61cf
JB		 2107 if (ret)
2108 goto error;
2109 }
2110
2111 if (key_data.use_tkip) {
e6bb4c9c 2112 ret = iwl_trans_send_cmd_pdu(trans(priv),
c8ac61cf
JB		 2113 REPLY_WOWLAN_TKIP_PARAMS,
2114 CMD_SYNC, sizeof(tkip_cmd),
2115 &tkip_cmd);
2116 if (ret)
2117 goto error;
2118 }
2119
2120 if (priv->have_rekey_data) {
2121 memset(&kek_kck_cmd, 0, sizeof(kek_kck_cmd));
2122 memcpy(kek_kck_cmd.kck, priv->kck, NL80211_KCK_LEN);
2123 kek_kck_cmd.kck_len = cpu_to_le16(NL80211_KCK_LEN);
2124 memcpy(kek_kck_cmd.kek, priv->kek, NL80211_KEK_LEN);
2125 kek_kck_cmd.kek_len = cpu_to_le16(NL80211_KEK_LEN);
2126 kek_kck_cmd.replay_ctr = priv->replay_ctr;
2127
e6bb4c9c 2128 ret = iwl_trans_send_cmd_pdu(trans(priv),
c8ac61cf
JB		 2129 REPLY_WOWLAN_KEK_KCK_MATERIAL,
2130 CMD_SYNC, sizeof(kek_kck_cmd),
2131 &kek_kck_cmd);
2132 if (ret)
2133 goto error;
2134 }
2135 }
2136
56012409
JB		 2137 ret = iwl_trans_send_cmd_pdu(trans(priv), REPLY_D3_CONFIG, CMD_SYNC,
2138 sizeof(d3_cfg_cmd), &d3_cfg_cmd);
2139 if (ret)
2140 goto error;
2141
e6bb4c9c 2142 ret = iwl_trans_send_cmd_pdu(trans(priv), REPLY_WOWLAN_WAKEUP_FILTER,
c8ac61cf
JB		 2143 CMD_SYNC, sizeof(wakeup_filter_cmd),
2144 &wakeup_filter_cmd);
2145 if (ret)
2146 goto error;
2147
2148 ret = iwlagn_send_patterns(priv, wowlan);
2149 if (ret)
2150 goto error;
2151
26bfc0cf 2152 device_set_wakeup_enable(bus(priv)->dev, true);
c8ac61cf
JB		 2153
2154 /* Now let the ucode operate on its own */
83ed9015 2155 iwl_write32(bus(priv), CSR_UCODE_DRV_GP1_SET,
c8ac61cf
JB		 2156 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
2157
2158 goto out;
2159
2160 error:
57210f7c 2161 priv->shrd->wowlan = false;
c8ac61cf
JB		 2162 iwlagn_prepare_restart(priv);
2163 ieee80211_restart_hw(priv->hw);
2164 out:
6ac2f839 2165 mutex_unlock(&priv->shrd->mutex);
c8ac61cf 2166 kfree(key_data.rsc_tsc);
770c72c4
WYG		 2167 IWL_DEBUG_MAC80211(priv, "leave\n");
2168
c8ac61cf
JB		 2169 return ret;
2170}
2171
2172static int iwlagn_mac_resume(struct ieee80211_hw *hw)
2173{
2174 struct iwl_priv *priv = hw->priv;
2175 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2176 struct ieee80211_vif *vif;
2177 unsigned long flags;
2178 u32 base, status = 0xffffffff;
2179 int ret = -EIO;
2180
770c72c4 2181 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 2182 mutex_lock(&priv->shrd->mutex);
c8ac61cf 2183
83ed9015 2184 iwl_write32(bus(priv), CSR_UCODE_DRV_GP1_CLR,
c8ac61cf
JB		 2185 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
2186
2187 base = priv->device_pointers.error_event_table;
2188 if (iwlagn_hw_valid_rtc_data_addr(base)) {
83ed9015
EG		 2189 spin_lock_irqsave(&bus(priv)->reg_lock, flags);
2190 ret = iwl_grab_nic_access_silent(bus(priv));
c8ac61cf 2191 if (ret == 0) {
83ed9015
EG		 2192 iwl_write32(bus(priv), HBUS_TARG_MEM_RADDR, base);
2193 status = iwl_read32(bus(priv), HBUS_TARG_MEM_RDAT);
2194 iwl_release_nic_access(bus(priv));
c8ac61cf 2195 }
83ed9015 2196 spin_unlock_irqrestore(&bus(priv)->reg_lock, flags);
c8ac61cf
JB		 2197
2198#ifdef CONFIG_IWLWIFI_DEBUGFS
2199 if (ret == 0) {
de7f5f92 2200 struct iwl_trans *trans = trans(priv);
c8ac61cf
JB		 2201 if (!priv->wowlan_sram)
2202 priv->wowlan_sram =
de7f5f92 2203 kzalloc(trans->ucode_wowlan.data.len,
c8ac61cf
JB		 2204 GFP_KERNEL);
2205
2206 if (priv->wowlan_sram)
2207 _iwl_read_targ_mem_words(
83ed9015 2208 bus(priv), 0x800000, priv->wowlan_sram,
de7f5f92 2209 trans->ucode_wowlan.data.len / 4);
c8ac61cf
JB		 2210 }
2211#endif
2212 }
2213
2214 /* we'll clear ctx->vif during iwlagn_prepare_restart() */
2215 vif = ctx->vif;
2216
57210f7c 2217 priv->shrd->wowlan = false;
c8ac61cf 2218
26bfc0cf 2219 device_set_wakeup_enable(bus(priv)->dev, false);
c8ac61cf
JB		 2220
2221 iwlagn_prepare_restart(priv);
2222
2223 memset((void *)&ctx->active, 0, sizeof(ctx->active));
2224 iwl_connection_init_rx_config(priv, ctx);
2225 iwlagn_set_rxon_chain(priv, ctx);
2226
6ac2f839 2227 mutex_unlock(&priv->shrd->mutex);
770c72c4 2228 IWL_DEBUG_MAC80211(priv, "leave\n");
c8ac61cf
JB		 2229
2230 ieee80211_resume_disconnect(vif);
2231
2232 return 1;
2233}
26293133 2234#endif
c8ac61cf 2235
2dedbf58 2236static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
b481de9c 2237{
c79dd5b5 2238 struct iwl_priv *priv = hw->priv;
b481de9c 2239
e1623446 2240 IWL_DEBUG_MACDUMP(priv, "enter\n");
b481de9c 2241
e1623446 2242 IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
e039fa4a 2243 ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
b481de9c 2244
74bcdb33 2245 if (iwlagn_tx_skb(priv, skb))
b481de9c
ZY		 2246 dev_kfree_skb_any(skb);
2247
e1623446 2248 IWL_DEBUG_MACDUMP(priv, "leave\n");
b481de9c
ZY		 2249}
2250
2dedbf58
JB		 2251static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
2252 struct ieee80211_vif *vif,
2253 struct ieee80211_key_conf *keyconf,
2254 struct ieee80211_sta *sta,
2255 u32 iv32, u16 *phase1key)
ab885f8c 2256{
9f58671e 2257 struct iwl_priv *priv = hw->priv;
ab885f8c 2258
5a3d9882 2259 iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
ab885f8c
EG		 2260}
2261
2dedbf58
JB		 2262static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2263 struct ieee80211_vif *vif,
2264 struct ieee80211_sta *sta,
2265 struct ieee80211_key_conf *key)
b481de9c 2266{
c79dd5b5 2267 struct iwl_priv *priv = hw->priv;
a194e324 2268 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
c10afb6e 2269 struct iwl_rxon_context *ctx = vif_priv->ctx;
42986796 2270 int ret;
42986796 2271 bool is_default_wep_key = false;
b481de9c 2272
e1623446 2273 IWL_DEBUG_MAC80211(priv, "enter\n");
b481de9c 2274
9d143e9a 2275 if (iwlagn_mod_params.sw_crypto) {
e1623446 2276 IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
b481de9c
ZY		 2277 return -EOPNOTSUPP;
2278 }
b481de9c 2279
274102a8 2280 /*
5a3d9882
JB		 2281 * We could program these keys into the hardware as well, but we
2282 * don't expect much multicast traffic in IBSS and having keys
2283 * for more stations is probably more useful.
2284 *
2285 * Mark key TX-only and return 0.
274102a8
JB		 2286 */
2287 if (vif->type == NL80211_IFTYPE_ADHOC &&
5a3d9882
JB		 2288 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
2289 key->hw_key_idx = WEP_INVALID_OFFSET;
2290 return 0;
2291 }
274102a8 2292
5a3d9882
JB		 2293 /* If they key was TX-only, accept deletion */
2294 if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
2295 return 0;
b481de9c 2296
6ac2f839 2297 mutex_lock(&priv->shrd->mutex);
2a421b91 2298 iwl_scan_cancel_timeout(priv, 100);
6974e363 2299
5a3d9882
JB		 2300 BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
2301
a90178fa
JB		 2302 /*
2303 * If we are getting WEP group key and we didn't receive any key mapping
6974e363
EG		 2304 * so far, we are in legacy wep mode (group key only), otherwise we are
2305 * in 1X mode.
a90178fa
JB		 2306 * In legacy wep mode, we use another host command to the uCode.
2307 */
97359d12 2308 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5a3d9882 2309 key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
6974e363 2310 if (cmd == SET_KEY)
c10afb6e 2311 is_default_wep_key = !ctx->key_mapping_keys;
6974e363 2312 else
ccc038ab 2313 is_default_wep_key =
5a3d9882 2314 key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
6974e363 2315 }
052c4b9f 2316
5a3d9882 2317
b481de9c 2318 switch (cmd) {
deb09c43 2319 case SET_KEY:
5a3d9882 2320 if (is_default_wep_key) {
2995bafa 2321 ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
5a3d9882
JB		 2322 break;
2323 }
2324 ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta);
2325 if (ret) {
2326 /*
2327 * can't add key for RX, but we don't need it
2328 * in the device for TX so still return 0
2329 */
2330 ret = 0;
2331 key->hw_key_idx = WEP_INVALID_OFFSET;
2332 }
deb09c43 2333
e1623446 2334 IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
b481de9c
ZY		 2335 break;
2336 case DISABLE_KEY:
6974e363 2337 if (is_default_wep_key)
c10afb6e 2338 ret = iwl_remove_default_wep_key(priv, ctx, key);
deb09c43 2339 else
5a3d9882 2340 ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
deb09c43 2341
e1623446 2342 IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
b481de9c
ZY		 2343 break;
2344 default:
deb09c43 2345 ret = -EINVAL;
b481de9c
ZY		 2346 }
2347
6ac2f839 2348 mutex_unlock(&priv->shrd->mutex);
e1623446 2349 IWL_DEBUG_MAC80211(priv, "leave\n");
b481de9c 2350
deb09c43 2351 return ret;
b481de9c
ZY		 2352}
2353
2dedbf58
JB		 2354static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
2355 struct ieee80211_vif *vif,
2356 enum ieee80211_ampdu_mlme_action action,
2357 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
2358 u8 buf_size)
d783b061
TW		 2359{
2360 struct iwl_priv *priv = hw->priv;
4620fefa 2361 int ret = -EINVAL;
7b090687 2362 struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
ba562f71 2363 struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
d783b061 2364
e1623446 2365 IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
e174961c 2366 sta->addr, tid);
d783b061 2367
88950758 2368 if (!(priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE))
d783b061
TW		 2369 return -EACCES;
2370
770c72c4 2371 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 2372 mutex_lock(&priv->shrd->mutex);
4620fefa 2373
d783b061
TW		 2374 switch (action) {
2375 case IEEE80211_AMPDU_RX_START:
e1623446 2376 IWL_DEBUG_HT(priv, "start Rx\n");
4620fefa
JB		 2377 ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
2378 break;
d783b061 2379 case IEEE80211_AMPDU_RX_STOP:
e1623446 2380 IWL_DEBUG_HT(priv, "stop Rx\n");
619753ff 2381 ret = iwl_sta_rx_agg_stop(priv, sta, tid);
63013ae3 2382 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
4620fefa
JB		 2383 ret = 0;
2384 break;
d783b061 2385 case IEEE80211_AMPDU_TX_START:
e1623446 2386 IWL_DEBUG_HT(priv, "start Tx\n");
619753ff 2387 ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
4620fefa 2388 break;
d783b061 2389 case IEEE80211_AMPDU_TX_STOP:
e1623446 2390 IWL_DEBUG_HT(priv, "stop Tx\n");
619753ff 2391 ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
898ed67b
WYG		 2392 if ((ret == 0) && (priv->agg_tids_count > 0)) {
2393 priv->agg_tids_count--;
2394 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2395 priv->agg_tids_count);
d5a0ffa3 2396 }
63013ae3 2397 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status))
4620fefa 2398 ret = 0;
ef082cb1 2399 if (!priv->agg_tids_count && priv->cfg->ht_params &&
7cb1b088 2400 priv->cfg->ht_params->use_rts_for_aggregation) {
94597ab2
JB		 2401 /*
2402 * switch off RTS/CTS if it was previously enabled
2403 */
94597ab2
JB		 2404 sta_priv->lq_sta.lq.general_params.flags &=
2405 ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
7e6a5886
JB		 2406 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
2407 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
94597ab2 2408 }
4620fefa 2409 break;
f0527971 2410 case IEEE80211_AMPDU_TX_OPERATIONAL:
c8823ec1
JB		 2411 buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
2412
c91bd124 2413 iwl_trans_tx_agg_setup(trans(priv), ctx->ctxid, iwl_sta_id(sta),
ba562f71 2414 tid, buf_size);
c8823ec1 2415
7b090687
JB		 2416 /*
2417 * If the limit is 0, then it wasn't initialised yet,
2418 * use the default. We can do that since we take the
2419 * minimum below, and we don't want to go above our
2420 * default due to hardware restrictions.
2421 */
2422 if (sta_priv->max_agg_bufsize == 0)
2423 sta_priv->max_agg_bufsize =
2424 LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2425
2426 /*
2427 * Even though in theory the peer could have different
2428 * aggregation reorder buffer sizes for different sessions,
2429 * our ucode doesn't allow for that and has a global limit
2430 * for each station. Therefore, use the minimum of all the
2431 * aggregation sessions and our default value.
2432 */
2433 sta_priv->max_agg_bufsize =
2434 min(sta_priv->max_agg_bufsize, buf_size);
2435
7cb1b088
WYG		 2436 if (priv->cfg->ht_params &&
2437 priv->cfg->ht_params->use_rts_for_aggregation) {
cfecc6b4
WYG		 2438 /*
2439 * switch to RTS/CTS if it is the prefer protection
2440 * method for HT traffic
2441 */
94597ab2
JB		 2442
2443 sta_priv->lq_sta.lq.general_params.flags |=
2444 LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
cfecc6b4 2445 }
ef082cb1
WYG		 2446 priv->agg_tids_count++;
2447 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2448 priv->agg_tids_count);
7b090687
JB		 2449
2450 sta_priv->lq_sta.lq.agg_params.agg_frame_cnt_limit =
2451 sta_priv->max_agg_bufsize;
2452
2453 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
2454 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
5bc9890f
WYG		 2455
2456 IWL_INFO(priv, "Tx aggregation enabled on ra = %pM tid = %d\n",
2457 sta->addr, tid);
cfecc6b4 2458 ret = 0;
d783b061
TW		 2459 break;
2460 }
6ac2f839 2461 mutex_unlock(&priv->shrd->mutex);
770c72c4 2462 IWL_DEBUG_MAC80211(priv, "leave\n");
4620fefa 2463 return ret;
d783b061 2464}
9f58671e 2465
2dedbf58
JB		 2466static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
2467 struct ieee80211_vif *vif,
2468 struct ieee80211_sta *sta)
fe6b23dd
RC		 2469{
2470 struct iwl_priv *priv = hw->priv;
2471 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
a194e324 2472 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
eafdfbd3 2473 bool is_ap = vif->type == NL80211_IFTYPE_STATION;
770c72c4 2474 int ret = 0;
fe6b23dd
RC		 2475 u8 sta_id;
2476
770c72c4 2477 IWL_DEBUG_MAC80211(priv, "received request to add station %pM\n",
fe6b23dd 2478 sta->addr);
6ac2f839 2479 mutex_lock(&priv->shrd->mutex);
da5ae1cf
RC		 2480 IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
2481 sta->addr);
c6892906 2482 sta_priv->sta_id = IWL_INVALID_STATION;
fe6b23dd
RC		 2483
2484 atomic_set(&sta_priv->pending_frames, 0);
2485 if (vif->type == NL80211_IFTYPE_AP)
2486 sta_priv->client = true;
2487
a194e324 2488 ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
238d781d 2489 is_ap, sta, &sta_id);
fe6b23dd
RC		 2490 if (ret) {
2491 IWL_ERR(priv, "Unable to add station %pM (%d)\n",
2492 sta->addr, ret);
2493 /* Should we return success if return code is EEXIST ? */
770c72c4 2494 goto out;
fe6b23dd
RC		 2495 }
2496
c6892906 2497 sta_priv->sta_id = sta_id;
fd1af15d 2498
fe6b23dd 2499 /* Initialize rate scaling */
91dd6c27 2500 IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
fe6b23dd
RC		 2501 sta->addr);
2502 iwl_rs_rate_init(priv, sta, sta_id);
770c72c4 2503 out:
6ac2f839 2504 mutex_unlock(&priv->shrd->mutex);
770c72c4 2505 IWL_DEBUG_MAC80211(priv, "leave\n");
fe6b23dd 2506
770c72c4 2507 return ret;
fe6b23dd
RC		 2508}
2509
2dedbf58
JB		 2510static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
2511 struct ieee80211_channel_switch *ch_switch)
79d07325
WYG		 2512{
2513 struct iwl_priv *priv = hw->priv;
2514 const struct iwl_channel_info *ch_info;
2515 struct ieee80211_conf *conf = &hw->conf;
aa2dc6b5 2516 struct ieee80211_channel *channel = ch_switch->channel;
79d07325 2517 struct iwl_ht_config *ht_conf = &priv->current_ht_config;
246ed355
JB		 2518 /*
2519 * MULTI-FIXME
2520 * When we add support for multiple interfaces, we need to
2521 * revisit this. The channel switch command in the device
2522 * only affects the BSS context, but what does that really
2523 * mean? And what if we get a CSA on the second interface?
2524 * This needs a lot of work.
2525 */
2526 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
79d07325 2527 u16 ch;
79d07325
WYG		 2528
2529 IWL_DEBUG_MAC80211(priv, "enter\n");
2530
6ac2f839 2531 mutex_lock(&priv->shrd->mutex);
dc1a4068 2532
845a9c0d 2533 if (iwl_is_rfkill(priv->shrd))
dc1a4068 2534 goto out;
79d07325 2535
63013ae3
EG		 2536 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status) ||
2537 test_bit(STATUS_SCANNING, &priv->shrd->status) ||
2538 test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status))
dc1a4068 2539 goto out;
79d07325 2540
246ed355 2541 if (!iwl_is_associated_ctx(ctx))
dc1a4068 2542 goto out;
79d07325 2543
90c300cb 2544 if (!priv->cfg->lib->set_channel_switch)
f973f87e 2545 goto out;
79d07325 2546
f973f87e
SG		 2547 ch = channel->hw_value;
2548 if (le16_to_cpu(ctx->active.channel) == ch)
2549 goto out;
2550
2551 ch_info = iwl_get_channel_info(priv, channel->band, ch);
2552 if (!is_channel_valid(ch_info)) {
2553 IWL_DEBUG_MAC80211(priv, "invalid channel\n");
2554 goto out;
2555 }
79d07325 2556
10b15e6f 2557 spin_lock_irq(&priv->shrd->lock);
79d07325 2558
f973f87e 2559 priv->current_ht_config.smps = conf->smps_mode;
79d07325 2560
f973f87e
SG		 2561 /* Configure HT40 channels */
2562 ctx->ht.enabled = conf_is_ht(conf);
2563 if (ctx->ht.enabled) {
2564 if (conf_is_ht40_minus(conf)) {
2565 ctx->ht.extension_chan_offset =
2566 IEEE80211_HT_PARAM_CHA_SEC_BELOW;
2567 ctx->ht.is_40mhz = true;
2568 } else if (conf_is_ht40_plus(conf)) {
2569 ctx->ht.extension_chan_offset =
2570 IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
2571 ctx->ht.is_40mhz = true;
2572 } else {
2573 ctx->ht.extension_chan_offset =
2574 IEEE80211_HT_PARAM_CHA_SEC_NONE;
2575 ctx->ht.is_40mhz = false;
79d07325 2576 }
f973f87e
SG		 2577 } else
2578 ctx->ht.is_40mhz = false;
2579
2580 if ((le16_to_cpu(ctx->staging.channel) != ch))
2581 ctx->staging.flags = 0;
2582
2583 iwl_set_rxon_channel(priv, channel, ctx);
2584 iwl_set_rxon_ht(priv, ht_conf);
2585 iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
2586
10b15e6f 2587 spin_unlock_irq(&priv->shrd->lock);
f973f87e
SG		 2588
2589 iwl_set_rate(priv);
2590 /*
2591 * at this point, staging_rxon has the
2592 * configuration for channel switch
2593 */
63013ae3 2594 set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status);
f973f87e 2595 priv->switch_channel = cpu_to_le16(ch);
90c300cb 2596 if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
63013ae3 2597 clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->shrd->status);
f973f87e
SG		 2598 priv->switch_channel = 0;
2599 ieee80211_chswitch_done(ctx->vif, false);
79d07325 2600 }
f973f87e 2601
79d07325 2602out:
6ac2f839 2603 mutex_unlock(&priv->shrd->mutex);
79d07325
WYG		 2604 IWL_DEBUG_MAC80211(priv, "leave\n");
2605}
2606
2dedbf58
JB		 2607static void iwlagn_configure_filter(struct ieee80211_hw *hw,
2608 unsigned int changed_flags,
2609 unsigned int *total_flags,
2610 u64 multicast)
8b8ab9d5
JB		 2611{
2612 struct iwl_priv *priv = hw->priv;
2613 __le32 filter_or = 0, filter_nand = 0;
246ed355 2614 struct iwl_rxon_context *ctx;
8b8ab9d5
JB		 2615
2616#define CHK(test, flag) do { \
2617 if (*total_flags & (test)) \
2618 filter_or |= (flag); \
2619 else \
2620 filter_nand |= (flag); \
2621 } while (0)
2622
2623 IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
2624 changed_flags, *total_flags);
2625
2626 CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
bdb84fec
JB		 2627 /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
2628 CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
8b8ab9d5
JB		 2629 CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
2630
2631#undef CHK
2632
6ac2f839 2633 mutex_lock(&priv->shrd->mutex);
8b8ab9d5 2634
246ed355
JB		 2635 for_each_context(priv, ctx) {
2636 ctx->staging.filter_flags &= ~filter_nand;
2637 ctx->staging.filter_flags |= filter_or;
749ff4ef
SG		 2638
2639 /*
2640 * Not committing directly because hardware can perform a scan,
2641 * but we'll eventually commit the filter flags change anyway.
2642 */
246ed355 2643 }
8b8ab9d5 2644
6ac2f839 2645 mutex_unlock(&priv->shrd->mutex);
8b8ab9d5
JB		 2646
2647 /*
2648 * Receiving all multicast frames is always enabled by the
2649 * default flags setup in iwl_connection_init_rx_config()
2650 * since we currently do not support programming multicast
2651 * filters into the device.
2652 */
2653 *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
2654 FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
2655}
2656
2dedbf58 2657static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
716c74b0
WYG		 2658{
2659 struct iwl_priv *priv = hw->priv;
2660
6ac2f839 2661 mutex_lock(&priv->shrd->mutex);
716c74b0
WYG		 2662 IWL_DEBUG_MAC80211(priv, "enter\n");
2663
63013ae3 2664 if (test_bit(STATUS_EXIT_PENDING, &priv->shrd->status)) {
716c74b0
WYG		 2665 IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
2666 goto done;
2667 }
845a9c0d 2668 if (iwl_is_rfkill(priv->shrd)) {
716c74b0
WYG		 2669 IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
2670 goto done;
2671 }
2672
2673 /*
2674 * mac80211 will not push any more frames for transmit
2675 * until the flush is completed
2676 */
2677 if (drop) {
2678 IWL_DEBUG_MAC80211(priv, "send flush command\n");
c68744fb 2679 if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
716c74b0
WYG		 2680 IWL_ERR(priv, "flush request fail\n");
2681 goto done;
2682 }
2683 }
2684 IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n");
5f178cd2 2685 iwl_trans_wait_tx_queue_empty(trans(priv));
716c74b0 2686done:
6ac2f839 2687 mutex_unlock(&priv->shrd->mutex);
716c74b0
WYG		 2688 IWL_DEBUG_MAC80211(priv, "leave\n");
2689}
2690
c6baf7fb 2691void iwlagn_disable_roc(struct iwl_priv *priv)
9b9190d9
JB		 2692{
2693 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
9b9190d9 2694
6ac2f839 2695 lockdep_assert_held(&priv->shrd->mutex);
9b9190d9 2696
c6baf7fb 2697 if (!priv->hw_roc_setup)
9b9190d9
JB		 2698 return;
2699
c6baf7fb 2700 ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
9b9190d9 2701 ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
9b9190d9 2702
898ed67b 2703 priv->hw_roc_channel = NULL;
9b9190d9 2704
c6baf7fb
JB		 2705 memset(ctx->staging.node_addr, 0, ETH_ALEN);
2706
805a3b81 2707 iwlagn_commit_rxon(priv, ctx);
9b9190d9
JB		 2708
2709 ctx->is_active = false;
c6baf7fb 2710 priv->hw_roc_setup = false;
9b9190d9
JB		 2711}
2712
c6baf7fb 2713static void iwlagn_disable_roc_work(struct work_struct *work)
9b9190d9
JB		 2714{
2715 struct iwl_priv *priv = container_of(work, struct iwl_priv,
c6baf7fb 2716 hw_roc_disable_work.work);
9b9190d9 2717
6ac2f839 2718 mutex_lock(&priv->shrd->mutex);
9b9190d9 2719 iwlagn_disable_roc(priv);
6ac2f839 2720 mutex_unlock(&priv->shrd->mutex);
9b9190d9
JB		 2721}
2722
ade4c649 2723static int iwlagn_mac_remain_on_channel(struct ieee80211_hw *hw,
9b9190d9
JB		 2724 struct ieee80211_channel *channel,
2725 enum nl80211_channel_type channel_type,
2726 int duration)
2727{
2728 struct iwl_priv *priv = hw->priv;
c6baf7fb 2729 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
9b9190d9
JB		 2730 int err = 0;
2731
7a10e3e4 2732 if (!(priv->shrd->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
9b9190d9
JB		 2733 return -EOPNOTSUPP;
2734
c6baf7fb 2735 if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)))
9b9190d9
JB		 2736 return -EOPNOTSUPP;
2737
770c72c4 2738 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 2739 mutex_lock(&priv->shrd->mutex);
9b9190d9 2740
63013ae3 2741 if (test_bit(STATUS_SCAN_HW, &priv->shrd->status)) {
9b9190d9
JB		 2742 err = -EBUSY;
2743 goto out;
2744 }
2745
898ed67b
WYG		 2746 priv->hw_roc_channel = channel;
2747 priv->hw_roc_chantype = channel_type;
c6baf7fb 2748 priv->hw_roc_duration = duration;
390808db 2749 priv->hw_roc_start_notified = false;
c6baf7fb
JB		 2750 cancel_delayed_work(&priv->hw_roc_disable_work);
2751
2752 if (!ctx->is_active) {
2753 ctx->is_active = true;
2754 ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
2755 memcpy(ctx->staging.node_addr,
2756 priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
2757 ETH_ALEN);
2758 memcpy(ctx->staging.bssid_addr,
2759 priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
2760 ETH_ALEN);
2761 err = iwlagn_commit_rxon(priv, ctx);
2762 if (err)
2763 goto out;
2764 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK |
2765 RXON_FILTER_PROMISC_MSK |
2766 RXON_FILTER_CTL2HOST_MSK;
2767
2768 err = iwlagn_commit_rxon(priv, ctx);
2769 if (err) {
2770 iwlagn_disable_roc(priv);
2771 goto out;
2772 }
2773 priv->hw_roc_setup = true;
2774 }
9b9190d9 2775
c6baf7fb
JB		 2776 err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band);
2777 if (err)
2778 iwlagn_disable_roc(priv);
9b9190d9
JB		 2779
2780 out:
6ac2f839 2781 mutex_unlock(&priv->shrd->mutex);
770c72c4 2782 IWL_DEBUG_MAC80211(priv, "leave\n");
9b9190d9
JB		 2783
2784 return err;
2785}
2786
ade4c649 2787static int iwlagn_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
9b9190d9
JB		 2788{
2789 struct iwl_priv *priv = hw->priv;
2790
7a10e3e4 2791 if (!(priv->shrd->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
9b9190d9
JB		 2792 return -EOPNOTSUPP;
2793
770c72c4 2794 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 2795 mutex_lock(&priv->shrd->mutex);
c6baf7fb 2796 iwl_scan_cancel_timeout(priv, priv->hw_roc_duration);
9b9190d9 2797 iwlagn_disable_roc(priv);
6ac2f839 2798 mutex_unlock(&priv->shrd->mutex);
770c72c4 2799 IWL_DEBUG_MAC80211(priv, "leave\n");
9b9190d9
JB		 2800
2801 return 0;
2802}
2803
ade4c649
WYG		 2804static int iwlagn_mac_tx_sync(struct ieee80211_hw *hw,
2805 struct ieee80211_vif *vif,
2806 const u8 *bssid,
2807 enum ieee80211_tx_sync_type type)
debcf734
JB		 2808{
2809 struct iwl_priv *priv = hw->priv;
2810 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2811 struct iwl_rxon_context *ctx = vif_priv->ctx;
2812 int ret;
2813 u8 sta_id;
2814
770c72c4 2815 IWL_DEBUG_MAC80211(priv, "enter\n");
debcf734
JB		 2816 mutex_lock(&priv->shrd->mutex);
2817
2818 if (iwl_is_associated_ctx(ctx)) {
2819 ret = 0;
2820 goto out;
2821 }
2822
2823 if (ctx->preauth_bssid || test_bit(STATUS_SCAN_HW, &priv->shrd->status)) {
2824 ret = -EBUSY;
2825 goto out;
2826 }
2827
2828 ret = iwl_add_station_common(priv, ctx, bssid, true, NULL, &sta_id);
2829 if (ret)
2830 goto out;
2831
2832 if (WARN_ON(sta_id != ctx->ap_sta_id)) {
2833 ret = -EIO;
2834 goto out_remove_sta;
2835 }
2836
2837 memcpy(ctx->bssid, bssid, ETH_ALEN);
2838 ctx->preauth_bssid = true;
2839
2840 ret = iwlagn_commit_rxon(priv, ctx);
2841
2842 if (ret == 0)
2843 goto out;
2844
2845 out_remove_sta:
2846 iwl_remove_station(priv, sta_id, bssid);
2847 out:
2848 mutex_unlock(&priv->shrd->mutex);
770c72c4
WYG		 2849 IWL_DEBUG_MAC80211(priv, "leave\n");
2850
debcf734
JB		 2851 return ret;
2852}
2853
ade4c649 2854static void iwlagn_mac_finish_tx_sync(struct ieee80211_hw *hw,
debcf734
JB		 2855 struct ieee80211_vif *vif,
2856 const u8 *bssid,
2857 enum ieee80211_tx_sync_type type)
2858{
2859 struct iwl_priv *priv = hw->priv;
2860 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2861 struct iwl_rxon_context *ctx = vif_priv->ctx;
2862
770c72c4 2863 IWL_DEBUG_MAC80211(priv, "enter\n");
debcf734
JB		 2864 mutex_lock(&priv->shrd->mutex);
2865
2866 if (iwl_is_associated_ctx(ctx))
2867 goto out;
2868
2869 iwl_remove_station(priv, ctx->ap_sta_id, bssid);
2870 ctx->preauth_bssid = false;
2871 /* no need to commit */
2872 out:
2873 mutex_unlock(&priv->shrd->mutex);
770c72c4 2874 IWL_DEBUG_MAC80211(priv, "leave\n");
debcf734
JB		 2875}
2876
b481de9c
ZY		 2877/*****************************************************************************
2878 *
2879 * driver setup and teardown
2880 *
2881 *****************************************************************************/
2882
4e39317d 2883static void iwl_setup_deferred_work(struct iwl_priv *priv)
b481de9c 2884{
74e28e44 2885 priv->shrd->workqueue = create_singlethread_workqueue(DRV_NAME);
b481de9c 2886
3e10caeb 2887 init_waitqueue_head(&priv->shrd->wait_command_queue);
b481de9c 2888
5b9f8cd3 2889 INIT_WORK(&priv->restart, iwl_bg_restart);
5b9f8cd3 2890 INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
16e727e8 2891 INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
65550636 2892 INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
bee008b7 2893 INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
fbba9410 2894 INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
c6baf7fb
JB		 2895 INIT_DELAYED_WORK(&priv->hw_roc_disable_work,
2896 iwlagn_disable_roc_work);
2a421b91 2897
2a421b91 2898 iwl_setup_scan_deferred_work(priv);
bb8c093b 2899
6bd4dba3
EG		 2900 if (priv->cfg->lib->bt_setup_deferred_work)
2901 priv->cfg->lib->bt_setup_deferred_work(priv);
4e39317d
EG		 2902
2903 init_timer(&priv->statistics_periodic);
2904 priv->statistics_periodic.data = (unsigned long)priv;
5b9f8cd3 2905 priv->statistics_periodic.function = iwl_bg_statistics_periodic;
b481de9c 2906
a9e1cb6a
WYG		 2907 init_timer(&priv->ucode_trace);
2908 priv->ucode_trace.data = (unsigned long)priv;
2909 priv->ucode_trace.function = iwl_bg_ucode_trace;
2910
22de94de
SG		 2911 init_timer(&priv->watchdog);
2912 priv->watchdog.data = (unsigned long)priv;
2913 priv->watchdog.function = iwl_bg_watchdog;
b481de9c
ZY		 2914}
2915
4e39317d 2916static void iwl_cancel_deferred_work(struct iwl_priv *priv)
b481de9c 2917{
90c300cb
WYG		 2918 if (priv->cfg->lib->cancel_deferred_work)
2919 priv->cfg->lib->cancel_deferred_work(priv);
b481de9c 2920
815e629b 2921 cancel_work_sync(&priv->run_time_calib_work);
b481de9c 2922 cancel_work_sync(&priv->beacon_update);
e7e16b90
SG		 2923
2924 iwl_cancel_scan_deferred_work(priv);
2925
bee008b7 2926 cancel_work_sync(&priv->bt_full_concurrency);
fbba9410 2927 cancel_work_sync(&priv->bt_runtime_config);
c6baf7fb 2928 cancel_delayed_work_sync(&priv->hw_roc_disable_work);
e7e16b90 2929
4e39317d 2930 del_timer_sync(&priv->statistics_periodic);
a9e1cb6a 2931 del_timer_sync(&priv->ucode_trace);
b481de9c
ZY		 2932}
2933
89f186a8
RC		 2934static void iwl_init_hw_rates(struct iwl_priv *priv,
2935 struct ieee80211_rate *rates)
2936{
2937 int i;
2938
2939 for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) {
2940 rates[i].bitrate = iwl_rates[i].ieee * 5;
2941 rates[i].hw_value = i; /* Rate scaling will work on indexes */
2942 rates[i].hw_value_short = i;
2943 rates[i].flags = 0;
2944 if ((i >= IWL_FIRST_CCK_RATE) && (i <= IWL_LAST_CCK_RATE)) {
2945 /*
2946 * If CCK != 1M then set short preamble rate flag.
2947 */
2948 rates[i].flags |=
2949 (iwl_rates[i].plcp == IWL_RATE_1M_PLCP) ?
2950 0 : IEEE80211_RATE_SHORT_PREAMBLE;
2951 }
2952 }
2953}
2954
2955static int iwl_init_drv(struct iwl_priv *priv)
2956{
2957 int ret;
2958
f39c95e8 2959 spin_lock_init(&priv->shrd->sta_lock);
89f186a8 2960
6ac2f839 2961 mutex_init(&priv->shrd->mutex);
89f186a8 2962
89f186a8
RC		 2963 priv->ieee_channels = NULL;
2964 priv->ieee_rates = NULL;
2965 priv->band = IEEE80211_BAND_2GHZ;
2966
2967 priv->iw_mode = NL80211_IFTYPE_STATION;
ba37a3d0 2968 priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
a13d276f 2969 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
898ed67b 2970 priv->agg_tids_count = 0;
89f186a8 2971
8a472da4
WYG		 2972 /* initialize force reset */
2973 priv->force_reset[IWL_RF_RESET].reset_duration =
2974 IWL_DELAY_NEXT_FORCE_RF_RESET;
2975 priv->force_reset[IWL_FW_RESET].reset_duration =
2976 IWL_DELAY_NEXT_FORCE_FW_RELOAD;
89f186a8 2977
410f2bb3
SG		 2978 priv->rx_statistics_jiffies = jiffies;
2979
89f186a8 2980 /* Choose which receivers/antennas to use */
e3f10cea 2981 iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
89f186a8
RC		 2982
2983 iwl_init_scan_params(priv);
2984
22bf59a0 2985 /* init bt coex */
7cb1b088
WYG		 2986 if (priv->cfg->bt_params &&
2987 priv->cfg->bt_params->advanced_bt_coexist) {
b6e116e8
WYG		 2988 priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
2989 priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
2990 priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
22bf59a0
WYG		 2991 priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
2992 priv->bt_duration = BT_DURATION_LIMIT_DEF;
2993 priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
22bf59a0
WYG		 2994 }
2995
89f186a8
RC		 2996 ret = iwl_init_channel_map(priv);
2997 if (ret) {
2998 IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
2999 goto err;
3000 }
3001
b39488a9 3002 ret = iwl_init_geos(priv);
89f186a8
RC		 3003 if (ret) {
3004 IWL_ERR(priv, "initializing geos failed: %d\n", ret);
3005 goto err_free_channel_map;
3006 }
3007 iwl_init_hw_rates(priv, priv->ieee_rates);
3008
3009 return 0;
3010
3011err_free_channel_map:
3012 iwl_free_channel_map(priv);
3013err:
3014 return ret;
3015}
3016
3017static void iwl_uninit_drv(struct iwl_priv *priv)
3018{
3019 iwl_calib_free_results(priv);
b39488a9 3020 iwl_free_geos(priv);
89f186a8 3021 iwl_free_channel_map(priv);
dfa2bdba
EG		 3022 if (priv->tx_cmd_pool)
3023 kmem_cache_destroy(priv->tx_cmd_pool);
811ecc99 3024 kfree(priv->scan_cmd);
4ce7cc2b 3025 kfree(priv->beacon_cmd);
79d3eef8 3026 kfree(rcu_dereference_raw(priv->noa_data));
c8ac61cf
JB		 3027#ifdef CONFIG_IWLWIFI_DEBUGFS
3028 kfree(priv->wowlan_sram);
3029#endif
89f186a8
RC		 3030}
3031
ade4c649 3032static void iwlagn_mac_rssi_callback(struct ieee80211_hw *hw,
207ecc5e
MV		 3033 enum ieee80211_rssi_event rssi_event)
3034{
3035 struct iwl_priv *priv = hw->priv;
3036
770c72c4 3037 IWL_DEBUG_MAC80211(priv, "enter\n");
6ac2f839 3038 mutex_lock(&priv->shrd->mutex);
207ecc5e
MV		 3039
3040 if (priv->cfg->bt_params &&
3041 priv->cfg->bt_params->advanced_bt_coexist) {
3042 if (rssi_event == RSSI_EVENT_LOW)
3043 priv->bt_enable_pspoll = true;
3044 else if (rssi_event == RSSI_EVENT_HIGH)
3045 priv->bt_enable_pspoll = false;
3046
3047 iwlagn_send_advance_bt_config(priv);
3048 } else {
3049 IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
3050 "ignoring RSSI callback\n");
3051 }
3052
6ac2f839 3053 mutex_unlock(&priv->shrd->mutex);
770c72c4 3054 IWL_DEBUG_MAC80211(priv, "leave\n");
207ecc5e
MV		 3055}
3056
ade4c649 3057static int iwlagn_mac_set_tim(struct ieee80211_hw *hw,
3bde2b68
JB		 3058 struct ieee80211_sta *sta, bool set)
3059{
3060 struct iwl_priv *priv = hw->priv;
3061
3062 queue_work(priv->shrd->workqueue, &priv->beacon_update);
3063
3064 return 0;
3065}
3066
dc21b545 3067struct ieee80211_ops iwlagn_hw_ops = {
2295c66b
JB		 3068 .tx = iwlagn_mac_tx,
3069 .start = iwlagn_mac_start,
3070 .stop = iwlagn_mac_stop,
c01a4047 3071#ifdef CONFIG_PM_SLEEP
c8ac61cf
JB		 3072 .suspend = iwlagn_mac_suspend,
3073 .resume = iwlagn_mac_resume,
26293133 3074#endif
ade4c649
WYG		 3075 .add_interface = iwlagn_mac_add_interface,
3076 .remove_interface = iwlagn_mac_remove_interface,
3077 .change_interface = iwlagn_mac_change_interface,
2295c66b 3078 .config = iwlagn_mac_config,
8b8ab9d5 3079 .configure_filter = iwlagn_configure_filter,
2295c66b
JB		 3080 .set_key = iwlagn_mac_set_key,
3081 .update_tkip_key = iwlagn_mac_update_tkip_key,
c8ac61cf 3082 .set_rekey_data = iwlagn_mac_set_rekey_data,
ade4c649 3083 .conf_tx = iwlagn_mac_conf_tx,
2295c66b
JB		 3084 .bss_info_changed = iwlagn_bss_info_changed,
3085 .ampdu_action = iwlagn_mac_ampdu_action,
ade4c649 3086 .hw_scan = iwlagn_mac_hw_scan,
2295c66b 3087 .sta_notify = iwlagn_mac_sta_notify,
fe6b23dd 3088 .sta_add = iwlagn_mac_sta_add,
ade4c649 3089 .sta_remove = iwlagn_mac_sta_remove,
2295c66b
JB		 3090 .channel_switch = iwlagn_mac_channel_switch,
3091 .flush = iwlagn_mac_flush,
ade4c649
WYG		 3092 .tx_last_beacon = iwlagn_mac_tx_last_beacon,
3093 .remain_on_channel = iwlagn_mac_remain_on_channel,
3094 .cancel_remain_on_channel = iwlagn_mac_cancel_remain_on_channel,
3095 .rssi_callback = iwlagn_mac_rssi_callback,
3096 CFG80211_TESTMODE_CMD(iwlagn_mac_testmode_cmd)
3097 CFG80211_TESTMODE_DUMP(iwlagn_mac_testmode_dump)
3098 .tx_sync = iwlagn_mac_tx_sync,
3099 .finish_tx_sync = iwlagn_mac_finish_tx_sync,
3100 .set_tim = iwlagn_mac_set_tim,
b481de9c
ZY		 3101};
3102
e98a1302 3103static u32 iwl_hw_detect(struct iwl_priv *priv)
3867fe04 3104{
83ed9015 3105 return iwl_read32(bus(priv), CSR_HW_REV);
3867fe04
WYG		 3106}
3107
dda61a44
EG		 3108/* Size of one Rx buffer in host DRAM */
3109#define IWL_RX_BUF_SIZE_4K (4 * 1024)
3110#define IWL_RX_BUF_SIZE_8K (8 * 1024)
3111
07d4f1ad
WYG		 3112static int iwl_set_hw_params(struct iwl_priv *priv)
3113{
9d143e9a 3114 if (iwlagn_mod_params.amsdu_size_8K)
d6189124
EG		 3115 hw_params(priv).rx_page_order =
3116 get_order(IWL_RX_BUF_SIZE_8K);
07d4f1ad 3117 else
d6189124
EG		 3118 hw_params(priv).rx_page_order =
3119 get_order(IWL_RX_BUF_SIZE_4K);
07d4f1ad 3120
9d143e9a 3121 if (iwlagn_mod_params.disable_11n)
88950758 3122 priv->cfg->sku &= ~EEPROM_SKU_CAP_11N_ENABLE;
07d4f1ad 3123
fd656935
EG		 3124 hw_params(priv).num_ampdu_queues =
3125 priv->cfg->base_params->num_of_ampdu_queues;
3126 hw_params(priv).shadow_reg_enable =
3127 priv->cfg->base_params->shadow_reg_enable;
f22be624
EG		 3128 hw_params(priv).sku = priv->cfg->sku;
3129 hw_params(priv).wd_timeout = priv->cfg->base_params->wd_timeout;
fd656935 3130
07d4f1ad 3131 /* Device-specific setup */
90c300cb 3132 return priv->cfg->lib->set_hw_params(priv);
07d4f1ad
WYG		 3133}
3134
119ea186 3135/* This function both allocates and initializes hw and priv. */
fa06ec79 3136static struct ieee80211_hw *iwl_alloc_all(void)
119ea186
WYG		 3137{
3138 struct iwl_priv *priv;
3139 /* mac80211 allocates memory for this device instance, including
3140 * space for this driver's private structure */
3141 struct ieee80211_hw *hw;
3142
3143 hw = ieee80211_alloc_hw(sizeof(struct iwl_priv), &iwlagn_hw_ops);
fa06ec79 3144 if (!hw)
119ea186 3145 goto out;
119ea186
WYG		 3146
3147 priv = hw->priv;
3148 priv->hw = hw;
3149
3150out:
3151 return hw;
3152}
3153
e6bb4c9c
EG		 3154int iwl_probe(struct iwl_bus *bus, const struct iwl_trans_ops *trans_ops,
3155 struct iwl_cfg *cfg)
b2ea345e
WYG		 3156{
3157 int err = 0;
3158 struct iwl_priv *priv;
3159 struct ieee80211_hw *hw;
084dd791 3160 u16 num_mac;
b2ea345e
WYG		 3161 u32 hw_rev;
3162
3163 /************************
3164 * 1. Allocating HW data
3165 ************************/
fa06ec79 3166 hw = iwl_alloc_all();
b2ea345e 3167 if (!hw) {
fa06ec79 3168 pr_err("%s: Cannot allocate network device\n", cfg->name);
b2ea345e 3169 err = -ENOMEM;
807caf26
EG		 3170 goto out;
3171 }
3172
b2ea345e 3173 priv = hw->priv;
cac988a6 3174 priv->shrd = &priv->_shrd;
18d0077f 3175 bus->shrd = priv->shrd;
cac988a6
EG		 3176 priv->shrd->bus = bus;
3177 priv->shrd->priv = priv;
a48709c5 3178
e6bb4c9c
EG		 3179 priv->shrd->trans = trans_ops->alloc(priv->shrd);
3180 if (priv->shrd->trans == NULL) {
3181 err = -ENOMEM;
3182 goto out_free_traffic_mem;
3183 }
3184
b2ea345e 3185 /* At this point both hw and priv are allocated. */
8f2d3d2a 3186
26bfc0cf 3187 SET_IEEE80211_DEV(hw, bus(priv)->dev);
b481de9c 3188
e1623446 3189 IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
82b9a121 3190 priv->cfg = cfg;
316c30d9 3191
bee008b7
WYG		 3192 /* is antenna coupling more than 35dB ? */
3193 priv->bt_ant_couple_ok =
48f20d35
EG		 3194 (iwlagn_mod_params.ant_coupling >
3195 IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
3196 true : false;
bee008b7 3197
9f28ebc3 3198 /* enable/disable bt channel inhibition */
48f20d35 3199 priv->bt_ch_announce = iwlagn_mod_params.bt_ch_announce;
9f28ebc3
WYG		 3200 IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
3201 (priv->bt_ch_announce) ? "On" : "Off");
f37837c9 3202
20594eb0
WYG		 3203 if (iwl_alloc_traffic_mem(priv))
3204 IWL_ERR(priv, "Not enough memory to generate traffic log\n");
b481de9c 3205
731a29b7 3206 /* these spin locks will be used in apm_ops.init and EEPROM access
a8b50a0a
MA		 3207 * we should init now
3208 */
83ed9015 3209 spin_lock_init(&bus(priv)->reg_lock);
10b15e6f 3210 spin_lock_init(&priv->shrd->lock);
4843b5a7
RC		 3211
3212 /*
3213 * stop and reset the on-board processor just in case it is in a
3214 * strange state ... like being left stranded by a primary kernel
3215 * and this is now the kdump kernel trying to start up
3216 */
83ed9015 3217 iwl_write32(bus(priv), CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
4843b5a7 3218
084dd791
EG		 3219 /***********************
3220 * 3. Read REV register
3221 ***********************/
e98a1302 3222 hw_rev = iwl_hw_detect(priv);
c11362c0 3223 IWL_INFO(priv, "Detected %s, REV=0x%X\n",
e98a1302 3224 priv->cfg->name, hw_rev);
316c30d9 3225
e6bb4c9c 3226 err = iwl_trans_request_irq(trans(priv));
1e89cbac 3227 if (err)
e6bb4c9c 3228 goto out_free_trans;
1e89cbac 3229
e6bb4c9c 3230 if (iwl_trans_prepare_card_hw(trans(priv))) {
bcd4fe2f 3231 err = -EIO;
086ed117 3232 IWL_WARN(priv, "Failed, HW not ready\n");
1e89cbac 3233 goto out_free_trans;
086ed117
MA		 3234 }
3235
91238714
TW		 3236 /*****************
3237 * 4. Read EEPROM
3238 *****************/
316c30d9 3239 /* Read the EEPROM */
e98a1302 3240 err = iwl_eeprom_init(priv, hw_rev);
316c30d9 3241 if (err) {
15b1687c 3242 IWL_ERR(priv, "Unable to init EEPROM\n");
1e89cbac 3243 goto out_free_trans;
316c30d9 3244 }
8614f360
TW		 3245 err = iwl_eeprom_check_version(priv);
3246 if (err)
c8f16138 3247 goto out_free_eeprom;
8614f360 3248
21a5b3c6
WYG		 3249 err = iwl_eeprom_check_sku(priv);
3250 if (err)
3251 goto out_free_eeprom;
3252
02883017 3253 /* extract MAC Address */
c6fa17ed
WYG		 3254 iwl_eeprom_get_mac(priv, priv->addresses[0].addr);
3255 IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
3256 priv->hw->wiphy->addresses = priv->addresses;
3257 priv->hw->wiphy->n_addresses = 1;
3258 num_mac = iwl_eeprom_query16(priv, EEPROM_NUM_MAC_ADDRESS);
3259 if (num_mac > 1) {
3260 memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
3261 ETH_ALEN);
3262 priv->addresses[1].addr[5]++;
3263 priv->hw->wiphy->n_addresses++;
3264 }
316c30d9
AK		 3265
3266 /************************
3267 * 5. Setup HW constants
3268 ************************/
da154e30 3269 if (iwl_set_hw_params(priv)) {
084dd791 3270 err = -ENOENT;
15b1687c 3271 IWL_ERR(priv, "failed to set hw parameters\n");
073d3f5f 3272 goto out_free_eeprom;
316c30d9
AK		 3273 }
3274
3275 /*******************
6ba87956 3276 * 6. Setup priv
316c30d9 3277 *******************/
b481de9c 3278
6ba87956 3279 err = iwl_init_drv(priv);
bf85ea4f 3280 if (err)
399f4900 3281 goto out_free_eeprom;
bf85ea4f 3282 /* At this point both hw and priv are initialized. */
316c30d9 3283
316c30d9 3284 /********************
09f9bf79 3285 * 7. Setup services
316c30d9 3286 ********************/
4e39317d 3287 iwl_setup_deferred_work(priv);
653fa4a0 3288 iwl_setup_rx_handlers(priv);
4613e72d 3289 iwl_testmode_init(priv);
316c30d9 3290
158bea07 3291 /*********************************************
084dd791 3292 * 8. Enable interrupts
158bea07 3293 *********************************************/
6ba87956 3294
554d1d02 3295 iwl_enable_rfkill_int(priv);
6cd0b1cb 3296
6cd0b1cb 3297 /* If platform's RF_KILL switch is NOT set to KILL */
83ed9015
EG		 3298 if (iwl_read32(bus(priv),
3299 CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
63013ae3 3300 clear_bit(STATUS_RF_KILL_HW, &priv->shrd->status);
6cd0b1cb 3301 else
63013ae3 3302 set_bit(STATUS_RF_KILL_HW, &priv->shrd->status);
6ba87956 3303
a60e77e5 3304 wiphy_rfkill_set_hw_state(priv->hw->wiphy,
63013ae3 3305 test_bit(STATUS_RF_KILL_HW, &priv->shrd->status));
6cd0b1cb 3306
58d0f361 3307 iwl_power_initialize(priv);
39b73fb1 3308 iwl_tt_initialize(priv);
158bea07 3309
898ed67b 3310 init_completion(&priv->firmware_loading_complete);
562db532 3311
b08dfd04 3312 err = iwl_request_firmware(priv, true);
158bea07 3313 if (err)
7d47618a 3314 goto out_destroy_workqueue;
158bea07 3315
b481de9c
ZY		 3316 return 0;
3317
34c1b7ba 3318out_destroy_workqueue:
74e28e44
EG		 3319 destroy_workqueue(priv->shrd->workqueue);
3320 priv->shrd->workqueue = NULL;
6ba87956 3321 iwl_uninit_drv(priv);
34c1b7ba 3322out_free_eeprom:
073d3f5f 3323 iwl_eeprom_free(priv);
1e89cbac 3324out_free_trans:
e6bb4c9c 3325 iwl_trans_free(trans(priv));
34c1b7ba 3326out_free_traffic_mem:
20594eb0 3327 iwl_free_traffic_mem(priv);
d7c76f4c 3328 ieee80211_free_hw(priv->hw);
34c1b7ba 3329out:
b481de9c
ZY		 3330 return err;
3331}
3332
a48709c5 3333void __devexit iwl_remove(struct iwl_priv * priv)
b481de9c 3334{
898ed67b 3335 wait_for_completion(&priv->firmware_loading_complete);
562db532 3336
e1623446 3337 IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
b481de9c 3338
67249625 3339 iwl_dbgfs_unregister(priv);
67249625 3340
ade4c649 3341 /* ieee80211_unregister_hw call wil cause iwlagn_mac_stop to
5b9f8cd3 3342 * to be called and iwl_down since we are removing the device
0b124c31
GG		 3343 * we need to set STATUS_EXIT_PENDING bit.
3344 */
63013ae3 3345 set_bit(STATUS_EXIT_PENDING, &priv->shrd->status);
5ed540ae 3346
7a4e5281 3347 iwl_testmode_cleanup(priv);
5ed540ae
WYG		 3348 iwl_leds_exit(priv);
3349
859cfb0a 3350 if (priv->mac80211_registered) {
c4f55232 3351 ieee80211_unregister_hw(priv->hw);
859cfb0a 3352 priv->mac80211_registered = 0;
c4f55232
RR		 3353 }
3354
39b73fb1
WYG		 3355 iwl_tt_exit(priv);
3356
ae2c30bf
EG		 3357 /*This will stop the queues, move the device to low power state */
3358 iwl_trans_stop_device(trans(priv));
0359facc 3359
de7f5f92 3360 iwl_dealloc_ucode(trans(priv));
b481de9c 3361
073d3f5f 3362 iwl_eeprom_free(priv);
b481de9c 3363
948c171c 3364 /*netif_stop_queue(dev); */
74e28e44 3365 flush_workqueue(priv->shrd->workqueue);
948c171c 3366
ade4c649 3367 /* ieee80211_unregister_hw calls iwlagn_mac_stop, which flushes
74e28e44 3368 * priv->shrd->workqueue... so we can't take down the workqueue
b481de9c 3369 * until now... */
74e28e44
EG		 3370 destroy_workqueue(priv->shrd->workqueue);
3371 priv->shrd->workqueue = NULL;
20594eb0 3372 iwl_free_traffic_mem(priv);
b481de9c 3373
e6bb4c9c 3374 iwl_trans_free(trans(priv));
34c1b7ba 3375
6ba87956 3376 iwl_uninit_drv(priv);
b481de9c 3377
77834543 3378 dev_kfree_skb(priv->beacon_skb);
b481de9c
ZY		 3379
3380 ieee80211_free_hw(priv->hw);
3381}
3382
b481de9c
ZY		 3383
3384/*****************************************************************************
3385 *
3386 * driver and module entry point
3387 *
3388 *****************************************************************************/
5b9f8cd3 3389static int __init iwl_init(void)
b481de9c
ZY		 3390{
3391
3392 int ret;
c96c31e4
JP		 3393 pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
3394 pr_info(DRV_COPYRIGHT "\n");
897e1cf2 3395
e227ceac 3396 ret = iwlagn_rate_control_register();
897e1cf2 3397 if (ret) {
c96c31e4 3398 pr_err("Unable to register rate control algorithm: %d\n", ret);
897e1cf2
RC		 3399 return ret;
3400 }
3401
48d1a211 3402 ret = iwl_pci_register_driver();
b481de9c 3403
48d1a211
EG		 3404 if (ret)
3405 goto error_register;
b481de9c 3406 return ret;
897e1cf2 3407
897e1cf2 3408error_register:
e227ceac 3409 iwlagn_rate_control_unregister();
897e1cf2 3410 return ret;
b481de9c
ZY		 3411}
3412
5b9f8cd3 3413static void __exit iwl_exit(void)
b481de9c 3414{
48d1a211 3415 iwl_pci_unregister_driver();
e227ceac 3416 iwlagn_rate_control_unregister();
b481de9c
ZY		 3417}
3418
5b9f8cd3
EG		 3419module_exit(iwl_exit);
3420module_init(iwl_init);
a562a9dd
RC		 3421
3422#ifdef CONFIG_IWLWIFI_DEBUG
48f20d35
EG		 3423module_param_named(debug, iwlagn_mod_params.debug_level, uint,
3424 S_IRUGO | S_IWUSR);
a562a9dd
RC		 3425MODULE_PARM_DESC(debug, "debug output mask");
3426#endif
3427
2b068618
WYG		 3428module_param_named(swcrypto, iwlagn_mod_params.sw_crypto, int, S_IRUGO);
3429MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
2b068618
WYG		 3430module_param_named(queues_num, iwlagn_mod_params.num_of_queues, int, S_IRUGO);
3431MODULE_PARM_DESC(queues_num, "number of hw queues.");
2b068618
WYG		 3432module_param_named(11n_disable, iwlagn_mod_params.disable_11n, int, S_IRUGO);
3433MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
2b068618
WYG		 3434module_param_named(amsdu_size_8K, iwlagn_mod_params.amsdu_size_8K,
3435 int, S_IRUGO);
3436MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
2b068618
WYG		 3437module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO);
3438MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
dd7a2509 3439
48f20d35
EG		 3440module_param_named(ucode_alternative,
3441 iwlagn_mod_params.wanted_ucode_alternative,
3442 int, S_IRUGO);
dd7a2509
JB		 3443MODULE_PARM_DESC(ucode_alternative,
3444 "specify ucode alternative to use from ucode file");
bee008b7 3445
48f20d35
EG		 3446module_param_named(antenna_coupling, iwlagn_mod_params.ant_coupling,
3447 int, S_IRUGO);
bee008b7
WYG		 3448MODULE_PARM_DESC(antenna_coupling,
3449 "specify antenna coupling in dB (defualt: 0 dB)");
f37837c9 3450
48f20d35
EG		 3451module_param_named(bt_ch_inhibition, iwlagn_mod_params.bt_ch_announce,
3452 bool, S_IRUGO);
9f28ebc3 3453MODULE_PARM_DESC(bt_ch_inhibition,
fee84f0d 3454 "Enable BT channel inhibition (default: enable)");
b7977ffa
SG		 3455
3456module_param_named(plcp_check, iwlagn_mod_params.plcp_check, bool, S_IRUGO);
3457MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])");
3458
3459module_param_named(ack_check, iwlagn_mod_params.ack_check, bool, S_IRUGO);
3460MODULE_PARM_DESC(ack_check, "Check ack health (default: 0 [disabled])");
b60eec9b 3461
300d0834
WYG		 3462module_param_named(wd_disable, iwlagn_mod_params.wd_disable, bool, S_IRUGO);
3463MODULE_PARM_DESC(wd_disable,
3464 "Disable stuck queue watchdog timer (default: 0 [enabled])");
3465
b60eec9b
WYG		 3466/*
3467 * set bt_coex_active to true, uCode will do kill/defer
3468 * every time the priority line is asserted (BT is sending signals on the
3469 * priority line in the PCIx).
3470 * set bt_coex_active to false, uCode will ignore the BT activity and
3471 * perform the normal operation
3472 *
3473 * User might experience transmit issue on some platform due to WiFi/BT
3474 * co-exist problem. The possible behaviors are:
3475 * Able to scan and finding all the available AP
3476 * Not able to associate with any AP
3477 * On those platforms, WiFi communication can be restored by set
3478 * "bt_coex_active" module parameter to "false"
3479 *
3480 * default: bt_coex_active = true (BT_COEX_ENABLE)
3481 */
3482module_param_named(bt_coex_active, iwlagn_mod_params.bt_coex_active,
3483 bool, S_IRUGO);
3484MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");
6b0184c4
WYG		 3485
3486module_param_named(led_mode, iwlagn_mod_params.led_mode, int, S_IRUGO);
3487MODULE_PARM_DESC(led_mode, "0=system default, "
3488 "1=On(RF On)/Off(RF Off), 2=blinking (default: 0)");
3f1e5f4a 3489
0172b029
WYG		 3490module_param_named(power_save, iwlagn_mod_params.power_save,
3491 bool, S_IRUGO);
3492MODULE_PARM_DESC(power_save,
3493 "enable WiFi power management (default: disable)");
3494
f7538168
WYG		 3495module_param_named(power_level, iwlagn_mod_params.power_level,
3496 int, S_IRUGO);
3497MODULE_PARM_DESC(power_level,
3498 "default power save level (range from 1 - 5, default: 1)");
3499
dd5b6d0a
WYG		 3500module_param_named(auto_agg, iwlagn_mod_params.auto_agg,
3501 bool, S_IRUGO);
3502MODULE_PARM_DESC(auto_agg,
3503 "enable agg w/o check traffic load (default: enable)");
3504
3f1e5f4a
WYG		 3505/*
3506 * For now, keep using power level 1 instead of automatically
3507 * adjusting ...
3508 */
3509module_param_named(no_sleep_autoadjust, iwlagn_mod_params.no_sleep_autoadjust,
3510 bool, S_IRUGO);
3511MODULE_PARM_DESC(no_sleep_autoadjust,
3512 "don't automatically adjust sleep level "
3513 "according to maximum network latency (default: true)");
Ubuntu Artful kernel mirror