iwl-shared.h revision 76bc10fcd128ad028cf77c62e179cd20dc2ffecf
1/****************************************************************************** 2 * 3 * This file is provided under a dual BSD/GPLv2 license. When using or 4 * redistributing this file, you may do so under either license. 5 * 6 * GPL LICENSE SUMMARY 7 * 8 * Copyright(c) 2007 - 2011 Intel Corporation. All rights reserved. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of version 2 of the GNU General Public License as 12 * published by the Free Software Foundation. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, 22 * USA 23 * 24 * The full GNU General Public License is included in this distribution 25 * in the file called LICENSE.GPL. 26 * 27 * Contact Information: 28 * Intel Linux Wireless <ilw@linux.intel.com> 29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 30 * 31 * BSD LICENSE 32 * 33 * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved. 34 * All rights reserved. 35 * 36 * Redistribution and use in source and binary forms, with or without 37 * modification, are permitted provided that the following conditions 38 * are met: 39 * 40 * * Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * * Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in 44 * the documentation and/or other materials provided with the 45 * distribution. 46 * * Neither the name Intel Corporation nor the names of its 47 * contributors may be used to endorse or promote products derived 48 * from this software without specific prior written permission. 49 * 50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 61 * 62 *****************************************************************************/ 63#ifndef __iwl_shared_h__ 64#define __iwl_shared_h__ 65 66#include <linux/types.h> 67#include <linux/spinlock.h> 68#include <linux/mutex.h> 69#include <linux/gfp.h> 70#include <linux/mm.h> /* for page_address */ 71#include <net/mac80211.h> 72 73#include "iwl-commands.h" 74 75/** 76 * DOC: shared area - role and goal 77 * 78 * The shared area contains all the data exported by the upper layer to the 79 * other layers. Since the bus and transport layer shouldn't dereference 80 * iwl_priv, all the data needed by the upper layer and the transport / bus 81 * layer must be here. 82 * The shared area also holds pointer to all the other layers. This allows a 83 * layer to call a function from another layer. 84 * 85 * NOTE: All the layers hold a pointer to the shared area which must be shrd. 86 * A few macros assume that (_m)->shrd points to the shared area no matter 87 * what _m is. 88 * 89 * gets notifications about enumeration, suspend, resume. 90 * For the moment, the bus layer is not a linux kernel module as itself, and 91 * the module_init function of the driver must call the bus specific 92 * registration functions. These functions are listed at the end of this file. 93 * For the moment, there is only one implementation of this interface: PCI-e. 94 * This implementation is iwl-pci.c 95 */ 96 97struct iwl_bus; 98struct iwl_priv; 99struct iwl_trans; 100struct iwl_sensitivity_ranges; 101struct iwl_trans_ops; 102 103#define DRV_NAME "iwlwifi" 104#define IWLWIFI_VERSION "in-tree:" 105#define DRV_COPYRIGHT "Copyright(c) 2003-2011 Intel Corporation" 106#define DRV_AUTHOR "<ilw@linux.intel.com>" 107 108extern struct iwl_mod_params iwlagn_mod_params; 109 110/** 111 * struct iwl_mod_params 112 * 113 * Holds the module parameters 114 * 115 * @sw_crypto: using hardware encryption, default = 0 116 * @num_of_queues: number of tx queue, HW dependent 117 * @disable_11n: 11n capabilities enabled, default = 0 118 * @amsdu_size_8K: enable 8K amsdu size, default = 1 119 * @antenna: both antennas (use diversity), default = 0 120 * @restart_fw: restart firmware, default = 1 121 * @plcp_check: enable plcp health check, default = true 122 * @ack_check: disable ack health check, default = false 123 * @wd_disable: enable stuck queue check, default = 0 124 * @bt_coex_active: enable bt coex, default = true 125 * @led_mode: system default, default = 0 126 * @no_sleep_autoadjust: disable autoadjust, default = true 127 * @power_save: disable power save, default = false 128 * @power_level: power level, default = 1 129 * @debug_level: levels are IWL_DL_* 130 * @ant_coupling: antenna coupling in dB, default = 0 131 * @bt_ch_announce: BT channel inhibition, default = enable 132 * @wanted_ucode_alternative: ucode alternative to use, default = 1 133 * @auto_agg: enable agg. without check, default = true 134 */ 135struct iwl_mod_params { 136 int sw_crypto; 137 int num_of_queues; 138 int disable_11n; 139 int amsdu_size_8K; 140 int antenna; 141 int restart_fw; 142 bool plcp_check; 143 bool ack_check; 144 int wd_disable; 145 bool bt_coex_active; 146 int led_mode; 147 bool no_sleep_autoadjust; 148 bool power_save; 149 int power_level; 150 u32 debug_level; 151 int ant_coupling; 152 bool bt_ch_announce; 153 int wanted_ucode_alternative; 154 bool auto_agg; 155}; 156 157/** 158 * struct iwl_hw_params 159 * 160 * Holds the module parameters 161 * 162 * @max_txq_num: Max # Tx queues supported 163 * @num_ampdu_queues: num of ampdu queues 164 * @tx_chains_num: Number of TX chains 165 * @rx_chains_num: Number of RX chains 166 * @valid_tx_ant: usable antennas for TX 167 * @valid_rx_ant: usable antennas for RX 168 * @ht40_channel: is 40MHz width possible: BIT(IEEE80211_BAND_XXX) 169 * @sku: sku read from EEPROM 170 * @rx_page_order: Rx buffer page order 171 * @max_inst_size: for ucode use 172 * @max_data_size: for ucode use 173 * @ct_kill_threshold: temperature threshold - in hw dependent unit 174 * @ct_kill_exit_threshold: when to reeable the device - in hw dependent unit 175 * relevant for 1000, 6000 and up 176 * @wd_timeout: TX queues watchdog timeout 177 * @calib_rt_cfg: setup runtime calibrations for the hw 178 * @struct iwl_sensitivity_ranges: range of sensitivity values 179 */ 180struct iwl_hw_params { 181 u8 max_txq_num; 182 u8 num_ampdu_queues; 183 u8 tx_chains_num; 184 u8 rx_chains_num; 185 u8 valid_tx_ant; 186 u8 valid_rx_ant; 187 u8 ht40_channel; 188 bool shadow_reg_enable; 189 u16 sku; 190 u32 rx_page_order; 191 u32 max_inst_size; 192 u32 max_data_size; 193 u32 ct_kill_threshold; 194 u32 ct_kill_exit_threshold; 195 unsigned int wd_timeout; 196 197 u32 calib_rt_cfg; 198 const struct iwl_sensitivity_ranges *sens; 199}; 200 201/** 202 * enum iwl_agg_state 203 * 204 * The state machine of the BA agreement establishment / tear down. 205 * These states relate to a specific RA / TID. 206 * 207 * @IWL_AGG_OFF: aggregation is not used 208 * @IWL_AGG_ON: aggregation session is up 209 * @IWL_EMPTYING_HW_QUEUE_ADDBA: establishing a BA session - waiting for the 210 * HW queue to be empty from packets for this RA /TID. 211 * @IWL_EMPTYING_HW_QUEUE_DELBA: tearing down a BA session - waiting for the 212 * HW queue to be empty from packets for this RA /TID. 213 */ 214enum iwl_agg_state { 215 IWL_AGG_OFF = 0, 216 IWL_AGG_ON, 217 IWL_EMPTYING_HW_QUEUE_ADDBA, 218 IWL_EMPTYING_HW_QUEUE_DELBA, 219}; 220 221/** 222 * struct iwl_ht_agg - aggregation state machine 223 224 * This structs holds the states for the BA agreement establishment and tear 225 * down. It also holds the state during the BA session itself. This struct is 226 * duplicated for each RA / TID. 227 228 * @rate_n_flags: Rate at which Tx was attempted. Holds the data between the 229 * Tx response (REPLY_TX), and the block ack notification 230 * (REPLY_COMPRESSED_BA). 231 * @state: state of the BA agreement establishment / tear down. 232 * @ssn: the first packet to be sent in AGG HW queue in Tx AGG start flow, or 233 * the first packet to be sent in legacy HW queue in Tx AGG stop flow. 234 * Basically when next_reclaimed reaches ssn, we can tell mac80211 that 235 * we are ready to finish the Tx AGG stop / start flow. 236 * @wait_for_ba: Expect block-ack before next Tx reply 237 */ 238struct iwl_ht_agg { 239 u32 rate_n_flags; 240 enum iwl_agg_state state; 241 u16 ssn; 242 bool wait_for_ba; 243}; 244 245/** 246 * struct iwl_tid_data - one for each RA / TID 247 248 * This structs holds the states for each RA / TID. 249 250 * @seq_number: the next WiFi sequence number to use 251 * @next_reclaimed: the WiFi sequence number of the next packet to be acked. 252 * This is basically (last acked packet++). 253 * @agg: aggregation state machine 254 */ 255struct iwl_tid_data { 256 u16 seq_number; 257 u16 next_reclaimed; 258 struct iwl_ht_agg agg; 259}; 260 261/** 262 * enum iwl_ucode_type 263 * 264 * The type of ucode currently loaded on the hardware. 265 * 266 * @IWL_UCODE_NONE: No ucode loaded 267 * @IWL_UCODE_REGULAR: Normal runtime ucode 268 * @IWL_UCODE_INIT: Initial ucode 269 * @IWL_UCODE_WOWLAN: Wake on Wireless enabled ucode 270 */ 271enum iwl_ucode_type { 272 IWL_UCODE_NONE, 273 IWL_UCODE_REGULAR, 274 IWL_UCODE_INIT, 275 IWL_UCODE_WOWLAN, 276}; 277 278/** 279 * struct iwl_notification_wait - notification wait entry 280 * @list: list head for global list 281 * @fn: function called with the notification 282 * @cmd: command ID 283 * 284 * This structure is not used directly, to wait for a 285 * notification declare it on the stack, and call 286 * iwlagn_init_notification_wait() with appropriate 287 * parameters. Then do whatever will cause the ucode 288 * to notify the driver, and to wait for that then 289 * call iwlagn_wait_notification(). 290 * 291 * Each notification is one-shot. If at some point we 292 * need to support multi-shot notifications (which 293 * can't be allocated on the stack) we need to modify 294 * the code for them. 295 */ 296struct iwl_notification_wait { 297 struct list_head list; 298 299 void (*fn)(struct iwl_trans *trans, struct iwl_rx_packet *pkt, 300 void *data); 301 void *fn_data; 302 303 u8 cmd; 304 bool triggered, aborted; 305}; 306 307/** 308 * enum iwl_pa_type - Power Amplifier type 309 * @IWL_PA_SYSTEM: based on uCode configuration 310 * @IWL_PA_INTERNAL: use Internal only 311 */ 312enum iwl_pa_type { 313 IWL_PA_SYSTEM = 0, 314 IWL_PA_INTERNAL = 1, 315}; 316 317/* 318 * LED mode 319 * IWL_LED_DEFAULT: use device default 320 * IWL_LED_RF_STATE: turn LED on/off based on RF state 321 * LED ON = RF ON 322 * LED OFF = RF OFF 323 * IWL_LED_BLINK: adjust led blink rate based on blink table 324 */ 325enum iwl_led_mode { 326 IWL_LED_DEFAULT, 327 IWL_LED_RF_STATE, 328 IWL_LED_BLINK, 329}; 330 331/** 332 * struct iwl_cfg 333 * @name: Offical name of the device 334 * @fw_name_pre: Firmware filename prefix. The api version and extension 335 * (.ucode) will be added to filename before loading from disk. The 336 * filename is constructed as fw_name_pre<api>.ucode. 337 * @ucode_api_max: Highest version of uCode API supported by driver. 338 * @ucode_api_ok: oldest version of the uCode API that is OK to load 339 * without a warning, for use in transitions 340 * @ucode_api_min: Lowest version of uCode API supported by driver. 341 * @valid_tx_ant: valid transmit antenna 342 * @valid_rx_ant: valid receive antenna 343 * @sku: sku information from EEPROM 344 * @eeprom_ver: EEPROM version 345 * @eeprom_calib_ver: EEPROM calibration version 346 * @lib: pointer to the lib ops 347 * @additional_nic_config: additional nic configuration 348 * @base_params: pointer to basic parameters 349 * @ht_params: point to ht patameters 350 * @bt_params: pointer to bt parameters 351 * @pa_type: used by 6000 series only to identify the type of Power Amplifier 352 * @need_temp_offset_calib: need to perform temperature offset calibration 353 * @no_xtal_calib: some devices do not need crystal calibration data, 354 * don't send it to those 355 * @scan_rx_antennas: available antenna for scan operation 356 * @led_mode: 0=blinking, 1=On(RF On)/Off(RF Off) 357 * @adv_pm: advance power management 358 * @rx_with_siso_diversity: 1x1 device with rx antenna diversity 359 * @internal_wimax_coex: internal wifi/wimax combo device 360 * @iq_invert: I/Q inversion 361 * @temp_offset_v2: support v2 of temperature offset calibration 362 * 363 * We enable the driver to be backward compatible wrt API version. The 364 * driver specifies which APIs it supports (with @ucode_api_max being the 365 * highest and @ucode_api_min the lowest). Firmware will only be loaded if 366 * it has a supported API version. 367 * 368 * The ideal usage of this infrastructure is to treat a new ucode API 369 * release as a new hardware revision. 370 */ 371struct iwl_cfg { 372 /* params specific to an individual device within a device family */ 373 const char *name; 374 const char *fw_name_pre; 375 const unsigned int ucode_api_max; 376 const unsigned int ucode_api_ok; 377 const unsigned int ucode_api_min; 378 u8 valid_tx_ant; 379 u8 valid_rx_ant; 380 u16 sku; 381 u16 eeprom_ver; 382 u16 eeprom_calib_ver; 383 const struct iwl_lib_ops *lib; 384 void (*additional_nic_config)(struct iwl_priv *priv); 385 /* params not likely to change within a device family */ 386 struct iwl_base_params *base_params; 387 /* params likely to change within a device family */ 388 struct iwl_ht_params *ht_params; 389 struct iwl_bt_params *bt_params; 390 enum iwl_pa_type pa_type; /* if used set to IWL_PA_SYSTEM */ 391 const bool need_temp_offset_calib; /* if used set to true */ 392 const bool no_xtal_calib; 393 u8 scan_rx_antennas[IEEE80211_NUM_BANDS]; 394 enum iwl_led_mode led_mode; 395 const bool adv_pm; 396 const bool rx_with_siso_diversity; 397 const bool internal_wimax_coex; 398 const bool iq_invert; 399 const bool temp_offset_v2; 400}; 401 402/** 403 * struct iwl_shared - shared fields for all the layers of the driver 404 * 405 * @dbg_level_dev: dbg level set per device. Prevails on 406 * iwlagn_mod_params.debug_level if set (!= 0) 407 * @ucode_owner: IWL_OWNERSHIP_* 408 * @cmd_queue: command queue number 409 * @status: STATUS_* 410 * @valid_contexts: microcode/device supports multiple contexts 411 * @bus: pointer to the bus layer data 412 * @cfg: see struct iwl_cfg 413 * @priv: pointer to the upper layer data 414 * @hw_params: see struct iwl_hw_params 415 * @workqueue: the workqueue used by all the layers of the driver 416 * @lock: protect general shared data 417 * @sta_lock: protects the station table. 418 * If lock and sta_lock are needed, lock must be acquired first. 419 * @mutex: 420 * @eeprom: pointer to the eeprom/OTP image 421 * @ucode_type: indicator of loaded ucode image 422 * @notif_waits: things waiting for notification 423 * @notif_wait_lock: lock protecting notification 424 * @notif_waitq: head of notification wait queue 425 * @device_pointers: pointers to ucode event tables 426 */ 427struct iwl_shared { 428#ifdef CONFIG_IWLWIFI_DEBUG 429 u32 dbg_level_dev; 430#endif /* CONFIG_IWLWIFI_DEBUG */ 431 432#define IWL_OWNERSHIP_DRIVER 0 433#define IWL_OWNERSHIP_TM 1 434 u8 ucode_owner; 435 u8 cmd_queue; 436 unsigned long status; 437 bool wowlan; 438 u8 valid_contexts; 439 440 struct iwl_bus *bus; 441 struct iwl_cfg *cfg; 442 struct iwl_priv *priv; 443 struct iwl_trans *trans; 444 struct iwl_hw_params hw_params; 445 446 struct workqueue_struct *workqueue; 447 spinlock_t lock; 448 spinlock_t sta_lock; 449 struct mutex mutex; 450 451 struct iwl_tid_data tid_data[IWLAGN_STATION_COUNT][IWL_MAX_TID_COUNT]; 452 453 wait_queue_head_t wait_command_queue; 454 455 /* eeprom -- this is in the card's little endian byte order */ 456 u8 *eeprom; 457 458 /* ucode related variables */ 459 enum iwl_ucode_type ucode_type; 460 461 /* notification wait support */ 462 struct list_head notif_waits; 463 spinlock_t notif_wait_lock; 464 wait_queue_head_t notif_waitq; 465 466 struct { 467 u32 error_event_table; 468 u32 log_event_table; 469 } device_pointers; 470 471}; 472 473/*Whatever _m is (iwl_trans, iwl_priv, iwl_bus, these macros will work */ 474#define priv(_m) ((_m)->shrd->priv) 475#define cfg(_m) ((_m)->shrd->cfg) 476#define bus(_m) ((_m)->shrd->bus) 477#define trans(_m) ((_m)->shrd->trans) 478#define hw_params(_m) ((_m)->shrd->hw_params) 479 480#ifdef CONFIG_IWLWIFI_DEBUG 481/* 482 * iwl_get_debug_level: Return active debug level for device 483 * 484 * Using sysfs it is possible to set per device debug level. This debug 485 * level will be used if set, otherwise the global debug level which can be 486 * set via module parameter is used. 487 */ 488static inline u32 iwl_get_debug_level(struct iwl_shared *shrd) 489{ 490 if (shrd->dbg_level_dev) 491 return shrd->dbg_level_dev; 492 else 493 return iwlagn_mod_params.debug_level; 494} 495#else 496static inline u32 iwl_get_debug_level(struct iwl_shared *shrd) 497{ 498 return iwlagn_mod_params.debug_level; 499} 500#endif 501 502static inline void iwl_free_pages(struct iwl_shared *shrd, unsigned long page) 503{ 504 free_pages(page, shrd->hw_params.rx_page_order); 505} 506 507/** 508 * iwl_queue_inc_wrap - increment queue index, wrap back to beginning 509 * @index -- current index 510 * @n_bd -- total number of entries in queue (must be power of 2) 511 */ 512static inline int iwl_queue_inc_wrap(int index, int n_bd) 513{ 514 return ++index & (n_bd - 1); 515} 516 517/** 518 * iwl_queue_dec_wrap - decrement queue index, wrap back to end 519 * @index -- current index 520 * @n_bd -- total number of entries in queue (must be power of 2) 521 */ 522static inline int iwl_queue_dec_wrap(int index, int n_bd) 523{ 524 return --index & (n_bd - 1); 525} 526 527struct iwl_rx_mem_buffer { 528 dma_addr_t page_dma; 529 struct page *page; 530 struct list_head list; 531}; 532 533#define rxb_addr(r) page_address(r->page) 534 535/* 536 * mac80211 queues, ACs, hardware queues, FIFOs. 537 * 538 * Cf. http://wireless.kernel.org/en/developers/Documentation/mac80211/queues 539 * 540 * Mac80211 uses the following numbers, which we get as from it 541 * by way of skb_get_queue_mapping(skb): 542 * 543 * VO 0 544 * VI 1 545 * BE 2 546 * BK 3 547 * 548 * 549 * Regular (not A-MPDU) frames are put into hardware queues corresponding 550 * to the FIFOs, see comments in iwl-prph.h. Aggregated frames get their 551 * own queue per aggregation session (RA/TID combination), such queues are 552 * set up to map into FIFOs too, for which we need an AC->FIFO mapping. In 553 * order to map frames to the right queue, we also need an AC->hw queue 554 * mapping. This is implemented here. 555 * 556 * Due to the way hw queues are set up (by the hw specific modules like 557 * iwl-4965.c, iwl-5000.c etc.), the AC->hw queue mapping is the identity 558 * mapping. 559 */ 560 561static const u8 tid_to_ac[] = { 562 IEEE80211_AC_BE, 563 IEEE80211_AC_BK, 564 IEEE80211_AC_BK, 565 IEEE80211_AC_BE, 566 IEEE80211_AC_VI, 567 IEEE80211_AC_VI, 568 IEEE80211_AC_VO, 569 IEEE80211_AC_VO 570}; 571 572static inline int get_ac_from_tid(u16 tid) 573{ 574 if (likely(tid < ARRAY_SIZE(tid_to_ac))) 575 return tid_to_ac[tid]; 576 577 /* no support for TIDs 8-15 yet */ 578 return -EINVAL; 579} 580 581enum iwl_rxon_context_id { 582 IWL_RXON_CTX_BSS, 583 IWL_RXON_CTX_PAN, 584 585 NUM_IWL_RXON_CTX 586}; 587 588int iwl_probe(struct iwl_bus *bus, const struct iwl_trans_ops *trans_ops, 589 struct iwl_cfg *cfg); 590void __devexit iwl_remove(struct iwl_priv * priv); 591struct iwl_device_cmd; 592int __must_check iwl_rx_dispatch(struct iwl_priv *priv, 593 struct iwl_rx_mem_buffer *rxb, 594 struct iwl_device_cmd *cmd); 595 596int iwlagn_hw_valid_rtc_data_addr(u32 addr); 597void iwl_start_tx_ba_trans_ready(struct iwl_priv *priv, 598 enum iwl_rxon_context_id ctx, 599 u8 sta_id, u8 tid); 600void iwl_stop_tx_ba_trans_ready(struct iwl_priv *priv, 601 enum iwl_rxon_context_id ctx, 602 u8 sta_id, u8 tid); 603void iwl_set_hw_rfkill_state(struct iwl_priv *priv, bool state); 604void iwl_nic_config(struct iwl_priv *priv); 605void iwl_free_skb(struct iwl_priv *priv, struct sk_buff *skb); 606void iwl_apm_stop(struct iwl_priv *priv); 607int iwl_apm_init(struct iwl_priv *priv); 608void iwlagn_fw_error(struct iwl_priv *priv, bool ondemand); 609const char *get_cmd_string(u8 cmd); 610bool iwl_check_for_ct_kill(struct iwl_priv *priv); 611 612void iwl_stop_sw_queue(struct iwl_priv *priv, u8 ac); 613void iwl_wake_sw_queue(struct iwl_priv *priv, u8 ac); 614 615/* notification wait support */ 616void iwl_abort_notification_waits(struct iwl_shared *shrd); 617void __acquires(wait_entry) 618iwl_init_notification_wait(struct iwl_shared *shrd, 619 struct iwl_notification_wait *wait_entry, 620 u8 cmd, 621 void (*fn)(struct iwl_trans *trans, 622 struct iwl_rx_packet *pkt, 623 void *data), 624 void *fn_data); 625int __must_check __releases(wait_entry) 626iwl_wait_notification(struct iwl_shared *shrd, 627 struct iwl_notification_wait *wait_entry, 628 unsigned long timeout); 629void __releases(wait_entry) 630iwl_remove_notification(struct iwl_shared *shrd, 631 struct iwl_notification_wait *wait_entry); 632 633#ifdef CONFIG_IWLWIFI_DEBUGFS 634void iwl_reset_traffic_log(struct iwl_priv *priv); 635#endif /* CONFIG_IWLWIFI_DEBUGFS */ 636 637#ifdef CONFIG_IWLWIFI_DEBUG 638void iwl_print_rx_config_cmd(struct iwl_priv *priv, 639 enum iwl_rxon_context_id ctxid); 640#else 641static inline void iwl_print_rx_config_cmd(struct iwl_priv *priv, 642 enum iwl_rxon_context_id ctxid) 643{ 644} 645#endif 646 647#define IWL_CMD(x) case x: return #x 648#define IWL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo)))) 649 650#define IWL_TRAFFIC_ENTRIES (256) 651#define IWL_TRAFFIC_ENTRY_SIZE (64) 652 653/***************************************************** 654* DRIVER STATUS FUNCTIONS 655******************************************************/ 656#define STATUS_HCMD_ACTIVE 0 /* host command in progress */ 657/* 1 is unused (used to be STATUS_HCMD_SYNC_ACTIVE) */ 658#define STATUS_INT_ENABLED 2 659#define STATUS_RF_KILL_HW 3 660#define STATUS_CT_KILL 4 661#define STATUS_INIT 5 662#define STATUS_ALIVE 6 663#define STATUS_READY 7 664#define STATUS_TEMPERATURE 8 665#define STATUS_GEO_CONFIGURED 9 666#define STATUS_EXIT_PENDING 10 667#define STATUS_STATISTICS 12 668#define STATUS_SCANNING 13 669#define STATUS_SCAN_ABORTING 14 670#define STATUS_SCAN_HW 15 671#define STATUS_POWER_PMI 16 672#define STATUS_FW_ERROR 17 673#define STATUS_DEVICE_ENABLED 18 674#define STATUS_CHANNEL_SWITCH_PENDING 19 675#define STATUS_SCAN_COMPLETE 20 676 677static inline int iwl_is_ready(struct iwl_shared *shrd) 678{ 679 /* The adapter is 'ready' if READY and GEO_CONFIGURED bits are 680 * set but EXIT_PENDING is not */ 681 return test_bit(STATUS_READY, &shrd->status) && 682 test_bit(STATUS_GEO_CONFIGURED, &shrd->status) && 683 !test_bit(STATUS_EXIT_PENDING, &shrd->status); 684} 685 686static inline int iwl_is_alive(struct iwl_shared *shrd) 687{ 688 return test_bit(STATUS_ALIVE, &shrd->status); 689} 690 691static inline int iwl_is_init(struct iwl_shared *shrd) 692{ 693 return test_bit(STATUS_INIT, &shrd->status); 694} 695 696static inline int iwl_is_rfkill_hw(struct iwl_shared *shrd) 697{ 698 return test_bit(STATUS_RF_KILL_HW, &shrd->status); 699} 700 701static inline int iwl_is_rfkill(struct iwl_shared *shrd) 702{ 703 return iwl_is_rfkill_hw(shrd); 704} 705 706static inline int iwl_is_ctkill(struct iwl_shared *shrd) 707{ 708 return test_bit(STATUS_CT_KILL, &shrd->status); 709} 710 711static inline int iwl_is_ready_rf(struct iwl_shared *shrd) 712{ 713 if (iwl_is_rfkill(shrd)) 714 return 0; 715 716 return iwl_is_ready(shrd); 717} 718 719#endif /* #__iwl_shared_h__ */ 720