rt2x00.h revision 0ed7b3c04434788ef03d267190c5e9e6e3f8e9ce
1/* 2 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com> 3 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com> 4 Copyright (C) 2004 - 2009 Gertjan van Wingerde <gwingerde@gmail.com> 5 <http://rt2x00.serialmonkey.com> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the 19 Free Software Foundation, Inc., 20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 21 */ 22 23/* 24 Module: rt2x00 25 Abstract: rt2x00 global information. 26 */ 27 28#ifndef RT2X00_H 29#define RT2X00_H 30 31#include <linux/bitops.h> 32#include <linux/skbuff.h> 33#include <linux/workqueue.h> 34#include <linux/firmware.h> 35#include <linux/leds.h> 36#include <linux/mutex.h> 37#include <linux/etherdevice.h> 38#include <linux/input-polldev.h> 39#include <linux/kfifo.h> 40#include <linux/timer.h> 41 42#include <net/mac80211.h> 43 44#include "rt2x00debug.h" 45#include "rt2x00dump.h" 46#include "rt2x00leds.h" 47#include "rt2x00reg.h" 48#include "rt2x00queue.h" 49 50/* 51 * Module information. 52 */ 53#define DRV_VERSION "2.3.0" 54#define DRV_PROJECT "http://rt2x00.serialmonkey.com" 55 56/* 57 * Debug definitions. 58 * Debug output has to be enabled during compile time. 59 */ 60#define DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, __args...) \ 61 printk(__kernlvl "%s -> %s: %s - " __msg, \ 62 wiphy_name((__dev)->hw->wiphy), __func__, __lvl, ##__args) 63 64#define DEBUG_PRINTK_PROBE(__kernlvl, __lvl, __msg, __args...) \ 65 printk(__kernlvl "%s -> %s: %s - " __msg, \ 66 KBUILD_MODNAME, __func__, __lvl, ##__args) 67 68#ifdef CONFIG_RT2X00_DEBUG 69#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...) \ 70 DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, ##__args) 71#else 72#define DEBUG_PRINTK(__dev, __kernlvl, __lvl, __msg, __args...) \ 73 do { } while (0) 74#endif /* CONFIG_RT2X00_DEBUG */ 75 76/* 77 * Various debug levels. 78 * The debug levels PANIC and ERROR both indicate serious problems, 79 * for this reason they should never be ignored. 80 * The special ERROR_PROBE message is for messages that are generated 81 * when the rt2x00_dev is not yet initialized. 82 */ 83#define PANIC(__dev, __msg, __args...) \ 84 DEBUG_PRINTK_MSG(__dev, KERN_CRIT, "Panic", __msg, ##__args) 85#define ERROR(__dev, __msg, __args...) \ 86 DEBUG_PRINTK_MSG(__dev, KERN_ERR, "Error", __msg, ##__args) 87#define ERROR_PROBE(__msg, __args...) \ 88 DEBUG_PRINTK_PROBE(KERN_ERR, "Error", __msg, ##__args) 89#define WARNING(__dev, __msg, __args...) \ 90 DEBUG_PRINTK(__dev, KERN_WARNING, "Warning", __msg, ##__args) 91#define NOTICE(__dev, __msg, __args...) \ 92 DEBUG_PRINTK(__dev, KERN_NOTICE, "Notice", __msg, ##__args) 93#define INFO(__dev, __msg, __args...) \ 94 DEBUG_PRINTK(__dev, KERN_INFO, "Info", __msg, ##__args) 95#define DEBUG(__dev, __msg, __args...) \ 96 DEBUG_PRINTK(__dev, KERN_DEBUG, "Debug", __msg, ##__args) 97#define EEPROM(__dev, __msg, __args...) \ 98 DEBUG_PRINTK(__dev, KERN_DEBUG, "EEPROM recovery", __msg, ##__args) 99 100/* 101 * Duration calculations 102 * The rate variable passed is: 100kbs. 103 * To convert from bytes to bits we multiply size with 8, 104 * then the size is multiplied with 10 to make the 105 * real rate -> rate argument correction. 106 */ 107#define GET_DURATION(__size, __rate) (((__size) * 8 * 10) / (__rate)) 108#define GET_DURATION_RES(__size, __rate)(((__size) * 8 * 10) % (__rate)) 109 110/* 111 * Determine the number of L2 padding bytes required between the header and 112 * the payload. 113 */ 114#define L2PAD_SIZE(__hdrlen) (-(__hdrlen) & 3) 115 116/* 117 * Determine the alignment requirement, 118 * to make sure the 802.11 payload is padded to a 4-byte boundrary 119 * we must determine the address of the payload and calculate the 120 * amount of bytes needed to move the data. 121 */ 122#define ALIGN_SIZE(__skb, __header) \ 123 ( ((unsigned long)((__skb)->data + (__header))) & 3 ) 124 125/* 126 * Constants for extra TX headroom for alignment purposes. 127 */ 128#define RT2X00_ALIGN_SIZE 4 /* Only whole frame needs alignment */ 129#define RT2X00_L2PAD_SIZE 8 /* Both header & payload need alignment */ 130 131/* 132 * Standard timing and size defines. 133 * These values should follow the ieee80211 specifications. 134 */ 135#define ACK_SIZE 14 136#define IEEE80211_HEADER 24 137#define PLCP 48 138#define BEACON 100 139#define PREAMBLE 144 140#define SHORT_PREAMBLE 72 141#define SLOT_TIME 20 142#define SHORT_SLOT_TIME 9 143#define SIFS 10 144#define PIFS ( SIFS + SLOT_TIME ) 145#define SHORT_PIFS ( SIFS + SHORT_SLOT_TIME ) 146#define DIFS ( PIFS + SLOT_TIME ) 147#define SHORT_DIFS ( SHORT_PIFS + SHORT_SLOT_TIME ) 148#define EIFS ( SIFS + DIFS + \ 149 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10) ) 150#define SHORT_EIFS ( SIFS + SHORT_DIFS + \ 151 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10) ) 152 153/* 154 * Structure for average calculation 155 * The avg field contains the actual average value, 156 * but avg_weight is internally used during calculations 157 * to prevent rounding errors. 158 */ 159struct avg_val { 160 int avg; 161 int avg_weight; 162}; 163 164enum rt2x00_chip_intf { 165 RT2X00_CHIP_INTF_PCI, 166 RT2X00_CHIP_INTF_PCIE, 167 RT2X00_CHIP_INTF_USB, 168 RT2X00_CHIP_INTF_SOC, 169}; 170 171/* 172 * Chipset identification 173 * The chipset on the device is composed of a RT and RF chip. 174 * The chipset combination is important for determining device capabilities. 175 */ 176struct rt2x00_chip { 177 u16 rt; 178#define RT2460 0x2460 179#define RT2560 0x2560 180#define RT2570 0x2570 181#define RT2661 0x2661 182#define RT2573 0x2573 183#define RT2860 0x2860 /* 2.4GHz */ 184#define RT2872 0x2872 /* WSOC */ 185#define RT2883 0x2883 /* WSOC */ 186#define RT3070 0x3070 187#define RT3071 0x3071 188#define RT3090 0x3090 /* 2.4GHz PCIe */ 189#define RT3390 0x3390 190#define RT3572 0x3572 191#define RT3593 0x3593 /* PCIe */ 192#define RT3883 0x3883 /* WSOC */ 193#define RT5390 0x5390 /* 2.4GHz */ 194 195 u16 rf; 196 u16 rev; 197 198 enum rt2x00_chip_intf intf; 199}; 200 201/* 202 * RF register values that belong to a particular channel. 203 */ 204struct rf_channel { 205 int channel; 206 u32 rf1; 207 u32 rf2; 208 u32 rf3; 209 u32 rf4; 210}; 211 212/* 213 * Channel information structure 214 */ 215struct channel_info { 216 unsigned int flags; 217#define GEOGRAPHY_ALLOWED 0x00000001 218 219 short max_power; 220 short default_power1; 221 short default_power2; 222}; 223 224/* 225 * Antenna setup values. 226 */ 227struct antenna_setup { 228 enum antenna rx; 229 enum antenna tx; 230 u8 rx_chain_num; 231 u8 tx_chain_num; 232}; 233 234/* 235 * Quality statistics about the currently active link. 236 */ 237struct link_qual { 238 /* 239 * Statistics required for Link tuning by driver 240 * The rssi value is provided by rt2x00lib during the 241 * link_tuner() callback function. 242 * The false_cca field is filled during the link_stats() 243 * callback function and could be used during the 244 * link_tuner() callback function. 245 */ 246 int rssi; 247 int false_cca; 248 249 /* 250 * VGC levels 251 * Hardware driver will tune the VGC level during each call 252 * to the link_tuner() callback function. This vgc_level is 253 * is determined based on the link quality statistics like 254 * average RSSI and the false CCA count. 255 * 256 * In some cases the drivers need to differentiate between 257 * the currently "desired" VGC level and the level configured 258 * in the hardware. The latter is important to reduce the 259 * number of BBP register reads to reduce register access 260 * overhead. For this reason we store both values here. 261 */ 262 u8 vgc_level; 263 u8 vgc_level_reg; 264 265 /* 266 * Statistics required for Signal quality calculation. 267 * These fields might be changed during the link_stats() 268 * callback function. 269 */ 270 int rx_success; 271 int rx_failed; 272 int tx_success; 273 int tx_failed; 274}; 275 276/* 277 * Antenna settings about the currently active link. 278 */ 279struct link_ant { 280 /* 281 * Antenna flags 282 */ 283 unsigned int flags; 284#define ANTENNA_RX_DIVERSITY 0x00000001 285#define ANTENNA_TX_DIVERSITY 0x00000002 286#define ANTENNA_MODE_SAMPLE 0x00000004 287 288 /* 289 * Currently active TX/RX antenna setup. 290 * When software diversity is used, this will indicate 291 * which antenna is actually used at this time. 292 */ 293 struct antenna_setup active; 294 295 /* 296 * RSSI history information for the antenna. 297 * Used to determine when to switch antenna 298 * when using software diversity. 299 */ 300 int rssi_history; 301 302 /* 303 * Current RSSI average of the currently active antenna. 304 * Similar to the avg_rssi in the link_qual structure 305 * this value is updated by using the walking average. 306 */ 307 struct avg_val rssi_ant; 308}; 309 310/* 311 * To optimize the quality of the link we need to store 312 * the quality of received frames and periodically 313 * optimize the link. 314 */ 315struct link { 316 /* 317 * Link tuner counter 318 * The number of times the link has been tuned 319 * since the radio has been switched on. 320 */ 321 u32 count; 322 323 /* 324 * Quality measurement values. 325 */ 326 struct link_qual qual; 327 328 /* 329 * TX/RX antenna setup. 330 */ 331 struct link_ant ant; 332 333 /* 334 * Currently active average RSSI value 335 */ 336 struct avg_val avg_rssi; 337 338 /* 339 * Work structure for scheduling periodic link tuning. 340 */ 341 struct delayed_work work; 342 343 /* 344 * Work structure for scheduling periodic watchdog monitoring. 345 * This work must be scheduled on the kernel workqueue, while 346 * all other work structures must be queued on the mac80211 347 * workqueue. This guarantees that the watchdog can schedule 348 * other work structures and wait for their completion in order 349 * to bring the device/driver back into the desired state. 350 */ 351 struct delayed_work watchdog_work; 352 353 /* 354 * Work structure for scheduling periodic AGC adjustments. 355 */ 356 struct delayed_work agc_work; 357}; 358 359enum rt2x00_delayed_flags { 360 DELAYED_UPDATE_BEACON, 361}; 362 363/* 364 * Interface structure 365 * Per interface configuration details, this structure 366 * is allocated as the private data for ieee80211_vif. 367 */ 368struct rt2x00_intf { 369 /* 370 * beacon->skb must be protected with the mutex. 371 */ 372 struct mutex beacon_skb_mutex; 373 374 /* 375 * Entry in the beacon queue which belongs to 376 * this interface. Each interface has its own 377 * dedicated beacon entry. 378 */ 379 struct queue_entry *beacon; 380 bool enable_beacon; 381 382 /* 383 * Actions that needed rescheduling. 384 */ 385 unsigned long delayed_flags; 386 387 /* 388 * Software sequence counter, this is only required 389 * for hardware which doesn't support hardware 390 * sequence counting. 391 */ 392 spinlock_t seqlock; 393 u16 seqno; 394}; 395 396static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif) 397{ 398 return (struct rt2x00_intf *)vif->drv_priv; 399} 400 401/** 402 * struct hw_mode_spec: Hardware specifications structure 403 * 404 * Details about the supported modes, rates and channels 405 * of a particular chipset. This is used by rt2x00lib 406 * to build the ieee80211_hw_mode array for mac80211. 407 * 408 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz). 409 * @supported_rates: Rate types which are supported (CCK, OFDM). 410 * @num_channels: Number of supported channels. This is used as array size 411 * for @tx_power_a, @tx_power_bg and @channels. 412 * @channels: Device/chipset specific channel values (See &struct rf_channel). 413 * @channels_info: Additional information for channels (See &struct channel_info). 414 * @ht: Driver HT Capabilities (See &ieee80211_sta_ht_cap). 415 */ 416struct hw_mode_spec { 417 unsigned int supported_bands; 418#define SUPPORT_BAND_2GHZ 0x00000001 419#define SUPPORT_BAND_5GHZ 0x00000002 420 421 unsigned int supported_rates; 422#define SUPPORT_RATE_CCK 0x00000001 423#define SUPPORT_RATE_OFDM 0x00000002 424 425 unsigned int num_channels; 426 const struct rf_channel *channels; 427 const struct channel_info *channels_info; 428 429 struct ieee80211_sta_ht_cap ht; 430}; 431 432/* 433 * Configuration structure wrapper around the 434 * mac80211 configuration structure. 435 * When mac80211 configures the driver, rt2x00lib 436 * can precalculate values which are equal for all 437 * rt2x00 drivers. Those values can be stored in here. 438 */ 439struct rt2x00lib_conf { 440 struct ieee80211_conf *conf; 441 442 struct rf_channel rf; 443 struct channel_info channel; 444}; 445 446/* 447 * Configuration structure for erp settings. 448 */ 449struct rt2x00lib_erp { 450 int short_preamble; 451 int cts_protection; 452 453 u32 basic_rates; 454 455 int slot_time; 456 457 short sifs; 458 short pifs; 459 short difs; 460 short eifs; 461 462 u16 beacon_int; 463 u16 ht_opmode; 464}; 465 466/* 467 * Configuration structure for hardware encryption. 468 */ 469struct rt2x00lib_crypto { 470 enum cipher cipher; 471 472 enum set_key_cmd cmd; 473 const u8 *address; 474 475 u32 bssidx; 476 477 u8 key[16]; 478 u8 tx_mic[8]; 479 u8 rx_mic[8]; 480}; 481 482/* 483 * Configuration structure wrapper around the 484 * rt2x00 interface configuration handler. 485 */ 486struct rt2x00intf_conf { 487 /* 488 * Interface type 489 */ 490 enum nl80211_iftype type; 491 492 /* 493 * TSF sync value, this is dependant on the operation type. 494 */ 495 enum tsf_sync sync; 496 497 /* 498 * The MAC and BSSID addressess are simple array of bytes, 499 * these arrays are little endian, so when sending the addressess 500 * to the drivers, copy the it into a endian-signed variable. 501 * 502 * Note that all devices (except rt2500usb) have 32 bits 503 * register word sizes. This means that whatever variable we 504 * pass _must_ be a multiple of 32 bits. Otherwise the device 505 * might not accept what we are sending to it. 506 * This will also make it easier for the driver to write 507 * the data to the device. 508 */ 509 __le32 mac[2]; 510 __le32 bssid[2]; 511}; 512 513/* 514 * rt2x00lib callback functions. 515 */ 516struct rt2x00lib_ops { 517 /* 518 * Interrupt handlers. 519 */ 520 irq_handler_t irq_handler; 521 522 /* 523 * TX status tasklet handler. 524 */ 525 void (*txstatus_tasklet) (unsigned long data); 526 void (*pretbtt_tasklet) (unsigned long data); 527 void (*tbtt_tasklet) (unsigned long data); 528 void (*rxdone_tasklet) (unsigned long data); 529 void (*autowake_tasklet) (unsigned long data); 530 531 /* 532 * Device init handlers. 533 */ 534 int (*probe_hw) (struct rt2x00_dev *rt2x00dev); 535 char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev); 536 int (*check_firmware) (struct rt2x00_dev *rt2x00dev, 537 const u8 *data, const size_t len); 538 int (*load_firmware) (struct rt2x00_dev *rt2x00dev, 539 const u8 *data, const size_t len); 540 541 /* 542 * Device initialization/deinitialization handlers. 543 */ 544 int (*initialize) (struct rt2x00_dev *rt2x00dev); 545 void (*uninitialize) (struct rt2x00_dev *rt2x00dev); 546 547 /* 548 * queue initialization handlers 549 */ 550 bool (*get_entry_state) (struct queue_entry *entry); 551 void (*clear_entry) (struct queue_entry *entry); 552 553 /* 554 * Radio control handlers. 555 */ 556 int (*set_device_state) (struct rt2x00_dev *rt2x00dev, 557 enum dev_state state); 558 int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev); 559 void (*link_stats) (struct rt2x00_dev *rt2x00dev, 560 struct link_qual *qual); 561 void (*reset_tuner) (struct rt2x00_dev *rt2x00dev, 562 struct link_qual *qual); 563 void (*link_tuner) (struct rt2x00_dev *rt2x00dev, 564 struct link_qual *qual, const u32 count); 565 void (*gain_calibration) (struct rt2x00_dev *rt2x00dev); 566 567 /* 568 * Data queue handlers. 569 */ 570 void (*watchdog) (struct rt2x00_dev *rt2x00dev); 571 void (*start_queue) (struct data_queue *queue); 572 void (*kick_queue) (struct data_queue *queue); 573 void (*stop_queue) (struct data_queue *queue); 574 void (*flush_queue) (struct data_queue *queue, bool drop); 575 void (*tx_dma_done) (struct queue_entry *entry); 576 577 /* 578 * TX control handlers 579 */ 580 void (*write_tx_desc) (struct queue_entry *entry, 581 struct txentry_desc *txdesc); 582 void (*write_tx_data) (struct queue_entry *entry, 583 struct txentry_desc *txdesc); 584 void (*write_beacon) (struct queue_entry *entry, 585 struct txentry_desc *txdesc); 586 void (*clear_beacon) (struct queue_entry *entry); 587 int (*get_tx_data_len) (struct queue_entry *entry); 588 589 /* 590 * RX control handlers 591 */ 592 void (*fill_rxdone) (struct queue_entry *entry, 593 struct rxdone_entry_desc *rxdesc); 594 595 /* 596 * Configuration handlers. 597 */ 598 int (*config_shared_key) (struct rt2x00_dev *rt2x00dev, 599 struct rt2x00lib_crypto *crypto, 600 struct ieee80211_key_conf *key); 601 int (*config_pairwise_key) (struct rt2x00_dev *rt2x00dev, 602 struct rt2x00lib_crypto *crypto, 603 struct ieee80211_key_conf *key); 604 void (*config_filter) (struct rt2x00_dev *rt2x00dev, 605 const unsigned int filter_flags); 606 void (*config_intf) (struct rt2x00_dev *rt2x00dev, 607 struct rt2x00_intf *intf, 608 struct rt2x00intf_conf *conf, 609 const unsigned int flags); 610#define CONFIG_UPDATE_TYPE ( 1 << 1 ) 611#define CONFIG_UPDATE_MAC ( 1 << 2 ) 612#define CONFIG_UPDATE_BSSID ( 1 << 3 ) 613 614 void (*config_erp) (struct rt2x00_dev *rt2x00dev, 615 struct rt2x00lib_erp *erp, 616 u32 changed); 617 void (*config_ant) (struct rt2x00_dev *rt2x00dev, 618 struct antenna_setup *ant); 619 void (*config) (struct rt2x00_dev *rt2x00dev, 620 struct rt2x00lib_conf *libconf, 621 const unsigned int changed_flags); 622}; 623 624/* 625 * rt2x00 driver callback operation structure. 626 */ 627struct rt2x00_ops { 628 const char *name; 629 const unsigned int max_sta_intf; 630 const unsigned int max_ap_intf; 631 const unsigned int eeprom_size; 632 const unsigned int rf_size; 633 const unsigned int tx_queues; 634 const unsigned int extra_tx_headroom; 635 const struct data_queue_desc *rx; 636 const struct data_queue_desc *tx; 637 const struct data_queue_desc *bcn; 638 const struct data_queue_desc *atim; 639 const struct rt2x00lib_ops *lib; 640 const void *drv; 641 const struct ieee80211_ops *hw; 642#ifdef CONFIG_RT2X00_LIB_DEBUGFS 643 const struct rt2x00debug *debugfs; 644#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 645}; 646 647/* 648 * rt2x00 state flags 649 */ 650enum rt2x00_state_flags { 651 /* 652 * Device flags 653 */ 654 DEVICE_STATE_PRESENT, 655 DEVICE_STATE_REGISTERED_HW, 656 DEVICE_STATE_INITIALIZED, 657 DEVICE_STATE_STARTED, 658 DEVICE_STATE_ENABLED_RADIO, 659 DEVICE_STATE_SCANNING, 660 661 /* 662 * Driver configuration 663 */ 664 CONFIG_CHANNEL_HT40, 665}; 666 667/* 668 * rt2x00 capability flags 669 */ 670enum rt2x00_capability_flags { 671 /* 672 * Requirements 673 */ 674 REQUIRE_FIRMWARE, 675 REQUIRE_BEACON_GUARD, 676 REQUIRE_ATIM_QUEUE, 677 REQUIRE_DMA, 678 REQUIRE_COPY_IV, 679 REQUIRE_L2PAD, 680 REQUIRE_TXSTATUS_FIFO, 681 REQUIRE_TASKLET_CONTEXT, 682 REQUIRE_SW_SEQNO, 683 REQUIRE_HT_TX_DESC, 684 685 /* 686 * Capabilities 687 */ 688 CAPABILITY_HW_BUTTON, 689 CAPABILITY_HW_CRYPTO, 690 CAPABILITY_POWER_LIMIT, 691 CAPABILITY_CONTROL_FILTERS, 692 CAPABILITY_CONTROL_FILTER_PSPOLL, 693 CAPABILITY_PRE_TBTT_INTERRUPT, 694 CAPABILITY_LINK_TUNING, 695 CAPABILITY_FRAME_TYPE, 696 CAPABILITY_RF_SEQUENCE, 697 CAPABILITY_EXTERNAL_LNA_A, 698 CAPABILITY_EXTERNAL_LNA_BG, 699 CAPABILITY_DOUBLE_ANTENNA, 700}; 701 702/* 703 * rt2x00 device structure. 704 */ 705struct rt2x00_dev { 706 /* 707 * Device structure. 708 * The structure stored in here depends on the 709 * system bus (PCI or USB). 710 * When accessing this variable, the rt2x00dev_{pci,usb} 711 * macros should be used for correct typecasting. 712 */ 713 struct device *dev; 714 715 /* 716 * Callback functions. 717 */ 718 const struct rt2x00_ops *ops; 719 720 /* 721 * IEEE80211 control structure. 722 */ 723 struct ieee80211_hw *hw; 724 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS]; 725 enum ieee80211_band curr_band; 726 int curr_freq; 727 728 /* 729 * If enabled, the debugfs interface structures 730 * required for deregistration of debugfs. 731 */ 732#ifdef CONFIG_RT2X00_LIB_DEBUGFS 733 struct rt2x00debug_intf *debugfs_intf; 734#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 735 736 /* 737 * LED structure for changing the LED status 738 * by mac8011 or the kernel. 739 */ 740#ifdef CONFIG_RT2X00_LIB_LEDS 741 struct rt2x00_led led_radio; 742 struct rt2x00_led led_assoc; 743 struct rt2x00_led led_qual; 744 u16 led_mcu_reg; 745#endif /* CONFIG_RT2X00_LIB_LEDS */ 746 747 /* 748 * Device state flags. 749 * In these flags the current status is stored. 750 * Access to these flags should occur atomically. 751 */ 752 unsigned long flags; 753 754 /* 755 * Device capabiltiy flags. 756 * In these flags the device/driver capabilities are stored. 757 * Access to these flags should occur non-atomically. 758 */ 759 unsigned long cap_flags; 760 761 /* 762 * Device information, Bus IRQ and name (PCI, SoC) 763 */ 764 int irq; 765 const char *name; 766 767 /* 768 * Chipset identification. 769 */ 770 struct rt2x00_chip chip; 771 772 /* 773 * hw capability specifications. 774 */ 775 struct hw_mode_spec spec; 776 777 /* 778 * This is the default TX/RX antenna setup as indicated 779 * by the device's EEPROM. 780 */ 781 struct antenna_setup default_ant; 782 783 /* 784 * Register pointers 785 * csr.base: CSR base register address. (PCI) 786 * csr.cache: CSR cache for usb_control_msg. (USB) 787 */ 788 union csr { 789 void __iomem *base; 790 void *cache; 791 } csr; 792 793 /* 794 * Mutex to protect register accesses. 795 * For PCI and USB devices it protects against concurrent indirect 796 * register access (BBP, RF, MCU) since accessing those 797 * registers require multiple calls to the CSR registers. 798 * For USB devices it also protects the csr_cache since that 799 * field is used for normal CSR access and it cannot support 800 * multiple callers simultaneously. 801 */ 802 struct mutex csr_mutex; 803 804 /* 805 * Current packet filter configuration for the device. 806 * This contains all currently active FIF_* flags send 807 * to us by mac80211 during configure_filter(). 808 */ 809 unsigned int packet_filter; 810 811 /* 812 * Interface details: 813 * - Open ap interface count. 814 * - Open sta interface count. 815 * - Association count. 816 * - Beaconing enabled count. 817 */ 818 unsigned int intf_ap_count; 819 unsigned int intf_sta_count; 820 unsigned int intf_associated; 821 unsigned int intf_beaconing; 822 823 /* 824 * Link quality 825 */ 826 struct link link; 827 828 /* 829 * EEPROM data. 830 */ 831 __le16 *eeprom; 832 833 /* 834 * Active RF register values. 835 * These are stored here so we don't need 836 * to read the rf registers and can directly 837 * use this value instead. 838 * This field should be accessed by using 839 * rt2x00_rf_read() and rt2x00_rf_write(). 840 */ 841 u32 *rf; 842 843 /* 844 * LNA gain 845 */ 846 short lna_gain; 847 848 /* 849 * Current TX power value. 850 */ 851 u16 tx_power; 852 853 /* 854 * Current retry values. 855 */ 856 u8 short_retry; 857 u8 long_retry; 858 859 /* 860 * Rssi <-> Dbm offset 861 */ 862 u8 rssi_offset; 863 864 /* 865 * Frequency offset (for rt61pci & rt73usb). 866 */ 867 u8 freq_offset; 868 869 /* 870 * Calibration information (for rt2800usb & rt2800pci). 871 * [0] -> BW20 872 * [1] -> BW40 873 */ 874 u8 calibration[2]; 875 876 /* 877 * Beacon interval. 878 */ 879 u16 beacon_int; 880 881 /* 882 * Low level statistics which will have 883 * to be kept up to date while device is running. 884 */ 885 struct ieee80211_low_level_stats low_level_stats; 886 887 /** 888 * Work queue for all work which should not be placed 889 * on the mac80211 workqueue (because of dependencies 890 * between various work structures). 891 */ 892 struct workqueue_struct *workqueue; 893 894 /* 895 * Scheduled work. 896 * NOTE: intf_work will use ieee80211_iterate_active_interfaces() 897 * which means it cannot be placed on the hw->workqueue 898 * due to RTNL locking requirements. 899 */ 900 struct work_struct intf_work; 901 902 /** 903 * Scheduled work for TX/RX done handling (USB devices) 904 */ 905 struct work_struct rxdone_work; 906 struct work_struct txdone_work; 907 908 /* 909 * Data queue arrays for RX, TX, Beacon and ATIM. 910 */ 911 unsigned int data_queues; 912 struct data_queue *rx; 913 struct data_queue *tx; 914 struct data_queue *bcn; 915 struct data_queue *atim; 916 917 /* 918 * Firmware image. 919 */ 920 const struct firmware *fw; 921 922 /* 923 * FIFO for storing tx status reports between isr and tasklet. 924 */ 925 DECLARE_KFIFO_PTR(txstatus_fifo, u32); 926 927 /* 928 * Timer to ensure tx status reports are read (rt2800usb). 929 */ 930 struct timer_list txstatus_timer; 931 932 /* 933 * Tasklet for processing tx status reports (rt2800pci). 934 */ 935 struct tasklet_struct txstatus_tasklet; 936 struct tasklet_struct pretbtt_tasklet; 937 struct tasklet_struct tbtt_tasklet; 938 struct tasklet_struct rxdone_tasklet; 939 struct tasklet_struct autowake_tasklet; 940 941 /* 942 * Protect the interrupt mask register. 943 */ 944 spinlock_t irqmask_lock; 945}; 946 947/* 948 * Register defines. 949 * Some registers require multiple attempts before success, 950 * in those cases REGISTER_BUSY_COUNT attempts should be 951 * taken with a REGISTER_BUSY_DELAY interval. 952 */ 953#define REGISTER_BUSY_COUNT 100 954#define REGISTER_BUSY_DELAY 100 955 956/* 957 * Generic RF access. 958 * The RF is being accessed by word index. 959 */ 960static inline void rt2x00_rf_read(struct rt2x00_dev *rt2x00dev, 961 const unsigned int word, u32 *data) 962{ 963 BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32)); 964 *data = rt2x00dev->rf[word - 1]; 965} 966 967static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev, 968 const unsigned int word, u32 data) 969{ 970 BUG_ON(word < 1 || word > rt2x00dev->ops->rf_size / sizeof(u32)); 971 rt2x00dev->rf[word - 1] = data; 972} 973 974/* 975 * Generic EEPROM access. 976 * The EEPROM is being accessed by word index. 977 */ 978static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev, 979 const unsigned int word) 980{ 981 return (void *)&rt2x00dev->eeprom[word]; 982} 983 984static inline void rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev, 985 const unsigned int word, u16 *data) 986{ 987 *data = le16_to_cpu(rt2x00dev->eeprom[word]); 988} 989 990static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev, 991 const unsigned int word, u16 data) 992{ 993 rt2x00dev->eeprom[word] = cpu_to_le16(data); 994} 995 996/* 997 * Chipset handlers 998 */ 999static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev, 1000 const u16 rt, const u16 rf, const u16 rev) 1001{ 1002 rt2x00dev->chip.rt = rt; 1003 rt2x00dev->chip.rf = rf; 1004 rt2x00dev->chip.rev = rev; 1005 1006 INFO(rt2x00dev, 1007 "Chipset detected - rt: %04x, rf: %04x, rev: %04x.\n", 1008 rt2x00dev->chip.rt, rt2x00dev->chip.rf, rt2x00dev->chip.rev); 1009} 1010 1011static inline bool rt2x00_rt(struct rt2x00_dev *rt2x00dev, const u16 rt) 1012{ 1013 return (rt2x00dev->chip.rt == rt); 1014} 1015 1016static inline bool rt2x00_rf(struct rt2x00_dev *rt2x00dev, const u16 rf) 1017{ 1018 return (rt2x00dev->chip.rf == rf); 1019} 1020 1021static inline u16 rt2x00_rev(struct rt2x00_dev *rt2x00dev) 1022{ 1023 return rt2x00dev->chip.rev; 1024} 1025 1026static inline bool rt2x00_rt_rev(struct rt2x00_dev *rt2x00dev, 1027 const u16 rt, const u16 rev) 1028{ 1029 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) == rev); 1030} 1031 1032static inline bool rt2x00_rt_rev_lt(struct rt2x00_dev *rt2x00dev, 1033 const u16 rt, const u16 rev) 1034{ 1035 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) < rev); 1036} 1037 1038static inline bool rt2x00_rt_rev_gte(struct rt2x00_dev *rt2x00dev, 1039 const u16 rt, const u16 rev) 1040{ 1041 return (rt2x00_rt(rt2x00dev, rt) && rt2x00_rev(rt2x00dev) >= rev); 1042} 1043 1044static inline void rt2x00_set_chip_intf(struct rt2x00_dev *rt2x00dev, 1045 enum rt2x00_chip_intf intf) 1046{ 1047 rt2x00dev->chip.intf = intf; 1048} 1049 1050static inline bool rt2x00_intf(struct rt2x00_dev *rt2x00dev, 1051 enum rt2x00_chip_intf intf) 1052{ 1053 return (rt2x00dev->chip.intf == intf); 1054} 1055 1056static inline bool rt2x00_is_pci(struct rt2x00_dev *rt2x00dev) 1057{ 1058 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCI) || 1059 rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE); 1060} 1061 1062static inline bool rt2x00_is_pcie(struct rt2x00_dev *rt2x00dev) 1063{ 1064 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_PCIE); 1065} 1066 1067static inline bool rt2x00_is_usb(struct rt2x00_dev *rt2x00dev) 1068{ 1069 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_USB); 1070} 1071 1072static inline bool rt2x00_is_soc(struct rt2x00_dev *rt2x00dev) 1073{ 1074 return rt2x00_intf(rt2x00dev, RT2X00_CHIP_INTF_SOC); 1075} 1076 1077/** 1078 * rt2x00queue_map_txskb - Map a skb into DMA for TX purposes. 1079 * @entry: Pointer to &struct queue_entry 1080 */ 1081void rt2x00queue_map_txskb(struct queue_entry *entry); 1082 1083/** 1084 * rt2x00queue_unmap_skb - Unmap a skb from DMA. 1085 * @entry: Pointer to &struct queue_entry 1086 */ 1087void rt2x00queue_unmap_skb(struct queue_entry *entry); 1088 1089/** 1090 * rt2x00queue_get_tx_queue - Convert tx queue index to queue pointer 1091 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1092 * @queue: rt2x00 queue index (see &enum data_queue_qid). 1093 * 1094 * Returns NULL for non tx queues. 1095 */ 1096static inline struct data_queue * 1097rt2x00queue_get_tx_queue(struct rt2x00_dev *rt2x00dev, 1098 const enum data_queue_qid queue) 1099{ 1100 if (queue < rt2x00dev->ops->tx_queues && rt2x00dev->tx) 1101 return &rt2x00dev->tx[queue]; 1102 1103 if (queue == QID_ATIM) 1104 return rt2x00dev->atim; 1105 1106 return NULL; 1107} 1108 1109/** 1110 * rt2x00queue_get_entry - Get queue entry where the given index points to. 1111 * @queue: Pointer to &struct data_queue from where we obtain the entry. 1112 * @index: Index identifier for obtaining the correct index. 1113 */ 1114struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue, 1115 enum queue_index index); 1116 1117/** 1118 * rt2x00queue_pause_queue - Pause a data queue 1119 * @queue: Pointer to &struct data_queue. 1120 * 1121 * This function will pause the data queue locally, preventing 1122 * new frames to be added to the queue (while the hardware is 1123 * still allowed to run). 1124 */ 1125void rt2x00queue_pause_queue(struct data_queue *queue); 1126 1127/** 1128 * rt2x00queue_unpause_queue - unpause a data queue 1129 * @queue: Pointer to &struct data_queue. 1130 * 1131 * This function will unpause the data queue locally, allowing 1132 * new frames to be added to the queue again. 1133 */ 1134void rt2x00queue_unpause_queue(struct data_queue *queue); 1135 1136/** 1137 * rt2x00queue_start_queue - Start a data queue 1138 * @queue: Pointer to &struct data_queue. 1139 * 1140 * This function will start handling all pending frames in the queue. 1141 */ 1142void rt2x00queue_start_queue(struct data_queue *queue); 1143 1144/** 1145 * rt2x00queue_stop_queue - Halt a data queue 1146 * @queue: Pointer to &struct data_queue. 1147 * 1148 * This function will stop all pending frames in the queue. 1149 */ 1150void rt2x00queue_stop_queue(struct data_queue *queue); 1151 1152/** 1153 * rt2x00queue_flush_queue - Flush a data queue 1154 * @queue: Pointer to &struct data_queue. 1155 * @drop: True to drop all pending frames. 1156 * 1157 * This function will flush the queue. After this call 1158 * the queue is guarenteed to be empty. 1159 */ 1160void rt2x00queue_flush_queue(struct data_queue *queue, bool drop); 1161 1162/** 1163 * rt2x00queue_start_queues - Start all data queues 1164 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1165 * 1166 * This function will loop through all available queues to start them 1167 */ 1168void rt2x00queue_start_queues(struct rt2x00_dev *rt2x00dev); 1169 1170/** 1171 * rt2x00queue_stop_queues - Halt all data queues 1172 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1173 * 1174 * This function will loop through all available queues to stop 1175 * any pending frames. 1176 */ 1177void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev); 1178 1179/** 1180 * rt2x00queue_flush_queues - Flush all data queues 1181 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1182 * @drop: True to drop all pending frames. 1183 * 1184 * This function will loop through all available queues to flush 1185 * any pending frames. 1186 */ 1187void rt2x00queue_flush_queues(struct rt2x00_dev *rt2x00dev, bool drop); 1188 1189/* 1190 * Debugfs handlers. 1191 */ 1192/** 1193 * rt2x00debug_dump_frame - Dump a frame to userspace through debugfs. 1194 * @rt2x00dev: Pointer to &struct rt2x00_dev. 1195 * @type: The type of frame that is being dumped. 1196 * @skb: The skb containing the frame to be dumped. 1197 */ 1198#ifdef CONFIG_RT2X00_LIB_DEBUGFS 1199void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev, 1200 enum rt2x00_dump_type type, struct sk_buff *skb); 1201#else 1202static inline void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev, 1203 enum rt2x00_dump_type type, 1204 struct sk_buff *skb) 1205{ 1206} 1207#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 1208 1209/* 1210 * Interrupt context handlers. 1211 */ 1212void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev); 1213void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev); 1214void rt2x00lib_dmastart(struct queue_entry *entry); 1215void rt2x00lib_dmadone(struct queue_entry *entry); 1216void rt2x00lib_txdone(struct queue_entry *entry, 1217 struct txdone_entry_desc *txdesc); 1218void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status); 1219void rt2x00lib_rxdone(struct queue_entry *entry); 1220 1221/* 1222 * mac80211 handlers. 1223 */ 1224void rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb); 1225int rt2x00mac_start(struct ieee80211_hw *hw); 1226void rt2x00mac_stop(struct ieee80211_hw *hw); 1227int rt2x00mac_add_interface(struct ieee80211_hw *hw, 1228 struct ieee80211_vif *vif); 1229void rt2x00mac_remove_interface(struct ieee80211_hw *hw, 1230 struct ieee80211_vif *vif); 1231int rt2x00mac_config(struct ieee80211_hw *hw, u32 changed); 1232void rt2x00mac_configure_filter(struct ieee80211_hw *hw, 1233 unsigned int changed_flags, 1234 unsigned int *total_flags, 1235 u64 multicast); 1236int rt2x00mac_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 1237 bool set); 1238#ifdef CONFIG_RT2X00_LIB_CRYPTO 1239int rt2x00mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 1240 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 1241 struct ieee80211_key_conf *key); 1242#else 1243#define rt2x00mac_set_key NULL 1244#endif /* CONFIG_RT2X00_LIB_CRYPTO */ 1245void rt2x00mac_sw_scan_start(struct ieee80211_hw *hw); 1246void rt2x00mac_sw_scan_complete(struct ieee80211_hw *hw); 1247int rt2x00mac_get_stats(struct ieee80211_hw *hw, 1248 struct ieee80211_low_level_stats *stats); 1249void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw, 1250 struct ieee80211_vif *vif, 1251 struct ieee80211_bss_conf *bss_conf, 1252 u32 changes); 1253int rt2x00mac_conf_tx(struct ieee80211_hw *hw, u16 queue, 1254 const struct ieee80211_tx_queue_params *params); 1255void rt2x00mac_rfkill_poll(struct ieee80211_hw *hw); 1256void rt2x00mac_flush(struct ieee80211_hw *hw, bool drop); 1257int rt2x00mac_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant); 1258int rt2x00mac_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant); 1259void rt2x00mac_get_ringparam(struct ieee80211_hw *hw, 1260 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max); 1261 1262/* 1263 * Driver allocation handlers. 1264 */ 1265int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev); 1266void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev); 1267#ifdef CONFIG_PM 1268int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state); 1269int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev); 1270#endif /* CONFIG_PM */ 1271 1272#endif /* RT2X00_H */ 1273