rt2x00.h revision 61486e0f68d1f8966c09b734566a187d42d65c54
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.5" 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#define DELAYED_LED_ASSOC 0x00000004 389}; 390 391static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif) 392{ 393 return (struct rt2x00_intf *)vif->drv_priv; 394} 395 396/** 397 * struct hw_mode_spec: Hardware specifications structure 398 * 399 * Details about the supported modes, rates and channels 400 * of a particular chipset. This is used by rt2x00lib 401 * to build the ieee80211_hw_mode array for mac80211. 402 * 403 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz). 404 * @supported_rates: Rate types which are supported (CCK, OFDM). 405 * @num_channels: Number of supported channels. This is used as array size 406 * for @tx_power_a, @tx_power_bg and @channels. 407 * @channels: Device/chipset specific channel values (See &struct rf_channel). 408 * @tx_power_a: TX power values for all 5.2GHz channels (may be NULL). 409 * @tx_power_bg: TX power values for all 2.4GHz channels (may be NULL). 410 * @tx_power_default: Default TX power value to use when either 411 * @tx_power_a or @tx_power_bg is missing. 412 */ 413struct hw_mode_spec { 414 unsigned int supported_bands; 415#define SUPPORT_BAND_2GHZ 0x00000001 416#define SUPPORT_BAND_5GHZ 0x00000002 417 418 unsigned int supported_rates; 419#define SUPPORT_RATE_CCK 0x00000001 420#define SUPPORT_RATE_OFDM 0x00000002 421 422 unsigned int num_channels; 423 const struct rf_channel *channels; 424 425 const u8 *tx_power_a; 426 const u8 *tx_power_bg; 427 u8 tx_power_default; 428}; 429 430/* 431 * Configuration structure wrapper around the 432 * mac80211 configuration structure. 433 * When mac80211 configures the driver, rt2x00lib 434 * can precalculate values which are equal for all 435 * rt2x00 drivers. Those values can be stored in here. 436 */ 437struct rt2x00lib_conf { 438 struct ieee80211_conf *conf; 439 struct rf_channel rf; 440 441 struct antenna_setup ant; 442 443 enum ieee80211_band band; 444 445 u32 basic_rates; 446 u32 slot_time; 447 448 short sifs; 449 short pifs; 450 short difs; 451 short eifs; 452}; 453 454/* 455 * Configuration structure for erp settings. 456 */ 457struct rt2x00lib_erp { 458 int short_preamble; 459 460 int ack_timeout; 461 int ack_consume_time; 462}; 463 464/* 465 * Configuration structure wrapper around the 466 * rt2x00 interface configuration handler. 467 */ 468struct rt2x00intf_conf { 469 /* 470 * Interface type 471 */ 472 enum ieee80211_if_types type; 473 474 /* 475 * TSF sync value, this is dependant on the operation type. 476 */ 477 enum tsf_sync sync; 478 479 /* 480 * The MAC and BSSID addressess are simple array of bytes, 481 * these arrays are little endian, so when sending the addressess 482 * to the drivers, copy the it into a endian-signed variable. 483 * 484 * Note that all devices (except rt2500usb) have 32 bits 485 * register word sizes. This means that whatever variable we 486 * pass _must_ be a multiple of 32 bits. Otherwise the device 487 * might not accept what we are sending to it. 488 * This will also make it easier for the driver to write 489 * the data to the device. 490 */ 491 __le32 mac[2]; 492 __le32 bssid[2]; 493}; 494 495/* 496 * rt2x00lib callback functions. 497 */ 498struct rt2x00lib_ops { 499 /* 500 * Interrupt handlers. 501 */ 502 irq_handler_t irq_handler; 503 504 /* 505 * Device init handlers. 506 */ 507 int (*probe_hw) (struct rt2x00_dev *rt2x00dev); 508 char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev); 509 u16 (*get_firmware_crc) (void *data, const size_t len); 510 int (*load_firmware) (struct rt2x00_dev *rt2x00dev, void *data, 511 const size_t len); 512 513 /* 514 * Device initialization/deinitialization handlers. 515 */ 516 int (*initialize) (struct rt2x00_dev *rt2x00dev); 517 void (*uninitialize) (struct rt2x00_dev *rt2x00dev); 518 519 /* 520 * queue initialization handlers 521 */ 522 void (*init_rxentry) (struct rt2x00_dev *rt2x00dev, 523 struct queue_entry *entry); 524 void (*init_txentry) (struct rt2x00_dev *rt2x00dev, 525 struct queue_entry *entry); 526 527 /* 528 * Radio control handlers. 529 */ 530 int (*set_device_state) (struct rt2x00_dev *rt2x00dev, 531 enum dev_state state); 532 int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev); 533 void (*link_stats) (struct rt2x00_dev *rt2x00dev, 534 struct link_qual *qual); 535 void (*reset_tuner) (struct rt2x00_dev *rt2x00dev); 536 void (*link_tuner) (struct rt2x00_dev *rt2x00dev); 537 538 /* 539 * TX control handlers 540 */ 541 void (*write_tx_desc) (struct rt2x00_dev *rt2x00dev, 542 struct sk_buff *skb, 543 struct txentry_desc *txdesc); 544 int (*write_tx_data) (struct rt2x00_dev *rt2x00dev, 545 struct data_queue *queue, struct sk_buff *skb, 546 struct ieee80211_tx_control *control); 547 int (*get_tx_data_len) (struct rt2x00_dev *rt2x00dev, 548 struct sk_buff *skb); 549 void (*kick_tx_queue) (struct rt2x00_dev *rt2x00dev, 550 const enum data_queue_qid queue); 551 552 /* 553 * RX control handlers 554 */ 555 void (*fill_rxdone) (struct queue_entry *entry, 556 struct rxdone_entry_desc *rxdesc); 557 558 /* 559 * Configuration handlers. 560 */ 561 void (*config_filter) (struct rt2x00_dev *rt2x00dev, 562 const unsigned int filter_flags); 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 void (*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_REQUIRE_FIRMWARE, 624 DRIVER_REQUIRE_BEACON_GUARD, 625 DRIVER_REQUIRE_ATIM_QUEUE, 626 DRIVER_REQUIRE_SCHEDULED, 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 unsigned long rfkill_state; 675#define RFKILL_STATE_ALLOCATED 1 676#define RFKILL_STATE_REGISTERED 2 677 struct rfkill *rfkill; 678 struct input_polled_dev *poll_dev; 679#endif /* CONFIG_RT2X00_LIB_RFKILL */ 680 681 /* 682 * If enabled, the debugfs interface structures 683 * required for deregistration of debugfs. 684 */ 685#ifdef CONFIG_RT2X00_LIB_DEBUGFS 686 struct rt2x00debug_intf *debugfs_intf; 687#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 688 689 /* 690 * LED structure for changing the LED status 691 * by mac8011 or the kernel. 692 */ 693#ifdef CONFIG_RT2X00_LIB_LEDS 694 struct rt2x00_led led_radio; 695 struct rt2x00_led led_assoc; 696 struct rt2x00_led led_qual; 697 u16 led_mcu_reg; 698#endif /* CONFIG_RT2X00_LIB_LEDS */ 699 700 /* 701 * Device flags. 702 * In these flags the current status and some 703 * of the device capabilities are stored. 704 */ 705 unsigned long flags; 706 707 /* 708 * Chipset identification. 709 */ 710 struct rt2x00_chip chip; 711 712 /* 713 * hw capability specifications. 714 */ 715 struct hw_mode_spec spec; 716 717 /* 718 * This is the default TX/RX antenna setup as indicated 719 * by the device's EEPROM. When mac80211 sets its 720 * antenna value to 0 we should be using these values. 721 */ 722 struct antenna_setup default_ant; 723 724 /* 725 * Register pointers 726 * csr.base: CSR base register address. (PCI) 727 * csr.cache: CSR cache for usb_control_msg. (USB) 728 */ 729 union csr { 730 void __iomem *base; 731 void *cache; 732 } csr; 733 734 /* 735 * Mutex to protect register accesses on USB devices. 736 * There are 2 reasons this is needed, one is to ensure 737 * use of the csr_cache (for USB devices) by one thread 738 * isn't corrupted by another thread trying to access it. 739 * The other is that access to BBP and RF registers 740 * require multiple BUS transactions and if another thread 741 * attempted to access one of those registers at the same 742 * time one of the writes could silently fail. 743 */ 744 struct mutex usb_cache_mutex; 745 746 /* 747 * Current packet filter configuration for the device. 748 * This contains all currently active FIF_* flags send 749 * to us by mac80211 during configure_filter(). 750 */ 751 unsigned int packet_filter; 752 753 /* 754 * Interface details: 755 * - Open ap interface count. 756 * - Open sta interface count. 757 * - Association count. 758 */ 759 unsigned int intf_ap_count; 760 unsigned int intf_sta_count; 761 unsigned int intf_associated; 762 763 /* 764 * Link quality 765 */ 766 struct link link; 767 768 /* 769 * EEPROM data. 770 */ 771 __le16 *eeprom; 772 773 /* 774 * Active RF register values. 775 * These are stored here so we don't need 776 * to read the rf registers and can directly 777 * use this value instead. 778 * This field should be accessed by using 779 * rt2x00_rf_read() and rt2x00_rf_write(). 780 */ 781 u32 *rf; 782 783 /* 784 * USB Max frame size (for rt2500usb & rt73usb). 785 */ 786 u16 usb_maxpacket; 787 788 /* 789 * Current TX power value. 790 */ 791 u16 tx_power; 792 793 /* 794 * Rssi <-> Dbm offset 795 */ 796 u8 rssi_offset; 797 798 /* 799 * Frequency offset (for rt61pci & rt73usb). 800 */ 801 u8 freq_offset; 802 803 /* 804 * Low level statistics which will have 805 * to be kept up to date while device is running. 806 */ 807 struct ieee80211_low_level_stats low_level_stats; 808 809 /* 810 * RX configuration information. 811 */ 812 struct ieee80211_rx_status rx_status; 813 814 /* 815 * Scheduled work. 816 */ 817 struct work_struct intf_work; 818 struct work_struct filter_work; 819 820 /* 821 * Data queue arrays for RX, TX and Beacon. 822 * The Beacon array also contains the Atim queue 823 * if that is supported by the device. 824 */ 825 int data_queues; 826 struct data_queue *rx; 827 struct data_queue *tx; 828 struct data_queue *bcn; 829 830 /* 831 * Firmware image. 832 */ 833 const struct firmware *fw; 834}; 835 836/* 837 * Generic RF access. 838 * The RF is being accessed by word index. 839 */ 840static inline void rt2x00_rf_read(struct rt2x00_dev *rt2x00dev, 841 const unsigned int word, u32 *data) 842{ 843 *data = rt2x00dev->rf[word]; 844} 845 846static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev, 847 const unsigned int word, u32 data) 848{ 849 rt2x00dev->rf[word] = data; 850} 851 852/* 853 * Generic EEPROM access. 854 * The EEPROM is being accessed by word index. 855 */ 856static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev, 857 const unsigned int word) 858{ 859 return (void *)&rt2x00dev->eeprom[word]; 860} 861 862static inline void rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev, 863 const unsigned int word, u16 *data) 864{ 865 *data = le16_to_cpu(rt2x00dev->eeprom[word]); 866} 867 868static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev, 869 const unsigned int word, u16 data) 870{ 871 rt2x00dev->eeprom[word] = cpu_to_le16(data); 872} 873 874/* 875 * Chipset handlers 876 */ 877static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev, 878 const u16 rt, const u16 rf, const u32 rev) 879{ 880 INFO(rt2x00dev, 881 "Chipset detected - rt: %04x, rf: %04x, rev: %08x.\n", 882 rt, rf, rev); 883 884 rt2x00dev->chip.rt = rt; 885 rt2x00dev->chip.rf = rf; 886 rt2x00dev->chip.rev = rev; 887} 888 889static inline char rt2x00_rt(const struct rt2x00_chip *chipset, const u16 chip) 890{ 891 return (chipset->rt == chip); 892} 893 894static inline char rt2x00_rf(const struct rt2x00_chip *chipset, const u16 chip) 895{ 896 return (chipset->rf == chip); 897} 898 899static inline u16 rt2x00_rev(const struct rt2x00_chip *chipset) 900{ 901 return chipset->rev; 902} 903 904static inline u16 rt2x00_check_rev(const struct rt2x00_chip *chipset, 905 const u32 rev) 906{ 907 return (((chipset->rev & 0xffff0) == rev) && 908 !!(chipset->rev & 0x0000f)); 909} 910 911/* 912 * Duration calculations 913 * The rate variable passed is: 100kbs. 914 * To convert from bytes to bits we multiply size with 8, 915 * then the size is multiplied with 10 to make the 916 * real rate -> rate argument correction. 917 */ 918static inline u16 get_duration(const unsigned int size, const u8 rate) 919{ 920 return ((size * 8 * 10) / rate); 921} 922 923static inline u16 get_duration_res(const unsigned int size, const u8 rate) 924{ 925 return ((size * 8 * 10) % rate); 926} 927 928/** 929 * rt2x00queue_get_queue - Convert queue index to queue pointer 930 * @rt2x00dev: Pointer to &struct rt2x00_dev. 931 * @queue: rt2x00 queue index (see &enum data_queue_qid). 932 */ 933struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev, 934 const enum data_queue_qid queue); 935 936/** 937 * rt2x00queue_get_entry - Get queue entry where the given index points to. 938 * @queue: Pointer to &struct data_queue from where we obtain the entry. 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 * @index: 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); 987void rt2x00mac_configure_filter(struct ieee80211_hw *hw, 988 unsigned int changed_flags, 989 unsigned int *total_flags, 990 int mc_count, struct dev_addr_list *mc_list); 991int rt2x00mac_get_stats(struct ieee80211_hw *hw, 992 struct ieee80211_low_level_stats *stats); 993int rt2x00mac_get_tx_stats(struct ieee80211_hw *hw, 994 struct ieee80211_tx_queue_stats *stats); 995void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, 996 struct ieee80211_vif *vif, 997 struct ieee80211_bss_conf *bss_conf, 998 u32 changes); 999int rt2x00mac_conf_tx(struct ieee80211_hw *hw, u16 queue, 1000 const struct ieee80211_tx_queue_params *params); 1001 1002/* 1003 * Driver allocation handlers. 1004 */ 1005int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev); 1006void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev); 1007#ifdef CONFIG_PM 1008int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state); 1009int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev); 1010#endif /* CONFIG_PM */ 1011 1012#endif /* RT2X00_H */ 1013