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