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