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); 72void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state); 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); 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 * @rt2x00dev: Pointer to &struct rt2x00_dev. 103 * @queue: The queue for which the skb will be applicable. 104 */ 105struct sk_buff *rt2x00queue_alloc_rxskb(struct rt2x00_dev *rt2x00dev, 106 struct queue_entry *entry); 107 108/** 109 * rt2x00queue_free_skb - free a skb 110 * @rt2x00dev: Pointer to &struct rt2x00_dev. 111 * @skb: The skb to free. 112 */ 113void rt2x00queue_free_skb(struct rt2x00_dev *rt2x00dev, struct sk_buff *skb); 114 115/** 116 * rt2x00queue_align_frame - Align 802.11 frame to 4-byte boundary 117 * @skb: The skb to align 118 * 119 * Align the start of the 802.11 frame to a 4-byte boundary, this could 120 * mean the payload is not aligned properly though. 121 */ 122void rt2x00queue_align_frame(struct sk_buff *skb); 123 124/** 125 * rt2x00queue_align_payload - Align 802.11 payload to 4-byte boundary 126 * @skb: The skb to align 127 * @header_length: Length of 802.11 header 128 * 129 * Align the 802.11 payload to a 4-byte boundary, this could 130 * mean the header is not aligned properly though. 131 */ 132void rt2x00queue_align_payload(struct sk_buff *skb, unsigned int header_length); 133 134/** 135 * rt2x00queue_insert_l2pad - Align 802.11 header & payload to 4-byte boundary 136 * @skb: The skb to align 137 * @header_length: Length of 802.11 header 138 * 139 * Apply L2 padding to align both header and payload to 4-byte boundary 140 */ 141void rt2x00queue_insert_l2pad(struct sk_buff *skb, unsigned int header_length); 142 143/** 144 * rt2x00queue_insert_l2pad - Remove L2 padding from 802.11 frame 145 * @skb: The skb to align 146 * @header_length: Length of 802.11 header 147 * 148 * Remove L2 padding used to align both header and payload to 4-byte boundary, 149 * by removing the L2 padding the header will no longer be 4-byte aligned. 150 */ 151void rt2x00queue_remove_l2pad(struct sk_buff *skb, unsigned int header_length); 152 153/** 154 * rt2x00queue_write_tx_frame - Write TX frame to hardware 155 * @queue: Queue over which the frame should be send 156 * @skb: The skb to send 157 * @local: frame is not from mac80211 158 */ 159int rt2x00queue_write_tx_frame(struct data_queue *queue, struct sk_buff *skb, 160 bool local); 161 162/** 163 * rt2x00queue_update_beacon - Send new beacon from mac80211 to hardware 164 * @rt2x00dev: Pointer to &struct rt2x00_dev. 165 * @vif: Interface for which the beacon should be updated. 166 * @enable_beacon: Enable beaconing 167 */ 168int rt2x00queue_update_beacon(struct rt2x00_dev *rt2x00dev, 169 struct ieee80211_vif *vif, 170 const bool enable_beacon); 171 172/** 173 * rt2x00queue_index_inc - Index incrementation function 174 * @queue: Queue (&struct data_queue) to perform the action on. 175 * @index: Index type (&enum queue_index) to perform the action on. 176 * 177 * This function will increase the requested index on the queue, 178 * it will grab the appropriate locks and handle queue overflow events by 179 * resetting the index to the start of the queue. 180 */ 181void rt2x00queue_index_inc(struct data_queue *queue, enum queue_index index); 182 183/** 184 * rt2x00queue_stop_queues - Halt all data queues 185 * @rt2x00dev: Pointer to &struct rt2x00_dev. 186 * 187 * This function will loop through all available queues to stop 188 * any pending outgoing frames. 189 */ 190void rt2x00queue_stop_queues(struct rt2x00_dev *rt2x00dev); 191 192/** 193 * rt2x00queue_init_queues - Initialize all data queues 194 * @rt2x00dev: Pointer to &struct rt2x00_dev. 195 * 196 * This function will loop through all available queues to clear all 197 * index numbers and set the queue entry to the correct initialization 198 * state. 199 */ 200void rt2x00queue_init_queues(struct rt2x00_dev *rt2x00dev); 201 202int rt2x00queue_initialize(struct rt2x00_dev *rt2x00dev); 203void rt2x00queue_uninitialize(struct rt2x00_dev *rt2x00dev); 204int rt2x00queue_allocate(struct rt2x00_dev *rt2x00dev); 205void rt2x00queue_free(struct rt2x00_dev *rt2x00dev); 206 207/** 208 * rt2x00link_update_stats - Update link statistics from RX frame 209 * @rt2x00dev: Pointer to &struct rt2x00_dev. 210 * @skb: Received frame 211 * @rxdesc: Received frame descriptor 212 * 213 * Update link statistics based on the information from the 214 * received frame descriptor. 215 */ 216void rt2x00link_update_stats(struct rt2x00_dev *rt2x00dev, 217 struct sk_buff *skb, 218 struct rxdone_entry_desc *rxdesc); 219 220/** 221 * rt2x00link_start_tuner - Start periodic link tuner work 222 * @rt2x00dev: Pointer to &struct rt2x00_dev. 223 * 224 * This start the link tuner periodic work, this work will 225 * be executed periodically until &rt2x00link_stop_tuner has 226 * been called. 227 */ 228void rt2x00link_start_tuner(struct rt2x00_dev *rt2x00dev); 229 230/** 231 * rt2x00link_stop_tuner - Stop periodic link tuner work 232 * @rt2x00dev: Pointer to &struct rt2x00_dev. 233 * 234 * After this function completed the link tuner will not 235 * be running until &rt2x00link_start_tuner is called. 236 */ 237void rt2x00link_stop_tuner(struct rt2x00_dev *rt2x00dev); 238 239/** 240 * rt2x00link_reset_tuner - Reset periodic link tuner work 241 * @rt2x00dev: Pointer to &struct rt2x00_dev. 242 * @antenna: Should the antenna tuning also be reset 243 * 244 * The VGC limit configured in the hardware will be reset to 0 245 * which forces the driver to rediscover the correct value for 246 * the current association. This is needed when configuration 247 * options have changed which could drastically change the 248 * SNR level or link quality (i.e. changing the antenna setting). 249 * 250 * Resetting the link tuner will also cause the periodic work counter 251 * to be reset. Any driver which has a fixed limit on the number 252 * of rounds the link tuner is supposed to work will accept the 253 * tuner actions again if this limit was previously reached. 254 * 255 * If @antenna is set to true a the software antenna diversity 256 * tuning will also be reset. 257 */ 258void rt2x00link_reset_tuner(struct rt2x00_dev *rt2x00dev, bool antenna); 259 260/** 261 * rt2x00link_start_watchdog - Start periodic watchdog monitoring 262 * @rt2x00dev: Pointer to &struct rt2x00_dev. 263 * 264 * This start the watchdog periodic work, this work will 265 *be executed periodically until &rt2x00link_stop_watchdog has 266 * been called. 267 */ 268void rt2x00link_start_watchdog(struct rt2x00_dev *rt2x00dev); 269 270/** 271 * rt2x00link_stop_watchdog - Stop periodic watchdog monitoring 272 * @rt2x00dev: Pointer to &struct rt2x00_dev. 273 * 274 * After this function completed the watchdog monitoring will not 275 * be running until &rt2x00link_start_watchdog is called. 276 */ 277void rt2x00link_stop_watchdog(struct rt2x00_dev *rt2x00dev); 278 279/** 280 * rt2x00link_register - Initialize link tuning & watchdog functionality 281 * @rt2x00dev: Pointer to &struct rt2x00_dev. 282 * 283 * Initialize work structure and all link tuning and watchdog related 284 * parameters. This will not start the periodic work itself. 285 */ 286void rt2x00link_register(struct rt2x00_dev *rt2x00dev); 287 288/* 289 * Firmware handlers. 290 */ 291#ifdef CONFIG_RT2X00_LIB_FIRMWARE 292int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev); 293void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev); 294#else 295static inline int rt2x00lib_load_firmware(struct rt2x00_dev *rt2x00dev) 296{ 297 return 0; 298} 299static inline void rt2x00lib_free_firmware(struct rt2x00_dev *rt2x00dev) 300{ 301} 302#endif /* CONFIG_RT2X00_LIB_FIRMWARE */ 303 304/* 305 * Debugfs handlers. 306 */ 307#ifdef CONFIG_RT2X00_LIB_DEBUGFS 308void rt2x00debug_register(struct rt2x00_dev *rt2x00dev); 309void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev); 310void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev, 311 struct rxdone_entry_desc *rxdesc); 312#else 313static inline void rt2x00debug_register(struct rt2x00_dev *rt2x00dev) 314{ 315} 316 317static inline void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev) 318{ 319} 320 321static inline void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev, 322 struct rxdone_entry_desc *rxdesc) 323{ 324} 325#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 326 327/* 328 * Crypto handlers. 329 */ 330#ifdef CONFIG_RT2X00_LIB_CRYPTO 331enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key); 332void rt2x00crypto_create_tx_descriptor(struct queue_entry *entry, 333 struct txentry_desc *txdesc); 334unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev, 335 struct sk_buff *skb); 336void rt2x00crypto_tx_copy_iv(struct sk_buff *skb, 337 struct txentry_desc *txdesc); 338void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, 339 struct txentry_desc *txdesc); 340void rt2x00crypto_tx_insert_iv(struct sk_buff *skb, unsigned int header_length); 341void rt2x00crypto_rx_insert_iv(struct sk_buff *skb, 342 unsigned int header_length, 343 struct rxdone_entry_desc *rxdesc); 344#else 345static inline enum cipher rt2x00crypto_key_to_cipher(struct ieee80211_key_conf *key) 346{ 347 return CIPHER_NONE; 348} 349 350static inline void rt2x00crypto_create_tx_descriptor(struct queue_entry *entry, 351 struct txentry_desc *txdesc) 352{ 353} 354 355static inline unsigned int rt2x00crypto_tx_overhead(struct rt2x00_dev *rt2x00dev, 356 struct sk_buff *skb) 357{ 358 return 0; 359} 360 361static inline void rt2x00crypto_tx_copy_iv(struct sk_buff *skb, 362 struct txentry_desc *txdesc) 363{ 364} 365 366static inline void rt2x00crypto_tx_remove_iv(struct sk_buff *skb, 367 struct txentry_desc *txdesc) 368{ 369} 370 371static inline void rt2x00crypto_tx_insert_iv(struct sk_buff *skb, 372 unsigned int header_length) 373{ 374} 375 376static inline void rt2x00crypto_rx_insert_iv(struct sk_buff *skb, 377 unsigned int header_length, 378 struct rxdone_entry_desc *rxdesc) 379{ 380} 381#endif /* CONFIG_RT2X00_LIB_CRYPTO */ 382 383/* 384 * HT handlers. 385 */ 386#ifdef CONFIG_RT2X00_LIB_HT 387void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 388 struct txentry_desc *txdesc, 389 const struct rt2x00_rate *hwrate); 390 391u16 rt2x00ht_center_channel(struct rt2x00_dev *rt2x00dev, 392 struct ieee80211_conf *conf); 393#else 394static inline void rt2x00ht_create_tx_descriptor(struct queue_entry *entry, 395 struct txentry_desc *txdesc, 396 const struct rt2x00_rate *hwrate) 397{ 398} 399 400static inline u16 rt2x00ht_center_channel(struct rt2x00_dev *rt2x00dev, 401 struct ieee80211_conf *conf) 402{ 403 return conf->channel->hw_value; 404} 405#endif /* CONFIG_RT2X00_LIB_HT */ 406 407/* 408 * RFkill handlers. 409 */ 410static inline void rt2x00rfkill_register(struct rt2x00_dev *rt2x00dev) 411{ 412 if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags)) 413 wiphy_rfkill_start_polling(rt2x00dev->hw->wiphy); 414} 415 416static inline void rt2x00rfkill_unregister(struct rt2x00_dev *rt2x00dev) 417{ 418 if (test_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags)) 419 wiphy_rfkill_stop_polling(rt2x00dev->hw->wiphy); 420} 421 422/* 423 * LED handlers 424 */ 425#ifdef CONFIG_RT2X00_LIB_LEDS 426void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi); 427void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled); 428void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled); 429void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled); 430void rt2x00leds_register(struct rt2x00_dev *rt2x00dev); 431void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev); 432void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev); 433void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev); 434#else 435static inline void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, 436 int rssi) 437{ 438} 439 440static inline void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, 441 bool enabled) 442{ 443} 444 445static inline void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, 446 bool enabled) 447{ 448} 449 450static inline void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, 451 bool enabled) 452{ 453} 454 455static inline void rt2x00leds_register(struct rt2x00_dev *rt2x00dev) 456{ 457} 458 459static inline void rt2x00leds_unregister(struct rt2x00_dev *rt2x00dev) 460{ 461} 462 463static inline void rt2x00leds_suspend(struct rt2x00_dev *rt2x00dev) 464{ 465} 466 467static inline void rt2x00leds_resume(struct rt2x00_dev *rt2x00dev) 468{ 469} 470#endif /* CONFIG_RT2X00_LIB_LEDS */ 471 472#endif /* RT2X00LIB_H */ 473