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