iwl-dev.h revision 390808db4ab5c658dc1eb8078d82027ce7d0ea78
1/****************************************************************************** 2 * 3 * Copyright(c) 2003 - 2011 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 * Please use this file (iwl-dev.h) for driver implementation definitions. 28 * Please use iwl-commands.h for uCode API definitions. 29 */ 30 31#ifndef __iwl_dev_h__ 32#define __iwl_dev_h__ 33 34#include <linux/interrupt.h> 35#include <linux/kernel.h> 36#include <linux/wait.h> 37#include <linux/leds.h> 38#include <linux/slab.h> 39#include <net/ieee80211_radiotap.h> 40 41#include "iwl-eeprom.h" 42#include "iwl-csr.h" 43#include "iwl-prph.h" 44#include "iwl-debug.h" 45#include "iwl-agn-hw.h" 46#include "iwl-led.h" 47#include "iwl-power.h" 48#include "iwl-agn-rs.h" 49#include "iwl-agn-tt.h" 50#include "iwl-bus.h" 51#include "iwl-trans.h" 52#include "iwl-shared.h" 53 54struct iwl_tx_queue; 55 56/* CT-KILL constants */ 57#define CT_KILL_THRESHOLD_LEGACY 110 /* in Celsius */ 58#define CT_KILL_THRESHOLD 114 /* in Celsius */ 59#define CT_KILL_EXIT_THRESHOLD 95 /* in Celsius */ 60 61/* Default noise level to report when noise measurement is not available. 62 * This may be because we're: 63 * 1) Not associated (4965, no beacon statistics being sent to driver) 64 * 2) Scanning (noise measurement does not apply to associated channel) 65 * 3) Receiving CCK (3945 delivers noise info only for OFDM frames) 66 * Use default noise value of -127 ... this is below the range of measurable 67 * Rx dBm for either 3945 or 4965, so it can indicate "unmeasurable" to user. 68 * Also, -127 works better than 0 when averaging frames with/without 69 * noise info (e.g. averaging might be done in app); measured dBm values are 70 * always negative ... using a negative value as the default keeps all 71 * averages within an s8's (used in some apps) range of negative values. */ 72#define IWL_NOISE_MEAS_NOT_AVAILABLE (-127) 73 74/* 75 * RTS threshold here is total size [2347] minus 4 FCS bytes 76 * Per spec: 77 * a value of 0 means RTS on all data/management packets 78 * a value > max MSDU size means no RTS 79 * else RTS for data/management frames where MPDU is larger 80 * than RTS value. 81 */ 82#define DEFAULT_RTS_THRESHOLD 2347U 83#define MIN_RTS_THRESHOLD 0U 84#define MAX_RTS_THRESHOLD 2347U 85#define MAX_MSDU_SIZE 2304U 86#define MAX_MPDU_SIZE 2346U 87#define DEFAULT_BEACON_INTERVAL 200U 88#define DEFAULT_SHORT_RETRY_LIMIT 7U 89#define DEFAULT_LONG_RETRY_LIMIT 4U 90 91#define IWL_NUM_SCAN_RATES (2) 92 93/* 94 * One for each channel, holds all channel setup data 95 * Some of the fields (e.g. eeprom and flags/max_power_avg) are redundant 96 * with one another! 97 */ 98struct iwl_channel_info { 99 struct iwl_eeprom_channel eeprom; /* EEPROM regulatory limit */ 100 struct iwl_eeprom_channel ht40_eeprom; /* EEPROM regulatory limit for 101 * HT40 channel */ 102 103 u8 channel; /* channel number */ 104 u8 flags; /* flags copied from EEPROM */ 105 s8 max_power_avg; /* (dBm) regul. eeprom, normal Tx, any rate */ 106 s8 curr_txpow; /* (dBm) regulatory/spectrum/user (not h/w) limit */ 107 s8 min_power; /* always 0 */ 108 s8 scan_power; /* (dBm) regul. eeprom, direct scans, any rate */ 109 110 u8 group_index; /* 0-4, maps channel to group1/2/3/4/5 */ 111 u8 band_index; /* 0-4, maps channel to band1/2/3/4/5 */ 112 enum ieee80211_band band; 113 114 /* HT40 channel info */ 115 s8 ht40_max_power_avg; /* (dBm) regul. eeprom, normal Tx, any rate */ 116 u8 ht40_flags; /* flags copied from EEPROM */ 117 u8 ht40_extension_channel; /* HT_IE_EXT_CHANNEL_* */ 118}; 119 120/* 121 * Minimum number of queues. MAX_NUM is defined in hw specific files. 122 * Set the minimum to accommodate 123 * - 4 standard TX queues 124 * - the command queue 125 * - 4 PAN TX queues 126 * - the PAN multicast queue, and 127 * - the AUX (TX during scan dwell) queue. 128 */ 129#define IWL_MIN_NUM_QUEUES 11 130 131/* 132 * Command queue depends on iPAN support. 133 */ 134#define IWL_DEFAULT_CMD_QUEUE_NUM 4 135#define IWL_IPAN_CMD_QUEUE_NUM 9 136 137#define IEEE80211_DATA_LEN 2304 138#define IEEE80211_4ADDR_LEN 30 139#define IEEE80211_HLEN (IEEE80211_4ADDR_LEN) 140#define IEEE80211_FRAME_LEN (IEEE80211_DATA_LEN + IEEE80211_HLEN) 141 142#define SUP_RATE_11A_MAX_NUM_CHANNELS 8 143#define SUP_RATE_11B_MAX_NUM_CHANNELS 4 144#define SUP_RATE_11G_MAX_NUM_CHANNELS 12 145 146#define IWL_SUPPORTED_RATES_IE_LEN 8 147 148#define IWL_INVALID_RATE 0xFF 149#define IWL_INVALID_VALUE -1 150 151union iwl_ht_rate_supp { 152 u16 rates; 153 struct { 154 u8 siso_rate; 155 u8 mimo_rate; 156 }; 157}; 158 159#define CFG_HT_RX_AMPDU_FACTOR_8K (0x0) 160#define CFG_HT_RX_AMPDU_FACTOR_16K (0x1) 161#define CFG_HT_RX_AMPDU_FACTOR_32K (0x2) 162#define CFG_HT_RX_AMPDU_FACTOR_64K (0x3) 163#define CFG_HT_RX_AMPDU_FACTOR_DEF CFG_HT_RX_AMPDU_FACTOR_64K 164#define CFG_HT_RX_AMPDU_FACTOR_MAX CFG_HT_RX_AMPDU_FACTOR_64K 165#define CFG_HT_RX_AMPDU_FACTOR_MIN CFG_HT_RX_AMPDU_FACTOR_8K 166 167/* 168 * Maximal MPDU density for TX aggregation 169 * 4 - 2us density 170 * 5 - 4us density 171 * 6 - 8us density 172 * 7 - 16us density 173 */ 174#define CFG_HT_MPDU_DENSITY_2USEC (0x4) 175#define CFG_HT_MPDU_DENSITY_4USEC (0x5) 176#define CFG_HT_MPDU_DENSITY_8USEC (0x6) 177#define CFG_HT_MPDU_DENSITY_16USEC (0x7) 178#define CFG_HT_MPDU_DENSITY_DEF CFG_HT_MPDU_DENSITY_4USEC 179#define CFG_HT_MPDU_DENSITY_MAX CFG_HT_MPDU_DENSITY_16USEC 180#define CFG_HT_MPDU_DENSITY_MIN (0x1) 181 182struct iwl_ht_config { 183 bool single_chain_sufficient; 184 enum ieee80211_smps_mode smps; /* current smps mode */ 185}; 186 187/* QoS structures */ 188struct iwl_qos_info { 189 int qos_active; 190 struct iwl_qosparam_cmd def_qos_parm; 191}; 192 193/* 194 * Structure should be accessed with sta_lock held. When station addition 195 * is in progress (IWL_STA_UCODE_INPROGRESS) it is possible to access only 196 * the commands (iwl_addsta_cmd and iwl_link_quality_cmd) without sta_lock 197 * held. 198 */ 199struct iwl_station_entry { 200 struct iwl_addsta_cmd sta; 201 u8 used, ctxid; 202 struct iwl_link_quality_cmd *lq; 203}; 204 205/* 206 * iwl_station_priv: Driver's private station information 207 * 208 * When mac80211 creates a station it reserves some space (hw->sta_data_size) 209 * in the structure for use by driver. This structure is places in that 210 * space. 211 */ 212struct iwl_station_priv { 213 struct iwl_rxon_context *ctx; 214 struct iwl_lq_sta lq_sta; 215 atomic_t pending_frames; 216 bool client; 217 bool asleep; 218 u8 max_agg_bufsize; 219 u8 sta_id; 220}; 221 222/** 223 * struct iwl_vif_priv - driver's private per-interface information 224 * 225 * When mac80211 allocates a virtual interface, it can allocate 226 * space for us to put data into. 227 */ 228struct iwl_vif_priv { 229 struct iwl_rxon_context *ctx; 230 u8 ibss_bssid_sta_id; 231}; 232 233/* one for each uCode image (inst/data, boot/init/runtime) */ 234struct fw_desc { 235 void *v_addr; /* access by driver */ 236 dma_addr_t p_addr; /* access by card's busmaster DMA */ 237 u32 len; /* bytes */ 238}; 239 240struct fw_img { 241 struct fw_desc code, data; 242}; 243 244/* v1/v2 uCode file layout */ 245struct iwl_ucode_header { 246 __le32 ver; /* major/minor/API/serial */ 247 union { 248 struct { 249 __le32 inst_size; /* bytes of runtime code */ 250 __le32 data_size; /* bytes of runtime data */ 251 __le32 init_size; /* bytes of init code */ 252 __le32 init_data_size; /* bytes of init data */ 253 __le32 boot_size; /* bytes of bootstrap code */ 254 u8 data[0]; /* in same order as sizes */ 255 } v1; 256 struct { 257 __le32 build; /* build number */ 258 __le32 inst_size; /* bytes of runtime code */ 259 __le32 data_size; /* bytes of runtime data */ 260 __le32 init_size; /* bytes of init code */ 261 __le32 init_data_size; /* bytes of init data */ 262 __le32 boot_size; /* bytes of bootstrap code */ 263 u8 data[0]; /* in same order as sizes */ 264 } v2; 265 } u; 266}; 267 268/* 269 * new TLV uCode file layout 270 * 271 * The new TLV file format contains TLVs, that each specify 272 * some piece of data. To facilitate "groups", for example 273 * different instruction image with different capabilities, 274 * bundled with the same init image, an alternative mechanism 275 * is provided: 276 * When the alternative field is 0, that means that the item 277 * is always valid. When it is non-zero, then it is only 278 * valid in conjunction with items of the same alternative, 279 * in which case the driver (user) selects one alternative 280 * to use. 281 */ 282 283enum iwl_ucode_tlv_type { 284 IWL_UCODE_TLV_INVALID = 0, /* unused */ 285 IWL_UCODE_TLV_INST = 1, 286 IWL_UCODE_TLV_DATA = 2, 287 IWL_UCODE_TLV_INIT = 3, 288 IWL_UCODE_TLV_INIT_DATA = 4, 289 IWL_UCODE_TLV_BOOT = 5, 290 IWL_UCODE_TLV_PROBE_MAX_LEN = 6, /* a u32 value */ 291 IWL_UCODE_TLV_PAN = 7, 292 IWL_UCODE_TLV_RUNT_EVTLOG_PTR = 8, 293 IWL_UCODE_TLV_RUNT_EVTLOG_SIZE = 9, 294 IWL_UCODE_TLV_RUNT_ERRLOG_PTR = 10, 295 IWL_UCODE_TLV_INIT_EVTLOG_PTR = 11, 296 IWL_UCODE_TLV_INIT_EVTLOG_SIZE = 12, 297 IWL_UCODE_TLV_INIT_ERRLOG_PTR = 13, 298 IWL_UCODE_TLV_ENHANCE_SENS_TBL = 14, 299 IWL_UCODE_TLV_PHY_CALIBRATION_SIZE = 15, 300 IWL_UCODE_TLV_WOWLAN_INST = 16, 301 IWL_UCODE_TLV_WOWLAN_DATA = 17, 302 IWL_UCODE_TLV_FLAGS = 18, 303}; 304 305/** 306 * enum iwl_ucode_tlv_flag - ucode API flags 307 * @IWL_UCODE_TLV_FLAGS_PAN: This is PAN capable microcode; this previously 308 * was a separate TLV but moved here to save space. 309 * @IWL_UCODE_TLV_FLAGS_NEWSCAN: new uCode scan behaviour on hidden SSID, 310 * treats good CRC threshold as a boolean 311 * @IWL_UCODE_TLV_FLAGS_MFP: This uCode image supports MFP (802.11w). 312 * @IWL_UCODE_TLV_FLAGS_P2P: This uCode image supports P2P. 313 */ 314enum iwl_ucode_tlv_flag { 315 IWL_UCODE_TLV_FLAGS_PAN = BIT(0), 316 IWL_UCODE_TLV_FLAGS_NEWSCAN = BIT(1), 317 IWL_UCODE_TLV_FLAGS_MFP = BIT(2), 318 IWL_UCODE_TLV_FLAGS_P2P = BIT(3), 319}; 320 321struct iwl_ucode_tlv { 322 __le16 type; /* see above */ 323 __le16 alternative; /* see comment */ 324 __le32 length; /* not including type/length fields */ 325 u8 data[0]; 326} __packed; 327 328#define IWL_TLV_UCODE_MAGIC 0x0a4c5749 329 330struct iwl_tlv_ucode_header { 331 /* 332 * The TLV style ucode header is distinguished from 333 * the v1/v2 style header by first four bytes being 334 * zero, as such is an invalid combination of 335 * major/minor/API/serial versions. 336 */ 337 __le32 zero; 338 __le32 magic; 339 u8 human_readable[64]; 340 __le32 ver; /* major/minor/API/serial */ 341 __le32 build; 342 __le64 alternatives; /* bitmask of valid alternatives */ 343 /* 344 * The data contained herein has a TLV layout, 345 * see above for the TLV header and types. 346 * Note that each TLV is padded to a length 347 * that is a multiple of 4 for alignment. 348 */ 349 u8 data[0]; 350}; 351 352struct iwl_sensitivity_ranges { 353 u16 min_nrg_cck; 354 u16 max_nrg_cck; 355 356 u16 nrg_th_cck; 357 u16 nrg_th_ofdm; 358 359 u16 auto_corr_min_ofdm; 360 u16 auto_corr_min_ofdm_mrc; 361 u16 auto_corr_min_ofdm_x1; 362 u16 auto_corr_min_ofdm_mrc_x1; 363 364 u16 auto_corr_max_ofdm; 365 u16 auto_corr_max_ofdm_mrc; 366 u16 auto_corr_max_ofdm_x1; 367 u16 auto_corr_max_ofdm_mrc_x1; 368 369 u16 auto_corr_max_cck; 370 u16 auto_corr_max_cck_mrc; 371 u16 auto_corr_min_cck; 372 u16 auto_corr_min_cck_mrc; 373 374 u16 barker_corr_th_min; 375 u16 barker_corr_th_min_mrc; 376 u16 nrg_th_cca; 377}; 378 379 380#define KELVIN_TO_CELSIUS(x) ((x)-273) 381#define CELSIUS_TO_KELVIN(x) ((x)+273) 382 383 384/****************************************************************************** 385 * 386 * Functions implemented in core module which are forward declared here 387 * for use by iwl-[4-5].c 388 * 389 * NOTE: The implementation of these functions are not hardware specific 390 * which is why they are in the core module files. 391 * 392 * Naming convention -- 393 * iwl_ <-- Is part of iwlwifi 394 * iwlXXXX_ <-- Hardware specific (implemented in iwl-XXXX.c for XXXX) 395 * 396 ****************************************************************************/ 397extern void iwl_update_chain_flags(struct iwl_priv *priv); 398extern const u8 iwl_bcast_addr[ETH_ALEN]; 399 400#define IWL_OPERATION_MODE_AUTO 0 401#define IWL_OPERATION_MODE_HT_ONLY 1 402#define IWL_OPERATION_MODE_MIXED 2 403#define IWL_OPERATION_MODE_20MHZ 3 404 405#define TX_POWER_IWL_ILLEGAL_VOLTAGE -10000 406 407/* Sensitivity and chain noise calibration */ 408#define INITIALIZATION_VALUE 0xFFFF 409#define IWL_CAL_NUM_BEACONS 16 410#define MAXIMUM_ALLOWED_PATHLOSS 15 411 412#define CHAIN_NOISE_MAX_DELTA_GAIN_CODE 3 413 414#define MAX_FA_OFDM 50 415#define MIN_FA_OFDM 5 416#define MAX_FA_CCK 50 417#define MIN_FA_CCK 5 418 419#define AUTO_CORR_STEP_OFDM 1 420 421#define AUTO_CORR_STEP_CCK 3 422#define AUTO_CORR_MAX_TH_CCK 160 423 424#define NRG_DIFF 2 425#define NRG_STEP_CCK 2 426#define NRG_MARGIN 8 427#define MAX_NUMBER_CCK_NO_FA 100 428 429#define AUTO_CORR_CCK_MIN_VAL_DEF (125) 430 431#define CHAIN_A 0 432#define CHAIN_B 1 433#define CHAIN_C 2 434#define CHAIN_NOISE_DELTA_GAIN_INIT_VAL 4 435#define ALL_BAND_FILTER 0xFF00 436#define IN_BAND_FILTER 0xFF 437#define MIN_AVERAGE_NOISE_MAX_VALUE 0xFFFFFFFF 438 439#define NRG_NUM_PREV_STAT_L 20 440#define NUM_RX_CHAINS 3 441 442enum iwlagn_false_alarm_state { 443 IWL_FA_TOO_MANY = 0, 444 IWL_FA_TOO_FEW = 1, 445 IWL_FA_GOOD_RANGE = 2, 446}; 447 448enum iwlagn_chain_noise_state { 449 IWL_CHAIN_NOISE_ALIVE = 0, /* must be 0 */ 450 IWL_CHAIN_NOISE_ACCUMULATE, 451 IWL_CHAIN_NOISE_CALIBRATED, 452 IWL_CHAIN_NOISE_DONE, 453}; 454 455 456/* 457 * enum iwl_calib 458 * defines the order in which results of initial calibrations 459 * should be sent to the runtime uCode 460 */ 461enum iwl_calib { 462 IWL_CALIB_XTAL, 463 IWL_CALIB_DC, 464 IWL_CALIB_LO, 465 IWL_CALIB_TX_IQ, 466 IWL_CALIB_TX_IQ_PERD, 467 IWL_CALIB_BASE_BAND, 468 IWL_CALIB_TEMP_OFFSET, 469 IWL_CALIB_MAX 470}; 471 472/* Opaque calibration results */ 473struct iwl_calib_result { 474 void *buf; 475 size_t buf_len; 476}; 477 478/* Sensitivity calib data */ 479struct iwl_sensitivity_data { 480 u32 auto_corr_ofdm; 481 u32 auto_corr_ofdm_mrc; 482 u32 auto_corr_ofdm_x1; 483 u32 auto_corr_ofdm_mrc_x1; 484 u32 auto_corr_cck; 485 u32 auto_corr_cck_mrc; 486 487 u32 last_bad_plcp_cnt_ofdm; 488 u32 last_fa_cnt_ofdm; 489 u32 last_bad_plcp_cnt_cck; 490 u32 last_fa_cnt_cck; 491 492 u32 nrg_curr_state; 493 u32 nrg_prev_state; 494 u32 nrg_value[10]; 495 u8 nrg_silence_rssi[NRG_NUM_PREV_STAT_L]; 496 u32 nrg_silence_ref; 497 u32 nrg_energy_idx; 498 u32 nrg_silence_idx; 499 u32 nrg_th_cck; 500 s32 nrg_auto_corr_silence_diff; 501 u32 num_in_cck_no_fa; 502 u32 nrg_th_ofdm; 503 504 u16 barker_corr_th_min; 505 u16 barker_corr_th_min_mrc; 506 u16 nrg_th_cca; 507}; 508 509/* Chain noise (differential Rx gain) calib data */ 510struct iwl_chain_noise_data { 511 u32 active_chains; 512 u32 chain_noise_a; 513 u32 chain_noise_b; 514 u32 chain_noise_c; 515 u32 chain_signal_a; 516 u32 chain_signal_b; 517 u32 chain_signal_c; 518 u16 beacon_count; 519 u8 disconn_array[NUM_RX_CHAINS]; 520 u8 delta_gain_code[NUM_RX_CHAINS]; 521 u8 radio_write; 522 u8 state; 523}; 524 525#define EEPROM_SEM_TIMEOUT 10 /* milliseconds */ 526#define EEPROM_SEM_RETRY_LIMIT 1000 /* number of attempts (not time) */ 527 528enum { 529 MEASUREMENT_READY = (1 << 0), 530 MEASUREMENT_ACTIVE = (1 << 1), 531}; 532 533enum iwl_nvm_type { 534 NVM_DEVICE_TYPE_EEPROM = 0, 535 NVM_DEVICE_TYPE_OTP, 536}; 537 538/* 539 * Two types of OTP memory access modes 540 * IWL_OTP_ACCESS_ABSOLUTE - absolute address mode, 541 * based on physical memory addressing 542 * IWL_OTP_ACCESS_RELATIVE - relative address mode, 543 * based on logical memory addressing 544 */ 545enum iwl_access_mode { 546 IWL_OTP_ACCESS_ABSOLUTE, 547 IWL_OTP_ACCESS_RELATIVE, 548}; 549 550/** 551 * enum iwl_pa_type - Power Amplifier type 552 * @IWL_PA_SYSTEM: based on uCode configuration 553 * @IWL_PA_INTERNAL: use Internal only 554 */ 555enum iwl_pa_type { 556 IWL_PA_SYSTEM = 0, 557 IWL_PA_INTERNAL = 1, 558}; 559 560/* reply_tx_statistics (for _agn devices) */ 561struct reply_tx_error_statistics { 562 u32 pp_delay; 563 u32 pp_few_bytes; 564 u32 pp_bt_prio; 565 u32 pp_quiet_period; 566 u32 pp_calc_ttak; 567 u32 int_crossed_retry; 568 u32 short_limit; 569 u32 long_limit; 570 u32 fifo_underrun; 571 u32 drain_flow; 572 u32 rfkill_flush; 573 u32 life_expire; 574 u32 dest_ps; 575 u32 host_abort; 576 u32 bt_retry; 577 u32 sta_invalid; 578 u32 frag_drop; 579 u32 tid_disable; 580 u32 fifo_flush; 581 u32 insuff_cf_poll; 582 u32 fail_hw_drop; 583 u32 sta_color_mismatch; 584 u32 unknown; 585}; 586 587/* reply_agg_tx_statistics (for _agn devices) */ 588struct reply_agg_tx_error_statistics { 589 u32 underrun; 590 u32 bt_prio; 591 u32 few_bytes; 592 u32 abort; 593 u32 last_sent_ttl; 594 u32 last_sent_try; 595 u32 last_sent_bt_kill; 596 u32 scd_query; 597 u32 bad_crc32; 598 u32 response; 599 u32 dump_tx; 600 u32 delay_tx; 601 u32 unknown; 602}; 603 604/* management statistics */ 605enum iwl_mgmt_stats { 606 MANAGEMENT_ASSOC_REQ = 0, 607 MANAGEMENT_ASSOC_RESP, 608 MANAGEMENT_REASSOC_REQ, 609 MANAGEMENT_REASSOC_RESP, 610 MANAGEMENT_PROBE_REQ, 611 MANAGEMENT_PROBE_RESP, 612 MANAGEMENT_BEACON, 613 MANAGEMENT_ATIM, 614 MANAGEMENT_DISASSOC, 615 MANAGEMENT_AUTH, 616 MANAGEMENT_DEAUTH, 617 MANAGEMENT_ACTION, 618 MANAGEMENT_MAX, 619}; 620/* control statistics */ 621enum iwl_ctrl_stats { 622 CONTROL_BACK_REQ = 0, 623 CONTROL_BACK, 624 CONTROL_PSPOLL, 625 CONTROL_RTS, 626 CONTROL_CTS, 627 CONTROL_ACK, 628 CONTROL_CFEND, 629 CONTROL_CFENDACK, 630 CONTROL_MAX, 631}; 632 633struct traffic_stats { 634#ifdef CONFIG_IWLWIFI_DEBUGFS 635 u32 mgmt[MANAGEMENT_MAX]; 636 u32 ctrl[CONTROL_MAX]; 637 u32 data_cnt; 638 u64 data_bytes; 639#endif 640}; 641 642/* 643 * schedule the timer to wake up every UCODE_TRACE_PERIOD milliseconds 644 * to perform continuous uCode event logging operation if enabled 645 */ 646#define UCODE_TRACE_PERIOD (100) 647 648/* 649 * iwl_event_log: current uCode event log position 650 * 651 * @ucode_trace: enable/disable ucode continuous trace timer 652 * @num_wraps: how many times the event buffer wraps 653 * @next_entry: the entry just before the next one that uCode would fill 654 * @non_wraps_count: counter for no wrap detected when dump ucode events 655 * @wraps_once_count: counter for wrap once detected when dump ucode events 656 * @wraps_more_count: counter for wrap more than once detected 657 * when dump ucode events 658 */ 659struct iwl_event_log { 660 bool ucode_trace; 661 u32 num_wraps; 662 u32 next_entry; 663 int non_wraps_count; 664 int wraps_once_count; 665 int wraps_more_count; 666}; 667 668/* 669 * This is the threshold value of plcp error rate per 100mSecs. It is 670 * used to set and check for the validity of plcp_delta. 671 */ 672#define IWL_MAX_PLCP_ERR_THRESHOLD_MIN (1) 673#define IWL_MAX_PLCP_ERR_THRESHOLD_DEF (50) 674#define IWL_MAX_PLCP_ERR_LONG_THRESHOLD_DEF (100) 675#define IWL_MAX_PLCP_ERR_EXT_LONG_THRESHOLD_DEF (200) 676#define IWL_MAX_PLCP_ERR_THRESHOLD_MAX (255) 677#define IWL_MAX_PLCP_ERR_THRESHOLD_DISABLE (0) 678 679#define IWL_DELAY_NEXT_FORCE_RF_RESET (HZ*3) 680#define IWL_DELAY_NEXT_FORCE_FW_RELOAD (HZ*5) 681 682/* TX queue watchdog timeouts in mSecs */ 683#define IWL_DEF_WD_TIMEOUT (2000) 684#define IWL_LONG_WD_TIMEOUT (10000) 685#define IWL_MAX_WD_TIMEOUT (120000) 686 687/* BT Antenna Coupling Threshold (dB) */ 688#define IWL_BT_ANTENNA_COUPLING_THRESHOLD (35) 689 690/* Firmware reload counter and Timestamp */ 691#define IWL_MIN_RELOAD_DURATION 1000 /* 1000 ms */ 692#define IWL_MAX_CONTINUE_RELOAD_CNT 4 693 694 695enum iwl_reset { 696 IWL_RF_RESET = 0, 697 IWL_FW_RESET, 698 IWL_MAX_FORCE_RESET, 699}; 700 701struct iwl_force_reset { 702 int reset_request_count; 703 int reset_success_count; 704 int reset_reject_count; 705 unsigned long reset_duration; 706 unsigned long last_force_reset_jiffies; 707}; 708 709/* extend beacon time format bit shifting */ 710/* 711 * for _agn devices 712 * bits 31:22 - extended 713 * bits 21:0 - interval 714 */ 715#define IWLAGN_EXT_BEACON_TIME_POS 22 716 717/** 718 * struct iwl_notification_wait - notification wait entry 719 * @list: list head for global list 720 * @fn: function called with the notification 721 * @cmd: command ID 722 * 723 * This structure is not used directly, to wait for a 724 * notification declare it on the stack, and call 725 * iwlagn_init_notification_wait() with appropriate 726 * parameters. Then do whatever will cause the ucode 727 * to notify the driver, and to wait for that then 728 * call iwlagn_wait_notification(). 729 * 730 * Each notification is one-shot. If at some point we 731 * need to support multi-shot notifications (which 732 * can't be allocated on the stack) we need to modify 733 * the code for them. 734 */ 735struct iwl_notification_wait { 736 struct list_head list; 737 738 void (*fn)(struct iwl_priv *priv, struct iwl_rx_packet *pkt, 739 void *data); 740 void *fn_data; 741 742 u8 cmd; 743 bool triggered, aborted; 744}; 745 746struct iwl_rxon_context { 747 struct ieee80211_vif *vif; 748 749 /* 750 * We could use the vif to indicate active, but we 751 * also need it to be active during disabling when 752 * we already removed the vif for type setting. 753 */ 754 bool always_active, is_active; 755 756 bool ht_need_multiple_chains; 757 758 enum iwl_rxon_context_id ctxid; 759 760 u32 interface_modes, exclusive_interface_modes; 761 u8 unused_devtype, ap_devtype, ibss_devtype, station_devtype; 762 763 /* 764 * We declare this const so it can only be 765 * changed via explicit cast within the 766 * routines that actually update the physical 767 * hardware. 768 */ 769 const struct iwl_rxon_cmd active; 770 struct iwl_rxon_cmd staging; 771 772 struct iwl_rxon_time_cmd timing; 773 774 struct iwl_qos_info qos_data; 775 776 u8 bcast_sta_id, ap_sta_id; 777 778 u8 rxon_cmd, rxon_assoc_cmd, rxon_timing_cmd; 779 u8 qos_cmd; 780 u8 wep_key_cmd; 781 782 struct iwl_wep_key wep_keys[WEP_KEYS_MAX]; 783 u8 key_mapping_keys; 784 785 __le32 station_flags; 786 787 int beacon_int; 788 789 struct { 790 bool non_gf_sta_present; 791 u8 protection; 792 bool enabled, is_40mhz; 793 u8 extension_chan_offset; 794 } ht; 795 796 u8 bssid[ETH_ALEN]; 797 bool preauth_bssid; 798 799 bool last_tx_rejected; 800}; 801 802enum iwl_scan_type { 803 IWL_SCAN_NORMAL, 804 IWL_SCAN_RADIO_RESET, 805 IWL_SCAN_ROC, 806}; 807 808enum iwlagn_ucode_type { 809 IWL_UCODE_NONE, 810 IWL_UCODE_REGULAR, 811 IWL_UCODE_INIT, 812 IWL_UCODE_WOWLAN, 813}; 814 815#ifdef CONFIG_IWLWIFI_DEVICE_SVTOOL 816struct iwl_testmode_trace { 817 u32 buff_size; 818 u32 total_size; 819 u32 num_chunks; 820 u8 *cpu_addr; 821 u8 *trace_addr; 822 dma_addr_t dma_addr; 823 bool trace_enabled; 824}; 825#endif 826 827struct iwl_priv { 828 829 /*data shared among all the driver's layers */ 830 struct iwl_shared _shrd; 831 struct iwl_shared *shrd; 832 833 /* ieee device used by generic ieee processing code */ 834 struct ieee80211_hw *hw; 835 struct ieee80211_channel *ieee_channels; 836 struct ieee80211_rate *ieee_rates; 837 struct kmem_cache *tx_cmd_pool; 838 struct iwl_cfg *cfg; 839 840 enum ieee80211_band band; 841 842 void (*pre_rx_handler)(struct iwl_priv *priv, 843 struct iwl_rx_mem_buffer *rxb); 844 void (*rx_handlers[REPLY_MAX])(struct iwl_priv *priv, 845 struct iwl_rx_mem_buffer *rxb); 846 847 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS]; 848 849 /* spectrum measurement report caching */ 850 struct iwl_spectrum_notification measure_report; 851 u8 measurement_status; 852 853 /* ucode beacon time */ 854 u32 ucode_beacon_time; 855 int missed_beacon_threshold; 856 857 /* track IBSS manager (last beacon) status */ 858 u32 ibss_manager; 859 860 /* jiffies when last recovery from statistics was performed */ 861 unsigned long rx_statistics_jiffies; 862 863 /*counters */ 864 u32 rx_handlers_stats[REPLY_MAX]; 865 866 /* force reset */ 867 struct iwl_force_reset force_reset[IWL_MAX_FORCE_RESET]; 868 869 /* firmware reload counter and timestamp */ 870 unsigned long reload_jiffies; 871 int reload_count; 872 873 /* we allocate array of iwl_channel_info for NIC's valid channels. 874 * Access via channel # using indirect index array */ 875 struct iwl_channel_info *channel_info; /* channel info array */ 876 u8 channel_count; /* # of channels */ 877 878 /* thermal calibration */ 879 s32 temperature; /* degrees Kelvin */ 880 s32 last_temperature; 881 882 /* init calibration results */ 883 struct iwl_calib_result calib_results[IWL_CALIB_MAX]; 884 885 /* Scan related variables */ 886 unsigned long scan_start; 887 unsigned long scan_start_tsf; 888 void *scan_cmd; 889 enum ieee80211_band scan_band; 890 struct cfg80211_scan_request *scan_request; 891 struct ieee80211_vif *scan_vif; 892 enum iwl_scan_type scan_type; 893 u8 scan_tx_ant[IEEE80211_NUM_BANDS]; 894 u8 mgmt_tx_ant; 895 896 /*TODO: remove these pointers - use bus(priv) instead */ 897 struct iwl_bus *bus; /* bus specific data */ 898 899 /* max number of station keys */ 900 u8 sta_key_max_num; 901 902 bool new_scan_threshold_behaviour; 903 904 /* EEPROM MAC addresses */ 905 struct mac_address addresses[2]; 906 907 /* uCode images, save to reload in case of failure */ 908 int fw_index; /* firmware we're trying to load */ 909 u32 ucode_ver; /* version of ucode, copy of 910 iwl_ucode.ver */ 911 912 struct fw_img ucode_rt; 913 struct fw_img ucode_init; 914 struct fw_img ucode_wowlan; 915 916 enum iwlagn_ucode_type ucode_type; 917 u8 ucode_write_complete; /* the image write is complete */ 918 char firmware_name[25]; 919 920 struct iwl_rxon_context contexts[NUM_IWL_RXON_CTX]; 921 922 __le16 switch_channel; 923 924 struct { 925 u32 error_event_table; 926 u32 log_event_table; 927 } device_pointers; 928 929 u16 active_rate; 930 931 u8 start_calib; 932 struct iwl_sensitivity_data sensitivity_data; 933 struct iwl_chain_noise_data chain_noise_data; 934 bool enhance_sensitivity_table; 935 __le16 sensitivity_tbl[HD_TABLE_SIZE]; 936 __le16 enhance_sensitivity_tbl[ENHANCE_HD_TABLE_ENTRIES]; 937 938 struct iwl_ht_config current_ht_config; 939 940 /* Rate scaling data */ 941 u8 retry_rate; 942 943 int activity_timer_active; 944 945 /* counts mgmt, ctl, and data packets */ 946 struct traffic_stats tx_stats; 947 struct traffic_stats rx_stats; 948 949 struct iwl_power_mgr power_data; 950 struct iwl_tt_mgmt thermal_throttle; 951 952 /* station table variables */ 953 int num_stations; 954 struct iwl_station_entry stations[IWLAGN_STATION_COUNT]; 955 unsigned long ucode_key_table; 956 957 u8 mac80211_registered; 958 959 /* Indication if ieee80211_ops->open has been called */ 960 u8 is_open; 961 962 /* eeprom -- this is in the card's little endian byte order */ 963 u8 *eeprom; 964 int nvm_device_type; 965 struct iwl_eeprom_calib_info *calib_info; 966 967 enum nl80211_iftype iw_mode; 968 969 /* Last Rx'd beacon timestamp */ 970 u64 timestamp; 971 972 struct { 973 __le32 flag; 974 struct statistics_general_common common; 975 struct statistics_rx_non_phy rx_non_phy; 976 struct statistics_rx_phy rx_ofdm; 977 struct statistics_rx_ht_phy rx_ofdm_ht; 978 struct statistics_rx_phy rx_cck; 979 struct statistics_tx tx; 980#ifdef CONFIG_IWLWIFI_DEBUGFS 981 struct statistics_bt_activity bt_activity; 982 __le32 num_bt_kills, accum_num_bt_kills; 983#endif 984 } statistics; 985#ifdef CONFIG_IWLWIFI_DEBUGFS 986 struct { 987 struct statistics_general_common common; 988 struct statistics_rx_non_phy rx_non_phy; 989 struct statistics_rx_phy rx_ofdm; 990 struct statistics_rx_ht_phy rx_ofdm_ht; 991 struct statistics_rx_phy rx_cck; 992 struct statistics_tx tx; 993 struct statistics_bt_activity bt_activity; 994 } accum_stats, delta_stats, max_delta_stats; 995#endif 996 997 /* 998 * reporting the number of tids has AGG on. 0 means 999 * no AGGREGATION 1000 */ 1001 u8 agg_tids_count; 1002 1003 struct iwl_rx_phy_res last_phy_res; 1004 bool last_phy_res_valid; 1005 1006 struct completion firmware_loading_complete; 1007 1008 u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr; 1009 u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr; 1010 1011 /* 1012 * chain noise reset and gain commands are the 1013 * two extra calibration commands follows the standard 1014 * phy calibration commands 1015 */ 1016 u8 phy_calib_chain_noise_reset_cmd; 1017 u8 phy_calib_chain_noise_gain_cmd; 1018 1019 /* counts reply_tx error */ 1020 struct reply_tx_error_statistics reply_tx_stats; 1021 struct reply_agg_tx_error_statistics reply_agg_tx_stats; 1022 /* notification wait support */ 1023 struct list_head notif_waits; 1024 spinlock_t notif_wait_lock; 1025 wait_queue_head_t notif_waitq; 1026 1027 /* remain-on-channel offload support */ 1028 struct ieee80211_channel *hw_roc_channel; 1029 struct delayed_work hw_roc_disable_work; 1030 enum nl80211_channel_type hw_roc_chantype; 1031 int hw_roc_duration; 1032 bool hw_roc_setup, hw_roc_start_notified; 1033 1034 /* bt coex */ 1035 u8 bt_enable_flag; 1036 u8 bt_status; 1037 u8 bt_traffic_load, last_bt_traffic_load; 1038 bool bt_ch_announce; 1039 bool bt_full_concurrent; 1040 bool bt_ant_couple_ok; 1041 __le32 kill_ack_mask; 1042 __le32 kill_cts_mask; 1043 __le16 bt_valid; 1044 u16 bt_on_thresh; 1045 u16 bt_duration; 1046 u16 dynamic_frag_thresh; 1047 u8 bt_ci_compliance; 1048 struct work_struct bt_traffic_change_work; 1049 bool bt_enable_pspoll; 1050 struct iwl_rxon_context *cur_rssi_ctx; 1051 bool bt_is_sco; 1052 1053 struct work_struct restart; 1054 struct work_struct scan_completed; 1055 struct work_struct abort_scan; 1056 1057 struct work_struct beacon_update; 1058 struct iwl_rxon_context *beacon_ctx; 1059 struct sk_buff *beacon_skb; 1060 void *beacon_cmd; 1061 1062 struct work_struct tt_work; 1063 struct work_struct ct_enter; 1064 struct work_struct ct_exit; 1065 struct work_struct start_internal_scan; 1066 struct work_struct tx_flush; 1067 struct work_struct bt_full_concurrency; 1068 struct work_struct bt_runtime_config; 1069 1070 struct delayed_work scan_check; 1071 1072 /* TX Power */ 1073 s8 tx_power_user_lmt; 1074 s8 tx_power_device_lmt; 1075 s8 tx_power_lmt_in_half_dbm; /* max tx power in half-dBm format */ 1076 s8 tx_power_next; 1077 1078#ifdef CONFIG_IWLWIFI_DEBUGFS 1079 /* debugfs */ 1080 u16 tx_traffic_idx; 1081 u16 rx_traffic_idx; 1082 u8 *tx_traffic; 1083 u8 *rx_traffic; 1084 struct dentry *debugfs_dir; 1085 u32 dbgfs_sram_offset, dbgfs_sram_len; 1086 bool disable_ht40; 1087 void *wowlan_sram; 1088#endif /* CONFIG_IWLWIFI_DEBUGFS */ 1089 1090 struct work_struct txpower_work; 1091 u32 disable_sens_cal; 1092 u32 disable_chain_noise_cal; 1093 struct work_struct run_time_calib_work; 1094 struct timer_list statistics_periodic; 1095 struct timer_list ucode_trace; 1096 struct timer_list watchdog; 1097 1098 struct iwl_event_log event_log; 1099 1100 struct led_classdev led; 1101 unsigned long blink_on, blink_off; 1102 bool led_registered; 1103#ifdef CONFIG_IWLWIFI_DEVICE_SVTOOL 1104 struct iwl_testmode_trace testmode_trace; 1105 u32 tm_fixed_rate; 1106#endif 1107 1108 /* WoWLAN GTK rekey data */ 1109 u8 kck[NL80211_KCK_LEN], kek[NL80211_KEK_LEN]; 1110 __le64 replay_ctr; 1111 __le16 last_seq_ctl; 1112 bool have_rekey_data; 1113}; /*iwl_priv */ 1114 1115extern struct iwl_mod_params iwlagn_mod_params; 1116 1117static inline struct iwl_rxon_context * 1118iwl_rxon_ctx_from_vif(struct ieee80211_vif *vif) 1119{ 1120 struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv; 1121 1122 return vif_priv->ctx; 1123} 1124 1125#define for_each_context(priv, ctx) \ 1126 for (ctx = &priv->contexts[IWL_RXON_CTX_BSS]; \ 1127 ctx < &priv->contexts[NUM_IWL_RXON_CTX]; ctx++) \ 1128 if (priv->shrd->valid_contexts & BIT(ctx->ctxid)) 1129 1130static inline int iwl_is_associated_ctx(struct iwl_rxon_context *ctx) 1131{ 1132 return (ctx->active.filter_flags & RXON_FILTER_ASSOC_MSK) ? 1 : 0; 1133} 1134 1135static inline int iwl_is_associated(struct iwl_priv *priv, 1136 enum iwl_rxon_context_id ctxid) 1137{ 1138 return iwl_is_associated_ctx(&priv->contexts[ctxid]); 1139} 1140 1141static inline int iwl_is_any_associated(struct iwl_priv *priv) 1142{ 1143 struct iwl_rxon_context *ctx; 1144 for_each_context(priv, ctx) 1145 if (iwl_is_associated_ctx(ctx)) 1146 return true; 1147 return false; 1148} 1149 1150static inline int is_channel_valid(const struct iwl_channel_info *ch_info) 1151{ 1152 if (ch_info == NULL) 1153 return 0; 1154 return (ch_info->flags & EEPROM_CHANNEL_VALID) ? 1 : 0; 1155} 1156 1157static inline int is_channel_radar(const struct iwl_channel_info *ch_info) 1158{ 1159 return (ch_info->flags & EEPROM_CHANNEL_RADAR) ? 1 : 0; 1160} 1161 1162static inline u8 is_channel_a_band(const struct iwl_channel_info *ch_info) 1163{ 1164 return ch_info->band == IEEE80211_BAND_5GHZ; 1165} 1166 1167static inline u8 is_channel_bg_band(const struct iwl_channel_info *ch_info) 1168{ 1169 return ch_info->band == IEEE80211_BAND_2GHZ; 1170} 1171 1172static inline int is_channel_passive(const struct iwl_channel_info *ch) 1173{ 1174 return (!(ch->flags & EEPROM_CHANNEL_ACTIVE)) ? 1 : 0; 1175} 1176 1177static inline int is_channel_ibss(const struct iwl_channel_info *ch) 1178{ 1179 return ((ch->flags & EEPROM_CHANNEL_IBSS)) ? 1 : 0; 1180} 1181 1182#endif /* __iwl_dev_h__ */ 1183