#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. * @IEEE80211_CHAN_NO_FAT_ABOVE: extension channel above this channel * is not permitted. * @IEEE80211_CHAN_NO_FAT_BELOW: extension channel below this channel * is not permitted. */ 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, IEEE80211_CHAN_NO_FAT_ABOVE = 1<<4, IEEE80211_CHAN_NO_FAT_BELOW = 1<<5, }; /** * 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); /* * Name indirection necessary because the ieee80211 code also has * a function named "ieee80211_get_channel", so if you include * cfg80211's header file you get cfg80211's version, if you try * to include both header files you'll (rightfully!) get a symbol * clash. */ extern struct ieee80211_channel *__ieee80211_get_channel(struct wiphy *wiphy, int freq); /** * ieee80211_get_channel - get channel struct from wiphy for specified frequency */ static inline struct ieee80211_channel * ieee80211_get_channel(struct wiphy *wiphy, int freq) { return __ieee80211_get_channel(wiphy, freq); } #endif /* __NET_WIRELESS_H */