iwl-6000.c 22.6 KB
Newer Older
1
2
/******************************************************************************
 *
Wey-Yi Guy's avatar
Wey-Yi Guy committed
3
 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 *
 * 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"
45
#include "iwl-agn.h"
46
#include "iwl-helpers.h"
47
#include "iwl-agn-hw.h"
48
#include "iwl-6000-hw.h"
Johannes Berg's avatar
Johannes Berg committed
49
#include "iwl-agn-led.h"
50
#include "iwl-agn-debugfs.h"
51
52

/* Highest firmware API version supported */
53
#define IWL6000_UCODE_API_MAX 4
54
#define IWL6050_UCODE_API_MAX 5
55
#define IWL6000G2_UCODE_API_MAX 5
56
57

/* Lowest firmware API version supported */
58
59
#define IWL6000_UCODE_API_MIN 4
#define IWL6050_UCODE_API_MIN 4
60
#define IWL6000G2_UCODE_API_MIN 4
61
62
63
64
65
66
67
68
69

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

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

70
71
72
#define IWL6005_FW_PRE "iwlwifi-6000g2a-"
#define _IWL6005_MODULE_FIRMWARE(api) IWL6005_FW_PRE #api ".ucode"
#define IWL6005_MODULE_FIRMWARE(api) _IWL6005_MODULE_FIRMWARE(api)
73

74
75
76
#define IWL6030_FW_PRE "iwlwifi-6000g2b-"
#define _IWL6030_MODULE_FIRMWARE(api) IWL6030_FW_PRE #api ".ucode"
#define IWL6030_MODULE_FIRMWARE(api) _IWL6030_MODULE_FIRMWARE(api)
77

78
79
80
81
82
83
84
static void iwl6000_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;
}

85
static void iwl6050_additional_nic_config(struct iwl_priv *priv)
86
{
87
88
	/* Indicate calibration version to uCode. */
	if (priv->cfg->ops->lib->eeprom_ops.calib_version(priv) >= 6)
89
90
91
92
		iwl_set_bit(priv, CSR_GP_DRIVER_REG,
				CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
}

93
static void iwl6150_additional_nic_config(struct iwl_priv *priv)
94
95
96
97
98
99
100
101
102
{
	/* Indicate calibration version to uCode. */
	if (priv->cfg->ops->lib->eeprom_ops.calib_version(priv) >= 6)
		iwl_set_bit(priv, CSR_GP_DRIVER_REG,
				CSR_GP_DRIVER_REG_BIT_CALIB_VERSION6);
	iwl_set_bit(priv, CSR_GP_DRIVER_REG,
		    CSR_GP_DRIVER_REG_BIT_6050_1x2);
}

103
104
105
/* NIC configuration for 6000 series */
static void iwl6000_nic_config(struct iwl_priv *priv)
{
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
	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);
121
122

	/* no locking required for register write */
123
	if (priv->cfg->pa_type == IWL_PA_INTERNAL) {
124
125
126
127
		/* 2x2 IPA phy type */
		iwl_write32(priv, CSR_GP_DRIVER_REG,
			     CSR_GP_DRIVER_REG_BIT_RADIO_SKU_2x2_IPA);
	}
128
129
130
131
132
	/* do additional nic configuration if needed */
	if (priv->cfg->ops->nic &&
		priv->cfg->ops->nic->additional_nic_config) {
			priv->cfg->ops->nic->additional_nic_config(priv);
	}
133
134
}

135
136
137
138
139
140
141
142
143
144
static struct iwl_sensitivity_ranges iwl6000_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,
145
	.auto_corr_max_ofdm_x1 = 110,
146
147
148
149
150
151
152
153
	.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,
154
155
156
157

	.barker_corr_th_min = 190,
	.barker_corr_th_min_mrc = 390,
	.nrg_th_cca = 62,
158
159
160
161
};

static int iwl6000_hw_set_hw_params(struct iwl_priv *priv)
{
162
	if (priv->cfg->mod_params->num_of_queues >= IWL_MIN_NUM_QUEUES &&
163
	    priv->cfg->mod_params->num_of_queues <= IWLAGN_NUM_QUEUES)
164
		priv->cfg->base_params->num_of_queues =
165
			priv->cfg->mod_params->num_of_queues;
166

167
	priv->hw_params.max_txq_num = priv->cfg->base_params->num_of_queues;
168
169
	priv->hw_params.dma_chnl_num = FH50_TCSR_CHNL_NUM;
	priv->hw_params.scd_bc_tbls_size =
170
			priv->cfg->base_params->num_of_queues *
171
			sizeof(struct iwlagn_scd_bc_tbl);
172
	priv->hw_params.tfd_size = sizeof(struct iwl_tfd);
173
	priv->hw_params.max_stations = IWLAGN_STATION_COUNT;
174
	priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id = IWLAGN_BROADCAST_ID;
175
176
177
178
179
180
181
182
183

	priv->hw_params.max_data_size = IWL60_RTC_DATA_SIZE;
	priv->hw_params.max_inst_size = IWL60_RTC_INST_SIZE;

	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);
Wey-Yi Guy's avatar
Wey-Yi Guy committed
184
185
186
187
188
	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);
189
190
191
	priv->hw_params.valid_tx_ant = priv->cfg->valid_tx_ant;
	priv->hw_params.valid_rx_ant = priv->cfg->valid_rx_ant;

192
	iwl6000_set_ct_threshold(priv);
193
194
195
196

	/* Set initial sensitivity parameters */
	/* Set initial calibration set */
	priv->hw_params.sens = &iwl6000_sensitivity;
197
198
199
200
201
	priv->hw_params.calib_init_cfg =
		BIT(IWL_CALIB_XTAL)		|
		BIT(IWL_CALIB_LO)		|
		BIT(IWL_CALIB_TX_IQ)		|
		BIT(IWL_CALIB_BASE_BAND);
202
	if (priv->cfg->need_dc_calib)
203
		priv->hw_params.calib_rt_cfg |= BIT(IWL_CALIB_CFG_DC_IDX);
204
205
	if (priv->cfg->need_temp_offset_calib)
		priv->hw_params.calib_init_cfg |= BIT(IWL_CALIB_TEMP_OFFSET);
206

207
208
	priv->hw_params.beacon_time_tsf_bits = IWLAGN_EXT_BEACON_TIME_POS;

209
210
211
	return 0;
}

212
213
static int iwl6000_hw_channel_switch(struct iwl_priv *priv,
				     struct ieee80211_channel_switch *ch_switch)
214
{
215
216
217
218
219
	/*
	 * MULTI-FIXME
	 * See iwl_mac_channel_switch.
	 */
	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
220
221
	struct iwl6000_channel_switch_cmd cmd;
	const struct iwl_channel_info *ch_info;
222
223
224
225
	u32 switch_time_in_usec, ucode_switch_time;
	u16 ch;
	u32 tsf_low;
	u8 switch_count;
226
	u16 beacon_interval = le16_to_cpu(ctx->timing.beacon_interval);
227
	struct ieee80211_vif *vif = ctx->vif;
228
229
230
	struct iwl_host_cmd hcmd = {
		.id = REPLY_CHANNEL_SWITCH,
		.len = sizeof(cmd),
231
		.flags = CMD_SYNC,
232
233
234
235
		.data = &cmd,
	};

	cmd.band = priv->band == IEEE80211_BAND_2GHZ;
236
	ch = ch_switch->channel->hw_value;
237
	IWL_DEBUG_11H(priv, "channel switch from %u to %u\n",
238
		      ctx->active.channel, ch);
239
	cmd.channel = cpu_to_le16(ch);
240
241
	cmd.rxon_flags = ctx->staging.flags;
	cmd.rxon_filter_flags = ctx->staging.filter_flags;
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
	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);
272
273
274
275
	if (ch_info)
		cmd.expect_beacon = is_channel_radar(ch_info);
	else {
		IWL_ERR(priv, "invalid channel switch from %u to %u\n",
276
			ctx->active.channel, ch);
277
278
		return -EFAULT;
	}
279
	priv->switch_rxon.channel = cmd.channel;
Wey-Yi Guy's avatar
Wey-Yi Guy committed
280
	priv->switch_rxon.switch_in_progress = true;
281
282
283
284

	return iwl_send_cmd_sync(priv, &hcmd);
}

285
static struct iwl_lib_ops iwl6000_lib = {
286
	.set_hw_params = iwl6000_hw_set_hw_params,
287
288
289
	.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,
290
291
292
	.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,
293
294
295
	.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,
296
297
	.dump_nic_event_log = iwl_dump_nic_event_log,
	.dump_nic_error_log = iwl_dump_nic_error_log,
298
	.dump_csr = iwl_dump_csr,
299
	.dump_fh = iwl_dump_fh,
300
	.send_tx_power = iwlagn_send_tx_power,
301
	.update_chain_flags = iwl_update_chain_flags,
302
	.set_channel_switch = iwl6000_hw_channel_switch,
303
	.apm_ops = {
304
		.init = iwl_apm_init,
305
		.config = iwl6000_nic_config,
306
307
308
	},
	.eeprom_ops = {
		.regulatory_bands = {
309
310
311
312
313
			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,
314
			EEPROM_6000_REG_BAND_24_HT40_CHANNELS,
315
			EEPROM_REG_BAND_52_HT40_CHANNELS
316
317
318
		},
		.acquire_semaphore = iwlcore_eeprom_acquire_semaphore,
		.release_semaphore = iwlcore_eeprom_release_semaphore,
319
320
		.calib_version	= iwlagn_eeprom_calib_version,
		.query_addr = iwlagn_eeprom_query_addr,
321
		.update_enhanced_txpower = iwlcore_eeprom_enhanced_txpower,
322
	},
323
324
325
326
327
328
329
	.isr_ops = {
		.isr = iwl_isr_ict,
		.free = iwl_free_isr_ict,
		.alloc = iwl_alloc_isr_ict,
		.reset = iwl_reset_ict,
		.disable = iwl_disable_ict,
	},
330
	.temp_ops = {
331
		.temperature = iwlagn_temperature,
332
	 },
333
334
335
336
	.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,
337
		.bt_stats_read = iwl_ucode_bt_stats_read,
338
		.reply_tx_error = iwl_reply_tx_error_read,
339
	},
340
	.txfifo_flush = iwlagn_txfifo_flush,
341
	.dev_txfifo_flush = iwlagn_dev_txfifo_flush,
342
343
344
345
346
	.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,
	}
347
348
};

349
static struct iwl_lib_ops iwl6030_lib = {
350
351
352
353
354
355
356
	.set_hw_params = iwl6000_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_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,
Wey-Yi Guy's avatar
Wey-Yi Guy committed
357
358
359
	.rx_handler_setup = iwlagn_bt_rx_handler_setup,
	.setup_deferred_work = iwlagn_bt_setup_deferred_work,
	.cancel_deferred_work = iwlagn_bt_cancel_deferred_work,
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
	.is_valid_rtc_data_addr = iwlagn_hw_valid_rtc_data_addr,
	.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,
	.send_tx_power = iwlagn_send_tx_power,
	.update_chain_flags = iwl_update_chain_flags,
	.set_channel_switch = iwl6000_hw_channel_switch,
	.apm_ops = {
		.init = iwl_apm_init,
		.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
		},
		.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,
	},
388
389
390
391
392
393
394
	.isr_ops = {
		.isr = iwl_isr_ict,
		.free = iwl_free_isr_ict,
		.alloc = iwl_alloc_isr_ict,
		.reset = iwl_reset_ict,
		.disable = iwl_disable_ict,
	},
395
396
397
398
399
400
401
402
	.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,
403
		.reply_tx_error = iwl_reply_tx_error_read,
404
405
406
407
408
409
410
411
412
413
	},
	.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,
	}
};

414
415
416
417
static struct iwl_nic_ops iwl6050_nic_ops = {
	.additional_nic_config = &iwl6050_additional_nic_config,
};

418
419
static struct iwl_nic_ops iwl6150_nic_ops = {
	.additional_nic_config = &iwl6150_additional_nic_config,
420
421
};

Emese Revfy's avatar
Emese Revfy committed
422
static const struct iwl_ops iwl6000_ops = {
423
	.lib = &iwl6000_lib,
424
425
	.hcmd = &iwlagn_hcmd,
	.utils = &iwlagn_hcmd_utils,
Johannes Berg's avatar
Johannes Berg committed
426
	.led = &iwlagn_led_ops,
427
	.ieee80211_ops = &iwlagn_hw_ops,
428
429
};

430
431
432
433
434
435
static const struct iwl_ops iwl6050_ops = {
	.lib = &iwl6000_lib,
	.hcmd = &iwlagn_hcmd,
	.utils = &iwlagn_hcmd_utils,
	.led = &iwlagn_led_ops,
	.nic = &iwl6050_nic_ops,
436
	.ieee80211_ops = &iwlagn_hw_ops,
437
438
};

439
static const struct iwl_ops iwl6150_ops = {
440
441
442
443
	.lib = &iwl6000_lib,
	.hcmd = &iwlagn_hcmd,
	.utils = &iwlagn_hcmd_utils,
	.led = &iwlagn_led_ops,
444
	.nic = &iwl6150_nic_ops,
445
	.ieee80211_ops = &iwlagn_hw_ops,
446
447
};

448
449
static const struct iwl_ops iwl6030_ops = {
	.lib = &iwl6030_lib,
Wey-Yi Guy's avatar
Wey-Yi Guy committed
450
	.hcmd = &iwlagn_bt_hcmd,
451
452
	.utils = &iwlagn_hcmd_utils,
	.led = &iwlagn_led_ops,
453
	.ieee80211_ops = &iwlagn_hw_ops,
454
455
};

456
static struct iwl_base_params iwl6000_base_params = {
457
458
459
460
461
462
463
464
465
466
467
468
469
470
	.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_6x00,
	.shadow_ram_support = true,
	.led_compensation = 51,
	.chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
	.adv_thermal_throttle = true,
	.support_ct_kill_exit = true,
	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
	.chain_noise_scale = 1000,
471
	.wd_timeout = IWL_DEF_WD_TIMEOUT,
472
	.max_event_log_size = 512,
473
	.ucode_tracing = true,
474
475
	.sensitivity_calib_by_driver = true,
	.chain_noise_calib_by_driver = true,
Wey-Yi Guy's avatar
Wey-Yi Guy committed
476
	.shadow_reg_enable = true,
477
478
};

479
static struct iwl_base_params iwl6050_base_params = {
480
481
482
483
484
485
	.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,
486
	.max_ll_items = OTP_MAX_LL_ITEMS_6x50,
487
488
489
490
491
492
	.shadow_ram_support = true,
	.led_compensation = 51,
	.chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
	.adv_thermal_throttle = true,
	.support_ct_kill_exit = true,
	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
493
	.chain_noise_scale = 1500,
494
	.wd_timeout = IWL_DEF_WD_TIMEOUT,
495
496
	.max_event_log_size = 1024,
	.ucode_tracing = true,
497
498
	.sensitivity_calib_by_driver = true,
	.chain_noise_calib_by_driver = true,
Wey-Yi Guy's avatar
Wey-Yi Guy committed
499
	.shadow_reg_enable = true,
500
};
501
static struct iwl_base_params iwl6000_g2_base_params = {
502
503
504
505
506
507
508
509
	.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_6x00,
	.shadow_ram_support = true,
510
	.led_compensation = 57,
511
512
513
514
515
	.chain_noise_num_beacons = IWL_CAL_NUM_BEACONS,
	.adv_thermal_throttle = true,
	.support_ct_kill_exit = true,
	.plcp_delta_threshold = IWL_MAX_PLCP_ERR_THRESHOLD_DEF,
	.chain_noise_scale = 1000,
516
	.wd_timeout = IWL_LONG_WD_TIMEOUT,
517
518
519
520
	.max_event_log_size = 512,
	.ucode_tracing = true,
	.sensitivity_calib_by_driver = true,
	.chain_noise_calib_by_driver = true,
Wey-Yi Guy's avatar
Wey-Yi Guy committed
521
	.shadow_reg_enable = true,
522
};
523
524
525
526
527
528
529
530
531
532

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

static struct iwl_bt_params iwl6000_bt_params = {
	.bt_statistics = true,
	/* Due to bluetooth, we transmit 2.4 GHz probes only on antenna A */
	.advanced_bt_coexist = true,
533
	.agg_time_limit = BT_AGG_THRESHOLD_DEF,
534
535
	.bt_init_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_NONE,
	.bt_prio_boost = IWLAGN_BT_PRIO_BOOST_DEFAULT,
536
	.bt_sco_disable = true,
537
538
};

539
#define IWL_DEVICE_6005						\
540
	.fw_name_pre = IWL6005_FW_PRE,			\
541
542
	.ucode_api_max = IWL6000G2_UCODE_API_MAX,		\
	.ucode_api_min = IWL6000G2_UCODE_API_MIN,		\
543
544
	.eeprom_ver = EEPROM_6005_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6005_TX_POWER_VERSION,	\
545
546
547
548
549
550
551
	.ops = &iwl6000_ops,					\
	.mod_params = &iwlagn_mod_params,			\
	.base_params = &iwl6000_g2_base_params,			\
	.need_dc_calib = true,					\
	.need_temp_offset_calib = true,				\
	.led_mode = IWL_LED_RF_STATE

552
struct iwl_cfg iwl6005_2agn_cfg = {
553
	.name = "Intel(R) Centrino(R) Advanced-N 6205 AGN",
554
	IWL_DEVICE_6005,
555
556
557
	.ht_params = &iwl6000_ht_params,
};

558
struct iwl_cfg iwl6005_2abg_cfg = {
559
	.name = "Intel(R) Centrino(R) Advanced-N 6205 ABG",
560
	IWL_DEVICE_6005,
561
562
};

563
struct iwl_cfg iwl6005_2bg_cfg = {
564
	.name = "Intel(R) Centrino(R) Advanced-N 6205 BG",
565
566
567
568
	IWL_DEVICE_6005,
};

#define IWL_DEVICE_6030						\
569
	.fw_name_pre = IWL6030_FW_PRE,			\
570
571
	.ucode_api_max = IWL6000G2_UCODE_API_MAX,		\
	.ucode_api_min = IWL6000G2_UCODE_API_MIN,		\
572
573
574
	.eeprom_ver = EEPROM_6030_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6030_TX_POWER_VERSION,	\
	.ops = &iwl6030_ops,					\
575
576
577
578
579
580
	.mod_params = &iwlagn_mod_params,			\
	.base_params = &iwl6000_g2_base_params,			\
	.bt_params = &iwl6000_bt_params,			\
	.need_dc_calib = true,					\
	.need_temp_offset_calib = true,				\
	.led_mode = IWL_LED_RF_STATE,				\
581
	.adv_pm = true						\
582

583
struct iwl_cfg iwl6030_2agn_cfg = {
584
	.name = "Intel(R) Centrino(R) Advanced-N 6230 AGN",
585
	IWL_DEVICE_6030,
586
	.ht_params = &iwl6000_ht_params,
587
588
};

589
struct iwl_cfg iwl6030_2abg_cfg = {
590
	.name = "Intel(R) Centrino(R) Advanced-N 6230 ABG",
591
	IWL_DEVICE_6030,
592
593
};

594
struct iwl_cfg iwl6030_2bgn_cfg = {
595
	.name = "Intel(R) Centrino(R) Advanced-N 6230 BGN",
596
	IWL_DEVICE_6030,
597
	.ht_params = &iwl6000_ht_params,
598
599
};

600
struct iwl_cfg iwl6030_2bg_cfg = {
601
	.name = "Intel(R) Centrino(R) Advanced-N 6230 BG",
602
	IWL_DEVICE_6030,
603
604
};

605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
struct iwl_cfg iwl6035_2agn_cfg = {
	.name = "6035 Series 2x2 AGN/BT",
	IWL_DEVICE_6030,
	.ht_params = &iwl6000_ht_params,
};

struct iwl_cfg iwl6035_2abg_cfg = {
	.name = "6035 Series 2x2 ABG/BT",
	IWL_DEVICE_6030,
};

struct iwl_cfg iwl6035_2bg_cfg = {
	.name = "6035 Series 2x2 BG/BT",
	IWL_DEVICE_6030,
};

621
struct iwl_cfg iwl1030_bgn_cfg = {
622
	.name = "Intel(R) Centrino(R) Wireless-N 1030 BGN",
623
	IWL_DEVICE_6030,
624
	.ht_params = &iwl6000_ht_params,
625
626
};

627
struct iwl_cfg iwl1030_bg_cfg = {
628
	.name = "Intel(R) Centrino(R) Wireless-N 1030 BG",
629
630
631
632
633
634
635
636
637
638
639
640
641
642
	IWL_DEVICE_6030,
};

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,
};

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

645
646
647
/*
 * "i": Internal configuration, use internal Power Amplifier
 */
648
649
650
651
652
653
654
655
656
657
658
659
660
661
#define IWL_DEVICE_6000i					\
	.fw_name_pre = IWL6000_FW_PRE,				\
	.ucode_api_max = IWL6000_UCODE_API_MAX,			\
	.ucode_api_min = IWL6000_UCODE_API_MIN,			\
	.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,	\
	.ops = &iwl6000_ops,					\
	.mod_params = &iwlagn_mod_params,			\
	.base_params = &iwl6000_base_params,			\
	.pa_type = IWL_PA_INTERNAL,				\
	.led_mode = IWL_LED_BLINK

662
struct iwl_cfg iwl6000i_2agn_cfg = {
663
	.name = "Intel(R) Centrino(R) Advanced-N 6200 AGN",
664
	IWL_DEVICE_6000i,
665
	.ht_params = &iwl6000_ht_params,
666
667
};

668
struct iwl_cfg iwl6000i_2abg_cfg = {
669
	.name = "Intel(R) Centrino(R) Advanced-N 6200 ABG",
670
	IWL_DEVICE_6000i,
671
672
673
};

struct iwl_cfg iwl6000i_2bg_cfg = {
674
	.name = "Intel(R) Centrino(R) Advanced-N 6200 BG",
675
676
677
678
679
680
681
	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,			\
682
683
	.valid_tx_ant = ANT_AB,		/* .cfg overwrite */	\
	.valid_rx_ant = ANT_AB,		/* .cfg overwrite */	\
684
685
686
687
688
689
690
691
	.ops = &iwl6050_ops,					\
	.eeprom_ver = EEPROM_6050_EEPROM_VERSION,		\
	.eeprom_calib_ver = EEPROM_6050_TX_POWER_VERSION,	\
	.mod_params = &iwlagn_mod_params,			\
	.base_params = &iwl6050_base_params,			\
	.need_dc_calib = true,					\
	.led_mode = IWL_LED_BLINK,				\
	.internal_wimax_coex = true
692

693
struct iwl_cfg iwl6050_2agn_cfg = {
694
	.name = "Intel(R) Centrino(R) Advanced-N + WiMAX 6250 AGN",
695
	IWL_DEVICE_6050,
696
	.ht_params = &iwl6000_ht_params,
697
698
699
700
701
};

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

704
struct iwl_cfg iwl6150_bgn_cfg = {
705
	.name = "Intel(R) Centrino(R) Wireless-N + WiMAX 6150 BGN",
706
707
708
	.fw_name_pre = IWL6050_FW_PRE,
	.ucode_api_max = IWL6050_UCODE_API_MAX,
	.ucode_api_min = IWL6050_UCODE_API_MIN,
709
710
711
	.eeprom_ver = EEPROM_6150_EEPROM_VERSION,
	.eeprom_calib_ver = EEPROM_6150_TX_POWER_VERSION,
	.ops = &iwl6150_ops,
712
	.mod_params = &iwlagn_mod_params,
713
714
	.base_params = &iwl6050_base_params,
	.ht_params = &iwl6000_ht_params,
715
	.need_dc_calib = true,
716
	.led_mode = IWL_LED_RF_STATE,
717
	.internal_wimax_coex = true,
718
719
720
};

struct iwl_cfg iwl6000_3agn_cfg = {
721
	.name = "Intel(R) Centrino(R) Ultimate-N 6300 AGN",
722
723
724
	.fw_name_pre = IWL6000_FW_PRE,
	.ucode_api_max = IWL6000_UCODE_API_MAX,
	.ucode_api_min = IWL6000_UCODE_API_MIN,
725
	.eeprom_ver = EEPROM_6000_EEPROM_VERSION,
726
	.eeprom_calib_ver = EEPROM_6000_TX_POWER_VERSION,
727
	.ops = &iwl6000_ops,
728
	.mod_params = &iwlagn_mod_params,
729
730
731
	.base_params = &iwl6000_base_params,
	.ht_params = &iwl6000_ht_params,
	.need_dc_calib = true,
732
	.led_mode = IWL_LED_BLINK,
733
734
735
736
};

MODULE_FIRMWARE(IWL6000_MODULE_FIRMWARE(IWL6000_UCODE_API_MAX));
MODULE_FIRMWARE(IWL6050_MODULE_FIRMWARE(IWL6050_UCODE_API_MAX));
737
738
MODULE_FIRMWARE(IWL6005_MODULE_FIRMWARE(IWL6000G2_UCODE_API_MAX));
MODULE_FIRMWARE(IWL6030_MODULE_FIRMWARE(IWL6000G2_UCODE_API_MAX));