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