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
{
105 hdr
= (struct iwl_eeprom_calib_hdr
*)iwl_eeprom_query_addr(priv
,
114 static u32
eeprom_indirect_address(const struct iwl_priv
*priv
, u32 address
)
118 if ((address
& INDIRECT_ADDRESS
) == 0)
121 switch (address
& INDIRECT_TYPE_MSK
) {
123 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_HOST
);
125 case INDIRECT_GENERAL
:
126 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_GENERAL
);
128 case INDIRECT_REGULATORY
:
129 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_REGULATORY
);
131 case INDIRECT_TXP_LIMIT
:
132 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_TXP_LIMIT
);
134 case INDIRECT_TXP_LIMIT_SIZE
:
135 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_TXP_LIMIT_SIZE
);
137 case INDIRECT_CALIBRATION
:
138 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_CALIBRATION
);
140 case INDIRECT_PROCESS_ADJST
:
141 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_PROCESS_ADJST
);
143 case INDIRECT_OTHERS
:
144 offset
= iwl_eeprom_query16(priv
, EEPROM_LINK_OTHERS
);
147 IWL_ERR(priv
, "illegal indirect type: 0x%X\n",
148 address
& INDIRECT_TYPE_MSK
);
152 /* translate the offset from words to byte */
153 return (address
& ADDRESS_MSK
) + (offset
<< 1);
156 const u8
*iwl_eeprom_query_addr(const struct iwl_priv
*priv
, size_t offset
)
158 u32 address
= eeprom_indirect_address(priv
, offset
);
159 BUG_ON(address
>= priv
->cfg
->base_params
->eeprom_size
);
160 return &priv
->eeprom
[address
];
163 struct iwl_mod_params iwlagn_mod_params
= {
167 .bt_coex_active
= true,
168 .no_sleep_autoadjust
= true,
169 .power_level
= IWL_POWER_INDEX_1
,
170 .bt_ch_announce
= true,
171 .wanted_ucode_alternative
= 1,
173 /* the rest are 0 by default */
176 int iwlagn_hwrate_to_mac80211_idx(u32 rate_n_flags
, enum ieee80211_band band
)
181 /* HT rate format: mac80211 wants an MCS number, which is just LSB */
182 if (rate_n_flags
& RATE_MCS_HT_MSK
) {
183 idx
= (rate_n_flags
& 0xff);
185 /* Legacy rate format, search for match in table */
187 if (band
== IEEE80211_BAND_5GHZ
)
188 band_offset
= IWL_FIRST_OFDM_RATE
;
189 for (idx
= band_offset
; idx
< IWL_RATE_COUNT_LEGACY
; idx
++)
190 if (iwl_rates
[idx
].plcp
== (rate_n_flags
& 0xFF))
191 return idx
- band_offset
;
197 static int iwl_get_single_channel_for_scan(struct iwl_priv
*priv
,
198 struct ieee80211_vif
*vif
,
199 enum ieee80211_band band
,
200 struct iwl_scan_channel
*scan_ch
)
202 const struct ieee80211_supported_band
*sband
;
203 u16 passive_dwell
= 0;
204 u16 active_dwell
= 0;
208 sband
= iwl_get_hw_mode(priv
, band
);
210 IWL_ERR(priv
, "invalid band\n");
214 active_dwell
= iwl_get_active_dwell_time(priv
, band
, 0);
215 passive_dwell
= iwl_get_passive_dwell_time(priv
, band
, vif
);
217 if (passive_dwell
<= active_dwell
)
218 passive_dwell
= active_dwell
+ 1;
220 channel
= iwl_get_single_channel_number(priv
, band
);
222 scan_ch
->channel
= cpu_to_le16(channel
);
223 scan_ch
->type
= SCAN_CHANNEL_TYPE_PASSIVE
;
224 scan_ch
->active_dwell
= cpu_to_le16(active_dwell
);
225 scan_ch
->passive_dwell
= cpu_to_le16(passive_dwell
);
226 /* Set txpower levels to defaults */
227 scan_ch
->dsp_atten
= 110;
228 if (band
== IEEE80211_BAND_5GHZ
)
229 scan_ch
->tx_gain
= ((1 << 5) | (3 << 3)) | 3;
231 scan_ch
->tx_gain
= ((1 << 5) | (5 << 3));
234 IWL_ERR(priv
, "no valid channel found\n");
238 static int iwl_get_channels_for_scan(struct iwl_priv
*priv
,
239 struct ieee80211_vif
*vif
,
240 enum ieee80211_band band
,
241 u8 is_active
, u8 n_probes
,
242 struct iwl_scan_channel
*scan_ch
)
244 struct ieee80211_channel
*chan
;
245 const struct ieee80211_supported_band
*sband
;
246 const struct iwl_channel_info
*ch_info
;
247 u16 passive_dwell
= 0;
248 u16 active_dwell
= 0;
252 sband
= iwl_get_hw_mode(priv
, band
);
256 active_dwell
= iwl_get_active_dwell_time(priv
, band
, n_probes
);
257 passive_dwell
= iwl_get_passive_dwell_time(priv
, band
, vif
);
259 if (passive_dwell
<= active_dwell
)
260 passive_dwell
= active_dwell
+ 1;
262 for (i
= 0, added
= 0; i
< priv
->scan_request
->n_channels
; i
++) {
263 chan
= priv
->scan_request
->channels
[i
];
265 if (chan
->band
!= band
)
268 channel
= chan
->hw_value
;
269 scan_ch
->channel
= cpu_to_le16(channel
);
271 ch_info
= iwl_get_channel_info(priv
, band
, channel
);
272 if (!is_channel_valid(ch_info
)) {
273 IWL_DEBUG_SCAN(priv
, "Channel %d is INVALID for this band.\n",
278 if (!is_active
|| is_channel_passive(ch_info
) ||
279 (chan
->flags
& IEEE80211_CHAN_PASSIVE_SCAN
))
280 scan_ch
->type
= SCAN_CHANNEL_TYPE_PASSIVE
;
282 scan_ch
->type
= SCAN_CHANNEL_TYPE_ACTIVE
;
285 scan_ch
->type
|= IWL_SCAN_PROBE_MASK(n_probes
);
287 scan_ch
->active_dwell
= cpu_to_le16(active_dwell
);
288 scan_ch
->passive_dwell
= cpu_to_le16(passive_dwell
);
290 /* Set txpower levels to defaults */
291 scan_ch
->dsp_atten
= 110;
293 /* NOTE: if we were doing 6Mb OFDM for scans we'd use
295 * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
297 if (band
== IEEE80211_BAND_5GHZ
)
298 scan_ch
->tx_gain
= ((1 << 5) | (3 << 3)) | 3;
300 scan_ch
->tx_gain
= ((1 << 5) | (5 << 3));
302 IWL_DEBUG_SCAN(priv
, "Scanning ch=%d prob=0x%X [%s %d]\n",
303 channel
, le32_to_cpu(scan_ch
->type
),
304 (scan_ch
->type
& SCAN_CHANNEL_TYPE_ACTIVE
) ?
305 "ACTIVE" : "PASSIVE",
306 (scan_ch
->type
& SCAN_CHANNEL_TYPE_ACTIVE
) ?
307 active_dwell
: passive_dwell
);
313 IWL_DEBUG_SCAN(priv
, "total channels to scan %d\n", added
);
317 int iwlagn_request_scan(struct iwl_priv
*priv
, struct ieee80211_vif
*vif
)
319 struct iwl_host_cmd cmd
= {
320 .id
= REPLY_SCAN_CMD
,
321 .len
= { sizeof(struct iwl_scan_cmd
), },
324 struct iwl_scan_cmd
*scan
;
325 struct iwl_rxon_context
*ctx
= &priv
->contexts
[IWL_RXON_CTX_BSS
];
329 enum ieee80211_band band
;
331 u8 rx_ant
= hw_params(priv
).valid_rx_ant
;
333 bool is_active
= false;
336 u8 scan_tx_antennas
= hw_params(priv
).valid_tx_ant
;
339 lockdep_assert_held(&priv
->shrd
->mutex
);
342 ctx
= iwl_rxon_ctx_from_vif(vif
);
344 if (!priv
->scan_cmd
) {
345 priv
->scan_cmd
= kmalloc(sizeof(struct iwl_scan_cmd
) +
346 IWL_MAX_SCAN_SIZE
, GFP_KERNEL
);
347 if (!priv
->scan_cmd
) {
349 "fail to allocate memory for scan\n");
353 scan
= priv
->scan_cmd
;
354 memset(scan
, 0, sizeof(struct iwl_scan_cmd
) + IWL_MAX_SCAN_SIZE
);
356 scan
->quiet_plcp_th
= IWL_PLCP_QUIET_THRESH
;
357 scan
->quiet_time
= IWL_ACTIVE_QUIET_TIME
;
359 if (priv
->scan_type
!= IWL_SCAN_ROC
&&
360 iwl_is_any_associated(priv
)) {
363 u32 suspend_time
= 100;
364 u32 scan_suspend_time
= 100;
366 IWL_DEBUG_INFO(priv
, "Scanning while associated...\n");
367 switch (priv
->scan_type
) {
371 case IWL_SCAN_RADIO_RESET
:
374 case IWL_SCAN_NORMAL
:
375 interval
= vif
->bss_conf
.beacon_int
;
379 scan
->suspend_time
= 0;
380 scan
->max_out_time
= cpu_to_le32(200 * 1024);
382 interval
= suspend_time
;
384 extra
= (suspend_time
/ interval
) << 22;
385 scan_suspend_time
= (extra
|
386 ((suspend_time
% interval
) * 1024));
387 scan
->suspend_time
= cpu_to_le32(scan_suspend_time
);
388 IWL_DEBUG_SCAN(priv
, "suspend_time 0x%X beacon interval %d\n",
389 scan_suspend_time
, interval
);
390 } else if (priv
->scan_type
== IWL_SCAN_ROC
) {
391 scan
->suspend_time
= 0;
392 scan
->max_out_time
= 0;
393 scan
->quiet_time
= 0;
394 scan
->quiet_plcp_th
= 0;
397 switch (priv
->scan_type
) {
398 case IWL_SCAN_RADIO_RESET
:
399 IWL_DEBUG_SCAN(priv
, "Start internal passive scan.\n");
401 case IWL_SCAN_NORMAL
:
402 if (priv
->scan_request
->n_ssids
) {
404 IWL_DEBUG_SCAN(priv
, "Kicking off active scan\n");
405 for (i
= 0; i
< priv
->scan_request
->n_ssids
; i
++) {
406 /* always does wildcard anyway */
407 if (!priv
->scan_request
->ssids
[i
].ssid_len
)
409 scan
->direct_scan
[p
].id
= WLAN_EID_SSID
;
410 scan
->direct_scan
[p
].len
=
411 priv
->scan_request
->ssids
[i
].ssid_len
;
412 memcpy(scan
->direct_scan
[p
].ssid
,
413 priv
->scan_request
->ssids
[i
].ssid
,
414 priv
->scan_request
->ssids
[i
].ssid_len
);
420 IWL_DEBUG_SCAN(priv
, "Start passive scan.\n");
423 IWL_DEBUG_SCAN(priv
, "Start ROC scan.\n");
427 scan
->tx_cmd
.tx_flags
= TX_CMD_FLG_SEQ_CTL_MSK
;
428 scan
->tx_cmd
.sta_id
= ctx
->bcast_sta_id
;
429 scan
->tx_cmd
.stop_time
.life_time
= TX_CMD_LIFE_TIME_INFINITE
;
431 switch (priv
->scan_band
) {
432 case IEEE80211_BAND_2GHZ
:
433 scan
->flags
= RXON_FLG_BAND_24G_MSK
| RXON_FLG_AUTO_DETECT_MSK
;
434 chan_mod
= le32_to_cpu(
435 priv
->contexts
[IWL_RXON_CTX_BSS
].active
.flags
&
436 RXON_FLG_CHANNEL_MODE_MSK
)
437 >> RXON_FLG_CHANNEL_MODE_POS
;
438 if (chan_mod
== CHANNEL_MODE_PURE_40
) {
439 rate
= IWL_RATE_6M_PLCP
;
441 rate
= IWL_RATE_1M_PLCP
;
442 rate_flags
= RATE_MCS_CCK_MSK
;
445 * Internal scans are passive, so we can indiscriminately set
446 * the BT ignore flag on 2.4 GHz since it applies to TX only.
448 if (priv
->cfg
->bt_params
&&
449 priv
->cfg
->bt_params
->advanced_bt_coexist
)
450 scan
->tx_cmd
.tx_flags
|= TX_CMD_FLG_IGNORE_BT
;
452 case IEEE80211_BAND_5GHZ
:
453 rate
= IWL_RATE_6M_PLCP
;
456 IWL_WARN(priv
, "Invalid scan band\n");
461 * If active scanning is requested but a certain channel is
462 * marked passive, we can do active scanning if we detect
465 * There is an issue with some firmware versions that triggers
466 * a sysassert on a "good CRC threshold" of zero (== disabled),
467 * on a radar channel even though this means that we should NOT
470 * The "good CRC threshold" is the number of frames that we
471 * need to receive during our dwell time on a channel before
472 * sending out probes -- setting this to a huge value will
473 * mean we never reach it, but at the same time work around
474 * the aforementioned issue. Thus use IWL_GOOD_CRC_TH_NEVER
475 * here instead of IWL_GOOD_CRC_TH_DISABLED.
477 * This was fixed in later versions along with some other
478 * scan changes, and the threshold behaves as a flag in those
481 if (priv
->new_scan_threshold_behaviour
)
482 scan
->good_CRC_th
= is_active
? IWL_GOOD_CRC_TH_DEFAULT
:
483 IWL_GOOD_CRC_TH_DISABLED
;
485 scan
->good_CRC_th
= is_active
? IWL_GOOD_CRC_TH_DEFAULT
:
486 IWL_GOOD_CRC_TH_NEVER
;
488 band
= priv
->scan_band
;
490 if (priv
->cfg
->scan_rx_antennas
[band
])
491 rx_ant
= priv
->cfg
->scan_rx_antennas
[band
];
493 if (band
== IEEE80211_BAND_2GHZ
&&
494 priv
->cfg
->bt_params
&&
495 priv
->cfg
->bt_params
->advanced_bt_coexist
) {
496 /* transmit 2.4 GHz probes only on first antenna */
497 scan_tx_antennas
= first_antenna(scan_tx_antennas
);
500 priv
->scan_tx_ant
[band
] = iwl_toggle_tx_ant(priv
, priv
->scan_tx_ant
[band
],
502 rate_flags
|= iwl_ant_idx_to_flags(priv
->scan_tx_ant
[band
]);
503 scan
->tx_cmd
.rate_n_flags
= iwl_hw_set_rate_n_flags(rate
, rate_flags
);
505 /* In power save mode use one chain, otherwise use all chains */
506 if (test_bit(STATUS_POWER_PMI
, &priv
->shrd
->status
)) {
507 /* rx_ant has been set to all valid chains previously */
508 active_chains
= rx_ant
&
509 ((u8
)(priv
->chain_noise_data
.active_chains
));
511 active_chains
= rx_ant
;
513 IWL_DEBUG_SCAN(priv
, "chain_noise_data.active_chains: %u\n",
514 priv
->chain_noise_data
.active_chains
);
516 rx_ant
= first_antenna(active_chains
);
518 if (priv
->cfg
->bt_params
&&
519 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
520 priv
->bt_full_concurrent
) {
521 /* operated as 1x1 in full concurrency mode */
522 rx_ant
= first_antenna(rx_ant
);
525 /* MIMO is not used here, but value is required */
527 hw_params(priv
).valid_rx_ant
<< RXON_RX_CHAIN_VALID_POS
;
528 rx_chain
|= rx_ant
<< RXON_RX_CHAIN_FORCE_MIMO_SEL_POS
;
529 rx_chain
|= rx_ant
<< RXON_RX_CHAIN_FORCE_SEL_POS
;
530 rx_chain
|= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS
;
531 scan
->rx_chain
= cpu_to_le16(rx_chain
);
532 switch (priv
->scan_type
) {
533 case IWL_SCAN_NORMAL
:
534 cmd_len
= iwl_fill_probe_req(priv
,
535 (struct ieee80211_mgmt
*)scan
->data
,
537 priv
->scan_request
->ie
,
538 priv
->scan_request
->ie_len
,
539 IWL_MAX_SCAN_SIZE
- sizeof(*scan
));
541 case IWL_SCAN_RADIO_RESET
:
543 /* use bcast addr, will not be transmitted but must be valid */
544 cmd_len
= iwl_fill_probe_req(priv
,
545 (struct ieee80211_mgmt
*)scan
->data
,
546 iwl_bcast_addr
, NULL
, 0,
547 IWL_MAX_SCAN_SIZE
- sizeof(*scan
));
552 scan
->tx_cmd
.len
= cpu_to_le16(cmd_len
);
554 scan
->filter_flags
|= (RXON_FILTER_ACCEPT_GRP_MSK
|
555 RXON_FILTER_BCON_AWARE_MSK
);
557 switch (priv
->scan_type
) {
558 case IWL_SCAN_RADIO_RESET
:
559 scan
->channel_count
=
560 iwl_get_single_channel_for_scan(priv
, vif
, band
,
561 (void *)&scan
->data
[cmd_len
]);
563 case IWL_SCAN_NORMAL
:
564 scan
->channel_count
=
565 iwl_get_channels_for_scan(priv
, vif
, band
,
567 (void *)&scan
->data
[cmd_len
]);
570 struct iwl_scan_channel
*scan_ch
;
572 scan
->channel_count
= 1;
574 scan_ch
= (void *)&scan
->data
[cmd_len
];
575 scan_ch
->type
= SCAN_CHANNEL_TYPE_PASSIVE
;
577 cpu_to_le16(priv
->hw_roc_channel
->hw_value
);
578 scan_ch
->active_dwell
=
579 scan_ch
->passive_dwell
=
580 cpu_to_le16(priv
->hw_roc_duration
);
582 /* Set txpower levels to defaults */
583 scan_ch
->dsp_atten
= 110;
585 /* NOTE: if we were doing 6Mb OFDM for scans we'd use
587 * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
589 if (priv
->hw_roc_channel
->band
== IEEE80211_BAND_5GHZ
)
590 scan_ch
->tx_gain
= ((1 << 5) | (3 << 3)) | 3;
592 scan_ch
->tx_gain
= ((1 << 5) | (5 << 3));
597 if (scan
->channel_count
== 0) {
598 IWL_DEBUG_SCAN(priv
, "channel count %d\n", scan
->channel_count
);
602 cmd
.len
[0] += le16_to_cpu(scan
->tx_cmd
.len
) +
603 scan
->channel_count
* sizeof(struct iwl_scan_channel
);
605 cmd
.dataflags
[0] = IWL_HCMD_DFL_NOCOPY
;
606 scan
->len
= cpu_to_le16(cmd
.len
[0]);
608 /* set scan bit here for PAN params */
609 set_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
611 ret
= iwlagn_set_pan_params(priv
);
615 ret
= iwl_trans_send_cmd(trans(priv
), &cmd
);
617 clear_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
);
618 iwlagn_set_pan_params(priv
);
624 int iwlagn_manage_ibss_station(struct iwl_priv
*priv
,
625 struct ieee80211_vif
*vif
, bool add
)
627 struct iwl_vif_priv
*vif_priv
= (void *)vif
->drv_priv
;
630 return iwlagn_add_bssid_station(priv
, vif_priv
->ctx
,
632 &vif_priv
->ibss_bssid_sta_id
);
633 return iwl_remove_station(priv
, vif_priv
->ibss_bssid_sta_id
,
634 vif
->bss_conf
.bssid
);
637 #define IWL_FLUSH_WAIT_MS 2000
639 int iwlagn_wait_tx_queue_empty(struct iwl_priv
*priv
)
641 struct iwl_tx_queue
*txq
;
644 unsigned long now
= jiffies
;
647 /* waiting for all the tx frames complete might take a while */
648 for (cnt
= 0; cnt
< hw_params(priv
).max_txq_num
; cnt
++) {
649 if (cnt
== priv
->shrd
->cmd_queue
)
651 txq
= &priv
->txq
[cnt
];
653 while (q
->read_ptr
!= q
->write_ptr
&& !time_after(jiffies
,
654 now
+ msecs_to_jiffies(IWL_FLUSH_WAIT_MS
)))
657 if (q
->read_ptr
!= q
->write_ptr
) {
658 IWL_ERR(priv
, "fail to flush all tx fifo queues\n");
666 #define IWL_TX_QUEUE_MSK 0xfffff
669 * iwlagn_txfifo_flush: send REPLY_TXFIFO_FLUSH command to uCode
672 * 1. acquire mutex before calling
673 * 2. make sure rf is on and not in exit state
675 int iwlagn_txfifo_flush(struct iwl_priv
*priv
, u16 flush_control
)
677 struct iwl_txfifo_flush_cmd flush_cmd
;
678 struct iwl_host_cmd cmd
= {
679 .id
= REPLY_TXFIFO_FLUSH
,
680 .len
= { sizeof(struct iwl_txfifo_flush_cmd
), },
682 .data
= { &flush_cmd
, },
687 memset(&flush_cmd
, 0, sizeof(flush_cmd
));
688 if (flush_control
& BIT(IWL_RXON_CTX_BSS
))
689 flush_cmd
.fifo_control
= IWL_SCD_VO_MSK
| IWL_SCD_VI_MSK
|
690 IWL_SCD_BE_MSK
| IWL_SCD_BK_MSK
|
692 if ((flush_control
& BIT(IWL_RXON_CTX_PAN
)) &&
693 (priv
->valid_contexts
!= BIT(IWL_RXON_CTX_BSS
)))
694 flush_cmd
.fifo_control
|= IWL_PAN_SCD_VO_MSK
|
695 IWL_PAN_SCD_VI_MSK
| IWL_PAN_SCD_BE_MSK
|
696 IWL_PAN_SCD_BK_MSK
| IWL_PAN_SCD_MGMT_MSK
|
697 IWL_PAN_SCD_MULTICAST_MSK
;
699 if (priv
->cfg
->sku
& EEPROM_SKU_CAP_11N_ENABLE
)
700 flush_cmd
.fifo_control
|= IWL_AGG_TX_QUEUE_MSK
;
702 IWL_DEBUG_INFO(priv
, "fifo queue control: 0X%x\n",
703 flush_cmd
.fifo_control
);
704 flush_cmd
.flush_control
= cpu_to_le16(flush_control
);
706 return iwl_trans_send_cmd(trans(priv
), &cmd
);
709 void iwlagn_dev_txfifo_flush(struct iwl_priv
*priv
, u16 flush_control
)
711 mutex_lock(&priv
->shrd
->mutex
);
712 ieee80211_stop_queues(priv
->hw
);
713 if (iwlagn_txfifo_flush(priv
, IWL_DROP_ALL
)) {
714 IWL_ERR(priv
, "flush request fail\n");
717 IWL_DEBUG_INFO(priv
, "wait transmit/flush all frames\n");
718 iwlagn_wait_tx_queue_empty(priv
);
720 ieee80211_wake_queues(priv
->hw
);
721 mutex_unlock(&priv
->shrd
->mutex
);
728 * Macros to access the lookup table.
730 * The lookup table has 7 inputs: bt3_prio, bt3_txrx, bt_rf_act, wifi_req,
731 * wifi_prio, wifi_txrx and wifi_sh_ant_req.
733 * It has three outputs: WLAN_ACTIVE, WLAN_KILL and ANT_SWITCH
735 * The format is that "registers" 8 through 11 contain the WLAN_ACTIVE bits
736 * one after another in 32-bit registers, and "registers" 0 through 7 contain
737 * the WLAN_KILL and ANT_SWITCH bits interleaved (in that order).
739 * These macros encode that format.
741 #define LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, wifi_req, wifi_prio, \
742 wifi_txrx, wifi_sh_ant_req) \
743 (bt3_prio | (bt3_txrx << 1) | (bt_rf_act << 2) | (wifi_req << 3) | \
744 (wifi_prio << 4) | (wifi_txrx << 5) | (wifi_sh_ant_req << 6))
746 #define LUT_PTA_WLAN_ACTIVE_OP(lut, op, val) \
747 lut[8 + ((val) >> 5)] op (cpu_to_le32(BIT((val) & 0x1f)))
748 #define LUT_TEST_PTA_WLAN_ACTIVE(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
749 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
750 (!!(LUT_PTA_WLAN_ACTIVE_OP(lut, &, LUT_VALUE(bt3_prio, bt3_txrx, \
751 bt_rf_act, wifi_req, wifi_prio, wifi_txrx, \
753 #define LUT_SET_PTA_WLAN_ACTIVE(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
754 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
755 LUT_PTA_WLAN_ACTIVE_OP(lut, |=, LUT_VALUE(bt3_prio, bt3_txrx, \
756 bt_rf_act, wifi_req, wifi_prio, wifi_txrx, \
758 #define LUT_CLEAR_PTA_WLAN_ACTIVE(lut, bt3_prio, bt3_txrx, bt_rf_act, \
759 wifi_req, wifi_prio, wifi_txrx, \
761 LUT_PTA_WLAN_ACTIVE_OP(lut, &= ~, LUT_VALUE(bt3_prio, bt3_txrx, \
762 bt_rf_act, wifi_req, wifi_prio, wifi_txrx, \
765 #define LUT_WLAN_KILL_OP(lut, op, val) \
766 lut[(val) >> 4] op (cpu_to_le32(BIT(((val) << 1) & 0x1e)))
767 #define LUT_TEST_WLAN_KILL(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
768 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
769 (!!(LUT_WLAN_KILL_OP(lut, &, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
770 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))))
771 #define LUT_SET_WLAN_KILL(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
772 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
773 LUT_WLAN_KILL_OP(lut, |=, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
774 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
775 #define LUT_CLEAR_WLAN_KILL(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
776 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
777 LUT_WLAN_KILL_OP(lut, &= ~, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
778 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
780 #define LUT_ANT_SWITCH_OP(lut, op, val) \
781 lut[(val) >> 4] op (cpu_to_le32(BIT((((val) << 1) & 0x1e) + 1)))
782 #define LUT_TEST_ANT_SWITCH(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
783 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
784 (!!(LUT_ANT_SWITCH_OP(lut, &, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
785 wifi_req, wifi_prio, wifi_txrx, \
787 #define LUT_SET_ANT_SWITCH(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
788 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
789 LUT_ANT_SWITCH_OP(lut, |=, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
790 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
791 #define LUT_CLEAR_ANT_SWITCH(lut, bt3_prio, bt3_txrx, bt_rf_act, wifi_req, \
792 wifi_prio, wifi_txrx, wifi_sh_ant_req) \
793 LUT_ANT_SWITCH_OP(lut, &= ~, LUT_VALUE(bt3_prio, bt3_txrx, bt_rf_act, \
794 wifi_req, wifi_prio, wifi_txrx, wifi_sh_ant_req))
796 static const __le32 iwlagn_def_3w_lookup
[12] = {
797 cpu_to_le32(0xaaaaaaaa),
798 cpu_to_le32(0xaaaaaaaa),
799 cpu_to_le32(0xaeaaaaaa),
800 cpu_to_le32(0xaaaaaaaa),
801 cpu_to_le32(0xcc00ff28),
802 cpu_to_le32(0x0000aaaa),
803 cpu_to_le32(0xcc00aaaa),
804 cpu_to_le32(0x0000aaaa),
805 cpu_to_le32(0xc0004000),
806 cpu_to_le32(0x00004000),
807 cpu_to_le32(0xf0005000),
808 cpu_to_le32(0xf0005000),
811 static const __le32 iwlagn_concurrent_lookup
[12] = {
812 cpu_to_le32(0xaaaaaaaa),
813 cpu_to_le32(0xaaaaaaaa),
814 cpu_to_le32(0xaaaaaaaa),
815 cpu_to_le32(0xaaaaaaaa),
816 cpu_to_le32(0xaaaaaaaa),
817 cpu_to_le32(0xaaaaaaaa),
818 cpu_to_le32(0xaaaaaaaa),
819 cpu_to_le32(0xaaaaaaaa),
820 cpu_to_le32(0x00000000),
821 cpu_to_le32(0x00000000),
822 cpu_to_le32(0x00000000),
823 cpu_to_le32(0x00000000),
826 void iwlagn_send_advance_bt_config(struct iwl_priv
*priv
)
828 struct iwl_basic_bt_cmd basic
= {
829 .max_kill
= IWLAGN_BT_MAX_KILL_DEFAULT
,
830 .bt3_timer_t7_value
= IWLAGN_BT3_T7_DEFAULT
,
831 .bt3_prio_sample_time
= IWLAGN_BT3_PRIO_SAMPLE_DEFAULT
,
832 .bt3_timer_t2_value
= IWLAGN_BT3_T2_DEFAULT
,
834 struct iwl6000_bt_cmd bt_cmd_6000
;
835 struct iwl2000_bt_cmd bt_cmd_2000
;
838 BUILD_BUG_ON(sizeof(iwlagn_def_3w_lookup
) !=
839 sizeof(basic
.bt3_lookup_table
));
841 if (priv
->cfg
->bt_params
) {
842 if (priv
->cfg
->bt_params
->bt_session_2
) {
843 bt_cmd_2000
.prio_boost
= cpu_to_le32(
844 priv
->cfg
->bt_params
->bt_prio_boost
);
845 bt_cmd_2000
.tx_prio_boost
= 0;
846 bt_cmd_2000
.rx_prio_boost
= 0;
848 bt_cmd_6000
.prio_boost
=
849 priv
->cfg
->bt_params
->bt_prio_boost
;
850 bt_cmd_6000
.tx_prio_boost
= 0;
851 bt_cmd_6000
.rx_prio_boost
= 0;
854 IWL_ERR(priv
, "failed to construct BT Coex Config\n");
858 basic
.kill_ack_mask
= priv
->kill_ack_mask
;
859 basic
.kill_cts_mask
= priv
->kill_cts_mask
;
860 basic
.valid
= priv
->bt_valid
;
863 * Configure BT coex mode to "no coexistence" when the
864 * user disabled BT coexistence, we have no interface
865 * (might be in monitor mode), or the interface is in
866 * IBSS mode (no proper uCode support for coex then).
868 if (!iwlagn_mod_params
.bt_coex_active
||
869 priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) {
870 basic
.flags
= IWLAGN_BT_FLAG_COEX_MODE_DISABLED
;
872 basic
.flags
= IWLAGN_BT_FLAG_COEX_MODE_3W
<<
873 IWLAGN_BT_FLAG_COEX_MODE_SHIFT
;
875 if (!priv
->bt_enable_pspoll
)
876 basic
.flags
|= IWLAGN_BT_FLAG_SYNC_2_BT_DISABLE
;
878 basic
.flags
&= ~IWLAGN_BT_FLAG_SYNC_2_BT_DISABLE
;
880 if (priv
->bt_ch_announce
)
881 basic
.flags
|= IWLAGN_BT_FLAG_CHANNEL_INHIBITION
;
882 IWL_DEBUG_COEX(priv
, "BT coex flag: 0X%x\n", basic
.flags
);
884 priv
->bt_enable_flag
= basic
.flags
;
885 if (priv
->bt_full_concurrent
)
886 memcpy(basic
.bt3_lookup_table
, iwlagn_concurrent_lookup
,
887 sizeof(iwlagn_concurrent_lookup
));
889 memcpy(basic
.bt3_lookup_table
, iwlagn_def_3w_lookup
,
890 sizeof(iwlagn_def_3w_lookup
));
892 IWL_DEBUG_COEX(priv
, "BT coex %s in %s mode\n",
893 basic
.flags
? "active" : "disabled",
894 priv
->bt_full_concurrent
?
895 "full concurrency" : "3-wire");
897 if (priv
->cfg
->bt_params
->bt_session_2
) {
898 memcpy(&bt_cmd_2000
.basic
, &basic
,
900 ret
= iwl_trans_send_cmd_pdu(trans(priv
), REPLY_BT_CONFIG
,
901 CMD_SYNC
, sizeof(bt_cmd_2000
), &bt_cmd_2000
);
903 memcpy(&bt_cmd_6000
.basic
, &basic
,
905 ret
= iwl_trans_send_cmd_pdu(trans(priv
), REPLY_BT_CONFIG
,
906 CMD_SYNC
, sizeof(bt_cmd_6000
), &bt_cmd_6000
);
909 IWL_ERR(priv
, "failed to send BT Coex Config\n");
913 void iwlagn_bt_adjust_rssi_monitor(struct iwl_priv
*priv
, bool rssi_ena
)
915 struct iwl_rxon_context
*ctx
, *found_ctx
= NULL
;
916 bool found_ap
= false;
918 lockdep_assert_held(&priv
->shrd
->mutex
);
920 /* Check whether AP or GO mode is active. */
922 for_each_context(priv
, ctx
) {
923 if (ctx
->vif
&& ctx
->vif
->type
== NL80211_IFTYPE_AP
&&
924 iwl_is_associated_ctx(ctx
)) {
932 * If disable was received or If GO/AP mode, disable RSSI
935 if (!rssi_ena
|| found_ap
) {
936 if (priv
->cur_rssi_ctx
) {
937 ctx
= priv
->cur_rssi_ctx
;
938 ieee80211_disable_rssi_reports(ctx
->vif
);
939 priv
->cur_rssi_ctx
= NULL
;
945 * If rssi measurements need to be enabled, consider all cases now.
946 * Figure out how many contexts are active.
948 for_each_context(priv
, ctx
) {
949 if (ctx
->vif
&& ctx
->vif
->type
== NL80211_IFTYPE_STATION
&&
950 iwl_is_associated_ctx(ctx
)) {
957 * rssi monitor already enabled for the correct interface...nothing
960 if (found_ctx
== priv
->cur_rssi_ctx
)
964 * Figure out if rssi monitor is currently enabled, and needs
965 * to be changed. If rssi monitor is already enabled, disable
966 * it first else just enable rssi measurements on the
967 * interface found above.
969 if (priv
->cur_rssi_ctx
) {
970 ctx
= priv
->cur_rssi_ctx
;
972 ieee80211_disable_rssi_reports(ctx
->vif
);
975 priv
->cur_rssi_ctx
= found_ctx
;
980 ieee80211_enable_rssi_reports(found_ctx
->vif
,
981 IWLAGN_BT_PSP_MIN_RSSI_THRESHOLD
,
982 IWLAGN_BT_PSP_MAX_RSSI_THRESHOLD
);
985 static bool iwlagn_bt_traffic_is_sco(struct iwl_bt_uart_msg
*uart_msg
)
987 return BT_UART_MSG_FRAME3SCOESCO_MSK
& uart_msg
->frame3
>>
988 BT_UART_MSG_FRAME3SCOESCO_POS
;
991 static void iwlagn_bt_traffic_change_work(struct work_struct
*work
)
993 struct iwl_priv
*priv
=
994 container_of(work
, struct iwl_priv
, bt_traffic_change_work
);
995 struct iwl_rxon_context
*ctx
;
996 int smps_request
= -1;
998 if (priv
->bt_enable_flag
== IWLAGN_BT_FLAG_COEX_MODE_DISABLED
) {
999 /* bt coex disabled */
1004 * Note: bt_traffic_load can be overridden by scan complete and
1005 * coex profile notifications. Ignore that since only bad consequence
1006 * can be not matching debug print with actual state.
1008 IWL_DEBUG_COEX(priv
, "BT traffic load changes: %d\n",
1009 priv
->bt_traffic_load
);
1011 switch (priv
->bt_traffic_load
) {
1012 case IWL_BT_COEX_TRAFFIC_LOAD_NONE
:
1013 if (priv
->bt_status
)
1014 smps_request
= IEEE80211_SMPS_DYNAMIC
;
1016 smps_request
= IEEE80211_SMPS_AUTOMATIC
;
1018 case IWL_BT_COEX_TRAFFIC_LOAD_LOW
:
1019 smps_request
= IEEE80211_SMPS_DYNAMIC
;
1021 case IWL_BT_COEX_TRAFFIC_LOAD_HIGH
:
1022 case IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS
:
1023 smps_request
= IEEE80211_SMPS_STATIC
;
1026 IWL_ERR(priv
, "Invalid BT traffic load: %d\n",
1027 priv
->bt_traffic_load
);
1031 mutex_lock(&priv
->shrd
->mutex
);
1034 * We can not send command to firmware while scanning. When the scan
1035 * complete we will schedule this work again. We do check with mutex
1036 * locked to prevent new scan request to arrive. We do not check
1037 * STATUS_SCANNING to avoid race when queue_work two times from
1038 * different notifications, but quit and not perform any work at all.
1040 if (test_bit(STATUS_SCAN_HW
, &priv
->shrd
->status
))
1043 iwl_update_chain_flags(priv
);
1045 if (smps_request
!= -1) {
1046 priv
->current_ht_config
.smps
= smps_request
;
1047 for_each_context(priv
, ctx
) {
1048 if (ctx
->vif
&& ctx
->vif
->type
== NL80211_IFTYPE_STATION
)
1049 ieee80211_request_smps(ctx
->vif
, smps_request
);
1054 * Dynamic PS poll related functionality. Adjust RSSI measurements if
1057 iwlagn_bt_coex_rssi_monitor(priv
);
1059 mutex_unlock(&priv
->shrd
->mutex
);
1063 * If BT sco traffic, and RSSI monitor is enabled, move measurements to the
1064 * correct interface or disable it if this is the last interface to be
1067 void iwlagn_bt_coex_rssi_monitor(struct iwl_priv
*priv
)
1069 if (priv
->bt_is_sco
&&
1070 priv
->bt_traffic_load
== IWL_BT_COEX_TRAFFIC_LOAD_CONTINUOUS
)
1071 iwlagn_bt_adjust_rssi_monitor(priv
, true);
1073 iwlagn_bt_adjust_rssi_monitor(priv
, false);
1076 static void iwlagn_print_uartmsg(struct iwl_priv
*priv
,
1077 struct iwl_bt_uart_msg
*uart_msg
)
1079 IWL_DEBUG_COEX(priv
, "Message Type = 0x%X, SSN = 0x%X, "
1080 "Update Req = 0x%X",
1081 (BT_UART_MSG_FRAME1MSGTYPE_MSK
& uart_msg
->frame1
) >>
1082 BT_UART_MSG_FRAME1MSGTYPE_POS
,
1083 (BT_UART_MSG_FRAME1SSN_MSK
& uart_msg
->frame1
) >>
1084 BT_UART_MSG_FRAME1SSN_POS
,
1085 (BT_UART_MSG_FRAME1UPDATEREQ_MSK
& uart_msg
->frame1
) >>
1086 BT_UART_MSG_FRAME1UPDATEREQ_POS
);
1088 IWL_DEBUG_COEX(priv
, "Open connections = 0x%X, Traffic load = 0x%X, "
1089 "Chl_SeqN = 0x%X, In band = 0x%X",
1090 (BT_UART_MSG_FRAME2OPENCONNECTIONS_MSK
& uart_msg
->frame2
) >>
1091 BT_UART_MSG_FRAME2OPENCONNECTIONS_POS
,
1092 (BT_UART_MSG_FRAME2TRAFFICLOAD_MSK
& uart_msg
->frame2
) >>
1093 BT_UART_MSG_FRAME2TRAFFICLOAD_POS
,
1094 (BT_UART_MSG_FRAME2CHLSEQN_MSK
& uart_msg
->frame2
) >>
1095 BT_UART_MSG_FRAME2CHLSEQN_POS
,
1096 (BT_UART_MSG_FRAME2INBAND_MSK
& uart_msg
->frame2
) >>
1097 BT_UART_MSG_FRAME2INBAND_POS
);
1099 IWL_DEBUG_COEX(priv
, "SCO/eSCO = 0x%X, Sniff = 0x%X, A2DP = 0x%X, "
1100 "ACL = 0x%X, Master = 0x%X, OBEX = 0x%X",
1101 (BT_UART_MSG_FRAME3SCOESCO_MSK
& uart_msg
->frame3
) >>
1102 BT_UART_MSG_FRAME3SCOESCO_POS
,
1103 (BT_UART_MSG_FRAME3SNIFF_MSK
& uart_msg
->frame3
) >>
1104 BT_UART_MSG_FRAME3SNIFF_POS
,
1105 (BT_UART_MSG_FRAME3A2DP_MSK
& uart_msg
->frame3
) >>
1106 BT_UART_MSG_FRAME3A2DP_POS
,
1107 (BT_UART_MSG_FRAME3ACL_MSK
& uart_msg
->frame3
) >>
1108 BT_UART_MSG_FRAME3ACL_POS
,
1109 (BT_UART_MSG_FRAME3MASTER_MSK
& uart_msg
->frame3
) >>
1110 BT_UART_MSG_FRAME3MASTER_POS
,
1111 (BT_UART_MSG_FRAME3OBEX_MSK
& uart_msg
->frame3
) >>
1112 BT_UART_MSG_FRAME3OBEX_POS
);
1114 IWL_DEBUG_COEX(priv
, "Idle duration = 0x%X",
1115 (BT_UART_MSG_FRAME4IDLEDURATION_MSK
& uart_msg
->frame4
) >>
1116 BT_UART_MSG_FRAME4IDLEDURATION_POS
);
1118 IWL_DEBUG_COEX(priv
, "Tx Activity = 0x%X, Rx Activity = 0x%X, "
1119 "eSCO Retransmissions = 0x%X",
1120 (BT_UART_MSG_FRAME5TXACTIVITY_MSK
& uart_msg
->frame5
) >>
1121 BT_UART_MSG_FRAME5TXACTIVITY_POS
,
1122 (BT_UART_MSG_FRAME5RXACTIVITY_MSK
& uart_msg
->frame5
) >>
1123 BT_UART_MSG_FRAME5RXACTIVITY_POS
,
1124 (BT_UART_MSG_FRAME5ESCORETRANSMIT_MSK
& uart_msg
->frame5
) >>
1125 BT_UART_MSG_FRAME5ESCORETRANSMIT_POS
);
1127 IWL_DEBUG_COEX(priv
, "Sniff Interval = 0x%X, Discoverable = 0x%X",
1128 (BT_UART_MSG_FRAME6SNIFFINTERVAL_MSK
& uart_msg
->frame6
) >>
1129 BT_UART_MSG_FRAME6SNIFFINTERVAL_POS
,
1130 (BT_UART_MSG_FRAME6DISCOVERABLE_MSK
& uart_msg
->frame6
) >>
1131 BT_UART_MSG_FRAME6DISCOVERABLE_POS
);
1133 IWL_DEBUG_COEX(priv
, "Sniff Activity = 0x%X, Page = "
1134 "0x%X, Inquiry = 0x%X, Connectable = 0x%X",
1135 (BT_UART_MSG_FRAME7SNIFFACTIVITY_MSK
& uart_msg
->frame7
) >>
1136 BT_UART_MSG_FRAME7SNIFFACTIVITY_POS
,
1137 (BT_UART_MSG_FRAME7PAGE_MSK
& uart_msg
->frame7
) >>
1138 BT_UART_MSG_FRAME7PAGE_POS
,
1139 (BT_UART_MSG_FRAME7INQUIRY_MSK
& uart_msg
->frame7
) >>
1140 BT_UART_MSG_FRAME7INQUIRY_POS
,
1141 (BT_UART_MSG_FRAME7CONNECTABLE_MSK
& uart_msg
->frame7
) >>
1142 BT_UART_MSG_FRAME7CONNECTABLE_POS
);
1145 static void iwlagn_set_kill_msk(struct iwl_priv
*priv
,
1146 struct iwl_bt_uart_msg
*uart_msg
)
1149 static const __le32 bt_kill_ack_msg
[2] = {
1150 IWLAGN_BT_KILL_ACK_MASK_DEFAULT
,
1151 IWLAGN_BT_KILL_ACK_CTS_MASK_SCO
};
1152 static const __le32 bt_kill_cts_msg
[2] = {
1153 IWLAGN_BT_KILL_CTS_MASK_DEFAULT
,
1154 IWLAGN_BT_KILL_ACK_CTS_MASK_SCO
};
1156 kill_msk
= (BT_UART_MSG_FRAME3SCOESCO_MSK
& uart_msg
->frame3
)
1158 if (priv
->kill_ack_mask
!= bt_kill_ack_msg
[kill_msk
] ||
1159 priv
->kill_cts_mask
!= bt_kill_cts_msg
[kill_msk
]) {
1160 priv
->bt_valid
|= IWLAGN_BT_VALID_KILL_ACK_MASK
;
1161 priv
->kill_ack_mask
= bt_kill_ack_msg
[kill_msk
];
1162 priv
->bt_valid
|= IWLAGN_BT_VALID_KILL_CTS_MASK
;
1163 priv
->kill_cts_mask
= bt_kill_cts_msg
[kill_msk
];
1165 /* schedule to send runtime bt_config */
1166 queue_work(priv
->shrd
->workqueue
, &priv
->bt_runtime_config
);
1170 void iwlagn_bt_coex_profile_notif(struct iwl_priv
*priv
,
1171 struct iwl_rx_mem_buffer
*rxb
)
1173 unsigned long flags
;
1174 struct iwl_rx_packet
*pkt
= rxb_addr(rxb
);
1175 struct iwl_bt_coex_profile_notif
*coex
= &pkt
->u
.bt_coex_profile_notif
;
1176 struct iwl_bt_uart_msg
*uart_msg
= &coex
->last_bt_uart_msg
;
1178 if (priv
->bt_enable_flag
== IWLAGN_BT_FLAG_COEX_MODE_DISABLED
) {
1179 /* bt coex disabled */
1183 IWL_DEBUG_COEX(priv
, "BT Coex notification:\n");
1184 IWL_DEBUG_COEX(priv
, " status: %d\n", coex
->bt_status
);
1185 IWL_DEBUG_COEX(priv
, " traffic load: %d\n", coex
->bt_traffic_load
);
1186 IWL_DEBUG_COEX(priv
, " CI compliance: %d\n",
1187 coex
->bt_ci_compliance
);
1188 iwlagn_print_uartmsg(priv
, uart_msg
);
1190 priv
->last_bt_traffic_load
= priv
->bt_traffic_load
;
1191 priv
->bt_is_sco
= iwlagn_bt_traffic_is_sco(uart_msg
);
1193 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
) {
1194 if (priv
->bt_status
!= coex
->bt_status
||
1195 priv
->last_bt_traffic_load
!= coex
->bt_traffic_load
) {
1196 if (coex
->bt_status
) {
1198 if (!priv
->bt_ch_announce
)
1199 priv
->bt_traffic_load
=
1200 IWL_BT_COEX_TRAFFIC_LOAD_HIGH
;
1202 priv
->bt_traffic_load
=
1203 coex
->bt_traffic_load
;
1206 priv
->bt_traffic_load
=
1207 IWL_BT_COEX_TRAFFIC_LOAD_NONE
;
1209 priv
->bt_status
= coex
->bt_status
;
1210 queue_work(priv
->shrd
->workqueue
,
1211 &priv
->bt_traffic_change_work
);
1215 iwlagn_set_kill_msk(priv
, uart_msg
);
1217 /* FIXME: based on notification, adjust the prio_boost */
1219 spin_lock_irqsave(&priv
->shrd
->lock
, flags
);
1220 priv
->bt_ci_compliance
= coex
->bt_ci_compliance
;
1221 spin_unlock_irqrestore(&priv
->shrd
->lock
, flags
);
1224 void iwlagn_bt_rx_handler_setup(struct iwl_priv
*priv
)
1226 priv
->rx_handlers
[REPLY_BT_COEX_PROFILE_NOTIF
] =
1227 iwlagn_bt_coex_profile_notif
;
1230 void iwlagn_bt_setup_deferred_work(struct iwl_priv
*priv
)
1232 INIT_WORK(&priv
->bt_traffic_change_work
,
1233 iwlagn_bt_traffic_change_work
);
1236 void iwlagn_bt_cancel_deferred_work(struct iwl_priv
*priv
)
1238 cancel_work_sync(&priv
->bt_traffic_change_work
);
1241 static bool is_single_rx_stream(struct iwl_priv
*priv
)
1243 return priv
->current_ht_config
.smps
== IEEE80211_SMPS_STATIC
||
1244 priv
->current_ht_config
.single_chain_sufficient
;
1247 #define IWL_NUM_RX_CHAINS_MULTIPLE 3
1248 #define IWL_NUM_RX_CHAINS_SINGLE 2
1249 #define IWL_NUM_IDLE_CHAINS_DUAL 2
1250 #define IWL_NUM_IDLE_CHAINS_SINGLE 1
1253 * Determine how many receiver/antenna chains to use.
1255 * More provides better reception via diversity. Fewer saves power
1256 * at the expense of throughput, but only when not in powersave to
1259 * MIMO (dual stream) requires at least 2, but works better with 3.
1260 * This does not determine *which* chains to use, just how many.
1262 static int iwl_get_active_rx_chain_count(struct iwl_priv
*priv
)
1264 if (priv
->cfg
->bt_params
&&
1265 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
1266 (priv
->bt_full_concurrent
||
1267 priv
->bt_traffic_load
>= IWL_BT_COEX_TRAFFIC_LOAD_HIGH
)) {
1269 * only use chain 'A' in bt high traffic load or
1270 * full concurrency mode
1272 return IWL_NUM_RX_CHAINS_SINGLE
;
1274 /* # of Rx chains to use when expecting MIMO. */
1275 if (is_single_rx_stream(priv
))
1276 return IWL_NUM_RX_CHAINS_SINGLE
;
1278 return IWL_NUM_RX_CHAINS_MULTIPLE
;
1282 * When we are in power saving mode, unless device support spatial
1283 * multiplexing power save, use the active count for rx chain count.
1285 static int iwl_get_idle_rx_chain_count(struct iwl_priv
*priv
, int active_cnt
)
1287 /* # Rx chains when idling, depending on SMPS mode */
1288 switch (priv
->current_ht_config
.smps
) {
1289 case IEEE80211_SMPS_STATIC
:
1290 case IEEE80211_SMPS_DYNAMIC
:
1291 return IWL_NUM_IDLE_CHAINS_SINGLE
;
1292 case IEEE80211_SMPS_OFF
:
1295 WARN(1, "invalid SMPS mode %d",
1296 priv
->current_ht_config
.smps
);
1301 /* up to 4 chains */
1302 static u8
iwl_count_chain_bitmap(u32 chain_bitmap
)
1305 res
= (chain_bitmap
& BIT(0)) >> 0;
1306 res
+= (chain_bitmap
& BIT(1)) >> 1;
1307 res
+= (chain_bitmap
& BIT(2)) >> 2;
1308 res
+= (chain_bitmap
& BIT(3)) >> 3;
1313 * iwlagn_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
1315 * Selects how many and which Rx receivers/antennas/chains to use.
1316 * This should not be used for scan command ... it puts data in wrong place.
1318 void iwlagn_set_rxon_chain(struct iwl_priv
*priv
, struct iwl_rxon_context
*ctx
)
1320 bool is_single
= is_single_rx_stream(priv
);
1321 bool is_cam
= !test_bit(STATUS_POWER_PMI
, &priv
->shrd
->status
);
1322 u8 idle_rx_cnt
, active_rx_cnt
, valid_rx_cnt
;
1326 /* Tell uCode which antennas are actually connected.
1327 * Before first association, we assume all antennas are connected.
1328 * Just after first association, iwl_chain_noise_calibration()
1329 * checks which antennas actually *are* connected. */
1330 if (priv
->chain_noise_data
.active_chains
)
1331 active_chains
= priv
->chain_noise_data
.active_chains
;
1333 active_chains
= hw_params(priv
).valid_rx_ant
;
1335 if (priv
->cfg
->bt_params
&&
1336 priv
->cfg
->bt_params
->advanced_bt_coexist
&&
1337 (priv
->bt_full_concurrent
||
1338 priv
->bt_traffic_load
>= IWL_BT_COEX_TRAFFIC_LOAD_HIGH
)) {
1340 * only use chain 'A' in bt high traffic load or
1341 * full concurrency mode
1343 active_chains
= first_antenna(active_chains
);
1346 rx_chain
= active_chains
<< RXON_RX_CHAIN_VALID_POS
;
1348 /* How many receivers should we use? */
1349 active_rx_cnt
= iwl_get_active_rx_chain_count(priv
);
1350 idle_rx_cnt
= iwl_get_idle_rx_chain_count(priv
, active_rx_cnt
);
1353 /* correct rx chain count according hw settings
1354 * and chain noise calibration
1356 valid_rx_cnt
= iwl_count_chain_bitmap(active_chains
);
1357 if (valid_rx_cnt
< active_rx_cnt
)
1358 active_rx_cnt
= valid_rx_cnt
;
1360 if (valid_rx_cnt
< idle_rx_cnt
)
1361 idle_rx_cnt
= valid_rx_cnt
;
1363 rx_chain
|= active_rx_cnt
<< RXON_RX_CHAIN_MIMO_CNT_POS
;
1364 rx_chain
|= idle_rx_cnt
<< RXON_RX_CHAIN_CNT_POS
;
1366 ctx
->staging
.rx_chain
= cpu_to_le16(rx_chain
);
1368 if (!is_single
&& (active_rx_cnt
>= IWL_NUM_RX_CHAINS_SINGLE
) && is_cam
)
1369 ctx
->staging
.rx_chain
|= RXON_RX_CHAIN_MIMO_FORCE_MSK
;
1371 ctx
->staging
.rx_chain
&= ~RXON_RX_CHAIN_MIMO_FORCE_MSK
;
1373 IWL_DEBUG_ASSOC(priv
, "rx_chain=0x%X active=%d idle=%d\n",
1374 ctx
->staging
.rx_chain
,
1375 active_rx_cnt
, idle_rx_cnt
);
1377 WARN_ON(active_rx_cnt
== 0 || idle_rx_cnt
== 0 ||
1378 active_rx_cnt
< idle_rx_cnt
);
1381 u8
iwl_toggle_tx_ant(struct iwl_priv
*priv
, u8 ant
, u8 valid
)
1386 if (priv
->band
== IEEE80211_BAND_2GHZ
&&
1387 priv
->bt_traffic_load
>= IWL_BT_COEX_TRAFFIC_LOAD_HIGH
)
1390 for (i
= 0; i
< RATE_ANT_NUM
- 1; i
++) {
1391 ind
= (ind
+ 1) < RATE_ANT_NUM
? ind
+ 1 : 0;
1392 if (valid
& BIT(ind
))
1398 static const char *get_csr_string(int cmd
)
1401 IWL_CMD(CSR_HW_IF_CONFIG_REG
);
1402 IWL_CMD(CSR_INT_COALESCING
);
1404 IWL_CMD(CSR_INT_MASK
);
1405 IWL_CMD(CSR_FH_INT_STATUS
);
1406 IWL_CMD(CSR_GPIO_IN
);
1408 IWL_CMD(CSR_GP_CNTRL
);
1409 IWL_CMD(CSR_HW_REV
);
1410 IWL_CMD(CSR_EEPROM_REG
);
1411 IWL_CMD(CSR_EEPROM_GP
);
1412 IWL_CMD(CSR_OTP_GP_REG
);
1413 IWL_CMD(CSR_GIO_REG
);
1414 IWL_CMD(CSR_GP_UCODE_REG
);
1415 IWL_CMD(CSR_GP_DRIVER_REG
);
1416 IWL_CMD(CSR_UCODE_DRV_GP1
);
1417 IWL_CMD(CSR_UCODE_DRV_GP2
);
1418 IWL_CMD(CSR_LED_REG
);
1419 IWL_CMD(CSR_DRAM_INT_TBL_REG
);
1420 IWL_CMD(CSR_GIO_CHICKEN_BITS
);
1421 IWL_CMD(CSR_ANA_PLL_CFG
);
1422 IWL_CMD(CSR_HW_REV_WA_REG
);
1423 IWL_CMD(CSR_DBG_HPET_MEM_REG
);
1429 void iwl_dump_csr(struct iwl_priv
*priv
)
1432 static const u32 csr_tbl
[] = {
1433 CSR_HW_IF_CONFIG_REG
,
1451 CSR_DRAM_INT_TBL_REG
,
1452 CSR_GIO_CHICKEN_BITS
,
1455 CSR_DBG_HPET_MEM_REG
1457 IWL_ERR(priv
, "CSR values:\n");
1458 IWL_ERR(priv
, "(2nd byte of CSR_INT_COALESCING is "
1459 "CSR_INT_PERIODIC_REG)\n");
1460 for (i
= 0; i
< ARRAY_SIZE(csr_tbl
); i
++) {
1461 IWL_ERR(priv
, " %25s: 0X%08x\n",
1462 get_csr_string(csr_tbl
[i
]),
1463 iwl_read32(priv
, csr_tbl
[i
]));
1467 static const char *get_fh_string(int cmd
)
1470 IWL_CMD(FH_RSCSR_CHNL0_STTS_WPTR_REG
);
1471 IWL_CMD(FH_RSCSR_CHNL0_RBDCB_BASE_REG
);
1472 IWL_CMD(FH_RSCSR_CHNL0_WPTR
);
1473 IWL_CMD(FH_MEM_RCSR_CHNL0_CONFIG_REG
);
1474 IWL_CMD(FH_MEM_RSSR_SHARED_CTRL_REG
);
1475 IWL_CMD(FH_MEM_RSSR_RX_STATUS_REG
);
1476 IWL_CMD(FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV
);
1477 IWL_CMD(FH_TSSR_TX_STATUS_REG
);
1478 IWL_CMD(FH_TSSR_TX_ERROR_REG
);
1484 int iwl_dump_fh(struct iwl_priv
*priv
, char **buf
, bool display
)
1487 #ifdef CONFIG_IWLWIFI_DEBUG
1491 static const u32 fh_tbl
[] = {
1492 FH_RSCSR_CHNL0_STTS_WPTR_REG
,
1493 FH_RSCSR_CHNL0_RBDCB_BASE_REG
,
1494 FH_RSCSR_CHNL0_WPTR
,
1495 FH_MEM_RCSR_CHNL0_CONFIG_REG
,
1496 FH_MEM_RSSR_SHARED_CTRL_REG
,
1497 FH_MEM_RSSR_RX_STATUS_REG
,
1498 FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV
,
1499 FH_TSSR_TX_STATUS_REG
,
1500 FH_TSSR_TX_ERROR_REG
1502 #ifdef CONFIG_IWLWIFI_DEBUG
1504 bufsz
= ARRAY_SIZE(fh_tbl
) * 48 + 40;
1505 *buf
= kmalloc(bufsz
, GFP_KERNEL
);
1508 pos
+= scnprintf(*buf
+ pos
, bufsz
- pos
,
1509 "FH register values:\n");
1510 for (i
= 0; i
< ARRAY_SIZE(fh_tbl
); i
++) {
1511 pos
+= scnprintf(*buf
+ pos
, bufsz
- pos
,
1513 get_fh_string(fh_tbl
[i
]),
1514 iwl_read_direct32(priv
, fh_tbl
[i
]));
1519 IWL_ERR(priv
, "FH register values:\n");
1520 for (i
= 0; i
< ARRAY_SIZE(fh_tbl
); i
++) {
1521 IWL_ERR(priv
, " %34s: 0X%08x\n",
1522 get_fh_string(fh_tbl
[i
]),
1523 iwl_read_direct32(priv
, fh_tbl
[i
]));
1528 /* notification wait support */
1529 void iwlagn_init_notification_wait(struct iwl_priv
*priv
,
1530 struct iwl_notification_wait
*wait_entry
,
1532 void (*fn
)(struct iwl_priv
*priv
,
1533 struct iwl_rx_packet
*pkt
,
1537 wait_entry
->fn
= fn
;
1538 wait_entry
->fn_data
= fn_data
;
1539 wait_entry
->cmd
= cmd
;
1540 wait_entry
->triggered
= false;
1541 wait_entry
->aborted
= false;
1543 spin_lock_bh(&priv
->notif_wait_lock
);
1544 list_add(&wait_entry
->list
, &priv
->notif_waits
);
1545 spin_unlock_bh(&priv
->notif_wait_lock
);
1548 int iwlagn_wait_notification(struct iwl_priv
*priv
,
1549 struct iwl_notification_wait
*wait_entry
,
1550 unsigned long timeout
)
1554 ret
= wait_event_timeout(priv
->notif_waitq
,
1555 wait_entry
->triggered
|| wait_entry
->aborted
,
1558 spin_lock_bh(&priv
->notif_wait_lock
);
1559 list_del(&wait_entry
->list
);
1560 spin_unlock_bh(&priv
->notif_wait_lock
);
1562 if (wait_entry
->aborted
)
1565 /* return value is always >= 0 */
1571 void iwlagn_remove_notification(struct iwl_priv
*priv
,
1572 struct iwl_notification_wait
*wait_entry
)
1574 spin_lock_bh(&priv
->notif_wait_lock
);
1575 list_del(&wait_entry
->list
);
1576 spin_unlock_bh(&priv
->notif_wait_lock
);