1 /******************************************************************************
5 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
21 * The full GNU General Public License is included in this distribution
22 * in the file called LICENSE.GPL.
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 *****************************************************************************/
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/etherdevice.h>
32 #include <linux/sched.h>
33 #include <linux/slab.h>
34 #include <linux/types.h>
35 #include <linux/lockdep.h>
36 #include <linux/init.h>
37 #include <linux/pci.h>
38 #include <linux/dma-mapping.h>
39 #include <linux/delay.h>
40 #include <linux/skbuff.h>
41 #include <net/mac80211.h>
46 _il_poll_bit(struct il_priv
*il
, u32 addr
, u32 bits
, u32 mask
, int timeout
)
48 const int interval
= 10; /* microseconds */
52 if ((_il_rd(il
, addr
) & mask
) == (bits
& mask
))
56 } while (t
< timeout
);
60 EXPORT_SYMBOL(_il_poll_bit
);
63 il_set_bit(struct il_priv
*p
, u32 r
, u32 m
)
65 unsigned long reg_flags
;
67 spin_lock_irqsave(&p
->reg_lock
, reg_flags
);
69 spin_unlock_irqrestore(&p
->reg_lock
, reg_flags
);
71 EXPORT_SYMBOL(il_set_bit
);
74 il_clear_bit(struct il_priv
*p
, u32 r
, u32 m
)
76 unsigned long reg_flags
;
78 spin_lock_irqsave(&p
->reg_lock
, reg_flags
);
79 _il_clear_bit(p
, r
, m
);
80 spin_unlock_irqrestore(&p
->reg_lock
, reg_flags
);
82 EXPORT_SYMBOL(il_clear_bit
);
85 _il_grab_nic_access(struct il_priv
*il
)
90 /* this bit wakes up the NIC */
91 _il_set_bit(il
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
94 * These bits say the device is running, and should keep running for
95 * at least a short while (at least as long as MAC_ACCESS_REQ stays 1),
96 * but they do not indicate that embedded SRAM is restored yet;
97 * 3945 and 4965 have volatile SRAM, and must save/restore contents
98 * to/from host DRAM when sleeping/waking for power-saving.
99 * Each direction takes approximately 1/4 millisecond; with this
100 * overhead, it's a good idea to grab and hold MAC_ACCESS_REQUEST if a
101 * series of register accesses are expected (e.g. reading Event Log),
102 * to keep device from sleeping.
104 * CSR_UCODE_DRV_GP1 register bit MAC_SLEEP == 0 indicates that
105 * SRAM is okay/restored. We don't check that here because this call
106 * is just for hardware register access; but GP1 MAC_SLEEP check is a
107 * good idea before accessing 3945/4965 SRAM (e.g. reading Event Log).
111 _il_poll_bit(il
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN
,
112 (CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
|
113 CSR_GP_CNTRL_REG_FLAG_GOING_TO_SLEEP
), 15000);
114 if (unlikely(ret
< 0)) {
115 val
= _il_rd(il
, CSR_GP_CNTRL
);
116 WARN_ONCE(1, "Timeout waiting for ucode processor access "
117 "(CSR_GP_CNTRL 0x%08x)\n", val
);
118 _il_wr(il
, CSR_RESET
, CSR_RESET_REG_FLAG_FORCE_NMI
);
124 EXPORT_SYMBOL_GPL(_il_grab_nic_access
);
127 il_poll_bit(struct il_priv
*il
, u32 addr
, u32 mask
, int timeout
)
129 const int interval
= 10; /* microseconds */
133 if ((il_rd(il
, addr
) & mask
) == mask
)
137 } while (t
< timeout
);
141 EXPORT_SYMBOL(il_poll_bit
);
144 il_rd_prph(struct il_priv
*il
, u32 reg
)
146 unsigned long reg_flags
;
149 spin_lock_irqsave(&il
->reg_lock
, reg_flags
);
150 _il_grab_nic_access(il
);
151 val
= _il_rd_prph(il
, reg
);
152 _il_release_nic_access(il
);
153 spin_unlock_irqrestore(&il
->reg_lock
, reg_flags
);
156 EXPORT_SYMBOL(il_rd_prph
);
159 il_wr_prph(struct il_priv
*il
, u32 addr
, u32 val
)
161 unsigned long reg_flags
;
163 spin_lock_irqsave(&il
->reg_lock
, reg_flags
);
164 if (likely(_il_grab_nic_access(il
))) {
165 _il_wr_prph(il
, addr
, val
);
166 _il_release_nic_access(il
);
168 spin_unlock_irqrestore(&il
->reg_lock
, reg_flags
);
170 EXPORT_SYMBOL(il_wr_prph
);
173 il_read_targ_mem(struct il_priv
*il
, u32 addr
)
175 unsigned long reg_flags
;
178 spin_lock_irqsave(&il
->reg_lock
, reg_flags
);
179 _il_grab_nic_access(il
);
181 _il_wr(il
, HBUS_TARG_MEM_RADDR
, addr
);
182 value
= _il_rd(il
, HBUS_TARG_MEM_RDAT
);
184 _il_release_nic_access(il
);
185 spin_unlock_irqrestore(&il
->reg_lock
, reg_flags
);
188 EXPORT_SYMBOL(il_read_targ_mem
);
191 il_write_targ_mem(struct il_priv
*il
, u32 addr
, u32 val
)
193 unsigned long reg_flags
;
195 spin_lock_irqsave(&il
->reg_lock
, reg_flags
);
196 if (likely(_il_grab_nic_access(il
))) {
197 _il_wr(il
, HBUS_TARG_MEM_WADDR
, addr
);
198 _il_wr(il
, HBUS_TARG_MEM_WDAT
, val
);
199 _il_release_nic_access(il
);
201 spin_unlock_irqrestore(&il
->reg_lock
, reg_flags
);
203 EXPORT_SYMBOL(il_write_targ_mem
);
206 il_get_cmd_string(u8 cmd
)
212 IL_CMD(C_RXON_ASSOC
);
214 IL_CMD(C_RXON_TIMING
);
220 IL_CMD(C_RATE_SCALE
);
222 IL_CMD(C_TX_LINK_QUALITY_CMD
);
223 IL_CMD(C_CHANNEL_SWITCH
);
224 IL_CMD(N_CHANNEL_SWITCH
);
225 IL_CMD(C_SPECTRUM_MEASUREMENT
);
226 IL_CMD(N_SPECTRUM_MEASUREMENT
);
229 IL_CMD(N_PM_DEBUG_STATS
);
231 IL_CMD(C_SCAN_ABORT
);
232 IL_CMD(N_SCAN_START
);
233 IL_CMD(N_SCAN_RESULTS
);
234 IL_CMD(N_SCAN_COMPLETE
);
237 IL_CMD(C_TX_PWR_TBL
);
241 IL_CMD(N_CARD_STATE
);
242 IL_CMD(N_MISSED_BEACONS
);
243 IL_CMD(C_CT_KILL_CONFIG
);
244 IL_CMD(C_SENSITIVITY
);
245 IL_CMD(C_PHY_CALIBRATION
);
249 IL_CMD(N_COMPRESSED_BA
);
255 EXPORT_SYMBOL(il_get_cmd_string
);
257 #define HOST_COMPLETE_TIMEOUT (HZ / 2)
260 il_generic_cmd_callback(struct il_priv
*il
, struct il_device_cmd
*cmd
,
261 struct il_rx_pkt
*pkt
)
263 if (pkt
->hdr
.flags
& IL_CMD_FAILED_MSK
) {
264 IL_ERR("Bad return from %s (0x%08X)\n",
265 il_get_cmd_string(cmd
->hdr
.cmd
), pkt
->hdr
.flags
);
268 #ifdef CONFIG_IWLEGACY_DEBUG
269 switch (cmd
->hdr
.cmd
) {
270 case C_TX_LINK_QUALITY_CMD
:
272 D_HC_DUMP("back from %s (0x%08X)\n",
273 il_get_cmd_string(cmd
->hdr
.cmd
), pkt
->hdr
.flags
);
276 D_HC("back from %s (0x%08X)\n", il_get_cmd_string(cmd
->hdr
.cmd
),
283 il_send_cmd_async(struct il_priv
*il
, struct il_host_cmd
*cmd
)
287 BUG_ON(!(cmd
->flags
& CMD_ASYNC
));
289 /* An asynchronous command can not expect an SKB to be set. */
290 BUG_ON(cmd
->flags
& CMD_WANT_SKB
);
292 /* Assign a generic callback if one is not provided */
294 cmd
->callback
= il_generic_cmd_callback
;
296 if (test_bit(S_EXIT_PENDING
, &il
->status
))
299 ret
= il_enqueue_hcmd(il
, cmd
);
301 IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
302 il_get_cmd_string(cmd
->id
), ret
);
309 il_send_cmd_sync(struct il_priv
*il
, struct il_host_cmd
*cmd
)
314 lockdep_assert_held(&il
->mutex
);
316 BUG_ON(cmd
->flags
& CMD_ASYNC
);
318 /* A synchronous command can not have a callback set. */
319 BUG_ON(cmd
->callback
);
321 D_INFO("Attempting to send sync command %s\n",
322 il_get_cmd_string(cmd
->id
));
324 set_bit(S_HCMD_ACTIVE
, &il
->status
);
325 D_INFO("Setting HCMD_ACTIVE for command %s\n",
326 il_get_cmd_string(cmd
->id
));
328 cmd_idx
= il_enqueue_hcmd(il
, cmd
);
331 IL_ERR("Error sending %s: enqueue_hcmd failed: %d\n",
332 il_get_cmd_string(cmd
->id
), ret
);
336 ret
= wait_event_timeout(il
->wait_command_queue
,
337 !test_bit(S_HCMD_ACTIVE
, &il
->status
),
338 HOST_COMPLETE_TIMEOUT
);
340 if (test_bit(S_HCMD_ACTIVE
, &il
->status
)) {
341 IL_ERR("Error sending %s: time out after %dms.\n",
342 il_get_cmd_string(cmd
->id
),
343 jiffies_to_msecs(HOST_COMPLETE_TIMEOUT
));
345 clear_bit(S_HCMD_ACTIVE
, &il
->status
);
346 D_INFO("Clearing HCMD_ACTIVE for command %s\n",
347 il_get_cmd_string(cmd
->id
));
353 if (test_bit(S_RFKILL
, &il
->status
)) {
354 IL_ERR("Command %s aborted: RF KILL Switch\n",
355 il_get_cmd_string(cmd
->id
));
359 if (test_bit(S_FW_ERROR
, &il
->status
)) {
360 IL_ERR("Command %s failed: FW Error\n",
361 il_get_cmd_string(cmd
->id
));
365 if ((cmd
->flags
& CMD_WANT_SKB
) && !cmd
->reply_page
) {
366 IL_ERR("Error: Response NULL in '%s'\n",
367 il_get_cmd_string(cmd
->id
));
376 if (cmd
->flags
& CMD_WANT_SKB
) {
378 * Cancel the CMD_WANT_SKB flag for the cmd in the
379 * TX cmd queue. Otherwise in case the cmd comes
380 * in later, it will possibly set an invalid
381 * address (cmd->meta.source).
383 il
->txq
[il
->cmd_queue
].meta
[cmd_idx
].flags
&= ~CMD_WANT_SKB
;
386 if (cmd
->reply_page
) {
387 il_free_pages(il
, cmd
->reply_page
);
393 EXPORT_SYMBOL(il_send_cmd_sync
);
396 il_send_cmd(struct il_priv
*il
, struct il_host_cmd
*cmd
)
398 if (cmd
->flags
& CMD_ASYNC
)
399 return il_send_cmd_async(il
, cmd
);
401 return il_send_cmd_sync(il
, cmd
);
403 EXPORT_SYMBOL(il_send_cmd
);
406 il_send_cmd_pdu(struct il_priv
*il
, u8 id
, u16 len
, const void *data
)
408 struct il_host_cmd cmd
= {
414 return il_send_cmd_sync(il
, &cmd
);
416 EXPORT_SYMBOL(il_send_cmd_pdu
);
419 il_send_cmd_pdu_async(struct il_priv
*il
, u8 id
, u16 len
, const void *data
,
420 void (*callback
) (struct il_priv
*il
,
421 struct il_device_cmd
*cmd
,
422 struct il_rx_pkt
*pkt
))
424 struct il_host_cmd cmd
= {
430 cmd
.flags
|= CMD_ASYNC
;
431 cmd
.callback
= callback
;
433 return il_send_cmd_async(il
, &cmd
);
435 EXPORT_SYMBOL(il_send_cmd_pdu_async
);
437 /* default: IL_LED_BLINK(0) using blinking idx table */
439 module_param(led_mode
, int, S_IRUGO
);
440 MODULE_PARM_DESC(led_mode
,
441 "0=system default, " "1=On(RF On)/Off(RF Off), 2=blinking");
443 /* Throughput OFF time(ms) ON time (ms)
456 static const struct ieee80211_tpt_blink il_blink
[] = {
457 {.throughput
= 0, .blink_time
= 334},
458 {.throughput
= 1 * 1024 - 1, .blink_time
= 260},
459 {.throughput
= 5 * 1024 - 1, .blink_time
= 220},
460 {.throughput
= 10 * 1024 - 1, .blink_time
= 190},
461 {.throughput
= 20 * 1024 - 1, .blink_time
= 170},
462 {.throughput
= 50 * 1024 - 1, .blink_time
= 150},
463 {.throughput
= 70 * 1024 - 1, .blink_time
= 130},
464 {.throughput
= 100 * 1024 - 1, .blink_time
= 110},
465 {.throughput
= 200 * 1024 - 1, .blink_time
= 80},
466 {.throughput
= 300 * 1024 - 1, .blink_time
= 50},
470 * Adjust led blink rate to compensate on a MAC Clock difference on every HW
471 * Led blink rate analysis showed an average deviation of 0% on 3945,
473 * Need to compensate on the led on/off time per HW according to the deviation
474 * to achieve the desired led frequency
475 * The calculation is: (100-averageDeviation)/100 * blinkTime
476 * For code efficiency the calculation will be:
477 * compensation = (100 - averageDeviation) * 64 / 100
478 * NewBlinkTime = (compensation * BlinkTime) / 64
481 il_blink_compensation(struct il_priv
*il
, u8 time
, u16 compensation
)
484 IL_ERR("undefined blink compensation: "
485 "use pre-defined blinking time\n");
489 return (u8
) ((time
* compensation
) >> 6);
492 /* Set led pattern command */
494 il_led_cmd(struct il_priv
*il
, unsigned long on
, unsigned long off
)
496 struct il_led_cmd led_cmd
= {
498 .interval
= IL_DEF_LED_INTRVL
502 if (!test_bit(S_READY
, &il
->status
))
505 if (il
->blink_on
== on
&& il
->blink_off
== off
)
509 /* led is SOLID_ON */
513 D_LED("Led blink time compensation=%u\n",
514 il
->cfg
->led_compensation
);
516 il_blink_compensation(il
, on
,
517 il
->cfg
->led_compensation
);
519 il_blink_compensation(il
, off
,
520 il
->cfg
->led_compensation
);
522 ret
= il
->ops
->send_led_cmd(il
, &led_cmd
);
531 il_led_brightness_set(struct led_classdev
*led_cdev
,
532 enum led_brightness brightness
)
534 struct il_priv
*il
= container_of(led_cdev
, struct il_priv
, led
);
535 unsigned long on
= 0;
540 il_led_cmd(il
, on
, 0);
544 il_led_blink_set(struct led_classdev
*led_cdev
, unsigned long *delay_on
,
545 unsigned long *delay_off
)
547 struct il_priv
*il
= container_of(led_cdev
, struct il_priv
, led
);
549 return il_led_cmd(il
, *delay_on
, *delay_off
);
553 il_leds_init(struct il_priv
*il
)
558 if (mode
== IL_LED_DEFAULT
)
559 mode
= il
->cfg
->led_mode
;
562 kasprintf(GFP_KERNEL
, "%s-led", wiphy_name(il
->hw
->wiphy
));
563 il
->led
.brightness_set
= il_led_brightness_set
;
564 il
->led
.blink_set
= il_led_blink_set
;
565 il
->led
.max_brightness
= 1;
572 il
->led
.default_trigger
=
573 ieee80211_create_tpt_led_trigger(il
->hw
,
574 IEEE80211_TPT_LEDTRIG_FL_CONNECTED
,
576 ARRAY_SIZE(il_blink
));
578 case IL_LED_RF_STATE
:
579 il
->led
.default_trigger
= ieee80211_get_radio_led_name(il
->hw
);
583 ret
= led_classdev_register(&il
->pci_dev
->dev
, &il
->led
);
589 il
->led_registered
= true;
591 EXPORT_SYMBOL(il_leds_init
);
594 il_leds_exit(struct il_priv
*il
)
596 if (!il
->led_registered
)
599 led_classdev_unregister(&il
->led
);
602 EXPORT_SYMBOL(il_leds_exit
);
604 /************************** EEPROM BANDS ****************************
606 * The il_eeprom_band definitions below provide the mapping from the
607 * EEPROM contents to the specific channel number supported for each
610 * For example, il_priv->eeprom.band_3_channels[4] from the band_3
611 * definition below maps to physical channel 42 in the 5.2GHz spectrum.
612 * The specific geography and calibration information for that channel
613 * is contained in the eeprom map itself.
615 * During init, we copy the eeprom information and channel map
616 * information into il->channel_info_24/52 and il->channel_map_24/52
618 * channel_map_24/52 provides the idx in the channel_info array for a
619 * given channel. We have to have two separate maps as there is channel
620 * overlap with the 2.4GHz and 5.2GHz spectrum as seen in band_1 and
623 * A value of 0xff stored in the channel_map indicates that the channel
624 * is not supported by the hardware at all.
626 * A value of 0xfe in the channel_map indicates that the channel is not
627 * valid for Tx with the current hardware. This means that
628 * while the system can tune and receive on a given channel, it may not
629 * be able to associate or transmit any frames on that
630 * channel. There is no corresponding channel information for that
633 *********************************************************************/
636 const u8 il_eeprom_band_1
[14] = {
637 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
641 static const u8 il_eeprom_band_2
[] = { /* 4915-5080MHz */
642 183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
645 static const u8 il_eeprom_band_3
[] = { /* 5170-5320MHz */
646 34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
649 static const u8 il_eeprom_band_4
[] = { /* 5500-5700MHz */
650 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
653 static const u8 il_eeprom_band_5
[] = { /* 5725-5825MHz */
654 145, 149, 153, 157, 161, 165
657 static const u8 il_eeprom_band_6
[] = { /* 2.4 ht40 channel */
661 static const u8 il_eeprom_band_7
[] = { /* 5.2 ht40 channel */
662 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
665 /******************************************************************************
667 * EEPROM related functions
669 ******************************************************************************/
672 il_eeprom_verify_signature(struct il_priv
*il
)
674 u32 gp
= _il_rd(il
, CSR_EEPROM_GP
) & CSR_EEPROM_GP_VALID_MSK
;
677 D_EEPROM("EEPROM signature=0x%08x\n", gp
);
679 case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K
:
680 case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K
:
683 IL_ERR("bad EEPROM signature," "EEPROM_GP=0x%08x\n", gp
);
691 il_eeprom_query_addr(const struct il_priv
*il
, size_t offset
)
693 BUG_ON(offset
>= il
->cfg
->eeprom_size
);
694 return &il
->eeprom
[offset
];
696 EXPORT_SYMBOL(il_eeprom_query_addr
);
699 il_eeprom_query16(const struct il_priv
*il
, size_t offset
)
703 return (u16
) il
->eeprom
[offset
] | ((u16
) il
->eeprom
[offset
+ 1] << 8);
705 EXPORT_SYMBOL(il_eeprom_query16
);
708 * il_eeprom_init - read EEPROM contents
710 * Load the EEPROM contents from adapter into il->eeprom
712 * NOTE: This routine uses the non-debug IO access functions.
715 il_eeprom_init(struct il_priv
*il
)
718 u32 gp
= _il_rd(il
, CSR_EEPROM_GP
);
723 /* allocate eeprom */
724 sz
= il
->cfg
->eeprom_size
;
725 D_EEPROM("NVM size = %d\n", sz
);
726 il
->eeprom
= kzalloc(sz
, GFP_KERNEL
);
731 e
= (__le16
*) il
->eeprom
;
733 il
->ops
->apm_init(il
);
735 ret
= il_eeprom_verify_signature(il
);
737 IL_ERR("EEPROM not found, EEPROM_GP=0x%08x\n", gp
);
742 /* Make sure driver (instead of uCode) is allowed to read EEPROM */
743 ret
= il
->ops
->eeprom_acquire_semaphore(il
);
745 IL_ERR("Failed to acquire EEPROM semaphore.\n");
750 /* eeprom is an array of 16bit values */
751 for (addr
= 0; addr
< sz
; addr
+= sizeof(u16
)) {
754 _il_wr(il
, CSR_EEPROM_REG
,
755 CSR_EEPROM_REG_MSK_ADDR
& (addr
<< 1));
758 _il_poll_bit(il
, CSR_EEPROM_REG
,
759 CSR_EEPROM_REG_READ_VALID_MSK
,
760 CSR_EEPROM_REG_READ_VALID_MSK
,
761 IL_EEPROM_ACCESS_TIMEOUT
);
763 IL_ERR("Time out reading EEPROM[%d]\n", addr
);
766 r
= _il_rd(il
, CSR_EEPROM_REG
);
767 e
[addr
/ 2] = cpu_to_le16(r
>> 16);
770 D_EEPROM("NVM Type: %s, version: 0x%x\n", "EEPROM",
771 il_eeprom_query16(il
, EEPROM_VERSION
));
775 il
->ops
->eeprom_release_semaphore(il
);
780 /* Reset chip to save power until we load uCode during "up". */
785 EXPORT_SYMBOL(il_eeprom_init
);
788 il_eeprom_free(struct il_priv
*il
)
793 EXPORT_SYMBOL(il_eeprom_free
);
796 il_init_band_reference(const struct il_priv
*il
, int eep_band
,
797 int *eeprom_ch_count
,
798 const struct il_eeprom_channel
**eeprom_ch_info
,
799 const u8
**eeprom_ch_idx
)
801 u32 offset
= il
->cfg
->regulatory_bands
[eep_band
- 1];
804 case 1: /* 2.4GHz band */
805 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_1
);
807 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
809 *eeprom_ch_idx
= il_eeprom_band_1
;
811 case 2: /* 4.9GHz band */
812 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_2
);
814 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
816 *eeprom_ch_idx
= il_eeprom_band_2
;
818 case 3: /* 5.2GHz band */
819 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_3
);
821 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
823 *eeprom_ch_idx
= il_eeprom_band_3
;
825 case 4: /* 5.5GHz band */
826 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_4
);
828 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
830 *eeprom_ch_idx
= il_eeprom_band_4
;
832 case 5: /* 5.7GHz band */
833 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_5
);
835 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
837 *eeprom_ch_idx
= il_eeprom_band_5
;
839 case 6: /* 2.4GHz ht40 channels */
840 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_6
);
842 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
844 *eeprom_ch_idx
= il_eeprom_band_6
;
846 case 7: /* 5 GHz ht40 channels */
847 *eeprom_ch_count
= ARRAY_SIZE(il_eeprom_band_7
);
849 (struct il_eeprom_channel
*)il_eeprom_query_addr(il
,
851 *eeprom_ch_idx
= il_eeprom_band_7
;
858 #define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
861 * il_mod_ht40_chan_info - Copy ht40 channel info into driver's il.
863 * Does not set up a command, or touch hardware.
866 il_mod_ht40_chan_info(struct il_priv
*il
, enum ieee80211_band band
, u16 channel
,
867 const struct il_eeprom_channel
*eeprom_ch
,
868 u8 clear_ht40_extension_channel
)
870 struct il_channel_info
*ch_info
;
873 (struct il_channel_info
*)il_get_channel_info(il
, band
, channel
);
875 if (!il_is_channel_valid(ch_info
))
878 D_EEPROM("HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
879 " Ad-Hoc %ssupported\n", ch_info
->channel
,
880 il_is_channel_a_band(ch_info
) ? "5.2" : "2.4",
881 CHECK_AND_PRINT(IBSS
), CHECK_AND_PRINT(ACTIVE
),
882 CHECK_AND_PRINT(RADAR
), CHECK_AND_PRINT(WIDE
),
883 CHECK_AND_PRINT(DFS
), eeprom_ch
->flags
,
884 eeprom_ch
->max_power_avg
,
885 ((eeprom_ch
->flags
& EEPROM_CHANNEL_IBSS
) &&
886 !(eeprom_ch
->flags
& EEPROM_CHANNEL_RADAR
)) ? "" : "not ");
888 ch_info
->ht40_eeprom
= *eeprom_ch
;
889 ch_info
->ht40_max_power_avg
= eeprom_ch
->max_power_avg
;
890 ch_info
->ht40_flags
= eeprom_ch
->flags
;
891 if (eeprom_ch
->flags
& EEPROM_CHANNEL_VALID
)
892 ch_info
->ht40_extension_channel
&=
893 ~clear_ht40_extension_channel
;
898 #define CHECK_AND_PRINT_I(x) ((eeprom_ch_info[ch].flags & EEPROM_CHANNEL_##x) \
902 * il_init_channel_map - Set up driver's info for all possible channels
905 il_init_channel_map(struct il_priv
*il
)
907 int eeprom_ch_count
= 0;
908 const u8
*eeprom_ch_idx
= NULL
;
909 const struct il_eeprom_channel
*eeprom_ch_info
= NULL
;
911 struct il_channel_info
*ch_info
;
913 if (il
->channel_count
) {
914 D_EEPROM("Channel map already initialized.\n");
918 D_EEPROM("Initializing regulatory info from EEPROM\n");
921 ARRAY_SIZE(il_eeprom_band_1
) + ARRAY_SIZE(il_eeprom_band_2
) +
922 ARRAY_SIZE(il_eeprom_band_3
) + ARRAY_SIZE(il_eeprom_band_4
) +
923 ARRAY_SIZE(il_eeprom_band_5
);
925 D_EEPROM("Parsing data for %d channels.\n", il
->channel_count
);
928 kzalloc(sizeof(struct il_channel_info
) * il
->channel_count
,
930 if (!il
->channel_info
) {
931 IL_ERR("Could not allocate channel_info\n");
932 il
->channel_count
= 0;
936 ch_info
= il
->channel_info
;
938 /* Loop through the 5 EEPROM bands adding them in order to the
939 * channel map we maintain (that contains additional information than
940 * what just in the EEPROM) */
941 for (band
= 1; band
<= 5; band
++) {
943 il_init_band_reference(il
, band
, &eeprom_ch_count
,
944 &eeprom_ch_info
, &eeprom_ch_idx
);
946 /* Loop through each band adding each of the channels */
947 for (ch
= 0; ch
< eeprom_ch_count
; ch
++) {
948 ch_info
->channel
= eeprom_ch_idx
[ch
];
951 1) ? IEEE80211_BAND_2GHZ
: IEEE80211_BAND_5GHZ
;
953 /* permanently store EEPROM's channel regulatory flags
954 * and max power in channel info database. */
955 ch_info
->eeprom
= eeprom_ch_info
[ch
];
957 /* Copy the run-time flags so they are there even on
958 * invalid channels */
959 ch_info
->flags
= eeprom_ch_info
[ch
].flags
;
960 /* First write that ht40 is not enabled, and then enable
962 ch_info
->ht40_extension_channel
=
963 IEEE80211_CHAN_NO_HT40
;
965 if (!(il_is_channel_valid(ch_info
))) {
966 D_EEPROM("Ch. %d Flags %x [%sGHz] - "
967 "No traffic\n", ch_info
->channel
,
969 il_is_channel_a_band(ch_info
) ? "5.2" :
975 /* Initialize regulatory-based run-time data */
976 ch_info
->max_power_avg
= ch_info
->curr_txpow
=
977 eeprom_ch_info
[ch
].max_power_avg
;
978 ch_info
->scan_power
= eeprom_ch_info
[ch
].max_power_avg
;
979 ch_info
->min_power
= 0;
981 D_EEPROM("Ch. %d [%sGHz] " "%s%s%s%s%s%s(0x%02x %ddBm):"
982 " Ad-Hoc %ssupported\n", ch_info
->channel
,
983 il_is_channel_a_band(ch_info
) ? "5.2" : "2.4",
984 CHECK_AND_PRINT_I(VALID
),
985 CHECK_AND_PRINT_I(IBSS
),
986 CHECK_AND_PRINT_I(ACTIVE
),
987 CHECK_AND_PRINT_I(RADAR
),
988 CHECK_AND_PRINT_I(WIDE
),
989 CHECK_AND_PRINT_I(DFS
),
990 eeprom_ch_info
[ch
].flags
,
991 eeprom_ch_info
[ch
].max_power_avg
,
992 ((eeprom_ch_info
[ch
].
993 flags
& EEPROM_CHANNEL_IBSS
) &&
994 !(eeprom_ch_info
[ch
].
995 flags
& EEPROM_CHANNEL_RADAR
)) ? "" :
1002 /* Check if we do have HT40 channels */
1003 if (il
->cfg
->regulatory_bands
[5] == EEPROM_REGULATORY_BAND_NO_HT40
&&
1004 il
->cfg
->regulatory_bands
[6] == EEPROM_REGULATORY_BAND_NO_HT40
)
1007 /* Two additional EEPROM bands for 2.4 and 5 GHz HT40 channels */
1008 for (band
= 6; band
<= 7; band
++) {
1009 enum ieee80211_band ieeeband
;
1011 il_init_band_reference(il
, band
, &eeprom_ch_count
,
1012 &eeprom_ch_info
, &eeprom_ch_idx
);
1014 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
1016 (band
== 6) ? IEEE80211_BAND_2GHZ
: IEEE80211_BAND_5GHZ
;
1018 /* Loop through each band adding each of the channels */
1019 for (ch
= 0; ch
< eeprom_ch_count
; ch
++) {
1020 /* Set up driver's info for lower half */
1021 il_mod_ht40_chan_info(il
, ieeeband
, eeprom_ch_idx
[ch
],
1022 &eeprom_ch_info
[ch
],
1023 IEEE80211_CHAN_NO_HT40PLUS
);
1025 /* Set up driver's info for upper half */
1026 il_mod_ht40_chan_info(il
, ieeeband
,
1027 eeprom_ch_idx
[ch
] + 4,
1028 &eeprom_ch_info
[ch
],
1029 IEEE80211_CHAN_NO_HT40MINUS
);
1035 EXPORT_SYMBOL(il_init_channel_map
);
1038 * il_free_channel_map - undo allocations in il_init_channel_map
1041 il_free_channel_map(struct il_priv
*il
)
1043 kfree(il
->channel_info
);
1044 il
->channel_count
= 0;
1046 EXPORT_SYMBOL(il_free_channel_map
);
1049 * il_get_channel_info - Find driver's ilate channel info
1051 * Based on band and channel number.
1053 const struct il_channel_info
*
1054 il_get_channel_info(const struct il_priv
*il
, enum ieee80211_band band
,
1060 case IEEE80211_BAND_5GHZ
:
1061 for (i
= 14; i
< il
->channel_count
; i
++) {
1062 if (il
->channel_info
[i
].channel
== channel
)
1063 return &il
->channel_info
[i
];
1066 case IEEE80211_BAND_2GHZ
:
1067 if (channel
>= 1 && channel
<= 14)
1068 return &il
->channel_info
[channel
- 1];
1076 EXPORT_SYMBOL(il_get_channel_info
);
1079 * Setting power level allows the card to go to sleep when not busy.
1081 * We calculate a sleep command based on the required latency, which
1082 * we get from mac80211. In order to handle thermal throttling, we can
1083 * also use pre-defined power levels.
1087 * This defines the old power levels. They are still used by default
1088 * (level 1) and for thermal throttle (levels 3 through 5)
1091 struct il_power_vec_entry
{
1092 struct il_powertable_cmd cmd
;
1093 u8 no_dtim
; /* number of skip dtim */
1097 il_power_sleep_cam_cmd(struct il_priv
*il
, struct il_powertable_cmd
*cmd
)
1099 memset(cmd
, 0, sizeof(*cmd
));
1101 if (il
->power_data
.pci_pm
)
1102 cmd
->flags
|= IL_POWER_PCI_PM_MSK
;
1104 D_POWER("Sleep command for CAM\n");
1108 il_set_power(struct il_priv
*il
, struct il_powertable_cmd
*cmd
)
1110 D_POWER("Sending power/sleep command\n");
1111 D_POWER("Flags value = 0x%08X\n", cmd
->flags
);
1112 D_POWER("Tx timeout = %u\n", le32_to_cpu(cmd
->tx_data_timeout
));
1113 D_POWER("Rx timeout = %u\n", le32_to_cpu(cmd
->rx_data_timeout
));
1114 D_POWER("Sleep interval vector = { %d , %d , %d , %d , %d }\n",
1115 le32_to_cpu(cmd
->sleep_interval
[0]),
1116 le32_to_cpu(cmd
->sleep_interval
[1]),
1117 le32_to_cpu(cmd
->sleep_interval
[2]),
1118 le32_to_cpu(cmd
->sleep_interval
[3]),
1119 le32_to_cpu(cmd
->sleep_interval
[4]));
1121 return il_send_cmd_pdu(il
, C_POWER_TBL
,
1122 sizeof(struct il_powertable_cmd
), cmd
);
1126 il_power_set_mode(struct il_priv
*il
, struct il_powertable_cmd
*cmd
, bool force
)
1131 lockdep_assert_held(&il
->mutex
);
1133 /* Don't update the RX chain when chain noise calibration is running */
1134 update_chains
= il
->chain_noise_data
.state
== IL_CHAIN_NOISE_DONE
||
1135 il
->chain_noise_data
.state
== IL_CHAIN_NOISE_ALIVE
;
1137 if (!memcmp(&il
->power_data
.sleep_cmd
, cmd
, sizeof(*cmd
)) && !force
)
1140 if (!il_is_ready_rf(il
))
1143 /* scan complete use sleep_power_next, need to be updated */
1144 memcpy(&il
->power_data
.sleep_cmd_next
, cmd
, sizeof(*cmd
));
1145 if (test_bit(S_SCANNING
, &il
->status
) && !force
) {
1146 D_INFO("Defer power set mode while scanning\n");
1150 if (cmd
->flags
& IL_POWER_DRIVER_ALLOW_SLEEP_MSK
)
1151 set_bit(S_POWER_PMI
, &il
->status
);
1153 ret
= il_set_power(il
, cmd
);
1155 if (!(cmd
->flags
& IL_POWER_DRIVER_ALLOW_SLEEP_MSK
))
1156 clear_bit(S_POWER_PMI
, &il
->status
);
1158 if (il
->ops
->update_chain_flags
&& update_chains
)
1159 il
->ops
->update_chain_flags(il
);
1160 else if (il
->ops
->update_chain_flags
)
1161 D_POWER("Cannot update the power, chain noise "
1162 "calibration running: %d\n",
1163 il
->chain_noise_data
.state
);
1165 memcpy(&il
->power_data
.sleep_cmd
, cmd
, sizeof(*cmd
));
1167 IL_ERR("set power fail, ret = %d", ret
);
1173 il_power_update_mode(struct il_priv
*il
, bool force
)
1175 struct il_powertable_cmd cmd
;
1177 il_power_sleep_cam_cmd(il
, &cmd
);
1178 return il_power_set_mode(il
, &cmd
, force
);
1180 EXPORT_SYMBOL(il_power_update_mode
);
1182 /* initialize to default */
1184 il_power_initialize(struct il_priv
*il
)
1188 pcie_capability_read_word(il
->pci_dev
, PCI_EXP_LNKCTL
, &lctl
);
1189 il
->power_data
.pci_pm
= !(lctl
& PCI_EXP_LNKCTL_ASPM_L0S
);
1191 il
->power_data
.debug_sleep_level_override
= -1;
1193 memset(&il
->power_data
.sleep_cmd
, 0, sizeof(il
->power_data
.sleep_cmd
));
1195 EXPORT_SYMBOL(il_power_initialize
);
1197 /* For active scan, listen ACTIVE_DWELL_TIME (msec) on each channel after
1198 * sending probe req. This should be set long enough to hear probe responses
1199 * from more than one AP. */
1200 #define IL_ACTIVE_DWELL_TIME_24 (30) /* all times in msec */
1201 #define IL_ACTIVE_DWELL_TIME_52 (20)
1203 #define IL_ACTIVE_DWELL_FACTOR_24GHZ (3)
1204 #define IL_ACTIVE_DWELL_FACTOR_52GHZ (2)
1206 /* For passive scan, listen PASSIVE_DWELL_TIME (msec) on each channel.
1207 * Must be set longer than active dwell time.
1208 * For the most reliable scan, set > AP beacon interval (typically 100msec). */
1209 #define IL_PASSIVE_DWELL_TIME_24 (20) /* all times in msec */
1210 #define IL_PASSIVE_DWELL_TIME_52 (10)
1211 #define IL_PASSIVE_DWELL_BASE (100)
1212 #define IL_CHANNEL_TUNE_TIME 5
1215 il_send_scan_abort(struct il_priv
*il
)
1218 struct il_rx_pkt
*pkt
;
1219 struct il_host_cmd cmd
= {
1221 .flags
= CMD_WANT_SKB
,
1224 /* Exit instantly with error when device is not ready
1225 * to receive scan abort command or it does not perform
1226 * hardware scan currently */
1227 if (!test_bit(S_READY
, &il
->status
) ||
1228 !test_bit(S_GEO_CONFIGURED
, &il
->status
) ||
1229 !test_bit(S_SCAN_HW
, &il
->status
) ||
1230 test_bit(S_FW_ERROR
, &il
->status
) ||
1231 test_bit(S_EXIT_PENDING
, &il
->status
))
1234 ret
= il_send_cmd_sync(il
, &cmd
);
1238 pkt
= (struct il_rx_pkt
*)cmd
.reply_page
;
1239 if (pkt
->u
.status
!= CAN_ABORT_STATUS
) {
1240 /* The scan abort will return 1 for success or
1241 * 2 for "failure". A failure condition can be
1242 * due to simply not being in an active scan which
1243 * can occur if we send the scan abort before we
1244 * the microcode has notified us that a scan is
1246 D_SCAN("SCAN_ABORT ret %d.\n", pkt
->u
.status
);
1250 il_free_pages(il
, cmd
.reply_page
);
1255 il_complete_scan(struct il_priv
*il
, bool aborted
)
1257 /* check if scan was requested from mac80211 */
1258 if (il
->scan_request
) {
1259 D_SCAN("Complete scan in mac80211\n");
1260 ieee80211_scan_completed(il
->hw
, aborted
);
1263 il
->scan_vif
= NULL
;
1264 il
->scan_request
= NULL
;
1268 il_force_scan_end(struct il_priv
*il
)
1270 lockdep_assert_held(&il
->mutex
);
1272 if (!test_bit(S_SCANNING
, &il
->status
)) {
1273 D_SCAN("Forcing scan end while not scanning\n");
1277 D_SCAN("Forcing scan end\n");
1278 clear_bit(S_SCANNING
, &il
->status
);
1279 clear_bit(S_SCAN_HW
, &il
->status
);
1280 clear_bit(S_SCAN_ABORTING
, &il
->status
);
1281 il_complete_scan(il
, true);
1285 il_do_scan_abort(struct il_priv
*il
)
1289 lockdep_assert_held(&il
->mutex
);
1291 if (!test_bit(S_SCANNING
, &il
->status
)) {
1292 D_SCAN("Not performing scan to abort\n");
1296 if (test_and_set_bit(S_SCAN_ABORTING
, &il
->status
)) {
1297 D_SCAN("Scan abort in progress\n");
1301 ret
= il_send_scan_abort(il
);
1303 D_SCAN("Send scan abort failed %d\n", ret
);
1304 il_force_scan_end(il
);
1306 D_SCAN("Successfully send scan abort\n");
1310 * il_scan_cancel - Cancel any currently executing HW scan
1313 il_scan_cancel(struct il_priv
*il
)
1315 D_SCAN("Queuing abort scan\n");
1316 queue_work(il
->workqueue
, &il
->abort_scan
);
1319 EXPORT_SYMBOL(il_scan_cancel
);
1322 * il_scan_cancel_timeout - Cancel any currently executing HW scan
1323 * @ms: amount of time to wait (in milliseconds) for scan to abort
1327 il_scan_cancel_timeout(struct il_priv
*il
, unsigned long ms
)
1329 unsigned long timeout
= jiffies
+ msecs_to_jiffies(ms
);
1331 lockdep_assert_held(&il
->mutex
);
1333 D_SCAN("Scan cancel timeout\n");
1335 il_do_scan_abort(il
);
1337 while (time_before_eq(jiffies
, timeout
)) {
1338 if (!test_bit(S_SCAN_HW
, &il
->status
))
1343 return test_bit(S_SCAN_HW
, &il
->status
);
1345 EXPORT_SYMBOL(il_scan_cancel_timeout
);
1347 /* Service response to C_SCAN (0x80) */
1349 il_hdl_scan(struct il_priv
*il
, struct il_rx_buf
*rxb
)
1351 #ifdef CONFIG_IWLEGACY_DEBUG
1352 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
1353 struct il_scanreq_notification
*notif
=
1354 (struct il_scanreq_notification
*)pkt
->u
.raw
;
1356 D_SCAN("Scan request status = 0x%x\n", notif
->status
);
1360 /* Service N_SCAN_START (0x82) */
1362 il_hdl_scan_start(struct il_priv
*il
, struct il_rx_buf
*rxb
)
1364 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
1365 struct il_scanstart_notification
*notif
=
1366 (struct il_scanstart_notification
*)pkt
->u
.raw
;
1367 il
->scan_start_tsf
= le32_to_cpu(notif
->tsf_low
);
1368 D_SCAN("Scan start: " "%d [802.11%s] "
1369 "(TSF: 0x%08X:%08X) - %d (beacon timer %u)\n", notif
->channel
,
1370 notif
->band
? "bg" : "a", le32_to_cpu(notif
->tsf_high
),
1371 le32_to_cpu(notif
->tsf_low
), notif
->status
, notif
->beacon_timer
);
1374 /* Service N_SCAN_RESULTS (0x83) */
1376 il_hdl_scan_results(struct il_priv
*il
, struct il_rx_buf
*rxb
)
1378 #ifdef CONFIG_IWLEGACY_DEBUG
1379 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
1380 struct il_scanresults_notification
*notif
=
1381 (struct il_scanresults_notification
*)pkt
->u
.raw
;
1383 D_SCAN("Scan ch.res: " "%d [802.11%s] " "(TSF: 0x%08X:%08X) - %d "
1384 "elapsed=%lu usec\n", notif
->channel
, notif
->band
? "bg" : "a",
1385 le32_to_cpu(notif
->tsf_high
), le32_to_cpu(notif
->tsf_low
),
1386 le32_to_cpu(notif
->stats
[0]),
1387 le32_to_cpu(notif
->tsf_low
) - il
->scan_start_tsf
);
1391 /* Service N_SCAN_COMPLETE (0x84) */
1393 il_hdl_scan_complete(struct il_priv
*il
, struct il_rx_buf
*rxb
)
1396 #ifdef CONFIG_IWLEGACY_DEBUG
1397 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
1398 struct il_scancomplete_notification
*scan_notif
= (void *)pkt
->u
.raw
;
1401 D_SCAN("Scan complete: %d channels (TSF 0x%08X:%08X) - %d\n",
1402 scan_notif
->scanned_channels
, scan_notif
->tsf_low
,
1403 scan_notif
->tsf_high
, scan_notif
->status
);
1405 /* The HW is no longer scanning */
1406 clear_bit(S_SCAN_HW
, &il
->status
);
1408 D_SCAN("Scan on %sGHz took %dms\n",
1409 (il
->scan_band
== IEEE80211_BAND_2GHZ
) ? "2.4" : "5.2",
1410 jiffies_to_msecs(jiffies
- il
->scan_start
));
1412 queue_work(il
->workqueue
, &il
->scan_completed
);
1416 il_setup_rx_scan_handlers(struct il_priv
*il
)
1419 il
->handlers
[C_SCAN
] = il_hdl_scan
;
1420 il
->handlers
[N_SCAN_START
] = il_hdl_scan_start
;
1421 il
->handlers
[N_SCAN_RESULTS
] = il_hdl_scan_results
;
1422 il
->handlers
[N_SCAN_COMPLETE
] = il_hdl_scan_complete
;
1424 EXPORT_SYMBOL(il_setup_rx_scan_handlers
);
1427 il_get_active_dwell_time(struct il_priv
*il
, enum ieee80211_band band
,
1430 if (band
== IEEE80211_BAND_5GHZ
)
1431 return IL_ACTIVE_DWELL_TIME_52
+
1432 IL_ACTIVE_DWELL_FACTOR_52GHZ
* (n_probes
+ 1);
1434 return IL_ACTIVE_DWELL_TIME_24
+
1435 IL_ACTIVE_DWELL_FACTOR_24GHZ
* (n_probes
+ 1);
1437 EXPORT_SYMBOL(il_get_active_dwell_time
);
1440 il_get_passive_dwell_time(struct il_priv
*il
, enum ieee80211_band band
,
1441 struct ieee80211_vif
*vif
)
1447 IEEE80211_BAND_2GHZ
) ? IL_PASSIVE_DWELL_BASE
+
1448 IL_PASSIVE_DWELL_TIME_24
: IL_PASSIVE_DWELL_BASE
+
1449 IL_PASSIVE_DWELL_TIME_52
;
1451 if (il_is_any_associated(il
)) {
1453 * If we're associated, we clamp the maximum passive
1454 * dwell time to be 98% of the smallest beacon interval
1455 * (minus 2 * channel tune time)
1457 value
= il
->vif
? il
->vif
->bss_conf
.beacon_int
: 0;
1458 if (value
> IL_PASSIVE_DWELL_BASE
|| !value
)
1459 value
= IL_PASSIVE_DWELL_BASE
;
1460 value
= (value
* 98) / 100 - IL_CHANNEL_TUNE_TIME
* 2;
1461 passive
= min(value
, passive
);
1466 EXPORT_SYMBOL(il_get_passive_dwell_time
);
1469 il_init_scan_params(struct il_priv
*il
)
1471 u8 ant_idx
= fls(il
->hw_params
.valid_tx_ant
) - 1;
1472 if (!il
->scan_tx_ant
[IEEE80211_BAND_5GHZ
])
1473 il
->scan_tx_ant
[IEEE80211_BAND_5GHZ
] = ant_idx
;
1474 if (!il
->scan_tx_ant
[IEEE80211_BAND_2GHZ
])
1475 il
->scan_tx_ant
[IEEE80211_BAND_2GHZ
] = ant_idx
;
1477 EXPORT_SYMBOL(il_init_scan_params
);
1480 il_scan_initiate(struct il_priv
*il
, struct ieee80211_vif
*vif
)
1484 lockdep_assert_held(&il
->mutex
);
1486 cancel_delayed_work(&il
->scan_check
);
1488 if (!il_is_ready_rf(il
)) {
1489 IL_WARN("Request scan called when driver not ready.\n");
1493 if (test_bit(S_SCAN_HW
, &il
->status
)) {
1494 D_SCAN("Multiple concurrent scan requests in parallel.\n");
1498 if (test_bit(S_SCAN_ABORTING
, &il
->status
)) {
1499 D_SCAN("Scan request while abort pending.\n");
1503 D_SCAN("Starting scan...\n");
1505 set_bit(S_SCANNING
, &il
->status
);
1506 il
->scan_start
= jiffies
;
1508 ret
= il
->ops
->request_scan(il
, vif
);
1510 clear_bit(S_SCANNING
, &il
->status
);
1514 queue_delayed_work(il
->workqueue
, &il
->scan_check
,
1515 IL_SCAN_CHECK_WATCHDOG
);
1521 il_mac_hw_scan(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
1522 struct cfg80211_scan_request
*req
)
1524 struct il_priv
*il
= hw
->priv
;
1527 if (req
->n_channels
== 0) {
1528 IL_ERR("Can not scan on no channels.\n");
1532 mutex_lock(&il
->mutex
);
1533 D_MAC80211("enter\n");
1535 if (test_bit(S_SCANNING
, &il
->status
)) {
1536 D_SCAN("Scan already in progress.\n");
1541 /* mac80211 will only ask for one band at a time */
1542 il
->scan_request
= req
;
1544 il
->scan_band
= req
->channels
[0]->band
;
1546 ret
= il_scan_initiate(il
, vif
);
1549 D_MAC80211("leave ret %d\n", ret
);
1550 mutex_unlock(&il
->mutex
);
1554 EXPORT_SYMBOL(il_mac_hw_scan
);
1557 il_bg_scan_check(struct work_struct
*data
)
1559 struct il_priv
*il
=
1560 container_of(data
, struct il_priv
, scan_check
.work
);
1562 D_SCAN("Scan check work\n");
1564 /* Since we are here firmware does not finish scan and
1565 * most likely is in bad shape, so we don't bother to
1566 * send abort command, just force scan complete to mac80211 */
1567 mutex_lock(&il
->mutex
);
1568 il_force_scan_end(il
);
1569 mutex_unlock(&il
->mutex
);
1573 * il_fill_probe_req - fill in all required fields and IE for probe request
1577 il_fill_probe_req(struct il_priv
*il
, struct ieee80211_mgmt
*frame
,
1578 const u8
*ta
, const u8
*ies
, int ie_len
, int left
)
1583 /* Make sure there is enough space for the probe request,
1584 * two mandatory IEs and the data */
1589 frame
->frame_control
= cpu_to_le16(IEEE80211_STYPE_PROBE_REQ
);
1590 eth_broadcast_addr(frame
->da
);
1591 memcpy(frame
->sa
, ta
, ETH_ALEN
);
1592 eth_broadcast_addr(frame
->bssid
);
1593 frame
->seq_ctrl
= 0;
1598 pos
= &frame
->u
.probe_req
.variable
[0];
1600 /* fill in our indirect SSID IE */
1604 *pos
++ = WLAN_EID_SSID
;
1609 if (WARN_ON(left
< ie_len
))
1612 if (ies
&& ie_len
) {
1613 memcpy(pos
, ies
, ie_len
);
1619 EXPORT_SYMBOL(il_fill_probe_req
);
1622 il_bg_abort_scan(struct work_struct
*work
)
1624 struct il_priv
*il
= container_of(work
, struct il_priv
, abort_scan
);
1626 D_SCAN("Abort scan work\n");
1628 /* We keep scan_check work queued in case when firmware will not
1629 * report back scan completed notification */
1630 mutex_lock(&il
->mutex
);
1631 il_scan_cancel_timeout(il
, 200);
1632 mutex_unlock(&il
->mutex
);
1636 il_bg_scan_completed(struct work_struct
*work
)
1638 struct il_priv
*il
= container_of(work
, struct il_priv
, scan_completed
);
1641 D_SCAN("Completed scan.\n");
1643 cancel_delayed_work(&il
->scan_check
);
1645 mutex_lock(&il
->mutex
);
1647 aborted
= test_and_clear_bit(S_SCAN_ABORTING
, &il
->status
);
1649 D_SCAN("Aborted scan completed.\n");
1651 if (!test_and_clear_bit(S_SCANNING
, &il
->status
)) {
1652 D_SCAN("Scan already completed.\n");
1656 il_complete_scan(il
, aborted
);
1659 /* Can we still talk to firmware ? */
1660 if (!il_is_ready_rf(il
))
1664 * We do not commit power settings while scan is pending,
1665 * do it now if the settings changed.
1667 il_power_set_mode(il
, &il
->power_data
.sleep_cmd_next
, false);
1668 il_set_tx_power(il
, il
->tx_power_next
, false);
1670 il
->ops
->post_scan(il
);
1673 mutex_unlock(&il
->mutex
);
1677 il_setup_scan_deferred_work(struct il_priv
*il
)
1679 INIT_WORK(&il
->scan_completed
, il_bg_scan_completed
);
1680 INIT_WORK(&il
->abort_scan
, il_bg_abort_scan
);
1681 INIT_DELAYED_WORK(&il
->scan_check
, il_bg_scan_check
);
1683 EXPORT_SYMBOL(il_setup_scan_deferred_work
);
1686 il_cancel_scan_deferred_work(struct il_priv
*il
)
1688 cancel_work_sync(&il
->abort_scan
);
1689 cancel_work_sync(&il
->scan_completed
);
1691 if (cancel_delayed_work_sync(&il
->scan_check
)) {
1692 mutex_lock(&il
->mutex
);
1693 il_force_scan_end(il
);
1694 mutex_unlock(&il
->mutex
);
1697 EXPORT_SYMBOL(il_cancel_scan_deferred_work
);
1699 /* il->sta_lock must be held */
1701 il_sta_ucode_activate(struct il_priv
*il
, u8 sta_id
)
1704 if (!(il
->stations
[sta_id
].used
& IL_STA_DRIVER_ACTIVE
))
1705 IL_ERR("ACTIVATE a non DRIVER active station id %u addr %pM\n",
1706 sta_id
, il
->stations
[sta_id
].sta
.sta
.addr
);
1708 if (il
->stations
[sta_id
].used
& IL_STA_UCODE_ACTIVE
) {
1709 D_ASSOC("STA id %u addr %pM already present"
1710 " in uCode (according to driver)\n", sta_id
,
1711 il
->stations
[sta_id
].sta
.sta
.addr
);
1713 il
->stations
[sta_id
].used
|= IL_STA_UCODE_ACTIVE
;
1714 D_ASSOC("Added STA id %u addr %pM to uCode\n", sta_id
,
1715 il
->stations
[sta_id
].sta
.sta
.addr
);
1720 il_process_add_sta_resp(struct il_priv
*il
, struct il_addsta_cmd
*addsta
,
1721 struct il_rx_pkt
*pkt
, bool sync
)
1723 u8 sta_id
= addsta
->sta
.sta_id
;
1724 unsigned long flags
;
1727 if (pkt
->hdr
.flags
& IL_CMD_FAILED_MSK
) {
1728 IL_ERR("Bad return from C_ADD_STA (0x%08X)\n", pkt
->hdr
.flags
);
1732 D_INFO("Processing response for adding station %u\n", sta_id
);
1734 spin_lock_irqsave(&il
->sta_lock
, flags
);
1736 switch (pkt
->u
.add_sta
.status
) {
1737 case ADD_STA_SUCCESS_MSK
:
1738 D_INFO("C_ADD_STA PASSED\n");
1739 il_sta_ucode_activate(il
, sta_id
);
1742 case ADD_STA_NO_ROOM_IN_TBL
:
1743 IL_ERR("Adding station %d failed, no room in table.\n", sta_id
);
1745 case ADD_STA_NO_BLOCK_ACK_RESOURCE
:
1746 IL_ERR("Adding station %d failed, no block ack resource.\n",
1749 case ADD_STA_MODIFY_NON_EXIST_STA
:
1750 IL_ERR("Attempting to modify non-existing station %d\n",
1754 D_ASSOC("Received C_ADD_STA:(0x%08X)\n", pkt
->u
.add_sta
.status
);
1758 D_INFO("%s station id %u addr %pM\n",
1759 il
->stations
[sta_id
].sta
.mode
==
1760 STA_CONTROL_MODIFY_MSK
? "Modified" : "Added", sta_id
,
1761 il
->stations
[sta_id
].sta
.sta
.addr
);
1764 * XXX: The MAC address in the command buffer is often changed from
1765 * the original sent to the device. That is, the MAC address
1766 * written to the command buffer often is not the same MAC address
1767 * read from the command buffer when the command returns. This
1768 * issue has not yet been resolved and this debugging is left to
1769 * observe the problem.
1771 D_INFO("%s station according to cmd buffer %pM\n",
1772 il
->stations
[sta_id
].sta
.mode
==
1773 STA_CONTROL_MODIFY_MSK
? "Modified" : "Added", addsta
->sta
.addr
);
1774 spin_unlock_irqrestore(&il
->sta_lock
, flags
);
1780 il_add_sta_callback(struct il_priv
*il
, struct il_device_cmd
*cmd
,
1781 struct il_rx_pkt
*pkt
)
1783 struct il_addsta_cmd
*addsta
= (struct il_addsta_cmd
*)cmd
->cmd
.payload
;
1785 il_process_add_sta_resp(il
, addsta
, pkt
, false);
1790 il_send_add_sta(struct il_priv
*il
, struct il_addsta_cmd
*sta
, u8 flags
)
1792 struct il_rx_pkt
*pkt
= NULL
;
1794 u8 data
[sizeof(*sta
)];
1795 struct il_host_cmd cmd
= {
1800 u8 sta_id __maybe_unused
= sta
->sta
.sta_id
;
1802 D_INFO("Adding sta %u (%pM) %ssynchronously\n", sta_id
, sta
->sta
.addr
,
1803 flags
& CMD_ASYNC
? "a" : "");
1805 if (flags
& CMD_ASYNC
)
1806 cmd
.callback
= il_add_sta_callback
;
1808 cmd
.flags
|= CMD_WANT_SKB
;
1812 cmd
.len
= il
->ops
->build_addsta_hcmd(sta
, data
);
1813 ret
= il_send_cmd(il
, &cmd
);
1815 if (ret
|| (flags
& CMD_ASYNC
))
1819 pkt
= (struct il_rx_pkt
*)cmd
.reply_page
;
1820 ret
= il_process_add_sta_resp(il
, sta
, pkt
, true);
1822 il_free_pages(il
, cmd
.reply_page
);
1826 EXPORT_SYMBOL(il_send_add_sta
);
1829 il_set_ht_add_station(struct il_priv
*il
, u8 idx
, struct ieee80211_sta
*sta
)
1831 struct ieee80211_sta_ht_cap
*sta_ht_inf
= &sta
->ht_cap
;
1834 if (!sta
|| !sta_ht_inf
->ht_supported
)
1837 D_ASSOC("spatial multiplexing power save mode: %s\n",
1838 (sta
->smps_mode
== IEEE80211_SMPS_STATIC
) ? "static" :
1839 (sta
->smps_mode
== IEEE80211_SMPS_DYNAMIC
) ? "dynamic" :
1842 sta_flags
= il
->stations
[idx
].sta
.station_flags
;
1844 sta_flags
&= ~(STA_FLG_RTS_MIMO_PROT_MSK
| STA_FLG_MIMO_DIS_MSK
);
1846 switch (sta
->smps_mode
) {
1847 case IEEE80211_SMPS_STATIC
:
1848 sta_flags
|= STA_FLG_MIMO_DIS_MSK
;
1850 case IEEE80211_SMPS_DYNAMIC
:
1851 sta_flags
|= STA_FLG_RTS_MIMO_PROT_MSK
;
1853 case IEEE80211_SMPS_OFF
:
1856 IL_WARN("Invalid MIMO PS mode %d\n", sta
->smps_mode
);
1861 cpu_to_le32((u32
) sta_ht_inf
->
1862 ampdu_factor
<< STA_FLG_MAX_AGG_SIZE_POS
);
1865 cpu_to_le32((u32
) sta_ht_inf
->
1866 ampdu_density
<< STA_FLG_AGG_MPDU_DENSITY_POS
);
1868 if (il_is_ht40_tx_allowed(il
, &sta
->ht_cap
))
1869 sta_flags
|= STA_FLG_HT40_EN_MSK
;
1871 sta_flags
&= ~STA_FLG_HT40_EN_MSK
;
1873 il
->stations
[idx
].sta
.station_flags
= sta_flags
;
1879 * il_prep_station - Prepare station information for addition
1881 * should be called with sta_lock held
1884 il_prep_station(struct il_priv
*il
, const u8
*addr
, bool is_ap
,
1885 struct ieee80211_sta
*sta
)
1887 struct il_station_entry
*station
;
1889 u8 sta_id
= IL_INVALID_STATION
;
1894 else if (is_broadcast_ether_addr(addr
))
1895 sta_id
= il
->hw_params
.bcast_id
;
1897 for (i
= IL_STA_ID
; i
< il
->hw_params
.max_stations
; i
++) {
1898 if (ether_addr_equal(il
->stations
[i
].sta
.sta
.addr
,
1904 if (!il
->stations
[i
].used
&&
1905 sta_id
== IL_INVALID_STATION
)
1910 * These two conditions have the same outcome, but keep them
1913 if (unlikely(sta_id
== IL_INVALID_STATION
))
1917 * uCode is not able to deal with multiple requests to add a
1918 * station. Keep track if one is in progress so that we do not send
1921 if (il
->stations
[sta_id
].used
& IL_STA_UCODE_INPROGRESS
) {
1922 D_INFO("STA %d already in process of being added.\n", sta_id
);
1926 if ((il
->stations
[sta_id
].used
& IL_STA_DRIVER_ACTIVE
) &&
1927 (il
->stations
[sta_id
].used
& IL_STA_UCODE_ACTIVE
) &&
1928 ether_addr_equal(il
->stations
[sta_id
].sta
.sta
.addr
, addr
)) {
1929 D_ASSOC("STA %d (%pM) already added, not adding again.\n",
1934 station
= &il
->stations
[sta_id
];
1935 station
->used
= IL_STA_DRIVER_ACTIVE
;
1936 D_ASSOC("Add STA to driver ID %d: %pM\n", sta_id
, addr
);
1939 /* Set up the C_ADD_STA command to send to device */
1940 memset(&station
->sta
, 0, sizeof(struct il_addsta_cmd
));
1941 memcpy(station
->sta
.sta
.addr
, addr
, ETH_ALEN
);
1942 station
->sta
.mode
= 0;
1943 station
->sta
.sta
.sta_id
= sta_id
;
1944 station
->sta
.station_flags
= 0;
1947 * OK to call unconditionally, since local stations (IBSS BSSID
1948 * STA and broadcast STA) pass in a NULL sta, and mac80211
1949 * doesn't allow HT IBSS.
1951 il_set_ht_add_station(il
, sta_id
, sta
);
1954 rate
= (il
->band
== IEEE80211_BAND_5GHZ
) ? RATE_6M_PLCP
: RATE_1M_PLCP
;
1955 /* Turn on both antennas for the station... */
1956 station
->sta
.rate_n_flags
= cpu_to_le16(rate
| RATE_MCS_ANT_AB_MSK
);
1961 EXPORT_SYMBOL_GPL(il_prep_station
);
1963 #define STA_WAIT_TIMEOUT (HZ/2)
1966 * il_add_station_common -
1969 il_add_station_common(struct il_priv
*il
, const u8
*addr
, bool is_ap
,
1970 struct ieee80211_sta
*sta
, u8
*sta_id_r
)
1972 unsigned long flags_spin
;
1975 struct il_addsta_cmd sta_cmd
;
1978 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
1979 sta_id
= il_prep_station(il
, addr
, is_ap
, sta
);
1980 if (sta_id
== IL_INVALID_STATION
) {
1981 IL_ERR("Unable to prepare station %pM for addition\n", addr
);
1982 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
1987 * uCode is not able to deal with multiple requests to add a
1988 * station. Keep track if one is in progress so that we do not send
1991 if (il
->stations
[sta_id
].used
& IL_STA_UCODE_INPROGRESS
) {
1992 D_INFO("STA %d already in process of being added.\n", sta_id
);
1993 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
1997 if ((il
->stations
[sta_id
].used
& IL_STA_DRIVER_ACTIVE
) &&
1998 (il
->stations
[sta_id
].used
& IL_STA_UCODE_ACTIVE
)) {
1999 D_ASSOC("STA %d (%pM) already added, not adding again.\n",
2001 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2005 il
->stations
[sta_id
].used
|= IL_STA_UCODE_INPROGRESS
;
2006 memcpy(&sta_cmd
, &il
->stations
[sta_id
].sta
,
2007 sizeof(struct il_addsta_cmd
));
2008 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2010 /* Add station to device's station table */
2011 ret
= il_send_add_sta(il
, &sta_cmd
, CMD_SYNC
);
2013 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2014 IL_ERR("Adding station %pM failed.\n",
2015 il
->stations
[sta_id
].sta
.sta
.addr
);
2016 il
->stations
[sta_id
].used
&= ~IL_STA_DRIVER_ACTIVE
;
2017 il
->stations
[sta_id
].used
&= ~IL_STA_UCODE_INPROGRESS
;
2018 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2023 EXPORT_SYMBOL(il_add_station_common
);
2026 * il_sta_ucode_deactivate - deactivate ucode status for a station
2028 * il->sta_lock must be held
2031 il_sta_ucode_deactivate(struct il_priv
*il
, u8 sta_id
)
2033 /* Ucode must be active and driver must be non active */
2034 if ((il
->stations
[sta_id
].
2035 used
& (IL_STA_UCODE_ACTIVE
| IL_STA_DRIVER_ACTIVE
)) !=
2036 IL_STA_UCODE_ACTIVE
)
2037 IL_ERR("removed non active STA %u\n", sta_id
);
2039 il
->stations
[sta_id
].used
&= ~IL_STA_UCODE_ACTIVE
;
2041 memset(&il
->stations
[sta_id
], 0, sizeof(struct il_station_entry
));
2042 D_ASSOC("Removed STA %u\n", sta_id
);
2046 il_send_remove_station(struct il_priv
*il
, const u8
* addr
, int sta_id
,
2049 struct il_rx_pkt
*pkt
;
2052 unsigned long flags_spin
;
2053 struct il_rem_sta_cmd rm_sta_cmd
;
2055 struct il_host_cmd cmd
= {
2057 .len
= sizeof(struct il_rem_sta_cmd
),
2059 .data
= &rm_sta_cmd
,
2062 memset(&rm_sta_cmd
, 0, sizeof(rm_sta_cmd
));
2063 rm_sta_cmd
.num_sta
= 1;
2064 memcpy(&rm_sta_cmd
.addr
, addr
, ETH_ALEN
);
2066 cmd
.flags
|= CMD_WANT_SKB
;
2068 ret
= il_send_cmd(il
, &cmd
);
2073 pkt
= (struct il_rx_pkt
*)cmd
.reply_page
;
2074 if (pkt
->hdr
.flags
& IL_CMD_FAILED_MSK
) {
2075 IL_ERR("Bad return from C_REM_STA (0x%08X)\n", pkt
->hdr
.flags
);
2080 switch (pkt
->u
.rem_sta
.status
) {
2081 case REM_STA_SUCCESS_MSK
:
2083 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2084 il_sta_ucode_deactivate(il
, sta_id
);
2085 spin_unlock_irqrestore(&il
->sta_lock
,
2088 D_ASSOC("C_REM_STA PASSED\n");
2092 IL_ERR("C_REM_STA failed\n");
2096 il_free_pages(il
, cmd
.reply_page
);
2102 * il_remove_station - Remove driver's knowledge of station.
2105 il_remove_station(struct il_priv
*il
, const u8 sta_id
, const u8
* addr
)
2107 unsigned long flags
;
2109 if (!il_is_ready(il
)) {
2110 D_INFO("Unable to remove station %pM, device not ready.\n",
2113 * It is typical for stations to be removed when we are
2114 * going down. Return success since device will be down
2120 D_ASSOC("Removing STA from driver:%d %pM\n", sta_id
, addr
);
2122 if (WARN_ON(sta_id
== IL_INVALID_STATION
))
2125 spin_lock_irqsave(&il
->sta_lock
, flags
);
2127 if (!(il
->stations
[sta_id
].used
& IL_STA_DRIVER_ACTIVE
)) {
2128 D_INFO("Removing %pM but non DRIVER active\n", addr
);
2132 if (!(il
->stations
[sta_id
].used
& IL_STA_UCODE_ACTIVE
)) {
2133 D_INFO("Removing %pM but non UCODE active\n", addr
);
2137 if (il
->stations
[sta_id
].used
& IL_STA_LOCAL
) {
2138 kfree(il
->stations
[sta_id
].lq
);
2139 il
->stations
[sta_id
].lq
= NULL
;
2142 il
->stations
[sta_id
].used
&= ~IL_STA_DRIVER_ACTIVE
;
2146 BUG_ON(il
->num_stations
< 0);
2148 spin_unlock_irqrestore(&il
->sta_lock
, flags
);
2150 return il_send_remove_station(il
, addr
, sta_id
, false);
2152 spin_unlock_irqrestore(&il
->sta_lock
, flags
);
2155 EXPORT_SYMBOL_GPL(il_remove_station
);
2158 * il_clear_ucode_stations - clear ucode station table bits
2160 * This function clears all the bits in the driver indicating
2161 * which stations are active in the ucode. Call when something
2162 * other than explicit station management would cause this in
2163 * the ucode, e.g. unassociated RXON.
2166 il_clear_ucode_stations(struct il_priv
*il
)
2169 unsigned long flags_spin
;
2170 bool cleared
= false;
2172 D_INFO("Clearing ucode stations in driver\n");
2174 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2175 for (i
= 0; i
< il
->hw_params
.max_stations
; i
++) {
2176 if (il
->stations
[i
].used
& IL_STA_UCODE_ACTIVE
) {
2177 D_INFO("Clearing ucode active for station %d\n", i
);
2178 il
->stations
[i
].used
&= ~IL_STA_UCODE_ACTIVE
;
2182 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2185 D_INFO("No active stations found to be cleared\n");
2187 EXPORT_SYMBOL(il_clear_ucode_stations
);
2190 * il_restore_stations() - Restore driver known stations to device
2192 * All stations considered active by driver, but not present in ucode, is
2198 il_restore_stations(struct il_priv
*il
)
2200 struct il_addsta_cmd sta_cmd
;
2201 struct il_link_quality_cmd lq
;
2202 unsigned long flags_spin
;
2208 if (!il_is_ready(il
)) {
2209 D_INFO("Not ready yet, not restoring any stations.\n");
2213 D_ASSOC("Restoring all known stations ... start.\n");
2214 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2215 for (i
= 0; i
< il
->hw_params
.max_stations
; i
++) {
2216 if ((il
->stations
[i
].used
& IL_STA_DRIVER_ACTIVE
) &&
2217 !(il
->stations
[i
].used
& IL_STA_UCODE_ACTIVE
)) {
2218 D_ASSOC("Restoring sta %pM\n",
2219 il
->stations
[i
].sta
.sta
.addr
);
2220 il
->stations
[i
].sta
.mode
= 0;
2221 il
->stations
[i
].used
|= IL_STA_UCODE_INPROGRESS
;
2226 for (i
= 0; i
< il
->hw_params
.max_stations
; i
++) {
2227 if ((il
->stations
[i
].used
& IL_STA_UCODE_INPROGRESS
)) {
2228 memcpy(&sta_cmd
, &il
->stations
[i
].sta
,
2229 sizeof(struct il_addsta_cmd
));
2231 if (il
->stations
[i
].lq
) {
2232 memcpy(&lq
, il
->stations
[i
].lq
,
2233 sizeof(struct il_link_quality_cmd
));
2236 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2237 ret
= il_send_add_sta(il
, &sta_cmd
, CMD_SYNC
);
2239 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2240 IL_ERR("Adding station %pM failed.\n",
2241 il
->stations
[i
].sta
.sta
.addr
);
2242 il
->stations
[i
].used
&= ~IL_STA_DRIVER_ACTIVE
;
2243 il
->stations
[i
].used
&=
2244 ~IL_STA_UCODE_INPROGRESS
;
2245 spin_unlock_irqrestore(&il
->sta_lock
,
2249 * Rate scaling has already been initialized, send
2250 * current LQ command
2253 il_send_lq_cmd(il
, &lq
, CMD_SYNC
, true);
2254 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2255 il
->stations
[i
].used
&= ~IL_STA_UCODE_INPROGRESS
;
2259 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2261 D_INFO("Restoring all known stations"
2262 " .... no stations to be restored.\n");
2264 D_INFO("Restoring all known stations" " .... complete.\n");
2266 EXPORT_SYMBOL(il_restore_stations
);
2269 il_get_free_ucode_key_idx(struct il_priv
*il
)
2273 for (i
= 0; i
< il
->sta_key_max_num
; i
++)
2274 if (!test_and_set_bit(i
, &il
->ucode_key_table
))
2277 return WEP_INVALID_OFFSET
;
2279 EXPORT_SYMBOL(il_get_free_ucode_key_idx
);
2282 il_dealloc_bcast_stations(struct il_priv
*il
)
2284 unsigned long flags
;
2287 spin_lock_irqsave(&il
->sta_lock
, flags
);
2288 for (i
= 0; i
< il
->hw_params
.max_stations
; i
++) {
2289 if (!(il
->stations
[i
].used
& IL_STA_BCAST
))
2292 il
->stations
[i
].used
&= ~IL_STA_UCODE_ACTIVE
;
2294 BUG_ON(il
->num_stations
< 0);
2295 kfree(il
->stations
[i
].lq
);
2296 il
->stations
[i
].lq
= NULL
;
2298 spin_unlock_irqrestore(&il
->sta_lock
, flags
);
2300 EXPORT_SYMBOL_GPL(il_dealloc_bcast_stations
);
2302 #ifdef CONFIG_IWLEGACY_DEBUG
2304 il_dump_lq_cmd(struct il_priv
*il
, struct il_link_quality_cmd
*lq
)
2307 D_RATE("lq station id 0x%x\n", lq
->sta_id
);
2308 D_RATE("lq ant 0x%X 0x%X\n", lq
->general_params
.single_stream_ant_msk
,
2309 lq
->general_params
.dual_stream_ant_msk
);
2311 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++)
2312 D_RATE("lq idx %d 0x%X\n", i
, lq
->rs_table
[i
].rate_n_flags
);
2316 il_dump_lq_cmd(struct il_priv
*il
, struct il_link_quality_cmd
*lq
)
2322 * il_is_lq_table_valid() - Test one aspect of LQ cmd for validity
2324 * It sometimes happens when a HT rate has been in use and we
2325 * loose connectivity with AP then mac80211 will first tell us that the
2326 * current channel is not HT anymore before removing the station. In such a
2327 * scenario the RXON flags will be updated to indicate we are not
2328 * communicating HT anymore, but the LQ command may still contain HT rates.
2329 * Test for this to prevent driver from sending LQ command between the time
2330 * RXON flags are updated and when LQ command is updated.
2333 il_is_lq_table_valid(struct il_priv
*il
, struct il_link_quality_cmd
*lq
)
2340 D_INFO("Channel %u is not an HT channel\n", il
->active
.channel
);
2341 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++) {
2342 if (le32_to_cpu(lq
->rs_table
[i
].rate_n_flags
) & RATE_MCS_HT_MSK
) {
2343 D_INFO("idx %d of LQ expects HT channel\n", i
);
2351 * il_send_lq_cmd() - Send link quality command
2352 * @init: This command is sent as part of station initialization right
2353 * after station has been added.
2355 * The link quality command is sent as the last step of station creation.
2356 * This is the special case in which init is set and we call a callback in
2357 * this case to clear the state indicating that station creation is in
2361 il_send_lq_cmd(struct il_priv
*il
, struct il_link_quality_cmd
*lq
,
2362 u8 flags
, bool init
)
2365 unsigned long flags_spin
;
2367 struct il_host_cmd cmd
= {
2368 .id
= C_TX_LINK_QUALITY_CMD
,
2369 .len
= sizeof(struct il_link_quality_cmd
),
2374 if (WARN_ON(lq
->sta_id
== IL_INVALID_STATION
))
2377 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2378 if (!(il
->stations
[lq
->sta_id
].used
& IL_STA_DRIVER_ACTIVE
)) {
2379 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2382 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2384 il_dump_lq_cmd(il
, lq
);
2385 BUG_ON(init
&& (cmd
.flags
& CMD_ASYNC
));
2387 if (il_is_lq_table_valid(il
, lq
))
2388 ret
= il_send_cmd(il
, &cmd
);
2392 if (cmd
.flags
& CMD_ASYNC
)
2396 D_INFO("init LQ command complete,"
2397 " clearing sta addition status for sta %d\n",
2399 spin_lock_irqsave(&il
->sta_lock
, flags_spin
);
2400 il
->stations
[lq
->sta_id
].used
&= ~IL_STA_UCODE_INPROGRESS
;
2401 spin_unlock_irqrestore(&il
->sta_lock
, flags_spin
);
2405 EXPORT_SYMBOL(il_send_lq_cmd
);
2408 il_mac_sta_remove(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
2409 struct ieee80211_sta
*sta
)
2411 struct il_priv
*il
= hw
->priv
;
2412 struct il_station_priv_common
*sta_common
= (void *)sta
->drv_priv
;
2415 mutex_lock(&il
->mutex
);
2416 D_MAC80211("enter station %pM\n", sta
->addr
);
2418 ret
= il_remove_station(il
, sta_common
->sta_id
, sta
->addr
);
2420 IL_ERR("Error removing station %pM\n", sta
->addr
);
2422 D_MAC80211("leave ret %d\n", ret
);
2423 mutex_unlock(&il
->mutex
);
2427 EXPORT_SYMBOL(il_mac_sta_remove
);
2429 /************************** RX-FUNCTIONS ****************************/
2431 * Rx theory of operation
2433 * Driver allocates a circular buffer of Receive Buffer Descriptors (RBDs),
2434 * each of which point to Receive Buffers to be filled by the NIC. These get
2435 * used not only for Rx frames, but for any command response or notification
2436 * from the NIC. The driver and NIC manage the Rx buffers by means
2437 * of idxes into the circular buffer.
2440 * The host/firmware share two idx registers for managing the Rx buffers.
2442 * The READ idx maps to the first position that the firmware may be writing
2443 * to -- the driver can read up to (but not including) this position and get
2445 * The READ idx is managed by the firmware once the card is enabled.
2447 * The WRITE idx maps to the last position the driver has read from -- the
2448 * position preceding WRITE is the last slot the firmware can place a packet.
2450 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
2453 * During initialization, the host sets up the READ queue position to the first
2454 * IDX position, and WRITE to the last (READ - 1 wrapped)
2456 * When the firmware places a packet in a buffer, it will advance the READ idx
2457 * and fire the RX interrupt. The driver can then query the READ idx and
2458 * process as many packets as possible, moving the WRITE idx forward as it
2459 * resets the Rx queue buffers with new memory.
2461 * The management in the driver is as follows:
2462 * + A list of pre-allocated SKBs is stored in iwl->rxq->rx_free. When
2463 * iwl->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
2464 * to replenish the iwl->rxq->rx_free.
2465 * + In il_rx_replenish (scheduled) if 'processed' != 'read' then the
2466 * iwl->rxq is replenished and the READ IDX is updated (updating the
2467 * 'processed' and 'read' driver idxes as well)
2468 * + A received packet is processed and handed to the kernel network stack,
2469 * detached from the iwl->rxq. The driver 'processed' idx is updated.
2470 * + The Host/Firmware iwl->rxq is replenished at tasklet time from the rx_free
2471 * list. If there are no allocated buffers in iwl->rxq->rx_free, the READ
2472 * IDX is not incremented and iwl->status(RX_STALLED) is set. If there
2473 * were enough free buffers and RX_STALLED is set it is cleared.
2478 * il_rx_queue_alloc() Allocates rx_free
2479 * il_rx_replenish() Replenishes rx_free list from rx_used, and calls
2480 * il_rx_queue_restock
2481 * il_rx_queue_restock() Moves available buffers from rx_free into Rx
2482 * queue, updates firmware pointers, and updates
2483 * the WRITE idx. If insufficient rx_free buffers
2484 * are available, schedules il_rx_replenish
2486 * -- enable interrupts --
2487 * ISR - il_rx() Detach il_rx_bufs from pool up to the
2488 * READ IDX, detaching the SKB from the pool.
2489 * Moves the packet buffer from queue to rx_used.
2490 * Calls il_rx_queue_restock to refill any empty
2497 * il_rx_queue_space - Return number of free slots available in queue.
2500 il_rx_queue_space(const struct il_rx_queue
*q
)
2502 int s
= q
->read
- q
->write
;
2505 /* keep some buffer to not confuse full and empty queue */
2511 EXPORT_SYMBOL(il_rx_queue_space
);
2514 * il_rx_queue_update_write_ptr - Update the write pointer for the RX queue
2517 il_rx_queue_update_write_ptr(struct il_priv
*il
, struct il_rx_queue
*q
)
2519 unsigned long flags
;
2520 u32 rx_wrt_ptr_reg
= il
->hw_params
.rx_wrt_ptr_reg
;
2523 spin_lock_irqsave(&q
->lock
, flags
);
2525 if (q
->need_update
== 0)
2528 /* If power-saving is in use, make sure device is awake */
2529 if (test_bit(S_POWER_PMI
, &il
->status
)) {
2530 reg
= _il_rd(il
, CSR_UCODE_DRV_GP1
);
2532 if (reg
& CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP
) {
2533 D_INFO("Rx queue requesting wakeup," " GP1 = 0x%x\n",
2535 il_set_bit(il
, CSR_GP_CNTRL
,
2536 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
2540 q
->write_actual
= (q
->write
& ~0x7);
2541 il_wr(il
, rx_wrt_ptr_reg
, q
->write_actual
);
2543 /* Else device is assumed to be awake */
2545 /* Device expects a multiple of 8 */
2546 q
->write_actual
= (q
->write
& ~0x7);
2547 il_wr(il
, rx_wrt_ptr_reg
, q
->write_actual
);
2553 spin_unlock_irqrestore(&q
->lock
, flags
);
2555 EXPORT_SYMBOL(il_rx_queue_update_write_ptr
);
2558 il_rx_queue_alloc(struct il_priv
*il
)
2560 struct il_rx_queue
*rxq
= &il
->rxq
;
2561 struct device
*dev
= &il
->pci_dev
->dev
;
2564 spin_lock_init(&rxq
->lock
);
2565 INIT_LIST_HEAD(&rxq
->rx_free
);
2566 INIT_LIST_HEAD(&rxq
->rx_used
);
2568 /* Alloc the circular buffer of Read Buffer Descriptors (RBDs) */
2570 dma_alloc_coherent(dev
, 4 * RX_QUEUE_SIZE
, &rxq
->bd_dma
,
2576 dma_alloc_coherent(dev
, sizeof(struct il_rb_status
),
2577 &rxq
->rb_stts_dma
, GFP_KERNEL
);
2581 /* Fill the rx_used queue with _all_ of the Rx buffers */
2582 for (i
= 0; i
< RX_FREE_BUFFERS
+ RX_QUEUE_SIZE
; i
++)
2583 list_add_tail(&rxq
->pool
[i
].list
, &rxq
->rx_used
);
2585 /* Set us so that we have processed and used all buffers, but have
2586 * not restocked the Rx queue with fresh buffers */
2587 rxq
->read
= rxq
->write
= 0;
2588 rxq
->write_actual
= 0;
2589 rxq
->free_count
= 0;
2590 rxq
->need_update
= 0;
2594 dma_free_coherent(&il
->pci_dev
->dev
, 4 * RX_QUEUE_SIZE
, rxq
->bd
,
2599 EXPORT_SYMBOL(il_rx_queue_alloc
);
2602 il_hdl_spectrum_measurement(struct il_priv
*il
, struct il_rx_buf
*rxb
)
2604 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
2605 struct il_spectrum_notification
*report
= &(pkt
->u
.spectrum_notif
);
2607 if (!report
->state
) {
2608 D_11H("Spectrum Measure Notification: Start\n");
2612 memcpy(&il
->measure_report
, report
, sizeof(*report
));
2613 il
->measurement_status
|= MEASUREMENT_READY
;
2615 EXPORT_SYMBOL(il_hdl_spectrum_measurement
);
2618 * returns non-zero if packet should be dropped
2621 il_set_decrypted_flag(struct il_priv
*il
, struct ieee80211_hdr
*hdr
,
2622 u32 decrypt_res
, struct ieee80211_rx_status
*stats
)
2624 u16 fc
= le16_to_cpu(hdr
->frame_control
);
2627 * All contexts have the same setting here due to it being
2628 * a module parameter, so OK to check any context.
2630 if (il
->active
.filter_flags
& RXON_FILTER_DIS_DECRYPT_MSK
)
2633 if (!(fc
& IEEE80211_FCTL_PROTECTED
))
2636 D_RX("decrypt_res:0x%x\n", decrypt_res
);
2637 switch (decrypt_res
& RX_RES_STATUS_SEC_TYPE_MSK
) {
2638 case RX_RES_STATUS_SEC_TYPE_TKIP
:
2639 /* The uCode has got a bad phase 1 Key, pushes the packet.
2640 * Decryption will be done in SW. */
2641 if ((decrypt_res
& RX_RES_STATUS_DECRYPT_TYPE_MSK
) ==
2642 RX_RES_STATUS_BAD_KEY_TTAK
)
2645 case RX_RES_STATUS_SEC_TYPE_WEP
:
2646 if ((decrypt_res
& RX_RES_STATUS_DECRYPT_TYPE_MSK
) ==
2647 RX_RES_STATUS_BAD_ICV_MIC
) {
2648 /* bad ICV, the packet is destroyed since the
2649 * decryption is inplace, drop it */
2650 D_RX("Packet destroyed\n");
2653 case RX_RES_STATUS_SEC_TYPE_CCMP
:
2654 if ((decrypt_res
& RX_RES_STATUS_DECRYPT_TYPE_MSK
) ==
2655 RX_RES_STATUS_DECRYPT_OK
) {
2656 D_RX("hw decrypt successfully!!!\n");
2657 stats
->flag
|= RX_FLAG_DECRYPTED
;
2666 EXPORT_SYMBOL(il_set_decrypted_flag
);
2669 * il_txq_update_write_ptr - Send new write idx to hardware
2672 il_txq_update_write_ptr(struct il_priv
*il
, struct il_tx_queue
*txq
)
2675 int txq_id
= txq
->q
.id
;
2677 if (txq
->need_update
== 0)
2680 /* if we're trying to save power */
2681 if (test_bit(S_POWER_PMI
, &il
->status
)) {
2682 /* wake up nic if it's powered down ...
2683 * uCode will wake up, and interrupt us again, so next
2684 * time we'll skip this part. */
2685 reg
= _il_rd(il
, CSR_UCODE_DRV_GP1
);
2687 if (reg
& CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP
) {
2688 D_INFO("Tx queue %d requesting wakeup," " GP1 = 0x%x\n",
2690 il_set_bit(il
, CSR_GP_CNTRL
,
2691 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
2695 il_wr(il
, HBUS_TARG_WRPTR
, txq
->q
.write_ptr
| (txq_id
<< 8));
2698 * else not in power-save mode,
2699 * uCode will never sleep when we're
2700 * trying to tx (during RFKILL, we're not trying to tx).
2703 _il_wr(il
, HBUS_TARG_WRPTR
, txq
->q
.write_ptr
| (txq_id
<< 8));
2704 txq
->need_update
= 0;
2706 EXPORT_SYMBOL(il_txq_update_write_ptr
);
2709 * il_tx_queue_unmap - Unmap any remaining DMA mappings and free skb's
2712 il_tx_queue_unmap(struct il_priv
*il
, int txq_id
)
2714 struct il_tx_queue
*txq
= &il
->txq
[txq_id
];
2715 struct il_queue
*q
= &txq
->q
;
2720 while (q
->write_ptr
!= q
->read_ptr
) {
2721 il
->ops
->txq_free_tfd(il
, txq
);
2722 q
->read_ptr
= il_queue_inc_wrap(q
->read_ptr
, q
->n_bd
);
2725 EXPORT_SYMBOL(il_tx_queue_unmap
);
2728 * il_tx_queue_free - Deallocate DMA queue.
2729 * @txq: Transmit queue to deallocate.
2731 * Empty queue by removing and destroying all BD's.
2733 * 0-fill, but do not free "txq" descriptor structure.
2736 il_tx_queue_free(struct il_priv
*il
, int txq_id
)
2738 struct il_tx_queue
*txq
= &il
->txq
[txq_id
];
2739 struct device
*dev
= &il
->pci_dev
->dev
;
2742 il_tx_queue_unmap(il
, txq_id
);
2744 /* De-alloc array of command/tx buffers */
2745 for (i
= 0; i
< TFD_TX_CMD_SLOTS
; i
++)
2748 /* De-alloc circular buffer of TFDs */
2750 dma_free_coherent(dev
, il
->hw_params
.tfd_size
* txq
->q
.n_bd
,
2751 txq
->tfds
, txq
->q
.dma_addr
);
2753 /* De-alloc array of per-TFD driver data */
2757 /* deallocate arrays */
2763 /* 0-fill queue descriptor structure */
2764 memset(txq
, 0, sizeof(*txq
));
2766 EXPORT_SYMBOL(il_tx_queue_free
);
2769 * il_cmd_queue_unmap - Unmap any remaining DMA mappings from command queue
2772 il_cmd_queue_unmap(struct il_priv
*il
)
2774 struct il_tx_queue
*txq
= &il
->txq
[il
->cmd_queue
];
2775 struct il_queue
*q
= &txq
->q
;
2781 while (q
->read_ptr
!= q
->write_ptr
) {
2782 i
= il_get_cmd_idx(q
, q
->read_ptr
, 0);
2784 if (txq
->meta
[i
].flags
& CMD_MAPPED
) {
2785 pci_unmap_single(il
->pci_dev
,
2786 dma_unmap_addr(&txq
->meta
[i
], mapping
),
2787 dma_unmap_len(&txq
->meta
[i
], len
),
2788 PCI_DMA_BIDIRECTIONAL
);
2789 txq
->meta
[i
].flags
= 0;
2792 q
->read_ptr
= il_queue_inc_wrap(q
->read_ptr
, q
->n_bd
);
2796 if (txq
->meta
[i
].flags
& CMD_MAPPED
) {
2797 pci_unmap_single(il
->pci_dev
,
2798 dma_unmap_addr(&txq
->meta
[i
], mapping
),
2799 dma_unmap_len(&txq
->meta
[i
], len
),
2800 PCI_DMA_BIDIRECTIONAL
);
2801 txq
->meta
[i
].flags
= 0;
2804 EXPORT_SYMBOL(il_cmd_queue_unmap
);
2807 * il_cmd_queue_free - Deallocate DMA queue.
2808 * @txq: Transmit queue to deallocate.
2810 * Empty queue by removing and destroying all BD's.
2812 * 0-fill, but do not free "txq" descriptor structure.
2815 il_cmd_queue_free(struct il_priv
*il
)
2817 struct il_tx_queue
*txq
= &il
->txq
[il
->cmd_queue
];
2818 struct device
*dev
= &il
->pci_dev
->dev
;
2821 il_cmd_queue_unmap(il
);
2823 /* De-alloc array of command/tx buffers */
2824 for (i
= 0; i
<= TFD_CMD_SLOTS
; i
++)
2827 /* De-alloc circular buffer of TFDs */
2829 dma_free_coherent(dev
, il
->hw_params
.tfd_size
* txq
->q
.n_bd
,
2830 txq
->tfds
, txq
->q
.dma_addr
);
2832 /* deallocate arrays */
2838 /* 0-fill queue descriptor structure */
2839 memset(txq
, 0, sizeof(*txq
));
2841 EXPORT_SYMBOL(il_cmd_queue_free
);
2843 /*************** DMA-QUEUE-GENERAL-FUNCTIONS *****
2846 * Theory of operation
2848 * A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
2849 * of buffer descriptors, each of which points to one or more data buffers for
2850 * the device to read from or fill. Driver and device exchange status of each
2851 * queue via "read" and "write" pointers. Driver keeps minimum of 2 empty
2852 * entries in each circular buffer, to protect against confusing empty and full
2855 * The device reads or writes the data in the queues via the device's several
2856 * DMA/FIFO channels. Each queue is mapped to a single DMA channel.
2858 * For Tx queue, there are low mark and high mark limits. If, after queuing
2859 * the packet for Tx, free space become < low mark, Tx queue stopped. When
2860 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
2863 * See more detailed info in 4965.h.
2864 ***************************************************/
2867 il_queue_space(const struct il_queue
*q
)
2869 int s
= q
->read_ptr
- q
->write_ptr
;
2871 if (q
->read_ptr
> q
->write_ptr
)
2876 /* keep some reserve to not confuse empty and full situations */
2882 EXPORT_SYMBOL(il_queue_space
);
2886 * il_queue_init - Initialize queue's high/low-water and read/write idxes
2889 il_queue_init(struct il_priv
*il
, struct il_queue
*q
, int slots
, u32 id
)
2892 * TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
2893 * il_queue_inc_wrap and il_queue_dec_wrap are broken.
2895 BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX
& (TFD_QUEUE_SIZE_MAX
- 1));
2896 /* FIXME: remove q->n_bd */
2897 q
->n_bd
= TFD_QUEUE_SIZE_MAX
;
2902 /* slots_must be power-of-two size, otherwise
2903 * il_get_cmd_idx is broken. */
2904 BUG_ON(!is_power_of_2(slots
));
2906 q
->low_mark
= q
->n_win
/ 4;
2907 if (q
->low_mark
< 4)
2910 q
->high_mark
= q
->n_win
/ 8;
2911 if (q
->high_mark
< 2)
2914 q
->write_ptr
= q
->read_ptr
= 0;
2920 * il_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
2923 il_tx_queue_alloc(struct il_priv
*il
, struct il_tx_queue
*txq
, u32 id
)
2925 struct device
*dev
= &il
->pci_dev
->dev
;
2926 size_t tfd_sz
= il
->hw_params
.tfd_size
* TFD_QUEUE_SIZE_MAX
;
2928 /* Driver ilate data, only for Tx (not command) queues,
2929 * not shared with device. */
2930 if (id
!= il
->cmd_queue
) {
2931 txq
->skbs
= kcalloc(TFD_QUEUE_SIZE_MAX
, sizeof(struct skb
*),
2934 IL_ERR("Fail to alloc skbs\n");
2940 /* Circular buffer of transmit frame descriptors (TFDs),
2941 * shared with device */
2943 dma_alloc_coherent(dev
, tfd_sz
, &txq
->q
.dma_addr
, GFP_KERNEL
);
2945 IL_ERR("Fail to alloc TFDs\n");
2960 * il_tx_queue_init - Allocate and initialize one tx/cmd queue
2963 il_tx_queue_init(struct il_priv
*il
, u32 txq_id
)
2966 int slots
, actual_slots
;
2967 struct il_tx_queue
*txq
= &il
->txq
[txq_id
];
2970 * Alloc buffer array for commands (Tx or other types of commands).
2971 * For the command queue (#4/#9), allocate command space + one big
2972 * command for scan, since scan command is very huge; the system will
2973 * not have two scans at the same time, so only one is needed.
2974 * For normal Tx queues (all other queues), no super-size command
2977 if (txq_id
== il
->cmd_queue
) {
2978 slots
= TFD_CMD_SLOTS
;
2979 actual_slots
= slots
+ 1;
2981 slots
= TFD_TX_CMD_SLOTS
;
2982 actual_slots
= slots
;
2986 kzalloc(sizeof(struct il_cmd_meta
) * actual_slots
, GFP_KERNEL
);
2988 kzalloc(sizeof(struct il_device_cmd
*) * actual_slots
, GFP_KERNEL
);
2990 if (!txq
->meta
|| !txq
->cmd
)
2991 goto out_free_arrays
;
2993 len
= sizeof(struct il_device_cmd
);
2994 for (i
= 0; i
< actual_slots
; i
++) {
2995 /* only happens for cmd queue */
2997 len
= IL_MAX_CMD_SIZE
;
2999 txq
->cmd
[i
] = kmalloc(len
, GFP_KERNEL
);
3004 /* Alloc driver data array and TFD circular buffer */
3005 ret
= il_tx_queue_alloc(il
, txq
, txq_id
);
3009 txq
->need_update
= 0;
3012 * For the default queues 0-3, set up the swq_id
3013 * already -- all others need to get one later
3014 * (if they need one at all).
3017 il_set_swq_id(txq
, txq_id
, txq_id
);
3019 /* Initialize queue's high/low-water marks, and head/tail idxes */
3020 il_queue_init(il
, &txq
->q
, slots
, txq_id
);
3022 /* Tell device where to find queue */
3023 il
->ops
->txq_init(il
, txq
);
3027 for (i
= 0; i
< actual_slots
; i
++)
3035 EXPORT_SYMBOL(il_tx_queue_init
);
3038 il_tx_queue_reset(struct il_priv
*il
, u32 txq_id
)
3040 int slots
, actual_slots
;
3041 struct il_tx_queue
*txq
= &il
->txq
[txq_id
];
3043 if (txq_id
== il
->cmd_queue
) {
3044 slots
= TFD_CMD_SLOTS
;
3045 actual_slots
= TFD_CMD_SLOTS
+ 1;
3047 slots
= TFD_TX_CMD_SLOTS
;
3048 actual_slots
= TFD_TX_CMD_SLOTS
;
3051 memset(txq
->meta
, 0, sizeof(struct il_cmd_meta
) * actual_slots
);
3052 txq
->need_update
= 0;
3054 /* Initialize queue's high/low-water marks, and head/tail idxes */
3055 il_queue_init(il
, &txq
->q
, slots
, txq_id
);
3057 /* Tell device where to find queue */
3058 il
->ops
->txq_init(il
, txq
);
3060 EXPORT_SYMBOL(il_tx_queue_reset
);
3062 /*************** HOST COMMAND QUEUE FUNCTIONS *****/
3065 * il_enqueue_hcmd - enqueue a uCode command
3066 * @il: device ilate data point
3067 * @cmd: a point to the ucode command structure
3069 * The function returns < 0 values to indicate the operation is
3070 * failed. On success, it turns the idx (> 0) of command in the
3074 il_enqueue_hcmd(struct il_priv
*il
, struct il_host_cmd
*cmd
)
3076 struct il_tx_queue
*txq
= &il
->txq
[il
->cmd_queue
];
3077 struct il_queue
*q
= &txq
->q
;
3078 struct il_device_cmd
*out_cmd
;
3079 struct il_cmd_meta
*out_meta
;
3080 dma_addr_t phys_addr
;
3081 unsigned long flags
;
3086 cmd
->len
= il
->ops
->get_hcmd_size(cmd
->id
, cmd
->len
);
3087 fix_size
= (u16
) (cmd
->len
+ sizeof(out_cmd
->hdr
));
3089 /* If any of the command structures end up being larger than
3090 * the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
3091 * we will need to increase the size of the TFD entries
3092 * Also, check to see if command buffer should not exceed the size
3093 * of device_cmd and max_cmd_size. */
3094 BUG_ON((fix_size
> TFD_MAX_PAYLOAD_SIZE
) &&
3095 !(cmd
->flags
& CMD_SIZE_HUGE
));
3096 BUG_ON(fix_size
> IL_MAX_CMD_SIZE
);
3098 if (il_is_rfkill(il
) || il_is_ctkill(il
)) {
3099 IL_WARN("Not sending command - %s KILL\n",
3100 il_is_rfkill(il
) ? "RF" : "CT");
3104 spin_lock_irqsave(&il
->hcmd_lock
, flags
);
3106 if (il_queue_space(q
) < ((cmd
->flags
& CMD_ASYNC
) ? 2 : 1)) {
3107 spin_unlock_irqrestore(&il
->hcmd_lock
, flags
);
3109 IL_ERR("Restarting adapter due to command queue full\n");
3110 queue_work(il
->workqueue
, &il
->restart
);
3114 idx
= il_get_cmd_idx(q
, q
->write_ptr
, cmd
->flags
& CMD_SIZE_HUGE
);
3115 out_cmd
= txq
->cmd
[idx
];
3116 out_meta
= &txq
->meta
[idx
];
3118 if (WARN_ON(out_meta
->flags
& CMD_MAPPED
)) {
3119 spin_unlock_irqrestore(&il
->hcmd_lock
, flags
);
3123 memset(out_meta
, 0, sizeof(*out_meta
)); /* re-initialize to NULL */
3124 out_meta
->flags
= cmd
->flags
| CMD_MAPPED
;
3125 if (cmd
->flags
& CMD_WANT_SKB
)
3126 out_meta
->source
= cmd
;
3127 if (cmd
->flags
& CMD_ASYNC
)
3128 out_meta
->callback
= cmd
->callback
;
3130 out_cmd
->hdr
.cmd
= cmd
->id
;
3131 memcpy(&out_cmd
->cmd
.payload
, cmd
->data
, cmd
->len
);
3133 /* At this point, the out_cmd now has all of the incoming cmd
3136 out_cmd
->hdr
.flags
= 0;
3137 out_cmd
->hdr
.sequence
=
3138 cpu_to_le16(QUEUE_TO_SEQ(il
->cmd_queue
) | IDX_TO_SEQ(q
->write_ptr
));
3139 if (cmd
->flags
& CMD_SIZE_HUGE
)
3140 out_cmd
->hdr
.sequence
|= SEQ_HUGE_FRAME
;
3141 len
= sizeof(struct il_device_cmd
);
3142 if (idx
== TFD_CMD_SLOTS
)
3143 len
= IL_MAX_CMD_SIZE
;
3145 #ifdef CONFIG_IWLEGACY_DEBUG
3146 switch (out_cmd
->hdr
.cmd
) {
3147 case C_TX_LINK_QUALITY_CMD
:
3149 D_HC_DUMP("Sending command %s (#%x), seq: 0x%04X, "
3150 "%d bytes at %d[%d]:%d\n",
3151 il_get_cmd_string(out_cmd
->hdr
.cmd
), out_cmd
->hdr
.cmd
,
3152 le16_to_cpu(out_cmd
->hdr
.sequence
), fix_size
,
3153 q
->write_ptr
, idx
, il
->cmd_queue
);
3156 D_HC("Sending command %s (#%x), seq: 0x%04X, "
3157 "%d bytes at %d[%d]:%d\n",
3158 il_get_cmd_string(out_cmd
->hdr
.cmd
), out_cmd
->hdr
.cmd
,
3159 le16_to_cpu(out_cmd
->hdr
.sequence
), fix_size
, q
->write_ptr
,
3160 idx
, il
->cmd_queue
);
3165 pci_map_single(il
->pci_dev
, &out_cmd
->hdr
, fix_size
,
3166 PCI_DMA_BIDIRECTIONAL
);
3167 if (unlikely(pci_dma_mapping_error(il
->pci_dev
, phys_addr
))) {
3171 dma_unmap_addr_set(out_meta
, mapping
, phys_addr
);
3172 dma_unmap_len_set(out_meta
, len
, fix_size
);
3174 txq
->need_update
= 1;
3176 if (il
->ops
->txq_update_byte_cnt_tbl
)
3177 /* Set up entry in queue's byte count circular buffer */
3178 il
->ops
->txq_update_byte_cnt_tbl(il
, txq
, 0);
3180 il
->ops
->txq_attach_buf_to_tfd(il
, txq
, phys_addr
, fix_size
, 1,
3183 /* Increment and update queue's write idx */
3184 q
->write_ptr
= il_queue_inc_wrap(q
->write_ptr
, q
->n_bd
);
3185 il_txq_update_write_ptr(il
, txq
);
3188 spin_unlock_irqrestore(&il
->hcmd_lock
, flags
);
3193 * il_hcmd_queue_reclaim - Reclaim TX command queue entries already Tx'd
3195 * When FW advances 'R' idx, all entries between old and new 'R' idx
3196 * need to be reclaimed. As result, some free space forms. If there is
3197 * enough free space (> low mark), wake the stack that feeds us.
3200 il_hcmd_queue_reclaim(struct il_priv
*il
, int txq_id
, int idx
, int cmd_idx
)
3202 struct il_tx_queue
*txq
= &il
->txq
[txq_id
];
3203 struct il_queue
*q
= &txq
->q
;
3206 if (idx
>= q
->n_bd
|| il_queue_used(q
, idx
) == 0) {
3207 IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
3208 "is out of range [0-%d] %d %d.\n", txq_id
, idx
, q
->n_bd
,
3209 q
->write_ptr
, q
->read_ptr
);
3213 for (idx
= il_queue_inc_wrap(idx
, q
->n_bd
); q
->read_ptr
!= idx
;
3214 q
->read_ptr
= il_queue_inc_wrap(q
->read_ptr
, q
->n_bd
)) {
3217 IL_ERR("HCMD skipped: idx (%d) %d %d\n", idx
,
3218 q
->write_ptr
, q
->read_ptr
);
3219 queue_work(il
->workqueue
, &il
->restart
);
3226 * il_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
3227 * @rxb: Rx buffer to reclaim
3229 * If an Rx buffer has an async callback associated with it the callback
3230 * will be executed. The attached skb (if present) will only be freed
3231 * if the callback returns 1
3234 il_tx_cmd_complete(struct il_priv
*il
, struct il_rx_buf
*rxb
)
3236 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
3237 u16 sequence
= le16_to_cpu(pkt
->hdr
.sequence
);
3238 int txq_id
= SEQ_TO_QUEUE(sequence
);
3239 int idx
= SEQ_TO_IDX(sequence
);
3241 bool huge
= !!(pkt
->hdr
.sequence
& SEQ_HUGE_FRAME
);
3242 struct il_device_cmd
*cmd
;
3243 struct il_cmd_meta
*meta
;
3244 struct il_tx_queue
*txq
= &il
->txq
[il
->cmd_queue
];
3245 unsigned long flags
;
3247 /* If a Tx command is being handled and it isn't in the actual
3248 * command queue then there a command routing bug has been introduced
3249 * in the queue management code. */
3251 (txq_id
!= il
->cmd_queue
,
3252 "wrong command queue %d (should be %d), sequence 0x%X readp=%d writep=%d\n",
3253 txq_id
, il
->cmd_queue
, sequence
, il
->txq
[il
->cmd_queue
].q
.read_ptr
,
3254 il
->txq
[il
->cmd_queue
].q
.write_ptr
)) {
3255 il_print_hex_error(il
, pkt
, 32);
3259 cmd_idx
= il_get_cmd_idx(&txq
->q
, idx
, huge
);
3260 cmd
= txq
->cmd
[cmd_idx
];
3261 meta
= &txq
->meta
[cmd_idx
];
3263 txq
->time_stamp
= jiffies
;
3265 pci_unmap_single(il
->pci_dev
, dma_unmap_addr(meta
, mapping
),
3266 dma_unmap_len(meta
, len
), PCI_DMA_BIDIRECTIONAL
);
3268 /* Input error checking is done when commands are added to queue. */
3269 if (meta
->flags
& CMD_WANT_SKB
) {
3270 meta
->source
->reply_page
= (unsigned long)rxb_addr(rxb
);
3272 } else if (meta
->callback
)
3273 meta
->callback(il
, cmd
, pkt
);
3275 spin_lock_irqsave(&il
->hcmd_lock
, flags
);
3277 il_hcmd_queue_reclaim(il
, txq_id
, idx
, cmd_idx
);
3279 if (!(meta
->flags
& CMD_ASYNC
)) {
3280 clear_bit(S_HCMD_ACTIVE
, &il
->status
);
3281 D_INFO("Clearing HCMD_ACTIVE for command %s\n",
3282 il_get_cmd_string(cmd
->hdr
.cmd
));
3283 wake_up(&il
->wait_command_queue
);
3286 /* Mark as unmapped */
3289 spin_unlock_irqrestore(&il
->hcmd_lock
, flags
);
3291 EXPORT_SYMBOL(il_tx_cmd_complete
);
3293 MODULE_DESCRIPTION("iwl-legacy: common functions for 3945 and 4965");
3294 MODULE_VERSION(IWLWIFI_VERSION
);
3295 MODULE_AUTHOR(DRV_COPYRIGHT
" " DRV_AUTHOR
);
3296 MODULE_LICENSE("GPL");
3299 * set bt_coex_active to true, uCode will do kill/defer
3300 * every time the priority line is asserted (BT is sending signals on the
3301 * priority line in the PCIx).
3302 * set bt_coex_active to false, uCode will ignore the BT activity and
3303 * perform the normal operation
3305 * User might experience transmit issue on some platform due to WiFi/BT
3306 * co-exist problem. The possible behaviors are:
3307 * Able to scan and finding all the available AP
3308 * Not able to associate with any AP
3309 * On those platforms, WiFi communication can be restored by set
3310 * "bt_coex_active" module parameter to "false"
3312 * default: bt_coex_active = true (BT_COEX_ENABLE)
3314 static bool bt_coex_active
= true;
3315 module_param(bt_coex_active
, bool, S_IRUGO
);
3316 MODULE_PARM_DESC(bt_coex_active
, "enable wifi/bluetooth co-exist");
3319 EXPORT_SYMBOL(il_debug_level
);
3321 const u8 il_bcast_addr
[ETH_ALEN
] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
3322 EXPORT_SYMBOL(il_bcast_addr
);
3324 #define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
3325 #define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
3327 il_init_ht_hw_capab(const struct il_priv
*il
,
3328 struct ieee80211_sta_ht_cap
*ht_info
,
3329 enum ieee80211_band band
)
3331 u16 max_bit_rate
= 0;
3332 u8 rx_chains_num
= il
->hw_params
.rx_chains_num
;
3333 u8 tx_chains_num
= il
->hw_params
.tx_chains_num
;
3336 memset(&ht_info
->mcs
, 0, sizeof(ht_info
->mcs
));
3338 ht_info
->ht_supported
= true;
3340 ht_info
->cap
|= IEEE80211_HT_CAP_SGI_20
;
3341 max_bit_rate
= MAX_BIT_RATE_20_MHZ
;
3342 if (il
->hw_params
.ht40_channel
& BIT(band
)) {
3343 ht_info
->cap
|= IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
3344 ht_info
->cap
|= IEEE80211_HT_CAP_SGI_40
;
3345 ht_info
->mcs
.rx_mask
[4] = 0x01;
3346 max_bit_rate
= MAX_BIT_RATE_40_MHZ
;
3349 if (il
->cfg
->mod_params
->amsdu_size_8K
)
3350 ht_info
->cap
|= IEEE80211_HT_CAP_MAX_AMSDU
;
3352 ht_info
->ampdu_factor
= CFG_HT_RX_AMPDU_FACTOR_DEF
;
3353 ht_info
->ampdu_density
= CFG_HT_MPDU_DENSITY_DEF
;
3355 ht_info
->mcs
.rx_mask
[0] = 0xFF;
3356 if (rx_chains_num
>= 2)
3357 ht_info
->mcs
.rx_mask
[1] = 0xFF;
3358 if (rx_chains_num
>= 3)
3359 ht_info
->mcs
.rx_mask
[2] = 0xFF;
3361 /* Highest supported Rx data rate */
3362 max_bit_rate
*= rx_chains_num
;
3363 WARN_ON(max_bit_rate
& ~IEEE80211_HT_MCS_RX_HIGHEST_MASK
);
3364 ht_info
->mcs
.rx_highest
= cpu_to_le16(max_bit_rate
);
3366 /* Tx MCS capabilities */
3367 ht_info
->mcs
.tx_params
= IEEE80211_HT_MCS_TX_DEFINED
;
3368 if (tx_chains_num
!= rx_chains_num
) {
3369 ht_info
->mcs
.tx_params
|= IEEE80211_HT_MCS_TX_RX_DIFF
;
3370 ht_info
->mcs
.tx_params
|=
3372 1) << IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT
);
3377 * il_init_geos - Initialize mac80211's geo/channel info based from eeprom
3380 il_init_geos(struct il_priv
*il
)
3382 struct il_channel_info
*ch
;
3383 struct ieee80211_supported_band
*sband
;
3384 struct ieee80211_channel
*channels
;
3385 struct ieee80211_channel
*geo_ch
;
3386 struct ieee80211_rate
*rates
;
3388 s8 max_tx_power
= 0;
3390 if (il
->bands
[IEEE80211_BAND_2GHZ
].n_bitrates
||
3391 il
->bands
[IEEE80211_BAND_5GHZ
].n_bitrates
) {
3392 D_INFO("Geography modes already initialized.\n");
3393 set_bit(S_GEO_CONFIGURED
, &il
->status
);
3398 kzalloc(sizeof(struct ieee80211_channel
) * il
->channel_count
,
3404 kzalloc((sizeof(struct ieee80211_rate
) * RATE_COUNT_LEGACY
),
3411 /* 5.2GHz channels start after the 2.4GHz channels */
3412 sband
= &il
->bands
[IEEE80211_BAND_5GHZ
];
3413 sband
->channels
= &channels
[ARRAY_SIZE(il_eeprom_band_1
)];
3415 sband
->bitrates
= &rates
[IL_FIRST_OFDM_RATE
];
3416 sband
->n_bitrates
= RATE_COUNT_LEGACY
- IL_FIRST_OFDM_RATE
;
3418 if (il
->cfg
->sku
& IL_SKU_N
)
3419 il_init_ht_hw_capab(il
, &sband
->ht_cap
, IEEE80211_BAND_5GHZ
);
3421 sband
= &il
->bands
[IEEE80211_BAND_2GHZ
];
3422 sband
->channels
= channels
;
3424 sband
->bitrates
= rates
;
3425 sband
->n_bitrates
= RATE_COUNT_LEGACY
;
3427 if (il
->cfg
->sku
& IL_SKU_N
)
3428 il_init_ht_hw_capab(il
, &sband
->ht_cap
, IEEE80211_BAND_2GHZ
);
3430 il
->ieee_channels
= channels
;
3431 il
->ieee_rates
= rates
;
3433 for (i
= 0; i
< il
->channel_count
; i
++) {
3434 ch
= &il
->channel_info
[i
];
3436 if (!il_is_channel_valid(ch
))
3439 sband
= &il
->bands
[ch
->band
];
3441 geo_ch
= &sband
->channels
[sband
->n_channels
++];
3443 geo_ch
->center_freq
=
3444 ieee80211_channel_to_frequency(ch
->channel
, ch
->band
);
3445 geo_ch
->max_power
= ch
->max_power_avg
;
3446 geo_ch
->max_antenna_gain
= 0xff;
3447 geo_ch
->hw_value
= ch
->channel
;
3449 if (il_is_channel_valid(ch
)) {
3450 if (!(ch
->flags
& EEPROM_CHANNEL_IBSS
))
3451 geo_ch
->flags
|= IEEE80211_CHAN_NO_IBSS
;
3453 if (!(ch
->flags
& EEPROM_CHANNEL_ACTIVE
))
3454 geo_ch
->flags
|= IEEE80211_CHAN_PASSIVE_SCAN
;
3456 if (ch
->flags
& EEPROM_CHANNEL_RADAR
)
3457 geo_ch
->flags
|= IEEE80211_CHAN_RADAR
;
3459 geo_ch
->flags
|= ch
->ht40_extension_channel
;
3461 if (ch
->max_power_avg
> max_tx_power
)
3462 max_tx_power
= ch
->max_power_avg
;
3464 geo_ch
->flags
|= IEEE80211_CHAN_DISABLED
;
3467 D_INFO("Channel %d Freq=%d[%sGHz] %s flag=0x%X\n", ch
->channel
,
3468 geo_ch
->center_freq
,
3469 il_is_channel_a_band(ch
) ? "5.2" : "2.4",
3471 flags
& IEEE80211_CHAN_DISABLED
? "restricted" : "valid",
3475 il
->tx_power_device_lmt
= max_tx_power
;
3476 il
->tx_power_user_lmt
= max_tx_power
;
3477 il
->tx_power_next
= max_tx_power
;
3479 if (il
->bands
[IEEE80211_BAND_5GHZ
].n_channels
== 0 &&
3480 (il
->cfg
->sku
& IL_SKU_A
)) {
3481 IL_INFO("Incorrectly detected BG card as ABG. "
3482 "Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
3483 il
->pci_dev
->device
, il
->pci_dev
->subsystem_device
);
3484 il
->cfg
->sku
&= ~IL_SKU_A
;
3487 IL_INFO("Tunable channels: %d 802.11bg, %d 802.11a channels\n",
3488 il
->bands
[IEEE80211_BAND_2GHZ
].n_channels
,
3489 il
->bands
[IEEE80211_BAND_5GHZ
].n_channels
);
3491 set_bit(S_GEO_CONFIGURED
, &il
->status
);
3495 EXPORT_SYMBOL(il_init_geos
);
3498 * il_free_geos - undo allocations in il_init_geos
3501 il_free_geos(struct il_priv
*il
)
3503 kfree(il
->ieee_channels
);
3504 kfree(il
->ieee_rates
);
3505 clear_bit(S_GEO_CONFIGURED
, &il
->status
);
3507 EXPORT_SYMBOL(il_free_geos
);
3510 il_is_channel_extension(struct il_priv
*il
, enum ieee80211_band band
,
3511 u16 channel
, u8 extension_chan_offset
)
3513 const struct il_channel_info
*ch_info
;
3515 ch_info
= il_get_channel_info(il
, band
, channel
);
3516 if (!il_is_channel_valid(ch_info
))
3519 if (extension_chan_offset
== IEEE80211_HT_PARAM_CHA_SEC_ABOVE
)
3521 ht40_extension_channel
& IEEE80211_CHAN_NO_HT40PLUS
);
3522 else if (extension_chan_offset
== IEEE80211_HT_PARAM_CHA_SEC_BELOW
)
3524 ht40_extension_channel
& IEEE80211_CHAN_NO_HT40MINUS
);
3530 il_is_ht40_tx_allowed(struct il_priv
*il
, struct ieee80211_sta_ht_cap
*ht_cap
)
3532 if (!il
->ht
.enabled
|| !il
->ht
.is_40mhz
)
3536 * We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40
3537 * the bit will not set if it is pure 40MHz case
3539 if (ht_cap
&& !ht_cap
->ht_supported
)
3542 #ifdef CONFIG_IWLEGACY_DEBUGFS
3543 if (il
->disable_ht40
)
3547 return il_is_channel_extension(il
, il
->band
,
3548 le16_to_cpu(il
->staging
.channel
),
3549 il
->ht
.extension_chan_offset
);
3551 EXPORT_SYMBOL(il_is_ht40_tx_allowed
);
3554 il_adjust_beacon_interval(u16 beacon_val
, u16 max_beacon_val
)
3560 * If mac80211 hasn't given us a beacon interval, program
3561 * the default into the device.
3564 return DEFAULT_BEACON_INTERVAL
;
3567 * If the beacon interval we obtained from the peer
3568 * is too large, we'll have to wake up more often
3569 * (and in IBSS case, we'll beacon too much)
3571 * For example, if max_beacon_val is 4096, and the
3572 * requested beacon interval is 7000, we'll have to
3573 * use 3500 to be able to wake up on the beacons.
3575 * This could badly influence beacon detection stats.
3578 beacon_factor
= (beacon_val
+ max_beacon_val
) / max_beacon_val
;
3579 new_val
= beacon_val
/ beacon_factor
;
3582 new_val
= max_beacon_val
;
3588 il_send_rxon_timing(struct il_priv
*il
)
3591 s32 interval_tm
, rem
;
3592 struct ieee80211_conf
*conf
= NULL
;
3594 struct ieee80211_vif
*vif
= il
->vif
;
3596 conf
= &il
->hw
->conf
;
3598 lockdep_assert_held(&il
->mutex
);
3600 memset(&il
->timing
, 0, sizeof(struct il_rxon_time_cmd
));
3602 il
->timing
.timestamp
= cpu_to_le64(il
->timestamp
);
3603 il
->timing
.listen_interval
= cpu_to_le16(conf
->listen_interval
);
3605 beacon_int
= vif
? vif
->bss_conf
.beacon_int
: 0;
3608 * TODO: For IBSS we need to get atim_win from mac80211,
3609 * for now just always use 0
3611 il
->timing
.atim_win
= 0;
3614 il_adjust_beacon_interval(beacon_int
,
3615 il
->hw_params
.max_beacon_itrvl
*
3617 il
->timing
.beacon_interval
= cpu_to_le16(beacon_int
);
3619 tsf
= il
->timestamp
; /* tsf is modifed by do_div: copy it */
3620 interval_tm
= beacon_int
* TIME_UNIT
;
3621 rem
= do_div(tsf
, interval_tm
);
3622 il
->timing
.beacon_init_val
= cpu_to_le32(interval_tm
- rem
);
3624 il
->timing
.dtim_period
= vif
? (vif
->bss_conf
.dtim_period
? : 1) : 1;
3626 D_ASSOC("beacon interval %d beacon timer %d beacon tim %d\n",
3627 le16_to_cpu(il
->timing
.beacon_interval
),
3628 le32_to_cpu(il
->timing
.beacon_init_val
),
3629 le16_to_cpu(il
->timing
.atim_win
));
3631 return il_send_cmd_pdu(il
, C_RXON_TIMING
, sizeof(il
->timing
),
3634 EXPORT_SYMBOL(il_send_rxon_timing
);
3637 il_set_rxon_hwcrypto(struct il_priv
*il
, int hw_decrypt
)
3639 struct il_rxon_cmd
*rxon
= &il
->staging
;
3642 rxon
->filter_flags
&= ~RXON_FILTER_DIS_DECRYPT_MSK
;
3644 rxon
->filter_flags
|= RXON_FILTER_DIS_DECRYPT_MSK
;
3647 EXPORT_SYMBOL(il_set_rxon_hwcrypto
);
3649 /* validate RXON structure is valid */
3651 il_check_rxon_cmd(struct il_priv
*il
)
3653 struct il_rxon_cmd
*rxon
= &il
->staging
;
3656 if (rxon
->flags
& RXON_FLG_BAND_24G_MSK
) {
3657 if (rxon
->flags
& RXON_FLG_TGJ_NARROW_BAND_MSK
) {
3658 IL_WARN("check 2.4G: wrong narrow\n");
3661 if (rxon
->flags
& RXON_FLG_RADAR_DETECT_MSK
) {
3662 IL_WARN("check 2.4G: wrong radar\n");
3666 if (!(rxon
->flags
& RXON_FLG_SHORT_SLOT_MSK
)) {
3667 IL_WARN("check 5.2G: not short slot!\n");
3670 if (rxon
->flags
& RXON_FLG_CCK_MSK
) {
3671 IL_WARN("check 5.2G: CCK!\n");
3675 if ((rxon
->node_addr
[0] | rxon
->bssid_addr
[0]) & 0x1) {
3676 IL_WARN("mac/bssid mcast!\n");
3680 /* make sure basic rates 6Mbps and 1Mbps are supported */
3681 if ((rxon
->ofdm_basic_rates
& RATE_6M_MASK
) == 0 &&
3682 (rxon
->cck_basic_rates
& RATE_1M_MASK
) == 0) {
3683 IL_WARN("neither 1 nor 6 are basic\n");
3687 if (le16_to_cpu(rxon
->assoc_id
) > 2007) {
3688 IL_WARN("aid > 2007\n");
3692 if ((rxon
->flags
& (RXON_FLG_CCK_MSK
| RXON_FLG_SHORT_SLOT_MSK
)) ==
3693 (RXON_FLG_CCK_MSK
| RXON_FLG_SHORT_SLOT_MSK
)) {
3694 IL_WARN("CCK and short slot\n");
3698 if ((rxon
->flags
& (RXON_FLG_CCK_MSK
| RXON_FLG_AUTO_DETECT_MSK
)) ==
3699 (RXON_FLG_CCK_MSK
| RXON_FLG_AUTO_DETECT_MSK
)) {
3700 IL_WARN("CCK and auto detect");
3705 flags
& (RXON_FLG_AUTO_DETECT_MSK
| RXON_FLG_TGG_PROTECT_MSK
)) ==
3706 RXON_FLG_TGG_PROTECT_MSK
) {
3707 IL_WARN("TGg but no auto-detect\n");
3712 IL_WARN("Tuning to channel %d\n", le16_to_cpu(rxon
->channel
));
3715 IL_ERR("Invalid RXON\n");
3720 EXPORT_SYMBOL(il_check_rxon_cmd
);
3723 * il_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
3724 * @il: staging_rxon is compared to active_rxon
3726 * If the RXON structure is changing enough to require a new tune,
3727 * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
3728 * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
3731 il_full_rxon_required(struct il_priv
*il
)
3733 const struct il_rxon_cmd
*staging
= &il
->staging
;
3734 const struct il_rxon_cmd
*active
= &il
->active
;
3738 D_INFO("need full RXON - " #cond "\n"); \
3742 #define CHK_NEQ(c1, c2) \
3743 if ((c1) != (c2)) { \
3744 D_INFO("need full RXON - " \
3745 #c1 " != " #c2 " - %d != %d\n", \
3750 /* These items are only settable from the full RXON command */
3751 CHK(!il_is_associated(il
));
3752 CHK(!ether_addr_equal(staging
->bssid_addr
, active
->bssid_addr
));
3753 CHK(!ether_addr_equal(staging
->node_addr
, active
->node_addr
));
3754 CHK(!ether_addr_equal(staging
->wlap_bssid_addr
,
3755 active
->wlap_bssid_addr
));
3756 CHK_NEQ(staging
->dev_type
, active
->dev_type
);
3757 CHK_NEQ(staging
->channel
, active
->channel
);
3758 CHK_NEQ(staging
->air_propagation
, active
->air_propagation
);
3759 CHK_NEQ(staging
->ofdm_ht_single_stream_basic_rates
,
3760 active
->ofdm_ht_single_stream_basic_rates
);
3761 CHK_NEQ(staging
->ofdm_ht_dual_stream_basic_rates
,
3762 active
->ofdm_ht_dual_stream_basic_rates
);
3763 CHK_NEQ(staging
->assoc_id
, active
->assoc_id
);
3765 /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
3766 * be updated with the RXON_ASSOC command -- however only some
3767 * flag transitions are allowed using RXON_ASSOC */
3769 /* Check if we are not switching bands */
3770 CHK_NEQ(staging
->flags
& RXON_FLG_BAND_24G_MSK
,
3771 active
->flags
& RXON_FLG_BAND_24G_MSK
);
3773 /* Check if we are switching association toggle */
3774 CHK_NEQ(staging
->filter_flags
& RXON_FILTER_ASSOC_MSK
,
3775 active
->filter_flags
& RXON_FILTER_ASSOC_MSK
);
3782 EXPORT_SYMBOL(il_full_rxon_required
);
3785 il_get_lowest_plcp(struct il_priv
*il
)
3788 * Assign the lowest rate -- should really get this from
3789 * the beacon skb from mac80211.
3791 if (il
->staging
.flags
& RXON_FLG_BAND_24G_MSK
)
3792 return RATE_1M_PLCP
;
3794 return RATE_6M_PLCP
;
3796 EXPORT_SYMBOL(il_get_lowest_plcp
);
3799 _il_set_rxon_ht(struct il_priv
*il
, struct il_ht_config
*ht_conf
)
3801 struct il_rxon_cmd
*rxon
= &il
->staging
;
3803 if (!il
->ht
.enabled
) {
3805 ~(RXON_FLG_CHANNEL_MODE_MSK
|
3806 RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
| RXON_FLG_HT40_PROT_MSK
3807 | RXON_FLG_HT_PROT_MSK
);
3812 cpu_to_le32(il
->ht
.protection
<< RXON_FLG_HT_OPERATING_MODE_POS
);
3814 /* Set up channel bandwidth:
3815 * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */
3816 /* clear the HT channel mode before set the mode */
3818 ~(RXON_FLG_CHANNEL_MODE_MSK
| RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
);
3819 if (il_is_ht40_tx_allowed(il
, NULL
)) {
3821 if (il
->ht
.protection
== IEEE80211_HT_OP_MODE_PROTECTION_20MHZ
) {
3822 rxon
->flags
|= RXON_FLG_CHANNEL_MODE_PURE_40
;
3823 /* Note: control channel is opposite of extension channel */
3824 switch (il
->ht
.extension_chan_offset
) {
3825 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
3827 ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
;
3829 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
3830 rxon
->flags
|= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
;
3834 /* Note: control channel is opposite of extension channel */
3835 switch (il
->ht
.extension_chan_offset
) {
3836 case IEEE80211_HT_PARAM_CHA_SEC_ABOVE
:
3838 ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
);
3839 rxon
->flags
|= RXON_FLG_CHANNEL_MODE_MIXED
;
3841 case IEEE80211_HT_PARAM_CHA_SEC_BELOW
:
3842 rxon
->flags
|= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
;
3843 rxon
->flags
|= RXON_FLG_CHANNEL_MODE_MIXED
;
3845 case IEEE80211_HT_PARAM_CHA_SEC_NONE
:
3847 /* channel location only valid if in Mixed mode */
3848 IL_ERR("invalid extension channel offset\n");
3853 rxon
->flags
|= RXON_FLG_CHANNEL_MODE_LEGACY
;
3856 if (il
->ops
->set_rxon_chain
)
3857 il
->ops
->set_rxon_chain(il
);
3859 D_ASSOC("rxon flags 0x%X operation mode :0x%X "
3860 "extension channel offset 0x%x\n", le32_to_cpu(rxon
->flags
),
3861 il
->ht
.protection
, il
->ht
.extension_chan_offset
);
3865 il_set_rxon_ht(struct il_priv
*il
, struct il_ht_config
*ht_conf
)
3867 _il_set_rxon_ht(il
, ht_conf
);
3869 EXPORT_SYMBOL(il_set_rxon_ht
);
3871 /* Return valid, unused, channel for a passive scan to reset the RF */
3873 il_get_single_channel_number(struct il_priv
*il
, enum ieee80211_band band
)
3875 const struct il_channel_info
*ch_info
;
3880 if (band
== IEEE80211_BAND_5GHZ
) {
3882 max
= il
->channel_count
;
3888 for (i
= min
; i
< max
; i
++) {
3889 channel
= il
->channel_info
[i
].channel
;
3890 if (channel
== le16_to_cpu(il
->staging
.channel
))
3893 ch_info
= il_get_channel_info(il
, band
, channel
);
3894 if (il_is_channel_valid(ch_info
))
3900 EXPORT_SYMBOL(il_get_single_channel_number
);
3903 * il_set_rxon_channel - Set the band and channel values in staging RXON
3904 * @ch: requested channel as a pointer to struct ieee80211_channel
3906 * NOTE: Does not commit to the hardware; it sets appropriate bit fields
3907 * in the staging RXON flag structure based on the ch->band
3910 il_set_rxon_channel(struct il_priv
*il
, struct ieee80211_channel
*ch
)
3912 enum ieee80211_band band
= ch
->band
;
3913 u16 channel
= ch
->hw_value
;
3915 if (le16_to_cpu(il
->staging
.channel
) == channel
&& il
->band
== band
)
3918 il
->staging
.channel
= cpu_to_le16(channel
);
3919 if (band
== IEEE80211_BAND_5GHZ
)
3920 il
->staging
.flags
&= ~RXON_FLG_BAND_24G_MSK
;
3922 il
->staging
.flags
|= RXON_FLG_BAND_24G_MSK
;
3926 D_INFO("Staging channel set to %d [%d]\n", channel
, band
);
3930 EXPORT_SYMBOL(il_set_rxon_channel
);
3933 il_set_flags_for_band(struct il_priv
*il
, enum ieee80211_band band
,
3934 struct ieee80211_vif
*vif
)
3936 if (band
== IEEE80211_BAND_5GHZ
) {
3937 il
->staging
.flags
&=
3938 ~(RXON_FLG_BAND_24G_MSK
| RXON_FLG_AUTO_DETECT_MSK
|
3940 il
->staging
.flags
|= RXON_FLG_SHORT_SLOT_MSK
;
3942 /* Copied from il_post_associate() */
3943 if (vif
&& vif
->bss_conf
.use_short_slot
)
3944 il
->staging
.flags
|= RXON_FLG_SHORT_SLOT_MSK
;
3946 il
->staging
.flags
&= ~RXON_FLG_SHORT_SLOT_MSK
;
3948 il
->staging
.flags
|= RXON_FLG_BAND_24G_MSK
;
3949 il
->staging
.flags
|= RXON_FLG_AUTO_DETECT_MSK
;
3950 il
->staging
.flags
&= ~RXON_FLG_CCK_MSK
;
3953 EXPORT_SYMBOL(il_set_flags_for_band
);
3956 * initialize rxon structure with default values from eeprom
3959 il_connection_init_rx_config(struct il_priv
*il
)
3961 const struct il_channel_info
*ch_info
;
3963 memset(&il
->staging
, 0, sizeof(il
->staging
));
3965 switch (il
->iw_mode
) {
3966 case NL80211_IFTYPE_UNSPECIFIED
:
3967 il
->staging
.dev_type
= RXON_DEV_TYPE_ESS
;
3969 case NL80211_IFTYPE_STATION
:
3970 il
->staging
.dev_type
= RXON_DEV_TYPE_ESS
;
3971 il
->staging
.filter_flags
= RXON_FILTER_ACCEPT_GRP_MSK
;
3973 case NL80211_IFTYPE_ADHOC
:
3974 il
->staging
.dev_type
= RXON_DEV_TYPE_IBSS
;
3975 il
->staging
.flags
= RXON_FLG_SHORT_PREAMBLE_MSK
;
3976 il
->staging
.filter_flags
=
3977 RXON_FILTER_BCON_AWARE_MSK
| RXON_FILTER_ACCEPT_GRP_MSK
;
3980 IL_ERR("Unsupported interface type %d\n", il
->vif
->type
);
3985 /* TODO: Figure out when short_preamble would be set and cache from
3987 if (!hw_to_local(il
->hw
)->short_preamble
)
3988 il
->staging
.flags
&= ~RXON_FLG_SHORT_PREAMBLE_MSK
;
3990 il
->staging
.flags
|= RXON_FLG_SHORT_PREAMBLE_MSK
;
3994 il_get_channel_info(il
, il
->band
, le16_to_cpu(il
->active
.channel
));
3997 ch_info
= &il
->channel_info
[0];
3999 il
->staging
.channel
= cpu_to_le16(ch_info
->channel
);
4000 il
->band
= ch_info
->band
;
4002 il_set_flags_for_band(il
, il
->band
, il
->vif
);
4004 il
->staging
.ofdm_basic_rates
=
4005 (IL_OFDM_RATES_MASK
>> IL_FIRST_OFDM_RATE
) & 0xFF;
4006 il
->staging
.cck_basic_rates
=
4007 (IL_CCK_RATES_MASK
>> IL_FIRST_CCK_RATE
) & 0xF;
4009 /* clear both MIX and PURE40 mode flag */
4010 il
->staging
.flags
&=
4011 ~(RXON_FLG_CHANNEL_MODE_MIXED
| RXON_FLG_CHANNEL_MODE_PURE_40
);
4013 memcpy(il
->staging
.node_addr
, il
->vif
->addr
, ETH_ALEN
);
4015 il
->staging
.ofdm_ht_single_stream_basic_rates
= 0xff;
4016 il
->staging
.ofdm_ht_dual_stream_basic_rates
= 0xff;
4018 EXPORT_SYMBOL(il_connection_init_rx_config
);
4021 il_set_rate(struct il_priv
*il
)
4023 const struct ieee80211_supported_band
*hw
= NULL
;
4024 struct ieee80211_rate
*rate
;
4027 hw
= il_get_hw_mode(il
, il
->band
);
4029 IL_ERR("Failed to set rate: unable to get hw mode\n");
4033 il
->active_rate
= 0;
4035 for (i
= 0; i
< hw
->n_bitrates
; i
++) {
4036 rate
= &(hw
->bitrates
[i
]);
4037 if (rate
->hw_value
< RATE_COUNT_LEGACY
)
4038 il
->active_rate
|= (1 << rate
->hw_value
);
4041 D_RATE("Set active_rate = %0x\n", il
->active_rate
);
4043 il
->staging
.cck_basic_rates
=
4044 (IL_CCK_BASIC_RATES_MASK
>> IL_FIRST_CCK_RATE
) & 0xF;
4046 il
->staging
.ofdm_basic_rates
=
4047 (IL_OFDM_BASIC_RATES_MASK
>> IL_FIRST_OFDM_RATE
) & 0xFF;
4049 EXPORT_SYMBOL(il_set_rate
);
4052 il_chswitch_done(struct il_priv
*il
, bool is_success
)
4054 if (test_bit(S_EXIT_PENDING
, &il
->status
))
4057 if (test_and_clear_bit(S_CHANNEL_SWITCH_PENDING
, &il
->status
))
4058 ieee80211_chswitch_done(il
->vif
, is_success
);
4060 EXPORT_SYMBOL(il_chswitch_done
);
4063 il_hdl_csa(struct il_priv
*il
, struct il_rx_buf
*rxb
)
4065 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
4066 struct il_csa_notification
*csa
= &(pkt
->u
.csa_notif
);
4067 struct il_rxon_cmd
*rxon
= (void *)&il
->active
;
4069 if (!test_bit(S_CHANNEL_SWITCH_PENDING
, &il
->status
))
4072 if (!le32_to_cpu(csa
->status
) && csa
->channel
== il
->switch_channel
) {
4073 rxon
->channel
= csa
->channel
;
4074 il
->staging
.channel
= csa
->channel
;
4075 D_11H("CSA notif: channel %d\n", le16_to_cpu(csa
->channel
));
4076 il_chswitch_done(il
, true);
4078 IL_ERR("CSA notif (fail) : channel %d\n",
4079 le16_to_cpu(csa
->channel
));
4080 il_chswitch_done(il
, false);
4083 EXPORT_SYMBOL(il_hdl_csa
);
4085 #ifdef CONFIG_IWLEGACY_DEBUG
4087 il_print_rx_config_cmd(struct il_priv
*il
)
4089 struct il_rxon_cmd
*rxon
= &il
->staging
;
4091 D_RADIO("RX CONFIG:\n");
4092 il_print_hex_dump(il
, IL_DL_RADIO
, (u8
*) rxon
, sizeof(*rxon
));
4093 D_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon
->channel
));
4094 D_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon
->flags
));
4095 D_RADIO("u32 filter_flags: 0x%08x\n", le32_to_cpu(rxon
->filter_flags
));
4096 D_RADIO("u8 dev_type: 0x%x\n", rxon
->dev_type
);
4097 D_RADIO("u8 ofdm_basic_rates: 0x%02x\n", rxon
->ofdm_basic_rates
);
4098 D_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon
->cck_basic_rates
);
4099 D_RADIO("u8[6] node_addr: %pM\n", rxon
->node_addr
);
4100 D_RADIO("u8[6] bssid_addr: %pM\n", rxon
->bssid_addr
);
4101 D_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon
->assoc_id
));
4103 EXPORT_SYMBOL(il_print_rx_config_cmd
);
4106 * il_irq_handle_error - called for HW or SW error interrupt from card
4109 il_irq_handle_error(struct il_priv
*il
)
4111 /* Set the FW error flag -- cleared on il_down */
4112 set_bit(S_FW_ERROR
, &il
->status
);
4114 /* Cancel currently queued command. */
4115 clear_bit(S_HCMD_ACTIVE
, &il
->status
);
4117 IL_ERR("Loaded firmware version: %s\n", il
->hw
->wiphy
->fw_version
);
4119 il
->ops
->dump_nic_error_log(il
);
4120 if (il
->ops
->dump_fh
)
4121 il
->ops
->dump_fh(il
, NULL
, false);
4122 #ifdef CONFIG_IWLEGACY_DEBUG
4123 if (il_get_debug_level(il
) & IL_DL_FW_ERRORS
)
4124 il_print_rx_config_cmd(il
);
4127 wake_up(&il
->wait_command_queue
);
4129 /* Keep the restart process from trying to send host
4130 * commands by clearing the INIT status bit */
4131 clear_bit(S_READY
, &il
->status
);
4133 if (!test_bit(S_EXIT_PENDING
, &il
->status
)) {
4134 IL_DBG(IL_DL_FW_ERRORS
,
4135 "Restarting adapter due to uCode error.\n");
4137 if (il
->cfg
->mod_params
->restart_fw
)
4138 queue_work(il
->workqueue
, &il
->restart
);
4141 EXPORT_SYMBOL(il_irq_handle_error
);
4144 _il_apm_stop_master(struct il_priv
*il
)
4148 /* stop device's busmaster DMA activity */
4149 _il_set_bit(il
, CSR_RESET
, CSR_RESET_REG_FLAG_STOP_MASTER
);
4152 _il_poll_bit(il
, CSR_RESET
, CSR_RESET_REG_FLAG_MASTER_DISABLED
,
4153 CSR_RESET_REG_FLAG_MASTER_DISABLED
, 100);
4155 IL_WARN("Master Disable Timed Out, 100 usec\n");
4157 D_INFO("stop master\n");
4163 _il_apm_stop(struct il_priv
*il
)
4165 lockdep_assert_held(&il
->reg_lock
);
4167 D_INFO("Stop card, put in low power state\n");
4169 /* Stop device's DMA activity */
4170 _il_apm_stop_master(il
);
4172 /* Reset the entire device */
4173 _il_set_bit(il
, CSR_RESET
, CSR_RESET_REG_FLAG_SW_RESET
);
4178 * Clear "initialization complete" bit to move adapter from
4179 * D0A* (powered-up Active) --> D0U* (Uninitialized) state.
4181 _il_clear_bit(il
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_INIT_DONE
);
4183 EXPORT_SYMBOL(_il_apm_stop
);
4186 il_apm_stop(struct il_priv
*il
)
4188 unsigned long flags
;
4190 spin_lock_irqsave(&il
->reg_lock
, flags
);
4192 spin_unlock_irqrestore(&il
->reg_lock
, flags
);
4194 EXPORT_SYMBOL(il_apm_stop
);
4197 * Start up NIC's basic functionality after it has been reset
4198 * (e.g. after platform boot, or shutdown via il_apm_stop())
4199 * NOTE: This does not load uCode nor start the embedded processor
4202 il_apm_init(struct il_priv
*il
)
4207 D_INFO("Init card's basic functions\n");
4210 * Use "set_bit" below rather than "write", to preserve any hardware
4211 * bits already set by default after reset.
4214 /* Disable L0S exit timer (platform NMI Work/Around) */
4215 il_set_bit(il
, CSR_GIO_CHICKEN_BITS
,
4216 CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER
);
4219 * Disable L0s without affecting L1;
4220 * don't wait for ICH L0s (ICH bug W/A)
4222 il_set_bit(il
, CSR_GIO_CHICKEN_BITS
,
4223 CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX
);
4225 /* Set FH wait threshold to maximum (HW error during stress W/A) */
4226 il_set_bit(il
, CSR_DBG_HPET_MEM_REG
, CSR_DBG_HPET_MEM_REG_VAL
);
4229 * Enable HAP INTA (interrupt from management bus) to
4230 * wake device's PCI Express link L1a -> L0s
4231 * NOTE: This is no-op for 3945 (non-existent bit)
4233 il_set_bit(il
, CSR_HW_IF_CONFIG_REG
,
4234 CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A
);
4237 * HW bug W/A for instability in PCIe bus L0->L0S->L1 transition.
4238 * Check if BIOS (or OS) enabled L1-ASPM on this device.
4239 * If so (likely), disable L0S, so device moves directly L0->L1;
4240 * costs negligible amount of power savings.
4241 * If not (unlikely), enable L0S, so there is at least some
4242 * power savings, even without L1.
4244 if (il
->cfg
->set_l0s
) {
4245 pcie_capability_read_word(il
->pci_dev
, PCI_EXP_LNKCTL
, &lctl
);
4246 if (lctl
& PCI_EXP_LNKCTL_ASPM_L1
) {
4247 /* L1-ASPM enabled; disable(!) L0S */
4248 il_set_bit(il
, CSR_GIO_REG
,
4249 CSR_GIO_REG_VAL_L0S_ENABLED
);
4250 D_POWER("L1 Enabled; Disabling L0S\n");
4252 /* L1-ASPM disabled; enable(!) L0S */
4253 il_clear_bit(il
, CSR_GIO_REG
,
4254 CSR_GIO_REG_VAL_L0S_ENABLED
);
4255 D_POWER("L1 Disabled; Enabling L0S\n");
4259 /* Configure analog phase-lock-loop before activating to D0A */
4260 if (il
->cfg
->pll_cfg_val
)
4261 il_set_bit(il
, CSR_ANA_PLL_CFG
,
4262 il
->cfg
->pll_cfg_val
);
4265 * Set "initialization complete" bit to move adapter from
4266 * D0U* --> D0A* (powered-up active) state.
4268 il_set_bit(il
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_INIT_DONE
);
4271 * Wait for clock stabilization; once stabilized, access to
4272 * device-internal resources is supported, e.g. il_wr_prph()
4273 * and accesses to uCode SRAM.
4276 _il_poll_bit(il
, CSR_GP_CNTRL
,
4277 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
,
4278 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
, 25000);
4280 D_INFO("Failed to init the card\n");
4285 * Enable DMA and BSM (if used) clocks, wait for them to stabilize.
4286 * BSM (Boostrap State Machine) is only in 3945 and 4965.
4288 * Write to "CLK_EN_REG"; "1" bits enable clocks, while "0" bits
4289 * do not disable clocks. This preserves any hardware bits already
4290 * set by default in "CLK_CTRL_REG" after reset.
4292 if (il
->cfg
->use_bsm
)
4293 il_wr_prph(il
, APMG_CLK_EN_REG
,
4294 APMG_CLK_VAL_DMA_CLK_RQT
| APMG_CLK_VAL_BSM_CLK_RQT
);
4296 il_wr_prph(il
, APMG_CLK_EN_REG
, APMG_CLK_VAL_DMA_CLK_RQT
);
4299 /* Disable L1-Active */
4300 il_set_bits_prph(il
, APMG_PCIDEV_STT_REG
,
4301 APMG_PCIDEV_STT_VAL_L1_ACT_DIS
);
4306 EXPORT_SYMBOL(il_apm_init
);
4309 il_set_tx_power(struct il_priv
*il
, s8 tx_power
, bool force
)
4315 lockdep_assert_held(&il
->mutex
);
4317 if (il
->tx_power_user_lmt
== tx_power
&& !force
)
4320 if (!il
->ops
->send_tx_power
)
4323 /* 0 dBm mean 1 milliwatt */
4325 IL_WARN("Requested user TXPOWER %d below 1 mW.\n", tx_power
);
4329 if (tx_power
> il
->tx_power_device_lmt
) {
4330 IL_WARN("Requested user TXPOWER %d above upper limit %d.\n",
4331 tx_power
, il
->tx_power_device_lmt
);
4335 if (!il_is_ready_rf(il
))
4338 /* scan complete and commit_rxon use tx_power_next value,
4339 * it always need to be updated for newest request */
4340 il
->tx_power_next
= tx_power
;
4342 /* do not set tx power when scanning or channel changing */
4343 defer
= test_bit(S_SCANNING
, &il
->status
) ||
4344 memcmp(&il
->active
, &il
->staging
, sizeof(il
->staging
));
4345 if (defer
&& !force
) {
4346 D_INFO("Deferring tx power set\n");
4350 prev_tx_power
= il
->tx_power_user_lmt
;
4351 il
->tx_power_user_lmt
= tx_power
;
4353 ret
= il
->ops
->send_tx_power(il
);
4355 /* if fail to set tx_power, restore the orig. tx power */
4357 il
->tx_power_user_lmt
= prev_tx_power
;
4358 il
->tx_power_next
= prev_tx_power
;
4362 EXPORT_SYMBOL(il_set_tx_power
);
4365 il_send_bt_config(struct il_priv
*il
)
4367 struct il_bt_cmd bt_cmd
= {
4368 .lead_time
= BT_LEAD_TIME_DEF
,
4369 .max_kill
= BT_MAX_KILL_DEF
,
4374 if (!bt_coex_active
)
4375 bt_cmd
.flags
= BT_COEX_DISABLE
;
4377 bt_cmd
.flags
= BT_COEX_ENABLE
;
4379 D_INFO("BT coex %s\n",
4380 (bt_cmd
.flags
== BT_COEX_DISABLE
) ? "disable" : "active");
4382 if (il_send_cmd_pdu(il
, C_BT_CONFIG
, sizeof(struct il_bt_cmd
), &bt_cmd
))
4383 IL_ERR("failed to send BT Coex Config\n");
4385 EXPORT_SYMBOL(il_send_bt_config
);
4388 il_send_stats_request(struct il_priv
*il
, u8 flags
, bool clear
)
4390 struct il_stats_cmd stats_cmd
= {
4391 .configuration_flags
= clear
? IL_STATS_CONF_CLEAR_STATS
: 0,
4394 if (flags
& CMD_ASYNC
)
4395 return il_send_cmd_pdu_async(il
, C_STATS
, sizeof(struct il_stats_cmd
),
4398 return il_send_cmd_pdu(il
, C_STATS
, sizeof(struct il_stats_cmd
),
4401 EXPORT_SYMBOL(il_send_stats_request
);
4404 il_hdl_pm_sleep(struct il_priv
*il
, struct il_rx_buf
*rxb
)
4406 #ifdef CONFIG_IWLEGACY_DEBUG
4407 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
4408 struct il_sleep_notification
*sleep
= &(pkt
->u
.sleep_notif
);
4409 D_RX("sleep mode: %d, src: %d\n",
4410 sleep
->pm_sleep_mode
, sleep
->pm_wakeup_src
);
4413 EXPORT_SYMBOL(il_hdl_pm_sleep
);
4416 il_hdl_pm_debug_stats(struct il_priv
*il
, struct il_rx_buf
*rxb
)
4418 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
4419 u32 len
= le32_to_cpu(pkt
->len_n_flags
) & IL_RX_FRAME_SIZE_MSK
;
4420 D_RADIO("Dumping %d bytes of unhandled notification for %s:\n", len
,
4421 il_get_cmd_string(pkt
->hdr
.cmd
));
4422 il_print_hex_dump(il
, IL_DL_RADIO
, pkt
->u
.raw
, len
);
4424 EXPORT_SYMBOL(il_hdl_pm_debug_stats
);
4427 il_hdl_error(struct il_priv
*il
, struct il_rx_buf
*rxb
)
4429 struct il_rx_pkt
*pkt
= rxb_addr(rxb
);
4431 IL_ERR("Error Reply type 0x%08X cmd %s (0x%02X) "
4432 "seq 0x%04X ser 0x%08X\n",
4433 le32_to_cpu(pkt
->u
.err_resp
.error_type
),
4434 il_get_cmd_string(pkt
->u
.err_resp
.cmd_id
),
4435 pkt
->u
.err_resp
.cmd_id
,
4436 le16_to_cpu(pkt
->u
.err_resp
.bad_cmd_seq_num
),
4437 le32_to_cpu(pkt
->u
.err_resp
.error_info
));
4439 EXPORT_SYMBOL(il_hdl_error
);
4442 il_clear_isr_stats(struct il_priv
*il
)
4444 memset(&il
->isr_stats
, 0, sizeof(il
->isr_stats
));
4448 il_mac_conf_tx(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
, u16 queue
,
4449 const struct ieee80211_tx_queue_params
*params
)
4451 struct il_priv
*il
= hw
->priv
;
4452 unsigned long flags
;
4455 D_MAC80211("enter\n");
4457 if (!il_is_ready_rf(il
)) {
4458 D_MAC80211("leave - RF not ready\n");
4462 if (queue
>= AC_NUM
) {
4463 D_MAC80211("leave - queue >= AC_NUM %d\n", queue
);
4467 q
= AC_NUM
- 1 - queue
;
4469 spin_lock_irqsave(&il
->lock
, flags
);
4471 il
->qos_data
.def_qos_parm
.ac
[q
].cw_min
=
4472 cpu_to_le16(params
->cw_min
);
4473 il
->qos_data
.def_qos_parm
.ac
[q
].cw_max
=
4474 cpu_to_le16(params
->cw_max
);
4475 il
->qos_data
.def_qos_parm
.ac
[q
].aifsn
= params
->aifs
;
4476 il
->qos_data
.def_qos_parm
.ac
[q
].edca_txop
=
4477 cpu_to_le16((params
->txop
* 32));
4479 il
->qos_data
.def_qos_parm
.ac
[q
].reserved1
= 0;
4481 spin_unlock_irqrestore(&il
->lock
, flags
);
4483 D_MAC80211("leave\n");
4486 EXPORT_SYMBOL(il_mac_conf_tx
);
4489 il_mac_tx_last_beacon(struct ieee80211_hw
*hw
)
4491 struct il_priv
*il
= hw
->priv
;
4494 D_MAC80211("enter\n");
4496 ret
= (il
->ibss_manager
== IL_IBSS_MANAGER
);
4498 D_MAC80211("leave ret %d\n", ret
);
4501 EXPORT_SYMBOL_GPL(il_mac_tx_last_beacon
);
4504 il_set_mode(struct il_priv
*il
)
4506 il_connection_init_rx_config(il
);
4508 if (il
->ops
->set_rxon_chain
)
4509 il
->ops
->set_rxon_chain(il
);
4511 return il_commit_rxon(il
);
4515 il_mac_add_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
4517 struct il_priv
*il
= hw
->priv
;
4521 mutex_lock(&il
->mutex
);
4522 D_MAC80211("enter: type %d, addr %pM\n", vif
->type
, vif
->addr
);
4524 if (!il_is_ready_rf(il
)) {
4525 IL_WARN("Try to add interface when device not ready\n");
4531 * We do not support multiple virtual interfaces, but on hardware reset
4532 * we have to add the same interface again.
4534 reset
= (il
->vif
== vif
);
4535 if (il
->vif
&& !reset
) {
4541 il
->iw_mode
= vif
->type
;
4543 err
= il_set_mode(il
);
4545 IL_WARN("Fail to set mode %d\n", vif
->type
);
4548 il
->iw_mode
= NL80211_IFTYPE_STATION
;
4553 D_MAC80211("leave err %d\n", err
);
4554 mutex_unlock(&il
->mutex
);
4558 EXPORT_SYMBOL(il_mac_add_interface
);
4561 il_teardown_interface(struct il_priv
*il
, struct ieee80211_vif
*vif
)
4563 lockdep_assert_held(&il
->mutex
);
4565 if (il
->scan_vif
== vif
) {
4566 il_scan_cancel_timeout(il
, 200);
4567 il_force_scan_end(il
);
4574 il_mac_remove_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
4576 struct il_priv
*il
= hw
->priv
;
4578 mutex_lock(&il
->mutex
);
4579 D_MAC80211("enter: type %d, addr %pM\n", vif
->type
, vif
->addr
);
4581 WARN_ON(il
->vif
!= vif
);
4583 il
->iw_mode
= NL80211_IFTYPE_UNSPECIFIED
;
4584 il_teardown_interface(il
, vif
);
4585 memset(il
->bssid
, 0, ETH_ALEN
);
4587 D_MAC80211("leave\n");
4588 mutex_unlock(&il
->mutex
);
4590 EXPORT_SYMBOL(il_mac_remove_interface
);
4593 il_alloc_txq_mem(struct il_priv
*il
)
4597 kzalloc(sizeof(struct il_tx_queue
) *
4598 il
->cfg
->num_of_queues
, GFP_KERNEL
);
4600 IL_ERR("Not enough memory for txq\n");
4605 EXPORT_SYMBOL(il_alloc_txq_mem
);
4608 il_free_txq_mem(struct il_priv
*il
)
4613 EXPORT_SYMBOL(il_free_txq_mem
);
4616 il_force_reset(struct il_priv
*il
, bool external
)
4618 struct il_force_reset
*force_reset
;
4620 if (test_bit(S_EXIT_PENDING
, &il
->status
))
4623 force_reset
= &il
->force_reset
;
4624 force_reset
->reset_request_count
++;
4626 if (force_reset
->last_force_reset_jiffies
&&
4627 time_after(force_reset
->last_force_reset_jiffies
+
4628 force_reset
->reset_duration
, jiffies
)) {
4629 D_INFO("force reset rejected\n");
4630 force_reset
->reset_reject_count
++;
4634 force_reset
->reset_success_count
++;
4635 force_reset
->last_force_reset_jiffies
= jiffies
;
4638 * if the request is from external(ex: debugfs),
4639 * then always perform the request in regardless the module
4641 * if the request is from internal (uCode error or driver
4642 * detect failure), then fw_restart module parameter
4643 * need to be check before performing firmware reload
4646 if (!external
&& !il
->cfg
->mod_params
->restart_fw
) {
4647 D_INFO("Cancel firmware reload based on "
4648 "module parameter setting\n");
4652 IL_ERR("On demand firmware reload\n");
4654 /* Set the FW error flag -- cleared on il_down */
4655 set_bit(S_FW_ERROR
, &il
->status
);
4656 wake_up(&il
->wait_command_queue
);
4658 * Keep the restart process from trying to send host
4659 * commands by clearing the INIT status bit
4661 clear_bit(S_READY
, &il
->status
);
4662 queue_work(il
->workqueue
, &il
->restart
);
4668 il_mac_change_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
4669 enum nl80211_iftype newtype
, bool newp2p
)
4671 struct il_priv
*il
= hw
->priv
;
4674 mutex_lock(&il
->mutex
);
4675 D_MAC80211("enter: type %d, addr %pM newtype %d newp2p %d\n",
4676 vif
->type
, vif
->addr
, newtype
, newp2p
);
4683 if (!il
->vif
|| !il_is_ready_rf(il
)) {
4685 * Huh? But wait ... this can maybe happen when
4686 * we're in the middle of a firmware restart!
4693 vif
->type
= newtype
;
4695 il
->iw_mode
= newtype
;
4696 il_teardown_interface(il
, vif
);
4700 D_MAC80211("leave err %d\n", err
);
4701 mutex_unlock(&il
->mutex
);
4705 EXPORT_SYMBOL(il_mac_change_interface
);
4708 il_mac_flush(struct ieee80211_hw
*hw
, bool drop
)
4710 struct il_priv
*il
= hw
->priv
;
4711 unsigned long timeout
= jiffies
+ msecs_to_jiffies(500);
4714 mutex_lock(&il
->mutex
);
4715 D_MAC80211("enter\n");
4717 if (il
->txq
== NULL
)
4720 for (i
= 0; i
< il
->hw_params
.max_txq_num
; i
++) {
4723 if (i
== il
->cmd_queue
)
4727 if (q
->read_ptr
== q
->write_ptr
)
4730 if (time_after(jiffies
, timeout
)) {
4731 IL_ERR("Failed to flush queue %d\n", q
->id
);
4738 D_MAC80211("leave\n");
4739 mutex_unlock(&il
->mutex
);
4741 EXPORT_SYMBOL(il_mac_flush
);
4744 * On every watchdog tick we check (latest) time stamp. If it does not
4745 * change during timeout period and queue is not empty we reset firmware.
4748 il_check_stuck_queue(struct il_priv
*il
, int cnt
)
4750 struct il_tx_queue
*txq
= &il
->txq
[cnt
];
4751 struct il_queue
*q
= &txq
->q
;
4752 unsigned long timeout
;
4753 unsigned long now
= jiffies
;
4756 if (q
->read_ptr
== q
->write_ptr
) {
4757 txq
->time_stamp
= now
;
4763 msecs_to_jiffies(il
->cfg
->wd_timeout
);
4765 if (time_after(now
, timeout
)) {
4766 IL_ERR("Queue %d stuck for %u ms.\n", q
->id
,
4767 jiffies_to_msecs(now
- txq
->time_stamp
));
4768 ret
= il_force_reset(il
, false);
4769 return (ret
== -EAGAIN
) ? 0 : 1;
4776 * Making watchdog tick be a quarter of timeout assure we will
4777 * discover the queue hung between timeout and 1.25*timeout
4779 #define IL_WD_TICK(timeout) ((timeout) / 4)
4782 * Watchdog timer callback, we check each tx queue for stuck, if if hung
4783 * we reset the firmware. If everything is fine just rearm the timer.
4786 il_bg_watchdog(unsigned long data
)
4788 struct il_priv
*il
= (struct il_priv
*)data
;
4790 unsigned long timeout
;
4792 if (test_bit(S_EXIT_PENDING
, &il
->status
))
4795 timeout
= il
->cfg
->wd_timeout
;
4799 /* monitor and check for stuck cmd queue */
4800 if (il_check_stuck_queue(il
, il
->cmd_queue
))
4803 /* monitor and check for other stuck queues */
4804 for (cnt
= 0; cnt
< il
->hw_params
.max_txq_num
; cnt
++) {
4805 /* skip as we already checked the command queue */
4806 if (cnt
== il
->cmd_queue
)
4808 if (il_check_stuck_queue(il
, cnt
))
4812 mod_timer(&il
->watchdog
,
4813 jiffies
+ msecs_to_jiffies(IL_WD_TICK(timeout
)));
4815 EXPORT_SYMBOL(il_bg_watchdog
);
4818 il_setup_watchdog(struct il_priv
*il
)
4820 unsigned int timeout
= il
->cfg
->wd_timeout
;
4823 mod_timer(&il
->watchdog
,
4824 jiffies
+ msecs_to_jiffies(IL_WD_TICK(timeout
)));
4826 del_timer(&il
->watchdog
);
4828 EXPORT_SYMBOL(il_setup_watchdog
);
4831 * extended beacon time format
4832 * time in usec will be changed into a 32-bit value in extended:internal format
4833 * the extended part is the beacon counts
4834 * the internal part is the time in usec within one beacon interval
4837 il_usecs_to_beacons(struct il_priv
*il
, u32 usec
, u32 beacon_interval
)
4841 u32 interval
= beacon_interval
* TIME_UNIT
;
4843 if (!interval
|| !usec
)
4848 interval
) & (il_beacon_time_mask_high(il
,
4850 beacon_time_tsf_bits
) >> il
->
4851 hw_params
.beacon_time_tsf_bits
);
4853 (usec
% interval
) & il_beacon_time_mask_low(il
,
4855 beacon_time_tsf_bits
);
4857 return (quot
<< il
->hw_params
.beacon_time_tsf_bits
) + rem
;
4859 EXPORT_SYMBOL(il_usecs_to_beacons
);
4861 /* base is usually what we get from ucode with each received frame,
4862 * the same as HW timer counter counting down
4865 il_add_beacon_time(struct il_priv
*il
, u32 base
, u32 addon
,
4866 u32 beacon_interval
)
4868 u32 base_low
= base
& il_beacon_time_mask_low(il
,
4870 beacon_time_tsf_bits
);
4871 u32 addon_low
= addon
& il_beacon_time_mask_low(il
,
4873 beacon_time_tsf_bits
);
4874 u32 interval
= beacon_interval
* TIME_UNIT
;
4875 u32 res
= (base
& il_beacon_time_mask_high(il
,
4877 beacon_time_tsf_bits
)) +
4878 (addon
& il_beacon_time_mask_high(il
,
4880 beacon_time_tsf_bits
));
4882 if (base_low
> addon_low
)
4883 res
+= base_low
- addon_low
;
4884 else if (base_low
< addon_low
) {
4885 res
+= interval
+ base_low
- addon_low
;
4886 res
+= (1 << il
->hw_params
.beacon_time_tsf_bits
);
4888 res
+= (1 << il
->hw_params
.beacon_time_tsf_bits
);
4890 return cpu_to_le32(res
);
4892 EXPORT_SYMBOL(il_add_beacon_time
);
4897 il_pci_suspend(struct device
*device
)
4899 struct pci_dev
*pdev
= to_pci_dev(device
);
4900 struct il_priv
*il
= pci_get_drvdata(pdev
);
4903 * This function is called when system goes into suspend state
4904 * mac80211 will call il_mac_stop() from the mac80211 suspend function
4905 * first but since il_mac_stop() has no knowledge of who the caller is,
4906 * it will not call apm_ops.stop() to stop the DMA operation.
4907 * Calling apm_ops.stop here to make sure we stop the DMA.
4915 il_pci_resume(struct device
*device
)
4917 struct pci_dev
*pdev
= to_pci_dev(device
);
4918 struct il_priv
*il
= pci_get_drvdata(pdev
);
4919 bool hw_rfkill
= false;
4922 * We disable the RETRY_TIMEOUT register (0x41) to keep
4923 * PCI Tx retries from interfering with C3 CPU state.
4925 pci_write_config_byte(pdev
, PCI_CFG_RETRY_TIMEOUT
, 0x00);
4927 il_enable_interrupts(il
);
4929 if (!(_il_rd(il
, CSR_GP_CNTRL
) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW
))
4933 set_bit(S_RFKILL
, &il
->status
);
4935 clear_bit(S_RFKILL
, &il
->status
);
4937 wiphy_rfkill_set_hw_state(il
->hw
->wiphy
, hw_rfkill
);
4942 SIMPLE_DEV_PM_OPS(il_pm_ops
, il_pci_suspend
, il_pci_resume
);
4943 EXPORT_SYMBOL(il_pm_ops
);
4945 #endif /* CONFIG_PM */
4948 il_update_qos(struct il_priv
*il
)
4950 if (test_bit(S_EXIT_PENDING
, &il
->status
))
4953 il
->qos_data
.def_qos_parm
.qos_flags
= 0;
4955 if (il
->qos_data
.qos_active
)
4956 il
->qos_data
.def_qos_parm
.qos_flags
|=
4957 QOS_PARAM_FLG_UPDATE_EDCA_MSK
;
4960 il
->qos_data
.def_qos_parm
.qos_flags
|= QOS_PARAM_FLG_TGN_MSK
;
4962 D_QOS("send QoS cmd with Qos active=%d FLAGS=0x%X\n",
4963 il
->qos_data
.qos_active
, il
->qos_data
.def_qos_parm
.qos_flags
);
4965 il_send_cmd_pdu_async(il
, C_QOS_PARAM
, sizeof(struct il_qosparam_cmd
),
4966 &il
->qos_data
.def_qos_parm
, NULL
);
4970 * il_mac_config - mac80211 config callback
4973 il_mac_config(struct ieee80211_hw
*hw
, u32 changed
)
4975 struct il_priv
*il
= hw
->priv
;
4976 const struct il_channel_info
*ch_info
;
4977 struct ieee80211_conf
*conf
= &hw
->conf
;
4978 struct ieee80211_channel
*channel
= conf
->channel
;
4979 struct il_ht_config
*ht_conf
= &il
->current_ht_config
;
4980 unsigned long flags
= 0;
4983 int scan_active
= 0;
4984 bool ht_changed
= false;
4986 mutex_lock(&il
->mutex
);
4987 D_MAC80211("enter: channel %d changed 0x%X\n", channel
->hw_value
,
4990 if (unlikely(test_bit(S_SCANNING
, &il
->status
))) {
4992 D_MAC80211("scan active\n");
4996 (IEEE80211_CONF_CHANGE_SMPS
| IEEE80211_CONF_CHANGE_CHANNEL
)) {
4997 /* mac80211 uses static for non-HT which is what we want */
4998 il
->current_ht_config
.smps
= conf
->smps_mode
;
5001 * Recalculate chain counts.
5003 * If monitor mode is enabled then mac80211 will
5004 * set up the SM PS mode to OFF if an HT channel is
5007 if (il
->ops
->set_rxon_chain
)
5008 il
->ops
->set_rxon_chain(il
);
5011 /* during scanning mac80211 will delay channel setting until
5012 * scan finish with changed = 0
5014 if (!changed
|| (changed
& IEEE80211_CONF_CHANGE_CHANNEL
)) {
5019 ch
= channel
->hw_value
;
5020 ch_info
= il_get_channel_info(il
, channel
->band
, ch
);
5021 if (!il_is_channel_valid(ch_info
)) {
5022 D_MAC80211("leave - invalid channel\n");
5027 if (il
->iw_mode
== NL80211_IFTYPE_ADHOC
&&
5028 !il_is_channel_ibss(ch_info
)) {
5029 D_MAC80211("leave - not IBSS channel\n");
5034 spin_lock_irqsave(&il
->lock
, flags
);
5036 /* Configure HT40 channels */
5037 if (il
->ht
.enabled
!= conf_is_ht(conf
)) {
5038 il
->ht
.enabled
= conf_is_ht(conf
);
5041 if (il
->ht
.enabled
) {
5042 if (conf_is_ht40_minus(conf
)) {
5043 il
->ht
.extension_chan_offset
=
5044 IEEE80211_HT_PARAM_CHA_SEC_BELOW
;
5045 il
->ht
.is_40mhz
= true;
5046 } else if (conf_is_ht40_plus(conf
)) {
5047 il
->ht
.extension_chan_offset
=
5048 IEEE80211_HT_PARAM_CHA_SEC_ABOVE
;
5049 il
->ht
.is_40mhz
= true;
5051 il
->ht
.extension_chan_offset
=
5052 IEEE80211_HT_PARAM_CHA_SEC_NONE
;
5053 il
->ht
.is_40mhz
= false;
5056 il
->ht
.is_40mhz
= false;
5059 * Default to no protection. Protection mode will
5060 * later be set from BSS config in il_ht_conf
5062 il
->ht
.protection
= IEEE80211_HT_OP_MODE_PROTECTION_NONE
;
5064 /* if we are switching from ht to 2.4 clear flags
5065 * from any ht related info since 2.4 does not
5067 if ((le16_to_cpu(il
->staging
.channel
) != ch
))
5068 il
->staging
.flags
= 0;
5070 il_set_rxon_channel(il
, channel
);
5071 il_set_rxon_ht(il
, ht_conf
);
5073 il_set_flags_for_band(il
, channel
->band
, il
->vif
);
5075 spin_unlock_irqrestore(&il
->lock
, flags
);
5077 if (il
->ops
->update_bcast_stations
)
5078 ret
= il
->ops
->update_bcast_stations(il
);
5081 /* The list of supported rates and rate mask can be different
5082 * for each band; since the band may have changed, reset
5083 * the rate mask to what mac80211 lists */
5087 if (changed
& (IEEE80211_CONF_CHANGE_PS
| IEEE80211_CONF_CHANGE_IDLE
)) {
5088 ret
= il_power_update_mode(il
, false);
5090 D_MAC80211("Error setting sleep level\n");
5093 if (changed
& IEEE80211_CONF_CHANGE_POWER
) {
5094 D_MAC80211("TX Power old=%d new=%d\n", il
->tx_power_user_lmt
,
5097 il_set_tx_power(il
, conf
->power_level
, false);
5100 if (!il_is_ready(il
)) {
5101 D_MAC80211("leave - not ready\n");
5108 if (memcmp(&il
->active
, &il
->staging
, sizeof(il
->staging
)))
5111 D_INFO("Not re-sending same RXON configuration.\n");
5116 D_MAC80211("leave ret %d\n", ret
);
5117 mutex_unlock(&il
->mutex
);
5121 EXPORT_SYMBOL(il_mac_config
);
5124 il_mac_reset_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
5126 struct il_priv
*il
= hw
->priv
;
5127 unsigned long flags
;
5129 mutex_lock(&il
->mutex
);
5130 D_MAC80211("enter: type %d, addr %pM\n", vif
->type
, vif
->addr
);
5132 spin_lock_irqsave(&il
->lock
, flags
);
5134 memset(&il
->current_ht_config
, 0, sizeof(struct il_ht_config
));
5136 /* new association get rid of ibss beacon skb */
5138 dev_kfree_skb(il
->beacon_skb
);
5139 il
->beacon_skb
= NULL
;
5142 spin_unlock_irqrestore(&il
->lock
, flags
);
5144 il_scan_cancel_timeout(il
, 100);
5145 if (!il_is_ready_rf(il
)) {
5146 D_MAC80211("leave - not ready\n");
5147 mutex_unlock(&il
->mutex
);
5151 /* we are restarting association process */
5152 il
->staging
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
5157 D_MAC80211("leave\n");
5158 mutex_unlock(&il
->mutex
);
5160 EXPORT_SYMBOL(il_mac_reset_tsf
);
5163 il_ht_conf(struct il_priv
*il
, struct ieee80211_vif
*vif
)
5165 struct il_ht_config
*ht_conf
= &il
->current_ht_config
;
5166 struct ieee80211_sta
*sta
;
5167 struct ieee80211_bss_conf
*bss_conf
= &vif
->bss_conf
;
5169 D_ASSOC("enter:\n");
5171 if (!il
->ht
.enabled
)
5175 bss_conf
->ht_operation_mode
& IEEE80211_HT_OP_MODE_PROTECTION
;
5176 il
->ht
.non_gf_sta_present
=
5178 ht_operation_mode
& IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
);
5180 ht_conf
->single_chain_sufficient
= false;
5182 switch (vif
->type
) {
5183 case NL80211_IFTYPE_STATION
:
5185 sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
5187 struct ieee80211_sta_ht_cap
*ht_cap
= &sta
->ht_cap
;
5192 tx_params
& IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK
)
5193 >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT
;
5196 if (ht_cap
->mcs
.rx_mask
[1] == 0 &&
5197 ht_cap
->mcs
.rx_mask
[2] == 0)
5198 ht_conf
->single_chain_sufficient
= true;
5199 if (maxstreams
<= 1)
5200 ht_conf
->single_chain_sufficient
= true;
5203 * If at all, this can only happen through a race
5204 * when the AP disconnects us while we're still
5205 * setting up the connection, in that case mac80211
5206 * will soon tell us about that.
5208 ht_conf
->single_chain_sufficient
= true;
5212 case NL80211_IFTYPE_ADHOC
:
5213 ht_conf
->single_chain_sufficient
= true;
5223 il_set_no_assoc(struct il_priv
*il
, struct ieee80211_vif
*vif
)
5226 * inform the ucode that there is no longer an
5227 * association and that no more packets should be
5230 il
->staging
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
5231 il
->staging
.assoc_id
= 0;
5236 il_beacon_update(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
5238 struct il_priv
*il
= hw
->priv
;
5239 unsigned long flags
;
5241 struct sk_buff
*skb
= ieee80211_beacon_get(hw
, vif
);
5246 D_MAC80211("enter\n");
5248 lockdep_assert_held(&il
->mutex
);
5250 if (!il
->beacon_enabled
) {
5251 IL_ERR("update beacon with no beaconing enabled\n");
5256 spin_lock_irqsave(&il
->lock
, flags
);
5259 dev_kfree_skb(il
->beacon_skb
);
5261 il
->beacon_skb
= skb
;
5263 timestamp
= ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
;
5264 il
->timestamp
= le64_to_cpu(timestamp
);
5266 D_MAC80211("leave\n");
5267 spin_unlock_irqrestore(&il
->lock
, flags
);
5269 if (!il_is_ready_rf(il
)) {
5270 D_MAC80211("leave - RF not ready\n");
5274 il
->ops
->post_associate(il
);
5278 il_mac_bss_info_changed(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
5279 struct ieee80211_bss_conf
*bss_conf
, u32 changes
)
5281 struct il_priv
*il
= hw
->priv
;
5284 mutex_lock(&il
->mutex
);
5285 D_MAC80211("enter: changes 0x%x\n", changes
);
5287 if (!il_is_alive(il
)) {
5288 D_MAC80211("leave - not alive\n");
5289 mutex_unlock(&il
->mutex
);
5293 if (changes
& BSS_CHANGED_QOS
) {
5294 unsigned long flags
;
5296 spin_lock_irqsave(&il
->lock
, flags
);
5297 il
->qos_data
.qos_active
= bss_conf
->qos
;
5299 spin_unlock_irqrestore(&il
->lock
, flags
);
5302 if (changes
& BSS_CHANGED_BEACON_ENABLED
) {
5303 /* FIXME: can we remove beacon_enabled ? */
5304 if (vif
->bss_conf
.enable_beacon
)
5305 il
->beacon_enabled
= true;
5307 il
->beacon_enabled
= false;
5310 if (changes
& BSS_CHANGED_BSSID
) {
5311 D_MAC80211("BSSID %pM\n", bss_conf
->bssid
);
5314 * If there is currently a HW scan going on in the background,
5315 * then we need to cancel it, otherwise sometimes we are not
5316 * able to authenticate (FIXME: why ?)
5318 if (il_scan_cancel_timeout(il
, 100)) {
5319 D_MAC80211("leave - scan abort failed\n");
5320 mutex_unlock(&il
->mutex
);
5324 /* mac80211 only sets assoc when in STATION mode */
5325 memcpy(il
->staging
.bssid_addr
, bss_conf
->bssid
, ETH_ALEN
);
5327 /* FIXME: currently needed in a few places */
5328 memcpy(il
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
5332 * This needs to be after setting the BSSID in case
5333 * mac80211 decides to do both changes at once because
5334 * it will invoke post_associate.
5336 if (vif
->type
== NL80211_IFTYPE_ADHOC
&& (changes
& BSS_CHANGED_BEACON
))
5337 il_beacon_update(hw
, vif
);
5339 if (changes
& BSS_CHANGED_ERP_PREAMBLE
) {
5340 D_MAC80211("ERP_PREAMBLE %d\n", bss_conf
->use_short_preamble
);
5341 if (bss_conf
->use_short_preamble
)
5342 il
->staging
.flags
|= RXON_FLG_SHORT_PREAMBLE_MSK
;
5344 il
->staging
.flags
&= ~RXON_FLG_SHORT_PREAMBLE_MSK
;
5347 if (changes
& BSS_CHANGED_ERP_CTS_PROT
) {
5348 D_MAC80211("ERP_CTS %d\n", bss_conf
->use_cts_prot
);
5349 if (bss_conf
->use_cts_prot
&& il
->band
!= IEEE80211_BAND_5GHZ
)
5350 il
->staging
.flags
|= RXON_FLG_TGG_PROTECT_MSK
;
5352 il
->staging
.flags
&= ~RXON_FLG_TGG_PROTECT_MSK
;
5353 if (bss_conf
->use_cts_prot
)
5354 il
->staging
.flags
|= RXON_FLG_SELF_CTS_EN
;
5356 il
->staging
.flags
&= ~RXON_FLG_SELF_CTS_EN
;
5359 if (changes
& BSS_CHANGED_BASIC_RATES
) {
5360 /* XXX use this information
5362 * To do that, remove code from il_set_rate() and put something
5366 il->staging.ofdm_basic_rates =
5367 bss_conf->basic_rates;
5369 il->staging.ofdm_basic_rates =
5370 bss_conf->basic_rates >> 4;
5371 il->staging.cck_basic_rates =
5372 bss_conf->basic_rates & 0xF;
5376 if (changes
& BSS_CHANGED_HT
) {
5377 il_ht_conf(il
, vif
);
5379 if (il
->ops
->set_rxon_chain
)
5380 il
->ops
->set_rxon_chain(il
);
5383 if (changes
& BSS_CHANGED_ASSOC
) {
5384 D_MAC80211("ASSOC %d\n", bss_conf
->assoc
);
5385 if (bss_conf
->assoc
) {
5386 il
->timestamp
= bss_conf
->sync_tsf
;
5388 if (!il_is_rfkill(il
))
5389 il
->ops
->post_associate(il
);
5391 il_set_no_assoc(il
, vif
);
5394 if (changes
&& il_is_associated(il
) && bss_conf
->aid
) {
5395 D_MAC80211("Changes (%#x) while associated\n", changes
);
5396 ret
= il_send_rxon_assoc(il
);
5398 /* Sync active_rxon with latest change. */
5399 memcpy((void *)&il
->active
, &il
->staging
,
5400 sizeof(struct il_rxon_cmd
));
5404 if (changes
& BSS_CHANGED_BEACON_ENABLED
) {
5405 if (vif
->bss_conf
.enable_beacon
) {
5406 memcpy(il
->staging
.bssid_addr
, bss_conf
->bssid
,
5408 memcpy(il
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
5409 il
->ops
->config_ap(il
);
5411 il_set_no_assoc(il
, vif
);
5414 if (changes
& BSS_CHANGED_IBSS
) {
5415 ret
= il
->ops
->manage_ibss_station(il
, vif
,
5416 bss_conf
->ibss_joined
);
5418 IL_ERR("failed to %s IBSS station %pM\n",
5419 bss_conf
->ibss_joined
? "add" : "remove",
5423 D_MAC80211("leave\n");
5424 mutex_unlock(&il
->mutex
);
5426 EXPORT_SYMBOL(il_mac_bss_info_changed
);
5429 il_isr(int irq
, void *data
)
5431 struct il_priv
*il
= data
;
5432 u32 inta
, inta_mask
;
5434 unsigned long flags
;
5438 spin_lock_irqsave(&il
->lock
, flags
);
5440 /* Disable (but don't clear!) interrupts here to avoid
5441 * back-to-back ISRs and sporadic interrupts from our NIC.
5442 * If we have something to service, the tasklet will re-enable ints.
5443 * If we *don't* have something, we'll re-enable before leaving here. */
5444 inta_mask
= _il_rd(il
, CSR_INT_MASK
); /* just for debug */
5445 _il_wr(il
, CSR_INT_MASK
, 0x00000000);
5447 /* Discover which interrupts are active/pending */
5448 inta
= _il_rd(il
, CSR_INT
);
5449 inta_fh
= _il_rd(il
, CSR_FH_INT_STATUS
);
5451 /* Ignore interrupt if there's nothing in NIC to service.
5452 * This may be due to IRQ shared with another device,
5453 * or due to sporadic interrupts thrown from our NIC. */
5454 if (!inta
&& !inta_fh
) {
5455 D_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
5459 if (inta
== 0xFFFFFFFF || (inta
& 0xFFFFFFF0) == 0xa5a5a5a0) {
5460 /* Hardware disappeared. It might have already raised
5462 IL_WARN("HARDWARE GONE?? INTA == 0x%08x\n", inta
);
5466 D_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta
, inta_mask
,
5469 inta
&= ~CSR_INT_BIT_SCD
;
5471 /* il_irq_tasklet() will service interrupts and re-enable them */
5472 if (likely(inta
|| inta_fh
))
5473 tasklet_schedule(&il
->irq_tasklet
);
5476 spin_unlock_irqrestore(&il
->lock
, flags
);
5480 /* re-enable interrupts here since we don't have anything to service. */
5481 /* only Re-enable if disabled by irq */
5482 if (test_bit(S_INT_ENABLED
, &il
->status
))
5483 il_enable_interrupts(il
);
5484 spin_unlock_irqrestore(&il
->lock
, flags
);
5487 EXPORT_SYMBOL(il_isr
);
5490 * il_tx_cmd_protection: Set rts/cts. 3945 and 4965 only share this
5494 il_tx_cmd_protection(struct il_priv
*il
, struct ieee80211_tx_info
*info
,
5495 __le16 fc
, __le32
*tx_flags
)
5497 if (info
->control
.rates
[0].flags
& IEEE80211_TX_RC_USE_RTS_CTS
) {
5498 *tx_flags
|= TX_CMD_FLG_RTS_MSK
;
5499 *tx_flags
&= ~TX_CMD_FLG_CTS_MSK
;
5500 *tx_flags
|= TX_CMD_FLG_FULL_TXOP_PROT_MSK
;
5502 if (!ieee80211_is_mgmt(fc
))
5505 switch (fc
& cpu_to_le16(IEEE80211_FCTL_STYPE
)) {
5506 case cpu_to_le16(IEEE80211_STYPE_AUTH
):
5507 case cpu_to_le16(IEEE80211_STYPE_DEAUTH
):
5508 case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ
):
5509 case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ
):
5510 *tx_flags
&= ~TX_CMD_FLG_RTS_MSK
;
5511 *tx_flags
|= TX_CMD_FLG_CTS_MSK
;
5514 } else if (info
->control
.rates
[0].
5515 flags
& IEEE80211_TX_RC_USE_CTS_PROTECT
) {
5516 *tx_flags
&= ~TX_CMD_FLG_RTS_MSK
;
5517 *tx_flags
|= TX_CMD_FLG_CTS_MSK
;
5518 *tx_flags
|= TX_CMD_FLG_FULL_TXOP_PROT_MSK
;
5521 EXPORT_SYMBOL(il_tx_cmd_protection
);