1 /******************************************************************************
3 * Copyright(c) 2003 - 2008 Intel Corporation. All rights reserved.
5 * Portions of this file are derived from the ipw3945 project, as well
6 * as portions of the ieee80211 subsystem header files.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of version 2 of the GNU General Public License as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
21 * The full GNU General Public License is included in this distribution in the
22 * file called LICENSE.
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 *****************************************************************************/
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/init.h>
33 #include <linux/pci.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/delay.h>
36 #include <linux/skbuff.h>
37 #include <linux/netdevice.h>
38 #include <linux/wireless.h>
39 #include <linux/firmware.h>
40 #include <linux/etherdevice.h>
41 #include <linux/if_arp.h>
43 #include <net/mac80211.h>
45 #include <asm/div64.h>
47 #include "iwl-eeprom.h"
51 #include "iwl-helpers.h"
53 #include "iwl-calib.h"
56 /******************************************************************************
60 ******************************************************************************/
63 * module name, copyright, version, etc.
64 * NOTE: DRV_NAME is defined in iwlwifi.h for use by iwl-debug.h and printk
67 #define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
69 #ifdef CONFIG_IWLWIFI_DEBUG
75 #ifdef CONFIG_IWLAGN_SPECTRUM_MEASUREMENT
81 #define DRV_VERSION IWLWIFI_VERSION VD VS
84 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
85 MODULE_VERSION(DRV_VERSION
);
86 MODULE_AUTHOR(DRV_COPYRIGHT
" " DRV_AUTHOR
);
87 MODULE_LICENSE("GPL");
88 MODULE_ALIAS("iwl4965");
90 /*************** STATION TABLE MANAGEMENT ****
91 * mac80211 should be examined to determine if sta_info is duplicating
92 * the functionality provided here
95 /**************************************************************/
99 static void iwl_set_rxon_hwcrypto(struct iwl_priv
*priv
, int hw_decrypt
)
101 struct iwl_rxon_cmd
*rxon
= &priv
->staging_rxon
;
104 rxon
->filter_flags
&= ~RXON_FILTER_DIS_DECRYPT_MSK
;
106 rxon
->filter_flags
|= RXON_FILTER_DIS_DECRYPT_MSK
;
111 * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
112 * @priv: staging_rxon is compared to active_rxon
114 * If the RXON structure is changing enough to require a new tune,
115 * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
116 * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
118 static int iwl_full_rxon_required(struct iwl_priv
*priv
)
121 /* These items are only settable from the full RXON command */
122 if (!(iwl_is_associated(priv
)) ||
123 compare_ether_addr(priv
->staging_rxon
.bssid_addr
,
124 priv
->active_rxon
.bssid_addr
) ||
125 compare_ether_addr(priv
->staging_rxon
.node_addr
,
126 priv
->active_rxon
.node_addr
) ||
127 compare_ether_addr(priv
->staging_rxon
.wlap_bssid_addr
,
128 priv
->active_rxon
.wlap_bssid_addr
) ||
129 (priv
->staging_rxon
.dev_type
!= priv
->active_rxon
.dev_type
) ||
130 (priv
->staging_rxon
.channel
!= priv
->active_rxon
.channel
) ||
131 (priv
->staging_rxon
.air_propagation
!=
132 priv
->active_rxon
.air_propagation
) ||
133 (priv
->staging_rxon
.ofdm_ht_single_stream_basic_rates
!=
134 priv
->active_rxon
.ofdm_ht_single_stream_basic_rates
) ||
135 (priv
->staging_rxon
.ofdm_ht_dual_stream_basic_rates
!=
136 priv
->active_rxon
.ofdm_ht_dual_stream_basic_rates
) ||
137 (priv
->staging_rxon
.assoc_id
!= priv
->active_rxon
.assoc_id
))
140 /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
141 * be updated with the RXON_ASSOC command -- however only some
142 * flag transitions are allowed using RXON_ASSOC */
144 /* Check if we are not switching bands */
145 if ((priv
->staging_rxon
.flags
& RXON_FLG_BAND_24G_MSK
) !=
146 (priv
->active_rxon
.flags
& RXON_FLG_BAND_24G_MSK
))
149 /* Check if we are switching association toggle */
150 if ((priv
->staging_rxon
.filter_flags
& RXON_FILTER_ASSOC_MSK
) !=
151 (priv
->active_rxon
.filter_flags
& RXON_FILTER_ASSOC_MSK
))
158 * iwl_commit_rxon - commit staging_rxon to hardware
160 * The RXON command in staging_rxon is committed to the hardware and
161 * the active_rxon structure is updated with the new data. This
162 * function correctly transitions out of the RXON_ASSOC_MSK state if
163 * a HW tune is required based on the RXON structure changes.
165 static int iwl_commit_rxon(struct iwl_priv
*priv
)
167 /* cast away the const for active_rxon in this function */
168 struct iwl_rxon_cmd
*active_rxon
= (void *)&priv
->active_rxon
;
171 !!(priv
->staging_rxon
.filter_flags
& RXON_FILTER_ASSOC_MSK
);
173 if (!iwl_is_alive(priv
))
176 /* always get timestamp with Rx frame */
177 priv
->staging_rxon
.flags
|= RXON_FLG_TSF2HOST_MSK
;
178 /* allow CTS-to-self if possible. this is relevant only for
179 * 5000, but will not damage 4965 */
180 priv
->staging_rxon
.flags
|= RXON_FLG_SELF_CTS_EN
;
182 ret
= iwl_agn_check_rxon_cmd(&priv
->staging_rxon
);
184 IWL_ERROR("Invalid RXON configuration. Not committing.\n");
188 /* If we don't need to send a full RXON, we can use
189 * iwl_rxon_assoc_cmd which is used to reconfigure filter
190 * and other flags for the current radio configuration. */
191 if (!iwl_full_rxon_required(priv
)) {
192 ret
= iwl_send_rxon_assoc(priv
);
194 IWL_ERROR("Error setting RXON_ASSOC (%d)\n", ret
);
198 memcpy(active_rxon
, &priv
->staging_rxon
, sizeof(*active_rxon
));
202 /* station table will be cleared */
203 priv
->assoc_station_added
= 0;
205 /* If we are currently associated and the new config requires
206 * an RXON_ASSOC and the new config wants the associated mask enabled,
207 * we must clear the associated from the active configuration
208 * before we apply the new config */
209 if (iwl_is_associated(priv
) && new_assoc
) {
210 IWL_DEBUG_INFO("Toggling associated bit on current RXON\n");
211 active_rxon
->filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
213 ret
= iwl_send_cmd_pdu(priv
, REPLY_RXON
,
214 sizeof(struct iwl_rxon_cmd
),
217 /* If the mask clearing failed then we set
218 * active_rxon back to what it was previously */
220 active_rxon
->filter_flags
|= RXON_FILTER_ASSOC_MSK
;
221 IWL_ERROR("Error clearing ASSOC_MSK (%d)\n", ret
);
226 IWL_DEBUG_INFO("Sending RXON\n"
227 "* with%s RXON_FILTER_ASSOC_MSK\n"
230 (new_assoc
? "" : "out"),
231 le16_to_cpu(priv
->staging_rxon
.channel
),
232 priv
->staging_rxon
.bssid_addr
);
234 iwl_set_rxon_hwcrypto(priv
, !priv
->hw_params
.sw_crypto
);
236 /* Apply the new configuration
237 * RXON unassoc clears the station table in uCode, send it before
238 * we add the bcast station. If assoc bit is set, we will send RXON
239 * after having added the bcast and bssid station.
242 ret
= iwl_send_cmd_pdu(priv
, REPLY_RXON
,
243 sizeof(struct iwl_rxon_cmd
), &priv
->staging_rxon
);
245 IWL_ERROR("Error setting new RXON (%d)\n", ret
);
248 memcpy(active_rxon
, &priv
->staging_rxon
, sizeof(*active_rxon
));
251 iwl_clear_stations_table(priv
);
253 if (!priv
->error_recovering
)
254 priv
->start_calib
= 0;
256 /* Add the broadcast address so we can send broadcast frames */
257 if (iwl_rxon_add_station(priv
, iwl_bcast_addr
, 0) ==
258 IWL_INVALID_STATION
) {
259 IWL_ERROR("Error adding BROADCAST address for transmit.\n");
263 /* If we have set the ASSOC_MSK and we are in BSS mode then
264 * add the IWL_AP_ID to the station rate table */
266 if (priv
->iw_mode
== NL80211_IFTYPE_STATION
) {
267 ret
= iwl_rxon_add_station(priv
,
268 priv
->active_rxon
.bssid_addr
, 1);
269 if (ret
== IWL_INVALID_STATION
) {
270 IWL_ERROR("Error adding AP address for TX.\n");
273 priv
->assoc_station_added
= 1;
274 if (priv
->default_wep_key
&&
275 iwl_send_static_wepkey_cmd(priv
, 0))
276 IWL_ERROR("Could not send WEP static key.\n");
279 /* Apply the new configuration
280 * RXON assoc doesn't clear the station table in uCode,
282 ret
= iwl_send_cmd_pdu(priv
, REPLY_RXON
,
283 sizeof(struct iwl_rxon_cmd
), &priv
->staging_rxon
);
285 IWL_ERROR("Error setting new RXON (%d)\n", ret
);
288 memcpy(active_rxon
, &priv
->staging_rxon
, sizeof(*active_rxon
));
291 iwl_init_sensitivity(priv
);
293 /* If we issue a new RXON command which required a tune then we must
294 * send a new TXPOWER command or we won't be able to Tx any frames */
295 ret
= iwl_set_tx_power(priv
, priv
->tx_power_user_lmt
, true);
297 IWL_ERROR("Error sending TX power (%d)\n", ret
);
304 void iwl_update_chain_flags(struct iwl_priv
*priv
)
307 iwl_set_rxon_chain(priv
);
308 iwl_commit_rxon(priv
);
311 static int iwl_send_bt_config(struct iwl_priv
*priv
)
313 struct iwl_bt_cmd bt_cmd
= {
321 return iwl_send_cmd_pdu(priv
, REPLY_BT_CONFIG
,
322 sizeof(struct iwl_bt_cmd
), &bt_cmd
);
325 static void iwl_clear_free_frames(struct iwl_priv
*priv
)
327 struct list_head
*element
;
329 IWL_DEBUG_INFO("%d frames on pre-allocated heap on clear.\n",
332 while (!list_empty(&priv
->free_frames
)) {
333 element
= priv
->free_frames
.next
;
335 kfree(list_entry(element
, struct iwl_frame
, list
));
336 priv
->frames_count
--;
339 if (priv
->frames_count
) {
340 IWL_WARNING("%d frames still in use. Did we lose one?\n",
342 priv
->frames_count
= 0;
346 static struct iwl_frame
*iwl_get_free_frame(struct iwl_priv
*priv
)
348 struct iwl_frame
*frame
;
349 struct list_head
*element
;
350 if (list_empty(&priv
->free_frames
)) {
351 frame
= kzalloc(sizeof(*frame
), GFP_KERNEL
);
353 IWL_ERROR("Could not allocate frame!\n");
357 priv
->frames_count
++;
361 element
= priv
->free_frames
.next
;
363 return list_entry(element
, struct iwl_frame
, list
);
366 static void iwl_free_frame(struct iwl_priv
*priv
, struct iwl_frame
*frame
)
368 memset(frame
, 0, sizeof(*frame
));
369 list_add(&frame
->list
, &priv
->free_frames
);
372 static unsigned int iwl_fill_beacon_frame(struct iwl_priv
*priv
,
373 struct ieee80211_hdr
*hdr
,
376 if (!iwl_is_associated(priv
) || !priv
->ibss_beacon
||
377 ((priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
) &&
378 (priv
->iw_mode
!= NL80211_IFTYPE_AP
)))
381 if (priv
->ibss_beacon
->len
> left
)
384 memcpy(hdr
, priv
->ibss_beacon
->data
, priv
->ibss_beacon
->len
);
386 return priv
->ibss_beacon
->len
;
389 static u8
iwl_rate_get_lowest_plcp(struct iwl_priv
*priv
)
395 if (priv
->staging_rxon
.flags
& RXON_FLG_BAND_24G_MSK
)
396 rate_mask
= priv
->active_rate_basic
& IWL_CCK_RATES_MASK
;
398 rate_mask
= priv
->active_rate_basic
& IWL_OFDM_RATES_MASK
;
400 /* Find lowest valid rate */
401 for (i
= IWL_RATE_1M_INDEX
; i
!= IWL_RATE_INVALID
;
402 i
= iwl_rates
[i
].next_ieee
) {
403 if (rate_mask
& (1 << i
))
404 return iwl_rates
[i
].plcp
;
407 /* No valid rate was found. Assign the lowest one */
408 if (priv
->staging_rxon
.flags
& RXON_FLG_BAND_24G_MSK
)
409 return IWL_RATE_1M_PLCP
;
411 return IWL_RATE_6M_PLCP
;
414 static unsigned int iwl_hw_get_beacon_cmd(struct iwl_priv
*priv
,
415 struct iwl_frame
*frame
, u8 rate
)
417 struct iwl_tx_beacon_cmd
*tx_beacon_cmd
;
418 unsigned int frame_size
;
420 tx_beacon_cmd
= &frame
->u
.beacon
;
421 memset(tx_beacon_cmd
, 0, sizeof(*tx_beacon_cmd
));
423 tx_beacon_cmd
->tx
.sta_id
= priv
->hw_params
.bcast_sta_id
;
424 tx_beacon_cmd
->tx
.stop_time
.life_time
= TX_CMD_LIFE_TIME_INFINITE
;
426 frame_size
= iwl_fill_beacon_frame(priv
, tx_beacon_cmd
->frame
,
427 sizeof(frame
->u
) - sizeof(*tx_beacon_cmd
));
429 BUG_ON(frame_size
> MAX_MPDU_SIZE
);
430 tx_beacon_cmd
->tx
.len
= cpu_to_le16((u16
)frame_size
);
432 if ((rate
== IWL_RATE_1M_PLCP
) || (rate
>= IWL_RATE_2M_PLCP
))
433 tx_beacon_cmd
->tx
.rate_n_flags
=
434 iwl_hw_set_rate_n_flags(rate
, RATE_MCS_CCK_MSK
);
436 tx_beacon_cmd
->tx
.rate_n_flags
=
437 iwl_hw_set_rate_n_flags(rate
, 0);
439 tx_beacon_cmd
->tx
.tx_flags
= TX_CMD_FLG_SEQ_CTL_MSK
|
441 TX_CMD_FLG_STA_RATE_MSK
;
443 return sizeof(*tx_beacon_cmd
) + frame_size
;
445 static int iwl_send_beacon_cmd(struct iwl_priv
*priv
)
447 struct iwl_frame
*frame
;
448 unsigned int frame_size
;
452 frame
= iwl_get_free_frame(priv
);
455 IWL_ERROR("Could not obtain free frame buffer for beacon "
460 rate
= iwl_rate_get_lowest_plcp(priv
);
462 frame_size
= iwl_hw_get_beacon_cmd(priv
, frame
, rate
);
464 rc
= iwl_send_cmd_pdu(priv
, REPLY_TX_BEACON
, frame_size
,
467 iwl_free_frame(priv
, frame
);
472 /******************************************************************************
474 * Misc. internal state and helper functions
476 ******************************************************************************/
478 static void iwl_ht_conf(struct iwl_priv
*priv
,
479 struct ieee80211_bss_conf
*bss_conf
)
481 struct ieee80211_sta_ht_cap
*ht_conf
;
482 struct iwl_ht_info
*iwl_conf
= &priv
->current_ht_config
;
483 struct ieee80211_sta
*sta
;
485 IWL_DEBUG_MAC80211("enter: \n");
487 if (!iwl_conf
->is_ht
)
492 * It is totally wrong to base global information on something
493 * that is valid only when associated, alas, this driver works
494 * that way and I don't know how to fix it.
498 sta
= ieee80211_find_sta(priv
->hw
, priv
->bssid
);
503 ht_conf
= &sta
->ht_cap
;
505 if (ht_conf
->cap
& IEEE80211_HT_CAP_SGI_20
)
506 iwl_conf
->sgf
|= HT_SHORT_GI_20MHZ
;
507 if (ht_conf
->cap
& IEEE80211_HT_CAP_SGI_40
)
508 iwl_conf
->sgf
|= HT_SHORT_GI_40MHZ
;
510 iwl_conf
->is_green_field
= !!(ht_conf
->cap
& IEEE80211_HT_CAP_GRN_FLD
);
511 iwl_conf
->max_amsdu_size
=
512 !!(ht_conf
->cap
& IEEE80211_HT_CAP_MAX_AMSDU
);
514 iwl_conf
->supported_chan_width
=
515 !!(ht_conf
->cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
);
518 * XXX: The HT configuration needs to be moved into iwl_mac_config()
519 * to be done there correctly.
522 iwl_conf
->extension_chan_offset
= IEEE80211_HT_PARAM_CHA_SEC_NONE
;
523 if (priv
->hw
->conf
.ht
.channel_type
== NL80211_CHAN_HT40MINUS
)
524 iwl_conf
->extension_chan_offset
= IEEE80211_HT_PARAM_CHA_SEC_BELOW
;
525 else if(priv
->hw
->conf
.ht
.channel_type
== NL80211_CHAN_HT40PLUS
)
526 iwl_conf
->extension_chan_offset
= IEEE80211_HT_PARAM_CHA_SEC_ABOVE
;
528 /* If no above or below channel supplied disable FAT channel */
529 if (iwl_conf
->extension_chan_offset
!= IEEE80211_HT_PARAM_CHA_SEC_ABOVE
&&
530 iwl_conf
->extension_chan_offset
!= IEEE80211_HT_PARAM_CHA_SEC_BELOW
)
531 iwl_conf
->supported_chan_width
= 0;
533 iwl_conf
->sm_ps
= (u8
)((ht_conf
->cap
& IEEE80211_HT_CAP_SM_PS
) >> 2);
535 memcpy(&iwl_conf
->mcs
, &ht_conf
->mcs
, 16);
537 iwl_conf
->tx_chan_width
= iwl_conf
->supported_chan_width
!= 0;
538 iwl_conf
->ht_protection
=
539 bss_conf
->ht
.operation_mode
& IEEE80211_HT_OP_MODE_PROTECTION
;
540 iwl_conf
->non_GF_STA_present
=
541 !!(bss_conf
->ht
.operation_mode
& IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
);
545 IWL_DEBUG_MAC80211("leave\n");
551 static void iwl_activate_qos(struct iwl_priv
*priv
, u8 force
)
553 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
556 priv
->qos_data
.def_qos_parm
.qos_flags
= 0;
558 if (priv
->qos_data
.qos_cap
.q_AP
.queue_request
&&
559 !priv
->qos_data
.qos_cap
.q_AP
.txop_request
)
560 priv
->qos_data
.def_qos_parm
.qos_flags
|=
561 QOS_PARAM_FLG_TXOP_TYPE_MSK
;
562 if (priv
->qos_data
.qos_active
)
563 priv
->qos_data
.def_qos_parm
.qos_flags
|=
564 QOS_PARAM_FLG_UPDATE_EDCA_MSK
;
566 if (priv
->current_ht_config
.is_ht
)
567 priv
->qos_data
.def_qos_parm
.qos_flags
|= QOS_PARAM_FLG_TGN_MSK
;
569 if (force
|| iwl_is_associated(priv
)) {
570 IWL_DEBUG_QOS("send QoS cmd with Qos active=%d FLAGS=0x%X\n",
571 priv
->qos_data
.qos_active
,
572 priv
->qos_data
.def_qos_parm
.qos_flags
);
574 iwl_send_cmd_pdu_async(priv
, REPLY_QOS_PARAM
,
575 sizeof(struct iwl_qosparam_cmd
),
576 &priv
->qos_data
.def_qos_parm
, NULL
);
580 #define MAX_UCODE_BEACON_INTERVAL 4096
582 static u16
iwl_adjust_beacon_interval(u16 beacon_val
)
585 u16 beacon_factor
= 0;
587 beacon_factor
= (beacon_val
+ MAX_UCODE_BEACON_INTERVAL
)
588 / MAX_UCODE_BEACON_INTERVAL
;
589 new_val
= beacon_val
/ beacon_factor
;
594 static void iwl_setup_rxon_timing(struct iwl_priv
*priv
)
597 s32 interval_tm
, rem
;
599 struct ieee80211_conf
*conf
= NULL
;
602 conf
= ieee80211_get_hw_conf(priv
->hw
);
604 spin_lock_irqsave(&priv
->lock
, flags
);
605 priv
->rxon_timing
.timestamp
= cpu_to_le64(priv
->timestamp
);
606 priv
->rxon_timing
.listen_interval
= cpu_to_le16(conf
->listen_interval
);
608 if (priv
->iw_mode
== NL80211_IFTYPE_STATION
) {
609 beacon_int
= iwl_adjust_beacon_interval(priv
->beacon_int
);
610 priv
->rxon_timing
.atim_window
= 0;
612 beacon_int
= iwl_adjust_beacon_interval(conf
->beacon_int
);
614 /* TODO: we need to get atim_window from upper stack
615 * for now we set to 0 */
616 priv
->rxon_timing
.atim_window
= 0;
619 priv
->rxon_timing
.beacon_interval
= cpu_to_le16(beacon_int
);
621 tsf
= priv
->timestamp
; /* tsf is modifed by do_div: copy it */
622 interval_tm
= beacon_int
* 1024;
623 rem
= do_div(tsf
, interval_tm
);
624 priv
->rxon_timing
.beacon_init_val
= cpu_to_le32(interval_tm
- rem
);
626 spin_unlock_irqrestore(&priv
->lock
, flags
);
627 IWL_DEBUG_ASSOC("beacon interval %d beacon timer %d beacon tim %d\n",
628 le16_to_cpu(priv
->rxon_timing
.beacon_interval
),
629 le32_to_cpu(priv
->rxon_timing
.beacon_init_val
),
630 le16_to_cpu(priv
->rxon_timing
.atim_window
));
633 static void iwl_set_flags_for_band(struct iwl_priv
*priv
,
634 enum ieee80211_band band
)
636 if (band
== IEEE80211_BAND_5GHZ
) {
637 priv
->staging_rxon
.flags
&=
638 ~(RXON_FLG_BAND_24G_MSK
| RXON_FLG_AUTO_DETECT_MSK
640 priv
->staging_rxon
.flags
|= RXON_FLG_SHORT_SLOT_MSK
;
642 /* Copied from iwl_post_associate() */
643 if (priv
->assoc_capability
& WLAN_CAPABILITY_SHORT_SLOT_TIME
)
644 priv
->staging_rxon
.flags
|= RXON_FLG_SHORT_SLOT_MSK
;
646 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_SLOT_MSK
;
648 if (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
)
649 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_SLOT_MSK
;
651 priv
->staging_rxon
.flags
|= RXON_FLG_BAND_24G_MSK
;
652 priv
->staging_rxon
.flags
|= RXON_FLG_AUTO_DETECT_MSK
;
653 priv
->staging_rxon
.flags
&= ~RXON_FLG_CCK_MSK
;
658 * initialize rxon structure with default values from eeprom
660 static void iwl_connection_init_rx_config(struct iwl_priv
*priv
, int mode
)
662 const struct iwl_channel_info
*ch_info
;
664 memset(&priv
->staging_rxon
, 0, sizeof(priv
->staging_rxon
));
667 case NL80211_IFTYPE_AP
:
668 priv
->staging_rxon
.dev_type
= RXON_DEV_TYPE_AP
;
671 case NL80211_IFTYPE_STATION
:
672 priv
->staging_rxon
.dev_type
= RXON_DEV_TYPE_ESS
;
673 priv
->staging_rxon
.filter_flags
= RXON_FILTER_ACCEPT_GRP_MSK
;
676 case NL80211_IFTYPE_ADHOC
:
677 priv
->staging_rxon
.dev_type
= RXON_DEV_TYPE_IBSS
;
678 priv
->staging_rxon
.flags
= RXON_FLG_SHORT_PREAMBLE_MSK
;
679 priv
->staging_rxon
.filter_flags
= RXON_FILTER_BCON_AWARE_MSK
|
680 RXON_FILTER_ACCEPT_GRP_MSK
;
683 case NL80211_IFTYPE_MONITOR
:
684 priv
->staging_rxon
.dev_type
= RXON_DEV_TYPE_SNIFFER
;
685 priv
->staging_rxon
.filter_flags
= RXON_FILTER_PROMISC_MSK
|
686 RXON_FILTER_CTL2HOST_MSK
| RXON_FILTER_ACCEPT_GRP_MSK
;
689 IWL_ERROR("Unsupported interface type %d\n", mode
);
694 /* TODO: Figure out when short_preamble would be set and cache from
696 if (!hw_to_local(priv
->hw
)->short_preamble
)
697 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_PREAMBLE_MSK
;
699 priv
->staging_rxon
.flags
|= RXON_FLG_SHORT_PREAMBLE_MSK
;
702 ch_info
= iwl_get_channel_info(priv
, priv
->band
,
703 le16_to_cpu(priv
->active_rxon
.channel
));
706 ch_info
= &priv
->channel_info
[0];
709 * in some case A channels are all non IBSS
710 * in this case force B/G channel
712 if ((priv
->iw_mode
== NL80211_IFTYPE_ADHOC
) &&
713 !(is_channel_ibss(ch_info
)))
714 ch_info
= &priv
->channel_info
[0];
716 priv
->staging_rxon
.channel
= cpu_to_le16(ch_info
->channel
);
717 priv
->band
= ch_info
->band
;
719 iwl_set_flags_for_band(priv
, priv
->band
);
721 priv
->staging_rxon
.ofdm_basic_rates
=
722 (IWL_OFDM_RATES_MASK
>> IWL_FIRST_OFDM_RATE
) & 0xFF;
723 priv
->staging_rxon
.cck_basic_rates
=
724 (IWL_CCK_RATES_MASK
>> IWL_FIRST_CCK_RATE
) & 0xF;
726 priv
->staging_rxon
.flags
&= ~(RXON_FLG_CHANNEL_MODE_MIXED_MSK
|
727 RXON_FLG_CHANNEL_MODE_PURE_40_MSK
);
728 memcpy(priv
->staging_rxon
.node_addr
, priv
->mac_addr
, ETH_ALEN
);
729 memcpy(priv
->staging_rxon
.wlap_bssid_addr
, priv
->mac_addr
, ETH_ALEN
);
730 priv
->staging_rxon
.ofdm_ht_single_stream_basic_rates
= 0xff;
731 priv
->staging_rxon
.ofdm_ht_dual_stream_basic_rates
= 0xff;
732 iwl_set_rxon_chain(priv
);
735 static int iwl_set_mode(struct iwl_priv
*priv
, int mode
)
737 iwl_connection_init_rx_config(priv
, mode
);
738 memcpy(priv
->staging_rxon
.node_addr
, priv
->mac_addr
, ETH_ALEN
);
740 iwl_clear_stations_table(priv
);
742 /* dont commit rxon if rf-kill is on*/
743 if (!iwl_is_ready_rf(priv
))
746 cancel_delayed_work(&priv
->scan_check
);
747 if (iwl_scan_cancel_timeout(priv
, 100)) {
748 IWL_WARNING("Aborted scan still in progress after 100ms\n");
749 IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
753 iwl_commit_rxon(priv
);
758 static void iwl_set_rate(struct iwl_priv
*priv
)
760 const struct ieee80211_supported_band
*hw
= NULL
;
761 struct ieee80211_rate
*rate
;
764 hw
= iwl_get_hw_mode(priv
, priv
->band
);
766 IWL_ERROR("Failed to set rate: unable to get hw mode\n");
770 priv
->active_rate
= 0;
771 priv
->active_rate_basic
= 0;
773 for (i
= 0; i
< hw
->n_bitrates
; i
++) {
774 rate
= &(hw
->bitrates
[i
]);
775 if (rate
->hw_value
< IWL_RATE_COUNT
)
776 priv
->active_rate
|= (1 << rate
->hw_value
);
779 IWL_DEBUG_RATE("Set active_rate = %0x, active_rate_basic = %0x\n",
780 priv
->active_rate
, priv
->active_rate_basic
);
783 * If a basic rate is configured, then use it (adding IWL_RATE_1M_MASK)
784 * otherwise set it to the default of all CCK rates and 6, 12, 24 for
787 if (priv
->active_rate_basic
& IWL_CCK_BASIC_RATES_MASK
)
788 priv
->staging_rxon
.cck_basic_rates
=
789 ((priv
->active_rate_basic
&
790 IWL_CCK_RATES_MASK
) >> IWL_FIRST_CCK_RATE
) & 0xF;
792 priv
->staging_rxon
.cck_basic_rates
=
793 (IWL_CCK_BASIC_RATES_MASK
>> IWL_FIRST_CCK_RATE
) & 0xF;
795 if (priv
->active_rate_basic
& IWL_OFDM_BASIC_RATES_MASK
)
796 priv
->staging_rxon
.ofdm_basic_rates
=
797 ((priv
->active_rate_basic
&
798 (IWL_OFDM_BASIC_RATES_MASK
| IWL_RATE_6M_MASK
)) >>
799 IWL_FIRST_OFDM_RATE
) & 0xFF;
801 priv
->staging_rxon
.ofdm_basic_rates
=
802 (IWL_OFDM_BASIC_RATES_MASK
>> IWL_FIRST_OFDM_RATE
) & 0xFF;
806 /******************************************************************************
808 * Generic RX handler implementations
810 ******************************************************************************/
811 static void iwl_rx_reply_alive(struct iwl_priv
*priv
,
812 struct iwl_rx_mem_buffer
*rxb
)
814 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
815 struct iwl_alive_resp
*palive
;
816 struct delayed_work
*pwork
;
818 palive
= &pkt
->u
.alive_frame
;
820 IWL_DEBUG_INFO("Alive ucode status 0x%08X revision "
822 palive
->is_valid
, palive
->ver_type
,
823 palive
->ver_subtype
);
825 if (palive
->ver_subtype
== INITIALIZE_SUBTYPE
) {
826 IWL_DEBUG_INFO("Initialization Alive received.\n");
827 memcpy(&priv
->card_alive_init
,
829 sizeof(struct iwl_init_alive_resp
));
830 pwork
= &priv
->init_alive_start
;
832 IWL_DEBUG_INFO("Runtime Alive received.\n");
833 memcpy(&priv
->card_alive
, &pkt
->u
.alive_frame
,
834 sizeof(struct iwl_alive_resp
));
835 pwork
= &priv
->alive_start
;
838 /* We delay the ALIVE response by 5ms to
839 * give the HW RF Kill time to activate... */
840 if (palive
->is_valid
== UCODE_VALID_OK
)
841 queue_delayed_work(priv
->workqueue
, pwork
,
842 msecs_to_jiffies(5));
844 IWL_WARNING("uCode did not respond OK.\n");
847 static void iwl_rx_reply_error(struct iwl_priv
*priv
,
848 struct iwl_rx_mem_buffer
*rxb
)
850 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
852 IWL_ERROR("Error Reply type 0x%08X cmd %s (0x%02X) "
853 "seq 0x%04X ser 0x%08X\n",
854 le32_to_cpu(pkt
->u
.err_resp
.error_type
),
855 get_cmd_string(pkt
->u
.err_resp
.cmd_id
),
856 pkt
->u
.err_resp
.cmd_id
,
857 le16_to_cpu(pkt
->u
.err_resp
.bad_cmd_seq_num
),
858 le32_to_cpu(pkt
->u
.err_resp
.error_info
));
861 #define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x
863 static void iwl_rx_csa(struct iwl_priv
*priv
, struct iwl_rx_mem_buffer
*rxb
)
865 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
866 struct iwl_rxon_cmd
*rxon
= (void *)&priv
->active_rxon
;
867 struct iwl_csa_notification
*csa
= &(pkt
->u
.csa_notif
);
868 IWL_DEBUG_11H("CSA notif: channel %d, status %d\n",
869 le16_to_cpu(csa
->channel
), le32_to_cpu(csa
->status
));
870 rxon
->channel
= csa
->channel
;
871 priv
->staging_rxon
.channel
= csa
->channel
;
874 static void iwl_rx_pm_sleep_notif(struct iwl_priv
*priv
,
875 struct iwl_rx_mem_buffer
*rxb
)
877 #ifdef CONFIG_IWLWIFI_DEBUG
878 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
879 struct iwl_sleep_notification
*sleep
= &(pkt
->u
.sleep_notif
);
880 IWL_DEBUG_RX("sleep mode: %d, src: %d\n",
881 sleep
->pm_sleep_mode
, sleep
->pm_wakeup_src
);
885 static void iwl_rx_pm_debug_statistics_notif(struct iwl_priv
*priv
,
886 struct iwl_rx_mem_buffer
*rxb
)
888 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
889 IWL_DEBUG_RADIO("Dumping %d bytes of unhandled "
890 "notification for %s:\n",
891 le32_to_cpu(pkt
->len
), get_cmd_string(pkt
->hdr
.cmd
));
892 iwl_print_hex_dump(priv
, IWL_DL_RADIO
, pkt
->u
.raw
, le32_to_cpu(pkt
->len
));
895 static void iwl_bg_beacon_update(struct work_struct
*work
)
897 struct iwl_priv
*priv
=
898 container_of(work
, struct iwl_priv
, beacon_update
);
899 struct sk_buff
*beacon
;
901 /* Pull updated AP beacon from mac80211. will fail if not in AP mode */
902 beacon
= ieee80211_beacon_get(priv
->hw
, priv
->vif
);
905 IWL_ERROR("update beacon failed\n");
909 mutex_lock(&priv
->mutex
);
910 /* new beacon skb is allocated every time; dispose previous.*/
911 if (priv
->ibss_beacon
)
912 dev_kfree_skb(priv
->ibss_beacon
);
914 priv
->ibss_beacon
= beacon
;
915 mutex_unlock(&priv
->mutex
);
917 iwl_send_beacon_cmd(priv
);
921 * iwl_bg_statistics_periodic - Timer callback to queue statistics
923 * This callback is provided in order to send a statistics request.
925 * This timer function is continually reset to execute within
926 * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
927 * was received. We need to ensure we receive the statistics in order
928 * to update the temperature used for calibrating the TXPOWER.
930 static void iwl_bg_statistics_periodic(unsigned long data
)
932 struct iwl_priv
*priv
= (struct iwl_priv
*)data
;
934 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
937 /* dont send host command if rf-kill is on */
938 if (!iwl_is_ready_rf(priv
))
941 iwl_send_statistics_request(priv
, CMD_ASYNC
);
944 static void iwl_rx_beacon_notif(struct iwl_priv
*priv
,
945 struct iwl_rx_mem_buffer
*rxb
)
947 #ifdef CONFIG_IWLWIFI_DEBUG
948 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
949 struct iwl4965_beacon_notif
*beacon
=
950 (struct iwl4965_beacon_notif
*)pkt
->u
.raw
;
951 u8 rate
= iwl_hw_get_rate(beacon
->beacon_notify_hdr
.rate_n_flags
);
953 IWL_DEBUG_RX("beacon status %x retries %d iss %d "
954 "tsf %d %d rate %d\n",
955 le32_to_cpu(beacon
->beacon_notify_hdr
.u
.status
) & TX_STATUS_MSK
,
956 beacon
->beacon_notify_hdr
.failure_frame
,
957 le32_to_cpu(beacon
->ibss_mgr_status
),
958 le32_to_cpu(beacon
->high_tsf
),
959 le32_to_cpu(beacon
->low_tsf
), rate
);
962 if ((priv
->iw_mode
== NL80211_IFTYPE_AP
) &&
963 (!test_bit(STATUS_EXIT_PENDING
, &priv
->status
)))
964 queue_work(priv
->workqueue
, &priv
->beacon_update
);
967 /* Handle notification from uCode that card's power state is changing
968 * due to software, hardware, or critical temperature RFKILL */
969 static void iwl_rx_card_state_notif(struct iwl_priv
*priv
,
970 struct iwl_rx_mem_buffer
*rxb
)
972 struct iwl_rx_packet
*pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
973 u32 flags
= le32_to_cpu(pkt
->u
.card_state_notif
.flags
);
974 unsigned long status
= priv
->status
;
976 IWL_DEBUG_RF_KILL("Card state received: HW:%s SW:%s\n",
977 (flags
& HW_CARD_DISABLED
) ? "Kill" : "On",
978 (flags
& SW_CARD_DISABLED
) ? "Kill" : "On");
980 if (flags
& (SW_CARD_DISABLED
| HW_CARD_DISABLED
|
983 iwl_write32(priv
, CSR_UCODE_DRV_GP1_SET
,
984 CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED
);
986 if (!iwl_grab_nic_access(priv
)) {
988 priv
, HBUS_TARG_MBX_C
,
989 HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED
);
991 iwl_release_nic_access(priv
);
994 if (!(flags
& RXON_CARD_DISABLED
)) {
995 iwl_write32(priv
, CSR_UCODE_DRV_GP1_CLR
,
996 CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED
);
997 if (!iwl_grab_nic_access(priv
)) {
999 priv
, HBUS_TARG_MBX_C
,
1000 HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED
);
1002 iwl_release_nic_access(priv
);
1006 if (flags
& RF_CARD_DISABLED
) {
1007 iwl_write32(priv
, CSR_UCODE_DRV_GP1_SET
,
1008 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT
);
1009 iwl_read32(priv
, CSR_UCODE_DRV_GP1
);
1010 if (!iwl_grab_nic_access(priv
))
1011 iwl_release_nic_access(priv
);
1015 if (flags
& HW_CARD_DISABLED
)
1016 set_bit(STATUS_RF_KILL_HW
, &priv
->status
);
1018 clear_bit(STATUS_RF_KILL_HW
, &priv
->status
);
1021 if (flags
& SW_CARD_DISABLED
)
1022 set_bit(STATUS_RF_KILL_SW
, &priv
->status
);
1024 clear_bit(STATUS_RF_KILL_SW
, &priv
->status
);
1026 if (!(flags
& RXON_CARD_DISABLED
))
1027 iwl_scan_cancel(priv
);
1029 if ((test_bit(STATUS_RF_KILL_HW
, &status
) !=
1030 test_bit(STATUS_RF_KILL_HW
, &priv
->status
)) ||
1031 (test_bit(STATUS_RF_KILL_SW
, &status
) !=
1032 test_bit(STATUS_RF_KILL_SW
, &priv
->status
)))
1033 queue_work(priv
->workqueue
, &priv
->rf_kill
);
1035 wake_up_interruptible(&priv
->wait_command_queue
);
1038 int iwl_set_pwr_src(struct iwl_priv
*priv
, enum iwl_pwr_src src
)
1041 unsigned long flags
;
1043 spin_lock_irqsave(&priv
->lock
, flags
);
1044 ret
= iwl_grab_nic_access(priv
);
1048 if (src
== IWL_PWR_SRC_VAUX
) {
1050 ret
= pci_read_config_dword(priv
->pci_dev
, PCI_CFG_POWER_SOURCE
,
1053 if (val
& PCI_CFG_PMC_PME_FROM_D3COLD_SUPPORT
)
1054 iwl_set_bits_mask_prph(priv
, APMG_PS_CTRL_REG
,
1055 APMG_PS_CTRL_VAL_PWR_SRC_VAUX
,
1056 ~APMG_PS_CTRL_MSK_PWR_SRC
);
1058 iwl_set_bits_mask_prph(priv
, APMG_PS_CTRL_REG
,
1059 APMG_PS_CTRL_VAL_PWR_SRC_VMAIN
,
1060 ~APMG_PS_CTRL_MSK_PWR_SRC
);
1063 iwl_release_nic_access(priv
);
1065 spin_unlock_irqrestore(&priv
->lock
, flags
);
1070 * iwl_setup_rx_handlers - Initialize Rx handler callbacks
1072 * Setup the RX handlers for each of the reply types sent from the uCode
1075 * This function chains into the hardware specific files for them to setup
1076 * any hardware specific handlers as well.
1078 static void iwl_setup_rx_handlers(struct iwl_priv
*priv
)
1080 priv
->rx_handlers
[REPLY_ALIVE
] = iwl_rx_reply_alive
;
1081 priv
->rx_handlers
[REPLY_ERROR
] = iwl_rx_reply_error
;
1082 priv
->rx_handlers
[CHANNEL_SWITCH_NOTIFICATION
] = iwl_rx_csa
;
1083 priv
->rx_handlers
[PM_SLEEP_NOTIFICATION
] = iwl_rx_pm_sleep_notif
;
1084 priv
->rx_handlers
[PM_DEBUG_STATISTIC_NOTIFIC
] =
1085 iwl_rx_pm_debug_statistics_notif
;
1086 priv
->rx_handlers
[BEACON_NOTIFICATION
] = iwl_rx_beacon_notif
;
1089 * The same handler is used for both the REPLY to a discrete
1090 * statistics request from the host as well as for the periodic
1091 * statistics notifications (after received beacons) from the uCode.
1093 priv
->rx_handlers
[REPLY_STATISTICS_CMD
] = iwl_rx_statistics
;
1094 priv
->rx_handlers
[STATISTICS_NOTIFICATION
] = iwl_rx_statistics
;
1096 iwl_setup_spectrum_handlers(priv
);
1097 iwl_setup_rx_scan_handlers(priv
);
1099 /* status change handler */
1100 priv
->rx_handlers
[CARD_STATE_NOTIFICATION
] = iwl_rx_card_state_notif
;
1102 priv
->rx_handlers
[MISSED_BEACONS_NOTIFICATION
] =
1103 iwl_rx_missed_beacon_notif
;
1105 priv
->rx_handlers
[REPLY_RX_PHY_CMD
] = iwl_rx_reply_rx_phy
;
1106 priv
->rx_handlers
[REPLY_RX_MPDU_CMD
] = iwl_rx_reply_rx
;
1108 priv
->rx_handlers
[REPLY_COMPRESSED_BA
] = iwl_rx_reply_compressed_ba
;
1109 /* Set up hardware specific Rx handlers */
1110 priv
->cfg
->ops
->lib
->rx_handler_setup(priv
);
1114 * this should be called while priv->lock is locked
1116 static void __iwl_rx_replenish(struct iwl_priv
*priv
)
1118 iwl_rx_allocate(priv
);
1119 iwl_rx_queue_restock(priv
);
1124 * iwl_rx_handle - Main entry function for receiving responses from uCode
1126 * Uses the priv->rx_handlers callback function array to invoke
1127 * the appropriate handlers, including command responses,
1128 * frame-received notifications, and other notifications.
1130 void iwl_rx_handle(struct iwl_priv
*priv
)
1132 struct iwl_rx_mem_buffer
*rxb
;
1133 struct iwl_rx_packet
*pkt
;
1134 struct iwl_rx_queue
*rxq
= &priv
->rxq
;
1137 unsigned long flags
;
1141 /* uCode's read index (stored in shared DRAM) indicates the last Rx
1142 * buffer that the driver may process (last buffer filled by ucode). */
1143 r
= le16_to_cpu(rxq
->rb_stts
->closed_rb_num
) & 0x0FFF;
1146 /* Rx interrupt, but nothing sent from uCode */
1148 IWL_DEBUG(IWL_DL_RX
, "r = %d, i = %d\n", r
, i
);
1150 if (iwl_rx_queue_space(rxq
) > (RX_QUEUE_SIZE
/ 2))
1154 rxb
= rxq
->queue
[i
];
1156 /* If an RXB doesn't have a Rx queue slot associated with it,
1157 * then a bug has been introduced in the queue refilling
1158 * routines -- catch it here */
1159 BUG_ON(rxb
== NULL
);
1161 rxq
->queue
[i
] = NULL
;
1163 dma_sync_single_range_for_cpu(
1164 &priv
->pci_dev
->dev
, rxb
->real_dma_addr
,
1165 rxb
->aligned_dma_addr
- rxb
->real_dma_addr
,
1166 priv
->hw_params
.rx_buf_size
,
1167 PCI_DMA_FROMDEVICE
);
1168 pkt
= (struct iwl_rx_packet
*)rxb
->skb
->data
;
1170 /* Reclaim a command buffer only if this packet is a response
1171 * to a (driver-originated) command.
1172 * If the packet (e.g. Rx frame) originated from uCode,
1173 * there is no command buffer to reclaim.
1174 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
1175 * but apparently a few don't get set; catch them here. */
1176 reclaim
= !(pkt
->hdr
.sequence
& SEQ_RX_FRAME
) &&
1177 (pkt
->hdr
.cmd
!= REPLY_RX_PHY_CMD
) &&
1178 (pkt
->hdr
.cmd
!= REPLY_RX
) &&
1179 (pkt
->hdr
.cmd
!= REPLY_RX_MPDU_CMD
) &&
1180 (pkt
->hdr
.cmd
!= REPLY_COMPRESSED_BA
) &&
1181 (pkt
->hdr
.cmd
!= STATISTICS_NOTIFICATION
) &&
1182 (pkt
->hdr
.cmd
!= REPLY_TX
);
1184 /* Based on type of command response or notification,
1185 * handle those that need handling via function in
1186 * rx_handlers table. See iwl_setup_rx_handlers() */
1187 if (priv
->rx_handlers
[pkt
->hdr
.cmd
]) {
1188 IWL_DEBUG(IWL_DL_RX
, "r = %d, i = %d, %s, 0x%02x\n", r
,
1189 i
, get_cmd_string(pkt
->hdr
.cmd
), pkt
->hdr
.cmd
);
1190 priv
->rx_handlers
[pkt
->hdr
.cmd
] (priv
, rxb
);
1192 /* No handling needed */
1193 IWL_DEBUG(IWL_DL_RX
,
1194 "r %d i %d No handler needed for %s, 0x%02x\n",
1195 r
, i
, get_cmd_string(pkt
->hdr
.cmd
),
1200 /* Invoke any callbacks, transfer the skb to caller, and
1201 * fire off the (possibly) blocking iwl_send_cmd()
1202 * as we reclaim the driver command queue */
1203 if (rxb
&& rxb
->skb
)
1204 iwl_tx_cmd_complete(priv
, rxb
);
1206 IWL_WARNING("Claim null rxb?\n");
1209 /* For now we just don't re-use anything. We can tweak this
1210 * later to try and re-use notification packets and SKBs that
1211 * fail to Rx correctly */
1212 if (rxb
->skb
!= NULL
) {
1213 priv
->alloc_rxb_skb
--;
1214 dev_kfree_skb_any(rxb
->skb
);
1218 pci_unmap_single(priv
->pci_dev
, rxb
->real_dma_addr
,
1219 priv
->hw_params
.rx_buf_size
+ 256,
1220 PCI_DMA_FROMDEVICE
);
1221 spin_lock_irqsave(&rxq
->lock
, flags
);
1222 list_add_tail(&rxb
->list
, &priv
->rxq
.rx_used
);
1223 spin_unlock_irqrestore(&rxq
->lock
, flags
);
1224 i
= (i
+ 1) & RX_QUEUE_MASK
;
1225 /* If there are a lot of unused frames,
1226 * restock the Rx queue so ucode wont assert. */
1231 __iwl_rx_replenish(priv
);
1237 /* Backtrack one entry */
1239 iwl_rx_queue_restock(priv
);
1242 #ifdef CONFIG_IWLWIFI_DEBUG
1243 static void iwl_print_rx_config_cmd(struct iwl_priv
*priv
)
1245 struct iwl_rxon_cmd
*rxon
= &priv
->staging_rxon
;
1247 IWL_DEBUG_RADIO("RX CONFIG:\n");
1248 iwl_print_hex_dump(priv
, IWL_DL_RADIO
, (u8
*) rxon
, sizeof(*rxon
));
1249 IWL_DEBUG_RADIO("u16 channel: 0x%x\n", le16_to_cpu(rxon
->channel
));
1250 IWL_DEBUG_RADIO("u32 flags: 0x%08X\n", le32_to_cpu(rxon
->flags
));
1251 IWL_DEBUG_RADIO("u32 filter_flags: 0x%08x\n",
1252 le32_to_cpu(rxon
->filter_flags
));
1253 IWL_DEBUG_RADIO("u8 dev_type: 0x%x\n", rxon
->dev_type
);
1254 IWL_DEBUG_RADIO("u8 ofdm_basic_rates: 0x%02x\n",
1255 rxon
->ofdm_basic_rates
);
1256 IWL_DEBUG_RADIO("u8 cck_basic_rates: 0x%02x\n", rxon
->cck_basic_rates
);
1257 IWL_DEBUG_RADIO("u8[6] node_addr: %pM\n", rxon
->node_addr
);
1258 IWL_DEBUG_RADIO("u8[6] bssid_addr: %pM\n", rxon
->bssid_addr
);
1259 IWL_DEBUG_RADIO("u16 assoc_id: 0x%x\n", le16_to_cpu(rxon
->assoc_id
));
1263 /* call this function to flush any scheduled tasklet */
1264 static inline void iwl_synchronize_irq(struct iwl_priv
*priv
)
1266 /* wait to make sure we flush pending tasklet*/
1267 synchronize_irq(priv
->pci_dev
->irq
);
1268 tasklet_kill(&priv
->irq_tasklet
);
1272 * iwl_irq_handle_error - called for HW or SW error interrupt from card
1274 static void iwl_irq_handle_error(struct iwl_priv
*priv
)
1276 /* Set the FW error flag -- cleared on iwl_down */
1277 set_bit(STATUS_FW_ERROR
, &priv
->status
);
1279 /* Cancel currently queued command. */
1280 clear_bit(STATUS_HCMD_ACTIVE
, &priv
->status
);
1282 #ifdef CONFIG_IWLWIFI_DEBUG
1283 if (priv
->debug_level
& IWL_DL_FW_ERRORS
) {
1284 iwl_dump_nic_error_log(priv
);
1285 iwl_dump_nic_event_log(priv
);
1286 iwl_print_rx_config_cmd(priv
);
1290 wake_up_interruptible(&priv
->wait_command_queue
);
1292 /* Keep the restart process from trying to send host
1293 * commands by clearing the INIT status bit */
1294 clear_bit(STATUS_READY
, &priv
->status
);
1296 if (!test_bit(STATUS_EXIT_PENDING
, &priv
->status
)) {
1297 IWL_DEBUG(IWL_DL_FW_ERRORS
,
1298 "Restarting adapter due to uCode error.\n");
1300 if (iwl_is_associated(priv
)) {
1301 memcpy(&priv
->recovery_rxon
, &priv
->active_rxon
,
1302 sizeof(priv
->recovery_rxon
));
1303 priv
->error_recovering
= 1;
1305 if (priv
->cfg
->mod_params
->restart_fw
)
1306 queue_work(priv
->workqueue
, &priv
->restart
);
1310 static void iwl_error_recovery(struct iwl_priv
*priv
)
1312 unsigned long flags
;
1314 memcpy(&priv
->staging_rxon
, &priv
->recovery_rxon
,
1315 sizeof(priv
->staging_rxon
));
1316 priv
->staging_rxon
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
1317 iwl_commit_rxon(priv
);
1319 iwl_rxon_add_station(priv
, priv
->bssid
, 1);
1321 spin_lock_irqsave(&priv
->lock
, flags
);
1322 priv
->assoc_id
= le16_to_cpu(priv
->staging_rxon
.assoc_id
);
1323 priv
->error_recovering
= 0;
1324 spin_unlock_irqrestore(&priv
->lock
, flags
);
1327 static void iwl_irq_tasklet(struct iwl_priv
*priv
)
1329 u32 inta
, handled
= 0;
1331 unsigned long flags
;
1332 #ifdef CONFIG_IWLWIFI_DEBUG
1336 spin_lock_irqsave(&priv
->lock
, flags
);
1338 /* Ack/clear/reset pending uCode interrupts.
1339 * Note: Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
1340 * and will clear only when CSR_FH_INT_STATUS gets cleared. */
1341 inta
= iwl_read32(priv
, CSR_INT
);
1342 iwl_write32(priv
, CSR_INT
, inta
);
1344 /* Ack/clear/reset pending flow-handler (DMA) interrupts.
1345 * Any new interrupts that happen after this, either while we're
1346 * in this tasklet, or later, will show up in next ISR/tasklet. */
1347 inta_fh
= iwl_read32(priv
, CSR_FH_INT_STATUS
);
1348 iwl_write32(priv
, CSR_FH_INT_STATUS
, inta_fh
);
1350 #ifdef CONFIG_IWLWIFI_DEBUG
1351 if (priv
->debug_level
& IWL_DL_ISR
) {
1352 /* just for debug */
1353 inta_mask
= iwl_read32(priv
, CSR_INT_MASK
);
1354 IWL_DEBUG_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
1355 inta
, inta_mask
, inta_fh
);
1359 /* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
1360 * atomic, make sure that inta covers all the interrupts that
1361 * we've discovered, even if FH interrupt came in just after
1362 * reading CSR_INT. */
1363 if (inta_fh
& CSR49_FH_INT_RX_MASK
)
1364 inta
|= CSR_INT_BIT_FH_RX
;
1365 if (inta_fh
& CSR49_FH_INT_TX_MASK
)
1366 inta
|= CSR_INT_BIT_FH_TX
;
1368 /* Now service all interrupt bits discovered above. */
1369 if (inta
& CSR_INT_BIT_HW_ERR
) {
1370 IWL_ERROR("Microcode HW error detected. Restarting.\n");
1372 /* Tell the device to stop sending interrupts */
1373 iwl_disable_interrupts(priv
);
1375 iwl_irq_handle_error(priv
);
1377 handled
|= CSR_INT_BIT_HW_ERR
;
1379 spin_unlock_irqrestore(&priv
->lock
, flags
);
1384 #ifdef CONFIG_IWLWIFI_DEBUG
1385 if (priv
->debug_level
& (IWL_DL_ISR
)) {
1386 /* NIC fires this, but we don't use it, redundant with WAKEUP */
1387 if (inta
& CSR_INT_BIT_SCD
)
1388 IWL_DEBUG_ISR("Scheduler finished to transmit "
1389 "the frame/frames.\n");
1391 /* Alive notification via Rx interrupt will do the real work */
1392 if (inta
& CSR_INT_BIT_ALIVE
)
1393 IWL_DEBUG_ISR("Alive interrupt\n");
1396 /* Safely ignore these bits for debug checks below */
1397 inta
&= ~(CSR_INT_BIT_SCD
| CSR_INT_BIT_ALIVE
);
1399 /* HW RF KILL switch toggled */
1400 if (inta
& CSR_INT_BIT_RF_KILL
) {
1402 if (!(iwl_read32(priv
, CSR_GP_CNTRL
) &
1403 CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW
))
1406 IWL_DEBUG(IWL_DL_RF_KILL
, "RF_KILL bit toggled to %s.\n",
1407 hw_rf_kill
? "disable radio" : "enable radio");
1409 /* driver only loads ucode once setting the interface up.
1410 * the driver as well won't allow loading if RFKILL is set
1411 * therefore no need to restart the driver from this handler
1413 if (!hw_rf_kill
&& !test_bit(STATUS_ALIVE
, &priv
->status
)) {
1414 clear_bit(STATUS_RF_KILL_HW
, &priv
->status
);
1415 if (priv
->is_open
&& !iwl_is_rfkill(priv
))
1416 queue_work(priv
->workqueue
, &priv
->up
);
1419 handled
|= CSR_INT_BIT_RF_KILL
;
1422 /* Chip got too hot and stopped itself */
1423 if (inta
& CSR_INT_BIT_CT_KILL
) {
1424 IWL_ERROR("Microcode CT kill error detected.\n");
1425 handled
|= CSR_INT_BIT_CT_KILL
;
1428 /* Error detected by uCode */
1429 if (inta
& CSR_INT_BIT_SW_ERR
) {
1430 IWL_ERROR("Microcode SW error detected. Restarting 0x%X.\n",
1432 iwl_irq_handle_error(priv
);
1433 handled
|= CSR_INT_BIT_SW_ERR
;
1436 /* uCode wakes up after power-down sleep */
1437 if (inta
& CSR_INT_BIT_WAKEUP
) {
1438 IWL_DEBUG_ISR("Wakeup interrupt\n");
1439 iwl_rx_queue_update_write_ptr(priv
, &priv
->rxq
);
1440 iwl_txq_update_write_ptr(priv
, &priv
->txq
[0]);
1441 iwl_txq_update_write_ptr(priv
, &priv
->txq
[1]);
1442 iwl_txq_update_write_ptr(priv
, &priv
->txq
[2]);
1443 iwl_txq_update_write_ptr(priv
, &priv
->txq
[3]);
1444 iwl_txq_update_write_ptr(priv
, &priv
->txq
[4]);
1445 iwl_txq_update_write_ptr(priv
, &priv
->txq
[5]);
1447 handled
|= CSR_INT_BIT_WAKEUP
;
1450 /* All uCode command responses, including Tx command responses,
1451 * Rx "responses" (frame-received notification), and other
1452 * notifications from uCode come through here*/
1453 if (inta
& (CSR_INT_BIT_FH_RX
| CSR_INT_BIT_SW_RX
)) {
1454 iwl_rx_handle(priv
);
1455 handled
|= (CSR_INT_BIT_FH_RX
| CSR_INT_BIT_SW_RX
);
1458 if (inta
& CSR_INT_BIT_FH_TX
) {
1459 IWL_DEBUG_ISR("Tx interrupt\n");
1460 handled
|= CSR_INT_BIT_FH_TX
;
1461 /* FH finished to write, send event */
1462 priv
->ucode_write_complete
= 1;
1463 wake_up_interruptible(&priv
->wait_command_queue
);
1466 if (inta
& ~handled
)
1467 IWL_ERROR("Unhandled INTA bits 0x%08x\n", inta
& ~handled
);
1469 if (inta
& ~CSR_INI_SET_MASK
) {
1470 IWL_WARNING("Disabled INTA bits 0x%08x were pending\n",
1471 inta
& ~CSR_INI_SET_MASK
);
1472 IWL_WARNING(" with FH_INT = 0x%08x\n", inta_fh
);
1475 /* Re-enable all interrupts */
1476 /* only Re-enable if diabled by irq */
1477 if (test_bit(STATUS_INT_ENABLED
, &priv
->status
))
1478 iwl_enable_interrupts(priv
);
1480 #ifdef CONFIG_IWLWIFI_DEBUG
1481 if (priv
->debug_level
& (IWL_DL_ISR
)) {
1482 inta
= iwl_read32(priv
, CSR_INT
);
1483 inta_mask
= iwl_read32(priv
, CSR_INT_MASK
);
1484 inta_fh
= iwl_read32(priv
, CSR_FH_INT_STATUS
);
1485 IWL_DEBUG_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
1486 "flags 0x%08lx\n", inta
, inta_mask
, inta_fh
, flags
);
1489 spin_unlock_irqrestore(&priv
->lock
, flags
);
1492 static irqreturn_t
iwl_isr(int irq
, void *data
)
1494 struct iwl_priv
*priv
= data
;
1495 u32 inta
, inta_mask
;
1500 spin_lock(&priv
->lock
);
1502 /* Disable (but don't clear!) interrupts here to avoid
1503 * back-to-back ISRs and sporadic interrupts from our NIC.
1504 * If we have something to service, the tasklet will re-enable ints.
1505 * If we *don't* have something, we'll re-enable before leaving here. */
1506 inta_mask
= iwl_read32(priv
, CSR_INT_MASK
); /* just for debug */
1507 iwl_write32(priv
, CSR_INT_MASK
, 0x00000000);
1509 /* Discover which interrupts are active/pending */
1510 inta
= iwl_read32(priv
, CSR_INT
);
1511 inta_fh
= iwl_read32(priv
, CSR_FH_INT_STATUS
);
1513 /* Ignore interrupt if there's nothing in NIC to service.
1514 * This may be due to IRQ shared with another device,
1515 * or due to sporadic interrupts thrown from our NIC. */
1516 if (!inta
&& !inta_fh
) {
1517 IWL_DEBUG_ISR("Ignore interrupt, inta == 0, inta_fh == 0\n");
1521 if ((inta
== 0xFFFFFFFF) || ((inta
& 0xFFFFFFF0) == 0xa5a5a5a0)) {
1522 /* Hardware disappeared. It might have already raised
1524 IWL_WARNING("HARDWARE GONE?? INTA == 0x%08x\n", inta
);
1528 IWL_DEBUG_ISR("ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
1529 inta
, inta_mask
, inta_fh
);
1531 inta
&= ~CSR_INT_BIT_SCD
;
1533 /* iwl_irq_tasklet() will service interrupts and re-enable them */
1534 if (likely(inta
|| inta_fh
))
1535 tasklet_schedule(&priv
->irq_tasklet
);
1538 spin_unlock(&priv
->lock
);
1542 /* re-enable interrupts here since we don't have anything to service. */
1543 /* only Re-enable if diabled by irq */
1544 if (test_bit(STATUS_INT_ENABLED
, &priv
->status
))
1545 iwl_enable_interrupts(priv
);
1546 spin_unlock(&priv
->lock
);
1550 /******************************************************************************
1552 * uCode download functions
1554 ******************************************************************************/
1556 static void iwl_dealloc_ucode_pci(struct iwl_priv
*priv
)
1558 iwl_free_fw_desc(priv
->pci_dev
, &priv
->ucode_code
);
1559 iwl_free_fw_desc(priv
->pci_dev
, &priv
->ucode_data
);
1560 iwl_free_fw_desc(priv
->pci_dev
, &priv
->ucode_data_backup
);
1561 iwl_free_fw_desc(priv
->pci_dev
, &priv
->ucode_init
);
1562 iwl_free_fw_desc(priv
->pci_dev
, &priv
->ucode_init_data
);
1563 iwl_free_fw_desc(priv
->pci_dev
, &priv
->ucode_boot
);
1566 static void iwl_nic_start(struct iwl_priv
*priv
)
1568 /* Remove all resets to allow NIC to operate */
1569 iwl_write32(priv
, CSR_RESET
, 0);
1574 * iwl_read_ucode - Read uCode images from disk file.
1576 * Copy into buffers for card to fetch via bus-mastering
1578 static int iwl_read_ucode(struct iwl_priv
*priv
)
1580 struct iwl_ucode
*ucode
;
1581 int ret
= -EINVAL
, index
;
1582 const struct firmware
*ucode_raw
;
1583 const char *name_pre
= priv
->cfg
->fw_name_pre
;
1584 const unsigned int api_max
= priv
->cfg
->ucode_api_max
;
1585 const unsigned int api_min
= priv
->cfg
->ucode_api_min
;
1589 u32 api_ver
, inst_size
, data_size
, init_size
, init_data_size
, boot_size
;
1591 /* Ask kernel firmware_class module to get the boot firmware off disk.
1592 * request_firmware() is synchronous, file is in memory on return. */
1593 for (index
= api_max
; index
>= api_min
; index
--) {
1594 sprintf(buf
, "%s%d%s", name_pre
, index
, ".ucode");
1595 ret
= request_firmware(&ucode_raw
, buf
, &priv
->pci_dev
->dev
);
1597 IWL_ERROR("%s firmware file req failed: Reason %d\n",
1604 if (index
< api_max
)
1605 IWL_ERROR("Loaded firmware %s, which is deprecated. Please use API v%u instead.\n",
1607 IWL_DEBUG_INFO("Got firmware '%s' file (%zd bytes) from disk\n",
1608 buf
, ucode_raw
->size
);
1616 /* Make sure that we got at least our header! */
1617 if (ucode_raw
->size
< sizeof(*ucode
)) {
1618 IWL_ERROR("File size way too small!\n");
1623 /* Data from ucode file: header followed by uCode images */
1624 ucode
= (void *)ucode_raw
->data
;
1626 priv
->ucode_ver
= le32_to_cpu(ucode
->ver
);
1627 api_ver
= IWL_UCODE_API(priv
->ucode_ver
);
1628 inst_size
= le32_to_cpu(ucode
->inst_size
);
1629 data_size
= le32_to_cpu(ucode
->data_size
);
1630 init_size
= le32_to_cpu(ucode
->init_size
);
1631 init_data_size
= le32_to_cpu(ucode
->init_data_size
);
1632 boot_size
= le32_to_cpu(ucode
->boot_size
);
1634 /* api_ver should match the api version forming part of the
1635 * firmware filename ... but we don't check for that and only rely
1636 * on the API version read from firware header from here on forward */
1638 if (api_ver
< api_min
|| api_ver
> api_max
) {
1639 IWL_ERROR("Driver unable to support your firmware API. "
1640 "Driver supports v%u, firmware is v%u.\n",
1642 priv
->ucode_ver
= 0;
1646 if (api_ver
!= api_max
)
1647 IWL_ERROR("Firmware has old API version. Expected v%u, "
1648 "got v%u. New firmware can be obtained "
1649 "from http://www.intellinuxwireless.org.\n",
1652 printk(KERN_INFO DRV_NAME
" loaded firmware version %u.%u.%u.%u\n",
1653 IWL_UCODE_MAJOR(priv
->ucode_ver
),
1654 IWL_UCODE_MINOR(priv
->ucode_ver
),
1655 IWL_UCODE_API(priv
->ucode_ver
),
1656 IWL_UCODE_SERIAL(priv
->ucode_ver
));
1658 IWL_DEBUG_INFO("f/w package hdr ucode version raw = 0x%x\n",
1660 IWL_DEBUG_INFO("f/w package hdr runtime inst size = %u\n",
1662 IWL_DEBUG_INFO("f/w package hdr runtime data size = %u\n",
1664 IWL_DEBUG_INFO("f/w package hdr init inst size = %u\n",
1666 IWL_DEBUG_INFO("f/w package hdr init data size = %u\n",
1668 IWL_DEBUG_INFO("f/w package hdr boot inst size = %u\n",
1671 /* Verify size of file vs. image size info in file's header */
1672 if (ucode_raw
->size
< sizeof(*ucode
) +
1673 inst_size
+ data_size
+ init_size
+
1674 init_data_size
+ boot_size
) {
1676 IWL_DEBUG_INFO("uCode file size %d too small\n",
1677 (int)ucode_raw
->size
);
1682 /* Verify that uCode images will fit in card's SRAM */
1683 if (inst_size
> priv
->hw_params
.max_inst_size
) {
1684 IWL_DEBUG_INFO("uCode instr len %d too large to fit in\n",
1690 if (data_size
> priv
->hw_params
.max_data_size
) {
1691 IWL_DEBUG_INFO("uCode data len %d too large to fit in\n",
1696 if (init_size
> priv
->hw_params
.max_inst_size
) {
1698 ("uCode init instr len %d too large to fit in\n",
1703 if (init_data_size
> priv
->hw_params
.max_data_size
) {
1705 ("uCode init data len %d too large to fit in\n",
1710 if (boot_size
> priv
->hw_params
.max_bsm_size
) {
1712 ("uCode boot instr len %d too large to fit in\n",
1718 /* Allocate ucode buffers for card's bus-master loading ... */
1720 /* Runtime instructions and 2 copies of data:
1721 * 1) unmodified from disk
1722 * 2) backup cache for save/restore during power-downs */
1723 priv
->ucode_code
.len
= inst_size
;
1724 iwl_alloc_fw_desc(priv
->pci_dev
, &priv
->ucode_code
);
1726 priv
->ucode_data
.len
= data_size
;
1727 iwl_alloc_fw_desc(priv
->pci_dev
, &priv
->ucode_data
);
1729 priv
->ucode_data_backup
.len
= data_size
;
1730 iwl_alloc_fw_desc(priv
->pci_dev
, &priv
->ucode_data_backup
);
1732 /* Initialization instructions and data */
1733 if (init_size
&& init_data_size
) {
1734 priv
->ucode_init
.len
= init_size
;
1735 iwl_alloc_fw_desc(priv
->pci_dev
, &priv
->ucode_init
);
1737 priv
->ucode_init_data
.len
= init_data_size
;
1738 iwl_alloc_fw_desc(priv
->pci_dev
, &priv
->ucode_init_data
);
1740 if (!priv
->ucode_init
.v_addr
|| !priv
->ucode_init_data
.v_addr
)
1744 /* Bootstrap (instructions only, no data) */
1746 priv
->ucode_boot
.len
= boot_size
;
1747 iwl_alloc_fw_desc(priv
->pci_dev
, &priv
->ucode_boot
);
1749 if (!priv
->ucode_boot
.v_addr
)
1753 /* Copy images into buffers for card's bus-master reads ... */
1755 /* Runtime instructions (first block of data in file) */
1756 src
= &ucode
->data
[0];
1757 len
= priv
->ucode_code
.len
;
1758 IWL_DEBUG_INFO("Copying (but not loading) uCode instr len %Zd\n", len
);
1759 memcpy(priv
->ucode_code
.v_addr
, src
, len
);
1760 IWL_DEBUG_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
1761 priv
->ucode_code
.v_addr
, (u32
)priv
->ucode_code
.p_addr
);
1763 /* Runtime data (2nd block)
1764 * NOTE: Copy into backup buffer will be done in iwl_up() */
1765 src
= &ucode
->data
[inst_size
];
1766 len
= priv
->ucode_data
.len
;
1767 IWL_DEBUG_INFO("Copying (but not loading) uCode data len %Zd\n", len
);
1768 memcpy(priv
->ucode_data
.v_addr
, src
, len
);
1769 memcpy(priv
->ucode_data_backup
.v_addr
, src
, len
);
1771 /* Initialization instructions (3rd block) */
1773 src
= &ucode
->data
[inst_size
+ data_size
];
1774 len
= priv
->ucode_init
.len
;
1775 IWL_DEBUG_INFO("Copying (but not loading) init instr len %Zd\n",
1777 memcpy(priv
->ucode_init
.v_addr
, src
, len
);
1780 /* Initialization data (4th block) */
1781 if (init_data_size
) {
1782 src
= &ucode
->data
[inst_size
+ data_size
+ init_size
];
1783 len
= priv
->ucode_init_data
.len
;
1784 IWL_DEBUG_INFO("Copying (but not loading) init data len %Zd\n",
1786 memcpy(priv
->ucode_init_data
.v_addr
, src
, len
);
1789 /* Bootstrap instructions (5th block) */
1790 src
= &ucode
->data
[inst_size
+ data_size
+ init_size
+ init_data_size
];
1791 len
= priv
->ucode_boot
.len
;
1792 IWL_DEBUG_INFO("Copying (but not loading) boot instr len %Zd\n", len
);
1793 memcpy(priv
->ucode_boot
.v_addr
, src
, len
);
1795 /* We have our copies now, allow OS release its copies */
1796 release_firmware(ucode_raw
);
1800 IWL_ERROR("failed to allocate pci memory\n");
1802 iwl_dealloc_ucode_pci(priv
);
1805 release_firmware(ucode_raw
);
1812 static int iwl_mac_beacon_update(struct ieee80211_hw
*hw
,
1813 struct sk_buff
*skb
);
1816 * iwl_alive_start - called after REPLY_ALIVE notification received
1817 * from protocol/runtime uCode (initialization uCode's
1818 * Alive gets handled by iwl_init_alive_start()).
1820 static void iwl_alive_start(struct iwl_priv
*priv
)
1824 IWL_DEBUG_INFO("Runtime Alive received.\n");
1826 if (priv
->card_alive
.is_valid
!= UCODE_VALID_OK
) {
1827 /* We had an error bringing up the hardware, so take it
1828 * all the way back down so we can try again */
1829 IWL_DEBUG_INFO("Alive failed.\n");
1833 /* Initialize uCode has loaded Runtime uCode ... verify inst image.
1834 * This is a paranoid check, because we would not have gotten the
1835 * "runtime" alive if code weren't properly loaded. */
1836 if (iwl_verify_ucode(priv
)) {
1837 /* Runtime instruction load was bad;
1838 * take it all the way back down so we can try again */
1839 IWL_DEBUG_INFO("Bad runtime uCode load.\n");
1843 iwl_clear_stations_table(priv
);
1844 ret
= priv
->cfg
->ops
->lib
->alive_notify(priv
);
1846 IWL_WARNING("Could not complete ALIVE transition [ntf]: %d\n",
1851 /* After the ALIVE response, we can send host commands to the uCode */
1852 set_bit(STATUS_ALIVE
, &priv
->status
);
1854 if (iwl_is_rfkill(priv
))
1857 ieee80211_wake_queues(priv
->hw
);
1859 priv
->active_rate
= priv
->rates_mask
;
1860 priv
->active_rate_basic
= priv
->rates_mask
& IWL_BASIC_RATES_MASK
;
1862 if (iwl_is_associated(priv
)) {
1863 struct iwl_rxon_cmd
*active_rxon
=
1864 (struct iwl_rxon_cmd
*)&priv
->active_rxon
;
1866 memcpy(&priv
->staging_rxon
, &priv
->active_rxon
,
1867 sizeof(priv
->staging_rxon
));
1868 active_rxon
->filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
1870 /* Initialize our rx_config data */
1871 iwl_connection_init_rx_config(priv
, priv
->iw_mode
);
1872 memcpy(priv
->staging_rxon
.node_addr
, priv
->mac_addr
, ETH_ALEN
);
1875 /* Configure Bluetooth device coexistence support */
1876 iwl_send_bt_config(priv
);
1878 iwl_reset_run_time_calib(priv
);
1880 /* Configure the adapter for unassociated operation */
1881 iwl_commit_rxon(priv
);
1883 /* At this point, the NIC is initialized and operational */
1884 iwl_rf_kill_ct_config(priv
);
1886 iwl_leds_register(priv
);
1888 IWL_DEBUG_INFO("ALIVE processing complete.\n");
1889 set_bit(STATUS_READY
, &priv
->status
);
1890 wake_up_interruptible(&priv
->wait_command_queue
);
1892 if (priv
->error_recovering
)
1893 iwl_error_recovery(priv
);
1895 iwl_power_update_mode(priv
, 1);
1897 /* reassociate for ADHOC mode */
1898 if (priv
->vif
&& (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
)) {
1899 struct sk_buff
*beacon
= ieee80211_beacon_get(priv
->hw
,
1902 iwl_mac_beacon_update(priv
->hw
, beacon
);
1906 if (test_and_clear_bit(STATUS_MODE_PENDING
, &priv
->status
))
1907 iwl_set_mode(priv
, priv
->iw_mode
);
1912 queue_work(priv
->workqueue
, &priv
->restart
);
1915 static void iwl_cancel_deferred_work(struct iwl_priv
*priv
);
1917 static void __iwl_down(struct iwl_priv
*priv
)
1919 unsigned long flags
;
1920 int exit_pending
= test_bit(STATUS_EXIT_PENDING
, &priv
->status
);
1922 IWL_DEBUG_INFO(DRV_NAME
" is going down\n");
1925 set_bit(STATUS_EXIT_PENDING
, &priv
->status
);
1927 iwl_leds_unregister(priv
);
1929 iwl_clear_stations_table(priv
);
1931 /* Unblock any waiting calls */
1932 wake_up_interruptible_all(&priv
->wait_command_queue
);
1934 /* Wipe out the EXIT_PENDING status bit if we are not actually
1935 * exiting the module */
1937 clear_bit(STATUS_EXIT_PENDING
, &priv
->status
);
1939 /* stop and reset the on-board processor */
1940 iwl_write32(priv
, CSR_RESET
, CSR_RESET_REG_FLAG_NEVO_RESET
);
1942 /* tell the device to stop sending interrupts */
1943 spin_lock_irqsave(&priv
->lock
, flags
);
1944 iwl_disable_interrupts(priv
);
1945 spin_unlock_irqrestore(&priv
->lock
, flags
);
1946 iwl_synchronize_irq(priv
);
1948 if (priv
->mac80211_registered
)
1949 ieee80211_stop_queues(priv
->hw
);
1951 /* If we have not previously called iwl_init() then
1952 * clear all bits but the RF Kill and SUSPEND bits and return */
1953 if (!iwl_is_init(priv
)) {
1954 priv
->status
= test_bit(STATUS_RF_KILL_HW
, &priv
->status
) <<
1956 test_bit(STATUS_RF_KILL_SW
, &priv
->status
) <<
1958 test_bit(STATUS_GEO_CONFIGURED
, &priv
->status
) <<
1959 STATUS_GEO_CONFIGURED
|
1960 test_bit(STATUS_IN_SUSPEND
, &priv
->status
) <<
1962 test_bit(STATUS_EXIT_PENDING
, &priv
->status
) <<
1963 STATUS_EXIT_PENDING
;
1967 /* ...otherwise clear out all the status bits but the RF Kill and
1968 * SUSPEND bits and continue taking the NIC down. */
1969 priv
->status
&= test_bit(STATUS_RF_KILL_HW
, &priv
->status
) <<
1971 test_bit(STATUS_RF_KILL_SW
, &priv
->status
) <<
1973 test_bit(STATUS_GEO_CONFIGURED
, &priv
->status
) <<
1974 STATUS_GEO_CONFIGURED
|
1975 test_bit(STATUS_IN_SUSPEND
, &priv
->status
) <<
1977 test_bit(STATUS_FW_ERROR
, &priv
->status
) <<
1979 test_bit(STATUS_EXIT_PENDING
, &priv
->status
) <<
1980 STATUS_EXIT_PENDING
;
1982 spin_lock_irqsave(&priv
->lock
, flags
);
1983 iwl_clear_bit(priv
, CSR_GP_CNTRL
,
1984 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ
);
1985 spin_unlock_irqrestore(&priv
->lock
, flags
);
1987 iwl_txq_ctx_stop(priv
);
1990 spin_lock_irqsave(&priv
->lock
, flags
);
1991 if (!iwl_grab_nic_access(priv
)) {
1992 iwl_write_prph(priv
, APMG_CLK_DIS_REG
,
1993 APMG_CLK_VAL_DMA_CLK_RQT
);
1994 iwl_release_nic_access(priv
);
1996 spin_unlock_irqrestore(&priv
->lock
, flags
);
2000 /* FIXME: apm_ops.suspend(priv) */
2001 if (exit_pending
|| test_bit(STATUS_IN_SUSPEND
, &priv
->status
))
2002 priv
->cfg
->ops
->lib
->apm_ops
.stop(priv
);
2004 priv
->cfg
->ops
->lib
->apm_ops
.reset(priv
);
2006 memset(&priv
->card_alive
, 0, sizeof(struct iwl_alive_resp
));
2008 if (priv
->ibss_beacon
)
2009 dev_kfree_skb(priv
->ibss_beacon
);
2010 priv
->ibss_beacon
= NULL
;
2012 /* clear out any free frames */
2013 iwl_clear_free_frames(priv
);
2016 static void iwl_down(struct iwl_priv
*priv
)
2018 mutex_lock(&priv
->mutex
);
2020 mutex_unlock(&priv
->mutex
);
2022 iwl_cancel_deferred_work(priv
);
2025 #define MAX_HW_RESTARTS 5
2027 static int __iwl_up(struct iwl_priv
*priv
)
2032 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
)) {
2033 IWL_WARNING("Exit pending; will not bring the NIC up\n");
2037 if (!priv
->ucode_data_backup
.v_addr
|| !priv
->ucode_data
.v_addr
) {
2038 IWL_ERROR("ucode not available for device bringup\n");
2042 /* If platform's RF_KILL switch is NOT set to KILL */
2043 if (iwl_read32(priv
, CSR_GP_CNTRL
) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW
)
2044 clear_bit(STATUS_RF_KILL_HW
, &priv
->status
);
2046 set_bit(STATUS_RF_KILL_HW
, &priv
->status
);
2048 if (iwl_is_rfkill(priv
)) {
2049 iwl_enable_interrupts(priv
);
2050 IWL_WARNING("Radio disabled by %s RF Kill switch\n",
2051 test_bit(STATUS_RF_KILL_HW
, &priv
->status
) ? "HW" : "SW");
2055 iwl_write32(priv
, CSR_INT
, 0xFFFFFFFF);
2057 ret
= iwl_hw_nic_init(priv
);
2059 IWL_ERROR("Unable to init nic\n");
2063 /* make sure rfkill handshake bits are cleared */
2064 iwl_write32(priv
, CSR_UCODE_DRV_GP1_CLR
, CSR_UCODE_SW_BIT_RFKILL
);
2065 iwl_write32(priv
, CSR_UCODE_DRV_GP1_CLR
,
2066 CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED
);
2068 /* clear (again), then enable host interrupts */
2069 iwl_write32(priv
, CSR_INT
, 0xFFFFFFFF);
2070 iwl_enable_interrupts(priv
);
2072 /* really make sure rfkill handshake bits are cleared */
2073 iwl_write32(priv
, CSR_UCODE_DRV_GP1_CLR
, CSR_UCODE_SW_BIT_RFKILL
);
2074 iwl_write32(priv
, CSR_UCODE_DRV_GP1_CLR
, CSR_UCODE_SW_BIT_RFKILL
);
2076 /* Copy original ucode data image from disk into backup cache.
2077 * This will be used to initialize the on-board processor's
2078 * data SRAM for a clean start when the runtime program first loads. */
2079 memcpy(priv
->ucode_data_backup
.v_addr
, priv
->ucode_data
.v_addr
,
2080 priv
->ucode_data
.len
);
2082 for (i
= 0; i
< MAX_HW_RESTARTS
; i
++) {
2084 iwl_clear_stations_table(priv
);
2086 /* load bootstrap state machine,
2087 * load bootstrap program into processor's memory,
2088 * prepare to load the "initialize" uCode */
2089 ret
= priv
->cfg
->ops
->lib
->load_ucode(priv
);
2092 IWL_ERROR("Unable to set up bootstrap uCode: %d\n", ret
);
2096 /* Clear out the uCode error bit if it is set */
2097 clear_bit(STATUS_FW_ERROR
, &priv
->status
);
2099 /* start card; "initialize" will load runtime ucode */
2100 iwl_nic_start(priv
);
2102 IWL_DEBUG_INFO(DRV_NAME
" is coming up\n");
2107 set_bit(STATUS_EXIT_PENDING
, &priv
->status
);
2109 clear_bit(STATUS_EXIT_PENDING
, &priv
->status
);
2111 /* tried to restart and config the device for as long as our
2112 * patience could withstand */
2113 IWL_ERROR("Unable to initialize device after %d attempts.\n", i
);
2118 /*****************************************************************************
2120 * Workqueue callbacks
2122 *****************************************************************************/
2124 static void iwl_bg_init_alive_start(struct work_struct
*data
)
2126 struct iwl_priv
*priv
=
2127 container_of(data
, struct iwl_priv
, init_alive_start
.work
);
2129 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2132 mutex_lock(&priv
->mutex
);
2133 priv
->cfg
->ops
->lib
->init_alive_start(priv
);
2134 mutex_unlock(&priv
->mutex
);
2137 static void iwl_bg_alive_start(struct work_struct
*data
)
2139 struct iwl_priv
*priv
=
2140 container_of(data
, struct iwl_priv
, alive_start
.work
);
2142 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2145 mutex_lock(&priv
->mutex
);
2146 iwl_alive_start(priv
);
2147 mutex_unlock(&priv
->mutex
);
2150 static void iwl_bg_rf_kill(struct work_struct
*work
)
2152 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
, rf_kill
);
2154 wake_up_interruptible(&priv
->wait_command_queue
);
2156 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2159 mutex_lock(&priv
->mutex
);
2161 if (!iwl_is_rfkill(priv
)) {
2162 IWL_DEBUG(IWL_DL_RF_KILL
,
2163 "HW and/or SW RF Kill no longer active, restarting "
2165 if (!test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2166 queue_work(priv
->workqueue
, &priv
->restart
);
2168 /* make sure mac80211 stop sending Tx frame */
2169 if (priv
->mac80211_registered
)
2170 ieee80211_stop_queues(priv
->hw
);
2172 if (!test_bit(STATUS_RF_KILL_HW
, &priv
->status
))
2173 IWL_DEBUG_RF_KILL("Can not turn radio back on - "
2174 "disabled by SW switch\n");
2176 IWL_WARNING("Radio Frequency Kill Switch is On:\n"
2177 "Kill switch must be turned off for "
2178 "wireless networking to work.\n");
2180 mutex_unlock(&priv
->mutex
);
2181 iwl_rfkill_set_hw_state(priv
);
2184 static void iwl_bg_run_time_calib_work(struct work_struct
*work
)
2186 struct iwl_priv
*priv
= container_of(work
, struct iwl_priv
,
2187 run_time_calib_work
);
2189 mutex_lock(&priv
->mutex
);
2191 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
) ||
2192 test_bit(STATUS_SCANNING
, &priv
->status
)) {
2193 mutex_unlock(&priv
->mutex
);
2197 if (priv
->start_calib
) {
2198 iwl_chain_noise_calibration(priv
, &priv
->statistics
);
2200 iwl_sensitivity_calibration(priv
, &priv
->statistics
);
2203 mutex_unlock(&priv
->mutex
);
2207 static void iwl_bg_up(struct work_struct
*data
)
2209 struct iwl_priv
*priv
= container_of(data
, struct iwl_priv
, up
);
2211 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2214 mutex_lock(&priv
->mutex
);
2216 mutex_unlock(&priv
->mutex
);
2217 iwl_rfkill_set_hw_state(priv
);
2220 static void iwl_bg_restart(struct work_struct
*data
)
2222 struct iwl_priv
*priv
= container_of(data
, struct iwl_priv
, restart
);
2224 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2228 queue_work(priv
->workqueue
, &priv
->up
);
2231 static void iwl_bg_rx_replenish(struct work_struct
*data
)
2233 struct iwl_priv
*priv
=
2234 container_of(data
, struct iwl_priv
, rx_replenish
);
2236 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2239 mutex_lock(&priv
->mutex
);
2240 iwl_rx_replenish(priv
);
2241 mutex_unlock(&priv
->mutex
);
2244 #define IWL_DELAY_NEXT_SCAN (HZ*2)
2246 static void iwl_post_associate(struct iwl_priv
*priv
)
2248 struct ieee80211_conf
*conf
= NULL
;
2250 unsigned long flags
;
2252 if (priv
->iw_mode
== NL80211_IFTYPE_AP
) {
2253 IWL_ERROR("%s Should not be called in AP mode\n", __func__
);
2257 IWL_DEBUG_ASSOC("Associated as %d to: %pM\n",
2258 priv
->assoc_id
, priv
->active_rxon
.bssid_addr
);
2261 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2265 if (!priv
->vif
|| !priv
->is_open
)
2268 iwl_power_cancel_timeout(priv
);
2269 iwl_scan_cancel_timeout(priv
, 200);
2271 conf
= ieee80211_get_hw_conf(priv
->hw
);
2273 priv
->staging_rxon
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
2274 iwl_commit_rxon(priv
);
2276 iwl_setup_rxon_timing(priv
);
2277 ret
= iwl_send_cmd_pdu(priv
, REPLY_RXON_TIMING
,
2278 sizeof(priv
->rxon_timing
), &priv
->rxon_timing
);
2280 IWL_WARNING("REPLY_RXON_TIMING failed - "
2281 "Attempting to continue.\n");
2283 priv
->staging_rxon
.filter_flags
|= RXON_FILTER_ASSOC_MSK
;
2285 iwl_set_rxon_ht(priv
, &priv
->current_ht_config
);
2287 iwl_set_rxon_chain(priv
);
2288 priv
->staging_rxon
.assoc_id
= cpu_to_le16(priv
->assoc_id
);
2290 IWL_DEBUG_ASSOC("assoc id %d beacon interval %d\n",
2291 priv
->assoc_id
, priv
->beacon_int
);
2293 if (priv
->assoc_capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
)
2294 priv
->staging_rxon
.flags
|= RXON_FLG_SHORT_PREAMBLE_MSK
;
2296 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_PREAMBLE_MSK
;
2298 if (priv
->staging_rxon
.flags
& RXON_FLG_BAND_24G_MSK
) {
2299 if (priv
->assoc_capability
& WLAN_CAPABILITY_SHORT_SLOT_TIME
)
2300 priv
->staging_rxon
.flags
|= RXON_FLG_SHORT_SLOT_MSK
;
2302 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_SLOT_MSK
;
2304 if (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
)
2305 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_SLOT_MSK
;
2309 iwl_commit_rxon(priv
);
2311 switch (priv
->iw_mode
) {
2312 case NL80211_IFTYPE_STATION
:
2315 case NL80211_IFTYPE_ADHOC
:
2317 /* assume default assoc id */
2320 iwl_rxon_add_station(priv
, priv
->bssid
, 0);
2321 iwl_send_beacon_cmd(priv
);
2326 IWL_ERROR("%s Should not be called in %d mode\n",
2327 __func__
, priv
->iw_mode
);
2331 if (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
)
2332 priv
->assoc_station_added
= 1;
2334 spin_lock_irqsave(&priv
->lock
, flags
);
2335 iwl_activate_qos(priv
, 0);
2336 spin_unlock_irqrestore(&priv
->lock
, flags
);
2338 /* the chain noise calibration will enabled PM upon completion
2339 * If chain noise has already been run, then we need to enable
2340 * power management here */
2341 if (priv
->chain_noise_data
.state
== IWL_CHAIN_NOISE_DONE
)
2342 iwl_power_enable_management(priv
);
2344 /* Enable Rx differential gain and sensitivity calibrations */
2345 iwl_chain_noise_reset(priv
);
2346 priv
->start_calib
= 1;
2350 /*****************************************************************************
2352 * mac80211 entry point functions
2354 *****************************************************************************/
2356 #define UCODE_READY_TIMEOUT (4 * HZ)
2358 static int iwl_mac_start(struct ieee80211_hw
*hw
)
2360 struct iwl_priv
*priv
= hw
->priv
;
2364 IWL_DEBUG_MAC80211("enter\n");
2366 if (pci_enable_device(priv
->pci_dev
)) {
2367 IWL_ERROR("Fail to pci_enable_device\n");
2370 pci_restore_state(priv
->pci_dev
);
2371 pci_enable_msi(priv
->pci_dev
);
2373 /* enable interrupts if needed: hw bug w/a */
2374 pci_read_config_word(priv
->pci_dev
, PCI_COMMAND
, &pci_cmd
);
2375 if (pci_cmd
& PCI_COMMAND_INTX_DISABLE
) {
2376 pci_cmd
&= ~PCI_COMMAND_INTX_DISABLE
;
2377 pci_write_config_word(priv
->pci_dev
, PCI_COMMAND
, pci_cmd
);
2380 ret
= request_irq(priv
->pci_dev
->irq
, iwl_isr
, IRQF_SHARED
,
2383 IWL_ERROR("Error allocating IRQ %d\n", priv
->pci_dev
->irq
);
2384 goto out_disable_msi
;
2387 /* we should be verifying the device is ready to be opened */
2388 mutex_lock(&priv
->mutex
);
2390 memset(&priv
->staging_rxon
, 0, sizeof(struct iwl_rxon_cmd
));
2391 /* fetch ucode file from disk, alloc and copy to bus-master buffers ...
2392 * ucode filename and max sizes are card-specific. */
2394 if (!priv
->ucode_code
.len
) {
2395 ret
= iwl_read_ucode(priv
);
2397 IWL_ERROR("Could not read microcode: %d\n", ret
);
2398 mutex_unlock(&priv
->mutex
);
2399 goto out_release_irq
;
2403 ret
= __iwl_up(priv
);
2405 mutex_unlock(&priv
->mutex
);
2407 iwl_rfkill_set_hw_state(priv
);
2410 goto out_release_irq
;
2412 if (iwl_is_rfkill(priv
))
2415 IWL_DEBUG_INFO("Start UP work done.\n");
2417 if (test_bit(STATUS_IN_SUSPEND
, &priv
->status
))
2420 /* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
2421 * mac80211 will not be run successfully. */
2422 ret
= wait_event_interruptible_timeout(priv
->wait_command_queue
,
2423 test_bit(STATUS_READY
, &priv
->status
),
2424 UCODE_READY_TIMEOUT
);
2426 if (!test_bit(STATUS_READY
, &priv
->status
)) {
2427 IWL_ERROR("START_ALIVE timeout after %dms.\n",
2428 jiffies_to_msecs(UCODE_READY_TIMEOUT
));
2430 goto out_release_irq
;
2436 IWL_DEBUG_MAC80211("leave\n");
2440 free_irq(priv
->pci_dev
->irq
, priv
);
2442 pci_disable_msi(priv
->pci_dev
);
2443 pci_disable_device(priv
->pci_dev
);
2445 IWL_DEBUG_MAC80211("leave - failed\n");
2449 static void iwl_mac_stop(struct ieee80211_hw
*hw
)
2451 struct iwl_priv
*priv
= hw
->priv
;
2453 IWL_DEBUG_MAC80211("enter\n");
2455 if (!priv
->is_open
) {
2456 IWL_DEBUG_MAC80211("leave - skip\n");
2462 if (iwl_is_ready_rf(priv
)) {
2463 /* stop mac, cancel any scan request and clear
2464 * RXON_FILTER_ASSOC_MSK BIT
2466 mutex_lock(&priv
->mutex
);
2467 iwl_scan_cancel_timeout(priv
, 100);
2468 mutex_unlock(&priv
->mutex
);
2473 flush_workqueue(priv
->workqueue
);
2474 free_irq(priv
->pci_dev
->irq
, priv
);
2475 pci_disable_msi(priv
->pci_dev
);
2476 pci_save_state(priv
->pci_dev
);
2477 pci_disable_device(priv
->pci_dev
);
2479 IWL_DEBUG_MAC80211("leave\n");
2482 static int iwl_mac_tx(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
2484 struct iwl_priv
*priv
= hw
->priv
;
2486 IWL_DEBUG_MACDUMP("enter\n");
2488 IWL_DEBUG_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb
->len
,
2489 ieee80211_get_tx_rate(hw
, IEEE80211_SKB_CB(skb
))->bitrate
);
2491 if (iwl_tx_skb(priv
, skb
))
2492 dev_kfree_skb_any(skb
);
2494 IWL_DEBUG_MACDUMP("leave\n");
2498 static int iwl_mac_add_interface(struct ieee80211_hw
*hw
,
2499 struct ieee80211_if_init_conf
*conf
)
2501 struct iwl_priv
*priv
= hw
->priv
;
2502 unsigned long flags
;
2504 IWL_DEBUG_MAC80211("enter: type %d\n", conf
->type
);
2507 IWL_DEBUG_MAC80211("leave - vif != NULL\n");
2511 spin_lock_irqsave(&priv
->lock
, flags
);
2512 priv
->vif
= conf
->vif
;
2513 priv
->iw_mode
= conf
->type
;
2515 spin_unlock_irqrestore(&priv
->lock
, flags
);
2517 mutex_lock(&priv
->mutex
);
2519 if (conf
->mac_addr
) {
2520 IWL_DEBUG_MAC80211("Set %pM\n", conf
->mac_addr
);
2521 memcpy(priv
->mac_addr
, conf
->mac_addr
, ETH_ALEN
);
2524 if (iwl_set_mode(priv
, conf
->type
) == -EAGAIN
)
2525 /* we are not ready, will run again when ready */
2526 set_bit(STATUS_MODE_PENDING
, &priv
->status
);
2528 mutex_unlock(&priv
->mutex
);
2530 IWL_DEBUG_MAC80211("leave\n");
2535 * iwl_mac_config - mac80211 config callback
2537 * We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
2538 * be set inappropriately and the driver currently sets the hardware up to
2539 * use it whenever needed.
2541 static int iwl_mac_config(struct ieee80211_hw
*hw
, u32 changed
)
2543 struct iwl_priv
*priv
= hw
->priv
;
2544 const struct iwl_channel_info
*ch_info
;
2545 struct ieee80211_conf
*conf
= &hw
->conf
;
2546 unsigned long flags
;
2550 mutex_lock(&priv
->mutex
);
2551 IWL_DEBUG_MAC80211("enter to channel %d\n", conf
->channel
->hw_value
);
2553 priv
->current_ht_config
.is_ht
= conf
->ht
.enabled
;
2555 if (conf
->radio_enabled
&& iwl_radio_kill_sw_enable_radio(priv
)) {
2556 IWL_DEBUG_MAC80211("leave - RF-KILL - waiting for uCode\n");
2560 if (!conf
->radio_enabled
)
2561 iwl_radio_kill_sw_disable_radio(priv
);
2563 if (!iwl_is_ready(priv
)) {
2564 IWL_DEBUG_MAC80211("leave - not ready\n");
2569 if (unlikely(!priv
->cfg
->mod_params
->disable_hw_scan
&&
2570 test_bit(STATUS_SCANNING
, &priv
->status
))) {
2571 IWL_DEBUG_MAC80211("leave - scanning\n");
2572 mutex_unlock(&priv
->mutex
);
2576 channel
= ieee80211_frequency_to_channel(conf
->channel
->center_freq
);
2577 ch_info
= iwl_get_channel_info(priv
, conf
->channel
->band
, channel
);
2578 if (!is_channel_valid(ch_info
)) {
2579 IWL_DEBUG_MAC80211("leave - invalid channel\n");
2584 if (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
&&
2585 !is_channel_ibss(ch_info
)) {
2586 IWL_ERROR("channel %d in band %d not IBSS channel\n",
2587 conf
->channel
->hw_value
, conf
->channel
->band
);
2592 spin_lock_irqsave(&priv
->lock
, flags
);
2595 /* if we are switching from ht to 2.4 clear flags
2596 * from any ht related info since 2.4 does not
2598 if ((le16_to_cpu(priv
->staging_rxon
.channel
) != channel
)
2599 #ifdef IEEE80211_CONF_CHANNEL_SWITCH
2600 && !(conf
->flags
& IEEE80211_CONF_CHANNEL_SWITCH
)
2603 priv
->staging_rxon
.flags
= 0;
2605 iwl_set_rxon_channel(priv
, conf
->channel
);
2607 iwl_set_flags_for_band(priv
, conf
->channel
->band
);
2609 /* The list of supported rates and rate mask can be different
2610 * for each band; since the band may have changed, reset
2611 * the rate mask to what mac80211 lists */
2614 spin_unlock_irqrestore(&priv
->lock
, flags
);
2616 #ifdef IEEE80211_CONF_CHANNEL_SWITCH
2617 if (conf
->flags
& IEEE80211_CONF_CHANNEL_SWITCH
) {
2618 iwl_hw_channel_switch(priv
, conf
->channel
);
2623 if (!conf
->radio_enabled
) {
2624 IWL_DEBUG_MAC80211("leave - radio disabled\n");
2628 if (iwl_is_rfkill(priv
)) {
2629 IWL_DEBUG_MAC80211("leave - RF kill\n");
2634 if (conf
->flags
& IEEE80211_CONF_PS
)
2635 ret
= iwl_power_set_user_mode(priv
, IWL_POWER_INDEX_3
);
2637 ret
= iwl_power_set_user_mode(priv
, IWL_POWER_MODE_CAM
);
2639 IWL_DEBUG_MAC80211("Error setting power level\n");
2641 IWL_DEBUG_MAC80211("TX Power old=%d new=%d\n",
2642 priv
->tx_power_user_lmt
, conf
->power_level
);
2644 iwl_set_tx_power(priv
, conf
->power_level
, false);
2648 if (memcmp(&priv
->active_rxon
,
2649 &priv
->staging_rxon
, sizeof(priv
->staging_rxon
)))
2650 iwl_commit_rxon(priv
);
2652 IWL_DEBUG_INFO("No re-sending same RXON configuration.\n");
2654 IWL_DEBUG_MAC80211("leave\n");
2657 mutex_unlock(&priv
->mutex
);
2661 static void iwl_config_ap(struct iwl_priv
*priv
)
2664 unsigned long flags
;
2666 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
2669 /* The following should be done only at AP bring up */
2670 if (!iwl_is_associated(priv
)) {
2672 /* RXON - unassoc (to set timing command) */
2673 priv
->staging_rxon
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
2674 iwl_commit_rxon(priv
);
2677 iwl_setup_rxon_timing(priv
);
2678 ret
= iwl_send_cmd_pdu(priv
, REPLY_RXON_TIMING
,
2679 sizeof(priv
->rxon_timing
), &priv
->rxon_timing
);
2681 IWL_WARNING("REPLY_RXON_TIMING failed - "
2682 "Attempting to continue.\n");
2684 iwl_set_rxon_chain(priv
);
2686 /* FIXME: what should be the assoc_id for AP? */
2687 priv
->staging_rxon
.assoc_id
= cpu_to_le16(priv
->assoc_id
);
2688 if (priv
->assoc_capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
)
2689 priv
->staging_rxon
.flags
|=
2690 RXON_FLG_SHORT_PREAMBLE_MSK
;
2692 priv
->staging_rxon
.flags
&=
2693 ~RXON_FLG_SHORT_PREAMBLE_MSK
;
2695 if (priv
->staging_rxon
.flags
& RXON_FLG_BAND_24G_MSK
) {
2696 if (priv
->assoc_capability
&
2697 WLAN_CAPABILITY_SHORT_SLOT_TIME
)
2698 priv
->staging_rxon
.flags
|=
2699 RXON_FLG_SHORT_SLOT_MSK
;
2701 priv
->staging_rxon
.flags
&=
2702 ~RXON_FLG_SHORT_SLOT_MSK
;
2704 if (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
)
2705 priv
->staging_rxon
.flags
&=
2706 ~RXON_FLG_SHORT_SLOT_MSK
;
2708 /* restore RXON assoc */
2709 priv
->staging_rxon
.filter_flags
|= RXON_FILTER_ASSOC_MSK
;
2710 iwl_commit_rxon(priv
);
2711 spin_lock_irqsave(&priv
->lock
, flags
);
2712 iwl_activate_qos(priv
, 1);
2713 spin_unlock_irqrestore(&priv
->lock
, flags
);
2714 iwl_rxon_add_station(priv
, iwl_bcast_addr
, 0);
2716 iwl_send_beacon_cmd(priv
);
2718 /* FIXME - we need to add code here to detect a totally new
2719 * configuration, reset the AP, unassoc, rxon timing, assoc,
2720 * clear sta table, add BCAST sta... */
2724 static int iwl_mac_config_interface(struct ieee80211_hw
*hw
,
2725 struct ieee80211_vif
*vif
,
2726 struct ieee80211_if_conf
*conf
)
2728 struct iwl_priv
*priv
= hw
->priv
;
2734 if (priv
->vif
!= vif
) {
2735 IWL_DEBUG_MAC80211("leave - priv->vif != vif\n");
2739 if (priv
->iw_mode
== NL80211_IFTYPE_ADHOC
&&
2740 conf
->changed
& IEEE80211_IFCC_BEACON
) {
2741 struct sk_buff
*beacon
= ieee80211_beacon_get(hw
, vif
);
2744 mutex_lock(&priv
->mutex
);
2745 rc
= iwl_mac_beacon_update(hw
, beacon
);
2746 mutex_unlock(&priv
->mutex
);
2751 if (!iwl_is_alive(priv
))
2754 mutex_lock(&priv
->mutex
);
2757 IWL_DEBUG_MAC80211("bssid: %pM\n", conf
->bssid
);
2760 * very dubious code was here; the probe filtering flag is never set:
2762 if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
2763 !(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
2766 if (priv
->iw_mode
== NL80211_IFTYPE_AP
) {
2768 conf
->bssid
= priv
->mac_addr
;
2769 memcpy(priv
->bssid
, priv
->mac_addr
, ETH_ALEN
);
2770 IWL_DEBUG_MAC80211("bssid was set to: %pM\n",
2773 if (priv
->ibss_beacon
)
2774 dev_kfree_skb(priv
->ibss_beacon
);
2776 priv
->ibss_beacon
= ieee80211_beacon_get(hw
, vif
);
2779 if (iwl_is_rfkill(priv
))
2782 if (conf
->bssid
&& !is_zero_ether_addr(conf
->bssid
) &&
2783 !is_multicast_ether_addr(conf
->bssid
)) {
2784 /* If there is currently a HW scan going on in the background
2785 * then we need to cancel it else the RXON below will fail. */
2786 if (iwl_scan_cancel_timeout(priv
, 100)) {
2787 IWL_WARNING("Aborted scan still in progress "
2789 IWL_DEBUG_MAC80211("leaving - scan abort failed.\n");
2790 mutex_unlock(&priv
->mutex
);
2793 memcpy(priv
->staging_rxon
.bssid_addr
, conf
->bssid
, ETH_ALEN
);
2795 /* TODO: Audit driver for usage of these members and see
2796 * if mac80211 deprecates them (priv->bssid looks like it
2797 * shouldn't be there, but I haven't scanned the IBSS code
2798 * to verify) - jpk */
2799 memcpy(priv
->bssid
, conf
->bssid
, ETH_ALEN
);
2801 if (priv
->iw_mode
== NL80211_IFTYPE_AP
)
2802 iwl_config_ap(priv
);
2804 rc
= iwl_commit_rxon(priv
);
2805 if ((priv
->iw_mode
== NL80211_IFTYPE_STATION
) && rc
)
2806 iwl_rxon_add_station(
2807 priv
, priv
->active_rxon
.bssid_addr
, 1);
2811 iwl_scan_cancel_timeout(priv
, 100);
2812 priv
->staging_rxon
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
2813 iwl_commit_rxon(priv
);
2817 IWL_DEBUG_MAC80211("leave\n");
2818 mutex_unlock(&priv
->mutex
);
2823 static void iwl_configure_filter(struct ieee80211_hw
*hw
,
2824 unsigned int changed_flags
,
2825 unsigned int *total_flags
,
2826 int mc_count
, struct dev_addr_list
*mc_list
)
2828 struct iwl_priv
*priv
= hw
->priv
;
2829 __le32
*filter_flags
= &priv
->staging_rxon
.filter_flags
;
2831 IWL_DEBUG_MAC80211("Enter: changed: 0x%x, total: 0x%x\n",
2832 changed_flags
, *total_flags
);
2834 if (changed_flags
& (FIF_OTHER_BSS
| FIF_PROMISC_IN_BSS
)) {
2835 if (*total_flags
& (FIF_OTHER_BSS
| FIF_PROMISC_IN_BSS
))
2836 *filter_flags
|= RXON_FILTER_PROMISC_MSK
;
2838 *filter_flags
&= ~RXON_FILTER_PROMISC_MSK
;
2840 if (changed_flags
& FIF_ALLMULTI
) {
2841 if (*total_flags
& FIF_ALLMULTI
)
2842 *filter_flags
|= RXON_FILTER_ACCEPT_GRP_MSK
;
2844 *filter_flags
&= ~RXON_FILTER_ACCEPT_GRP_MSK
;
2846 if (changed_flags
& FIF_CONTROL
) {
2847 if (*total_flags
& FIF_CONTROL
)
2848 *filter_flags
|= RXON_FILTER_CTL2HOST_MSK
;
2850 *filter_flags
&= ~RXON_FILTER_CTL2HOST_MSK
;
2852 if (changed_flags
& FIF_BCN_PRBRESP_PROMISC
) {
2853 if (*total_flags
& FIF_BCN_PRBRESP_PROMISC
)
2854 *filter_flags
|= RXON_FILTER_BCON_AWARE_MSK
;
2856 *filter_flags
&= ~RXON_FILTER_BCON_AWARE_MSK
;
2859 /* We avoid iwl_commit_rxon here to commit the new filter flags
2860 * since mac80211 will call ieee80211_hw_config immediately.
2861 * (mc_list is not supported at this time). Otherwise, we need to
2862 * queue a background iwl_commit_rxon work.
2865 *total_flags
&= FIF_OTHER_BSS
| FIF_ALLMULTI
| FIF_PROMISC_IN_BSS
|
2866 FIF_BCN_PRBRESP_PROMISC
| FIF_CONTROL
;
2869 static void iwl_mac_remove_interface(struct ieee80211_hw
*hw
,
2870 struct ieee80211_if_init_conf
*conf
)
2872 struct iwl_priv
*priv
= hw
->priv
;
2874 IWL_DEBUG_MAC80211("enter\n");
2876 mutex_lock(&priv
->mutex
);
2878 if (iwl_is_ready_rf(priv
)) {
2879 iwl_scan_cancel_timeout(priv
, 100);
2880 priv
->staging_rxon
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
2881 iwl_commit_rxon(priv
);
2883 if (priv
->vif
== conf
->vif
) {
2885 memset(priv
->bssid
, 0, ETH_ALEN
);
2887 mutex_unlock(&priv
->mutex
);
2889 IWL_DEBUG_MAC80211("leave\n");
2893 #define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
2894 static void iwl_bss_info_changed(struct ieee80211_hw
*hw
,
2895 struct ieee80211_vif
*vif
,
2896 struct ieee80211_bss_conf
*bss_conf
,
2899 struct iwl_priv
*priv
= hw
->priv
;
2901 IWL_DEBUG_MAC80211("changes = 0x%X\n", changes
);
2903 if (changes
& BSS_CHANGED_ERP_PREAMBLE
) {
2904 IWL_DEBUG_MAC80211("ERP_PREAMBLE %d\n",
2905 bss_conf
->use_short_preamble
);
2906 if (bss_conf
->use_short_preamble
)
2907 priv
->staging_rxon
.flags
|= RXON_FLG_SHORT_PREAMBLE_MSK
;
2909 priv
->staging_rxon
.flags
&= ~RXON_FLG_SHORT_PREAMBLE_MSK
;
2912 if (changes
& BSS_CHANGED_ERP_CTS_PROT
) {
2913 IWL_DEBUG_MAC80211("ERP_CTS %d\n", bss_conf
->use_cts_prot
);
2914 if (bss_conf
->use_cts_prot
&& (priv
->band
!= IEEE80211_BAND_5GHZ
))
2915 priv
->staging_rxon
.flags
|= RXON_FLG_TGG_PROTECT_MSK
;
2917 priv
->staging_rxon
.flags
&= ~RXON_FLG_TGG_PROTECT_MSK
;
2920 if (changes
& BSS_CHANGED_HT
) {
2921 iwl_ht_conf(priv
, bss_conf
);
2922 iwl_set_rxon_chain(priv
);
2925 if (changes
& BSS_CHANGED_ASSOC
) {
2926 IWL_DEBUG_MAC80211("ASSOC %d\n", bss_conf
->assoc
);
2927 /* This should never happen as this function should
2928 * never be called from interrupt context. */
2929 if (WARN_ON_ONCE(in_interrupt()))
2931 if (bss_conf
->assoc
) {
2932 priv
->assoc_id
= bss_conf
->aid
;
2933 priv
->beacon_int
= bss_conf
->beacon_int
;
2934 priv
->power_data
.dtim_period
= bss_conf
->dtim_period
;
2935 priv
->timestamp
= bss_conf
->timestamp
;
2936 priv
->assoc_capability
= bss_conf
->assoc_capability
;
2938 /* we have just associated, don't start scan too early
2939 * leave time for EAPOL exchange to complete
2941 priv
->next_scan_jiffies
= jiffies
+
2942 IWL_DELAY_NEXT_SCAN_AFTER_ASSOC
;
2943 mutex_lock(&priv
->mutex
);
2944 iwl_post_associate(priv
);
2945 mutex_unlock(&priv
->mutex
);
2948 IWL_DEBUG_MAC80211("DISASSOC %d\n", bss_conf
->assoc
);
2950 } else if (changes
&& iwl_is_associated(priv
) && priv
->assoc_id
) {
2951 IWL_DEBUG_MAC80211("Associated Changes %d\n", changes
);
2952 iwl_send_rxon_assoc(priv
);
2957 static int iwl_mac_hw_scan(struct ieee80211_hw
*hw
, u8
*ssid
, size_t ssid_len
)
2959 unsigned long flags
;
2960 struct iwl_priv
*priv
= hw
->priv
;
2963 IWL_DEBUG_MAC80211("enter\n");
2965 mutex_lock(&priv
->mutex
);
2966 spin_lock_irqsave(&priv
->lock
, flags
);
2968 if (!iwl_is_ready_rf(priv
)) {
2970 IWL_DEBUG_MAC80211("leave - not ready or exit pending\n");
2974 /* We don't schedule scan within next_scan_jiffies period.
2975 * Avoid scanning during possible EAPOL exchange, return
2976 * success immediately.
2978 if (priv
->next_scan_jiffies
&&
2979 time_after(priv
->next_scan_jiffies
, jiffies
)) {
2980 IWL_DEBUG_SCAN("scan rejected: within next scan period\n");
2981 queue_work(priv
->workqueue
, &priv
->scan_completed
);
2986 /* if we just finished scan ask for delay */
2987 if (iwl_is_associated(priv
) && priv
->last_scan_jiffies
&&
2988 time_after(priv
->last_scan_jiffies
+ IWL_DELAY_NEXT_SCAN
, jiffies
)) {
2989 IWL_DEBUG_SCAN("scan rejected: within previous scan period\n");
2990 queue_work(priv
->workqueue
, &priv
->scan_completed
);
2996 priv
->one_direct_scan
= 1;
2997 priv
->direct_ssid_len
= min_t(u8
, ssid_len
, IW_ESSID_MAX_SIZE
);
2998 memcpy(priv
->direct_ssid
, ssid
, priv
->direct_ssid_len
);
3000 priv
->one_direct_scan
= 0;
3003 ret
= iwl_scan_initiate(priv
);
3005 IWL_DEBUG_MAC80211("leave\n");
3008 spin_unlock_irqrestore(&priv
->lock
, flags
);
3009 mutex_unlock(&priv
->mutex
);
3014 static void iwl_mac_update_tkip_key(struct ieee80211_hw
*hw
,
3015 struct ieee80211_key_conf
*keyconf
, const u8
*addr
,
3016 u32 iv32
, u16
*phase1key
)
3019 struct iwl_priv
*priv
= hw
->priv
;
3020 IWL_DEBUG_MAC80211("enter\n");
3022 iwl_update_tkip_key(priv
, keyconf
, addr
, iv32
, phase1key
);
3024 IWL_DEBUG_MAC80211("leave\n");
3027 static int iwl_mac_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
3028 const u8
*local_addr
, const u8
*addr
,
3029 struct ieee80211_key_conf
*key
)
3031 struct iwl_priv
*priv
= hw
->priv
;
3033 u8 sta_id
= IWL_INVALID_STATION
;
3034 u8 is_default_wep_key
= 0;
3036 IWL_DEBUG_MAC80211("enter\n");
3038 if (priv
->hw_params
.sw_crypto
) {
3039 IWL_DEBUG_MAC80211("leave - hwcrypto disabled\n");
3043 if (is_zero_ether_addr(addr
))
3044 /* only support pairwise keys */
3047 sta_id
= iwl_find_station(priv
, addr
);
3048 if (sta_id
== IWL_INVALID_STATION
) {
3049 IWL_DEBUG_MAC80211("leave - %pM not in station map.\n",
3055 mutex_lock(&priv
->mutex
);
3056 iwl_scan_cancel_timeout(priv
, 100);
3057 mutex_unlock(&priv
->mutex
);
3059 /* If we are getting WEP group key and we didn't receive any key mapping
3060 * so far, we are in legacy wep mode (group key only), otherwise we are
3062 * In legacy wep mode, we use another host command to the uCode */
3063 if (key
->alg
== ALG_WEP
&& sta_id
== priv
->hw_params
.bcast_sta_id
&&
3064 priv
->iw_mode
!= NL80211_IFTYPE_AP
) {
3066 is_default_wep_key
= !priv
->key_mapping_key
;
3068 is_default_wep_key
=
3069 (key
->hw_key_idx
== HW_KEY_DEFAULT
);
3074 if (is_default_wep_key
)
3075 ret
= iwl_set_default_wep_key(priv
, key
);
3077 ret
= iwl_set_dynamic_key(priv
, key
, sta_id
);
3079 IWL_DEBUG_MAC80211("enable hwcrypto key\n");
3082 if (is_default_wep_key
)
3083 ret
= iwl_remove_default_wep_key(priv
, key
);
3085 ret
= iwl_remove_dynamic_key(priv
, key
, sta_id
);
3087 IWL_DEBUG_MAC80211("disable hwcrypto key\n");
3093 IWL_DEBUG_MAC80211("leave\n");
3098 static int iwl_mac_conf_tx(struct ieee80211_hw
*hw
, u16 queue
,
3099 const struct ieee80211_tx_queue_params
*params
)
3101 struct iwl_priv
*priv
= hw
->priv
;
3102 unsigned long flags
;
3105 IWL_DEBUG_MAC80211("enter\n");
3107 if (!iwl_is_ready_rf(priv
)) {
3108 IWL_DEBUG_MAC80211("leave - RF not ready\n");
3112 if (queue
>= AC_NUM
) {
3113 IWL_DEBUG_MAC80211("leave - queue >= AC_NUM %d\n", queue
);
3117 q
= AC_NUM
- 1 - queue
;
3119 spin_lock_irqsave(&priv
->lock
, flags
);
3121 priv
->qos_data
.def_qos_parm
.ac
[q
].cw_min
= cpu_to_le16(params
->cw_min
);
3122 priv
->qos_data
.def_qos_parm
.ac
[q
].cw_max
= cpu_to_le16(params
->cw_max
);
3123 priv
->qos_data
.def_qos_parm
.ac
[q
].aifsn
= params
->aifs
;
3124 priv
->qos_data
.def_qos_parm
.ac
[q
].edca_txop
=
3125 cpu_to_le16((params
->txop
* 32));
3127 priv
->qos_data
.def_qos_parm
.ac
[q
].reserved1
= 0;
3128 priv
->qos_data
.qos_active
= 1;
3130 if (priv
->iw_mode
== NL80211_IFTYPE_AP
)
3131 iwl_activate_qos(priv
, 1);
3132 else if (priv
->assoc_id
&& iwl_is_associated(priv
))
3133 iwl_activate_qos(priv
, 0);
3135 spin_unlock_irqrestore(&priv
->lock
, flags
);
3137 IWL_DEBUG_MAC80211("leave\n");
3141 static int iwl_mac_ampdu_action(struct ieee80211_hw
*hw
,
3142 enum ieee80211_ampdu_mlme_action action
,
3143 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
)
3145 struct iwl_priv
*priv
= hw
->priv
;
3147 IWL_DEBUG_HT("A-MPDU action on addr %pM tid %d\n",
3150 if (!(priv
->cfg
->sku
& IWL_SKU_N
))
3154 case IEEE80211_AMPDU_RX_START
:
3155 IWL_DEBUG_HT("start Rx\n");
3156 return iwl_sta_rx_agg_start(priv
, sta
->addr
, tid
, *ssn
);
3157 case IEEE80211_AMPDU_RX_STOP
:
3158 IWL_DEBUG_HT("stop Rx\n");
3159 return iwl_sta_rx_agg_stop(priv
, sta
->addr
, tid
);
3160 case IEEE80211_AMPDU_TX_START
:
3161 IWL_DEBUG_HT("start Tx\n");
3162 return iwl_tx_agg_start(priv
, sta
->addr
, tid
, ssn
);
3163 case IEEE80211_AMPDU_TX_STOP
:
3164 IWL_DEBUG_HT("stop Tx\n");
3165 return iwl_tx_agg_stop(priv
, sta
->addr
, tid
);
3167 IWL_DEBUG_HT("unknown\n");
3174 static int iwl_mac_get_tx_stats(struct ieee80211_hw
*hw
,
3175 struct ieee80211_tx_queue_stats
*stats
)
3177 struct iwl_priv
*priv
= hw
->priv
;
3179 struct iwl_tx_queue
*txq
;
3180 struct iwl_queue
*q
;
3181 unsigned long flags
;
3183 IWL_DEBUG_MAC80211("enter\n");
3185 if (!iwl_is_ready_rf(priv
)) {
3186 IWL_DEBUG_MAC80211("leave - RF not ready\n");
3190 spin_lock_irqsave(&priv
->lock
, flags
);
3192 for (i
= 0; i
< AC_NUM
; i
++) {
3193 txq
= &priv
->txq
[i
];
3195 avail
= iwl_queue_space(q
);
3197 stats
[i
].len
= q
->n_window
- avail
;
3198 stats
[i
].limit
= q
->n_window
- q
->high_mark
;
3199 stats
[i
].count
= q
->n_window
;
3202 spin_unlock_irqrestore(&priv
->lock
, flags
);
3204 IWL_DEBUG_MAC80211("leave\n");
3209 static int iwl_mac_get_stats(struct ieee80211_hw
*hw
,
3210 struct ieee80211_low_level_stats
*stats
)
3212 struct iwl_priv
*priv
= hw
->priv
;
3215 IWL_DEBUG_MAC80211("enter\n");
3216 IWL_DEBUG_MAC80211("leave\n");
3221 static void iwl_mac_reset_tsf(struct ieee80211_hw
*hw
)
3223 struct iwl_priv
*priv
= hw
->priv
;
3224 unsigned long flags
;
3226 mutex_lock(&priv
->mutex
);
3227 IWL_DEBUG_MAC80211("enter\n");
3229 spin_lock_irqsave(&priv
->lock
, flags
);
3230 memset(&priv
->current_ht_config
, 0, sizeof(struct iwl_ht_info
));
3231 spin_unlock_irqrestore(&priv
->lock
, flags
);
3233 iwl_reset_qos(priv
);
3235 spin_lock_irqsave(&priv
->lock
, flags
);
3237 priv
->assoc_capability
= 0;
3238 priv
->assoc_station_added
= 0;
3240 /* new association get rid of ibss beacon skb */
3241 if (priv
->ibss_beacon
)
3242 dev_kfree_skb(priv
->ibss_beacon
);
3244 priv
->ibss_beacon
= NULL
;
3246 priv
->beacon_int
= priv
->hw
->conf
.beacon_int
;
3247 priv
->timestamp
= 0;
3248 if ((priv
->iw_mode
== NL80211_IFTYPE_STATION
))
3249 priv
->beacon_int
= 0;
3251 spin_unlock_irqrestore(&priv
->lock
, flags
);
3253 if (!iwl_is_ready_rf(priv
)) {
3254 IWL_DEBUG_MAC80211("leave - not ready\n");
3255 mutex_unlock(&priv
->mutex
);
3259 /* we are restarting association process
3260 * clear RXON_FILTER_ASSOC_MSK bit
3262 if (priv
->iw_mode
!= NL80211_IFTYPE_AP
) {
3263 iwl_scan_cancel_timeout(priv
, 100);
3264 priv
->staging_rxon
.filter_flags
&= ~RXON_FILTER_ASSOC_MSK
;
3265 iwl_commit_rxon(priv
);
3268 iwl_power_update_mode(priv
, 0);
3270 /* Per mac80211.h: This is only used in IBSS mode... */
3271 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
) {
3273 /* switch to CAM during association period.
3274 * the ucode will block any association/authentication
3275 * frome during assiciation period if it can not hear
3276 * the AP because of PM. the timer enable PM back is
3277 * association do not complete
3279 if (priv
->hw
->conf
.channel
->flags
& (IEEE80211_CHAN_PASSIVE_SCAN
|
3280 IEEE80211_CHAN_RADAR
))
3281 iwl_power_disable_management(priv
, 3000);
3283 IWL_DEBUG_MAC80211("leave - not in IBSS\n");
3284 mutex_unlock(&priv
->mutex
);
3290 mutex_unlock(&priv
->mutex
);
3292 IWL_DEBUG_MAC80211("leave\n");
3295 static int iwl_mac_beacon_update(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
3297 struct iwl_priv
*priv
= hw
->priv
;
3298 unsigned long flags
;
3301 IWL_DEBUG_MAC80211("enter\n");
3303 if (!iwl_is_ready_rf(priv
)) {
3304 IWL_DEBUG_MAC80211("leave - RF not ready\n");
3308 if (priv
->iw_mode
!= NL80211_IFTYPE_ADHOC
) {
3309 IWL_DEBUG_MAC80211("leave - not IBSS\n");
3313 spin_lock_irqsave(&priv
->lock
, flags
);
3315 if (priv
->ibss_beacon
)
3316 dev_kfree_skb(priv
->ibss_beacon
);
3318 priv
->ibss_beacon
= skb
;
3321 timestamp
= ((struct ieee80211_mgmt
*)skb
->data
)->u
.beacon
.timestamp
;
3322 priv
->timestamp
= le64_to_cpu(timestamp
);
3324 IWL_DEBUG_MAC80211("leave\n");
3325 spin_unlock_irqrestore(&priv
->lock
, flags
);
3327 iwl_reset_qos(priv
);
3329 iwl_post_associate(priv
);
3335 /*****************************************************************************
3339 *****************************************************************************/
3341 #ifdef CONFIG_IWLWIFI_DEBUG
3344 * The following adds a new attribute to the sysfs representation
3345 * of this device driver (i.e. a new file in /sys/bus/pci/drivers/iwl/)
3346 * used for controlling the debug level.
3348 * See the level definitions in iwl for details.
3351 static ssize_t
show_debug_level(struct device
*d
,
3352 struct device_attribute
*attr
, char *buf
)
3354 struct iwl_priv
*priv
= d
->driver_data
;
3356 return sprintf(buf
, "0x%08X\n", priv
->debug_level
);
3358 static ssize_t
store_debug_level(struct device
*d
,
3359 struct device_attribute
*attr
,
3360 const char *buf
, size_t count
)
3362 struct iwl_priv
*priv
= d
->driver_data
;
3366 ret
= strict_strtoul(buf
, 0, &val
);
3368 printk(KERN_INFO DRV_NAME
3369 ": %s is not in hex or decimal form.\n", buf
);
3371 priv
->debug_level
= val
;
3373 return strnlen(buf
, count
);
3376 static DEVICE_ATTR(debug_level
, S_IWUSR
| S_IRUGO
,
3377 show_debug_level
, store_debug_level
);
3380 #endif /* CONFIG_IWLWIFI_DEBUG */
3383 static ssize_t
show_version(struct device
*d
,
3384 struct device_attribute
*attr
, char *buf
)
3386 struct iwl_priv
*priv
= d
->driver_data
;
3387 struct iwl_alive_resp
*palive
= &priv
->card_alive
;
3391 if (palive
->is_valid
)
3392 pos
+= sprintf(buf
+ pos
,
3393 "fw version: 0x%01X.0x%01X.0x%01X.0x%01X\n"
3394 "fw type: 0x%01X 0x%01X\n",
3395 palive
->ucode_major
, palive
->ucode_minor
,
3396 palive
->sw_rev
[0], palive
->sw_rev
[1],
3397 palive
->ver_type
, palive
->ver_subtype
);
3399 pos
+= sprintf(buf
+ pos
, "fw not loaded\n");
3402 eeprom_ver
= iwl_eeprom_query16(priv
, EEPROM_VERSION
);
3403 pos
+= sprintf(buf
+ pos
, "EEPROM version: 0x%x\n",
3406 pos
+= sprintf(buf
+ pos
, "EEPROM not initialzed\n");
3412 static DEVICE_ATTR(version
, S_IWUSR
| S_IRUGO
, show_version
, NULL
);
3414 static ssize_t
show_temperature(struct device
*d
,
3415 struct device_attribute
*attr
, char *buf
)
3417 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3419 if (!iwl_is_alive(priv
))
3422 return sprintf(buf
, "%d\n", priv
->temperature
);
3425 static DEVICE_ATTR(temperature
, S_IRUGO
, show_temperature
, NULL
);
3427 static ssize_t
show_tx_power(struct device
*d
,
3428 struct device_attribute
*attr
, char *buf
)
3430 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3431 return sprintf(buf
, "%d\n", priv
->tx_power_user_lmt
);
3434 static ssize_t
store_tx_power(struct device
*d
,
3435 struct device_attribute
*attr
,
3436 const char *buf
, size_t count
)
3438 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3442 ret
= strict_strtoul(buf
, 10, &val
);
3444 printk(KERN_INFO DRV_NAME
3445 ": %s is not in decimal form.\n", buf
);
3447 iwl_set_tx_power(priv
, val
, false);
3452 static DEVICE_ATTR(tx_power
, S_IWUSR
| S_IRUGO
, show_tx_power
, store_tx_power
);
3454 static ssize_t
show_flags(struct device
*d
,
3455 struct device_attribute
*attr
, char *buf
)
3457 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3459 return sprintf(buf
, "0x%04X\n", priv
->active_rxon
.flags
);
3462 static ssize_t
store_flags(struct device
*d
,
3463 struct device_attribute
*attr
,
3464 const char *buf
, size_t count
)
3466 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3469 int ret
= strict_strtoul(buf
, 0, &val
);
3474 mutex_lock(&priv
->mutex
);
3475 if (le32_to_cpu(priv
->staging_rxon
.flags
) != flags
) {
3476 /* Cancel any currently running scans... */
3477 if (iwl_scan_cancel_timeout(priv
, 100))
3478 IWL_WARNING("Could not cancel scan.\n");
3480 IWL_DEBUG_INFO("Commit rxon.flags = 0x%04X\n", flags
);
3481 priv
->staging_rxon
.flags
= cpu_to_le32(flags
);
3482 iwl_commit_rxon(priv
);
3485 mutex_unlock(&priv
->mutex
);
3490 static DEVICE_ATTR(flags
, S_IWUSR
| S_IRUGO
, show_flags
, store_flags
);
3492 static ssize_t
show_filter_flags(struct device
*d
,
3493 struct device_attribute
*attr
, char *buf
)
3495 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3497 return sprintf(buf
, "0x%04X\n",
3498 le32_to_cpu(priv
->active_rxon
.filter_flags
));
3501 static ssize_t
store_filter_flags(struct device
*d
,
3502 struct device_attribute
*attr
,
3503 const char *buf
, size_t count
)
3505 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3508 int ret
= strict_strtoul(buf
, 0, &val
);
3511 filter_flags
= (u32
)val
;
3513 mutex_lock(&priv
->mutex
);
3514 if (le32_to_cpu(priv
->staging_rxon
.filter_flags
) != filter_flags
) {
3515 /* Cancel any currently running scans... */
3516 if (iwl_scan_cancel_timeout(priv
, 100))
3517 IWL_WARNING("Could not cancel scan.\n");
3519 IWL_DEBUG_INFO("Committing rxon.filter_flags = "
3520 "0x%04X\n", filter_flags
);
3521 priv
->staging_rxon
.filter_flags
=
3522 cpu_to_le32(filter_flags
);
3523 iwl_commit_rxon(priv
);
3526 mutex_unlock(&priv
->mutex
);
3531 static DEVICE_ATTR(filter_flags
, S_IWUSR
| S_IRUGO
, show_filter_flags
,
3532 store_filter_flags
);
3534 static ssize_t
store_retry_rate(struct device
*d
,
3535 struct device_attribute
*attr
,
3536 const char *buf
, size_t count
)
3538 struct iwl_priv
*priv
= dev_get_drvdata(d
);
3540 int ret
= strict_strtol(buf
, 10, &val
);
3544 priv
->retry_rate
= (val
> 0) ? val
: 1;
3549 static ssize_t
show_retry_rate(struct device
*d
,
3550 struct device_attribute
*attr
, char *buf
)
3552 struct iwl_priv
*priv
= dev_get_drvdata(d
);
3553 return sprintf(buf
, "%d", priv
->retry_rate
);
3556 static DEVICE_ATTR(retry_rate
, S_IWUSR
| S_IRUSR
, show_retry_rate
,
3559 static ssize_t
store_power_level(struct device
*d
,
3560 struct device_attribute
*attr
,
3561 const char *buf
, size_t count
)
3563 struct iwl_priv
*priv
= dev_get_drvdata(d
);
3568 mutex_lock(&priv
->mutex
);
3570 if (!iwl_is_ready(priv
)) {
3575 ret
= strict_strtoul(buf
, 10, &mode
);
3579 ret
= iwl_power_set_user_mode(priv
, mode
);
3581 IWL_DEBUG_MAC80211("failed setting power mode.\n");
3587 mutex_unlock(&priv
->mutex
);
3591 static ssize_t
show_power_level(struct device
*d
,
3592 struct device_attribute
*attr
, char *buf
)
3594 struct iwl_priv
*priv
= dev_get_drvdata(d
);
3595 int mode
= priv
->power_data
.user_power_setting
;
3596 int system
= priv
->power_data
.system_power_setting
;
3597 int level
= priv
->power_data
.power_mode
;
3601 case IWL_POWER_SYS_AUTO
:
3602 p
+= sprintf(p
, "SYSTEM:auto");
3604 case IWL_POWER_SYS_AC
:
3605 p
+= sprintf(p
, "SYSTEM:ac");
3607 case IWL_POWER_SYS_BATTERY
:
3608 p
+= sprintf(p
, "SYSTEM:battery");
3612 p
+= sprintf(p
, "\tMODE:%s", (mode
< IWL_POWER_AUTO
) ?
3614 p
+= sprintf(p
, "\tINDEX:%d", level
);
3615 p
+= sprintf(p
, "\n");
3619 static DEVICE_ATTR(power_level
, S_IWUSR
| S_IRUSR
, show_power_level
,
3623 static ssize_t
show_statistics(struct device
*d
,
3624 struct device_attribute
*attr
, char *buf
)
3626 struct iwl_priv
*priv
= dev_get_drvdata(d
);
3627 u32 size
= sizeof(struct iwl_notif_statistics
);
3628 u32 len
= 0, ofs
= 0;
3629 u8
*data
= (u8
*)&priv
->statistics
;
3632 if (!iwl_is_alive(priv
))
3635 mutex_lock(&priv
->mutex
);
3636 rc
= iwl_send_statistics_request(priv
, 0);
3637 mutex_unlock(&priv
->mutex
);
3641 "Error sending statistics request: 0x%08X\n", rc
);
3645 while (size
&& (PAGE_SIZE
- len
)) {
3646 hex_dump_to_buffer(data
+ ofs
, size
, 16, 1, buf
+ len
,
3647 PAGE_SIZE
- len
, 1);
3649 if (PAGE_SIZE
- len
)
3653 size
-= min(size
, 16U);
3659 static DEVICE_ATTR(statistics
, S_IRUGO
, show_statistics
, NULL
);
3661 static ssize_t
show_status(struct device
*d
,
3662 struct device_attribute
*attr
, char *buf
)
3664 struct iwl_priv
*priv
= (struct iwl_priv
*)d
->driver_data
;
3665 if (!iwl_is_alive(priv
))
3667 return sprintf(buf
, "0x%08x\n", (int)priv
->status
);
3670 static DEVICE_ATTR(status
, S_IRUGO
, show_status
, NULL
);
3672 /*****************************************************************************
3674 * driver setup and teardown
3676 *****************************************************************************/
3678 static void iwl_setup_deferred_work(struct iwl_priv
*priv
)
3680 priv
->workqueue
= create_workqueue(DRV_NAME
);
3682 init_waitqueue_head(&priv
->wait_command_queue
);
3684 INIT_WORK(&priv
->up
, iwl_bg_up
);
3685 INIT_WORK(&priv
->restart
, iwl_bg_restart
);
3686 INIT_WORK(&priv
->rx_replenish
, iwl_bg_rx_replenish
);
3687 INIT_WORK(&priv
->rf_kill
, iwl_bg_rf_kill
);
3688 INIT_WORK(&priv
->beacon_update
, iwl_bg_beacon_update
);
3689 INIT_WORK(&priv
->run_time_calib_work
, iwl_bg_run_time_calib_work
);
3690 INIT_DELAYED_WORK(&priv
->init_alive_start
, iwl_bg_init_alive_start
);
3691 INIT_DELAYED_WORK(&priv
->alive_start
, iwl_bg_alive_start
);
3693 iwl_setup_scan_deferred_work(priv
);
3694 iwl_setup_power_deferred_work(priv
);
3696 if (priv
->cfg
->ops
->lib
->setup_deferred_work
)
3697 priv
->cfg
->ops
->lib
->setup_deferred_work(priv
);
3699 init_timer(&priv
->statistics_periodic
);
3700 priv
->statistics_periodic
.data
= (unsigned long)priv
;
3701 priv
->statistics_periodic
.function
= iwl_bg_statistics_periodic
;
3703 tasklet_init(&priv
->irq_tasklet
, (void (*)(unsigned long))
3704 iwl_irq_tasklet
, (unsigned long)priv
);
3707 static void iwl_cancel_deferred_work(struct iwl_priv
*priv
)
3709 if (priv
->cfg
->ops
->lib
->cancel_deferred_work
)
3710 priv
->cfg
->ops
->lib
->cancel_deferred_work(priv
);
3712 cancel_delayed_work_sync(&priv
->init_alive_start
);
3713 cancel_delayed_work(&priv
->scan_check
);
3714 cancel_delayed_work_sync(&priv
->set_power_save
);
3715 cancel_delayed_work(&priv
->alive_start
);
3716 cancel_work_sync(&priv
->beacon_update
);
3717 del_timer_sync(&priv
->statistics_periodic
);
3720 static struct attribute
*iwl_sysfs_entries
[] = {
3721 &dev_attr_flags
.attr
,
3722 &dev_attr_filter_flags
.attr
,
3723 &dev_attr_power_level
.attr
,
3724 &dev_attr_retry_rate
.attr
,
3725 &dev_attr_statistics
.attr
,
3726 &dev_attr_status
.attr
,
3727 &dev_attr_temperature
.attr
,
3728 &dev_attr_tx_power
.attr
,
3729 #ifdef CONFIG_IWLWIFI_DEBUG
3730 &dev_attr_debug_level
.attr
,
3732 &dev_attr_version
.attr
,
3737 static struct attribute_group iwl_attribute_group
= {
3738 .name
= NULL
, /* put in device directory */
3739 .attrs
= iwl_sysfs_entries
,
3742 static struct ieee80211_ops iwl_hw_ops
= {
3744 .start
= iwl_mac_start
,
3745 .stop
= iwl_mac_stop
,
3746 .add_interface
= iwl_mac_add_interface
,
3747 .remove_interface
= iwl_mac_remove_interface
,
3748 .config
= iwl_mac_config
,
3749 .config_interface
= iwl_mac_config_interface
,
3750 .configure_filter
= iwl_configure_filter
,
3751 .set_key
= iwl_mac_set_key
,
3752 .update_tkip_key
= iwl_mac_update_tkip_key
,
3753 .get_stats
= iwl_mac_get_stats
,
3754 .get_tx_stats
= iwl_mac_get_tx_stats
,
3755 .conf_tx
= iwl_mac_conf_tx
,
3756 .reset_tsf
= iwl_mac_reset_tsf
,
3757 .bss_info_changed
= iwl_bss_info_changed
,
3758 .ampdu_action
= iwl_mac_ampdu_action
,
3759 .hw_scan
= iwl_mac_hw_scan
3762 static int iwl_pci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
3765 struct iwl_priv
*priv
;
3766 struct ieee80211_hw
*hw
;
3767 struct iwl_cfg
*cfg
= (struct iwl_cfg
*)(ent
->driver_data
);
3768 unsigned long flags
;
3770 /************************
3771 * 1. Allocating HW data
3772 ************************/
3774 /* Disabling hardware scan means that mac80211 will perform scans
3775 * "the hard way", rather than using device's scan. */
3776 if (cfg
->mod_params
->disable_hw_scan
) {
3777 if (cfg
->mod_params
->debug
& IWL_DL_INFO
)
3778 dev_printk(KERN_DEBUG
, &(pdev
->dev
),
3779 "Disabling hw_scan\n");
3780 iwl_hw_ops
.hw_scan
= NULL
;
3783 hw
= iwl_alloc_all(cfg
, &iwl_hw_ops
);
3789 /* At this point both hw and priv are allocated. */
3791 SET_IEEE80211_DEV(hw
, &pdev
->dev
);
3793 IWL_DEBUG_INFO("*** LOAD DRIVER ***\n");
3795 priv
->pci_dev
= pdev
;
3797 #ifdef CONFIG_IWLWIFI_DEBUG
3798 priv
->debug_level
= priv
->cfg
->mod_params
->debug
;
3799 atomic_set(&priv
->restrict_refcnt
, 0);
3802 /**************************
3803 * 2. Initializing PCI bus
3804 **************************/
3805 if (pci_enable_device(pdev
)) {
3807 goto out_ieee80211_free_hw
;
3810 pci_set_master(pdev
);
3812 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(36));
3814 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(36));
3816 err
= pci_set_dma_mask(pdev
, DMA_BIT_MASK(32));
3818 err
= pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32));
3819 /* both attempts failed: */
3821 printk(KERN_WARNING
"%s: No suitable DMA available.\n",
3823 goto out_pci_disable_device
;
3827 err
= pci_request_regions(pdev
, DRV_NAME
);
3829 goto out_pci_disable_device
;
3831 pci_set_drvdata(pdev
, priv
);
3834 /***********************
3835 * 3. Read REV register
3836 ***********************/
3837 priv
->hw_base
= pci_iomap(pdev
, 0, 0);
3838 if (!priv
->hw_base
) {
3840 goto out_pci_release_regions
;
3843 IWL_DEBUG_INFO("pci_resource_len = 0x%08llx\n",
3844 (unsigned long long) pci_resource_len(pdev
, 0));
3845 IWL_DEBUG_INFO("pci_resource_base = %p\n", priv
->hw_base
);
3847 iwl_hw_detect(priv
);
3848 printk(KERN_INFO DRV_NAME
3849 ": Detected Intel Wireless WiFi Link %s REV=0x%X\n",
3850 priv
->cfg
->name
, priv
->hw_rev
);
3852 /* We disable the RETRY_TIMEOUT register (0x41) to keep
3853 * PCI Tx retries from interfering with C3 CPU state */
3854 pci_write_config_byte(pdev
, PCI_CFG_RETRY_TIMEOUT
, 0x00);
3857 err
= priv
->cfg
->ops
->lib
->apm_ops
.init(priv
);
3859 IWL_DEBUG_INFO("Failed to init APMG\n");
3865 /* Read the EEPROM */
3866 err
= iwl_eeprom_init(priv
);
3868 IWL_ERROR("Unable to init EEPROM\n");
3871 err
= iwl_eeprom_check_version(priv
);
3875 /* extract MAC Address */
3876 iwl_eeprom_get_mac(priv
, priv
->mac_addr
);
3877 IWL_DEBUG_INFO("MAC address: %pM\n", priv
->mac_addr
);
3878 SET_IEEE80211_PERM_ADDR(priv
->hw
, priv
->mac_addr
);
3880 /************************
3881 * 5. Setup HW constants
3882 ************************/
3883 if (iwl_set_hw_params(priv
)) {
3884 IWL_ERROR("failed to set hw parameters\n");
3885 goto out_free_eeprom
;
3888 /*******************
3890 *******************/
3892 err
= iwl_init_drv(priv
);
3894 goto out_free_eeprom
;
3895 /* At this point both hw and priv are initialized. */
3897 /**********************************
3898 * 7. Initialize module parameters
3899 **********************************/
3901 /* Disable radio (SW RF KILL) via parameter when loading driver */
3902 if (priv
->cfg
->mod_params
->disable
) {
3903 set_bit(STATUS_RF_KILL_SW
, &priv
->status
);
3904 IWL_DEBUG_INFO("Radio disabled.\n");
3907 /********************
3909 ********************/
3910 spin_lock_irqsave(&priv
->lock
, flags
);
3911 iwl_disable_interrupts(priv
);
3912 spin_unlock_irqrestore(&priv
->lock
, flags
);
3914 err
= sysfs_create_group(&pdev
->dev
.kobj
, &iwl_attribute_group
);
3916 IWL_ERROR("failed to create sysfs device attributes\n");
3917 goto out_uninit_drv
;
3921 iwl_setup_deferred_work(priv
);
3922 iwl_setup_rx_handlers(priv
);
3924 /********************
3926 ********************/
3927 pci_save_state(pdev
);
3928 pci_disable_device(pdev
);
3930 /**********************************
3931 * 10. Setup and register mac80211
3932 **********************************/
3934 err
= iwl_setup_mac(priv
);
3936 goto out_remove_sysfs
;
3938 err
= iwl_dbgfs_register(priv
, DRV_NAME
);
3940 IWL_ERROR("failed to create debugfs files\n");
3942 err
= iwl_rfkill_init(priv
);
3944 IWL_ERROR("Unable to initialize RFKILL system. "
3945 "Ignoring error: %d\n", err
);
3946 iwl_power_initialize(priv
);
3950 sysfs_remove_group(&pdev
->dev
.kobj
, &iwl_attribute_group
);
3952 iwl_uninit_drv(priv
);
3954 iwl_eeprom_free(priv
);
3956 pci_iounmap(pdev
, priv
->hw_base
);
3957 out_pci_release_regions
:
3958 pci_release_regions(pdev
);
3959 pci_set_drvdata(pdev
, NULL
);
3960 out_pci_disable_device
:
3961 pci_disable_device(pdev
);
3962 out_ieee80211_free_hw
:
3963 ieee80211_free_hw(priv
->hw
);
3968 static void __devexit
iwl_pci_remove(struct pci_dev
*pdev
)
3970 struct iwl_priv
*priv
= pci_get_drvdata(pdev
);
3971 unsigned long flags
;
3976 IWL_DEBUG_INFO("*** UNLOAD DRIVER ***\n");
3978 iwl_dbgfs_unregister(priv
);
3979 sysfs_remove_group(&pdev
->dev
.kobj
, &iwl_attribute_group
);
3981 /* ieee80211_unregister_hw call wil cause iwl_mac_stop to
3982 * to be called and iwl_down since we are removing the device
3983 * we need to set STATUS_EXIT_PENDING bit.
3985 set_bit(STATUS_EXIT_PENDING
, &priv
->status
);
3986 if (priv
->mac80211_registered
) {
3987 ieee80211_unregister_hw(priv
->hw
);
3988 priv
->mac80211_registered
= 0;
3993 /* make sure we flush any pending irq or
3994 * tasklet for the driver
3996 spin_lock_irqsave(&priv
->lock
, flags
);
3997 iwl_disable_interrupts(priv
);
3998 spin_unlock_irqrestore(&priv
->lock
, flags
);
4000 iwl_synchronize_irq(priv
);
4002 iwl_rfkill_unregister(priv
);
4003 iwl_dealloc_ucode_pci(priv
);
4006 iwl_rx_queue_free(priv
, &priv
->rxq
);
4007 iwl_hw_txq_ctx_free(priv
);
4009 iwl_clear_stations_table(priv
);
4010 iwl_eeprom_free(priv
);
4013 /*netif_stop_queue(dev); */
4014 flush_workqueue(priv
->workqueue
);
4016 /* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
4017 * priv->workqueue... so we can't take down the workqueue
4019 destroy_workqueue(priv
->workqueue
);
4020 priv
->workqueue
= NULL
;
4022 pci_iounmap(pdev
, priv
->hw_base
);
4023 pci_release_regions(pdev
);
4024 pci_disable_device(pdev
);
4025 pci_set_drvdata(pdev
, NULL
);
4027 iwl_uninit_drv(priv
);
4029 if (priv
->ibss_beacon
)
4030 dev_kfree_skb(priv
->ibss_beacon
);
4032 ieee80211_free_hw(priv
->hw
);
4037 static int iwl_pci_suspend(struct pci_dev
*pdev
, pm_message_t state
)
4039 struct iwl_priv
*priv
= pci_get_drvdata(pdev
);
4041 if (priv
->is_open
) {
4042 set_bit(STATUS_IN_SUSPEND
, &priv
->status
);
4043 iwl_mac_stop(priv
->hw
);
4047 pci_set_power_state(pdev
, PCI_D3hot
);
4052 static int iwl_pci_resume(struct pci_dev
*pdev
)
4054 struct iwl_priv
*priv
= pci_get_drvdata(pdev
);
4056 pci_set_power_state(pdev
, PCI_D0
);
4059 iwl_mac_start(priv
->hw
);
4061 clear_bit(STATUS_IN_SUSPEND
, &priv
->status
);
4065 #endif /* CONFIG_PM */
4067 /*****************************************************************************
4069 * driver and module entry point
4071 *****************************************************************************/
4073 /* Hardware specific file defines the PCI IDs table for that hardware module */
4074 static struct pci_device_id iwl_hw_card_ids
[] = {
4075 #ifdef CONFIG_IWL4965
4076 {IWL_PCI_DEVICE(0x4229, PCI_ANY_ID
, iwl4965_agn_cfg
)},
4077 {IWL_PCI_DEVICE(0x4230, PCI_ANY_ID
, iwl4965_agn_cfg
)},
4078 #endif /* CONFIG_IWL4965 */
4079 #ifdef CONFIG_IWL5000
4080 {IWL_PCI_DEVICE(0x4232, 0x1205, iwl5100_bg_cfg
)},
4081 {IWL_PCI_DEVICE(0x4232, 0x1305, iwl5100_bg_cfg
)},
4082 {IWL_PCI_DEVICE(0x4232, 0x1206, iwl5100_abg_cfg
)},
4083 {IWL_PCI_DEVICE(0x4232, 0x1306, iwl5100_abg_cfg
)},
4084 {IWL_PCI_DEVICE(0x4232, 0x1326, iwl5100_abg_cfg
)},
4085 {IWL_PCI_DEVICE(0x4237, 0x1216, iwl5100_abg_cfg
)},
4086 {IWL_PCI_DEVICE(0x4232, PCI_ANY_ID
, iwl5100_agn_cfg
)},
4087 {IWL_PCI_DEVICE(0x4235, PCI_ANY_ID
, iwl5300_agn_cfg
)},
4088 {IWL_PCI_DEVICE(0x4236, PCI_ANY_ID
, iwl5300_agn_cfg
)},
4089 {IWL_PCI_DEVICE(0x4237, PCI_ANY_ID
, iwl5100_agn_cfg
)},
4090 /* 5350 WiFi/WiMax */
4091 {IWL_PCI_DEVICE(0x423A, 0x1001, iwl5350_agn_cfg
)},
4092 {IWL_PCI_DEVICE(0x423A, 0x1021, iwl5350_agn_cfg
)},
4093 {IWL_PCI_DEVICE(0x423B, 0x1011, iwl5350_agn_cfg
)},
4094 /* 5150 Wifi/WiMax */
4095 {IWL_PCI_DEVICE(0x423C, PCI_ANY_ID
, iwl5150_agn_cfg
)},
4096 {IWL_PCI_DEVICE(0x423D, PCI_ANY_ID
, iwl5150_agn_cfg
)},
4097 #endif /* CONFIG_IWL5000 */
4101 MODULE_DEVICE_TABLE(pci
, iwl_hw_card_ids
);
4103 static struct pci_driver iwl_driver
= {
4105 .id_table
= iwl_hw_card_ids
,
4106 .probe
= iwl_pci_probe
,
4107 .remove
= __devexit_p(iwl_pci_remove
),
4109 .suspend
= iwl_pci_suspend
,
4110 .resume
= iwl_pci_resume
,
4114 static int __init
iwl_init(void)
4118 printk(KERN_INFO DRV_NAME
": " DRV_DESCRIPTION
", " DRV_VERSION
"\n");
4119 printk(KERN_INFO DRV_NAME
": " DRV_COPYRIGHT
"\n");
4121 ret
= iwlagn_rate_control_register();
4123 IWL_ERROR("Unable to register rate control algorithm: %d\n", ret
);
4127 ret
= pci_register_driver(&iwl_driver
);
4129 IWL_ERROR("Unable to initialize PCI module\n");
4130 goto error_register
;
4136 iwlagn_rate_control_unregister();
4140 static void __exit
iwl_exit(void)
4142 pci_unregister_driver(&iwl_driver
);
4143 iwlagn_rate_control_unregister();
4146 module_exit(iwl_exit
);
4147 module_init(iwl_init
);