blob: 21c5d966142d9cc3b5964364c482068a03f25c0b [file] [log] [blame]
Johannes Berg704232c2007-04-23 12:20:05 -07001#ifndef __NET_WIRELESS_H
2#define __NET_WIRELESS_H
3
4/*
5 * 802.11 device management
6 *
7 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
8 */
9
10#include <linux/netdevice.h>
11#include <linux/debugfs.h>
12#include <linux/list.h>
Johannes Bergd9fe60d2008-10-09 12:13:49 +020013#include <linux/ieee80211.h>
Johannes Berg704232c2007-04-23 12:20:05 -070014#include <net/cfg80211.h>
15
16/**
Johannes Berg8318d782008-01-24 19:38:38 +010017 * enum ieee80211_band - supported frequency bands
18 *
19 * The bands are assigned this way because the supported
20 * bitrates differ in these bands.
21 *
22 * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band
23 * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7)
24 */
25enum ieee80211_band {
26 IEEE80211_BAND_2GHZ,
27 IEEE80211_BAND_5GHZ,
28
29 /* keep last */
30 IEEE80211_NUM_BANDS
31};
32
33/**
34 * enum ieee80211_channel_flags - channel flags
35 *
36 * Channel flags set by the regulatory control code.
37 *
38 * @IEEE80211_CHAN_DISABLED: This channel is disabled.
39 * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted
40 * on this channel.
41 * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel.
42 * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel.
Emmanuel Grumbach93061022008-05-29 16:35:23 +080043 * @IEEE80211_CHAN_NO_FAT_ABOVE: extension channel above this channel
44 * is not permitted.
45 * @IEEE80211_CHAN_NO_FAT_BELOW: extension channel below this channel
46 * is not permitted.
Johannes Berg8318d782008-01-24 19:38:38 +010047 */
48enum ieee80211_channel_flags {
49 IEEE80211_CHAN_DISABLED = 1<<0,
50 IEEE80211_CHAN_PASSIVE_SCAN = 1<<1,
51 IEEE80211_CHAN_NO_IBSS = 1<<2,
52 IEEE80211_CHAN_RADAR = 1<<3,
Emmanuel Grumbach93061022008-05-29 16:35:23 +080053 IEEE80211_CHAN_NO_FAT_ABOVE = 1<<4,
54 IEEE80211_CHAN_NO_FAT_BELOW = 1<<5,
Johannes Berg8318d782008-01-24 19:38:38 +010055};
56
57/**
58 * struct ieee80211_channel - channel definition
59 *
60 * This structure describes a single channel for use
61 * with cfg80211.
62 *
63 * @center_freq: center frequency in MHz
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070064 * @max_bandwidth: maximum allowed bandwidth for this channel, in MHz
Johannes Berg8318d782008-01-24 19:38:38 +010065 * @hw_value: hardware-specific value for the channel
66 * @flags: channel flags from &enum ieee80211_channel_flags.
67 * @orig_flags: channel flags at registration time, used by regulatory
68 * code to support devices with additional restrictions
69 * @band: band this channel belongs to.
70 * @max_antenna_gain: maximum antenna gain in dBi
71 * @max_power: maximum transmission power (in dBm)
72 * @orig_mag: internal use
73 * @orig_mpwr: internal use
74 */
75struct ieee80211_channel {
76 enum ieee80211_band band;
77 u16 center_freq;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070078 u8 max_bandwidth;
Johannes Berg8318d782008-01-24 19:38:38 +010079 u16 hw_value;
80 u32 flags;
81 int max_antenna_gain;
82 int max_power;
83 u32 orig_flags;
84 int orig_mag, orig_mpwr;
85};
86
87/**
88 * enum ieee80211_rate_flags - rate flags
89 *
90 * Hardware/specification flags for rates. These are structured
91 * in a way that allows using the same bitrate structure for
92 * different bands/PHY modes.
93 *
94 * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short
95 * preamble on this bitrate; only relevant in 2.4GHz band and
96 * with CCK rates.
97 * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate
98 * when used with 802.11a (on the 5 GHz band); filled by the
99 * core code when registering the wiphy.
100 * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate
101 * when used with 802.11b (on the 2.4 GHz band); filled by the
102 * core code when registering the wiphy.
103 * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate
104 * when used with 802.11g (on the 2.4 GHz band); filled by the
105 * core code when registering the wiphy.
106 * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode.
107 */
108enum ieee80211_rate_flags {
109 IEEE80211_RATE_SHORT_PREAMBLE = 1<<0,
110 IEEE80211_RATE_MANDATORY_A = 1<<1,
111 IEEE80211_RATE_MANDATORY_B = 1<<2,
112 IEEE80211_RATE_MANDATORY_G = 1<<3,
113 IEEE80211_RATE_ERP_G = 1<<4,
114};
115
116/**
117 * struct ieee80211_rate - bitrate definition
118 *
119 * This structure describes a bitrate that an 802.11 PHY can
120 * operate with. The two values @hw_value and @hw_value_short
121 * are only for driver use when pointers to this structure are
122 * passed around.
123 *
124 * @flags: rate-specific flags
125 * @bitrate: bitrate in units of 100 Kbps
126 * @hw_value: driver/hardware value for this rate
127 * @hw_value_short: driver/hardware value for this rate when
128 * short preamble is used
129 */
130struct ieee80211_rate {
131 u32 flags;
132 u16 bitrate;
133 u16 hw_value, hw_value_short;
134};
135
136/**
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200137 * struct ieee80211_sta_ht_cap - STA's HT capabilities
Johannes Berg8318d782008-01-24 19:38:38 +0100138 *
139 * This structure describes most essential parameters needed
140 * to describe 802.11n HT capabilities for an STA.
141 *
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200142 * @ht_supported: is HT supported by the STA
Johannes Berg8318d782008-01-24 19:38:38 +0100143 * @cap: HT capabilities map as described in 802.11n spec
144 * @ampdu_factor: Maximum A-MPDU length factor
145 * @ampdu_density: Minimum A-MPDU spacing
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200146 * @mcs: Supported MCS rates
Johannes Berg8318d782008-01-24 19:38:38 +0100147 */
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200148struct ieee80211_sta_ht_cap {
Johannes Berg8318d782008-01-24 19:38:38 +0100149 u16 cap; /* use IEEE80211_HT_CAP_ */
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200150 bool ht_supported;
Johannes Berg8318d782008-01-24 19:38:38 +0100151 u8 ampdu_factor;
152 u8 ampdu_density;
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200153 struct ieee80211_mcs_info mcs;
Johannes Berg8318d782008-01-24 19:38:38 +0100154};
155
156/**
157 * struct ieee80211_supported_band - frequency band definition
158 *
159 * This structure describes a frequency band a wiphy
160 * is able to operate in.
161 *
162 * @channels: Array of channels the hardware can operate in
163 * in this band.
164 * @band: the band this structure represents
165 * @n_channels: Number of channels in @channels
166 * @bitrates: Array of bitrates the hardware can operate with
167 * in this band. Must be sorted to give a valid "supported
168 * rates" IE, i.e. CCK rates first, then OFDM.
169 * @n_bitrates: Number of bitrates in @bitrates
170 */
171struct ieee80211_supported_band {
172 struct ieee80211_channel *channels;
173 struct ieee80211_rate *bitrates;
174 enum ieee80211_band band;
175 int n_channels;
176 int n_bitrates;
Johannes Bergd9fe60d2008-10-09 12:13:49 +0200177 struct ieee80211_sta_ht_cap ht_cap;
Johannes Berg8318d782008-01-24 19:38:38 +0100178};
179
180/**
Johannes Berg704232c2007-04-23 12:20:05 -0700181 * struct wiphy - wireless hardware description
182 * @idx: the wiphy index assigned to this item
183 * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name>
Luis R. Rodriguez14b98152008-11-12 14:22:03 -0800184 * @fw_handles_regulatory: tells us the firmware for this device
185 * has its own regulatory solution and cannot identify the
186 * ISO / IEC 3166 alpha2 it belongs to. When this is enabled
187 * we will disregard the first regulatory hint (when the
188 * initiator is %REGDOM_SET_BY_CORE).
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700189 * @reg_notifier: the driver's regulatory notification callback
Johannes Berg704232c2007-04-23 12:20:05 -0700190 */
191struct wiphy {
192 /* assign these fields before you register the wiphy */
193
194 /* permanent MAC address */
195 u8 perm_addr[ETH_ALEN];
196
Luis R. Rodriguezf59ac042008-08-29 16:26:43 -0700197 /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */
198 u16 interface_modes;
199
Luis R. Rodriguez14b98152008-11-12 14:22:03 -0800200 bool fw_handles_regulatory;
201
Johannes Berg704232c2007-04-23 12:20:05 -0700202 /* If multiple wiphys are registered and you're handed e.g.
203 * a regular netdev with assigned ieee80211_ptr, you won't
204 * know whether it points to a wiphy your driver has registered
205 * or not. Assign this to something global to your driver to
206 * help determine whether you own this wiphy or not. */
207 void *privid;
208
Johannes Berg8318d782008-01-24 19:38:38 +0100209 struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS];
210
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700211 /* Lets us get back the wiphy on the callback */
212 int (*reg_notifier)(struct wiphy *wiphy, enum reg_set_by setby);
213
Johannes Berg704232c2007-04-23 12:20:05 -0700214 /* fields below are read-only, assigned by cfg80211 */
215
216 /* the item in /sys/class/ieee80211/ points to this,
217 * you need use set_wiphy_dev() (see below) */
218 struct device dev;
219
220 /* dir in debugfs: ieee80211/<wiphyname> */
221 struct dentry *debugfsdir;
222
223 char priv[0] __attribute__((__aligned__(NETDEV_ALIGN)));
224};
225
226/** struct wireless_dev - wireless per-netdev state
227 *
228 * This structure must be allocated by the driver/stack
229 * that uses the ieee80211_ptr field in struct net_device
230 * (this is intentional so it can be allocated along with
231 * the netdev.)
232 *
233 * @wiphy: pointer to hardware description
Johannes Berg60719ff2008-09-16 14:55:09 +0200234 * @iftype: interface type
Johannes Berg704232c2007-04-23 12:20:05 -0700235 */
236struct wireless_dev {
237 struct wiphy *wiphy;
Johannes Berg60719ff2008-09-16 14:55:09 +0200238 enum nl80211_iftype iftype;
Johannes Berg704232c2007-04-23 12:20:05 -0700239
240 /* private to the generic wireless code */
241 struct list_head list;
242 struct net_device *netdev;
243};
244
245/**
246 * wiphy_priv - return priv from wiphy
247 */
248static inline void *wiphy_priv(struct wiphy *wiphy)
249{
250 BUG_ON(!wiphy);
251 return &wiphy->priv;
252}
253
254/**
255 * set_wiphy_dev - set device pointer for wiphy
256 */
257static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev)
258{
259 wiphy->dev.parent = dev;
260}
261
262/**
263 * wiphy_dev - get wiphy dev pointer
264 */
265static inline struct device *wiphy_dev(struct wiphy *wiphy)
266{
267 return wiphy->dev.parent;
268}
269
270/**
271 * wiphy_name - get wiphy name
272 */
Kay Sieversfb28ad32008-11-10 13:55:14 -0800273static inline const char *wiphy_name(struct wiphy *wiphy)
Johannes Berg704232c2007-04-23 12:20:05 -0700274{
Kay Sieversfb28ad32008-11-10 13:55:14 -0800275 return dev_name(&wiphy->dev);
Johannes Berg704232c2007-04-23 12:20:05 -0700276}
277
278/**
279 * wdev_priv - return wiphy priv from wireless_dev
280 */
281static inline void *wdev_priv(struct wireless_dev *wdev)
282{
283 BUG_ON(!wdev);
284 return wiphy_priv(wdev->wiphy);
285}
286
287/**
288 * wiphy_new - create a new wiphy for use with cfg80211
289 *
290 * create a new wiphy and associate the given operations with it.
291 * @sizeof_priv bytes are allocated for private use.
292 *
293 * the returned pointer must be assigned to each netdev's
294 * ieee80211_ptr for proper operation.
295 */
296struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv);
297
298/**
299 * wiphy_register - register a wiphy with cfg80211
300 *
301 * register the given wiphy
302 *
303 * Returns a non-negative wiphy index or a negative error code.
304 */
305extern int wiphy_register(struct wiphy *wiphy);
306
307/**
308 * wiphy_unregister - deregister a wiphy from cfg80211
309 *
310 * unregister a device with the given priv pointer.
311 * After this call, no more requests can be made with this priv
312 * pointer, but the call may sleep to wait for an outstanding
313 * request that is being handled.
314 */
315extern void wiphy_unregister(struct wiphy *wiphy);
316
317/**
318 * wiphy_free - free wiphy
319 */
320extern void wiphy_free(struct wiphy *wiphy);
321
Johannes Berg8318d782008-01-24 19:38:38 +0100322/**
323 * ieee80211_channel_to_frequency - convert channel number to frequency
324 */
325extern int ieee80211_channel_to_frequency(int chan);
326
327/**
328 * ieee80211_frequency_to_channel - convert frequency to channel number
329 */
330extern int ieee80211_frequency_to_channel(int freq);
331
Johannes Berg6c507cd2008-03-26 14:14:55 +0100332/*
333 * Name indirection necessary because the ieee80211 code also has
334 * a function named "ieee80211_get_channel", so if you include
335 * cfg80211's header file you get cfg80211's version, if you try
336 * to include both header files you'll (rightfully!) get a symbol
337 * clash.
338 */
339extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy,
340 int freq);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700341/**
Johannes Berge07aa372008-09-15 13:11:19 +0200342 * ieee80211_get_channel - get channel struct from wiphy for specified frequency
343 */
344static inline struct ieee80211_channel *
345ieee80211_get_channel(struct wiphy *wiphy, int freq)
346{
347 return __ieee80211_get_channel(wiphy, freq);
348}
349
350/**
Johannes Bergbd815252008-10-29 20:00:45 +0100351 * ieee80211_get_response_rate - get basic rate for a given rate
352 *
353 * @sband: the band to look for rates in
354 * @basic_rates: bitmap of basic rates
355 * @bitrate: the bitrate for which to find the basic rate
356 *
357 * This function returns the basic rate corresponding to a given
358 * bitrate, that is the next lower bitrate contained in the basic
359 * rate map, which is, for this function, given as a bitmap of
360 * indices of rates in the band's bitrate table.
361 */
362struct ieee80211_rate *
363ieee80211_get_response_rate(struct ieee80211_supported_band *sband,
364 u64 basic_rates, int bitrate);
365
366/**
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700367 * regulatory_hint - driver hint to the wireless core a regulatory domain
Johannes Bergbe3d4812008-10-24 20:32:21 +0200368 * @wiphy: the wireless device giving the hint (used only for reporting
369 * conflicts)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700370 * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain
371 * should be in. If @rd is set this should be NULL. Note that if you
372 * set this to NULL you should still set rd->alpha2 to some accepted
373 * alpha2.
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700374 *
375 * Wireless drivers can use this function to hint to the wireless core
376 * what it believes should be the current regulatory domain by
377 * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory
378 * domain should be in or by providing a completely build regulatory domain.
379 * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried
Johannes Bergbe3d4812008-10-24 20:32:21 +0200380 * for a regulatory domain structure for the respective country.
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700381 */
Johannes Bergbe3d4812008-10-24 20:32:21 +0200382extern void regulatory_hint(struct wiphy *wiphy, const char *alpha2);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800383
384/**
385 * regulatory_hint_11d - hints a country IE as a regulatory domain
386 * @wiphy: the wireless device giving the hint (used only for reporting
387 * conflicts)
388 * @country_ie: pointer to the country IE
389 * @country_ie_len: length of the country IE
390 *
391 * We will intersect the rd with the what CRDA tells us should apply
392 * for the alpha2 this country IE belongs to, this prevents APs from
393 * sending us incorrect or outdated information against a country.
394 */
395extern void regulatory_hint_11d(struct wiphy *wiphy,
396 u8 *country_ie,
397 u8 country_ie_len);
Johannes Berg704232c2007-04-23 12:20:05 -0700398#endif /* __NET_WIRELESS_H */