2 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
3 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
4 Copyright (C) 2004 - 2009 Gertjan van Wingerde <gwingerde@gmail.com>
5 <http://rt2x00.serialmonkey.com>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, see <http://www.gnu.org/licenses/>.
23 Abstract: rt2x00 global information.
29 #include <linux/bitops.h>
30 #include <linux/interrupt.h>
31 #include <linux/skbuff.h>
32 #include <linux/workqueue.h>
33 #include <linux/firmware.h>
34 #include <linux/leds.h>
35 #include <linux/mutex.h>
36 #include <linux/etherdevice.h>
37 #include <linux/input-polldev.h>
38 #include <linux/kfifo.h>
39 #include <linux/hrtimer.h>
40 #include <linux/average.h>
41 #include <linux/usb.h>
42 #include <linux/clk.h>
44 #include <net/mac80211.h>
46 #include "rt2x00debug.h"
47 #include "rt2x00dump.h"
48 #include "rt2x00leds.h"
49 #include "rt2x00reg.h"
50 #include "rt2x00queue.h"
55 #define DRV_VERSION "2.3.0"
56 #define DRV_PROJECT "http://rt2x00.serialmonkey.com"
59 * Debug output has to be enabled during compile time.
61 #ifdef CONFIG_RT2X00_DEBUG
63 #endif /* CONFIG_RT2X00_DEBUG */
65 /* Utility printing macros
66 * rt2x00_probe_err is for messages when rt2x00_dev is uninitialized
68 #define rt2x00_probe_err(fmt, ...) \
69 printk(KERN_ERR KBUILD_MODNAME ": %s: Error - " fmt, \
70 __func__, ##__VA_ARGS__)
71 #define rt2x00_err(dev, fmt, ...) \
72 wiphy_err((dev)->hw->wiphy, "%s: Error - " fmt, \
73 __func__, ##__VA_ARGS__)
74 #define rt2x00_warn(dev, fmt, ...) \
75 wiphy_warn((dev)->hw->wiphy, "%s: Warning - " fmt, \
76 __func__, ##__VA_ARGS__)
77 #define rt2x00_info(dev, fmt, ...) \
78 wiphy_info((dev)->hw->wiphy, "%s: Info - " fmt, \
79 __func__, ##__VA_ARGS__)
81 /* Various debug levels */
82 #define rt2x00_dbg(dev, fmt, ...) \
83 wiphy_dbg((dev)->hw->wiphy, "%s: Debug - " fmt, \
84 __func__, ##__VA_ARGS__)
85 #define rt2x00_eeprom_dbg(dev, fmt, ...) \
86 wiphy_dbg((dev)->hw->wiphy, "%s: EEPROM recovery - " fmt, \
87 __func__, ##__VA_ARGS__)
90 * Duration calculations
91 * The rate variable passed is: 100kbs.
92 * To convert from bytes to bits we multiply size with 8,
93 * then the size is multiplied with 10 to make the
94 * real rate -> rate argument correction.
96 #define GET_DURATION(__size, __rate) (((__size) * 8 * 10) / (__rate))
97 #define GET_DURATION_RES(__size, __rate)(((__size) * 8 * 10) % (__rate))
100 * Determine the number of L2 padding bytes required between the header and
103 #define L2PAD_SIZE(__hdrlen) (-(__hdrlen) & 3)
106 * Determine the alignment requirement,
107 * to make sure the 802.11 payload is padded to a 4-byte boundrary
108 * we must determine the address of the payload and calculate the
109 * amount of bytes needed to move the data.
111 #define ALIGN_SIZE(__skb, __header) \
112 (((unsigned long)((__skb)->data + (__header))) & 3)
115 * Constants for extra TX headroom for alignment purposes.
117 #define RT2X00_ALIGN_SIZE 4 /* Only whole frame needs alignment */
118 #define RT2X00_L2PAD_SIZE 8 /* Both header & payload need alignment */
121 * Standard timing and size defines.
122 * These values should follow the ieee80211 specifications.
125 #define IEEE80211_HEADER 24
129 #define SHORT_PREAMBLE 72
131 #define SHORT_SLOT_TIME 9
133 #define PIFS (SIFS + SLOT_TIME)
134 #define SHORT_PIFS (SIFS + SHORT_SLOT_TIME)
135 #define DIFS (PIFS + SLOT_TIME)
136 #define SHORT_DIFS (SHORT_PIFS + SHORT_SLOT_TIME)
137 #define EIFS (SIFS + DIFS + \
138 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10))
139 #define SHORT_EIFS (SIFS + SHORT_DIFS + \
140 GET_DURATION(IEEE80211_HEADER + ACK_SIZE, 10))
142 enum rt2x00_chip_intf
{
143 RT2X00_CHIP_INTF_PCI
,
144 RT2X00_CHIP_INTF_PCIE
,
145 RT2X00_CHIP_INTF_USB
,
146 RT2X00_CHIP_INTF_SOC
,
150 * Chipset identification
151 * The chipset on the device is composed of a RT and RF chip.
152 * The chipset combination is important for determining device capabilities.
156 #define RT2460 0x2460
157 #define RT2560 0x2560
158 #define RT2570 0x2570
159 #define RT2661 0x2661
160 #define RT2573 0x2573
161 #define RT2860 0x2860 /* 2.4GHz */
162 #define RT2872 0x2872 /* WSOC */
163 #define RT2883 0x2883 /* WSOC */
164 #define RT3070 0x3070
165 #define RT3071 0x3071
166 #define RT3090 0x3090 /* 2.4GHz PCIe */
167 #define RT3290 0x3290
168 #define RT3352 0x3352 /* WSOC */
169 #define RT3390 0x3390
170 #define RT3572 0x3572
171 #define RT3593 0x3593
172 #define RT3883 0x3883 /* WSOC */
173 #define RT5350 0x5350 /* WSOC 2.4GHz */
174 #define RT5390 0x5390 /* 2.4GHz */
175 #define RT5392 0x5392 /* 2.4GHz */
176 #define RT5592 0x5592
181 enum rt2x00_chip_intf intf
;
185 * RF register values that belong to a particular channel.
196 * Channel information structure
198 struct channel_info
{
200 #define GEOGRAPHY_ALLOWED 0x00000001
203 short default_power1
;
204 short default_power2
;
205 short default_power3
;
209 * Antenna setup values.
211 struct antenna_setup
{
219 * Quality statistics about the currently active link.
223 * Statistics required for Link tuning by driver
224 * The rssi value is provided by rt2x00lib during the
225 * link_tuner() callback function.
226 * The false_cca field is filled during the link_stats()
227 * callback function and could be used during the
228 * link_tuner() callback function.
235 * Hardware driver will tune the VGC level during each call
236 * to the link_tuner() callback function. This vgc_level is
237 * is determined based on the link quality statistics like
238 * average RSSI and the false CCA count.
240 * In some cases the drivers need to differentiate between
241 * the currently "desired" VGC level and the level configured
242 * in the hardware. The latter is important to reduce the
243 * number of BBP register reads to reduce register access
244 * overhead. For this reason we store both values here.
250 * Statistics required for Signal quality calculation.
251 * These fields might be changed during the link_stats()
260 DECLARE_EWMA(rssi
, 1024, 8)
263 * Antenna settings about the currently active link.
270 #define ANTENNA_RX_DIVERSITY 0x00000001
271 #define ANTENNA_TX_DIVERSITY 0x00000002
272 #define ANTENNA_MODE_SAMPLE 0x00000004
275 * Currently active TX/RX antenna setup.
276 * When software diversity is used, this will indicate
277 * which antenna is actually used at this time.
279 struct antenna_setup active
;
282 * RSSI history information for the antenna.
283 * Used to determine when to switch antenna
284 * when using software diversity.
289 * Current RSSI average of the currently active antenna.
290 * Similar to the avg_rssi in the link_qual structure
291 * this value is updated by using the walking average.
293 struct ewma_rssi rssi_ant
;
297 * To optimize the quality of the link we need to store
298 * the quality of received frames and periodically
304 * The number of times the link has been tuned
305 * since the radio has been switched on.
310 * Quality measurement values.
312 struct link_qual qual
;
315 * TX/RX antenna setup.
320 * Currently active average RSSI value
322 struct ewma_rssi avg_rssi
;
325 * Work structure for scheduling periodic link tuning.
327 struct delayed_work work
;
330 * Work structure for scheduling periodic watchdog monitoring.
331 * This work must be scheduled on the kernel workqueue, while
332 * all other work structures must be queued on the mac80211
333 * workqueue. This guarantees that the watchdog can schedule
334 * other work structures and wait for their completion in order
335 * to bring the device/driver back into the desired state.
337 struct delayed_work watchdog_work
;
340 * Work structure for scheduling periodic AGC adjustments.
342 struct delayed_work agc_work
;
345 * Work structure for scheduling periodic VCO calibration.
347 struct delayed_work vco_work
;
350 enum rt2x00_delayed_flags
{
351 DELAYED_UPDATE_BEACON
,
355 * Interface structure
356 * Per interface configuration details, this structure
357 * is allocated as the private data for ieee80211_vif.
361 * beacon->skb must be protected with the mutex.
363 struct mutex beacon_skb_mutex
;
366 * Entry in the beacon queue which belongs to
367 * this interface. Each interface has its own
368 * dedicated beacon entry.
370 struct queue_entry
*beacon
;
374 * Actions that needed rescheduling.
376 unsigned long delayed_flags
;
379 * Software sequence counter, this is only required
380 * for hardware which doesn't support hardware
386 static inline struct rt2x00_intf
* vif_to_intf(struct ieee80211_vif
*vif
)
388 return (struct rt2x00_intf
*)vif
->drv_priv
;
392 * struct hw_mode_spec: Hardware specifications structure
394 * Details about the supported modes, rates and channels
395 * of a particular chipset. This is used by rt2x00lib
396 * to build the ieee80211_hw_mode array for mac80211.
398 * @supported_bands: Bitmask contained the supported bands (2.4GHz, 5.2GHz).
399 * @supported_rates: Rate types which are supported (CCK, OFDM).
400 * @num_channels: Number of supported channels. This is used as array size
401 * for @tx_power_a, @tx_power_bg and @channels.
402 * @channels: Device/chipset specific channel values (See &struct rf_channel).
403 * @channels_info: Additional information for channels (See &struct channel_info).
404 * @ht: Driver HT Capabilities (See &ieee80211_sta_ht_cap).
406 struct hw_mode_spec
{
407 unsigned int supported_bands
;
408 #define SUPPORT_BAND_2GHZ 0x00000001
409 #define SUPPORT_BAND_5GHZ 0x00000002
411 unsigned int supported_rates
;
412 #define SUPPORT_RATE_CCK 0x00000001
413 #define SUPPORT_RATE_OFDM 0x00000002
415 unsigned int num_channels
;
416 const struct rf_channel
*channels
;
417 const struct channel_info
*channels_info
;
419 struct ieee80211_sta_ht_cap ht
;
423 * Configuration structure wrapper around the
424 * mac80211 configuration structure.
425 * When mac80211 configures the driver, rt2x00lib
426 * can precalculate values which are equal for all
427 * rt2x00 drivers. Those values can be stored in here.
429 struct rt2x00lib_conf
{
430 struct ieee80211_conf
*conf
;
432 struct rf_channel rf
;
433 struct channel_info channel
;
437 * Configuration structure for erp settings.
439 struct rt2x00lib_erp
{
457 * Configuration structure for hardware encryption.
459 struct rt2x00lib_crypto
{
462 enum set_key_cmd cmd
;
475 * Configuration structure wrapper around the
476 * rt2x00 interface configuration handler.
478 struct rt2x00intf_conf
{
482 enum nl80211_iftype type
;
485 * TSF sync value, this is dependent on the operation type.
490 * The MAC and BSSID addresses are simple array of bytes,
491 * these arrays are little endian, so when sending the addresses
492 * to the drivers, copy the it into a endian-signed variable.
494 * Note that all devices (except rt2500usb) have 32 bits
495 * register word sizes. This means that whatever variable we
496 * pass _must_ be a multiple of 32 bits. Otherwise the device
497 * might not accept what we are sending to it.
498 * This will also make it easier for the driver to write
499 * the data to the device.
506 * Private structure for storing STA details
507 * wcid: Wireless Client ID
513 static inline struct rt2x00_sta
* sta_to_rt2x00_sta(struct ieee80211_sta
*sta
)
515 return (struct rt2x00_sta
*)sta
->drv_priv
;
519 * rt2x00lib callback functions.
521 struct rt2x00lib_ops
{
523 * Interrupt handlers.
525 irq_handler_t irq_handler
;
528 * TX status tasklet handler.
530 void (*txstatus_tasklet
) (unsigned long data
);
531 void (*pretbtt_tasklet
) (unsigned long data
);
532 void (*tbtt_tasklet
) (unsigned long data
);
533 void (*rxdone_tasklet
) (unsigned long data
);
534 void (*autowake_tasklet
) (unsigned long data
);
537 * Device init handlers.
539 int (*probe_hw
) (struct rt2x00_dev
*rt2x00dev
);
540 char *(*get_firmware_name
) (struct rt2x00_dev
*rt2x00dev
);
541 int (*check_firmware
) (struct rt2x00_dev
*rt2x00dev
,
542 const u8
*data
, const size_t len
);
543 int (*load_firmware
) (struct rt2x00_dev
*rt2x00dev
,
544 const u8
*data
, const size_t len
);
547 * Device initialization/deinitialization handlers.
549 int (*initialize
) (struct rt2x00_dev
*rt2x00dev
);
550 void (*uninitialize
) (struct rt2x00_dev
*rt2x00dev
);
553 * queue initialization handlers
555 bool (*get_entry_state
) (struct queue_entry
*entry
);
556 void (*clear_entry
) (struct queue_entry
*entry
);
559 * Radio control handlers.
561 int (*set_device_state
) (struct rt2x00_dev
*rt2x00dev
,
562 enum dev_state state
);
563 int (*rfkill_poll
) (struct rt2x00_dev
*rt2x00dev
);
564 void (*link_stats
) (struct rt2x00_dev
*rt2x00dev
,
565 struct link_qual
*qual
);
566 void (*reset_tuner
) (struct rt2x00_dev
*rt2x00dev
,
567 struct link_qual
*qual
);
568 void (*link_tuner
) (struct rt2x00_dev
*rt2x00dev
,
569 struct link_qual
*qual
, const u32 count
);
570 void (*gain_calibration
) (struct rt2x00_dev
*rt2x00dev
);
571 void (*vco_calibration
) (struct rt2x00_dev
*rt2x00dev
);
574 * Data queue handlers.
576 void (*watchdog
) (struct rt2x00_dev
*rt2x00dev
);
577 void (*start_queue
) (struct data_queue
*queue
);
578 void (*kick_queue
) (struct data_queue
*queue
);
579 void (*stop_queue
) (struct data_queue
*queue
);
580 void (*flush_queue
) (struct data_queue
*queue
, bool drop
);
581 void (*tx_dma_done
) (struct queue_entry
*entry
);
584 * TX control handlers
586 void (*write_tx_desc
) (struct queue_entry
*entry
,
587 struct txentry_desc
*txdesc
);
588 void (*write_tx_data
) (struct queue_entry
*entry
,
589 struct txentry_desc
*txdesc
);
590 void (*write_beacon
) (struct queue_entry
*entry
,
591 struct txentry_desc
*txdesc
);
592 void (*clear_beacon
) (struct queue_entry
*entry
);
593 int (*get_tx_data_len
) (struct queue_entry
*entry
);
596 * RX control handlers
598 void (*fill_rxdone
) (struct queue_entry
*entry
,
599 struct rxdone_entry_desc
*rxdesc
);
602 * Configuration handlers.
604 int (*config_shared_key
) (struct rt2x00_dev
*rt2x00dev
,
605 struct rt2x00lib_crypto
*crypto
,
606 struct ieee80211_key_conf
*key
);
607 int (*config_pairwise_key
) (struct rt2x00_dev
*rt2x00dev
,
608 struct rt2x00lib_crypto
*crypto
,
609 struct ieee80211_key_conf
*key
);
610 void (*config_filter
) (struct rt2x00_dev
*rt2x00dev
,
611 const unsigned int filter_flags
);
612 void (*config_intf
) (struct rt2x00_dev
*rt2x00dev
,
613 struct rt2x00_intf
*intf
,
614 struct rt2x00intf_conf
*conf
,
615 const unsigned int flags
);
616 #define CONFIG_UPDATE_TYPE ( 1 << 1 )
617 #define CONFIG_UPDATE_MAC ( 1 << 2 )
618 #define CONFIG_UPDATE_BSSID ( 1 << 3 )
620 void (*config_erp
) (struct rt2x00_dev
*rt2x00dev
,
621 struct rt2x00lib_erp
*erp
,
623 void (*config_ant
) (struct rt2x00_dev
*rt2x00dev
,
624 struct antenna_setup
*ant
);
625 void (*config
) (struct rt2x00_dev
*rt2x00dev
,
626 struct rt2x00lib_conf
*libconf
,
627 const unsigned int changed_flags
);
628 int (*sta_add
) (struct rt2x00_dev
*rt2x00dev
,
629 struct ieee80211_vif
*vif
,
630 struct ieee80211_sta
*sta
);
631 int (*sta_remove
) (struct rt2x00_dev
*rt2x00dev
,
632 struct ieee80211_sta
*sta
);
636 * rt2x00 driver callback operation structure.
640 const unsigned int drv_data_size
;
641 const unsigned int max_ap_intf
;
642 const unsigned int eeprom_size
;
643 const unsigned int rf_size
;
644 const unsigned int tx_queues
;
645 void (*queue_init
)(struct data_queue
*queue
);
646 const struct rt2x00lib_ops
*lib
;
648 const struct ieee80211_ops
*hw
;
649 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
650 const struct rt2x00debug
*debugfs
;
651 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
657 enum rt2x00_state_flags
{
661 DEVICE_STATE_PRESENT
,
662 DEVICE_STATE_REGISTERED_HW
,
663 DEVICE_STATE_INITIALIZED
,
664 DEVICE_STATE_STARTED
,
665 DEVICE_STATE_ENABLED_RADIO
,
666 DEVICE_STATE_SCANNING
,
669 * Driver configuration
678 * Mark we currently are sequentially reading TX_STA_FIFO register
679 * FIXME: this is for only rt2800usb, should go to private data
685 * rt2x00 capability flags
687 enum rt2x00_capability_flags
{
692 REQUIRE_BEACON_GUARD
,
697 REQUIRE_TXSTATUS_FIFO
,
698 REQUIRE_TASKLET_CONTEXT
,
702 REQUIRE_DELAYED_RFKILL
,
707 CAPABILITY_HW_BUTTON
,
708 CAPABILITY_HW_CRYPTO
,
709 CAPABILITY_POWER_LIMIT
,
710 CAPABILITY_CONTROL_FILTERS
,
711 CAPABILITY_CONTROL_FILTER_PSPOLL
,
712 CAPABILITY_PRE_TBTT_INTERRUPT
,
713 CAPABILITY_LINK_TUNING
,
714 CAPABILITY_FRAME_TYPE
,
715 CAPABILITY_RF_SEQUENCE
,
716 CAPABILITY_EXTERNAL_LNA_A
,
717 CAPABILITY_EXTERNAL_LNA_BG
,
718 CAPABILITY_DOUBLE_ANTENNA
,
719 CAPABILITY_BT_COEXIST
,
720 CAPABILITY_VCO_RECALIBRATION
,
721 CAPABILITY_INTERNAL_PA_TX0
,
722 CAPABILITY_INTERNAL_PA_TX1
,
726 * Interface combinations
734 * rt2x00 device structure.
739 * The structure stored in here depends on the
740 * system bus (PCI or USB).
741 * When accessing this variable, the rt2x00dev_{pci,usb}
742 * macros should be used for correct typecasting.
747 * Callback functions.
749 const struct rt2x00_ops
*ops
;
757 * IEEE80211 control structure.
759 struct ieee80211_hw
*hw
;
760 struct ieee80211_supported_band bands
[NUM_NL80211_BANDS
];
761 enum nl80211_band curr_band
;
765 * If enabled, the debugfs interface structures
766 * required for deregistration of debugfs.
768 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
769 struct rt2x00debug_intf
*debugfs_intf
;
770 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
773 * LED structure for changing the LED status
774 * by mac8011 or the kernel.
776 #ifdef CONFIG_RT2X00_LIB_LEDS
777 struct rt2x00_led led_radio
;
778 struct rt2x00_led led_assoc
;
779 struct rt2x00_led led_qual
;
781 #endif /* CONFIG_RT2X00_LIB_LEDS */
784 * Device state flags.
785 * In these flags the current status is stored.
786 * Access to these flags should occur atomically.
791 * Device capabiltiy flags.
792 * In these flags the device/driver capabilities are stored.
793 * Access to these flags should occur non-atomically.
795 unsigned long cap_flags
;
798 * Device information, Bus IRQ and name (PCI, SoC)
804 * Chipset identification.
806 struct rt2x00_chip chip
;
809 * hw capability specifications.
811 struct hw_mode_spec spec
;
814 * This is the default TX/RX antenna setup as indicated
815 * by the device's EEPROM.
817 struct antenna_setup default_ant
;
821 * csr.base: CSR base register address. (PCI)
822 * csr.cache: CSR cache for usb_control_msg. (USB)
830 * Mutex to protect register accesses.
831 * For PCI and USB devices it protects against concurrent indirect
832 * register access (BBP, RF, MCU) since accessing those
833 * registers require multiple calls to the CSR registers.
834 * For USB devices it also protects the csr_cache since that
835 * field is used for normal CSR access and it cannot support
836 * multiple callers simultaneously.
838 struct mutex csr_mutex
;
841 * Mutex to synchronize config and link tuner.
843 struct mutex conf_mutex
;
845 * Current packet filter configuration for the device.
846 * This contains all currently active FIF_* flags send
847 * to us by mac80211 during configure_filter().
849 unsigned int packet_filter
;
853 * - Open ap interface count.
854 * - Open sta interface count.
855 * - Association count.
856 * - Beaconing enabled count.
858 unsigned int intf_ap_count
;
859 unsigned int intf_sta_count
;
860 unsigned int intf_associated
;
861 unsigned int intf_beaconing
;
864 * Interface combinations
866 struct ieee80211_iface_limit if_limits_ap
;
867 struct ieee80211_iface_combination if_combinations
[NUM_IF_COMB
];
880 * Active RF register values.
881 * These are stored here so we don't need
882 * to read the rf registers and can directly
883 * use this value instead.
884 * This field should be accessed by using
885 * rt2x00_rf_read() and rt2x00_rf_write().
895 * Current TX power value.
900 * Current retry values.
906 * Rssi <-> Dbm offset
926 * Timestamp of last received beacon
928 unsigned long last_beacon
;
931 * Low level statistics which will have
932 * to be kept up to date while device is running.
934 struct ieee80211_low_level_stats low_level_stats
;
937 * Work queue for all work which should not be placed
938 * on the mac80211 workqueue (because of dependencies
939 * between various work structures).
941 struct workqueue_struct
*workqueue
;
945 * NOTE: intf_work will use ieee80211_iterate_active_interfaces()
946 * which means it cannot be placed on the hw->workqueue
947 * due to RTNL locking requirements.
949 struct work_struct intf_work
;
952 * Scheduled work for TX/RX done handling (USB devices)
954 struct work_struct rxdone_work
;
955 struct work_struct txdone_work
;
960 struct delayed_work autowakeup_work
;
961 struct work_struct sleep_work
;
964 * Data queue arrays for RX, TX, Beacon and ATIM.
966 unsigned int data_queues
;
967 struct data_queue
*rx
;
968 struct data_queue
*tx
;
969 struct data_queue
*bcn
;
970 struct data_queue
*atim
;
975 const struct firmware
*fw
;
978 * FIFO for storing tx status reports between isr and tasklet.
980 DECLARE_KFIFO_PTR(txstatus_fifo
, u32
);
983 * Timer to ensure tx status reports are read (rt2800usb).
985 struct hrtimer txstatus_timer
;
988 * Tasklet for processing tx status reports (rt2800pci).
990 struct tasklet_struct txstatus_tasklet
;
991 struct tasklet_struct pretbtt_tasklet
;
992 struct tasklet_struct tbtt_tasklet
;
993 struct tasklet_struct rxdone_tasklet
;
994 struct tasklet_struct autowake_tasklet
;
997 * Used for VCO periodic calibration.
1002 * Protect the interrupt mask register.
1004 spinlock_t irqmask_lock
;
1007 * List of BlockAckReq TX entries that need driver BlockAck processing.
1009 struct list_head bar_list
;
1010 spinlock_t bar_list_lock
;
1012 /* Extra TX headroom required for alignment purposes. */
1013 unsigned int extra_tx_headroom
;
1015 struct usb_anchor
*anchor
;
1017 /* Clock for System On Chip devices. */
1021 struct rt2x00_bar_list_entry
{
1022 struct list_head list
;
1023 struct rcu_head head
;
1025 struct queue_entry
*entry
;
1028 /* Relevant parts of the IEEE80211 BAR header */
1032 __le16 start_seq_num
;
1037 * Some registers require multiple attempts before success,
1038 * in those cases REGISTER_BUSY_COUNT attempts should be
1039 * taken with a REGISTER_BUSY_DELAY interval. Due to USB
1040 * bus delays, we do not have to loop so many times to wait
1041 * for valid register value on that bus.
1043 #define REGISTER_BUSY_COUNT 100
1044 #define REGISTER_USB_BUSY_COUNT 20
1045 #define REGISTER_BUSY_DELAY 100
1048 * Generic RF access.
1049 * The RF is being accessed by word index.
1051 static inline void rt2x00_rf_read(struct rt2x00_dev
*rt2x00dev
,
1052 const unsigned int word
, u32
*data
)
1054 BUG_ON(word
< 1 || word
> rt2x00dev
->ops
->rf_size
/ sizeof(u32
));
1055 *data
= rt2x00dev
->rf
[word
- 1];
1058 static inline void rt2x00_rf_write(struct rt2x00_dev
*rt2x00dev
,
1059 const unsigned int word
, u32 data
)
1061 BUG_ON(word
< 1 || word
> rt2x00dev
->ops
->rf_size
/ sizeof(u32
));
1062 rt2x00dev
->rf
[word
- 1] = data
;
1066 * Generic EEPROM access. The EEPROM is being accessed by word or byte index.
1068 static inline void *rt2x00_eeprom_addr(struct rt2x00_dev
*rt2x00dev
,
1069 const unsigned int word
)
1071 return (void *)&rt2x00dev
->eeprom
[word
];
1074 static inline void rt2x00_eeprom_read(struct rt2x00_dev
*rt2x00dev
,
1075 const unsigned int word
, u16
*data
)
1077 *data
= le16_to_cpu(rt2x00dev
->eeprom
[word
]);
1080 static inline void rt2x00_eeprom_write(struct rt2x00_dev
*rt2x00dev
,
1081 const unsigned int word
, u16 data
)
1083 rt2x00dev
->eeprom
[word
] = cpu_to_le16(data
);
1086 static inline u8
rt2x00_eeprom_byte(struct rt2x00_dev
*rt2x00dev
,
1087 const unsigned int byte
)
1089 return *(((u8
*)rt2x00dev
->eeprom
) + byte
);
1095 static inline void rt2x00_set_chip(struct rt2x00_dev
*rt2x00dev
,
1096 const u16 rt
, const u16 rf
, const u16 rev
)
1098 rt2x00dev
->chip
.rt
= rt
;
1099 rt2x00dev
->chip
.rf
= rf
;
1100 rt2x00dev
->chip
.rev
= rev
;
1102 rt2x00_info(rt2x00dev
, "Chipset detected - rt: %04x, rf: %04x, rev: %04x\n",
1103 rt2x00dev
->chip
.rt
, rt2x00dev
->chip
.rf
,
1104 rt2x00dev
->chip
.rev
);
1107 static inline void rt2x00_set_rt(struct rt2x00_dev
*rt2x00dev
,
1108 const u16 rt
, const u16 rev
)
1110 rt2x00dev
->chip
.rt
= rt
;
1111 rt2x00dev
->chip
.rev
= rev
;
1113 rt2x00_info(rt2x00dev
, "RT chipset %04x, rev %04x detected\n",
1114 rt2x00dev
->chip
.rt
, rt2x00dev
->chip
.rev
);
1117 static inline void rt2x00_set_rf(struct rt2x00_dev
*rt2x00dev
, const u16 rf
)
1119 rt2x00dev
->chip
.rf
= rf
;
1121 rt2x00_info(rt2x00dev
, "RF chipset %04x detected\n",
1122 rt2x00dev
->chip
.rf
);
1125 static inline bool rt2x00_rt(struct rt2x00_dev
*rt2x00dev
, const u16 rt
)
1127 return (rt2x00dev
->chip
.rt
== rt
);
1130 static inline bool rt2x00_rf(struct rt2x00_dev
*rt2x00dev
, const u16 rf
)
1132 return (rt2x00dev
->chip
.rf
== rf
);
1135 static inline u16
rt2x00_rev(struct rt2x00_dev
*rt2x00dev
)
1137 return rt2x00dev
->chip
.rev
;
1140 static inline bool rt2x00_rt_rev(struct rt2x00_dev
*rt2x00dev
,
1141 const u16 rt
, const u16 rev
)
1143 return (rt2x00_rt(rt2x00dev
, rt
) && rt2x00_rev(rt2x00dev
) == rev
);
1146 static inline bool rt2x00_rt_rev_lt(struct rt2x00_dev
*rt2x00dev
,
1147 const u16 rt
, const u16 rev
)
1149 return (rt2x00_rt(rt2x00dev
, rt
) && rt2x00_rev(rt2x00dev
) < rev
);
1152 static inline bool rt2x00_rt_rev_gte(struct rt2x00_dev
*rt2x00dev
,
1153 const u16 rt
, const u16 rev
)
1155 return (rt2x00_rt(rt2x00dev
, rt
) && rt2x00_rev(rt2x00dev
) >= rev
);
1158 static inline void rt2x00_set_chip_intf(struct rt2x00_dev
*rt2x00dev
,
1159 enum rt2x00_chip_intf intf
)
1161 rt2x00dev
->chip
.intf
= intf
;
1164 static inline bool rt2x00_intf(struct rt2x00_dev
*rt2x00dev
,
1165 enum rt2x00_chip_intf intf
)
1167 return (rt2x00dev
->chip
.intf
== intf
);
1170 static inline bool rt2x00_is_pci(struct rt2x00_dev
*rt2x00dev
)
1172 return rt2x00_intf(rt2x00dev
, RT2X00_CHIP_INTF_PCI
) ||
1173 rt2x00_intf(rt2x00dev
, RT2X00_CHIP_INTF_PCIE
);
1176 static inline bool rt2x00_is_pcie(struct rt2x00_dev
*rt2x00dev
)
1178 return rt2x00_intf(rt2x00dev
, RT2X00_CHIP_INTF_PCIE
);
1181 static inline bool rt2x00_is_usb(struct rt2x00_dev
*rt2x00dev
)
1183 return rt2x00_intf(rt2x00dev
, RT2X00_CHIP_INTF_USB
);
1186 static inline bool rt2x00_is_soc(struct rt2x00_dev
*rt2x00dev
)
1188 return rt2x00_intf(rt2x00dev
, RT2X00_CHIP_INTF_SOC
);
1191 /* Helpers for capability flags */
1194 rt2x00_has_cap_flag(struct rt2x00_dev
*rt2x00dev
,
1195 enum rt2x00_capability_flags cap_flag
)
1197 return test_bit(cap_flag
, &rt2x00dev
->cap_flags
);
1201 rt2x00_has_cap_hw_crypto(struct rt2x00_dev
*rt2x00dev
)
1203 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_HW_CRYPTO
);
1207 rt2x00_has_cap_power_limit(struct rt2x00_dev
*rt2x00dev
)
1209 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_POWER_LIMIT
);
1213 rt2x00_has_cap_control_filters(struct rt2x00_dev
*rt2x00dev
)
1215 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_CONTROL_FILTERS
);
1219 rt2x00_has_cap_control_filter_pspoll(struct rt2x00_dev
*rt2x00dev
)
1221 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_CONTROL_FILTER_PSPOLL
);
1225 rt2x00_has_cap_pre_tbtt_interrupt(struct rt2x00_dev
*rt2x00dev
)
1227 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_PRE_TBTT_INTERRUPT
);
1231 rt2x00_has_cap_link_tuning(struct rt2x00_dev
*rt2x00dev
)
1233 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_LINK_TUNING
);
1237 rt2x00_has_cap_frame_type(struct rt2x00_dev
*rt2x00dev
)
1239 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_FRAME_TYPE
);
1243 rt2x00_has_cap_rf_sequence(struct rt2x00_dev
*rt2x00dev
)
1245 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_RF_SEQUENCE
);
1249 rt2x00_has_cap_external_lna_a(struct rt2x00_dev
*rt2x00dev
)
1251 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_EXTERNAL_LNA_A
);
1255 rt2x00_has_cap_external_lna_bg(struct rt2x00_dev
*rt2x00dev
)
1257 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_EXTERNAL_LNA_BG
);
1261 rt2x00_has_cap_double_antenna(struct rt2x00_dev
*rt2x00dev
)
1263 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_DOUBLE_ANTENNA
);
1267 rt2x00_has_cap_bt_coexist(struct rt2x00_dev
*rt2x00dev
)
1269 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_BT_COEXIST
);
1273 rt2x00_has_cap_vco_recalibration(struct rt2x00_dev
*rt2x00dev
)
1275 return rt2x00_has_cap_flag(rt2x00dev
, CAPABILITY_VCO_RECALIBRATION
);
1279 * rt2x00queue_map_txskb - Map a skb into DMA for TX purposes.
1280 * @entry: Pointer to &struct queue_entry
1282 * Returns -ENOMEM if mapping fail, 0 otherwise.
1284 int rt2x00queue_map_txskb(struct queue_entry
*entry
);
1287 * rt2x00queue_unmap_skb - Unmap a skb from DMA.
1288 * @entry: Pointer to &struct queue_entry
1290 void rt2x00queue_unmap_skb(struct queue_entry
*entry
);
1293 * rt2x00queue_get_tx_queue - Convert tx queue index to queue pointer
1294 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1295 * @queue: rt2x00 queue index (see &enum data_queue_qid).
1297 * Returns NULL for non tx queues.
1299 static inline struct data_queue
*
1300 rt2x00queue_get_tx_queue(struct rt2x00_dev
*rt2x00dev
,
1301 const enum data_queue_qid queue
)
1303 if (queue
< rt2x00dev
->ops
->tx_queues
&& rt2x00dev
->tx
)
1304 return &rt2x00dev
->tx
[queue
];
1306 if (queue
== QID_ATIM
)
1307 return rt2x00dev
->atim
;
1313 * rt2x00queue_get_entry - Get queue entry where the given index points to.
1314 * @queue: Pointer to &struct data_queue from where we obtain the entry.
1315 * @index: Index identifier for obtaining the correct index.
1317 struct queue_entry
*rt2x00queue_get_entry(struct data_queue
*queue
,
1318 enum queue_index index
);
1321 * rt2x00queue_pause_queue - Pause a data queue
1322 * @queue: Pointer to &struct data_queue.
1324 * This function will pause the data queue locally, preventing
1325 * new frames to be added to the queue (while the hardware is
1326 * still allowed to run).
1328 void rt2x00queue_pause_queue(struct data_queue
*queue
);
1331 * rt2x00queue_unpause_queue - unpause a data queue
1332 * @queue: Pointer to &struct data_queue.
1334 * This function will unpause the data queue locally, allowing
1335 * new frames to be added to the queue again.
1337 void rt2x00queue_unpause_queue(struct data_queue
*queue
);
1340 * rt2x00queue_start_queue - Start a data queue
1341 * @queue: Pointer to &struct data_queue.
1343 * This function will start handling all pending frames in the queue.
1345 void rt2x00queue_start_queue(struct data_queue
*queue
);
1348 * rt2x00queue_stop_queue - Halt a data queue
1349 * @queue: Pointer to &struct data_queue.
1351 * This function will stop all pending frames in the queue.
1353 void rt2x00queue_stop_queue(struct data_queue
*queue
);
1356 * rt2x00queue_flush_queue - Flush a data queue
1357 * @queue: Pointer to &struct data_queue.
1358 * @drop: True to drop all pending frames.
1360 * This function will flush the queue. After this call
1361 * the queue is guaranteed to be empty.
1363 void rt2x00queue_flush_queue(struct data_queue
*queue
, bool drop
);
1366 * rt2x00queue_start_queues - Start all data queues
1367 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1369 * This function will loop through all available queues to start them
1371 void rt2x00queue_start_queues(struct rt2x00_dev
*rt2x00dev
);
1374 * rt2x00queue_stop_queues - Halt all data queues
1375 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1377 * This function will loop through all available queues to stop
1378 * any pending frames.
1380 void rt2x00queue_stop_queues(struct rt2x00_dev
*rt2x00dev
);
1383 * rt2x00queue_flush_queues - Flush all data queues
1384 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1385 * @drop: True to drop all pending frames.
1387 * This function will loop through all available queues to flush
1388 * any pending frames.
1390 void rt2x00queue_flush_queues(struct rt2x00_dev
*rt2x00dev
, bool drop
);
1396 * rt2x00debug_dump_frame - Dump a frame to userspace through debugfs.
1397 * @rt2x00dev: Pointer to &struct rt2x00_dev.
1398 * @type: The type of frame that is being dumped.
1399 * @skb: The skb containing the frame to be dumped.
1401 #ifdef CONFIG_RT2X00_LIB_DEBUGFS
1402 void rt2x00debug_dump_frame(struct rt2x00_dev
*rt2x00dev
,
1403 enum rt2x00_dump_type type
, struct queue_entry
*entry
);
1405 static inline void rt2x00debug_dump_frame(struct rt2x00_dev
*rt2x00dev
,
1406 enum rt2x00_dump_type type
,
1407 struct queue_entry
*entry
)
1410 #endif /* CONFIG_RT2X00_LIB_DEBUGFS */
1413 * Utility functions.
1415 u32
rt2x00lib_get_bssidx(struct rt2x00_dev
*rt2x00dev
,
1416 struct ieee80211_vif
*vif
);
1417 void rt2x00lib_set_mac_address(struct rt2x00_dev
*rt2x00dev
, u8
*eeprom_mac_addr
);
1420 * Interrupt context handlers.
1422 void rt2x00lib_beacondone(struct rt2x00_dev
*rt2x00dev
);
1423 void rt2x00lib_pretbtt(struct rt2x00_dev
*rt2x00dev
);
1424 void rt2x00lib_dmastart(struct queue_entry
*entry
);
1425 void rt2x00lib_dmadone(struct queue_entry
*entry
);
1426 void rt2x00lib_txdone(struct queue_entry
*entry
,
1427 struct txdone_entry_desc
*txdesc
);
1428 void rt2x00lib_txdone_noinfo(struct queue_entry
*entry
, u32 status
);
1429 void rt2x00lib_rxdone(struct queue_entry
*entry
, gfp_t gfp
);
1432 * mac80211 handlers.
1434 void rt2x00mac_tx(struct ieee80211_hw
*hw
,
1435 struct ieee80211_tx_control
*control
,
1436 struct sk_buff
*skb
);
1437 int rt2x00mac_start(struct ieee80211_hw
*hw
);
1438 void rt2x00mac_stop(struct ieee80211_hw
*hw
);
1439 int rt2x00mac_add_interface(struct ieee80211_hw
*hw
,
1440 struct ieee80211_vif
*vif
);
1441 void rt2x00mac_remove_interface(struct ieee80211_hw
*hw
,
1442 struct ieee80211_vif
*vif
);
1443 int rt2x00mac_config(struct ieee80211_hw
*hw
, u32 changed
);
1444 void rt2x00mac_configure_filter(struct ieee80211_hw
*hw
,
1445 unsigned int changed_flags
,
1446 unsigned int *total_flags
,
1448 int rt2x00mac_set_tim(struct ieee80211_hw
*hw
, struct ieee80211_sta
*sta
,
1450 #ifdef CONFIG_RT2X00_LIB_CRYPTO
1451 int rt2x00mac_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
1452 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
1453 struct ieee80211_key_conf
*key
);
1455 #define rt2x00mac_set_key NULL
1456 #endif /* CONFIG_RT2X00_LIB_CRYPTO */
1457 int rt2x00mac_sta_add(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
1458 struct ieee80211_sta
*sta
);
1459 int rt2x00mac_sta_remove(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
1460 struct ieee80211_sta
*sta
);
1461 void rt2x00mac_sw_scan_start(struct ieee80211_hw
*hw
,
1462 struct ieee80211_vif
*vif
,
1463 const u8
*mac_addr
);
1464 void rt2x00mac_sw_scan_complete(struct ieee80211_hw
*hw
,
1465 struct ieee80211_vif
*vif
);
1466 int rt2x00mac_get_stats(struct ieee80211_hw
*hw
,
1467 struct ieee80211_low_level_stats
*stats
);
1468 void rt2x00mac_bss_info_changed(struct ieee80211_hw
*hw
,
1469 struct ieee80211_vif
*vif
,
1470 struct ieee80211_bss_conf
*bss_conf
,
1472 int rt2x00mac_conf_tx(struct ieee80211_hw
*hw
,
1473 struct ieee80211_vif
*vif
, u16 queue
,
1474 const struct ieee80211_tx_queue_params
*params
);
1475 void rt2x00mac_rfkill_poll(struct ieee80211_hw
*hw
);
1476 void rt2x00mac_flush(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
1477 u32 queues
, bool drop
);
1478 int rt2x00mac_set_antenna(struct ieee80211_hw
*hw
, u32 tx_ant
, u32 rx_ant
);
1479 int rt2x00mac_get_antenna(struct ieee80211_hw
*hw
, u32
*tx_ant
, u32
*rx_ant
);
1480 void rt2x00mac_get_ringparam(struct ieee80211_hw
*hw
,
1481 u32
*tx
, u32
*tx_max
, u32
*rx
, u32
*rx_max
);
1482 bool rt2x00mac_tx_frames_pending(struct ieee80211_hw
*hw
);
1485 * Driver allocation handlers.
1487 int rt2x00lib_probe_dev(struct rt2x00_dev
*rt2x00dev
);
1488 void rt2x00lib_remove_dev(struct rt2x00_dev
*rt2x00dev
);
1490 int rt2x00lib_suspend(struct rt2x00_dev
*rt2x00dev
, pm_message_t state
);
1491 int rt2x00lib_resume(struct rt2x00_dev
*rt2x00dev
);
1492 #endif /* CONFIG_PM */
1494 #endif /* RT2X00_H */