linux/drivers/net/wireless/ralink/rt2x00/rt2x00lib.h
<<
>>
Prefs
   1/*
   2        Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
   3        Copyright (C) 2004 - 2009 Gertjan van Wingerde <gwingerde@gmail.com>
   4        <http://rt2x00.serialmonkey.com>
   5
   6        This program is free software; you can redistribute it and/or modify
   7        it under the terms of the GNU General Public License as published by
   8        the Free Software Foundation; either version 2 of the License, or
   9        (at your option) any later version.
  10
  11        This program is distributed in the hope that it will be useful,
  12        but WITHOUT ANY WARRANTY; without even the implied warranty of
  13        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14        GNU General Public License for more details.
  15
  16        You should have received a copy of the GNU General Public License
  17        along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20/*
  21        Module: rt2x00lib
  22        Abstract: Data structures and definitions for the rt2x00lib module.
  23 */
  24
  25#ifndef RT2X00LIB_H
  26#define RT2X00LIB_H
  27
  28/*
  29 * Interval defines
  30 */
  31#define WATCHDOG_INTERVAL       round_jiffies_relative(HZ)
  32#define LINK_TUNE_SECONDS       1
  33#define LINK_TUNE_INTERVAL      round_jiffies_relative(LINK_TUNE_SECONDS * HZ)
  34#define AGC_SECONDS             4
  35#define VCO_SECONDS             10
  36
  37/*
  38 * rt2x00_rate: Per rate device information
  39 */
  40struct rt2x00_rate {
  41        unsigned short flags;
  42#define DEV_RATE_CCK                    0x0001
  43#define DEV_RATE_OFDM                   0x0002
  44#define DEV_RATE_SHORT_PREAMBLE         0x0004
  45
  46        unsigned short bitrate; /* In 100kbit/s */
  47        unsigned short ratemask;
  48
  49        unsigned short plcp;
  50        unsigned short mcs;
  51};
  52
  53extern const struct rt2x00_rate rt2x00_supported_rates[12];
  54
  55static inline const struct rt2x00_rate *rt2x00_get_rate(const u16 hw_value)
  56{
  57        return &rt2x00_supported_rates[hw_value & 0xff];
  58}
  59
  60#define RATE_MCS(__mode, __mcs) \
  61        ((((__mode) & 0x00ff) << 8) | ((__mcs) & 0x00ff))
  62
  63static inline int rt2x00_get_rate_mcs(const u16 mcs_value)
  64{
  65        return (mcs_value & 0x00ff);
  66}
  67
  68/*
  69 * Radio control handlers.
  70 */
  71int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev);
  72void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev);
  73
  74/*
  75 * Initialization handlers.
  76 */
  77int rt2x00lib_start(struct rt2x00_dev *rt2x00dev);
  78void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev);
  79
  80/*
  81 * Configuration handlers.
  82 */
  83void rt2x00lib_config_intf(struct rt2x00_dev *rt2x00dev,
  84                           struct rt2x00_intf *intf,
  85                           enum nl80211_iftype type,
  86                           const u8 *mac, const u8 *bssid);
  87void rt2x00lib_config_erp(struct rt2x00_dev *rt2x00dev,
  88                          struct rt2x00_intf *intf,
  89                          struct ieee80211_bss_conf *conf,
  90                          u32 changed);
  91void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev,
  92                              struct antenna_setup ant);
  93void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
  94                      struct ieee80211_conf *conf,
  95                      const unsigned int changed_flags);
  96
  97/**
  98 * DOC: Queue handlers
  99 */
 100
 101/**
 102 * rt2x00queue_alloc_rxskb - allocate a skb for RX purposes.
 103 * @entry: The entry for which the skb will be applicable.
 104 */
 105struct sk_buff *rt2x00queue_alloc_rxskb(struct queue_entry *entry, gfp_t gfp);
 106
 107/**
 108 * rt2x00queue_free_skb - free a skb
 109 * @entry: The entry for which the skb will be applicable.
 110 */
 111void rt2x00queue_free_skb(struct queue_entry *entry);
 112
 113/**
 114 * rt2x00queue_align_frame - Align 802.11 frame to 4-byte boundary
 115 * @skb: The skb to align
 116 *
 117 * Align the start of the 802.11 frame to a 4-byte boundary, this could
 118 * mean the payload is not aligned properly though.
 119 */
 120void rt2x00queue_align_frame(struct sk_buff *skb);
 121
 122/**
 123 * rt2x00queue_insert_l2pad - Align 802.11 header & payload to 4-byte boundary
 124 * @skb: The skb to align
 125 * @header_length: Length of 802.11 header
 126 *
 127 * Apply L2 padding to align both header and payload to 4-byte boundary
 128 */
 129void rt2x00queue_insert_l2pad(struct sk_buff *skb, unsigned int header_length);
 130
 131/**
 132 * rt2x00queue_insert_l2pad - Remove L2 padding from 802.11 frame
 133 * @skb: The skb to align
 134 * @header_length: Length of 802.11 header
 135 *
 136 * Remove L2 padding used to align both header and payload to 4-byte boundary,
 137 * by removing the L2 padding the header will no longer be 4-byte aligned.
 138 */
 139void rt2x00queue_remove_l2pad(struct sk_buff *skb, unsigned int header_length);
 140
 141/**
 142 * rt2x00queue_write_tx_frame - Write TX frame to hardware
 143 * @queue: Queue over which the frame should be send
 144 * @skb: The skb to send
 145 * @local: frame is not from mac80211
 146 */
 147int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb,
 148                               struct ieee80211_sta *sta, bool local);
 149
 150/**
 151 * rt2x00queue_update_beacon - Send new beacon from mac80211
 152 *      to hardware. Handles locking by itself (mutex).
 153 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 154 * @vif: Interface for which the beacon should be updated.
 155 */
 156int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev,
 157                              struct ieee80211_vif *vif);
 158
 159/**
 160 * rt2x00queue_update_beacon_locked - Send new beacon from mac80211
 161 *      to hardware. Caller needs to ensure locking.
 162 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 163 * @vif: Interface for which the beacon should be updated.
 164 */
 165int rt2x00queue_update_beacon_locked(struct rt2x00_dev *rt2x00dev,
 166                                     struct ieee80211_vif *vif);
 167
 168/**
 169 * rt2x00queue_clear_beacon - Clear beacon in hardware
 170 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 171 * @vif: Interface for which the beacon should be updated.
 172 */
 173int rt2x00queue_clear_beacon(struct rt2x00_dev *rt2x00dev,
 174                             struct ieee80211_vif *vif);
 175
 176/**
 177 * rt2x00queue_index_inc - Index incrementation function
 178 * @entry: Queue entry (&struct queue_entry) to perform the action on.
 179 * @index: Index type (&enum queue_index) to perform the action on.
 180 *
 181 * This function will increase the requested index on the entry's queue,
 182 * it will grab the appropriate locks and handle queue overflow events by
 183 * resetting the index to the start of the queue.
 184 */
 185void rt2x00queue_index_inc(struct queue_entry *entry, enum queue_index index);
 186
 187/**
 188 * rt2x00queue_init_queues - Initialize all data queues
 189 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 190 *
 191 * This function will loop through all available queues to clear all
 192 * index numbers and set the queue entry to the correct initialization
 193 * state.
 194 */
 195void rt2x00queue_init_queues(struct rt2x00_dev *rt2x00dev);
 196
 197int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev);
 198void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev);
 199int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev);
 200void rt2x00queue_free(struct rt2x00_dev *rt2x00dev);
 201
 202/**
 203 * rt2x00link_update_stats - Update link statistics from RX frame
 204 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 205 * @skb: Received frame
 206 * @rxdesc: Received frame descriptor
 207 *
 208 * Update link statistics based on the information from the
 209 * received frame descriptor.
 210 */
 211void rt2x00link_update_stats(struct rt2x00_dev *rt2x00dev,
 212                             struct sk_buff *skb,
 213                             struct rxdone_entry_desc *rxdesc);
 214
 215/**
 216 * rt2x00link_start_tuner - Start periodic link tuner work
 217 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 218 *
 219 * This start the link tuner periodic work, this work will
 220 * be executed periodically until &rt2x00link_stop_tuner has
 221 * been called.
 222 */
 223void rt2x00link_start_tuner(struct rt2x00_dev *rt2x00dev);
 224
 225/**
 226 * rt2x00link_stop_tuner - Stop periodic link tuner work
 227 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 228 *
 229 * After this function completed the link tuner will not
 230 * be running until &rt2x00link_start_tuner is called.
 231 */
 232void rt2x00link_stop_tuner(struct rt2x00_dev *rt2x00dev);
 233
 234/**
 235 * rt2x00link_reset_tuner - Reset periodic link tuner work
 236 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 237 * @antenna: Should the antenna tuning also be reset
 238 *
 239 * The VGC limit configured in the hardware will be reset to 0
 240 * which forces the driver to rediscover the correct value for
 241 * the current association. This is needed when configuration
 242 * options have changed which could drastically change the
 243 * SNR level or link quality (i.e. changing the antenna setting).
 244 *
 245 * Resetting the link tuner will also cause the periodic work counter
 246 * to be reset. Any driver which has a fixed limit on the number
 247 * of rounds the link tuner is supposed to work will accept the
 248 * tuner actions again if this limit was previously reached.
 249 *
 250 * If @antenna is set to true a the software antenna diversity
 251 * tuning will also be reset.
 252 */
 253void rt2x00link_reset_tuner(struct rt2x00_dev *rt2x00dev, bool antenna);
 254
 255/**
 256 * rt2x00link_start_watchdog - Start periodic watchdog monitoring
 257 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 258 *
 259 * This start the watchdog periodic work, this work will
 260 *be executed periodically until &rt2x00link_stop_watchdog has
 261 * been called.
 262 */
 263void rt2x00link_start_watchdog(struct rt2x00_dev *rt2x00dev);
 264
 265/**
 266 * rt2x00link_stop_watchdog - Stop periodic watchdog monitoring
 267 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 268 *
 269 * After this function completed the watchdog monitoring will not
 270 * be running until &rt2x00link_start_watchdog is called.
 271 */
 272void rt2x00link_stop_watchdog(struct rt2x00_dev *rt2x00dev);
 273
 274/**
 275 * rt2x00link_register - Initialize link tuning & watchdog functionality
 276 * @rt2x00dev: Pointer to &struct rt2x00_dev.
 277 *
 278 * Initialize work structure and all link tuning and watchdog related
 279 * parameters. This will not start the periodic work itself.
 280 */
 281void rt2x00link_register(struct rt2x00_dev *rt2x00dev);
 282
 283/*
 284 * Firmware handlers.
 285 */
 286#ifdef CONFIG_RT2X00_LIB_FIRMWARE
 287int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev);
 288void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev);
 289#else
 290static inline int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev)
 291{
 292        return 0;
 293}
 294static inline void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev)
 295{
 296}
 297#endif /* CONFIG_RT2X00_LIB_FIRMWARE */
 298
 299/*
 300 * Debugfs handlers.
 301 */
 302#ifdef CONFIG_RT2X00_LIB_DEBUGFS
 303void rt2x00debug_register(struct rt2x00_dev *rt2x00dev);
 304void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev);
 305void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev,
 306                               struct rxdone_entry_desc *rxdesc);
 307#else
 308static inline void rt2x00debug_register(struct rt2x00_dev *rt2x00dev)
 309{
 310}
 311
 312static inline void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev)
 313{
 314}
 315
 316static inline void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev,
 317                                             struct rxdone_entry_desc *rxdesc)
 318{
 319}
 320#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
 321
 322/*
 323 * Crypto handlers.
 324 */
 325#ifdef CONFIG_RT2X00_LIB_CRYPTO
 326enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key);
 327void rt2x00crypto_create_tx_descriptor(struct rt2x00_dev *rt2x00dev,
 328                                       struct sk_buff *skb,
 329                                       struct txentry_desc *txdesc);
 330unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev,
 331                                      struct sk_buff *skb);
 332void rt2x00crypto_tx_copy_iv(struct sk_buff *skb,
 333                             struct txentry_desc *txdesc);
 334void rt2x00crypto_tx_remove_iv(struct sk_buff *skb,
 335                               struct txentry_desc *txdesc);
 336void rt2x00crypto_tx_insert_iv(struct sk_buff *skb, unsigned int header_length);
 337void rt2x00crypto_rx_insert_iv(struct sk_buff *skb,
 338                               unsigned int header_length,
 339                               struct rxdone_entry_desc *rxdesc);
 340#else
 341static inline enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key)
 342{
 343        return CIPHER_NONE;
 344}
 345
 346static inline void rt2x00crypto_create_tx_descriptor(struct rt2x00_dev *rt2x00dev,
 347                                                     struct sk_buff *skb,
 348                                                     struct txentry_desc *txdesc)
 349{
 350}
 351
 352static inline unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev,
 353                                                    struct sk_buff *skb)
 354{
 355        return 0;
 356}
 357
 358static inline void rt2x00crypto_tx_copy_iv(struct sk_buff *skb,
 359                                           struct txentry_desc *txdesc)
 360{
 361}
 362
 363static inline void rt2x00crypto_tx_remove_iv(struct sk_buff *skb,
 364                                             struct txentry_desc *txdesc)
 365{
 366}
 367
 368static inline void rt2x00crypto_tx_insert_iv(struct sk_buff *skb,
 369                                             unsigned int header_length)
 370{
 371}
 372
 373static inline void rt2x00crypto_rx_insert_iv(struct sk_buff *skb,
 374                                             unsigned int header_length,
 375                                             struct rxdone_entry_desc *rxdesc)
 376{
 377}
 378#endif /* CONFIG_RT2X00_LIB_CRYPTO */
 379
 380/*
 381 * RFkill handlers.
 382 */
 383static inline void rt2x00rfkill_register(struct rt2x00_dev *rt2x00dev)
 384{
 385        if (test_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags))
 386                wiphy_rfkill_start_polling(rt2x00dev->hw->wiphy);
 387}
 388
 389static inline void rt2x00rfkill_unregister(struct rt2x00_dev *rt2x00dev)
 390{
 391        if (test_bit(CAPABILITY_HW_BUTTON, &rt2x00dev->cap_flags))
 392                wiphy_rfkill_stop_polling(rt2x00dev->hw->wiphy);
 393}
 394
 395/*
 396 * LED handlers
 397 */
 398#ifdef CONFIG_RT2X00_LIB_LEDS
 399void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi);
 400void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled);
 401void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled);
 402void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled);
 403void rt2x00leds_register(struct rt2x00_dev *rt2x00dev);
 404void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev);
 405void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev);
 406void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev);
 407#else
 408static inline void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev,
 409                                          int rssi)
 410{
 411}
 412
 413static inline void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev,
 414                                          bool enabled)
 415{
 416}
 417
 418static inline void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev,
 419                                        bool enabled)
 420{
 421}
 422
 423static inline void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev,
 424                                        bool enabled)
 425{
 426}
 427
 428static inline void rt2x00leds_register(struct rt2x00_dev *rt2x00dev)
 429{
 430}
 431
 432static inline void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev)
 433{
 434}
 435
 436static inline void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev)
 437{
 438}
 439
 440static inline void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev)
 441{
 442}
 443#endif /* CONFIG_RT2X00_LIB_LEDS */
 444
 445#endif /* RT2X00LIB_H */
 446