projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
rt2x00: Select CONFIG_NEW_LEDS
[deliverable/linux.git] / drivers / net / wireless / rt2x00 / rt2x00.h
CommitLineData
95ea3627 1/*
811aa9ca 2 Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
95ea3627
ID		 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>
95ea3627
ID		 30#include <linux/skbuff.h>
31#include <linux/workqueue.h>
32#include <linux/firmware.h>
a9450b70 33#include <linux/leds.h>
3d82346c 34#include <linux/mutex.h>
61af43c5 35#include <linux/etherdevice.h>
95ea3627
ID		 36
37#include <net/mac80211.h>
38
39#include "rt2x00debug.h"
a9450b70 40#include "rt2x00leds.h"
95ea3627 41#include "rt2x00reg.h"
181d6902 42#include "rt2x00queue.h"
95ea3627
ID		 43
44/*
45 * Module information.
95ea3627 46 */
b86af631 47#define DRV_VERSION "2.1.0"
95ea3627
ID		 48#define DRV_PROJECT "http://rt2x00.serialmonkey.com"
49
50/*
51 * Debug definitions.
52 * Debug output has to be enabled during compile time.
53 */
54#define DEBUG_PRINTK_MSG(__dev, __kernlvl, __lvl, __msg, __args...) \
55 printk(__kernlvl "%s -> %s: %s - " __msg, \
56 wiphy_name((__dev)->hw->wiphy), __FUNCTION__, __lvl, ##__args)
57
58#define DEBUG_PRINTK_PROBE(__kernlvl, __lvl, __msg, __args...) \
59 printk(__kernlvl "%s -> %s: %s - " __msg, \
2360157c 60 KBUILD_MODNAME, __FUNCTION__, __lvl, ##__args)
95ea3627
ID		 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
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
95ea3627
ID		 94/*
95 * Standard timing and size defines.
96 * These values should follow the ieee80211 specifications.
97 */
98#define ACK_SIZE 14
99#define IEEE80211_HEADER 24
100#define PLCP 48
101#define BEACON 100
102#define PREAMBLE 144
103#define SHORT_PREAMBLE 72
104#define SLOT_TIME 20
105#define SHORT_SLOT_TIME 9
106#define SIFS 10
107#define PIFS ( SIFS + SLOT_TIME )
108#define SHORT_PIFS ( SIFS + SHORT_SLOT_TIME )
109#define DIFS ( PIFS + SLOT_TIME )
110#define SHORT_DIFS ( SHORT_PIFS + SHORT_SLOT_TIME )
111#define EIFS ( SIFS + (8 * (IEEE80211_HEADER + ACK_SIZE)) )
112
113/*
114 * IEEE802.11 header defines
115 */
116static inline int is_rts_frame(u16 fc)
117{
ddc827f9
ID		 118 return (((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL) &&
119 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_RTS));
95ea3627
ID		 120}
121
122static inline int is_cts_frame(u16 fc)
123{
ddc827f9
ID		 124 return (((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL) &&
125 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_CTS));
95ea3627
ID		 126}
127
128static inline int is_probe_resp(u16 fc)
129{
ddc827f9
ID		 130 return (((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) &&
131 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP));
95ea3627
ID		 132}
133
61af43c5
MN		 134static inline int is_beacon(u16 fc)
135{
136 return (((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) &&
137 ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_BEACON));
138}
139
95ea3627
ID		 140/*
141 * Chipset identification
142 * The chipset on the device is composed of a RT and RF chip.
143 * The chipset combination is important for determining device capabilities.
144 */
145struct rt2x00_chip {
146 u16 rt;
147#define RT2460 0x0101
148#define RT2560 0x0201
149#define RT2570 0x1201
12dadb90
ID		 150#define RT2561s 0x0301 /* Turbo */
151#define RT2561 0x0302
95ea3627
ID		 152#define RT2661 0x0401
153#define RT2571 0x1300
154
155 u16 rf;
156 u32 rev;
157};
158
159/*
160 * RF register values that belong to a particular channel.
161 */
162struct rf_channel {
163 int channel;
164 u32 rf1;
165 u32 rf2;
166 u32 rf3;
167 u32 rf4;
168};
169
addc81bd
ID		 170/*
171 * Antenna setup values.
172 */
173struct antenna_setup {
174 enum antenna rx;
175 enum antenna tx;
176};
177
95ea3627 178/*
ebcf26da 179 * Quality statistics about the currently active link.
95ea3627 180 */
ebcf26da 181struct link_qual {
95ea3627
ID		 182 /*
183 * Statistics required for Link tuning.
184 * For the average RSSI value we use the "Walking average" approach.
185 * When adding RSSI to the average value the following calculation
186 * is needed:
187 *
188 * avg_rssi = ((avg_rssi * 7) + rssi) / 8;
189 *
190 * The advantage of this approach is that we only need 1 variable
191 * to store the average in (No need for a count and a total).
192 * But more importantly, normal average values will over time
193 * move less and less towards newly added values this results
194 * that with link tuning, the device can have a very good RSSI
195 * for a few minutes but when the device is moved away from the AP
196 * the average will not decrease fast enough to compensate.
197 * The walking average compensates this and will move towards
198 * the new values correctly allowing a effective link tuning.
199 */
200 int avg_rssi;
95ea3627
ID		 201 int false_cca;
202
203 /*
204 * Statistics required for Signal quality calculation.
205 * For calculating the Signal quality we have to determine
206 * the total number of success and failed RX and TX frames.
207 * After that we also use the average RSSI value to help
208 * determining the signal quality.
209 * For the calculation we will use the following algorithm:
210 *
211 * rssi_percentage = (avg_rssi * 100) / rssi_offset
212 * rx_percentage = (rx_success * 100) / rx_total
213 * tx_percentage = (tx_success * 100) / tx_total
214 * avg_signal = ((WEIGHT_RSSI * avg_rssi) +
215 * (WEIGHT_TX * tx_percentage) +
216 * (WEIGHT_RX * rx_percentage)) / 100
217 *
218 * This value should then be checked to not be greated then 100.
219 */
220 int rx_percentage;
221 int rx_success;
222 int rx_failed;
223 int tx_percentage;
224 int tx_success;
225 int tx_failed;
226#define WEIGHT_RSSI 20
227#define WEIGHT_RX 40
228#define WEIGHT_TX 40
ebcf26da
ID		 229};
230
69f81a2c
ID		 231/*
232 * Antenna settings about the currently active link.
233 */
234struct link_ant {
235 /*
236 * Antenna flags
237 */
238 unsigned int flags;
239#define ANTENNA_RX_DIVERSITY 0x00000001
240#define ANTENNA_TX_DIVERSITY 0x00000002
241#define ANTENNA_MODE_SAMPLE 0x00000004
242
243 /*
244 * Currently active TX/RX antenna setup.
245 * When software diversity is used, this will indicate
246 * which antenna is actually used at this time.
247 */
248 struct antenna_setup active;
249
250 /*
251 * RSSI information for the different antenna's.
252 * These statistics are used to determine when
253 * to switch antenna when using software diversity.
254 *
255 * rssi[0] -> Antenna A RSSI
256 * rssi[1] -> Antenna B RSSI
257 */
258 int rssi_history[2];
259
260 /*
261 * Current RSSI average of the currently active antenna.
262 * Similar to the avg_rssi in the link_qual structure
263 * this value is updated by using the walking average.
264 */
265 int rssi_ant;
266};
267
ebcf26da
ID		 268/*
269 * To optimize the quality of the link we need to store
270 * the quality of received frames and periodically
271 * optimize the link.
272 */
273struct link {
274 /*
275 * Link tuner counter
276 * The number of times the link has been tuned
277 * since the radio has been switched on.
278 */
279 u32 count;
280
281 /*
282 * Quality measurement values.
283 */
284 struct link_qual qual;
285
addc81bd 286 /*
69f81a2c 287 * TX/RX antenna setup.
addc81bd 288 */
69f81a2c 289 struct link_ant ant;
addc81bd 290
ebcf26da
ID		 291 /*
292 * Active VGC level
293 */
294 int vgc_level;
95ea3627
ID		 295
296 /*
297 * Work structure for scheduling periodic link tuning.
298 */
299 struct delayed_work work;
300};
301
95ea3627 302/*
69f81a2c 303 * Small helper macro to work with moving/walking averages.
95ea3627 304 */
69f81a2c
ID		 305#define MOVING_AVERAGE(__avg, __val, __samples) \
306 ( (((__avg) * ((__samples) - 1)) + (__val)) / (__samples) )
307
308/*
309 * When we lack RSSI information return something less then -80 to
310 * tell the driver to tune the device to maximum sensitivity.
311 */
312#define DEFAULT_RSSI ( -128 )
95ea3627
ID		 313
314/*
69f81a2c 315 * Link quality access functions.
95ea3627
ID		 316 */
317static inline int rt2x00_get_link_rssi(struct link *link)
318{
ebcf26da
ID		 319 if (link->qual.avg_rssi && link->qual.rx_success)
320 return link->qual.avg_rssi;
69f81a2c
ID		 321 return DEFAULT_RSSI;
322}
323
324static inline int rt2x00_get_link_ant_rssi(struct link *link)
325{
326 if (link->ant.rssi_ant && link->qual.rx_success)
327 return link->ant.rssi_ant;
328 return DEFAULT_RSSI;
329}
330
331static inline int rt2x00_get_link_ant_rssi_history(struct link *link,
332 enum antenna ant)
333{
334 if (link->ant.rssi_history[ant - ANTENNA_A])
335 return link->ant.rssi_history[ant - ANTENNA_A];
336 return DEFAULT_RSSI;
337}
338
339static inline int rt2x00_update_ant_rssi(struct link *link, int rssi)
340{
341 int old_rssi = link->ant.rssi_history[link->ant.active.rx - ANTENNA_A];
342 link->ant.rssi_history[link->ant.active.rx - ANTENNA_A] = rssi;
343 return old_rssi;
95ea3627
ID		 344}
345
346/*
347 * Interface structure
6bb40dd1
ID		 348 * Per interface configuration details, this structure
349 * is allocated as the private data for ieee80211_vif.
95ea3627 350 */
6bb40dd1 351struct rt2x00_intf {
95ea3627 352 /*
6bb40dd1
ID		 353 * All fields within the rt2x00_intf structure
354 * must be protected with a spinlock.
95ea3627 355 */
6bb40dd1 356 spinlock_t lock;
95ea3627
ID		 357
358 /*
6bb40dd1
ID		 359 * BSS configuration. Copied from the structure
360 * passed to us through the bss_info_changed()
361 * callback funtion.
95ea3627 362 */
6bb40dd1 363 struct ieee80211_bss_conf conf;
95ea3627
ID		 364
365 /*
366 * MAC of the device.
367 */
368 u8 mac[ETH_ALEN];
369
370 /*
371 * BBSID of the AP to associate with.
372 */
373 u8 bssid[ETH_ALEN];
95ea3627 374
6bb40dd1
ID		 375 /*
376 * Entry in the beacon queue which belongs to
377 * this interface. Each interface has its own
378 * dedicated beacon entry.
379 */
380 struct queue_entry *beacon;
95ea3627 381
6bb40dd1
ID		 382 /*
383 * Actions that needed rescheduling.
384 */
385 unsigned int delayed_flags;
386#define DELAYED_UPDATE_BEACON 0x00000001
387#define DELAYED_CONFIG_PREAMBLE 0x00000002
388};
389
390static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif)
95ea3627 391{
6bb40dd1 392 return (struct rt2x00_intf *)vif->drv_priv;
95ea3627
ID		 393}
394
395/*
396 * Details about the supported modes, rates and channels
397 * of a particular chipset. This is used by rt2x00lib
398 * to build the ieee80211_hw_mode array for mac80211.
399 */
400struct hw_mode_spec {
401 /*
402 * Number of modes, rates and channels.
403 */
404 int num_modes;
405 int num_rates;
406 int num_channels;
407
408 /*
409 * txpower values.
410 */
411 const u8 *tx_power_a;
412 const u8 *tx_power_bg;
413 u8 tx_power_default;
414
415 /*
416 * Device/chipset specific value.
417 */
418 const struct rf_channel *channels;
419};
420
5c58ee51
ID		 421/*
422 * Configuration structure wrapper around the
423 * mac80211 configuration structure.
424 * When mac80211 configures the driver, rt2x00lib
425 * can precalculate values which are equal for all
426 * rt2x00 drivers. Those values can be stored in here.
427 */
428struct rt2x00lib_conf {
429 struct ieee80211_conf *conf;
430 struct rf_channel rf;
431
addc81bd
ID		 432 struct antenna_setup ant;
433
f5507ce9 434 enum ieee80211_band band;
5c58ee51
ID		 435
436 int basic_rates;
437 int slot_time;
438
439 short sifs;
440 short pifs;
441 short difs;
442 short eifs;
443};
444
6bb40dd1
ID		 445/*
446 * Configuration structure wrapper around the
447 * rt2x00 interface configuration handler.
448 */
449struct rt2x00intf_conf {
450 /*
451 * Interface type
452 */
453 enum ieee80211_if_types type;
454
455 /*
456 * TSF sync value, this is dependant on the operation type.
457 */
458 enum tsf_sync sync;
459
460 /*
461 * The MAC and BSSID addressess are simple array of bytes,
462 * these arrays are little endian, so when sending the addressess
463 * to the drivers, copy the it into a endian-signed variable.
464 *
465 * Note that all devices (except rt2500usb) have 32 bits
466 * register word sizes. This means that whatever variable we
467 * pass _must_ be a multiple of 32 bits. Otherwise the device
468 * might not accept what we are sending to it.
469 * This will also make it easier for the driver to write
470 * the data to the device.
471 */
472 __le32 mac[2];
473 __le32 bssid[2];
474};
475
95ea3627
ID		 476/*
477 * rt2x00lib callback functions.
478 */
479struct rt2x00lib_ops {
480 /*
481 * Interrupt handlers.
482 */
483 irq_handler_t irq_handler;
484
485 /*
486 * Device init handlers.
487 */
488 int (*probe_hw) (struct rt2x00_dev *rt2x00dev);
489 char *(*get_firmware_name) (struct rt2x00_dev *rt2x00dev);
490 int (*load_firmware) (struct rt2x00_dev *rt2x00dev, void *data,
491 const size_t len);
492
493 /*
494 * Device initialization/deinitialization handlers.
495 */
496 int (*initialize) (struct rt2x00_dev *rt2x00dev);
497 void (*uninitialize) (struct rt2x00_dev *rt2x00dev);
498
837e7f24 499 /*
181d6902 500 * queue initialization handlers
837e7f24
ID		 501 */
502 void (*init_rxentry) (struct rt2x00_dev *rt2x00dev,
181d6902 503 struct queue_entry *entry);
837e7f24 504 void (*init_txentry) (struct rt2x00_dev *rt2x00dev,
181d6902 505 struct queue_entry *entry);
837e7f24 506
95ea3627
ID		 507 /*
508 * Radio control handlers.
509 */
510 int (*set_device_state) (struct rt2x00_dev *rt2x00dev,
511 enum dev_state state);
512 int (*rfkill_poll) (struct rt2x00_dev *rt2x00dev);
ebcf26da
ID		 513 void (*link_stats) (struct rt2x00_dev *rt2x00dev,
514 struct link_qual *qual);
95ea3627
ID		 515 void (*reset_tuner) (struct rt2x00_dev *rt2x00dev);
516 void (*link_tuner) (struct rt2x00_dev *rt2x00dev);
a9450b70
ID		 517 void (*led_brightness) (struct led_classdev *led_cdev,
518 enum led_brightness brightness);
95ea3627
ID		 519
520 /*
521 * TX control handlers
522 */
523 void (*write_tx_desc) (struct rt2x00_dev *rt2x00dev,
dd3193e1 524 struct sk_buff *skb,
181d6902 525 struct txentry_desc *txdesc,
95ea3627
ID		 526 struct ieee80211_tx_control *control);
527 int (*write_tx_data) (struct rt2x00_dev *rt2x00dev,
181d6902 528 struct data_queue *queue, struct sk_buff *skb,
95ea3627 529 struct ieee80211_tx_control *control);
b242e891 530 int (*get_tx_data_len) (struct rt2x00_dev *rt2x00dev,
dd9fa2d2 531 struct sk_buff *skb);
95ea3627 532 void (*kick_tx_queue) (struct rt2x00_dev *rt2x00dev,
5957da4c 533 const unsigned int queue);
95ea3627
ID		 534
535 /*
536 * RX control handlers
537 */
181d6902
ID		 538 void (*fill_rxdone) (struct queue_entry *entry,
539 struct rxdone_entry_desc *rxdesc);
95ea3627
ID		 540
541 /*
542 * Configuration handlers.
543 */
6bb40dd1
ID		 544 void (*config_intf) (struct rt2x00_dev *rt2x00dev,
545 struct rt2x00_intf *intf,
546 struct rt2x00intf_conf *conf,
547 const unsigned int flags);
548#define CONFIG_UPDATE_TYPE ( 1 << 1 )
549#define CONFIG_UPDATE_MAC ( 1 << 2 )
550#define CONFIG_UPDATE_BSSID ( 1 << 3 )
551
552 int (*config_preamble) (struct rt2x00_dev *rt2x00dev,
553 const int short_preamble,
554 const int ack_timeout,
555 const int ack_consume_time);
556 void (*config) (struct rt2x00_dev *rt2x00dev,
557 struct rt2x00lib_conf *libconf,
558 const unsigned int flags);
95ea3627
ID		 559#define CONFIG_UPDATE_PHYMODE ( 1 << 1 )
560#define CONFIG_UPDATE_CHANNEL ( 1 << 2 )
561#define CONFIG_UPDATE_TXPOWER ( 1 << 3 )
562#define CONFIG_UPDATE_ANTENNA ( 1 << 4 )
563#define CONFIG_UPDATE_SLOT_TIME ( 1 << 5 )
564#define CONFIG_UPDATE_BEACON_INT ( 1 << 6 )
565#define CONFIG_UPDATE_ALL 0xffff
566};
567
568/*
569 * rt2x00 driver callback operation structure.
570 */
571struct rt2x00_ops {
572 const char *name;
6bb40dd1
ID		 573 const unsigned int max_sta_intf;
574 const unsigned int max_ap_intf;
95ea3627
ID		 575 const unsigned int eeprom_size;
576 const unsigned int rf_size;
181d6902
ID		 577 const struct data_queue_desc *rx;
578 const struct data_queue_desc *tx;
579 const struct data_queue_desc *bcn;
580 const struct data_queue_desc *atim;
95ea3627
ID		 581 const struct rt2x00lib_ops *lib;
582 const struct ieee80211_ops *hw;
583#ifdef CONFIG_RT2X00_LIB_DEBUGFS
584 const struct rt2x00debug *debugfs;
585#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
586};
587
483272f5
ID		 588/*
589 * rt2x00 device flags
590 */
591enum rt2x00_flags {
592 /*
593 * Device state flags
594 */
595 DEVICE_PRESENT,
596 DEVICE_REGISTERED_HW,
597 DEVICE_INITIALIZED,
598 DEVICE_STARTED,
599 DEVICE_STARTED_SUSPEND,
600 DEVICE_ENABLED_RADIO,
81873e9c 601 DEVICE_DISABLED_RADIO_HW,
483272f5
ID		 602
603 /*
604 * Driver features
605 */
6bb40dd1 606 DRIVER_SUPPORT_MIXED_INTERFACES,
483272f5 607 DRIVER_REQUIRE_FIRMWARE,
9404ef34
ID		 608 DRIVER_REQUIRE_FIRMWARE_CRC_ITU_T,
609 DRIVER_REQUIRE_FIRMWARE_CCITT,
181d6902
ID		 610 DRIVER_REQUIRE_BEACON_GUARD,
611 DRIVER_REQUIRE_ATIM_QUEUE,
483272f5
ID		 612
613 /*
614 * Driver configuration
615 */
616 CONFIG_SUPPORT_HW_BUTTON,
617 CONFIG_FRAME_TYPE,
618 CONFIG_RF_SEQUENCE,
619 CONFIG_EXTERNAL_LNA_A,
620 CONFIG_EXTERNAL_LNA_BG,
621 CONFIG_DOUBLE_ANTENNA,
622 CONFIG_DISABLE_LINK_TUNING,
623};
624
95ea3627
ID		 625/*
626 * rt2x00 device structure.
627 */
628struct rt2x00_dev {
629 /*
630 * Device structure.
631 * The structure stored in here depends on the
632 * system bus (PCI or USB).
633 * When accessing this variable, the rt2x00dev_{pci,usb}
634 * macro's should be used for correct typecasting.
635 */
636 void *dev;
181d6902
ID		 637#define rt2x00dev_pci(__dev) ( (struct pci_dev *)(__dev)->dev )
638#define rt2x00dev_usb(__dev) ( (struct usb_interface *)(__dev)->dev )
639#define rt2x00dev_usb_dev(__dev)\
640 ( (struct usb_device *)interface_to_usbdev(rt2x00dev_usb(__dev)) )
95ea3627
ID		 641
642 /*
643 * Callback functions.
644 */
645 const struct rt2x00_ops *ops;
646
647 /*
648 * IEEE80211 control structure.
649 */
650 struct ieee80211_hw *hw;
8318d78a
JB		 651 struct ieee80211_supported_band bands[IEEE80211_NUM_BANDS];
652 enum ieee80211_band curr_band;
95ea3627
ID		 653
654 /*
655 * rfkill structure for RF state switching support.
656 * This will only be compiled in when required.
657 */
658#ifdef CONFIG_RT2X00_LIB_RFKILL
659 struct rfkill *rfkill;
660 struct input_polled_dev *poll_dev;
661#endif /* CONFIG_RT2X00_LIB_RFKILL */
662
663 /*
664 * If enabled, the debugfs interface structures
665 * required for deregistration of debugfs.
666 */
667#ifdef CONFIG_RT2X00_LIB_DEBUGFS
4d8dd66c 668 struct rt2x00debug_intf *debugfs_intf;
95ea3627
ID		 669#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
670
a9450b70
ID		 671 /*
672 * LED structure for changing the LED status
673 * by mac8011 or the kernel.
674 */
675#ifdef CONFIG_RT2X00_LIB_LEDS
676 unsigned int led_flags;
677 struct rt2x00_trigger trigger_qual;
678 struct rt2x00_led led_radio;
679 struct rt2x00_led led_assoc;
680 struct rt2x00_led led_qual;
681 u16 led_mcu_reg;
682#endif /* CONFIG_RT2X00_LIB_LEDS */
683
95ea3627
ID		 684 /*
685 * Device flags.
686 * In these flags the current status and some
687 * of the device capabilities are stored.
688 */
689 unsigned long flags;
95ea3627
ID		 690
691 /*
692 * Chipset identification.
693 */
694 struct rt2x00_chip chip;
695
696 /*
697 * hw capability specifications.
698 */
699 struct hw_mode_spec spec;
700
addc81bd
ID		 701 /*
702 * This is the default TX/RX antenna setup as indicated
703 * by the device's EEPROM. When mac80211 sets its
704 * antenna value to 0 we should be using these values.
705 */
706 struct antenna_setup default_ant;
707
95ea3627
ID		 708 /*
709 * Register pointers
710 * csr_addr: Base register address. (PCI)
711 * csr_cache: CSR cache for usb_control_msg. (USB)
712 */
713 void __iomem *csr_addr;
714 void *csr_cache;
715
3d82346c
AB		 716 /*
717 * Mutex to protect register accesses on USB devices.
718 * There are 2 reasons this is needed, one is to ensure
719 * use of the csr_cache (for USB devices) by one thread
720 * isn't corrupted by another thread trying to access it.
721 * The other is that access to BBP and RF registers
722 * require multiple BUS transactions and if another thread
723 * attempted to access one of those registers at the same
724 * time one of the writes could silently fail.
725 */
726 struct mutex usb_cache_mutex;
727
3c4f2085
ID		 728 /*
729 * Current packet filter configuration for the device.
730 * This contains all currently active FIF_* flags send
731 * to us by mac80211 during configure_filter().
732 */
733 unsigned int packet_filter;
734
95ea3627 735 /*
6bb40dd1
ID		 736 * Interface details:
737 * - Open ap interface count.
738 * - Open sta interface count.
739 * - Association count.
95ea3627 740 */
6bb40dd1
ID		 741 unsigned int intf_ap_count;
742 unsigned int intf_sta_count;
743 unsigned int intf_associated;
95ea3627
ID		 744
745 /*
746 * Link quality
747 */
748 struct link link;
749
750 /*
751 * EEPROM data.
752 */
753 __le16 *eeprom;
754
755 /*
756 * Active RF register values.
757 * These are stored here so we don't need
758 * to read the rf registers and can directly
759 * use this value instead.
760 * This field should be accessed by using
761 * rt2x00_rf_read() and rt2x00_rf_write().
762 */
763 u32 *rf;
764
b242e891
ID		 765 /*
766 * USB Max frame size (for rt2500usb & rt73usb).
767 */
768 u16 usb_maxpacket;
769
95ea3627
ID		 770 /*
771 * Current TX power value.
772 */
773 u16 tx_power;
774
95ea3627
ID		 775 /*
776 * Rssi <-> Dbm offset
777 */
778 u8 rssi_offset;
779
780 /*
781 * Frequency offset (for rt61pci & rt73usb).
782 */
783 u8 freq_offset;
784
785 /*
786 * Low level statistics which will have
787 * to be kept up to date while device is running.
788 */
789 struct ieee80211_low_level_stats low_level_stats;
790
791 /*
792 * RX configuration information.
793 */
794 struct ieee80211_rx_status rx_status;
795
796 /*
4150c572 797 * Scheduled work.
95ea3627 798 */
6bb40dd1 799 struct work_struct intf_work;
4150c572 800 struct work_struct filter_work;
95ea3627
ID		 801
802 /*
181d6902
ID		 803 * Data queue arrays for RX, TX and Beacon.
804 * The Beacon array also contains the Atim queue
95ea3627
ID		 805 * if that is supported by the device.
806 */
181d6902
ID		 807 int data_queues;
808 struct data_queue *rx;
809 struct data_queue *tx;
810 struct data_queue *bcn;
95ea3627
ID		 811
812 /*
813 * Firmware image.
814 */
815 const struct firmware *fw;
816};
817
95ea3627
ID		 818/*
819 * Generic RF access.
820 * The RF is being accessed by word index.
821 */
0e14f6d3 822static inline void rt2x00_rf_read(struct rt2x00_dev *rt2x00dev,
95ea3627
ID		 823 const unsigned int word, u32 *data)
824{
825 *data = rt2x00dev->rf[word];
826}
827
0e14f6d3 828static inline void rt2x00_rf_write(struct rt2x00_dev *rt2x00dev,
95ea3627
ID		 829 const unsigned int word, u32 data)
830{
831 rt2x00dev->rf[word] = data;
832}
833
834/*
835 * Generic EEPROM access.
836 * The EEPROM is being accessed by word index.
837 */
0e14f6d3 838static inline void *rt2x00_eeprom_addr(struct rt2x00_dev *rt2x00dev,
95ea3627
ID		 839 const unsigned int word)
840{
841 return (void *)&rt2x00dev->eeprom[word];
842}
843
0e14f6d3 844static inline void rt2x00_eeprom_read(struct rt2x00_dev *rt2x00dev,
95ea3627
ID		 845 const unsigned int word, u16 *data)
846{
847 *data = le16_to_cpu(rt2x00dev->eeprom[word]);
848}
849
0e14f6d3 850static inline void rt2x00_eeprom_write(struct rt2x00_dev *rt2x00dev,
95ea3627
ID		 851 const unsigned int word, u16 data)
852{
853 rt2x00dev->eeprom[word] = cpu_to_le16(data);
854}
855
856/*
857 * Chipset handlers
858 */
859static inline void rt2x00_set_chip(struct rt2x00_dev *rt2x00dev,
860 const u16 rt, const u16 rf, const u32 rev)
861{
862 INFO(rt2x00dev,
863 "Chipset detected - rt: %04x, rf: %04x, rev: %08x.\n",
864 rt, rf, rev);
865
866 rt2x00dev->chip.rt = rt;
867 rt2x00dev->chip.rf = rf;
868 rt2x00dev->chip.rev = rev;
869}
870
871static inline char rt2x00_rt(const struct rt2x00_chip *chipset, const u16 chip)
872{
873 return (chipset->rt == chip);
874}
875
876static inline char rt2x00_rf(const struct rt2x00_chip *chipset, const u16 chip)
877{
878 return (chipset->rf == chip);
879}
880
755a957d 881static inline u16 rt2x00_rev(const struct rt2x00_chip *chipset)
95ea3627
ID		 882{
883 return chipset->rev;
884}
885
755a957d
ID		 886static inline u16 rt2x00_check_rev(const struct rt2x00_chip *chipset,
887 const u32 rev)
95ea3627 888{
755a957d
ID		 889 return (((chipset->rev & 0xffff0) == rev) &&
890 !!(chipset->rev & 0x0000f));
95ea3627
ID		 891}
892
893/*
894 * Duration calculations
895 * The rate variable passed is: 100kbs.
896 * To convert from bytes to bits we multiply size with 8,
897 * then the size is multiplied with 10 to make the
898 * real rate -> rate argument correction.
899 */
900static inline u16 get_duration(const unsigned int size, const u8 rate)
901{
902 return ((size * 8 * 10) / rate);
903}
904
905static inline u16 get_duration_res(const unsigned int size, const u8 rate)
906{
907 return ((size * 8 * 10) % rate);
908}
909
181d6902
ID		 910/**
911 * rt2x00queue_get_queue - Convert mac80211 queue index to rt2x00 queue
912 * @rt2x00dev: Pointer to &struct rt2x00_dev.
5957da4c
ID		 913 * @queue: mac80211/rt2x00 queue index
914 * (see &enum ieee80211_tx_queue and &enum rt2x00_bcn_queue).
95ea3627 915 */
181d6902 916struct data_queue *rt2x00queue_get_queue(struct rt2x00_dev *rt2x00dev,
5957da4c 917 const unsigned int queue);
181d6902
ID		 918
919/**
920 * rt2x00queue_get_entry - Get queue entry where the given index points to.
921 * @rt2x00dev: Pointer to &struct rt2x00_dev.
922 * @index: Index identifier for obtaining the correct index.
923 */
924struct queue_entry *rt2x00queue_get_entry(struct data_queue *queue,
925 enum queue_index index);
926
927/**
928 * rt2x00queue_index_inc - Index incrementation function
929 * @queue: Queue (&struct data_queue) to perform the action on.
930 * @action: Index type (&enum queue_index) to perform the action on.
931 *
932 * This function will increase the requested index on the queue,
933 * it will grab the appropriate locks and handle queue overflow events by
934 * resetting the index to the start of the queue.
935 */
936void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index);
937
95ea3627
ID		 938
939/*
940 * Interrupt context handlers.
941 */
942void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev);
181d6902
ID		 943void rt2x00lib_txdone(struct queue_entry *entry,
944 struct txdone_entry_desc *txdesc);
945void rt2x00lib_rxdone(struct queue_entry *entry,
946 struct rxdone_entry_desc *rxdesc);
95ea3627
ID		 947
948/*
949 * TX descriptor initializer
950 */
951void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
08992f7f 952 struct sk_buff *skb,
95ea3627
ID		 953 struct ieee80211_tx_control *control);
954
955/*
956 * mac80211 handlers.
957 */
958int rt2x00mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb,
959 struct ieee80211_tx_control *control);
960int rt2x00mac_start(struct ieee80211_hw *hw);
961void rt2x00mac_stop(struct ieee80211_hw *hw);
962int rt2x00mac_add_interface(struct ieee80211_hw *hw,
963 struct ieee80211_if_init_conf *conf);
964void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
965 struct ieee80211_if_init_conf *conf);
966int rt2x00mac_config(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
32bfd35d
JB		 967int rt2x00mac_config_interface(struct ieee80211_hw *hw,
968 struct ieee80211_vif *vif,
95ea3627 969 struct ieee80211_if_conf *conf);
95ea3627
ID		 970int rt2x00mac_get_stats(struct ieee80211_hw *hw,
971 struct ieee80211_low_level_stats *stats);
972int rt2x00mac_get_tx_stats(struct ieee80211_hw *hw,
973 struct ieee80211_tx_queue_stats *stats);
471b3efd
JB		 974void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
975 struct ieee80211_vif *vif,
976 struct ieee80211_bss_conf *bss_conf,
977 u32 changes);
95ea3627
ID		 978int rt2x00mac_conf_tx(struct ieee80211_hw *hw, int queue,
979 const struct ieee80211_tx_queue_params *params);
980
981/*
982 * Driver allocation handlers.
983 */
984int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev);
985void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev);
986#ifdef CONFIG_PM
987int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state);
988int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev);
989#endif /* CONFIG_PM */
990
991#endif /* RT2X00_H */
Linux kernel - Deliverables
This page took 0.16549 seconds and 5 git commands to generate.