Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
Ivo van Doorn | 3a1532f | 2007-09-25 20:58:08 +0200 | [diff] [blame] | 45 | #define DRV_VERSION "2.0.9" |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
| 134 | static 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 | |
| 140 | static 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 | |
| 146 | static 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 | */ |
| 157 | struct rt2x00_chip { |
| 158 | u16 rt; |
| 159 | #define RT2460 0x0101 |
| 160 | #define RT2560 0x0201 |
| 161 | #define RT2570 0x1201 |
Ivo van Doorn | 12dadb9 | 2007-09-25 20:54:44 +0200 | [diff] [blame] | 162 | #define RT2561s 0x0301 /* Turbo */ |
| 163 | #define RT2561 0x0302 |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
| 174 | struct 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 | */ |
| 187 | struct 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 | */ |
| 255 | static 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 | */ |
| 265 | static 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 | */ |
| 278 | static 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 | */ |
| 287 | struct 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_*). |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 297 | * When set to INVALID_INTERFACE, no interface is configured. |
| 298 | */ |
| 299 | int type; |
Johannes Berg | a289755 | 2007-09-28 14:01:25 +0200 | [diff] [blame] | 300 | #define INVALID_INTERFACE IEEE80211_IF_TYPE_INVALID |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 314 | */ |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 315 | unsigned int filter; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 316 | }; |
| 317 | |
| 318 | static inline int is_interface_present(struct interface *intf) |
| 319 | { |
| 320 | return !!intf->id; |
| 321 | } |
| 322 | |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 323 | static inline int is_interface_type(struct interface *intf, int type) |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 324 | { |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 325 | return intf->type == type; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
| 333 | struct 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 | */ |
| 357 | struct 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, |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 392 | struct txdata_entry_desc *desc, |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 405 | void (*fill_rxdone) (struct data_entry *entry, |
| 406 | struct rxdata_entry_desc *desc); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 407 | |
| 408 | /* |
| 409 | * Configuration handlers. |
| 410 | */ |
Ivo van Doorn | 4abee4b | 2007-10-06 14:11:46 +0200 | [diff] [blame^] | 411 | void (*config_mac_addr) (struct rt2x00_dev *rt2x00dev, __le32 *mac); |
| 412 | void (*config_bssid) (struct rt2x00_dev *rt2x00dev, __le32 *bssid); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
| 430 | struct 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 | */ |
| 446 | struct 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; |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 496 | #define DEVICE_PRESENT 1 |
| 497 | #define DEVICE_REGISTERED_HW 2 |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 498 | #define DEVICE_INITIALIZED 3 |
Ivo van Doorn | 066cb63 | 2007-09-25 20:55:39 +0200 | [diff] [blame] | 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 |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | /* |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 592 | * Scheduled work. |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 593 | */ |
| 594 | struct work_struct beacon_work; |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 595 | struct work_struct filter_work; |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 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 | */ |
| 648 | static 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 | |
| 654 | static 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 | */ |
| 664 | static inline void *rt2x00_eeprom_addr(const struct rt2x00_dev *rt2x00dev, |
| 665 | const unsigned int word) |
| 666 | { |
| 667 | return (void *)&rt2x00dev->eeprom[word]; |
| 668 | } |
| 669 | |
| 670 | static 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 | |
| 676 | static 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 | */ |
| 685 | static 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 | |
| 697 | static inline char rt2x00_rt(const struct rt2x00_chip *chipset, const u16 chip) |
| 698 | { |
| 699 | return (chipset->rt == chip); |
| 700 | } |
| 701 | |
| 702 | static inline char rt2x00_rf(const struct rt2x00_chip *chipset, const u16 chip) |
| 703 | { |
| 704 | return (chipset->rf == chip); |
| 705 | } |
| 706 | |
| 707 | static inline u16 rt2x00_get_rev(const struct rt2x00_chip *chipset) |
| 708 | { |
| 709 | return chipset->rev; |
| 710 | } |
| 711 | |
| 712 | static 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 | */ |
| 724 | static inline u16 get_duration(const unsigned int size, const u8 rate) |
| 725 | { |
| 726 | return ((size * 8 * 10) / rate); |
| 727 | } |
| 728 | |
| 729 | static 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 | */ |
| 737 | struct data_ring *rt2x00lib_get_ring(struct rt2x00_dev *rt2x00dev, |
| 738 | const unsigned int queue); |
| 739 | |
| 740 | /* |
| 741 | * Interrupt context handlers. |
| 742 | */ |
| 743 | void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev); |
| 744 | void rt2x00lib_txdone(struct data_entry *entry, |
| 745 | const int status, const int retry); |
| 746 | void rt2x00lib_rxdone(struct data_entry *entry, struct sk_buff *skb, |
Johannes Berg | 4150c57 | 2007-09-17 01:29:23 -0400 | [diff] [blame] | 747 | struct rxdata_entry_desc *desc); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 748 | |
| 749 | /* |
| 750 | * TX descriptor initializer |
| 751 | */ |
| 752 | void 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 | */ |
| 761 | int rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb, |
| 762 | struct ieee80211_tx_control *control); |
| 763 | int rt2x00mac_start(struct ieee80211_hw *hw); |
| 764 | void rt2x00mac_stop(struct ieee80211_hw *hw); |
| 765 | int rt2x00mac_add_interface(struct ieee80211_hw *hw, |
| 766 | struct ieee80211_if_init_conf *conf); |
| 767 | void rt2x00mac_remove_interface(struct ieee80211_hw *hw, |
| 768 | struct ieee80211_if_init_conf *conf); |
| 769 | int rt2x00mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf); |
| 770 | int rt2x00mac_config_interface(struct ieee80211_hw *hw, int if_id, |
| 771 | struct ieee80211_if_conf *conf); |
Ivo van Doorn | 95ea362 | 2007-09-25 17:57:13 -0700 | [diff] [blame] | 772 | int rt2x00mac_get_stats(struct ieee80211_hw *hw, |
| 773 | struct ieee80211_low_level_stats *stats); |
| 774 | int rt2x00mac_get_tx_stats(struct ieee80211_hw *hw, |
| 775 | struct ieee80211_tx_queue_stats *stats); |
| 776 | int rt2x00mac_conf_tx(struct ieee80211_hw *hw, int queue, |
| 777 | const struct ieee80211_tx_queue_params *params); |
| 778 | |
| 779 | /* |
| 780 | * Driver allocation handlers. |
| 781 | */ |
| 782 | int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev); |
| 783 | void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev); |
| 784 | #ifdef CONFIG_PM |
| 785 | int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state); |
| 786 | int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev); |
| 787 | #endif /* CONFIG_PM */ |
| 788 | |
| 789 | #endif /* RT2X00_H */ |