?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwlagn: move context init after firmware loading
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / net / wireless / iwlwifi / iwl-agn.c
blobd5242fba8756a8c97dd41767f0de2ccd8a3d1c3c
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 #ifdef CONFIG_IWL_P2P
684 priv->contexts[IWL_RXON_CTX_PAN].interface_modes |=
685 BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
686 #endif
687 priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;
688 priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;
689 priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
690
691 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
692 }
693
694
695 struct iwlagn_ucode_capabilities {
696 u32 max_probe_length;
697 u32 standard_phy_calibration_size;
698 u32 flags;
699 };
700
701 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
702 static int iwl_mac_setup_register(struct iwl_priv *priv,
703 struct iwlagn_ucode_capabilities *capa);
704
705 #define UCODE_EXPERIMENTAL_INDEX 100
706 #define UCODE_EXPERIMENTAL_TAG "exp"
707
708 static int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first)
709 {
710 const char *name_pre = priv->cfg->fw_name_pre;
711 char tag[8];
712
713 if (first) {
714 #ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
715 priv->fw_index = UCODE_EXPERIMENTAL_INDEX;
716 strcpy(tag, UCODE_EXPERIMENTAL_TAG);
717 } else if (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
718 #endif
719 priv->fw_index = priv->cfg->ucode_api_max;
720 sprintf(tag, "%d", priv->fw_index);
721 } else {
722 priv->fw_index--;
723 sprintf(tag, "%d", priv->fw_index);
724 }
725
726 if (priv->fw_index < priv->cfg->ucode_api_min) {
727 IWL_ERR(priv, "no suitable firmware found!\n");
728 return -ENOENT;
729 }
730
731 sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
732
733 IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
734 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
735 ? "EXPERIMENTAL " : "",
736 priv->firmware_name);
737
738 return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name,
739 priv->bus->dev,
740 GFP_KERNEL, priv, iwl_ucode_callback);
741 }
742
743 struct iwlagn_firmware_pieces {
744 const void *inst, *data, *init, *init_data, *wowlan_inst, *wowlan_data;
745 size_t inst_size, data_size, init_size, init_data_size,
746 wowlan_inst_size, wowlan_data_size;
747
748 u32 build;
749
750 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
751 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
752 };
753
754 static int iwlagn_load_legacy_firmware(struct iwl_priv *priv,
755 const struct firmware *ucode_raw,
756 struct iwlagn_firmware_pieces *pieces)
757 {
758 struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
759 u32 api_ver, hdr_size;
760 const u8 *src;
761
762 priv->ucode_ver = le32_to_cpu(ucode->ver);
763 api_ver = IWL_UCODE_API(priv->ucode_ver);
764
765 switch (api_ver) {
766 default:
767 hdr_size = 28;
768 if (ucode_raw->size < hdr_size) {
769 IWL_ERR(priv, "File size too small!\n");
770 return -EINVAL;
771 }
772 pieces->build = le32_to_cpu(ucode->u.v2.build);
773 pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
774 pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
775 pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
776 pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
777 src = ucode->u.v2.data;
778 break;
779 case 0:
780 case 1:
781 case 2:
782 hdr_size = 24;
783 if (ucode_raw->size < hdr_size) {
784 IWL_ERR(priv, "File size too small!\n");
785 return -EINVAL;
786 }
787 pieces->build = 0;
788 pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
789 pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
790 pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
791 pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
792 src = ucode->u.v1.data;
793 break;
794 }
795
796 /* Verify size of file vs. image size info in file's header */
797 if (ucode_raw->size != hdr_size + pieces->inst_size +
798 pieces->data_size + pieces->init_size +
799 pieces->init_data_size) {
800
801 IWL_ERR(priv,
802 "uCode file size %d does not match expected size\n",
803 (int)ucode_raw->size);
804 return -EINVAL;
805 }
806
807 pieces->inst = src;
808 src += pieces->inst_size;
809 pieces->data = src;
810 src += pieces->data_size;
811 pieces->init = src;
812 src += pieces->init_size;
813 pieces->init_data = src;
814 src += pieces->init_data_size;
815
816 return 0;
817 }
818
819 static int iwlagn_wanted_ucode_alternative = 1;
820
821 static int iwlagn_load_firmware(struct iwl_priv *priv,
822 const struct firmware *ucode_raw,
823 struct iwlagn_firmware_pieces *pieces,
824 struct iwlagn_ucode_capabilities *capa)
825 {
826 struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
827 struct iwl_ucode_tlv *tlv;
828 size_t len = ucode_raw->size;
829 const u8 *data;
830 int wanted_alternative = iwlagn_wanted_ucode_alternative, tmp;
831 u64 alternatives;
832 u32 tlv_len;
833 enum iwl_ucode_tlv_type tlv_type;
834 const u8 *tlv_data;
835
836 if (len < sizeof(*ucode)) {
837 IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
838 return -EINVAL;
839 }
840
841 if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
842 IWL_ERR(priv, "invalid uCode magic: 0X%x\n",
843 le32_to_cpu(ucode->magic));
844 return -EINVAL;
845 }
846
847 /*
848 * Check which alternatives are present, and "downgrade"
849 * when the chosen alternative is not present, warning
850 * the user when that happens. Some files may not have
851 * any alternatives, so don't warn in that case.
852 */
853 alternatives = le64_to_cpu(ucode->alternatives);
854 tmp = wanted_alternative;
855 if (wanted_alternative > 63)
856 wanted_alternative = 63;
857 while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
858 wanted_alternative--;
859 if (wanted_alternative && wanted_alternative != tmp)
860 IWL_WARN(priv,
861 "uCode alternative %d not available, choosing %d\n",
862 tmp, wanted_alternative);
863
864 priv->ucode_ver = le32_to_cpu(ucode->ver);
865 pieces->build = le32_to_cpu(ucode->build);
866 data = ucode->data;
867
868 len -= sizeof(*ucode);
869
870 while (len >= sizeof(*tlv)) {
871 u16 tlv_alt;
872
873 len -= sizeof(*tlv);
874 tlv = (void *)data;
875
876 tlv_len = le32_to_cpu(tlv->length);
877 tlv_type = le16_to_cpu(tlv->type);
878 tlv_alt = le16_to_cpu(tlv->alternative);
879 tlv_data = tlv->data;
880
881 if (len < tlv_len) {
882 IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
883 len, tlv_len);
884 return -EINVAL;
885 }
886 len -= ALIGN(tlv_len, 4);
887 data += sizeof(*tlv) + ALIGN(tlv_len, 4);
888
889 /*
890 * Alternative 0 is always valid.
891 *
892 * Skip alternative TLVs that are not selected.
893 */
894 if (tlv_alt != 0 && tlv_alt != wanted_alternative)
895 continue;
896
897 switch (tlv_type) {
898 case IWL_UCODE_TLV_INST:
899 pieces->inst = tlv_data;
900 pieces->inst_size = tlv_len;
901 break;
902 case IWL_UCODE_TLV_DATA:
903 pieces->data = tlv_data;
904 pieces->data_size = tlv_len;
905 break;
906 case IWL_UCODE_TLV_INIT:
907 pieces->init = tlv_data;
908 pieces->init_size = tlv_len;
909 break;
910 case IWL_UCODE_TLV_INIT_DATA:
911 pieces->init_data = tlv_data;
912 pieces->init_data_size = tlv_len;
913 break;
914 case IWL_UCODE_TLV_BOOT:
915 IWL_ERR(priv, "Found unexpected BOOT ucode\n");
916 break;
917 case IWL_UCODE_TLV_PROBE_MAX_LEN:
918 if (tlv_len != sizeof(u32))
919 goto invalid_tlv_len;
920 capa->max_probe_length =
921 le32_to_cpup((__le32 *)tlv_data);
922 break;
923 case IWL_UCODE_TLV_PAN:
924 if (tlv_len)
925 goto invalid_tlv_len;
926 capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
927 break;
928 case IWL_UCODE_TLV_FLAGS:
929 /* must be at least one u32 */
930 if (tlv_len < sizeof(u32))
931 goto invalid_tlv_len;
932 /* and a proper number of u32s */
933 if (tlv_len % sizeof(u32))
934 goto invalid_tlv_len;
935 /*
936 * This driver only reads the first u32 as
937 * right now no more features are defined,
938 * if that changes then either the driver
939 * will not work with the new firmware, or
940 * it'll not take advantage of new features.
941 */
942 capa->flags = le32_to_cpup((__le32 *)tlv_data);
943 break;
944 case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
945 if (tlv_len != sizeof(u32))
946 goto invalid_tlv_len;
947 pieces->init_evtlog_ptr =
948 le32_to_cpup((__le32 *)tlv_data);
949 break;
950 case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
951 if (tlv_len != sizeof(u32))
952 goto invalid_tlv_len;
953 pieces->init_evtlog_size =
954 le32_to_cpup((__le32 *)tlv_data);
955 break;
956 case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
957 if (tlv_len != sizeof(u32))
958 goto invalid_tlv_len;
959 pieces->init_errlog_ptr =
960 le32_to_cpup((__le32 *)tlv_data);
961 break;
962 case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
963 if (tlv_len != sizeof(u32))
964 goto invalid_tlv_len;
965 pieces->inst_evtlog_ptr =
966 le32_to_cpup((__le32 *)tlv_data);
967 break;
968 case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
969 if (tlv_len != sizeof(u32))
970 goto invalid_tlv_len;
971 pieces->inst_evtlog_size =
972 le32_to_cpup((__le32 *)tlv_data);
973 break;
974 case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
975 if (tlv_len != sizeof(u32))
976 goto invalid_tlv_len;
977 pieces->inst_errlog_ptr =
978 le32_to_cpup((__le32 *)tlv_data);
979 break;
980 case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
981 if (tlv_len)
982 goto invalid_tlv_len;
983 priv->enhance_sensitivity_table = true;
984 break;
985 case IWL_UCODE_TLV_WOWLAN_INST:
986 pieces->wowlan_inst = tlv_data;
987 pieces->wowlan_inst_size = tlv_len;
988 break;
989 case IWL_UCODE_TLV_WOWLAN_DATA:
990 pieces->wowlan_data = tlv_data;
991 pieces->wowlan_data_size = tlv_len;
992 break;
993 case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
994 if (tlv_len != sizeof(u32))
995 goto invalid_tlv_len;
996 capa->standard_phy_calibration_size =
997 le32_to_cpup((__le32 *)tlv_data);
998 break;
999 default:
1000 IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type);
1001 break;
1002 }
1003 }
1004
1005 if (len) {
1006 IWL_ERR(priv, "invalid TLV after parsing: %zd\n", len);
1007 iwl_print_hex_dump(priv, IWL_DL_FW, (u8 *)data, len);
1008 return -EINVAL;
1009 }
1010
1011 return 0;
1012
1013 invalid_tlv_len:
1014 IWL_ERR(priv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
1015 iwl_print_hex_dump(priv, IWL_DL_FW, tlv_data, tlv_len);
1016
1017 return -EINVAL;
1018 }
1019
1020 /**
1021 * iwl_ucode_callback - callback when firmware was loaded
1022 *
1023 * If loaded successfully, copies the firmware into buffers
1024 * for the card to fetch (via DMA).
1025 */
1026 static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
1027 {
1028 struct iwl_priv *priv = context;
1029 struct iwl_ucode_header *ucode;
1030 int err;
1031 struct iwlagn_firmware_pieces pieces;
1032 const unsigned int api_max = priv->cfg->ucode_api_max;
1033 unsigned int api_ok = priv->cfg->ucode_api_ok;
1034 const unsigned int api_min = priv->cfg->ucode_api_min;
1035 u32 api_ver;
1036 char buildstr[25];
1037 u32 build;
1038 struct iwlagn_ucode_capabilities ucode_capa = {
1039 .max_probe_length = 200,
1040 .standard_phy_calibration_size =
1041 IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE,
1042 };
1043
1044 if (!api_ok)
1045 api_ok = api_max;
1046
1047 memset(&pieces, 0, sizeof(pieces));
1048
1049 if (!ucode_raw) {
1050 if (priv->fw_index <= api_ok)
1051 IWL_ERR(priv,
1052 "request for firmware file '%s' failed.\n",
1053 priv->firmware_name);
1054 goto try_again;
1055 }
1056
1057 IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
1058 priv->firmware_name, ucode_raw->size);
1059
1060 /* Make sure that we got at least the API version number */
1061 if (ucode_raw->size < 4) {
1062 IWL_ERR(priv, "File size way too small!\n");
1063 goto try_again;
1064 }
1065
1066 /* Data from ucode file: header followed by uCode images */
1067 ucode = (struct iwl_ucode_header *)ucode_raw->data;
1068
1069 if (ucode->ver)
1070 err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
1071 else
1072 err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
1073 &ucode_capa);
1074
1075 if (err)
1076 goto try_again;
1077
1078 api_ver = IWL_UCODE_API(priv->ucode_ver);
1079 build = pieces.build;
1080
1081 /*
1082 * api_ver should match the api version forming part of the
1083 * firmware filename ... but we don't check for that and only rely
1084 * on the API version read from firmware header from here on forward
1085 */
1086 /* no api version check required for experimental uCode */
1087 if (priv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
1088 if (api_ver < api_min || api_ver > api_max) {
1089 IWL_ERR(priv,
1090 "Driver unable to support your firmware API. "
1091 "Driver supports v%u, firmware is v%u.\n",
1092 api_max, api_ver);
1093 goto try_again;
1094 }
1095
1096 if (api_ver < api_ok) {
1097 if (api_ok != api_max)
1098 IWL_ERR(priv, "Firmware has old API version, "
1099 "expected v%u through v%u, got v%u.\n",
1100 api_ok, api_max, api_ver);
1101 else
1102 IWL_ERR(priv, "Firmware has old API version, "
1103 "expected v%u, got v%u.\n",
1104 api_max, api_ver);
1105 IWL_ERR(priv, "New firmware can be obtained from "
1106 "http://www.intellinuxwireless.org/.\n");
1107 }
1108 }
1109
1110 if (build)
1111 sprintf(buildstr, " build %u%s", build,
1112 (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
1113 ? " (EXP)" : "");
1114 else
1115 buildstr[0] = '\0';
1116
1117 IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u%s\n",
1118 IWL_UCODE_MAJOR(priv->ucode_ver),
1119 IWL_UCODE_MINOR(priv->ucode_ver),
1120 IWL_UCODE_API(priv->ucode_ver),
1121 IWL_UCODE_SERIAL(priv->ucode_ver),
1122 buildstr);
1123
1124 snprintf(priv->hw->wiphy->fw_version,
1125 sizeof(priv->hw->wiphy->fw_version),
1126 "%u.%u.%u.%u%s",
1127 IWL_UCODE_MAJOR(priv->ucode_ver),
1128 IWL_UCODE_MINOR(priv->ucode_ver),
1129 IWL_UCODE_API(priv->ucode_ver),
1130 IWL_UCODE_SERIAL(priv->ucode_ver),
1131 buildstr);
1132
1133 /*
1134 * For any of the failures below (before allocating pci memory)
1135 * we will try to load a version with a smaller API -- maybe the
1136 * user just got a corrupted version of the latest API.
1137 */
1138
1139 IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
1140 priv->ucode_ver);
1141 IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %Zd\n",
1142 pieces.inst_size);
1143 IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %Zd\n",
1144 pieces.data_size);
1145 IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %Zd\n",
1146 pieces.init_size);
1147 IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %Zd\n",
1148 pieces.init_data_size);
1149
1150 /* Verify that uCode images will fit in card's SRAM */
1151 if (pieces.inst_size > priv->hw_params.max_inst_size) {
1152 IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n",
1153 pieces.inst_size);
1154 goto try_again;
1155 }
1156
1157 if (pieces.data_size > priv->hw_params.max_data_size) {
1158 IWL_ERR(priv, "uCode data len %Zd too large to fit in\n",
1159 pieces.data_size);
1160 goto try_again;
1161 }
1162
1163 if (pieces.init_size > priv->hw_params.max_inst_size) {
1164 IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n",
1165 pieces.init_size);
1166 goto try_again;
1167 }
1168
1169 if (pieces.init_data_size > priv->hw_params.max_data_size) {
1170 IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n",
1171 pieces.init_data_size);
1172 goto try_again;
1173 }
1174
1175 /* Allocate ucode buffers for card's bus-master loading ... */
1176
1177 /* Runtime instructions and 2 copies of data:
1178 * 1) unmodified from disk
1179 * 2) backup cache for save/restore during power-downs */
1180 if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.code,
1181 pieces.inst, pieces.inst_size))
1182 goto err_pci_alloc;
1183 if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.data,
1184 pieces.data, pieces.data_size))
1185 goto err_pci_alloc;
1186
1187 /* Initialization instructions and data */
1188 if (pieces.init_size && pieces.init_data_size) {
1189 if (iwl_alloc_fw_desc(priv, &priv->ucode_init.code,
1190 pieces.init, pieces.init_size))
1191 goto err_pci_alloc;
1192 if (iwl_alloc_fw_desc(priv, &priv->ucode_init.data,
1193 pieces.init_data, pieces.init_data_size))
1194 goto err_pci_alloc;
1195 }
1196
1197 /* WoWLAN instructions and data */
1198 if (pieces.wowlan_inst_size && pieces.wowlan_data_size) {
1199 if (iwl_alloc_fw_desc(priv, &priv->ucode_wowlan.code,
1200 pieces.wowlan_inst,
1201 pieces.wowlan_inst_size))
1202 goto err_pci_alloc;
1203 if (iwl_alloc_fw_desc(priv, &priv->ucode_wowlan.data,
1204 pieces.wowlan_data,
1205 pieces.wowlan_data_size))
1206 goto err_pci_alloc;
1207 }
1208
1209 /* Now that we can no longer fail, copy information */
1210
1211 /*
1212 * The (size - 16) / 12 formula is based on the information recorded
1213 * for each event, which is of mode 1 (including timestamp) for all
1214 * new microcodes that include this information.
1215 */
1216 priv->init_evtlog_ptr = pieces.init_evtlog_ptr;
1217 if (pieces.init_evtlog_size)
1218 priv->init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
1219 else
1220 priv->init_evtlog_size =
1221 priv->cfg->base_params->max_event_log_size;
1222 priv->init_errlog_ptr = pieces.init_errlog_ptr;
1223 priv->inst_evtlog_ptr = pieces.inst_evtlog_ptr;
1224 if (pieces.inst_evtlog_size)
1225 priv->inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
1226 else
1227 priv->inst_evtlog_size =
1228 priv->cfg->base_params->max_event_log_size;
1229 priv->inst_errlog_ptr = pieces.inst_errlog_ptr;
1230
1231 priv->new_scan_threshold_behaviour =
1232 !!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
1233
1234 if (!(priv->cfg->sku & EEPROM_SKU_CAP_IPAN_ENABLE))
1235 ucode_capa.flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
1236
1237 if (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN) {
1238 priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
1239 priv->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
1240 } else {
1241 priv->sta_key_max_num = STA_KEY_MAX_NUM;
1242 priv->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
1243 }
1244
1245 /*
1246 * figure out the offset of chain noise reset and gain commands
1247 * base on the size of standard phy calibration commands table size
1248 */
1249 if (ucode_capa.standard_phy_calibration_size >
1250 IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
1251 ucode_capa.standard_phy_calibration_size =
1252 IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
1253
1254 priv->phy_calib_chain_noise_reset_cmd =
1255 ucode_capa.standard_phy_calibration_size;
1256 priv->phy_calib_chain_noise_gain_cmd =
1257 ucode_capa.standard_phy_calibration_size + 1;
1258
1259 /* initialize all valid contexts */
1260 iwl_init_context(priv, ucode_capa.flags);
1261
1262 /**************************************************
1263 * This is still part of probe() in a sense...
1264 *
1265 * 9. Setup and register with mac80211 and debugfs
1266 **************************************************/
1267 err = iwl_mac_setup_register(priv, &ucode_capa);
1268 if (err)
1269 goto out_unbind;
1270
1271 err = iwl_dbgfs_register(priv, DRV_NAME);
1272 if (err)
1273 IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);
1274
1275 err = sysfs_create_group(&(priv->bus->dev->kobj),
1276 &iwl_attribute_group);
1277 if (err) {
1278 IWL_ERR(priv, "failed to create sysfs device attributes\n");
1279 goto out_unbind;
1280 }
1281
1282 /* We have our copies now, allow OS release its copies */
1283 release_firmware(ucode_raw);
1284 complete(&priv->firmware_loading_complete);
1285 return;
1286
1287 try_again:
1288 /* try next, if any */
1289 if (iwl_request_firmware(priv, false))
1290 goto out_unbind;
1291 release_firmware(ucode_raw);
1292 return;
1293
1294 err_pci_alloc:
1295 IWL_ERR(priv, "failed to allocate pci memory\n");
1296 iwl_dealloc_ucode(priv);
1297 out_unbind:
1298 complete(&priv->firmware_loading_complete);
1299 device_release_driver(priv->bus->dev);
1300 release_firmware(ucode_raw);
1301 }
1302
1303 static const char * const desc_lookup_text[] = {
1304 "OK",
1305 "FAIL",
1306 "BAD_PARAM",
1307 "BAD_CHECKSUM",
1308 "NMI_INTERRUPT_WDG",
1309 "SYSASSERT",
1310 "FATAL_ERROR",
1311 "BAD_COMMAND",
1312 "HW_ERROR_TUNE_LOCK",
1313 "HW_ERROR_TEMPERATURE",
1314 "ILLEGAL_CHAN_FREQ",
1315 "VCC_NOT_STABLE",
1316 "FH_ERROR",
1317 "NMI_INTERRUPT_HOST",
1318 "NMI_INTERRUPT_ACTION_PT",
1319 "NMI_INTERRUPT_UNKNOWN",
1320 "UCODE_VERSION_MISMATCH",
1321 "HW_ERROR_ABS_LOCK",
1322 "HW_ERROR_CAL_LOCK_FAIL",
1323 "NMI_INTERRUPT_INST_ACTION_PT",
1324 "NMI_INTERRUPT_DATA_ACTION_PT",
1325 "NMI_TRM_HW_ER",
1326 "NMI_INTERRUPT_TRM",
1327 "NMI_INTERRUPT_BREAK_POINT",
1328 "DEBUG_0",
1329 "DEBUG_1",
1330 "DEBUG_2",
1331 "DEBUG_3",
1332 };
1333
1334 static struct { char *name; u8 num; } advanced_lookup[] = {
1335 { "NMI_INTERRUPT_WDG", 0x34 },
1336 { "SYSASSERT", 0x35 },
1337 { "UCODE_VERSION_MISMATCH", 0x37 },
1338 { "BAD_COMMAND", 0x38 },
1339 { "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C },
1340 { "FATAL_ERROR", 0x3D },
1341 { "NMI_TRM_HW_ERR", 0x46 },
1342 { "NMI_INTERRUPT_TRM", 0x4C },
1343 { "NMI_INTERRUPT_BREAK_POINT", 0x54 },
1344 { "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C },
1345 { "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64 },
1346 { "NMI_INTERRUPT_HOST", 0x66 },
1347 { "NMI_INTERRUPT_ACTION_PT", 0x7C },
1348 { "NMI_INTERRUPT_UNKNOWN", 0x84 },
1349 { "NMI_INTERRUPT_INST_ACTION_PT", 0x86 },
1350 { "ADVANCED_SYSASSERT", 0 },
1351 };
1352
1353 static const char *desc_lookup(u32 num)
1354 {
1355 int i;
1356 int max = ARRAY_SIZE(desc_lookup_text);
1357
1358 if (num < max)
1359 return desc_lookup_text[num];
1360
1361 max = ARRAY_SIZE(advanced_lookup) - 1;
1362 for (i = 0; i < max; i++) {
1363 if (advanced_lookup[i].num == num)
1364 break;
1365 }
1366 return advanced_lookup[i].name;
1367 }
1368
1369 #define ERROR_START_OFFSET (1 * sizeof(u32))
1370 #define ERROR_ELEM_SIZE (7 * sizeof(u32))
1371
1372 void iwl_dump_nic_error_log(struct iwl_priv *priv)
1373 {
1374 u32 base;
1375 struct iwl_error_event_table table;
1376
1377 base = priv->device_pointers.error_event_table;
1378 if (priv->ucode_type == IWL_UCODE_INIT) {
1379 if (!base)
1380 base = priv->init_errlog_ptr;
1381 } else {
1382 if (!base)
1383 base = priv->inst_errlog_ptr;
1384 }
1385
1386 if (!iwlagn_hw_valid_rtc_data_addr(base)) {
1387 IWL_ERR(priv,
1388 "Not valid error log pointer 0x%08X for %s uCode\n",
1389 base,
1390 (priv->ucode_type == IWL_UCODE_INIT)
1391 ? "Init" : "RT");
1392 return;
1393 }
1394
1395 iwl_read_targ_mem_words(priv, base, &table, sizeof(table));
1396
1397 if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
1398 IWL_ERR(priv, "Start IWL Error Log Dump:\n");
1399 IWL_ERR(priv, "Status: 0x%08lX, count: %d\n",
1400 priv->status, table.valid);
1401 }
1402
1403 priv->isr_stats.err_code = table.error_id;
1404
1405 trace_iwlwifi_dev_ucode_error(priv, table.error_id, table.tsf_low,
1406 table.data1, table.data2, table.line,
1407 table.blink1, table.blink2, table.ilink1,
1408 table.ilink2, table.bcon_time, table.gp1,
1409 table.gp2, table.gp3, table.ucode_ver,
1410 table.hw_ver, table.brd_ver);
1411 IWL_ERR(priv, "0x%08X | %-28s\n", table.error_id,
1412 desc_lookup(table.error_id));
1413 IWL_ERR(priv, "0x%08X | uPc\n", table.pc);
1414 IWL_ERR(priv, "0x%08X | branchlink1\n", table.blink1);
1415 IWL_ERR(priv, "0x%08X | branchlink2\n", table.blink2);
1416 IWL_ERR(priv, "0x%08X | interruptlink1\n", table.ilink1);
1417 IWL_ERR(priv, "0x%08X | interruptlink2\n", table.ilink2);
1418 IWL_ERR(priv, "0x%08X | data1\n", table.data1);
1419 IWL_ERR(priv, "0x%08X | data2\n", table.data2);
1420 IWL_ERR(priv, "0x%08X | line\n", table.line);
1421 IWL_ERR(priv, "0x%08X | beacon time\n", table.bcon_time);
1422 IWL_ERR(priv, "0x%08X | tsf low\n", table.tsf_low);
1423 IWL_ERR(priv, "0x%08X | tsf hi\n", table.tsf_hi);
1424 IWL_ERR(priv, "0x%08X | time gp1\n", table.gp1);
1425 IWL_ERR(priv, "0x%08X | time gp2\n", table.gp2);
1426 IWL_ERR(priv, "0x%08X | time gp3\n", table.gp3);
1427 IWL_ERR(priv, "0x%08X | uCode version\n", table.ucode_ver);
1428 IWL_ERR(priv, "0x%08X | hw version\n", table.hw_ver);
1429 IWL_ERR(priv, "0x%08X | board version\n", table.brd_ver);
1430 IWL_ERR(priv, "0x%08X | hcmd\n", table.hcmd);
1431 }
1432
1433 #define EVENT_START_OFFSET (4 * sizeof(u32))
1434
1435 /**
1436 * iwl_print_event_log - Dump error event log to syslog
1437 *
1438 */
1439 static int iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
1440 u32 num_events, u32 mode,
1441 int pos, char **buf, size_t bufsz)
1442 {
1443 u32 i;
1444 u32 base; /* SRAM byte address of event log header */
1445 u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
1446 u32 ptr; /* SRAM byte address of log data */
1447 u32 ev, time, data; /* event log data */
1448 unsigned long reg_flags;
1449
1450 if (num_events == 0)
1451 return pos;
1452
1453 base = priv->device_pointers.log_event_table;
1454 if (priv->ucode_type == IWL_UCODE_INIT) {
1455 if (!base)
1456 base = priv->init_evtlog_ptr;
1457 } else {
1458 if (!base)
1459 base = priv->inst_evtlog_ptr;
1460 }
1461
1462 if (mode == 0)
1463 event_size = 2 * sizeof(u32);
1464 else
1465 event_size = 3 * sizeof(u32);
1466
1467 ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
1468
1469 /* Make sure device is powered up for SRAM reads */
1470 spin_lock_irqsave(&priv->reg_lock, reg_flags);
1471 iwl_grab_nic_access(priv);
1472
1473 /* Set starting address; reads will auto-increment */
1474 iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
1475 rmb();
1476
1477 /* "time" is actually "data" for mode 0 (no timestamp).
1478 * place event id # at far right for easier visual parsing. */
1479 for (i = 0; i < num_events; i++) {
1480 ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
1481 time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
1482 if (mode == 0) {
1483 /* data, ev */
1484 if (bufsz) {
1485 pos += scnprintf(*buf + pos, bufsz - pos,
1486 "EVT_LOG:0x%08x:%04u\n",
1487 time, ev);
1488 } else {
1489 trace_iwlwifi_dev_ucode_event(priv, 0,
1490 time, ev);
1491 IWL_ERR(priv, "EVT_LOG:0x%08x:%04u\n",
1492 time, ev);
1493 }
1494 } else {
1495 data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
1496 if (bufsz) {
1497 pos += scnprintf(*buf + pos, bufsz - pos,
1498 "EVT_LOGT:%010u:0x%08x:%04u\n",
1499 time, data, ev);
1500 } else {
1501 IWL_ERR(priv, "EVT_LOGT:%010u:0x%08x:%04u\n",
1502 time, data, ev);
1503 trace_iwlwifi_dev_ucode_event(priv, time,
1504 data, ev);
1505 }
1506 }
1507 }
1508
1509 /* Allow device to power down */
1510 iwl_release_nic_access(priv);
1511 spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
1512 return pos;
1513 }
1514
1515 /**
1516 * iwl_print_last_event_logs - Dump the newest # of event log to syslog
1517 */
1518 static int iwl_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
1519 u32 num_wraps, u32 next_entry,
1520 u32 size, u32 mode,
1521 int pos, char **buf, size_t bufsz)
1522 {
1523 /*
1524 * display the newest DEFAULT_LOG_ENTRIES entries
1525 * i.e the entries just before the next ont that uCode would fill.
1526 */
1527 if (num_wraps) {
1528 if (next_entry < size) {
1529 pos = iwl_print_event_log(priv,
1530 capacity - (size - next_entry),
1531 size - next_entry, mode,
1532 pos, buf, bufsz);
1533 pos = iwl_print_event_log(priv, 0,
1534 next_entry, mode,
1535 pos, buf, bufsz);
1536 } else
1537 pos = iwl_print_event_log(priv, next_entry - size,
1538 size, mode, pos, buf, bufsz);
1539 } else {
1540 if (next_entry < size) {
1541 pos = iwl_print_event_log(priv, 0, next_entry,
1542 mode, pos, buf, bufsz);
1543 } else {
1544 pos = iwl_print_event_log(priv, next_entry - size,
1545 size, mode, pos, buf, bufsz);
1546 }
1547 }
1548 return pos;
1549 }
1550
1551 #define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
1552
1553 int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
1554 char **buf, bool display)
1555 {
1556 u32 base; /* SRAM byte address of event log header */
1557 u32 capacity; /* event log capacity in # entries */
1558 u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
1559 u32 num_wraps; /* # times uCode wrapped to top of log */
1560 u32 next_entry; /* index of next entry to be written by uCode */
1561 u32 size; /* # entries that we'll print */
1562 u32 logsize;
1563 int pos = 0;
1564 size_t bufsz = 0;
1565
1566 base = priv->device_pointers.log_event_table;
1567 if (priv->ucode_type == IWL_UCODE_INIT) {
1568 logsize = priv->init_evtlog_size;
1569 if (!base)
1570 base = priv->init_evtlog_ptr;
1571 } else {
1572 logsize = priv->inst_evtlog_size;
1573 if (!base)
1574 base = priv->inst_evtlog_ptr;
1575 }
1576
1577 if (!iwlagn_hw_valid_rtc_data_addr(base)) {
1578 IWL_ERR(priv,
1579 "Invalid event log pointer 0x%08X for %s uCode\n",
1580 base,
1581 (priv->ucode_type == IWL_UCODE_INIT)
1582 ? "Init" : "RT");
1583 return -EINVAL;
1584 }
1585
1586 /* event log header */
1587 capacity = iwl_read_targ_mem(priv, base);
1588 mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
1589 num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
1590 next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
1591
1592 if (capacity > logsize) {
1593 IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
1594 capacity, logsize);
1595 capacity = logsize;
1596 }
1597
1598 if (next_entry > logsize) {
1599 IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
1600 next_entry, logsize);
1601 next_entry = logsize;
1602 }
1603
1604 size = num_wraps ? capacity : next_entry;
1605
1606 /* bail out if nothing in log */
1607 if (size == 0) {
1608 IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
1609 return pos;
1610 }
1611
1612 /* enable/disable bt channel inhibition */
1613 priv->bt_ch_announce = iwlagn_bt_ch_announce;
1614
1615 #ifdef CONFIG_IWLWIFI_DEBUG
1616 if (!(iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
1617 size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
1618 ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
1619 #else
1620 size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
1621 ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
1622 #endif
1623 IWL_ERR(priv, "Start IWL Event Log Dump: display last %u entries\n",
1624 size);
1625
1626 #ifdef CONFIG_IWLWIFI_DEBUG
1627 if (display) {
1628 if (full_log)
1629 bufsz = capacity * 48;
1630 else
1631 bufsz = size * 48;
1632 *buf = kmalloc(bufsz, GFP_KERNEL);
1633 if (!*buf)
1634 return -ENOMEM;
1635 }
1636 if ((iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) || full_log) {
1637 /*
1638 * if uCode has wrapped back to top of log,
1639 * start at the oldest entry,
1640 * i.e the next one that uCode would fill.
1641 */
1642 if (num_wraps)
1643 pos = iwl_print_event_log(priv, next_entry,
1644 capacity - next_entry, mode,
1645 pos, buf, bufsz);
1646 /* (then/else) start at top of log */
1647 pos = iwl_print_event_log(priv, 0,
1648 next_entry, mode, pos, buf, bufsz);
1649 } else
1650 pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
1651 next_entry, size, mode,
1652 pos, buf, bufsz);
1653 #else
1654 pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
1655 next_entry, size, mode,
1656 pos, buf, bufsz);
1657 #endif
1658 return pos;
1659 }
1660
1661 static void iwl_rf_kill_ct_config(struct iwl_priv *priv)
1662 {
1663 struct iwl_ct_kill_config cmd;
1664 struct iwl_ct_kill_throttling_config adv_cmd;
1665 unsigned long flags;
1666 int ret = 0;
1667
1668 spin_lock_irqsave(&priv->lock, flags);
1669 iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
1670 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
1671 spin_unlock_irqrestore(&priv->lock, flags);
1672 priv->thermal_throttle.ct_kill_toggle = false;
1673
1674 if (priv->cfg->base_params->support_ct_kill_exit) {
1675 adv_cmd.critical_temperature_enter =
1676 cpu_to_le32(priv->hw_params.ct_kill_threshold);
1677 adv_cmd.critical_temperature_exit =
1678 cpu_to_le32(priv->hw_params.ct_kill_exit_threshold);
1679
1680 ret = trans_send_cmd_pdu(&priv->trans,
1681 REPLY_CT_KILL_CONFIG_CMD,
1682 CMD_SYNC, sizeof(adv_cmd), &adv_cmd);
1683 if (ret)
1684 IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
1685 else
1686 IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
1687 "succeeded, "
1688 "critical temperature enter is %d,"
1689 "exit is %d\n",
1690 priv->hw_params.ct_kill_threshold,
1691 priv->hw_params.ct_kill_exit_threshold);
1692 } else {
1693 cmd.critical_temperature_R =
1694 cpu_to_le32(priv->hw_params.ct_kill_threshold);
1695
1696 ret = trans_send_cmd_pdu(&priv->trans,
1697 REPLY_CT_KILL_CONFIG_CMD,
1698 CMD_SYNC, sizeof(cmd), &cmd);
1699 if (ret)
1700 IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
1701 else
1702 IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
1703 "succeeded, "
1704 "critical temperature is %d\n",
1705 priv->hw_params.ct_kill_threshold);
1706 }
1707 }
1708
1709 static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg)
1710 {
1711 struct iwl_calib_cfg_cmd calib_cfg_cmd;
1712 struct iwl_host_cmd cmd = {
1713 .id = CALIBRATION_CFG_CMD,
1714 .len = { sizeof(struct iwl_calib_cfg_cmd), },
1715 .data = { &calib_cfg_cmd, },
1716 };
1717
1718 memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
1719 calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
1720 calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
1721
1722 return trans_send_cmd(&priv->trans, &cmd);
1723 }
1724
1725
1726 static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
1727 {
1728 struct iwl_tx_ant_config_cmd tx_ant_cmd = {
1729 .valid = cpu_to_le32(valid_tx_ant),
1730 };
1731
1732 if (IWL_UCODE_API(priv->ucode_ver) > 1) {
1733 IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
1734 return trans_send_cmd_pdu(&priv->trans,
1735 TX_ANT_CONFIGURATION_CMD,
1736 CMD_SYNC,
1737 sizeof(struct iwl_tx_ant_config_cmd),
1738 &tx_ant_cmd);
1739 } else {
1740 IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
1741 return -EOPNOTSUPP;
1742 }
1743 }
1744
1745 /**
1746 * iwl_alive_start - called after REPLY_ALIVE notification received
1747 * from protocol/runtime uCode (initialization uCode's
1748 * Alive gets handled by iwl_init_alive_start()).
1749 */
1750 int iwl_alive_start(struct iwl_priv *priv)
1751 {
1752 int ret = 0;
1753 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
1754
1755 /*TODO: this should go to the transport layer */
1756 iwl_reset_ict(priv);
1757
1758 IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
1759
1760 /* After the ALIVE response, we can send host commands to the uCode */
1761 set_bit(STATUS_ALIVE, &priv->status);
1762
1763 /* Enable watchdog to monitor the driver tx queues */
1764 iwl_setup_watchdog(priv);
1765
1766 if (iwl_is_rfkill(priv))
1767 return -ERFKILL;
1768
1769 /* download priority table before any calibration request */
1770 if (priv->cfg->bt_params &&
1771 priv->cfg->bt_params->advanced_bt_coexist) {
1772 /* Configure Bluetooth device coexistence support */
1773 if (priv->cfg->bt_params->bt_sco_disable)
1774 priv->bt_enable_pspoll = false;
1775 else
1776 priv->bt_enable_pspoll = true;
1777
1778 priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
1779 priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
1780 priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
1781 iwlagn_send_advance_bt_config(priv);
1782 priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
1783 priv->cur_rssi_ctx = NULL;
1784
1785 iwlagn_send_prio_tbl(priv);
1786
1787 /* FIXME: w/a to force change uCode BT state machine */
1788 ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
1789 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
1790 if (ret)
1791 return ret;
1792 ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
1793 BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
1794 if (ret)
1795 return ret;
1796 } else {
1797 /*
1798 * default is 2-wire BT coexexistence support
1799 */
1800 iwl_send_bt_config(priv);
1801 }
1802
1803 if (priv->hw_params.calib_rt_cfg)
1804 iwlagn_send_calib_cfg_rt(priv, priv->hw_params.calib_rt_cfg);
1805
1806 ieee80211_wake_queues(priv->hw);
1807
1808 priv->active_rate = IWL_RATES_MASK;
1809
1810 /* Configure Tx antenna selection based on H/W config */
1811 iwlagn_send_tx_ant_config(priv, priv->cfg->valid_tx_ant);
1812
1813 if (iwl_is_associated_ctx(ctx) && !priv->wowlan) {
1814 struct iwl_rxon_cmd *active_rxon =
1815 (struct iwl_rxon_cmd *)&ctx->active;
1816 /* apply any changes in staging */
1817 ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
1818 active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
1819 } else {
1820 struct iwl_rxon_context *tmp;
1821 /* Initialize our rx_config data */
1822 for_each_context(priv, tmp)
1823 iwl_connection_init_rx_config(priv, tmp);
1824
1825 iwlagn_set_rxon_chain(priv, ctx);
1826 }
1827
1828 if (!priv->wowlan) {
1829 /* WoWLAN ucode will not reply in the same way, skip it */
1830 iwl_reset_run_time_calib(priv);
1831 }
1832
1833 set_bit(STATUS_READY, &priv->status);
1834
1835 /* Configure the adapter for unassociated operation */
1836 ret = iwlagn_commit_rxon(priv, ctx);
1837 if (ret)
1838 return ret;
1839
1840 /* At this point, the NIC is initialized and operational */
1841 iwl_rf_kill_ct_config(priv);
1842
1843 IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
1844
1845 return iwl_power_update_mode(priv, true);
1846 }
1847
1848 static void iwl_cancel_deferred_work(struct iwl_priv *priv);
1849
1850 static void __iwl_down(struct iwl_priv *priv)
1851 {
1852 int exit_pending;
1853
1854 IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
1855
1856 iwl_scan_cancel_timeout(priv, 200);
1857
1858 exit_pending = test_and_set_bit(STATUS_EXIT_PENDING, &priv->status);
1859
1860 /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
1861 * to prevent rearm timer */
1862 del_timer_sync(&priv->watchdog);
1863
1864 iwl_clear_ucode_stations(priv, NULL);
1865 iwl_dealloc_bcast_stations(priv);
1866 iwl_clear_driver_stations(priv);
1867
1868 /* reset BT coex data */
1869 priv->bt_status = 0;
1870 priv->cur_rssi_ctx = NULL;
1871 priv->bt_is_sco = 0;
1872 if (priv->cfg->bt_params)
1873 priv->bt_traffic_load =
1874 priv->cfg->bt_params->bt_init_traffic_load;
1875 else
1876 priv->bt_traffic_load = 0;
1877 priv->bt_full_concurrent = false;
1878 priv->bt_ci_compliance = 0;
1879
1880 /* Wipe out the EXIT_PENDING status bit if we are not actually
1881 * exiting the module */
1882 if (!exit_pending)
1883 clear_bit(STATUS_EXIT_PENDING, &priv->status);
1884
1885 if (priv->mac80211_registered)
1886 ieee80211_stop_queues(priv->hw);
1887
1888 /* Clear out all status bits but a few that are stable across reset */
1889 priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
1890 STATUS_RF_KILL_HW |
1891 test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
1892 STATUS_GEO_CONFIGURED |
1893 test_bit(STATUS_FW_ERROR, &priv->status) <<
1894 STATUS_FW_ERROR |
1895 test_bit(STATUS_EXIT_PENDING, &priv->status) <<
1896 STATUS_EXIT_PENDING;
1897
1898 trans_stop_device(&priv->trans);
1899
1900 dev_kfree_skb(priv->beacon_skb);
1901 priv->beacon_skb = NULL;
1902 }
1903
1904 static void iwl_down(struct iwl_priv *priv)
1905 {
1906 mutex_lock(&priv->mutex);
1907 __iwl_down(priv);
1908 mutex_unlock(&priv->mutex);
1909
1910 iwl_cancel_deferred_work(priv);
1911 }
1912
1913 #define MAX_HW_RESTARTS 5
1914
1915 static int __iwl_up(struct iwl_priv *priv)
1916 {
1917 struct iwl_rxon_context *ctx;
1918 int ret;
1919
1920 lockdep_assert_held(&priv->mutex);
1921
1922 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
1923 IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
1924 return -EIO;
1925 }
1926
1927 for_each_context(priv, ctx) {
1928 ret = iwlagn_alloc_bcast_station(priv, ctx);
1929 if (ret) {
1930 iwl_dealloc_bcast_stations(priv);
1931 return ret;
1932 }
1933 }
1934
1935 ret = iwlagn_run_init_ucode(priv);
1936 if (ret) {
1937 IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
1938 goto error;
1939 }
1940
1941 ret = iwlagn_load_ucode_wait_alive(priv,
1942 &priv->ucode_rt,
1943 IWL_UCODE_REGULAR);
1944 if (ret) {
1945 IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
1946 goto error;
1947 }
1948
1949 ret = iwl_alive_start(priv);
1950 if (ret)
1951 goto error;
1952 return 0;
1953
1954 error:
1955 set_bit(STATUS_EXIT_PENDING, &priv->status);
1956 __iwl_down(priv);
1957 clear_bit(STATUS_EXIT_PENDING, &priv->status);
1958
1959 IWL_ERR(priv, "Unable to initialize device.\n");
1960 return ret;
1961 }
1962
1963
1964 /*****************************************************************************
1965 *
1966 * Workqueue callbacks
1967 *
1968 *****************************************************************************/
1969
1970 static void iwl_bg_run_time_calib_work(struct work_struct *work)
1971 {
1972 struct iwl_priv *priv = container_of(work, struct iwl_priv,
1973 run_time_calib_work);
1974
1975 mutex_lock(&priv->mutex);
1976
1977 if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
1978 test_bit(STATUS_SCANNING, &priv->status)) {
1979 mutex_unlock(&priv->mutex);
1980 return;
1981 }
1982
1983 if (priv->start_calib) {
1984 iwl_chain_noise_calibration(priv);
1985 iwl_sensitivity_calibration(priv);
1986 }
1987
1988 mutex_unlock(&priv->mutex);
1989 }
1990
1991 static void iwlagn_prepare_restart(struct iwl_priv *priv)
1992 {
1993 struct iwl_rxon_context *ctx;
1994 bool bt_full_concurrent;
1995 u8 bt_ci_compliance;
1996 u8 bt_load;
1997 u8 bt_status;
1998 bool bt_is_sco;
1999
2000 lockdep_assert_held(&priv->mutex);
2001
2002 for_each_context(priv, ctx)
2003 ctx->vif = NULL;
2004 priv->is_open = 0;
2005
2006 /*
2007 * __iwl_down() will clear the BT status variables,
2008 * which is correct, but when we restart we really
2009 * want to keep them so restore them afterwards.
2010 *
2011 * The restart process will later pick them up and
2012 * re-configure the hw when we reconfigure the BT
2013 * command.
2014 */
2015 bt_full_concurrent = priv->bt_full_concurrent;
2016 bt_ci_compliance = priv->bt_ci_compliance;
2017 bt_load = priv->bt_traffic_load;
2018 bt_status = priv->bt_status;
2019 bt_is_sco = priv->bt_is_sco;
2020
2021 __iwl_down(priv);
2022
2023 priv->bt_full_concurrent = bt_full_concurrent;
2024 priv->bt_ci_compliance = bt_ci_compliance;
2025 priv->bt_traffic_load = bt_load;
2026 priv->bt_status = bt_status;
2027 priv->bt_is_sco = bt_is_sco;
2028 }
2029
2030 static void iwl_bg_restart(struct work_struct *data)
2031 {
2032 struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
2033
2034 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2035 return;
2036
2037 if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
2038 mutex_lock(&priv->mutex);
2039 iwlagn_prepare_restart(priv);
2040 mutex_unlock(&priv->mutex);
2041 iwl_cancel_deferred_work(priv);
2042 ieee80211_restart_hw(priv->hw);
2043 } else {
2044 WARN_ON(1);
2045 }
2046 }
2047
2048 static int iwl_mac_offchannel_tx(struct ieee80211_hw *hw, struct sk_buff *skb,
2049 struct ieee80211_channel *chan,
2050 enum nl80211_channel_type channel_type,
2051 unsigned int wait)
2052 {
2053 struct iwl_priv *priv = hw->priv;
2054 int ret;
2055
2056 /* Not supported if we don't have PAN */
2057 if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN))) {
2058 ret = -EOPNOTSUPP;
2059 goto free;
2060 }
2061
2062 /* Not supported on pre-P2P firmware */
2063 if (!(priv->contexts[IWL_RXON_CTX_PAN].interface_modes &
2064 BIT(NL80211_IFTYPE_P2P_CLIENT))) {
2065 ret = -EOPNOTSUPP;
2066 goto free;
2067 }
2068
2069 mutex_lock(&priv->mutex);
2070
2071 if (!priv->contexts[IWL_RXON_CTX_PAN].is_active) {
2072 /*
2073 * If the PAN context is free, use the normal
2074 * way of doing remain-on-channel offload + TX.
2075 */
2076 ret = 1;
2077 goto out;
2078 }
2079
2080 /* TODO: queue up if scanning? */
2081 if (test_bit(STATUS_SCANNING, &priv->status) ||
2082 priv->offchan_tx_skb) {
2083 ret = -EBUSY;
2084 goto out;
2085 }
2086
2087 /*
2088 * max_scan_ie_len doesn't include the blank SSID or the header,
2089 * so need to add that again here.
2090 */
2091 if (skb->len > hw->wiphy->max_scan_ie_len + 24 + 2) {
2092 ret = -ENOBUFS;
2093 goto out;
2094 }
2095
2096 priv->offchan_tx_skb = skb;
2097 priv->offchan_tx_timeout = wait;
2098 priv->offchan_tx_chan = chan;
2099
2100 ret = iwl_scan_initiate(priv, priv->contexts[IWL_RXON_CTX_PAN].vif,
2101 IWL_SCAN_OFFCH_TX, chan->band);
2102 if (ret)
2103 priv->offchan_tx_skb = NULL;
2104 out:
2105 mutex_unlock(&priv->mutex);
2106 free:
2107 if (ret < 0)
2108 kfree_skb(skb);
2109
2110 return ret;
2111 }
2112
2113 static int iwl_mac_offchannel_tx_cancel_wait(struct ieee80211_hw *hw)
2114 {
2115 struct iwl_priv *priv = hw->priv;
2116 int ret;
2117
2118 mutex_lock(&priv->mutex);
2119
2120 if (!priv->offchan_tx_skb) {
2121 ret = -EINVAL;
2122 goto unlock;
2123 }
2124
2125 priv->offchan_tx_skb = NULL;
2126
2127 ret = iwl_scan_cancel_timeout(priv, 200);
2128 if (ret)
2129 ret = -EIO;
2130 unlock:
2131 mutex_unlock(&priv->mutex);
2132
2133 return ret;
2134 }
2135
2136 /*****************************************************************************
2137 *
2138 * mac80211 entry point functions
2139 *
2140 *****************************************************************************/
2141
2142 static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
2143 {
2144 .max = 1,
2145 .types = BIT(NL80211_IFTYPE_STATION),
2146 },
2147 {
2148 .max = 1,
2149 .types = BIT(NL80211_IFTYPE_AP),
2150 },
2151 };
2152
2153 static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
2154 {
2155 .max = 2,
2156 .types = BIT(NL80211_IFTYPE_STATION),
2157 },
2158 };
2159
2160 static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {
2161 {
2162 .max = 1,
2163 .types = BIT(NL80211_IFTYPE_STATION),
2164 },
2165 {
2166 .max = 1,
2167 .types = BIT(NL80211_IFTYPE_P2P_GO) |
2168 BIT(NL80211_IFTYPE_AP),
2169 },
2170 };
2171
2172 static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {
2173 {
2174 .max = 2,
2175 .types = BIT(NL80211_IFTYPE_STATION),
2176 },
2177 {
2178 .max = 1,
2179 .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
2180 },
2181 };
2182
2183 static const struct ieee80211_iface_combination
2184 iwlagn_iface_combinations_dualmode[] = {
2185 { .num_different_channels = 1,
2186 .max_interfaces = 2,
2187 .beacon_int_infra_match = true,
2188 .limits = iwlagn_sta_ap_limits,
2189 .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
2190 },
2191 { .num_different_channels = 1,
2192 .max_interfaces = 2,
2193 .limits = iwlagn_2sta_limits,
2194 .n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
2195 },
2196 };
2197
2198 static const struct ieee80211_iface_combination
2199 iwlagn_iface_combinations_p2p[] = {
2200 { .num_different_channels = 1,
2201 .max_interfaces = 2,
2202 .beacon_int_infra_match = true,
2203 .limits = iwlagn_p2p_sta_go_limits,
2204 .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),
2205 },
2206 { .num_different_channels = 1,
2207 .max_interfaces = 2,
2208 .limits = iwlagn_p2p_2sta_limits,
2209 .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),
2210 },
2211 };
2212
2213 /*
2214 * Not a mac80211 entry point function, but it fits in with all the
2215 * other mac80211 functions grouped here.
2216 */
2217 static int iwl_mac_setup_register(struct iwl_priv *priv,
2218 struct iwlagn_ucode_capabilities *capa)
2219 {
2220 int ret;
2221 struct ieee80211_hw *hw = priv->hw;
2222 struct iwl_rxon_context *ctx;
2223
2224 hw->rate_control_algorithm = "iwl-agn-rs";
2225
2226 /* Tell mac80211 our characteristics */
2227 hw->flags = IEEE80211_HW_SIGNAL_DBM |
2228 IEEE80211_HW_AMPDU_AGGREGATION |
2229 IEEE80211_HW_NEED_DTIM_PERIOD |
2230 IEEE80211_HW_SPECTRUM_MGMT |
2231 IEEE80211_HW_REPORTS_TX_ACK_STATUS;
2232
2233 hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
2234
2235 hw->flags |= IEEE80211_HW_SUPPORTS_PS |
2236 IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
2237
2238 if (priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE)
2239 hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
2240 IEEE80211_HW_SUPPORTS_STATIC_SMPS;
2241
2242 if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
2243 hw->flags |= IEEE80211_HW_MFP_CAPABLE;
2244
2245 hw->sta_data_size = sizeof(struct iwl_station_priv);
2246 hw->vif_data_size = sizeof(struct iwl_vif_priv);
2247
2248 for_each_context(priv, ctx) {
2249 hw->wiphy->interface_modes |= ctx->interface_modes;
2250 hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
2251 }
2252
2253 BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
2254
2255 if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
2256 hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
2257 hw->wiphy->n_iface_combinations =
2258 ARRAY_SIZE(iwlagn_iface_combinations_p2p);
2259 } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
2260 hw->wiphy->iface_combinations = iwlagn_iface_combinations_dualmode;
2261 hw->wiphy->n_iface_combinations =
2262 ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
2263 }
2264
2265 hw->wiphy->max_remain_on_channel_duration = 1000;
2266
2267 hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
2268 WIPHY_FLAG_DISABLE_BEACON_HINTS |
2269 WIPHY_FLAG_IBSS_RSN;
2270
2271 if (priv->ucode_wowlan.code.len && device_can_wakeup(priv->bus->dev)) {
2272 hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
2273 WIPHY_WOWLAN_DISCONNECT |
2274 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
2275 WIPHY_WOWLAN_RFKILL_RELEASE;
2276 if (!iwlagn_mod_params.sw_crypto)
2277 hw->wiphy->wowlan.flags |=
2278 WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
2279 WIPHY_WOWLAN_GTK_REKEY_FAILURE;
2280
2281 hw->wiphy->wowlan.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS;
2282 hw->wiphy->wowlan.pattern_min_len =
2283 IWLAGN_WOWLAN_MIN_PATTERN_LEN;
2284 hw->wiphy->wowlan.pattern_max_len =
2285 IWLAGN_WOWLAN_MAX_PATTERN_LEN;
2286 }
2287
2288 if (iwlagn_mod_params.power_save)
2289 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
2290 else
2291 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2292
2293 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
2294 /* we create the 802.11 header and a zero-length SSID element */
2295 hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
2296
2297 /* Default value; 4 EDCA QOS priorities */
2298 hw->queues = 4;
2299
2300 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
2301
2302 if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
2303 priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
2304 &priv->bands[IEEE80211_BAND_2GHZ];
2305 if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
2306 priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
2307 &priv->bands[IEEE80211_BAND_5GHZ];
2308
2309 iwl_leds_init(priv);
2310
2311 ret = ieee80211_register_hw(priv->hw);
2312 if (ret) {
2313 IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
2314 return ret;
2315 }
2316 priv->mac80211_registered = 1;
2317
2318 return 0;
2319 }
2320
2321
2322 static int iwlagn_mac_start(struct ieee80211_hw *hw)
2323 {
2324 struct iwl_priv *priv = hw->priv;
2325 int ret;
2326
2327 IWL_DEBUG_MAC80211(priv, "enter\n");
2328
2329 /* we should be verifying the device is ready to be opened */
2330 mutex_lock(&priv->mutex);
2331 ret = __iwl_up(priv);
2332 mutex_unlock(&priv->mutex);
2333 if (ret)
2334 return ret;
2335
2336 IWL_DEBUG_INFO(priv, "Start UP work done.\n");
2337
2338 /* Now we should be done, and the READY bit should be set. */
2339 if (WARN_ON(!test_bit(STATUS_READY, &priv->status)))
2340 ret = -EIO;
2341
2342 iwlagn_led_enable(priv);
2343
2344 priv->is_open = 1;
2345 IWL_DEBUG_MAC80211(priv, "leave\n");
2346 return 0;
2347 }
2348
2349 static void iwlagn_mac_stop(struct ieee80211_hw *hw)
2350 {
2351 struct iwl_priv *priv = hw->priv;
2352
2353 IWL_DEBUG_MAC80211(priv, "enter\n");
2354
2355 if (!priv->is_open)
2356 return;
2357
2358 priv->is_open = 0;
2359
2360 iwl_down(priv);
2361
2362 flush_workqueue(priv->workqueue);
2363
2364 /* User space software may expect getting rfkill changes
2365 * even if interface is down */
2366 iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
2367 iwl_enable_rfkill_int(priv);
2368
2369 IWL_DEBUG_MAC80211(priv, "leave\n");
2370 }
2371
2372 #ifdef CONFIG_PM
2373 static int iwlagn_send_patterns(struct iwl_priv *priv,
2374 struct cfg80211_wowlan *wowlan)
2375 {
2376 struct iwlagn_wowlan_patterns_cmd *pattern_cmd;
2377 struct iwl_host_cmd cmd = {
2378 .id = REPLY_WOWLAN_PATTERNS,
2379 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
2380 .flags = CMD_SYNC,
2381 };
2382 int i, err;
2383
2384 if (!wowlan->n_patterns)
2385 return 0;
2386
2387 cmd.len[0] = sizeof(*pattern_cmd) +
2388 wowlan->n_patterns * sizeof(struct iwlagn_wowlan_pattern);
2389
2390 pattern_cmd = kmalloc(cmd.len[0], GFP_KERNEL);
2391 if (!pattern_cmd)
2392 return -ENOMEM;
2393
2394 pattern_cmd->n_patterns = cpu_to_le32(wowlan->n_patterns);
2395
2396 for (i = 0; i < wowlan->n_patterns; i++) {
2397 int mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
2398
2399 memcpy(&pattern_cmd->patterns[i].mask,
2400 wowlan->patterns[i].mask, mask_len);
2401 memcpy(&pattern_cmd->patterns[i].pattern,
2402 wowlan->patterns[i].pattern,
2403 wowlan->patterns[i].pattern_len);
2404 pattern_cmd->patterns[i].mask_size = mask_len;
2405 pattern_cmd->patterns[i].pattern_size =
2406 wowlan->patterns[i].pattern_len;
2407 }
2408
2409 cmd.data[0] = pattern_cmd;
2410 err = trans_send_cmd(&priv->trans, &cmd);
2411 kfree(pattern_cmd);
2412 return err;
2413 }
2414 #endif
2415
2416 static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw,
2417 struct ieee80211_vif *vif,
2418 struct cfg80211_gtk_rekey_data *data)
2419 {
2420 struct iwl_priv *priv = hw->priv;
2421
2422 if (iwlagn_mod_params.sw_crypto)
2423 return;
2424
2425 mutex_lock(&priv->mutex);
2426
2427 if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif)
2428 goto out;
2429
2430 memcpy(priv->kek, data->kek, NL80211_KEK_LEN);
2431 memcpy(priv->kck, data->kck, NL80211_KCK_LEN);
2432 priv->replay_ctr = cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
2433 priv->have_rekey_data = true;
2434
2435 out:
2436 mutex_unlock(&priv->mutex);
2437 }
2438
2439 struct wowlan_key_data {
2440 struct iwl_rxon_context *ctx;
2441 struct iwlagn_wowlan_rsc_tsc_params_cmd *rsc_tsc;
2442 struct iwlagn_wowlan_tkip_params_cmd *tkip;
2443 const u8 *bssid;
2444 bool error, use_rsc_tsc, use_tkip;
2445 };
2446
2447 #ifdef CONFIG_PM
2448 static void iwlagn_convert_p1k(u16 *p1k, __le16 *out)
2449 {
2450 int i;
2451
2452 for (i = 0; i < IWLAGN_P1K_SIZE; i++)
2453 out[i] = cpu_to_le16(p1k[i]);
2454 }
2455
2456 static void iwlagn_wowlan_program_keys(struct ieee80211_hw *hw,
2457 struct ieee80211_vif *vif,
2458 struct ieee80211_sta *sta,
2459 struct ieee80211_key_conf *key,
2460 void *_data)
2461 {
2462 struct iwl_priv *priv = hw->priv;
2463 struct wowlan_key_data *data = _data;
2464 struct iwl_rxon_context *ctx = data->ctx;
2465 struct aes_sc *aes_sc, *aes_tx_sc = NULL;
2466 struct tkip_sc *tkip_sc, *tkip_tx_sc = NULL;
2467 struct iwlagn_p1k_cache *rx_p1ks;
2468 u8 *rx_mic_key;
2469 struct ieee80211_key_seq seq;
2470 u32 cur_rx_iv32 = 0;
2471 u16 p1k[IWLAGN_P1K_SIZE];
2472 int ret, i;
2473
2474 mutex_lock(&priv->mutex);
2475
2476 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2477 key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
2478 !sta && !ctx->key_mapping_keys)
2479 ret = iwl_set_default_wep_key(priv, ctx, key);
2480 else
2481 ret = iwl_set_dynamic_key(priv, ctx, key, sta);
2482
2483 if (ret) {
2484 IWL_ERR(priv, "Error setting key during suspend!\n");
2485 data->error = true;
2486 }
2487
2488 switch (key->cipher) {
2489 case WLAN_CIPHER_SUITE_TKIP:
2490 if (sta) {
2491 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.unicast_rsc;
2492 tkip_tx_sc = &data->rsc_tsc->all_tsc_rsc.tkip.tsc;
2493
2494 rx_p1ks = data->tkip->rx_uni;
2495
2496 ieee80211_get_key_tx_seq(key, &seq);
2497 tkip_tx_sc->iv16 = cpu_to_le16(seq.tkip.iv16);
2498 tkip_tx_sc->iv32 = cpu_to_le32(seq.tkip.iv32);
2499
2500 ieee80211_get_tkip_p1k_iv(key, seq.tkip.iv32, p1k);
2501 iwlagn_convert_p1k(p1k, data->tkip->tx.p1k);
2502
2503 memcpy(data->tkip->mic_keys.tx,
2504 &key->key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY],
2505 IWLAGN_MIC_KEY_SIZE);
2506
2507 rx_mic_key = data->tkip->mic_keys.rx_unicast;
2508 } else {
2509 tkip_sc = data->rsc_tsc->all_tsc_rsc.tkip.multicast_rsc;
2510 rx_p1ks = data->tkip->rx_multi;
2511 rx_mic_key = data->tkip->mic_keys.rx_mcast;
2512 }
2513
2514 /*
2515 * For non-QoS this relies on the fact that both the uCode and
2516 * mac80211 use TID 0 (as they need to to avoid replay attacks)
2517 * for checking the IV in the frames.
2518 */
2519 for (i = 0; i < IWLAGN_NUM_RSC; i++) {
2520 ieee80211_get_key_rx_seq(key, i, &seq);
2521 tkip_sc[i].iv16 = cpu_to_le16(seq.tkip.iv16);
2522 tkip_sc[i].iv32 = cpu_to_le32(seq.tkip.iv32);
2523 /* wrapping isn't allowed, AP must rekey */
2524 if (seq.tkip.iv32 > cur_rx_iv32)
2525 cur_rx_iv32 = seq.tkip.iv32;
2526 }
2527
2528 ieee80211_get_tkip_rx_p1k(key, data->bssid, cur_rx_iv32, p1k);
2529 iwlagn_convert_p1k(p1k, rx_p1ks[0].p1k);
2530 ieee80211_get_tkip_rx_p1k(key, data->bssid,
2531 cur_rx_iv32 + 1, p1k);
2532 iwlagn_convert_p1k(p1k, rx_p1ks[1].p1k);
2533
2534 memcpy(rx_mic_key,
2535 &key->key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY],
2536 IWLAGN_MIC_KEY_SIZE);
2537
2538 data->use_tkip = true;
2539 data->use_rsc_tsc = true;
2540 break;
2541 case WLAN_CIPHER_SUITE_CCMP:
2542 if (sta) {
2543 u8 *pn = seq.ccmp.pn;
2544
2545 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.unicast_rsc;
2546 aes_tx_sc = &data->rsc_tsc->all_tsc_rsc.aes.tsc;
2547
2548 ieee80211_get_key_tx_seq(key, &seq);
2549 aes_tx_sc->pn = cpu_to_le64(
2550 (u64)pn[5] |
2551 ((u64)pn[4] << 8) |
2552 ((u64)pn[3] << 16) |
2553 ((u64)pn[2] << 24) |
2554 ((u64)pn[1] << 32) |
2555 ((u64)pn[0] << 40));
2556 } else
2557 aes_sc = data->rsc_tsc->all_tsc_rsc.aes.multicast_rsc;
2558
2559 /*
2560 * For non-QoS this relies on the fact that both the uCode and
2561 * mac80211 use TID 0 for checking the IV in the frames.
2562 */
2563 for (i = 0; i < IWLAGN_NUM_RSC; i++) {
2564 u8 *pn = seq.ccmp.pn;
2565
2566 ieee80211_get_key_rx_seq(key, i, &seq);
2567 aes_sc->pn = cpu_to_le64(
2568 (u64)pn[5] |
2569 ((u64)pn[4] << 8) |
2570 ((u64)pn[3] << 16) |
2571 ((u64)pn[2] << 24) |
2572 ((u64)pn[1] << 32) |
2573 ((u64)pn[0] << 40));
2574 }
2575 data->use_rsc_tsc = true;
2576 break;
2577 }
2578
2579 mutex_unlock(&priv->mutex);
2580 }
2581
2582 static int iwlagn_mac_suspend(struct ieee80211_hw *hw,
2583 struct cfg80211_wowlan *wowlan)
2584 {
2585 struct iwl_priv *priv = hw->priv;
2586 struct iwlagn_wowlan_wakeup_filter_cmd wakeup_filter_cmd;
2587 struct iwl_rxon_cmd rxon;
2588 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2589 struct iwlagn_wowlan_kek_kck_material_cmd kek_kck_cmd;
2590 struct iwlagn_wowlan_tkip_params_cmd tkip_cmd = {};
2591 struct wowlan_key_data key_data = {
2592 .ctx = ctx,
2593 .bssid = ctx->active.bssid_addr,
2594 .use_rsc_tsc = false,
2595 .tkip = &tkip_cmd,
2596 .use_tkip = false,
2597 };
2598 int ret, i;
2599 u16 seq;
2600
2601 if (WARN_ON(!wowlan))
2602 return -EINVAL;
2603
2604 mutex_lock(&priv->mutex);
2605
2606 /* Don't attempt WoWLAN when not associated, tear down instead. */
2607 if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION ||
2608 !iwl_is_associated_ctx(ctx)) {
2609 ret = 1;
2610 goto out;
2611 }
2612
2613 key_data.rsc_tsc = kzalloc(sizeof(*key_data.rsc_tsc), GFP_KERNEL);
2614 if (!key_data.rsc_tsc) {
2615 ret = -ENOMEM;
2616 goto out;
2617 }
2618
2619 memset(&wakeup_filter_cmd, 0, sizeof(wakeup_filter_cmd));
2620
2621 /*
2622 * We know the last used seqno, and the uCode expects to know that
2623 * one, it will increment before TX.
2624 */
2625 seq = le16_to_cpu(priv->last_seq_ctl) & IEEE80211_SCTL_SEQ;
2626 wakeup_filter_cmd.non_qos_seq = cpu_to_le16(seq);
2627
2628 /*
2629 * For QoS counters, we store the one to use next, so subtract 0x10
2630 * since the uCode will add 0x10 before using the value.
2631 */
2632 for (i = 0; i < 8; i++) {
2633 seq = priv->stations[IWL_AP_ID].tid[i].seq_number;
2634 seq -= 0x10;
2635 wakeup_filter_cmd.qos_seq[i] = cpu_to_le16(seq);
2636 }
2637
2638 if (wowlan->disconnect)
2639 wakeup_filter_cmd.enabled |=
2640 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_BEACON_MISS |
2641 IWLAGN_WOWLAN_WAKEUP_LINK_CHANGE);
2642 if (wowlan->magic_pkt)
2643 wakeup_filter_cmd.enabled |=
2644 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_MAGIC_PACKET);
2645 if (wowlan->gtk_rekey_failure)
2646 wakeup_filter_cmd.enabled |=
2647 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_GTK_REKEY_FAIL);
2648 if (wowlan->eap_identity_req)
2649 wakeup_filter_cmd.enabled |=
2650 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_EAP_IDENT_REQ);
2651 if (wowlan->four_way_handshake)
2652 wakeup_filter_cmd.enabled |=
2653 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_4WAY_HANDSHAKE);
2654 if (wowlan->rfkill_release)
2655 wakeup_filter_cmd.enabled |=
2656 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_RFKILL);
2657 if (wowlan->n_patterns)
2658 wakeup_filter_cmd.enabled |=
2659 cpu_to_le32(IWLAGN_WOWLAN_WAKEUP_PATTERN_MATCH);
2660
2661 iwl_scan_cancel_timeout(priv, 200);
2662
2663 memcpy(&rxon, &ctx->active, sizeof(rxon));
2664
2665 trans_stop_device(&priv->trans);
2666
2667 priv->wowlan = true;
2668
2669 ret = iwlagn_load_ucode_wait_alive(priv, &priv->ucode_wowlan,
2670 IWL_UCODE_WOWLAN);
2671 if (ret)
2672 goto error;
2673
2674 /* now configure WoWLAN ucode */
2675 ret = iwl_alive_start(priv);
2676 if (ret)
2677 goto error;
2678
2679 memcpy(&ctx->staging, &rxon, sizeof(rxon));
2680 ret = iwlagn_commit_rxon(priv, ctx);
2681 if (ret)
2682 goto error;
2683
2684 ret = iwl_power_update_mode(priv, true);
2685 if (ret)
2686 goto error;
2687
2688 if (!iwlagn_mod_params.sw_crypto) {
2689 /* mark all keys clear */
2690 priv->ucode_key_table = 0;
2691 ctx->key_mapping_keys = 0;
2692
2693 /*
2694 * This needs to be unlocked due to lock ordering
2695 * constraints. Since we're in the suspend path
2696 * that isn't really a problem though.
2697 */
2698 mutex_unlock(&priv->mutex);
2699 ieee80211_iter_keys(priv->hw, ctx->vif,
2700 iwlagn_wowlan_program_keys,
2701 &key_data);
2702 mutex_lock(&priv->mutex);
2703 if (key_data.error) {
2704 ret = -EIO;
2705 goto error;
2706 }
2707
2708 if (key_data.use_rsc_tsc) {
2709 struct iwl_host_cmd rsc_tsc_cmd = {
2710 .id = REPLY_WOWLAN_TSC_RSC_PARAMS,
2711 .flags = CMD_SYNC,
2712 .data[0] = key_data.rsc_tsc,
2713 .dataflags[0] = IWL_HCMD_DFL_NOCOPY,
2714 .len[0] = sizeof(*key_data.rsc_tsc),
2715 };
2716
2717 ret = trans_send_cmd(&priv->trans, &rsc_tsc_cmd);
2718 if (ret)
2719 goto error;
2720 }
2721
2722 if (key_data.use_tkip) {
2723 ret = trans_send_cmd_pdu(&priv->trans,
2724 REPLY_WOWLAN_TKIP_PARAMS,
2725 CMD_SYNC, sizeof(tkip_cmd),
2726 &tkip_cmd);
2727 if (ret)
2728 goto error;
2729 }
2730
2731 if (priv->have_rekey_data) {
2732 memset(&kek_kck_cmd, 0, sizeof(kek_kck_cmd));
2733 memcpy(kek_kck_cmd.kck, priv->kck, NL80211_KCK_LEN);
2734 kek_kck_cmd.kck_len = cpu_to_le16(NL80211_KCK_LEN);
2735 memcpy(kek_kck_cmd.kek, priv->kek, NL80211_KEK_LEN);
2736 kek_kck_cmd.kek_len = cpu_to_le16(NL80211_KEK_LEN);
2737 kek_kck_cmd.replay_ctr = priv->replay_ctr;
2738
2739 ret = trans_send_cmd_pdu(&priv->trans,
2740 REPLY_WOWLAN_KEK_KCK_MATERIAL,
2741 CMD_SYNC, sizeof(kek_kck_cmd),
2742 &kek_kck_cmd);
2743 if (ret)
2744 goto error;
2745 }
2746 }
2747
2748 ret = trans_send_cmd_pdu(&priv->trans, REPLY_WOWLAN_WAKEUP_FILTER,
2749 CMD_SYNC, sizeof(wakeup_filter_cmd),
2750 &wakeup_filter_cmd);
2751 if (ret)
2752 goto error;
2753
2754 ret = iwlagn_send_patterns(priv, wowlan);
2755 if (ret)
2756 goto error;
2757
2758 device_set_wakeup_enable(priv->bus->dev, true);
2759
2760 /* Now let the ucode operate on its own */
2761 iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
2762 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
2763
2764 goto out;
2765
2766 error:
2767 priv->wowlan = false;
2768 iwlagn_prepare_restart(priv);
2769 ieee80211_restart_hw(priv->hw);
2770 out:
2771 mutex_unlock(&priv->mutex);
2772 kfree(key_data.rsc_tsc);
2773 return ret;
2774 }
2775
2776 static int iwlagn_mac_resume(struct ieee80211_hw *hw)
2777 {
2778 struct iwl_priv *priv = hw->priv;
2779 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
2780 struct ieee80211_vif *vif;
2781 unsigned long flags;
2782 u32 base, status = 0xffffffff;
2783 int ret = -EIO;
2784
2785 mutex_lock(&priv->mutex);
2786
2787 iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
2788 CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
2789
2790 base = priv->device_pointers.error_event_table;
2791 if (iwlagn_hw_valid_rtc_data_addr(base)) {
2792 spin_lock_irqsave(&priv->reg_lock, flags);
2793 ret = iwl_grab_nic_access_silent(priv);
2794 if (ret == 0) {
2795 iwl_write32(priv, HBUS_TARG_MEM_RADDR, base);
2796 status = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
2797 iwl_release_nic_access(priv);
2798 }
2799 spin_unlock_irqrestore(&priv->reg_lock, flags);
2800
2801 #ifdef CONFIG_IWLWIFI_DEBUGFS
2802 if (ret == 0) {
2803 if (!priv->wowlan_sram)
2804 priv->wowlan_sram =
2805 kzalloc(priv->ucode_wowlan.data.len,
2806 GFP_KERNEL);
2807
2808 if (priv->wowlan_sram)
2809 _iwl_read_targ_mem_words(
2810 priv, 0x800000, priv->wowlan_sram,
2811 priv->ucode_wowlan.data.len / 4);
2812 }
2813 #endif
2814 }
2815
2816 /* we'll clear ctx->vif during iwlagn_prepare_restart() */
2817 vif = ctx->vif;
2818
2819 priv->wowlan = false;
2820
2821 device_set_wakeup_enable(priv->bus->dev, false);
2822
2823 iwlagn_prepare_restart(priv);
2824
2825 memset((void *)&ctx->active, 0, sizeof(ctx->active));
2826 iwl_connection_init_rx_config(priv, ctx);
2827 iwlagn_set_rxon_chain(priv, ctx);
2828
2829 mutex_unlock(&priv->mutex);
2830
2831 ieee80211_resume_disconnect(vif);
2832
2833 return 1;
2834 }
2835 #endif
2836
2837 static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
2838 {
2839 struct iwl_priv *priv = hw->priv;
2840
2841 IWL_DEBUG_MACDUMP(priv, "enter\n");
2842
2843 IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
2844 ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
2845
2846 if (iwlagn_tx_skb(priv, skb))
2847 dev_kfree_skb_any(skb);
2848
2849 IWL_DEBUG_MACDUMP(priv, "leave\n");
2850 }
2851
2852 static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
2853 struct ieee80211_vif *vif,
2854 struct ieee80211_key_conf *keyconf,
2855 struct ieee80211_sta *sta,
2856 u32 iv32, u16 *phase1key)
2857 {
2858 struct iwl_priv *priv = hw->priv;
2859
2860 iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
2861 }
2862
2863 static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2864 struct ieee80211_vif *vif,
2865 struct ieee80211_sta *sta,
2866 struct ieee80211_key_conf *key)
2867 {
2868 struct iwl_priv *priv = hw->priv;
2869 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
2870 struct iwl_rxon_context *ctx = vif_priv->ctx;
2871 int ret;
2872 bool is_default_wep_key = false;
2873
2874 IWL_DEBUG_MAC80211(priv, "enter\n");
2875
2876 if (iwlagn_mod_params.sw_crypto) {
2877 IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
2878 return -EOPNOTSUPP;
2879 }
2880
2881 /*
2882 * We could program these keys into the hardware as well, but we
2883 * don't expect much multicast traffic in IBSS and having keys
2884 * for more stations is probably more useful.
2885 *
2886 * Mark key TX-only and return 0.
2887 */
2888 if (vif->type == NL80211_IFTYPE_ADHOC &&
2889 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
2890 key->hw_key_idx = WEP_INVALID_OFFSET;
2891 return 0;
2892 }
2893
2894 /* If they key was TX-only, accept deletion */
2895 if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
2896 return 0;
2897
2898 mutex_lock(&priv->mutex);
2899 iwl_scan_cancel_timeout(priv, 100);
2900
2901 BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
2902
2903 /*
2904 * If we are getting WEP group key and we didn't receive any key mapping
2905 * so far, we are in legacy wep mode (group key only), otherwise we are
2906 * in 1X mode.
2907 * In legacy wep mode, we use another host command to the uCode.
2908 */
2909 if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2910 key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
2911 if (cmd == SET_KEY)
2912 is_default_wep_key = !ctx->key_mapping_keys;
2913 else
2914 is_default_wep_key =
2915 key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
2916 }
2917
2918
2919 switch (cmd) {
2920 case SET_KEY:
2921 if (is_default_wep_key) {
2922 ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
2923 break;
2924 }
2925 ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta);
2926 if (ret) {
2927 /*
2928 * can't add key for RX, but we don't need it
2929 * in the device for TX so still return 0
2930 */
2931 ret = 0;
2932 key->hw_key_idx = WEP_INVALID_OFFSET;
2933 }
2934
2935 IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
2936 break;
2937 case DISABLE_KEY:
2938 if (is_default_wep_key)
2939 ret = iwl_remove_default_wep_key(priv, ctx, key);
2940 else
2941 ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
2942
2943 IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
2944 break;
2945 default:
2946 ret = -EINVAL;
2947 }
2948
2949 mutex_unlock(&priv->mutex);
2950 IWL_DEBUG_MAC80211(priv, "leave\n");
2951
2952 return ret;
2953 }
2954
2955 static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
2956 struct ieee80211_vif *vif,
2957 enum ieee80211_ampdu_mlme_action action,
2958 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
2959 u8 buf_size)
2960 {
2961 struct iwl_priv *priv = hw->priv;
2962 int ret = -EINVAL;
2963 struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
2964
2965 IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
2966 sta->addr, tid);
2967
2968 if (!(priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE))
2969 return -EACCES;
2970
2971 mutex_lock(&priv->mutex);
2972
2973 switch (action) {
2974 case IEEE80211_AMPDU_RX_START:
2975 IWL_DEBUG_HT(priv, "start Rx\n");
2976 ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
2977 break;
2978 case IEEE80211_AMPDU_RX_STOP:
2979 IWL_DEBUG_HT(priv, "stop Rx\n");
2980 ret = iwl_sta_rx_agg_stop(priv, sta, tid);
2981 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
2982 ret = 0;
2983 break;
2984 case IEEE80211_AMPDU_TX_START:
2985 IWL_DEBUG_HT(priv, "start Tx\n");
2986 ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
2987 if (ret == 0) {
2988 priv->agg_tids_count++;
2989 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2990 priv->agg_tids_count);
2991 }
2992 break;
2993 case IEEE80211_AMPDU_TX_STOP:
2994 IWL_DEBUG_HT(priv, "stop Tx\n");
2995 ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
2996 if ((ret == 0) && (priv->agg_tids_count > 0)) {
2997 priv->agg_tids_count--;
2998 IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
2999 priv->agg_tids_count);
3000 }
3001 if (test_bit(STATUS_EXIT_PENDING, &priv->status))
3002 ret = 0;
3003 if (priv->cfg->ht_params &&
3004 priv->cfg->ht_params->use_rts_for_aggregation) {
3005 /*
3006 * switch off RTS/CTS if it was previously enabled
3007 */
3008 sta_priv->lq_sta.lq.general_params.flags &=
3009 ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
3010 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
3011 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
3012 }
3013 break;
3014 case IEEE80211_AMPDU_TX_OPERATIONAL:
3015 buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
3016
3017 trans_txq_agg_setup(&priv->trans, iwl_sta_id(sta), tid,
3018 buf_size);
3019
3020 /*
3021 * If the limit is 0, then it wasn't initialised yet,
3022 * use the default. We can do that since we take the
3023 * minimum below, and we don't want to go above our
3024 * default due to hardware restrictions.
3025 */
3026 if (sta_priv->max_agg_bufsize == 0)
3027 sta_priv->max_agg_bufsize =
3028 LINK_QUAL_AGG_FRAME_LIMIT_DEF;
3029
3030 /*
3031 * Even though in theory the peer could have different
3032 * aggregation reorder buffer sizes for different sessions,
3033 * our ucode doesn't allow for that and has a global limit
3034 * for each station. Therefore, use the minimum of all the
3035 * aggregation sessions and our default value.
3036 */
3037 sta_priv->max_agg_bufsize =
3038 min(sta_priv->max_agg_bufsize, buf_size);
3039
3040 if (priv->cfg->ht_params &&
3041 priv->cfg->ht_params->use_rts_for_aggregation) {
3042 /*
3043 * switch to RTS/CTS if it is the prefer protection
3044 * method for HT traffic
3045 */
3046
3047 sta_priv->lq_sta.lq.general_params.flags |=
3048 LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
3049 }
3050
3051 sta_priv->lq_sta.lq.agg_params.agg_frame_cnt_limit =
3052 sta_priv->max_agg_bufsize;
3053
3054 iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
3055 &sta_priv->lq_sta.lq, CMD_ASYNC, false);
3056
3057 IWL_INFO(priv, "Tx aggregation enabled on ra = %pM tid = %d\n",
3058 sta->addr, tid);
3059 ret = 0;
3060 break;
3061 }
3062 mutex_unlock(&priv->mutex);
3063
3064 return ret;
3065 }
3066
3067 static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
3068 struct ieee80211_vif *vif,
3069 struct ieee80211_sta *sta)
3070 {
3071 struct iwl_priv *priv = hw->priv;
3072 struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
3073 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
3074 bool is_ap = vif->type == NL80211_IFTYPE_STATION;
3075 int ret;
3076 u8 sta_id;
3077
3078 IWL_DEBUG_INFO(priv, "received request to add station %pM\n",
3079 sta->addr);
3080 mutex_lock(&priv->mutex);
3081 IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
3082 sta->addr);
3083 sta_priv->common.sta_id = IWL_INVALID_STATION;
3084
3085 atomic_set(&sta_priv->pending_frames, 0);
3086 if (vif->type == NL80211_IFTYPE_AP)
3087 sta_priv->client = true;
3088
3089 ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
3090 is_ap, sta, &sta_id);
3091 if (ret) {
3092 IWL_ERR(priv, "Unable to add station %pM (%d)\n",
3093 sta->addr, ret);
3094 /* Should we return success if return code is EEXIST ? */
3095 mutex_unlock(&priv->mutex);
3096 return ret;
3097 }
3098
3099 sta_priv->common.sta_id = sta_id;
3100
3101 /* Initialize rate scaling */
3102 IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
3103 sta->addr);
3104 iwl_rs_rate_init(priv, sta, sta_id);
3105 mutex_unlock(&priv->mutex);
3106
3107 return 0;
3108 }
3109
3110 static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
3111 struct ieee80211_channel_switch *ch_switch)
3112 {
3113 struct iwl_priv *priv = hw->priv;
3114 const struct iwl_channel_info *ch_info;
3115 struct ieee80211_conf *conf = &hw->conf;
3116 struct ieee80211_channel *channel = ch_switch->channel;
3117 struct iwl_ht_config *ht_conf = &priv->current_ht_config;
3118 /*
3119 * MULTI-FIXME
3120 * When we add support for multiple interfaces, we need to
3121 * revisit this. The channel switch command in the device
3122 * only affects the BSS context, but what does that really
3123 * mean? And what if we get a CSA on the second interface?
3124 * This needs a lot of work.
3125 */
3126 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
3127 u16 ch;
3128
3129 IWL_DEBUG_MAC80211(priv, "enter\n");
3130
3131 mutex_lock(&priv->mutex);
3132
3133 if (iwl_is_rfkill(priv))
3134 goto out;
3135
3136 if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
3137 test_bit(STATUS_SCANNING, &priv->status) ||
3138 test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
3139 goto out;
3140
3141 if (!iwl_is_associated_ctx(ctx))
3142 goto out;
3143
3144 if (!priv->cfg->lib->set_channel_switch)
3145 goto out;
3146
3147 ch = channel->hw_value;
3148 if (le16_to_cpu(ctx->active.channel) == ch)
3149 goto out;
3150
3151 ch_info = iwl_get_channel_info(priv, channel->band, ch);
3152 if (!is_channel_valid(ch_info)) {
3153 IWL_DEBUG_MAC80211(priv, "invalid channel\n");
3154 goto out;
3155 }
3156
3157 spin_lock_irq(&priv->lock);
3158
3159 priv->current_ht_config.smps = conf->smps_mode;
3160
3161 /* Configure HT40 channels */
3162 ctx->ht.enabled = conf_is_ht(conf);
3163 if (ctx->ht.enabled) {
3164 if (conf_is_ht40_minus(conf)) {
3165 ctx->ht.extension_chan_offset =
3166 IEEE80211_HT_PARAM_CHA_SEC_BELOW;
3167 ctx->ht.is_40mhz = true;
3168 } else if (conf_is_ht40_plus(conf)) {
3169 ctx->ht.extension_chan_offset =
3170 IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
3171 ctx->ht.is_40mhz = true;
3172 } else {
3173 ctx->ht.extension_chan_offset =
3174 IEEE80211_HT_PARAM_CHA_SEC_NONE;
3175 ctx->ht.is_40mhz = false;
3176 }
3177 } else
3178 ctx->ht.is_40mhz = false;
3179
3180 if ((le16_to_cpu(ctx->staging.channel) != ch))
3181 ctx->staging.flags = 0;
3182
3183 iwl_set_rxon_channel(priv, channel, ctx);
3184 iwl_set_rxon_ht(priv, ht_conf);
3185 iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
3186
3187 spin_unlock_irq(&priv->lock);
3188
3189 iwl_set_rate(priv);
3190 /*
3191 * at this point, staging_rxon has the
3192 * configuration for channel switch
3193 */
3194 set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
3195 priv->switch_channel = cpu_to_le16(ch);
3196 if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
3197 clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
3198 priv->switch_channel = 0;
3199 ieee80211_chswitch_done(ctx->vif, false);
3200 }
3201
3202 out:
3203 mutex_unlock(&priv->mutex);
3204 IWL_DEBUG_MAC80211(priv, "leave\n");
3205 }
3206
3207 static void iwlagn_configure_filter(struct ieee80211_hw *hw,
3208 unsigned int changed_flags,
3209 unsigned int *total_flags,
3210 u64 multicast)
3211 {
3212 struct iwl_priv *priv = hw->priv;
3213 __le32 filter_or = 0, filter_nand = 0;
3214 struct iwl_rxon_context *ctx;
3215
3216 #define CHK(test, flag) do { \
3217 if (*total_flags & (test)) \
3218 filter_or |= (flag); \
3219 else \
3220 filter_nand |= (flag); \
3221 } while (0)
3222
3223 IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
3224 changed_flags, *total_flags);
3225
3226 CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
3227 /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
3228 CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
3229 CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
3230
3231 #undef CHK
3232
3233 mutex_lock(&priv->mutex);
3234
3235 for_each_context(priv, ctx) {
3236 ctx->staging.filter_flags &= ~filter_nand;
3237 ctx->staging.filter_flags |= filter_or;
3238
3239 /*
3240 * Not committing directly because hardware can perform a scan,
3241 * but we'll eventually commit the filter flags change anyway.
3242 */
3243 }
3244
3245 mutex_unlock(&priv->mutex);
3246
3247 /*
3248 * Receiving all multicast frames is always enabled by the
3249 * default flags setup in iwl_connection_init_rx_config()
3250 * since we currently do not support programming multicast
3251 * filters into the device.
3252 */
3253 *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
3254 FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
3255 }
3256
3257 static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
3258 {
3259 struct iwl_priv *priv = hw->priv;
3260
3261 mutex_lock(&priv->mutex);
3262 IWL_DEBUG_MAC80211(priv, "enter\n");
3263
3264 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
3265 IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
3266 goto done;
3267 }
3268 if (iwl_is_rfkill(priv)) {
3269 IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
3270 goto done;
3271 }
3272
3273 /*
3274 * mac80211 will not push any more frames for transmit
3275 * until the flush is completed
3276 */
3277 if (drop) {
3278 IWL_DEBUG_MAC80211(priv, "send flush command\n");
3279 if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
3280 IWL_ERR(priv, "flush request fail\n");
3281 goto done;
3282 }
3283 }
3284 IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n");
3285 iwlagn_wait_tx_queue_empty(priv);
3286 done:
3287 mutex_unlock(&priv->mutex);
3288 IWL_DEBUG_MAC80211(priv, "leave\n");
3289 }
3290
3291 static void iwlagn_disable_roc(struct iwl_priv *priv)
3292 {
3293 struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
3294 struct ieee80211_channel *chan = ACCESS_ONCE(priv->hw->conf.channel);
3295
3296 lockdep_assert_held(&priv->mutex);
3297
3298 if (!ctx->is_active)
3299 return;
3300
3301 ctx->staging.dev_type = RXON_DEV_TYPE_2STA;
3302 ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
3303 iwl_set_rxon_channel(priv, chan, ctx);
3304 iwl_set_flags_for_band(priv, ctx, chan->band, NULL);
3305
3306 priv->hw_roc_channel = NULL;
3307
3308 iwlagn_commit_rxon(priv, ctx);
3309
3310 ctx->is_active = false;
3311 }
3312
3313 static void iwlagn_bg_roc_done(struct work_struct *work)
3314 {
3315 struct iwl_priv *priv = container_of(work, struct iwl_priv,
3316 hw_roc_work.work);
3317
3318 mutex_lock(&priv->mutex);
3319 ieee80211_remain_on_channel_expired(priv->hw);
3320 iwlagn_disable_roc(priv);
3321 mutex_unlock(&priv->mutex);
3322 }
3323
3324 static int iwl_mac_remain_on_channel(struct ieee80211_hw *hw,
3325 struct ieee80211_channel *channel,
3326 enum nl80211_channel_type channel_type,
3327 int duration)
3328 {
3329 struct iwl_priv *priv = hw->priv;
3330 int err = 0;
3331
3332 if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
3333 return -EOPNOTSUPP;
3334
3335 if (!(priv->contexts[IWL_RXON_CTX_PAN].interface_modes &
3336 BIT(NL80211_IFTYPE_P2P_CLIENT)))
3337 return -EOPNOTSUPP;
3338
3339 mutex_lock(&priv->mutex);
3340
3341 if (priv->contexts[IWL_RXON_CTX_PAN].is_active ||
3342 test_bit(STATUS_SCAN_HW, &priv->status)) {
3343 err = -EBUSY;
3344 goto out;
3345 }
3346
3347 priv->contexts[IWL_RXON_CTX_PAN].is_active = true;
3348 priv->hw_roc_channel = channel;
3349 priv->hw_roc_chantype = channel_type;
3350 priv->hw_roc_duration = DIV_ROUND_UP(duration * 1000, 1024);
3351 iwlagn_commit_rxon(priv, &priv->contexts[IWL_RXON_CTX_PAN]);
3352 queue_delayed_work(priv->workqueue, &priv->hw_roc_work,
3353 msecs_to_jiffies(duration + 20));
3354
3355 msleep(IWL_MIN_SLOT_TIME); /* TU is almost ms */
3356 ieee80211_ready_on_channel(priv->hw);
3357
3358 out:
3359 mutex_unlock(&priv->mutex);
3360
3361 return err;
3362 }
3363
3364 static int iwl_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
3365 {
3366 struct iwl_priv *priv = hw->priv;
3367
3368 if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
3369 return -EOPNOTSUPP;
3370
3371 cancel_delayed_work_sync(&priv->hw_roc_work);
3372
3373 mutex_lock(&priv->mutex);
3374 iwlagn_disable_roc(priv);
3375 mutex_unlock(&priv->mutex);
3376
3377 return 0;
3378 }
3379
3380 /*****************************************************************************
3381 *
3382 * driver setup and teardown
3383 *
3384 *****************************************************************************/
3385
3386 static void iwl_setup_deferred_work(struct iwl_priv *priv)
3387 {
3388 priv->workqueue = create_singlethread_workqueue(DRV_NAME);
3389
3390 init_waitqueue_head(&priv->wait_command_queue);
3391
3392 INIT_WORK(&priv->restart, iwl_bg_restart);
3393 INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
3394 INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
3395 INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
3396 INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
3397 INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
3398 INIT_DELAYED_WORK(&priv->hw_roc_work, iwlagn_bg_roc_done);
3399
3400 iwl_setup_scan_deferred_work(priv);
3401
3402 if (priv->cfg->lib->bt_setup_deferred_work)
3403 priv->cfg->lib->bt_setup_deferred_work(priv);
3404
3405 init_timer(&priv->statistics_periodic);
3406 priv->statistics_periodic.data = (unsigned long)priv;
3407 priv->statistics_periodic.function = iwl_bg_statistics_periodic;
3408
3409 init_timer(&priv->ucode_trace);
3410 priv->ucode_trace.data = (unsigned long)priv;
3411 priv->ucode_trace.function = iwl_bg_ucode_trace;
3412
3413 init_timer(&priv->watchdog);
3414 priv->watchdog.data = (unsigned long)priv;
3415 priv->watchdog.function = iwl_bg_watchdog;
3416 }
3417
3418 static void iwl_cancel_deferred_work(struct iwl_priv *priv)
3419 {
3420 if (priv->cfg->lib->cancel_deferred_work)
3421 priv->cfg->lib->cancel_deferred_work(priv);
3422
3423 cancel_work_sync(&priv->run_time_calib_work);
3424 cancel_work_sync(&priv->beacon_update);
3425
3426 iwl_cancel_scan_deferred_work(priv);
3427
3428 cancel_work_sync(&priv->bt_full_concurrency);
3429 cancel_work_sync(&priv->bt_runtime_config);
3430
3431 del_timer_sync(&priv->statistics_periodic);
3432 del_timer_sync(&priv->ucode_trace);
3433 }
3434
3435 static void iwl_init_hw_rates(struct iwl_priv *priv,
3436 struct ieee80211_rate *rates)
3437 {
3438 int i;
3439
3440 for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) {
3441 rates[i].bitrate = iwl_rates[i].ieee * 5;
3442 rates[i].hw_value = i; /* Rate scaling will work on indexes */
3443 rates[i].hw_value_short = i;
3444 rates[i].flags = 0;
3445 if ((i >= IWL_FIRST_CCK_RATE) && (i <= IWL_LAST_CCK_RATE)) {
3446 /*
3447 * If CCK != 1M then set short preamble rate flag.
3448 */
3449 rates[i].flags |=
3450 (iwl_rates[i].plcp == IWL_RATE_1M_PLCP) ?
3451 0 : IEEE80211_RATE_SHORT_PREAMBLE;
3452 }
3453 }
3454 }
3455
3456 static int iwl_init_drv(struct iwl_priv *priv)
3457 {
3458 int ret;
3459
3460 spin_lock_init(&priv->sta_lock);
3461 spin_lock_init(&priv->hcmd_lock);
3462
3463 mutex_init(&priv->mutex);
3464
3465 priv->ieee_channels = NULL;
3466 priv->ieee_rates = NULL;
3467 priv->band = IEEE80211_BAND_2GHZ;
3468
3469 priv->iw_mode = NL80211_IFTYPE_STATION;
3470 priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
3471 priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
3472 priv->agg_tids_count = 0;
3473
3474 /* initialize force reset */
3475 priv->force_reset[IWL_RF_RESET].reset_duration =
3476 IWL_DELAY_NEXT_FORCE_RF_RESET;
3477 priv->force_reset[IWL_FW_RESET].reset_duration =
3478 IWL_DELAY_NEXT_FORCE_FW_RELOAD;
3479
3480 priv->rx_statistics_jiffies = jiffies;
3481
3482 /* Choose which receivers/antennas to use */
3483 iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
3484
3485 iwl_init_scan_params(priv);
3486
3487 /* init bt coex */
3488 if (priv->cfg->bt_params &&
3489 priv->cfg->bt_params->advanced_bt_coexist) {
3490 priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
3491 priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
3492 priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
3493 priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
3494 priv->bt_duration = BT_DURATION_LIMIT_DEF;
3495 priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
3496 }
3497
3498 ret = iwl_init_channel_map(priv);
3499 if (ret) {
3500 IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
3501 goto err;
3502 }
3503
3504 ret = iwlcore_init_geos(priv);
3505 if (ret) {
3506 IWL_ERR(priv, "initializing geos failed: %d\n", ret);
3507 goto err_free_channel_map;
3508 }
3509 iwl_init_hw_rates(priv, priv->ieee_rates);
3510
3511 return 0;
3512
3513 err_free_channel_map:
3514 iwl_free_channel_map(priv);
3515 err:
3516 return ret;
3517 }
3518
3519 static void iwl_uninit_drv(struct iwl_priv *priv)
3520 {
3521 iwl_calib_free_results(priv);
3522 iwlcore_free_geos(priv);
3523 iwl_free_channel_map(priv);
3524 kfree(priv->scan_cmd);
3525 kfree(priv->beacon_cmd);
3526 #ifdef CONFIG_IWLWIFI_DEBUGFS
3527 kfree(priv->wowlan_sram);
3528 #endif
3529 }
3530
3531 static void iwl_mac_rssi_callback(struct ieee80211_hw *hw,
3532 enum ieee80211_rssi_event rssi_event)
3533 {
3534 struct iwl_priv *priv = hw->priv;
3535
3536 mutex_lock(&priv->mutex);
3537
3538 if (priv->cfg->bt_params &&
3539 priv->cfg->bt_params->advanced_bt_coexist) {
3540 if (rssi_event == RSSI_EVENT_LOW)
3541 priv->bt_enable_pspoll = true;
3542 else if (rssi_event == RSSI_EVENT_HIGH)
3543 priv->bt_enable_pspoll = false;
3544
3545 iwlagn_send_advance_bt_config(priv);
3546 } else {
3547 IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
3548 "ignoring RSSI callback\n");
3549 }
3550
3551 mutex_unlock(&priv->mutex);
3552 }
3553
3554 struct ieee80211_ops iwlagn_hw_ops = {
3555 .tx = iwlagn_mac_tx,
3556 .start = iwlagn_mac_start,
3557 .stop = iwlagn_mac_stop,
3558 #ifdef CONFIG_PM
3559 .suspend = iwlagn_mac_suspend,
3560 .resume = iwlagn_mac_resume,
3561 #endif
3562 .add_interface = iwl_mac_add_interface,
3563 .remove_interface = iwl_mac_remove_interface,
3564 .change_interface = iwl_mac_change_interface,
3565 .config = iwlagn_mac_config,
3566 .configure_filter = iwlagn_configure_filter,
3567 .set_key = iwlagn_mac_set_key,
3568 .update_tkip_key = iwlagn_mac_update_tkip_key,
3569 .set_rekey_data = iwlagn_mac_set_rekey_data,
3570 .conf_tx = iwl_mac_conf_tx,
3571 .bss_info_changed = iwlagn_bss_info_changed,
3572 .ampdu_action = iwlagn_mac_ampdu_action,
3573 .hw_scan = iwl_mac_hw_scan,
3574 .sta_notify = iwlagn_mac_sta_notify,
3575 .sta_add = iwlagn_mac_sta_add,
3576 .sta_remove = iwl_mac_sta_remove,
3577 .channel_switch = iwlagn_mac_channel_switch,
3578 .flush = iwlagn_mac_flush,
3579 .tx_last_beacon = iwl_mac_tx_last_beacon,
3580 .remain_on_channel = iwl_mac_remain_on_channel,
3581 .cancel_remain_on_channel = iwl_mac_cancel_remain_on_channel,
3582 .offchannel_tx = iwl_mac_offchannel_tx,
3583 .offchannel_tx_cancel_wait = iwl_mac_offchannel_tx_cancel_wait,
3584 .rssi_callback = iwl_mac_rssi_callback,
3585 CFG80211_TESTMODE_CMD(iwl_testmode_cmd)
3586 CFG80211_TESTMODE_DUMP(iwl_testmode_dump)
3587 };
3588
3589 static u32 iwl_hw_detect(struct iwl_priv *priv)
3590 {
3591 return iwl_read32(priv, CSR_HW_REV);
3592 }
3593
3594 static int iwl_set_hw_params(struct iwl_priv *priv)
3595 {
3596 priv->hw_params.max_rxq_size = RX_QUEUE_SIZE;
3597 priv->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
3598 if (iwlagn_mod_params.amsdu_size_8K)
3599 priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_8K);
3600 else
3601 priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_4K);
3602
3603 priv->hw_params.max_beacon_itrvl = IWL_MAX_UCODE_BEACON_INTERVAL;
3604
3605 if (iwlagn_mod_params.disable_11n)
3606 priv->cfg->sku &= ~EEPROM_SKU_CAP_11N_ENABLE;
3607
3608 /* Device-specific setup */
3609 return priv->cfg->lib->set_hw_params(priv);
3610 }
3611
3612 /* This function both allocates and initializes hw and priv. */
3613 static struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg)
3614 {
3615 struct iwl_priv *priv;
3616 /* mac80211 allocates memory for this device instance, including
3617 * space for this driver's private structure */
3618 struct ieee80211_hw *hw;
3619
3620 hw = ieee80211_alloc_hw(sizeof(struct iwl_priv), &iwlagn_hw_ops);
3621 if (hw == NULL) {
3622 pr_err("%s: Can not allocate network device\n",
3623 cfg->name);
3624 goto out;
3625 }
3626
3627 priv = hw->priv;
3628 priv->hw = hw;
3629
3630 out:
3631 return hw;
3632 }
3633
3634 int iwl_probe(struct iwl_bus *bus, struct iwl_cfg *cfg)
3635 {
3636 int err = 0;
3637 struct iwl_priv *priv;
3638 struct ieee80211_hw *hw;
3639 u16 num_mac;
3640 u32 hw_rev;
3641
3642 /************************
3643 * 1. Allocating HW data
3644 ************************/
3645 hw = iwl_alloc_all(cfg);
3646 if (!hw) {
3647 err = -ENOMEM;
3648 goto out;
3649 }
3650
3651 priv = hw->priv;
3652 priv->bus = bus;
3653 bus_set_drv_data(priv->bus, priv);
3654
3655 /* At this point both hw and priv are allocated. */
3656
3657 SET_IEEE80211_DEV(hw, priv->bus->dev);
3658
3659 IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
3660 priv->cfg = cfg;
3661 priv->inta_mask = CSR_INI_SET_MASK;
3662
3663 /* is antenna coupling more than 35dB ? */
3664 priv->bt_ant_couple_ok =
3665 (iwlagn_ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
3666 true : false;
3667
3668 /* enable/disable bt channel inhibition */
3669 priv->bt_ch_announce = iwlagn_bt_ch_announce;
3670 IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
3671 (priv->bt_ch_announce) ? "On" : "Off");
3672
3673 if (iwl_alloc_traffic_mem(priv))
3674 IWL_ERR(priv, "Not enough memory to generate traffic log\n");
3675
3676 /* these spin locks will be used in apm_ops.init and EEPROM access
3677 * we should init now
3678 */
3679 spin_lock_init(&priv->reg_lock);
3680 spin_lock_init(&priv->lock);
3681
3682 /*
3683 * stop and reset the on-board processor just in case it is in a
3684 * strange state ... like being left stranded by a primary kernel
3685 * and this is now the kdump kernel trying to start up
3686 */
3687 iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
3688
3689 /***********************
3690 * 3. Read REV register
3691 ***********************/
3692 hw_rev = iwl_hw_detect(priv);
3693 IWL_INFO(priv, "Detected %s, REV=0x%X\n",
3694 priv->cfg->name, hw_rev);
3695
3696 err = iwl_trans_register(&priv->trans, priv);
3697 if (err)
3698 goto out_free_traffic_mem;
3699
3700 if (trans_prepare_card_hw(&priv->trans)) {
3701 err = -EIO;
3702 IWL_WARN(priv, "Failed, HW not ready\n");
3703 goto out_free_trans;
3704 }
3705
3706 /*****************
3707 * 4. Read EEPROM
3708 *****************/
3709 /* Read the EEPROM */
3710 err = iwl_eeprom_init(priv, hw_rev);
3711 if (err) {
3712 IWL_ERR(priv, "Unable to init EEPROM\n");
3713 goto out_free_trans;
3714 }
3715 err = iwl_eeprom_check_version(priv);
3716 if (err)
3717 goto out_free_eeprom;
3718
3719 err = iwl_eeprom_check_sku(priv);
3720 if (err)
3721 goto out_free_eeprom;
3722
3723 /* extract MAC Address */
3724 iwl_eeprom_get_mac(priv, priv->addresses[0].addr);
3725 IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
3726 priv->hw->wiphy->addresses = priv->addresses;
3727 priv->hw->wiphy->n_addresses = 1;
3728 num_mac = iwl_eeprom_query16(priv, EEPROM_NUM_MAC_ADDRESS);
3729 if (num_mac > 1) {
3730 memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
3731 ETH_ALEN);
3732 priv->addresses[1].addr[5]++;
3733 priv->hw->wiphy->n_addresses++;
3734 }
3735
3736 /************************
3737 * 5. Setup HW constants
3738 ************************/
3739 if (iwl_set_hw_params(priv)) {
3740 err = -ENOENT;
3741 IWL_ERR(priv, "failed to set hw parameters\n");
3742 goto out_free_eeprom;
3743 }
3744
3745 /*******************
3746 * 6. Setup priv
3747 *******************/
3748
3749 err = iwl_init_drv(priv);
3750 if (err)
3751 goto out_free_eeprom;
3752 /* At this point both hw and priv are initialized. */
3753
3754 /********************
3755 * 7. Setup services
3756 ********************/
3757 iwl_setup_deferred_work(priv);
3758 iwl_setup_rx_handlers(priv);
3759 iwl_testmode_init(priv);
3760
3761 /*********************************************
3762 * 8. Enable interrupts
3763 *********************************************/
3764
3765 iwl_enable_rfkill_int(priv);
3766
3767 /* If platform's RF_KILL switch is NOT set to KILL */
3768 if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
3769 clear_bit(STATUS_RF_KILL_HW, &priv->status);
3770 else
3771 set_bit(STATUS_RF_KILL_HW, &priv->status);
3772
3773 wiphy_rfkill_set_hw_state(priv->hw->wiphy,
3774 test_bit(STATUS_RF_KILL_HW, &priv->status));
3775
3776 iwl_power_initialize(priv);
3777 iwl_tt_initialize(priv);
3778
3779 init_completion(&priv->firmware_loading_complete);
3780
3781 err = iwl_request_firmware(priv, true);
3782 if (err)
3783 goto out_destroy_workqueue;
3784
3785 return 0;
3786
3787 out_destroy_workqueue:
3788 destroy_workqueue(priv->workqueue);
3789 priv->workqueue = NULL;
3790 iwl_uninit_drv(priv);
3791 out_free_eeprom:
3792 iwl_eeprom_free(priv);
3793 out_free_trans:
3794 trans_free(&priv->trans);
3795 out_free_traffic_mem:
3796 iwl_free_traffic_mem(priv);
3797 ieee80211_free_hw(priv->hw);
3798 out:
3799 return err;
3800 }
3801
3802 void __devexit iwl_remove(struct iwl_priv * priv)
3803 {
3804 unsigned long flags;
3805
3806 wait_for_completion(&priv->firmware_loading_complete);
3807
3808 IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
3809
3810 iwl_dbgfs_unregister(priv);
3811 sysfs_remove_group(&priv->bus->dev->kobj,
3812 &iwl_attribute_group);
3813
3814 /* ieee80211_unregister_hw call wil cause iwl_mac_stop to
3815 * to be called and iwl_down since we are removing the device
3816 * we need to set STATUS_EXIT_PENDING bit.
3817 */
3818 set_bit(STATUS_EXIT_PENDING, &priv->status);
3819
3820 iwl_testmode_cleanup(priv);
3821 iwl_leds_exit(priv);
3822
3823 if (priv->mac80211_registered) {
3824 ieee80211_unregister_hw(priv->hw);
3825 priv->mac80211_registered = 0;
3826 }
3827
3828 /* Reset to low power before unloading driver. */
3829 iwl_apm_stop(priv);
3830
3831 iwl_tt_exit(priv);
3832
3833 /* make sure we flush any pending irq or
3834 * tasklet for the driver
3835 */
3836 spin_lock_irqsave(&priv->lock, flags);
3837 iwl_disable_interrupts(priv);
3838 spin_unlock_irqrestore(&priv->lock, flags);
3839
3840 trans_sync_irq(&priv->trans);
3841
3842 iwl_dealloc_ucode(priv);
3843
3844 trans_rx_free(&priv->trans);
3845 trans_tx_free(&priv->trans);
3846
3847 iwl_eeprom_free(priv);
3848
3849 /*netif_stop_queue(dev); */
3850 flush_workqueue(priv->workqueue);
3851
3852 /* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
3853 * priv->workqueue... so we can't take down the workqueue
3854 * until now... */
3855 destroy_workqueue(priv->workqueue);
3856 priv->workqueue = NULL;
3857 iwl_free_traffic_mem(priv);
3858
3859 trans_free(&priv->trans);
3860
3861 bus_set_drv_data(priv->bus, NULL);
3862
3863 iwl_uninit_drv(priv);
3864
3865 dev_kfree_skb(priv->beacon_skb);
3866
3867 ieee80211_free_hw(priv->hw);
3868 }
3869
3870
3871 /*****************************************************************************
3872 *
3873 * driver and module entry point
3874 *
3875 *****************************************************************************/
3876 static int __init iwl_init(void)
3877 {
3878
3879 int ret;
3880 pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
3881 pr_info(DRV_COPYRIGHT "\n");
3882
3883 ret = iwlagn_rate_control_register();
3884 if (ret) {
3885 pr_err("Unable to register rate control algorithm: %d\n", ret);
3886 return ret;
3887 }
3888
3889 ret = iwl_pci_register_driver();
3890
3891 if (ret)
3892 goto error_register;
3893 return ret;
3894
3895 error_register:
3896 iwlagn_rate_control_unregister();
3897 return ret;
3898 }
3899
3900 static void __exit iwl_exit(void)
3901 {
3902 iwl_pci_unregister_driver();
3903 iwlagn_rate_control_unregister();
3904 }
3905
3906 module_exit(iwl_exit);
3907 module_init(iwl_init);
3908
3909 #ifdef CONFIG_IWLWIFI_DEBUG
3910 module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
3911 MODULE_PARM_DESC(debug, "debug output mask");
3912 #endif
3913
3914 module_param_named(swcrypto, iwlagn_mod_params.sw_crypto, int, S_IRUGO);
3915 MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
3916 module_param_named(queues_num, iwlagn_mod_params.num_of_queues, int, S_IRUGO);
3917 MODULE_PARM_DESC(queues_num, "number of hw queues.");
3918 module_param_named(11n_disable, iwlagn_mod_params.disable_11n, int, S_IRUGO);
3919 MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
3920 module_param_named(amsdu_size_8K, iwlagn_mod_params.amsdu_size_8K,
3921 int, S_IRUGO);
3922 MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
3923 module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO);
3924 MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
3925
3926 module_param_named(ucode_alternative, iwlagn_wanted_ucode_alternative, int,
3927 S_IRUGO);
3928 MODULE_PARM_DESC(ucode_alternative,
3929 "specify ucode alternative to use from ucode file");
3930
3931 module_param_named(antenna_coupling, iwlagn_ant_coupling, int, S_IRUGO);
3932 MODULE_PARM_DESC(antenna_coupling,
3933 "specify antenna coupling in dB (defualt: 0 dB)");
3934
3935 module_param_named(bt_ch_inhibition, iwlagn_bt_ch_announce, bool, S_IRUGO);
3936 MODULE_PARM_DESC(bt_ch_inhibition,
3937 "Disable BT channel inhibition (default: enable)");
3938
3939 module_param_named(plcp_check, iwlagn_mod_params.plcp_check, bool, S_IRUGO);
3940 MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])");
3941
3942 module_param_named(ack_check, iwlagn_mod_params.ack_check, bool, S_IRUGO);
3943 MODULE_PARM_DESC(ack_check, "Check ack health (default: 0 [disabled])");
3944
3945 module_param_named(wd_disable, iwlagn_mod_params.wd_disable, bool, S_IRUGO);
3946 MODULE_PARM_DESC(wd_disable,
3947 "Disable stuck queue watchdog timer (default: 0 [enabled])");
3948
3949 /*
3950 * set bt_coex_active to true, uCode will do kill/defer
3951 * every time the priority line is asserted (BT is sending signals on the
3952 * priority line in the PCIx).
3953 * set bt_coex_active to false, uCode will ignore the BT activity and
3954 * perform the normal operation
3955 *
3956 * User might experience transmit issue on some platform due to WiFi/BT
3957 * co-exist problem. The possible behaviors are:
3958 * Able to scan and finding all the available AP
3959 * Not able to associate with any AP
3960 * On those platforms, WiFi communication can be restored by set
3961 * "bt_coex_active" module parameter to "false"
3962 *
3963 * default: bt_coex_active = true (BT_COEX_ENABLE)
3964 */
3965 module_param_named(bt_coex_active, iwlagn_mod_params.bt_coex_active,
3966 bool, S_IRUGO);
3967 MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");
3968
3969 module_param_named(led_mode, iwlagn_mod_params.led_mode, int, S_IRUGO);
3970 MODULE_PARM_DESC(led_mode, "0=system default, "
3971 "1=On(RF On)/Off(RF Off), 2=blinking (default: 0)");
3972
3973 module_param_named(power_save, iwlagn_mod_params.power_save,
3974 bool, S_IRUGO);
3975 MODULE_PARM_DESC(power_save,
3976 "enable WiFi power management (default: disable)");
3977
3978 module_param_named(power_level, iwlagn_mod_params.power_level,
3979 int, S_IRUGO);
3980 MODULE_PARM_DESC(power_level,
3981 "default power save level (range from 1 - 5, default: 1)");
3982
3983 /*
3984 * For now, keep using power level 1 instead of automatically
3985 * adjusting ...
3986 */
3987 module_param_named(no_sleep_autoadjust, iwlagn_mod_params.no_sleep_autoadjust,
3988 bool, S_IRUGO);
3989 MODULE_PARM_DESC(no_sleep_autoadjust,
3990 "don't automatically adjust sleep level "
3991 "according to maximum network latency (default: true)");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree