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 */ 40 struct 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 53 extern const struct rt2x00_rate rt2x00_supported_rates[12]; 54 55 static 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 63 static inline int rt2x00_get_rate_mcs(const u16 mcs_value) 64 { 65 return (mcs_value & 0x00ff); 66 } 67 68 /* 69 * Radio control handlers. 70 */ 71 int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev); 72 void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev); 73 74 /* 75 * Initialization handlers. 76 */ 77 int rt2x00lib_start(struct rt2x00_dev *rt2x00dev); 78 void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev); 79 80 /* 81 * Configuration handlers. 82 */ 83 void rt2x00lib_config_intf(struct rt2x00_dev *rt2x00dev, 84 struct rt2x00_intf *intf, 85 enum nl80211_iftype type, 86 const u8 *mac, const u8 *bssid); 87 void rt2x00lib_config_erp(struct rt2x00_dev *rt2x00dev, 88 struct rt2x00_intf *intf, 89 struct ieee80211_bss_conf *conf, 90 u32 changed); 91 void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev, 92 struct antenna_setup ant); 93 void 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 */ 105 struct 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 */ 111 void 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 */ 120 void 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 */ 129 void 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 */ 139 void 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 */ 147 int 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 */ 156 int 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 */ 165 int 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 */ 173 int 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 */ 185 void 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 */ 195 void rt2x00queue_init_queues(struct rt2x00_dev *rt2x00dev); 196 197 int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev); 198 void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev); 199 int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev); 200 void 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 */ 211 void 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 */ 223 void 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 */ 232 void 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 */ 253 void 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 */ 263 void 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 */ 272 void 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 */ 281 void rt2x00link_register(struct rt2x00_dev *rt2x00dev); 282 283 /* 284 * Firmware handlers. 285 */ 286 #ifdef CONFIG_RT2X00_LIB_FIRMWARE 287 int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev); 288 void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev); 289 #else 290 static inline int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev) 291 { 292 return 0; 293 } 294 static 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 303 void rt2x00debug_register(struct rt2x00_dev *rt2x00dev); 304 void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev); 305 void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev, 306 struct rxdone_entry_desc *rxdesc); 307 #else 308 static inline void rt2x00debug_register(struct rt2x00_dev *rt2x00dev) 309 { 310 } 311 312 static inline void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev) 313 { 314 } 315 316 static 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 326 enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key); 327 void rt2x00crypto_create_tx_descriptor(struct rt2x00_dev *rt2x00dev, 328 struct sk_buff *skb, 329 struct txentry_desc *txdesc); 330 unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev, 331 struct sk_buff *skb); 332 void rt2x00crypto_tx_copy_iv(struct sk_buff *skb, 333 struct txentry_desc *txdesc); 334 void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, 335 struct txentry_desc *txdesc); 336 void rt2x00crypto_tx_insert_iv(struct sk_buff *skb, unsigned int header_length); 337 void rt2x00crypto_rx_insert_iv(struct sk_buff *skb, 338 unsigned int header_length, 339 struct rxdone_entry_desc *rxdesc); 340 #else 341 static inline enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key) 342 { 343 return CIPHER_NONE; 344 } 345 346 static inline void rt2x00crypto_create_tx_descriptor(struct rt2x00_dev *rt2x00dev, 347 struct sk_buff *skb, 348 struct txentry_desc *txdesc) 349 { 350 } 351 352 static inline unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev, 353 struct sk_buff *skb) 354 { 355 return 0; 356 } 357 358 static inline void rt2x00crypto_tx_copy_iv(struct sk_buff *skb, 359 struct txentry_desc *txdesc) 360 { 361 } 362 363 static inline void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, 364 struct txentry_desc *txdesc) 365 { 366 } 367 368 static inline void rt2x00crypto_tx_insert_iv(struct sk_buff *skb, 369 unsigned int header_length) 370 { 371 } 372 373 static 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 */ 383 static 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 389 static 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 399 void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi); 400 void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled); 401 void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled); 402 void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled); 403 void rt2x00leds_register(struct rt2x00_dev *rt2x00dev); 404 void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev); 405 void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev); 406 void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev); 407 #else 408 static inline void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, 409 int rssi) 410 { 411 } 412 413 static inline void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, 414 bool enabled) 415 { 416 } 417 418 static inline void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, 419 bool enabled) 420 { 421 } 422 423 static inline void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, 424 bool enabled) 425 { 426 } 427 428 static inline void rt2x00leds_register(struct rt2x00_dev *rt2x00dev) 429 { 430 } 431 432 static inline void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev) 433 { 434 } 435 436 static inline void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev) 437 { 438 } 439 440 static inline void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev) 441 { 442 } 443 #endif /* CONFIG_RT2X00_LIB_LEDS */ 444 445 #endif /* RT2X00LIB_H */ 446