2007-04-24 02:20:05 +07:00
|
|
|
#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>
|
|
|
|
|
2008-01-25 01:38:38 +07:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
};
|
|
|
|
|
2007-04-24 02:20:05 +07:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
2008-01-25 01:38:38 +07:00
|
|
|
struct ieee80211_supported_band *bands[IEEE80211_NUM_BANDS];
|
|
|
|
|
2007-04-24 02:20:05 +07:00
|
|
|
/* 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);
|
|
|
|
|
2008-01-25 01:38:38 +07:00
|
|
|
/**
|
|
|
|
* 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);
|
|
|
|
|
2008-03-26 20:14:55 +07:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
|
2008-03-17 00:34:33 +07:00
|
|
|
/**
|
|
|
|
* ieee80211_get_channel - get channel struct from wiphy for specified frequency
|
|
|
|
*/
|
2008-03-26 20:14:55 +07:00
|
|
|
static inline struct ieee80211_channel *
|
|
|
|
ieee80211_get_channel(struct wiphy *wiphy, int freq)
|
|
|
|
{
|
|
|
|
return __ieee80211_get_channel(wiphy, freq);
|
|
|
|
}
|
2007-04-24 02:20:05 +07:00
|
|
|
#endif /* __NET_WIRELESS_H */
|