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