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