?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'akpm'
[linux-2.6/next.git] / drivers / net / wireless / iwlwifi / iwl-agn.c
blob33894dde1ae3dd454930d2b38cda3a8feec7e453
1 /******************************************************************************
2 *
3 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
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:
25 * Intel Linux Wireless <ilw@linux.intel.com>
26 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *
28 *****************************************************************************/
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/dma-mapping.h>
34 #include <linux/delay.h>
35 #include <linux/sched.h>
36 #include <linux/skbuff.h>
37 #include <linux/netdevice.h>
38 #include <linux/firmware.h>
39 #include <linux/etherdevice.h>
40 #include <linux/if_arp.h>
41
42 #include <net/mac80211.h>
43
44 #include <asm/div64.h>
45
46 #include "iwl-eeprom.h"
47 #include "iwl-dev.h"
48 #include "iwl-core.h"
49 #include "iwl-io.h"
50 #include "iwl-helpers.h"
51 #include "iwl-sta.h"
52 #include "iwl-agn-calib.h"
53 #include "iwl-agn.h"
54 #include "iwl-bus.h"
55 #include "iwl-trans.h"
56
57 /******************************************************************************
58 *
59 * module boiler plate
60 *
61 ******************************************************************************/
62
63 /*
64 * module name, copyright, version, etc.
65 */
66 #define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
67
68 #ifdef CONFIG_IWLWIFI_DEBUG
69 #define VD "d"
70 #else
71 #define VD
72 #endif
73
74 #define DRV_VERSION IWLWIFI_VERSION VD
75
76
77 MODULE_DESCRIPTION(DRV_DESCRIPTION);
78 MODULE_VERSION(DRV_VERSION);
79 MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
80 MODULE_LICENSE("GPL");
81
82 static int iwlagn_ant_coupling;
83 static bool iwlagn_bt_ch_announce = 1;
84
85 void iwl_update_chain_flags(struct iwl_priv *priv)
86 {
87 struct iwl_rxon_context *ctx;
88
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);
93 }
94 }
95
96 /* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
97 static void iwl_set_beacon_tim(struct iwl_priv *priv,
98 struct iwl_tx_beacon_cmd *tx_beacon_cmd,
99 u8 *beacon, u32 frame_size)
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
123 int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
124 {
125 struct iwl_tx_beacon_cmd *tx_beacon_cmd;
126 struct iwl_host_cmd cmd = {
127 .id = REPLY_TX_BEACON,
128 .flags = CMD_SYNC,
129 };
130 struct ieee80211_tx_info *info;
131 u32 frame_size;
132 u32 rate_flags;
133 u32 rate;
134
135 /*
136 * We have to set up the TX command, the TX Beacon command, and the
137 * beacon contents.
138 */
139
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");
144 return 0;
145 }
146
147 if (WARN_ON(!priv->beacon_skb))
148 return -EINVAL;
149
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;
154 if (!tx_beacon_cmd)
155 return -ENOMEM;
156
157 frame_size = priv->beacon_skb->len;
158
159 /* Set up TX command fields */
160 tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
161 tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
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;
165
166 /* Set up TX beacon command fields */
167 iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data,
168 frame_size);
169
170 /* Set up packet rate and flags */
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
184 priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
185 priv->hw_params.valid_tx_ant);
186 rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
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)
192 rate_flags |= RATE_MCS_CCK_MSK;
193
194 tx_beacon_cmd->tx.rate_n_flags =
195 iwl_hw_set_rate_n_flags(rate, rate_flags);
196
197 /* Submit command */
198 cmd.len[0] = sizeof(*tx_beacon_cmd);
199 cmd.data[0] = tx_beacon_cmd;
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;
204
205 return trans_send_cmd(&priv->trans, &cmd);
206 }
207
208 static void iwl_bg_beacon_update(struct work_struct *work)
209 {
210 struct iwl_priv *priv =
211 container_of(work, struct iwl_priv, beacon_update);
212 struct sk_buff *beacon;
213
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 }
219
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
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);
232 if (!beacon) {
233 IWL_ERR(priv, "update beacon failed -- keeping old\n");
234 goto out;
235 }
236
237 /* new beacon skb is allocated every time; dispose previous.*/
238 dev_kfree_skb(priv->beacon_skb);
239
240 priv->beacon_skb = beacon;
241
242 iwlagn_send_beacon_cmd(priv);
243 out:
244 mutex_unlock(&priv->mutex);
245 }
246
247 static 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;
258 iwlagn_send_advance_bt_config(priv);
259 }
260
261 static 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);
265 struct iwl_rxon_context *ctx;
266
267 mutex_lock(&priv->mutex);
268
269 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
270 goto out;
271
272 /* dont send host command if rf-kill is on */
273 if (!iwl_is_ready_rf(priv))
274 goto out;
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 */
284 for_each_context(priv, ctx) {
285 iwlagn_set_rxon_chain(priv, ctx);
286 iwlagn_commit_rxon(priv, ctx);
287 }
288
289 iwlagn_send_advance_bt_config(priv);
290 out:
291 mutex_unlock(&priv->mutex);
292 }
293
294 /**
295 * iwl_bg_statistics_periodic - Timer callback to queue statistics
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 */
304 static void iwl_bg_statistics_periodic(unsigned long data)
305 {
306 struct iwl_priv *priv = (struct iwl_priv *)data;
307
308 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
309 return;
310
311 /* dont send host command if rf-kill is on */
312 if (!iwl_is_ready_rf(priv))
313 return;
314
315 iwl_send_statistics_request(priv, CMD_ASYNC, false);
316 }
317
318
319 static 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 */
341 iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
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++) {
349 ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
350 time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
351 if (mode == 0) {
352 trace_iwlwifi_dev_ucode_cont_event(priv,
353 0, time, ev);
354 } else {
355 data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
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
365 static void iwl_continuous_event_trace(struct iwl_priv *priv)
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
373 base = priv->device_pointers.error_event_table;
374 if (iwlagn_hw_valid_rtc_data_addr(base)) {
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 */
425 static 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
440 static 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
452 IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
453 iwlagn_dev_txfifo_flush(priv, IWL_DROP_ALL);
454 }
455
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 */
475 static 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 }
481 static 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
501 static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
502 show_debug_level, store_debug_level);
503
504
505 #endif /* CONFIG_IWLWIFI_DEBUG */
506
507
508 static 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
519 static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
520
521 static 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
532 static 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
554 static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
555
556 static struct attribute *iwl_sysfs_entries[] = {
557 &dev_attr_temperature.attr,
558 &dev_attr_tx_power.attr,
559 #ifdef CONFIG_IWLWIFI_DEBUG
560 &dev_attr_debug_level.attr,
561 #endif
562 NULL
563 };
564
565 static struct attribute_group iwl_attribute_group = {
566 .name = NULL, /* put in device directory */
567 .attrs = iwl_sysfs_entries,
568 };
569
570 /******************************************************************************
571 *
572 * uCode download functions
573 *
574 ******************************************************************************/
575
576 static void iwl_free_fw_desc(struct iwl_priv *priv, struct fw_desc *desc)
577 {
578 if (desc->v_addr)
579 dma_free_coherent(priv->bus->dev, desc->len,
580 desc->v_addr, desc->p_addr);
581 desc->v_addr = NULL;
582 desc->len = 0;
583 }
584
585 static void iwl_free_fw_img(struct iwl_priv *priv, struct fw_img *img)
586 {
587 iwl_free_fw_desc(priv, &img->code);
588 iwl_free_fw_desc(priv, &img->data);
589 }
590
591 static 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);
595 iwl_free_fw_img(priv, &priv->ucode_wowlan);
596 }
597
598 static int iwl_alloc_fw_desc(struct iwl_priv *priv, struct fw_desc *desc,
599 const void *data, size_t len)
600 {
601 if (!len) {
602 desc->v_addr = NULL;
603 return -EINVAL;
604 }
605
606 desc->v_addr = dma_alloc_coherent(priv->bus->dev, len,
607 &desc->p_addr, GFP_KERNEL);
608 if (!desc->v_addr)
609 return -ENOMEM;
610
611 desc->len = len;
612 memcpy(desc->v_addr, data, len);
613 return 0;
614 }
615
616 static 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);
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
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
697 struct iwlagn_ucode_capabilities {
698 u32 max_probe_length;
699 u32 standard_phy_calibration_size;
700 u32 flags;
701 };
702
703 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
704 static int iwl_mac_setup_register(struct iwl_priv *priv,
705 struct iwlagn_ucode_capabilities *capa);
706
707 #define UCODE_EXPERIMENTAL_INDEX 100
708 #define UCODE_EXPERIMENTAL_TAG "exp"
709
710 static int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first)
711 {
712 const char *name_pre = priv->cfg->fw_name_pre;
713 char tag[8];
714
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
721 priv->fw_index = priv->cfg->ucode_api_max;
722 sprintf(tag, "%d", priv->fw_index);
723 } else {
724 priv->fw_index--;
725 sprintf(tag, "%d", priv->fw_index);
726 }
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
733 sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
734
735 IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
736 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
737 ? "EXPERIMENTAL " : "",
738 priv->firmware_name);
739
740 return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name,
741 priv->bus->dev,
742 GFP_KERNEL, priv, iwl_ucode_callback);
743 }
744
745 struct iwlagn_firmware_pieces {
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;
749
750 u32 build;
751
752 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
753 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
754 };
755
756 static 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:
769 hdr_size = 28;
770 if (ucode_raw->size < hdr_size) {
771 IWL_ERR(priv, "File size too small!\n");
772 return -EINVAL;
773 }
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);
779 src = ucode->u.v2.data;
780 break;
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);
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 +
801 pieces->init_data_size) {
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;
817
818 return 0;
819 }
820
821 static int iwlagn_wanted_ucode_alternative = 1;
822
823 static 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;
834 u32 tlv_len;
835 enum iwl_ucode_tlv_type tlv_type;
836 const u8 *tlv_data;
837
838 if (len < sizeof(*ucode)) {
839 IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
840 return -EINVAL;
841 }
842
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));
846 return -EINVAL;
847 }
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
872 while (len >= sizeof(*tlv)) {
873 u16 tlv_alt;
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
883 if (len < tlv_len) {
884 IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
885 len, tlv_len);
886 return -EINVAL;
887 }
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:
917 IWL_ERR(priv, "Found unexpected BOOT ucode\n");
918 break;
919 case IWL_UCODE_TLV_PROBE_MAX_LEN:
920 if (tlv_len != sizeof(u32))
921 goto invalid_tlv_len;
922 capa->max_probe_length =
923 le32_to_cpup((__le32 *)tlv_data);
924 break;
925 case IWL_UCODE_TLV_PAN:
926 if (tlv_len)
927 goto invalid_tlv_len;
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);
945 break;
946 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
947 if (tlv_len != sizeof(u32))
948 goto invalid_tlv_len;
949 pieces->init_evtlog_ptr =
950 le32_to_cpup((__le32 *)tlv_data);
951 break;
952 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
953 if (tlv_len != sizeof(u32))
954 goto invalid_tlv_len;
955 pieces->init_evtlog_size =
956 le32_to_cpup((__le32 *)tlv_data);
957 break;
958 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
959 if (tlv_len != sizeof(u32))
960 goto invalid_tlv_len;
961 pieces->init_errlog_ptr =
962 le32_to_cpup((__le32 *)tlv_data);
963 break;
964 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
965 if (tlv_len != sizeof(u32))
966 goto invalid_tlv_len;
967 pieces->inst_evtlog_ptr =
968 le32_to_cpup((__le32 *)tlv_data);
969 break;
970 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
971 if (tlv_len != sizeof(u32))
972 goto invalid_tlv_len;
973 pieces->inst_evtlog_size =
974 le32_to_cpup((__le32 *)tlv_data);
975 break;
976 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
977 if (tlv_len != sizeof(u32))
978 goto invalid_tlv_len;
979 pieces->inst_errlog_ptr =
980 le32_to_cpup((__le32 *)tlv_data);
981 break;
982 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
983 if (tlv_len)
984 goto invalid_tlv_len;
985 priv->enhance_sensitivity_table = true;
986 break;
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;
995 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
996 if (tlv_len != sizeof(u32))
997 goto invalid_tlv_len;
998 capa->standard_phy_calibration_size =
999 le32_to_cpup((__le32 *)tlv_data);
1000 break;
1001 default:
1002 IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type);
1003 break;
1004 }
1005 }
1006
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);
1010 return -EINVAL;
1011 }
1012
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;
1020 }
1021
1022 /**
1023 * iwl_ucode_callback - callback when firmware was loaded
1024 *
1025 * If loaded successfully, copies the firmware into buffers
1026 * for the card to fetch (via DMA).
1027 */
1028 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
1029 {
1030 struct iwl_priv *priv = context;
1031 struct iwl_ucode_header *ucode;
1032 int err;
1033 struct iwlagn_firmware_pieces pieces;
1034 const unsigned int api_max = priv->cfg->ucode_api_max;
1035 unsigned int api_ok = priv->cfg->ucode_api_ok;
1036 const unsigned int api_min = priv->cfg->ucode_api_min;
1037 u32 api_ver;
1038 char buildstr[25];
1039 u32 build;
1040 struct iwlagn_ucode_capabilities ucode_capa = {
1041 .max_probe_length = 200,
1042 .standard_phy_calibration_size =
1043 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE,
1044 };
1045
1046 if (!api_ok)
1047 api_ok = api_max;
1048
1049 memset(&pieces, 0, sizeof(pieces));
1050
1051 if (!ucode_raw) {
1052 if (priv->fw_index <= api_ok)
1053 IWL_ERR(priv,
1054 "request for firmware file '%s' failed.\n",
1055 priv->firmware_name);
1056 goto try_again;
1057 }
1058
1059 IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
1060 priv->firmware_name, ucode_raw->size);
1061
1062 /* Make sure that we got at least the API version number */
1063 if (ucode_raw->size < 4) {
1064 IWL_ERR(priv, "File size way too small!\n");
1065 goto try_again;
1066 }
1067
1068 /* Data from ucode file: header followed by uCode images */
1069 ucode = (struct iwl_ucode_header *)ucode_raw->data;
1070
1071 if (ucode->ver)
1072 err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
1073 else
1074 err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
1075 &ucode_capa);
1076
1077 if (err)
1078 goto try_again;
1079
1080 api_ver = IWL_UCODE_API(priv->ucode_ver);
1081 build = pieces.build;
1082
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 */
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 }
1097
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 }
1110 }
1111
1112 if (build)
1113 sprintf(buildstr, " build %u%s", build,
1114 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
1115 ? " (EXP)" : "");
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);
1125
1126 snprintf(priv->hw->wiphy->fw_version,
1127 sizeof(priv->hw->wiphy->fw_version),
1128 "%u.%u.%u.%u%s",
1129 IWL_UCODE_MAJOR(priv->ucode_ver),
1130 IWL_UCODE_MINOR(priv->ucode_ver),
1131 IWL_UCODE_API(priv->ucode_ver),
1132 IWL_UCODE_SERIAL(priv->ucode_ver),
1133 buildstr);
1134
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
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);
1151
1152 /* Verify that uCode images will fit in card's SRAM */
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);
1156 goto try_again;
1157 }
1158
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);
1162 goto try_again;
1163 }
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);
1168 goto try_again;
1169 }
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);
1174 goto try_again;
1175 }
1176
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 */
1182 if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.code,
1183 pieces.inst, pieces.inst_size))
1184 goto err_pci_alloc;
1185 if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.data,
1186 pieces.data, pieces.data_size))
1187 goto err_pci_alloc;
1188
1189 /* Initialization instructions and data */
1190 if (pieces.init_size && pieces.init_data_size) {
1191 if (iwl_alloc_fw_desc(priv, &priv->ucode_init.code,
1192 pieces.init, pieces.init_size))
1193 goto err_pci_alloc;
1194 if (iwl_alloc_fw_desc(priv, &priv->ucode_init.data,
1195 pieces.init_data, pieces.init_data_size))
1196 goto err_pci_alloc;
1197 }
1198
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
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 */
1218 priv->init_evtlog_ptr = pieces.init_evtlog_ptr;
1219 if (pieces.init_evtlog_size)
1220 priv->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1221 else
1222 priv->init_evtlog_size =
1223 priv->cfg->base_params->max_event_log_size;
1224 priv->init_errlog_ptr = pieces.init_errlog_ptr;
1225 priv->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1226 if (pieces.inst_evtlog_size)
1227 priv->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1228 else
1229 priv->inst_evtlog_size =
1230 priv->cfg->base_params->max_event_log_size;
1231 priv->inst_errlog_ptr = pieces.inst_errlog_ptr;
1232
1233 priv->new_scan_threshold_behaviour =
1234 !!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
1235
1236 if (!(priv->cfg->sku & EEPROM_SKU_CAP_IPAN_ENABLE))
1237 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
1238
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
1246 if (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN) {
1247 priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
1248 priv->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
1249 } else {
1250 priv->sta_key_max_num = STA_KEY_MAX_NUM;
1251 priv->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
1252 }
1253
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
1263 priv->phy_calib_chain_noise_reset_cmd =
1264 ucode_capa.standard_phy_calibration_size;
1265 priv->phy_calib_chain_noise_gain_cmd =
1266 ucode_capa.standard_phy_calibration_size + 1;
1267
1268 /* initialize all valid contexts */
1269 iwl_init_context(priv, ucode_capa.flags);
1270
1271 /**************************************************
1272 * This is still part of probe() in a sense...
1273 *
1274 * 9. Setup and register with mac80211 and debugfs
1275 **************************************************/
1276 err = iwl_mac_setup_register(priv, &ucode_capa);
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
1284 err = sysfs_create_group(&(priv->bus->dev->kobj),
1285 &iwl_attribute_group);
1286 if (err) {
1287 IWL_ERR(priv, "failed to create sysfs device attributes\n");
1288 goto out_unbind;
1289 }
1290
1291 /* We have our copies now, allow OS release its copies */
1292 release_firmware(ucode_raw);
1293 complete(&priv->firmware_loading_complete);
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;
1302
1303 err_pci_alloc:
1304 IWL_ERR(priv, "failed to allocate pci memory\n");
1305 iwl_dealloc_ucode(priv);
1306 out_unbind:
1307 complete(&priv->firmware_loading_complete);
1308 device_release_driver(priv->bus->dev);
1309 release_firmware(ucode_raw);
1310 }
1311
1312 static const char * const desc_lookup_text[] = {
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",
1336 "NMI_INTERRUPT_BREAK_POINT",
1337 "DEBUG_0",
1338 "DEBUG_1",
1339 "DEBUG_2",
1340 "DEBUG_3",
1341 };
1342
1343 static 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
1362 static const char *desc_lookup(u32 num)
1363 {
1364 int i;
1365 int max = ARRAY_SIZE(desc_lookup_text);
1366
1367 if (num < max)
1368 return desc_lookup_text[num];
1369
1370 max = ARRAY_SIZE(advanced_lookup) - 1;
1371 for (i = 0; i < max; i++) {
1372 if (advanced_lookup[i].num == num)
1373 break;
1374 }
1375 return advanced_lookup[i].name;
1376 }
1377
1378 #define ERROR_START_OFFSET (1 * sizeof(u32))
1379 #define ERROR_ELEM_SIZE (7 * sizeof(u32))
1380
1381 void iwl_dump_nic_error_log(struct iwl_priv *priv)
1382 {
1383 u32 base;
1384 struct iwl_error_event_table table;
1385
1386 base = priv->device_pointers.error_event_table;
1387 if (priv->ucode_type == IWL_UCODE_INIT) {
1388 if (!base)
1389 base = priv->init_errlog_ptr;
1390 } else {
1391 if (!base)
1392 base = priv->inst_errlog_ptr;
1393 }
1394
1395 if (!iwlagn_hw_valid_rtc_data_addr(base)) {
1396 IWL_ERR(priv,
1397 "Not valid error log pointer 0x%08X for %s uCode\n",
1398 base,
1399 (priv->ucode_type == IWL_UCODE_INIT)
1400 ? "Init" : "RT");
1401 return;
1402 }
1403
1404 iwl_read_targ_mem_words(priv, base, &table, sizeof(table));
1405
1406 if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
1407 IWL_ERR(priv, "Start IWL Error Log Dump:\n");
1408 IWL_ERR(priv, "Status: 0x%08lX, count: %d\n",
1409 priv->status, table.valid);
1410 }
1411
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);
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 */
1448 static 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)
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 */
1457 unsigned long reg_flags;
1458
1459 if (num_events == 0)
1460 return pos;
1461
1462 base = priv->device_pointers.log_event_table;
1463 if (priv->ucode_type == IWL_UCODE_INIT) {
1464 if (!base)
1465 base = priv->init_evtlog_ptr;
1466 } else {
1467 if (!base)
1468 base = priv->inst_evtlog_ptr;
1469 }
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
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 */
1483 iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
1484 rmb();
1485
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++) {
1489 ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
1490 time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
1491 if (mode == 0) {
1492 /* data, ev */
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 }
1503 } else {
1504 data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
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",
1511 time, data, ev);
1512 trace_iwlwifi_dev_ucode_event(priv, time,
1513 data, ev);
1514 }
1515 }
1516 }
1517
1518 /* Allow device to power down */
1519 iwl_release_nic_access(priv);
1520 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
1521 return pos;
1522 }
1523
1524 /**
1525 * iwl_print_last_event_logs - Dump the newest # of event log to syslog
1526 */
1527 static 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)
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) {
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);
1545 } else
1546 pos = iwl_print_event_log(priv, next_entry - size,
1547 size, mode, pos, buf, bufsz);
1548 } else {
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 }
1556 }
1557 return pos;
1558 }
1559
1560 #define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
1561
1562 int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
1563 char **buf, bool display)
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 */
1571 u32 logsize;
1572 int pos = 0;
1573 size_t bufsz = 0;
1574
1575 base = priv->device_pointers.log_event_table;
1576 if (priv->ucode_type == IWL_UCODE_INIT) {
1577 logsize = priv->init_evtlog_size;
1578 if (!base)
1579 base = priv->init_evtlog_ptr;
1580 } else {
1581 logsize = priv->inst_evtlog_size;
1582 if (!base)
1583 base = priv->inst_evtlog_ptr;
1584 }
1585
1586 if (!iwlagn_hw_valid_rtc_data_addr(base)) {
1587 IWL_ERR(priv,
1588 "Invalid event log pointer 0x%08X for %s uCode\n",
1589 base,
1590 (priv->ucode_type == IWL_UCODE_INIT)
1591 ? "Init" : "RT");
1592 return -EINVAL;
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
1601 if (capacity > logsize) {
1602 IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
1603 capacity, logsize);
1604 capacity = logsize;
1605 }
1606
1607 if (next_entry > logsize) {
1608 IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
1609 next_entry, logsize);
1610 next_entry = logsize;
1611 }
1612
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");
1618 return pos;
1619 }
1620
1621 /* enable/disable bt channel inhibition */
1622 priv->bt_ch_announce = iwlagn_bt_ch_announce;
1623
1624 #ifdef CONFIG_IWLWIFI_DEBUG
1625 if (!(iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
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);
1634
1635 #ifdef CONFIG_IWLWIFI_DEBUG
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)
1643 return -ENOMEM;
1644 }
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)
1652 pos = iwl_print_event_log(priv, next_entry,
1653 capacity - next_entry, mode,
1654 pos, buf, bufsz);
1655 /* (then/else) start at top of log */
1656 pos = iwl_print_event_log(priv, 0,
1657 next_entry, mode, pos, buf, bufsz);
1658 } else
1659 pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
1660 next_entry, size, mode,
1661 pos, buf, bufsz);
1662 #else
1663 pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
1664 next_entry, size, mode,
1665 pos, buf, bufsz);
1666 #endif
1667 return pos;
1668 }
1669
1670 static 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
1683 if (priv->cfg->base_params->support_ct_kill_exit) {
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
1689 ret = trans_send_cmd_pdu(&priv->trans,
1690 REPLY_CT_KILL_CONFIG_CMD,
1691 CMD_SYNC, sizeof(adv_cmd), &adv_cmd);
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
1705 ret = trans_send_cmd_pdu(&priv->trans,
1706 REPLY_CT_KILL_CONFIG_CMD,
1707 CMD_SYNC, sizeof(cmd), &cmd);
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
1718 static 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,
1723 .len = { sizeof(struct iwl_calib_cfg_cmd), },
1724 .data = { &calib_cfg_cmd, },
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;
1729 calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
1730
1731 return trans_send_cmd(&priv->trans, &cmd);
1732 }
1733
1734
1735 static 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);
1743 return trans_send_cmd_pdu(&priv->trans,
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
1754 /**
1755 * iwl_alive_start - called after REPLY_ALIVE notification received
1756 * from protocol/runtime uCode (initialization uCode's
1757 * Alive gets handled by iwl_init_alive_start()).
1758 */
1759 int iwl_alive_start(struct iwl_priv *priv)
1760 {
1761 int ret = 0;
1762 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
1763
1764 /*TODO: this should go to the transport layer */
1765 iwl_reset_ict(priv);
1766
1767 IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
1768
1769 /* After the ALIVE response, we can send host commands to the uCode */
1770 set_bit(STATUS_ALIVE, &priv->status);
1771
1772 /* Enable watchdog to monitor the driver tx queues */
1773 iwl_setup_watchdog(priv);
1774
1775 if (iwl_is_rfkill(priv))
1776 return -ERFKILL;
1777
1778 /* download priority table before any calibration request */
1779 if (priv->cfg->bt_params &&
1780 priv->cfg->bt_params->advanced_bt_coexist) {
1781 /* Configure Bluetooth device coexistence support */
1782 if (priv->cfg->bt_params->bt_sco_disable)
1783 priv->bt_enable_pspoll = false;
1784 else
1785 priv->bt_enable_pspoll = true;
1786
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;
1790 iwlagn_send_advance_bt_config(priv);
1791 priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
1792 priv->cur_rssi_ctx = NULL;
1793
1794 iwlagn_send_prio_tbl(priv);
1795
1796 /* FIXME: w/a to force change uCode BT state machine */
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;
1805 } else {
1806 /*
1807 * default is 2-wire BT coexexistence support
1808 */
1809 iwl_send_bt_config(priv);
1810 }
1811
1812 if (priv->hw_params.calib_rt_cfg)
1813 iwlagn_send_calib_cfg_rt(priv, priv->hw_params.calib_rt_cfg);
1814
1815 ieee80211_wake_queues(priv->hw);
1816
1817 priv->active_rate = IWL_RATES_MASK;
1818
1819 /* Configure Tx antenna selection based on H/W config */
1820 iwlagn_send_tx_ant_config(priv, priv->cfg->valid_tx_ant);
1821
1822 if (iwl_is_associated_ctx(ctx) && !priv->wowlan) {
1823 struct iwl_rxon_cmd *active_rxon =
1824 (struct iwl_rxon_cmd *)&ctx->active;
1825 /* apply any changes in staging */
1826 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
1827 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
1828 } else {
1829 struct iwl_rxon_context *tmp;
1830 /* Initialize our rx_config data */
1831 for_each_context(priv, tmp)
1832 iwl_connection_init_rx_config(priv, tmp);
1833
1834 iwlagn_set_rxon_chain(priv, ctx);
1835 }
1836
1837 if (!priv->wowlan) {
1838 /* WoWLAN ucode will not reply in the same way, skip it */
1839 iwl_reset_run_time_calib(priv);
1840 }
1841
1842 set_bit(STATUS_READY, &priv->status);
1843
1844 /* Configure the adapter for unassociated operation */
1845 ret = iwlagn_commit_rxon(priv, ctx);
1846 if (ret)
1847 return ret;
1848
1849 /* At this point, the NIC is initialized and operational */
1850 iwl_rf_kill_ct_config(priv);
1851
1852 IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
1853
1854 return iwl_power_update_mode(priv, true);
1855 }
1856
1857 static void iwl_cancel_deferred_work(struct iwl_priv *priv);
1858
1859 static void __iwl_down(struct iwl_priv *priv)
1860 {
1861 int exit_pending;
1862
1863 IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
1864
1865 iwl_scan_cancel_timeout(priv, 200);
1866
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
1874 exit_pending = test_and_set_bit(STATUS_EXIT_PENDING, &priv->status);
1875
1876 /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
1877 * to prevent rearm timer */
1878 del_timer_sync(&priv->watchdog);
1879
1880 iwl_clear_ucode_stations(priv, NULL);
1881 iwl_dealloc_bcast_stations(priv);
1882 iwl_clear_driver_stations(priv);
1883
1884 /* reset BT coex data */
1885 priv->bt_status = 0;
1886 priv->cur_rssi_ctx = NULL;
1887 priv->bt_is_sco = 0;
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;
1893 priv->bt_full_concurrent = false;
1894 priv->bt_ci_compliance = 0;
1895
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
1901 if (priv->mac80211_registered)
1902 ieee80211_stop_queues(priv->hw);
1903
1904 /* Clear out all status bits but a few that are stable across reset */
1905 priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
1906 STATUS_RF_KILL_HW |
1907 test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
1908 STATUS_GEO_CONFIGURED |
1909 test_bit(STATUS_FW_ERROR, &priv->status) <<
1910 STATUS_FW_ERROR |
1911 test_bit(STATUS_EXIT_PENDING, &priv->status) <<
1912 STATUS_EXIT_PENDING;
1913
1914 trans_stop_device(&priv->trans);
1915
1916 dev_kfree_skb(priv->beacon_skb);
1917 priv->beacon_skb = NULL;
1918 }
1919
1920 static void iwl_down(struct iwl_priv *priv)
1921 {
1922 mutex_lock(&priv->mutex);
1923 __iwl_down(priv);
1924 mutex_unlock(&priv->mutex);
1925
1926 iwl_cancel_deferred_work(priv);
1927 }
1928
1929 #define MAX_HW_RESTARTS 5
1930
1931 static int __iwl_up(struct iwl_priv *priv)
1932 {
1933 struct iwl_rxon_context *ctx;
1934 int ret;
1935
1936 lockdep_assert_held(&priv->mutex);
1937
1938 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
1939 IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
1940 return -EIO;
1941 }
1942
1943 for_each_context(priv, ctx) {
1944 ret = iwlagn_alloc_bcast_station(priv, ctx);
1945 if (ret) {
1946 iwl_dealloc_bcast_stations(priv);
1947 return ret;
1948 }
1949 }
1950
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 }
1956
1957 ret = iwlagn_load_ucode_wait_alive(priv,
1958 &priv->ucode_rt,
1959 IWL_UCODE_REGULAR);
1960 if (ret) {
1961 IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
1962 goto error;
1963 }
1964
1965 ret = iwl_alive_start(priv);
1966 if (ret)
1967 goto error;
1968 return 0;
1969
1970 error:
1971 set_bit(STATUS_EXIT_PENDING, &priv->status);
1972 __iwl_down(priv);
1973 clear_bit(STATUS_EXIT_PENDING, &priv->status);
1974
1975 IWL_ERR(priv, "Unable to initialize device.\n");
1976 return ret;
1977 }
1978
1979
1980 /*****************************************************************************
1981 *
1982 * Workqueue callbacks
1983 *
1984 *****************************************************************************/
1985
1986 static 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) {
2000 iwl_chain_noise_calibration(priv);
2001 iwl_sensitivity_calibration(priv);
2002 }
2003
2004 mutex_unlock(&priv->mutex);
2005 }
2006
2007 static 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;
2014 bool bt_is_sco;
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;
2035 bt_is_sco = priv->bt_is_sco;
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;
2043 priv->bt_is_sco = bt_is_sco;
2044 }
2045
2046 static void iwl_bg_restart(struct work_struct *data)
2047 {
2048 struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
2049
2050 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2051 return;
2052
2053 if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
2054 mutex_lock(&priv->mutex);
2055 iwlagn_prepare_restart(priv);
2056 mutex_unlock(&priv->mutex);
2057 iwl_cancel_deferred_work(priv);
2058 ieee80211_restart_hw(priv->hw);
2059 } else {
2060 WARN_ON(1);
2061 }
2062 }
2063
2064 /*****************************************************************************
2065 *
2066 * mac80211 entry point functions
2067 *
2068 *****************************************************************************/
2069
2070 static 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
2081 static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
2082 {
2083 .max = 2,
2084 .types = BIT(NL80211_IFTYPE_STATION),
2085 },
2086 };
2087
2088 static 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
2100 static 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
2111 static const struct ieee80211_iface_combination
2112 iwlagn_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
2126 static const struct ieee80211_iface_combination
2127 iwlagn_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
2141 /*
2142 * Not a mac80211 entry point function, but it fits in with all the
2143 * other mac80211 functions grouped here.
2144 */
2145 static int iwl_mac_setup_register(struct iwl_priv *priv,
2146 struct iwlagn_ucode_capabilities *capa)
2147 {
2148 int ret;
2149 struct ieee80211_hw *hw = priv->hw;
2150 struct iwl_rxon_context *ctx;
2151
2152 hw->rate_control_algorithm = "iwl-agn-rs";
2153
2154 /* Tell mac80211 our characteristics */
2155 hw->flags = IEEE80211_HW_SIGNAL_DBM |
2156 IEEE80211_HW_AMPDU_AGGREGATION |
2157 IEEE80211_HW_NEED_DTIM_PERIOD |
2158 IEEE80211_HW_SPECTRUM_MGMT |
2159 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
2160
2161 hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2162
2163 hw->flags |= IEEE80211_HW_SUPPORTS_PS |
2164 IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
2165
2166 if (priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE)
2167 hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
2168 IEEE80211_HW_SUPPORTS_STATIC_SMPS;
2169
2170 if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
2171 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
2172
2173 hw->sta_data_size = sizeof(struct iwl_station_priv);
2174 hw->vif_data_size = sizeof(struct iwl_vif_priv);
2175
2176 for_each_context(priv, ctx) {
2177 hw->wiphy->interface_modes |= ctx->interface_modes;
2178 hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
2179 }
2180
2181 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
2182
2183 if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
2184 hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
2185 hw->wiphy->n_iface_combinations =
2186 ARRAY_SIZE(iwlagn_iface_combinations_p2p);
2187 } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
2188 hw->wiphy->iface_combinations = iwlagn_iface_combinations_dualmode;
2189 hw->wiphy->n_iface_combinations =
2190 ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
2191 }
2192
2193 hw->wiphy->max_remain_on_channel_duration = 1000;
2194
2195 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
2196 WIPHY_FLAG_DISABLE_BEACON_HINTS |
2197 WIPHY_FLAG_IBSS_RSN;
2198
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
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;
2220
2221 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
2222 /* we create the 802.11 header and a zero-length SSID element */
2223 hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
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
2237 iwl_leds_init(priv);
2238
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
2250 static int iwlagn_mac_start(struct ieee80211_hw *hw)
2251 {
2252 struct iwl_priv *priv = hw->priv;
2253 int ret;
2254
2255 IWL_DEBUG_MAC80211(priv, "enter\n");
2256
2257 /* we should be verifying the device is ready to be opened */
2258 mutex_lock(&priv->mutex);
2259 ret = __iwl_up(priv);
2260 mutex_unlock(&priv->mutex);
2261 if (ret)
2262 return ret;
2263
2264 IWL_DEBUG_INFO(priv, "Start UP work done.\n");
2265
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;
2269
2270 iwlagn_led_enable(priv);
2271
2272 priv->is_open = 1;
2273 IWL_DEBUG_MAC80211(priv, "leave\n");
2274 return 0;
2275 }
2276
2277 static void iwlagn_mac_stop(struct ieee80211_hw *hw)
2278 {
2279 struct iwl_priv *priv = hw->priv;
2280
2281 IWL_DEBUG_MAC80211(priv, "enter\n");
2282
2283 if (!priv->is_open)
2284 return;
2285
2286 priv->is_open = 0;
2287
2288 iwl_down(priv);
2289
2290 flush_workqueue(priv->workqueue);
2291
2292 /* User space software may expect getting rfkill changes
2293 * even if interface is down */
2294 iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2295 iwl_enable_rfkill_int(priv);
2296
2297 IWL_DEBUG_MAC80211(priv, "leave\n");
2298 }
2299
2300 #ifdef CONFIG_PM
2301 static 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 }
2342 #endif
2343
2344 static 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
2367 struct 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
2375 #ifdef CONFIG_PM
2376 static 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
2384 static 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
2510 static 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
2704 static 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 }
2763 #endif
2764
2765 static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
2766 {
2767 struct iwl_priv *priv = hw->priv;
2768
2769 IWL_DEBUG_MACDUMP(priv, "enter\n");
2770
2771 IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
2772 ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
2773
2774 if (iwlagn_tx_skb(priv, skb))
2775 dev_kfree_skb_any(skb);
2776
2777 IWL_DEBUG_MACDUMP(priv, "leave\n");
2778 }
2779
2780 static 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)
2785 {
2786 struct iwl_priv *priv = hw->priv;
2787
2788 iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
2789 }
2790
2791 static 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)
2795 {
2796 struct iwl_priv *priv = hw->priv;
2797 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2798 struct iwl_rxon_context *ctx = vif_priv->ctx;
2799 int ret;
2800 bool is_default_wep_key = false;
2801
2802 IWL_DEBUG_MAC80211(priv, "enter\n");
2803
2804 if (iwlagn_mod_params.sw_crypto) {
2805 IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
2806 return -EOPNOTSUPP;
2807 }
2808
2809 /*
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.
2815 */
2816 if (vif->type == NL80211_IFTYPE_ADHOC &&
2817 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
2818 key->hw_key_idx = WEP_INVALID_OFFSET;
2819 return 0;
2820 }
2821
2822 /* If they key was TX-only, accept deletion */
2823 if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
2824 return 0;
2825
2826 mutex_lock(&priv->mutex);
2827 iwl_scan_cancel_timeout(priv, 100);
2828
2829 BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
2830
2831 /*
2832 * If we are getting WEP group key and we didn't receive any key mapping
2833 * so far, we are in legacy wep mode (group key only), otherwise we are
2834 * in 1X mode.
2835 * In legacy wep mode, we use another host command to the uCode.
2836 */
2837 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2838 key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
2839 if (cmd == SET_KEY)
2840 is_default_wep_key = !ctx->key_mapping_keys;
2841 else
2842 is_default_wep_key =
2843 key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
2844 }
2845
2846
2847 switch (cmd) {
2848 case SET_KEY:
2849 if (is_default_wep_key) {
2850 ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
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 }
2862
2863 IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
2864 break;
2865 case DISABLE_KEY:
2866 if (is_default_wep_key)
2867 ret = iwl_remove_default_wep_key(priv, ctx, key);
2868 else
2869 ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
2870
2871 IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
2872 break;
2873 default:
2874 ret = -EINVAL;
2875 }
2876
2877 mutex_unlock(&priv->mutex);
2878 IWL_DEBUG_MAC80211(priv, "leave\n");
2879
2880 return ret;
2881 }
2882
2883 static 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)
2888 {
2889 struct iwl_priv *priv = hw->priv;
2890 int ret = -EINVAL;
2891 struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
2892
2893 IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
2894 sta->addr, tid);
2895
2896 if (!(priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE))
2897 return -EACCES;
2898
2899 mutex_lock(&priv->mutex);
2900
2901 switch (action) {
2902 case IEEE80211_AMPDU_RX_START:
2903 IWL_DEBUG_HT(priv, "start Rx\n");
2904 ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
2905 break;
2906 case IEEE80211_AMPDU_RX_STOP:
2907 IWL_DEBUG_HT(priv, "stop Rx\n");
2908 ret = iwl_sta_rx_agg_stop(priv, sta, tid);
2909 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2910 ret = 0;
2911 break;
2912 case IEEE80211_AMPDU_TX_START:
2913 IWL_DEBUG_HT(priv, "start Tx\n");
2914 ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
2915 if (ret == 0) {
2916 priv->agg_tids_count++;
2917 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2918 priv->agg_tids_count);
2919 }
2920 break;
2921 case IEEE80211_AMPDU_TX_STOP:
2922 IWL_DEBUG_HT(priv, "stop Tx\n");
2923 ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
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);
2928 }
2929 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2930 ret = 0;
2931 if (priv->cfg->ht_params &&
2932 priv->cfg->ht_params->use_rts_for_aggregation) {
2933 /*
2934 * switch off RTS/CTS if it was previously enabled
2935 */
2936 sta_priv->lq_sta.lq.general_params.flags &=
2937 ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
2938 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
2939 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
2940 }
2941 break;
2942 case IEEE80211_AMPDU_TX_OPERATIONAL:
2943 buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
2944
2945 trans_txq_agg_setup(&priv->trans, iwl_sta_id(sta), tid,
2946 buf_size);
2947
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
2968 if (priv->cfg->ht_params &&
2969 priv->cfg->ht_params->use_rts_for_aggregation) {
2970 /*
2971 * switch to RTS/CTS if it is the prefer protection
2972 * method for HT traffic
2973 */
2974
2975 sta_priv->lq_sta.lq.general_params.flags |=
2976 LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
2977 }
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);
2984
2985 IWL_INFO(priv, "Tx aggregation enabled on ra = %pM tid = %d\n",
2986 sta->addr, tid);
2987 ret = 0;
2988 break;
2989 }
2990 mutex_unlock(&priv->mutex);
2991
2992 return ret;
2993 }
2994
2995 static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
2996 struct ieee80211_vif *vif,
2997 struct ieee80211_sta *sta)
2998 {
2999 struct iwl_priv *priv = hw->priv;
3000 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
3001 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
3002 bool is_ap = vif->type == NL80211_IFTYPE_STATION;
3003 int ret;
3004 u8 sta_id;
3005
3006 IWL_DEBUG_INFO(priv, "received request to add station %pM\n",
3007 sta->addr);
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;
3012
3013 atomic_set(&sta_priv->pending_frames, 0);
3014 if (vif->type == NL80211_IFTYPE_AP)
3015 sta_priv->client = true;
3016
3017 ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
3018 is_ap, sta, &sta_id);
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 ? */
3023 mutex_unlock(&priv->mutex);
3024 return ret;
3025 }
3026
3027 sta_priv->common.sta_id = sta_id;
3028
3029 /* Initialize rate scaling */
3030 IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
3031 sta->addr);
3032 iwl_rs_rate_init(priv, sta, sta_id);
3033 mutex_unlock(&priv->mutex);
3034
3035 return 0;
3036 }
3037
3038 static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
3039 struct ieee80211_channel_switch *ch_switch)
3040 {
3041 struct iwl_priv *priv = hw->priv;
3042 const struct iwl_channel_info *ch_info;
3043 struct ieee80211_conf *conf = &hw->conf;
3044 struct ieee80211_channel *channel = ch_switch->channel;
3045 struct iwl_ht_config *ht_conf = &priv->current_ht_config;
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];
3055 u16 ch;
3056
3057 IWL_DEBUG_MAC80211(priv, "enter\n");
3058
3059 mutex_lock(&priv->mutex);
3060
3061 if (iwl_is_rfkill(priv))
3062 goto out;
3063
3064 if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
3065 test_bit(STATUS_SCANNING, &priv->status) ||
3066 test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
3067 goto out;
3068
3069 if (!iwl_is_associated_ctx(ctx))
3070 goto out;
3071
3072 if (!priv->cfg->lib->set_channel_switch)
3073 goto out;
3074
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 }
3084
3085 spin_lock_irq(&priv->lock);
3086
3087 priv->current_ht_config.smps = conf->smps_mode;
3088
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;
3104 }
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);
3124 if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
3125 clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
3126 priv->switch_channel = 0;
3127 ieee80211_chswitch_done(ctx->vif, false);
3128 }
3129
3130 out:
3131 mutex_unlock(&priv->mutex);
3132 IWL_DEBUG_MAC80211(priv, "leave\n");
3133 }
3134
3135 static void iwlagn_configure_filter(struct ieee80211_hw *hw,
3136 unsigned int changed_flags,
3137 unsigned int *total_flags,
3138 u64 multicast)
3139 {
3140 struct iwl_priv *priv = hw->priv;
3141 __le32 filter_or = 0, filter_nand = 0;
3142 struct iwl_rxon_context *ctx;
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);
3155 /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
3156 CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
3157 CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
3158
3159 #undef CHK
3160
3161 mutex_lock(&priv->mutex);
3162
3163 for_each_context(priv, ctx) {
3164 ctx->staging.filter_flags &= ~filter_nand;
3165 ctx->staging.filter_flags |= filter_or;
3166
3167 /*
3168 * Not committing directly because hardware can perform a scan,
3169 * but we'll eventually commit the filter flags change anyway.
3170 */
3171 }
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
3185 static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
3186 {
3187 struct iwl_priv *priv = hw->priv;
3188
3189 mutex_lock(&priv->mutex);
3190 IWL_DEBUG_MAC80211(priv, "enter\n");
3191
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");
3207 if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
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);
3214 done:
3215 mutex_unlock(&priv->mutex);
3216 IWL_DEBUG_MAC80211(priv, "leave\n");
3217 }
3218
3219 void iwlagn_disable_roc(struct iwl_priv *priv)
3220 {
3221 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
3222
3223 lockdep_assert_held(&priv->mutex);
3224
3225 if (!priv->hw_roc_setup)
3226 return;
3227
3228 ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
3229 ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
3230
3231 priv->hw_roc_channel = NULL;
3232
3233 memset(ctx->staging.node_addr, 0, ETH_ALEN);
3234
3235 iwlagn_commit_rxon(priv, ctx);
3236
3237 ctx->is_active = false;
3238 priv->hw_roc_setup = false;
3239 }
3240
3241 static void iwlagn_disable_roc_work(struct work_struct *work)
3242 {
3243 struct iwl_priv *priv = container_of(work, struct iwl_priv,
3244 hw_roc_disable_work.work);
3245
3246 mutex_lock(&priv->mutex);
3247 iwlagn_disable_roc(priv);
3248 mutex_unlock(&priv->mutex);
3249 }
3250
3251 static 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;
3257 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
3258 int err = 0;
3259
3260 if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
3261 return -EOPNOTSUPP;
3262
3263 if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)))
3264 return -EOPNOTSUPP;
3265
3266 mutex_lock(&priv->mutex);
3267
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)) {
3278 err = -EBUSY;
3279 goto out;
3280 }
3281
3282 priv->hw_roc_channel = channel;
3283 priv->hw_roc_chantype = channel_type;
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 }
3310
3311 err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band);
3312 if (err)
3313 iwlagn_disable_roc(priv);
3314
3315 out:
3316 mutex_unlock(&priv->mutex);
3317
3318 return err;
3319 }
3320
3321 static 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
3328 mutex_lock(&priv->mutex);
3329 iwl_scan_cancel_timeout(priv, priv->hw_roc_duration);
3330 iwlagn_disable_roc(priv);
3331 mutex_unlock(&priv->mutex);
3332
3333 return 0;
3334 }
3335
3336 /*****************************************************************************
3337 *
3338 * driver setup and teardown
3339 *
3340 *****************************************************************************/
3341
3342 static void iwl_setup_deferred_work(struct iwl_priv *priv)
3343 {
3344 priv->workqueue = create_singlethread_workqueue(DRV_NAME);
3345
3346 init_waitqueue_head(&priv->wait_command_queue);
3347
3348 INIT_WORK(&priv->restart, iwl_bg_restart);
3349 INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
3350 INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
3351 INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
3352 INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
3353 INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
3354 INIT_DELAYED_WORK(&priv->hw_roc_disable_work,
3355 iwlagn_disable_roc_work);
3356
3357 iwl_setup_scan_deferred_work(priv);
3358
3359 if (priv->cfg->lib->bt_setup_deferred_work)
3360 priv->cfg->lib->bt_setup_deferred_work(priv);
3361
3362 init_timer(&priv->statistics_periodic);
3363 priv->statistics_periodic.data = (unsigned long)priv;
3364 priv->statistics_periodic.function = iwl_bg_statistics_periodic;
3365
3366 init_timer(&priv->ucode_trace);
3367 priv->ucode_trace.data = (unsigned long)priv;
3368 priv->ucode_trace.function = iwl_bg_ucode_trace;
3369
3370 init_timer(&priv->watchdog);
3371 priv->watchdog.data = (unsigned long)priv;
3372 priv->watchdog.function = iwl_bg_watchdog;
3373 }
3374
3375 static void iwl_cancel_deferred_work(struct iwl_priv *priv)
3376 {
3377 if (priv->cfg->lib->cancel_deferred_work)
3378 priv->cfg->lib->cancel_deferred_work(priv);
3379
3380 cancel_work_sync(&priv->run_time_calib_work);
3381 cancel_work_sync(&priv->beacon_update);
3382
3383 iwl_cancel_scan_deferred_work(priv);
3384
3385 cancel_work_sync(&priv->bt_full_concurrency);
3386 cancel_work_sync(&priv->bt_runtime_config);
3387 cancel_delayed_work_sync(&priv->hw_roc_disable_work);
3388
3389 del_timer_sync(&priv->statistics_periodic);
3390 del_timer_sync(&priv->ucode_trace);
3391 }
3392
3393 static 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
3414 static int iwl_init_drv(struct iwl_priv *priv)
3415 {
3416 int ret;
3417
3418 spin_lock_init(&priv->sta_lock);
3419 spin_lock_init(&priv->hcmd_lock);
3420
3421 mutex_init(&priv->mutex);
3422
3423 priv->ieee_channels = NULL;
3424 priv->ieee_rates = NULL;
3425 priv->band = IEEE80211_BAND_2GHZ;
3426
3427 priv->iw_mode = NL80211_IFTYPE_STATION;
3428 priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
3429 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
3430 priv->agg_tids_count = 0;
3431
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;
3437
3438 priv->rx_statistics_jiffies = jiffies;
3439
3440 /* Choose which receivers/antennas to use */
3441 iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
3442
3443 iwl_init_scan_params(priv);
3444
3445 /* init bt coex */
3446 if (priv->cfg->bt_params &&
3447 priv->cfg->bt_params->advanced_bt_coexist) {
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;
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;
3454 }
3455
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
3471 err_free_channel_map:
3472 iwl_free_channel_map(priv);
3473 err:
3474 return ret;
3475 }
3476
3477 static 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);
3482 kfree(priv->scan_cmd);
3483 kfree(priv->beacon_cmd);
3484 #ifdef CONFIG_IWLWIFI_DEBUGFS
3485 kfree(priv->wowlan_sram);
3486 #endif
3487 }
3488
3489 static void iwl_mac_rssi_callback(struct ieee80211_hw *hw,
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
3512 struct ieee80211_ops iwlagn_hw_ops = {
3513 .tx = iwlagn_mac_tx,
3514 .start = iwlagn_mac_start,
3515 .stop = iwlagn_mac_stop,
3516 #ifdef CONFIG_PM
3517 .suspend = iwlagn_mac_suspend,
3518 .resume = iwlagn_mac_resume,
3519 #endif
3520 .add_interface = iwl_mac_add_interface,
3521 .remove_interface = iwl_mac_remove_interface,
3522 .change_interface = iwl_mac_change_interface,
3523 .config = iwlagn_mac_config,
3524 .configure_filter = iwlagn_configure_filter,
3525 .set_key = iwlagn_mac_set_key,
3526 .update_tkip_key = iwlagn_mac_update_tkip_key,
3527 .set_rekey_data = iwlagn_mac_set_rekey_data,
3528 .conf_tx = iwl_mac_conf_tx,
3529 .bss_info_changed = iwlagn_bss_info_changed,
3530 .ampdu_action = iwlagn_mac_ampdu_action,
3531 .hw_scan = iwl_mac_hw_scan,
3532 .sta_notify = iwlagn_mac_sta_notify,
3533 .sta_add = iwlagn_mac_sta_add,
3534 .sta_remove = iwl_mac_sta_remove,
3535 .channel_switch = iwlagn_mac_channel_switch,
3536 .flush = iwlagn_mac_flush,
3537 .tx_last_beacon = iwl_mac_tx_last_beacon,
3538 .remain_on_channel = iwl_mac_remain_on_channel,
3539 .cancel_remain_on_channel = iwl_mac_cancel_remain_on_channel,
3540 .rssi_callback = iwl_mac_rssi_callback,
3541 CFG80211_TESTMODE_CMD(iwl_testmode_cmd)
3542 CFG80211_TESTMODE_DUMP(iwl_testmode_dump)
3543 };
3544
3545 static u32 iwl_hw_detect(struct iwl_priv *priv)
3546 {
3547 return iwl_read32(priv, CSR_HW_REV);
3548 }
3549
3550 static 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;
3554 if (iwlagn_mod_params.amsdu_size_8K)
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
3561 if (iwlagn_mod_params.disable_11n)
3562 priv->cfg->sku &= ~EEPROM_SKU_CAP_11N_ENABLE;
3563
3564 /* Device-specific setup */
3565 return priv->cfg->lib->set_hw_params(priv);
3566 }
3567
3568 /* This function both allocates and initializes hw and priv. */
3569 static 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
3586 out:
3587 return hw;
3588 }
3589
3590 int iwl_probe(struct iwl_bus *bus, struct iwl_cfg *cfg)
3591 {
3592 int err = 0;
3593 struct iwl_priv *priv;
3594 struct ieee80211_hw *hw;
3595 u16 num_mac;
3596 u32 hw_rev;
3597
3598 /************************
3599 * 1. Allocating HW data
3600 ************************/
3601 hw = iwl_alloc_all(cfg);
3602 if (!hw) {
3603 err = -ENOMEM;
3604 goto out;
3605 }
3606
3607 priv = hw->priv;
3608 priv->bus = bus;
3609 bus_set_drv_data(priv->bus, priv);
3610
3611 /* At this point both hw and priv are allocated. */
3612
3613 SET_IEEE80211_DEV(hw, priv->bus->dev);
3614
3615 IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
3616 priv->cfg = cfg;
3617 priv->inta_mask = CSR_INI_SET_MASK;
3618
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
3624 /* enable/disable bt channel inhibition */
3625 priv->bt_ch_announce = iwlagn_bt_ch_announce;
3626 IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
3627 (priv->bt_ch_announce) ? "On" : "Off");
3628
3629 if (iwl_alloc_traffic_mem(priv))
3630 IWL_ERR(priv, "Not enough memory to generate traffic log\n");
3631
3632 /* these spin locks will be used in apm_ops.init and EEPROM access
3633 * we should init now
3634 */
3635 spin_lock_init(&priv->reg_lock);
3636 spin_lock_init(&priv->lock);
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
3645 /***********************
3646 * 3. Read REV register
3647 ***********************/
3648 hw_rev = iwl_hw_detect(priv);
3649 IWL_INFO(priv, "Detected %s, REV=0x%X\n",
3650 priv->cfg->name, hw_rev);
3651
3652 err = iwl_trans_register(&priv->trans, priv);
3653 if (err)
3654 goto out_free_traffic_mem;
3655
3656 if (trans_prepare_card_hw(&priv->trans)) {
3657 err = -EIO;
3658 IWL_WARN(priv, "Failed, HW not ready\n");
3659 goto out_free_trans;
3660 }
3661
3662 /*****************
3663 * 4. Read EEPROM
3664 *****************/
3665 /* Read the EEPROM */
3666 err = iwl_eeprom_init(priv, hw_rev);
3667 if (err) {
3668 IWL_ERR(priv, "Unable to init EEPROM\n");
3669 goto out_free_trans;
3670 }
3671 err = iwl_eeprom_check_version(priv);
3672 if (err)
3673 goto out_free_eeprom;
3674
3675 err = iwl_eeprom_check_sku(priv);
3676 if (err)
3677 goto out_free_eeprom;
3678
3679 /* extract MAC Address */
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 }
3691
3692 /************************
3693 * 5. Setup HW constants
3694 ************************/
3695 if (iwl_set_hw_params(priv)) {
3696 err = -ENOENT;
3697 IWL_ERR(priv, "failed to set hw parameters\n");
3698 goto out_free_eeprom;
3699 }
3700
3701 /*******************
3702 * 6. Setup priv
3703 *******************/
3704
3705 err = iwl_init_drv(priv);
3706 if (err)
3707 goto out_free_eeprom;
3708 /* At this point both hw and priv are initialized. */
3709
3710 /********************
3711 * 7. Setup services
3712 ********************/
3713 iwl_setup_deferred_work(priv);
3714 iwl_setup_rx_handlers(priv);
3715 iwl_testmode_init(priv);
3716
3717 /*********************************************
3718 * 8. Enable interrupts
3719 *********************************************/
3720
3721 iwl_enable_rfkill_int(priv);
3722
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);
3728
3729 wiphy_rfkill_set_hw_state(priv->hw->wiphy,
3730 test_bit(STATUS_RF_KILL_HW, &priv->status));
3731
3732 iwl_power_initialize(priv);
3733 iwl_tt_initialize(priv);
3734
3735 init_completion(&priv->firmware_loading_complete);
3736
3737 err = iwl_request_firmware(priv, true);
3738 if (err)
3739 goto out_destroy_workqueue;
3740
3741 return 0;
3742
3743 out_destroy_workqueue:
3744 destroy_workqueue(priv->workqueue);
3745 priv->workqueue = NULL;
3746 iwl_uninit_drv(priv);
3747 out_free_eeprom:
3748 iwl_eeprom_free(priv);
3749 out_free_trans:
3750 trans_free(&priv->trans);
3751 out_free_traffic_mem:
3752 iwl_free_traffic_mem(priv);
3753 ieee80211_free_hw(priv->hw);
3754 out:
3755 return err;
3756 }
3757
3758 void __devexit iwl_remove(struct iwl_priv * priv)
3759 {
3760 unsigned long flags;
3761
3762 wait_for_completion(&priv->firmware_loading_complete);
3763
3764 IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
3765
3766 iwl_dbgfs_unregister(priv);
3767 sysfs_remove_group(&priv->bus->dev->kobj,
3768 &iwl_attribute_group);
3769
3770 /* ieee80211_unregister_hw call wil cause iwl_mac_stop to
3771 * to be called and iwl_down since we are removing the device
3772 * we need to set STATUS_EXIT_PENDING bit.
3773 */
3774 set_bit(STATUS_EXIT_PENDING, &priv->status);
3775
3776 iwl_testmode_cleanup(priv);
3777 iwl_leds_exit(priv);
3778
3779 if (priv->mac80211_registered) {
3780 ieee80211_unregister_hw(priv->hw);
3781 priv->mac80211_registered = 0;
3782 }
3783
3784 /* Reset to low power before unloading driver. */
3785 iwl_apm_stop(priv);
3786
3787 iwl_tt_exit(priv);
3788
3789 /* make sure we flush any pending irq or
3790 * tasklet for the driver
3791 */
3792 spin_lock_irqsave(&priv->lock, flags);
3793 iwl_disable_interrupts(priv);
3794 spin_unlock_irqrestore(&priv->lock, flags);
3795
3796 trans_sync_irq(&priv->trans);
3797
3798 iwl_dealloc_ucode(priv);
3799
3800 trans_rx_free(&priv->trans);
3801 trans_tx_free(&priv->trans);
3802
3803 iwl_eeprom_free(priv);
3804
3805 /*netif_stop_queue(dev); */
3806 flush_workqueue(priv->workqueue);
3807
3808 /* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
3809 * priv->workqueue... so we can't take down the workqueue
3810 * until now... */
3811 destroy_workqueue(priv->workqueue);
3812 priv->workqueue = NULL;
3813 iwl_free_traffic_mem(priv);
3814
3815 trans_free(&priv->trans);
3816
3817 bus_set_drv_data(priv->bus, NULL);
3818
3819 iwl_uninit_drv(priv);
3820
3821 dev_kfree_skb(priv->beacon_skb);
3822
3823 ieee80211_free_hw(priv->hw);
3824 }
3825
3826
3827 /*****************************************************************************
3828 *
3829 * driver and module entry point
3830 *
3831 *****************************************************************************/
3832 static int __init iwl_init(void)
3833 {
3834
3835 int ret;
3836 pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
3837 pr_info(DRV_COPYRIGHT "\n");
3838
3839 ret = iwlagn_rate_control_register();
3840 if (ret) {
3841 pr_err("Unable to register rate control algorithm: %d\n", ret);
3842 return ret;
3843 }
3844
3845 ret = iwl_pci_register_driver();
3846
3847 if (ret)
3848 goto error_register;
3849 return ret;
3850
3851 error_register:
3852 iwlagn_rate_control_unregister();
3853 return ret;
3854 }
3855
3856 static void __exit iwl_exit(void)
3857 {
3858 iwl_pci_unregister_driver();
3859 iwlagn_rate_control_unregister();
3860 }
3861
3862 module_exit(iwl_exit);
3863 module_init(iwl_init);
3864
3865 #ifdef CONFIG_IWLWIFI_DEBUG
3866 module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
3867 MODULE_PARM_DESC(debug, "debug output mask");
3868 #endif
3869
3870 module_param_named(swcrypto, iwlagn_mod_params.sw_crypto, int, S_IRUGO);
3871 MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
3872 module_param_named(queues_num, iwlagn_mod_params.num_of_queues, int, S_IRUGO);
3873 MODULE_PARM_DESC(queues_num, "number of hw queues.");
3874 module_param_named(11n_disable, iwlagn_mod_params.disable_11n, int, S_IRUGO);
3875 MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
3876 module_param_named(amsdu_size_8K, iwlagn_mod_params.amsdu_size_8K,
3877 int, S_IRUGO);
3878 MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
3879 module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO);
3880 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
3881
3882 module_param_named(ucode_alternative, iwlagn_wanted_ucode_alternative, int,
3883 S_IRUGO);
3884 MODULE_PARM_DESC(ucode_alternative,
3885 "specify ucode alternative to use from ucode file");
3886
3887 module_param_named(antenna_coupling, iwlagn_ant_coupling, int, S_IRUGO);
3888 MODULE_PARM_DESC(antenna_coupling,
3889 "specify antenna coupling in dB (defualt: 0 dB)");
3890
3891 module_param_named(bt_ch_inhibition, iwlagn_bt_ch_announce, bool, S_IRUGO);
3892 MODULE_PARM_DESC(bt_ch_inhibition,
3893 "Disable BT channel inhibition (default: enable)");
3894
3895 module_param_named(plcp_check, iwlagn_mod_params.plcp_check, bool, S_IRUGO);
3896 MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])");
3897
3898 module_param_named(ack_check, iwlagn_mod_params.ack_check, bool, S_IRUGO);
3899 MODULE_PARM_DESC(ack_check, "Check ack health (default: 0 [disabled])");
3900
3901 module_param_named(wd_disable, iwlagn_mod_params.wd_disable, bool, S_IRUGO);
3902 MODULE_PARM_DESC(wd_disable,
3903 "Disable stuck queue watchdog timer (default: 0 [enabled])");
3904
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 */
3921 module_param_named(bt_coex_active, iwlagn_mod_params.bt_coex_active,
3922 bool, S_IRUGO);
3923 MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");
3924
3925 module_param_named(led_mode, iwlagn_mod_params.led_mode, int, S_IRUGO);
3926 MODULE_PARM_DESC(led_mode, "0=system default, "
3927 "1=On(RF On)/Off(RF Off), 2=blinking (default: 0)");
3928
3929 module_param_named(power_save, iwlagn_mod_params.power_save,
3930 bool, S_IRUGO);
3931 MODULE_PARM_DESC(power_save,
3932 "enable WiFi power management (default: disable)");
3933
3934 module_param_named(power_level, iwlagn_mod_params.power_level,
3935 int, S_IRUGO);
3936 MODULE_PARM_DESC(power_level,
3937 "default power save level (range from 1 - 5, default: 1)");
3938
3939 /*
3940 * For now, keep using power level 1 instead of automatically
3941 * adjusting ...
3942 */
3943 module_param_named(no_sleep_autoadjust, iwlagn_mod_params.no_sleep_autoadjust,
3944 bool, S_IRUGO);
3945 MODULE_PARM_DESC(no_sleep_autoadjust,
3946 "don't automatically adjust sleep level "
3947 "according to maximum network latency (default: true)");
linux-next