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
28 *****************************************************************************/
29 #include <linux/etherdevice.h>
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/sched.h>
38 #include "iwl-helpers.h"
39 #include "iwl-agn-hw.h"
42 #include "iwl-trans.h"
43 #include "iwl-shared.h"
45 int iwlagn_hw_valid_rtc_data_addr(u32 addr
)
47 return (addr
>= IWLAGN_RTC_DATA_LOWER_BOUND
) &&
48 (addr
< IWLAGN_RTC_DATA_UPPER_BOUND
);
51 int iwlagn_send_tx_power(struct iwl_priv
*priv
)
53 struct iwlagn_tx_power_dbm_cmd tx_power_cmd
;
56 if (WARN_ONCE(test_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
),
57 "TX Power requested while scanning!\n"))
60 /* half dBm need to multiply */
61 tx_power_cmd
.global_lmt
= (s8
)(2 * priv
->tx_power_user_lmt
);
63 if (priv
->tx_power_lmt_in_half_dbm
&&
64 priv
->tx_power_lmt_in_half_dbm
< tx_power_cmd
.global_lmt
) {
66 * For the newer devices which using enhanced/extend tx power
67 * table in EEPROM, the format is in half dBm. driver need to
68 * convert to dBm format before report to mac80211.
69 * By doing so, there is a possibility of 1/2 dBm resolution
70 * lost. driver will perform "round-up" operation before
71 * reporting, but it will cause 1/2 dBm tx power over the
72 * regulatory limit. Perform the checking here, if the
73 * "tx_power_user_lmt" is higher than EEPROM value (in
74 * half-dBm format), lower the tx power based on EEPROM
76 tx_power_cmd
.global_lmt
= priv
->tx_power_lmt_in_half_dbm
;
78 tx_power_cmd
.flags
= IWLAGN_TX_POWER_NO_CLOSED
;
79 tx_power_cmd
.srv_chan_lmt
= IWLAGN_TX_POWER_AUTO
;
81 if (IWL_UCODE_API(priv
->ucode_ver
) == 1)
82 tx_ant_cfg_cmd
= REPLY_TX_POWER_DBM_CMD_V1
;
84 tx_ant_cfg_cmd
= REPLY_TX_POWER_DBM_CMD
;
86 return iwl_trans_send_cmd_pdu(trans(priv
), tx_ant_cfg_cmd
, CMD_SYNC
,
87 sizeof(tx_power_cmd
), &tx_power_cmd
);
90 void iwlagn_temperature(struct iwl_priv
*priv
)
92 /* store temperature from correct statistics (in Celsius) */
93 priv
->temperature
= le32_to_cpu(priv
->statistics
.common
.temperature
);
97 u16
iwlagn_eeprom_calib_version(struct iwl_priv
*priv
)
99 struct iwl_eeprom_calib_hdr
*hdr
;
101 hdr
= (struct iwl_eeprom_calib_hdr
*)iwl_eeprom_query_addr(priv
,
110 static u32
eeprom_indirect_address(const struct iwl_priv
*priv
, u32 address
)
114 if ((address
& INDIRECT_ADDRESS
) == 0)
117 switch (address
& INDIRECT_TYPE_MSK
) {
119 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_HOST
);
121 case INDIRECT_GENERAL
:
122 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_GENERAL
);
124 case INDIRECT_REGULATORY
:
125 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_REGULATORY
);
127 case INDIRECT_TXP_LIMIT
:
128 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_TXP_LIMIT
);
130 case INDIRECT_TXP_LIMIT_SIZE
:
131 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_TXP_LIMIT_SIZE
);
133 case INDIRECT_CALIBRATION
:
134 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_CALIBRATION
);
136 case INDIRECT_PROCESS_ADJST
:
137 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_PROCESS_ADJST
);
139 case INDIRECT_OTHERS
:
140 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_OTHERS
);
143 IWL_ERR(priv
, "illegal indirect type: 0x%X\n",
144 address
& INDIRECT_TYPE_MSK
);
148 /* translate the offset from words to byte */
149 return (address
& ADDRESS_MSK
) + (offset
<< 1);
152 const u8
*iwl_eeprom_query_addr(const struct iwl_priv
*priv
, size_t offset
)
154 u32 address
= eeprom_indirect_address(priv
, offset
);
155 BUG_ON(address
>= priv
->cfg
->base_params
->eeprom_size
);
156 return &priv
->eeprom
[address
];
159 struct iwl_mod_params iwlagn_mod_params
= {
163 .bt_coex_active
= true,
164 .no_sleep_autoadjust
= true,
165 .power_level
= IWL_POWER_INDEX_1
,
166 .bt_ch_announce
= true,
167 .wanted_ucode_alternative
= 1,
169 /* the rest are 0 by default */
172 int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags
, enum ieee80211_band band
)
177 /* HT rate format: mac80211 wants an MCS number, which is just LSB */
178 if (rate_n_flags
& RATE_MCS_HT_MSK
) {
179 idx
= (rate_n_flags
& 0xff);
181 /* Legacy rate format, search for match in table */
183 if (band
== IEEE80211_BAND_5GHZ
)
184 band_offset
= IWL_FIRST_OFDM_RATE
;
185 for (idx
= band_offset
; idx
< IWL_RATE_COUNT_LEGACY
; idx
++)
186 if (iwl_rates
[idx
].plcp
== (rate_n_flags
& 0xFF))
187 return idx
- band_offset
;
193 static int iwl_get_single_channel_for_scan(struct iwl_priv
*priv
,
194 struct ieee80211_vif
*vif
,
195 enum ieee80211_band band
,
196 struct iwl_scan_channel
*scan_ch
)
198 const struct ieee80211_supported_band
*sband
;
199 u16 passive_dwell
= 0;
200 u16 active_dwell
= 0;
204 sband
= iwl_get_hw_mode(priv
, band
);
206 IWL_ERR(priv
, "invalid band\n");
210 active_dwell
= iwl_get_active_dwell_time(priv
, band
, 0);
211 passive_dwell
= iwl_get_passive_dwell_time(priv
, band
, vif
);
213 if (passive_dwell
<= active_dwell
)
214 passive_dwell
= active_dwell
+ 1;
216 channel
= iwl_get_single_channel_number(priv
, band
);
218 scan_ch
->channel
= cpu_to_le16(channel
);
219 scan_ch
->type
= SCAN_CHANNEL_TYPE_PASSIVE
;
220 scan_ch
->active_dwell
= cpu_to_le16(active_dwell
);
221 scan_ch
->passive_dwell
= cpu_to_le16(passive_dwell
);
222 /* Set txpower levels to defaults */
223 scan_ch
->dsp_atten
= 110;
224 if (band
== IEEE80211_BAND_5GHZ
)
225 scan_ch
->tx_gain
= ((1 << 5) | (3 << 3)) | 3;
227 scan_ch
->tx_gain
= ((1 << 5) | (5 << 3));
230 IWL_ERR(priv
, "no valid channel found\n");
234 static int iwl_get_channels_for_scan(struct iwl_priv
*priv
,
235 struct ieee80211_vif
*vif
,
236 enum ieee80211_band band
,
237 u8 is_active
, u8 n_probes
,
238 struct iwl_scan_channel
*scan_ch
)
240 struct ieee80211_channel
*chan
;
241 const struct ieee80211_supported_band
*sband
;
242 const struct iwl_channel_info
*ch_info
;
243 u16 passive_dwell
= 0;
244 u16 active_dwell
= 0;
248 sband
= iwl_get_hw_mode(priv
, band
);
252 active_dwell
= iwl_get_active_dwell_time(priv
, band
, n_probes
);
253 passive_dwell
= iwl_get_passive_dwell_time(priv
, band
, vif
);
255 if (passive_dwell
<= active_dwell
)
256 passive_dwell
= active_dwell
+ 1;
258 for (i
= 0, added
= 0; i
< priv
->scan_request
->n_channels
; i
++) {
259 chan
= priv
->scan_request
->channels
[i
];
261 if (chan
->band
!= band
)
264 channel
= chan
->hw_value
;
265 scan_ch
->channel
= cpu_to_le16(channel
);
267 ch_info
= iwl_get_channel_info(priv
, band
, channel
);
268 if (!is_channel_valid(ch_info
)) {
269 IWL_DEBUG_SCAN(priv
, "Channel %d is INVALID for this band.\n",
274 if (!is_active
|| is_channel_passive(ch_info
) ||
275 (chan
->flags
& IEEE80211_CHAN_PASSIVE_SCAN
))
276 scan_ch
->type
= SCAN_CHANNEL_TYPE_PASSIVE
;
278 scan_ch
->type
= SCAN_CHANNEL_TYPE_ACTIVE
;
281 scan_ch
->type
|= IWL_SCAN_PROBE_MASK(n_probes
);
283 scan_ch
->active_dwell
= cpu_to_le16(active_dwell
);
284 scan_ch
->passive_dwell
= cpu_to_le16(passive_dwell
);
286 /* Set txpower levels to defaults */
287 scan_ch
->dsp_atten
= 110;
289 /* NOTE: if we were doing 6Mb OFDM for scans we'd use
291 * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
293 if (band
== IEEE80211_BAND_5GHZ
)
294 scan_ch
->tx_gain
= ((1 << 5) | (3 << 3)) | 3;
296 scan_ch
->tx_gain
= ((1 << 5) | (5 << 3));
298 IWL_DEBUG_SCAN(priv
, "Scanning ch=%d prob=0x%X [%s %d]\n",
299 channel
, le32_to_cpu(scan_ch
->type
),
300 (scan_ch
->type
& SCAN_CHANNEL_TYPE_ACTIVE
) ?
301 "ACTIVE" : "PASSIVE",
302 (scan_ch
->type
& SCAN_CHANNEL_TYPE_ACTIVE
) ?
303 active_dwell
: passive_dwell
);
309 IWL_DEBUG_SCAN(priv
, "total channels to scan %d\n", added
);
313 int iwlagn_request_scan(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
)
315 struct iwl_host_cmd cmd
= {
316 .id
= REPLY_SCAN_CMD
,
317 .len
= { sizeof(struct iwl_scan_cmd
), },
320 struct iwl_scan_cmd
*scan
;
321 struct iwl_rxon_context
*ctx
= &priv
->contexts
[IWL_RXON_CTX_BSS
];
325 enum ieee80211_band band
;
327 u8 rx_ant
= hw_params(priv
).valid_rx_ant
;
329 bool is_active
= false;
332 u8 scan_tx_antennas
= hw_params(priv
).valid_tx_ant
;
335 lockdep_assert_held(&priv
->shrd
->mutex
);
338 ctx
= iwl_rxon_ctx_from_vif(vif
);
340 if (!priv
->scan_cmd
) {
341 priv
->scan_cmd
= kmalloc(sizeof(struct iwl_scan_cmd
) +
342 IWL_MAX_SCAN_SIZE
, GFP_KERNEL
);
343 if (!priv
->scan_cmd
) {
345 "fail to allocate memory for scan\n");
349 scan
= priv
->scan_cmd
;
350 memset(scan
, 0, sizeof(struct iwl_scan_cmd
) + IWL_MAX_SCAN_SIZE
);
352 scan
->quiet_plcp_th
= IWL_PLCP_QUIET_THRESH
;
353 scan
->quiet_time
= IWL_ACTIVE_QUIET_TIME
;
355 if (priv
->scan_type
!= IWL_SCAN_ROC
&&
356 iwl_is_any_associated(priv
)) {
359 u32 suspend_time
= 100;
360 u32 scan_suspend_time
= 100;
362 IWL_DEBUG_INFO(priv
, "Scanning while associated...\n");
363 switch (priv
->scan_type
) {
367 case IWL_SCAN_RADIO_RESET
:
370 case IWL_SCAN_NORMAL
:
371 interval
= vif
->bss_conf
.beacon_int
;
375 scan
->suspend_time
= 0;
376 scan
->max_out_time
= cpu_to_le32(200 * 1024);
378 interval
= suspend_time
;
380 extra
= (suspend_time
/ interval
) << 22;
381 scan_suspend_time
= (extra
|
382 ((suspend_time
% interval
) * 1024));
383 scan
->suspend_time
= cpu_to_le32(scan_suspend_time
);
384 IWL_DEBUG_SCAN(priv
, "suspend_time 0x%X beacon interval %d\n",
385 scan_suspend_time
, interval
);
386 } else if (priv
->scan_type
== IWL_SCAN_ROC
) {
387 scan
->suspend_time
= 0;
388 scan
->max_out_time
= 0;
389 scan
->quiet_time
= 0;
390 scan
->quiet_plcp_th
= 0;
393 switch (priv
->scan_type
) {
394 case IWL_SCAN_RADIO_RESET
:
395 IWL_DEBUG_SCAN(priv
, "Start internal passive scan.\n");
397 case IWL_SCAN_NORMAL
:
398 if (priv
->scan_request
->n_ssids
) {
400 IWL_DEBUG_SCAN(priv
, "Kicking off active scan\n");
401 for (i
= 0; i
< priv
->scan_request
->n_ssids
; i
++) {
402 /* always does wildcard anyway */
403 if (!priv
->scan_request
->ssids
[i
].ssid_len
)
405 scan
->direct_scan
[p
].id
= WLAN_EID_SSID
;
406 scan
->direct_scan
[p
].len
=
407 priv
->scan_request
->ssids
[i
].ssid_len
;
408 memcpy(scan
->direct_scan
[p
].ssid
,
409 priv
->scan_request
->ssids
[i
].ssid
,
410 priv
->scan_request
->ssids
[i
].ssid_len
);
416 IWL_DEBUG_SCAN(priv
, "Start passive scan.\n");
419 IWL_DEBUG_SCAN(priv
, "Start ROC scan.\n");
423 scan
->tx_cmd
.tx_flags
= TX_CMD_FLG_SEQ_CTL_MSK
;
424 scan
->tx_cmd
.sta_id
= ctx
->bcast_sta_id
;
425 scan
->tx_cmd
.stop_time
.life_time
= TX_CMD_LIFE_TIME_INFINITE
;
427 switch (priv
->scan_band
) {
428 case IEEE80211_BAND_2GHZ
:
429 scan
->flags
= RXON_FLG_BAND_24G_MSK
| RXON_FLG_AUTO_DETECT_MSK
;
430 chan_mod
= le32_to_cpu(
431 priv
->contexts
[IWL_RXON_CTX_BSS
].active
.flags
&
432 RXON_FLG_CHANNEL_MODE_MSK
)
433 >> RXON_FLG_CHANNEL_MODE_POS
;
434 if (chan_mod
== CHANNEL_MODE_PURE_40
) {
435 rate
= IWL_RATE_6M_PLCP
;
437 rate
= IWL_RATE_1M_PLCP
;
438 rate_flags
= RATE_MCS_CCK_MSK
;
441 * Internal scans are passive, so we can indiscriminately set
442 * the BT ignore flag on 2.4 GHz since it applies to TX only.
444 if (priv
->cfg
->bt_params
&&
445 priv
->cfg
->bt_params
->advanced_bt_coexist
)
446 scan
->tx_cmd
.tx_flags
|= TX_CMD_FLG_IGNORE_BT
;
448 case IEEE80211_BAND_5GHZ
:
449 rate
= IWL_RATE_6M_PLCP
;
452 IWL_WARN(priv
, "Invalid scan band\n");
457 * If active scanning is requested but a certain channel is
458 * marked passive, we can do active scanning if we detect
461 * There is an issue with some firmware versions that triggers
462 * a sysassert on a "good CRC threshold" of zero (== disabled),
463 * on a radar channel even though this means that we should NOT
466 * The "good CRC threshold" is the number of frames that we
467 * need to receive during our dwell time on a channel before
468 * sending out probes -- setting this to a huge value will
469 * mean we never reach it, but at the same time work around
470 * the aforementioned issue. Thus use IWL_GOOD_CRC_TH_NEVER
471 * here instead of IWL_GOOD_CRC_TH_DISABLED.
473 * This was fixed in later versions along with some other
474 * scan changes, and the threshold behaves as a flag in those
477 if (priv
->new_scan_threshold_behaviour
)
478 scan
->good_CRC_th
= is_active
? IWL_GOOD_CRC_TH_DEFAULT
:
479 IWL_GOOD_CRC_TH_DISABLED
;
481 scan
->good_CRC_th
= is_active
? IWL_GOOD_CRC_TH_DEFAULT
:
482 IWL_GOOD_CRC_TH_NEVER
;
484 band
= priv
->scan_band
;
486 if (priv
->cfg
->scan_rx_antennas
[band
])
487 rx_ant
= priv
->cfg
->scan_rx_antennas
[band
];
489 if (band
== IEEE80211_BAND_2GHZ
&&
490 priv
->cfg
->bt_params
&&
491 priv
->cfg
->bt_params
->advanced_bt_coexist
) {
492 /* transmit 2.4 GHz probes only on first antenna */
493 scan_tx_antennas
= first_antenna(scan_tx_antennas
);
496 priv
->scan_tx_ant
[band
] = iwl_toggle_tx_ant(priv
, priv
->scan_tx_ant
[band
],
498 rate_flags
|= iwl_ant_idx_to_flags(priv
->scan_tx_ant
[band
]);
499 scan
->tx_cmd
.rate_n_flags
= iwl_hw_set_rate_n_flags(rate
, rate_flags
);
501 /* In power save mode use one chain, otherwise use all chains */
502 if (test_bit(STATUS_POWER_PMI
, &priv
->shrd
->status
)) {
503 /* rx_ant has been set to all valid chains previously */
504 active_chains
= rx_ant
&
505 ((u8
)(priv
->chain_noise_data
.active_chains
));
507 active_chains
= rx_ant
;
509 IWL_DEBUG_SCAN(priv
, "chain_noise_data.active_chains: %u\n",
510 priv
->chain_noise_data
.active_chains
);
512 rx_ant
= first_antenna(active_chains
);
514 if (priv
->cfg
->bt_params
&&
515 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
516 priv
->bt_full_concurrent
) {
517 /* operated as 1x1 in full concurrency mode */
518 rx_ant
= first_antenna(rx_ant
);
521 /* MIMO is not used here, but value is required */
523 hw_params(priv
).valid_rx_ant
<< RXON_RX_CHAIN_VALID_POS
;
524 rx_chain
|= rx_ant
<< RXON_RX_CHAIN_FORCE_MIMO_SEL_POS
;
525 rx_chain
|= rx_ant
<< RXON_RX_CHAIN_FORCE_SEL_POS
;
526 rx_chain
|= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS
;
527 scan
->rx_chain
= cpu_to_le16(rx_chain
);
528 switch (priv
->scan_type
) {
529 case IWL_SCAN_NORMAL
:
530 cmd_len
= iwl_fill_probe_req(priv
,
531 (struct ieee80211_mgmt
*)scan
->data
,
533 priv
->scan_request
->ie
,
534 priv
->scan_request
->ie_len
,
535 IWL_MAX_SCAN_SIZE
- sizeof(*scan
));
537 case IWL_SCAN_RADIO_RESET
:
539 /* use bcast addr, will not be transmitted but must be valid */
540 cmd_len
= iwl_fill_probe_req(priv
,
541 (struct ieee80211_mgmt
*)scan
->data
,
542 iwl_bcast_addr
, NULL
, 0,
543 IWL_MAX_SCAN_SIZE
- sizeof(*scan
));
548 scan
->tx_cmd
.len
= cpu_to_le16(cmd_len
);
550 scan
->filter_flags
|= (RXON_FILTER_ACCEPT_GRP_MSK
|
551 RXON_FILTER_BCON_AWARE_MSK
);
553 switch (priv
->scan_type
) {
554 case IWL_SCAN_RADIO_RESET
:
555 scan
->channel_count
=
556 iwl_get_single_channel_for_scan(priv
, vif
, band
,
557 (void *)&scan
->data
[cmd_len
]);
559 case IWL_SCAN_NORMAL
:
560 scan
->channel_count
=
561 iwl_get_channels_for_scan(priv
, vif
, band
,
563 (void *)&scan
->data
[cmd_len
]);
566 struct iwl_scan_channel
*scan_ch
;
568 scan
->channel_count
= 1;
570 scan_ch
= (void *)&scan
->data
[cmd_len
];
571 scan_ch
->type
= SCAN_CHANNEL_TYPE_PASSIVE
;
573 cpu_to_le16(priv
->hw_roc_channel
->hw_value
);
574 scan_ch
->active_dwell
=
575 scan_ch
->passive_dwell
=
576 cpu_to_le16(priv
->hw_roc_duration
);
578 /* Set txpower levels to defaults */
579 scan_ch
->dsp_atten
= 110;
581 /* NOTE: if we were doing 6Mb OFDM for scans we'd use
583 * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
585 if (priv
->hw_roc_channel
->band
== IEEE80211_BAND_5GHZ
)
586 scan_ch
->tx_gain
= ((1 << 5) | (3 << 3)) | 3;
588 scan_ch
->tx_gain
= ((1 << 5) | (5 << 3));
593 if (scan
->channel_count
== 0) {
594 IWL_DEBUG_SCAN(priv
, "channel count %d\n", scan
->channel_count
);
598 cmd
.len
[0] += le16_to_cpu(scan
->tx_cmd
.len
) +
599 scan
->channel_count
* sizeof(struct iwl_scan_channel
);
601 cmd
.dataflags
[0] = IWL_HCMD_DFL_NOCOPY
;
602 scan
->len
= cpu_to_le16(cmd
.len
[0]);
604 /* set scan bit here for PAN params */
605 set_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
607 ret
= iwlagn_set_pan_params(priv
);
611 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
613 clear_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
614 iwlagn_set_pan_params(priv
);
620 int iwlagn_manage_ibss_station(struct iwl_priv
*priv
,
621 struct ieee80211_vif
*vif
, bool add
)
623 struct iwl_vif_priv
*vif_priv
= (void *)vif
->drv_priv
;
626 return iwlagn_add_bssid_station(priv
, vif_priv
->ctx
,
628 &vif_priv
->ibss_bssid_sta_id
);
629 return iwl_remove_station(priv
, vif_priv
->ibss_bssid_sta_id
,
630 vif
->bss_conf
.bssid
);
634 * iwlagn_txfifo_flush: send REPLY_TXFIFO_FLUSH command to uCode
637 * 1. acquire mutex before calling
638 * 2. make sure rf is on and not in exit state
640 int iwlagn_txfifo_flush(struct iwl_priv
*priv
, u16 flush_control
)
642 struct iwl_txfifo_flush_cmd flush_cmd
;
643 struct iwl_host_cmd cmd
= {
644 .id
= REPLY_TXFIFO_FLUSH
,
645 .len
= { sizeof(struct iwl_txfifo_flush_cmd
), },
647 .data
= { &flush_cmd
, },
652 memset(&flush_cmd
, 0, sizeof(flush_cmd
));
653 if (flush_control
& BIT(IWL_RXON_CTX_BSS
))
654 flush_cmd
.fifo_control
= IWL_SCD_VO_MSK
| IWL_SCD_VI_MSK
|
655 IWL_SCD_BE_MSK
| IWL_SCD_BK_MSK
|
657 if ((flush_control
& BIT(IWL_RXON_CTX_PAN
)) &&
658 (priv
->shrd
->valid_contexts
!= BIT(IWL_RXON_CTX_BSS
)))
659 flush_cmd
.fifo_control
|= IWL_PAN_SCD_VO_MSK
|
660 IWL_PAN_SCD_VI_MSK
| IWL_PAN_SCD_BE_MSK
|
661 IWL_PAN_SCD_BK_MSK
| IWL_PAN_SCD_MGMT_MSK
|
662 IWL_PAN_SCD_MULTICAST_MSK
;
664 if (priv
->cfg
->sku
& EEPROM_SKU_CAP_11N_ENABLE
)
665 flush_cmd
.fifo_control
|= IWL_AGG_TX_QUEUE_MSK
;
667 IWL_DEBUG_INFO(priv
, "fifo queue control: 0X%x\n",
668 flush_cmd
.fifo_control
);
669 flush_cmd
.flush_control
= cpu_to_le16(flush_control
);
671 return iwl_trans_send_cmd(trans(priv
), &cmd
);
674 void iwlagn_dev_txfifo_flush(struct iwl_priv
*priv
, u16 flush_control
)
676 mutex_lock(&priv
->shrd
->mutex
);
677 ieee80211_stop_queues(priv
->hw
);
678 if (iwlagn_txfifo_flush(priv
, IWL_DROP_ALL
)) {
679 IWL_ERR(priv
, "flush request fail\n");
682 IWL_DEBUG_INFO(priv
, "wait transmit/flush all frames\n");
683 iwl_trans_wait_tx_queue_empty(trans(priv
));
685 ieee80211_wake_queues(priv
->hw
);
686 mutex_unlock(&priv
->shrd
->mutex
);
693 * Macros to access the lookup table.
695 * The lookup table has 7 inputs: bt3_prio, bt3_txrx, bt_rf_act, wifi_req,
696 * wifi_prio, wifi_txrx and wifi_sh_ant_req.
698 * It has three outputs: WLAN_ACTIVE, WLAN_KILL and ANT_SWITCH
700 * The format is that "registers" 8 through 11 contain the WLAN_ACTIVE bits
701 * one after another in 32-bit registers, and "registers" 0 through 7 contain
702 * the WLAN_KILL and ANT_SWITCH bits interleaved (in that order).
704 * These macros encode that format.
706 #define LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, wifi_req, wifi_prio, \
707 wifi_txrx, wifi_sh_ant_req) \
708 (bt3_prio | (bt3_txrx << 1) | (bt_rf_act << 2) | (wifi_req << 3) | \
709 (wifi_prio << 4) | (wifi_txrx << 5) | (wifi_sh_ant_req << 6))
711 #define LUT_PTA_WLAN_ACTIVE_OP(lut, op, val) \
712 lut[8 + ((val) >> 5)] op (cpu_to_le32(BIT((val) & 0x1f)))
713 #define LUT_TEST_PTA_WLAN_ACTIVE(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
714 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
715 (!!(LUT_PTA_WLAN_ACTIVE_OP(lut, &, LUT_VALUE(bt3_prio, bt3_txrx, \
716 bt_rf_act, wifi_req, wifi_prio, wifi_txrx, \
718 #define LUT_SET_PTA_WLAN_ACTIVE(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
719 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
720 LUT_PTA_WLAN_ACTIVE_OP(lut, |=, LUT_VALUE(bt3_prio, bt3_txrx, \
721 bt_rf_act, wifi_req, wifi_prio, wifi_txrx, \
723 #define LUT_CLEAR_PTA_WLAN_ACTIVE(lut, bt3_prio, bt3_txrx, bt_rf_act, \
724 wifi_req, wifi_prio, wifi_txrx, \
726 LUT_PTA_WLAN_ACTIVE_OP(lut, &= ~, LUT_VALUE(bt3_prio, bt3_txrx, \
727 bt_rf_act, wifi_req, wifi_prio, wifi_txrx, \
730 #define LUT_WLAN_KILL_OP(lut, op, val) \
731 lut[(val) >> 4] op (cpu_to_le32(BIT(((val) << 1) & 0x1e)))
732 #define LUT_TEST_WLAN_KILL(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
733 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
734 (!!(LUT_WLAN_KILL_OP(lut, &, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
735 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))))
736 #define LUT_SET_WLAN_KILL(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
737 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
738 LUT_WLAN_KILL_OP(lut, |=, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
739 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
740 #define LUT_CLEAR_WLAN_KILL(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
741 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
742 LUT_WLAN_KILL_OP(lut, &= ~, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
743 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
745 #define LUT_ANT_SWITCH_OP(lut, op, val) \
746 lut[(val) >> 4] op (cpu_to_le32(BIT((((val) << 1) & 0x1e) + 1)))
747 #define LUT_TEST_ANT_SWITCH(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
748 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
749 (!!(LUT_ANT_SWITCH_OP(lut, &, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
750 wifi_req, wifi_prio, wifi_txrx, \
752 #define LUT_SET_ANT_SWITCH(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
753 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
754 LUT_ANT_SWITCH_OP(lut, |=, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
755 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
756 #define LUT_CLEAR_ANT_SWITCH(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
757 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
758 LUT_ANT_SWITCH_OP(lut, &= ~, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
759 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
761 static const __le32 iwlagn_def_3w_lookup
[12] = {
762 cpu_to_le32(0xaaaaaaaa),
763 cpu_to_le32(0xaaaaaaaa),
764 cpu_to_le32(0xaeaaaaaa),
765 cpu_to_le32(0xaaaaaaaa),
766 cpu_to_le32(0xcc00ff28),
767 cpu_to_le32(0x0000aaaa),
768 cpu_to_le32(0xcc00aaaa),
769 cpu_to_le32(0x0000aaaa),
770 cpu_to_le32(0xc0004000),
771 cpu_to_le32(0x00004000),
772 cpu_to_le32(0xf0005000),
773 cpu_to_le32(0xf0005000),
776 static const __le32 iwlagn_concurrent_lookup
[12] = {
777 cpu_to_le32(0xaaaaaaaa),
778 cpu_to_le32(0xaaaaaaaa),
779 cpu_to_le32(0xaaaaaaaa),
780 cpu_to_le32(0xaaaaaaaa),
781 cpu_to_le32(0xaaaaaaaa),
782 cpu_to_le32(0xaaaaaaaa),
783 cpu_to_le32(0xaaaaaaaa),
784 cpu_to_le32(0xaaaaaaaa),
785 cpu_to_le32(0x00000000),
786 cpu_to_le32(0x00000000),
787 cpu_to_le32(0x00000000),
788 cpu_to_le32(0x00000000),
791 void iwlagn_send_advance_bt_config(struct iwl_priv
*priv
)
793 struct iwl_basic_bt_cmd basic
= {
794 .max_kill
= IWLAGN_BT_MAX_KILL_DEFAULT
,
795 .bt3_timer_t7_value
= IWLAGN_BT3_T7_DEFAULT
,
796 .bt3_prio_sample_time
= IWLAGN_BT3_PRIO_SAMPLE_DEFAULT
,
797 .bt3_timer_t2_value
= IWLAGN_BT3_T2_DEFAULT
,
799 struct iwl6000_bt_cmd bt_cmd_6000
;
800 struct iwl2000_bt_cmd bt_cmd_2000
;
803 BUILD_BUG_ON(sizeof(iwlagn_def_3w_lookup
) !=
804 sizeof(basic
.bt3_lookup_table
));
806 if (priv
->cfg
->bt_params
) {
807 if (priv
->cfg
->bt_params
->bt_session_2
) {
808 bt_cmd_2000
.prio_boost
= cpu_to_le32(
809 priv
->cfg
->bt_params
->bt_prio_boost
);
810 bt_cmd_2000
.tx_prio_boost
= 0;
811 bt_cmd_2000
.rx_prio_boost
= 0;
813 bt_cmd_6000
.prio_boost
=
814 priv
->cfg
->bt_params
->bt_prio_boost
;
815 bt_cmd_6000
.tx_prio_boost
= 0;
816 bt_cmd_6000
.rx_prio_boost
= 0;
819 IWL_ERR(priv
, "failed to construct BT Coex Config\n");
823 basic
.kill_ack_mask
= priv
->kill_ack_mask
;
824 basic
.kill_cts_mask
= priv
->kill_cts_mask
;
825 basic
.valid
= priv
->bt_valid
;
828 * Configure BT coex mode to "no coexistence" when the
829 * user disabled BT coexistence, we have no interface
830 * (might be in monitor mode), or the interface is in
831 * IBSS mode (no proper uCode support for coex then).
833 if (!iwlagn_mod_params
.bt_coex_active
||
834 priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) {
835 basic
.flags
= IWLAGN_BT_FLAG_COEX_MODE_DISABLED
;
837 basic
.flags
= IWLAGN_BT_FLAG_COEX_MODE_3W
<<
838 IWLAGN_BT_FLAG_COEX_MODE_SHIFT
;
840 if (!priv
->bt_enable_pspoll
)
841 basic
.flags
|= IWLAGN_BT_FLAG_SYNC_2_BT_DISABLE
;
843 basic
.flags
&= ~IWLAGN_BT_FLAG_SYNC_2_BT_DISABLE
;
845 if (priv
->bt_ch_announce
)
846 basic
.flags
|= IWLAGN_BT_FLAG_CHANNEL_INHIBITION
;
847 IWL_DEBUG_COEX(priv
, "BT coex flag: 0X%x\n", basic
.flags
);
849 priv
->bt_enable_flag
= basic
.flags
;
850 if (priv
->bt_full_concurrent
)
851 memcpy(basic
.bt3_lookup_table
, iwlagn_concurrent_lookup
,
852 sizeof(iwlagn_concurrent_lookup
));
854 memcpy(basic
.bt3_lookup_table
, iwlagn_def_3w_lookup
,
855 sizeof(iwlagn_def_3w_lookup
));
857 IWL_DEBUG_COEX(priv
, "BT coex %s in %s mode\n",
858 basic
.flags
? "active" : "disabled",
859 priv
->bt_full_concurrent
?
860 "full concurrency" : "3-wire");
862 if (priv
->cfg
->bt_params
->bt_session_2
) {
863 memcpy(&bt_cmd_2000
.basic
, &basic
,
865 ret
= iwl_trans_send_cmd_pdu(trans(priv
), REPLY_BT_CONFIG
,
866 CMD_SYNC
, sizeof(bt_cmd_2000
), &bt_cmd_2000
);
868 memcpy(&bt_cmd_6000
.basic
, &basic
,
870 ret
= iwl_trans_send_cmd_pdu(trans(priv
), REPLY_BT_CONFIG
,
871 CMD_SYNC
, sizeof(bt_cmd_6000
), &bt_cmd_6000
);
874 IWL_ERR(priv
, "failed to send BT Coex Config\n");
878 void iwlagn_bt_adjust_rssi_monitor(struct iwl_priv
*priv
, bool rssi_ena
)
880 struct iwl_rxon_context
*ctx
, *found_ctx
= NULL
;
881 bool found_ap
= false;
883 lockdep_assert_held(&priv
->shrd
->mutex
);
885 /* Check whether AP or GO mode is active. */
887 for_each_context(priv
, ctx
) {
888 if (ctx
->vif
&& ctx
->vif
->type
== NL80211_IFTYPE_AP
&&
889 iwl_is_associated_ctx(ctx
)) {
897 * If disable was received or If GO/AP mode, disable RSSI
900 if (!rssi_ena
|| found_ap
) {
901 if (priv
->cur_rssi_ctx
) {
902 ctx
= priv
->cur_rssi_ctx
;
903 ieee80211_disable_rssi_reports(ctx
->vif
);
904 priv
->cur_rssi_ctx
= NULL
;
910 * If rssi measurements need to be enabled, consider all cases now.
911 * Figure out how many contexts are active.
913 for_each_context(priv
, ctx
) {
914 if (ctx
->vif
&& ctx
->vif
->type
== NL80211_IFTYPE_STATION
&&
915 iwl_is_associated_ctx(ctx
)) {
922 * rssi monitor already enabled for the correct interface...nothing
925 if (found_ctx
== priv
->cur_rssi_ctx
)
929 * Figure out if rssi monitor is currently enabled, and needs
930 * to be changed. If rssi monitor is already enabled, disable
931 * it first else just enable rssi measurements on the
932 * interface found above.
934 if (priv
->cur_rssi_ctx
) {
935 ctx
= priv
->cur_rssi_ctx
;
937 ieee80211_disable_rssi_reports(ctx
->vif
);
940 priv
->cur_rssi_ctx
= found_ctx
;
945 ieee80211_enable_rssi_reports(found_ctx
->vif
,
946 IWLAGN_BT_PSP_MIN_RSSI_THRESHOLD
,
947 IWLAGN_BT_PSP_MAX_RSSI_THRESHOLD
);
950 static bool iwlagn_bt_traffic_is_sco(struct iwl_bt_uart_msg
*uart_msg
)
952 return BT_UART_MSG_FRAME3SCOESCO_MSK
& uart_msg
->frame3
>>
953 BT_UART_MSG_FRAME3SCOESCO_POS
;
956 static void iwlagn_bt_traffic_change_work(struct work_struct
*work
)
958 struct iwl_priv
*priv
=
959 container_of(work
, struct iwl_priv
, bt_traffic_change_work
);
960 struct iwl_rxon_context
*ctx
;
961 int smps_request
= -1;
963 if (priv
->bt_enable_flag
== IWLAGN_BT_FLAG_COEX_MODE_DISABLED
) {
964 /* bt coex disabled */
969 * Note: bt_traffic_load can be overridden by scan complete and
970 * coex profile notifications. Ignore that since only bad consequence
971 * can be not matching debug print with actual state.
973 IWL_DEBUG_COEX(priv
, "BT traffic load changes: %d\n",
974 priv
->bt_traffic_load
);
976 switch (priv
->bt_traffic_load
) {
977 case IWL_BT_COEX_TRAFFIC_LOAD_NONE
:
979 smps_request
= IEEE80211_SMPS_DYNAMIC
;
981 smps_request
= IEEE80211_SMPS_AUTOMATIC
;
983 case IWL_BT_COEX_TRAFFIC_LOAD_LOW
:
984 smps_request
= IEEE80211_SMPS_DYNAMIC
;
986 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH
:
987 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS
:
988 smps_request
= IEEE80211_SMPS_STATIC
;
991 IWL_ERR(priv
, "Invalid BT traffic load: %d\n",
992 priv
->bt_traffic_load
);
996 mutex_lock(&priv
->shrd
->mutex
);
999 * We can not send command to firmware while scanning. When the scan
1000 * complete we will schedule this work again. We do check with mutex
1001 * locked to prevent new scan request to arrive. We do not check
1002 * STATUS_SCANNING to avoid race when queue_work two times from
1003 * different notifications, but quit and not perform any work at all.
1005 if (test_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
))
1008 iwl_update_chain_flags(priv
);
1010 if (smps_request
!= -1) {
1011 priv
->current_ht_config
.smps
= smps_request
;
1012 for_each_context(priv
, ctx
) {
1013 if (ctx
->vif
&& ctx
->vif
->type
== NL80211_IFTYPE_STATION
)
1014 ieee80211_request_smps(ctx
->vif
, smps_request
);
1019 * Dynamic PS poll related functionality. Adjust RSSI measurements if
1022 iwlagn_bt_coex_rssi_monitor(priv
);
1024 mutex_unlock(&priv
->shrd
->mutex
);
1028 * If BT sco traffic, and RSSI monitor is enabled, move measurements to the
1029 * correct interface or disable it if this is the last interface to be
1032 void iwlagn_bt_coex_rssi_monitor(struct iwl_priv
*priv
)
1034 if (priv
->bt_is_sco
&&
1035 priv
->bt_traffic_load
== IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS
)
1036 iwlagn_bt_adjust_rssi_monitor(priv
, true);
1038 iwlagn_bt_adjust_rssi_monitor(priv
, false);
1041 static void iwlagn_print_uartmsg(struct iwl_priv
*priv
,
1042 struct iwl_bt_uart_msg
*uart_msg
)
1044 IWL_DEBUG_COEX(priv
, "Message Type = 0x%X, SSN = 0x%X, "
1045 "Update Req = 0x%X",
1046 (BT_UART_MSG_FRAME1MSGTYPE_MSK
& uart_msg
->frame1
) >>
1047 BT_UART_MSG_FRAME1MSGTYPE_POS
,
1048 (BT_UART_MSG_FRAME1SSN_MSK
& uart_msg
->frame1
) >>
1049 BT_UART_MSG_FRAME1SSN_POS
,
1050 (BT_UART_MSG_FRAME1UPDATEREQ_MSK
& uart_msg
->frame1
) >>
1051 BT_UART_MSG_FRAME1UPDATEREQ_POS
);
1053 IWL_DEBUG_COEX(priv
, "Open connections = 0x%X, Traffic load = 0x%X, "
1054 "Chl_SeqN = 0x%X, In band = 0x%X",
1055 (BT_UART_MSG_FRAME2OPENCONNECTIONS_MSK
& uart_msg
->frame2
) >>
1056 BT_UART_MSG_FRAME2OPENCONNECTIONS_POS
,
1057 (BT_UART_MSG_FRAME2TRAFFICLOAD_MSK
& uart_msg
->frame2
) >>
1058 BT_UART_MSG_FRAME2TRAFFICLOAD_POS
,
1059 (BT_UART_MSG_FRAME2CHLSEQN_MSK
& uart_msg
->frame2
) >>
1060 BT_UART_MSG_FRAME2CHLSEQN_POS
,
1061 (BT_UART_MSG_FRAME2INBAND_MSK
& uart_msg
->frame2
) >>
1062 BT_UART_MSG_FRAME2INBAND_POS
);
1064 IWL_DEBUG_COEX(priv
, "SCO/eSCO = 0x%X, Sniff = 0x%X, A2DP = 0x%X, "
1065 "ACL = 0x%X, Master = 0x%X, OBEX = 0x%X",
1066 (BT_UART_MSG_FRAME3SCOESCO_MSK
& uart_msg
->frame3
) >>
1067 BT_UART_MSG_FRAME3SCOESCO_POS
,
1068 (BT_UART_MSG_FRAME3SNIFF_MSK
& uart_msg
->frame3
) >>
1069 BT_UART_MSG_FRAME3SNIFF_POS
,
1070 (BT_UART_MSG_FRAME3A2DP_MSK
& uart_msg
->frame3
) >>
1071 BT_UART_MSG_FRAME3A2DP_POS
,
1072 (BT_UART_MSG_FRAME3ACL_MSK
& uart_msg
->frame3
) >>
1073 BT_UART_MSG_FRAME3ACL_POS
,
1074 (BT_UART_MSG_FRAME3MASTER_MSK
& uart_msg
->frame3
) >>
1075 BT_UART_MSG_FRAME3MASTER_POS
,
1076 (BT_UART_MSG_FRAME3OBEX_MSK
& uart_msg
->frame3
) >>
1077 BT_UART_MSG_FRAME3OBEX_POS
);
1079 IWL_DEBUG_COEX(priv
, "Idle duration = 0x%X",
1080 (BT_UART_MSG_FRAME4IDLEDURATION_MSK
& uart_msg
->frame4
) >>
1081 BT_UART_MSG_FRAME4IDLEDURATION_POS
);
1083 IWL_DEBUG_COEX(priv
, "Tx Activity = 0x%X, Rx Activity = 0x%X, "
1084 "eSCO Retransmissions = 0x%X",
1085 (BT_UART_MSG_FRAME5TXACTIVITY_MSK
& uart_msg
->frame5
) >>
1086 BT_UART_MSG_FRAME5TXACTIVITY_POS
,
1087 (BT_UART_MSG_FRAME5RXACTIVITY_MSK
& uart_msg
->frame5
) >>
1088 BT_UART_MSG_FRAME5RXACTIVITY_POS
,
1089 (BT_UART_MSG_FRAME5ESCORETRANSMIT_MSK
& uart_msg
->frame5
) >>
1090 BT_UART_MSG_FRAME5ESCORETRANSMIT_POS
);
1092 IWL_DEBUG_COEX(priv
, "Sniff Interval = 0x%X, Discoverable = 0x%X",
1093 (BT_UART_MSG_FRAME6SNIFFINTERVAL_MSK
& uart_msg
->frame6
) >>
1094 BT_UART_MSG_FRAME6SNIFFINTERVAL_POS
,
1095 (BT_UART_MSG_FRAME6DISCOVERABLE_MSK
& uart_msg
->frame6
) >>
1096 BT_UART_MSG_FRAME6DISCOVERABLE_POS
);
1098 IWL_DEBUG_COEX(priv
, "Sniff Activity = 0x%X, Page = "
1099 "0x%X, Inquiry = 0x%X, Connectable = 0x%X",
1100 (BT_UART_MSG_FRAME7SNIFFACTIVITY_MSK
& uart_msg
->frame7
) >>
1101 BT_UART_MSG_FRAME7SNIFFACTIVITY_POS
,
1102 (BT_UART_MSG_FRAME7PAGE_MSK
& uart_msg
->frame7
) >>
1103 BT_UART_MSG_FRAME7PAGE_POS
,
1104 (BT_UART_MSG_FRAME7INQUIRY_MSK
& uart_msg
->frame7
) >>
1105 BT_UART_MSG_FRAME7INQUIRY_POS
,
1106 (BT_UART_MSG_FRAME7CONNECTABLE_MSK
& uart_msg
->frame7
) >>
1107 BT_UART_MSG_FRAME7CONNECTABLE_POS
);
1110 static void iwlagn_set_kill_msk(struct iwl_priv
*priv
,
1111 struct iwl_bt_uart_msg
*uart_msg
)
1114 static const __le32 bt_kill_ack_msg
[2] = {
1115 IWLAGN_BT_KILL_ACK_MASK_DEFAULT
,
1116 IWLAGN_BT_KILL_ACK_CTS_MASK_SCO
};
1117 static const __le32 bt_kill_cts_msg
[2] = {
1118 IWLAGN_BT_KILL_CTS_MASK_DEFAULT
,
1119 IWLAGN_BT_KILL_ACK_CTS_MASK_SCO
};
1121 kill_msk
= (BT_UART_MSG_FRAME3SCOESCO_MSK
& uart_msg
->frame3
)
1123 if (priv
->kill_ack_mask
!= bt_kill_ack_msg
[kill_msk
] ||
1124 priv
->kill_cts_mask
!= bt_kill_cts_msg
[kill_msk
]) {
1125 priv
->bt_valid
|= IWLAGN_BT_VALID_KILL_ACK_MASK
;
1126 priv
->kill_ack_mask
= bt_kill_ack_msg
[kill_msk
];
1127 priv
->bt_valid
|= IWLAGN_BT_VALID_KILL_CTS_MASK
;
1128 priv
->kill_cts_mask
= bt_kill_cts_msg
[kill_msk
];
1130 /* schedule to send runtime bt_config */
1131 queue_work(priv
->shrd
->workqueue
, &priv
->bt_runtime_config
);
1135 void iwlagn_bt_coex_profile_notif(struct iwl_priv
*priv
,
1136 struct iwl_rx_mem_buffer
*rxb
)
1138 unsigned long flags
;
1139 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
1140 struct iwl_bt_coex_profile_notif
*coex
= &pkt
->u
.bt_coex_profile_notif
;
1141 struct iwl_bt_uart_msg
*uart_msg
= &coex
->last_bt_uart_msg
;
1143 if (priv
->bt_enable_flag
== IWLAGN_BT_FLAG_COEX_MODE_DISABLED
) {
1144 /* bt coex disabled */
1148 IWL_DEBUG_COEX(priv
, "BT Coex notification:\n");
1149 IWL_DEBUG_COEX(priv
, " status: %d\n", coex
->bt_status
);
1150 IWL_DEBUG_COEX(priv
, " traffic load: %d\n", coex
->bt_traffic_load
);
1151 IWL_DEBUG_COEX(priv
, " CI compliance: %d\n",
1152 coex
->bt_ci_compliance
);
1153 iwlagn_print_uartmsg(priv
, uart_msg
);
1155 priv
->last_bt_traffic_load
= priv
->bt_traffic_load
;
1156 priv
->bt_is_sco
= iwlagn_bt_traffic_is_sco(uart_msg
);
1158 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
) {
1159 if (priv
->bt_status
!= coex
->bt_status
||
1160 priv
->last_bt_traffic_load
!= coex
->bt_traffic_load
) {
1161 if (coex
->bt_status
) {
1163 if (!priv
->bt_ch_announce
)
1164 priv
->bt_traffic_load
=
1165 IWL_BT_COEX_TRAFFIC_LOAD_HIGH
;
1167 priv
->bt_traffic_load
=
1168 coex
->bt_traffic_load
;
1171 priv
->bt_traffic_load
=
1172 IWL_BT_COEX_TRAFFIC_LOAD_NONE
;
1174 priv
->bt_status
= coex
->bt_status
;
1175 queue_work(priv
->shrd
->workqueue
,
1176 &priv
->bt_traffic_change_work
);
1180 iwlagn_set_kill_msk(priv
, uart_msg
);
1182 /* FIXME: based on notification, adjust the prio_boost */
1184 spin_lock_irqsave(&priv
->shrd
->lock
, flags
);
1185 priv
->bt_ci_compliance
= coex
->bt_ci_compliance
;
1186 spin_unlock_irqrestore(&priv
->shrd
->lock
, flags
);
1189 void iwlagn_bt_rx_handler_setup(struct iwl_priv
*priv
)
1191 priv
->rx_handlers
[REPLY_BT_COEX_PROFILE_NOTIF
] =
1192 iwlagn_bt_coex_profile_notif
;
1195 void iwlagn_bt_setup_deferred_work(struct iwl_priv
*priv
)
1197 INIT_WORK(&priv
->bt_traffic_change_work
,
1198 iwlagn_bt_traffic_change_work
);
1201 void iwlagn_bt_cancel_deferred_work(struct iwl_priv
*priv
)
1203 cancel_work_sync(&priv
->bt_traffic_change_work
);
1206 static bool is_single_rx_stream(struct iwl_priv
*priv
)
1208 return priv
->current_ht_config
.smps
== IEEE80211_SMPS_STATIC
||
1209 priv
->current_ht_config
.single_chain_sufficient
;
1212 #define IWL_NUM_RX_CHAINS_MULTIPLE 3
1213 #define IWL_NUM_RX_CHAINS_SINGLE 2
1214 #define IWL_NUM_IDLE_CHAINS_DUAL 2
1215 #define IWL_NUM_IDLE_CHAINS_SINGLE 1
1218 * Determine how many receiver/antenna chains to use.
1220 * More provides better reception via diversity. Fewer saves power
1221 * at the expense of throughput, but only when not in powersave to
1224 * MIMO (dual stream) requires at least 2, but works better with 3.
1225 * This does not determine *which* chains to use, just how many.
1227 static int iwl_get_active_rx_chain_count(struct iwl_priv
*priv
)
1229 if (priv
->cfg
->bt_params
&&
1230 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
1231 (priv
->bt_full_concurrent
||
1232 priv
->bt_traffic_load
>= IWL_BT_COEX_TRAFFIC_LOAD_HIGH
)) {
1234 * only use chain 'A' in bt high traffic load or
1235 * full concurrency mode
1237 return IWL_NUM_RX_CHAINS_SINGLE
;
1239 /* # of Rx chains to use when expecting MIMO. */
1240 if (is_single_rx_stream(priv
))
1241 return IWL_NUM_RX_CHAINS_SINGLE
;
1243 return IWL_NUM_RX_CHAINS_MULTIPLE
;
1247 * When we are in power saving mode, unless device support spatial
1248 * multiplexing power save, use the active count for rx chain count.
1250 static int iwl_get_idle_rx_chain_count(struct iwl_priv
*priv
, int active_cnt
)
1252 /* # Rx chains when idling, depending on SMPS mode */
1253 switch (priv
->current_ht_config
.smps
) {
1254 case IEEE80211_SMPS_STATIC
:
1255 case IEEE80211_SMPS_DYNAMIC
:
1256 return IWL_NUM_IDLE_CHAINS_SINGLE
;
1257 case IEEE80211_SMPS_OFF
:
1260 WARN(1, "invalid SMPS mode %d",
1261 priv
->current_ht_config
.smps
);
1266 /* up to 4 chains */
1267 static u8
iwl_count_chain_bitmap(u32 chain_bitmap
)
1270 res
= (chain_bitmap
& BIT(0)) >> 0;
1271 res
+= (chain_bitmap
& BIT(1)) >> 1;
1272 res
+= (chain_bitmap
& BIT(2)) >> 2;
1273 res
+= (chain_bitmap
& BIT(3)) >> 3;
1278 * iwlagn_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
1280 * Selects how many and which Rx receivers/antennas/chains to use.
1281 * This should not be used for scan command ... it puts data in wrong place.
1283 void iwlagn_set_rxon_chain(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
)
1285 bool is_single
= is_single_rx_stream(priv
);
1286 bool is_cam
= !test_bit(STATUS_POWER_PMI
, &priv
->shrd
->status
);
1287 u8 idle_rx_cnt
, active_rx_cnt
, valid_rx_cnt
;
1291 /* Tell uCode which antennas are actually connected.
1292 * Before first association, we assume all antennas are connected.
1293 * Just after first association, iwl_chain_noise_calibration()
1294 * checks which antennas actually *are* connected. */
1295 if (priv
->chain_noise_data
.active_chains
)
1296 active_chains
= priv
->chain_noise_data
.active_chains
;
1298 active_chains
= hw_params(priv
).valid_rx_ant
;
1300 if (priv
->cfg
->bt_params
&&
1301 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
1302 (priv
->bt_full_concurrent
||
1303 priv
->bt_traffic_load
>= IWL_BT_COEX_TRAFFIC_LOAD_HIGH
)) {
1305 * only use chain 'A' in bt high traffic load or
1306 * full concurrency mode
1308 active_chains
= first_antenna(active_chains
);
1311 rx_chain
= active_chains
<< RXON_RX_CHAIN_VALID_POS
;
1313 /* How many receivers should we use? */
1314 active_rx_cnt
= iwl_get_active_rx_chain_count(priv
);
1315 idle_rx_cnt
= iwl_get_idle_rx_chain_count(priv
, active_rx_cnt
);
1318 /* correct rx chain count according hw settings
1319 * and chain noise calibration
1321 valid_rx_cnt
= iwl_count_chain_bitmap(active_chains
);
1322 if (valid_rx_cnt
< active_rx_cnt
)
1323 active_rx_cnt
= valid_rx_cnt
;
1325 if (valid_rx_cnt
< idle_rx_cnt
)
1326 idle_rx_cnt
= valid_rx_cnt
;
1328 rx_chain
|= active_rx_cnt
<< RXON_RX_CHAIN_MIMO_CNT_POS
;
1329 rx_chain
|= idle_rx_cnt
<< RXON_RX_CHAIN_CNT_POS
;
1331 ctx
->staging
.rx_chain
= cpu_to_le16(rx_chain
);
1333 if (!is_single
&& (active_rx_cnt
>= IWL_NUM_RX_CHAINS_SINGLE
) && is_cam
)
1334 ctx
->staging
.rx_chain
|= RXON_RX_CHAIN_MIMO_FORCE_MSK
;
1336 ctx
->staging
.rx_chain
&= ~RXON_RX_CHAIN_MIMO_FORCE_MSK
;
1338 IWL_DEBUG_ASSOC(priv
, "rx_chain=0x%X active=%d idle=%d\n",
1339 ctx
->staging
.rx_chain
,
1340 active_rx_cnt
, idle_rx_cnt
);
1342 WARN_ON(active_rx_cnt
== 0 || idle_rx_cnt
== 0 ||
1343 active_rx_cnt
< idle_rx_cnt
);
1346 u8
iwl_toggle_tx_ant(struct iwl_priv
*priv
, u8 ant
, u8 valid
)
1351 if (priv
->band
== IEEE80211_BAND_2GHZ
&&
1352 priv
->bt_traffic_load
>= IWL_BT_COEX_TRAFFIC_LOAD_HIGH
)
1355 for (i
= 0; i
< RATE_ANT_NUM
- 1; i
++) {
1356 ind
= (ind
+ 1) < RATE_ANT_NUM
? ind
+ 1 : 0;
1357 if (valid
& BIT(ind
))
1363 /* notification wait support */
1364 void iwlagn_init_notification_wait(struct iwl_priv
*priv
,
1365 struct iwl_notification_wait
*wait_entry
,
1367 void (*fn
)(struct iwl_priv
*priv
,
1368 struct iwl_rx_packet
*pkt
,
1372 wait_entry
->fn
= fn
;
1373 wait_entry
->fn_data
= fn_data
;
1374 wait_entry
->cmd
= cmd
;
1375 wait_entry
->triggered
= false;
1376 wait_entry
->aborted
= false;
1378 spin_lock_bh(&priv
->notif_wait_lock
);
1379 list_add(&wait_entry
->list
, &priv
->notif_waits
);
1380 spin_unlock_bh(&priv
->notif_wait_lock
);
1383 int iwlagn_wait_notification(struct iwl_priv
*priv
,
1384 struct iwl_notification_wait
*wait_entry
,
1385 unsigned long timeout
)
1389 ret
= wait_event_timeout(priv
->notif_waitq
,
1390 wait_entry
->triggered
|| wait_entry
->aborted
,
1393 spin_lock_bh(&priv
->notif_wait_lock
);
1394 list_del(&wait_entry
->list
);
1395 spin_unlock_bh(&priv
->notif_wait_lock
);
1397 if (wait_entry
->aborted
)
1400 /* return value is always >= 0 */
1406 void iwlagn_remove_notification(struct iwl_priv
*priv
,
1407 struct iwl_notification_wait
*wait_entry
)
1409 spin_lock_bh(&priv
->notif_wait_lock
);
1410 list_del(&wait_entry
->list
);
1411 spin_unlock_bh(&priv
->notif_wait_lock
);