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