rt2x00.h revision aa776721b472e343a8db7f3c0673b1fa24e6c7f7
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.3" 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_ERP 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 u32 basic_rates; 445 u32 slot_time; 446 447 short sifs; 448 short pifs; 449 short difs; 450 short eifs; 451}; 452 453/* 454 * Configuration structure for erp settings. 455 */ 456struct rt2x00lib_erp { 457 int short_preamble; 458 459 int ack_timeout; 460 int ack_consume_time; 461}; 462 463/* 464 * Configuration structure wrapper around the 465 * rt2x00 interface configuration handler. 466 */ 467struct rt2x00intf_conf { 468 /* 469 * Interface type 470 */ 471 enum ieee80211_if_types type; 472 473 /* 474 * TSF sync value, this is dependant on the operation type. 475 */ 476 enum tsf_sync sync; 477 478 /* 479 * The MAC and BSSID addressess are simple array of bytes, 480 * these arrays are little endian, so when sending the addressess 481 * to the drivers, copy the it into a endian-signed variable. 482 * 483 * Note that all devices (except rt2500usb) have 32 bits 484 * register word sizes. This means that whatever variable we 485 * pass _must_ be a multiple of 32 bits. Otherwise the device 486 * might not accept what we are sending to it. 487 * This will also make it easier for the driver to write 488 * the data to the device. 489 */ 490 __le32 mac[2]; 491 __le32 bssid[2]; 492}; 493 494/* 495 * rt2x00lib callback functions. 496 */ 497struct rt2x00lib_ops { 498 /* 499 * Interrupt handlers. 500 */ 501 irq_handler_t irq_handler; 502 503 /* 504 * Device init handlers. 505 */ 506 int (*probe_hw) (struct rt2x00_dev *rt2x00dev); 507 char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev); 508 u16 (*get_firmware_crc) (void *data, const size_t len); 509 int (*load_firmware) (struct rt2x00_dev *rt2x00dev, void *data, 510 const size_t len); 511 512 /* 513 * Device initialization/deinitialization handlers. 514 */ 515 int (*initialize) (struct rt2x00_dev *rt2x00dev); 516 void (*uninitialize) (struct rt2x00_dev *rt2x00dev); 517 518 /* 519 * queue initialization handlers 520 */ 521 void (*init_rxentry) (struct rt2x00_dev *rt2x00dev, 522 struct queue_entry *entry); 523 void (*init_txentry) (struct rt2x00_dev *rt2x00dev, 524 struct queue_entry *entry); 525 526 /* 527 * Radio control handlers. 528 */ 529 int (*set_device_state) (struct rt2x00_dev *rt2x00dev, 530 enum dev_state state); 531 int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev); 532 void (*link_stats) (struct rt2x00_dev *rt2x00dev, 533 struct link_qual *qual); 534 void (*reset_tuner) (struct rt2x00_dev *rt2x00dev); 535 void (*link_tuner) (struct rt2x00_dev *rt2x00dev); 536 void (*led_brightness) (struct led_classdev *led_cdev, 537 enum led_brightness brightness); 538 539 /* 540 * TX control handlers 541 */ 542 void (*write_tx_desc) (struct rt2x00_dev *rt2x00dev, 543 struct sk_buff *skb, 544 struct txentry_desc *txdesc, 545 struct ieee80211_tx_control *control); 546 int (*write_tx_data) (struct rt2x00_dev *rt2x00dev, 547 struct data_queue *queue, struct sk_buff *skb, 548 struct ieee80211_tx_control *control); 549 int (*get_tx_data_len) (struct rt2x00_dev *rt2x00dev, 550 struct sk_buff *skb); 551 void (*kick_tx_queue) (struct rt2x00_dev *rt2x00dev, 552 const unsigned int queue); 553 554 /* 555 * RX control handlers 556 */ 557 void (*fill_rxdone) (struct queue_entry *entry, 558 struct rxdone_entry_desc *rxdesc); 559 560 /* 561 * Configuration handlers. 562 */ 563 void (*config_intf) (struct rt2x00_dev *rt2x00dev, 564 struct rt2x00_intf *intf, 565 struct rt2x00intf_conf *conf, 566 const unsigned int flags); 567#define CONFIG_UPDATE_TYPE ( 1 << 1 ) 568#define CONFIG_UPDATE_MAC ( 1 << 2 ) 569#define CONFIG_UPDATE_BSSID ( 1 << 3 ) 570 571 int (*config_erp) (struct rt2x00_dev *rt2x00dev, 572 struct rt2x00lib_erp *erp); 573 void (*config) (struct rt2x00_dev *rt2x00dev, 574 struct rt2x00lib_conf *libconf, 575 const unsigned int flags); 576#define CONFIG_UPDATE_PHYMODE ( 1 << 1 ) 577#define CONFIG_UPDATE_CHANNEL ( 1 << 2 ) 578#define CONFIG_UPDATE_TXPOWER ( 1 << 3 ) 579#define CONFIG_UPDATE_ANTENNA ( 1 << 4 ) 580#define CONFIG_UPDATE_SLOT_TIME ( 1 << 5 ) 581#define CONFIG_UPDATE_BEACON_INT ( 1 << 6 ) 582#define CONFIG_UPDATE_ALL 0xffff 583}; 584 585/* 586 * rt2x00 driver callback operation structure. 587 */ 588struct rt2x00_ops { 589 const char *name; 590 const unsigned int max_sta_intf; 591 const unsigned int max_ap_intf; 592 const unsigned int eeprom_size; 593 const unsigned int rf_size; 594 const struct data_queue_desc *rx; 595 const struct data_queue_desc *tx; 596 const struct data_queue_desc *bcn; 597 const struct data_queue_desc *atim; 598 const struct rt2x00lib_ops *lib; 599 const struct ieee80211_ops *hw; 600#ifdef CONFIG_RT2X00_LIB_DEBUGFS 601 const struct rt2x00debug *debugfs; 602#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 603}; 604 605/* 606 * rt2x00 device flags 607 */ 608enum rt2x00_flags { 609 /* 610 * Device state flags 611 */ 612 DEVICE_PRESENT, 613 DEVICE_REGISTERED_HW, 614 DEVICE_INITIALIZED, 615 DEVICE_STARTED, 616 DEVICE_STARTED_SUSPEND, 617 DEVICE_ENABLED_RADIO, 618 DEVICE_DISABLED_RADIO_HW, 619 620 /* 621 * Driver features 622 */ 623 DRIVER_SUPPORT_MIXED_INTERFACES, 624 DRIVER_REQUIRE_FIRMWARE, 625 DRIVER_REQUIRE_BEACON_GUARD, 626 DRIVER_REQUIRE_ATIM_QUEUE, 627 628 /* 629 * Driver configuration 630 */ 631 CONFIG_SUPPORT_HW_BUTTON, 632 CONFIG_FRAME_TYPE, 633 CONFIG_RF_SEQUENCE, 634 CONFIG_EXTERNAL_LNA_A, 635 CONFIG_EXTERNAL_LNA_BG, 636 CONFIG_DOUBLE_ANTENNA, 637 CONFIG_DISABLE_LINK_TUNING, 638}; 639 640/* 641 * rt2x00 device structure. 642 */ 643struct rt2x00_dev { 644 /* 645 * Device structure. 646 * The structure stored in here depends on the 647 * system bus (PCI or USB). 648 * When accessing this variable, the rt2x00dev_{pci,usb} 649 * macro's should be used for correct typecasting. 650 */ 651 void *dev; 652#define rt2x00dev_pci(__dev) ( (struct pci_dev *)(__dev)->dev ) 653#define rt2x00dev_usb(__dev) ( (struct usb_interface *)(__dev)->dev ) 654#define rt2x00dev_usb_dev(__dev)\ 655 ( (struct usb_device *)interface_to_usbdev(rt2x00dev_usb(__dev)) ) 656 657 /* 658 * Callback functions. 659 */ 660 const struct rt2x00_ops *ops; 661 662 /* 663 * IEEE80211 control structure. 664 */ 665 struct ieee80211_hw *hw; 666 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS]; 667 enum ieee80211_band curr_band; 668 669 /* 670 * rfkill structure for RF state switching support. 671 * This will only be compiled in when required. 672 */ 673#ifdef CONFIG_RT2X00_LIB_RFKILL 674 struct rfkill *rfkill; 675 struct input_polled_dev *poll_dev; 676#endif /* CONFIG_RT2X00_LIB_RFKILL */ 677 678 /* 679 * If enabled, the debugfs interface structures 680 * required for deregistration of debugfs. 681 */ 682#ifdef CONFIG_RT2X00_LIB_DEBUGFS 683 struct rt2x00debug_intf *debugfs_intf; 684#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 685 686 /* 687 * LED structure for changing the LED status 688 * by mac8011 or the kernel. 689 */ 690#ifdef CONFIG_RT2X00_LIB_LEDS 691 unsigned int led_flags; 692 struct rt2x00_trigger trigger_qual; 693 struct rt2x00_led led_radio; 694 struct rt2x00_led led_assoc; 695 struct rt2x00_led led_qual; 696 u16 led_mcu_reg; 697#endif /* CONFIG_RT2X00_LIB_LEDS */ 698 699 /* 700 * Device flags. 701 * In these flags the current status and some 702 * of the device capabilities are stored. 703 */ 704 unsigned long flags; 705 706 /* 707 * Chipset identification. 708 */ 709 struct rt2x00_chip chip; 710 711 /* 712 * hw capability specifications. 713 */ 714 struct hw_mode_spec spec; 715 716 /* 717 * This is the default TX/RX antenna setup as indicated 718 * by the device's EEPROM. When mac80211 sets its 719 * antenna value to 0 we should be using these values. 720 */ 721 struct antenna_setup default_ant; 722 723 /* 724 * Register pointers 725 * csr.base: CSR base register address. (PCI) 726 * csr.cache: CSR cache for usb_control_msg. (USB) 727 */ 728 union csr { 729 void __iomem *base; 730 void *cache; 731 } csr; 732 733 /* 734 * Mutex to protect register accesses on USB devices. 735 * There are 2 reasons this is needed, one is to ensure 736 * use of the csr_cache (for USB devices) by one thread 737 * isn't corrupted by another thread trying to access it. 738 * The other is that access to BBP and RF registers 739 * require multiple BUS transactions and if another thread 740 * attempted to access one of those registers at the same 741 * time one of the writes could silently fail. 742 */ 743 struct mutex usb_cache_mutex; 744 745 /* 746 * Current packet filter configuration for the device. 747 * This contains all currently active FIF_* flags send 748 * to us by mac80211 during configure_filter(). 749 */ 750 unsigned int packet_filter; 751 752 /* 753 * Interface details: 754 * - Open ap interface count. 755 * - Open sta interface count. 756 * - Association count. 757 */ 758 unsigned int intf_ap_count; 759 unsigned int intf_sta_count; 760 unsigned int intf_associated; 761 762 /* 763 * Link quality 764 */ 765 struct link link; 766 767 /* 768 * EEPROM data. 769 */ 770 __le16 *eeprom; 771 772 /* 773 * Active RF register values. 774 * These are stored here so we don't need 775 * to read the rf registers and can directly 776 * use this value instead. 777 * This field should be accessed by using 778 * rt2x00_rf_read() and rt2x00_rf_write(). 779 */ 780 u32 *rf; 781 782 /* 783 * USB Max frame size (for rt2500usb & rt73usb). 784 */ 785 u16 usb_maxpacket; 786 787 /* 788 * Current TX power value. 789 */ 790 u16 tx_power; 791 792 /* 793 * Rssi <-> Dbm offset 794 */ 795 u8 rssi_offset; 796 797 /* 798 * Frequency offset (for rt61pci & rt73usb). 799 */ 800 u8 freq_offset; 801 802 /* 803 * Low level statistics which will have 804 * to be kept up to date while device is running. 805 */ 806 struct ieee80211_low_level_stats low_level_stats; 807 808 /* 809 * RX configuration information. 810 */ 811 struct ieee80211_rx_status rx_status; 812 813 /* 814 * Scheduled work. 815 */ 816 struct work_struct intf_work; 817 struct work_struct filter_work; 818 819 /* 820 * Data queue arrays for RX, TX and Beacon. 821 * The Beacon array also contains the Atim queue 822 * if that is supported by the device. 823 */ 824 int data_queues; 825 struct data_queue *rx; 826 struct data_queue *tx; 827 struct data_queue *bcn; 828 829 /* 830 * Firmware image. 831 */ 832 const struct firmware *fw; 833}; 834 835/* 836 * Generic RF access. 837 * The RF is being accessed by word index. 838 */ 839static inline void rt2x00_rf_read(struct rt2x00_dev *rt2x00dev, 840 const unsigned int word, u32 *data) 841{ 842 *data = rt2x00dev->rf[word]; 843} 844 845static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev, 846 const unsigned int word, u32 data) 847{ 848 rt2x00dev->rf[word] = data; 849} 850 851/* 852 * Generic EEPROM access. 853 * The EEPROM is being accessed by word index. 854 */ 855static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev, 856 const unsigned int word) 857{ 858 return (void *)&rt2x00dev->eeprom[word]; 859} 860 861static inline void rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev, 862 const unsigned int word, u16 *data) 863{ 864 *data = le16_to_cpu(rt2x00dev->eeprom[word]); 865} 866 867static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev, 868 const unsigned int word, u16 data) 869{ 870 rt2x00dev->eeprom[word] = cpu_to_le16(data); 871} 872 873/* 874 * Chipset handlers 875 */ 876static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev, 877 const u16 rt, const u16 rf, const u32 rev) 878{ 879 INFO(rt2x00dev, 880 "Chipset detected - rt: %04x, rf: %04x, rev: %08x.\n", 881 rt, rf, rev); 882 883 rt2x00dev->chip.rt = rt; 884 rt2x00dev->chip.rf = rf; 885 rt2x00dev->chip.rev = rev; 886} 887 888static inline char rt2x00_rt(const struct rt2x00_chip *chipset, const u16 chip) 889{ 890 return (chipset->rt == chip); 891} 892 893static inline char rt2x00_rf(const struct rt2x00_chip *chipset, const u16 chip) 894{ 895 return (chipset->rf == chip); 896} 897 898static inline u16 rt2x00_rev(const struct rt2x00_chip *chipset) 899{ 900 return chipset->rev; 901} 902 903static inline u16 rt2x00_check_rev(const struct rt2x00_chip *chipset, 904 const u32 rev) 905{ 906 return (((chipset->rev & 0xffff0) == rev) && 907 !!(chipset->rev & 0x0000f)); 908} 909 910/* 911 * Duration calculations 912 * The rate variable passed is: 100kbs. 913 * To convert from bytes to bits we multiply size with 8, 914 * then the size is multiplied with 10 to make the 915 * real rate -> rate argument correction. 916 */ 917static inline u16 get_duration(const unsigned int size, const u8 rate) 918{ 919 return ((size * 8 * 10) / rate); 920} 921 922static inline u16 get_duration_res(const unsigned int size, const u8 rate) 923{ 924 return ((size * 8 * 10) % rate); 925} 926 927/** 928 * rt2x00queue_get_queue - Convert mac80211 queue index to rt2x00 queue 929 * @rt2x00dev: Pointer to &struct rt2x00_dev. 930 * @queue: mac80211/rt2x00 queue index 931 * (see &enum ieee80211_tx_queue and &enum rt2x00_bcn_queue). 932 */ 933struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev, 934 const unsigned int queue); 935 936/** 937 * rt2x00queue_get_entry - Get queue entry where the given index points to. 938 * @rt2x00dev: Pointer to &struct rt2x00_dev. 939 * @index: Index identifier for obtaining the correct index. 940 */ 941struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue, 942 enum queue_index index); 943 944/** 945 * rt2x00queue_index_inc - Index incrementation function 946 * @queue: Queue (&struct data_queue) to perform the action on. 947 * @action: Index type (&enum queue_index) to perform the action on. 948 * 949 * This function will increase the requested index on the queue, 950 * it will grab the appropriate locks and handle queue overflow events by 951 * resetting the index to the start of the queue. 952 */ 953void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index); 954 955 956/* 957 * Interrupt context handlers. 958 */ 959void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev); 960void rt2x00lib_txdone(struct queue_entry *entry, 961 struct txdone_entry_desc *txdesc); 962void rt2x00lib_rxdone(struct queue_entry *entry, 963 struct rxdone_entry_desc *rxdesc); 964 965/* 966 * TX descriptor initializer 967 */ 968void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev, 969 struct sk_buff *skb, 970 struct ieee80211_tx_control *control); 971 972/* 973 * mac80211 handlers. 974 */ 975int rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb, 976 struct ieee80211_tx_control *control); 977int rt2x00mac_start(struct ieee80211_hw *hw); 978void rt2x00mac_stop(struct ieee80211_hw *hw); 979int rt2x00mac_add_interface(struct ieee80211_hw *hw, 980 struct ieee80211_if_init_conf *conf); 981void rt2x00mac_remove_interface(struct ieee80211_hw *hw, 982 struct ieee80211_if_init_conf *conf); 983int rt2x00mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf); 984int rt2x00mac_config_interface(struct ieee80211_hw *hw, 985 struct ieee80211_vif *vif, 986 struct ieee80211_if_conf *conf); 987int rt2x00mac_get_stats(struct ieee80211_hw *hw, 988 struct ieee80211_low_level_stats *stats); 989int rt2x00mac_get_tx_stats(struct ieee80211_hw *hw, 990 struct ieee80211_tx_queue_stats *stats); 991void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, 992 struct ieee80211_vif *vif, 993 struct ieee80211_bss_conf *bss_conf, 994 u32 changes); 995int rt2x00mac_conf_tx(struct ieee80211_hw *hw, int queue, 996 const struct ieee80211_tx_queue_params *params); 997 998/* 999 * Driver allocation handlers. 1000 */ 1001int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev); 1002void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev); 1003#ifdef CONFIG_PM 1004int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state); 1005int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev); 1006#endif /* CONFIG_PM */ 1007 1008#endif /* RT2X00_H */ 1009