4df39eb9115f3b4fa0eb54da5a030b4b95acf842
[safe/jmp/linux-2.6] / include / net / mac80211.h
1 /*
2  * mac80211 <-> driver interface
3  *
4  * Copyright 2002-2005, Devicescape Software, Inc.
5  * Copyright 2006-2007  Jiri Benc <jbenc@suse.cz>
6  * Copyright 2007       Johannes Berg <johannes@sipsolutions.net>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #ifndef MAC80211_H
14 #define MAC80211_H
15
16 #include <linux/kernel.h>
17 #include <linux/if_ether.h>
18 #include <linux/skbuff.h>
19 #include <linux/wireless.h>
20 #include <linux/device.h>
21 #include <linux/ieee80211.h>
22 #include <net/wireless.h>
23 #include <net/cfg80211.h>
24
25 /**
26  * DOC: Introduction
27  *
28  * mac80211 is the Linux stack for 802.11 hardware that implements
29  * only partial functionality in hard- or firmware. This document
30  * defines the interface between mac80211 and low-level hardware
31  * drivers.
32  */
33
34 /**
35  * DOC: Calling mac80211 from interrupts
36  *
37  * Only ieee80211_tx_status_irqsafe() and ieee80211_rx_irqsafe() can be
38  * called in hardware interrupt context. The low-level driver must not call any
39  * other functions in hardware interrupt context. If there is a need for such
40  * call, the low-level driver should first ACK the interrupt and perform the
41  * IEEE 802.11 code call after this, e.g. from a scheduled workqueue or even
42  * tasklet function.
43  *
44  * NOTE: If the driver opts to use the _irqsafe() functions, it may not also
45  *       use the non-irqsafe functions!
46  */
47
48 /**
49  * DOC: Warning
50  *
51  * If you're reading this document and not the header file itself, it will
52  * be incomplete because not all documentation has been converted yet.
53  */
54
55 /**
56  * DOC: Frame format
57  *
58  * As a general rule, when frames are passed between mac80211 and the driver,
59  * they start with the IEEE 802.11 header and include the same octets that are
60  * sent over the air except for the FCS which should be calculated by the
61  * hardware.
62  *
63  * There are, however, various exceptions to this rule for advanced features:
64  *
65  * The first exception is for hardware encryption and decryption offload
66  * where the IV/ICV may or may not be generated in hardware.
67  *
68  * Secondly, when the hardware handles fragmentation, the frame handed to
69  * the driver from mac80211 is the MSDU, not the MPDU.
70  *
71  * Finally, for received frames, the driver is able to indicate that it has
72  * filled a radiotap header and put that in front of the frame; if it does
73  * not do so then mac80211 may add this under certain circumstances.
74  */
75
76 /**
77  * enum ieee80211_notification_type - Low level driver notification
78  * @IEEE80211_NOTIFY_RE_ASSOC: start the re-association sequence
79  */
80 enum ieee80211_notification_types {
81         IEEE80211_NOTIFY_RE_ASSOC,
82 };
83
84 /**
85  * struct ieee80211_ht_bss_info - describing BSS's HT characteristics
86  *
87  * This structure describes most essential parameters needed
88  * to describe 802.11n HT characteristics in a BSS
89  *
90  * @primary_channel: channel number of primery channel
91  * @bss_cap: 802.11n's general BSS capabilities (e.g. channel width)
92  * @bss_op_mode: 802.11n's BSS operation modes (e.g. HT protection)
93  */
94 struct ieee80211_ht_bss_info {
95         u8 primary_channel;
96         u8 bss_cap;  /* use IEEE80211_HT_IE_CHA_ */
97         u8 bss_op_mode; /* use IEEE80211_HT_IE_ */
98 };
99
100 /**
101  * enum ieee80211_max_queues - maximum number of queues
102  *
103  * @IEEE80211_MAX_QUEUES: Maximum number of regular device queues.
104  * @IEEE80211_MAX_AMPDU_QUEUES: Maximum number of queues usable
105  *      for A-MPDU operation.
106  */
107 enum ieee80211_max_queues {
108         IEEE80211_MAX_QUEUES =          16,
109         IEEE80211_MAX_AMPDU_QUEUES =    16,
110 };
111
112 /**
113  * struct ieee80211_tx_queue_params - transmit queue configuration
114  *
115  * The information provided in this structure is required for QoS
116  * transmit queue configuration. Cf. IEEE 802.11 7.3.2.29.
117  *
118  * @aifs: arbitration interface space [0..255, -1: use default]
119  * @cw_min: minimum contention window [will be a value of the form
120  *      2^n-1 in the range 1..1023; 0: use default]
121  * @cw_max: maximum contention window [like @cw_min]
122  * @txop: maximum burst time in units of 32 usecs, 0 meaning disabled
123  */
124 struct ieee80211_tx_queue_params {
125         s16 aifs;
126         u16 cw_min;
127         u16 cw_max;
128         u16 txop;
129 };
130
131 /**
132  * struct ieee80211_tx_queue_stats - transmit queue statistics
133  *
134  * @len: number of packets in queue
135  * @limit: queue length limit
136  * @count: number of frames sent
137  */
138 struct ieee80211_tx_queue_stats {
139         unsigned int len;
140         unsigned int limit;
141         unsigned int count;
142 };
143
144 struct ieee80211_low_level_stats {
145         unsigned int dot11ACKFailureCount;
146         unsigned int dot11RTSFailureCount;
147         unsigned int dot11FCSErrorCount;
148         unsigned int dot11RTSSuccessCount;
149 };
150
151 /**
152  * enum ieee80211_bss_change - BSS change notification flags
153  *
154  * These flags are used with the bss_info_changed() callback
155  * to indicate which BSS parameter changed.
156  *
157  * @BSS_CHANGED_ASSOC: association status changed (associated/disassociated),
158  *      also implies a change in the AID.
159  * @BSS_CHANGED_ERP_CTS_PROT: CTS protection changed
160  * @BSS_CHANGED_ERP_PREAMBLE: preamble changed
161  * @BSS_CHANGED_HT: 802.11n parameters changed
162  */
163 enum ieee80211_bss_change {
164         BSS_CHANGED_ASSOC               = 1<<0,
165         BSS_CHANGED_ERP_CTS_PROT        = 1<<1,
166         BSS_CHANGED_ERP_PREAMBLE        = 1<<2,
167         BSS_CHANGED_HT                  = 1<<4,
168 };
169
170 /**
171  * struct ieee80211_bss_conf - holds the BSS's changing parameters
172  *
173  * This structure keeps information about a BSS (and an association
174  * to that BSS) that can change during the lifetime of the BSS.
175  *
176  * @assoc: association status
177  * @aid: association ID number, valid only when @assoc is true
178  * @use_cts_prot: use CTS protection
179  * @use_short_preamble: use 802.11b short preamble
180  * @timestamp: beacon timestamp
181  * @beacon_int: beacon interval
182  * @assoc_capability: capabbilities taken from assoc resp
183  * @assoc_ht: association in HT mode
184  * @ht_conf: ht capabilities
185  * @ht_bss_conf: ht extended capabilities
186  */
187 struct ieee80211_bss_conf {
188         /* association related data */
189         bool assoc;
190         u16 aid;
191         /* erp related data */
192         bool use_cts_prot;
193         bool use_short_preamble;
194         u16 beacon_int;
195         u16 assoc_capability;
196         u64 timestamp;
197         /* ht related data */
198         bool assoc_ht;
199         struct ieee80211_ht_info *ht_conf;
200         struct ieee80211_ht_bss_info *ht_bss_conf;
201 };
202
203 /**
204  * enum mac80211_tx_flags - flags to transmission information/status
205  *
206  * These flags are used with the @flags member of &ieee80211_tx_info
207  *
208  * @IEEE80211_TX_CTL_REQ_TX_STATUS: request TX status callback for this frame.
209  * @IEEE80211_TX_CTL_DO_NOT_ENCRYPT: send this frame without encryption;
210  *      e.g., for EAPOL frame
211  * @IEEE80211_TX_CTL_USE_RTS_CTS: use RTS-CTS before sending frame
212  * @IEEE80211_TX_CTL_USE_CTS_PROTECT: use CTS protection for the frame (e.g.,
213  *      for combined 802.11g / 802.11b networks)
214  * @IEEE80211_TX_CTL_NO_ACK: tell the low level not to wait for an ack
215  * @IEEE80211_TX_CTL_RATE_CTRL_PROBE
216  * @IEEE80211_TX_CTL_CLEAR_PS_FILT: clear powersave filter for destination
217  *      station
218  * @IEEE80211_TX_CTL_REQUEUE:
219  * @IEEE80211_TX_CTL_FIRST_FRAGMENT: this is a first fragment of the frame
220  * @IEEE80211_TX_CTL_LONG_RETRY_LIMIT: this frame should be send using the
221  *      through set_retry_limit configured long retry value
222  * @IEEE80211_TX_CTL_EAPOL_FRAME: internal to mac80211
223  * @IEEE80211_TX_CTL_SEND_AFTER_DTIM: send this frame after DTIM beacon
224  * @IEEE80211_TX_CTL_AMPDU: this frame should be sent as part of an A-MPDU
225  * @IEEE80211_TX_CTL_OFDM_HT: this frame can be sent in HT OFDM rates. number
226  *      of streams when this flag is on can be extracted from antenna_sel_tx,
227  *      so if 1 antenna is marked use SISO, 2 antennas marked use MIMO, n
228  *      antennas marked use MIMO_n.
229  * @IEEE80211_TX_CTL_GREEN_FIELD: use green field protection for this frame
230  * @IEEE80211_TX_CTL_40_MHZ_WIDTH: send this frame using 40 Mhz channel width
231  * @IEEE80211_TX_CTL_DUP_DATA: duplicate data frame on both 20 Mhz channels
232  * @IEEE80211_TX_CTL_SHORT_GI: send this frame using short guard interval
233  * @IEEE80211_TX_STAT_TX_FILTERED: The frame was not transmitted
234  *      because the destination STA was in powersave mode.
235  * @IEEE80211_TX_STAT_ACK: Frame was acknowledged
236  * @IEEE80211_TX_STAT_AMPDU: The frame was aggregated, so status
237  *      is for the whole aggregation.
238  */
239 enum mac80211_tx_control_flags {
240         IEEE80211_TX_CTL_REQ_TX_STATUS          = BIT(0),
241         IEEE80211_TX_CTL_DO_NOT_ENCRYPT         = BIT(1),
242         IEEE80211_TX_CTL_USE_RTS_CTS            = BIT(2),
243         IEEE80211_TX_CTL_USE_CTS_PROTECT        = BIT(3),
244         IEEE80211_TX_CTL_NO_ACK                 = BIT(4),
245         IEEE80211_TX_CTL_RATE_CTRL_PROBE        = BIT(5),
246         IEEE80211_TX_CTL_CLEAR_PS_FILT          = BIT(6),
247         IEEE80211_TX_CTL_REQUEUE                = BIT(7),
248         IEEE80211_TX_CTL_FIRST_FRAGMENT         = BIT(8),
249         IEEE80211_TX_CTL_SHORT_PREAMBLE         = BIT(9),
250         IEEE80211_TX_CTL_LONG_RETRY_LIMIT       = BIT(10),
251         IEEE80211_TX_CTL_EAPOL_FRAME            = BIT(11),
252         IEEE80211_TX_CTL_SEND_AFTER_DTIM        = BIT(12),
253         IEEE80211_TX_CTL_AMPDU                  = BIT(13),
254         IEEE80211_TX_CTL_OFDM_HT                = BIT(14),
255         IEEE80211_TX_CTL_GREEN_FIELD            = BIT(15),
256         IEEE80211_TX_CTL_40_MHZ_WIDTH           = BIT(16),
257         IEEE80211_TX_CTL_DUP_DATA               = BIT(17),
258         IEEE80211_TX_CTL_SHORT_GI               = BIT(18),
259         IEEE80211_TX_CTL_INJECTED               = BIT(19),
260         IEEE80211_TX_STAT_TX_FILTERED           = BIT(20),
261         IEEE80211_TX_STAT_ACK                   = BIT(21),
262         IEEE80211_TX_STAT_AMPDU                 = BIT(22),
263 };
264
265
266 #define IEEE80211_TX_INFO_DRIVER_DATA_SIZE \
267         (sizeof(((struct sk_buff *)0)->cb) - 8)
268 #define IEEE80211_TX_INFO_DRIVER_DATA_PTRS \
269         (IEEE80211_TX_INFO_DRIVER_DATA_SIZE / sizeof(void *))
270
271 /**
272  * struct ieee80211_tx_info - skb transmit information
273  *
274  * This structure is placed in skb->cb for three uses:
275  *  (1) mac80211 TX control - mac80211 tells the driver what to do
276  *  (2) driver internal use (if applicable)
277  *  (3) TX status information - driver tells mac80211 what happened
278  *
279  * @flags: transmit info flags, defined above
280  * @retry_count: number of retries
281  * @excessive_retries: set to 1 if the frame was retried many times
282  *      but not acknowledged
283  * @ampdu_ack_len: number of aggregated frames.
284  *      relevant only if IEEE80211_TX_STATUS_AMPDU was set.
285  * @ampdu_ack_map: block ack bit map for the aggregation.
286  *      relevant only if IEEE80211_TX_STATUS_AMPDU was set.
287  * @ack_signal: signal strength of the ACK frame
288  */
289 struct ieee80211_tx_info {
290         /* common information */
291         u32 flags;
292         u8 band;
293         s8 tx_rate_idx;
294         u8 antenna_sel_tx;
295
296         u8 queue; /* use skb_queue_mapping soon */
297
298         union {
299                 struct {
300                         struct ieee80211_vif *vif;
301                         struct ieee80211_key_conf *hw_key;
302                         unsigned long jiffies;
303                         int ifindex;
304                         u16 aid;
305                         s8 rts_cts_rate_idx, alt_retry_rate_idx;
306                         u8 retry_limit;
307                         u8 icv_len;
308                         u8 iv_len;
309                 } control;
310                 struct {
311                         u64 ampdu_ack_map;
312                         int ack_signal;
313                         u8 retry_count;
314                         bool excessive_retries;
315                         u8 ampdu_ack_len;
316                 } status;
317                 void *driver_data[IEEE80211_TX_INFO_DRIVER_DATA_PTRS];
318         };
319 };
320
321 static inline struct ieee80211_tx_info *IEEE80211_SKB_CB(struct sk_buff *skb)
322 {
323         return (struct ieee80211_tx_info *)skb->cb;
324 }
325
326
327 /**
328  * enum mac80211_rx_flags - receive flags
329  *
330  * These flags are used with the @flag member of &struct ieee80211_rx_status.
331  * @RX_FLAG_MMIC_ERROR: Michael MIC error was reported on this frame.
332  *      Use together with %RX_FLAG_MMIC_STRIPPED.
333  * @RX_FLAG_DECRYPTED: This frame was decrypted in hardware.
334  * @RX_FLAG_RADIOTAP: This frame starts with a radiotap header.
335  * @RX_FLAG_MMIC_STRIPPED: the Michael MIC is stripped off this frame,
336  *      verification has been done by the hardware.
337  * @RX_FLAG_IV_STRIPPED: The IV/ICV are stripped from this frame.
338  *      If this flag is set, the stack cannot do any replay detection
339  *      hence the driver or hardware will have to do that.
340  * @RX_FLAG_FAILED_FCS_CRC: Set this flag if the FCS check failed on
341  *      the frame.
342  * @RX_FLAG_FAILED_PLCP_CRC: Set this flag if the PCLP check failed on
343  *      the frame.
344  * @RX_FLAG_TSFT: The timestamp passed in the RX status (@mactime field)
345  *      is valid. This is useful in monitor mode and necessary for beacon frames
346  *      to enable IBSS merging.
347  */
348 enum mac80211_rx_flags {
349         RX_FLAG_MMIC_ERROR      = 1<<0,
350         RX_FLAG_DECRYPTED       = 1<<1,
351         RX_FLAG_RADIOTAP        = 1<<2,
352         RX_FLAG_MMIC_STRIPPED   = 1<<3,
353         RX_FLAG_IV_STRIPPED     = 1<<4,
354         RX_FLAG_FAILED_FCS_CRC  = 1<<5,
355         RX_FLAG_FAILED_PLCP_CRC = 1<<6,
356         RX_FLAG_TSFT            = 1<<7,
357 };
358
359 /**
360  * struct ieee80211_rx_status - receive status
361  *
362  * The low-level driver should provide this information (the subset
363  * supported by hardware) to the 802.11 code with each received
364  * frame.
365  *
366  * @mactime: value in microseconds of the 64-bit Time Synchronization Function
367  *      (TSF) timer when the first data symbol (MPDU) arrived at the hardware.
368  * @band: the active band when this frame was received
369  * @freq: frequency the radio was tuned to when receiving this frame, in MHz
370  * @signal: signal strength when receiving this frame, either in dBm, in dB or
371  *      unspecified depending on the hardware capabilities flags
372  *      @IEEE80211_HW_SIGNAL_*
373  * @noise: noise when receiving this frame, in dBm.
374  * @qual: overall signal quality indication, in percent (0-100).
375  * @antenna: antenna used
376  * @rate_idx: index of data rate into band's supported rates
377  * @flag: %RX_FLAG_*
378  */
379 struct ieee80211_rx_status {
380         u64 mactime;
381         enum ieee80211_band band;
382         int freq;
383         int signal;
384         int noise;
385         int qual;
386         int antenna;
387         int rate_idx;
388         int flag;
389 };
390
391 /**
392  * enum ieee80211_conf_flags - configuration flags
393  *
394  * Flags to define PHY configuration options
395  *
396  * @IEEE80211_CONF_SHORT_SLOT_TIME: use 802.11g short slot time
397  * @IEEE80211_CONF_RADIOTAP: add radiotap header at receive time (if supported)
398  * @IEEE80211_CONF_SUPPORT_HT_MODE: use 802.11n HT capabilities (if supported)
399  */
400 enum ieee80211_conf_flags {
401         IEEE80211_CONF_SHORT_SLOT_TIME  = (1<<0),
402         IEEE80211_CONF_RADIOTAP         = (1<<1),
403         IEEE80211_CONF_SUPPORT_HT_MODE  = (1<<2),
404 };
405
406 /**
407  * struct ieee80211_conf - configuration of the device
408  *
409  * This struct indicates how the driver shall configure the hardware.
410  *
411  * @radio_enabled: when zero, driver is required to switch off the radio.
412  *      TODO make a flag
413  * @beacon_int: beacon interval (TODO make interface config)
414  * @flags: configuration flags defined above
415  * @power_level: requested transmit power (in dBm)
416  * @max_antenna_gain: maximum antenna gain (in dBi)
417  * @antenna_sel_tx: transmit antenna selection, 0: default/diversity,
418  *      1/2: antenna 0/1
419  * @antenna_sel_rx: receive antenna selection, like @antenna_sel_tx
420  * @ht_conf: describes current self configuration of 802.11n HT capabilies
421  * @ht_bss_conf: describes current BSS configuration of 802.11n HT parameters
422  * @channel: the channel to tune to
423  */
424 struct ieee80211_conf {
425         int radio_enabled;
426
427         int beacon_int;
428         u32 flags;
429         int power_level;
430         int max_antenna_gain;
431         u8 antenna_sel_tx;
432         u8 antenna_sel_rx;
433
434         struct ieee80211_channel *channel;
435
436         struct ieee80211_ht_info ht_conf;
437         struct ieee80211_ht_bss_info ht_bss_conf;
438 };
439
440 /**
441  * enum ieee80211_if_types - types of 802.11 network interfaces
442  *
443  * @IEEE80211_IF_TYPE_INVALID: invalid interface type, not used
444  *      by mac80211 itself
445  * @IEEE80211_IF_TYPE_AP: interface in AP mode.
446  * @IEEE80211_IF_TYPE_MGMT: special interface for communication with hostap
447  *      daemon. Drivers should never see this type.
448  * @IEEE80211_IF_TYPE_STA: interface in STA (client) mode.
449  * @IEEE80211_IF_TYPE_IBSS: interface in IBSS (ad-hoc) mode.
450  * @IEEE80211_IF_TYPE_MNTR: interface in monitor (rfmon) mode.
451  * @IEEE80211_IF_TYPE_WDS: interface in WDS mode.
452  * @IEEE80211_IF_TYPE_VLAN: VLAN interface bound to an AP, drivers
453  *      will never see this type.
454  * @IEEE80211_IF_TYPE_MESH_POINT: 802.11s mesh point
455  */
456 enum ieee80211_if_types {
457         IEEE80211_IF_TYPE_INVALID,
458         IEEE80211_IF_TYPE_AP,
459         IEEE80211_IF_TYPE_STA,
460         IEEE80211_IF_TYPE_IBSS,
461         IEEE80211_IF_TYPE_MESH_POINT,
462         IEEE80211_IF_TYPE_MNTR,
463         IEEE80211_IF_TYPE_WDS,
464         IEEE80211_IF_TYPE_VLAN,
465 };
466
467 /**
468  * struct ieee80211_vif - per-interface data
469  *
470  * Data in this structure is continually present for driver
471  * use during the life of a virtual interface.
472  *
473  * @type: type of this virtual interface
474  * @drv_priv: data area for driver use, will always be aligned to
475  *      sizeof(void *).
476  */
477 struct ieee80211_vif {
478         enum ieee80211_if_types type;
479         /* must be last */
480         u8 drv_priv[0] __attribute__((__aligned__(sizeof(void *))));
481 };
482
483 static inline bool ieee80211_vif_is_mesh(struct ieee80211_vif *vif)
484 {
485 #ifdef CONFIG_MAC80211_MESH
486         return vif->type == IEEE80211_IF_TYPE_MESH_POINT;
487 #endif
488         return false;
489 }
490
491 /**
492  * struct ieee80211_if_init_conf - initial configuration of an interface
493  *
494  * @vif: pointer to a driver-use per-interface structure. The pointer
495  *      itself is also used for various functions including
496  *      ieee80211_beacon_get() and ieee80211_get_buffered_bc().
497  * @type: one of &enum ieee80211_if_types constants. Determines the type of
498  *      added/removed interface.
499  * @mac_addr: pointer to MAC address of the interface. This pointer is valid
500  *      until the interface is removed (i.e. it cannot be used after
501  *      remove_interface() callback was called for this interface).
502  *
503  * This structure is used in add_interface() and remove_interface()
504  * callbacks of &struct ieee80211_hw.
505  *
506  * When you allow multiple interfaces to be added to your PHY, take care
507  * that the hardware can actually handle multiple MAC addresses. However,
508  * also take care that when there's no interface left with mac_addr != %NULL
509  * you remove the MAC address from the device to avoid acknowledging packets
510  * in pure monitor mode.
511  */
512 struct ieee80211_if_init_conf {
513         enum ieee80211_if_types type;
514         struct ieee80211_vif *vif;
515         void *mac_addr;
516 };
517
518 /**
519  * struct ieee80211_if_conf - configuration of an interface
520  *
521  * @type: type of the interface. This is always the same as was specified in
522  *      &struct ieee80211_if_init_conf. The type of an interface never changes
523  *      during the life of the interface; this field is present only for
524  *      convenience.
525  * @bssid: BSSID of the network we are associated to/creating.
526  * @ssid: used (together with @ssid_len) by drivers for hardware that
527  *      generate beacons independently. The pointer is valid only during the
528  *      config_interface() call, so copy the value somewhere if you need
529  *      it.
530  * @ssid_len: length of the @ssid field.
531  * @beacon: beacon template. Valid only if @host_gen_beacon_template in
532  *      &struct ieee80211_hw is set. The driver is responsible of freeing
533  *      the sk_buff.
534  * @beacon_control: tx_control for the beacon template, this field is only
535  *      valid when the @beacon field was set.
536  *
537  * This structure is passed to the config_interface() callback of
538  * &struct ieee80211_hw.
539  */
540 struct ieee80211_if_conf {
541         int type;
542         u8 *bssid;
543         u8 *ssid;
544         size_t ssid_len;
545         struct sk_buff *beacon;
546 };
547
548 /**
549  * enum ieee80211_key_alg - key algorithm
550  * @ALG_WEP: WEP40 or WEP104
551  * @ALG_TKIP: TKIP
552  * @ALG_CCMP: CCMP (AES)
553  */
554 enum ieee80211_key_alg {
555         ALG_WEP,
556         ALG_TKIP,
557         ALG_CCMP,
558 };
559
560
561 /**
562  * enum ieee80211_key_flags - key flags
563  *
564  * These flags are used for communication about keys between the driver
565  * and mac80211, with the @flags parameter of &struct ieee80211_key_conf.
566  *
567  * @IEEE80211_KEY_FLAG_WMM_STA: Set by mac80211, this flag indicates
568  *      that the STA this key will be used with could be using QoS.
569  * @IEEE80211_KEY_FLAG_GENERATE_IV: This flag should be set by the
570  *      driver to indicate that it requires IV generation for this
571  *      particular key.
572  * @IEEE80211_KEY_FLAG_GENERATE_MMIC: This flag should be set by
573  *      the driver for a TKIP key if it requires Michael MIC
574  *      generation in software.
575  * @IEEE80211_KEY_FLAG_PAIRWISE: Set by mac80211, this flag indicates
576  *      that the key is pairwise rather then a shared key.
577  */
578 enum ieee80211_key_flags {
579         IEEE80211_KEY_FLAG_WMM_STA      = 1<<0,
580         IEEE80211_KEY_FLAG_GENERATE_IV  = 1<<1,
581         IEEE80211_KEY_FLAG_GENERATE_MMIC= 1<<2,
582         IEEE80211_KEY_FLAG_PAIRWISE     = 1<<3,
583 };
584
585 /**
586  * struct ieee80211_key_conf - key information
587  *
588  * This key information is given by mac80211 to the driver by
589  * the set_key() callback in &struct ieee80211_ops.
590  *
591  * @hw_key_idx: To be set by the driver, this is the key index the driver
592  *      wants to be given when a frame is transmitted and needs to be
593  *      encrypted in hardware.
594  * @alg: The key algorithm.
595  * @flags: key flags, see &enum ieee80211_key_flags.
596  * @keyidx: the key index (0-3)
597  * @keylen: key material length
598  * @key: key material
599  */
600 struct ieee80211_key_conf {
601         enum ieee80211_key_alg alg;
602         u8 hw_key_idx;
603         u8 flags;
604         s8 keyidx;
605         u8 keylen;
606         u8 key[0];
607 };
608
609 /**
610  * enum set_key_cmd - key command
611  *
612  * Used with the set_key() callback in &struct ieee80211_ops, this
613  * indicates whether a key is being removed or added.
614  *
615  * @SET_KEY: a key is set
616  * @DISABLE_KEY: a key must be disabled
617  */
618 enum set_key_cmd {
619         SET_KEY, DISABLE_KEY,
620 };
621
622 /**
623  * enum sta_notify_cmd - sta notify command
624  *
625  * Used with the sta_notify() callback in &struct ieee80211_ops, this
626  * indicates addition and removal of a station to station table
627  *
628  * @STA_NOTIFY_ADD: a station was added to the station table
629  * @STA_NOTIFY_REMOVE: a station being removed from the station table
630  */
631 enum sta_notify_cmd {
632         STA_NOTIFY_ADD, STA_NOTIFY_REMOVE
633 };
634
635 /**
636  * enum ieee80211_tkip_key_type - get tkip key
637  *
638  * Used by drivers which need to get a tkip key for skb. Some drivers need a
639  * phase 1 key, others need a phase 2 key. A single function allows the driver
640  * to get the key, this enum indicates what type of key is required.
641  *
642  * @IEEE80211_TKIP_P1_KEY: the driver needs a phase 1 key
643  * @IEEE80211_TKIP_P2_KEY: the driver needs a phase 2 key
644  */
645 enum ieee80211_tkip_key_type {
646         IEEE80211_TKIP_P1_KEY,
647         IEEE80211_TKIP_P2_KEY,
648 };
649
650 /**
651  * enum ieee80211_hw_flags - hardware flags
652  *
653  * These flags are used to indicate hardware capabilities to
654  * the stack. Generally, flags here should have their meaning
655  * done in a way that the simplest hardware doesn't need setting
656  * any particular flags. There are some exceptions to this rule,
657  * however, so you are advised to review these flags carefully.
658  *
659  * @IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE:
660  *      The device only needs to be supplied with a beacon template.
661  *      If you need the host to generate each beacon then don't use
662  *      this flag and call ieee80211_beacon_get() when you need the
663  *      next beacon frame. Note that if you set this flag, you must
664  *      implement the set_tim() callback for powersave mode to work
665  *      properly.
666  *      This flag is only relevant for access-point mode.
667  *
668  * @IEEE80211_HW_RX_INCLUDES_FCS:
669  *      Indicates that received frames passed to the stack include
670  *      the FCS at the end.
671  *
672  * @IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING:
673  *      Some wireless LAN chipsets buffer broadcast/multicast frames
674  *      for power saving stations in the hardware/firmware and others
675  *      rely on the host system for such buffering. This option is used
676  *      to configure the IEEE 802.11 upper layer to buffer broadcast and
677  *      multicast frames when there are power saving stations so that
678  *      the driver can fetch them with ieee80211_get_buffered_bc(). Note
679  *      that not setting this flag works properly only when the
680  *      %IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE is also not set because
681  *      otherwise the stack will not know when the DTIM beacon was sent.
682  *
683  * @IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE:
684  *      Hardware is not capable of short slot operation on the 2.4 GHz band.
685  *
686  * @IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE:
687  *      Hardware is not capable of receiving frames with short preamble on
688  *      the 2.4 GHz band.
689  *
690  * @IEEE80211_HW_SIGNAL_UNSPEC:
691  *      Hardware can provide signal values but we don't know its units. We
692  *      expect values between 0 and @max_signal.
693  *      If possible please provide dB or dBm instead.
694  *
695  * @IEEE80211_HW_SIGNAL_DB:
696  *      Hardware gives signal values in dB, decibel difference from an
697  *      arbitrary, fixed reference. We expect values between 0 and @max_signal.
698  *      If possible please provide dBm instead.
699  *
700  * @IEEE80211_HW_SIGNAL_DBM:
701  *      Hardware gives signal values in dBm, decibel difference from
702  *      one milliwatt. This is the preferred method since it is standardized
703  *      between different devices. @max_signal does not need to be set.
704  *
705  * @IEEE80211_HW_NOISE_DBM:
706  *      Hardware can provide noise (radio interference) values in units dBm,
707  *      decibel difference from one milliwatt.
708  */
709 enum ieee80211_hw_flags {
710         IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE           = 1<<0,
711         IEEE80211_HW_RX_INCLUDES_FCS                    = 1<<1,
712         IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING        = 1<<2,
713         IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE          = 1<<3,
714         IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE      = 1<<4,
715         IEEE80211_HW_SIGNAL_UNSPEC                      = 1<<5,
716         IEEE80211_HW_SIGNAL_DB                          = 1<<6,
717         IEEE80211_HW_SIGNAL_DBM                         = 1<<7,
718         IEEE80211_HW_NOISE_DBM                          = 1<<8,
719 };
720
721 /**
722  * struct ieee80211_hw - hardware information and state
723  *
724  * This structure contains the configuration and hardware
725  * information for an 802.11 PHY.
726  *
727  * @wiphy: This points to the &struct wiphy allocated for this
728  *      802.11 PHY. You must fill in the @perm_addr and @dev
729  *      members of this structure using SET_IEEE80211_DEV()
730  *      and SET_IEEE80211_PERM_ADDR(). Additionally, all supported
731  *      bands (with channels, bitrates) are registered here.
732  *
733  * @conf: &struct ieee80211_conf, device configuration, don't use.
734  *
735  * @workqueue: single threaded workqueue available for driver use,
736  *      allocated by mac80211 on registration and flushed on
737  *      unregistration.
738  *
739  * @priv: pointer to private area that was allocated for driver use
740  *      along with this structure.
741  *
742  * @flags: hardware flags, see &enum ieee80211_hw_flags.
743  *
744  * @extra_tx_headroom: headroom to reserve in each transmit skb
745  *      for use by the driver (e.g. for transmit headers.)
746  *
747  * @channel_change_time: time (in microseconds) it takes to change channels.
748  *
749  * @max_signal: Maximum value for signal (rssi) in RX information, used
750  *     only when @IEEE80211_HW_SIGNAL_UNSPEC or @IEEE80211_HW_SIGNAL_DB
751  *
752  * @queues: number of available hardware transmit queues for
753  *      data packets. WMM/QoS requires at least four, these
754  *      queues need to have configurable access parameters.
755  *
756  * @ampdu_queues: number of available hardware transmit queues
757  *      for A-MPDU packets, these have no access parameters
758  *      because they're used only for A-MPDU frames. Note that
759  *      mac80211 will not currently use any of the regular queues
760  *      for aggregation.
761  *
762  * @rate_control_algorithm: rate control algorithm for this hardware.
763  *      If unset (NULL), the default algorithm will be used. Must be
764  *      set before calling ieee80211_register_hw().
765  *
766  * @vif_data_size: size (in bytes) of the drv_priv data area
767  *      within &struct ieee80211_vif.
768  */
769 struct ieee80211_hw {
770         struct ieee80211_conf conf;
771         struct wiphy *wiphy;
772         struct workqueue_struct *workqueue;
773         const char *rate_control_algorithm;
774         void *priv;
775         u32 flags;
776         unsigned int extra_tx_headroom;
777         int channel_change_time;
778         int vif_data_size;
779         u16 queues, ampdu_queues;
780         s8 max_signal;
781 };
782
783 /**
784  * SET_IEEE80211_DEV - set device for 802.11 hardware
785  *
786  * @hw: the &struct ieee80211_hw to set the device for
787  * @dev: the &struct device of this 802.11 device
788  */
789 static inline void SET_IEEE80211_DEV(struct ieee80211_hw *hw, struct device *dev)
790 {
791         set_wiphy_dev(hw->wiphy, dev);
792 }
793
794 /**
795  * SET_IEEE80211_PERM_ADDR - set the permanenet MAC address for 802.11 hardware
796  *
797  * @hw: the &struct ieee80211_hw to set the MAC address for
798  * @addr: the address to set
799  */
800 static inline void SET_IEEE80211_PERM_ADDR(struct ieee80211_hw *hw, u8 *addr)
801 {
802         memcpy(hw->wiphy->perm_addr, addr, ETH_ALEN);
803 }
804
805 static inline struct ieee80211_rate *
806 ieee80211_get_tx_rate(const struct ieee80211_hw *hw,
807                       const struct ieee80211_tx_info *c)
808 {
809         if (WARN_ON(c->tx_rate_idx < 0))
810                 return NULL;
811         return &hw->wiphy->bands[c->band]->bitrates[c->tx_rate_idx];
812 }
813
814 static inline struct ieee80211_rate *
815 ieee80211_get_rts_cts_rate(const struct ieee80211_hw *hw,
816                            const struct ieee80211_tx_info *c)
817 {
818         if (c->control.rts_cts_rate_idx < 0)
819                 return NULL;
820         return &hw->wiphy->bands[c->band]->bitrates[c->control.rts_cts_rate_idx];
821 }
822
823 static inline struct ieee80211_rate *
824 ieee80211_get_alt_retry_rate(const struct ieee80211_hw *hw,
825                              const struct ieee80211_tx_info *c)
826 {
827         if (c->control.alt_retry_rate_idx < 0)
828                 return NULL;
829         return &hw->wiphy->bands[c->band]->bitrates[c->control.alt_retry_rate_idx];
830 }
831
832 /**
833  * DOC: Hardware crypto acceleration
834  *
835  * mac80211 is capable of taking advantage of many hardware
836  * acceleration designs for encryption and decryption operations.
837  *
838  * The set_key() callback in the &struct ieee80211_ops for a given
839  * device is called to enable hardware acceleration of encryption and
840  * decryption. The callback takes an @address parameter that will be
841  * the broadcast address for default keys, the other station's hardware
842  * address for individual keys or the zero address for keys that will
843  * be used only for transmission.
844  * Multiple transmission keys with the same key index may be used when
845  * VLANs are configured for an access point.
846  *
847  * The @local_address parameter will always be set to our own address,
848  * this is only relevant if you support multiple local addresses.
849  *
850  * When transmitting, the TX control data will use the @hw_key_idx
851  * selected by the driver by modifying the &struct ieee80211_key_conf
852  * pointed to by the @key parameter to the set_key() function.
853  *
854  * The set_key() call for the %SET_KEY command should return 0 if
855  * the key is now in use, -%EOPNOTSUPP or -%ENOSPC if it couldn't be
856  * added; if you return 0 then hw_key_idx must be assigned to the
857  * hardware key index, you are free to use the full u8 range.
858  *
859  * When the cmd is %DISABLE_KEY then it must succeed.
860  *
861  * Note that it is permissible to not decrypt a frame even if a key
862  * for it has been uploaded to hardware, the stack will not make any
863  * decision based on whether a key has been uploaded or not but rather
864  * based on the receive flags.
865  *
866  * The &struct ieee80211_key_conf structure pointed to by the @key
867  * parameter is guaranteed to be valid until another call to set_key()
868  * removes it, but it can only be used as a cookie to differentiate
869  * keys.
870  *
871  * In TKIP some HW need to be provided a phase 1 key, for RX decryption
872  * acceleration (i.e. iwlwifi). Those drivers should provide update_tkip_key
873  * handler.
874  * The update_tkip_key() call updates the driver with the new phase 1 key.
875  * This happens everytime the iv16 wraps around (every 65536 packets). The
876  * set_key() call will happen only once for each key (unless the AP did
877  * rekeying), it will not include a valid phase 1 key. The valid phase 1 key is
878  * provided by udpate_tkip_key only. The trigger that makes mac80211 call this
879  * handler is software decryption with wrap around of iv16.
880  */
881
882 /**
883  * DOC: Frame filtering
884  *
885  * mac80211 requires to see many management frames for proper
886  * operation, and users may want to see many more frames when
887  * in monitor mode. However, for best CPU usage and power consumption,
888  * having as few frames as possible percolate through the stack is
889  * desirable. Hence, the hardware should filter as much as possible.
890  *
891  * To achieve this, mac80211 uses filter flags (see below) to tell
892  * the driver's configure_filter() function which frames should be
893  * passed to mac80211 and which should be filtered out.
894  *
895  * The configure_filter() callback is invoked with the parameters
896  * @mc_count and @mc_list for the combined multicast address list
897  * of all virtual interfaces, @changed_flags telling which flags
898  * were changed and @total_flags with the new flag states.
899  *
900  * If your device has no multicast address filters your driver will
901  * need to check both the %FIF_ALLMULTI flag and the @mc_count
902  * parameter to see whether multicast frames should be accepted
903  * or dropped.
904  *
905  * All unsupported flags in @total_flags must be cleared.
906  * Hardware does not support a flag if it is incapable of _passing_
907  * the frame to the stack. Otherwise the driver must ignore
908  * the flag, but not clear it.
909  * You must _only_ clear the flag (announce no support for the
910  * flag to mac80211) if you are not able to pass the packet type
911  * to the stack (so the hardware always filters it).
912  * So for example, you should clear @FIF_CONTROL, if your hardware
913  * always filters control frames. If your hardware always passes
914  * control frames to the kernel and is incapable of filtering them,
915  * you do _not_ clear the @FIF_CONTROL flag.
916  * This rule applies to all other FIF flags as well.
917  */
918
919 /**
920  * enum ieee80211_filter_flags - hardware filter flags
921  *
922  * These flags determine what the filter in hardware should be
923  * programmed to let through and what should not be passed to the
924  * stack. It is always safe to pass more frames than requested,
925  * but this has negative impact on power consumption.
926  *
927  * @FIF_PROMISC_IN_BSS: promiscuous mode within your BSS,
928  *      think of the BSS as your network segment and then this corresponds
929  *      to the regular ethernet device promiscuous mode.
930  *
931  * @FIF_ALLMULTI: pass all multicast frames, this is used if requested
932  *      by the user or if the hardware is not capable of filtering by
933  *      multicast address.
934  *
935  * @FIF_FCSFAIL: pass frames with failed FCS (but you need to set the
936  *      %RX_FLAG_FAILED_FCS_CRC for them)
937  *
938  * @FIF_PLCPFAIL: pass frames with failed PLCP CRC (but you need to set
939  *      the %RX_FLAG_FAILED_PLCP_CRC for them
940  *
941  * @FIF_BCN_PRBRESP_PROMISC: This flag is set during scanning to indicate
942  *      to the hardware that it should not filter beacons or probe responses
943  *      by BSSID. Filtering them can greatly reduce the amount of processing
944  *      mac80211 needs to do and the amount of CPU wakeups, so you should
945  *      honour this flag if possible.
946  *
947  * @FIF_CONTROL: pass control frames, if PROMISC_IN_BSS is not set then
948  *      only those addressed to this station
949  *
950  * @FIF_OTHER_BSS: pass frames destined to other BSSes
951  */
952 enum ieee80211_filter_flags {
953         FIF_PROMISC_IN_BSS      = 1<<0,
954         FIF_ALLMULTI            = 1<<1,
955         FIF_FCSFAIL             = 1<<2,
956         FIF_PLCPFAIL            = 1<<3,
957         FIF_BCN_PRBRESP_PROMISC = 1<<4,
958         FIF_CONTROL             = 1<<5,
959         FIF_OTHER_BSS           = 1<<6,
960 };
961
962 /**
963  * enum ieee80211_ampdu_mlme_action - A-MPDU actions
964  *
965  * These flags are used with the ampdu_action() callback in
966  * &struct ieee80211_ops to indicate which action is needed.
967  * @IEEE80211_AMPDU_RX_START: start Rx aggregation
968  * @IEEE80211_AMPDU_RX_STOP: stop Rx aggregation
969  * @IEEE80211_AMPDU_TX_START: start Tx aggregation
970  * @IEEE80211_AMPDU_TX_STOP: stop Tx aggregation
971  */
972 enum ieee80211_ampdu_mlme_action {
973         IEEE80211_AMPDU_RX_START,
974         IEEE80211_AMPDU_RX_STOP,
975         IEEE80211_AMPDU_TX_START,
976         IEEE80211_AMPDU_TX_STOP,
977 };
978
979 /**
980  * struct ieee80211_ops - callbacks from mac80211 to the driver
981  *
982  * This structure contains various callbacks that the driver may
983  * handle or, in some cases, must handle, for example to configure
984  * the hardware to a new channel or to transmit a frame.
985  *
986  * @tx: Handler that 802.11 module calls for each transmitted frame.
987  *      skb contains the buffer starting from the IEEE 802.11 header.
988  *      The low-level driver should send the frame out based on
989  *      configuration in the TX control data. This handler should,
990  *      preferably, never fail and stop queues appropriately, more
991  *      importantly, however, it must never fail for A-MPDU-queues.
992  *      Must be implemented and atomic.
993  *
994  * @start: Called before the first netdevice attached to the hardware
995  *      is enabled. This should turn on the hardware and must turn on
996  *      frame reception (for possibly enabled monitor interfaces.)
997  *      Returns negative error codes, these may be seen in userspace,
998  *      or zero.
999  *      When the device is started it should not have a MAC address
1000  *      to avoid acknowledging frames before a non-monitor device
1001  *      is added.
1002  *      Must be implemented.
1003  *
1004  * @stop: Called after last netdevice attached to the hardware
1005  *      is disabled. This should turn off the hardware (at least
1006  *      it must turn off frame reception.)
1007  *      May be called right after add_interface if that rejects
1008  *      an interface.
1009  *      Must be implemented.
1010  *
1011  * @add_interface: Called when a netdevice attached to the hardware is
1012  *      enabled. Because it is not called for monitor mode devices, @open
1013  *      and @stop must be implemented.
1014  *      The driver should perform any initialization it needs before
1015  *      the device can be enabled. The initial configuration for the
1016  *      interface is given in the conf parameter.
1017  *      The callback may refuse to add an interface by returning a
1018  *      negative error code (which will be seen in userspace.)
1019  *      Must be implemented.
1020  *
1021  * @remove_interface: Notifies a driver that an interface is going down.
1022  *      The @stop callback is called after this if it is the last interface
1023  *      and no monitor interfaces are present.
1024  *      When all interfaces are removed, the MAC address in the hardware
1025  *      must be cleared so the device no longer acknowledges packets,
1026  *      the mac_addr member of the conf structure is, however, set to the
1027  *      MAC address of the device going away.
1028  *      Hence, this callback must be implemented.
1029  *
1030  * @config: Handler for configuration requests. IEEE 802.11 code calls this
1031  *      function to change hardware configuration, e.g., channel.
1032  *
1033  * @config_interface: Handler for configuration requests related to interfaces
1034  *      (e.g. BSSID changes.)
1035  *
1036  * @bss_info_changed: Handler for configuration requests related to BSS
1037  *      parameters that may vary during BSS's lifespan, and may affect low
1038  *      level driver (e.g. assoc/disassoc status, erp parameters).
1039  *      This function should not be used if no BSS has been set, unless
1040  *      for association indication. The @changed parameter indicates which
1041  *      of the bss parameters has changed when a call is made.
1042  *
1043  * @configure_filter: Configure the device's RX filter.
1044  *      See the section "Frame filtering" for more information.
1045  *      This callback must be implemented and atomic.
1046  *
1047  * @set_tim: Set TIM bit. If the hardware/firmware takes care of beacon
1048  *      generation (that is, %IEEE80211_HW_HOST_GEN_BEACON_TEMPLATE is set)
1049  *      mac80211 calls this function when a TIM bit must be set or cleared
1050  *      for a given AID. Must be atomic.
1051  *
1052  * @set_key: See the section "Hardware crypto acceleration"
1053  *      This callback can sleep, and is only called between add_interface
1054  *      and remove_interface calls, i.e. while the interface with the
1055  *      given local_address is enabled.
1056  *
1057  * @update_tkip_key: See the section "Hardware crypto acceleration"
1058  *      This callback will be called in the context of Rx. Called for drivers
1059  *      which set IEEE80211_KEY_FLAG_TKIP_REQ_RX_P1_KEY.
1060  *
1061  * @hw_scan: Ask the hardware to service the scan request, no need to start
1062  *      the scan state machine in stack. The scan must honour the channel
1063  *      configuration done by the regulatory agent in the wiphy's registered
1064  *      bands.
1065  *
1066  * @get_stats: return low-level statistics
1067  *
1068  * @get_tkip_seq: If your device implements TKIP encryption in hardware this
1069  *      callback should be provided to read the TKIP transmit IVs (both IV32
1070  *      and IV16) for the given key from hardware.
1071  *
1072  * @set_rts_threshold: Configuration of RTS threshold (if device needs it)
1073  *
1074  * @set_frag_threshold: Configuration of fragmentation threshold. Assign this if
1075  *      the device does fragmentation by itself; if this method is assigned then
1076  *      the stack will not do fragmentation.
1077  *
1078  * @set_retry_limit: Configuration of retry limits (if device needs it)
1079  *
1080  * @sta_notify: Notifies low level driver about addition or removal
1081  *      of assocaited station or AP.
1082  *
1083  * @conf_tx: Configure TX queue parameters (EDCF (aifs, cw_min, cw_max),
1084  *      bursting) for a hardware TX queue. Must be atomic.
1085  *
1086  * @get_tx_stats: Get statistics of the current TX queue status. This is used
1087  *      to get number of currently queued packets (queue length), maximum queue
1088  *      size (limit), and total number of packets sent using each TX queue
1089  *      (count). The 'stats' pointer points to an array that has hw->queues +
1090  *      hw->ampdu_queues items.
1091  *
1092  * @get_tsf: Get the current TSF timer value from firmware/hardware. Currently,
1093  *      this is only used for IBSS mode debugging and, as such, is not a
1094  *      required function. Must be atomic.
1095  *
1096  * @reset_tsf: Reset the TSF timer and allow firmware/hardware to synchronize
1097  *      with other STAs in the IBSS. This is only used in IBSS mode. This
1098  *      function is optional if the firmware/hardware takes full care of
1099  *      TSF synchronization.
1100  *
1101  * @beacon_update: Setup beacon data for IBSS beacons. Unlike access point,
1102  *      IBSS uses a fixed beacon frame which is configured using this
1103  *      function.
1104  *      If the driver returns success (0) from this callback, it owns
1105  *      the skb. That means the driver is responsible to kfree_skb() it.
1106  *      The control structure is not dynamically allocated. That means the
1107  *      driver does not own the pointer and if it needs it somewhere
1108  *      outside of the context of this function, it must copy it
1109  *      somewhere else.
1110  *      This handler is required only for IBSS mode.
1111  *
1112  * @tx_last_beacon: Determine whether the last IBSS beacon was sent by us.
1113  *      This is needed only for IBSS mode and the result of this function is
1114  *      used to determine whether to reply to Probe Requests.
1115  *
1116  * @conf_ht: Configures low level driver with 802.11n HT data. Must be atomic.
1117  *
1118  * @ampdu_action: Perform a certain A-MPDU action
1119  *      The RA/TID combination determines the destination and TID we want
1120  *      the ampdu action to be performed for. The action is defined through
1121  *      ieee80211_ampdu_mlme_action. Starting sequence number (@ssn)
1122  *      is the first frame we expect to perform the action on. notice
1123  *      that TX/RX_STOP can pass NULL for this parameter.
1124  */
1125 struct ieee80211_ops {
1126         int (*tx)(struct ieee80211_hw *hw, struct sk_buff *skb);
1127         int (*start)(struct ieee80211_hw *hw);
1128         void (*stop)(struct ieee80211_hw *hw);
1129         int (*add_interface)(struct ieee80211_hw *hw,
1130                              struct ieee80211_if_init_conf *conf);
1131         void (*remove_interface)(struct ieee80211_hw *hw,
1132                                  struct ieee80211_if_init_conf *conf);
1133         int (*config)(struct ieee80211_hw *hw, struct ieee80211_conf *conf);
1134         int (*config_interface)(struct ieee80211_hw *hw,
1135                                 struct ieee80211_vif *vif,
1136                                 struct ieee80211_if_conf *conf);
1137         void (*bss_info_changed)(struct ieee80211_hw *hw,
1138                                  struct ieee80211_vif *vif,
1139                                  struct ieee80211_bss_conf *info,
1140                                  u32 changed);
1141         void (*configure_filter)(struct ieee80211_hw *hw,
1142                                  unsigned int changed_flags,
1143                                  unsigned int *total_flags,
1144                                  int mc_count, struct dev_addr_list *mc_list);
1145         int (*set_tim)(struct ieee80211_hw *hw, int aid, int set);
1146         int (*set_key)(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1147                        const u8 *local_address, const u8 *address,
1148                        struct ieee80211_key_conf *key);
1149         void (*update_tkip_key)(struct ieee80211_hw *hw,
1150                         struct ieee80211_key_conf *conf, const u8 *address,
1151                         u32 iv32, u16 *phase1key);
1152         int (*hw_scan)(struct ieee80211_hw *hw, u8 *ssid, size_t len);
1153         int (*get_stats)(struct ieee80211_hw *hw,
1154                          struct ieee80211_low_level_stats *stats);
1155         void (*get_tkip_seq)(struct ieee80211_hw *hw, u8 hw_key_idx,
1156                              u32 *iv32, u16 *iv16);
1157         int (*set_rts_threshold)(struct ieee80211_hw *hw, u32 value);
1158         int (*set_frag_threshold)(struct ieee80211_hw *hw, u32 value);
1159         int (*set_retry_limit)(struct ieee80211_hw *hw,
1160                                u32 short_retry, u32 long_retr);
1161         void (*sta_notify)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1162                         enum sta_notify_cmd, const u8 *addr);
1163         int (*conf_tx)(struct ieee80211_hw *hw, u16 queue,
1164                        const struct ieee80211_tx_queue_params *params);
1165         int (*get_tx_stats)(struct ieee80211_hw *hw,
1166                             struct ieee80211_tx_queue_stats *stats);
1167         u64 (*get_tsf)(struct ieee80211_hw *hw);
1168         void (*reset_tsf)(struct ieee80211_hw *hw);
1169         int (*beacon_update)(struct ieee80211_hw *hw,
1170                              struct sk_buff *skb);
1171         int (*tx_last_beacon)(struct ieee80211_hw *hw);
1172         int (*ampdu_action)(struct ieee80211_hw *hw,
1173                             enum ieee80211_ampdu_mlme_action action,
1174                             const u8 *addr, u16 tid, u16 *ssn);
1175 };
1176
1177 /**
1178  * ieee80211_alloc_hw -  Allocate a new hardware device
1179  *
1180  * This must be called once for each hardware device. The returned pointer
1181  * must be used to refer to this device when calling other functions.
1182  * mac80211 allocates a private data area for the driver pointed to by
1183  * @priv in &struct ieee80211_hw, the size of this area is given as
1184  * @priv_data_len.
1185  *
1186  * @priv_data_len: length of private data
1187  * @ops: callbacks for this device
1188  */
1189 struct ieee80211_hw *ieee80211_alloc_hw(size_t priv_data_len,
1190                                         const struct ieee80211_ops *ops);
1191
1192 /**
1193  * ieee80211_register_hw - Register hardware device
1194  *
1195  * You must call this function before any other functions in
1196  * mac80211. Note that before a hardware can be registered, you
1197  * need to fill the contained wiphy's information.
1198  *
1199  * @hw: the device to register as returned by ieee80211_alloc_hw()
1200  */
1201 int ieee80211_register_hw(struct ieee80211_hw *hw);
1202
1203 #ifdef CONFIG_MAC80211_LEDS
1204 extern char *__ieee80211_get_tx_led_name(struct ieee80211_hw *hw);
1205 extern char *__ieee80211_get_rx_led_name(struct ieee80211_hw *hw);
1206 extern char *__ieee80211_get_assoc_led_name(struct ieee80211_hw *hw);
1207 extern char *__ieee80211_get_radio_led_name(struct ieee80211_hw *hw);
1208 #endif
1209 /**
1210  * ieee80211_get_tx_led_name - get name of TX LED
1211  *
1212  * mac80211 creates a transmit LED trigger for each wireless hardware
1213  * that can be used to drive LEDs if your driver registers a LED device.
1214  * This function returns the name (or %NULL if not configured for LEDs)
1215  * of the trigger so you can automatically link the LED device.
1216  *
1217  * @hw: the hardware to get the LED trigger name for
1218  */
1219 static inline char *ieee80211_get_tx_led_name(struct ieee80211_hw *hw)
1220 {
1221 #ifdef CONFIG_MAC80211_LEDS
1222         return __ieee80211_get_tx_led_name(hw);
1223 #else
1224         return NULL;
1225 #endif
1226 }
1227
1228 /**
1229  * ieee80211_get_rx_led_name - get name of RX LED
1230  *
1231  * mac80211 creates a receive LED trigger for each wireless hardware
1232  * that can be used to drive LEDs if your driver registers a LED device.
1233  * This function returns the name (or %NULL if not configured for LEDs)
1234  * of the trigger so you can automatically link the LED device.
1235  *
1236  * @hw: the hardware to get the LED trigger name for
1237  */
1238 static inline char *ieee80211_get_rx_led_name(struct ieee80211_hw *hw)
1239 {
1240 #ifdef CONFIG_MAC80211_LEDS
1241         return __ieee80211_get_rx_led_name(hw);
1242 #else
1243         return NULL;
1244 #endif
1245 }
1246
1247 /**
1248  * ieee80211_get_assoc_led_name - get name of association LED
1249  *
1250  * mac80211 creates a association LED trigger for each wireless hardware
1251  * that can be used to drive LEDs if your driver registers a LED device.
1252  * This function returns the name (or %NULL if not configured for LEDs)
1253  * of the trigger so you can automatically link the LED device.
1254  *
1255  * @hw: the hardware to get the LED trigger name for
1256  */
1257 static inline char *ieee80211_get_assoc_led_name(struct ieee80211_hw *hw)
1258 {
1259 #ifdef CONFIG_MAC80211_LEDS
1260         return __ieee80211_get_assoc_led_name(hw);
1261 #else
1262         return NULL;
1263 #endif
1264 }
1265
1266 /**
1267  * ieee80211_get_radio_led_name - get name of radio LED
1268  *
1269  * mac80211 creates a radio change LED trigger for each wireless hardware
1270  * that can be used to drive LEDs if your driver registers a LED device.
1271  * This function returns the name (or %NULL if not configured for LEDs)
1272  * of the trigger so you can automatically link the LED device.
1273  *
1274  * @hw: the hardware to get the LED trigger name for
1275  */
1276 static inline char *ieee80211_get_radio_led_name(struct ieee80211_hw *hw)
1277 {
1278 #ifdef CONFIG_MAC80211_LEDS
1279         return __ieee80211_get_radio_led_name(hw);
1280 #else
1281         return NULL;
1282 #endif
1283 }
1284
1285 /**
1286  * ieee80211_unregister_hw - Unregister a hardware device
1287  *
1288  * This function instructs mac80211 to free allocated resources
1289  * and unregister netdevices from the networking subsystem.
1290  *
1291  * @hw: the hardware to unregister
1292  */
1293 void ieee80211_unregister_hw(struct ieee80211_hw *hw);
1294
1295 /**
1296  * ieee80211_free_hw - free hardware descriptor
1297  *
1298  * This function frees everything that was allocated, including the
1299  * private data for the driver. You must call ieee80211_unregister_hw()
1300  * before calling this function
1301  *
1302  * @hw: the hardware to free
1303  */
1304 void ieee80211_free_hw(struct ieee80211_hw *hw);
1305
1306 /* trick to avoid symbol clashes with the ieee80211 subsystem */
1307 void __ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
1308                     struct ieee80211_rx_status *status);
1309
1310 /**
1311  * ieee80211_rx - receive frame
1312  *
1313  * Use this function to hand received frames to mac80211. The receive
1314  * buffer in @skb must start with an IEEE 802.11 header or a radiotap
1315  * header if %RX_FLAG_RADIOTAP is set in the @status flags.
1316  *
1317  * This function may not be called in IRQ context. Calls to this function
1318  * for a single hardware must be synchronized against each other. Calls
1319  * to this function and ieee80211_rx_irqsafe() may not be mixed for a
1320  * single hardware.
1321  *
1322  * @hw: the hardware this frame came in on
1323  * @skb: the buffer to receive, owned by mac80211 after this call
1324  * @status: status of this frame; the status pointer need not be valid
1325  *      after this function returns
1326  */
1327 static inline void ieee80211_rx(struct ieee80211_hw *hw, struct sk_buff *skb,
1328                                 struct ieee80211_rx_status *status)
1329 {
1330         __ieee80211_rx(hw, skb, status);
1331 }
1332
1333 /**
1334  * ieee80211_rx_irqsafe - receive frame
1335  *
1336  * Like ieee80211_rx() but can be called in IRQ context
1337  * (internally defers to a tasklet.)
1338  *
1339  * Calls to this function and ieee80211_rx() may not be mixed for a
1340  * single hardware.
1341  *
1342  * @hw: the hardware this frame came in on
1343  * @skb: the buffer to receive, owned by mac80211 after this call
1344  * @status: status of this frame; the status pointer need not be valid
1345  *      after this function returns and is not freed by mac80211,
1346  *      it is recommended that it points to a stack area
1347  */
1348 void ieee80211_rx_irqsafe(struct ieee80211_hw *hw,
1349                           struct sk_buff *skb,
1350                           struct ieee80211_rx_status *status);
1351
1352 /**
1353  * ieee80211_tx_status - transmit status callback
1354  *
1355  * Call this function for all transmitted frames after they have been
1356  * transmitted. It is permissible to not call this function for
1357  * multicast frames but this can affect statistics.
1358  *
1359  * This function may not be called in IRQ context. Calls to this function
1360  * for a single hardware must be synchronized against each other. Calls
1361  * to this function and ieee80211_tx_status_irqsafe() may not be mixed
1362  * for a single hardware.
1363  *
1364  * @hw: the hardware the frame was transmitted by
1365  * @skb: the frame that was transmitted, owned by mac80211 after this call
1366  */
1367 void ieee80211_tx_status(struct ieee80211_hw *hw,
1368                          struct sk_buff *skb);
1369
1370 /**
1371  * ieee80211_tx_status_irqsafe - irq-safe transmit status callback
1372  *
1373  * Like ieee80211_tx_status() but can be called in IRQ context
1374  * (internally defers to a tasklet.)
1375  *
1376  * Calls to this function and ieee80211_tx_status() may not be mixed for a
1377  * single hardware.
1378  *
1379  * @hw: the hardware the frame was transmitted by
1380  * @skb: the frame that was transmitted, owned by mac80211 after this call
1381  */
1382 void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
1383                                  struct sk_buff *skb);
1384
1385 /**
1386  * ieee80211_beacon_get - beacon generation function
1387  * @hw: pointer obtained from ieee80211_alloc_hw().
1388  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1389  * @control: will be filled with information needed to send this beacon.
1390  *
1391  * If the beacon frames are generated by the host system (i.e., not in
1392  * hardware/firmware), the low-level driver uses this function to receive
1393  * the next beacon frame from the 802.11 code. The low-level is responsible
1394  * for calling this function before beacon data is needed (e.g., based on
1395  * hardware interrupt). Returned skb is used only once and low-level driver
1396  * is responsible of freeing it.
1397  */
1398 struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
1399                                      struct ieee80211_vif *vif);
1400
1401 /**
1402  * ieee80211_rts_get - RTS frame generation function
1403  * @hw: pointer obtained from ieee80211_alloc_hw().
1404  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1405  * @frame: pointer to the frame that is going to be protected by the RTS.
1406  * @frame_len: the frame length (in octets).
1407  * @frame_txctl: &struct ieee80211_tx_info of the frame.
1408  * @rts: The buffer where to store the RTS frame.
1409  *
1410  * If the RTS frames are generated by the host system (i.e., not in
1411  * hardware/firmware), the low-level driver uses this function to receive
1412  * the next RTS frame from the 802.11 code. The low-level is responsible
1413  * for calling this function before and RTS frame is needed.
1414  */
1415 void ieee80211_rts_get(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1416                        const void *frame, size_t frame_len,
1417                        const struct ieee80211_tx_info *frame_txctl,
1418                        struct ieee80211_rts *rts);
1419
1420 /**
1421  * ieee80211_rts_duration - Get the duration field for an RTS frame
1422  * @hw: pointer obtained from ieee80211_alloc_hw().
1423  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1424  * @frame_len: the length of the frame that is going to be protected by the RTS.
1425  * @frame_txctl: &struct ieee80211_tx_info of the frame.
1426  *
1427  * If the RTS is generated in firmware, but the host system must provide
1428  * the duration field, the low-level driver uses this function to receive
1429  * the duration field value in little-endian byteorder.
1430  */
1431 __le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
1432                               struct ieee80211_vif *vif, size_t frame_len,
1433                               const struct ieee80211_tx_info *frame_txctl);
1434
1435 /**
1436  * ieee80211_ctstoself_get - CTS-to-self frame generation function
1437  * @hw: pointer obtained from ieee80211_alloc_hw().
1438  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1439  * @frame: pointer to the frame that is going to be protected by the CTS-to-self.
1440  * @frame_len: the frame length (in octets).
1441  * @frame_txctl: &struct ieee80211_tx_info of the frame.
1442  * @cts: The buffer where to store the CTS-to-self frame.
1443  *
1444  * If the CTS-to-self frames are generated by the host system (i.e., not in
1445  * hardware/firmware), the low-level driver uses this function to receive
1446  * the next CTS-to-self frame from the 802.11 code. The low-level is responsible
1447  * for calling this function before and CTS-to-self frame is needed.
1448  */
1449 void ieee80211_ctstoself_get(struct ieee80211_hw *hw,
1450                              struct ieee80211_vif *vif,
1451                              const void *frame, size_t frame_len,
1452                              const struct ieee80211_tx_info *frame_txctl,
1453                              struct ieee80211_cts *cts);
1454
1455 /**
1456  * ieee80211_ctstoself_duration - Get the duration field for a CTS-to-self frame
1457  * @hw: pointer obtained from ieee80211_alloc_hw().
1458  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1459  * @frame_len: the length of the frame that is going to be protected by the CTS-to-self.
1460  * @frame_txctl: &struct ieee80211_tx_info of the frame.
1461  *
1462  * If the CTS-to-self is generated in firmware, but the host system must provide
1463  * the duration field, the low-level driver uses this function to receive
1464  * the duration field value in little-endian byteorder.
1465  */
1466 __le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
1467                                     struct ieee80211_vif *vif,
1468                                     size_t frame_len,
1469                                     const struct ieee80211_tx_info *frame_txctl);
1470
1471 /**
1472  * ieee80211_generic_frame_duration - Calculate the duration field for a frame
1473  * @hw: pointer obtained from ieee80211_alloc_hw().
1474  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1475  * @frame_len: the length of the frame.
1476  * @rate: the rate at which the frame is going to be transmitted.
1477  *
1478  * Calculate the duration field of some generic frame, given its
1479  * length and transmission rate (in 100kbps).
1480  */
1481 __le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
1482                                         struct ieee80211_vif *vif,
1483                                         size_t frame_len,
1484                                         struct ieee80211_rate *rate);
1485
1486 /**
1487  * ieee80211_get_buffered_bc - accessing buffered broadcast and multicast frames
1488  * @hw: pointer as obtained from ieee80211_alloc_hw().
1489  * @vif: &struct ieee80211_vif pointer from &struct ieee80211_if_init_conf.
1490  * @control: will be filled with information needed to send returned frame.
1491  *
1492  * Function for accessing buffered broadcast and multicast frames. If
1493  * hardware/firmware does not implement buffering of broadcast/multicast
1494  * frames when power saving is used, 802.11 code buffers them in the host
1495  * memory. The low-level driver uses this function to fetch next buffered
1496  * frame. In most cases, this is used when generating beacon frame. This
1497  * function returns a pointer to the next buffered skb or NULL if no more
1498  * buffered frames are available.
1499  *
1500  * Note: buffered frames are returned only after DTIM beacon frame was
1501  * generated with ieee80211_beacon_get() and the low-level driver must thus
1502  * call ieee80211_beacon_get() first. ieee80211_get_buffered_bc() returns
1503  * NULL if the previous generated beacon was not DTIM, so the low-level driver
1504  * does not need to check for DTIM beacons separately and should be able to
1505  * use common code for all beacons.
1506  */
1507 struct sk_buff *
1508 ieee80211_get_buffered_bc(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
1509
1510 /**
1511  * ieee80211_get_hdrlen_from_skb - get header length from data
1512  *
1513  * Given an skb with a raw 802.11 header at the data pointer this function
1514  * returns the 802.11 header length in bytes (not including encryption
1515  * headers). If the data in the sk_buff is too short to contain a valid 802.11
1516  * header the function returns 0.
1517  *
1518  * @skb: the frame
1519  */
1520 int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb);
1521
1522 /**
1523  * ieee80211_get_hdrlen - get header length from frame control
1524  *
1525  * This function returns the 802.11 header length in bytes (not including
1526  * encryption headers.)
1527  *
1528  * @fc: the frame control field (in CPU endianness)
1529  */
1530 int ieee80211_get_hdrlen(u16 fc);
1531
1532 /**
1533  * ieee80211_get_tkip_key - get a TKIP rc4 for skb
1534  *
1535  * This function computes a TKIP rc4 key for an skb. It computes
1536  * a phase 1 key if needed (iv16 wraps around). This function is to
1537  * be used by drivers which can do HW encryption but need to compute
1538  * to phase 1/2 key in SW.
1539  *
1540  * @keyconf: the parameter passed with the set key
1541  * @skb: the skb for which the key is needed
1542  * @rc4key: a buffer to which the key will be written
1543  */
1544 void ieee80211_get_tkip_key(struct ieee80211_key_conf *keyconf,
1545                                 struct sk_buff *skb,
1546                                 enum ieee80211_tkip_key_type type, u8 *key);
1547 /**
1548  * ieee80211_wake_queue - wake specific queue
1549  * @hw: pointer as obtained from ieee80211_alloc_hw().
1550  * @queue: queue number (counted from zero).
1551  *
1552  * Drivers should use this function instead of netif_wake_queue.
1553  */
1554 void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue);
1555
1556 /**
1557  * ieee80211_stop_queue - stop specific queue
1558  * @hw: pointer as obtained from ieee80211_alloc_hw().
1559  * @queue: queue number (counted from zero).
1560  *
1561  * Drivers should use this function instead of netif_stop_queue.
1562  */
1563 void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue);
1564
1565 /**
1566  * ieee80211_stop_queues - stop all queues
1567  * @hw: pointer as obtained from ieee80211_alloc_hw().
1568  *
1569  * Drivers should use this function instead of netif_stop_queue.
1570  */
1571 void ieee80211_stop_queues(struct ieee80211_hw *hw);
1572
1573 /**
1574  * ieee80211_wake_queues - wake all queues
1575  * @hw: pointer as obtained from ieee80211_alloc_hw().
1576  *
1577  * Drivers should use this function instead of netif_wake_queue.
1578  */
1579 void ieee80211_wake_queues(struct ieee80211_hw *hw);
1580
1581 /**
1582  * ieee80211_scan_completed - completed hardware scan
1583  *
1584  * When hardware scan offload is used (i.e. the hw_scan() callback is
1585  * assigned) this function needs to be called by the driver to notify
1586  * mac80211 that the scan finished.
1587  *
1588  * @hw: the hardware that finished the scan
1589  */
1590 void ieee80211_scan_completed(struct ieee80211_hw *hw);
1591
1592 /**
1593  * ieee80211_iterate_active_interfaces - iterate active interfaces
1594  *
1595  * This function iterates over the interfaces associated with a given
1596  * hardware that are currently active and calls the callback for them.
1597  *
1598  * @hw: the hardware struct of which the interfaces should be iterated over
1599  * @iterator: the iterator function to call, cannot sleep
1600  * @data: first argument of the iterator function
1601  */
1602 void ieee80211_iterate_active_interfaces(struct ieee80211_hw *hw,
1603                                          void (*iterator)(void *data, u8 *mac,
1604                                                 struct ieee80211_vif *vif),
1605                                          void *data);
1606
1607 /**
1608  * ieee80211_start_tx_ba_session - Start a tx Block Ack session.
1609  * @hw: pointer as obtained from ieee80211_alloc_hw().
1610  * @ra: receiver address of the BA session recipient
1611  * @tid: the TID to BA on.
1612  * @return: success if addBA request was sent, failure otherwise
1613  *
1614  * Although mac80211/low level driver/user space application can estimate
1615  * the need to start aggregation on a certain RA/TID, the session level
1616  * will be managed by the mac80211.
1617  */
1618 int ieee80211_start_tx_ba_session(struct ieee80211_hw *hw, u8 *ra, u16 tid);
1619
1620 /**
1621  * ieee80211_start_tx_ba_cb - low level driver ready to aggregate.
1622  * @hw: pointer as obtained from ieee80211_alloc_hw().
1623  * @ra: receiver address of the BA session recipient.
1624  * @tid: the TID to BA on.
1625  *
1626  * This function must be called by low level driver once it has
1627  * finished with preparations for the BA session.
1628  */
1629 void ieee80211_start_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u16 tid);
1630
1631 /**
1632  * ieee80211_start_tx_ba_cb_irqsafe - low level driver ready to aggregate.
1633  * @hw: pointer as obtained from ieee80211_alloc_hw().
1634  * @ra: receiver address of the BA session recipient.
1635  * @tid: the TID to BA on.
1636  *
1637  * This function must be called by low level driver once it has
1638  * finished with preparations for the BA session.
1639  * This version of the function is irq safe.
1640  */
1641 void ieee80211_start_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, const u8 *ra,
1642                                       u16 tid);
1643
1644 /**
1645  * ieee80211_stop_tx_ba_session - Stop a Block Ack session.
1646  * @hw: pointer as obtained from ieee80211_alloc_hw().
1647  * @ra: receiver address of the BA session recipient
1648  * @tid: the TID to stop BA.
1649  * @initiator: if indicates initiator DELBA frame will be sent.
1650  * @return: error if no sta with matching da found, success otherwise
1651  *
1652  * Although mac80211/low level driver/user space application can estimate
1653  * the need to stop aggregation on a certain RA/TID, the session level
1654  * will be managed by the mac80211.
1655  */
1656 int ieee80211_stop_tx_ba_session(struct ieee80211_hw *hw,
1657                                  u8 *ra, u16 tid,
1658                                  enum ieee80211_back_parties initiator);
1659
1660 /**
1661  * ieee80211_stop_tx_ba_cb - low level driver ready to stop aggregate.
1662  * @hw: pointer as obtained from ieee80211_alloc_hw().
1663  * @ra: receiver address of the BA session recipient.
1664  * @tid: the desired TID to BA on.
1665  *
1666  * This function must be called by low level driver once it has
1667  * finished with preparations for the BA session tear down.
1668  */
1669 void ieee80211_stop_tx_ba_cb(struct ieee80211_hw *hw, u8 *ra, u8 tid);
1670
1671 /**
1672  * ieee80211_stop_tx_ba_cb_irqsafe - low level driver ready to stop aggregate.
1673  * @hw: pointer as obtained from ieee80211_alloc_hw().
1674  * @ra: receiver address of the BA session recipient.
1675  * @tid: the desired TID to BA on.
1676  *
1677  * This function must be called by low level driver once it has
1678  * finished with preparations for the BA session tear down.
1679  * This version of the function is irq safe.
1680  */
1681 void ieee80211_stop_tx_ba_cb_irqsafe(struct ieee80211_hw *hw, const u8 *ra,
1682                                      u16 tid);
1683
1684 /**
1685  * ieee80211_notify_mac - low level driver notification
1686  * @hw: pointer as obtained from ieee80211_alloc_hw().
1687  * @notification_types: enum ieee80211_notification_types
1688  *
1689  * This function must be called by low level driver to inform mac80211 of
1690  * low level driver status change or force mac80211 to re-assoc for low
1691  * level driver internal error that require re-assoc.
1692  */
1693 void ieee80211_notify_mac(struct ieee80211_hw *hw,
1694                           enum ieee80211_notification_types  notif_type);
1695 #endif /* MAC80211_H */