| #ifndef __NET_WIRELESS_H |
| #define __NET_WIRELESS_H |
| |
| /* |
| * 802.11 device management |
| * |
| * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> |
| */ |
| |
| #include <linux/netdevice.h> |
| #include <linux/debugfs.h> |
| #include <linux/list.h> |
| #include <net/cfg80211.h> |
| |
| /** |
| * enum ieee80211_band - supported frequency bands |
| * |
| * The bands are assigned this way because the supported |
| * bitrates differ in these bands. |
| * |
| * @IEEE80211_BAND_2GHZ: 2.4GHz ISM band |
| * @IEEE80211_BAND_5GHZ: around 5GHz band (4.9-5.7) |
| */ |
| enum ieee80211_band { |
| IEEE80211_BAND_2GHZ, |
| IEEE80211_BAND_5GHZ, |
| |
| /* keep last */ |
| IEEE80211_NUM_BANDS |
| }; |
| |
| /** |
| * enum ieee80211_channel_flags - channel flags |
| * |
| * Channel flags set by the regulatory control code. |
| * |
| * @IEEE80211_CHAN_DISABLED: This channel is disabled. |
| * @IEEE80211_CHAN_PASSIVE_SCAN: Only passive scanning is permitted |
| * on this channel. |
| * @IEEE80211_CHAN_NO_IBSS: IBSS is not allowed on this channel. |
| * @IEEE80211_CHAN_RADAR: Radar detection is required on this channel. |
| */ |
| enum ieee80211_channel_flags { |
| IEEE80211_CHAN_DISABLED = 1<<0, |
| IEEE80211_CHAN_PASSIVE_SCAN = 1<<1, |
| IEEE80211_CHAN_NO_IBSS = 1<<2, |
| IEEE80211_CHAN_RADAR = 1<<3, |
| }; |
| |
| /** |
| * struct ieee80211_channel - channel definition |
| * |
| * This structure describes a single channel for use |
| * with cfg80211. |
| * |
| * @center_freq: center frequency in MHz |
| * @hw_value: hardware-specific value for the channel |
| * @flags: channel flags from &enum ieee80211_channel_flags. |
| * @orig_flags: channel flags at registration time, used by regulatory |
| * code to support devices with additional restrictions |
| * @band: band this channel belongs to. |
| * @max_antenna_gain: maximum antenna gain in dBi |
| * @max_power: maximum transmission power (in dBm) |
| * @orig_mag: internal use |
| * @orig_mpwr: internal use |
| */ |
| struct ieee80211_channel { |
| enum ieee80211_band band; |
| u16 center_freq; |
| u16 hw_value; |
| u32 flags; |
| int max_antenna_gain; |
| int max_power; |
| u32 orig_flags; |
| int orig_mag, orig_mpwr; |
| }; |
| |
| /** |
| * enum ieee80211_rate_flags - rate flags |
| * |
| * Hardware/specification flags for rates. These are structured |
| * in a way that allows using the same bitrate structure for |
| * different bands/PHY modes. |
| * |
| * @IEEE80211_RATE_SHORT_PREAMBLE: Hardware can send with short |
| * preamble on this bitrate; only relevant in 2.4GHz band and |
| * with CCK rates. |
| * @IEEE80211_RATE_MANDATORY_A: This bitrate is a mandatory rate |
| * when used with 802.11a (on the 5 GHz band); filled by the |
| * core code when registering the wiphy. |
| * @IEEE80211_RATE_MANDATORY_B: This bitrate is a mandatory rate |
| * when used with 802.11b (on the 2.4 GHz band); filled by the |
| * core code when registering the wiphy. |
| * @IEEE80211_RATE_MANDATORY_G: This bitrate is a mandatory rate |
| * when used with 802.11g (on the 2.4 GHz band); filled by the |
| * core code when registering the wiphy. |
| * @IEEE80211_RATE_ERP_G: This is an ERP rate in 802.11g mode. |
| */ |
| enum ieee80211_rate_flags { |
| IEEE80211_RATE_SHORT_PREAMBLE = 1<<0, |
| IEEE80211_RATE_MANDATORY_A = 1<<1, |
| IEEE80211_RATE_MANDATORY_B = 1<<2, |
| IEEE80211_RATE_MANDATORY_G = 1<<3, |
| IEEE80211_RATE_ERP_G = 1<<4, |
| }; |
| |
| /** |
| * struct ieee80211_rate - bitrate definition |
| * |
| * This structure describes a bitrate that an 802.11 PHY can |
| * operate with. The two values @hw_value and @hw_value_short |
| * are only for driver use when pointers to this structure are |
| * passed around. |
| * |
| * @flags: rate-specific flags |
| * @bitrate: bitrate in units of 100 Kbps |
| * @hw_value: driver/hardware value for this rate |
| * @hw_value_short: driver/hardware value for this rate when |
| * short preamble is used |
| */ |
| struct ieee80211_rate { |
| u32 flags; |
| u16 bitrate; |
| u16 hw_value, hw_value_short; |
| }; |
| |
| /** |
| * struct ieee80211_ht_info - describing STA's HT capabilities |
| * |
| * This structure describes most essential parameters needed |
| * to describe 802.11n HT capabilities for an STA. |
| * |
| * @ht_supported: is HT supported by STA, 0: no, 1: yes |
| * @cap: HT capabilities map as described in 802.11n spec |
| * @ampdu_factor: Maximum A-MPDU length factor |
| * @ampdu_density: Minimum A-MPDU spacing |
| * @supp_mcs_set: Supported MCS set as described in 802.11n spec |
| */ |
| struct ieee80211_ht_info { |
| u16 cap; /* use IEEE80211_HT_CAP_ */ |
| u8 ht_supported; |
| u8 ampdu_factor; |
| u8 ampdu_density; |
| u8 supp_mcs_set[16]; |
| }; |
| |
| /** |
| * struct ieee80211_supported_band - frequency band definition |
| * |
| * This structure describes a frequency band a wiphy |
| * is able to operate in. |
| * |
| * @channels: Array of channels the hardware can operate in |
| * in this band. |
| * @band: the band this structure represents |
| * @n_channels: Number of channels in @channels |
| * @bitrates: Array of bitrates the hardware can operate with |
| * in this band. Must be sorted to give a valid "supported |
| * rates" IE, i.e. CCK rates first, then OFDM. |
| * @n_bitrates: Number of bitrates in @bitrates |
| */ |
| struct ieee80211_supported_band { |
| struct ieee80211_channel *channels; |
| struct ieee80211_rate *bitrates; |
| enum ieee80211_band band; |
| int n_channels; |
| int n_bitrates; |
| struct ieee80211_ht_info ht_info; |
| }; |
| |
| /** |
| * struct wiphy - wireless hardware description |
| * @idx: the wiphy index assigned to this item |
| * @class_dev: the class device representing /sys/class/ieee80211/<wiphy-name> |
| */ |
| struct wiphy { |
| /* assign these fields before you register the wiphy */ |
| |
| /* permanent MAC address */ |
| u8 perm_addr[ETH_ALEN]; |
| |
| /* If multiple wiphys are registered and you're handed e.g. |
| * a regular netdev with assigned ieee80211_ptr, you won't |
| * know whether it points to a wiphy your driver has registered |
| * or not. Assign this to something global to your driver to |
| * help determine whether you own this wiphy or not. */ |
| void *privid; |
| |
| struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS]; |
| |
| /* fields below are read-only, assigned by cfg80211 */ |
| |
| /* the item in /sys/class/ieee80211/ points to this, |
| * you need use set_wiphy_dev() (see below) */ |
| struct device dev; |
| |
| /* dir in debugfs: ieee80211/<wiphyname> */ |
| struct dentry *debugfsdir; |
| |
| char priv[0] __attribute__((__aligned__(NETDEV_ALIGN))); |
| }; |
| |
| /** struct wireless_dev - wireless per-netdev state |
| * |
| * This structure must be allocated by the driver/stack |
| * that uses the ieee80211_ptr field in struct net_device |
| * (this is intentional so it can be allocated along with |
| * the netdev.) |
| * |
| * @wiphy: pointer to hardware description |
| */ |
| struct wireless_dev { |
| struct wiphy *wiphy; |
| |
| /* private to the generic wireless code */ |
| struct list_head list; |
| struct net_device *netdev; |
| }; |
| |
| /** |
| * wiphy_priv - return priv from wiphy |
| */ |
| static inline void *wiphy_priv(struct wiphy *wiphy) |
| { |
| BUG_ON(!wiphy); |
| return &wiphy->priv; |
| } |
| |
| /** |
| * set_wiphy_dev - set device pointer for wiphy |
| */ |
| static inline void set_wiphy_dev(struct wiphy *wiphy, struct device *dev) |
| { |
| wiphy->dev.parent = dev; |
| } |
| |
| /** |
| * wiphy_dev - get wiphy dev pointer |
| */ |
| static inline struct device *wiphy_dev(struct wiphy *wiphy) |
| { |
| return wiphy->dev.parent; |
| } |
| |
| /** |
| * wiphy_name - get wiphy name |
| */ |
| static inline char *wiphy_name(struct wiphy *wiphy) |
| { |
| return wiphy->dev.bus_id; |
| } |
| |
| /** |
| * wdev_priv - return wiphy priv from wireless_dev |
| */ |
| static inline void *wdev_priv(struct wireless_dev *wdev) |
| { |
| BUG_ON(!wdev); |
| return wiphy_priv(wdev->wiphy); |
| } |
| |
| /** |
| * wiphy_new - create a new wiphy for use with cfg80211 |
| * |
| * create a new wiphy and associate the given operations with it. |
| * @sizeof_priv bytes are allocated for private use. |
| * |
| * the returned pointer must be assigned to each netdev's |
| * ieee80211_ptr for proper operation. |
| */ |
| struct wiphy *wiphy_new(struct cfg80211_ops *ops, int sizeof_priv); |
| |
| /** |
| * wiphy_register - register a wiphy with cfg80211 |
| * |
| * register the given wiphy |
| * |
| * Returns a non-negative wiphy index or a negative error code. |
| */ |
| extern int wiphy_register(struct wiphy *wiphy); |
| |
| /** |
| * wiphy_unregister - deregister a wiphy from cfg80211 |
| * |
| * unregister a device with the given priv pointer. |
| * After this call, no more requests can be made with this priv |
| * pointer, but the call may sleep to wait for an outstanding |
| * request that is being handled. |
| */ |
| extern void wiphy_unregister(struct wiphy *wiphy); |
| |
| /** |
| * wiphy_free - free wiphy |
| */ |
| extern void wiphy_free(struct wiphy *wiphy); |
| |
| /** |
| * ieee80211_channel_to_frequency - convert channel number to frequency |
| */ |
| extern int ieee80211_channel_to_frequency(int chan); |
| |
| /** |
| * ieee80211_frequency_to_channel - convert frequency to channel number |
| */ |
| extern int ieee80211_frequency_to_channel(int freq); |
| |
| #endif /* __NET_WIRELESS_H */ |