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