Commit | Line | Data |
---|---|---|
704232c2 JB |
1 | #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> | |
13 | #include <net/cfg80211.h> | |
14 | ||
8318d78a JB |
15 | /** |
16 | * enum ieee80211_band - supported frequency bands | |
17 | * | |
18 | * The bands are assigned this way because the supported | |
19 | * bitrates differ in these bands. | |
20 | * | |
21 | * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band | |
22 | * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7) | |
23 | */ | |
24 | enum ieee80211_band { | |
25 | IEEE80211_BAND_2GHZ, | |
26 | IEEE80211_BAND_5GHZ, | |
27 | ||
28 | /* keep last */ | |
29 | IEEE80211_NUM_BANDS | |
30 | }; | |
31 | ||
32 | /** | |
33 | * enum ieee80211_channel_flags - channel flags | |
34 | * | |
35 | * Channel flags set by the regulatory control code. | |
36 | * | |
37 | * @IEEE80211_CHAN_DISABLED: This channel is disabled. | |
38 | * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted | |
39 | * on this channel. | |
40 | * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel. | |
41 | * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel. | |
9306102e EG |
42 | * @IEEE80211_CHAN_NO_FAT_ABOVE: extension channel above this channel |
43 | * is not permitted. | |
44 | * @IEEE80211_CHAN_NO_FAT_BELOW: extension channel below this channel | |
45 | * is not permitted. | |
8318d78a JB |
46 | */ |
47 | enum ieee80211_channel_flags { | |
48 | IEEE80211_CHAN_DISABLED = 1<<0, | |
49 | IEEE80211_CHAN_PASSIVE_SCAN = 1<<1, | |
50 | IEEE80211_CHAN_NO_IBSS = 1<<2, | |
51 | IEEE80211_CHAN_RADAR = 1<<3, | |
9306102e EG |
52 | IEEE80211_CHAN_NO_FAT_ABOVE = 1<<4, |
53 | IEEE80211_CHAN_NO_FAT_BELOW = 1<<5, | |
8318d78a JB |
54 | }; |
55 | ||
56 | /** | |
57 | * struct ieee80211_channel - channel definition | |
58 | * | |
59 | * This structure describes a single channel for use | |
60 | * with cfg80211. | |
61 | * | |
62 | * @center_freq: center frequency in MHz | |
b2e1b302 | 63 | * @max_bandwidth: maximum allowed bandwidth for this channel, in MHz |
8318d78a JB |
64 | * @hw_value: hardware-specific value for the channel |
65 | * @flags: channel flags from &enum ieee80211_channel_flags. | |
66 | * @orig_flags: channel flags at registration time, used by regulatory | |
67 | * code to support devices with additional restrictions | |
68 | * @band: band this channel belongs to. | |
69 | * @max_antenna_gain: maximum antenna gain in dBi | |
70 | * @max_power: maximum transmission power (in dBm) | |
71 | * @orig_mag: internal use | |
72 | * @orig_mpwr: internal use | |
73 | */ | |
74 | struct ieee80211_channel { | |
75 | enum ieee80211_band band; | |
76 | u16 center_freq; | |
b2e1b302 | 77 | u8 max_bandwidth; |
8318d78a JB |
78 | u16 hw_value; |
79 | u32 flags; | |
80 | int max_antenna_gain; | |
81 | int max_power; | |
82 | u32 orig_flags; | |
83 | int orig_mag, orig_mpwr; | |
84 | }; | |
85 | ||
86 | /** | |
87 | * enum ieee80211_rate_flags - rate flags | |
88 | * | |
89 | * Hardware/specification flags for rates. These are structured | |
90 | * in a way that allows using the same bitrate structure for | |
91 | * different bands/PHY modes. | |
92 | * | |
93 | * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short | |
94 | * preamble on this bitrate; only relevant in 2.4GHz band and | |
95 | * with CCK rates. | |
96 | * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate | |
97 | * when used with 802.11a (on the 5 GHz band); filled by the | |
98 | * core code when registering the wiphy. | |
99 | * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate | |
100 | * when used with 802.11b (on the 2.4 GHz band); filled by the | |
101 | * core code when registering the wiphy. | |
102 | * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate | |
103 | * when used with 802.11g (on the 2.4 GHz band); filled by the | |
104 | * core code when registering the wiphy. | |
105 | * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode. | |
106 | */ | |
107 | enum ieee80211_rate_flags { | |
108 | IEEE80211_RATE_SHORT_PREAMBLE = 1<<0, | |
109 | IEEE80211_RATE_MANDATORY_A = 1<<1, | |
110 | IEEE80211_RATE_MANDATORY_B = 1<<2, | |
111 | IEEE80211_RATE_MANDATORY_G = 1<<3, | |
112 | IEEE80211_RATE_ERP_G = 1<<4, | |
113 | }; | |
114 | ||
115 | /** | |
116 | * struct ieee80211_rate - bitrate definition | |
117 | * | |
118 | * This structure describes a bitrate that an 802.11 PHY can | |
119 | * operate with. The two values @hw_value and @hw_value_short | |
120 | * are only for driver use when pointers to this structure are | |
121 | * passed around. | |
122 | * | |
123 | * @flags: rate-specific flags | |
124 | * @bitrate: bitrate in units of 100 Kbps | |
125 | * @hw_value: driver/hardware value for this rate | |
126 | * @hw_value_short: driver/hardware value for this rate when | |
127 | * short preamble is used | |
128 | */ | |
129 | struct ieee80211_rate { | |
130 | u32 flags; | |
131 | u16 bitrate; | |
132 | u16 hw_value, hw_value_short; | |
133 | }; | |
134 | ||
135 | /** | |
136 | * struct ieee80211_ht_info - describing STA's HT capabilities | |
137 | * | |
138 | * This structure describes most essential parameters needed | |
139 | * to describe 802.11n HT capabilities for an STA. | |
140 | * | |
141 | * @ht_supported: is HT supported by STA, 0: no, 1: yes | |
142 | * @cap: HT capabilities map as described in 802.11n spec | |
143 | * @ampdu_factor: Maximum A-MPDU length factor | |
144 | * @ampdu_density: Minimum A-MPDU spacing | |
145 | * @supp_mcs_set: Supported MCS set as described in 802.11n spec | |
146 | */ | |
147 | struct ieee80211_ht_info { | |
148 | u16 cap; /* use IEEE80211_HT_CAP_ */ | |
149 | u8 ht_supported; | |
150 | u8 ampdu_factor; | |
151 | u8 ampdu_density; | |
152 | u8 supp_mcs_set[16]; | |
153 | }; | |
154 | ||
155 | /** | |
156 | * struct ieee80211_supported_band - frequency band definition | |
157 | * | |
158 | * This structure describes a frequency band a wiphy | |
159 | * is able to operate in. | |
160 | * | |
161 | * @channels: Array of channels the hardware can operate in | |
162 | * in this band. | |
163 | * @band: the band this structure represents | |
164 | * @n_channels: Number of channels in @channels | |
165 | * @bitrates: Array of bitrates the hardware can operate with | |
166 | * in this band. Must be sorted to give a valid "supported | |
167 | * rates" IE, i.e. CCK rates first, then OFDM. | |
168 | * @n_bitrates: Number of bitrates in @bitrates | |
169 | */ | |
170 | struct ieee80211_supported_band { | |
171 | struct ieee80211_channel *channels; | |
172 | struct ieee80211_rate *bitrates; | |
173 | enum ieee80211_band band; | |
174 | int n_channels; | |
175 | int n_bitrates; | |
176 | struct ieee80211_ht_info ht_info; | |
177 | }; | |
178 | ||
704232c2 JB |
179 | /** |
180 | * struct wiphy - wireless hardware description | |
181 | * @idx: the wiphy index assigned to this item | |
182 | * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name> | |
b2e1b302 | 183 | * @reg_notifier: the driver's regulatory notification callback |
704232c2 JB |
184 | */ |
185 | struct wiphy { | |
186 | /* assign these fields before you register the wiphy */ | |
187 | ||
188 | /* permanent MAC address */ | |
189 | u8 perm_addr[ETH_ALEN]; | |
190 | ||
f59ac048 LR |
191 | /* Supported interface modes, OR together BIT(NL80211_IFTYPE_...) */ |
192 | u16 interface_modes; | |
193 | ||
704232c2 JB |
194 | /* If multiple wiphys are registered and you're handed e.g. |
195 | * a regular netdev with assigned ieee80211_ptr, you won't | |
196 | * know whether it points to a wiphy your driver has registered | |
197 | * or not. Assign this to something global to your driver to | |
198 | * help determine whether you own this wiphy or not. */ | |
199 | void *privid; | |
200 | ||
8318d78a JB |
201 | struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS]; |
202 | ||
b2e1b302 LR |
203 | /* Lets us get back the wiphy on the callback */ |
204 | int (*reg_notifier)(struct wiphy *wiphy, enum reg_set_by setby); | |
205 | ||
704232c2 JB |
206 | /* fields below are read-only, assigned by cfg80211 */ |
207 | ||
208 | /* the item in /sys/class/ieee80211/ points to this, | |
209 | * you need use set_wiphy_dev() (see below) */ | |
210 | struct device dev; | |
211 | ||
212 | /* dir in debugfs: ieee80211/<wiphyname> */ | |
213 | struct dentry *debugfsdir; | |
214 | ||
215 | char priv[0] __attribute__((__aligned__(NETDEV_ALIGN))); | |
216 | }; | |
217 | ||
218 | /** struct wireless_dev - wireless per-netdev state | |
219 | * | |
220 | * This structure must be allocated by the driver/stack | |
221 | * that uses the ieee80211_ptr field in struct net_device | |
222 | * (this is intentional so it can be allocated along with | |
223 | * the netdev.) | |
224 | * | |
225 | * @wiphy: pointer to hardware description | |
60719ffd | 226 | * @iftype: interface type |
704232c2 JB |
227 | */ |
228 | struct wireless_dev { | |
229 | struct wiphy *wiphy; | |
60719ffd | 230 | enum nl80211_iftype iftype; |
704232c2 JB |
231 | |
232 | /* private to the generic wireless code */ | |
233 | struct list_head list; | |
234 | struct net_device *netdev; | |
235 | }; | |
236 | ||
237 | /** | |
238 | * wiphy_priv - return priv from wiphy | |
239 | */ | |
240 | static inline void *wiphy_priv(struct wiphy *wiphy) | |
241 | { | |
242 | BUG_ON(!wiphy); | |
243 | return &wiphy->priv; | |
244 | } | |
245 | ||
246 | /** | |
247 | * set_wiphy_dev - set device pointer for wiphy | |
248 | */ | |
249 | static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev) | |
250 | { | |
251 | wiphy->dev.parent = dev; | |
252 | } | |
253 | ||
254 | /** | |
255 | * wiphy_dev - get wiphy dev pointer | |
256 | */ | |
257 | static inline struct device *wiphy_dev(struct wiphy *wiphy) | |
258 | { | |
259 | return wiphy->dev.parent; | |
260 | } | |
261 | ||
262 | /** | |
263 | * wiphy_name - get wiphy name | |
264 | */ | |
265 | static inline char *wiphy_name(struct wiphy *wiphy) | |
266 | { | |
267 | return wiphy->dev.bus_id; | |
268 | } | |
269 | ||
270 | /** | |
271 | * wdev_priv - return wiphy priv from wireless_dev | |
272 | */ | |
273 | static inline void *wdev_priv(struct wireless_dev *wdev) | |
274 | { | |
275 | BUG_ON(!wdev); | |
276 | return wiphy_priv(wdev->wiphy); | |
277 | } | |
278 | ||
279 | /** | |
280 | * wiphy_new - create a new wiphy for use with cfg80211 | |
281 | * | |
282 | * create a new wiphy and associate the given operations with it. | |
283 | * @sizeof_priv bytes are allocated for private use. | |
284 | * | |
285 | * the returned pointer must be assigned to each netdev's | |
286 | * ieee80211_ptr for proper operation. | |
287 | */ | |
288 | struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv); | |
289 | ||
290 | /** | |
291 | * wiphy_register - register a wiphy with cfg80211 | |
292 | * | |
293 | * register the given wiphy | |
294 | * | |
295 | * Returns a non-negative wiphy index or a negative error code. | |
296 | */ | |
297 | extern int wiphy_register(struct wiphy *wiphy); | |
298 | ||
299 | /** | |
300 | * wiphy_unregister - deregister a wiphy from cfg80211 | |
301 | * | |
302 | * unregister a device with the given priv pointer. | |
303 | * After this call, no more requests can be made with this priv | |
304 | * pointer, but the call may sleep to wait for an outstanding | |
305 | * request that is being handled. | |
306 | */ | |
307 | extern void wiphy_unregister(struct wiphy *wiphy); | |
308 | ||
309 | /** | |
310 | * wiphy_free - free wiphy | |
311 | */ | |
312 | extern void wiphy_free(struct wiphy *wiphy); | |
313 | ||
8318d78a JB |
314 | /** |
315 | * ieee80211_channel_to_frequency - convert channel number to frequency | |
316 | */ | |
317 | extern int ieee80211_channel_to_frequency(int chan); | |
318 | ||
319 | /** | |
320 | * ieee80211_frequency_to_channel - convert frequency to channel number | |
321 | */ | |
322 | extern int ieee80211_frequency_to_channel(int freq); | |
323 | ||
6c507cd0 JB |
324 | /* |
325 | * Name indirection necessary because the ieee80211 code also has | |
326 | * a function named "ieee80211_get_channel", so if you include | |
327 | * cfg80211's header file you get cfg80211's version, if you try | |
328 | * to include both header files you'll (rightfully!) get a symbol | |
329 | * clash. | |
330 | */ | |
331 | extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy, | |
332 | int freq); | |
e07aa378 JB |
333 | /** |
334 | * ieee80211_get_channel - get channel struct from wiphy for specified frequency | |
335 | */ | |
336 | static inline struct ieee80211_channel * | |
337 | ieee80211_get_channel(struct wiphy *wiphy, int freq) | |
338 | { | |
339 | return __ieee80211_get_channel(wiphy, freq); | |
340 | } | |
341 | ||
b2e1b302 LR |
342 | /** |
343 | * __regulatory_hint - hint to the wireless core a regulatory domain | |
344 | * @wiphy: if a driver is providing the hint this is the driver's very | |
345 | * own &struct wiphy | |
346 | * @alpha2: the ISO/IEC 3166 alpha2 being claimed the regulatory domain | |
347 | * should be in. If @rd is set this should be NULL | |
348 | * @rd: a complete regulatory domain, if passed the caller need not worry | |
349 | * about freeing it | |
350 | * | |
351 | * The Wireless subsystem can use this function to hint to the wireless core | |
352 | * what it believes should be the current regulatory domain by | |
353 | * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory | |
354 | * domain should be in or by providing a completely build regulatory domain. | |
355 | * | |
356 | * Returns -EALREADY if *a regulatory domain* has already been set. Note that | |
357 | * this could be by another driver. It is safe for drivers to continue if | |
358 | * -EALREADY is returned, if drivers are not capable of world roaming they | |
359 | * should not register more channels than they support. Right now we only | |
360 | * support listening to the first driver hint. If the driver is capable | |
361 | * of world roaming but wants to respect its own EEPROM mappings for | |
362 | * specific regulatory domains it should register the @reg_notifier callback | |
363 | * on the &struct wiphy. Returns 0 if the hint went through fine or through an | |
364 | * intersection operation. Otherwise a standard error code is returned. | |
365 | * | |
366 | */ | |
367 | extern int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by, | |
368 | const char *alpha2, struct ieee80211_regdomain *rd); | |
369 | /** | |
370 | * regulatory_hint - driver hint to the wireless core a regulatory domain | |
371 | * @wiphy: the driver's very own &struct wiphy | |
372 | * @alpha2: the ISO/IEC 3166 alpha2 the driver claims its regulatory domain | |
373 | * should be in. If @rd is set this should be NULL. Note that if you | |
374 | * set this to NULL you should still set rd->alpha2 to some accepted | |
375 | * alpha2. | |
376 | * @rd: a complete regulatory domain provided by the driver. If passed | |
377 | * the driver does not need to worry about freeing it. | |
378 | * | |
379 | * Wireless drivers can use this function to hint to the wireless core | |
380 | * what it believes should be the current regulatory domain by | |
381 | * giving it an ISO/IEC 3166 alpha2 country code it knows its regulatory | |
382 | * domain should be in or by providing a completely build regulatory domain. | |
383 | * If the driver provides an ISO/IEC 3166 alpha2 userspace will be queried | |
384 | * for a regulatory domain structure for the respective country. If | |
385 | * a regulatory domain is build and passed you should set the alpha2 | |
386 | * if possible, otherwise set it to the special value of "99" which tells | |
387 | * the wireless core it is unknown. If you pass a built regulatory domain | |
388 | * and we return non zero you are in charge of kfree()'ing the structure. | |
389 | * | |
390 | * See __regulatory_hint() documentation for possible return values. | |
391 | */ | |
392 | extern int regulatory_hint(struct wiphy *wiphy, | |
393 | const char *alpha2, struct ieee80211_regdomain *rd); | |
704232c2 | 394 | #endif /* __NET_WIRELESS_H */ |