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