2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
2009-01-08 18:20:02 +00:00
|
|
|
* Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Portions of this file are derived from the ipw3945 project, as well
|
|
|
|
* as portions of the ieee80211 subsystem header files.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
|
|
|
|
*
|
|
|
|
* The full GNU General Public License is included in this distribution in the
|
|
|
|
* file called LICENSE.
|
|
|
|
*
|
|
|
|
* Contact Information:
|
2008-12-09 19:28:58 +00:00
|
|
|
* Intel Linux Wireless <ilw@linux.intel.com>
|
2007-09-26 00:54:57 +00:00
|
|
|
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/wireless.h>
|
|
|
|
#include <linux/firmware.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
|
|
|
|
#include <asm/div64.h>
|
|
|
|
|
2008-12-19 02:37:09 +00:00
|
|
|
#define DRV_NAME "iwlagn"
|
|
|
|
|
2008-03-11 23:17:18 +00:00
|
|
|
#include "iwl-eeprom.h"
|
2008-04-24 18:55:38 +00:00
|
|
|
#include "iwl-dev.h"
|
2008-04-03 23:05:21 +00:00
|
|
|
#include "iwl-core.h"
|
2008-03-25 23:33:37 +00:00
|
|
|
#include "iwl-io.h"
|
2007-09-26 00:54:57 +00:00
|
|
|
#include "iwl-helpers.h"
|
2008-04-15 04:16:06 +00:00
|
|
|
#include "iwl-sta.h"
|
2008-04-16 23:34:47 +00:00
|
|
|
#include "iwl-calib.h"
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-10-25 09:15:49 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* module boiler plate
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* module name, copyright, version, etc.
|
|
|
|
*/
|
2008-07-18 05:53:02 +00:00
|
|
|
#define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2007-09-26 00:54:57 +00:00
|
|
|
#define VD "d"
|
|
|
|
#else
|
|
|
|
#define VD
|
|
|
|
#endif
|
|
|
|
|
2009-02-13 19:51:19 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_SPECTRUM_MEASUREMENT
|
2007-09-26 00:54:57 +00:00
|
|
|
#define VS "s"
|
|
|
|
#else
|
|
|
|
#define VS
|
|
|
|
#endif
|
|
|
|
|
2008-03-06 18:40:19 +00:00
|
|
|
#define DRV_VERSION IWLWIFI_VERSION VD VS
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION(DRV_DESCRIPTION);
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
2008-12-11 18:33:41 +00:00
|
|
|
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
|
2007-09-26 00:54:57 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
2008-07-21 15:54:42 +00:00
|
|
|
MODULE_ALIAS("iwl4965");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/*************** STATION TABLE MANAGEMENT ****
|
2007-11-29 03:09:47 +00:00
|
|
|
* mac80211 should be examined to determine if sta_info is duplicating
|
2007-09-26 00:54:57 +00:00
|
|
|
* the functionality provided here
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**************************************************************/
|
|
|
|
|
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_commit_rxon - commit staging_rxon to hardware
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
2007-10-25 09:15:22 +00:00
|
|
|
* The RXON command in staging_rxon is committed to the hardware and
|
2007-09-26 00:54:57 +00:00
|
|
|
* the active_rxon structure is updated with the new data. This
|
|
|
|
* function correctly transitions out of the RXON_ASSOC_MSK state if
|
|
|
|
* a HW tune is required based on the RXON structure changes.
|
|
|
|
*/
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_commit_rxon(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
/* cast away the const for active_rxon in this function */
|
2008-05-15 05:53:59 +00:00
|
|
|
struct iwl_rxon_cmd *active_rxon = (void *)&priv->active_rxon;
|
2008-06-30 09:23:06 +00:00
|
|
|
int ret;
|
|
|
|
bool new_assoc =
|
|
|
|
!!(priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_alive(priv))
|
2008-06-30 09:23:06 +00:00
|
|
|
return -EBUSY;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* always get timestamp with Rx frame */
|
|
|
|
priv->staging_rxon.flags |= RXON_FLG_TSF2HOST_MSK;
|
2008-07-11 03:53:31 +00:00
|
|
|
/* allow CTS-to-self if possible. this is relevant only for
|
|
|
|
* 5000, but will not damage 4965 */
|
|
|
|
priv->staging_rxon.flags |= RXON_FLG_SELF_CTS_EN;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:52 +00:00
|
|
|
ret = iwl_check_rxon_cmd(priv);
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Invalid RXON configuration. Not committing.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we don't need to send a full RXON, we can use
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_rxon_assoc_cmd which is used to reconfigure filter
|
2007-09-26 00:54:57 +00:00
|
|
|
* and other flags for the current radio configuration. */
|
2008-09-03 03:18:44 +00:00
|
|
|
if (!iwl_full_rxon_required(priv)) {
|
2008-06-30 09:23:06 +00:00
|
|
|
ret = iwl_send_rxon_assoc(priv);
|
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error setting RXON_ASSOC (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* station table will be cleared */
|
|
|
|
priv->assoc_station_added = 0;
|
|
|
|
|
|
|
|
/* If we are currently associated and the new config requires
|
|
|
|
* an RXON_ASSOC and the new config wants the associated mask enabled,
|
|
|
|
* we must clear the associated from the active configuration
|
|
|
|
* before we apply the new config */
|
2008-06-30 09:23:06 +00:00
|
|
|
if (iwl_is_associated(priv) && new_assoc) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Toggling associated bit on current RXON\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
|
2008-06-30 09:23:06 +00:00
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
|
2008-05-15 05:53:59 +00:00
|
|
|
sizeof(struct iwl_rxon_cmd),
|
2007-09-26 00:54:57 +00:00
|
|
|
&priv->active_rxon);
|
|
|
|
|
|
|
|
/* If the mask clearing failed then we set
|
|
|
|
* active_rxon back to what it was previously */
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2007-09-26 00:54:57 +00:00
|
|
|
active_rxon->filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error clearing ASSOC_MSK (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Sending RXON\n"
|
2007-09-26 00:54:57 +00:00
|
|
|
"* with%s RXON_FILTER_ASSOC_MSK\n"
|
|
|
|
"* channel = %d\n"
|
2008-10-27 22:59:26 +00:00
|
|
|
"* bssid = %pM\n",
|
2008-06-30 09:23:06 +00:00
|
|
|
(new_assoc ? "" : "out"),
|
2007-09-26 00:54:57 +00:00
|
|
|
le16_to_cpu(priv->staging_rxon.channel),
|
2008-10-27 22:59:26 +00:00
|
|
|
priv->staging_rxon.bssid_addr);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_set_rxon_hwcrypto(priv, !priv->hw_params.sw_crypto);
|
2008-06-30 09:23:06 +00:00
|
|
|
|
|
|
|
/* Apply the new configuration
|
|
|
|
* RXON unassoc clears the station table in uCode, send it before
|
|
|
|
* we add the bcast station. If assoc bit is set, we will send RXON
|
|
|
|
* after having added the bcast and bssid station.
|
|
|
|
*/
|
|
|
|
if (!new_assoc) {
|
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
|
2008-05-15 05:53:59 +00:00
|
|
|
sizeof(struct iwl_rxon_cmd), &priv->staging_rxon);
|
2008-06-30 09:23:06 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-06-30 09:23:08 +00:00
|
|
|
iwl_clear_stations_table(priv);
|
2007-09-27 03:27:33 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if (!priv->error_recovering)
|
|
|
|
priv->start_calib = 0;
|
|
|
|
|
|
|
|
/* Add the broadcast address so we can send broadcast frames */
|
2008-05-15 05:54:04 +00:00
|
|
|
if (iwl_rxon_add_station(priv, iwl_bcast_addr, 0) ==
|
2008-06-30 09:23:06 +00:00
|
|
|
IWL_INVALID_STATION) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error adding BROADCAST address for transmit.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we have set the ASSOC_MSK and we are in BSS mode then
|
|
|
|
* add the IWL_AP_ID to the station rate table */
|
2008-06-30 09:23:14 +00:00
|
|
|
if (new_assoc) {
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_STATION) {
|
2008-06-30 09:23:14 +00:00
|
|
|
ret = iwl_rxon_add_station(priv,
|
|
|
|
priv->active_rxon.bssid_addr, 1);
|
|
|
|
if (ret == IWL_INVALID_STATION) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Error adding AP address for TX.\n");
|
2008-06-30 09:23:14 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
priv->assoc_station_added = 1;
|
|
|
|
if (priv->default_wep_key &&
|
|
|
|
iwl_send_static_wepkey_cmd(priv, 0))
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"Could not send WEP static key.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2008-06-30 09:23:06 +00:00
|
|
|
|
|
|
|
/* Apply the new configuration
|
|
|
|
* RXON assoc doesn't clear the station table in uCode,
|
|
|
|
*/
|
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_RXON,
|
|
|
|
sizeof(struct iwl_rxon_cmd), &priv->staging_rxon);
|
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error setting new RXON (%d)\n", ret);
|
2008-06-30 09:23:06 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
memcpy(active_rxon, &priv->staging_rxon, sizeof(*active_rxon));
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-07-11 03:53:40 +00:00
|
|
|
iwl_init_sensitivity(priv);
|
|
|
|
|
|
|
|
/* If we issue a new RXON command which required a tune then we must
|
|
|
|
* send a new TXPOWER command or we won't be able to Tx any frames */
|
|
|
|
ret = iwl_set_tx_power(priv, priv->tx_power_user_lmt, true);
|
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Error sending TX power (%d)\n", ret);
|
2008-07-11 03:53:40 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
void iwl_update_chain_flags(struct iwl_priv *priv)
|
2008-04-21 22:41:51 +00:00
|
|
|
{
|
|
|
|
|
2008-04-24 00:15:05 +00:00
|
|
|
iwl_set_rxon_chain(priv);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2008-04-21 22:41:51 +00:00
|
|
|
}
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
static void iwl_clear_free_frames(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
struct list_head *element;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "%d frames on pre-allocated heap on clear.\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->frames_count);
|
|
|
|
|
|
|
|
while (!list_empty(&priv->free_frames)) {
|
|
|
|
element = priv->free_frames.next;
|
|
|
|
list_del(element);
|
2008-05-15 05:54:01 +00:00
|
|
|
kfree(list_entry(element, struct iwl_frame, list));
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->frames_count--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->frames_count) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "%d frames still in use. Did we lose one?\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->frames_count);
|
|
|
|
priv->frames_count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
static struct iwl_frame *iwl_get_free_frame(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-15 05:54:01 +00:00
|
|
|
struct iwl_frame *frame;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct list_head *element;
|
|
|
|
if (list_empty(&priv->free_frames)) {
|
|
|
|
frame = kzalloc(sizeof(*frame), GFP_KERNEL);
|
|
|
|
if (!frame) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Could not allocate frame!\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->frames_count++;
|
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
element = priv->free_frames.next;
|
|
|
|
list_del(element);
|
2008-05-15 05:54:01 +00:00
|
|
|
return list_entry(element, struct iwl_frame, list);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
static void iwl_free_frame(struct iwl_priv *priv, struct iwl_frame *frame)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
memset(frame, 0, sizeof(*frame));
|
|
|
|
list_add(&frame->list, &priv->free_frames);
|
|
|
|
}
|
|
|
|
|
2008-07-18 05:53:03 +00:00
|
|
|
static unsigned int iwl_fill_beacon_frame(struct iwl_priv *priv,
|
|
|
|
struct ieee80211_hdr *hdr,
|
2008-12-16 07:37:07 +00:00
|
|
|
int left)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-28 23:33:35 +00:00
|
|
|
if (!iwl_is_associated(priv) || !priv->ibss_beacon ||
|
2008-09-10 22:01:58 +00:00
|
|
|
((priv->iw_mode != NL80211_IFTYPE_ADHOC) &&
|
|
|
|
(priv->iw_mode != NL80211_IFTYPE_AP)))
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (priv->ibss_beacon->len > left)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
memcpy(hdr, priv->ibss_beacon->data, priv->ibss_beacon->len);
|
|
|
|
|
|
|
|
return priv->ibss_beacon->len;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static unsigned int iwl_hw_get_beacon_cmd(struct iwl_priv *priv,
|
2008-07-18 05:53:03 +00:00
|
|
|
struct iwl_frame *frame, u8 rate)
|
|
|
|
{
|
|
|
|
struct iwl_tx_beacon_cmd *tx_beacon_cmd;
|
|
|
|
unsigned int frame_size;
|
|
|
|
|
|
|
|
tx_beacon_cmd = &frame->u.beacon;
|
|
|
|
memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));
|
|
|
|
|
|
|
|
tx_beacon_cmd->tx.sta_id = priv->hw_params.bcast_sta_id;
|
|
|
|
tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
|
|
|
|
|
|
|
|
frame_size = iwl_fill_beacon_frame(priv, tx_beacon_cmd->frame,
|
|
|
|
sizeof(frame->u) - sizeof(*tx_beacon_cmd));
|
|
|
|
|
|
|
|
BUG_ON(frame_size > MAX_MPDU_SIZE);
|
|
|
|
tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
|
|
|
|
|
|
|
|
if ((rate == IWL_RATE_1M_PLCP) || (rate >= IWL_RATE_2M_PLCP))
|
|
|
|
tx_beacon_cmd->tx.rate_n_flags =
|
|
|
|
iwl_hw_set_rate_n_flags(rate, RATE_MCS_CCK_MSK);
|
|
|
|
else
|
|
|
|
tx_beacon_cmd->tx.rate_n_flags =
|
|
|
|
iwl_hw_set_rate_n_flags(rate, 0);
|
|
|
|
|
|
|
|
tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
|
|
|
|
TX_CMD_FLG_TSF_MSK |
|
|
|
|
TX_CMD_FLG_STA_RATE_MSK;
|
|
|
|
|
|
|
|
return sizeof(*tx_beacon_cmd) + frame_size;
|
|
|
|
}
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_send_beacon_cmd(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-15 05:54:01 +00:00
|
|
|
struct iwl_frame *frame;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned int frame_size;
|
|
|
|
int rc;
|
|
|
|
u8 rate;
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
frame = iwl_get_free_frame(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!frame) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Could not obtain free frame buffer for beacon "
|
2007-09-26 00:54:57 +00:00
|
|
|
"command.\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
rate = iwl_rate_get_lowest_plcp(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
frame_size = iwl_hw_get_beacon_cmd(priv, frame, rate);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-21 20:53:44 +00:00
|
|
|
rc = iwl_send_cmd_pdu(priv, REPLY_TX_BEACON, frame_size,
|
2007-09-26 00:54:57 +00:00
|
|
|
&frame->u.cmd[0]);
|
|
|
|
|
2008-05-15 05:54:01 +00:00
|
|
|
iwl_free_frame(priv, frame);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2009-01-19 23:30:26 +00:00
|
|
|
static inline dma_addr_t iwl_tfd_tb_get_addr(struct iwl_tfd *tfd, u8 idx)
|
|
|
|
{
|
|
|
|
struct iwl_tfd_tb *tb = &tfd->tbs[idx];
|
|
|
|
|
|
|
|
dma_addr_t addr = get_unaligned_le32(&tb->lo);
|
|
|
|
if (sizeof(dma_addr_t) > sizeof(u32))
|
|
|
|
addr |=
|
|
|
|
((dma_addr_t)(le16_to_cpu(tb->hi_n_len) & 0xF) << 16) << 16;
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u16 iwl_tfd_tb_get_len(struct iwl_tfd *tfd, u8 idx)
|
|
|
|
{
|
|
|
|
struct iwl_tfd_tb *tb = &tfd->tbs[idx];
|
|
|
|
|
|
|
|
return le16_to_cpu(tb->hi_n_len) >> 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void iwl_tfd_set_tb(struct iwl_tfd *tfd, u8 idx,
|
|
|
|
dma_addr_t addr, u16 len)
|
|
|
|
{
|
|
|
|
struct iwl_tfd_tb *tb = &tfd->tbs[idx];
|
|
|
|
u16 hi_n_len = len << 4;
|
|
|
|
|
|
|
|
put_unaligned_le32(addr, &tb->lo);
|
|
|
|
if (sizeof(dma_addr_t) > sizeof(u32))
|
|
|
|
hi_n_len |= ((addr >> 16) >> 16) & 0xF;
|
|
|
|
|
|
|
|
tb->hi_n_len = cpu_to_le16(hi_n_len);
|
|
|
|
|
|
|
|
tfd->num_tbs = idx + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline u8 iwl_tfd_get_num_tbs(struct iwl_tfd *tfd)
|
|
|
|
{
|
|
|
|
return tfd->num_tbs & 0x1f;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
|
|
|
|
* @priv - driver private data
|
|
|
|
* @txq - tx queue
|
|
|
|
*
|
|
|
|
* Does NOT advance any TFD circular buffer read/write indexes
|
|
|
|
* Does NOT free the TFD itself (which is within circular buffer)
|
|
|
|
*/
|
|
|
|
void iwl_hw_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
|
|
|
|
{
|
2009-01-23 21:45:13 +00:00
|
|
|
struct iwl_tfd *tfd_tmp = (struct iwl_tfd *)txq->tfds;
|
2009-01-19 23:30:26 +00:00
|
|
|
struct iwl_tfd *tfd;
|
|
|
|
struct pci_dev *dev = priv->pci_dev;
|
|
|
|
int index = txq->q.read_ptr;
|
|
|
|
int i;
|
|
|
|
int num_tbs;
|
|
|
|
|
|
|
|
tfd = &tfd_tmp[index];
|
|
|
|
|
|
|
|
/* Sanity check on number of chunks */
|
|
|
|
num_tbs = iwl_tfd_get_num_tbs(tfd);
|
|
|
|
|
|
|
|
if (num_tbs >= IWL_NUM_OF_TBS) {
|
|
|
|
IWL_ERR(priv, "Too many chunks: %i\n", num_tbs);
|
|
|
|
/* @todo issue fatal error, it is quite serious situation */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Unmap tx_cmd */
|
|
|
|
if (num_tbs)
|
|
|
|
pci_unmap_single(dev,
|
|
|
|
pci_unmap_addr(&txq->cmd[index]->meta, mapping),
|
|
|
|
pci_unmap_len(&txq->cmd[index]->meta, len),
|
2009-02-18 23:54:33 +00:00
|
|
|
PCI_DMA_BIDIRECTIONAL);
|
2009-01-19 23:30:26 +00:00
|
|
|
|
|
|
|
/* Unmap chunks, if any. */
|
|
|
|
for (i = 1; i < num_tbs; i++) {
|
|
|
|
pci_unmap_single(dev, iwl_tfd_tb_get_addr(tfd, i),
|
|
|
|
iwl_tfd_tb_get_len(tfd, i), PCI_DMA_TODEVICE);
|
|
|
|
|
|
|
|
if (txq->txb) {
|
|
|
|
dev_kfree_skb(txq->txb[txq->q.read_ptr].skb[i - 1]);
|
|
|
|
txq->txb[txq->q.read_ptr].skb[i - 1] = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int iwl_hw_txq_attach_buf_to_tfd(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_queue *txq,
|
|
|
|
dma_addr_t addr, u16 len,
|
|
|
|
u8 reset, u8 pad)
|
|
|
|
{
|
|
|
|
struct iwl_queue *q;
|
2009-01-23 21:45:13 +00:00
|
|
|
struct iwl_tfd *tfd, *tfd_tmp;
|
2009-01-19 23:30:26 +00:00
|
|
|
u32 num_tbs;
|
|
|
|
|
|
|
|
q = &txq->q;
|
2009-01-23 21:45:13 +00:00
|
|
|
tfd_tmp = (struct iwl_tfd *)txq->tfds;
|
|
|
|
tfd = &tfd_tmp[q->write_ptr];
|
2009-01-19 23:30:26 +00:00
|
|
|
|
|
|
|
if (reset)
|
|
|
|
memset(tfd, 0, sizeof(*tfd));
|
|
|
|
|
|
|
|
num_tbs = iwl_tfd_get_num_tbs(tfd);
|
|
|
|
|
|
|
|
/* Each TFD can point to a maximum 20 Tx buffers */
|
|
|
|
if (num_tbs >= IWL_NUM_OF_TBS) {
|
|
|
|
IWL_ERR(priv, "Error can not send more than %d chunks\n",
|
|
|
|
IWL_NUM_OF_TBS);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(addr & ~DMA_BIT_MASK(36));
|
|
|
|
if (unlikely(addr & ~IWL_TX_DMA_MASK))
|
|
|
|
IWL_ERR(priv, "Unaligned address = %llx\n",
|
|
|
|
(unsigned long long)addr);
|
|
|
|
|
|
|
|
iwl_tfd_set_tb(tfd, num_tbs, addr, len);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-23 21:45:14 +00:00
|
|
|
/*
|
|
|
|
* Tell nic where to find circular buffer of Tx Frame Descriptors for
|
|
|
|
* given Tx queue, and enable the DMA channel used for that queue.
|
|
|
|
*
|
|
|
|
* 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
|
|
|
|
* channels supported in hardware.
|
|
|
|
*/
|
|
|
|
int iwl_hw_tx_queue_init(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_queue *txq)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
unsigned long flags;
|
|
|
|
int txq_id = txq->q.id;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
ret = iwl_grab_nic_access(priv);
|
|
|
|
if (ret) {
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Circular buffer (TFD queue in DRAM) physical base address */
|
|
|
|
iwl_write_direct32(priv, FH_MEM_CBBC_QUEUE(txq_id),
|
|
|
|
txq->q.dma_addr >> 8);
|
|
|
|
|
|
|
|
iwl_release_nic_access(priv);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Misc. internal state and helper functions
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_ht_conf(struct iwl_priv *priv,
|
2008-04-21 22:42:00 +00:00
|
|
|
struct ieee80211_bss_conf *bss_conf)
|
|
|
|
{
|
2008-10-14 14:58:37 +00:00
|
|
|
struct ieee80211_sta_ht_cap *ht_conf;
|
2008-04-21 22:42:00 +00:00
|
|
|
struct iwl_ht_info *iwl_conf = &priv->current_ht_config;
|
2008-10-14 14:58:37 +00:00
|
|
|
struct ieee80211_sta *sta;
|
2008-04-21 22:42:00 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter: \n");
|
2008-04-21 22:42:00 +00:00
|
|
|
|
|
|
|
if (!iwl_conf->is_ht)
|
|
|
|
return;
|
|
|
|
|
2008-10-14 14:58:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It is totally wrong to base global information on something
|
|
|
|
* that is valid only when associated, alas, this driver works
|
|
|
|
* that way and I don't know how to fix it.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
sta = ieee80211_find_sta(priv->hw, priv->bssid);
|
|
|
|
if (!sta) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ht_conf = &sta->ht_cap;
|
|
|
|
|
2008-04-21 22:42:00 +00:00
|
|
|
if (ht_conf->cap & IEEE80211_HT_CAP_SGI_20)
|
2008-05-15 05:54:08 +00:00
|
|
|
iwl_conf->sgf |= HT_SHORT_GI_20MHZ;
|
2008-04-21 22:42:00 +00:00
|
|
|
if (ht_conf->cap & IEEE80211_HT_CAP_SGI_40)
|
2008-05-15 05:54:08 +00:00
|
|
|
iwl_conf->sgf |= HT_SHORT_GI_40MHZ;
|
2008-04-21 22:42:00 +00:00
|
|
|
|
|
|
|
iwl_conf->is_green_field = !!(ht_conf->cap & IEEE80211_HT_CAP_GRN_FLD);
|
|
|
|
iwl_conf->max_amsdu_size =
|
|
|
|
!!(ht_conf->cap & IEEE80211_HT_CAP_MAX_AMSDU);
|
|
|
|
|
|
|
|
iwl_conf->supported_chan_width =
|
2008-10-09 10:13:49 +00:00
|
|
|
!!(ht_conf->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40);
|
2008-10-14 14:58:37 +00:00
|
|
|
|
2008-12-12 06:27:43 +00:00
|
|
|
/*
|
|
|
|
* XXX: The HT configuration needs to be moved into iwl_mac_config()
|
|
|
|
* to be done there correctly.
|
|
|
|
*/
|
|
|
|
|
|
|
|
iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
|
2008-12-23 23:58:44 +00:00
|
|
|
if (conf_is_ht40_minus(&priv->hw->conf))
|
2008-12-12 06:27:43 +00:00
|
|
|
iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
|
2008-12-23 23:58:44 +00:00
|
|
|
else if (conf_is_ht40_plus(&priv->hw->conf))
|
2008-12-12 06:27:43 +00:00
|
|
|
iwl_conf->extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
|
|
|
|
|
2008-04-21 22:42:00 +00:00
|
|
|
/* If no above or below channel supplied disable FAT channel */
|
2008-10-09 10:13:49 +00:00
|
|
|
if (iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_ABOVE &&
|
2008-12-12 06:27:43 +00:00
|
|
|
iwl_conf->extension_chan_offset != IEEE80211_HT_PARAM_CHA_SEC_BELOW)
|
2008-04-21 22:42:00 +00:00
|
|
|
iwl_conf->supported_chan_width = 0;
|
|
|
|
|
2008-09-03 03:26:47 +00:00
|
|
|
iwl_conf->sm_ps = (u8)((ht_conf->cap & IEEE80211_HT_CAP_SM_PS) >> 2);
|
|
|
|
|
2008-10-09 10:13:49 +00:00
|
|
|
memcpy(&iwl_conf->mcs, &ht_conf->mcs, 16);
|
2008-04-21 22:42:00 +00:00
|
|
|
|
2008-12-12 06:27:43 +00:00
|
|
|
iwl_conf->tx_chan_width = iwl_conf->supported_chan_width != 0;
|
2008-04-21 22:42:00 +00:00
|
|
|
iwl_conf->ht_protection =
|
2008-10-14 14:58:37 +00:00
|
|
|
bss_conf->ht.operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
|
2008-04-21 22:42:00 +00:00
|
|
|
iwl_conf->non_GF_STA_present =
|
2008-10-14 14:58:37 +00:00
|
|
|
!!(bss_conf->ht.operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
2008-04-21 22:42:00 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2008-04-21 22:42:00 +00:00
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
#define MAX_UCODE_BEACON_INTERVAL 4096
|
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
static u16 iwl_adjust_beacon_interval(u16 beacon_val)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
u16 new_val = 0;
|
|
|
|
u16 beacon_factor = 0;
|
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
beacon_factor = (beacon_val + MAX_UCODE_BEACON_INTERVAL)
|
|
|
|
/ MAX_UCODE_BEACON_INTERVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
new_val = beacon_val / beacon_factor;
|
|
|
|
|
2009-02-21 00:03:31 +00:00
|
|
|
if (!new_val)
|
|
|
|
new_val = MAX_UCODE_BEACON_INTERVAL;
|
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
return new_val;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
static void iwl_setup_rxon_timing(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-10-08 01:37:30 +00:00
|
|
|
u64 tsf;
|
|
|
|
s32 interval_tm, rem;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned long flags;
|
|
|
|
struct ieee80211_conf *conf = NULL;
|
|
|
|
u16 beacon_int = 0;
|
|
|
|
|
|
|
|
conf = ieee80211_get_hw_conf(priv->hw);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-08 01:37:30 +00:00
|
|
|
priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
|
2008-07-19 01:41:24 +00:00
|
|
|
priv->rxon_timing.listen_interval = cpu_to_le16(conf->listen_interval);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_STATION) {
|
2008-10-08 01:37:30 +00:00
|
|
|
beacon_int = iwl_adjust_beacon_interval(priv->beacon_int);
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->rxon_timing.atim_window = 0;
|
|
|
|
} else {
|
2008-10-08 01:37:30 +00:00
|
|
|
beacon_int = iwl_adjust_beacon_interval(conf->beacon_int);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* TODO: we need to get atim_window from upper stack
|
|
|
|
* for now we set to 0 */
|
|
|
|
priv->rxon_timing.atim_window = 0;
|
|
|
|
}
|
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
priv->rxon_timing.beacon_interval = cpu_to_le16(beacon_int);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */
|
|
|
|
interval_tm = beacon_int * 1024;
|
|
|
|
rem = do_div(tsf, interval_tm);
|
|
|
|
priv->rxon_timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ASSOC(priv, "beacon interval %d beacon timer %d beacon tim %d\n",
|
2008-10-08 01:37:30 +00:00
|
|
|
le16_to_cpu(priv->rxon_timing.beacon_interval),
|
|
|
|
le32_to_cpu(priv->rxon_timing.beacon_init_val),
|
|
|
|
le16_to_cpu(priv->rxon_timing.atim_window));
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_set_mode(struct iwl_priv *priv, int mode)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_connection_init_rx_config(priv, mode);
|
2009-01-27 22:27:52 +00:00
|
|
|
iwl_set_rxon_chain(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
|
|
|
|
|
2008-06-30 09:23:08 +00:00
|
|
|
iwl_clear_stations_table(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:10:15 +00:00
|
|
|
/* dont commit rxon if rf-kill is on*/
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_ready_rf(priv))
|
2007-11-29 03:10:15 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
cancel_delayed_work(&priv->scan_check);
|
2008-06-12 01:47:10 +00:00
|
|
|
if (iwl_scan_cancel_timeout(priv, 100)) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
|
2007-11-29 03:10:15 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* Generic RX handler implementations
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
2008-05-29 08:34:55 +00:00
|
|
|
static void iwl_rx_reply_alive(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-05 02:22:33 +00:00
|
|
|
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
|
2008-05-29 08:34:55 +00:00
|
|
|
struct iwl_alive_resp *palive;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct delayed_work *pwork;
|
|
|
|
|
|
|
|
palive = &pkt->u.alive_frame;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Alive ucode status 0x%08X revision "
|
2007-09-26 00:54:57 +00:00
|
|
|
"0x%01X 0x%01X\n",
|
|
|
|
palive->is_valid, palive->ver_type,
|
|
|
|
palive->ver_subtype);
|
|
|
|
|
|
|
|
if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Initialization Alive received.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(&priv->card_alive_init,
|
|
|
|
&pkt->u.alive_frame,
|
2008-05-29 08:34:55 +00:00
|
|
|
sizeof(struct iwl_init_alive_resp));
|
2007-09-26 00:54:57 +00:00
|
|
|
pwork = &priv->init_alive_start;
|
|
|
|
} else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(&priv->card_alive, &pkt->u.alive_frame,
|
2008-05-29 08:34:55 +00:00
|
|
|
sizeof(struct iwl_alive_resp));
|
2007-09-26 00:54:57 +00:00
|
|
|
pwork = &priv->alive_start;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We delay the ALIVE response by 5ms to
|
|
|
|
* give the HW RF Kill time to activate... */
|
|
|
|
if (palive->is_valid == UCODE_VALID_OK)
|
|
|
|
queue_delayed_work(priv->workqueue, pwork,
|
|
|
|
msecs_to_jiffies(5));
|
|
|
|
else
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "uCode did not respond OK.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_beacon_update(struct work_struct *work)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(work, struct iwl_priv, beacon_update);
|
2007-09-26 00:54:57 +00:00
|
|
|
struct sk_buff *beacon;
|
|
|
|
|
|
|
|
/* Pull updated AP beacon from mac80211. will fail if not in AP mode */
|
2008-05-15 10:55:29 +00:00
|
|
|
beacon = ieee80211_beacon_get(priv->hw, priv->vif);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!beacon) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "update beacon failed\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
/* new beacon skb is allocated every time; dispose previous.*/
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
|
|
|
priv->ibss_beacon = beacon;
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_beacon_cmd(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_bg_statistics_periodic - Timer callback to queue statistics
|
2008-06-12 01:46:53 +00:00
|
|
|
*
|
|
|
|
* This callback is provided in order to send a statistics request.
|
|
|
|
*
|
|
|
|
* This timer function is continually reset to execute within
|
|
|
|
* REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
|
|
|
|
* was received. We need to ensure we receive the statistics in order
|
|
|
|
* to update the temperature used for calibrating the TXPOWER.
|
|
|
|
*/
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_statistics_periodic(unsigned long data)
|
2008-06-12 01:46:53 +00:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)data;
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
2008-10-29 21:05:49 +00:00
|
|
|
/* dont send host command if rf-kill is on */
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return;
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
iwl_send_statistics_request(priv, CMD_ASYNC);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_rx_beacon_notif(struct iwl_priv *priv,
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-05-05 02:22:33 +00:00
|
|
|
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
|
2008-12-11 18:33:40 +00:00
|
|
|
struct iwl4965_beacon_notif *beacon =
|
|
|
|
(struct iwl4965_beacon_notif *)pkt->u.raw;
|
2008-06-12 01:47:11 +00:00
|
|
|
u8 rate = iwl_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "beacon status %x retries %d iss %d "
|
2007-09-26 00:54:57 +00:00
|
|
|
"tsf %d %d rate %d\n",
|
2008-06-12 01:47:07 +00:00
|
|
|
le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
|
2007-09-26 00:54:57 +00:00
|
|
|
beacon->beacon_notify_hdr.failure_frame,
|
|
|
|
le32_to_cpu(beacon->ibss_mgr_status),
|
|
|
|
le32_to_cpu(beacon->high_tsf),
|
|
|
|
le32_to_cpu(beacon->low_tsf), rate);
|
|
|
|
#endif
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if ((priv->iw_mode == NL80211_IFTYPE_AP) &&
|
2007-09-26 00:54:57 +00:00
|
|
|
(!test_bit(STATUS_EXIT_PENDING, &priv->status)))
|
|
|
|
queue_work(priv->workqueue, &priv->beacon_update);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle notification from uCode that card's power state is changing
|
|
|
|
* due to software, hardware, or critical temperature RFKILL */
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_rx_card_state_notif(struct iwl_priv *priv,
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-05 02:22:33 +00:00
|
|
|
struct iwl_rx_packet *pkt = (struct iwl_rx_packet *)rxb->skb->data;
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
|
|
|
|
unsigned long status = priv->status;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RF_KILL(priv, "Card state received: HW:%s SW:%s\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
(flags & HW_CARD_DISABLED) ? "Kill" : "On",
|
|
|
|
(flags & SW_CARD_DISABLED) ? "Kill" : "On");
|
|
|
|
|
|
|
|
if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED |
|
|
|
|
RF_CARD_DISABLED)) {
|
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
|
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
if (!iwl_grab_nic_access(priv)) {
|
|
|
|
iwl_write_direct32(
|
2007-09-26 00:54:57 +00:00
|
|
|
priv, HBUS_TARG_MBX_C,
|
|
|
|
HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
|
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_release_nic_access(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & RXON_CARD_DISABLED)) {
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
|
2008-03-25 23:33:37 +00:00
|
|
|
if (!iwl_grab_nic_access(priv)) {
|
|
|
|
iwl_write_direct32(
|
2007-09-26 00:54:57 +00:00
|
|
|
priv, HBUS_TARG_MBX_C,
|
|
|
|
HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
|
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_release_nic_access(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & RF_CARD_DISABLED) {
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_SET,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_read32(priv, CSR_UCODE_DRV_GP1);
|
|
|
|
if (!iwl_grab_nic_access(priv))
|
|
|
|
iwl_release_nic_access(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & HW_CARD_DISABLED)
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
|
|
|
|
|
|
|
|
if (flags & SW_CARD_DISABLED)
|
|
|
|
set_bit(STATUS_RF_KILL_SW, &priv->status);
|
|
|
|
else
|
|
|
|
clear_bit(STATUS_RF_KILL_SW, &priv->status);
|
|
|
|
|
|
|
|
if (!(flags & RXON_CARD_DISABLED))
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if ((test_bit(STATUS_RF_KILL_HW, &status) !=
|
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->status)) ||
|
|
|
|
(test_bit(STATUS_RF_KILL_SW, &status) !=
|
|
|
|
test_bit(STATUS_RF_KILL_SW, &priv->status)))
|
|
|
|
queue_work(priv->workqueue, &priv->rf_kill);
|
|
|
|
else
|
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
int iwl_set_pwr_src(struct iwl_priv *priv, enum iwl_pwr_src src)
|
2008-07-18 05:53:04 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
ret = iwl_grab_nic_access(priv);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
if (src == IWL_PWR_SRC_VAUX) {
|
2009-02-10 23:19:02 +00:00
|
|
|
if (pci_pme_capable(priv->pci_dev, PCI_D3cold))
|
2008-07-18 05:53:04 +00:00
|
|
|
iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
|
|
|
|
APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
|
|
|
|
~APMG_PS_CTRL_MSK_PWR_SRC);
|
|
|
|
} else {
|
|
|
|
iwl_set_bits_mask_prph(priv, APMG_PS_CTRL_REG,
|
|
|
|
APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
|
|
|
|
~APMG_PS_CTRL_MSK_PWR_SRC);
|
|
|
|
}
|
|
|
|
|
|
|
|
iwl_release_nic_access(priv);
|
|
|
|
err:
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_setup_rx_handlers - Initialize Rx handler callbacks
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Setup the RX handlers for each of the reply types sent from the uCode
|
|
|
|
* to the host.
|
|
|
|
*
|
|
|
|
* This function chains into the hardware specific files for them to setup
|
|
|
|
* any hardware specific handlers as well.
|
|
|
|
*/
|
2008-06-30 09:23:11 +00:00
|
|
|
static void iwl_setup_rx_handlers(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-29 08:34:55 +00:00
|
|
|
priv->rx_handlers[REPLY_ALIVE] = iwl_rx_reply_alive;
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->rx_handlers[REPLY_ERROR] = iwl_rx_reply_error;
|
|
|
|
priv->rx_handlers[CHANNEL_SWITCH_NOTIFICATION] = iwl_rx_csa;
|
|
|
|
priv->rx_handlers[PM_SLEEP_NOTIFICATION] = iwl_rx_pm_sleep_notif;
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->rx_handlers[PM_DEBUG_STATISTIC_NOTIFIC] =
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_rx_pm_debug_statistics_notif;
|
|
|
|
priv->rx_handlers[BEACON_NOTIFICATION] = iwl_rx_beacon_notif;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/*
|
|
|
|
* The same handler is used for both the REPLY to a discrete
|
|
|
|
* statistics request from the host as well as for the periodic
|
|
|
|
* statistics notifications (after received beacons) from the uCode.
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
2008-06-30 09:23:07 +00:00
|
|
|
priv->rx_handlers[REPLY_STATISTICS_CMD] = iwl_rx_statistics;
|
|
|
|
priv->rx_handlers[STATISTICS_NOTIFICATION] = iwl_rx_statistics;
|
2008-06-12 01:47:10 +00:00
|
|
|
|
2008-11-07 17:58:41 +00:00
|
|
|
iwl_setup_spectrum_handlers(priv);
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_setup_rx_scan_handlers(priv);
|
|
|
|
|
2008-05-29 08:35:18 +00:00
|
|
|
/* status change handler */
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->rx_handlers[CARD_STATE_NOTIFICATION] = iwl_rx_card_state_notif;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-29 08:35:04 +00:00
|
|
|
priv->rx_handlers[MISSED_BEACONS_NOTIFICATION] =
|
|
|
|
iwl_rx_missed_beacon_notif;
|
2008-05-29 08:35:18 +00:00
|
|
|
/* Rx handlers */
|
2008-06-30 09:23:09 +00:00
|
|
|
priv->rx_handlers[REPLY_RX_PHY_CMD] = iwl_rx_reply_rx_phy;
|
|
|
|
priv->rx_handlers[REPLY_RX_MPDU_CMD] = iwl_rx_reply_rx;
|
2008-06-30 09:23:11 +00:00
|
|
|
/* block ack */
|
|
|
|
priv->rx_handlers[REPLY_COMPRESSED_BA] = iwl_rx_reply_compressed_ba;
|
2007-11-29 03:09:47 +00:00
|
|
|
/* Set up hardware specific Rx handlers */
|
2008-04-24 18:55:20 +00:00
|
|
|
priv->cfg->ops->lib->rx_handler_setup(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-05-05 02:22:28 +00:00
|
|
|
* iwl_rx_handle - Main entry function for receiving responses from uCode
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Uses the priv->rx_handlers callback function array to invoke
|
|
|
|
* the appropriate handlers, including command responses,
|
|
|
|
* frame-received notifications, and other notifications.
|
|
|
|
*/
|
2008-05-05 02:22:28 +00:00
|
|
|
void iwl_rx_handle(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_mem_buffer *rxb;
|
2008-05-05 02:22:33 +00:00
|
|
|
struct iwl_rx_packet *pkt;
|
2008-05-05 02:22:28 +00:00
|
|
|
struct iwl_rx_queue *rxq = &priv->rxq;
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 r, i;
|
|
|
|
int reclaim;
|
|
|
|
unsigned long flags;
|
2007-11-29 03:10:14 +00:00
|
|
|
u8 fill_rx = 0;
|
2008-02-07 21:16:33 +00:00
|
|
|
u32 count = 8;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:55 +00:00
|
|
|
/* uCode's read index (stored in shared DRAM) indicates the last Rx
|
|
|
|
* buffer that the driver may process (last buffer filled by ucode). */
|
2008-11-07 17:58:39 +00:00
|
|
|
r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
|
2007-09-26 00:54:57 +00:00
|
|
|
i = rxq->read;
|
|
|
|
|
|
|
|
/* Rx interrupt, but nothing sent from uCode */
|
|
|
|
if (i == r)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "r = %d, i = %d\n", r, i);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-05 02:22:28 +00:00
|
|
|
if (iwl_rx_queue_space(rxq) > (RX_QUEUE_SIZE / 2))
|
2007-11-29 03:10:14 +00:00
|
|
|
fill_rx = 1;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
while (i != r) {
|
|
|
|
rxb = rxq->queue[i];
|
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* If an RXB doesn't have a Rx queue slot associated with it,
|
2007-09-26 00:54:57 +00:00
|
|
|
* then a bug has been introduced in the queue refilling
|
|
|
|
* routines -- catch it here */
|
|
|
|
BUG_ON(rxb == NULL);
|
|
|
|
|
|
|
|
rxq->queue[i] = NULL;
|
|
|
|
|
2009-04-21 17:55:48 +00:00
|
|
|
pci_unmap_single(priv->pci_dev, rxb->real_dma_addr,
|
|
|
|
priv->hw_params.rx_buf_size + 256,
|
|
|
|
PCI_DMA_FROMDEVICE);
|
2008-05-05 02:22:33 +00:00
|
|
|
pkt = (struct iwl_rx_packet *)rxb->skb->data;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Reclaim a command buffer only if this packet is a response
|
|
|
|
* to a (driver-originated) command.
|
|
|
|
* If the packet (e.g. Rx frame) originated from uCode,
|
|
|
|
* there is no command buffer to reclaim.
|
|
|
|
* Ucode should set SEQ_RX_FRAME bit if ucode-originated,
|
|
|
|
* but apparently a few don't get set; catch them here. */
|
|
|
|
reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
|
|
|
|
(pkt->hdr.cmd != REPLY_RX_PHY_CMD) &&
|
2008-03-21 20:53:44 +00:00
|
|
|
(pkt->hdr.cmd != REPLY_RX) &&
|
2008-10-24 06:48:58 +00:00
|
|
|
(pkt->hdr.cmd != REPLY_RX_MPDU_CMD) &&
|
2007-09-27 03:27:31 +00:00
|
|
|
(pkt->hdr.cmd != REPLY_COMPRESSED_BA) &&
|
2007-09-26 00:54:57 +00:00
|
|
|
(pkt->hdr.cmd != STATISTICS_NOTIFICATION) &&
|
|
|
|
(pkt->hdr.cmd != REPLY_TX);
|
|
|
|
|
|
|
|
/* Based on type of command response or notification,
|
|
|
|
* handle those that need handling via function in
|
2008-10-29 21:05:46 +00:00
|
|
|
* rx_handlers table. See iwl_setup_rx_handlers() */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (priv->rx_handlers[pkt->hdr.cmd]) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv, "r = %d, i = %d, %s, 0x%02x\n", r,
|
2008-05-06 03:05:12 +00:00
|
|
|
i, get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->rx_handlers[pkt->hdr.cmd] (priv, rxb);
|
|
|
|
} else {
|
|
|
|
/* No handling needed */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RX(priv,
|
2007-09-26 00:54:57 +00:00
|
|
|
"r %d i %d No handler needed for %s, 0x%02x\n",
|
|
|
|
r, i, get_cmd_string(pkt->hdr.cmd),
|
|
|
|
pkt->hdr.cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reclaim) {
|
2007-11-29 03:09:47 +00:00
|
|
|
/* Invoke any callbacks, transfer the skb to caller, and
|
2008-03-21 20:53:44 +00:00
|
|
|
* fire off the (possibly) blocking iwl_send_cmd()
|
2007-09-26 00:54:57 +00:00
|
|
|
* as we reclaim the driver command queue */
|
|
|
|
if (rxb && rxb->skb)
|
2008-05-29 08:35:12 +00:00
|
|
|
iwl_tx_cmd_complete(priv, rxb);
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Claim null rxb?\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* For now we just don't re-use anything. We can tweak this
|
|
|
|
* later to try and re-use notification packets and SKBs that
|
|
|
|
* fail to Rx correctly */
|
|
|
|
if (rxb->skb != NULL) {
|
|
|
|
priv->alloc_rxb_skb--;
|
|
|
|
dev_kfree_skb_any(rxb->skb);
|
|
|
|
rxb->skb = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rxq->lock, flags);
|
|
|
|
list_add_tail(&rxb->list, &priv->rxq.rx_used);
|
|
|
|
spin_unlock_irqrestore(&rxq->lock, flags);
|
|
|
|
i = (i + 1) & RX_QUEUE_MASK;
|
2007-11-29 03:10:14 +00:00
|
|
|
/* If there are a lot of unused frames,
|
|
|
|
* restock the Rx queue so ucode wont assert. */
|
|
|
|
if (fill_rx) {
|
|
|
|
count++;
|
|
|
|
if (count >= 8) {
|
|
|
|
priv->rxq.read = i;
|
2008-12-17 08:52:33 +00:00
|
|
|
iwl_rx_queue_restock(priv);
|
2007-11-29 03:10:14 +00:00
|
|
|
count = 0;
|
|
|
|
}
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Backtrack one entry */
|
|
|
|
priv->rxq.read = i;
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_queue_restock(priv);
|
|
|
|
}
|
|
|
|
|
2008-03-28 23:21:08 +00:00
|
|
|
/* call this function to flush any scheduled tasklet */
|
|
|
|
static inline void iwl_synchronize_irq(struct iwl_priv *priv)
|
|
|
|
{
|
2008-10-24 06:48:56 +00:00
|
|
|
/* wait to make sure we flush pending tasklet*/
|
2008-03-28 23:21:08 +00:00
|
|
|
synchronize_irq(priv->pci_dev->irq);
|
|
|
|
tasklet_kill(&priv->irq_tasklet);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_error_recovery(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
memcpy(&priv->staging_rxon, &priv->recovery_rxon,
|
|
|
|
sizeof(priv->staging_rxon));
|
|
|
|
priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-15 05:54:04 +00:00
|
|
|
iwl_rxon_add_station(priv, priv->bssid, 1);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->assoc_id = le16_to_cpu(priv->staging_rxon.assoc_id);
|
|
|
|
priv->error_recovering = 0;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_irq_tasklet(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
u32 inta, handled = 0;
|
|
|
|
u32 inta_fh;
|
|
|
|
unsigned long flags;
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 inta_mask;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* Ack/clear/reset pending uCode interrupts.
|
|
|
|
* Note: Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
|
|
|
|
* and will clear only when CSR_FH_INT_STATUS gets cleared. */
|
2008-03-25 23:33:37 +00:00
|
|
|
inta = iwl_read32(priv, CSR_INT);
|
|
|
|
iwl_write32(priv, CSR_INT, inta);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Ack/clear/reset pending flow-handler (DMA) interrupts.
|
|
|
|
* Any new interrupts that happen after this, either while we're
|
|
|
|
* in this tasklet, or later, will show up in next ISR/tasklet. */
|
2008-03-25 23:33:37 +00:00
|
|
|
inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
|
|
|
|
iwl_write32(priv, CSR_FH_INT_STATUS, inta_fh);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-05-05 02:22:40 +00:00
|
|
|
if (priv->debug_level & IWL_DL_ISR) {
|
2007-11-29 03:09:47 +00:00
|
|
|
/* just for debug */
|
2008-03-25 23:33:37 +00:00
|
|
|
inta_mask = iwl_read32(priv, CSR_INT_MASK);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
inta, inta_mask, inta_fh);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
|
|
|
|
* atomic, make sure that inta covers all the interrupts that
|
|
|
|
* we've discovered, even if FH interrupt came in just after
|
|
|
|
* reading CSR_INT. */
|
2008-03-05 02:09:28 +00:00
|
|
|
if (inta_fh & CSR49_FH_INT_RX_MASK)
|
2007-09-26 00:54:57 +00:00
|
|
|
inta |= CSR_INT_BIT_FH_RX;
|
2008-03-05 02:09:28 +00:00
|
|
|
if (inta_fh & CSR49_FH_INT_TX_MASK)
|
2007-09-26 00:54:57 +00:00
|
|
|
inta |= CSR_INT_BIT_FH_TX;
|
|
|
|
|
|
|
|
/* Now service all interrupt bits discovered above. */
|
|
|
|
if (inta & CSR_INT_BIT_HW_ERR) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Microcode HW error detected. Restarting.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Tell the device to stop sending interrupts */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_irq_handle_error(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_HW_ERR;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-05-05 02:22:40 +00:00
|
|
|
if (priv->debug_level & (IWL_DL_ISR)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
/* NIC fires this, but we don't use it, redundant with WAKEUP */
|
2008-01-23 18:15:20 +00:00
|
|
|
if (inta & CSR_INT_BIT_SCD)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Scheduler finished to transmit "
|
2008-01-23 18:15:20 +00:00
|
|
|
"the frame/frames.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Alive notification via Rx interrupt will do the real work */
|
|
|
|
if (inta & CSR_INT_BIT_ALIVE)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Alive interrupt\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Safely ignore these bits for debug checks below */
|
2008-01-23 18:15:20 +00:00
|
|
|
inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* HW RF KILL switch toggled */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (inta & CSR_INT_BIT_RF_KILL) {
|
|
|
|
int hw_rf_kill = 0;
|
2008-03-25 23:33:37 +00:00
|
|
|
if (!(iwl_read32(priv, CSR_GP_CNTRL) &
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
|
|
|
|
hw_rf_kill = 1;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_RF_KILL(priv, "RF_KILL bit toggled to %s.\n",
|
2008-11-12 21:14:08 +00:00
|
|
|
hw_rf_kill ? "disable radio" : "enable radio");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-06-30 09:23:25 +00:00
|
|
|
/* driver only loads ucode once setting the interface up.
|
2009-01-19 12:10:07 +00:00
|
|
|
* the driver allows loading the ucode even if the radio
|
|
|
|
* is killed. Hence update the killswitch state here. The
|
|
|
|
* rfkill handler will care about restarting if needed.
|
2008-06-30 09:23:25 +00:00
|
|
|
*/
|
2009-01-19 12:10:07 +00:00
|
|
|
if (!test_bit(STATUS_ALIVE, &priv->status)) {
|
|
|
|
if (hw_rf_kill)
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
queue_work(priv->workqueue, &priv->rf_kill);
|
2008-12-11 18:33:37 +00:00
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_RF_KILL;
|
|
|
|
}
|
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* Chip got too hot and stopped itself */
|
2007-09-26 00:54:57 +00:00
|
|
|
if (inta & CSR_INT_BIT_CT_KILL) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Microcode CT kill error detected.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_CT_KILL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Error detected by uCode */
|
|
|
|
if (inta & CSR_INT_BIT_SW_ERR) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Microcode SW error detected. "
|
|
|
|
" Restarting 0x%X.\n", inta);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_irq_handle_error(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_SW_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* uCode wakes up after power-down sleep */
|
|
|
|
if (inta & CSR_INT_BIT_WAKEUP) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Wakeup interrupt\n");
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_queue_update_write_ptr(priv, &priv->rxq);
|
2008-05-15 05:54:00 +00:00
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[0]);
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[1]);
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[2]);
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[3]);
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[4]);
|
|
|
|
iwl_txq_update_write_ptr(priv, &priv->txq[5]);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
handled |= CSR_INT_BIT_WAKEUP;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* All uCode command responses, including Tx command responses,
|
|
|
|
* Rx "responses" (frame-received notification), and other
|
|
|
|
* notifications from uCode come through here*/
|
|
|
|
if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_handle(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (inta & CSR_INT_BIT_FH_TX) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "Tx interrupt\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
handled |= CSR_INT_BIT_FH_TX;
|
2008-05-15 05:54:12 +00:00
|
|
|
/* FH finished to write, send event */
|
|
|
|
priv->ucode_write_complete = 1;
|
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (inta & ~handled)
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unhandled INTA bits 0x%08x\n", inta & ~handled);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (inta & ~CSR_INI_SET_MASK) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Disabled INTA bits 0x%08x were pending\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
inta & ~CSR_INI_SET_MASK);
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, " with FH_INT = 0x%08x\n", inta_fh);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Re-enable all interrupts */
|
2008-03-28 23:21:08 +00:00
|
|
|
/* only Re-enable if diabled by irq */
|
|
|
|
if (test_bit(STATUS_INT_ENABLED, &priv->status))
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_enable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-05-05 02:22:40 +00:00
|
|
|
if (priv->debug_level & (IWL_DL_ISR)) {
|
2008-03-25 23:33:37 +00:00
|
|
|
inta = iwl_read32(priv, CSR_INT);
|
|
|
|
inta_mask = iwl_read32(priv, CSR_INT_MASK);
|
|
|
|
inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ISR(priv, "End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
|
2007-09-26 00:54:57 +00:00
|
|
|
"flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************
|
|
|
|
*
|
|
|
|
* uCode download functions
|
|
|
|
*
|
|
|
|
******************************************************************************/
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_dealloc_ucode_pci(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_code);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_init_data);
|
|
|
|
iwl_free_fw_desc(priv->pci_dev, &priv->ucode_boot);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_nic_start(struct iwl_priv *priv)
|
2008-05-15 05:53:55 +00:00
|
|
|
{
|
|
|
|
/* Remove all resets to allow NIC to operate */
|
|
|
|
iwl_write32(priv, CSR_RESET, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_read_ucode - Read uCode images from disk file.
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* Copy into buffers for card to fetch via bus-mastering
|
|
|
|
*/
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_read_ucode(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-06-13 07:44:54 +00:00
|
|
|
struct iwl_ucode *ucode;
|
2008-12-02 20:14:06 +00:00
|
|
|
int ret = -EINVAL, index;
|
2007-09-26 00:54:57 +00:00
|
|
|
const struct firmware *ucode_raw;
|
2008-12-02 20:14:06 +00:00
|
|
|
const char *name_pre = priv->cfg->fw_name_pre;
|
|
|
|
const unsigned int api_max = priv->cfg->ucode_api_max;
|
|
|
|
const unsigned int api_min = priv->cfg->ucode_api_min;
|
|
|
|
char buf[25];
|
2007-09-26 00:54:57 +00:00
|
|
|
u8 *src;
|
|
|
|
size_t len;
|
2008-12-02 20:14:06 +00:00
|
|
|
u32 api_ver, inst_size, data_size, init_size, init_data_size, boot_size;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Ask kernel firmware_class module to get the boot firmware off disk.
|
|
|
|
* request_firmware() is synchronous, file is in memory on return. */
|
2008-12-02 20:14:06 +00:00
|
|
|
for (index = api_max; index >= api_min; index--) {
|
|
|
|
sprintf(buf, "%s%d%s", name_pre, index, ".ucode");
|
|
|
|
ret = request_firmware(&ucode_raw, buf, &priv->pci_dev->dev);
|
|
|
|
if (ret < 0) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "%s firmware file req failed: %d\n",
|
2008-12-02 20:14:06 +00:00
|
|
|
buf, ret);
|
|
|
|
if (ret == -ENOENT)
|
|
|
|
continue;
|
|
|
|
else
|
|
|
|
goto error;
|
|
|
|
} else {
|
|
|
|
if (index < api_max)
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Loaded firmware %s, "
|
|
|
|
"which is deprecated. "
|
|
|
|
"Please use API v%u instead.\n",
|
2008-12-02 20:14:06 +00:00
|
|
|
buf, api_max);
|
2008-12-19 02:37:33 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Got firmware '%s' file (%zd bytes) from disk\n",
|
2008-12-02 20:14:06 +00:00
|
|
|
buf, ucode_raw->size);
|
|
|
|
break;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-12-02 20:14:06 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto error;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Make sure that we got at least our header! */
|
|
|
|
if (ucode_raw->size < sizeof(*ucode)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "File size way too small!\n");
|
2007-11-29 03:09:41 +00:00
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Data from ucode file: header followed by uCode images */
|
|
|
|
ucode = (void *)ucode_raw->data;
|
|
|
|
|
2008-12-02 20:14:05 +00:00
|
|
|
priv->ucode_ver = le32_to_cpu(ucode->ver);
|
2008-12-02 20:14:06 +00:00
|
|
|
api_ver = IWL_UCODE_API(priv->ucode_ver);
|
2007-09-26 00:54:57 +00:00
|
|
|
inst_size = le32_to_cpu(ucode->inst_size);
|
|
|
|
data_size = le32_to_cpu(ucode->data_size);
|
|
|
|
init_size = le32_to_cpu(ucode->init_size);
|
|
|
|
init_data_size = le32_to_cpu(ucode->init_data_size);
|
|
|
|
boot_size = le32_to_cpu(ucode->boot_size);
|
|
|
|
|
2008-12-02 20:14:06 +00:00
|
|
|
/* api_ver should match the api version forming part of the
|
|
|
|
* firmware filename ... but we don't check for that and only rely
|
2009-01-26 10:06:57 +00:00
|
|
|
* on the API version read from firmware header from here on forward */
|
2008-12-02 20:14:06 +00:00
|
|
|
|
|
|
|
if (api_ver < api_min || api_ver > api_max) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Driver unable to support your firmware API. "
|
2008-12-02 20:14:06 +00:00
|
|
|
"Driver supports v%u, firmware is v%u.\n",
|
|
|
|
api_max, api_ver);
|
|
|
|
priv->ucode_ver = 0;
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err_release;
|
|
|
|
}
|
|
|
|
if (api_ver != api_max)
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_ERR(priv, "Firmware has old API version. Expected v%u, "
|
2008-12-02 20:14:06 +00:00
|
|
|
"got v%u. New firmware can be obtained "
|
|
|
|
"from http://www.intellinuxwireless.org.\n",
|
|
|
|
api_max, api_ver);
|
|
|
|
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u\n",
|
|
|
|
IWL_UCODE_MAJOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_MINOR(priv->ucode_ver),
|
|
|
|
IWL_UCODE_API(priv->ucode_ver),
|
|
|
|
IWL_UCODE_SERIAL(priv->ucode_ver));
|
2008-12-02 20:14:06 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
|
2008-12-02 20:14:06 +00:00
|
|
|
priv->ucode_ver);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %u\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
inst_size);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %u\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
data_size);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %u\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
init_size);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %u\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
init_data_size);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "f/w package hdr boot inst size = %u\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
boot_size);
|
|
|
|
|
|
|
|
/* Verify size of file vs. image size info in file's header */
|
|
|
|
if (ucode_raw->size < sizeof(*ucode) +
|
|
|
|
inst_size + data_size + init_size +
|
|
|
|
init_data_size + boot_size) {
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "uCode file size %d too small\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
(int)ucode_raw->size);
|
2007-11-29 03:09:41 +00:00
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Verify that uCode images will fit in card's SRAM */
|
2008-04-21 22:41:53 +00:00
|
|
|
if (inst_size > priv->hw_params.max_inst_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "uCode instr len %d too large to fit in\n",
|
2007-11-29 03:09:41 +00:00
|
|
|
inst_size);
|
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
|
|
|
|
2008-04-21 22:41:53 +00:00
|
|
|
if (data_size > priv->hw_params.max_data_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "uCode data len %d too large to fit in\n",
|
2007-11-29 03:09:41 +00:00
|
|
|
data_size);
|
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
2008-04-21 22:41:53 +00:00
|
|
|
if (init_size > priv->hw_params.max_inst_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_INFO(priv, "uCode init instr len %d too large to fit in\n",
|
|
|
|
init_size);
|
2007-11-29 03:09:41 +00:00
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
2008-04-21 22:41:53 +00:00
|
|
|
if (init_data_size > priv->hw_params.max_data_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_INFO(priv, "uCode init data len %d too large to fit in\n",
|
2007-11-29 03:09:41 +00:00
|
|
|
init_data_size);
|
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
2008-04-21 22:41:53 +00:00
|
|
|
if (boot_size > priv->hw_params.max_bsm_size) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_INFO(priv, "uCode boot instr len %d too large to fit in\n",
|
|
|
|
boot_size);
|
2007-11-29 03:09:41 +00:00
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto err_release;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate ucode buffers for card's bus-master loading ... */
|
|
|
|
|
|
|
|
/* Runtime instructions and 2 copies of data:
|
|
|
|
* 1) unmodified from disk
|
|
|
|
* 2) backup cache for save/restore during power-downs */
|
|
|
|
priv->ucode_code.len = inst_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_code);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
priv->ucode_data.len = data_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
priv->ucode_data_backup.len = data_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_data_backup);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-23 21:45:22 +00:00
|
|
|
if (!priv->ucode_code.v_addr || !priv->ucode_data.v_addr ||
|
|
|
|
!priv->ucode_data_backup.v_addr)
|
|
|
|
goto err_pci_alloc;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Initialization instructions and data */
|
2007-11-29 03:09:41 +00:00
|
|
|
if (init_size && init_data_size) {
|
|
|
|
priv->ucode_init.len = init_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init);
|
2007-11-29 03:09:41 +00:00
|
|
|
|
|
|
|
priv->ucode_init_data.len = init_data_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_init_data);
|
2007-11-29 03:09:41 +00:00
|
|
|
|
|
|
|
if (!priv->ucode_init.v_addr || !priv->ucode_init_data.v_addr)
|
|
|
|
goto err_pci_alloc;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Bootstrap (instructions only, no data) */
|
2007-11-29 03:09:41 +00:00
|
|
|
if (boot_size) {
|
|
|
|
priv->ucode_boot.len = boot_size;
|
2008-01-15 01:46:20 +00:00
|
|
|
iwl_alloc_fw_desc(priv->pci_dev, &priv->ucode_boot);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 03:09:41 +00:00
|
|
|
if (!priv->ucode_boot.v_addr)
|
|
|
|
goto err_pci_alloc;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Copy images into buffers for card's bus-master reads ... */
|
|
|
|
|
|
|
|
/* Runtime instructions (first block of data in file) */
|
|
|
|
src = &ucode->data[0];
|
|
|
|
len = priv->ucode_code.len;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) uCode instr len %Zd\n", len);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->ucode_code.v_addr, src, len);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->ucode_code.v_addr, (u32)priv->ucode_code.p_addr);
|
|
|
|
|
|
|
|
/* Runtime data (2nd block)
|
2008-10-29 21:05:46 +00:00
|
|
|
* NOTE: Copy into backup buffer will be done in iwl_up() */
|
2007-09-26 00:54:57 +00:00
|
|
|
src = &ucode->data[inst_size];
|
|
|
|
len = priv->ucode_data.len;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) uCode data len %Zd\n", len);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->ucode_data.v_addr, src, len);
|
|
|
|
memcpy(priv->ucode_data_backup.v_addr, src, len);
|
|
|
|
|
|
|
|
/* Initialization instructions (3rd block) */
|
|
|
|
if (init_size) {
|
|
|
|
src = &ucode->data[inst_size + data_size];
|
|
|
|
len = priv->ucode_init.len;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) init instr len %Zd\n",
|
2007-11-29 03:09:41 +00:00
|
|
|
len);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->ucode_init.v_addr, src, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialization data (4th block) */
|
|
|
|
if (init_data_size) {
|
|
|
|
src = &ucode->data[inst_size + data_size + init_size];
|
|
|
|
len = priv->ucode_init_data.len;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) init data len %Zd\n",
|
2007-11-29 03:09:41 +00:00
|
|
|
len);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->ucode_init_data.v_addr, src, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Bootstrap instructions (5th block) */
|
|
|
|
src = &ucode->data[inst_size + data_size + init_size + init_data_size];
|
|
|
|
len = priv->ucode_boot.len;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Copying (but not loading) boot instr len %Zd\n", len);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->ucode_boot.v_addr, src, len);
|
|
|
|
|
|
|
|
/* We have our copies now, allow OS release its copies */
|
|
|
|
release_firmware(ucode_raw);
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_pci_alloc:
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to allocate pci memory\n");
|
2007-11-29 03:09:41 +00:00
|
|
|
ret = -ENOMEM;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_dealloc_ucode_pci(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
err_release:
|
|
|
|
release_firmware(ucode_raw);
|
|
|
|
|
|
|
|
error:
|
2007-11-29 03:09:41 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-11-07 17:58:34 +00:00
|
|
|
/* temporary */
|
|
|
|
static int iwl_mac_beacon_update(struct ieee80211_hw *hw,
|
|
|
|
struct sk_buff *skb);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/**
|
2008-05-29 08:34:54 +00:00
|
|
|
* iwl_alive_start - called after REPLY_ALIVE notification received
|
2007-09-26 00:54:57 +00:00
|
|
|
* from protocol/runtime uCode (initialization uCode's
|
2008-05-29 08:34:54 +00:00
|
|
|
* Alive gets handled by iwl_init_alive_start()).
|
2007-09-26 00:54:57 +00:00
|
|
|
*/
|
2008-05-29 08:34:54 +00:00
|
|
|
static void iwl_alive_start(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-04-15 04:16:03 +00:00
|
|
|
int ret = 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->card_alive.is_valid != UCODE_VALID_OK) {
|
|
|
|
/* We had an error bringing up the hardware, so take it
|
|
|
|
* all the way back down so we can try again */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Alive failed.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize uCode has loaded Runtime uCode ... verify inst image.
|
|
|
|
* This is a paranoid check, because we would not have gotten the
|
|
|
|
* "runtime" alive if code weren't properly loaded. */
|
2008-04-24 18:55:18 +00:00
|
|
|
if (iwl_verify_ucode(priv)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Runtime instruction load was bad;
|
|
|
|
* take it all the way back down so we can try again */
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Bad runtime uCode load.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
2008-06-30 09:23:08 +00:00
|
|
|
iwl_clear_stations_table(priv);
|
2008-04-15 04:16:03 +00:00
|
|
|
ret = priv->cfg->ops->lib->alive_notify(priv);
|
|
|
|
if (ret) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv,
|
|
|
|
"Could not complete ALIVE transition [ntf]: %d\n", ret);
|
2007-09-26 00:54:57 +00:00
|
|
|
goto restart;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* After the ALIVE response, we can send host commands to the uCode */
|
2007-09-26 00:54:57 +00:00
|
|
|
set_bit(STATUS_ALIVE, &priv->status);
|
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (iwl_is_rfkill(priv))
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
|
2008-05-15 10:55:26 +00:00
|
|
|
ieee80211_wake_queues(priv->hw);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
priv->active_rate = priv->rates_mask;
|
|
|
|
priv->active_rate_basic = priv->rates_mask & IWL_BASIC_RATES_MASK;
|
|
|
|
|
2008-03-28 23:33:35 +00:00
|
|
|
if (iwl_is_associated(priv)) {
|
2008-05-15 05:53:59 +00:00
|
|
|
struct iwl_rxon_cmd *active_rxon =
|
|
|
|
(struct iwl_rxon_cmd *)&priv->active_rxon;
|
2009-03-18 04:59:18 +00:00
|
|
|
/* apply any changes in staging */
|
|
|
|
priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2007-09-26 00:54:57 +00:00
|
|
|
active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
|
|
|
} else {
|
|
|
|
/* Initialize our rx_config data */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_connection_init_rx_config(priv, priv->iw_mode);
|
2009-01-27 22:27:52 +00:00
|
|
|
iwl_set_rxon_chain(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
memcpy(priv->staging_rxon.node_addr, priv->mac_addr, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
2007-11-29 03:09:47 +00:00
|
|
|
/* Configure Bluetooth device coexistence support */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_bt_config(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-29 08:34:54 +00:00
|
|
|
iwl_reset_run_time_calib(priv);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Configure the adapter for unassociated operation */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* At this point, the NIC is initialized and operational */
|
2008-06-12 01:47:13 +00:00
|
|
|
iwl_rf_kill_ct_config(priv);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2008-04-03 23:05:23 +00:00
|
|
|
iwl_leds_register(priv);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
|
2008-03-18 21:57:49 +00:00
|
|
|
set_bit(STATUS_READY, &priv->status);
|
2008-01-15 01:46:18 +00:00
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->error_recovering)
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_error_recovery(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-06-12 01:47:19 +00:00
|
|
|
iwl_power_update_mode(priv, 1);
|
2008-06-12 01:47:05 +00:00
|
|
|
|
2008-11-07 17:58:34 +00:00
|
|
|
/* reassociate for ADHOC mode */
|
|
|
|
if (priv->vif && (priv->iw_mode == NL80211_IFTYPE_ADHOC)) {
|
|
|
|
struct sk_buff *beacon = ieee80211_beacon_get(priv->hw,
|
|
|
|
priv->vif);
|
|
|
|
if (beacon)
|
|
|
|
iwl_mac_beacon_update(priv->hw, beacon);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-06-12 01:47:05 +00:00
|
|
|
if (test_and_clear_bit(STATUS_MODE_PENDING, &priv->status))
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_set_mode(priv, priv->iw_mode);
|
2008-06-12 01:47:05 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
restart:
|
|
|
|
queue_work(priv->workqueue, &priv->restart);
|
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
static void iwl_cancel_deferred_work(struct iwl_priv *priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void __iwl_down(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int exit_pending = test_bit(STATUS_EXIT_PENDING, &priv->status);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!exit_pending)
|
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->status);
|
|
|
|
|
2008-03-25 23:33:36 +00:00
|
|
|
iwl_leds_unregister(priv);
|
|
|
|
|
2008-06-30 09:23:08 +00:00
|
|
|
iwl_clear_stations_table(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Unblock any waiting calls */
|
|
|
|
wake_up_interruptible_all(&priv->wait_command_queue);
|
|
|
|
|
|
|
|
/* Wipe out the EXIT_PENDING status bit if we are not actually
|
|
|
|
* exiting the module */
|
|
|
|
if (!exit_pending)
|
|
|
|
clear_bit(STATUS_EXIT_PENDING, &priv->status);
|
|
|
|
|
|
|
|
/* stop and reset the on-board processor */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* tell the device to stop sending interrupts */
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
iwl_synchronize_irq(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->mac80211_registered)
|
|
|
|
ieee80211_stop_queues(priv->hw);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* If we have not previously called iwl_init() then
|
2007-09-26 00:54:57 +00:00
|
|
|
* clear all bits but the RF Kill and SUSPEND bits and return */
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_init(priv)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->status = test_bit(STATUS_RF_KILL_HW, &priv->status) <<
|
|
|
|
STATUS_RF_KILL_HW |
|
|
|
|
test_bit(STATUS_RF_KILL_SW, &priv->status) <<
|
|
|
|
STATUS_RF_KILL_SW |
|
2008-02-06 19:20:38 +00:00
|
|
|
test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
|
|
|
|
STATUS_GEO_CONFIGURED |
|
2007-09-26 00:54:57 +00:00
|
|
|
test_bit(STATUS_IN_SUSPEND, &priv->status) <<
|
2008-06-30 09:23:15 +00:00
|
|
|
STATUS_IN_SUSPEND |
|
|
|
|
test_bit(STATUS_EXIT_PENDING, &priv->status) <<
|
|
|
|
STATUS_EXIT_PENDING;
|
2007-09-26 00:54:57 +00:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ...otherwise clear out all the status bits but the RF Kill and
|
|
|
|
* SUSPEND bits and continue taking the NIC down. */
|
|
|
|
priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
|
|
|
|
STATUS_RF_KILL_HW |
|
|
|
|
test_bit(STATUS_RF_KILL_SW, &priv->status) <<
|
|
|
|
STATUS_RF_KILL_SW |
|
2008-02-06 19:20:38 +00:00
|
|
|
test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
|
|
|
|
STATUS_GEO_CONFIGURED |
|
2007-09-26 00:54:57 +00:00
|
|
|
test_bit(STATUS_IN_SUSPEND, &priv->status) <<
|
|
|
|
STATUS_IN_SUSPEND |
|
|
|
|
test_bit(STATUS_FW_ERROR, &priv->status) <<
|
2008-06-30 09:23:15 +00:00
|
|
|
STATUS_FW_ERROR |
|
|
|
|
test_bit(STATUS_EXIT_PENDING, &priv->status) <<
|
|
|
|
STATUS_EXIT_PENDING;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_clear_bit(priv, CSR_GP_CNTRL,
|
2007-11-29 03:09:47 +00:00
|
|
|
CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
|
2007-09-26 00:54:57 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-05-29 08:35:00 +00:00
|
|
|
iwl_txq_ctx_stop(priv);
|
2008-05-29 08:35:01 +00:00
|
|
|
iwl_rxq_stop(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-03-25 23:33:37 +00:00
|
|
|
if (!iwl_grab_nic_access(priv)) {
|
|
|
|
iwl_write_prph(priv, APMG_CLK_DIS_REG,
|
2007-09-26 00:54:57 +00:00
|
|
|
APMG_CLK_VAL_DMA_CLK_RQT);
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_release_nic_access(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
udelay(5);
|
|
|
|
|
2008-05-29 08:34:57 +00:00
|
|
|
/* FIXME: apm_ops.suspend(priv) */
|
2008-09-03 03:18:49 +00:00
|
|
|
if (exit_pending || test_bit(STATUS_IN_SUSPEND, &priv->status))
|
|
|
|
priv->cfg->ops->lib->apm_ops.stop(priv);
|
|
|
|
else
|
|
|
|
priv->cfg->ops->lib->apm_ops.reset(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
exit:
|
2008-05-29 08:34:55 +00:00
|
|
|
memset(&priv->card_alive, 0, sizeof(struct iwl_alive_resp));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
priv->ibss_beacon = NULL;
|
|
|
|
|
|
|
|
/* clear out any free frames */
|
2008-05-15 05:54:01 +00:00
|
|
|
iwl_clear_free_frames(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_down(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-29 21:05:46 +00:00
|
|
|
__iwl_down(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2007-12-19 05:59:52 +00:00
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
iwl_cancel_deferred_work(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define MAX_HW_RESTARTS 5
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int __iwl_up(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-04-15 04:16:03 +00:00
|
|
|
int i;
|
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-01-31 06:05:15 +00:00
|
|
|
if (!priv->ucode_data_backup.v_addr || !priv->ucode_data.v_addr) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "ucode not available for device bringup\n");
|
2008-01-31 06:05:15 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
/* If platform's RF_KILL switch is NOT set to KILL */
|
2008-08-04 08:00:43 +00:00
|
|
|
if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
|
2008-01-24 10:19:38 +00:00
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
2008-06-30 09:23:19 +00:00
|
|
|
else
|
2008-01-24 10:19:38 +00:00
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
2008-06-30 09:23:19 +00:00
|
|
|
|
2008-08-04 08:00:43 +00:00
|
|
|
if (iwl_is_rfkill(priv)) {
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_enable_interrupts(priv);
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Radio disabled by %s RF Kill switch\n",
|
2008-06-30 09:23:19 +00:00
|
|
|
test_bit(STATUS_RF_KILL_HW, &priv->status) ? "HW" : "SW");
|
2008-08-04 08:00:43 +00:00
|
|
|
return 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-05 02:22:43 +00:00
|
|
|
ret = iwl_hw_nic_init(priv);
|
2008-04-15 04:16:03 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to init nic\n");
|
2008-04-15 04:16:03 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* make sure rfkill handshake bits are cleared */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
|
2007-09-26 00:54:57 +00:00
|
|
|
CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
|
|
|
|
|
|
|
|
/* clear (again), then enable host interrupts */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_enable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* really make sure rfkill handshake bits are cleared */
|
2008-03-25 23:33:37 +00:00
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
|
|
|
|
iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* Copy original ucode data image from disk into backup cache.
|
|
|
|
* This will be used to initialize the on-board processor's
|
|
|
|
* data SRAM for a clean start when the runtime program first loads. */
|
|
|
|
memcpy(priv->ucode_data_backup.v_addr, priv->ucode_data.v_addr,
|
2008-01-15 01:46:18 +00:00
|
|
|
priv->ucode_data.len);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
for (i = 0; i < MAX_HW_RESTARTS; i++) {
|
|
|
|
|
2008-06-30 09:23:08 +00:00
|
|
|
iwl_clear_stations_table(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* load bootstrap state machine,
|
|
|
|
* load bootstrap program into processor's memory,
|
|
|
|
* prepare to load the "initialize" uCode */
|
2008-04-15 04:16:03 +00:00
|
|
|
ret = priv->cfg->ops->lib->load_ucode(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-15 04:16:03 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to set up bootstrap uCode: %d\n",
|
|
|
|
ret);
|
2007-09-26 00:54:57 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2008-06-12 01:47:04 +00:00
|
|
|
/* Clear out the uCode error bit if it is set */
|
|
|
|
clear_bit(STATUS_FW_ERROR, &priv->status);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* start card; "initialize" will load runtime ucode */
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_nic_start(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, DRV_NAME " is coming up\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->status);
|
2008-10-29 21:05:46 +00:00
|
|
|
__iwl_down(priv);
|
2008-06-12 01:47:03 +00:00
|
|
|
clear_bit(STATUS_EXIT_PENDING, &priv->status);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* tried to restart and config the device for as long as our
|
|
|
|
* patience could withstand */
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to initialize device after %d attempts.\n", i);
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* Workqueue callbacks
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-05-29 08:34:54 +00:00
|
|
|
static void iwl_bg_init_alive_start(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, init_alive_start.work);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-05-05 02:22:45 +00:00
|
|
|
priv->cfg->ops->lib->init_alive_start(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-05-29 08:34:54 +00:00
|
|
|
static void iwl_bg_alive_start(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, alive_start.work);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-05-29 08:34:54 +00:00
|
|
|
iwl_alive_start(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:52 +00:00
|
|
|
static void iwl_bg_run_time_calib_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = container_of(work, struct iwl_priv,
|
|
|
|
run_time_calib_work);
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
|
|
|
|
test_bit(STATUS_SCANNING, &priv->status)) {
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->start_calib) {
|
|
|
|
iwl_chain_noise_calibration(priv, &priv->statistics);
|
|
|
|
|
|
|
|
iwl_sensitivity_calibration(priv, &priv->statistics);
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_up(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = container_of(data, struct iwl_priv, up);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-29 21:05:46 +00:00
|
|
|
__iwl_up(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-07-01 15:49:50 +00:00
|
|
|
iwl_rfkill_set_hw_state(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_restart(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_down(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
queue_work(priv->workqueue, &priv->up);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bg_rx_replenish(struct work_struct *data)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv =
|
|
|
|
container_of(data, struct iwl_priv, rx_replenish);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_replenish(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2007-11-29 03:10:13 +00:00
|
|
|
#define IWL_DELAY_NEXT_SCAN (HZ*2)
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_post_associate(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_conf *conf = NULL;
|
2008-03-21 20:53:44 +00:00
|
|
|
int ret = 0;
|
2008-07-11 03:53:34 +00:00
|
|
|
unsigned long flags;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_AP) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "%s Should not be called in AP mode\n", __func__);
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ASSOC(priv, "Associated as %d to: %pM\n",
|
2008-10-27 22:59:26 +00:00
|
|
|
priv->assoc_id, priv->active_rxon.bssid_addr);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
2008-04-15 04:16:13 +00:00
|
|
|
if (!priv->vif || !priv->is_open)
|
2007-10-25 09:15:45 +00:00
|
|
|
return;
|
2008-04-15 04:16:13 +00:00
|
|
|
|
2008-09-03 03:26:50 +00:00
|
|
|
iwl_power_cancel_timeout(priv);
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 200);
|
2007-10-25 09:15:43 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
conf = ieee80211_get_hw_conf(priv->hw);
|
|
|
|
|
|
|
|
priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-08 01:37:30 +00:00
|
|
|
iwl_setup_rxon_timing(priv);
|
2008-03-21 20:53:44 +00:00
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
|
2007-09-26 00:54:57 +00:00
|
|
|
sizeof(priv->rxon_timing), &priv->rxon_timing);
|
2008-03-21 20:53:44 +00:00
|
|
|
if (ret)
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
|
2007-09-26 00:54:57 +00:00
|
|
|
"Attempting to continue.\n");
|
|
|
|
|
|
|
|
priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
|
|
|
|
2008-09-17 02:10:05 +00:00
|
|
|
iwl_set_rxon_ht(priv, &priv->current_ht_config);
|
2008-06-09 19:54:35 +00:00
|
|
|
|
2008-04-24 00:15:05 +00:00
|
|
|
iwl_set_rxon_chain(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_ASSOC(priv, "assoc id %d beacon interval %d\n",
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->assoc_id, priv->beacon_int);
|
|
|
|
|
|
|
|
if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
|
|
|
|
priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
else
|
|
|
|
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
|
|
|
|
if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
|
|
|
|
if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_SLOT_TIME)
|
|
|
|
priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
else
|
|
|
|
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
switch (priv->iw_mode) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-06-12 01:47:05 +00:00
|
|
|
/* assume default assoc id */
|
|
|
|
priv->assoc_id = 1;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-15 05:54:04 +00:00
|
|
|
iwl_rxon_add_station(priv, priv->bssid, 0);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_beacon_cmd(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "%s Should not be called in %d mode\n",
|
2008-07-20 23:40:14 +00:00
|
|
|
__func__, priv->iw_mode);
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->assoc_station_added = 1;
|
|
|
|
|
2008-07-11 03:53:34 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
iwl_activate_qos(priv, 0);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-02-06 19:20:39 +00:00
|
|
|
|
2008-09-03 03:26:53 +00:00
|
|
|
/* the chain noise calibration will enabled PM upon completion
|
|
|
|
* If chain noise has already been run, then we need to enable
|
|
|
|
* power management here */
|
|
|
|
if (priv->chain_noise_data.state == IWL_CHAIN_NOISE_DONE)
|
|
|
|
iwl_power_enable_management(priv);
|
2008-09-03 03:26:50 +00:00
|
|
|
|
|
|
|
/* Enable Rx differential gain and sensitivity calibrations */
|
|
|
|
iwl_chain_noise_reset(priv);
|
|
|
|
priv->start_calib = 1;
|
|
|
|
|
2008-04-15 04:16:13 +00:00
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* mac80211 entry point functions
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-06-30 09:23:24 +00:00
|
|
|
#define UCODE_READY_TIMEOUT (4 * HZ)
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_start(struct ieee80211_hw *hw)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2008-01-15 01:46:18 +00:00
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* we should be verifying the device is ready to be opened */
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2008-05-15 05:53:59 +00:00
|
|
|
memset(&priv->staging_rxon, 0, sizeof(struct iwl_rxon_cmd));
|
2008-01-15 01:46:18 +00:00
|
|
|
/* fetch ucode file from disk, alloc and copy to bus-master buffers ...
|
|
|
|
* ucode filename and max sizes are card-specific. */
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-15 01:46:18 +00:00
|
|
|
if (!priv->ucode_code.len) {
|
2008-10-29 21:05:46 +00:00
|
|
|
ret = iwl_read_ucode(priv);
|
2008-01-15 01:46:18 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Could not read microcode: %d\n", ret);
|
2008-01-15 01:46:18 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2009-01-19 12:10:07 +00:00
|
|
|
return ret;
|
2008-01-15 01:46:18 +00:00
|
|
|
}
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
ret = __iwl_up(priv);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2008-07-01 15:49:50 +00:00
|
|
|
iwl_rfkill_set_hw_state(priv);
|
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
if (ret)
|
2009-01-19 12:10:07 +00:00
|
|
|
return ret;
|
2008-01-24 10:19:38 +00:00
|
|
|
|
2008-08-04 08:00:43 +00:00
|
|
|
if (iwl_is_rfkill(priv))
|
|
|
|
goto out;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Start UP work done.\n");
|
2008-01-24 10:19:38 +00:00
|
|
|
|
|
|
|
if (test_bit(STATUS_IN_SUSPEND, &priv->status))
|
|
|
|
return 0;
|
|
|
|
|
2008-05-29 08:35:06 +00:00
|
|
|
/* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
|
2008-01-15 01:46:18 +00:00
|
|
|
* mac80211 will not be run successfully. */
|
2008-06-30 09:23:24 +00:00
|
|
|
ret = wait_event_interruptible_timeout(priv->wait_command_queue,
|
|
|
|
test_bit(STATUS_READY, &priv->status),
|
|
|
|
UCODE_READY_TIMEOUT);
|
|
|
|
if (!ret) {
|
|
|
|
if (!test_bit(STATUS_READY, &priv->status)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "START_ALIVE timeout after %dms.\n",
|
2008-06-30 09:23:24 +00:00
|
|
|
jiffies_to_msecs(UCODE_READY_TIMEOUT));
|
2009-01-19 12:10:07 +00:00
|
|
|
return -ETIMEDOUT;
|
2008-01-15 01:46:18 +00:00
|
|
|
}
|
2008-05-29 08:35:06 +00:00
|
|
|
}
|
2008-06-30 09:23:26 +00:00
|
|
|
|
2008-08-04 08:00:43 +00:00
|
|
|
out:
|
2008-06-30 09:23:26 +00:00
|
|
|
priv->is_open = 1;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_mac_stop(struct ieee80211_hw *hw)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-10-25 09:15:45 +00:00
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
if (!priv->is_open) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - skip\n");
|
2008-01-24 10:19:38 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->is_open = 0;
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (iwl_is_ready_rf(priv)) {
|
2008-01-24 10:19:38 +00:00
|
|
|
/* stop mac, cancel any scan request and clear
|
|
|
|
* RXON_FILTER_ASSOC_MSK BIT
|
|
|
|
*/
|
2008-01-15 01:46:18 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2007-11-29 03:10:15 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_down(priv);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
|
|
|
flush_workqueue(priv->workqueue);
|
2009-01-19 12:10:07 +00:00
|
|
|
|
|
|
|
/* enable interrupts again in order to receive rfkill changes */
|
|
|
|
iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
|
|
|
|
iwl_enable_interrupts(priv);
|
2007-10-25 09:15:45 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MACDUMP(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
|
2008-05-15 10:55:29 +00:00
|
|
|
ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
if (iwl_tx_skb(priv, skb))
|
2007-09-26 00:54:57 +00:00
|
|
|
dev_kfree_skb_any(skb);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MACDUMP(priv, "leave\n");
|
2009-01-19 23:30:32 +00:00
|
|
|
return NETDEV_TX_OK;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_add_interface(struct ieee80211_hw *hw,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_if_init_conf *conf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter: type %d\n", conf->type);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
if (priv->vif) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - vif != NULL\n");
|
2008-01-23 18:15:17 +00:00
|
|
|
return -EOPNOTSUPP;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2007-12-19 00:31:26 +00:00
|
|
|
priv->vif = conf->vif;
|
2008-10-29 21:05:45 +00:00
|
|
|
priv->iw_mode = conf->type;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2007-11-27 19:00:52 +00:00
|
|
|
|
|
|
|
if (conf->mac_addr) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "Set %pM\n", conf->mac_addr);
|
2007-11-27 19:00:52 +00:00
|
|
|
memcpy(priv->mac_addr, conf->mac_addr, ETH_ALEN);
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
if (iwl_set_mode(priv, conf->type) == -EAGAIN)
|
2008-06-12 01:47:05 +00:00
|
|
|
/* we are not ready, will run again when ready */
|
|
|
|
set_bit(STATUS_MODE_PENDING, &priv->status);
|
2008-01-15 01:46:18 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2008-10-29 21:05:46 +00:00
|
|
|
* iwl_mac_config - mac80211 config callback
|
2007-09-26 00:54:57 +00:00
|
|
|
*
|
|
|
|
* We ignore conf->flags & IEEE80211_CONF_SHORT_SLOT_TIME since it seems to
|
|
|
|
* be set inappropriately and the driver currently sets the hardware up to
|
|
|
|
* use it whenever needed.
|
|
|
|
*/
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_config(struct ieee80211_hw *hw, u32 changed)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2008-03-14 17:38:49 +00:00
|
|
|
const struct iwl_channel_info *ch_info;
|
2008-10-09 10:18:51 +00:00
|
|
|
struct ieee80211_conf *conf = &hw->conf;
|
2009-03-18 04:59:18 +00:00
|
|
|
unsigned long flags = 0;
|
2007-11-22 02:53:22 +00:00
|
|
|
int ret = 0;
|
2009-03-18 04:59:18 +00:00
|
|
|
u16 ch;
|
|
|
|
int scan_active = 0;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2009-03-18 04:59:18 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter to channel %d changed 0x%X\n",
|
|
|
|
conf->channel->hw_value, changed);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
if (unlikely(!priv->cfg->mod_params->disable_hw_scan &&
|
|
|
|
test_bit(STATUS_SCANNING, &priv->status))) {
|
|
|
|
scan_active = 1;
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - scanning\n");
|
2008-06-12 01:47:03 +00:00
|
|
|
}
|
|
|
|
|
2008-06-13 07:44:55 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
/* during scanning mac80211 will delay channel setting until
|
|
|
|
* scan finish with changed = 0
|
|
|
|
*/
|
|
|
|
if (!changed || (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
|
|
|
|
if (scan_active)
|
|
|
|
goto set_ch_out;
|
|
|
|
|
|
|
|
ch = ieee80211_frequency_to_channel(conf->channel->center_freq);
|
|
|
|
ch_info = iwl_get_channel_info(priv, conf->channel->band, ch);
|
|
|
|
if (!is_channel_valid(ch_info)) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - invalid channel\n");
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto set_ch_out;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
|
|
|
|
!is_channel_ibss(ch_info)) {
|
|
|
|
IWL_ERR(priv, "channel %d in band %d not "
|
|
|
|
"IBSS channel\n",
|
|
|
|
conf->channel->hw_value, conf->channel->band);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto set_ch_out;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
priv->current_ht_config.is_ht = conf_is_ht(conf);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-06-12 01:47:06 +00:00
|
|
|
|
2008-05-29 08:35:28 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
/* if we are switching from ht to 2.4 clear flags
|
|
|
|
* from any ht related info since 2.4 does not
|
|
|
|
* support ht */
|
|
|
|
if ((le16_to_cpu(priv->staging_rxon.channel) != ch))
|
|
|
|
priv->staging_rxon.flags = 0;
|
2008-07-19 01:41:24 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
iwl_set_rxon_channel(priv, conf->channel);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
iwl_set_flags_for_band(priv, conf->channel->band);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
set_ch_out:
|
|
|
|
/* The list of supported rates and rate mask can be different
|
|
|
|
* for each band; since the band may have changed, reset
|
|
|
|
* the rate mask to what mac80211 lists */
|
|
|
|
iwl_set_rate(priv);
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
if (changed & IEEE80211_CONF_CHANGE_PS) {
|
|
|
|
if (conf->flags & IEEE80211_CONF_PS)
|
|
|
|
ret = iwl_power_set_user_mode(priv, IWL_POWER_INDEX_3);
|
|
|
|
else
|
|
|
|
ret = iwl_power_set_user_mode(priv, IWL_POWER_MODE_CAM);
|
|
|
|
if (ret)
|
|
|
|
IWL_DEBUG_MAC80211(priv, "Error setting power level\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
if (changed & IEEE80211_CONF_CHANGE_POWER) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "TX Power old=%d new=%d\n",
|
|
|
|
priv->tx_power_user_lmt, conf->power_level);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
iwl_set_tx_power(priv, conf->power_level, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* call to ensure that 4965 rx_chain is set properly in monitor mode */
|
|
|
|
iwl_set_rxon_chain(priv);
|
|
|
|
|
|
|
|
if (changed & IEEE80211_CONF_CHANGE_RADIO_ENABLED) {
|
|
|
|
if (conf->radio_enabled &&
|
|
|
|
iwl_radio_kill_sw_enable_radio(priv)) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - RF-KILL - "
|
|
|
|
"waiting for uCode\n");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!conf->radio_enabled)
|
|
|
|
iwl_radio_kill_sw_disable_radio(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!conf->radio_enabled) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - radio disabled\n");
|
2007-11-22 02:53:22 +00:00
|
|
|
goto out;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
if (!iwl_is_ready(priv)) {
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
|
2007-11-22 02:53:22 +00:00
|
|
|
goto out;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-03-18 04:59:18 +00:00
|
|
|
if (scan_active)
|
|
|
|
goto out;
|
2009-01-23 21:45:10 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if (memcmp(&priv->active_rxon,
|
|
|
|
&priv->staging_rxon, sizeof(priv->staging_rxon)))
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "No re-sending same RXON configuration.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
2007-12-20 06:10:01 +00:00
|
|
|
out:
|
2009-03-18 04:59:18 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2008-01-15 01:46:18 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2007-11-22 02:53:22 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_config_ap(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-21 20:53:44 +00:00
|
|
|
int ret = 0;
|
2008-07-11 03:53:34 +00:00
|
|
|
unsigned long flags;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-23 18:15:16 +00:00
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
2007-09-26 00:54:57 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
/* The following should be done only at AP bring up */
|
2008-10-08 01:37:30 +00:00
|
|
|
if (!iwl_is_associated(priv)) {
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* RXON - unassoc (to set timing command) */
|
|
|
|
priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* RXON Timing */
|
2008-10-08 01:37:30 +00:00
|
|
|
iwl_setup_rxon_timing(priv);
|
2008-03-21 20:53:44 +00:00
|
|
|
ret = iwl_send_cmd_pdu(priv, REPLY_RXON_TIMING,
|
2007-09-26 00:54:57 +00:00
|
|
|
sizeof(priv->rxon_timing), &priv->rxon_timing);
|
2008-03-21 20:53:44 +00:00
|
|
|
if (ret)
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "REPLY_RXON_TIMING failed - "
|
2007-09-26 00:54:57 +00:00
|
|
|
"Attempting to continue.\n");
|
|
|
|
|
2008-04-24 00:15:05 +00:00
|
|
|
iwl_set_rxon_chain(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* FIXME: what should be the assoc_id for AP? */
|
|
|
|
priv->staging_rxon.assoc_id = cpu_to_le16(priv->assoc_id);
|
|
|
|
if (priv->assoc_capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
|
|
|
|
priv->staging_rxon.flags |=
|
|
|
|
RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
else
|
|
|
|
priv->staging_rxon.flags &=
|
|
|
|
~RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
|
|
|
|
if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) {
|
|
|
|
if (priv->assoc_capability &
|
|
|
|
WLAN_CAPABILITY_SHORT_SLOT_TIME)
|
|
|
|
priv->staging_rxon.flags |=
|
|
|
|
RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
else
|
|
|
|
priv->staging_rxon.flags &=
|
|
|
|
~RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_ADHOC)
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->staging_rxon.flags &=
|
|
|
|
~RXON_FLG_SHORT_SLOT_MSK;
|
|
|
|
}
|
|
|
|
/* restore RXON assoc */
|
|
|
|
priv->staging_rxon.filter_flags |= RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2008-07-11 03:53:34 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
iwl_activate_qos(priv, 1);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-05-15 05:54:04 +00:00
|
|
|
iwl_rxon_add_station(priv, iwl_bcast_addr, 0);
|
2007-09-27 03:27:32 +00:00
|
|
|
}
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_send_beacon_cmd(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/* FIXME - we need to add code here to detect a totally new
|
|
|
|
* configuration, reset the AP, unassoc, rxon timing, assoc,
|
|
|
|
* clear sta table, add BCAST sta... */
|
|
|
|
}
|
|
|
|
|
2008-07-09 12:40:37 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_config_interface(struct ieee80211_hw *hw,
|
2007-12-19 00:31:26 +00:00
|
|
|
struct ieee80211_vif *vif,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_if_conf *conf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
if (conf == NULL)
|
|
|
|
return -EIO;
|
|
|
|
|
2008-03-05 02:09:32 +00:00
|
|
|
if (priv->vif != vif) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - priv->vif != vif\n");
|
2008-03-05 02:09:32 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_ADHOC &&
|
2008-07-09 12:40:37 +00:00
|
|
|
conf->changed & IEEE80211_IFCC_BEACON) {
|
|
|
|
struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
|
|
|
|
if (!beacon)
|
|
|
|
return -ENOMEM;
|
2008-11-07 17:58:34 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-29 21:05:46 +00:00
|
|
|
rc = iwl_mac_beacon_update(hw, beacon);
|
2008-11-07 17:58:34 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-07-09 12:40:37 +00:00
|
|
|
if (rc)
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_alive(priv))
|
2008-01-15 01:46:18 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
|
|
|
if (conf->bssid)
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "bssid: %pM\n", conf->bssid);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 05:29:23 +00:00
|
|
|
/*
|
|
|
|
* very dubious code was here; the probe filtering flag is never set:
|
|
|
|
*
|
2007-09-26 00:54:57 +00:00
|
|
|
if (unlikely(test_bit(STATUS_SCANNING, &priv->status)) &&
|
|
|
|
!(priv->hw->flags & IEEE80211_HW_NO_PROBE_FILTERING)) {
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 05:29:23 +00:00
|
|
|
*/
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_AP) {
|
2007-09-26 00:54:57 +00:00
|
|
|
if (!conf->bssid) {
|
|
|
|
conf->bssid = priv->mac_addr;
|
|
|
|
memcpy(priv->bssid, priv->mac_addr, ETH_ALEN);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "bssid was set to: %pM\n",
|
2008-10-27 22:59:26 +00:00
|
|
|
conf->bssid);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
2008-07-09 12:40:37 +00:00
|
|
|
priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (iwl_is_rfkill(priv))
|
2007-11-29 03:10:15 +00:00
|
|
|
goto done;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
if (conf->bssid && !is_zero_ether_addr(conf->bssid) &&
|
|
|
|
!is_multicast_ether_addr(conf->bssid)) {
|
|
|
|
/* If there is currently a HW scan going on in the background
|
|
|
|
* then we need to cancel it else the RXON below will fail. */
|
2008-06-12 01:47:10 +00:00
|
|
|
if (iwl_scan_cancel_timeout(priv, 100)) {
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Aborted scan still in progress "
|
2007-09-26 00:54:57 +00:00
|
|
|
"after 100ms\n");
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
memcpy(priv->staging_rxon.bssid_addr, conf->bssid, ETH_ALEN);
|
|
|
|
|
|
|
|
/* TODO: Audit driver for usage of these members and see
|
|
|
|
* if mac80211 deprecates them (priv->bssid looks like it
|
|
|
|
* shouldn't be there, but I haven't scanned the IBSS code
|
|
|
|
* to verify) - jpk */
|
|
|
|
memcpy(priv->bssid, conf->bssid, ETH_ALEN);
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_AP)
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_config_ap(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
else {
|
2008-10-29 21:05:46 +00:00
|
|
|
rc = iwl_commit_rxon(priv);
|
2008-09-10 22:01:58 +00:00
|
|
|
if ((priv->iw_mode == NL80211_IFTYPE_STATION) && rc)
|
2008-05-15 05:54:04 +00:00
|
|
|
iwl_rxon_add_station(
|
2007-09-26 00:54:57 +00:00
|
|
|
priv, priv->active_rxon.bssid_addr, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2007-11-29 03:10:15 +00:00
|
|
|
done:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_mac_remove_interface(struct ieee80211_hw *hw,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_if_init_conf *conf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2007-10-25 09:15:45 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (iwl_is_ready_rf(priv)) {
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2007-11-29 03:10:15 +00:00
|
|
|
priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-11-29 03:10:15 +00:00
|
|
|
}
|
2007-12-19 00:31:26 +00:00
|
|
|
if (priv->vif == conf->vif) {
|
|
|
|
priv->vif = NULL;
|
2007-09-26 00:54:57 +00:00
|
|
|
memset(priv->bssid, 0, ETH_ALEN);
|
|
|
|
}
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
}
|
2007-12-28 13:32:58 +00:00
|
|
|
|
2008-03-28 23:33:35 +00:00
|
|
|
#define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_bss_info_changed(struct ieee80211_hw *hw,
|
2007-12-28 13:32:58 +00:00
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_bss_conf *bss_conf,
|
|
|
|
u32 changes)
|
2007-10-15 22:50:25 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-10-15 22:50:25 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "changes = 0x%X\n", changes);
|
2008-03-28 23:33:35 +00:00
|
|
|
|
2007-12-28 13:32:58 +00:00
|
|
|
if (changes & BSS_CHANGED_ERP_PREAMBLE) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "ERP_PREAMBLE %d\n",
|
2008-03-28 23:33:35 +00:00
|
|
|
bss_conf->use_short_preamble);
|
2007-12-28 13:32:58 +00:00
|
|
|
if (bss_conf->use_short_preamble)
|
2007-10-15 22:50:25 +00:00
|
|
|
priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
else
|
|
|
|
priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
|
|
|
|
}
|
|
|
|
|
2007-12-28 13:32:58 +00:00
|
|
|
if (changes & BSS_CHANGED_ERP_CTS_PROT) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "ERP_CTS %d\n", bss_conf->use_cts_prot);
|
2008-01-24 18:38:38 +00:00
|
|
|
if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
|
2007-10-15 22:50:25 +00:00
|
|
|
priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
|
|
|
|
else
|
|
|
|
priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
|
|
|
|
}
|
|
|
|
|
2008-03-28 23:33:33 +00:00
|
|
|
if (changes & BSS_CHANGED_HT) {
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_ht_conf(priv, bss_conf);
|
2008-04-24 00:15:05 +00:00
|
|
|
iwl_set_rxon_chain(priv);
|
2008-03-28 23:33:33 +00:00
|
|
|
}
|
|
|
|
|
2007-12-28 13:32:58 +00:00
|
|
|
if (changes & BSS_CHANGED_ASSOC) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
|
2008-04-15 04:16:13 +00:00
|
|
|
/* This should never happen as this function should
|
|
|
|
* never be called from interrupt context. */
|
|
|
|
if (WARN_ON_ONCE(in_interrupt()))
|
|
|
|
return;
|
2008-03-28 23:33:35 +00:00
|
|
|
if (bss_conf->assoc) {
|
|
|
|
priv->assoc_id = bss_conf->aid;
|
|
|
|
priv->beacon_int = bss_conf->beacon_int;
|
2008-07-19 01:41:24 +00:00
|
|
|
priv->power_data.dtim_period = bss_conf->dtim_period;
|
2008-03-28 23:33:35 +00:00
|
|
|
priv->timestamp = bss_conf->timestamp;
|
|
|
|
priv->assoc_capability = bss_conf->assoc_capability;
|
2008-09-16 06:01:03 +00:00
|
|
|
|
|
|
|
/* we have just associated, don't start scan too early
|
|
|
|
* leave time for EAPOL exchange to complete
|
|
|
|
*/
|
2008-03-28 23:33:35 +00:00
|
|
|
priv->next_scan_jiffies = jiffies +
|
|
|
|
IWL_DELAY_NEXT_SCAN_AFTER_ASSOC;
|
2008-04-15 04:16:13 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_post_associate(priv);
|
2008-04-15 04:16:13 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
2008-03-28 23:33:35 +00:00
|
|
|
} else {
|
|
|
|
priv->assoc_id = 0;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "DISASSOC %d\n", bss_conf->assoc);
|
2008-03-28 23:33:35 +00:00
|
|
|
}
|
|
|
|
} else if (changes && iwl_is_associated(priv) && priv->assoc_id) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "Associated Changes %d\n", changes);
|
2008-04-15 23:01:43 +00:00
|
|
|
iwl_send_rxon_assoc(priv);
|
2007-12-28 13:32:58 +00:00
|
|
|
}
|
|
|
|
|
2007-10-15 22:50:25 +00:00
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_mac_update_tkip_key(struct ieee80211_hw *hw,
|
2008-03-20 13:06:43 +00:00
|
|
|
struct ieee80211_key_conf *keyconf, const u8 *addr,
|
|
|
|
u32 iv32, u16 *phase1key)
|
|
|
|
{
|
|
|
|
|
2008-11-12 21:14:05 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2008-03-20 13:06:43 +00:00
|
|
|
|
2008-11-12 21:14:05 +00:00
|
|
|
iwl_update_tkip_key(priv, keyconf, addr, iv32, phase1key);
|
2008-03-20 13:06:43 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2008-03-20 13:06:43 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
|
2008-12-29 11:55:09 +00:00
|
|
|
struct ieee80211_vif *vif,
|
|
|
|
struct ieee80211_sta *sta,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_key_conf *key)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2009-01-19 23:30:22 +00:00
|
|
|
const u8 *addr;
|
|
|
|
int ret;
|
|
|
|
u8 sta_id;
|
|
|
|
bool is_default_wep_key = false;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-21 22:41:53 +00:00
|
|
|
if (priv->hw_params.sw_crypto) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2009-01-19 23:30:22 +00:00
|
|
|
addr = sta ? sta->addr : iwl_bcast_addr;
|
2008-04-16 23:34:48 +00:00
|
|
|
sta_id = iwl_find_station(priv, addr);
|
2008-04-15 04:16:06 +00:00
|
|
|
if (sta_id == IWL_INVALID_STATION) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - %pM not in station map.\n",
|
2008-10-27 22:59:26 +00:00
|
|
|
addr);
|
2008-04-15 04:16:06 +00:00
|
|
|
return -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-19 23:41:41 +00:00
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-15 04:16:06 +00:00
|
|
|
mutex_lock(&priv->mutex);
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2008-04-15 04:16:06 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
/* If we are getting WEP group key and we didn't receive any key mapping
|
|
|
|
* so far, we are in legacy wep mode (group key only), otherwise we are
|
|
|
|
* in 1X mode.
|
|
|
|
* In legacy wep mode, we use another host command to the uCode */
|
2008-04-15 23:01:38 +00:00
|
|
|
if (key->alg == ALG_WEP && sta_id == priv->hw_params.bcast_sta_id &&
|
2008-09-10 22:01:58 +00:00
|
|
|
priv->iw_mode != NL80211_IFTYPE_AP) {
|
2008-04-15 04:16:06 +00:00
|
|
|
if (cmd == SET_KEY)
|
|
|
|
is_default_wep_key = !priv->key_mapping_key;
|
|
|
|
else
|
2008-05-15 05:54:09 +00:00
|
|
|
is_default_wep_key =
|
|
|
|
(key->hw_key_idx == HW_KEY_DEFAULT);
|
2008-04-15 04:16:06 +00:00
|
|
|
}
|
2007-10-25 09:15:43 +00:00
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
switch (cmd) {
|
2008-03-19 23:41:41 +00:00
|
|
|
case SET_KEY:
|
2008-04-15 04:16:06 +00:00
|
|
|
if (is_default_wep_key)
|
|
|
|
ret = iwl_set_default_wep_key(priv, key);
|
2008-03-19 23:41:41 +00:00
|
|
|
else
|
2008-04-15 04:16:09 +00:00
|
|
|
ret = iwl_set_dynamic_key(priv, key, sta_id);
|
2008-03-19 23:41:41 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
case DISABLE_KEY:
|
2008-04-15 04:16:06 +00:00
|
|
|
if (is_default_wep_key)
|
|
|
|
ret = iwl_remove_default_wep_key(priv, key);
|
2008-03-19 23:41:41 +00:00
|
|
|
else
|
2008-04-17 23:03:36 +00:00
|
|
|
ret = iwl_remove_dynamic_key(priv, key, sta_id);
|
2008-03-19 23:41:41 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
default:
|
2008-03-19 23:41:41 +00:00
|
|
|
ret = -EINVAL;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-19 23:41:41 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
|
2007-09-26 00:54:57 +00:00
|
|
|
const struct ieee80211_tx_queue_params *params)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int q;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_ready_rf(priv)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (queue >= AC_NUM) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
q = AC_NUM - 1 - queue;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
|
|
|
|
priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
|
|
|
|
priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
|
|
|
|
priv->qos_data.def_qos_parm.ac[q].edca_txop =
|
2008-02-10 15:49:38 +00:00
|
|
|
cpu_to_le16((params->txop * 32));
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
priv->qos_data.def_qos_parm.ac[q].reserved1 = 0;
|
|
|
|
priv->qos_data.qos_active = 1;
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode == NL80211_IFTYPE_AP)
|
2008-07-11 03:53:34 +00:00
|
|
|
iwl_activate_qos(priv, 1);
|
2008-03-28 23:33:35 +00:00
|
|
|
else if (priv->assoc_id && iwl_is_associated(priv))
|
2008-07-11 03:53:34 +00:00
|
|
|
iwl_activate_qos(priv, 0);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-07-11 03:53:34 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_ampdu_action(struct ieee80211_hw *hw,
|
2008-07-18 05:53:02 +00:00
|
|
|
enum ieee80211_ampdu_mlme_action action,
|
2008-09-10 22:02:02 +00:00
|
|
|
struct ieee80211_sta *sta, u16 tid, u16 *ssn)
|
2008-07-18 05:53:02 +00:00
|
|
|
{
|
|
|
|
struct iwl_priv *priv = hw->priv;
|
2009-03-18 04:51:43 +00:00
|
|
|
int ret;
|
2008-07-18 05:53:02 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
|
2008-10-27 22:59:26 +00:00
|
|
|
sta->addr, tid);
|
2008-07-18 05:53:02 +00:00
|
|
|
|
|
|
|
if (!(priv->cfg->sku & IWL_SKU_N))
|
|
|
|
return -EACCES;
|
|
|
|
|
|
|
|
switch (action) {
|
|
|
|
case IEEE80211_AMPDU_RX_START:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "start Rx\n");
|
2008-11-12 21:14:05 +00:00
|
|
|
return iwl_sta_rx_agg_start(priv, sta->addr, tid, *ssn);
|
2008-07-18 05:53:02 +00:00
|
|
|
case IEEE80211_AMPDU_RX_STOP:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "stop Rx\n");
|
2009-03-18 04:51:43 +00:00
|
|
|
ret = iwl_sta_rx_agg_stop(priv, sta->addr, tid);
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return ret;
|
2008-07-18 05:53:02 +00:00
|
|
|
case IEEE80211_AMPDU_TX_START:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "start Tx\n");
|
2008-09-10 22:02:02 +00:00
|
|
|
return iwl_tx_agg_start(priv, sta->addr, tid, ssn);
|
2008-07-18 05:53:02 +00:00
|
|
|
case IEEE80211_AMPDU_TX_STOP:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "stop Tx\n");
|
2009-03-18 04:51:43 +00:00
|
|
|
ret = iwl_tx_agg_stop(priv, sta->addr, tid);
|
|
|
|
if (test_bit(STATUS_EXIT_PENDING, &priv->status))
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return ret;
|
2008-07-18 05:53:02 +00:00
|
|
|
default:
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_HT(priv, "unknown\n");
|
2008-07-18 05:53:02 +00:00
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2008-11-12 21:14:05 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_get_tx_stats(struct ieee80211_hw *hw,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_tx_queue_stats *stats)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
int i, avail;
|
2008-05-05 02:22:50 +00:00
|
|
|
struct iwl_tx_queue *txq;
|
2008-05-15 05:53:57 +00:00
|
|
|
struct iwl_queue *q;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_ready_rf(priv)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
for (i = 0; i < AC_NUM; i++) {
|
|
|
|
txq = &priv->txq[i];
|
|
|
|
q = &txq->q;
|
2008-05-15 05:53:57 +00:00
|
|
|
avail = iwl_queue_space(q);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-29 15:18:59 +00:00
|
|
|
stats[i].len = q->n_window - avail;
|
|
|
|
stats[i].limit = q->n_window - q->high_mark;
|
|
|
|
stats[i].count = q->n_window;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_get_stats(struct ieee80211_hw *hw,
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_low_level_stats *stats)
|
|
|
|
{
|
2008-05-05 02:22:40 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
|
|
|
|
|
|
|
priv = hw->priv;
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void iwl_mac_reset_tsf(struct ieee80211_hw *hw)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2007-11-26 14:14:39 +00:00
|
|
|
memset(&priv->current_ht_config, 0, sizeof(struct iwl_ht_info));
|
2007-09-26 00:54:57 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-04-24 00:15:05 +00:00
|
|
|
iwl_reset_qos(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->assoc_id = 0;
|
|
|
|
priv->assoc_capability = 0;
|
|
|
|
priv->assoc_station_added = 0;
|
|
|
|
|
|
|
|
/* new association get rid of ibss beacon skb */
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
|
|
|
priv->ibss_beacon = NULL;
|
|
|
|
|
|
|
|
priv->beacon_int = priv->hw->conf.beacon_int;
|
2008-03-28 23:33:35 +00:00
|
|
|
priv->timestamp = 0;
|
2008-09-10 22:01:58 +00:00
|
|
|
if ((priv->iw_mode == NL80211_IFTYPE_STATION))
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->beacon_int = 0;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_ready_rf(priv)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
|
2007-11-29 03:10:15 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-10-25 09:15:43 +00:00
|
|
|
/* we are restarting association process
|
|
|
|
* clear RXON_FILTER_ASSOC_MSK bit
|
|
|
|
*/
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode != NL80211_IFTYPE_AP) {
|
2008-06-12 01:47:10 +00:00
|
|
|
iwl_scan_cancel_timeout(priv, 100);
|
2007-10-25 09:15:43 +00:00
|
|
|
priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-10-25 09:15:43 +00:00
|
|
|
}
|
|
|
|
|
2008-04-21 22:41:51 +00:00
|
|
|
iwl_power_update_mode(priv, 0);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
/* Per mac80211.h: This is only used in IBSS mode... */
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
|
2007-10-25 09:15:43 +00:00
|
|
|
|
2008-09-03 03:26:50 +00:00
|
|
|
/* switch to CAM during association period.
|
|
|
|
* the ucode will block any association/authentication
|
|
|
|
* frome during assiciation period if it can not hear
|
|
|
|
* the AP because of PM. the timer enable PM back is
|
|
|
|
* association do not complete
|
|
|
|
*/
|
|
|
|
if (priv->hw->conf.channel->flags & (IEEE80211_CHAN_PASSIVE_SCAN |
|
|
|
|
IEEE80211_CHAN_RADAR))
|
|
|
|
iwl_power_disable_management(priv, 3000);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - not in IBSS\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_set_rate(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = hw->priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
unsigned long flags;
|
2008-06-30 09:23:17 +00:00
|
|
|
__le64 timestamp;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "enter\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_ready_rf(priv)) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2008-09-10 22:01:58 +00:00
|
|
|
if (priv->iw_mode != NL80211_IFTYPE_ADHOC) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave - not IBSS\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
|
|
|
priv->ibss_beacon = skb;
|
|
|
|
|
|
|
|
priv->assoc_id = 0;
|
2008-06-30 09:23:17 +00:00
|
|
|
timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
|
2008-09-03 03:18:42 +00:00
|
|
|
priv->timestamp = le64_to_cpu(timestamp);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "leave\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-04-24 00:15:05 +00:00
|
|
|
iwl_reset_qos(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_post_associate(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* sysfs attributes
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The following adds a new attribute to the sysfs representation
|
2008-12-17 08:52:29 +00:00
|
|
|
* of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
|
2007-09-26 00:54:57 +00:00
|
|
|
* used for controlling the debug level.
|
|
|
|
*
|
|
|
|
* See the level definitions in iwl for details.
|
|
|
|
*/
|
|
|
|
|
2008-05-06 03:05:11 +00:00
|
|
|
static ssize_t show_debug_level(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-05-06 03:05:11 +00:00
|
|
|
struct iwl_priv *priv = d->driver_data;
|
|
|
|
|
|
|
|
return sprintf(buf, "0x%08X\n", priv->debug_level);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2008-05-06 03:05:11 +00:00
|
|
|
static ssize_t store_debug_level(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
2007-09-26 00:54:57 +00:00
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2008-05-06 03:05:11 +00:00
|
|
|
struct iwl_priv *priv = d->driver_data;
|
2008-09-03 03:26:32 +00:00
|
|
|
unsigned long val;
|
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-09-03 03:26:32 +00:00
|
|
|
ret = strict_strtoul(buf, 0, &val);
|
|
|
|
if (ret)
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2008-05-06 03:05:11 +00:00
|
|
|
priv->debug_level = val;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return strnlen(buf, count);
|
|
|
|
}
|
|
|
|
|
2008-05-06 03:05:11 +00:00
|
|
|
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
|
|
|
|
show_debug_level, store_debug_level);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#endif /* CONFIG_IWLWIFI_DEBUG */
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
2008-05-06 03:05:13 +00:00
|
|
|
static ssize_t show_version(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct iwl_priv *priv = d->driver_data;
|
2008-05-29 08:34:55 +00:00
|
|
|
struct iwl_alive_resp *palive = &priv->card_alive;
|
2008-06-30 09:23:02 +00:00
|
|
|
ssize_t pos = 0;
|
|
|
|
u16 eeprom_ver;
|
2008-05-06 03:05:13 +00:00
|
|
|
|
|
|
|
if (palive->is_valid)
|
2008-06-30 09:23:02 +00:00
|
|
|
pos += sprintf(buf + pos,
|
|
|
|
"fw version: 0x%01X.0x%01X.0x%01X.0x%01X\n"
|
|
|
|
"fw type: 0x%01X 0x%01X\n",
|
2008-05-06 03:05:13 +00:00
|
|
|
palive->ucode_major, palive->ucode_minor,
|
|
|
|
palive->sw_rev[0], palive->sw_rev[1],
|
|
|
|
palive->ver_type, palive->ver_subtype);
|
|
|
|
else
|
2008-06-30 09:23:02 +00:00
|
|
|
pos += sprintf(buf + pos, "fw not loaded\n");
|
|
|
|
|
|
|
|
if (priv->eeprom) {
|
|
|
|
eeprom_ver = iwl_eeprom_query16(priv, EEPROM_VERSION);
|
|
|
|
pos += sprintf(buf + pos, "EEPROM version: 0x%x\n",
|
|
|
|
eeprom_ver);
|
|
|
|
} else {
|
|
|
|
pos += sprintf(buf + pos, "EEPROM not initialzed\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return pos;
|
2008-05-06 03:05:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(version, S_IWUSR | S_IRUGO, show_version, NULL);
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
static ssize_t show_temperature(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_alive(priv))
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
2008-06-12 01:47:14 +00:00
|
|
|
return sprintf(buf, "%d\n", priv->temperature);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
|
|
|
|
|
|
|
|
static ssize_t show_tx_power(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2008-12-17 08:52:34 +00:00
|
|
|
|
|
|
|
if (!iwl_is_ready_rf(priv))
|
|
|
|
return sprintf(buf, "off\n");
|
|
|
|
else
|
|
|
|
return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t store_tx_power(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2008-09-03 03:26:32 +00:00
|
|
|
unsigned long val;
|
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-09-03 03:26:32 +00:00
|
|
|
ret = strict_strtoul(buf, 10, &val);
|
|
|
|
if (ret)
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_INFO(priv, "%s is not in decimal form.\n", buf);
|
2007-09-26 00:54:57 +00:00
|
|
|
else
|
2008-06-12 01:47:08 +00:00
|
|
|
iwl_set_tx_power(priv, val, false);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
|
|
|
|
|
|
|
|
static ssize_t show_flags(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return sprintf(buf, "0x%04X\n", priv->active_rxon.flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t store_flags(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2008-09-03 03:26:32 +00:00
|
|
|
unsigned long val;
|
|
|
|
u32 flags;
|
|
|
|
int ret = strict_strtoul(buf, 0, &val);
|
2008-09-03 03:26:39 +00:00
|
|
|
if (ret)
|
2008-09-03 03:26:32 +00:00
|
|
|
return ret;
|
|
|
|
flags = (u32)val;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
if (le32_to_cpu(priv->staging_rxon.flags) != flags) {
|
|
|
|
/* Cancel any currently running scans... */
|
2008-06-12 01:47:10 +00:00
|
|
|
if (iwl_scan_cancel_timeout(priv, 100))
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Could not cancel scan.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Commit rxon.flags = 0x%04X\n", flags);
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->staging_rxon.flags = cpu_to_le32(flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(flags, S_IWUSR | S_IRUGO, show_flags, store_flags);
|
|
|
|
|
|
|
|
static ssize_t show_filter_flags(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
return sprintf(buf, "0x%04X\n",
|
|
|
|
le32_to_cpu(priv->active_rxon.filter_flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t store_filter_flags(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = (struct iwl_priv *)d->driver_data;
|
2008-09-03 03:26:32 +00:00
|
|
|
unsigned long val;
|
|
|
|
u32 filter_flags;
|
|
|
|
int ret = strict_strtoul(buf, 0, &val);
|
2008-09-03 03:26:39 +00:00
|
|
|
if (ret)
|
2008-09-03 03:26:32 +00:00
|
|
|
return ret;
|
|
|
|
filter_flags = (u32)val;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
if (le32_to_cpu(priv->staging_rxon.filter_flags) != filter_flags) {
|
|
|
|
/* Cancel any currently running scans... */
|
2008-06-12 01:47:10 +00:00
|
|
|
if (iwl_scan_cancel_timeout(priv, 100))
|
2008-12-19 02:37:32 +00:00
|
|
|
IWL_WARN(priv, "Could not cancel scan.\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
else {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Committing rxon.filter_flags = "
|
2007-09-26 00:54:57 +00:00
|
|
|
"0x%04X\n", filter_flags);
|
|
|
|
priv->staging_rxon.filter_flags =
|
|
|
|
cpu_to_le32(filter_flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_commit_rxon(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(filter_flags, S_IWUSR | S_IRUGO, show_filter_flags,
|
|
|
|
store_filter_flags);
|
|
|
|
|
|
|
|
static ssize_t store_power_level(struct device *d,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
2008-07-18 05:52:58 +00:00
|
|
|
int ret;
|
2008-09-03 03:26:32 +00:00
|
|
|
unsigned long mode;
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
|
|
|
|
2008-09-03 03:26:32 +00:00
|
|
|
ret = strict_strtoul(buf, 10, &mode);
|
2008-09-03 03:26:39 +00:00
|
|
|
if (ret)
|
2008-09-03 03:26:32 +00:00
|
|
|
goto out;
|
|
|
|
|
2008-07-18 05:52:58 +00:00
|
|
|
ret = iwl_power_set_user_mode(priv, mode);
|
|
|
|
if (ret) {
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_MAC80211(priv, "failed setting power mode.\n");
|
2008-04-21 22:41:51 +00:00
|
|
|
goto out;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
2008-07-18 05:52:58 +00:00
|
|
|
ret = count;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&priv->mutex);
|
2008-07-18 05:52:58 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t show_power_level(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
2008-07-18 05:52:58 +00:00
|
|
|
int mode = priv->power_data.user_power_setting;
|
|
|
|
int system = priv->power_data.system_power_setting;
|
2008-04-21 22:41:51 +00:00
|
|
|
int level = priv->power_data.power_mode;
|
2007-09-26 00:54:57 +00:00
|
|
|
char *p = buf;
|
|
|
|
|
2008-07-18 05:52:58 +00:00
|
|
|
switch (system) {
|
|
|
|
case IWL_POWER_SYS_AUTO:
|
|
|
|
p += sprintf(p, "SYSTEM:auto");
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
2008-07-18 05:52:58 +00:00
|
|
|
case IWL_POWER_SYS_AC:
|
|
|
|
p += sprintf(p, "SYSTEM:ac");
|
|
|
|
break;
|
|
|
|
case IWL_POWER_SYS_BATTERY:
|
|
|
|
p += sprintf(p, "SYSTEM:battery");
|
2007-09-26 00:54:57 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-07-18 05:52:58 +00:00
|
|
|
|
2008-11-12 21:14:08 +00:00
|
|
|
p += sprintf(p, "\tMODE:%s", (mode < IWL_POWER_AUTO) ?
|
|
|
|
"fixed" : "auto");
|
2008-07-18 05:52:58 +00:00
|
|
|
p += sprintf(p, "\tINDEX:%d", level);
|
|
|
|
p += sprintf(p, "\n");
|
2008-07-20 23:40:14 +00:00
|
|
|
return p - buf + 1;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(power_level, S_IWUSR | S_IRUSR, show_power_level,
|
|
|
|
store_power_level);
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t show_statistics(struct device *d,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = dev_get_drvdata(d);
|
2008-06-30 09:23:07 +00:00
|
|
|
u32 size = sizeof(struct iwl_notif_statistics);
|
2007-09-26 00:54:57 +00:00
|
|
|
u32 len = 0, ofs = 0;
|
2008-07-20 23:40:14 +00:00
|
|
|
u8 *data = (u8 *)&priv->statistics;
|
2007-09-26 00:54:57 +00:00
|
|
|
int rc = 0;
|
|
|
|
|
2008-04-03 23:05:21 +00:00
|
|
|
if (!iwl_is_alive(priv))
|
2007-09-26 00:54:57 +00:00
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
mutex_lock(&priv->mutex);
|
2008-04-15 23:01:37 +00:00
|
|
|
rc = iwl_send_statistics_request(priv, 0);
|
2007-09-26 00:54:57 +00:00
|
|
|
mutex_unlock(&priv->mutex);
|
|
|
|
|
|
|
|
if (rc) {
|
|
|
|
len = sprintf(buf,
|
|
|
|
"Error sending statistics request: 0x%08X\n", rc);
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (size && (PAGE_SIZE - len)) {
|
|
|
|
hex_dump_to_buffer(data + ofs, size, 16, 1, buf + len,
|
|
|
|
PAGE_SIZE - len, 1);
|
|
|
|
len = strlen(buf);
|
|
|
|
if (PAGE_SIZE - len)
|
|
|
|
buf[len++] = '\n';
|
|
|
|
|
|
|
|
ofs += 16;
|
|
|
|
size -= min(size, 16U);
|
|
|
|
}
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(statistics, S_IRUGO, show_statistics, NULL);
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* driver setup and teardown
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
static void iwl_setup_deferred_work(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2009-02-13 19:51:18 +00:00
|
|
|
priv->workqueue = create_singlethread_workqueue(DRV_NAME);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
init_waitqueue_head(&priv->wait_command_queue);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
INIT_WORK(&priv->up, iwl_bg_up);
|
|
|
|
INIT_WORK(&priv->restart, iwl_bg_restart);
|
|
|
|
INIT_WORK(&priv->rx_replenish, iwl_bg_rx_replenish);
|
|
|
|
INIT_WORK(&priv->rf_kill, iwl_bg_rf_kill);
|
|
|
|
INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
|
2008-06-12 01:46:52 +00:00
|
|
|
INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
|
2008-05-29 08:34:54 +00:00
|
|
|
INIT_DELAYED_WORK(&priv->init_alive_start, iwl_bg_init_alive_start);
|
|
|
|
INIT_DELAYED_WORK(&priv->alive_start, iwl_bg_alive_start);
|
2008-06-12 01:47:10 +00:00
|
|
|
|
|
|
|
iwl_setup_scan_deferred_work(priv);
|
2008-09-03 03:26:50 +00:00
|
|
|
iwl_setup_power_deferred_work(priv);
|
2008-01-28 00:41:47 +00:00
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
if (priv->cfg->ops->lib->setup_deferred_work)
|
|
|
|
priv->cfg->ops->lib->setup_deferred_work(priv);
|
|
|
|
|
|
|
|
init_timer(&priv->statistics_periodic);
|
|
|
|
priv->statistics_periodic.data = (unsigned long)priv;
|
2008-10-29 21:05:46 +00:00
|
|
|
priv->statistics_periodic.function = iwl_bg_statistics_periodic;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_irq_tasklet, (unsigned long)priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
static void iwl_cancel_deferred_work(struct iwl_priv *priv)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-06-12 01:46:53 +00:00
|
|
|
if (priv->cfg->ops->lib->cancel_deferred_work)
|
|
|
|
priv->cfg->ops->lib->cancel_deferred_work(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2007-11-29 01:43:16 +00:00
|
|
|
cancel_delayed_work_sync(&priv->init_alive_start);
|
2007-09-26 00:54:57 +00:00
|
|
|
cancel_delayed_work(&priv->scan_check);
|
2008-09-03 03:26:50 +00:00
|
|
|
cancel_delayed_work_sync(&priv->set_power_save);
|
2007-09-26 00:54:57 +00:00
|
|
|
cancel_delayed_work(&priv->alive_start);
|
|
|
|
cancel_work_sync(&priv->beacon_update);
|
2008-06-12 01:46:53 +00:00
|
|
|
del_timer_sync(&priv->statistics_periodic);
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static struct attribute *iwl_sysfs_entries[] = {
|
2007-09-26 00:54:57 +00:00
|
|
|
&dev_attr_flags.attr,
|
|
|
|
&dev_attr_filter_flags.attr,
|
|
|
|
&dev_attr_power_level.attr,
|
|
|
|
&dev_attr_statistics.attr,
|
|
|
|
&dev_attr_temperature.attr,
|
|
|
|
&dev_attr_tx_power.attr,
|
2008-05-06 03:05:11 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
|
|
|
&dev_attr_debug_level.attr,
|
|
|
|
#endif
|
2008-05-06 03:05:13 +00:00
|
|
|
&dev_attr_version.attr,
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static struct attribute_group iwl_attribute_group = {
|
2007-09-26 00:54:57 +00:00
|
|
|
.name = NULL, /* put in device directory */
|
2008-10-29 21:05:46 +00:00
|
|
|
.attrs = iwl_sysfs_entries,
|
2007-09-26 00:54:57 +00:00
|
|
|
};
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static struct ieee80211_ops iwl_hw_ops = {
|
|
|
|
.tx = iwl_mac_tx,
|
|
|
|
.start = iwl_mac_start,
|
|
|
|
.stop = iwl_mac_stop,
|
|
|
|
.add_interface = iwl_mac_add_interface,
|
|
|
|
.remove_interface = iwl_mac_remove_interface,
|
|
|
|
.config = iwl_mac_config,
|
|
|
|
.config_interface = iwl_mac_config_interface,
|
|
|
|
.configure_filter = iwl_configure_filter,
|
|
|
|
.set_key = iwl_mac_set_key,
|
|
|
|
.update_tkip_key = iwl_mac_update_tkip_key,
|
|
|
|
.get_stats = iwl_mac_get_stats,
|
|
|
|
.get_tx_stats = iwl_mac_get_tx_stats,
|
|
|
|
.conf_tx = iwl_mac_conf_tx,
|
|
|
|
.reset_tsf = iwl_mac_reset_tsf,
|
|
|
|
.bss_info_changed = iwl_bss_info_changed,
|
|
|
|
.ampdu_action = iwl_mac_ampdu_action,
|
2008-09-03 03:26:23 +00:00
|
|
|
.hw_scan = iwl_mac_hw_scan
|
2007-09-26 00:54:57 +00:00
|
|
|
};
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
int err = 0;
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv;
|
2007-09-26 00:54:57 +00:00
|
|
|
struct ieee80211_hw *hw;
|
2008-03-05 02:09:30 +00:00
|
|
|
struct iwl_cfg *cfg = (struct iwl_cfg *)(ent->driver_data);
|
2008-03-28 23:21:08 +00:00
|
|
|
unsigned long flags;
|
2009-01-19 12:10:07 +00:00
|
|
|
u16 pci_cmd;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-03-14 17:38:46 +00:00
|
|
|
/************************
|
|
|
|
* 1. Allocating HW data
|
|
|
|
************************/
|
|
|
|
|
2007-11-29 03:09:55 +00:00
|
|
|
/* Disabling hardware scan means that mac80211 will perform scans
|
|
|
|
* "the hard way", rather than using device's scan. */
|
2008-03-18 21:57:50 +00:00
|
|
|
if (cfg->mod_params->disable_hw_scan) {
|
2008-05-05 02:22:40 +00:00
|
|
|
if (cfg->mod_params->debug & IWL_DL_INFO)
|
|
|
|
dev_printk(KERN_DEBUG, &(pdev->dev),
|
|
|
|
"Disabling hw_scan\n");
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_hw_ops.hw_scan = NULL;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
hw = iwl_alloc_all(cfg, &iwl_hw_ops);
|
2008-03-14 17:38:48 +00:00
|
|
|
if (!hw) {
|
2007-09-26 00:54:57 +00:00
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2008-03-14 17:38:48 +00:00
|
|
|
priv = hw->priv;
|
|
|
|
/* At this point both hw and priv are allocated. */
|
|
|
|
|
2007-09-26 00:54:57 +00:00
|
|
|
SET_IEEE80211_DEV(hw, &pdev->dev);
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
|
2008-03-05 02:09:30 +00:00
|
|
|
priv->cfg = cfg;
|
2007-09-26 00:54:57 +00:00
|
|
|
priv->pci_dev = pdev;
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2008-03-12 23:58:49 +00:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-05-05 02:22:40 +00:00
|
|
|
priv->debug_level = priv->cfg->mod_params->debug;
|
2007-09-26 00:54:57 +00:00
|
|
|
atomic_set(&priv->restrict_refcnt, 0);
|
|
|
|
#endif
|
|
|
|
|
2008-03-14 17:38:46 +00:00
|
|
|
/**************************
|
|
|
|
* 2. Initializing PCI bus
|
|
|
|
**************************/
|
|
|
|
if (pci_enable_device(pdev)) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out_ieee80211_free_hw;
|
|
|
|
}
|
|
|
|
|
|
|
|
pci_set_master(pdev);
|
|
|
|
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
|
2008-03-14 17:38:46 +00:00
|
|
|
if (!err)
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
|
2008-04-21 22:41:59 +00:00
|
|
|
if (err) {
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-04-21 22:41:59 +00:00
|
|
|
if (!err)
|
2008-09-26 07:09:34 +00:00
|
|
|
err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
|
2008-04-21 22:41:59 +00:00
|
|
|
/* both attempts failed: */
|
2008-03-14 17:38:46 +00:00
|
|
|
if (err) {
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_WARN(priv, "No suitable DMA available.\n");
|
2008-03-14 17:38:46 +00:00
|
|
|
goto out_pci_disable_device;
|
2008-04-21 22:41:59 +00:00
|
|
|
}
|
2008-03-14 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
err = pci_request_regions(pdev, DRV_NAME);
|
|
|
|
if (err)
|
|
|
|
goto out_pci_disable_device;
|
|
|
|
|
|
|
|
pci_set_drvdata(pdev, priv);
|
|
|
|
|
|
|
|
|
|
|
|
/***********************
|
|
|
|
* 3. Read REV register
|
|
|
|
***********************/
|
|
|
|
priv->hw_base = pci_iomap(pdev, 0, 0);
|
|
|
|
if (!priv->hw_base) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto out_pci_release_regions;
|
|
|
|
}
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "pci_resource_len = 0x%08llx\n",
|
2008-03-14 17:38:46 +00:00
|
|
|
(unsigned long long) pci_resource_len(pdev, 0));
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "pci_resource_base = %p\n", priv->hw_base);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2008-04-24 00:14:54 +00:00
|
|
|
iwl_hw_detect(priv);
|
2008-12-19 02:37:31 +00:00
|
|
|
IWL_INFO(priv, "Detected Intel Wireless WiFi Link %s REV=0x%X\n",
|
2008-04-24 00:14:54 +00:00
|
|
|
priv->cfg->name, priv->hw_rev);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2008-09-03 03:26:49 +00:00
|
|
|
/* We disable the RETRY_TIMEOUT register (0x41) to keep
|
|
|
|
* PCI Tx retries from interfering with C3 CPU state */
|
|
|
|
pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
|
|
|
|
|
2008-04-24 00:14:53 +00:00
|
|
|
/* amp init */
|
|
|
|
err = priv->cfg->ops->lib->apm_ops.init(priv);
|
2008-03-14 17:38:46 +00:00
|
|
|
if (err < 0) {
|
2009-03-11 18:18:01 +00:00
|
|
|
IWL_ERR(priv, "Failed to init APMG\n");
|
2008-03-14 17:38:46 +00:00
|
|
|
goto out_iounmap;
|
|
|
|
}
|
2008-04-24 00:14:53 +00:00
|
|
|
/*****************
|
|
|
|
* 4. Read EEPROM
|
|
|
|
*****************/
|
2008-03-14 17:38:46 +00:00
|
|
|
/* Read the EEPROM */
|
|
|
|
err = iwl_eeprom_init(priv);
|
|
|
|
if (err) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to init EEPROM\n");
|
2008-03-14 17:38:46 +00:00
|
|
|
goto out_iounmap;
|
|
|
|
}
|
2008-04-24 00:14:55 +00:00
|
|
|
err = iwl_eeprom_check_version(priv);
|
|
|
|
if (err)
|
2009-02-28 00:21:22 +00:00
|
|
|
goto out_free_eeprom;
|
2008-04-24 00:14:55 +00:00
|
|
|
|
2008-05-15 05:53:53 +00:00
|
|
|
/* extract MAC Address */
|
2008-03-14 17:38:46 +00:00
|
|
|
iwl_eeprom_get_mac(priv, priv->mac_addr);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->mac_addr);
|
2008-03-14 17:38:46 +00:00
|
|
|
SET_IEEE80211_PERM_ADDR(priv->hw, priv->mac_addr);
|
|
|
|
|
|
|
|
/************************
|
|
|
|
* 5. Setup HW constants
|
|
|
|
************************/
|
2008-06-30 09:23:20 +00:00
|
|
|
if (iwl_set_hw_params(priv)) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to set hw parameters\n");
|
2008-04-21 22:41:52 +00:00
|
|
|
goto out_free_eeprom;
|
2008-03-14 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*******************
|
2008-05-15 05:54:17 +00:00
|
|
|
* 6. Setup priv
|
2008-03-14 17:38:46 +00:00
|
|
|
*******************/
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-15 05:54:17 +00:00
|
|
|
err = iwl_init_drv(priv);
|
2008-03-14 17:38:49 +00:00
|
|
|
if (err)
|
2008-04-24 00:14:56 +00:00
|
|
|
goto out_free_eeprom;
|
2008-03-14 17:38:49 +00:00
|
|
|
/* At this point both hw and priv are initialized. */
|
2008-03-14 17:38:46 +00:00
|
|
|
|
|
|
|
/**********************************
|
|
|
|
* 7. Initialize module parameters
|
|
|
|
**********************************/
|
|
|
|
|
|
|
|
/* Disable radio (SW RF KILL) via parameter when loading driver */
|
2008-03-18 21:57:50 +00:00
|
|
|
if (priv->cfg->mod_params->disable) {
|
2008-03-14 17:38:46 +00:00
|
|
|
set_bit(STATUS_RF_KILL_SW, &priv->status);
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "Radio disabled.\n");
|
2008-03-14 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/********************
|
|
|
|
* 8. Setup services
|
|
|
|
********************/
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
pci_enable_msi(priv->pci_dev);
|
|
|
|
|
|
|
|
err = request_irq(priv->pci_dev->irq, iwl_isr, IRQF_SHARED,
|
|
|
|
DRV_NAME, priv);
|
|
|
|
if (err) {
|
|
|
|
IWL_ERR(priv, "Error allocating IRQ %d\n", priv->pci_dev->irq);
|
|
|
|
goto out_disable_msi;
|
|
|
|
}
|
2008-10-29 21:05:46 +00:00
|
|
|
err = sysfs_create_group(&pdev->dev.kobj, &iwl_attribute_group);
|
2008-03-14 17:38:46 +00:00
|
|
|
if (err) {
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to create sysfs device attributes\n");
|
2009-02-12 17:51:03 +00:00
|
|
|
goto out_free_irq;
|
2008-03-14 17:38:46 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 01:46:53 +00:00
|
|
|
iwl_setup_deferred_work(priv);
|
2008-06-30 09:23:11 +00:00
|
|
|
iwl_setup_rx_handlers(priv);
|
2008-03-14 17:38:46 +00:00
|
|
|
|
2008-05-15 05:54:17 +00:00
|
|
|
/**********************************
|
2009-01-19 12:10:07 +00:00
|
|
|
* 9. Setup and register mac80211
|
2008-05-15 05:54:17 +00:00
|
|
|
**********************************/
|
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
/* enable interrupts if needed: hw bug w/a */
|
|
|
|
pci_read_config_word(priv->pci_dev, PCI_COMMAND, &pci_cmd);
|
|
|
|
if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
|
|
|
|
pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
|
|
|
|
pci_write_config_word(priv->pci_dev, PCI_COMMAND, pci_cmd);
|
|
|
|
}
|
|
|
|
|
|
|
|
iwl_enable_interrupts(priv);
|
|
|
|
|
2008-05-15 05:54:17 +00:00
|
|
|
err = iwl_setup_mac(priv);
|
|
|
|
if (err)
|
|
|
|
goto out_remove_sysfs;
|
|
|
|
|
|
|
|
err = iwl_dbgfs_register(priv, DRV_NAME);
|
|
|
|
if (err)
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "failed to create debugfs files\n");
|
2008-05-15 05:54:17 +00:00
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
/* If platform's RF_KILL switch is NOT set to KILL */
|
|
|
|
if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
|
|
|
|
clear_bit(STATUS_RF_KILL_HW, &priv->status);
|
|
|
|
else
|
|
|
|
set_bit(STATUS_RF_KILL_HW, &priv->status);
|
2008-05-15 05:54:17 +00:00
|
|
|
|
2008-06-12 01:47:19 +00:00
|
|
|
err = iwl_rfkill_init(priv);
|
|
|
|
if (err)
|
2008-12-19 02:37:33 +00:00
|
|
|
IWL_ERR(priv, "Unable to initialize RFKILL system. "
|
2008-06-12 01:47:19 +00:00
|
|
|
"Ignoring error: %d\n", err);
|
2009-01-19 12:10:07 +00:00
|
|
|
else
|
|
|
|
iwl_rfkill_set_hw_state(priv);
|
|
|
|
|
2008-06-12 01:47:19 +00:00
|
|
|
iwl_power_initialize(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-03-14 17:38:46 +00:00
|
|
|
out_remove_sysfs:
|
2009-02-28 00:21:22 +00:00
|
|
|
destroy_workqueue(priv->workqueue);
|
|
|
|
priv->workqueue = NULL;
|
2008-10-29 21:05:46 +00:00
|
|
|
sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
|
2009-02-12 17:51:03 +00:00
|
|
|
out_free_irq:
|
|
|
|
free_irq(priv->pci_dev->irq, priv);
|
2009-01-19 12:10:07 +00:00
|
|
|
out_disable_msi:
|
|
|
|
pci_disable_msi(priv->pci_dev);
|
2008-05-15 05:54:17 +00:00
|
|
|
iwl_uninit_drv(priv);
|
2008-04-21 22:41:52 +00:00
|
|
|
out_free_eeprom:
|
|
|
|
iwl_eeprom_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
out_iounmap:
|
|
|
|
pci_iounmap(pdev, priv->hw_base);
|
|
|
|
out_pci_release_regions:
|
2008-03-14 17:38:46 +00:00
|
|
|
pci_set_drvdata(pdev, NULL);
|
2009-03-03 19:37:04 +00:00
|
|
|
pci_release_regions(pdev);
|
2007-09-26 00:54:57 +00:00
|
|
|
out_pci_disable_device:
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
out_ieee80211_free_hw:
|
|
|
|
ieee80211_free_hw(priv->hw);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void __devexit iwl_pci_remove(struct pci_dev *pdev)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = pci_get_drvdata(pdev);
|
2008-03-28 23:21:08 +00:00
|
|
|
unsigned long flags;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (!priv)
|
|
|
|
return;
|
|
|
|
|
2009-01-27 22:27:56 +00:00
|
|
|
IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-05-29 08:35:26 +00:00
|
|
|
iwl_dbgfs_unregister(priv);
|
2008-10-29 21:05:46 +00:00
|
|
|
sysfs_remove_group(&pdev->dev.kobj, &iwl_attribute_group);
|
2008-05-29 08:35:26 +00:00
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* ieee80211_unregister_hw call wil cause iwl_mac_stop to
|
|
|
|
* to be called and iwl_down since we are removing the device
|
2008-09-03 03:18:50 +00:00
|
|
|
* we need to set STATUS_EXIT_PENDING bit.
|
|
|
|
*/
|
|
|
|
set_bit(STATUS_EXIT_PENDING, &priv->status);
|
2008-03-28 23:21:10 +00:00
|
|
|
if (priv->mac80211_registered) {
|
|
|
|
ieee80211_unregister_hw(priv->hw);
|
|
|
|
priv->mac80211_registered = 0;
|
2008-09-03 03:18:50 +00:00
|
|
|
} else {
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_down(priv);
|
2008-03-28 23:21:10 +00:00
|
|
|
}
|
|
|
|
|
2008-03-28 23:21:08 +00:00
|
|
|
/* make sure we flush any pending irq or
|
|
|
|
* tasklet for the driver
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_disable_interrupts(priv);
|
2008-03-28 23:21:08 +00:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
iwl_synchronize_irq(priv);
|
|
|
|
|
2008-06-12 01:47:19 +00:00
|
|
|
iwl_rfkill_unregister(priv);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_dealloc_ucode_pci(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->rxq.bd)
|
2008-05-05 02:22:28 +00:00
|
|
|
iwl_rx_queue_free(priv, &priv->rxq);
|
2008-05-05 02:22:43 +00:00
|
|
|
iwl_hw_txq_ctx_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-06-30 09:23:08 +00:00
|
|
|
iwl_clear_stations_table(priv);
|
2008-04-21 22:41:52 +00:00
|
|
|
iwl_eeprom_free(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
|
2007-10-25 09:15:45 +00:00
|
|
|
/*netif_stop_queue(dev); */
|
|
|
|
flush_workqueue(priv->workqueue);
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
/* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
|
2007-09-26 00:54:57 +00:00
|
|
|
* priv->workqueue... so we can't take down the workqueue
|
|
|
|
* until now... */
|
|
|
|
destroy_workqueue(priv->workqueue);
|
|
|
|
priv->workqueue = NULL;
|
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
free_irq(priv->pci_dev->irq, priv);
|
|
|
|
pci_disable_msi(priv->pci_dev);
|
2007-09-26 00:54:57 +00:00
|
|
|
pci_iounmap(pdev, priv->hw_base);
|
|
|
|
pci_release_regions(pdev);
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
pci_set_drvdata(pdev, NULL);
|
|
|
|
|
2008-05-15 05:54:17 +00:00
|
|
|
iwl_uninit_drv(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
if (priv->ibss_beacon)
|
|
|
|
dev_kfree_skb(priv->ibss_beacon);
|
|
|
|
|
|
|
|
ieee80211_free_hw(priv->hw);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_pci_suspend(struct pci_dev *pdev, pm_message_t state)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = pci_get_drvdata(pdev);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
if (priv->is_open) {
|
|
|
|
set_bit(STATUS_IN_SUSPEND, &priv->status);
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_mac_stop(priv->hw);
|
2008-01-24 10:19:38 +00:00
|
|
|
priv->is_open = 1;
|
|
|
|
}
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2009-01-19 12:10:07 +00:00
|
|
|
pci_save_state(pdev);
|
|
|
|
pci_disable_device(pdev);
|
2007-09-26 00:54:57 +00:00
|
|
|
pci_set_power_state(pdev, PCI_D3hot);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int iwl_pci_resume(struct pci_dev *pdev)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-03-12 23:58:50 +00:00
|
|
|
struct iwl_priv *priv = pci_get_drvdata(pdev);
|
2009-01-27 22:27:55 +00:00
|
|
|
int ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
|
|
|
|
pci_set_power_state(pdev, PCI_D0);
|
2009-01-27 22:27:55 +00:00
|
|
|
ret = pci_enable_device(pdev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2009-01-19 12:10:07 +00:00
|
|
|
pci_restore_state(pdev);
|
|
|
|
iwl_enable_interrupts(priv);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
if (priv->is_open)
|
2008-10-29 21:05:46 +00:00
|
|
|
iwl_mac_start(priv->hw);
|
2007-09-26 00:54:57 +00:00
|
|
|
|
2008-01-24 10:19:38 +00:00
|
|
|
clear_bit(STATUS_IN_SUSPEND, &priv->status);
|
2007-09-26 00:54:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
*
|
|
|
|
* driver and module entry point
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-04-15 23:01:41 +00:00
|
|
|
/* Hardware specific file defines the PCI IDs table for that hardware module */
|
|
|
|
static struct pci_device_id iwl_hw_card_ids[] = {
|
2008-07-21 15:54:42 +00:00
|
|
|
#ifdef CONFIG_IWL4965
|
2008-04-15 23:01:41 +00:00
|
|
|
{IWL_PCI_DEVICE(0x4229, PCI_ANY_ID, iwl4965_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4230, PCI_ANY_ID, iwl4965_agn_cfg)},
|
2008-07-21 15:54:42 +00:00
|
|
|
#endif /* CONFIG_IWL4965 */
|
2008-04-24 18:55:23 +00:00
|
|
|
#ifdef CONFIG_IWL5000
|
2008-07-11 03:53:30 +00:00
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1205, iwl5100_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1305, iwl5100_bg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1206, iwl5100_abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1306, iwl5100_abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4232, 0x1326, iwl5100_abg_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4237, 0x1216, iwl5100_abg_cfg)},
|
2008-04-24 18:55:23 +00:00
|
|
|
{IWL_PCI_DEVICE(0x4232, PCI_ANY_ID, iwl5100_agn_cfg)},
|
2008-07-11 03:53:30 +00:00
|
|
|
{IWL_PCI_DEVICE(0x4235, PCI_ANY_ID, iwl5300_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4236, PCI_ANY_ID, iwl5300_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4237, PCI_ANY_ID, iwl5100_agn_cfg)},
|
2008-09-11 03:45:20 +00:00
|
|
|
/* 5350 WiFi/WiMax */
|
|
|
|
{IWL_PCI_DEVICE(0x423A, 0x1001, iwl5350_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x423A, 0x1021, iwl5350_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x423B, 0x1011, iwl5350_agn_cfg)},
|
2008-12-02 00:32:18 +00:00
|
|
|
/* 5150 Wifi/WiMax */
|
|
|
|
{IWL_PCI_DEVICE(0x423C, PCI_ANY_ID, iwl5150_agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x423D, PCI_ANY_ID, iwl5150_agn_cfg)},
|
2009-01-19 23:30:34 +00:00
|
|
|
/* 6000/6050 Series */
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1102, iwl6000_2ag_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0085, 0x1112, iwl6000_2ag_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, 0x1122, iwl6000_2ag_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x422B, PCI_ANY_ID, iwl6000_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x4238, PCI_ANY_ID, iwl6000_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0082, PCI_ANY_ID, iwl6000_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0085, PCI_ANY_ID, iwl6000_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0086, PCI_ANY_ID, iwl6050_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0087, PCI_ANY_ID, iwl6050_2agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0088, PCI_ANY_ID, iwl6050_3agn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0089, PCI_ANY_ID, iwl6050_2agn_cfg)},
|
2009-03-06 21:52:55 +00:00
|
|
|
/* 1000 Series WiFi */
|
|
|
|
{IWL_PCI_DEVICE(0x0083, PCI_ANY_ID, iwl1000_bgn_cfg)},
|
|
|
|
{IWL_PCI_DEVICE(0x0084, PCI_ANY_ID, iwl1000_bgn_cfg)},
|
2008-04-24 18:55:23 +00:00
|
|
|
#endif /* CONFIG_IWL5000 */
|
2008-12-02 00:32:18 +00:00
|
|
|
|
2008-04-15 23:01:41 +00:00
|
|
|
{0}
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, iwl_hw_card_ids);
|
|
|
|
|
|
|
|
static struct pci_driver iwl_driver = {
|
2007-09-26 00:54:57 +00:00
|
|
|
.name = DRV_NAME,
|
2008-04-15 23:01:41 +00:00
|
|
|
.id_table = iwl_hw_card_ids,
|
2008-10-29 21:05:46 +00:00
|
|
|
.probe = iwl_pci_probe,
|
|
|
|
.remove = __devexit_p(iwl_pci_remove),
|
2007-09-26 00:54:57 +00:00
|
|
|
#ifdef CONFIG_PM
|
2008-10-29 21:05:46 +00:00
|
|
|
.suspend = iwl_pci_suspend,
|
|
|
|
.resume = iwl_pci_resume,
|
2007-09-26 00:54:57 +00:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static int __init iwl_init(void)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
int ret;
|
|
|
|
printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
|
|
|
|
printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
|
2008-03-28 23:21:09 +00:00
|
|
|
|
2008-07-18 05:53:05 +00:00
|
|
|
ret = iwlagn_rate_control_register();
|
2008-03-28 23:21:09 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:09 +00:00
|
|
|
printk(KERN_ERR DRV_NAME
|
|
|
|
"Unable to register rate control algorithm: %d\n", ret);
|
2008-03-28 23:21:09 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-15 23:01:41 +00:00
|
|
|
ret = pci_register_driver(&iwl_driver);
|
2007-09-26 00:54:57 +00:00
|
|
|
if (ret) {
|
2008-12-19 02:37:09 +00:00
|
|
|
printk(KERN_ERR DRV_NAME "Unable to initialize PCI module\n");
|
2008-03-28 23:21:09 +00:00
|
|
|
goto error_register;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2008-03-28 23:21:09 +00:00
|
|
|
|
|
|
|
error_register:
|
2008-07-18 05:53:05 +00:00
|
|
|
iwlagn_rate_control_unregister();
|
2008-03-28 23:21:09 +00:00
|
|
|
return ret;
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
static void __exit iwl_exit(void)
|
2007-09-26 00:54:57 +00:00
|
|
|
{
|
2008-04-15 23:01:41 +00:00
|
|
|
pci_unregister_driver(&iwl_driver);
|
2008-07-18 05:53:05 +00:00
|
|
|
iwlagn_rate_control_unregister();
|
2007-09-26 00:54:57 +00:00
|
|
|
}
|
|
|
|
|
2008-10-29 21:05:46 +00:00
|
|
|
module_exit(iwl_exit);
|
|
|
|
module_init(iwl_init);
|