package/rt2x00/src/rt2x00.h

   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         Supported chipsets: RT2460, RT2560, RT2570,
  25         rt2561, rt2561s, rt2661, rt2571W & rt2671.
  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
  35 #include <net/mac80211.h>
  36
  37 #include "rt2x00lib.h"
  38 #include "rt2x00debug.h"
  39
  40 /*
  41  * Module information.
  42  */
  43 #ifndef DRV_NAME
  44 #define DRV_NAME        "rt2x00"
  45 #endif /* DRV_NAME */
  46 #define DRV_VERSION     "2.0.1"
  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(rt2x00dev->hw->wiphy),                       \
  56                 __FUNCTION__, __lvl, ##__args)
  57
  58 #define DEBUG_PRINTK_PROBE(__kernlvl, __lvl, __msg, __args...)          \
  59         printk(__kernlvl "%s -> %s: %s - " __msg,                       \
  60                 DRV_NAME, __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 /* CONFIG_RT2X00_DEBUG */
  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  * Ring sizes.
  96  * Ralink PCI devices demand the Frame size to be a multiple of 128 bytes.
  97  * DATA_FRAME_SIZE is used for TX, RX, ATIM and PRIO rings.
  98  * MGMT_FRAME_SIZE is used for the BEACON ring.
  99  */
 100 #define DATA_FRAME_SIZE 2432
 101 #define MGMT_FRAME_SIZE 256
 102
 103 /*
 104  * Number of entries in a packet ring.
 105  */
 106 #define RX_ENTRIES      12
 107 #define TX_ENTRIES      12
 108 #define ATIM_ENTRIES    1
 109 #define BEACON_ENTRIES  1
 110
 111 /*
 112  * Standard timing and size defines.
 113  */
 114 #define ACK_SIZE                14
 115 #define IEEE80211_HEADER        24
 116 #define PLCP                    48
 117 #define BEACON                  100
 118 #define PREAMBLE                144
 119 #define SHORT_PREAMBLE          72
 120 #define SLOT_TIME               20
 121 #define SHORT_SLOT_TIME         9
 122 #define SIFS                    10
 123 #define PIFS                    ( SIFS + SLOT_TIME )
 124 #define SHORT_PIFS              ( SIFS + SHORT_SLOT_TIME )
 125 #define DIFS                    ( PIFS + SLOT_TIME )
 126 #define SHORT_DIFS              ( SHORT_PIFS + SHORT_SLOT_TIME )
 127 #define EIFS                    ( SIFS + (8 * (IEEE80211_HEADER + ACK_SIZE)) )
 128
 129 /*
 130  * IEEE802.11 header defines
 131  */
 132 #define is_rts_frame(__fc) \
 133         ( !!((((__fc) &  IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL) && \
 134              (((__fc) &  IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_RTS)) )
 135 #define is_cts_frame(__fc) \
 136         ( !!((((__fc) &  IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL) && \
 137              (((__fc) &  IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_CTS)) )
 138 #define is_probe_resp(__fc) \
 139         ( !!((((__fc) & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) && \
 140              (((__fc) & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP)) )
 141
 142 /*
 143  * Interval defines
 144  */
 145 #define LINK_TUNE_INTERVAL      ( 1 * HZ )
 146 #define RFKILL_POLL_INTERVAL    ( HZ / 4 )
 147
 148 /*
 149  * TX result flags.
 150  */
 151 enum TX_STATUS {
 152         TX_SUCCESS = 0,
 153         TX_SUCCESS_RETRY = 1,
 154         TX_FAIL_RETRY = 2,
 155         TX_FAIL_INVALID = 3,
 156         TX_FAIL_OTHER = 4,
 157 };
 158
 159 /*
 160  * Antenna values
 161  */
 162 enum antenna {
 163         ANTENNA_DIVERSITY = 0,
 164         ANTENNA_A = 1,
 165         ANTENNA_B = 2,
 166 };
 167
 168 /*
 169  * Led mode values.
 170  */
 171 enum led_mode {
 172         LED_MODE_DEFAULT = 0,
 173         LED_MODE_TXRX_ACTIVITY = 1,
 174         LED_MODE_SIGNAL_STRENGTH = 2,
 175         LED_MODE_ASUS = 3,
 176         LED_MODE_ALPHA = 4,
 177 };
 178
 179 /*
 180  * Device states
 181  */
 182 enum dev_state {
 183         STATE_DEEP_SLEEP = 0,
 184         STATE_SLEEP = 1,
 185         STATE_STANDBY = 2,
 186         STATE_AWAKE = 3,
 187
 188 /*
 189  * Additional device states, these values are
 190  * not strict since they are not directly passed
 191  * into the device.
 192  */
 193         STATE_RADIO_ON,
 194         STATE_RADIO_OFF,
 195         STATE_RADIO_RX_ON,
 196         STATE_RADIO_RX_OFF,
 197 };
 198
 199 /*
 200  * IFS backoff values
 201  */
 202 enum ifs {
 203         IFS_BACKOFF = 0,
 204         IFS_SIFS = 1,
 205         IFS_NEW_BACKOFF = 2,
 206         IFS_NONE = 3,
 207 };
 208
 209 /*
 210  * Cipher types for hardware encryption
 211  */
 212 enum cipher {
 213         CIPHER_NONE = 0,
 214         CIPHER_WEP64 = 1,
 215         CIPHER_WEP128 = 2,
 216         CIPHER_TKIP = 3,
 217         CIPHER_AES = 4,
 218 /*
 219  * The following fields were added by rt61pci and rt73usb.
 220  */
 221         CIPHER_CKIP64 = 5,
 222         CIPHER_CKIP128 = 6,
 223         CIPHER_TKIP_NO_MIC = 7,
 224 };
 225
 226 /*
 227  * Register handlers.
 228  * We store the position of a register field inside a field structure,
 229  * This will simplify the process of setting and reading a certain field
 230  * inside the register while making sure the process remains byte order safe.
 231  */
 232 struct rt2x00_field8 {
 233         u8 bit_offset;
 234         u8 bit_mask;
 235 };
 236
 237 struct rt2x00_field16 {
 238         u16 bit_offset;
 239         u16 bit_mask;
 240 };
 241
 242 struct rt2x00_field32 {
 243         u32 bit_offset;
 244         u32 bit_mask;
 245 };
 246
 247 /*
 248  * Power of two check from Linus Torvalds,
 249  * this will check if the mask that has been
 250  * given contains and contiguous set of bits.
 251  */
 252 #define is_power_of_two(x)      ( !((x) & ((x)-1)) )
 253 #define low_bit_mask(x)         ( ((x)-1) & ~(x) )
 254 #define is_valid_mask(x)        is_power_of_two(1 + (x) + low_bit_mask(x))
 255
 256 #define FIELD8(__mask)                          \
 257 ({                                              \
 258         BUILD_BUG_ON(!(__mask) ||               \
 259                      !is_valid_mask(__mask) ||  \
 260                      (__mask) != (u8)(__mask)); \
 261         (struct rt2x00_field8) {                \
 262                 __ffs(__mask), (__mask)         \
 263         };                                      \
 264 })
 265
 266 #define FIELD16(__mask)                         \
 267 ({                                              \
 268         BUILD_BUG_ON(!(__mask) ||               \
 269                      !is_valid_mask(__mask) ||  \
 270                      (__mask) != (u16)(__mask));\
 271         (struct rt2x00_field16) {               \
 272                 __ffs(__mask), (__mask)         \
 273         };                                      \
 274 })
 275
 276 #define FIELD32(__mask)                         \
 277 ({                                              \
 278         BUILD_BUG_ON(!(__mask) ||               \
 279                      !is_valid_mask(__mask) ||  \
 280                      (__mask) != (u32)(__mask));\
 281         (struct rt2x00_field32) {               \
 282                 __ffs(__mask), (__mask)         \
 283         };                                      \
 284 })
 285
 286 static inline void rt2x00_set_field32(u32 *reg,
 287         const struct rt2x00_field32 field, const u32 value)
 288 {
 289         *reg &= ~(field.bit_mask);
 290         *reg |= (value << field.bit_offset) & field.bit_mask;
 291 }
 292
 293 static inline u32 rt2x00_get_field32(const u32 reg,
 294         const struct rt2x00_field32 field)
 295 {
 296         return (reg & field.bit_mask) >> field.bit_offset;
 297 }
 298
 299 static inline void rt2x00_set_field16(u16 *reg,
 300         const struct rt2x00_field16 field, const u16 value)
 301 {
 302         *reg &= ~(field.bit_mask);
 303         *reg |= (value << field.bit_offset) & field.bit_mask;
 304 }
 305
 306 static inline u16 rt2x00_get_field16(const u16 reg,
 307         const struct rt2x00_field16 field)
 308 {
 309         return (reg & field.bit_mask) >> field.bit_offset;
 310 }
 311
 312 static inline void rt2x00_set_field8(u8 *reg,
 313         const struct rt2x00_field8 field, const u8 value)
 314 {
 315         *reg &= ~(field.bit_mask);
 316         *reg |= (value << field.bit_offset) & field.bit_mask;
 317 }
 318
 319 static inline u8 rt2x00_get_field8(const u8 reg,
 320         const struct rt2x00_field8 field)
 321 {
 322         return (reg & field.bit_mask) >> field.bit_offset;
 323 }
 324
 325 /*
 326  * Chipset identification
 327  * The chipset on the device is composed of a RT and RF chip.
 328  * The chipset combination is important for determining device capabilities.
 329  */
 330 struct rt2x00_chip {
 331         u16 rt;
 332 #define RT2460          0x0101
 333 #define RT2560          0x0201
 334 #define RT2570          0x1201
 335 #define RT2561          0x0301
 336 #define RT2561s         0x0302
 337 #define RT2661          0x0401
 338 #define RT2571          0x1300
 339
 340         u16 rf;
 341         u32 rev;
 342 };
 343
 344 /*
 345  * data_desc
 346  * Each data entry also contains a descriptor which is used by the
 347  * device to determine what should be done with the packet and
 348  * what the current status is.
 349  * This structure is greatly simplified, but the descriptors
 350  * are basically a list of little endian 32 bit values.
 351  * Make the array by default 1 word big, this will allow us
 352  * to use sizeof() correctly.
 353  */
 354 struct data_desc {
 355         __le32 word[1];
 356 };
 357
 358 /*
 359  * data_entry_desc
 360  * Summary of information that should be written into the
 361  * descriptor for sending a TX frame.
 362  */
 363 struct data_entry_desc {
 364         /*
 365          * PLCP values.
 366          */
 367         u16 length_high;
 368         u16 length_low;
 369         u16 signal;
 370         u16 service;
 371
 372         int queue;
 373         int ifs;
 374 };
 375
 376 /*
 377  * data_entry
 378  * The data ring is a list of data entries.
 379  * Each entry holds a reference to the descriptor
 380  * and the data buffer. For TX rings the reference to the
 381  * sk_buff of the packet being transmitted is also stored here.
 382  */
 383 struct data_entry {
 384         /*
 385          * Status flags
 386          */
 387         unsigned long flags;
 388 #define ENTRY_OWNER_NIC         1
 389 #define ENTRY_TXDONE            2
 390 #define ENTRY_TXD_RTS_FRAME     3
 391 #define ENTRY_TXD_OFDM_RATE     4
 392 #define ENTRY_TXD_MORE_FRAG     5
 393 #define ENTRY_TXD_REQ_TIMESTAMP 6
 394 #define ENTRY_TXD_REQ_ACK       7
 395 #define ENTRY_TXD_NEW_SEQ       8
 396
 397         /*
 398          * Ring we belong to.
 399          */
 400         struct data_ring *ring;
 401
 402         /*
 403          * sk_buff for the packet which is being transmitted
 404          * in this entry (Only used with TX related rings).
 405          */
 406         struct sk_buff *skb;
 407
 408         /*
 409          * Store a ieee80211_tx_status structure in each
 410          * ring entry, this will optimize the txdone
 411          * handler.
 412          */
 413         struct ieee80211_tx_status tx_status;
 414
 415         /*
 416          * private pointer specific to driver.
 417          */
 418         void *priv;
 419
 420         /*
 421          * Data address for this entry.
 422          */
 423         void *data_addr;
 424         dma_addr_t data_dma;
 425 };
 426
 427 /*
 428  * data_ring
 429  * Data rings are used by the device to send and receive packets.
 430  * The data_addr is the base address of the data memory.
 431  * To determine at which point in the ring we are,
 432  * have to use the rt2x00_ring_index_*() functions.
 433  */
 434 struct data_ring {
 435         /*
 436          * Pointer to main rt2x00dev structure where this
 437          * ring belongs to.
 438          */
 439         struct rt2x00_dev *rt2x00dev;
 440
 441         /*
 442          * Base address for the device specific data entries.
 443          */
 444         struct data_entry *entry;
 445
 446         /*
 447          * TX queue statistic info.
 448          */
 449         struct ieee80211_tx_queue_stats_data stats;
 450
 451         /*
 452          * TX Queue parameters.
 453          */
 454         struct ieee80211_tx_queue_params tx_params;
 455
 456         /*
 457          * Base address for data ring.
 458          */
 459         dma_addr_t data_dma;
 460         void *data_addr;
 461
 462         /*
 463          * Index variables.
 464          */
 465         u16 index;
 466         u16 index_done;
 467
 468         /*
 469          * Size of packet and descriptor in bytes.
 470          */
 471         u16 data_size;
 472         u16 desc_size;
 473 };
 474
 475 /*
 476  * Handlers to determine the address of the current device specific
 477  * data entry, where either index or index_done points to.
 478  */
 479 static inline struct data_entry* rt2x00_get_data_entry(
 480         struct data_ring *ring)
 481 {
 482         return &ring->entry[ring->index];
 483 }
 484
 485 static inline struct data_entry* rt2x00_get_data_entry_done(
 486         struct data_ring *ring)
 487 {
 488         return &ring->entry[ring->index_done];
 489 }
 490
 491 /*
 492  * Total ring memory
 493  */
 494 static inline int rt2x00_get_ring_size(struct data_ring *ring)
 495 {
 496         return ring->stats.limit * (ring->desc_size + ring->data_size);
 497 }
 498
 499 /*
 500  * Ring index manipulation functions.
 501  */
 502 static inline void rt2x00_ring_index_inc(struct data_ring *ring)
 503 {
 504         ring->index++;
 505         if (ring->index >= ring->stats.limit)
 506                 ring->index = 0;
 507         ring->stats.len++;
 508 }
 509
 510 static inline void rt2x00_ring_index_done_inc(struct data_ring *ring)
 511 {
 512         ring->index_done++;
 513         if (ring->index_done >= ring->stats.limit)
 514                 ring->index_done = 0;
 515         ring->stats.len--;
 516         ring->stats.count++;
 517 }
 518
 519 static inline void rt2x00_ring_index_clear(struct data_ring *ring)
 520 {
 521         ring->index = 0;
 522         ring->index_done = 0;
 523         ring->stats.len = 0;
 524         ring->stats.count = 0;
 525 }
 526
 527 static inline int rt2x00_ring_empty(struct data_ring *ring)
 528 {
 529         return ring->stats.len == 0;
 530 }
 531
 532 static inline int rt2x00_ring_full(struct data_ring *ring)
 533 {
 534         return ring->stats.len == ring->stats.limit;
 535 }
 536
 537 static inline int rt2x00_ring_free(struct data_ring *ring)
 538 {
 539         if (ring->index_done >= ring->index)
 540                 return ring->index_done - ring->index;
 541         return ring->stats.len - (ring->index - ring->index_done);
 542 }
 543
 544 /*
 545  * TX/RX Descriptor access functions.
 546  */
 547 static inline void rt2x00_desc_read(struct data_desc *desc,
 548         const u8 word, u32 *value)
 549 {
 550         *value = le32_to_cpu(desc->word[word]);
 551 }
 552
 553 static inline void rt2x00_desc_write(struct data_desc *desc,
 554         const u8 word, const u32 value)
 555 {
 556         desc->word[word] = cpu_to_le32(value);
 557 }
 558
 559 /*
 560  * To optimize the quality of the link we need to store
 561  * the quality of received frames and periodically
 562  * optimize the link.
 563  */
 564 struct link {
 565         /*
 566          * Link tuner counter
 567          * The number of times the link has been tuned
 568          * since the radio has been switched on.
 569          */
 570         u32 count;
 571
 572         /*
 573          * RSSI statistics.
 574          */
 575         u32 count_rssi;
 576         u32 total_rssi;
 577
 578         /*
 579          * Misc statistics.
 580          */
 581         u32 curr_noise;
 582         u32 false_cca;
 583
 584         /*
 585          * Work structure for scheduling periodic link tuning.
 586          */
 587         struct delayed_work work;
 588 };
 589
 590 /*
 591  * Interface structure
 592  * Configuration details about the current interface.
 593  */
 594 struct interface {
 595         /*
 596          * Interface identification. The value is assigned
 597          * to us by the 80211 stack, and is used to request
 598          * new beacons.
 599          */
 600         int id;
 601
 602         /*
 603          * Current working type (IEEE80211_IF_TYPE_*).
 604          * This excludes the type IEEE80211_IF_TYPE_MNTR
 605          * since that is counted seperately in the monitor_count
 606          * field.
 607          */
 608         int type;
 609
 610         /*
 611          * BBSID of the AP to associate with.
 612          */
 613         u8 bssid[ETH_ALEN];
 614
 615         /*
 616          * Store the promisc mode for the current interface.
 617          * monitor mode always forces promisc mode to be enabled,
 618          * so we need to store the promisc mode seperately.
 619          */
 620         short promisc;
 621
 622         /*
 623          * Monitor mode count, the number of interfaces
 624          * in monitor mode that that have been added.
 625          */
 626         short monitor_count;
 627 };
 628
 629 static inline int is_interface_present(struct interface *intf)
 630 {
 631         return !!intf->id;
 632 }
 633
 634 static inline int is_monitor_present(struct interface *intf)
 635 {
 636         return !!intf->monitor_count;
 637 }
 638
 639 /*
 640  * rt2x00lib callback functions.
 641  */
 642 struct rt2x00lib_ops {
 643         /*
 644          * Interrupt handlers.
 645          */
 646         irq_handler_t irq_handler;
 647
 648         /*
 649          * Device init handlers.
 650          */
 651         int (*init_hw)(struct rt2x00_dev *rt2x00dev);
 652         char* (*get_fw_name)(struct rt2x00_dev *rt2x00dev);
 653         int (*load_firmware)(struct rt2x00_dev *rt2x00dev, void *data,
 654                 const size_t len);
 655
 656         /*
 657          * Device initialization/deinitialization handlers.
 658          */
 659         int (*initialize)(struct rt2x00_dev *rt2x00dev);
 660         void (*uninitialize)(struct rt2x00_dev *rt2x00dev);
 661
 662         /*
 663          * Radio control handlers.
 664          */
 665         int (*set_device_state)(struct rt2x00_dev *rt2x00dev,
 666                 enum dev_state state);
 667         int (*rfkill_poll)(struct rt2x00_dev *rt2x00dev);
 668         void (*link_tuner)(struct rt2x00_dev *rt2x00dev, int rssi);
 669
 670         /*
 671          * TX control handlers
 672          */
 673         void (*write_tx_desc)(struct rt2x00_dev *rt2x00dev,
 674                 struct data_entry *entry, struct data_desc *txd,
 675                 struct data_entry_desc *desc,
 676                 struct ieee80211_hdr *ieee80211hdr, unsigned int length,
 677                 struct ieee80211_tx_control *control);
 678         int (*write_tx_data)(struct rt2x00_dev *rt2x00dev,
 679                 struct data_ring *ring, struct sk_buff *skb,
 680                 struct ieee80211_tx_control *control);
 681         void (*kick_tx_queue)(struct rt2x00_dev *rt2x00dev, int queue);
 682
 683         /*
 684          * Configuration handlers.
 685          */
 686         void (*config_type)(struct rt2x00_dev *rt2x00dev, const int type);
 687         void (*config_phymode)(struct rt2x00_dev *rt2x00dev, const int phy);
 688         void (*config_channel)(struct rt2x00_dev *rt2x00dev, const int value,
 689         const int channel, const int txpower);
 690         void (*config_mac_addr)(struct rt2x00_dev *rt2x00dev, u8 *mac);
 691         void (*config_bssid)(struct rt2x00_dev *rt2x00dev, u8 *bssid);
 692         void (*config_promisc)(struct rt2x00_dev *rt2x00dev, const int promisc);
 693         void (*config_txpower)(struct rt2x00_dev *rt2x00dev, const int txpower);
 694         void (*config_antenna)(struct rt2x00_dev *rt2x00dev,
 695                 const int antenna_tx, const int antenna_rx);
 696         void (*config_duration)(struct rt2x00_dev *rt2x00dev,
 697                 const int short_slot_time, const int beacon_int);
 698 };
 699
 700 /*
 701  * rt2x00 driver callback operation structure.
 702  */
 703 struct rt2x00_ops {
 704         const char *name;
 705         const unsigned int rxd_size;
 706         const unsigned int txd_size;
 707         const struct rt2x00lib_ops *lib;
 708         const struct ieee80211_ops *hw;
 709 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
 710         const struct rt2x00debug *debugfs;
 711 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
 712 };
 713
 714 /*
 715  * rt2x00 device structure.
 716  */
 717 struct rt2x00_dev {
 718         /*
 719          * Device structure.
 720          * The structure stored in here depends on the
 721          * system bus (PCI or USB).
 722          * When accessing this variable, the rt2x00dev_{pci,usb}
 723          * macro's should be used for correct typecasting.
 724          */
 725         void *dev;
 726         struct device *device;
 727 #define rt2x00dev_pci(__dev)    ( (struct pci_dev*)(__dev)->dev )
 728 #define rt2x00dev_usb(__dev)    ( (struct usb_interface*)(__dev)->dev )
 729
 730         /*
 731          * Callback functions.
 732          */
 733         const struct rt2x00_ops *ops;
 734
 735         /*
 736          * IEEE80211 control structure.
 737          */
 738         struct ieee80211_hw *hw;
 739         struct ieee80211_hw_mode *hwmodes;
 740         unsigned int curr_hwmode;
 741 #define HWMODE_B        0
 742 #define HWMODE_G        1
 743 #define HWMODE_A        2
 744
 745         /*
 746          * rfkill structure for RF state switching support.
 747          * This will only be compiled in when required.
 748          */
 749 #ifdef CONFIG_RT2X00_LIB_RFKILL
 750         struct rfkill *rfkill;
 751         struct delayed_work rfkill_work;
 752 #endif /* CONFIG_RT2X00_LIB_RFKILL */
 753
 754         /*
 755          * Device flags.
 756          * In these flags the current status and some
 757          * of the device capabilities are stored.
 758          */
 759         unsigned long flags;
 760 #define DEVICE_ENABLED_RADIO            1
 761 #define DEVICE_ENABLED_RADIO_HW         2
 762 #define DEVICE_INITIALIZED              3
 763 #define DEVICE_INITIALIZED_HW           4
 764 #define FIRMWARE_REQUIRED               5
 765 #define FIRMWARE_LOADED                 6
 766 #define FIRMWARE_FAILED                 7
 767 #define INTERFACE_ENABLED               8
 768 #define INTERFACE_ENABLED_MONITOR       9
 769 #define INTERFACE_ENABLED_PROMISC       10
 770 #define DEVICE_SUPPORT_ATIM             11
 771 #define DEVICE_SUPPORT_HW_BUTTON        12
 772 #define CONFIG_FRAME_TYPE               13
 773 #define CONFIG_RF_SEQUENCE              14
 774 #define CONFIG_EXTERNAL_LNA             15
 775 #define CONFIG_EXTERNAL_LNA_A           16
 776 #define CONFIG_EXTERNAL_LNA_BG          17
 777 #define CONFIG_DOUBLE_ANTENNA           18
 778 #define CONFIG_DISABLE_LINK_TUNING      19
 779
 780         /*
 781          * Chipset identification.
 782          */
 783         struct rt2x00_chip chip;
 784
 785         /*
 786          * hw capability specifications.
 787          */
 788         struct hw_mode_spec spec;
 789
 790         /*
 791          * Base address of device registers (PCI devices only).
 792          */
 793         void __iomem *csr_addr;
 794
 795         /*
 796          * If enabled, the debugfs interface structures
 797          * required for deregistration of debugfs.
 798          */
 799         const struct rt2x00debug_intf *debugfs_intf;
 800
 801         /*
 802          * Queue for deferred work.
 803          */
 804         struct workqueue_struct *workqueue;
 805
 806         /*
 807          * Interface configuration.
 808          */
 809         struct interface interface;
 810
 811         /*
 812          * Link quality
 813          */
 814         struct link link;
 815
 816         /*
 817          * EEPROM data.
 818          */
 819         __le16 *eeprom;
 820
 821         /*
 822          * Active RF register values.
 823          * These are stored here for easier working
 824          * with the rf registers.
 825          */
 826         u32 rf1;
 827         u32 rf2;
 828         u32 rf3;
 829         u32 rf4;
 830
 831         /*
 832          * Current TX power value.
 833          */
 834         u16 tx_power;
 835
 836         /*
 837          * LED register (for rt61pci & rt73usb).
 838          */
 839         u16 led_reg;
 840
 841         /*
 842          * Led mode (LED_MODE_*)
 843          */
 844         u8 led_mode;
 845
 846         /*
 847          * EEPROM bus width (PCI devices only).
 848          */
 849         u8 eeprom_width;
 850
 851         /*
 852          * Frequency offset (for rt61pci & rt73usb).
 853          */
 854         u8 freq_offset;
 855
 856         /*
 857          * Low level statistics which will have
 858          * to be kept up to date while device is running.
 859          */
 860         struct ieee80211_low_level_stats low_level_stats;
 861
 862         /*
 863          * RX configuration information.
 864          */
 865         struct ieee80211_rx_status rx_status;
 866
 867         /*
 868          * Data ring arrays for RX, TX and Beacon.
 869          * The Beacon array also contains the Atim ring
 870          * if that is supported by the device.
 871          */
 872         struct data_ring *rx;
 873         struct data_ring *tx;
 874         struct data_ring *bcn;
 875 };
 876
 877 static inline struct data_ring* rt2x00_get_ring(
 878         struct rt2x00_dev *rt2x00dev, const unsigned int queue)
 879 {
 880         int atim = test_bit(DEVICE_SUPPORT_ATIM, &rt2x00dev->flags);
 881
 882         /*
 883          * Check if the rings have been allocated.
 884          */
 885         if (!rt2x00dev->tx || !rt2x00dev->bcn)
 886                 return NULL;
 887
 888         /*
 889          * Check if we are requesting a reqular TX ring,
 890          * or if we are requesting a Beacon or Atim ring.
 891          * For Atim rings, we should check if it is supported.
 892          */
 893         if (queue < rt2x00dev->hw->queues)
 894                 return &rt2x00dev->tx[queue];
 895         else if (queue == IEEE80211_TX_QUEUE_BEACON)
 896                 return &rt2x00dev->bcn[0];
 897         else if (queue == IEEE80211_TX_QUEUE_AFTER_BEACON && atim)
 898                 return &rt2x00dev->bcn[1];
 899
 900         return NULL;
 901 }
 902
 903 /*
 904  * For-each loop for the ring array.
 905  * Since the all rings are allocated as a single array,
 906  * we can start at the rx pointer and move forward to the tx rings.
 907  * The 1 + Atim check will assure that the address directly after
 908  * the ring array is obtained and the for-each loop exits correctly.
 909  */
 910 #define ring_for_each(__dev, __entry)           \
 911         for ((__entry) = (__dev)->rx;           \
 912                 (__entry) != &(__dev)->bcn[1 +  \
 913                         test_bit(DEVICE_SUPPORT_ATIM, &rt2x00dev->flags)]; \
 914                 (__entry)++)
 915
 916 #define txring_for_each(__dev, __entry)         \
 917         for ((__entry) = (__dev)->tx; (__entry) != (__dev)->bcn; (__entry)++)
 918
 919 /*
 920  * EEPROM access.
 921  * The EEPROM is being accessed by word index.
 922  */
 923 static inline void* rt2x00_eeprom_addr(const struct rt2x00_dev *rt2x00dev,
 924         const u8 word)
 925 {
 926         return (void*)&rt2x00dev->eeprom[word];
 927 }
 928
 929 static inline void rt2x00_eeprom_read(const struct rt2x00_dev *rt2x00dev,
 930         const u8 word, u16 *data)
 931 {
 932         *data = le16_to_cpu(rt2x00dev->eeprom[word]);
 933 }
 934
 935 static inline void rt2x00_eeprom_write(const struct rt2x00_dev *rt2x00dev,
 936         const u8 word, u16 data)
 937 {
 938         rt2x00dev->eeprom[word] = cpu_to_le16(data);
 939 }
 940
 941 /*
 942  * Link tuning handlers
 943  */
 944 static inline void rt2x00_start_link_tune(struct rt2x00_dev *rt2x00dev)
 945 {
 946         rt2x00dev->link.count = 0;
 947         rt2x00dev->link.count_rssi = 0;
 948         rt2x00dev->link.total_rssi = 0;
 949         rt2x00dev->link.curr_noise = 0;
 950
 951         queue_delayed_work(rt2x00dev->workqueue,
 952                 &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
 953 }
 954
 955 static inline void rt2x00_stop_link_tune(struct rt2x00_dev *rt2x00dev)
 956 {
 957         if (work_pending(&rt2x00dev->link.work.work))
 958                 cancel_rearming_delayed_workqueue(
 959                         rt2x00dev->workqueue, &rt2x00dev->link.work);
 960 }
 961
 962 static inline void rt2x00_update_link_rssi(struct link *link, u32 rssi)
 963 {
 964         link->count_rssi++;
 965         link->total_rssi += rssi;
 966 }
 967
 968 static inline u32 rt2x00_get_link_rssi(struct link *link)
 969 {
 970         u32 average = 0;
 971
 972         if (link->count_rssi && link->total_rssi)
 973                 average = link->total_rssi / link->count_rssi;
 974
 975         link->count_rssi = 0;
 976         link->total_rssi = 0;
 977
 978         return average;
 979 }
 980
 981 /*
 982  * Chipset handlers
 983  */
 984 static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev,
 985         const u16 rt, const u16 rf, const u32 rev)
 986 {
 987         INFO(rt2x00dev,
 988                 "Chipset detected - rt: %04x, rf: %04x, rev: %08x.\n",
 989                 rt, rf, rev);
 990
 991         rt2x00dev->chip.rt = rt;
 992         rt2x00dev->chip.rf = rf;
 993         rt2x00dev->chip.rev = rev;
 994 }
 995
 996 static inline char rt2x00_rt(const struct rt2x00_chip *chipset, const u16 chip)
 997 {
 998         return (chipset->rt == chip);
 999 }
1000
1001 static inline char rt2x00_rf(const struct rt2x00_chip *chipset, const u16 chip)
1002 {
1003         return (chipset->rf == chip);
1004 }
1005
1006 static inline u16 rt2x00_rev(const struct rt2x00_chip *chipset)
1007 {
1008         return chipset->rev;
1009 }
1010
1011 /*
1012  * Device specific rate value.
1013  * We will have to create the device specific rate value
1014  * passed to the ieee80211 kernel. We need to make it a consist of
1015  * multiple fields because we want to store more then 1 device specific
1016  * values inside the value.
1017  *      1 - rate, stored as 100 kbit/s.
1018  *      2 - preamble, short_preamble enabled flag.
1019  *      3 - MASK_RATE, which rates are enabled in this mode, this mask
1020  *      corresponds with the TX register format for the current device.
1021  *      4 - plcp, 802.11b rates are device specific,
1022  *      802.11g rates are set according to the ieee802.11a-1999 p.14.
1023  * The bit to enable preamble is set in a seperate define.
1024  */
1025 #define DEV_RATE        FIELD32(0x000007ff)
1026 #define DEV_PREAMBLE    FIELD32(0x00000800)
1027 #define DEV_RATEMASK    FIELD32(0x00fff000)
1028 #define DEV_PLCP        FIELD32(0xff000000)
1029
1030 /*
1031  * Bitmask for MASK_RATE
1032  */
1033 #define DEV_RATE_1MB    0x00000001
1034 #define DEV_RATE_2MB    0x00000002
1035 #define DEV_RATE_5_5MB  0x00000004
1036 #define DEV_RATE_11MB   0x00000008
1037 #define DEV_RATE_6MB    0x00000010
1038 #define DEV_RATE_9MB    0x00000020
1039 #define DEV_RATE_12MB   0x00000040
1040 #define DEV_RATE_18MB   0x00000080
1041 #define DEV_RATE_24MB   0x00000100
1042 #define DEV_RATE_36MB   0x00000200
1043 #define DEV_RATE_48MB   0x00000400
1044 #define DEV_RATE_54MB   0x00000800
1045
1046 /*
1047  * Bitmask groups of bitrates
1048  */
1049 #define DEV_BASIC_RATE \
1050         ( DEV_RATE_1MB | DEV_RATE_2MB | DEV_RATE_5_5MB | DEV_RATE_11MB | \
1051           DEV_RATE_6MB | DEV_RATE_12MB | DEV_RATE_24MB )
1052
1053 #define DEV_CCK_RATE \
1054         ( DEV_RATE_1MB | DEV_RATE_2MB | DEV_RATE_5_5MB | DEV_RATE_11MB )
1055
1056 #define DEV_OFDM_RATE \
1057         ( DEV_RATE_6MB | DEV_RATE_9MB | DEV_RATE_12MB | DEV_RATE_18MB | \
1058           DEV_RATE_24MB | DEV_RATE_36MB | DEV_RATE_48MB | DEV_RATE_54MB )
1059
1060 /*
1061  * Macro's to set and get specific fields from the device specific val and val2
1062  * fields inside the ieee80211_rate entry.
1063  */
1064 #define DEVICE_SET_RATE_FIELD(__value, __mask) \
1065         (int)( ((__value) << DEV_##__mask.bit_offset) & DEV_##__mask.bit_mask )
1066
1067 #define DEVICE_GET_RATE_FIELD(__value, __mask) \
1068         (int)( ((__value) & DEV_##__mask.bit_mask) >> DEV_##__mask.bit_offset )
1069
1070 /*
1071  * Duration calculations
1072  * The rate variable passed is: 100kbs.
1073  * To convert from bytes to bits we multiply size with 8,
1074  * then the size is multiplied with 10 to make the
1075  * real rate -> rate argument correction.
1076  */
1077 static inline u16 get_duration(const unsigned int size, const u8 rate)
1078 {
1079         return ((size * 8 * 10) / rate);
1080 }
1081
1082 static inline u16 get_duration_res(const unsigned int size, const u8 rate)
1083 {
1084         return ((size * 8 * 10) % rate);
1085 }
1086
1087 #endif /* RT2X00_H */