[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-6000.c

/******************************************************************************
 *
 * Copyright(c) 2008 - 2012 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/delay.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <net/mac80211.h>
#include <linux/etherdevice.h>
#include <asm/unaligned.h>
#include <linux/stringify.h>

#include "iwl-eeprom.h"
#include "iwl-dev.h"
#include "iwl-core.h"
#include "iwl-io.h"
#include "iwl-agn.h"
#include "iwl-agn-hw.h"
#include "iwl-trans.h"
#include "iwl-shared.h"
#include "iwl-cfg.h"

/* Highest firmware API version supported */
#define IWL6000_UCODE_API_MAX 6
#define IWL6050_UCODE_API_MAX 5
#define IWL6000G2_UCODE_API_MAX 6

/* Oldest version we won't warn about */
#define IWL6000_UCODE_API_OK 4
#define IWL6000G2_UCODE_API_OK 5

/* Lowest firmware API version supported */
#define IWL6000_UCODE_API_MIN 4
#define IWL6050_UCODE_API_MIN 4
#define IWL6000G2_UCODE_API_MIN 4

#define IWL6000_FW_PRE "iwlwifi-6000-"
#define IWL6000_MODULE_FIRMWARE(api) IWL6000_FW_PRE __stringify(api) ".ucode"

#define IWL6050_FW_PRE "iwlwifi-6050-"
#define IWL6050_MODULE_FIRMWARE(api) IWL6050_FW_PRE __stringify(api) ".ucode"

#define IWL6005_FW_PRE "iwlwifi-6000g2a-"
#define IWL6005_MODULE_FIRMWARE(api) IWL6005_FW_PRE __stringify(api) ".ucode"

#define IWL6030_FW_PRE "iwlwifi-6000g2b-"
#define IWL6030_MODULE_FIRMWARE(api) IWL6030_FW_PRE __stringify(api) ".ucode"

static void iwl6000_set_ct_threshold(struct iwl_priv *priv)
{
	/* want Celsius */
	hw_params(priv).ct_kill_threshold = CT_KILL_THRESHOLD;
	hw_params(priv).ct_kill_exit_threshold = CT_KILL_EXIT_THRESHOLD;
}

static void iwl6050_additional_nic_config(struct iwl_priv *priv)
{
	/* Indicate calibration version to uCode. */
	if (iwl_eeprom_calib_version(priv->shrd) >= 6)
		iwl_set_bit(trans(priv), CSR_GP_DRIVER_REG,
				CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
}

static void iwl6150_additional_nic_config(struct iwl_priv *priv)
{
	/* Indicate calibration version to uCode. */
	if (iwl_eeprom_calib_version(priv->shrd) >= 6)
		iwl_set_bit(trans(priv), CSR_GP_DRIVER_REG,
				CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
	iwl_set_bit(trans(priv), CSR_GP_DRIVER_REG,
		    CSR_GP_DRIVER_REG_BIT_6050_1x2);
}

static void iwl6000i_additional_nic_config(struct iwl_priv *priv)
{
	/* 2x2 IPA phy type */
	iwl_write32(trans(priv), CSR_GP_DRIVER_REG,
		     CSR_GP_DRIVER_REG_BIT_RADIO_SKU_2x2_IPA);
}

/* NIC configuration for 6000 series */
static void iwl6000_nic_config(struct iwl_priv *priv)
{
	iwl_rf_config(priv);

	/* do additional nic configuration if needed */
	if (cfg(priv)->additional_nic_config)
		cfg(priv)->additional_nic_config(priv);
}

static const struct iwl_sensitivity_ranges iwl6000_sensitivity = {
	.min_nrg_cck = 110,
	.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 = 110,
	.nrg_th_ofdm = 110,

	.barker_corr_th_min = 190,
	.barker_corr_th_min_mrc = 336,
	.nrg_th_cca = 62,
};

static void iwl6000_hw_set_hw_params(struct iwl_priv *priv)
{
	hw_params(priv).ht40_channel =  BIT(IEEE80211_BAND_2GHZ) |
					BIT(IEEE80211_BAND_5GHZ);

	hw_params(priv).tx_chains_num =
		num_of_ant(hw_params(priv).valid_tx_ant);
	if (cfg(priv)->rx_with_siso_diversity)
		hw_params(priv).rx_chains_num = 1;
	else
		hw_params(priv).rx_chains_num =
			num_of_ant(hw_params(priv).valid_rx_ant);

	iwl6000_set_ct_threshold(priv);

	/* Set initial sensitivity parameters */
	hw_params(priv).sens = &iwl6000_sensitivity;

}

static int iwl6000_hw_channel_switch(struct iwl_priv *priv,
				     struct ieee80211_channel_switch *ch_switch)
{
	/*
	 * MULTI-FIXME
	 * See iwlagn_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;
	}

	return iwl_dvm_send_cmd(priv, &hcmd);
}

static struct iwl_lib_ops iwl6000_lib = {
	.set_hw_params = iwl6000_hw_set_hw_params,
	.set_channel_switch = iwl6000_hw_channel_switch,
	.nic_config = iwl6000_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
		},
		.enhanced_txpower = true,
	},
	.temperature = iwlagn_temperature,
};

static struct iwl_lib_ops iwl6030_lib = {
	.set_hw_params = iwl6000_hw_set_hw_params,
	.set_channel_switch = iwl6000_hw_channel_switch,
	.nic_config = iwl6000_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
		},
		.enhanced_txpower = true,
	},
	.temperature = iwlagn_temperature,
};

static const struct iwl_base_params iwl6000_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,
	.max_ll_items = OTP_MAX_LL_ITEMS_6x00,
	.shadow_ram_support = true,
	.led_compensation = 51,
	.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,
	.shadow_reg_enable = true,
};

static const struct iwl_base_params iwl6050_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,
	.max_ll_items = OTP_MAX_LL_ITEMS_6x50,
	.shadow_ram_support = true,
	.led_compensation = 51,
	.adv_thermal_throttle = true,
	.support_ct_kill_exit = true,
	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
	.chain_noise_scale = 1500,
	.wd_timeout = IWL_DEF_WD_TIMEOUT,
	.max_event_log_size = 1024,
	.shadow_reg_enable = true,
};

static const struct iwl_base_params iwl6000_g2_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,
	.max_ll_items = OTP_MAX_LL_ITEMS_6x00,
	.shadow_ram_support = true,
	.led_compensation = 57,
	.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,
	.shadow_reg_enable = true,
};

static const struct iwl_ht_params iwl6000_ht_params = {
	.ht_greenfield_support = true,
	.use_rts_for_aggregation = true, /* use rts/cts protection */
};

static const struct iwl_bt_params iwl6000_bt_params = {
	/* 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_6005						\
	.fw_name_pre = IWL6005_FW_PRE,				\
	.ucode_api_max = IWL6000G2_UCODE_API_MAX,		\
	.ucode_api_ok = IWL6000G2_UCODE_API_OK,			\
	.ucode_api_min = IWL6000G2_UCODE_API_MIN,		\
	.max_inst_size = IWL60_RTC_INST_SIZE,			\
	.max_data_size = IWL60_RTC_DATA_SIZE,			\
	.eeprom_ver = EEPROM_6005_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6005_TX_POWER_VERSION,	\
	.lib = &iwl6000_lib,					\
	.base_params = &iwl6000_g2_base_params,			\
	.need_temp_offset_calib = true,				\
	.led_mode = IWL_LED_RF_STATE

const struct iwl_cfg iwl6005_2agn_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6205 AGN",
	IWL_DEVICE_6005,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6005_2abg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6205 ABG",
	IWL_DEVICE_6005,
};

const struct iwl_cfg iwl6005_2bg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6205 BG",
	IWL_DEVICE_6005,
};

const struct iwl_cfg iwl6005_2agn_sff_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6205S AGN",
	IWL_DEVICE_6005,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6005_2agn_d_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6205D AGN",
	IWL_DEVICE_6005,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6005_2agn_mow1_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6206 AGN",
	IWL_DEVICE_6005,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6005_2agn_mow2_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6207 AGN",
	IWL_DEVICE_6005,
	.ht_params = &iwl6000_ht_params,
};

#define IWL_DEVICE_6030						\
	.fw_name_pre = IWL6030_FW_PRE,				\
	.ucode_api_max = IWL6000G2_UCODE_API_MAX,		\
	.ucode_api_ok = IWL6000G2_UCODE_API_OK,			\
	.ucode_api_min = IWL6000G2_UCODE_API_MIN,		\
	.max_inst_size = IWL60_RTC_INST_SIZE,			\
	.max_data_size = IWL60_RTC_DATA_SIZE,			\
	.eeprom_ver = EEPROM_6030_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6030_TX_POWER_VERSION,	\
	.lib = &iwl6030_lib,					\
	.base_params = &iwl6000_g2_base_params,			\
	.bt_params = &iwl6000_bt_params,			\
	.need_temp_offset_calib = true,				\
	.led_mode = IWL_LED_RF_STATE,				\
	.adv_pm = true						\

const struct iwl_cfg iwl6030_2agn_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6230 AGN",
	IWL_DEVICE_6030,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6030_2abg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6230 ABG",
	IWL_DEVICE_6030,
};

const struct iwl_cfg iwl6030_2bgn_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6230 BGN",
	IWL_DEVICE_6030,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6030_2bg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6230 BG",
	IWL_DEVICE_6030,
};

const struct iwl_cfg iwl6035_2agn_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6235 AGN",
	IWL_DEVICE_6030,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl1030_bgn_cfg = {
	.name = "Intel(R) Centrino(R) Wireless-N 1030 BGN",
	IWL_DEVICE_6030,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl1030_bg_cfg = {
	.name = "Intel(R) Centrino(R) Wireless-N 1030 BG",
	IWL_DEVICE_6030,
};

const struct iwl_cfg iwl130_bgn_cfg = {
	.name = "Intel(R) Centrino(R) Wireless-N 130 BGN",
	IWL_DEVICE_6030,
	.ht_params = &iwl6000_ht_params,
	.rx_with_siso_diversity = true,
};

const struct iwl_cfg iwl130_bg_cfg = {
	.name = "Intel(R) Centrino(R) Wireless-N 130 BG",
	IWL_DEVICE_6030,
	.rx_with_siso_diversity = true,
};

/*
 * "i": Internal configuration, use internal Power Amplifier
 */
#define IWL_DEVICE_6000i					\
	.fw_name_pre = IWL6000_FW_PRE,				\
	.ucode_api_max = IWL6000_UCODE_API_MAX,			\
	.ucode_api_ok = IWL6000_UCODE_API_OK,			\
	.ucode_api_min = IWL6000_UCODE_API_MIN,			\
	.max_inst_size = IWL60_RTC_INST_SIZE,			\
	.max_data_size = IWL60_RTC_DATA_SIZE,			\
	.valid_tx_ant = ANT_BC,		/* .cfg overwrite */	\
	.valid_rx_ant = ANT_BC,		/* .cfg overwrite */	\
	.eeprom_ver = EEPROM_6000_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,	\
	.lib = &iwl6000_lib,					\
	.additional_nic_config = iwl6000i_additional_nic_config,\
	.base_params = &iwl6000_base_params,			\
	.led_mode = IWL_LED_BLINK

const struct iwl_cfg iwl6000i_2agn_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6200 AGN",
	IWL_DEVICE_6000i,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6000i_2abg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6200 ABG",
	IWL_DEVICE_6000i,
};

const struct iwl_cfg iwl6000i_2bg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N 6200 BG",
	IWL_DEVICE_6000i,
};

#define IWL_DEVICE_6050						\
	.fw_name_pre = IWL6050_FW_PRE,				\
	.ucode_api_max = IWL6050_UCODE_API_MAX,			\
	.ucode_api_min = IWL6050_UCODE_API_MIN,			\
	.max_inst_size = IWL60_RTC_INST_SIZE,			\
	.max_data_size = IWL60_RTC_DATA_SIZE,			\
	.valid_tx_ant = ANT_AB,		/* .cfg overwrite */	\
	.valid_rx_ant = ANT_AB,		/* .cfg overwrite */	\
	.lib = &iwl6000_lib,					\
	.additional_nic_config = iwl6050_additional_nic_config,	\
	.eeprom_ver = EEPROM_6050_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION,	\
	.base_params = &iwl6050_base_params,			\
	.led_mode = IWL_LED_BLINK,				\
	.internal_wimax_coex = true

const struct iwl_cfg iwl6050_2agn_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N + WiMAX 6250 AGN",
	IWL_DEVICE_6050,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6050_2abg_cfg = {
	.name = "Intel(R) Centrino(R) Advanced-N + WiMAX 6250 ABG",
	IWL_DEVICE_6050,
};

#define IWL_DEVICE_6150						\
	.fw_name_pre = IWL6050_FW_PRE,				\
	.ucode_api_max = IWL6050_UCODE_API_MAX,			\
	.ucode_api_min = IWL6050_UCODE_API_MIN,			\
	.max_inst_size = IWL60_RTC_INST_SIZE,			\
	.max_data_size = IWL60_RTC_DATA_SIZE,			\
	.lib = &iwl6000_lib,					\
	.additional_nic_config = iwl6150_additional_nic_config,	\
	.eeprom_ver = EEPROM_6150_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION,	\
	.base_params = &iwl6050_base_params,			\
	.led_mode = IWL_LED_BLINK,				\
	.internal_wimax_coex = true

const struct iwl_cfg iwl6150_bgn_cfg = {
	.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BGN",
	IWL_DEVICE_6150,
	.ht_params = &iwl6000_ht_params,
};

const struct iwl_cfg iwl6150_bg_cfg = {
	.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BG",
	IWL_DEVICE_6150,
};

const struct iwl_cfg iwl6000_3agn_cfg = {
	.name = "Intel(R) Centrino(R) Ultimate-N 6300 AGN",
	.fw_name_pre = IWL6000_FW_PRE,
	.ucode_api_max = IWL6000_UCODE_API_MAX,
	.ucode_api_ok = IWL6000_UCODE_API_OK,
	.ucode_api_min = IWL6000_UCODE_API_MIN,
	.max_inst_size = IWL60_RTC_INST_SIZE,
	.max_data_size = IWL60_RTC_DATA_SIZE,
	.eeprom_ver = EEPROM_6000_EEPROM_VERSION,
	.eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,
	.lib = &iwl6000_lib,
	.base_params = &iwl6000_base_params,
	.ht_params = &iwl6000_ht_params,
	.led_mode = IWL_LED_BLINK,
};

MODULE_FIRMWARE(IWL6000_MODULE_FIRMWARE(IWL6000_UCODE_API_OK));
MODULE_FIRMWARE(IWL6050_MODULE_FIRMWARE(IWL6050_UCODE_API_MAX));
MODULE_FIRMWARE(IWL6005_MODULE_FIRMWARE(IWL6000G2_UCODE_API_MAX));
MODULE_FIRMWARE(IWL6030_MODULE_FIRMWARE(IWL6000G2_UCODE_API_MAX));
Commit	Line	Data
	1	/******************************************************************************
	2	*
	3	* Copyright(c) 2008 - 2012 Intel Corporation. All rights reserved.
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of version 2 of the GNU General Public License as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program; if not, write to the Free Software Foundation, Inc.,
	16	* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
	17	*
	18	* The full GNU General Public License is included in this distribution in the
	19	* file called LICENSE.
	20	*
	21	* Contact Information:
	22	* Intel Linux Wireless <ilw@linux.intel.com>
	23	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
	24	*
	25	*****************************************************************************/
	26
	27	#include <linux/kernel.h>
	28	#include <linux/module.h>
	29	#include <linux/init.h>
	30	#include <linux/delay.h>
	31	#include <linux/skbuff.h>
	32	#include <linux/netdevice.h>
	33	#include <net/mac80211.h>
	34	#include <linux/etherdevice.h>
	35	#include <asm/unaligned.h>
	36	#include <linux/stringify.h>
	37
	38	#include "iwl-eeprom.h"
	39	#include "iwl-dev.h"
	40	#include "iwl-core.h"
	41	#include "iwl-io.h"
	42	#include "iwl-agn.h"
	43	#include "iwl-agn-hw.h"
	44	#include "iwl-trans.h"
	45	#include "iwl-shared.h"
	46	#include "iwl-cfg.h"
	47
	48	/* Highest firmware API version supported */
	49	#define IWL6000_UCODE_API_MAX 6
	50	#define IWL6050_UCODE_API_MAX 5
	51	#define IWL6000G2_UCODE_API_MAX 6
	52
	53	/* Oldest version we won't warn about */
	54	#define IWL6000_UCODE_API_OK 4
	55	#define IWL6000G2_UCODE_API_OK 5
	56
	57	/* Lowest firmware API version supported */
	58	#define IWL6000_UCODE_API_MIN 4
	59	#define IWL6050_UCODE_API_MIN 4
	60	#define IWL6000G2_UCODE_API_MIN 4
	61
	62	#define IWL6000_FW_PRE "iwlwifi-6000-"
	63	#define IWL6000_MODULE_FIRMWARE(api) IWL6000_FW_PRE __stringify(api) ".ucode"
	64
	65	#define IWL6050_FW_PRE "iwlwifi-6050-"
	66	#define IWL6050_MODULE_FIRMWARE(api) IWL6050_FW_PRE __stringify(api) ".ucode"
	67
	68	#define IWL6005_FW_PRE "iwlwifi-6000g2a-"
	69	#define IWL6005_MODULE_FIRMWARE(api) IWL6005_FW_PRE __stringify(api) ".ucode"
	70
	71	#define IWL6030_FW_PRE "iwlwifi-6000g2b-"
	72	#define IWL6030_MODULE_FIRMWARE(api) IWL6030_FW_PRE __stringify(api) ".ucode"
	73
	74	static void iwl6000_set_ct_threshold(struct iwl_priv *priv)
	75	{
	76	/* want Celsius */
	77	hw_params(priv).ct_kill_threshold = CT_KILL_THRESHOLD;
	78	hw_params(priv).ct_kill_exit_threshold = CT_KILL_EXIT_THRESHOLD;
	79	}
	80
	81	static void iwl6050_additional_nic_config(struct iwl_priv *priv)
	82	{
	83	/* Indicate calibration version to uCode. */
	84	if (iwl_eeprom_calib_version(priv->shrd) >= 6)
	85	iwl_set_bit(trans(priv), CSR_GP_DRIVER_REG,
	86	CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
	87	}
	88
	89	static void iwl6150_additional_nic_config(struct iwl_priv *priv)
	90	{
	91	/* Indicate calibration version to uCode. */
	92	if (iwl_eeprom_calib_version(priv->shrd) >= 6)
	93	iwl_set_bit(trans(priv), CSR_GP_DRIVER_REG,
	94	CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
	95	iwl_set_bit(trans(priv), CSR_GP_DRIVER_REG,
	96	CSR_GP_DRIVER_REG_BIT_6050_1x2);
	97	}
	98
	99	static void iwl6000i_additional_nic_config(struct iwl_priv *priv)
	100	{
	101	/* 2x2 IPA phy type */
	102	iwl_write32(trans(priv), CSR_GP_DRIVER_REG,
	103	CSR_GP_DRIVER_REG_BIT_RADIO_SKU_2x2_IPA);
	104	}
	105
	106	/* NIC configuration for 6000 series */
	107	static void iwl6000_nic_config(struct iwl_priv *priv)
	108	{
	109	iwl_rf_config(priv);
	110
	111	/* do additional nic configuration if needed */
	112	if (cfg(priv)->additional_nic_config)
	113	cfg(priv)->additional_nic_config(priv);
	114	}
	115
	116	static const struct iwl_sensitivity_ranges iwl6000_sensitivity = {
	117	.min_nrg_cck = 110,
	118	.auto_corr_min_ofdm = 80,
	119	.auto_corr_min_ofdm_mrc = 128,
	120	.auto_corr_min_ofdm_x1 = 105,
	121	.auto_corr_min_ofdm_mrc_x1 = 192,
	122
	123	.auto_corr_max_ofdm = 145,
	124	.auto_corr_max_ofdm_mrc = 232,
	125	.auto_corr_max_ofdm_x1 = 110,
	126	.auto_corr_max_ofdm_mrc_x1 = 232,
	127
	128	.auto_corr_min_cck = 125,
	129	.auto_corr_max_cck = 175,
	130	.auto_corr_min_cck_mrc = 160,
	131	.auto_corr_max_cck_mrc = 310,
	132	.nrg_th_cck = 110,
	133	.nrg_th_ofdm = 110,
	134
	135	.barker_corr_th_min = 190,
	136	.barker_corr_th_min_mrc = 336,
	137	.nrg_th_cca = 62,
	138	};
	139
	140	static void iwl6000_hw_set_hw_params(struct iwl_priv *priv)
	141	{
	142	hw_params(priv).ht40_channel = BIT(IEEE80211_BAND_2GHZ) \|
	143	BIT(IEEE80211_BAND_5GHZ);
	144
	145	hw_params(priv).tx_chains_num =
	146	num_of_ant(hw_params(priv).valid_tx_ant);
	147	if (cfg(priv)->rx_with_siso_diversity)
	148	hw_params(priv).rx_chains_num = 1;
	149	else
	150	hw_params(priv).rx_chains_num =
	151	num_of_ant(hw_params(priv).valid_rx_ant);
	152
	153	iwl6000_set_ct_threshold(priv);
	154
	155	/* Set initial sensitivity parameters */
	156	hw_params(priv).sens = &iwl6000_sensitivity;
	157
	158	}
	159
	160	static int iwl6000_hw_channel_switch(struct iwl_priv *priv,
	161	struct ieee80211_channel_switch *ch_switch)
	162	{
	163	/*
	164	* MULTI-FIXME
	165	* See iwlagn_mac_channel_switch.
	166	*/
	167	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
	168	struct iwl6000_channel_switch_cmd cmd;
	169	const struct iwl_channel_info *ch_info;
	170	u32 switch_time_in_usec, ucode_switch_time;
	171	u16 ch;
	172	u32 tsf_low;
	173	u8 switch_count;
	174	u16 beacon_interval = le16_to_cpu(ctx->timing.beacon_interval);
	175	struct ieee80211_vif *vif = ctx->vif;
	176	struct iwl_host_cmd hcmd = {
	177	.id = REPLY_CHANNEL_SWITCH,
	178	.len = { sizeof(cmd), },
	179	.flags = CMD_SYNC,
	180	.data = { &cmd, },
	181	};
	182
	183	cmd.band = priv->band == IEEE80211_BAND_2GHZ;
	184	ch = ch_switch->channel->hw_value;
	185	IWL_DEBUG_11H(priv, "channel switch from %u to %u\n",
	186	ctx->active.channel, ch);
	187	cmd.channel = cpu_to_le16(ch);
	188	cmd.rxon_flags = ctx->staging.flags;
	189	cmd.rxon_filter_flags = ctx->staging.filter_flags;
	190	switch_count = ch_switch->count;
	191	tsf_low = ch_switch->timestamp & 0x0ffffffff;
	192	/*
	193	* calculate the ucode channel switch time
	194	* adding TSF as one of the factor for when to switch
	195	*/
	196	if ((priv->ucode_beacon_time > tsf_low) && beacon_interval) {
	197	if (switch_count > ((priv->ucode_beacon_time - tsf_low) /
	198	beacon_interval)) {
	199	switch_count -= (priv->ucode_beacon_time -
	200	tsf_low) / beacon_interval;
	201	} else
	202	switch_count = 0;
	203	}
	204	if (switch_count <= 1)
	205	cmd.switch_time = cpu_to_le32(priv->ucode_beacon_time);
	206	else {
	207	switch_time_in_usec =
	208	vif->bss_conf.beacon_int * switch_count * TIME_UNIT;
	209	ucode_switch_time = iwl_usecs_to_beacons(priv,
	210	switch_time_in_usec,
	211	beacon_interval);
	212	cmd.switch_time = iwl_add_beacon_time(priv,
	213	priv->ucode_beacon_time,
	214	ucode_switch_time,
	215	beacon_interval);
	216	}
	217	IWL_DEBUG_11H(priv, "uCode time for the switch is 0x%x\n",
	218	cmd.switch_time);
	219	ch_info = iwl_get_channel_info(priv, priv->band, ch);
	220	if (ch_info)
	221	cmd.expect_beacon = is_channel_radar(ch_info);
	222	else {
	223	IWL_ERR(priv, "invalid channel switch from %u to %u\n",
	224	ctx->active.channel, ch);
	225	return -EFAULT;
	226	}
	227
	228	return iwl_dvm_send_cmd(priv, &hcmd);
	229	}
	230
	231	static struct iwl_lib_ops iwl6000_lib = {
	232	.set_hw_params = iwl6000_hw_set_hw_params,
	233	.set_channel_switch = iwl6000_hw_channel_switch,
	234	.nic_config = iwl6000_nic_config,
	235	.eeprom_ops = {
	236	.regulatory_bands = {
	237	EEPROM_REG_BAND_1_CHANNELS,
	238	EEPROM_REG_BAND_2_CHANNELS,
	239	EEPROM_REG_BAND_3_CHANNELS,
	240	EEPROM_REG_BAND_4_CHANNELS,
	241	EEPROM_REG_BAND_5_CHANNELS,
	242	EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
	243	EEPROM_REG_BAND_52_HT40_CHANNELS
	244	},
	245	.enhanced_txpower = true,
	246	},
	247	.temperature = iwlagn_temperature,
	248	};
	249
	250	static struct iwl_lib_ops iwl6030_lib = {
	251	.set_hw_params = iwl6000_hw_set_hw_params,
	252	.set_channel_switch = iwl6000_hw_channel_switch,
	253	.nic_config = iwl6000_nic_config,
	254	.eeprom_ops = {
	255	.regulatory_bands = {
	256	EEPROM_REG_BAND_1_CHANNELS,
	257	EEPROM_REG_BAND_2_CHANNELS,
	258	EEPROM_REG_BAND_3_CHANNELS,
	259	EEPROM_REG_BAND_4_CHANNELS,
	260	EEPROM_REG_BAND_5_CHANNELS,
	261	EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
	262	EEPROM_REG_BAND_52_HT40_CHANNELS
	263	},
	264	.enhanced_txpower = true,
	265	},
	266	.temperature = iwlagn_temperature,
	267	};
	268
	269	static const struct iwl_base_params iwl6000_base_params = {
	270	.eeprom_size = OTP_LOW_IMAGE_SIZE,
	271	.num_of_queues = IWLAGN_NUM_QUEUES,
	272	.num_of_ampdu_queues = IWLAGN_NUM_AMPDU_QUEUES,
	273	.pll_cfg_val = 0,
	274	.max_ll_items = OTP_MAX_LL_ITEMS_6x00,
	275	.shadow_ram_support = true,
	276	.led_compensation = 51,
	277	.adv_thermal_throttle = true,
	278	.support_ct_kill_exit = true,
	279	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
	280	.chain_noise_scale = 1000,
	281	.wd_timeout = IWL_DEF_WD_TIMEOUT,
	282	.max_event_log_size = 512,
	283	.shadow_reg_enable = true,
	284	};
	285
	286	static const struct iwl_base_params iwl6050_base_params = {
	287	.eeprom_size = OTP_LOW_IMAGE_SIZE,
	288	.num_of_queues = IWLAGN_NUM_QUEUES,
	289	.num_of_ampdu_queues = IWLAGN_NUM_AMPDU_QUEUES,
	290	.pll_cfg_val = 0,
	291	.max_ll_items = OTP_MAX_LL_ITEMS_6x50,
	292	.shadow_ram_support = true,
	293	.led_compensation = 51,
	294	.adv_thermal_throttle = true,
	295	.support_ct_kill_exit = true,
	296	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
	297	.chain_noise_scale = 1500,
	298	.wd_timeout = IWL_DEF_WD_TIMEOUT,
	299	.max_event_log_size = 1024,
	300	.shadow_reg_enable = true,
	301	};
	302
	303	static const struct iwl_base_params iwl6000_g2_base_params = {
	304	.eeprom_size = OTP_LOW_IMAGE_SIZE,
	305	.num_of_queues = IWLAGN_NUM_QUEUES,
	306	.num_of_ampdu_queues = IWLAGN_NUM_AMPDU_QUEUES,
	307	.pll_cfg_val = 0,
	308	.max_ll_items = OTP_MAX_LL_ITEMS_6x00,
	309	.shadow_ram_support = true,
	310	.led_compensation = 57,
	311	.adv_thermal_throttle = true,
	312	.support_ct_kill_exit = true,
	313	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
	314	.chain_noise_scale = 1000,
	315	.wd_timeout = IWL_LONG_WD_TIMEOUT,
	316	.max_event_log_size = 512,
	317	.shadow_reg_enable = true,
	318	};
	319
	320	static const struct iwl_ht_params iwl6000_ht_params = {
	321	.ht_greenfield_support = true,
	322	.use_rts_for_aggregation = true, /* use rts/cts protection */
	323	};
	324
	325	static const struct iwl_bt_params iwl6000_bt_params = {
	326	/* Due to bluetooth, we transmit 2.4 GHz probes only on antenna A */
	327	.advanced_bt_coexist = true,
	328	.agg_time_limit = BT_AGG_THRESHOLD_DEF,
	329	.bt_init_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_NONE,
	330	.bt_prio_boost = IWLAGN_BT_PRIO_BOOST_DEFAULT,
	331	.bt_sco_disable = true,
	332	};
	333
	334	#define IWL_DEVICE_6005 \
	335	.fw_name_pre = IWL6005_FW_PRE, \
	336	.ucode_api_max = IWL6000G2_UCODE_API_MAX, \
	337	.ucode_api_ok = IWL6000G2_UCODE_API_OK, \
	338	.ucode_api_min = IWL6000G2_UCODE_API_MIN, \
	339	.max_inst_size = IWL60_RTC_INST_SIZE, \
	340	.max_data_size = IWL60_RTC_DATA_SIZE, \
	341	.eeprom_ver = EEPROM_6005_EEPROM_VERSION, \
	342	.eeprom_calib_ver = EEPROM_6005_TX_POWER_VERSION, \
	343	.lib = &iwl6000_lib, \
	344	.base_params = &iwl6000_g2_base_params, \
	345	.need_temp_offset_calib = true, \
	346	.led_mode = IWL_LED_RF_STATE
	347
	348	const struct iwl_cfg iwl6005_2agn_cfg = {
	349	.name = "Intel(R) Centrino(R) Advanced-N 6205 AGN",
	350	IWL_DEVICE_6005,
	351	.ht_params = &iwl6000_ht_params,
	352	};
	353
	354	const struct iwl_cfg iwl6005_2abg_cfg = {
	355	.name = "Intel(R) Centrino(R) Advanced-N 6205 ABG",
	356	IWL_DEVICE_6005,
	357	};
	358
	359	const struct iwl_cfg iwl6005_2bg_cfg = {
	360	.name = "Intel(R) Centrino(R) Advanced-N 6205 BG",
	361	IWL_DEVICE_6005,
	362	};
	363
	364	const struct iwl_cfg iwl6005_2agn_sff_cfg = {
	365	.name = "Intel(R) Centrino(R) Advanced-N 6205S AGN",
	366	IWL_DEVICE_6005,
	367	.ht_params = &iwl6000_ht_params,
	368	};
	369
	370	const struct iwl_cfg iwl6005_2agn_d_cfg = {
	371	.name = "Intel(R) Centrino(R) Advanced-N 6205D AGN",
	372	IWL_DEVICE_6005,
	373	.ht_params = &iwl6000_ht_params,
	374	};
	375
	376	const struct iwl_cfg iwl6005_2agn_mow1_cfg = {
	377	.name = "Intel(R) Centrino(R) Advanced-N 6206 AGN",
	378	IWL_DEVICE_6005,
	379	.ht_params = &iwl6000_ht_params,
	380	};
	381
	382	const struct iwl_cfg iwl6005_2agn_mow2_cfg = {
	383	.name = "Intel(R) Centrino(R) Advanced-N 6207 AGN",
	384	IWL_DEVICE_6005,
	385	.ht_params = &iwl6000_ht_params,
	386	};
	387
	388	#define IWL_DEVICE_6030 \
	389	.fw_name_pre = IWL6030_FW_PRE, \
	390	.ucode_api_max = IWL6000G2_UCODE_API_MAX, \
	391	.ucode_api_ok = IWL6000G2_UCODE_API_OK, \
	392	.ucode_api_min = IWL6000G2_UCODE_API_MIN, \
	393	.max_inst_size = IWL60_RTC_INST_SIZE, \
	394	.max_data_size = IWL60_RTC_DATA_SIZE, \
	395	.eeprom_ver = EEPROM_6030_EEPROM_VERSION, \
	396	.eeprom_calib_ver = EEPROM_6030_TX_POWER_VERSION, \
	397	.lib = &iwl6030_lib, \
	398	.base_params = &iwl6000_g2_base_params, \
	399	.bt_params = &iwl6000_bt_params, \
	400	.need_temp_offset_calib = true, \
	401	.led_mode = IWL_LED_RF_STATE, \
	402	.adv_pm = true \
	403
	404	const struct iwl_cfg iwl6030_2agn_cfg = {
	405	.name = "Intel(R) Centrino(R) Advanced-N 6230 AGN",
	406	IWL_DEVICE_6030,
	407	.ht_params = &iwl6000_ht_params,
	408	};
	409
	410	const struct iwl_cfg iwl6030_2abg_cfg = {
	411	.name = "Intel(R) Centrino(R) Advanced-N 6230 ABG",
	412	IWL_DEVICE_6030,
	413	};
	414
	415	const struct iwl_cfg iwl6030_2bgn_cfg = {
	416	.name = "Intel(R) Centrino(R) Advanced-N 6230 BGN",
	417	IWL_DEVICE_6030,
	418	.ht_params = &iwl6000_ht_params,
	419	};
	420
	421	const struct iwl_cfg iwl6030_2bg_cfg = {
	422	.name = "Intel(R) Centrino(R) Advanced-N 6230 BG",
	423	IWL_DEVICE_6030,
	424	};
	425
	426	const struct iwl_cfg iwl6035_2agn_cfg = {
	427	.name = "Intel(R) Centrino(R) Advanced-N 6235 AGN",
	428	IWL_DEVICE_6030,
	429	.ht_params = &iwl6000_ht_params,
	430	};
	431
	432	const struct iwl_cfg iwl1030_bgn_cfg = {
	433	.name = "Intel(R) Centrino(R) Wireless-N 1030 BGN",
	434	IWL_DEVICE_6030,
	435	.ht_params = &iwl6000_ht_params,
	436	};
	437
	438	const struct iwl_cfg iwl1030_bg_cfg = {
	439	.name = "Intel(R) Centrino(R) Wireless-N 1030 BG",
	440	IWL_DEVICE_6030,
	441	};
	442
	443	const struct iwl_cfg iwl130_bgn_cfg = {
	444	.name = "Intel(R) Centrino(R) Wireless-N 130 BGN",
	445	IWL_DEVICE_6030,
	446	.ht_params = &iwl6000_ht_params,
	447	.rx_with_siso_diversity = true,
	448	};
	449
	450	const struct iwl_cfg iwl130_bg_cfg = {
	451	.name = "Intel(R) Centrino(R) Wireless-N 130 BG",
	452	IWL_DEVICE_6030,
	453	.rx_with_siso_diversity = true,
	454	};
	455
	456	/*
	457	* "i": Internal configuration, use internal Power Amplifier
	458	*/
	459	#define IWL_DEVICE_6000i \
	460	.fw_name_pre = IWL6000_FW_PRE, \
	461	.ucode_api_max = IWL6000_UCODE_API_MAX, \
	462	.ucode_api_ok = IWL6000_UCODE_API_OK, \
	463	.ucode_api_min = IWL6000_UCODE_API_MIN, \
	464	.max_inst_size = IWL60_RTC_INST_SIZE, \
	465	.max_data_size = IWL60_RTC_DATA_SIZE, \
	466	.valid_tx_ant = ANT_BC, /* .cfg overwrite */ \
	467	.valid_rx_ant = ANT_BC, /* .cfg overwrite */ \
	468	.eeprom_ver = EEPROM_6000_EEPROM_VERSION, \
	469	.eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION, \
	470	.lib = &iwl6000_lib, \
	471	.additional_nic_config = iwl6000i_additional_nic_config,\
	472	.base_params = &iwl6000_base_params, \
	473	.led_mode = IWL_LED_BLINK
	474
	475	const struct iwl_cfg iwl6000i_2agn_cfg = {
	476	.name = "Intel(R) Centrino(R) Advanced-N 6200 AGN",
	477	IWL_DEVICE_6000i,
	478	.ht_params = &iwl6000_ht_params,
	479	};
	480
	481	const struct iwl_cfg iwl6000i_2abg_cfg = {
	482	.name = "Intel(R) Centrino(R) Advanced-N 6200 ABG",
	483	IWL_DEVICE_6000i,
	484	};
	485
	486	const struct iwl_cfg iwl6000i_2bg_cfg = {
	487	.name = "Intel(R) Centrino(R) Advanced-N 6200 BG",
	488	IWL_DEVICE_6000i,
	489	};
	490
	491	#define IWL_DEVICE_6050 \
	492	.fw_name_pre = IWL6050_FW_PRE, \
	493	.ucode_api_max = IWL6050_UCODE_API_MAX, \
	494	.ucode_api_min = IWL6050_UCODE_API_MIN, \
	495	.max_inst_size = IWL60_RTC_INST_SIZE, \
	496	.max_data_size = IWL60_RTC_DATA_SIZE, \
	497	.valid_tx_ant = ANT_AB, /* .cfg overwrite */ \
	498	.valid_rx_ant = ANT_AB, /* .cfg overwrite */ \
	499	.lib = &iwl6000_lib, \
	500	.additional_nic_config = iwl6050_additional_nic_config, \
	501	.eeprom_ver = EEPROM_6050_EEPROM_VERSION, \
	502	.eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION, \
	503	.base_params = &iwl6050_base_params, \
	504	.led_mode = IWL_LED_BLINK, \
	505	.internal_wimax_coex = true
	506
	507	const struct iwl_cfg iwl6050_2agn_cfg = {
	508	.name = "Intel(R) Centrino(R) Advanced-N + WiMAX 6250 AGN",
	509	IWL_DEVICE_6050,
	510	.ht_params = &iwl6000_ht_params,
	511	};
	512
	513	const struct iwl_cfg iwl6050_2abg_cfg = {
	514	.name = "Intel(R) Centrino(R) Advanced-N + WiMAX 6250 ABG",
	515	IWL_DEVICE_6050,
	516	};
	517
	518	#define IWL_DEVICE_6150 \
	519	.fw_name_pre = IWL6050_FW_PRE, \
	520	.ucode_api_max = IWL6050_UCODE_API_MAX, \
	521	.ucode_api_min = IWL6050_UCODE_API_MIN, \
	522	.max_inst_size = IWL60_RTC_INST_SIZE, \
	523	.max_data_size = IWL60_RTC_DATA_SIZE, \
	524	.lib = &iwl6000_lib, \
	525	.additional_nic_config = iwl6150_additional_nic_config, \
	526	.eeprom_ver = EEPROM_6150_EEPROM_VERSION, \
	527	.eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION, \
	528	.base_params = &iwl6050_base_params, \
	529	.led_mode = IWL_LED_BLINK, \
	530	.internal_wimax_coex = true
	531
	532	const struct iwl_cfg iwl6150_bgn_cfg = {
	533	.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BGN",
	534	IWL_DEVICE_6150,
	535	.ht_params = &iwl6000_ht_params,
	536	};
	537
	538	const struct iwl_cfg iwl6150_bg_cfg = {
	539	.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BG",
	540	IWL_DEVICE_6150,
	541	};
	542
	543	const struct iwl_cfg iwl6000_3agn_cfg = {
	544	.name = "Intel(R) Centrino(R) Ultimate-N 6300 AGN",
	545	.fw_name_pre = IWL6000_FW_PRE,
	546	.ucode_api_max = IWL6000_UCODE_API_MAX,
	547	.ucode_api_ok = IWL6000_UCODE_API_OK,
	548	.ucode_api_min = IWL6000_UCODE_API_MIN,
	549	.max_inst_size = IWL60_RTC_INST_SIZE,
	550	.max_data_size = IWL60_RTC_DATA_SIZE,
	551	.eeprom_ver = EEPROM_6000_EEPROM_VERSION,
	552	.eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,
	553	.lib = &iwl6000_lib,
	554	.base_params = &iwl6000_base_params,
	555	.ht_params = &iwl6000_ht_params,
	556	.led_mode = IWL_LED_BLINK,
	557	};
	558
	559	MODULE_FIRMWARE(IWL6000_MODULE_FIRMWARE(IWL6000_UCODE_API_OK));
	560	MODULE_FIRMWARE(IWL6050_MODULE_FIRMWARE(IWL6050_UCODE_API_MAX));
	561	MODULE_FIRMWARE(IWL6005_MODULE_FIRMWARE(IWL6000G2_UCODE_API_MAX));
	562	MODULE_FIRMWARE(IWL6030_MODULE_FIRMWARE(IWL6000G2_UCODE_API_MAX));