Commit 62362dee authored by John W. Linville's avatar John W. Linville
Browse files

Merge branch 'wireless-next-2.6' of... 

Merge branch 'wireless-next-2.6' of git://git.kernel.org/pub/scm/linux/kernel/git/iwlwifi/iwlwifi-2.6
parents 97d9c3a3 f35c0c56

drivers/net/wireless/iwlwifi/Kconfig

+24 −2
Original line number Diff line number Diff line
@@ -2,6 +2,10 @@ config IWLWIFI 
	tristate "Intel Wireless Wifi"

	depends on PCI && MAC80211

	select FW_LOADER

	select NEW_LEDS

	select LEDS_CLASS

	select LEDS_TRIGGERS

	select MAC80211_LEDS



menu "Debugging Options"

	depends on IWLWIFI
@@ -106,9 +110,27 @@ config IWL5000 
		Intel WiFi Link 1000BGN

		Intel Wireless WiFi 5150AGN

		Intel Wireless WiFi 5100AGN, 5300AGN, and 5350AGN

		Intel 6000 Gen 2 Series Wi-Fi Adapters (6000G2A and 6000G2B)

		Intel WIreless WiFi Link 6050BGN Gen 2 Adapter

		Intel 6005 Series Wi-Fi Adapters

		Intel 6030 Series Wi-Fi Adapters

		Intel Wireless WiFi Link 6150BGN 2 Adapter

		Intel 100 Series Wi-Fi Adapters (100BGN and 130BGN)

		Intel 2000 Series Wi-Fi Adapters



config IWL_P2P

	bool "iwlwifi experimental P2P support"

	depends on IWL5000

	help

	  This option enables experimental P2P support for some devices

	  based on microcode support. Since P2P support is still under

	  development, this option may even enable it for some devices

	  now that turn out to not support it in the future due to

	  microcode restrictions.



	  To determine if your microcode supports the experimental P2P

	  offered by this option, check if the driver advertises AP

	  support when it is loaded.



	  Say Y only if you want to experiment with P2P.



config IWL3945

	tristate "Intel PRO/Wireless 3945ABG/BG Network Connection (iwl3945)"

drivers/net/wireless/iwlwifi/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ iwlagn-$(CONFIG_IWL5000) += iwl-agn-rxon.o iwl-agn-hcmd.o iwl-agn-ict.o 
iwlagn-$(CONFIG_IWL5000) += iwl-5000.o

iwlagn-$(CONFIG_IWL5000) += iwl-6000.o

iwlagn-$(CONFIG_IWL5000) += iwl-1000.o

iwlagn-$(CONFIG_IWL5000) += iwl-2000.o



# 3945

obj-$(CONFIG_IWL3945)	+= iwl3945.o

drivers/net/wireless/iwlwifi/iwl-1000.c

+1 −0
Original line number Diff line number Diff line
@@ -270,6 +270,7 @@ static struct iwl_base_params iwl1000_base_params = { 
	.ucode_tracing = true,

	.sensitivity_calib_by_driver = true,

	.chain_noise_calib_by_driver = true,

	.supports_idle = true,

};

static struct iwl_ht_params iwl1000_ht_params = {

	.ht_greenfield_support = true,

drivers/net/wireless/iwlwifi/iwl-2000.c

0 → 100644
+556 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.

 *

 * 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:

 *  Intel Linux Wireless <ilw@linux.intel.com>

 * 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 <net/mac80211.h>

#include <linux/etherdevice.h>

#include <asm/unaligned.h>



#include "iwl-eeprom.h"

#include "iwl-dev.h"

#include "iwl-core.h"

#include "iwl-io.h"

#include "iwl-sta.h"

#include "iwl-agn.h"

#include "iwl-helpers.h"

#include "iwl-agn-hw.h"

#include "iwl-6000-hw.h"

#include "iwl-agn-led.h"

#include "iwl-agn-debugfs.h"



/* Highest firmware API version supported */

#define IWL2030_UCODE_API_MAX 5

#define IWL2000_UCODE_API_MAX 5

#define IWL200_UCODE_API_MAX 5



/* Lowest firmware API version supported */

#define IWL2030_UCODE_API_MIN 5

#define IWL2000_UCODE_API_MIN 5

#define IWL200_UCODE_API_MIN 5



#define IWL2030_FW_PRE "iwlwifi-2030-"

#define _IWL2030_MODULE_FIRMWARE(api) IWL2030_FW_PRE #api ".ucode"

#define IWL2030_MODULE_FIRMWARE(api) _IWL2030_MODULE_FIRMWARE(api)



#define IWL2000_FW_PRE "iwlwifi-2000-"

#define _IWL2000_MODULE_FIRMWARE(api) IWL2000_FW_PRE #api ".ucode"

#define IWL2000_MODULE_FIRMWARE(api) _IWL2000_MODULE_FIRMWARE(api)



#define IWL200_FW_PRE "iwlwifi-200-"

#define _IWL200_MODULE_FIRMWARE(api) IWL200_FW_PRE #api ".ucode"

#define IWL200_MODULE_FIRMWARE(api) _IWL200_MODULE_FIRMWARE(api)



static void iwl2000_set_ct_threshold(struct iwl_priv *priv)

{

	/* want Celsius */

	priv->hw_params.ct_kill_threshold = CT_KILL_THRESHOLD;

	priv->hw_params.ct_kill_exit_threshold = CT_KILL_EXIT_THRESHOLD;

}



/* NIC configuration for 2000 series */

static void iwl2000_nic_config(struct iwl_priv *priv)

{

	u16 radio_cfg;



	radio_cfg = iwl_eeprom_query16(priv, EEPROM_RADIO_CONFIG);



	/* write radio config values to register */

	if (EEPROM_RF_CFG_TYPE_MSK(radio_cfg) <= EEPROM_RF_CONFIG_TYPE_MAX)

	iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,

			EEPROM_RF_CFG_TYPE_MSK(radio_cfg) |

			EEPROM_RF_CFG_STEP_MSK(radio_cfg) |

			EEPROM_RF_CFG_DASH_MSK(radio_cfg));



	/* set CSR_HW_CONFIG_REG for uCode use */

	iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,

		    CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |

		    CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);



}



static struct iwl_sensitivity_ranges iwl2000_sensitivity = {

	.min_nrg_cck = 97,

	.max_nrg_cck = 0, /* not used, set to 0 */

	.auto_corr_min_ofdm = 80,

	.auto_corr_min_ofdm_mrc = 128,

	.auto_corr_min_ofdm_x1 = 105,

	.auto_corr_min_ofdm_mrc_x1 = 192,



	.auto_corr_max_ofdm = 145,

	.auto_corr_max_ofdm_mrc = 232,

	.auto_corr_max_ofdm_x1 = 110,

	.auto_corr_max_ofdm_mrc_x1 = 232,



	.auto_corr_min_cck = 125,

	.auto_corr_max_cck = 175,

	.auto_corr_min_cck_mrc = 160,

	.auto_corr_max_cck_mrc = 310,

	.nrg_th_cck = 97,

	.nrg_th_ofdm = 100,



	.barker_corr_th_min = 190,

	.barker_corr_th_min_mrc = 390,

	.nrg_th_cca = 62,

};



static int iwl2000_hw_set_hw_params(struct iwl_priv *priv)

{

	if (priv->cfg->mod_params->num_of_queues >= IWL_MIN_NUM_QUEUES &&

	    priv->cfg->mod_params->num_of_queues <= IWLAGN_NUM_QUEUES)

		priv->cfg->base_params->num_of_queues =

			priv->cfg->mod_params->num_of_queues;



	priv->hw_params.max_txq_num = priv->cfg->base_params->num_of_queues;

	priv->hw_params.dma_chnl_num = FH50_TCSR_CHNL_NUM;

	priv->hw_params.scd_bc_tbls_size =

		priv->cfg->base_params->num_of_queues *

		sizeof(struct iwlagn_scd_bc_tbl);

	priv->hw_params.tfd_size = sizeof(struct iwl_tfd);

	priv->hw_params.max_stations = IWLAGN_STATION_COUNT;

	priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id = IWLAGN_BROADCAST_ID;



	priv->hw_params.max_data_size = IWL60_RTC_DATA_SIZE;

	priv->hw_params.max_inst_size = IWL60_RTC_INST_SIZE;



	priv->hw_params.max_bsm_size = 0;

	priv->hw_params.ht40_channel =  BIT(IEEE80211_BAND_2GHZ) |

					BIT(IEEE80211_BAND_5GHZ);

	priv->hw_params.rx_wrt_ptr_reg = FH_RSCSR_CHNL0_WPTR;



	priv->hw_params.tx_chains_num = num_of_ant(priv->cfg->valid_tx_ant);

	if (priv->cfg->rx_with_siso_diversity)

		priv->hw_params.rx_chains_num = 1;

	else

		priv->hw_params.rx_chains_num =

			num_of_ant(priv->cfg->valid_rx_ant);

	priv->hw_params.valid_tx_ant = priv->cfg->valid_tx_ant;

	priv->hw_params.valid_rx_ant = priv->cfg->valid_rx_ant;



	iwl2000_set_ct_threshold(priv);



	/* Set initial sensitivity parameters */

	/* Set initial calibration set */

	priv->hw_params.sens = &iwl2000_sensitivity;

	priv->hw_params.calib_init_cfg =

		BIT(IWL_CALIB_XTAL)             |

		BIT(IWL_CALIB_LO)               |

		BIT(IWL_CALIB_TX_IQ)            |

		BIT(IWL_CALIB_BASE_BAND);

	if (priv->cfg->need_dc_calib)

		priv->hw_params.calib_rt_cfg |= BIT(IWL_CALIB_CFG_DC_IDX);

	if (priv->cfg->need_temp_offset_calib)

		priv->hw_params.calib_init_cfg |= BIT(IWL_CALIB_TEMP_OFFSET);



	priv->hw_params.beacon_time_tsf_bits = IWLAGN_EXT_BEACON_TIME_POS;



	return 0;

}



static int iwl2030_hw_channel_switch(struct iwl_priv *priv,

                                    struct ieee80211_channel_switch *ch_switch)

{

	/*

	 * MULTI-FIXME

	 * See iwl_mac_channel_switch.

	 */

	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];

	struct iwl6000_channel_switch_cmd cmd;

	const struct iwl_channel_info *ch_info;

	u32 switch_time_in_usec, ucode_switch_time;

	u16 ch;

	u32 tsf_low;

	u8 switch_count;

	u16 beacon_interval = le16_to_cpu(ctx->timing.beacon_interval);

	struct ieee80211_vif *vif = ctx->vif;

	struct iwl_host_cmd hcmd = {

		.id = REPLY_CHANNEL_SWITCH,

		.len = sizeof(cmd),

		.flags = CMD_SYNC,

		.data = &cmd,

	};



	cmd.band = priv->band == IEEE80211_BAND_2GHZ;

	ch = ch_switch->channel->hw_value;

	IWL_DEBUG_11H(priv, "channel switch from %u to %u\n",

		ctx->active.channel, ch);

	cmd.channel = cpu_to_le16(ch);

	cmd.rxon_flags = ctx->staging.flags;

	cmd.rxon_filter_flags = ctx->staging.filter_flags;

	switch_count = ch_switch->count;

	tsf_low = ch_switch->timestamp & 0x0ffffffff;

	/*

	 * calculate the ucode channel switch time

	 * adding TSF as one of the factor for when to switch

	 */

	if ((priv->ucode_beacon_time > tsf_low) && beacon_interval) {

		if (switch_count > ((priv->ucode_beacon_time - tsf_low) /

		    beacon_interval)) {

			switch_count -= (priv->ucode_beacon_time -

				tsf_low) / beacon_interval;

		} else

			switch_count = 0;

	}

	if (switch_count <= 1)

		cmd.switch_time = cpu_to_le32(priv->ucode_beacon_time);

	else {

		switch_time_in_usec =

			vif->bss_conf.beacon_int * switch_count * TIME_UNIT;

		ucode_switch_time = iwl_usecs_to_beacons(priv,

						switch_time_in_usec,

						beacon_interval);

		cmd.switch_time = iwl_add_beacon_time(priv,

						priv->ucode_beacon_time,

						ucode_switch_time,

						beacon_interval);

	}

	IWL_DEBUG_11H(priv, "uCode time for the switch is 0x%x\n",

		      cmd.switch_time);

	ch_info = iwl_get_channel_info(priv, priv->band, ch);

	if (ch_info)

		cmd.expect_beacon = is_channel_radar(ch_info);

	else {

		IWL_ERR(priv, "invalid channel switch from %u to %u\n",

			ctx->active.channel, ch);

		return -EFAULT;

	}

	priv->switch_rxon.channel = cmd.channel;

	priv->switch_rxon.switch_in_progress = true;



	return iwl_send_cmd_sync(priv, &hcmd);

}



static struct iwl_lib_ops iwl2000_lib = {

	.set_hw_params = iwl2000_hw_set_hw_params,

	.txq_update_byte_cnt_tbl = iwlagn_txq_update_byte_cnt_tbl,

	.txq_inval_byte_cnt_tbl = iwlagn_txq_inval_byte_cnt_tbl,

	.txq_set_sched = iwlagn_txq_set_sched,

	.txq_agg_enable = iwlagn_txq_agg_enable,

	.txq_agg_disable = iwlagn_txq_agg_disable,

	.txq_attach_buf_to_tfd = iwl_hw_txq_attach_buf_to_tfd,

	.txq_free_tfd = iwl_hw_txq_free_tfd,

	.txq_init = iwl_hw_tx_queue_init,

	.rx_handler_setup = iwlagn_rx_handler_setup,

	.setup_deferred_work = iwlagn_setup_deferred_work,

	.is_valid_rtc_data_addr = iwlagn_hw_valid_rtc_data_addr,

	.load_ucode = iwlagn_load_ucode,

	.dump_nic_event_log = iwl_dump_nic_event_log,

	.dump_nic_error_log = iwl_dump_nic_error_log,

	.dump_csr = iwl_dump_csr,

	.dump_fh = iwl_dump_fh,

	.init_alive_start = iwlagn_init_alive_start,

	.alive_notify = iwlagn_alive_notify,

	.send_tx_power = iwlagn_send_tx_power,

	.update_chain_flags = iwl_update_chain_flags,

	.set_channel_switch = iwl2030_hw_channel_switch,

	.apm_ops = {

		.init = iwl_apm_init,

		.config = iwl2000_nic_config,

	},

	.eeprom_ops = {

		.regulatory_bands = {

			EEPROM_REG_BAND_1_CHANNELS,

			EEPROM_REG_BAND_2_CHANNELS,

			EEPROM_REG_BAND_3_CHANNELS,

			EEPROM_REG_BAND_4_CHANNELS,

			EEPROM_REG_BAND_5_CHANNELS,

			EEPROM_6000_REG_BAND_24_HT40_CHANNELS,

			EEPROM_REG_BAND_52_HT40_CHANNELS

		},

		.acquire_semaphore = iwlcore_eeprom_acquire_semaphore,

		.release_semaphore = iwlcore_eeprom_release_semaphore,

		.calib_version  = iwlagn_eeprom_calib_version,

		.query_addr = iwlagn_eeprom_query_addr,

		.update_enhanced_txpower = iwlcore_eeprom_enhanced_txpower,

	},

	.isr_ops = {

		.isr = iwl_isr_ict,

		.free = iwl_free_isr_ict,

		.alloc = iwl_alloc_isr_ict,

		.reset = iwl_reset_ict,

		.disable = iwl_disable_ict,

	},

	.temp_ops = {

		.temperature = iwlagn_temperature,

	},

	.debugfs_ops = {

		.rx_stats_read = iwl_ucode_rx_stats_read,

		.tx_stats_read = iwl_ucode_tx_stats_read,

		.general_stats_read = iwl_ucode_general_stats_read,

		.bt_stats_read = iwl_ucode_bt_stats_read,

		.reply_tx_error = iwl_reply_tx_error_read,

	},

	.check_plcp_health = iwl_good_plcp_health,

	.check_ack_health = iwl_good_ack_health,

	.txfifo_flush = iwlagn_txfifo_flush,

	.dev_txfifo_flush = iwlagn_dev_txfifo_flush,

	.tt_ops = {

		.lower_power_detection = iwl_tt_is_low_power_state,

		.tt_power_mode = iwl_tt_current_power_mode,

		.ct_kill_check = iwl_check_for_ct_kill,

	}

};



static const struct iwl_ops iwl2000_ops = {

	.lib = &iwl2000_lib,

	.hcmd = &iwlagn_hcmd,

	.utils = &iwlagn_hcmd_utils,

	.led = &iwlagn_led_ops,

	.ieee80211_ops = &iwlagn_hw_ops,

};



static const struct iwl_ops iwl2030_ops = {

	.lib = &iwl2000_lib,

	.hcmd = &iwlagn_bt_hcmd,

	.utils = &iwlagn_hcmd_utils,

	.led = &iwlagn_led_ops,

	.ieee80211_ops = &iwlagn_hw_ops,

};



static const struct iwl_ops iwl200_ops = {

	.lib = &iwl2000_lib,

	.hcmd = &iwlagn_hcmd,

	.utils = &iwlagn_hcmd_utils,

	.led = &iwlagn_led_ops,

	.ieee80211_ops = &iwlagn_hw_ops,

};



static const struct iwl_ops iwl230_ops = {

	.lib = &iwl2000_lib,

	.hcmd = &iwlagn_bt_hcmd,

	.utils = &iwlagn_hcmd_utils,

	.led = &iwlagn_led_ops,

	.ieee80211_ops = &iwlagn_hw_ops,

};



static struct iwl_base_params iwl2000_base_params = {

	.eeprom_size = OTP_LOW_IMAGE_SIZE,

	.num_of_queues = IWLAGN_NUM_QUEUES,

	.num_of_ampdu_queues = IWLAGN_NUM_AMPDU_QUEUES,

	.pll_cfg_val = 0,

	.set_l0s = true,

	.use_bsm = false,

	.max_ll_items = OTP_MAX_LL_ITEMS_2x00,

	.shadow_ram_support = true,

	.led_compensation = 51,

	.chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,

	.supports_idle = true,

	.adv_thermal_throttle = true,

	.support_ct_kill_exit = true,

	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,

	.chain_noise_scale = 1000,

	.wd_timeout = IWL_DEF_WD_TIMEOUT,

	.max_event_log_size = 512,

	.ucode_tracing = true,

	.sensitivity_calib_by_driver = true,

	.chain_noise_calib_by_driver = true,

	.shadow_reg_enable = true,

};





static struct iwl_base_params iwl2030_base_params = {

	.eeprom_size = OTP_LOW_IMAGE_SIZE,

	.num_of_queues = IWLAGN_NUM_QUEUES,

	.num_of_ampdu_queues = IWLAGN_NUM_AMPDU_QUEUES,

	.pll_cfg_val = 0,

	.set_l0s = true,

	.use_bsm = false,

	.max_ll_items = OTP_MAX_LL_ITEMS_2x00,

	.shadow_ram_support = true,

	.led_compensation = 57,

	.chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,

	.supports_idle = true,

	.adv_thermal_throttle = true,

	.support_ct_kill_exit = true,

	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,

	.chain_noise_scale = 1000,

	.wd_timeout = IWL_LONG_WD_TIMEOUT,

	.max_event_log_size = 512,

	.ucode_tracing = true,

	.sensitivity_calib_by_driver = true,

	.chain_noise_calib_by_driver = true,

	.shadow_reg_enable = true,

};



static struct iwl_ht_params iwl2000_ht_params = {

	.ht_greenfield_support = true,

	.use_rts_for_aggregation = true, /* use rts/cts protection */

};



static struct iwl_bt_params iwl2030_bt_params = {

	.bt_statistics = true,

	/* Due to bluetooth, we transmit 2.4 GHz probes only on antenna A */

	.advanced_bt_coexist = true,

	.agg_time_limit = BT_AGG_THRESHOLD_DEF,

	.bt_init_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_NONE,

	.bt_prio_boost = IWLAGN_BT_PRIO_BOOST_DEFAULT,

	.bt_sco_disable = true,

};



#define IWL_DEVICE_2000						\

	.fw_name_pre = IWL2000_FW_PRE,				\

	.ucode_api_max = IWL2000_UCODE_API_MAX,			\

	.ucode_api_min = IWL2000_UCODE_API_MIN,			\

	.eeprom_ver = EEPROM_2000_EEPROM_VERSION,		\

	.eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,	\

	.ops = &iwl2000_ops,					\

	.mod_params = &iwlagn_mod_params,			\

	.base_params = &iwl2000_base_params,			\

	.need_dc_calib = true,					\

	.need_temp_offset_calib = true,				\

	.led_mode = IWL_LED_RF_STATE				\



struct iwl_cfg iwl2000_2bgn_cfg = {

	.name = "2000 Series 2x2 BGN",

	IWL_DEVICE_2000,

	.ht_params = &iwl2000_ht_params,

};



struct iwl_cfg iwl2000_2bg_cfg = {

	.name = "2000 Series 2x2 BG",

	IWL_DEVICE_2000,

};



#define IWL_DEVICE_2030						\

	.fw_name_pre = IWL2030_FW_PRE,				\

	.ucode_api_max = IWL2030_UCODE_API_MAX,			\

	.ucode_api_min = IWL2030_UCODE_API_MIN,			\

	.eeprom_ver = EEPROM_2000_EEPROM_VERSION,		\

	.eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,	\

	.ops = &iwl2030_ops,					\

	.mod_params = &iwlagn_mod_params,			\

	.base_params = &iwl2030_base_params,			\

	.bt_params = &iwl2030_bt_params,			\

	.need_dc_calib = true,					\

	.need_temp_offset_calib = true,				\

	.led_mode = IWL_LED_RF_STATE,				\

	.adv_pm = true						\



struct iwl_cfg iwl2030_2bgn_cfg = {

	.name = "2000 Series 2x2 BGN/BT",

	IWL_DEVICE_2000,

	.ht_params = &iwl2000_ht_params,

};



struct iwl_cfg iwl2030_2bg_cfg = {

	.name = "2000 Series 2x2 BG/BT",

	IWL_DEVICE_2000,

};



#define IWL_DEVICE_6035						\

	.fw_name_pre = IWL2030_FW_PRE,				\

	.ucode_api_max = IWL2030_UCODE_API_MAX,			\

	.ucode_api_min = IWL2030_UCODE_API_MIN,			\

	.eeprom_ver = EEPROM_6035_EEPROM_VERSION,		\

	.eeprom_calib_ver = EEPROM_6035_TX_POWER_VERSION,	\

	.ops = &iwl2030_ops,					\

	.mod_params = &iwlagn_mod_params,			\

	.base_params = &iwl2030_base_params,			\

	.bt_params = &iwl2030_bt_params,			\

	.need_dc_calib = true,					\

	.need_temp_offset_calib = true,				\

	.led_mode = IWL_LED_RF_STATE,				\

	.adv_pm = true						\



struct iwl_cfg iwl6035_2agn_cfg = {

	.name = "2000 Series 2x2 AGN/BT",

	IWL_DEVICE_6035,

	.ht_params = &iwl2000_ht_params,

};



struct iwl_cfg iwl6035_2abg_cfg = {

	.name = "2000 Series 2x2 ABG/BT",

	IWL_DEVICE_6035,

};



struct iwl_cfg iwl6035_2bg_cfg = {

	.name = "2000 Series 2x2 BG/BT",

	IWL_DEVICE_6035,

};



#define IWL_DEVICE_200						\

	.fw_name_pre = IWL200_FW_PRE,				\

	.ucode_api_max = IWL200_UCODE_API_MAX,			\

	.ucode_api_min = IWL200_UCODE_API_MIN,			\

	.eeprom_ver = EEPROM_2000_EEPROM_VERSION,		\

	.eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,	\

	.ops = &iwl200_ops,					\

	.mod_params = &iwlagn_mod_params,			\

	.base_params = &iwl2000_base_params,			\

	.need_dc_calib = true,					\

	.need_temp_offset_calib = true,				\

	.led_mode = IWL_LED_RF_STATE,				\

	.adv_pm = true,						\

	.rx_with_siso_diversity = true				\



struct iwl_cfg iwl200_bg_cfg = {

	.name = "200 Series 1x1 BG",

	IWL_DEVICE_200,

};



struct iwl_cfg iwl200_bgn_cfg = {

	.name = "200 Series 1x1 BGN",

	IWL_DEVICE_200,

	.ht_params = &iwl2000_ht_params,

};



#define IWL_DEVICE_230						\

	.fw_name_pre = IWL200_FW_PRE,				\

	.ucode_api_max = IWL200_UCODE_API_MAX,			\

	.ucode_api_min = IWL200_UCODE_API_MIN,			\

	.eeprom_ver = EEPROM_2000_EEPROM_VERSION,		\

	.eeprom_calib_ver = EEPROM_2000_TX_POWER_VERSION,	\

	.ops = &iwl230_ops,					\

	.mod_params = &iwlagn_mod_params,			\

	.base_params = &iwl2030_base_params,			\

	.bt_params = &iwl2030_bt_params,			\

	.need_dc_calib = true,					\

	.need_temp_offset_calib = true,				\

	.led_mode = IWL_LED_RF_STATE,				\

	.adv_pm = true,						\

	.rx_with_siso_diversity = true				\



struct iwl_cfg iwl230_bg_cfg = {

	.name = "200 Series 1x1 BG/BT",

	IWL_DEVICE_230,

};



struct iwl_cfg iwl230_bgn_cfg = {

	.name = "200 Series 1x1 BGN/BT",

	IWL_DEVICE_230,

	.ht_params = &iwl2000_ht_params,

};



MODULE_FIRMWARE(IWL2000_MODULE_FIRMWARE(IWL2000_UCODE_API_MAX));

MODULE_FIRMWARE(IWL2030_MODULE_FIRMWARE(IWL2030_UCODE_API_MAX));

MODULE_FIRMWARE(IWL200_MODULE_FIRMWARE(IWL200_UCODE_API_MAX));

drivers/net/wireless/iwlwifi/iwl-3945-led.c

+0 −27
Original line number Diff line number Diff line
@@ -59,33 +59,6 @@ static int iwl3945_send_led_cmd(struct iwl_priv *priv, 
	return iwl_send_cmd(priv, &cmd);

}



/* Set led on command */

static int iwl3945_led_on(struct iwl_priv *priv)

{

	struct iwl_led_cmd led_cmd = {

		.id = IWL_LED_LINK,

		.on = IWL_LED_SOLID,

		.off = 0,

		.interval = IWL_DEF_LED_INTRVL

	};

	return iwl3945_send_led_cmd(priv, &led_cmd);

}



/* Set led off command */

static int iwl3945_led_off(struct iwl_priv *priv)

{

	struct iwl_led_cmd led_cmd = {

		.id = IWL_LED_LINK,

		.on = 0,

		.off = 0,

		.interval = IWL_DEF_LED_INTRVL

	};

	IWL_DEBUG_LED(priv, "led off\n");

	return iwl3945_send_led_cmd(priv, &led_cmd);

}



const struct iwl_led_ops iwl3945_led_ops = {

	.cmd = iwl3945_send_led_cmd,

	.on = iwl3945_led_on,

	.off = iwl3945_led_off,

};