rt2x00.h revision e74df4a7562da56a7e4dbf41ff167b2f44e84a50
1/* 2 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com> 3 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com> 4 Copyright (C) 2004 - 2009 Gertjan van Wingerde <gwingerde@gmail.com> 5 <http://rt2x00.serialmonkey.com> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the 19 Free Software Foundation, Inc., 20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 21 */ 22 23/* 24 Module: rt2x00 25 Abstract: rt2x00 global information. 26 */ 27 28#ifndef RT2X00_H 29#define RT2X00_H 30 31#include <linux/bitops.h> 32#include <linux/skbuff.h> 33#include <linux/workqueue.h> 34#include <linux/firmware.h> 35#include <linux/leds.h> 36#include <linux/mutex.h> 37#include <linux/etherdevice.h> 38#include <linux/input-polldev.h> 39#include <linux/kfifo.h> 40 41#include <net/mac80211.h> 42 43#include "rt2x00debug.h" 44#include "rt2x00dump.h" 45#include "rt2x00leds.h" 46#include "rt2x00reg.h" 47#include "rt2x00queue.h" 48 49/* 50 * Module information. 51 */ 52#define DRV_VERSION "2.3.0" 53#define DRV_PROJECT "http://rt2x00.serialmonkey.com" 54 55/* 56 * Debug definitions. 57 * Debug output has to be enabled during compile time. 58 */ 59#define DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, __args...) \ 60 printk(__kernlvl "%s -> %s: %s - " __msg, \ 61 wiphy_name((__dev)->hw->wiphy), __func__, __lvl, ##__args) 62 63#define DEBUG_PRINTK_PROBE(__kernlvl, __lvl, __msg, __args...) \ 64 printk(__kernlvl "%s -> %s: %s - " __msg, \ 65 KBUILD_MODNAME, __func__, __lvl, ##__args) 66 67#ifdef CONFIG_RT2X00_DEBUG 68#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...) \ 69 DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, ##__args) 70#else 71#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...) \ 72 do { } while (0) 73#endif /* CONFIG_RT2X00_DEBUG */ 74 75/* 76 * Various debug levels. 77 * The debug levels PANIC and ERROR both indicate serious problems, 78 * for this reason they should never be ignored. 79 * The special ERROR_PROBE message is for messages that are generated 80 * when the rt2x00_dev is not yet initialized. 81 */ 82#define PANIC(__dev, __msg, __args...) \ 83 DEBUG_PRINTK_MSG(__dev, KERN_CRIT, "Panic", __msg, ##__args) 84#define ERROR(__dev, __msg, __args...) \ 85 DEBUG_PRINTK_MSG(__dev, KERN_ERR, "Error", __msg, ##__args) 86#define ERROR_PROBE(__msg, __args...) \ 87 DEBUG_PRINTK_PROBE(KERN_ERR, "Error", __msg, ##__args) 88#define WARNING(__dev, __msg, __args...) \ 89 DEBUG_PRINTK(__dev, KERN_WARNING, "Warning", __msg, ##__args) 90#define NOTICE(__dev, __msg, __args...) \ 91 DEBUG_PRINTK(__dev, KERN_NOTICE, "Notice", __msg, ##__args) 92#define INFO(__dev, __msg, __args...) \ 93 DEBUG_PRINTK(__dev, KERN_INFO, "Info", __msg, ##__args) 94#define DEBUG(__dev, __msg, __args...) \ 95 DEBUG_PRINTK(__dev, KERN_DEBUG, "Debug", __msg, ##__args) 96#define EEPROM(__dev, __msg, __args...) \ 97 DEBUG_PRINTK(__dev, KERN_DEBUG, "EEPROM recovery", __msg, ##__args) 98 99/* 100 * Duration calculations 101 * The rate variable passed is: 100kbs. 102 * To convert from bytes to bits we multiply size with 8, 103 * then the size is multiplied with 10 to make the 104 * real rate -> rate argument correction. 105 */ 106#define GET_DURATION(__size, __rate) (((__size) * 8 * 10) / (__rate)) 107#define GET_DURATION_RES(__size, __rate)(((__size) * 8 * 10) % (__rate)) 108 109/* 110 * Determine the number of L2 padding bytes required between the header and 111 * the payload. 112 */ 113#define L2PAD_SIZE(__hdrlen) (-(__hdrlen) & 3) 114 115/* 116 * Determine the alignment requirement, 117 * to make sure the 802.11 payload is padded to a 4-byte boundrary 118 * we must determine the address of the payload and calculate the 119 * amount of bytes needed to move the data. 120 */ 121#define ALIGN_SIZE(__skb, __header) \ 122 ( ((unsigned long)((__skb)->data + (__header))) & 3 ) 123 124/* 125 * Constants for extra TX headroom for alignment purposes. 126 */ 127#define RT2X00_ALIGN_SIZE 4 /* Only whole frame needs alignment */ 128#define RT2X00_L2PAD_SIZE 8 /* Both header & payload need alignment */ 129 130/* 131 * Standard timing and size defines. 132 * These values should follow the ieee80211 specifications. 133 */ 134#define ACK_SIZE 14 135#define IEEE80211_HEADER 24 136#define PLCP 48 137#define BEACON 100 138#define PREAMBLE 144 139#define SHORT_PREAMBLE 72 140#define SLOT_TIME 20 141#define SHORT_SLOT_TIME 9 142#define SIFS 10 143#define PIFS ( SIFS + SLOT_TIME ) 144#define SHORT_PIFS ( SIFS + SHORT_SLOT_TIME ) 145#define DIFS ( PIFS + SLOT_TIME ) 146#define SHORT_DIFS ( SHORT_PIFS + SHORT_SLOT_TIME ) 147#define EIFS ( SIFS + DIFS + \ 148 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10) ) 149#define SHORT_EIFS ( SIFS + SHORT_DIFS + \ 150 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10) ) 151 152/* 153 * Structure for average calculation 154 * The avg field contains the actual average value, 155 * but avg_weight is internally used during calculations 156 * to prevent rounding errors. 157 */ 158struct avg_val { 159 int avg; 160 int avg_weight; 161}; 162 163enum rt2x00_chip_intf { 164 RT2X00_CHIP_INTF_PCI, 165 RT2X00_CHIP_INTF_PCIE, 166 RT2X00_CHIP_INTF_USB, 167 RT2X00_CHIP_INTF_SOC, 168}; 169 170/* 171 * Chipset identification 172 * The chipset on the device is composed of a RT and RF chip. 173 * The chipset combination is important for determining device capabilities. 174 */ 175struct rt2x00_chip { 176 u16 rt; 177#define RT2460 0x2460 178#define RT2560 0x2560 179#define RT2570 0x2570 180#define RT2661 0x2661 181#define RT2573 0x2573 182#define RT2860 0x2860 /* 2.4GHz */ 183#define RT2872 0x2872 /* WSOC */ 184#define RT2883 0x2883 /* WSOC */ 185#define RT3070 0x3070 186#define RT3071 0x3071 187#define RT3090 0x3090 /* 2.4GHz PCIe */ 188#define RT3390 0x3390 189#define RT3572 0x3572 190#define RT3593 0x3593 /* PCIe */ 191#define RT3883 0x3883 /* WSOC */ 192#define RT5390 0x5390 /* 2.4GHz */ 193 194 u16 rf; 195 u16 rev; 196 197 enum rt2x00_chip_intf intf; 198}; 199 200/* 201 * RF register values that belong to a particular channel. 202 */ 203struct rf_channel { 204 int channel; 205 u32 rf1; 206 u32 rf2; 207 u32 rf3; 208 u32 rf4; 209}; 210 211/* 212 * Channel information structure 213 */ 214struct channel_info { 215 unsigned int flags; 216#define GEOGRAPHY_ALLOWED 0x00000001 217 218 short max_power; 219 short default_power1; 220 short default_power2; 221}; 222 223/* 224 * Antenna setup values. 225 */ 226struct antenna_setup { 227 enum antenna rx; 228 enum antenna tx; 229 u8 rx_chain_num; 230 u8 tx_chain_num; 231}; 232 233/* 234 * Quality statistics about the currently active link. 235 */ 236struct link_qual { 237 /* 238 * Statistics required for Link tuning by driver 239 * The rssi value is provided by rt2x00lib during the 240 * link_tuner() callback function. 241 * The false_cca field is filled during the link_stats() 242 * callback function and could be used during the 243 * link_tuner() callback function. 244 */ 245 int rssi; 246 int false_cca; 247 248 /* 249 * VGC levels 250 * Hardware driver will tune the VGC level during each call 251 * to the link_tuner() callback function. This vgc_level is 252 * is determined based on the link quality statistics like 253 * average RSSI and the false CCA count. 254 * 255 * In some cases the drivers need to differentiate between 256 * the currently "desired" VGC level and the level configured 257 * in the hardware. The latter is important to reduce the 258 * number of BBP register reads to reduce register access 259 * overhead. For this reason we store both values here. 260 */ 261 u8 vgc_level; 262 u8 vgc_level_reg; 263 264 /* 265 * Statistics required for Signal quality calculation. 266 * These fields might be changed during the link_stats() 267 * callback function. 268 */ 269 int rx_success; 270 int rx_failed; 271 int tx_success; 272 int tx_failed; 273}; 274 275/* 276 * Antenna settings about the currently active link. 277 */ 278struct link_ant { 279 /* 280 * Antenna flags 281 */ 282 unsigned int flags; 283#define ANTENNA_RX_DIVERSITY 0x00000001 284#define ANTENNA_TX_DIVERSITY 0x00000002 285#define ANTENNA_MODE_SAMPLE 0x00000004 286 287 /* 288 * Currently active TX/RX antenna setup. 289 * When software diversity is used, this will indicate 290 * which antenna is actually used at this time. 291 */ 292 struct antenna_setup active; 293 294 /* 295 * RSSI history information for the antenna. 296 * Used to determine when to switch antenna 297 * when using software diversity. 298 */ 299 int rssi_history; 300 301 /* 302 * Current RSSI average of the currently active antenna. 303 * Similar to the avg_rssi in the link_qual structure 304 * this value is updated by using the walking average. 305 */ 306 struct avg_val rssi_ant; 307}; 308 309/* 310 * To optimize the quality of the link we need to store 311 * the quality of received frames and periodically 312 * optimize the link. 313 */ 314struct link { 315 /* 316 * Link tuner counter 317 * The number of times the link has been tuned 318 * since the radio has been switched on. 319 */ 320 u32 count; 321 322 /* 323 * Quality measurement values. 324 */ 325 struct link_qual qual; 326 327 /* 328 * TX/RX antenna setup. 329 */ 330 struct link_ant ant; 331 332 /* 333 * Currently active average RSSI value 334 */ 335 struct avg_val avg_rssi; 336 337 /* 338 * Work structure for scheduling periodic link tuning. 339 */ 340 struct delayed_work work; 341 342 /* 343 * Work structure for scheduling periodic watchdog monitoring. 344 * This work must be scheduled on the kernel workqueue, while 345 * all other work structures must be queued on the mac80211 346 * workqueue. This guarantees that the watchdog can schedule 347 * other work structures and wait for their completion in order 348 * to bring the device/driver back into the desired state. 349 */ 350 struct delayed_work watchdog_work; 351}; 352 353enum rt2x00_delayed_flags { 354 DELAYED_UPDATE_BEACON, 355}; 356 357/* 358 * Interface structure 359 * Per interface configuration details, this structure 360 * is allocated as the private data for ieee80211_vif. 361 */ 362struct rt2x00_intf { 363 /* 364 * beacon->skb must be protected with the mutex. 365 */ 366 struct mutex beacon_skb_mutex; 367 368 /* 369 * Entry in the beacon queue which belongs to 370 * this interface. Each interface has its own 371 * dedicated beacon entry. 372 */ 373 struct queue_entry *beacon; 374 bool enable_beacon; 375 376 /* 377 * Actions that needed rescheduling. 378 */ 379 unsigned long delayed_flags; 380 381 /* 382 * Software sequence counter, this is only required 383 * for hardware which doesn't support hardware 384 * sequence counting. 385 */ 386 spinlock_t seqlock; 387 u16 seqno; 388}; 389 390static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif) 391{ 392 return (struct rt2x00_intf *)vif->drv_priv; 393} 394 395/** 396 * struct hw_mode_spec: Hardware specifications structure 397 * 398 * Details about the supported modes, rates and channels 399 * of a particular chipset. This is used by rt2x00lib 400 * to build the ieee80211_hw_mode array for mac80211. 401 * 402 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz). 403 * @supported_rates: Rate types which are supported (CCK, OFDM). 404 * @num_channels: Number of supported channels. This is used as array size 405 * for @tx_power_a, @tx_power_bg and @channels. 406 * @channels: Device/chipset specific channel values (See &struct rf_channel). 407 * @channels_info: Additional information for channels (See &struct channel_info). 408 * @ht: Driver HT Capabilities (See &ieee80211_sta_ht_cap). 409 */ 410struct hw_mode_spec { 411 unsigned int supported_bands; 412#define SUPPORT_BAND_2GHZ 0x00000001 413#define SUPPORT_BAND_5GHZ 0x00000002 414 415 unsigned int supported_rates; 416#define SUPPORT_RATE_CCK 0x00000001 417#define SUPPORT_RATE_OFDM 0x00000002 418 419 unsigned int num_channels; 420 const struct rf_channel *channels; 421 const struct channel_info *channels_info; 422 423 struct ieee80211_sta_ht_cap ht; 424}; 425 426/* 427 * Configuration structure wrapper around the 428 * mac80211 configuration structure. 429 * When mac80211 configures the driver, rt2x00lib 430 * can precalculate values which are equal for all 431 * rt2x00 drivers. Those values can be stored in here. 432 */ 433struct rt2x00lib_conf { 434 struct ieee80211_conf *conf; 435 436 struct rf_channel rf; 437 struct channel_info channel; 438}; 439 440/* 441 * Configuration structure for erp settings. 442 */ 443struct rt2x00lib_erp { 444 int short_preamble; 445 int cts_protection; 446 447 u32 basic_rates; 448 449 int slot_time; 450 451 short sifs; 452 short pifs; 453 short difs; 454 short eifs; 455 456 u16 beacon_int; 457 u16 ht_opmode; 458}; 459 460/* 461 * Configuration structure for hardware encryption. 462 */ 463struct rt2x00lib_crypto { 464 enum cipher cipher; 465 466 enum set_key_cmd cmd; 467 const u8 *address; 468 469 u32 bssidx; 470 471 u8 key[16]; 472 u8 tx_mic[8]; 473 u8 rx_mic[8]; 474}; 475 476/* 477 * Configuration structure wrapper around the 478 * rt2x00 interface configuration handler. 479 */ 480struct rt2x00intf_conf { 481 /* 482 * Interface type 483 */ 484 enum nl80211_iftype type; 485 486 /* 487 * TSF sync value, this is dependant on the operation type. 488 */ 489 enum tsf_sync sync; 490 491 /* 492 * The MAC and BSSID addressess are simple array of bytes, 493 * these arrays are little endian, so when sending the addressess 494 * to the drivers, copy the it into a endian-signed variable. 495 * 496 * Note that all devices (except rt2500usb) have 32 bits 497 * register word sizes. This means that whatever variable we 498 * pass _must_ be a multiple of 32 bits. Otherwise the device 499 * might not accept what we are sending to it. 500 * This will also make it easier for the driver to write 501 * the data to the device. 502 */ 503 __le32 mac[2]; 504 __le32 bssid[2]; 505}; 506 507/* 508 * rt2x00lib callback functions. 509 */ 510struct rt2x00lib_ops { 511 /* 512 * Interrupt handlers. 513 */ 514 irq_handler_t irq_handler; 515 516 /* 517 * TX status tasklet handler. 518 */ 519 void (*txstatus_tasklet) (unsigned long data); 520 void (*pretbtt_tasklet) (unsigned long data); 521 void (*tbtt_tasklet) (unsigned long data); 522 void (*rxdone_tasklet) (unsigned long data); 523 void (*autowake_tasklet) (unsigned long data); 524 525 /* 526 * Device init handlers. 527 */ 528 int (*probe_hw) (struct rt2x00_dev *rt2x00dev); 529 char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev); 530 int (*check_firmware) (struct rt2x00_dev *rt2x00dev, 531 const u8 *data, const size_t len); 532 int (*load_firmware) (struct rt2x00_dev *rt2x00dev, 533 const u8 *data, const size_t len); 534 535 /* 536 * Device initialization/deinitialization handlers. 537 */ 538 int (*initialize) (struct rt2x00_dev *rt2x00dev); 539 void (*uninitialize) (struct rt2x00_dev *rt2x00dev); 540 541 /* 542 * queue initialization handlers 543 */ 544 bool (*get_entry_state) (struct queue_entry *entry); 545 void (*clear_entry) (struct queue_entry *entry); 546 547 /* 548 * Radio control handlers. 549 */ 550 int (*set_device_state) (struct rt2x00_dev *rt2x00dev, 551 enum dev_state state); 552 int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev); 553 void (*link_stats) (struct rt2x00_dev *rt2x00dev, 554 struct link_qual *qual); 555 void (*reset_tuner) (struct rt2x00_dev *rt2x00dev, 556 struct link_qual *qual); 557 void (*link_tuner) (struct rt2x00_dev *rt2x00dev, 558 struct link_qual *qual, const u32 count); 559 560 /* 561 * Data queue handlers. 562 */ 563 void (*watchdog) (struct rt2x00_dev *rt2x00dev); 564 void (*start_queue) (struct data_queue *queue); 565 void (*kick_queue) (struct data_queue *queue); 566 void (*stop_queue) (struct data_queue *queue); 567 void (*flush_queue) (struct data_queue *queue); 568 569 /* 570 * TX control handlers 571 */ 572 void (*write_tx_desc) (struct queue_entry *entry, 573 struct txentry_desc *txdesc); 574 void (*write_tx_data) (struct queue_entry *entry, 575 struct txentry_desc *txdesc); 576 void (*write_beacon) (struct queue_entry *entry, 577 struct txentry_desc *txdesc); 578 void (*clear_beacon) (struct queue_entry *entry); 579 int (*get_tx_data_len) (struct queue_entry *entry); 580 581 /* 582 * RX control handlers 583 */ 584 void (*fill_rxdone) (struct queue_entry *entry, 585 struct rxdone_entry_desc *rxdesc); 586 587 /* 588 * Configuration handlers. 589 */ 590 int (*config_shared_key) (struct rt2x00_dev *rt2x00dev, 591 struct rt2x00lib_crypto *crypto, 592 struct ieee80211_key_conf *key); 593 int (*config_pairwise_key) (struct rt2x00_dev *rt2x00dev, 594 struct rt2x00lib_crypto *crypto, 595 struct ieee80211_key_conf *key); 596 void (*config_filter) (struct rt2x00_dev *rt2x00dev, 597 const unsigned int filter_flags); 598 void (*config_intf) (struct rt2x00_dev *rt2x00dev, 599 struct rt2x00_intf *intf, 600 struct rt2x00intf_conf *conf, 601 const unsigned int flags); 602#define CONFIG_UPDATE_TYPE ( 1 << 1 ) 603#define CONFIG_UPDATE_MAC ( 1 << 2 ) 604#define CONFIG_UPDATE_BSSID ( 1 << 3 ) 605 606 void (*config_erp) (struct rt2x00_dev *rt2x00dev, 607 struct rt2x00lib_erp *erp, 608 u32 changed); 609 void (*config_ant) (struct rt2x00_dev *rt2x00dev, 610 struct antenna_setup *ant); 611 void (*config) (struct rt2x00_dev *rt2x00dev, 612 struct rt2x00lib_conf *libconf, 613 const unsigned int changed_flags); 614}; 615 616/* 617 * rt2x00 driver callback operation structure. 618 */ 619struct rt2x00_ops { 620 const char *name; 621 const unsigned int max_sta_intf; 622 const unsigned int max_ap_intf; 623 const unsigned int eeprom_size; 624 const unsigned int rf_size; 625 const unsigned int tx_queues; 626 const unsigned int extra_tx_headroom; 627 const struct data_queue_desc *rx; 628 const struct data_queue_desc *tx; 629 const struct data_queue_desc *bcn; 630 const struct data_queue_desc *atim; 631 const struct rt2x00lib_ops *lib; 632 const void *drv; 633 const struct ieee80211_ops *hw; 634#ifdef CONFIG_RT2X00_LIB_DEBUGFS 635 const struct rt2x00debug *debugfs; 636#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 637}; 638 639/* 640 * rt2x00 device flags 641 */ 642enum rt2x00_flags { 643 /* 644 * Device state flags 645 */ 646 DEVICE_STATE_PRESENT, 647 DEVICE_STATE_REGISTERED_HW, 648 DEVICE_STATE_INITIALIZED, 649 DEVICE_STATE_STARTED, 650 DEVICE_STATE_ENABLED_RADIO, 651 DEVICE_STATE_SCANNING, 652 653 /* 654 * Driver requirements 655 */ 656 DRIVER_REQUIRE_FIRMWARE, 657 DRIVER_REQUIRE_BEACON_GUARD, 658 DRIVER_REQUIRE_ATIM_QUEUE, 659 DRIVER_REQUIRE_DMA, 660 DRIVER_REQUIRE_COPY_IV, 661 DRIVER_REQUIRE_L2PAD, 662 DRIVER_REQUIRE_TXSTATUS_FIFO, 663 DRIVER_REQUIRE_TASKLET_CONTEXT, 664 DRIVER_REQUIRE_SW_SEQNO, 665 DRIVER_REQUIRE_HT_TX_DESC, 666 667 /* 668 * Driver features 669 */ 670 CONFIG_SUPPORT_HW_BUTTON, 671 CONFIG_SUPPORT_HW_CRYPTO, 672 CONFIG_SUPPORT_POWER_LIMIT, 673 DRIVER_SUPPORT_CONTROL_FILTERS, 674 DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, 675 DRIVER_SUPPORT_PRE_TBTT_INTERRUPT, 676 DRIVER_SUPPORT_LINK_TUNING, 677 DRIVER_SUPPORT_WATCHDOG, 678 679 /* 680 * Driver configuration 681 */ 682 CONFIG_FRAME_TYPE, 683 CONFIG_RF_SEQUENCE, 684 CONFIG_EXTERNAL_LNA_A, 685 CONFIG_EXTERNAL_LNA_BG, 686 CONFIG_DOUBLE_ANTENNA, 687 CONFIG_CHANNEL_HT40, 688}; 689 690/* 691 * rt2x00 device structure. 692 */ 693struct rt2x00_dev { 694 /* 695 * Device structure. 696 * The structure stored in here depends on the 697 * system bus (PCI or USB). 698 * When accessing this variable, the rt2x00dev_{pci,usb} 699 * macros should be used for correct typecasting. 700 */ 701 struct device *dev; 702 703 /* 704 * Callback functions. 705 */ 706 const struct rt2x00_ops *ops; 707 708 /* 709 * IEEE80211 control structure. 710 */ 711 struct ieee80211_hw *hw; 712 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS]; 713 enum ieee80211_band curr_band; 714 int curr_freq; 715 716 /* 717 * If enabled, the debugfs interface structures 718 * required for deregistration of debugfs. 719 */ 720#ifdef CONFIG_RT2X00_LIB_DEBUGFS 721 struct rt2x00debug_intf *debugfs_intf; 722#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 723 724 /* 725 * LED structure for changing the LED status 726 * by mac8011 or the kernel. 727 */ 728#ifdef CONFIG_RT2X00_LIB_LEDS 729 struct rt2x00_led led_radio; 730 struct rt2x00_led led_assoc; 731 struct rt2x00_led led_qual; 732 u16 led_mcu_reg; 733#endif /* CONFIG_RT2X00_LIB_LEDS */ 734 735 /* 736 * Device flags. 737 * In these flags the current status and some 738 * of the device capabilities are stored. 739 */ 740 unsigned long flags; 741 742 /* 743 * Device information, Bus IRQ and name (PCI, SoC) 744 */ 745 int irq; 746 const char *name; 747 748 /* 749 * Chipset identification. 750 */ 751 struct rt2x00_chip chip; 752 753 /* 754 * hw capability specifications. 755 */ 756 struct hw_mode_spec spec; 757 758 /* 759 * This is the default TX/RX antenna setup as indicated 760 * by the device's EEPROM. 761 */ 762 struct antenna_setup default_ant; 763 764 /* 765 * Register pointers 766 * csr.base: CSR base register address. (PCI) 767 * csr.cache: CSR cache for usb_control_msg. (USB) 768 */ 769 union csr { 770 void __iomem *base; 771 void *cache; 772 } csr; 773 774 /* 775 * Mutex to protect register accesses. 776 * For PCI and USB devices it protects against concurrent indirect 777 * register access (BBP, RF, MCU) since accessing those 778 * registers require multiple calls to the CSR registers. 779 * For USB devices it also protects the csr_cache since that 780 * field is used for normal CSR access and it cannot support 781 * multiple callers simultaneously. 782 */ 783 struct mutex csr_mutex; 784 785 /* 786 * Current packet filter configuration for the device. 787 * This contains all currently active FIF_* flags send 788 * to us by mac80211 during configure_filter(). 789 */ 790 unsigned int packet_filter; 791 792 /* 793 * Interface details: 794 * - Open ap interface count. 795 * - Open sta interface count. 796 * - Association count. 797 * - Beaconing enabled count. 798 */ 799 unsigned int intf_ap_count; 800 unsigned int intf_sta_count; 801 unsigned int intf_associated; 802 unsigned int intf_beaconing; 803 804 /* 805 * Link quality 806 */ 807 struct link link; 808 809 /* 810 * EEPROM data. 811 */ 812 __le16 *eeprom; 813 814 /* 815 * Active RF register values. 816 * These are stored here so we don't need 817 * to read the rf registers and can directly 818 * use this value instead. 819 * This field should be accessed by using 820 * rt2x00_rf_read() and rt2x00_rf_write(). 821 */ 822 u32 *rf; 823 824 /* 825 * LNA gain 826 */ 827 short lna_gain; 828 829 /* 830 * Current TX power value. 831 */ 832 u16 tx_power; 833 834 /* 835 * Current retry values. 836 */ 837 u8 short_retry; 838 u8 long_retry; 839 840 /* 841 * Rssi <-> Dbm offset 842 */ 843 u8 rssi_offset; 844 845 /* 846 * Frequency offset (for rt61pci & rt73usb). 847 */ 848 u8 freq_offset; 849 850 /* 851 * Calibration information (for rt2800usb & rt2800pci). 852 * [0] -> BW20 853 * [1] -> BW40 854 */ 855 u8 calibration[2]; 856 857 /* 858 * Beacon interval. 859 */ 860 u16 beacon_int; 861 862 /* 863 * Low level statistics which will have 864 * to be kept up to date while device is running. 865 */ 866 struct ieee80211_low_level_stats low_level_stats; 867 868 /** 869 * Work queue for all work which should not be placed 870 * on the mac80211 workqueue (because of dependencies 871 * between various work structures). 872 */ 873 struct workqueue_struct *workqueue; 874 875 /* 876 * Scheduled work. 877 * NOTE: intf_work will use ieee80211_iterate_active_interfaces() 878 * which means it cannot be placed on the hw->workqueue 879 * due to RTNL locking requirements. 880 */ 881 struct work_struct intf_work; 882 883 /** 884 * Scheduled work for TX/RX done handling (USB devices) 885 */ 886 struct work_struct rxdone_work; 887 struct work_struct txdone_work; 888 889 /* 890 * Data queue arrays for RX, TX, Beacon and ATIM. 891 */ 892 unsigned int data_queues; 893 struct data_queue *rx; 894 struct data_queue *tx; 895 struct data_queue *bcn; 896 struct data_queue *atim; 897 898 /* 899 * Firmware image. 900 */ 901 const struct firmware *fw; 902 903 /* 904 * FIFO for storing tx status reports between isr and tasklet. 905 */ 906 DECLARE_KFIFO_PTR(txstatus_fifo, u32); 907 908 /* 909 * Tasklet for processing tx status reports (rt2800pci). 910 */ 911 struct tasklet_struct txstatus_tasklet; 912 struct tasklet_struct pretbtt_tasklet; 913 struct tasklet_struct tbtt_tasklet; 914 struct tasklet_struct rxdone_tasklet; 915 struct tasklet_struct autowake_tasklet; 916 917 /* 918 * Protect the interrupt mask register. 919 */ 920 spinlock_t irqmask_lock; 921}; 922 923/* 924 * Register defines. 925 * Some registers require multiple attempts before success, 926 * in those cases REGISTER_BUSY_COUNT attempts should be 927 * taken with a REGISTER_BUSY_DELAY interval. 928 */ 929#define REGISTER_BUSY_COUNT 100 930#define REGISTER_BUSY_DELAY 100 931 932/* 933 * Generic RF access. 934 * The RF is being accessed by word index. 935 */ 936static inline void rt2x00_rf_read(struct rt2x00_dev *rt2x00dev, 937 const unsigned int word, u32 *data) 938{ 939 BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32)); 940 *data = rt2x00dev->rf[word - 1]; 941} 942 943static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev, 944 const unsigned int word, u32 data) 945{ 946 BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32)); 947 rt2x00dev->rf[word - 1] = data; 948} 949 950/* 951 * Generic EEPROM access. 952 * The EEPROM is being accessed by word index. 953 */ 954static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev, 955 const unsigned int word) 956{ 957 return (void *)&rt2x00dev->eeprom[word]; 958} 959 960static inline void rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev, 961 const unsigned int word, u16 *data) 962{ 963 *data = le16_to_cpu(rt2x00dev->eeprom[word]); 964} 965 966static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev, 967 const unsigned int word, u16 data) 968{ 969 rt2x00dev->eeprom[word] = cpu_to_le16(data); 970} 971 972/* 973 * Chipset handlers 974 */ 975static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev, 976 const u16 rt, const u16 rf, const u16 rev) 977{ 978 rt2x00dev->chip.rt = rt; 979 rt2x00dev->chip.rf = rf; 980 rt2x00dev->chip.rev = rev; 981 982 INFO(rt2x00dev, 983 "Chipset detected - rt: %04x, rf: %04x, rev: %04x.\n", 984 rt2x00dev->chip.rt, rt2x00dev->chip.rf, rt2x00dev->chip.rev); 985} 986 987static inline bool rt2x00_rt(struct rt2x00_dev *rt2x00dev, const u16 rt) 988{ 989 return (rt2x00dev->chip.rt == rt); 990} 991 992static inline bool rt2x00_rf(struct rt2x00_dev *rt2x00dev, const u16 rf) 993{ 994 return (rt2x00dev->chip.rf == rf); 995} 996 997static inline u16 rt2x00_rev(struct rt2x00_dev *rt2x00dev) 998{ 999 return rt2x00dev->chip.rev; 1000} 1001 1002static inline bool rt2x00_rt_rev(struct rt2x00_dev *rt2x00dev, 1003 const u16 rt, const u16 rev) 1004{ 1005 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) == rev); 1006} 1007 1008static inline bool rt2x00_rt_rev_lt(struct rt2x00_dev *rt2x00dev, 1009 const u16 rt, const u16 rev) 1010{ 1011 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) < rev); 1012} 1013 1014static inline bool rt2x00_rt_rev_gte(struct rt2x00_dev *rt2x00dev, 1015 const u16 rt, const u16 rev) 1016{ 1017 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) >= rev); 1018} 1019 1020static inline void rt2x00_set_chip_intf(struct rt2x00_dev *rt2x00dev, 1021 enum rt2x00_chip_intf intf) 1022{ 1023 rt2x00dev->chip.intf = intf; 1024} 1025 1026static inline bool rt2x00_intf(struct rt2x00_dev *rt2x00dev, 1027 enum rt2x00_chip_intf intf) 1028{ 1029 return (rt2x00dev->chip.intf == intf); 1030} 1031 1032static inline bool rt2x00_is_pci(struct rt2x00_dev *rt2x00dev) 1033{ 1034 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI) || 1035 rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE); 1036} 1037 1038static inline bool rt2x00_is_pcie(struct rt2x00_dev *rt2x00dev) 1039{ 1040 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE); 1041} 1042 1043static inline bool rt2x00_is_usb(struct rt2x00_dev *rt2x00dev) 1044{ 1045 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_USB); 1046} 1047 1048static inline bool rt2x00_is_soc(struct rt2x00_dev *rt2x00dev) 1049{ 1050 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_SOC); 1051} 1052 1053/** 1054 * rt2x00queue_map_txskb - Map a skb into DMA for TX purposes. 1055 * @entry: Pointer to &struct queue_entry 1056 */ 1057void rt2x00queue_map_txskb(struct queue_entry *entry); 1058 1059/** 1060 * rt2x00queue_unmap_skb - Unmap a skb from DMA. 1061 * @entry: Pointer to &struct queue_entry 1062 */ 1063void rt2x00queue_unmap_skb(struct queue_entry *entry); 1064 1065/** 1066 * rt2x00queue_get_tx_queue - Convert tx queue index to queue pointer 1067 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1068 * @queue: rt2x00 queue index (see &enum data_queue_qid). 1069 * 1070 * Returns NULL for non tx queues. 1071 */ 1072static inline struct data_queue * 1073rt2x00queue_get_tx_queue(struct rt2x00_dev *rt2x00dev, 1074 const enum data_queue_qid queue) 1075{ 1076 if (queue < rt2x00dev->ops->tx_queues && rt2x00dev->tx) 1077 return &rt2x00dev->tx[queue]; 1078 1079 return NULL; 1080} 1081 1082/** 1083 * rt2x00queue_get_queue - Convert queue index to queue pointer 1084 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1085 * @queue: rt2x00 queue index (see &enum data_queue_qid). 1086 */ 1087struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev, 1088 const enum data_queue_qid queue); 1089 1090/** 1091 * rt2x00queue_get_entry - Get queue entry where the given index points to. 1092 * @queue: Pointer to &struct data_queue from where we obtain the entry. 1093 * @index: Index identifier for obtaining the correct index. 1094 */ 1095struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue, 1096 enum queue_index index); 1097 1098/** 1099 * rt2x00queue_pause_queue - Pause a data queue 1100 * @queue: Pointer to &struct data_queue. 1101 * 1102 * This function will pause the data queue locally, preventing 1103 * new frames to be added to the queue (while the hardware is 1104 * still allowed to run). 1105 */ 1106void rt2x00queue_pause_queue(struct data_queue *queue); 1107 1108/** 1109 * rt2x00queue_unpause_queue - unpause a data queue 1110 * @queue: Pointer to &struct data_queue. 1111 * 1112 * This function will unpause the data queue locally, allowing 1113 * new frames to be added to the queue again. 1114 */ 1115void rt2x00queue_unpause_queue(struct data_queue *queue); 1116 1117/** 1118 * rt2x00queue_start_queue - Start a data queue 1119 * @queue: Pointer to &struct data_queue. 1120 * 1121 * This function will start handling all pending frames in the queue. 1122 */ 1123void rt2x00queue_start_queue(struct data_queue *queue); 1124 1125/** 1126 * rt2x00queue_stop_queue - Halt a data queue 1127 * @queue: Pointer to &struct data_queue. 1128 * 1129 * This function will stop all pending frames in the queue. 1130 */ 1131void rt2x00queue_stop_queue(struct data_queue *queue); 1132 1133/** 1134 * rt2x00queue_flush_queue - Flush a data queue 1135 * @queue: Pointer to &struct data_queue. 1136 * @drop: True to drop all pending frames. 1137 * 1138 * This function will flush the queue. After this call 1139 * the queue is guarenteed to be empty. 1140 */ 1141void rt2x00queue_flush_queue(struct data_queue *queue, bool drop); 1142 1143/** 1144 * rt2x00queue_start_queues - Start all data queues 1145 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1146 * 1147 * This function will loop through all available queues to start them 1148 */ 1149void rt2x00queue_start_queues(struct rt2x00_dev *rt2x00dev); 1150 1151/** 1152 * rt2x00queue_stop_queues - Halt all data queues 1153 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1154 * 1155 * This function will loop through all available queues to stop 1156 * any pending frames. 1157 */ 1158void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev); 1159 1160/** 1161 * rt2x00queue_flush_queues - Flush all data queues 1162 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1163 * @drop: True to drop all pending frames. 1164 * 1165 * This function will loop through all available queues to flush 1166 * any pending frames. 1167 */ 1168void rt2x00queue_flush_queues(struct rt2x00_dev *rt2x00dev, bool drop); 1169 1170/* 1171 * Debugfs handlers. 1172 */ 1173/** 1174 * rt2x00debug_dump_frame - Dump a frame to userspace through debugfs. 1175 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1176 * @type: The type of frame that is being dumped. 1177 * @skb: The skb containing the frame to be dumped. 1178 */ 1179#ifdef CONFIG_RT2X00_LIB_DEBUGFS 1180void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev, 1181 enum rt2x00_dump_type type, struct sk_buff *skb); 1182#else 1183static inline void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev, 1184 enum rt2x00_dump_type type, 1185 struct sk_buff *skb) 1186{ 1187} 1188#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 1189 1190/* 1191 * Interrupt context handlers. 1192 */ 1193void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev); 1194void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev); 1195void rt2x00lib_dmastart(struct queue_entry *entry); 1196void rt2x00lib_dmadone(struct queue_entry *entry); 1197void rt2x00lib_txdone(struct queue_entry *entry, 1198 struct txdone_entry_desc *txdesc); 1199void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status); 1200void rt2x00lib_rxdone(struct queue_entry *entry); 1201 1202/* 1203 * mac80211 handlers. 1204 */ 1205void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb); 1206int rt2x00mac_start(struct ieee80211_hw *hw); 1207void rt2x00mac_stop(struct ieee80211_hw *hw); 1208int rt2x00mac_add_interface(struct ieee80211_hw *hw, 1209 struct ieee80211_vif *vif); 1210void rt2x00mac_remove_interface(struct ieee80211_hw *hw, 1211 struct ieee80211_vif *vif); 1212int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed); 1213void rt2x00mac_configure_filter(struct ieee80211_hw *hw, 1214 unsigned int changed_flags, 1215 unsigned int *total_flags, 1216 u64 multicast); 1217int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 1218 bool set); 1219#ifdef CONFIG_RT2X00_LIB_CRYPTO 1220int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 1221 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 1222 struct ieee80211_key_conf *key); 1223#else 1224#define rt2x00mac_set_key NULL 1225#endif /* CONFIG_RT2X00_LIB_CRYPTO */ 1226void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw); 1227void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw); 1228int rt2x00mac_get_stats(struct ieee80211_hw *hw, 1229 struct ieee80211_low_level_stats *stats); 1230void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, 1231 struct ieee80211_vif *vif, 1232 struct ieee80211_bss_conf *bss_conf, 1233 u32 changes); 1234int rt2x00mac_conf_tx(struct ieee80211_hw *hw, u16 queue, 1235 const struct ieee80211_tx_queue_params *params); 1236void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw); 1237void rt2x00mac_flush(struct ieee80211_hw *hw, bool drop); 1238 1239/* 1240 * Driver allocation handlers. 1241 */ 1242int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev); 1243void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev); 1244#ifdef CONFIG_PM 1245int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state); 1246int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev); 1247#endif /* CONFIG_PM */ 1248 1249#endif /* RT2X00_H */ 1250