rt2x00lib.h revision ea175ee26268370ca07aff91cf6ba1e0f1a3bd36
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, write to the 18 Free Software Foundation, Inc., 19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 20 */ 21 22/* 23 Module: rt2x00lib 24 Abstract: Data structures and definitions for the rt2x00lib module. 25 */ 26 27#ifndef RT2X00LIB_H 28#define RT2X00LIB_H 29 30/* 31 * Interval defines 32 */ 33#define WATCHDOG_INTERVAL round_jiffies_relative(HZ) 34#define LINK_TUNE_INTERVAL round_jiffies_relative(HZ) 35 36/* 37 * rt2x00_rate: Per rate device information 38 */ 39struct rt2x00_rate { 40 unsigned short flags; 41#define DEV_RATE_CCK 0x0001 42#define DEV_RATE_OFDM 0x0002 43#define DEV_RATE_SHORT_PREAMBLE 0x0004 44 45 unsigned short bitrate; /* In 100kbit/s */ 46 unsigned short ratemask; 47 48 unsigned short plcp; 49 unsigned short mcs; 50}; 51 52extern const struct rt2x00_rate rt2x00_supported_rates[12]; 53 54static inline const struct rt2x00_rate *rt2x00_get_rate(const u16 hw_value) 55{ 56 return &rt2x00_supported_rates[hw_value & 0xff]; 57} 58 59#define RATE_MCS(__mode, __mcs) \ 60 ((((__mode) & 0x00ff) << 8) | ((__mcs) & 0x00ff)) 61 62static inline int rt2x00_get_rate_mcs(const u16 mcs_value) 63{ 64 return (mcs_value & 0x00ff); 65} 66 67/* 68 * Radio control handlers. 69 */ 70int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev); 71void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev); 72 73/* 74 * Initialization handlers. 75 */ 76int rt2x00lib_start(struct rt2x00_dev *rt2x00dev); 77void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev); 78 79/* 80 * Configuration handlers. 81 */ 82void rt2x00lib_config_intf(struct rt2x00_dev *rt2x00dev, 83 struct rt2x00_intf *intf, 84 enum nl80211_iftype type, 85 const u8 *mac, const u8 *bssid); 86void rt2x00lib_config_erp(struct rt2x00_dev *rt2x00dev, 87 struct rt2x00_intf *intf, 88 struct ieee80211_bss_conf *conf, 89 u32 changed); 90void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev, 91 struct antenna_setup ant); 92void rt2x00lib_config(struct rt2x00_dev *rt2x00dev, 93 struct ieee80211_conf *conf, 94 const unsigned int changed_flags); 95 96/** 97 * DOC: Queue handlers 98 */ 99 100/** 101 * rt2x00queue_alloc_rxskb - allocate a skb for RX purposes. 102 * @entry: The entry for which the skb will be applicable. 103 */ 104struct sk_buff *rt2x00queue_alloc_rxskb(struct queue_entry *entry); 105 106/** 107 * rt2x00queue_free_skb - free a skb 108 * @entry: The entry for which the skb will be applicable. 109 */ 110void rt2x00queue_free_skb(struct queue_entry *entry); 111 112/** 113 * rt2x00queue_align_frame - Align 802.11 frame to 4-byte boundary 114 * @skb: The skb to align 115 * 116 * Align the start of the 802.11 frame to a 4-byte boundary, this could 117 * mean the payload is not aligned properly though. 118 */ 119void rt2x00queue_align_frame(struct sk_buff *skb); 120 121/** 122 * rt2x00queue_align_payload - Align 802.11 payload to 4-byte boundary 123 * @skb: The skb to align 124 * @header_length: Length of 802.11 header 125 * 126 * Align the 802.11 payload to a 4-byte boundary, this could 127 * mean the header is not aligned properly though. 128 */ 129void rt2x00queue_align_payload(struct sk_buff *skb, unsigned int header_length); 130 131/** 132 * rt2x00queue_insert_l2pad - Align 802.11 header & payload to 4-byte boundary 133 * @skb: The skb to align 134 * @header_length: Length of 802.11 header 135 * 136 * Apply L2 padding to align both header and payload to 4-byte boundary 137 */ 138void rt2x00queue_insert_l2pad(struct sk_buff *skb, unsigned int header_length); 139 140/** 141 * rt2x00queue_insert_l2pad - Remove L2 padding from 802.11 frame 142 * @skb: The skb to align 143 * @header_length: Length of 802.11 header 144 * 145 * Remove L2 padding used to align both header and payload to 4-byte boundary, 146 * by removing the L2 padding the header will no longer be 4-byte aligned. 147 */ 148void rt2x00queue_remove_l2pad(struct sk_buff *skb, unsigned int header_length); 149 150/** 151 * rt2x00queue_write_tx_frame - Write TX frame to hardware 152 * @queue: Queue over which the frame should be send 153 * @skb: The skb to send 154 * @local: frame is not from mac80211 155 */ 156int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb, 157 bool local); 158 159/** 160 * rt2x00queue_update_beacon - Send new beacon from mac80211 to hardware 161 * @rt2x00dev: Pointer to &struct rt2x00_dev. 162 * @vif: Interface for which the beacon should be updated. 163 * @enable_beacon: Enable beaconing 164 */ 165int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev, 166 struct ieee80211_vif *vif, 167 const bool enable_beacon); 168 169/** 170 * rt2x00queue_index_inc - Index incrementation function 171 * @queue: Queue (&struct data_queue) to perform the action on. 172 * @index: Index type (&enum queue_index) to perform the action on. 173 * 174 * This function will increase the requested index on the queue, 175 * it will grab the appropriate locks and handle queue overflow events by 176 * resetting the index to the start of the queue. 177 */ 178void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index); 179 180/** 181 * rt2x00queue_stop_queues - Halt all data queues 182 * @rt2x00dev: Pointer to &struct rt2x00_dev. 183 * 184 * This function will loop through all available queues to stop 185 * any pending outgoing frames. 186 */ 187void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev); 188 189/** 190 * rt2x00queue_init_queues - Initialize all data queues 191 * @rt2x00dev: Pointer to &struct rt2x00_dev. 192 * 193 * This function will loop through all available queues to clear all 194 * index numbers and set the queue entry to the correct initialization 195 * state. 196 */ 197void rt2x00queue_init_queues(struct rt2x00_dev *rt2x00dev); 198 199int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev); 200void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev); 201int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev); 202void rt2x00queue_free(struct rt2x00_dev *rt2x00dev); 203 204/** 205 * rt2x00link_update_stats - Update link statistics from RX frame 206 * @rt2x00dev: Pointer to &struct rt2x00_dev. 207 * @skb: Received frame 208 * @rxdesc: Received frame descriptor 209 * 210 * Update link statistics based on the information from the 211 * received frame descriptor. 212 */ 213void rt2x00link_update_stats(struct rt2x00_dev *rt2x00dev, 214 struct sk_buff *skb, 215 struct rxdone_entry_desc *rxdesc); 216 217/** 218 * rt2x00link_start_tuner - Start periodic link tuner work 219 * @rt2x00dev: Pointer to &struct rt2x00_dev. 220 * 221 * This start the link tuner periodic work, this work will 222 * be executed periodically until &rt2x00link_stop_tuner has 223 * been called. 224 */ 225void rt2x00link_start_tuner(struct rt2x00_dev *rt2x00dev); 226 227/** 228 * rt2x00link_stop_tuner - Stop periodic link tuner work 229 * @rt2x00dev: Pointer to &struct rt2x00_dev. 230 * 231 * After this function completed the link tuner will not 232 * be running until &rt2x00link_start_tuner is called. 233 */ 234void rt2x00link_stop_tuner(struct rt2x00_dev *rt2x00dev); 235 236/** 237 * rt2x00link_reset_tuner - Reset periodic link tuner work 238 * @rt2x00dev: Pointer to &struct rt2x00_dev. 239 * @antenna: Should the antenna tuning also be reset 240 * 241 * The VGC limit configured in the hardware will be reset to 0 242 * which forces the driver to rediscover the correct value for 243 * the current association. This is needed when configuration 244 * options have changed which could drastically change the 245 * SNR level or link quality (i.e. changing the antenna setting). 246 * 247 * Resetting the link tuner will also cause the periodic work counter 248 * to be reset. Any driver which has a fixed limit on the number 249 * of rounds the link tuner is supposed to work will accept the 250 * tuner actions again if this limit was previously reached. 251 * 252 * If @antenna is set to true a the software antenna diversity 253 * tuning will also be reset. 254 */ 255void rt2x00link_reset_tuner(struct rt2x00_dev *rt2x00dev, bool antenna); 256 257/** 258 * rt2x00link_start_watchdog - Start periodic watchdog monitoring 259 * @rt2x00dev: Pointer to &struct rt2x00_dev. 260 * 261 * This start the watchdog periodic work, this work will 262 *be executed periodically until &rt2x00link_stop_watchdog has 263 * been called. 264 */ 265void rt2x00link_start_watchdog(struct rt2x00_dev *rt2x00dev); 266 267/** 268 * rt2x00link_stop_watchdog - Stop periodic watchdog monitoring 269 * @rt2x00dev: Pointer to &struct rt2x00_dev. 270 * 271 * After this function completed the watchdog monitoring will not 272 * be running until &rt2x00link_start_watchdog is called. 273 */ 274void rt2x00link_stop_watchdog(struct rt2x00_dev *rt2x00dev); 275 276/** 277 * rt2x00link_register - Initialize link tuning & watchdog functionality 278 * @rt2x00dev: Pointer to &struct rt2x00_dev. 279 * 280 * Initialize work structure and all link tuning and watchdog related 281 * parameters. This will not start the periodic work itself. 282 */ 283void rt2x00link_register(struct rt2x00_dev *rt2x00dev); 284 285/* 286 * Firmware handlers. 287 */ 288#ifdef CONFIG_RT2X00_LIB_FIRMWARE 289int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev); 290void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev); 291#else 292static inline int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev) 293{ 294 return 0; 295} 296static inline void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev) 297{ 298} 299#endif /* CONFIG_RT2X00_LIB_FIRMWARE */ 300 301/* 302 * Debugfs handlers. 303 */ 304#ifdef CONFIG_RT2X00_LIB_DEBUGFS 305void rt2x00debug_register(struct rt2x00_dev *rt2x00dev); 306void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev); 307void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev, 308 struct rxdone_entry_desc *rxdesc); 309#else 310static inline void rt2x00debug_register(struct rt2x00_dev *rt2x00dev) 311{ 312} 313 314static inline void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev) 315{ 316} 317 318static inline void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev, 319 struct rxdone_entry_desc *rxdesc) 320{ 321} 322#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 323 324/* 325 * Crypto handlers. 326 */ 327#ifdef CONFIG_RT2X00_LIB_CRYPTO 328enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key); 329void rt2x00crypto_create_tx_descriptor(struct queue_entry *entry, 330 struct txentry_desc *txdesc); 331unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev, 332 struct sk_buff *skb); 333void rt2x00crypto_tx_copy_iv(struct sk_buff *skb, 334 struct txentry_desc *txdesc); 335void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, 336 struct txentry_desc *txdesc); 337void rt2x00crypto_tx_insert_iv(struct sk_buff *skb, unsigned int header_length); 338void rt2x00crypto_rx_insert_iv(struct sk_buff *skb, 339 unsigned int header_length, 340 struct rxdone_entry_desc *rxdesc); 341#else 342static inline enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key) 343{ 344 return CIPHER_NONE; 345} 346 347static inline void rt2x00crypto_create_tx_descriptor(struct queue_entry *entry, 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 * HT handlers. 382 */ 383#ifdef CONFIG_RT2X00_LIB_HT 384void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 385 struct txentry_desc *txdesc, 386 const struct rt2x00_rate *hwrate); 387 388u16 rt2x00ht_center_channel(struct rt2x00_dev *rt2x00dev, 389 struct ieee80211_conf *conf); 390#else 391static inline void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 392 struct txentry_desc *txdesc, 393 const struct rt2x00_rate *hwrate) 394{ 395} 396 397static inline u16 rt2x00ht_center_channel(struct rt2x00_dev *rt2x00dev, 398 struct ieee80211_conf *conf) 399{ 400 return conf->channel->hw_value; 401} 402#endif /* CONFIG_RT2X00_LIB_HT */ 403 404/* 405 * RFkill handlers. 406 */ 407static inline void rt2x00rfkill_register(struct rt2x00_dev *rt2x00dev) 408{ 409 if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags)) 410 wiphy_rfkill_start_polling(rt2x00dev->hw->wiphy); 411} 412 413static inline void rt2x00rfkill_unregister(struct rt2x00_dev *rt2x00dev) 414{ 415 if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags)) 416 wiphy_rfkill_stop_polling(rt2x00dev->hw->wiphy); 417} 418 419/* 420 * LED handlers 421 */ 422#ifdef CONFIG_RT2X00_LIB_LEDS 423void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi); 424void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled); 425void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled); 426void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled); 427void rt2x00leds_register(struct rt2x00_dev *rt2x00dev); 428void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev); 429void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev); 430void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev); 431#else 432static inline void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, 433 int rssi) 434{ 435} 436 437static inline void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, 438 bool enabled) 439{ 440} 441 442static inline void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, 443 bool enabled) 444{ 445} 446 447static inline void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, 448 bool enabled) 449{ 450} 451 452static inline void rt2x00leds_register(struct rt2x00_dev *rt2x00dev) 453{ 454} 455 456static inline void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev) 457{ 458} 459 460static inline void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev) 461{ 462} 463 464static inline void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev) 465{ 466} 467#endif /* CONFIG_RT2X00_LIB_LEDS */ 468 469#endif /* RT2X00LIB_H */ 470