core.h 7.33 KB
Newer Older
1 2 3
/*
 * Wireless configuration interface internals.
 *
4
 * Copyright 2006-2009	Johannes Berg <johannes@sipsolutions.net>
5 6 7 8 9 10
 */
#ifndef __NET_WIRELESS_CORE_H
#define __NET_WIRELESS_CORE_H
#include <linux/mutex.h>
#include <linux/list.h>
#include <linux/netdevice.h>
11 12
#include <linux/kref.h>
#include <linux/rbtree.h>
13
#include <linux/debugfs.h>
Johannes Berg's avatar
Johannes Berg committed
14 15
#include <linux/rfkill.h>
#include <linux/workqueue.h>
16 17
#include <net/genetlink.h>
#include <net/cfg80211.h>
18
#include "reg.h"
19 20

struct cfg80211_registered_device {
21
	const struct cfg80211_ops *ops;
22 23 24 25 26 27 28
	struct list_head list;
	/* we hold this mutex during any call so that
	 * we cannot do multiple calls at once, and also
	 * to avoid the deregister call to proceed while
	 * any call is in progress */
	struct mutex mtx;

Johannes Berg's avatar
Johannes Berg committed
29 30 31 32 33
	/* rfkill support */
	struct rfkill_ops rfkill_ops;
	struct rfkill *rfkill;
	struct work_struct rfkill_sync;

34 35 36 37 38 39 40 41 42 43 44 45
	/* ISO / IEC 3166 alpha2 for which this device is receiving
	 * country IEs on, this can help disregard country IEs from APs
	 * on the same alpha2 quickly. The alpha2 may differ from
	 * cfg80211_regdomain's alpha2 when an intersection has occurred.
	 * If the AP is reconfigured this can also be used to tell us if
	 * the country on the country IE changed. */
	char country_ie_alpha2[2];

	/* If a Country IE has been received this tells us the environment
	 * which its telling us its in. This defaults to ENVIRON_ANY */
	enum environment_cap env;

46
	/* wiphy index, internal only */
47
	int wiphy_idx;
48 49 50 51 52

	/* associate netdev list */
	struct mutex devlist_mtx;
	struct list_head netdev_list;

53 54 55 56 57 58
	/* BSSes/scanning */
	spinlock_t bss_lock;
	struct list_head bss_list;
	struct rb_root bss_tree;
	u32 bss_generation;
	struct cfg80211_scan_request *scan_req; /* protected by RTNL */
59
	unsigned long suspend_at;
60

61 62 63 64
#ifdef CONFIG_NL80211_TESTMODE
	struct genl_info *testmode_info;
#endif

65 66
	struct work_struct conn_work;

67
#ifdef CONFIG_CFG80211_DEBUGFS
68 69 70 71 72 73
	/* Debugfs entries */
	struct wiphy_debugfsdentries {
		struct dentry *rts_threshold;
		struct dentry *fragmentation_threshold;
		struct dentry *short_retry_limit;
		struct dentry *long_retry_limit;
74
		struct dentry *ht40allow_map;
75 76 77
	} debugfs;
#endif

78 79 80 81 82 83 84 85 86 87 88 89
	/* must be last because of the way we do wiphy_priv(),
	 * and it should at least be aligned to NETDEV_ALIGN */
	struct wiphy wiphy __attribute__((__aligned__(NETDEV_ALIGN)));
};

static inline
struct cfg80211_registered_device *wiphy_to_dev(struct wiphy *wiphy)
{
	BUG_ON(!wiphy);
	return container_of(wiphy, struct cfg80211_registered_device, wiphy);
}

90 91 92 93 94 95 96
/* Note 0 is valid, hence phy0 */
static inline
bool wiphy_idx_valid(int wiphy_idx)
{
	return (wiphy_idx >= 0);
}

97
extern struct mutex cfg80211_mutex;
98 99
extern struct list_head cfg80211_drv_list;

100
#define assert_cfg80211_lock() WARN_ON(!mutex_is_locked(&cfg80211_mutex))
101

102 103 104 105 106 107
/*
 * You can use this to mark a wiphy_idx as not having an associated wiphy.
 * It guarantees cfg80211_drv_by_wiphy_idx(wiphy_idx) will return NULL
 */
#define WIPHY_IDX_STALE -1

108 109 110 111 112
struct cfg80211_internal_bss {
	struct list_head list;
	struct rb_node rbn;
	unsigned long ts;
	struct kref ref;
Johannes Berg's avatar
Johannes Berg committed
113 114
	atomic_t hold;
	bool ies_allocated;
Kalle Valo's avatar
Kalle Valo committed
115

116 117 118 119
	/* must be last because of priv member */
	struct cfg80211_bss pub;
};

Johannes Berg's avatar
Johannes Berg committed
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
static inline struct cfg80211_internal_bss *bss_from_pub(struct cfg80211_bss *pub)
{
	return container_of(pub, struct cfg80211_internal_bss, pub);
}

static inline void cfg80211_hold_bss(struct cfg80211_internal_bss *bss)
{
	atomic_inc(&bss->hold);
}

static inline void cfg80211_unhold_bss(struct cfg80211_internal_bss *bss)
{
	int r = atomic_dec_return(&bss->hold);
	WARN_ON(r < 0);
}


137 138 139
struct cfg80211_registered_device *cfg80211_drv_by_wiphy_idx(int wiphy_idx);
int get_wiphy_idx(struct wiphy *wiphy);

140 141 142
struct cfg80211_registered_device *
__cfg80211_drv_from_info(struct genl_info *info);

143 144 145 146 147 148 149
/*
 * This function returns a pointer to the driver
 * that the genl_info item that is passed refers to.
 * If successful, it returns non-NULL and also locks
 * the driver's mutex!
 *
 * This means that you need to call cfg80211_put_dev()
150
 * before being allowed to acquire &cfg80211_mutex!
151 152 153 154 155
 *
 * This is necessary because we need to lock the global
 * mutex to get an item off the list safely, and then
 * we lock the drv mutex so it doesn't go away under us.
 *
156
 * We don't want to keep cfg80211_mutex locked
157 158 159 160 161 162 163 164 165
 * for all the time in order to allow requests on
 * other interfaces to go through at the same time.
 *
 * The result of this can be a PTR_ERR and hence must
 * be checked with IS_ERR() for errors.
 */
extern struct cfg80211_registered_device *
cfg80211_get_dev_from_info(struct genl_info *info);

166 167 168
/* requires cfg80211_drv_mutex to be held! */
struct wiphy *wiphy_idx_to_wiphy(int wiphy_idx);

169 170 171 172 173 174
/* identical to cfg80211_get_dev_from_info but only operate on ifindex */
extern struct cfg80211_registered_device *
cfg80211_get_dev_from_ifindex(int ifindex);

extern void cfg80211_put_dev(struct cfg80211_registered_device *drv);

175 176 177
/* free object */
extern void cfg80211_dev_free(struct cfg80211_registered_device *drv);

178 179 180
extern int cfg80211_dev_rename(struct cfg80211_registered_device *drv,
			       char *newname);

181
void ieee80211_set_bitrate_flags(struct wiphy *wiphy);
182 183
void wiphy_update_regulatory(struct wiphy *wiphy,
			     enum nl80211_reg_initiator setby);
184

185
void cfg80211_bss_expire(struct cfg80211_registered_device *dev);
186 187
void cfg80211_bss_age(struct cfg80211_registered_device *dev,
                      unsigned long age_secs);
188

Johannes Berg's avatar
Johannes Berg committed
189 190 191 192
/* IBSS */
int cfg80211_join_ibss(struct cfg80211_registered_device *rdev,
		       struct net_device *dev,
		       struct cfg80211_ibss_params *params);
193
void cfg80211_clear_ibss(struct net_device *dev, bool nowext);
Johannes Berg's avatar
Johannes Berg committed
194
int cfg80211_leave_ibss(struct cfg80211_registered_device *rdev,
195
			struct net_device *dev, bool nowext);
Johannes Berg's avatar
Johannes Berg committed
196

Johannes Berg's avatar
Johannes Berg committed
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
/* MLME */
int cfg80211_mlme_auth(struct cfg80211_registered_device *rdev,
		       struct net_device *dev, struct ieee80211_channel *chan,
		       enum nl80211_auth_type auth_type, const u8 *bssid,
		       const u8 *ssid, int ssid_len,
		       const u8 *ie, int ie_len);
int cfg80211_mlme_assoc(struct cfg80211_registered_device *rdev,
			struct net_device *dev, struct ieee80211_channel *chan,
			const u8 *bssid, const u8 *ssid, int ssid_len,
			const u8 *ie, int ie_len, bool use_mfp,
			struct cfg80211_crypto_settings *crypt);
int cfg80211_mlme_deauth(struct cfg80211_registered_device *rdev,
			 struct net_device *dev, const u8 *bssid,
			 const u8 *ie, int ie_len, u16 reason);
int cfg80211_mlme_disassoc(struct cfg80211_registered_device *rdev,
			   struct net_device *dev, const u8 *bssid,
			   const u8 *ie, int ie_len, u16 reason);
void cfg80211_mlme_down(struct cfg80211_registered_device *rdev,
			struct net_device *dev);

217 218 219 220 221
/* SME */
int cfg80211_connect(struct cfg80211_registered_device *rdev,
		     struct net_device *dev,
		     struct cfg80211_connect_params *connect);
int cfg80211_disconnect(struct cfg80211_registered_device *rdev,
222 223
			struct net_device *dev, u16 reason,
			bool wextev);
224

225 226
void cfg80211_conn_work(struct work_struct *work);

227 228 229
/* internal helpers */
int cfg80211_validate_key_settings(struct key_params *params, int key_idx,
				   const u8 *mac_addr);
230 231 232 233
void __cfg80211_disconnected(struct net_device *dev, gfp_t gfp, u8 *ie,
			     size_t ie_len, u16 reason, bool from_ap);
void cfg80211_sme_scan_done(struct net_device *dev);
void cfg80211_sme_rx_auth(struct net_device *dev, const u8 *buf, size_t len);
Johannes Berg's avatar
Johannes Berg committed
234
void cfg80211_sme_disassoc(struct net_device *dev, int idx);
235

236
#endif /* __NET_WIRELESS_CORE_H */