2007-05-05 12:45:53 -06:00
|
|
|
/*
|
|
|
|
* mac80211 configuration hooks for cfg80211
|
|
|
|
*
|
2010-02-15 03:53:10 -07:00
|
|
|
* Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
|
2007-05-05 12:45:53 -06:00
|
|
|
*
|
|
|
|
* This file is GPLv2 as found in COPYING.
|
|
|
|
*/
|
|
|
|
|
2007-12-18 18:03:30 -07:00
|
|
|
#include <linux/ieee80211.h>
|
2007-05-05 12:45:53 -06:00
|
|
|
#include <linux/nl80211.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2007-09-17 12:56:21 -06:00
|
|
|
#include <net/net_namespace.h>
|
2007-12-18 18:03:33 -07:00
|
|
|
#include <linux/rcupdate.h>
|
2011-09-28 05:12:52 -06:00
|
|
|
#include <linux/if_ether.h>
|
2007-05-05 12:45:53 -06:00
|
|
|
#include <net/cfg80211.h>
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 10:52:52 -06:00
|
|
|
#include "driver-ops.h"
|
2007-09-18 15:29:21 -06:00
|
|
|
#include "cfg.h"
|
2008-04-08 13:14:40 -06:00
|
|
|
#include "rate.h"
|
2008-02-23 07:17:17 -07:00
|
|
|
#include "mesh.h"
|
|
|
|
|
2010-12-03 01:20:42 -07:00
|
|
|
static struct net_device *ieee80211_add_iface(struct wiphy *wiphy, char *name,
|
|
|
|
enum nl80211_iftype type,
|
|
|
|
u32 *flags,
|
|
|
|
struct vif_params *params)
|
2007-05-05 12:45:53 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2008-01-31 11:48:23 -07:00
|
|
|
struct net_device *dev;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
int err;
|
2007-05-05 12:45:53 -06:00
|
|
|
|
2008-09-10 16:01:58 -06:00
|
|
|
err = ieee80211_if_add(local, name, &dev, type, params);
|
2010-12-03 01:20:42 -07:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
2008-01-31 11:48:23 -07:00
|
|
|
|
2010-12-03 01:20:42 -07:00
|
|
|
if (type == NL80211_IFTYPE_MONITOR && flags) {
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
sdata->u.mntr_flags = *flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dev;
|
2007-05-05 12:45:53 -06:00
|
|
|
}
|
|
|
|
|
2009-07-13 16:33:35 -06:00
|
|
|
static int ieee80211_del_iface(struct wiphy *wiphy, struct net_device *dev)
|
2007-05-05 12:45:53 -06:00
|
|
|
{
|
2009-07-13 16:33:35 -06:00
|
|
|
ieee80211_if_remove(IEEE80211_DEV_TO_SUB_IF(dev));
|
2007-05-05 12:45:53 -06:00
|
|
|
|
2008-07-09 06:40:35 -06:00
|
|
|
return 0;
|
2007-05-05 12:45:53 -06:00
|
|
|
}
|
|
|
|
|
2009-06-09 13:04:43 -06:00
|
|
|
static int ieee80211_change_iface(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
2008-02-23 07:17:06 -07:00
|
|
|
enum nl80211_iftype type, u32 *flags,
|
|
|
|
struct vif_params *params)
|
2007-09-28 13:52:27 -06:00
|
|
|
{
|
2009-12-23 05:15:31 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2008-07-09 06:40:36 -06:00
|
|
|
int ret;
|
2007-09-28 13:52:27 -06:00
|
|
|
|
2008-09-10 16:01:58 -06:00
|
|
|
ret = ieee80211_if_change_type(sdata, type);
|
2008-07-09 06:40:36 -06:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2007-09-28 13:52:27 -06:00
|
|
|
|
2009-11-19 03:55:19 -07:00
|
|
|
if (type == NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
params && params->use_4addr == 0)
|
2011-08-01 10:19:00 -06:00
|
|
|
RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
|
2009-11-19 03:55:19 -07:00
|
|
|
else if (type == NL80211_IFTYPE_STATION &&
|
|
|
|
params && params->use_4addr >= 0)
|
|
|
|
sdata->u.mgd.use_4addr = params->use_4addr;
|
|
|
|
|
2010-10-02 05:17:07 -06:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_MONITOR && flags) {
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
if (ieee80211_sdata_running(sdata)) {
|
|
|
|
/*
|
|
|
|
* Prohibit MONITOR_FLAG_COOK_FRAMES to be
|
|
|
|
* changed while the interface is up.
|
|
|
|
* Else we would need to add a lot of cruft
|
|
|
|
* to update everything:
|
|
|
|
* cooked_mntrs, monitor and all fif_* counters
|
|
|
|
* reconfigure hardware
|
|
|
|
*/
|
|
|
|
if ((*flags & MONITOR_FLAG_COOK_FRAMES) !=
|
|
|
|
(sdata->u.mntr_flags & MONITOR_FLAG_COOK_FRAMES))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
ieee80211_adjust_monitor_flags(sdata, -1);
|
|
|
|
sdata->u.mntr_flags = *flags;
|
|
|
|
ieee80211_adjust_monitor_flags(sdata, 1);
|
|
|
|
|
|
|
|
ieee80211_configure_filter(local);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Because the interface is down, ieee80211_do_stop
|
|
|
|
* and ieee80211_do_open take care of "everything"
|
|
|
|
* mentioned in the comment above.
|
|
|
|
*/
|
|
|
|
sdata->u.mntr_flags = *flags;
|
|
|
|
}
|
|
|
|
}
|
2010-04-26 16:26:34 -06:00
|
|
|
|
2007-09-28 13:52:27 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-18 06:20:44 -07:00
|
|
|
static int ieee80211_set_noack_map(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u16 noack_map)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
sdata->noack_map = noack_map;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-18 18:03:30 -07:00
|
|
|
static int ieee80211_add_key(struct wiphy *wiphy, struct net_device *dev,
|
2010-10-05 11:39:30 -06:00
|
|
|
u8 key_idx, bool pairwise, const u8 *mac_addr,
|
2007-12-18 18:03:30 -07:00
|
|
|
struct key_params *params)
|
|
|
|
{
|
2010-08-27 04:35:55 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2007-12-18 18:03:30 -07:00
|
|
|
struct sta_info *sta = NULL;
|
2008-02-25 08:27:45 -07:00
|
|
|
struct ieee80211_key *key;
|
2008-04-08 09:56:52 -06:00
|
|
|
int err;
|
2007-12-18 18:03:30 -07:00
|
|
|
|
2010-08-27 04:35:55 -06:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
2010-06-01 02:19:19 -06:00
|
|
|
return -ENETDOWN;
|
|
|
|
|
2010-08-10 01:46:38 -06:00
|
|
|
/* reject WEP and TKIP keys if WEP failed to initialize */
|
2007-12-18 18:03:30 -07:00
|
|
|
switch (params->cipher) {
|
|
|
|
case WLAN_CIPHER_SUITE_WEP40:
|
|
|
|
case WLAN_CIPHER_SUITE_TKIP:
|
2010-08-10 01:46:38 -06:00
|
|
|
case WLAN_CIPHER_SUITE_WEP104:
|
|
|
|
if (IS_ERR(sdata->local->wep_tx_tfm))
|
|
|
|
return -EINVAL;
|
2009-01-08 04:32:02 -07:00
|
|
|
break;
|
2007-12-18 18:03:30 -07:00
|
|
|
default:
|
2010-08-10 01:46:38 -06:00
|
|
|
break;
|
2007-12-18 18:03:30 -07:00
|
|
|
}
|
|
|
|
|
2010-08-10 01:46:38 -06:00
|
|
|
key = ieee80211_key_alloc(params->cipher, key_idx, params->key_len,
|
|
|
|
params->key, params->seq_len, params->seq);
|
2010-08-01 10:37:03 -06:00
|
|
|
if (IS_ERR(key))
|
|
|
|
return PTR_ERR(key);
|
2008-02-25 08:27:45 -07:00
|
|
|
|
2010-10-05 11:39:30 -06:00
|
|
|
if (pairwise)
|
|
|
|
key->conf.flags |= IEEE80211_KEY_FLAG_PAIRWISE;
|
|
|
|
|
2010-06-01 02:19:19 -06:00
|
|
|
mutex_lock(&sdata->local->sta_mtx);
|
2008-04-08 09:56:52 -06:00
|
|
|
|
2007-12-18 18:03:30 -07:00
|
|
|
if (mac_addr) {
|
2011-05-03 17:57:12 -06:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
sta = sta_info_get(sdata, mac_addr);
|
|
|
|
else
|
|
|
|
sta = sta_info_get_bss(sdata, mac_addr);
|
2008-02-25 08:27:45 -07:00
|
|
|
if (!sta) {
|
2010-07-26 16:52:03 -06:00
|
|
|
ieee80211_key_free(sdata->local, key);
|
2008-04-08 09:56:52 -06:00
|
|
|
err = -ENOENT;
|
|
|
|
goto out_unlock;
|
2008-02-25 08:27:45 -07:00
|
|
|
}
|
2007-12-18 18:03:30 -07:00
|
|
|
}
|
|
|
|
|
2010-08-27 05:26:52 -06:00
|
|
|
err = ieee80211_key_link(key, sdata, sta);
|
|
|
|
if (err)
|
|
|
|
ieee80211_key_free(sdata->local, key);
|
2008-02-25 08:27:45 -07:00
|
|
|
|
2008-04-08 09:56:52 -06:00
|
|
|
out_unlock:
|
2010-06-01 02:19:19 -06:00
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
2008-04-08 09:56:52 -06:00
|
|
|
|
|
|
|
return err;
|
2007-12-18 18:03:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_del_key(struct wiphy *wiphy, struct net_device *dev,
|
2010-10-05 11:39:30 -06:00
|
|
|
u8 key_idx, bool pairwise, const u8 *mac_addr)
|
2007-12-18 18:03:30 -07:00
|
|
|
{
|
2011-05-12 06:31:49 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2007-12-18 18:03:30 -07:00
|
|
|
struct sta_info *sta;
|
2011-05-12 06:31:49 -06:00
|
|
|
struct ieee80211_key *key = NULL;
|
2007-12-18 18:03:30 -07:00
|
|
|
int ret;
|
|
|
|
|
2011-05-12 06:31:49 -06:00
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
mutex_lock(&local->key_mtx);
|
2008-04-08 09:56:52 -06:00
|
|
|
|
2007-12-18 18:03:30 -07:00
|
|
|
if (mac_addr) {
|
2008-04-08 09:56:52 -06:00
|
|
|
ret = -ENOENT;
|
|
|
|
|
2010-01-08 10:10:58 -07:00
|
|
|
sta = sta_info_get_bss(sdata, mac_addr);
|
2007-12-18 18:03:30 -07:00
|
|
|
if (!sta)
|
2008-04-08 09:56:52 -06:00
|
|
|
goto out_unlock;
|
2007-12-18 18:03:30 -07:00
|
|
|
|
2011-05-12 06:31:49 -06:00
|
|
|
if (pairwise)
|
2011-05-13 06:15:49 -06:00
|
|
|
key = key_mtx_dereference(local, sta->ptk);
|
2011-05-12 06:31:49 -06:00
|
|
|
else
|
2011-05-13 06:15:49 -06:00
|
|
|
key = key_mtx_dereference(local, sta->gtk[key_idx]);
|
2011-05-12 06:31:49 -06:00
|
|
|
} else
|
2011-05-13 06:15:49 -06:00
|
|
|
key = key_mtx_dereference(local, sdata->keys[key_idx]);
|
2007-12-18 18:03:30 -07:00
|
|
|
|
2011-05-12 06:31:49 -06:00
|
|
|
if (!key) {
|
2008-04-08 09:56:52 -06:00
|
|
|
ret = -ENOENT;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2007-12-18 18:03:30 -07:00
|
|
|
|
2011-05-12 06:31:49 -06:00
|
|
|
__ieee80211_key_free(key);
|
2007-12-18 18:03:30 -07:00
|
|
|
|
2008-04-08 09:56:52 -06:00
|
|
|
ret = 0;
|
|
|
|
out_unlock:
|
2011-05-12 06:31:49 -06:00
|
|
|
mutex_unlock(&local->key_mtx);
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
2008-04-08 09:56:52 -06:00
|
|
|
|
|
|
|
return ret;
|
2007-12-18 18:03:30 -07:00
|
|
|
}
|
|
|
|
|
2007-12-18 18:03:31 -07:00
|
|
|
static int ieee80211_get_key(struct wiphy *wiphy, struct net_device *dev,
|
2010-10-05 11:39:30 -06:00
|
|
|
u8 key_idx, bool pairwise, const u8 *mac_addr,
|
|
|
|
void *cookie,
|
2007-12-18 18:03:31 -07:00
|
|
|
void (*callback)(void *cookie,
|
|
|
|
struct key_params *params))
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-18 18:03:31 -07:00
|
|
|
struct sta_info *sta = NULL;
|
|
|
|
u8 seq[6] = {0};
|
|
|
|
struct key_params params;
|
2010-10-05 11:39:30 -06:00
|
|
|
struct ieee80211_key *key = NULL;
|
2011-07-06 13:59:39 -06:00
|
|
|
u64 pn64;
|
2007-12-18 18:03:31 -07:00
|
|
|
u32 iv32;
|
|
|
|
u16 iv16;
|
|
|
|
int err = -ENOENT;
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2008-04-08 09:56:52 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
|
2007-12-18 18:03:31 -07:00
|
|
|
if (mac_addr) {
|
2010-01-08 10:10:58 -07:00
|
|
|
sta = sta_info_get_bss(sdata, mac_addr);
|
2007-12-18 18:03:31 -07:00
|
|
|
if (!sta)
|
|
|
|
goto out;
|
|
|
|
|
2010-10-05 11:39:30 -06:00
|
|
|
if (pairwise)
|
2011-05-12 07:11:37 -06:00
|
|
|
key = rcu_dereference(sta->ptk);
|
2010-10-05 11:39:30 -06:00
|
|
|
else if (key_idx < NUM_DEFAULT_KEYS)
|
2011-05-12 07:11:37 -06:00
|
|
|
key = rcu_dereference(sta->gtk[key_idx]);
|
2007-12-18 18:03:31 -07:00
|
|
|
} else
|
2011-05-12 07:11:37 -06:00
|
|
|
key = rcu_dereference(sdata->keys[key_idx]);
|
2007-12-18 18:03:31 -07:00
|
|
|
|
|
|
|
if (!key)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
memset(¶ms, 0, sizeof(params));
|
|
|
|
|
2010-08-10 01:46:38 -06:00
|
|
|
params.cipher = key->conf.cipher;
|
2007-12-18 18:03:31 -07:00
|
|
|
|
2010-08-10 01:46:38 -06:00
|
|
|
switch (key->conf.cipher) {
|
|
|
|
case WLAN_CIPHER_SUITE_TKIP:
|
2008-05-14 17:26:19 -06:00
|
|
|
iv32 = key->u.tkip.tx.iv32;
|
|
|
|
iv16 = key->u.tkip.tx.iv16;
|
2007-12-18 18:03:31 -07:00
|
|
|
|
2009-04-23 10:52:52 -06:00
|
|
|
if (key->flags & KEY_FLAG_UPLOADED_TO_HARDWARE)
|
|
|
|
drv_get_tkip_seq(sdata->local,
|
|
|
|
key->conf.hw_key_idx,
|
|
|
|
&iv32, &iv16);
|
2007-12-18 18:03:31 -07:00
|
|
|
|
|
|
|
seq[0] = iv16 & 0xff;
|
|
|
|
seq[1] = (iv16 >> 8) & 0xff;
|
|
|
|
seq[2] = iv32 & 0xff;
|
|
|
|
seq[3] = (iv32 >> 8) & 0xff;
|
|
|
|
seq[4] = (iv32 >> 16) & 0xff;
|
|
|
|
seq[5] = (iv32 >> 24) & 0xff;
|
|
|
|
params.seq = seq;
|
|
|
|
params.seq_len = 6;
|
|
|
|
break;
|
2010-08-10 01:46:38 -06:00
|
|
|
case WLAN_CIPHER_SUITE_CCMP:
|
2011-07-06 13:59:39 -06:00
|
|
|
pn64 = atomic64_read(&key->u.ccmp.tx_pn);
|
|
|
|
seq[0] = pn64;
|
|
|
|
seq[1] = pn64 >> 8;
|
|
|
|
seq[2] = pn64 >> 16;
|
|
|
|
seq[3] = pn64 >> 24;
|
|
|
|
seq[4] = pn64 >> 32;
|
|
|
|
seq[5] = pn64 >> 40;
|
2007-12-18 18:03:31 -07:00
|
|
|
params.seq = seq;
|
|
|
|
params.seq_len = 6;
|
|
|
|
break;
|
2010-08-10 01:46:38 -06:00
|
|
|
case WLAN_CIPHER_SUITE_AES_CMAC:
|
2011-07-06 14:00:35 -06:00
|
|
|
pn64 = atomic64_read(&key->u.aes_cmac.tx_pn);
|
|
|
|
seq[0] = pn64;
|
|
|
|
seq[1] = pn64 >> 8;
|
|
|
|
seq[2] = pn64 >> 16;
|
|
|
|
seq[3] = pn64 >> 24;
|
|
|
|
seq[4] = pn64 >> 32;
|
|
|
|
seq[5] = pn64 >> 40;
|
2009-01-08 04:32:02 -07:00
|
|
|
params.seq = seq;
|
|
|
|
params.seq_len = 6;
|
|
|
|
break;
|
2007-12-18 18:03:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
params.key = key->conf.key;
|
|
|
|
params.key_len = key->conf.keylen;
|
|
|
|
|
|
|
|
callback(cookie, ¶ms);
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
out:
|
2008-04-08 09:56:52 -06:00
|
|
|
rcu_read_unlock();
|
2007-12-18 18:03:31 -07:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2007-12-18 18:03:30 -07:00
|
|
|
static int ieee80211_config_default_key(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
2010-12-09 11:58:59 -07:00
|
|
|
u8 key_idx, bool uni,
|
|
|
|
bool multi)
|
2007-12-18 18:03:30 -07:00
|
|
|
{
|
2010-06-01 02:19:19 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2008-04-08 09:56:52 -06:00
|
|
|
|
2010-12-09 11:49:02 -07:00
|
|
|
ieee80211_set_default_key(sdata, key_idx, uni, multi);
|
2007-12-18 18:03:30 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-08 04:32:02 -07:00
|
|
|
static int ieee80211_config_default_mgmt_key(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u8 key_idx)
|
|
|
|
{
|
2010-07-22 05:58:51 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2009-01-08 04:32:02 -07:00
|
|
|
|
|
|
|
ieee80211_set_default_mgmt_key(sdata, key_idx);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-27 14:08:01 -07:00
|
|
|
static void rate_idx_to_bitrate(struct rate_info *rate, struct sta_info *sta, int idx)
|
|
|
|
{
|
|
|
|
if (!(rate->flags & RATE_INFO_FLAGS_MCS)) {
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
sband = sta->local->hw.wiphy->bands[
|
|
|
|
sta->local->hw.conf.channel->band];
|
|
|
|
rate->legacy = sband->bitrates[idx].bitrate;
|
|
|
|
} else
|
|
|
|
rate->mcs = idx;
|
|
|
|
}
|
|
|
|
|
2012-03-05 16:31:48 -07:00
|
|
|
void sta_set_rate_info_tx(struct sta_info *sta,
|
|
|
|
const struct ieee80211_tx_rate *rate,
|
|
|
|
struct rate_info *rinfo)
|
|
|
|
{
|
|
|
|
rinfo->flags = 0;
|
|
|
|
if (rate->flags & IEEE80211_TX_RC_MCS)
|
|
|
|
rinfo->flags |= RATE_INFO_FLAGS_MCS;
|
|
|
|
if (rate->flags & IEEE80211_TX_RC_40_MHZ_WIDTH)
|
|
|
|
rinfo->flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
|
|
|
|
if (rate->flags & IEEE80211_TX_RC_SHORT_GI)
|
|
|
|
rinfo->flags |= RATE_INFO_FLAGS_SHORT_GI;
|
|
|
|
rate_idx_to_bitrate(rinfo, sta, rate->idx);
|
|
|
|
}
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
static void sta_set_sinfo(struct sta_info *sta, struct station_info *sinfo)
|
|
|
|
{
|
2008-02-25 08:27:46 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2011-04-08 09:54:24 -06:00
|
|
|
struct timespec uptime;
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2009-08-07 08:17:38 -06:00
|
|
|
sinfo->generation = sdata->local->sta_generation;
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
sinfo->filled = STATION_INFO_INACTIVE_TIME |
|
|
|
|
STATION_INFO_RX_BYTES |
|
2008-12-11 14:04:19 -07:00
|
|
|
STATION_INFO_TX_BYTES |
|
2009-02-17 04:24:57 -07:00
|
|
|
STATION_INFO_RX_PACKETS |
|
|
|
|
STATION_INFO_TX_PACKETS |
|
2010-10-06 03:34:12 -06:00
|
|
|
STATION_INFO_TX_RETRIES |
|
|
|
|
STATION_INFO_TX_FAILED |
|
2010-10-07 17:39:20 -06:00
|
|
|
STATION_INFO_TX_BITRATE |
|
2011-02-27 14:08:01 -07:00
|
|
|
STATION_INFO_RX_BITRATE |
|
2011-03-31 10:25:41 -06:00
|
|
|
STATION_INFO_RX_DROP_MISC |
|
2011-04-08 09:54:24 -06:00
|
|
|
STATION_INFO_BSS_PARAM |
|
2011-10-13 08:30:40 -06:00
|
|
|
STATION_INFO_CONNECTED_TIME |
|
2011-12-09 12:01:49 -07:00
|
|
|
STATION_INFO_STA_FLAGS |
|
|
|
|
STATION_INFO_BEACON_LOSS_COUNT;
|
2011-04-08 09:54:24 -06:00
|
|
|
|
|
|
|
do_posix_clock_monotonic_gettime(&uptime);
|
|
|
|
sinfo->connected_time = uptime.tv_sec - sta->last_connected;
|
2008-02-23 07:17:17 -07:00
|
|
|
|
|
|
|
sinfo->inactive_time = jiffies_to_msecs(jiffies - sta->last_rx);
|
|
|
|
sinfo->rx_bytes = sta->rx_bytes;
|
|
|
|
sinfo->tx_bytes = sta->tx_bytes;
|
2009-02-17 04:24:57 -07:00
|
|
|
sinfo->rx_packets = sta->rx_packets;
|
|
|
|
sinfo->tx_packets = sta->tx_packets;
|
2010-10-06 03:34:12 -06:00
|
|
|
sinfo->tx_retries = sta->tx_retry_count;
|
|
|
|
sinfo->tx_failed = sta->tx_retry_failed;
|
2010-10-07 17:39:20 -06:00
|
|
|
sinfo->rx_dropped_misc = sta->rx_dropped;
|
2011-12-09 12:01:49 -07:00
|
|
|
sinfo->beacon_loss_count = sta->beacon_loss_count;
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2009-12-08 15:10:13 -07:00
|
|
|
if ((sta->local->hw.flags & IEEE80211_HW_SIGNAL_DBM) ||
|
|
|
|
(sta->local->hw.flags & IEEE80211_HW_SIGNAL_UNSPEC)) {
|
2010-12-02 03:12:43 -07:00
|
|
|
sinfo->filled |= STATION_INFO_SIGNAL | STATION_INFO_SIGNAL_AVG;
|
2008-12-11 14:04:19 -07:00
|
|
|
sinfo->signal = (s8)sta->last_signal;
|
2010-12-02 03:12:43 -07:00
|
|
|
sinfo->signal_avg = (s8) -ewma_read(&sta->avg_signal);
|
2008-12-11 14:04:19 -07:00
|
|
|
}
|
|
|
|
|
2012-03-05 16:31:48 -07:00
|
|
|
sta_set_rate_info_tx(sta, &sta->last_tx_rate, &sinfo->txrate);
|
2011-02-27 14:08:01 -07:00
|
|
|
|
|
|
|
sinfo->rxrate.flags = 0;
|
|
|
|
if (sta->last_rx_rate_flag & RX_FLAG_HT)
|
|
|
|
sinfo->rxrate.flags |= RATE_INFO_FLAGS_MCS;
|
|
|
|
if (sta->last_rx_rate_flag & RX_FLAG_40MHZ)
|
|
|
|
sinfo->rxrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
|
|
|
|
if (sta->last_rx_rate_flag & RX_FLAG_SHORT_GI)
|
|
|
|
sinfo->rxrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
|
|
|
|
rate_idx_to_bitrate(&sinfo->rxrate, sta, sta->last_rx_rate_idx);
|
2008-12-11 14:04:19 -07:00
|
|
|
|
2008-02-23 07:17:19 -07:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
2008-02-23 07:17:17 -07:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
|
|
|
sinfo->filled |= STATION_INFO_LLID |
|
|
|
|
STATION_INFO_PLID |
|
|
|
|
STATION_INFO_PLINK_STATE;
|
|
|
|
|
|
|
|
sinfo->llid = le16_to_cpu(sta->llid);
|
|
|
|
sinfo->plid = le16_to_cpu(sta->plid);
|
|
|
|
sinfo->plink_state = sta->plink_state;
|
2012-03-31 12:31:33 -06:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_TOFFSET_KNOWN)) {
|
|
|
|
sinfo->filled |= STATION_INFO_T_OFFSET;
|
|
|
|
sinfo->t_offset = sta->t_offset;
|
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
#endif
|
2008-02-23 07:17:19 -07:00
|
|
|
}
|
2011-03-31 10:25:41 -06:00
|
|
|
|
|
|
|
sinfo->bss_param.flags = 0;
|
|
|
|
if (sdata->vif.bss_conf.use_cts_prot)
|
|
|
|
sinfo->bss_param.flags |= BSS_PARAM_FLAGS_CTS_PROT;
|
|
|
|
if (sdata->vif.bss_conf.use_short_preamble)
|
|
|
|
sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_PREAMBLE;
|
|
|
|
if (sdata->vif.bss_conf.use_short_slot)
|
|
|
|
sinfo->bss_param.flags |= BSS_PARAM_FLAGS_SHORT_SLOT_TIME;
|
|
|
|
sinfo->bss_param.dtim_period = sdata->local->hw.conf.ps_dtim_period;
|
|
|
|
sinfo->bss_param.beacon_interval = sdata->vif.bss_conf.beacon_int;
|
2011-10-13 08:30:40 -06:00
|
|
|
|
|
|
|
sinfo->sta_flags.set = 0;
|
|
|
|
sinfo->sta_flags.mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
|
|
|
|
BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
|
|
|
|
BIT(NL80211_STA_FLAG_WME) |
|
|
|
|
BIT(NL80211_STA_FLAG_MFP) |
|
2011-11-05 07:15:24 -06:00
|
|
|
BIT(NL80211_STA_FLAG_AUTHENTICATED) |
|
|
|
|
BIT(NL80211_STA_FLAG_TDLS_PEER);
|
2011-10-13 08:30:40 -06:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
|
|
|
|
sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHORIZED);
|
|
|
|
if (test_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE))
|
|
|
|
sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_SHORT_PREAMBLE);
|
|
|
|
if (test_sta_flag(sta, WLAN_STA_WME))
|
|
|
|
sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_WME);
|
|
|
|
if (test_sta_flag(sta, WLAN_STA_MFP))
|
|
|
|
sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_MFP);
|
|
|
|
if (test_sta_flag(sta, WLAN_STA_AUTH))
|
|
|
|
sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_AUTHENTICATED);
|
2011-11-05 07:15:24 -06:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_TDLS_PEER))
|
|
|
|
sinfo->sta_flags.set |= BIT(NL80211_STA_FLAG_TDLS_PEER);
|
2008-02-23 07:17:17 -07:00
|
|
|
}
|
|
|
|
|
2012-04-23 13:50:30 -06:00
|
|
|
static const char ieee80211_gstrings_sta_stats[][ETH_GSTRING_LEN] = {
|
|
|
|
"rx_packets", "rx_bytes", "wep_weak_iv_count",
|
|
|
|
"rx_duplicates", "rx_fragments", "rx_dropped",
|
|
|
|
"tx_packets", "tx_bytes", "tx_fragments",
|
|
|
|
"tx_filtered", "tx_retry_failed", "tx_retries",
|
2012-04-23 13:50:32 -06:00
|
|
|
"beacon_loss", "sta_state", "txrate", "rxrate", "signal",
|
|
|
|
"channel", "noise", "ch_time", "ch_time_busy",
|
|
|
|
"ch_time_ext_busy", "ch_time_rx", "ch_time_tx"
|
2012-04-23 13:50:30 -06:00
|
|
|
};
|
|
|
|
#define STA_STATS_LEN ARRAY_SIZE(ieee80211_gstrings_sta_stats)
|
|
|
|
|
|
|
|
static int ieee80211_get_et_sset_count(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
int sset)
|
|
|
|
{
|
2012-04-23 13:50:31 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
int rv = 0;
|
|
|
|
|
2012-04-23 13:50:30 -06:00
|
|
|
if (sset == ETH_SS_STATS)
|
2012-04-23 13:50:31 -06:00
|
|
|
rv += STA_STATS_LEN;
|
|
|
|
|
|
|
|
rv += drv_get_et_sset_count(sdata, sset);
|
2012-04-23 13:50:30 -06:00
|
|
|
|
2012-04-23 13:50:31 -06:00
|
|
|
if (rv == 0)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return rv;
|
2012-04-23 13:50:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_get_et_stats(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct ethtool_stats *stats,
|
|
|
|
u64 *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct sta_info *sta;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2012-04-23 13:50:32 -06:00
|
|
|
struct station_info sinfo;
|
|
|
|
struct survey_info survey;
|
|
|
|
int i, q;
|
|
|
|
#define STA_STATS_SURVEY_LEN 7
|
2012-04-23 13:50:30 -06:00
|
|
|
|
|
|
|
memset(data, 0, sizeof(u64) * STA_STATS_LEN);
|
|
|
|
|
|
|
|
#define ADD_STA_STATS(sta) \
|
|
|
|
do { \
|
|
|
|
data[i++] += sta->rx_packets; \
|
|
|
|
data[i++] += sta->rx_bytes; \
|
|
|
|
data[i++] += sta->wep_weak_iv_count; \
|
|
|
|
data[i++] += sta->num_duplicates; \
|
|
|
|
data[i++] += sta->rx_fragments; \
|
|
|
|
data[i++] += sta->rx_dropped; \
|
|
|
|
\
|
|
|
|
data[i++] += sta->tx_packets; \
|
|
|
|
data[i++] += sta->tx_bytes; \
|
|
|
|
data[i++] += sta->tx_fragments; \
|
|
|
|
data[i++] += sta->tx_filtered_count; \
|
|
|
|
data[i++] += sta->tx_retry_failed; \
|
|
|
|
data[i++] += sta->tx_retry_count; \
|
|
|
|
data[i++] += sta->beacon_loss_count; \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
/* For Managed stations, find the single station based on BSSID
|
|
|
|
* and use that. For interface types, iterate through all available
|
|
|
|
* stations and add stats for any station that is assigned to this
|
|
|
|
* network device.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION) {
|
|
|
|
sta = sta_info_get_bss(sdata, sdata->u.mgd.bssid);
|
2012-04-23 13:50:32 -06:00
|
|
|
|
|
|
|
if (!(sta && !WARN_ON(sta->sdata->dev != dev)))
|
|
|
|
goto do_survey;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
ADD_STA_STATS(sta);
|
|
|
|
|
|
|
|
data[i++] = sta->sta_state;
|
|
|
|
|
|
|
|
sinfo.filled = 0;
|
|
|
|
sta_set_sinfo(sta, &sinfo);
|
|
|
|
|
2012-05-30 14:25:54 -06:00
|
|
|
if (sinfo.filled & STATION_INFO_TX_BITRATE)
|
2012-04-23 13:50:32 -06:00
|
|
|
data[i] = 100000 *
|
|
|
|
cfg80211_calculate_bitrate(&sinfo.txrate);
|
|
|
|
i++;
|
2012-05-30 14:25:54 -06:00
|
|
|
if (sinfo.filled & STATION_INFO_RX_BITRATE)
|
2012-04-23 13:50:32 -06:00
|
|
|
data[i] = 100000 *
|
|
|
|
cfg80211_calculate_bitrate(&sinfo.rxrate);
|
|
|
|
i++;
|
|
|
|
|
2012-05-30 14:25:54 -06:00
|
|
|
if (sinfo.filled & STATION_INFO_SIGNAL_AVG)
|
2012-04-23 13:50:32 -06:00
|
|
|
data[i] = (u8)sinfo.signal_avg;
|
|
|
|
i++;
|
2012-04-23 13:50:30 -06:00
|
|
|
} else {
|
|
|
|
list_for_each_entry_rcu(sta, &local->sta_list, list) {
|
|
|
|
/* Make sure this station belongs to the proper dev */
|
|
|
|
if (sta->sdata->dev != dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
ADD_STA_STATS(sta);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-23 13:50:32 -06:00
|
|
|
do_survey:
|
|
|
|
i = STA_STATS_LEN - STA_STATS_SURVEY_LEN;
|
|
|
|
/* Get survey stats for current channel */
|
|
|
|
q = 0;
|
|
|
|
while (true) {
|
|
|
|
survey.filled = 0;
|
|
|
|
if (drv_get_survey(local, q, &survey) != 0) {
|
|
|
|
survey.filled = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (survey.channel &&
|
|
|
|
(local->oper_channel->center_freq ==
|
|
|
|
survey.channel->center_freq))
|
|
|
|
break;
|
|
|
|
q++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (survey.filled)
|
|
|
|
data[i++] = survey.channel->center_freq;
|
|
|
|
else
|
|
|
|
data[i++] = 0;
|
|
|
|
if (survey.filled & SURVEY_INFO_NOISE_DBM)
|
|
|
|
data[i++] = (u8)survey.noise;
|
|
|
|
else
|
|
|
|
data[i++] = -1LL;
|
|
|
|
if (survey.filled & SURVEY_INFO_CHANNEL_TIME)
|
|
|
|
data[i++] = survey.channel_time;
|
|
|
|
else
|
|
|
|
data[i++] = -1LL;
|
|
|
|
if (survey.filled & SURVEY_INFO_CHANNEL_TIME_BUSY)
|
|
|
|
data[i++] = survey.channel_time_busy;
|
|
|
|
else
|
|
|
|
data[i++] = -1LL;
|
|
|
|
if (survey.filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY)
|
|
|
|
data[i++] = survey.channel_time_ext_busy;
|
|
|
|
else
|
|
|
|
data[i++] = -1LL;
|
|
|
|
if (survey.filled & SURVEY_INFO_CHANNEL_TIME_RX)
|
|
|
|
data[i++] = survey.channel_time_rx;
|
|
|
|
else
|
|
|
|
data[i++] = -1LL;
|
|
|
|
if (survey.filled & SURVEY_INFO_CHANNEL_TIME_TX)
|
|
|
|
data[i++] = survey.channel_time_tx;
|
|
|
|
else
|
|
|
|
data[i++] = -1LL;
|
|
|
|
|
2012-04-23 13:50:30 -06:00
|
|
|
rcu_read_unlock();
|
2012-04-23 13:50:31 -06:00
|
|
|
|
2012-04-23 13:50:32 -06:00
|
|
|
if (WARN_ON(i != STA_STATS_LEN))
|
|
|
|
return;
|
|
|
|
|
2012-04-23 13:50:31 -06:00
|
|
|
drv_get_et_stats(sdata, stats, &(data[STA_STATS_LEN]));
|
2012-04-23 13:50:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_get_et_strings(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u32 sset, u8 *data)
|
|
|
|
{
|
2012-04-23 13:50:31 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
int sz_sta_stats = 0;
|
|
|
|
|
2012-04-23 13:50:30 -06:00
|
|
|
if (sset == ETH_SS_STATS) {
|
2012-04-23 13:50:31 -06:00
|
|
|
sz_sta_stats = sizeof(ieee80211_gstrings_sta_stats);
|
2012-04-23 13:50:30 -06:00
|
|
|
memcpy(data, *ieee80211_gstrings_sta_stats, sz_sta_stats);
|
|
|
|
}
|
2012-04-23 13:50:31 -06:00
|
|
|
drv_get_et_strings(sdata, sset, &(data[sz_sta_stats]));
|
2012-04-23 13:50:30 -06:00
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
|
|
|
|
static int ieee80211_dump_station(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
int idx, u8 *mac, struct station_info *sinfo)
|
|
|
|
{
|
2009-11-16 04:00:37 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2008-02-23 07:17:17 -07:00
|
|
|
struct sta_info *sta;
|
2008-02-25 08:27:46 -07:00
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2009-11-16 04:00:37 -07:00
|
|
|
sta = sta_info_get_by_idx(sdata, idx);
|
2008-02-25 08:27:46 -07:00
|
|
|
if (sta) {
|
|
|
|
ret = 0;
|
2008-09-10 16:02:02 -06:00
|
|
|
memcpy(mac, sta->sta.addr, ETH_ALEN);
|
2008-02-25 08:27:46 -07:00
|
|
|
sta_set_sinfo(sta, sinfo);
|
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
rcu_read_unlock();
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
return ret;
|
2008-02-23 07:17:17 -07:00
|
|
|
}
|
|
|
|
|
2010-04-19 02:23:57 -06:00
|
|
|
static int ieee80211_dump_survey(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
int idx, struct survey_info *survey)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
|
|
|
|
|
|
|
return drv_get_survey(local, idx, survey);
|
|
|
|
}
|
|
|
|
|
2007-12-18 18:03:37 -07:00
|
|
|
static int ieee80211_get_station(struct wiphy *wiphy, struct net_device *dev,
|
2008-02-23 07:17:06 -07:00
|
|
|
u8 *mac, struct station_info *sinfo)
|
2007-12-18 18:03:37 -07:00
|
|
|
{
|
2009-11-25 09:46:18 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2007-12-18 18:03:37 -07:00
|
|
|
struct sta_info *sta;
|
2008-02-25 08:27:46 -07:00
|
|
|
int ret = -ENOENT;
|
2007-12-18 18:03:37 -07:00
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
rcu_read_lock();
|
2007-12-18 18:03:37 -07:00
|
|
|
|
2010-01-08 10:10:58 -07:00
|
|
|
sta = sta_info_get_bss(sdata, mac);
|
2008-02-25 08:27:46 -07:00
|
|
|
if (sta) {
|
|
|
|
ret = 0;
|
|
|
|
sta_set_sinfo(sta, sinfo);
|
|
|
|
}
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return ret;
|
2007-12-18 18:03:37 -07:00
|
|
|
}
|
|
|
|
|
2011-11-10 02:28:57 -07:00
|
|
|
static int ieee80211_set_probe_resp(struct ieee80211_sub_if_data *sdata,
|
2012-02-13 07:17:18 -07:00
|
|
|
const u8 *resp, size_t resp_len)
|
2011-11-10 02:28:57 -07:00
|
|
|
{
|
|
|
|
struct sk_buff *new, *old;
|
|
|
|
|
|
|
|
if (!resp || !resp_len)
|
2012-02-13 07:17:18 -07:00
|
|
|
return 1;
|
2011-11-10 02:28:57 -07:00
|
|
|
|
2011-11-19 01:51:26 -07:00
|
|
|
old = rtnl_dereference(sdata->u.ap.probe_resp);
|
2011-11-10 02:28:57 -07:00
|
|
|
|
|
|
|
new = dev_alloc_skb(resp_len);
|
|
|
|
if (!new)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
memcpy(skb_put(new, resp_len), resp, resp_len);
|
|
|
|
|
|
|
|
rcu_assign_pointer(sdata->u.ap.probe_resp, new);
|
2012-02-13 07:17:18 -07:00
|
|
|
if (old) {
|
|
|
|
/* TODO: use call_rcu() */
|
|
|
|
synchronize_rcu();
|
2011-11-10 02:28:57 -07:00
|
|
|
dev_kfree_skb(old);
|
2012-02-13 07:17:18 -07:00
|
|
|
}
|
2011-11-10 02:28:57 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
static int ieee80211_assign_beacon(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct cfg80211_beacon_data *params)
|
2007-12-18 18:03:33 -07:00
|
|
|
{
|
|
|
|
struct beacon_data *new, *old;
|
|
|
|
int new_head_len, new_tail_len;
|
2012-02-13 07:17:18 -07:00
|
|
|
int size, err;
|
|
|
|
u32 changed = BSS_CHANGED_BEACON;
|
2007-12-18 18:03:33 -07:00
|
|
|
|
2011-05-13 06:15:49 -06:00
|
|
|
old = rtnl_dereference(sdata->u.ap.beacon);
|
2007-12-18 18:03:33 -07:00
|
|
|
|
|
|
|
/* Need to have a beacon head if we don't have one yet */
|
|
|
|
if (!params->head && !old)
|
2012-02-13 07:17:18 -07:00
|
|
|
return -EINVAL;
|
2007-12-18 18:03:33 -07:00
|
|
|
|
|
|
|
/* new or old head? */
|
|
|
|
if (params->head)
|
|
|
|
new_head_len = params->head_len;
|
|
|
|
else
|
|
|
|
new_head_len = old->head_len;
|
|
|
|
|
|
|
|
/* new or old tail? */
|
|
|
|
if (params->tail || !old)
|
|
|
|
/* params->tail_len will be zero for !params->tail */
|
|
|
|
new_tail_len = params->tail_len;
|
|
|
|
else
|
|
|
|
new_tail_len = old->tail_len;
|
|
|
|
|
|
|
|
size = sizeof(*new) + new_head_len + new_tail_len;
|
|
|
|
|
|
|
|
new = kzalloc(size, GFP_KERNEL);
|
|
|
|
if (!new)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* start filling the new info now */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pointers go into the block we allocated,
|
|
|
|
* memory is | beacon_data | head | tail |
|
|
|
|
*/
|
|
|
|
new->head = ((u8 *) new) + sizeof(*new);
|
|
|
|
new->tail = new->head + new_head_len;
|
|
|
|
new->head_len = new_head_len;
|
|
|
|
new->tail_len = new_tail_len;
|
|
|
|
|
|
|
|
/* copy in head */
|
|
|
|
if (params->head)
|
|
|
|
memcpy(new->head, params->head, new_head_len);
|
|
|
|
else
|
|
|
|
memcpy(new->head, old->head, new_head_len);
|
|
|
|
|
|
|
|
/* copy in optional tail */
|
|
|
|
if (params->tail)
|
|
|
|
memcpy(new->tail, params->tail, new_tail_len);
|
|
|
|
else
|
|
|
|
if (old)
|
|
|
|
memcpy(new->tail, old->tail, new_tail_len);
|
|
|
|
|
2011-11-10 02:28:57 -07:00
|
|
|
err = ieee80211_set_probe_resp(sdata, params->probe_resp,
|
|
|
|
params->probe_resp_len);
|
2012-02-13 07:17:18 -07:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (err == 0)
|
2011-11-10 02:28:57 -07:00
|
|
|
changed |= BSS_CHANGED_AP_PROBE_RESP;
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
rcu_assign_pointer(sdata->u.ap.beacon, new);
|
|
|
|
|
|
|
|
if (old)
|
|
|
|
kfree_rcu(old, rcu_head);
|
2011-09-04 02:11:32 -06:00
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
return changed;
|
2007-12-18 18:03:33 -07:00
|
|
|
}
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
static int ieee80211_start_ap(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
struct cfg80211_ap_settings *params)
|
2007-12-18 18:03:33 -07:00
|
|
|
{
|
2012-02-13 07:17:18 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2007-12-18 18:03:33 -07:00
|
|
|
struct beacon_data *old;
|
2011-11-04 04:18:11 -06:00
|
|
|
struct ieee80211_sub_if_data *vlan;
|
2012-02-13 07:17:18 -07:00
|
|
|
u32 changed = BSS_CHANGED_BEACON_INT |
|
|
|
|
BSS_CHANGED_BEACON_ENABLED |
|
|
|
|
BSS_CHANGED_BEACON |
|
|
|
|
BSS_CHANGED_SSID;
|
|
|
|
int err;
|
2008-07-29 05:22:52 -06:00
|
|
|
|
2011-05-13 06:15:49 -06:00
|
|
|
old = rtnl_dereference(sdata->u.ap.beacon);
|
2007-12-18 18:03:33 -07:00
|
|
|
if (old)
|
|
|
|
return -EALREADY;
|
|
|
|
|
2011-11-04 04:18:11 -06:00
|
|
|
/*
|
|
|
|
* Apply control port protocol, this allows us to
|
|
|
|
* not encrypt dynamic WEP control frames.
|
|
|
|
*/
|
|
|
|
sdata->control_port_protocol = params->crypto.control_port_ethertype;
|
|
|
|
sdata->control_port_no_encrypt = params->crypto.control_port_no_encrypt;
|
|
|
|
list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list) {
|
|
|
|
vlan->control_port_protocol =
|
|
|
|
params->crypto.control_port_ethertype;
|
|
|
|
vlan->control_port_no_encrypt =
|
|
|
|
params->crypto.control_port_no_encrypt;
|
|
|
|
}
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
sdata->vif.bss_conf.beacon_int = params->beacon_interval;
|
|
|
|
sdata->vif.bss_conf.dtim_period = params->dtim_period;
|
|
|
|
|
|
|
|
sdata->vif.bss_conf.ssid_len = params->ssid_len;
|
|
|
|
if (params->ssid_len)
|
|
|
|
memcpy(sdata->vif.bss_conf.ssid, params->ssid,
|
|
|
|
params->ssid_len);
|
|
|
|
sdata->vif.bss_conf.hidden_ssid =
|
|
|
|
(params->hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE);
|
|
|
|
|
|
|
|
err = ieee80211_assign_beacon(sdata, ¶ms->beacon);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
changed |= err;
|
|
|
|
|
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
|
|
|
|
2012-04-03 02:24:00 -06:00
|
|
|
netif_carrier_on(dev);
|
|
|
|
list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
|
|
|
|
netif_carrier_on(vlan->dev);
|
|
|
|
|
2011-11-04 04:18:11 -06:00
|
|
|
return 0;
|
2007-12-18 18:03:33 -07:00
|
|
|
}
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
static int ieee80211_change_beacon(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
struct cfg80211_beacon_data *params)
|
2007-12-18 18:03:33 -07:00
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-18 18:03:33 -07:00
|
|
|
struct beacon_data *old;
|
2012-02-13 07:17:18 -07:00
|
|
|
int err;
|
2007-12-18 18:03:33 -07:00
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2011-05-13 06:15:49 -06:00
|
|
|
old = rtnl_dereference(sdata->u.ap.beacon);
|
2007-12-18 18:03:33 -07:00
|
|
|
if (!old)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
err = ieee80211_assign_beacon(sdata, params);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
ieee80211_bss_info_change_notify(sdata, err);
|
|
|
|
return 0;
|
2007-12-18 18:03:33 -07:00
|
|
|
}
|
|
|
|
|
2012-02-13 07:17:18 -07:00
|
|
|
static int ieee80211_stop_ap(struct wiphy *wiphy, struct net_device *dev)
|
2007-12-18 18:03:33 -07:00
|
|
|
{
|
2012-04-03 02:24:00 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata, *vlan;
|
2007-12-18 18:03:33 -07:00
|
|
|
struct beacon_data *old;
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2011-05-13 06:15:49 -06:00
|
|
|
old = rtnl_dereference(sdata->u.ap.beacon);
|
2007-12-18 18:03:33 -07:00
|
|
|
if (!old)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2012-04-03 02:24:00 -06:00
|
|
|
list_for_each_entry(vlan, &sdata->u.ap.vlans, u.vlan.list)
|
|
|
|
netif_carrier_off(vlan->dev);
|
|
|
|
netif_carrier_off(dev);
|
|
|
|
|
2011-08-01 10:19:00 -06:00
|
|
|
RCU_INIT_POINTER(sdata->u.ap.beacon, NULL);
|
2012-02-13 07:17:18 -07:00
|
|
|
|
|
|
|
kfree_rcu(old, rcu_head);
|
2007-12-18 18:03:33 -07:00
|
|
|
|
2009-04-23 08:13:26 -06:00
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED);
|
2012-02-13 07:17:18 -07:00
|
|
|
|
2009-04-23 08:13:26 -06:00
|
|
|
return 0;
|
2007-12-18 18:03:33 -07:00
|
|
|
}
|
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
/* Layer 2 Update frame (802.2 Type 1 LLC XID Update response) */
|
|
|
|
struct iapp_layer2_update {
|
|
|
|
u8 da[ETH_ALEN]; /* broadcast */
|
|
|
|
u8 sa[ETH_ALEN]; /* STA addr */
|
|
|
|
__be16 len; /* 6 */
|
|
|
|
u8 dsap; /* 0 */
|
|
|
|
u8 ssap; /* 0 */
|
|
|
|
u8 control;
|
|
|
|
u8 xid_info[3];
|
2010-06-03 04:21:52 -06:00
|
|
|
} __packed;
|
2007-12-18 18:03:35 -07:00
|
|
|
|
|
|
|
static void ieee80211_send_layer2_update(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
struct iapp_layer2_update *msg;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
/* Send Level 2 Update Frame to update forwarding tables in layer 2
|
|
|
|
* bridge devices */
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(sizeof(*msg));
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
msg = (struct iapp_layer2_update *)skb_put(skb, sizeof(*msg));
|
|
|
|
|
|
|
|
/* 802.2 Type 1 Logical Link Control (LLC) Exchange Identifier (XID)
|
|
|
|
* Update response frame; IEEE Std 802.2-1998, 5.4.1.2.1 */
|
|
|
|
|
|
|
|
memset(msg->da, 0xff, ETH_ALEN);
|
2008-09-10 16:02:02 -06:00
|
|
|
memcpy(msg->sa, sta->sta.addr, ETH_ALEN);
|
2007-12-18 18:03:35 -07:00
|
|
|
msg->len = htons(6);
|
|
|
|
msg->dsap = 0;
|
|
|
|
msg->ssap = 0x01; /* NULL LSAP, CR Bit: Response */
|
|
|
|
msg->control = 0xaf; /* XID response lsb.1111F101.
|
|
|
|
* F=0 (no poll command; unsolicited frame) */
|
|
|
|
msg->xid_info[0] = 0x81; /* XID format identifier */
|
|
|
|
msg->xid_info[1] = 1; /* LLC types/classes: Type 1 LLC */
|
|
|
|
msg->xid_info[2] = 0; /* XID sender's receive window size (RW) */
|
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
skb->dev = sta->sdata->dev;
|
|
|
|
skb->protocol = eth_type_trans(skb, sta->sdata->dev);
|
2007-12-18 18:03:35 -07:00
|
|
|
memset(skb->cb, 0, sizeof(skb->cb));
|
2010-07-19 09:52:59 -06:00
|
|
|
netif_rx_ni(skb);
|
2007-12-18 18:03:35 -07:00
|
|
|
}
|
|
|
|
|
2011-12-14 04:35:30 -07:00
|
|
|
static int sta_apply_parameters(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta,
|
|
|
|
struct station_parameters *params)
|
2007-12-18 18:03:35 -07:00
|
|
|
{
|
2011-12-14 04:35:30 -07:00
|
|
|
int ret = 0;
|
2007-12-18 18:03:35 -07:00
|
|
|
u32 rates;
|
|
|
|
int i, j;
|
2008-01-24 11:38:38 -07:00
|
|
|
struct ieee80211_supported_band *sband;
|
2008-02-25 08:27:46 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2009-05-11 12:57:56 -06:00
|
|
|
u32 mask, set;
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2008-10-14 08:58:37 -06:00
|
|
|
sband = local->hw.wiphy->bands[local->oper_channel->band];
|
|
|
|
|
2009-05-11 12:57:56 -06:00
|
|
|
mask = params->sta_flags_mask;
|
|
|
|
set = params->sta_flags_set;
|
2008-02-25 08:27:47 -07:00
|
|
|
|
2011-12-14 04:35:30 -07:00
|
|
|
/*
|
|
|
|
* In mesh mode, we can clear AUTHENTICATED flag but must
|
|
|
|
* also make ASSOCIATED follow appropriately for the driver
|
|
|
|
* API. See also below, after AUTHORIZED changes.
|
|
|
|
*/
|
|
|
|
if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) {
|
|
|
|
/* cfg80211 should not allow this in non-mesh modes */
|
|
|
|
if (WARN_ON(!ieee80211_vif_is_mesh(&sdata->vif)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (set & BIT(NL80211_STA_FLAG_AUTHENTICATED) &&
|
|
|
|
!test_sta_flag(sta, WLAN_STA_AUTH)) {
|
2012-01-12 01:31:10 -07:00
|
|
|
ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
|
2011-12-14 04:35:30 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-01-12 01:31:10 -07:00
|
|
|
ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
|
2011-12-14 04:35:30 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-11 12:57:56 -06:00
|
|
|
if (mask & BIT(NL80211_STA_FLAG_AUTHORIZED)) {
|
|
|
|
if (set & BIT(NL80211_STA_FLAG_AUTHORIZED))
|
2012-01-12 01:31:10 -07:00
|
|
|
ret = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
|
2012-01-13 06:17:59 -07:00
|
|
|
else if (test_sta_flag(sta, WLAN_STA_AUTHORIZED))
|
2012-01-12 01:31:10 -07:00
|
|
|
ret = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
|
2011-12-14 04:35:30 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mask & BIT(NL80211_STA_FLAG_AUTHENTICATED)) {
|
|
|
|
/* cfg80211 should not allow this in non-mesh modes */
|
|
|
|
if (WARN_ON(!ieee80211_vif_is_mesh(&sdata->vif)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!(set & BIT(NL80211_STA_FLAG_AUTHENTICATED)) &&
|
|
|
|
test_sta_flag(sta, WLAN_STA_AUTH)) {
|
2012-01-12 01:31:10 -07:00
|
|
|
ret = sta_info_move_state(sta, IEEE80211_STA_AUTH);
|
2011-12-14 04:35:30 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-01-12 01:31:10 -07:00
|
|
|
ret = sta_info_move_state(sta, IEEE80211_STA_NONE);
|
2011-12-14 04:35:30 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-05-11 12:57:56 -06:00
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-12-14 04:35:30 -07:00
|
|
|
|
2009-05-11 12:57:56 -06:00
|
|
|
if (mask & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE)) {
|
|
|
|
if (set & BIT(NL80211_STA_FLAG_SHORT_PREAMBLE))
|
2011-09-29 08:04:36 -06:00
|
|
|
set_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
|
|
|
|
else
|
|
|
|
clear_sta_flag(sta, WLAN_STA_SHORT_PREAMBLE);
|
2009-05-11 12:57:56 -06:00
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2009-05-11 12:57:56 -06:00
|
|
|
if (mask & BIT(NL80211_STA_FLAG_WME)) {
|
2011-06-27 14:58:45 -06:00
|
|
|
if (set & BIT(NL80211_STA_FLAG_WME)) {
|
2011-09-29 08:04:36 -06:00
|
|
|
set_sta_flag(sta, WLAN_STA_WME);
|
2011-06-27 14:58:45 -06:00
|
|
|
sta->sta.wme = true;
|
2011-09-29 08:04:36 -06:00
|
|
|
} else {
|
|
|
|
clear_sta_flag(sta, WLAN_STA_WME);
|
|
|
|
sta->sta.wme = false;
|
2011-06-27 14:58:45 -06:00
|
|
|
}
|
2009-05-11 12:57:56 -06:00
|
|
|
}
|
2009-01-08 04:31:59 -07:00
|
|
|
|
2009-05-11 12:57:56 -06:00
|
|
|
if (mask & BIT(NL80211_STA_FLAG_MFP)) {
|
|
|
|
if (set & BIT(NL80211_STA_FLAG_MFP))
|
2011-09-29 08:04:36 -06:00
|
|
|
set_sta_flag(sta, WLAN_STA_MFP);
|
|
|
|
else
|
|
|
|
clear_sta_flag(sta, WLAN_STA_MFP);
|
2007-12-18 18:03:35 -07:00
|
|
|
}
|
2011-04-07 16:08:30 -06:00
|
|
|
|
2011-09-28 05:12:53 -06:00
|
|
|
if (mask & BIT(NL80211_STA_FLAG_TDLS_PEER)) {
|
|
|
|
if (set & BIT(NL80211_STA_FLAG_TDLS_PEER))
|
2011-09-29 08:04:36 -06:00
|
|
|
set_sta_flag(sta, WLAN_STA_TDLS_PEER);
|
|
|
|
else
|
|
|
|
clear_sta_flag(sta, WLAN_STA_TDLS_PEER);
|
2011-09-28 05:12:53 -06:00
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-09-27 12:56:12 -06:00
|
|
|
if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) {
|
|
|
|
sta->sta.uapsd_queues = params->uapsd_queues;
|
|
|
|
sta->sta.max_sp = params->max_sp;
|
|
|
|
}
|
2011-08-23 05:37:47 -06:00
|
|
|
|
2009-05-24 08:42:30 -06:00
|
|
|
/*
|
|
|
|
* cfg80211 validates this (1-2007) and allows setting the AID
|
|
|
|
* only when creating a new station entry
|
|
|
|
*/
|
|
|
|
if (params->aid)
|
|
|
|
sta->sta.aid = params->aid;
|
|
|
|
|
2008-02-25 08:27:47 -07:00
|
|
|
/*
|
|
|
|
* FIXME: updating the following information is racy when this
|
|
|
|
* function is called from ieee80211_change_station().
|
|
|
|
* However, all this information should be static so
|
|
|
|
* maybe we should just reject attemps to change it.
|
|
|
|
*/
|
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
if (params->listen_interval >= 0)
|
|
|
|
sta->listen_interval = params->listen_interval;
|
|
|
|
|
|
|
|
if (params->supported_rates) {
|
|
|
|
rates = 0;
|
2008-01-24 11:38:38 -07:00
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
for (i = 0; i < params->supported_rates_len; i++) {
|
|
|
|
int rate = (params->supported_rates[i] & 0x7f) * 5;
|
2008-01-24 11:38:38 -07:00
|
|
|
for (j = 0; j < sband->n_bitrates; j++) {
|
|
|
|
if (sband->bitrates[j].bitrate == rate)
|
2007-12-18 18:03:35 -07:00
|
|
|
rates |= BIT(j);
|
|
|
|
}
|
|
|
|
}
|
2008-09-10 18:45:11 -06:00
|
|
|
sta->sta.supp_rates[local->oper_channel->band] = rates;
|
2007-12-18 18:03:35 -07:00
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2008-10-09 04:13:49 -06:00
|
|
|
if (params->ht_capa)
|
2011-11-18 12:32:00 -07:00
|
|
|
ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
|
2008-10-14 08:58:37 -06:00
|
|
|
params->ht_capa,
|
2008-10-09 04:13:49 -06:00
|
|
|
&sta->sta.ht_cap);
|
2008-08-25 02:58:58 -06:00
|
|
|
|
2011-05-03 17:57:11 -06:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif)) {
|
2011-05-12 07:32:17 -06:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2011-05-03 17:57:11 -06:00
|
|
|
if (sdata->u.mesh.security & IEEE80211_MESH_SEC_SECURED)
|
|
|
|
switch (params->plink_state) {
|
2011-05-13 11:45:43 -06:00
|
|
|
case NL80211_PLINK_LISTEN:
|
|
|
|
case NL80211_PLINK_ESTAB:
|
|
|
|
case NL80211_PLINK_BLOCKED:
|
2011-05-03 17:57:11 -06:00
|
|
|
sta->plink_state = params->plink_state;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* nothing */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
switch (params->plink_action) {
|
|
|
|
case PLINK_ACTION_OPEN:
|
|
|
|
mesh_plink_open(sta);
|
|
|
|
break;
|
|
|
|
case PLINK_ACTION_BLOCK:
|
|
|
|
mesh_plink_block(sta);
|
|
|
|
break;
|
|
|
|
}
|
2011-05-12 07:32:17 -06:00
|
|
|
#endif
|
2008-02-23 07:17:19 -07:00
|
|
|
}
|
2011-12-14 04:35:30 -07:00
|
|
|
|
|
|
|
return 0;
|
2007-12-18 18:03:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_add_station(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *mac, struct station_parameters *params)
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2007-12-18 18:03:35 -07:00
|
|
|
struct sta_info *sta;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-02-25 08:27:47 -07:00
|
|
|
int err;
|
2008-12-12 08:08:31 -07:00
|
|
|
int layer2_update;
|
2007-12-18 18:03:35 -07:00
|
|
|
|
|
|
|
if (params->vlan) {
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
|
|
|
|
|
2008-09-10 16:01:58 -06:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sdata->vif.type != NL80211_IFTYPE_AP)
|
2007-12-18 18:03:35 -07:00
|
|
|
return -EINVAL;
|
|
|
|
} else
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
mac80211: Convert compare_ether_addr to ether_addr_equal
Use the new bool function ether_addr_equal to add
some clarity and reduce the likelihood for misuse
of compare_ether_addr for sorting.
Done via cocci script:
$ cat compare_ether_addr.cocci
@@
expression a,b;
@@
- !compare_ether_addr(a, b)
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- compare_ether_addr(a, b)
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) == 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !ether_addr_equal(a, b) != 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) == 0
+ !ether_addr_equal(a, b)
@@
expression a,b;
@@
- ether_addr_equal(a, b) != 0
+ ether_addr_equal(a, b)
@@
expression a,b;
@@
- !!ether_addr_equal(a, b)
+ ether_addr_equal(a, b)
Signed-off-by: Joe Perches <joe@perches.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-05-08 12:56:52 -06:00
|
|
|
if (ether_addr_equal(mac, sdata->vif.addr))
|
2008-02-27 01:56:40 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (is_multicast_ether_addr(mac))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
sta = sta_info_alloc(sdata, mac, GFP_KERNEL);
|
2008-02-25 08:27:47 -07:00
|
|
|
if (!sta)
|
|
|
|
return -ENOMEM;
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2012-01-12 01:31:10 -07:00
|
|
|
sta_info_pre_move_state(sta, IEEE80211_STA_AUTH);
|
|
|
|
sta_info_pre_move_state(sta, IEEE80211_STA_ASSOC);
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-12-14 04:35:30 -07:00
|
|
|
err = sta_apply_parameters(local, sta, params);
|
|
|
|
if (err) {
|
|
|
|
sta_info_free(local, sta);
|
|
|
|
return err;
|
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-11-07 14:24:39 -07:00
|
|
|
/*
|
|
|
|
* for TDLS, rate control should be initialized only when supported
|
|
|
|
* rates are known.
|
|
|
|
*/
|
|
|
|
if (!test_sta_flag(sta, WLAN_STA_TDLS_PEER))
|
|
|
|
rate_control_rate_init(sta);
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2008-12-12 08:08:31 -07:00
|
|
|
layer2_update = sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
|
|
|
|
sdata->vif.type == NL80211_IFTYPE_AP;
|
|
|
|
|
2010-02-03 05:59:58 -07:00
|
|
|
err = sta_info_insert_rcu(sta);
|
2008-02-25 08:27:47 -07:00
|
|
|
if (err) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-12-12 08:08:31 -07:00
|
|
|
if (layer2_update)
|
2008-02-25 08:27:47 -07:00
|
|
|
ieee80211_send_layer2_update(sta);
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_del_station(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *mac)
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2010-02-03 05:59:58 -07:00
|
|
|
if (mac)
|
|
|
|
return sta_info_destroy_addr_bss(sdata, mac);
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2010-02-03 05:59:58 -07:00
|
|
|
sta_info_flush(local, sdata);
|
2007-12-18 18:03:35 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_change_station(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u8 *mac,
|
|
|
|
struct station_parameters *params)
|
|
|
|
{
|
2009-11-25 09:46:18 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2007-12-18 18:03:35 -07:00
|
|
|
struct sta_info *sta;
|
|
|
|
struct ieee80211_sub_if_data *vlansdata;
|
2011-12-29 05:41:39 -07:00
|
|
|
int err;
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-12-14 04:20:29 -07:00
|
|
|
mutex_lock(&local->sta_mtx);
|
2008-04-10 07:36:09 -06:00
|
|
|
|
2010-01-08 10:10:58 -07:00
|
|
|
sta = sta_info_get_bss(sdata, mac);
|
2008-04-10 07:36:09 -06:00
|
|
|
if (!sta) {
|
2011-12-14 04:20:29 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2007-12-18 18:03:35 -07:00
|
|
|
return -ENOENT;
|
2008-04-10 07:36:09 -06:00
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-12-14 04:20:27 -07:00
|
|
|
/* in station mode, supported rates are only valid with TDLS */
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
|
|
|
|
params->supported_rates &&
|
|
|
|
!test_sta_flag(sta, WLAN_STA_TDLS_PEER)) {
|
2011-12-14 04:20:29 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2011-12-14 04:20:27 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
if (params->vlan && params->vlan != sta->sdata->dev) {
|
2012-04-23 11:49:03 -06:00
|
|
|
bool prev_4addr = false;
|
|
|
|
bool new_4addr = false;
|
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
vlansdata = IEEE80211_DEV_TO_SUB_IF(params->vlan);
|
|
|
|
|
2008-09-10 16:01:58 -06:00
|
|
|
if (vlansdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
vlansdata->vif.type != NL80211_IFTYPE_AP) {
|
2011-12-14 04:20:29 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2007-12-18 18:03:35 -07:00
|
|
|
return -EINVAL;
|
2008-04-10 07:36:09 -06:00
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2009-11-19 03:55:19 -07:00
|
|
|
if (params->vlan->ieee80211_ptr->use_4addr) {
|
2009-11-20 02:09:14 -07:00
|
|
|
if (vlansdata->u.vlan.sta) {
|
2011-12-14 04:20:29 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2009-11-10 12:10:05 -07:00
|
|
|
return -EBUSY;
|
2009-11-20 02:09:14 -07:00
|
|
|
}
|
2009-11-10 12:10:05 -07:00
|
|
|
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(vlansdata->u.vlan.sta, sta);
|
2012-04-23 11:49:03 -06:00
|
|
|
new_4addr = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN &&
|
|
|
|
sta->sdata->u.vlan.sta) {
|
|
|
|
rcu_assign_pointer(sta->sdata->u.vlan.sta, NULL);
|
|
|
|
prev_4addr = true;
|
2009-11-10 12:10:05 -07:00
|
|
|
}
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sta->sdata = vlansdata;
|
2012-04-23 11:49:03 -06:00
|
|
|
|
|
|
|
if (sta->sta_state == IEEE80211_STA_AUTHORIZED &&
|
|
|
|
prev_4addr != new_4addr) {
|
|
|
|
if (new_4addr)
|
|
|
|
atomic_dec(&sta->sdata->bss->num_mcast_sta);
|
|
|
|
else
|
|
|
|
atomic_inc(&sta->sdata->bss->num_mcast_sta);
|
|
|
|
}
|
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
ieee80211_send_layer2_update(sta);
|
|
|
|
}
|
|
|
|
|
2011-12-29 05:41:39 -07:00
|
|
|
err = sta_apply_parameters(local, sta, params);
|
|
|
|
if (err) {
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
return err;
|
|
|
|
}
|
2007-12-18 18:03:35 -07:00
|
|
|
|
2011-11-07 14:24:39 -07:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_TDLS_PEER) && params->supported_rates)
|
|
|
|
rate_control_rate_init(sta);
|
|
|
|
|
2011-12-14 04:20:29 -07:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2008-04-10 07:36:09 -06:00
|
|
|
|
2011-03-10 17:43:19 -07:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_STATION &&
|
|
|
|
params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED))
|
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
|
2007-12-18 18:03:35 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
|
|
|
static int ieee80211_add_mpath(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *dst, u8 *next_hop)
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-02-23 07:17:17 -07:00
|
|
|
struct mesh_path *mpath;
|
|
|
|
struct sta_info *sta;
|
|
|
|
int err;
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
rcu_read_lock();
|
2009-11-25 09:46:18 -07:00
|
|
|
sta = sta_info_get(sdata, next_hop);
|
2008-02-25 08:27:46 -07:00
|
|
|
if (!sta) {
|
|
|
|
rcu_read_unlock();
|
2008-02-23 07:17:17 -07:00
|
|
|
return -ENOENT;
|
2008-02-25 08:27:46 -07:00
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2008-08-02 18:04:37 -06:00
|
|
|
err = mesh_path_add(dst, sdata);
|
2008-02-25 08:27:46 -07:00
|
|
|
if (err) {
|
|
|
|
rcu_read_unlock();
|
2008-02-23 07:17:17 -07:00
|
|
|
return err;
|
2008-02-25 08:27:46 -07:00
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2008-08-02 18:04:37 -06:00
|
|
|
mpath = mesh_path_lookup(dst, sdata);
|
2008-02-23 07:17:17 -07:00
|
|
|
if (!mpath) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
mesh_path_fix_nexthop(mpath, sta);
|
2008-02-25 08:27:46 -07:00
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_del_mpath(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *dst)
|
|
|
|
{
|
2008-08-02 18:04:37 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
if (dst)
|
2008-08-02 18:04:37 -06:00
|
|
|
return mesh_path_del(dst, sdata);
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2011-08-29 14:23:04 -06:00
|
|
|
mesh_path_flush_by_iface(sdata);
|
2008-02-23 07:17:17 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_change_mpath(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u8 *dst, u8 *next_hop)
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-02-23 07:17:17 -07:00
|
|
|
struct mesh_path *mpath;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2008-02-25 08:27:46 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
|
2009-11-25 09:46:18 -07:00
|
|
|
sta = sta_info_get(sdata, next_hop);
|
2008-02-25 08:27:46 -07:00
|
|
|
if (!sta) {
|
|
|
|
rcu_read_unlock();
|
2008-02-23 07:17:17 -07:00
|
|
|
return -ENOENT;
|
2008-02-25 08:27:46 -07:00
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
|
2008-08-02 18:04:37 -06:00
|
|
|
mpath = mesh_path_lookup(dst, sdata);
|
2008-02-23 07:17:17 -07:00
|
|
|
if (!mpath) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
mesh_path_fix_nexthop(mpath, sta);
|
2008-02-25 08:27:46 -07:00
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mpath_set_pinfo(struct mesh_path *mpath, u8 *next_hop,
|
|
|
|
struct mpath_info *pinfo)
|
|
|
|
{
|
2011-05-12 07:11:37 -06:00
|
|
|
struct sta_info *next_hop_sta = rcu_dereference(mpath->next_hop);
|
|
|
|
|
|
|
|
if (next_hop_sta)
|
|
|
|
memcpy(next_hop, next_hop_sta->sta.addr, ETH_ALEN);
|
2008-02-23 07:17:17 -07:00
|
|
|
else
|
|
|
|
memset(next_hop, 0, ETH_ALEN);
|
|
|
|
|
2009-08-07 08:17:38 -06:00
|
|
|
pinfo->generation = mesh_paths_generation;
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
pinfo->filled = MPATH_INFO_FRAME_QLEN |
|
2009-11-09 16:46:55 -07:00
|
|
|
MPATH_INFO_SN |
|
2008-02-23 07:17:17 -07:00
|
|
|
MPATH_INFO_METRIC |
|
|
|
|
MPATH_INFO_EXPTIME |
|
|
|
|
MPATH_INFO_DISCOVERY_TIMEOUT |
|
|
|
|
MPATH_INFO_DISCOVERY_RETRIES |
|
|
|
|
MPATH_INFO_FLAGS;
|
|
|
|
|
|
|
|
pinfo->frame_qlen = mpath->frame_queue.qlen;
|
2009-11-09 16:46:55 -07:00
|
|
|
pinfo->sn = mpath->sn;
|
2008-02-23 07:17:17 -07:00
|
|
|
pinfo->metric = mpath->metric;
|
|
|
|
if (time_before(jiffies, mpath->exp_time))
|
|
|
|
pinfo->exptime = jiffies_to_msecs(mpath->exp_time - jiffies);
|
|
|
|
pinfo->discovery_timeout =
|
|
|
|
jiffies_to_msecs(mpath->discovery_timeout);
|
|
|
|
pinfo->discovery_retries = mpath->discovery_retries;
|
|
|
|
pinfo->flags = 0;
|
|
|
|
if (mpath->flags & MESH_PATH_ACTIVE)
|
|
|
|
pinfo->flags |= NL80211_MPATH_FLAG_ACTIVE;
|
|
|
|
if (mpath->flags & MESH_PATH_RESOLVING)
|
|
|
|
pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
|
2009-11-09 16:46:55 -07:00
|
|
|
if (mpath->flags & MESH_PATH_SN_VALID)
|
|
|
|
pinfo->flags |= NL80211_MPATH_FLAG_SN_VALID;
|
2008-02-23 07:17:17 -07:00
|
|
|
if (mpath->flags & MESH_PATH_FIXED)
|
|
|
|
pinfo->flags |= NL80211_MPATH_FLAG_FIXED;
|
|
|
|
if (mpath->flags & MESH_PATH_RESOLVING)
|
|
|
|
pinfo->flags |= NL80211_MPATH_FLAG_RESOLVING;
|
|
|
|
|
|
|
|
pinfo->flags = mpath->flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_get_mpath(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *dst, u8 *next_hop, struct mpath_info *pinfo)
|
|
|
|
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-02-23 07:17:17 -07:00
|
|
|
struct mesh_path *mpath;
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
rcu_read_lock();
|
2008-08-02 18:04:37 -06:00
|
|
|
mpath = mesh_path_lookup(dst, sdata);
|
2008-02-23 07:17:17 -07:00
|
|
|
if (!mpath) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
memcpy(dst, mpath->dst, ETH_ALEN);
|
|
|
|
mpath_set_pinfo(mpath, next_hop, pinfo);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_dump_mpath(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
int idx, u8 *dst, u8 *next_hop,
|
|
|
|
struct mpath_info *pinfo)
|
|
|
|
{
|
2008-07-29 05:22:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2008-02-23 07:17:17 -07:00
|
|
|
struct mesh_path *mpath;
|
|
|
|
|
2008-07-29 05:22:52 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
2008-02-23 07:17:17 -07:00
|
|
|
rcu_read_lock();
|
2008-08-02 18:04:37 -06:00
|
|
|
mpath = mesh_path_lookup_by_idx(idx, sdata);
|
2008-02-23 07:17:17 -07:00
|
|
|
if (!mpath) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
memcpy(dst, mpath->dst, ETH_ALEN);
|
|
|
|
mpath_set_pinfo(mpath, next_hop, pinfo);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
2008-10-21 13:03:48 -06:00
|
|
|
|
2010-12-16 18:37:48 -07:00
|
|
|
static int ieee80211_get_mesh_config(struct wiphy *wiphy,
|
2008-10-21 13:03:48 -06:00
|
|
|
struct net_device *dev,
|
|
|
|
struct mesh_config *conf)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
memcpy(conf, &(sdata->u.mesh.mshcfg), sizeof(struct mesh_config));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool _chg_mesh_attr(enum nl80211_meshconf_params parm, u32 mask)
|
|
|
|
{
|
|
|
|
return (mask >> (parm-1)) & 0x1;
|
|
|
|
}
|
|
|
|
|
2010-12-16 18:37:49 -07:00
|
|
|
static int copy_mesh_setup(struct ieee80211_if_mesh *ifmsh,
|
|
|
|
const struct mesh_setup *setup)
|
|
|
|
{
|
|
|
|
u8 *new_ie;
|
|
|
|
const u8 *old_ie;
|
2011-11-24 18:15:20 -07:00
|
|
|
struct ieee80211_sub_if_data *sdata = container_of(ifmsh,
|
|
|
|
struct ieee80211_sub_if_data, u.mesh);
|
2010-12-16 18:37:49 -07:00
|
|
|
|
2011-04-07 16:08:27 -06:00
|
|
|
/* allocate information elements */
|
2010-12-16 18:37:49 -07:00
|
|
|
new_ie = NULL;
|
2011-04-07 16:08:27 -06:00
|
|
|
old_ie = ifmsh->ie;
|
2010-12-16 18:37:49 -07:00
|
|
|
|
2011-04-07 16:08:27 -06:00
|
|
|
if (setup->ie_len) {
|
|
|
|
new_ie = kmemdup(setup->ie, setup->ie_len,
|
2010-12-16 18:37:49 -07:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!new_ie)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2011-04-07 16:08:27 -06:00
|
|
|
ifmsh->ie_len = setup->ie_len;
|
|
|
|
ifmsh->ie = new_ie;
|
|
|
|
kfree(old_ie);
|
2010-12-16 18:37:49 -07:00
|
|
|
|
|
|
|
/* now copy the rest of the setup parameters */
|
|
|
|
ifmsh->mesh_id_len = setup->mesh_id_len;
|
|
|
|
memcpy(ifmsh->mesh_id, setup->mesh_id, ifmsh->mesh_id_len);
|
2012-03-31 12:31:33 -06:00
|
|
|
ifmsh->mesh_sp_id = setup->sync_method;
|
2010-12-16 18:37:49 -07:00
|
|
|
ifmsh->mesh_pp_id = setup->path_sel_proto;
|
|
|
|
ifmsh->mesh_pm_id = setup->path_metric;
|
2011-05-03 17:57:07 -06:00
|
|
|
ifmsh->security = IEEE80211_MESH_SEC_NONE;
|
|
|
|
if (setup->is_authenticated)
|
|
|
|
ifmsh->security |= IEEE80211_MESH_SEC_AUTHED;
|
|
|
|
if (setup->is_secure)
|
|
|
|
ifmsh->security |= IEEE80211_MESH_SEC_SECURED;
|
2010-12-16 18:37:49 -07:00
|
|
|
|
2011-11-24 18:15:20 -07:00
|
|
|
/* mcast rate setting in Mesh Node */
|
|
|
|
memcpy(sdata->vif.bss_conf.mcast_rate, setup->mcast_rate,
|
|
|
|
sizeof(setup->mcast_rate));
|
|
|
|
|
2010-12-16 18:37:49 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-16 18:37:48 -07:00
|
|
|
static int ieee80211_update_mesh_config(struct wiphy *wiphy,
|
2010-12-03 01:20:44 -07:00
|
|
|
struct net_device *dev, u32 mask,
|
|
|
|
const struct mesh_config *nconf)
|
2008-10-21 13:03:48 -06:00
|
|
|
{
|
|
|
|
struct mesh_config *conf;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2009-11-09 16:46:57 -07:00
|
|
|
struct ieee80211_if_mesh *ifmsh;
|
|
|
|
|
2008-10-21 13:03:48 -06:00
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2009-11-09 16:46:57 -07:00
|
|
|
ifmsh = &sdata->u.mesh;
|
2008-10-21 13:03:48 -06:00
|
|
|
|
|
|
|
/* Set the config options which we are interested in setting */
|
|
|
|
conf = &(sdata->u.mesh.mshcfg);
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_RETRY_TIMEOUT, mask))
|
|
|
|
conf->dot11MeshRetryTimeout = nconf->dot11MeshRetryTimeout;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_CONFIRM_TIMEOUT, mask))
|
|
|
|
conf->dot11MeshConfirmTimeout = nconf->dot11MeshConfirmTimeout;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HOLDING_TIMEOUT, mask))
|
|
|
|
conf->dot11MeshHoldingTimeout = nconf->dot11MeshHoldingTimeout;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_MAX_PEER_LINKS, mask))
|
|
|
|
conf->dot11MeshMaxPeerLinks = nconf->dot11MeshMaxPeerLinks;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_MAX_RETRIES, mask))
|
|
|
|
conf->dot11MeshMaxRetries = nconf->dot11MeshMaxRetries;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_TTL, mask))
|
|
|
|
conf->dot11MeshTTL = nconf->dot11MeshTTL;
|
2010-12-03 01:20:40 -07:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_ELEMENT_TTL, mask))
|
|
|
|
conf->dot11MeshTTL = nconf->element_ttl;
|
2008-10-21 13:03:48 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_AUTO_OPEN_PLINKS, mask))
|
|
|
|
conf->auto_open_plinks = nconf->auto_open_plinks;
|
2012-03-31 12:31:33 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, mask))
|
|
|
|
conf->dot11MeshNbrOffsetMaxNeighbor =
|
|
|
|
nconf->dot11MeshNbrOffsetMaxNeighbor;
|
2008-10-21 13:03:48 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, mask))
|
|
|
|
conf->dot11MeshHWMPmaxPREQretries =
|
|
|
|
nconf->dot11MeshHWMPmaxPREQretries;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_PATH_REFRESH_TIME, mask))
|
|
|
|
conf->path_refresh_time = nconf->path_refresh_time;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, mask))
|
|
|
|
conf->min_discovery_timeout = nconf->min_discovery_timeout;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, mask))
|
|
|
|
conf->dot11MeshHWMPactivePathTimeout =
|
|
|
|
nconf->dot11MeshHWMPactivePathTimeout;
|
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, mask))
|
|
|
|
conf->dot11MeshHWMPpreqMinInterval =
|
|
|
|
nconf->dot11MeshHWMPpreqMinInterval;
|
2011-11-24 18:15:24 -07:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, mask))
|
|
|
|
conf->dot11MeshHWMPperrMinInterval =
|
|
|
|
nconf->dot11MeshHWMPperrMinInterval;
|
2008-10-21 13:03:48 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
|
|
|
|
mask))
|
|
|
|
conf->dot11MeshHWMPnetDiameterTraversalTime =
|
|
|
|
nconf->dot11MeshHWMPnetDiameterTraversalTime;
|
2009-11-09 16:46:57 -07:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_ROOTMODE, mask)) {
|
|
|
|
conf->dot11MeshHWMPRootMode = nconf->dot11MeshHWMPRootMode;
|
|
|
|
ieee80211_mesh_root_setup(ifmsh);
|
|
|
|
}
|
2011-08-09 17:45:11 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_GATE_ANNOUNCEMENTS, mask)) {
|
2011-08-25 11:36:14 -06:00
|
|
|
/* our current gate announcement implementation rides on root
|
|
|
|
* announcements, so require this ifmsh to also be a root node
|
|
|
|
* */
|
|
|
|
if (nconf->dot11MeshGateAnnouncementProtocol &&
|
|
|
|
!conf->dot11MeshHWMPRootMode) {
|
|
|
|
conf->dot11MeshHWMPRootMode = 1;
|
|
|
|
ieee80211_mesh_root_setup(ifmsh);
|
|
|
|
}
|
2011-08-09 17:45:11 -06:00
|
|
|
conf->dot11MeshGateAnnouncementProtocol =
|
|
|
|
nconf->dot11MeshGateAnnouncementProtocol;
|
|
|
|
}
|
2011-08-09 17:45:10 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HWMP_RANN_INTERVAL, mask)) {
|
|
|
|
conf->dot11MeshHWMPRannInterval =
|
|
|
|
nconf->dot11MeshHWMPRannInterval;
|
|
|
|
}
|
2012-01-20 10:02:16 -07:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_FORWARDING, mask))
|
|
|
|
conf->dot11MeshForwarding = nconf->dot11MeshForwarding;
|
2012-02-28 18:04:08 -07:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_RSSI_THRESHOLD, mask)) {
|
|
|
|
/* our RSSI threshold implementation is supported only for
|
|
|
|
* devices that report signal in dBm.
|
|
|
|
*/
|
|
|
|
if (!(sdata->local->hw.flags & IEEE80211_HW_SIGNAL_DBM))
|
|
|
|
return -ENOTSUPP;
|
|
|
|
conf->rssi_threshold = nconf->rssi_threshold;
|
|
|
|
}
|
2012-04-30 15:20:32 -06:00
|
|
|
if (_chg_mesh_attr(NL80211_MESHCONF_HT_OPMODE, mask)) {
|
|
|
|
conf->ht_opmode = nconf->ht_opmode;
|
|
|
|
sdata->vif.bss_conf.ht_operation_mode = nconf->ht_opmode;
|
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
|
|
|
|
}
|
2008-10-21 13:03:48 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-03 01:20:44 -07:00
|
|
|
static int ieee80211_join_mesh(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
const struct mesh_config *conf,
|
|
|
|
const struct mesh_setup *setup)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
|
2010-12-16 18:37:49 -07:00
|
|
|
int err;
|
2010-12-03 01:20:44 -07:00
|
|
|
|
2010-12-16 18:37:49 -07:00
|
|
|
memcpy(&ifmsh->mshcfg, conf, sizeof(struct mesh_config));
|
|
|
|
err = copy_mesh_setup(ifmsh, setup);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2010-12-03 01:20:44 -07:00
|
|
|
ieee80211_start_mesh(sdata);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_leave_mesh(struct wiphy *wiphy, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
ieee80211_stop_mesh(sdata);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-02-23 07:17:17 -07:00
|
|
|
#endif
|
|
|
|
|
2008-08-07 11:07:01 -06:00
|
|
|
static int ieee80211_change_bss(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct bss_parameters *params)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
u32 changed = 0;
|
|
|
|
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
if (params->use_cts_prot >= 0) {
|
2008-10-10 17:51:51 -06:00
|
|
|
sdata->vif.bss_conf.use_cts_prot = params->use_cts_prot;
|
2008-08-07 11:07:01 -06:00
|
|
|
changed |= BSS_CHANGED_ERP_CTS_PROT;
|
|
|
|
}
|
|
|
|
if (params->use_short_preamble >= 0) {
|
2008-10-10 17:51:51 -06:00
|
|
|
sdata->vif.bss_conf.use_short_preamble =
|
2008-08-07 11:07:01 -06:00
|
|
|
params->use_short_preamble;
|
|
|
|
changed |= BSS_CHANGED_ERP_PREAMBLE;
|
|
|
|
}
|
2010-01-14 19:00:48 -07:00
|
|
|
|
|
|
|
if (!sdata->vif.bss_conf.use_short_slot &&
|
|
|
|
sdata->local->hw.conf.channel->band == IEEE80211_BAND_5GHZ) {
|
|
|
|
sdata->vif.bss_conf.use_short_slot = true;
|
|
|
|
changed |= BSS_CHANGED_ERP_SLOT;
|
|
|
|
}
|
|
|
|
|
2008-08-07 11:07:01 -06:00
|
|
|
if (params->use_short_slot_time >= 0) {
|
2008-10-10 17:51:51 -06:00
|
|
|
sdata->vif.bss_conf.use_short_slot =
|
2008-08-07 11:07:01 -06:00
|
|
|
params->use_short_slot_time;
|
|
|
|
changed |= BSS_CHANGED_ERP_SLOT;
|
|
|
|
}
|
|
|
|
|
2008-10-30 08:59:22 -06:00
|
|
|
if (params->basic_rates) {
|
|
|
|
int i, j;
|
|
|
|
u32 rates = 0;
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
struct ieee80211_supported_band *sband =
|
|
|
|
wiphy->bands[local->oper_channel->band];
|
|
|
|
|
|
|
|
for (i = 0; i < params->basic_rates_len; i++) {
|
|
|
|
int rate = (params->basic_rates[i] & 0x7f) * 5;
|
|
|
|
for (j = 0; j < sband->n_bitrates; j++) {
|
|
|
|
if (sband->bitrates[j].bitrate == rate)
|
|
|
|
rates |= BIT(j);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sdata->vif.bss_conf.basic_rates = rates;
|
|
|
|
changed |= BSS_CHANGED_BASIC_RATES;
|
|
|
|
}
|
|
|
|
|
2010-04-26 17:23:36 -06:00
|
|
|
if (params->ap_isolate >= 0) {
|
|
|
|
if (params->ap_isolate)
|
|
|
|
sdata->flags |= IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
|
|
|
|
else
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_DONT_BRIDGE_PACKETS;
|
|
|
|
}
|
|
|
|
|
2010-11-19 04:40:26 -07:00
|
|
|
if (params->ht_opmode >= 0) {
|
|
|
|
sdata->vif.bss_conf.ht_operation_mode =
|
|
|
|
(u16) params->ht_opmode;
|
|
|
|
changed |= BSS_CHANGED_HT;
|
|
|
|
}
|
|
|
|
|
2008-08-07 11:07:01 -06:00
|
|
|
ieee80211_bss_info_change_notify(sdata, changed);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-30 08:59:24 -06:00
|
|
|
static int ieee80211_set_txq_params(struct wiphy *wiphy,
|
2011-09-25 11:06:53 -06:00
|
|
|
struct net_device *dev,
|
2008-10-30 08:59:24 -06:00
|
|
|
struct ieee80211_txq_params *params)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2011-09-25 11:06:54 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2008-10-30 08:59:24 -06:00
|
|
|
struct ieee80211_tx_queue_params p;
|
|
|
|
|
|
|
|
if (!local->ops->conf_tx)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2012-03-28 03:04:25 -06:00
|
|
|
if (local->hw.queues < IEEE80211_NUM_ACS)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2008-10-30 08:59:24 -06:00
|
|
|
memset(&p, 0, sizeof(p));
|
|
|
|
p.aifs = params->aifs;
|
|
|
|
p.cw_max = params->cwmax;
|
|
|
|
p.cw_min = params->cwmin;
|
|
|
|
p.txop = params->txop;
|
2010-01-12 01:42:31 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Setting tx queue params disables u-apsd because it's only
|
|
|
|
* called in master mode.
|
|
|
|
*/
|
|
|
|
p.uapsd = false;
|
|
|
|
|
2012-03-28 03:04:24 -06:00
|
|
|
sdata->tx_conf[params->ac] = p;
|
|
|
|
if (drv_conf_tx(local, sdata, params->ac, &p)) {
|
2010-08-20 17:25:38 -06:00
|
|
|
wiphy_debug(local->hw.wiphy,
|
2012-03-28 03:04:24 -06:00
|
|
|
"failed to set TX queue parameters for AC %d\n",
|
|
|
|
params->ac);
|
2008-10-30 08:59:24 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-26 07:15:24 -07:00
|
|
|
static int ieee80211_set_channel(struct wiphy *wiphy,
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
struct net_device *netdev,
|
2008-11-26 07:15:24 -07:00
|
|
|
struct ieee80211_channel *chan,
|
2008-12-11 23:27:43 -07:00
|
|
|
enum nl80211_channel_type channel_type)
|
2008-11-26 07:15:24 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2010-05-05 07:28:27 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = NULL;
|
2011-01-28 11:20:47 -07:00
|
|
|
struct ieee80211_channel *old_oper;
|
|
|
|
enum nl80211_channel_type old_oper_type;
|
|
|
|
enum nl80211_channel_type old_vif_oper_type= NL80211_CHAN_NO_HT;
|
2010-05-05 07:28:27 -06:00
|
|
|
|
|
|
|
if (netdev)
|
|
|
|
sdata = IEEE80211_DEV_TO_SUB_IF(netdev);
|
2008-11-26 07:15:24 -07:00
|
|
|
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
switch (ieee80211_get_channel_mode(local, NULL)) {
|
|
|
|
case CHAN_MODE_HOPPING:
|
|
|
|
return -EBUSY;
|
|
|
|
case CHAN_MODE_FIXED:
|
2010-05-05 07:28:27 -06:00
|
|
|
if (local->oper_channel != chan)
|
|
|
|
return -EBUSY;
|
|
|
|
if (!sdata && local->_oper_channel_type == channel_type)
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
return 0;
|
2010-05-05 07:28:27 -06:00
|
|
|
break;
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
case CHAN_MODE_UNDEFINED:
|
|
|
|
break;
|
|
|
|
}
|
2008-11-26 07:15:24 -07:00
|
|
|
|
2011-01-28 11:20:47 -07:00
|
|
|
if (sdata)
|
|
|
|
old_vif_oper_type = sdata->vif.bss_conf.channel_type;
|
|
|
|
old_oper_type = local->_oper_channel_type;
|
2008-11-26 07:15:24 -07:00
|
|
|
|
2010-05-05 07:28:27 -06:00
|
|
|
if (!ieee80211_set_channel_type(local, sdata, channel_type))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2011-01-28 11:20:47 -07:00
|
|
|
old_oper = local->oper_channel;
|
|
|
|
local->oper_channel = chan;
|
|
|
|
|
|
|
|
/* Update driver if changes were actually made. */
|
|
|
|
if ((old_oper != local->oper_channel) ||
|
|
|
|
(old_oper_type != local->_oper_channel_type))
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_CHANNEL);
|
|
|
|
|
2011-10-18 05:39:14 -06:00
|
|
|
if (sdata && sdata->vif.type != NL80211_IFTYPE_MONITOR &&
|
2011-01-28 11:20:47 -07:00
|
|
|
old_vif_oper_type != sdata->vif.bss_conf.channel_type)
|
2010-05-05 07:28:27 -06:00
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_HT);
|
|
|
|
|
|
|
|
return 0;
|
2008-11-26 07:15:24 -07:00
|
|
|
}
|
|
|
|
|
2009-01-19 09:20:53 -07:00
|
|
|
#ifdef CONFIG_PM
|
2011-05-04 07:37:28 -06:00
|
|
|
static int ieee80211_suspend(struct wiphy *wiphy,
|
|
|
|
struct cfg80211_wowlan *wowlan)
|
2009-01-19 09:20:53 -07:00
|
|
|
{
|
2011-05-04 07:37:29 -06:00
|
|
|
return __ieee80211_suspend(wiphy_priv(wiphy), wowlan);
|
2009-01-19 09:20:53 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_resume(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
return __ieee80211_resume(wiphy_priv(wiphy));
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ieee80211_suspend NULL
|
|
|
|
#define ieee80211_resume NULL
|
|
|
|
#endif
|
|
|
|
|
2009-02-10 13:25:55 -07:00
|
|
|
static int ieee80211_scan(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct cfg80211_scan_request *req)
|
|
|
|
{
|
2010-09-16 06:58:23 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2009-02-10 13:25:55 -07:00
|
|
|
|
2010-09-16 06:58:23 -06:00
|
|
|
switch (ieee80211_vif_type_p2p(&sdata->vif)) {
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
|
|
|
if (sdata->local->ops->hw_scan)
|
|
|
|
break;
|
2011-02-01 07:35:36 -07:00
|
|
|
/*
|
|
|
|
* FIXME: implement NoA while scanning in software,
|
|
|
|
* for now fall through to allow scanning only when
|
|
|
|
* beaconing hasn't been configured yet
|
|
|
|
*/
|
2010-09-16 06:58:23 -06:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
if (sdata->u.ap.beacon)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
2009-02-10 13:25:55 -07:00
|
|
|
|
|
|
|
return ieee80211_request_scan(sdata, req);
|
|
|
|
}
|
|
|
|
|
2011-05-11 08:09:36 -06:00
|
|
|
static int
|
|
|
|
ieee80211_sched_scan_start(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct cfg80211_sched_scan_request *req)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
if (!sdata->local->ops->sched_scan_start)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return ieee80211_request_sched_scan_start(sdata, req);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-05-12 07:28:29 -06:00
|
|
|
ieee80211_sched_scan_stop(struct wiphy *wiphy, struct net_device *dev)
|
2011-05-11 08:09:36 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
if (!sdata->local->ops->sched_scan_stop)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2011-05-12 07:28:29 -06:00
|
|
|
return ieee80211_request_sched_scan_stop(sdata);
|
2011-05-11 08:09:36 -06:00
|
|
|
}
|
|
|
|
|
2009-03-19 05:39:22 -06:00
|
|
|
static int ieee80211_auth(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
struct cfg80211_auth_request *req)
|
|
|
|
{
|
2009-07-06 19:45:17 -06:00
|
|
|
return ieee80211_mgd_auth(IEEE80211_DEV_TO_SUB_IF(dev), req);
|
2009-03-19 05:39:22 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_assoc(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
struct cfg80211_assoc_request *req)
|
|
|
|
{
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
switch (ieee80211_get_channel_mode(local, sdata)) {
|
|
|
|
case CHAN_MODE_HOPPING:
|
|
|
|
return -EBUSY;
|
|
|
|
case CHAN_MODE_FIXED:
|
|
|
|
if (local->oper_channel == req->bss->channel)
|
|
|
|
break;
|
|
|
|
return -EBUSY;
|
|
|
|
case CHAN_MODE_UNDEFINED:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-07-06 19:45:17 -06:00
|
|
|
return ieee80211_mgd_assoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
|
2009-03-19 05:39:22 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_deauth(struct wiphy *wiphy, struct net_device *dev,
|
2012-02-24 05:50:51 -07:00
|
|
|
struct cfg80211_deauth_request *req)
|
2009-03-19 05:39:22 -06:00
|
|
|
{
|
2012-02-24 05:50:51 -07:00
|
|
|
return ieee80211_mgd_deauth(IEEE80211_DEV_TO_SUB_IF(dev), req);
|
2009-03-19 05:39:22 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_disassoc(struct wiphy *wiphy, struct net_device *dev,
|
2012-02-24 05:50:51 -07:00
|
|
|
struct cfg80211_disassoc_request *req)
|
2009-03-19 05:39:22 -06:00
|
|
|
{
|
2012-02-24 05:50:51 -07:00
|
|
|
return ieee80211_mgd_disassoc(IEEE80211_DEV_TO_SUB_IF(dev), req);
|
2009-03-19 05:39:22 -06:00
|
|
|
}
|
|
|
|
|
2009-04-19 13:25:43 -06:00
|
|
|
static int ieee80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
struct cfg80211_ibss_params *params)
|
|
|
|
{
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2009-04-19 13:25:43 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
cfg80211/mac80211: better channel handling
Currently (all tested with hwsim) you can do stupid
things like setting up an AP on a certain channel,
then adding another virtual interface and making
that associate on another channel -- this will make
the beaconing to move channel but obviously without
the necessary IEs data update.
In order to improve this situation, first make the
configuration APIs (cfg80211 and nl80211) aware of
multi-channel operation -- we'll eventually need
that in the future anyway. There's one userland API
change and one API addition. The API change is that
now SET_WIPHY must be called with virtual interface
index rather than only wiphy index in order to take
effect for that interface -- luckily all current
users (hostapd) do that. For monitor interfaces, the
old setting is preserved, but monitors are always
slaved to other devices anyway so no guarantees.
The second userland API change is the introduction
of a per virtual interface SET_CHANNEL command, that
hostapd should use going forward to make it easier
to understand what's going on (it can automatically
detect a kernel with this command).
Other than mac80211, no existing cfg80211 drivers
are affected by this change because they only allow
a single virtual interface.
mac80211, however, now needs to be aware that the
channel settings are per interface now, and needs
to disallow (for now) real multi-channel operation,
which is another important part of this patch.
One of the immediate benefits is that you can now
start hostapd to operate on a hardware that already
has a connection on another virtual interface, as
long as you specify the same channel.
Note that two things are left unhandled (this is an
improvement -- not a complete fix):
* different HT/no-HT modes
currently you could start an HT AP and then
connect to a non-HT network on the same channel
which would configure the hardware for no HT;
that can be fixed fairly easily
* CSA
An AP we're connected to on a virtual interface
might indicate switching channels, and in that
case we would follow it, regardless of how many
other interfaces are operating; this requires
more effort to fix but is pretty rare after all
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2010-05-05 07:25:02 -06:00
|
|
|
switch (ieee80211_get_channel_mode(local, sdata)) {
|
|
|
|
case CHAN_MODE_HOPPING:
|
|
|
|
return -EBUSY;
|
|
|
|
case CHAN_MODE_FIXED:
|
|
|
|
if (!params->channel_fixed)
|
|
|
|
return -EBUSY;
|
|
|
|
if (local->oper_channel == params->channel)
|
|
|
|
break;
|
|
|
|
return -EBUSY;
|
|
|
|
case CHAN_MODE_UNDEFINED:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2009-04-19 13:25:43 -06:00
|
|
|
return ieee80211_ibss_join(sdata, params);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
return ieee80211_ibss_leave(sdata);
|
|
|
|
}
|
|
|
|
|
2009-04-20 10:39:05 -06:00
|
|
|
static int ieee80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
2009-04-23 10:52:52 -06:00
|
|
|
int err;
|
2009-04-20 10:39:05 -06:00
|
|
|
|
2010-11-08 02:51:06 -07:00
|
|
|
if (changed & WIPHY_PARAM_FRAG_THRESHOLD) {
|
|
|
|
err = drv_set_frag_threshold(local, wiphy->frag_threshold);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-12-21 14:50:48 -07:00
|
|
|
if (changed & WIPHY_PARAM_COVERAGE_CLASS) {
|
|
|
|
err = drv_set_coverage_class(local, wiphy->coverage_class);
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-04-20 10:39:05 -06:00
|
|
|
if (changed & WIPHY_PARAM_RTS_THRESHOLD) {
|
2009-04-23 10:52:52 -06:00
|
|
|
err = drv_set_rts_threshold(local, wiphy->rts_threshold);
|
2009-04-20 10:39:05 -06:00
|
|
|
|
2009-04-23 10:52:52 -06:00
|
|
|
if (err)
|
|
|
|
return err;
|
2009-04-20 10:39:05 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (changed & WIPHY_PARAM_RETRY_SHORT)
|
|
|
|
local->hw.conf.short_frame_max_tx_count = wiphy->retry_short;
|
|
|
|
if (changed & WIPHY_PARAM_RETRY_LONG)
|
|
|
|
local->hw.conf.long_frame_max_tx_count = wiphy->retry_long;
|
|
|
|
if (changed &
|
|
|
|
(WIPHY_PARAM_RETRY_SHORT | WIPHY_PARAM_RETRY_LONG))
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_RETRY_LIMITS);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-02 05:01:39 -06:00
|
|
|
static int ieee80211_set_tx_power(struct wiphy *wiphy,
|
2010-06-23 03:12:37 -06:00
|
|
|
enum nl80211_tx_power_setting type, int mbm)
|
2009-06-02 05:01:39 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
struct ieee80211_channel *chan = local->hw.conf.channel;
|
|
|
|
u32 changes = 0;
|
|
|
|
|
|
|
|
switch (type) {
|
2010-06-23 03:12:37 -06:00
|
|
|
case NL80211_TX_POWER_AUTOMATIC:
|
2009-06-02 05:01:39 -06:00
|
|
|
local->user_power_level = -1;
|
|
|
|
break;
|
2010-06-23 03:12:37 -06:00
|
|
|
case NL80211_TX_POWER_LIMITED:
|
|
|
|
if (mbm < 0 || (mbm % 100))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
local->user_power_level = MBM_TO_DBM(mbm);
|
2009-06-02 05:01:39 -06:00
|
|
|
break;
|
2010-06-23 03:12:37 -06:00
|
|
|
case NL80211_TX_POWER_FIXED:
|
|
|
|
if (mbm < 0 || (mbm % 100))
|
|
|
|
return -EOPNOTSUPP;
|
2009-06-02 05:01:39 -06:00
|
|
|
/* TODO: move to cfg80211 when it knows the channel */
|
2010-06-23 03:12:37 -06:00
|
|
|
if (MBM_TO_DBM(mbm) > chan->max_power)
|
2009-06-02 05:01:39 -06:00
|
|
|
return -EINVAL;
|
2010-06-23 03:12:37 -06:00
|
|
|
local->user_power_level = MBM_TO_DBM(mbm);
|
2009-06-02 05:01:39 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_hw_config(local, changes);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_get_tx_power(struct wiphy *wiphy, int *dbm)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
*dbm = local->hw.conf.power_level;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-01 13:26:58 -06:00
|
|
|
static int ieee80211_set_wds_peer(struct wiphy *wiphy, struct net_device *dev,
|
2010-10-07 05:11:09 -06:00
|
|
|
const u8 *addr)
|
2009-07-01 13:26:58 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
memcpy(&sdata->u.wds.remote_addr, addr, ETH_ALEN);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-02 05:01:41 -06:00
|
|
|
static void ieee80211_rfkill_poll(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
drv_rfkill_poll(local);
|
|
|
|
}
|
|
|
|
|
2009-07-01 13:26:51 -06:00
|
|
|
#ifdef CONFIG_NL80211_TESTMODE
|
2009-07-06 19:54:43 -06:00
|
|
|
static int ieee80211_testmode_cmd(struct wiphy *wiphy, void *data, int len)
|
2009-07-01 13:26:51 -06:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
if (!local->ops->testmode_cmd)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return local->ops->testmode_cmd(&local->hw, data, len);
|
|
|
|
}
|
2011-05-20 10:05:54 -06:00
|
|
|
|
|
|
|
static int ieee80211_testmode_dump(struct wiphy *wiphy,
|
|
|
|
struct sk_buff *skb,
|
|
|
|
struct netlink_callback *cb,
|
|
|
|
void *data, int len)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
if (!local->ops->testmode_dump)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return local->ops->testmode_dump(&local->hw, skb, cb, data, len);
|
|
|
|
}
|
2009-07-01 13:26:51 -06:00
|
|
|
#endif
|
|
|
|
|
2009-12-01 05:37:02 -07:00
|
|
|
int __ieee80211_request_smps(struct ieee80211_sub_if_data *sdata,
|
|
|
|
enum ieee80211_smps_mode smps_mode)
|
|
|
|
{
|
|
|
|
const u8 *ap;
|
|
|
|
enum ieee80211_smps_mode old_req;
|
|
|
|
int err;
|
|
|
|
|
2011-04-19 12:44:04 -06:00
|
|
|
lockdep_assert_held(&sdata->u.mgd.mtx);
|
|
|
|
|
2009-12-01 05:37:02 -07:00
|
|
|
old_req = sdata->u.mgd.req_smps;
|
|
|
|
sdata->u.mgd.req_smps = smps_mode;
|
|
|
|
|
|
|
|
if (old_req == smps_mode &&
|
|
|
|
smps_mode != IEEE80211_SMPS_AUTOMATIC)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If not associated, or current association is not an HT
|
|
|
|
* association, there's no need to send an action frame.
|
|
|
|
*/
|
|
|
|
if (!sdata->u.mgd.associated ||
|
2010-05-05 07:28:27 -06:00
|
|
|
sdata->vif.bss_conf.channel_type == NL80211_CHAN_NO_HT) {
|
2009-12-01 05:37:02 -07:00
|
|
|
mutex_lock(&sdata->local->iflist_mtx);
|
2010-10-05 02:41:47 -06:00
|
|
|
ieee80211_recalc_smps(sdata->local);
|
2009-12-01 05:37:02 -07:00
|
|
|
mutex_unlock(&sdata->local->iflist_mtx);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-23 05:15:39 -07:00
|
|
|
ap = sdata->u.mgd.associated->bssid;
|
2009-12-01 05:37:02 -07:00
|
|
|
|
|
|
|
if (smps_mode == IEEE80211_SMPS_AUTOMATIC) {
|
|
|
|
if (sdata->u.mgd.powersave)
|
|
|
|
smps_mode = IEEE80211_SMPS_DYNAMIC;
|
|
|
|
else
|
|
|
|
smps_mode = IEEE80211_SMPS_OFF;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* send SM PS frame to AP */
|
|
|
|
err = ieee80211_send_smps_action(sdata, smps_mode,
|
|
|
|
ap, ap);
|
|
|
|
if (err)
|
|
|
|
sdata->u.mgd.req_smps = old_req;
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-07-01 13:26:57 -06:00
|
|
|
static int ieee80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
bool enabled, int timeout)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
|
|
|
|
2010-01-15 04:21:37 -07:00
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2009-07-01 13:26:57 -06:00
|
|
|
if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (enabled == sdata->u.mgd.powersave &&
|
2010-06-09 00:51:52 -06:00
|
|
|
timeout == local->dynamic_ps_forced_timeout)
|
2009-07-01 13:26:57 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
sdata->u.mgd.powersave = enabled;
|
2010-06-09 00:51:52 -06:00
|
|
|
local->dynamic_ps_forced_timeout = timeout;
|
2009-07-01 13:26:57 -06:00
|
|
|
|
2009-12-01 05:37:02 -07:00
|
|
|
/* no change, but if automatic follow powersave */
|
|
|
|
mutex_lock(&sdata->u.mgd.mtx);
|
|
|
|
__ieee80211_request_smps(sdata, sdata->u.mgd.req_smps);
|
|
|
|
mutex_unlock(&sdata->u.mgd.mtx);
|
|
|
|
|
2009-07-01 13:26:57 -06:00
|
|
|
if (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)
|
|
|
|
ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
|
|
|
|
|
|
|
|
ieee80211_recalc_ps(local, -1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-23 01:02:34 -06:00
|
|
|
static int ieee80211_set_cqm_rssi_config(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
s32 rssi_thold, u32 rssi_hyst)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_vif *vif = &sdata->vif;
|
|
|
|
struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
|
|
|
|
|
|
|
|
if (rssi_thold == bss_conf->cqm_rssi_thold &&
|
|
|
|
rssi_hyst == bss_conf->cqm_rssi_hyst)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bss_conf->cqm_rssi_thold = rssi_thold;
|
|
|
|
bss_conf->cqm_rssi_hyst = rssi_hyst;
|
|
|
|
|
|
|
|
/* tell the driver upon association, unless already associated */
|
2012-01-19 01:29:58 -07:00
|
|
|
if (sdata->u.mgd.associated &&
|
|
|
|
sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)
|
2010-03-23 01:02:34 -06:00
|
|
|
ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_CQM);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-01 13:26:59 -06:00
|
|
|
static int ieee80211_set_bitrate_mask(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
const u8 *addr,
|
|
|
|
const struct cfg80211_bitrate_mask *mask)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
|
2011-04-27 05:26:51 -06:00
|
|
|
int i, ret;
|
2009-12-04 01:26:38 -07:00
|
|
|
|
2012-06-12 03:41:15 -06:00
|
|
|
if (!ieee80211_sdata_running(sdata))
|
|
|
|
return -ENETDOWN;
|
|
|
|
|
2011-04-27 05:26:51 -06:00
|
|
|
if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL) {
|
|
|
|
ret = drv_set_bitrate_mask(local, sdata, mask);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-07-01 13:26:59 -06:00
|
|
|
|
2012-01-28 09:25:33 -07:00
|
|
|
for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
|
2010-01-06 04:09:08 -07:00
|
|
|
sdata->rc_rateidx_mask[i] = mask->control[i].legacy;
|
2012-01-28 09:25:33 -07:00
|
|
|
memcpy(sdata->rc_rateidx_mcs_mask[i], mask->control[i].mcs,
|
|
|
|
sizeof(mask->control[i].mcs));
|
|
|
|
}
|
2009-07-01 13:26:59 -06:00
|
|
|
|
2010-01-06 04:09:08 -07:00
|
|
|
return 0;
|
2009-07-01 13:26:59 -06:00
|
|
|
}
|
|
|
|
|
2010-12-18 09:20:47 -07:00
|
|
|
static int ieee80211_remain_on_channel_hw(struct ieee80211_local *local,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
enum nl80211_channel_type chantype,
|
|
|
|
unsigned int duration, u64 *cookie)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
u32 random_cookie;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->mtx);
|
|
|
|
|
|
|
|
if (local->hw_roc_cookie)
|
|
|
|
return -EBUSY;
|
|
|
|
/* must be nonzero */
|
|
|
|
random_cookie = random32() | 1;
|
|
|
|
|
|
|
|
*cookie = random_cookie;
|
|
|
|
local->hw_roc_dev = dev;
|
|
|
|
local->hw_roc_cookie = random_cookie;
|
|
|
|
local->hw_roc_channel = chan;
|
|
|
|
local->hw_roc_channel_type = chantype;
|
|
|
|
local->hw_roc_duration = duration;
|
|
|
|
ret = drv_remain_on_channel(local, chan, chantype, duration);
|
|
|
|
if (ret) {
|
|
|
|
local->hw_roc_channel = NULL;
|
|
|
|
local->hw_roc_cookie = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-12-23 05:15:42 -07:00
|
|
|
static int ieee80211_remain_on_channel(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct ieee80211_channel *chan,
|
|
|
|
enum nl80211_channel_type channel_type,
|
|
|
|
unsigned int duration,
|
|
|
|
u64 *cookie)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2010-12-18 09:20:47 -07:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
if (local->ops->remain_on_channel) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ret = ieee80211_remain_on_channel_hw(local, dev,
|
|
|
|
chan, channel_type,
|
|
|
|
duration, cookie);
|
2010-12-18 09:20:48 -07:00
|
|
|
local->hw_roc_for_tx = false;
|
2010-12-18 09:20:47 -07:00
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2009-12-23 05:15:42 -07:00
|
|
|
|
|
|
|
return ieee80211_wk_remain_on_channel(sdata, chan, channel_type,
|
|
|
|
duration, cookie);
|
|
|
|
}
|
|
|
|
|
2010-12-18 09:20:47 -07:00
|
|
|
static int ieee80211_cancel_remain_on_channel_hw(struct ieee80211_local *local,
|
|
|
|
u64 cookie)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->mtx);
|
|
|
|
|
|
|
|
if (local->hw_roc_cookie != cookie)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
ret = drv_cancel_remain_on_channel(local);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
local->hw_roc_cookie = 0;
|
|
|
|
local->hw_roc_channel = NULL;
|
|
|
|
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-12-23 05:15:42 -07:00
|
|
|
static int ieee80211_cancel_remain_on_channel(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u64 cookie)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
2010-12-18 09:20:47 -07:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
if (local->ops->cancel_remain_on_channel) {
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
ret = ieee80211_cancel_remain_on_channel_hw(local, cookie);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2009-12-23 05:15:42 -07:00
|
|
|
|
|
|
|
return ieee80211_wk_cancel_remain_on_channel(sdata, cookie);
|
|
|
|
}
|
|
|
|
|
2010-11-25 02:02:30 -07:00
|
|
|
static enum work_done_result
|
|
|
|
ieee80211_offchan_tx_done(struct ieee80211_work *wk, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Use the data embedded in the work struct for reporting
|
|
|
|
* here so if the driver mangled the SKB before dropping
|
|
|
|
* it (which is the only way we really should get here)
|
|
|
|
* then we don't report mangled data.
|
|
|
|
*
|
|
|
|
* If there was no wait time, then by the time we get here
|
|
|
|
* the driver will likely not have reported the status yet,
|
|
|
|
* so in that case userspace will have to deal with it.
|
|
|
|
*/
|
|
|
|
|
2011-10-04 10:27:10 -06:00
|
|
|
if (wk->offchan_tx.wait && !wk->offchan_tx.status)
|
2010-11-25 02:02:30 -07:00
|
|
|
cfg80211_mgmt_tx_status(wk->sdata->dev,
|
|
|
|
(unsigned long) wk->offchan_tx.frame,
|
2012-01-20 05:55:27 -07:00
|
|
|
wk->data, wk->data_len, false, GFP_KERNEL);
|
2010-11-25 02:02:30 -07:00
|
|
|
|
|
|
|
return WORK_DONE_DESTROY;
|
|
|
|
}
|
|
|
|
|
2010-08-12 07:38:38 -06:00
|
|
|
static int ieee80211_mgmt_tx(struct wiphy *wiphy, struct net_device *dev,
|
2010-11-25 02:02:29 -07:00
|
|
|
struct ieee80211_channel *chan, bool offchan,
|
2010-08-12 07:38:38 -06:00
|
|
|
enum nl80211_channel_type channel_type,
|
2010-11-25 02:02:29 -07:00
|
|
|
bool channel_type_valid, unsigned int wait,
|
2011-09-25 03:23:30 -06:00
|
|
|
const u8 *buf, size_t len, bool no_cck,
|
2011-11-04 04:18:21 -06:00
|
|
|
bool dont_wait_for_ack, u64 *cookie)
|
2010-02-15 03:53:10 -07:00
|
|
|
{
|
2010-06-09 09:20:33 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct sta_info *sta;
|
2010-11-25 02:02:30 -07:00
|
|
|
struct ieee80211_work *wk;
|
2010-06-09 09:20:33 -06:00
|
|
|
const struct ieee80211_mgmt *mgmt = (void *)buf;
|
2011-11-04 04:18:21 -06:00
|
|
|
u32 flags;
|
2010-11-25 02:02:30 -07:00
|
|
|
bool is_offchan = false;
|
2010-11-25 02:02:29 -07:00
|
|
|
|
2011-11-04 04:18:21 -06:00
|
|
|
if (dont_wait_for_ack)
|
|
|
|
flags = IEEE80211_TX_CTL_NO_ACK;
|
|
|
|
else
|
|
|
|
flags = IEEE80211_TX_INTFL_NL80211_FRAME_TX |
|
|
|
|
IEEE80211_TX_CTL_REQ_TX_STATUS;
|
|
|
|
|
2010-06-09 09:20:33 -06:00
|
|
|
/* Check that we are on the requested channel for transmission */
|
|
|
|
if (chan != local->tmp_channel &&
|
|
|
|
chan != local->oper_channel)
|
2010-11-25 02:02:30 -07:00
|
|
|
is_offchan = true;
|
2010-06-09 09:20:33 -06:00
|
|
|
if (channel_type_valid &&
|
|
|
|
(channel_type != local->tmp_channel_type &&
|
|
|
|
channel_type != local->_oper_channel_type))
|
2010-11-25 02:02:30 -07:00
|
|
|
is_offchan = true;
|
|
|
|
|
2010-12-18 09:20:47 -07:00
|
|
|
if (chan == local->hw_roc_channel) {
|
|
|
|
/* TODO: check channel type? */
|
|
|
|
is_offchan = false;
|
|
|
|
flags |= IEEE80211_TX_CTL_TX_OFFCHAN;
|
|
|
|
}
|
|
|
|
|
2011-09-25 03:23:31 -06:00
|
|
|
if (no_cck)
|
|
|
|
flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
|
|
|
|
|
2010-11-25 02:02:30 -07:00
|
|
|
if (is_offchan && !offchan)
|
2010-06-09 09:20:33 -06:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
switch (sdata->vif.type) {
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
2010-09-30 13:06:09 -06:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
|
|
|
case NL80211_IFTYPE_P2P_GO:
|
2010-12-16 18:37:50 -07:00
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2010-09-30 13:06:09 -06:00
|
|
|
if (!ieee80211_is_action(mgmt->frame_control) ||
|
|
|
|
mgmt->u.action.category == WLAN_CATEGORY_PUBLIC)
|
2010-06-09 09:20:33 -06:00
|
|
|
break;
|
|
|
|
rcu_read_lock();
|
|
|
|
sta = sta_info_get(sdata, mgmt->da);
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (!sta)
|
|
|
|
return -ENOLINK;
|
|
|
|
break;
|
|
|
|
case NL80211_IFTYPE_STATION:
|
2010-09-30 13:06:09 -06:00
|
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
2010-06-09 09:20:33 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + len);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
memcpy(skb_put(skb, len), buf, len);
|
|
|
|
|
|
|
|
IEEE80211_SKB_CB(skb)->flags = flags;
|
|
|
|
|
2012-04-03 08:28:50 -06:00
|
|
|
if (flags & IEEE80211_TX_CTL_TX_OFFCHAN)
|
|
|
|
IEEE80211_SKB_CB(skb)->hw_queue =
|
|
|
|
local->hw.offchannel_tx_hw_queue;
|
|
|
|
|
2010-06-09 09:20:33 -06:00
|
|
|
skb->dev = sdata->dev;
|
|
|
|
|
|
|
|
*cookie = (unsigned long) skb;
|
2010-11-25 02:02:30 -07:00
|
|
|
|
2010-12-18 09:20:48 -07:00
|
|
|
if (is_offchan && local->ops->remain_on_channel) {
|
|
|
|
unsigned int duration;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
/*
|
|
|
|
* If the duration is zero, then the driver
|
|
|
|
* wouldn't actually do anything. Set it to
|
|
|
|
* 100 for now.
|
|
|
|
*
|
|
|
|
* TODO: cancel the off-channel operation
|
|
|
|
* when we get the SKB's TX status and
|
|
|
|
* the wait time was zero before.
|
|
|
|
*/
|
|
|
|
duration = 100;
|
|
|
|
if (wait)
|
|
|
|
duration = wait;
|
|
|
|
ret = ieee80211_remain_on_channel_hw(local, dev, chan,
|
|
|
|
channel_type,
|
|
|
|
duration, cookie);
|
|
|
|
if (ret) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
local->hw_roc_for_tx = true;
|
|
|
|
local->hw_roc_duration = wait;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* queue up frame for transmission after
|
|
|
|
* ieee80211_ready_on_channel call
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* modify cookie to prevent API mismatches */
|
|
|
|
*cookie ^= 2;
|
|
|
|
IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_TX_OFFCHAN;
|
2012-04-03 08:28:50 -06:00
|
|
|
IEEE80211_SKB_CB(skb)->hw_queue =
|
|
|
|
local->hw.offchannel_tx_hw_queue;
|
2010-12-18 09:20:48 -07:00
|
|
|
local->hw_roc_skb = skb;
|
2011-02-02 08:58:06 -07:00
|
|
|
local->hw_roc_skb_for_status = skb;
|
2010-12-18 09:20:48 -07:00
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-25 02:02:30 -07:00
|
|
|
/*
|
|
|
|
* Can transmit right away if the channel was the
|
|
|
|
* right one and there's no wait involved... If a
|
|
|
|
* wait is involved, we might otherwise not be on
|
|
|
|
* the right channel for long enough!
|
|
|
|
*/
|
|
|
|
if (!is_offchan && !wait && !sdata->vif.bss_conf.idle) {
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
wk = kzalloc(sizeof(*wk) + len, GFP_KERNEL);
|
|
|
|
if (!wk) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
wk->type = IEEE80211_WORK_OFFCHANNEL_TX;
|
|
|
|
wk->chan = chan;
|
2011-02-07 14:44:34 -07:00
|
|
|
wk->chan_type = channel_type;
|
2010-11-25 02:02:30 -07:00
|
|
|
wk->sdata = sdata;
|
|
|
|
wk->done = ieee80211_offchan_tx_done;
|
|
|
|
wk->offchan_tx.frame = skb;
|
|
|
|
wk->offchan_tx.wait = wait;
|
2012-01-20 05:55:27 -07:00
|
|
|
wk->data_len = len;
|
|
|
|
memcpy(wk->data, buf, len);
|
2010-11-25 02:02:30 -07:00
|
|
|
|
|
|
|
ieee80211_add_work(wk);
|
2010-06-09 09:20:33 -06:00
|
|
|
return 0;
|
2010-02-15 03:53:10 -07:00
|
|
|
}
|
|
|
|
|
2010-11-25 02:02:30 -07:00
|
|
|
static int ieee80211_mgmt_tx_cancel_wait(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u64 cookie)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_work *wk;
|
|
|
|
int ret = -ENOENT;
|
|
|
|
|
|
|
|
mutex_lock(&local->mtx);
|
2010-12-18 09:20:48 -07:00
|
|
|
|
|
|
|
if (local->ops->cancel_remain_on_channel) {
|
|
|
|
cookie ^= 2;
|
|
|
|
ret = ieee80211_cancel_remain_on_channel_hw(local, cookie);
|
|
|
|
|
|
|
|
if (ret == 0) {
|
|
|
|
kfree_skb(local->hw_roc_skb);
|
|
|
|
local->hw_roc_skb = NULL;
|
2011-02-02 08:58:06 -07:00
|
|
|
local->hw_roc_skb_for_status = NULL;
|
2010-12-18 09:20:48 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-11-25 02:02:30 -07:00
|
|
|
list_for_each_entry(wk, &local->work_list, list) {
|
|
|
|
if (wk->sdata != sdata)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (wk->type != IEEE80211_WORK_OFFCHANNEL_TX)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (cookie != (unsigned long) wk->offchan_tx.frame)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
wk->timeout = jiffies;
|
|
|
|
|
|
|
|
ieee80211_queue_work(&local->hw, &local->work_work);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-10-13 04:06:24 -06:00
|
|
|
static void ieee80211_mgmt_frame_register(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
u16 frame_type, bool reg)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
if (frame_type != (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_PROBE_REQ))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (reg)
|
|
|
|
local->probe_req_reg++;
|
|
|
|
else
|
|
|
|
local->probe_req_reg--;
|
|
|
|
|
|
|
|
ieee80211_queue_work(&local->hw, &local->reconfig_filter);
|
|
|
|
}
|
|
|
|
|
2010-11-09 20:50:56 -07:00
|
|
|
static int ieee80211_set_antenna(struct wiphy *wiphy, u32 tx_ant, u32 rx_ant)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
if (local->started)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return drv_set_antenna(local, tx_ant, rx_ant);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_get_antenna(struct wiphy *wiphy, u32 *tx_ant, u32 *rx_ant)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
return drv_get_antenna(local, tx_ant, rx_ant);
|
|
|
|
}
|
|
|
|
|
2011-03-07 14:19:18 -07:00
|
|
|
static int ieee80211_set_ringparam(struct wiphy *wiphy, u32 tx, u32 rx)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
return drv_set_ringparam(local, tx, rx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_get_ringparam(struct wiphy *wiphy,
|
|
|
|
u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
|
|
|
drv_get_ringparam(local, tx, tx_max, rx, rx_max);
|
|
|
|
}
|
|
|
|
|
2011-07-05 08:35:41 -06:00
|
|
|
static int ieee80211_set_rekey_data(struct wiphy *wiphy,
|
|
|
|
struct net_device *dev,
|
|
|
|
struct cfg80211_gtk_rekey_data *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
if (!local->ops->set_rekey_data)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
drv_set_rekey_data(local, sdata, data);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-09-28 05:12:52 -06:00
|
|
|
static void ieee80211_tdls_add_ext_capab(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
u8 *pos = (void *)skb_put(skb, 7);
|
|
|
|
|
|
|
|
*pos++ = WLAN_EID_EXT_CAPABILITY;
|
|
|
|
*pos++ = 5; /* len */
|
|
|
|
*pos++ = 0x0;
|
|
|
|
*pos++ = 0x0;
|
|
|
|
*pos++ = 0x0;
|
|
|
|
*pos++ = 0x0;
|
|
|
|
*pos++ = WLAN_EXT_CAPA5_TDLS_ENABLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u16 ieee80211_get_tdls_sta_capab(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
u16 capab;
|
|
|
|
|
|
|
|
capab = 0;
|
|
|
|
if (local->oper_channel->band != IEEE80211_BAND_2GHZ)
|
|
|
|
return capab;
|
|
|
|
|
|
|
|
if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
|
|
|
|
capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
|
|
|
|
if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
|
|
|
|
capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
|
|
|
|
|
|
|
|
return capab;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ieee80211_tdls_add_link_ie(struct sk_buff *skb, u8 *src_addr,
|
|
|
|
u8 *peer, u8 *bssid)
|
|
|
|
{
|
|
|
|
struct ieee80211_tdls_lnkie *lnkid;
|
|
|
|
|
|
|
|
lnkid = (void *)skb_put(skb, sizeof(struct ieee80211_tdls_lnkie));
|
|
|
|
|
|
|
|
lnkid->ie_type = WLAN_EID_LINK_ID;
|
|
|
|
lnkid->ie_len = sizeof(struct ieee80211_tdls_lnkie) - 2;
|
|
|
|
|
|
|
|
memcpy(lnkid->bssid, bssid, ETH_ALEN);
|
|
|
|
memcpy(lnkid->init_sta, src_addr, ETH_ALEN);
|
|
|
|
memcpy(lnkid->resp_sta, peer, ETH_ALEN);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ieee80211_prep_tdls_encap_data(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *peer, u8 action_code, u8 dialog_token,
|
|
|
|
u16 status_code, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_tdls_data *tf;
|
|
|
|
|
|
|
|
tf = (void *)skb_put(skb, offsetof(struct ieee80211_tdls_data, u));
|
|
|
|
|
|
|
|
memcpy(tf->da, peer, ETH_ALEN);
|
|
|
|
memcpy(tf->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
tf->ether_type = cpu_to_be16(ETH_P_TDLS);
|
|
|
|
tf->payload_type = WLAN_TDLS_SNAP_RFTYPE;
|
|
|
|
|
|
|
|
switch (action_code) {
|
|
|
|
case WLAN_TDLS_SETUP_REQUEST:
|
|
|
|
tf->category = WLAN_CATEGORY_TDLS;
|
|
|
|
tf->action_code = WLAN_TDLS_SETUP_REQUEST;
|
|
|
|
|
|
|
|
skb_put(skb, sizeof(tf->u.setup_req));
|
|
|
|
tf->u.setup_req.dialog_token = dialog_token;
|
|
|
|
tf->u.setup_req.capability =
|
|
|
|
cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
|
|
|
|
|
2012-04-02 22:21:20 -06:00
|
|
|
ieee80211_add_srates_ie(&sdata->vif, skb, false);
|
|
|
|
ieee80211_add_ext_srates_ie(&sdata->vif, skb, false);
|
2011-09-28 05:12:52 -06:00
|
|
|
ieee80211_tdls_add_ext_capab(skb);
|
|
|
|
break;
|
|
|
|
case WLAN_TDLS_SETUP_RESPONSE:
|
|
|
|
tf->category = WLAN_CATEGORY_TDLS;
|
|
|
|
tf->action_code = WLAN_TDLS_SETUP_RESPONSE;
|
|
|
|
|
|
|
|
skb_put(skb, sizeof(tf->u.setup_resp));
|
|
|
|
tf->u.setup_resp.status_code = cpu_to_le16(status_code);
|
|
|
|
tf->u.setup_resp.dialog_token = dialog_token;
|
|
|
|
tf->u.setup_resp.capability =
|
|
|
|
cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
|
|
|
|
|
2012-04-02 22:21:20 -06:00
|
|
|
ieee80211_add_srates_ie(&sdata->vif, skb, false);
|
|
|
|
ieee80211_add_ext_srates_ie(&sdata->vif, skb, false);
|
2011-09-28 05:12:52 -06:00
|
|
|
ieee80211_tdls_add_ext_capab(skb);
|
|
|
|
break;
|
|
|
|
case WLAN_TDLS_SETUP_CONFIRM:
|
|
|
|
tf->category = WLAN_CATEGORY_TDLS;
|
|
|
|
tf->action_code = WLAN_TDLS_SETUP_CONFIRM;
|
|
|
|
|
|
|
|
skb_put(skb, sizeof(tf->u.setup_cfm));
|
|
|
|
tf->u.setup_cfm.status_code = cpu_to_le16(status_code);
|
|
|
|
tf->u.setup_cfm.dialog_token = dialog_token;
|
|
|
|
break;
|
|
|
|
case WLAN_TDLS_TEARDOWN:
|
|
|
|
tf->category = WLAN_CATEGORY_TDLS;
|
|
|
|
tf->action_code = WLAN_TDLS_TEARDOWN;
|
|
|
|
|
|
|
|
skb_put(skb, sizeof(tf->u.teardown));
|
|
|
|
tf->u.teardown.reason_code = cpu_to_le16(status_code);
|
|
|
|
break;
|
|
|
|
case WLAN_TDLS_DISCOVERY_REQUEST:
|
|
|
|
tf->category = WLAN_CATEGORY_TDLS;
|
|
|
|
tf->action_code = WLAN_TDLS_DISCOVERY_REQUEST;
|
|
|
|
|
|
|
|
skb_put(skb, sizeof(tf->u.discover_req));
|
|
|
|
tf->u.discover_req.dialog_token = dialog_token;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
ieee80211_prep_tdls_direct(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *peer, u8 action_code, u8 dialog_token,
|
|
|
|
u16 status_code, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
|
|
|
|
|
|
|
mgmt = (void *)skb_put(skb, 24);
|
|
|
|
memset(mgmt, 0, 24);
|
|
|
|
memcpy(mgmt->da, peer, ETH_ALEN);
|
|
|
|
memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN);
|
|
|
|
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_ACTION);
|
|
|
|
|
|
|
|
switch (action_code) {
|
|
|
|
case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
|
|
|
|
skb_put(skb, 1 + sizeof(mgmt->u.action.u.tdls_discover_resp));
|
|
|
|
mgmt->u.action.category = WLAN_CATEGORY_PUBLIC;
|
|
|
|
mgmt->u.action.u.tdls_discover_resp.action_code =
|
|
|
|
WLAN_PUB_ACTION_TDLS_DISCOVER_RES;
|
|
|
|
mgmt->u.action.u.tdls_discover_resp.dialog_token =
|
|
|
|
dialog_token;
|
|
|
|
mgmt->u.action.u.tdls_discover_resp.capability =
|
|
|
|
cpu_to_le16(ieee80211_get_tdls_sta_capab(sdata));
|
|
|
|
|
2012-04-02 22:21:20 -06:00
|
|
|
ieee80211_add_srates_ie(&sdata->vif, skb, false);
|
|
|
|
ieee80211_add_ext_srates_ie(&sdata->vif, skb, false);
|
2011-09-28 05:12:52 -06:00
|
|
|
ieee80211_tdls_add_ext_capab(skb);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_tdls_mgmt(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *peer, u8 action_code, u8 dialog_token,
|
|
|
|
u16 status_code, const u8 *extra_ies,
|
|
|
|
size_t extra_ies_len)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_tx_info *info;
|
|
|
|
struct sk_buff *skb = NULL;
|
|
|
|
bool send_direct;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
|
|
|
/* make sure we are in managed mode, and associated */
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION ||
|
|
|
|
!sdata->u.mgd.associated)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_TDLS_DEBUG
|
|
|
|
printk(KERN_DEBUG "TDLS mgmt action %d peer %pM\n", action_code, peer);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom +
|
|
|
|
max(sizeof(struct ieee80211_mgmt),
|
|
|
|
sizeof(struct ieee80211_tdls_data)) +
|
|
|
|
50 + /* supported rates */
|
|
|
|
7 + /* ext capab */
|
|
|
|
extra_ies_len +
|
|
|
|
sizeof(struct ieee80211_tdls_lnkie));
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
info = IEEE80211_SKB_CB(skb);
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
switch (action_code) {
|
|
|
|
case WLAN_TDLS_SETUP_REQUEST:
|
|
|
|
case WLAN_TDLS_SETUP_RESPONSE:
|
|
|
|
case WLAN_TDLS_SETUP_CONFIRM:
|
|
|
|
case WLAN_TDLS_TEARDOWN:
|
|
|
|
case WLAN_TDLS_DISCOVERY_REQUEST:
|
|
|
|
ret = ieee80211_prep_tdls_encap_data(wiphy, dev, peer,
|
|
|
|
action_code, dialog_token,
|
|
|
|
status_code, skb);
|
|
|
|
send_direct = false;
|
|
|
|
break;
|
|
|
|
case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
|
|
|
|
ret = ieee80211_prep_tdls_direct(wiphy, dev, peer, action_code,
|
|
|
|
dialog_token, status_code,
|
|
|
|
skb);
|
|
|
|
send_direct = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -ENOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
if (extra_ies_len)
|
|
|
|
memcpy(skb_put(skb, extra_ies_len), extra_ies, extra_ies_len);
|
|
|
|
|
|
|
|
/* the TDLS link IE is always added last */
|
|
|
|
switch (action_code) {
|
|
|
|
case WLAN_TDLS_SETUP_REQUEST:
|
|
|
|
case WLAN_TDLS_SETUP_CONFIRM:
|
|
|
|
case WLAN_TDLS_TEARDOWN:
|
|
|
|
case WLAN_TDLS_DISCOVERY_REQUEST:
|
|
|
|
/* we are the initiator */
|
|
|
|
ieee80211_tdls_add_link_ie(skb, sdata->vif.addr, peer,
|
|
|
|
sdata->u.mgd.bssid);
|
|
|
|
break;
|
|
|
|
case WLAN_TDLS_SETUP_RESPONSE:
|
|
|
|
case WLAN_PUB_ACTION_TDLS_DISCOVER_RES:
|
|
|
|
/* we are the responder */
|
|
|
|
ieee80211_tdls_add_link_ie(skb, peer, sdata->vif.addr,
|
|
|
|
sdata->u.mgd.bssid);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -ENOTSUPP;
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (send_direct) {
|
|
|
|
ieee80211_tx_skb(sdata, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* According to 802.11z: Setup req/resp are sent in AC_BK, otherwise
|
|
|
|
* we should default to AC_VI.
|
|
|
|
*/
|
|
|
|
switch (action_code) {
|
|
|
|
case WLAN_TDLS_SETUP_REQUEST:
|
|
|
|
case WLAN_TDLS_SETUP_RESPONSE:
|
|
|
|
skb_set_queue_mapping(skb, IEEE80211_AC_BK);
|
|
|
|
skb->priority = 2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
skb_set_queue_mapping(skb, IEEE80211_AC_VI);
|
|
|
|
skb->priority = 5;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* disable bottom halves when entering the Tx path */
|
|
|
|
local_bh_disable();
|
|
|
|
ret = ieee80211_subif_start_xmit(skb, dev);
|
|
|
|
local_bh_enable();
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ieee80211_tdls_oper(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
u8 *peer, enum nl80211_tdls_operation oper)
|
|
|
|
{
|
2011-09-28 05:12:54 -06:00
|
|
|
struct sta_info *sta;
|
2011-09-28 05:12:52 -06:00
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
|
|
|
|
if (!(wiphy->flags & WIPHY_FLAG_SUPPORTS_TDLS))
|
|
|
|
return -ENOTSUPP;
|
|
|
|
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_STATION)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_TDLS_DEBUG
|
|
|
|
printk(KERN_DEBUG "TDLS oper %d peer %pM\n", oper, peer);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
switch (oper) {
|
|
|
|
case NL80211_TDLS_ENABLE_LINK:
|
2011-09-28 05:12:54 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
sta = sta_info_get(sdata, peer);
|
|
|
|
if (!sta) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -ENOLINK;
|
|
|
|
}
|
|
|
|
|
2011-09-29 08:04:36 -06:00
|
|
|
set_sta_flag(sta, WLAN_STA_TDLS_PEER_AUTH);
|
2011-09-28 05:12:54 -06:00
|
|
|
rcu_read_unlock();
|
2011-09-28 05:12:52 -06:00
|
|
|
break;
|
|
|
|
case NL80211_TDLS_DISABLE_LINK:
|
|
|
|
return sta_info_destroy_addr(sdata, peer);
|
|
|
|
case NL80211_TDLS_TEARDOWN:
|
|
|
|
case NL80211_TDLS_SETUP:
|
|
|
|
case NL80211_TDLS_DISCOVERY_REQ:
|
|
|
|
/* We don't support in-driver setup/teardown/discovery */
|
|
|
|
return -ENOTSUPP;
|
|
|
|
default:
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-04 04:18:16 -06:00
|
|
|
static int ieee80211_probe_client(struct wiphy *wiphy, struct net_device *dev,
|
|
|
|
const u8 *peer, u64 *cookie)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_qos_hdr *nullfunc;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int size = sizeof(*nullfunc);
|
|
|
|
__le16 fc;
|
|
|
|
bool qos;
|
|
|
|
struct ieee80211_tx_info *info;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
sta = sta_info_get(sdata, peer);
|
2011-11-11 12:22:30 -07:00
|
|
|
if (sta) {
|
2011-11-04 04:18:16 -06:00
|
|
|
qos = test_sta_flag(sta, WLAN_STA_WME);
|
2011-11-11 12:22:30 -07:00
|
|
|
rcu_read_unlock();
|
|
|
|
} else {
|
|
|
|
rcu_read_unlock();
|
2011-11-04 04:18:16 -06:00
|
|
|
return -ENOLINK;
|
2011-11-11 12:22:30 -07:00
|
|
|
}
|
2011-11-04 04:18:16 -06:00
|
|
|
|
|
|
|
if (qos) {
|
|
|
|
fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
|
|
|
|
IEEE80211_STYPE_QOS_NULLFUNC |
|
|
|
|
IEEE80211_FCTL_FROMDS);
|
|
|
|
} else {
|
|
|
|
size -= 2;
|
|
|
|
fc = cpu_to_le16(IEEE80211_FTYPE_DATA |
|
|
|
|
IEEE80211_STYPE_NULLFUNC |
|
|
|
|
IEEE80211_FCTL_FROMDS);
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
|
|
|
|
if (!skb)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
skb->dev = dev;
|
|
|
|
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
nullfunc = (void *) skb_put(skb, size);
|
|
|
|
nullfunc->frame_control = fc;
|
|
|
|
nullfunc->duration_id = 0;
|
|
|
|
memcpy(nullfunc->addr1, sta->sta.addr, ETH_ALEN);
|
|
|
|
memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
|
|
|
|
memcpy(nullfunc->addr3, sdata->vif.addr, ETH_ALEN);
|
|
|
|
nullfunc->seq_ctrl = 0;
|
|
|
|
|
|
|
|
info = IEEE80211_SKB_CB(skb);
|
|
|
|
|
|
|
|
info->flags |= IEEE80211_TX_CTL_REQ_TX_STATUS |
|
|
|
|
IEEE80211_TX_INTFL_NL80211_FRAME_TX;
|
|
|
|
|
|
|
|
skb_set_queue_mapping(skb, IEEE80211_AC_VO);
|
|
|
|
skb->priority = 7;
|
|
|
|
if (qos)
|
|
|
|
nullfunc->qos_ctrl = cpu_to_le16(7);
|
|
|
|
|
|
|
|
local_bh_disable();
|
|
|
|
ieee80211_xmit(sdata, skb);
|
|
|
|
local_bh_enable();
|
|
|
|
|
|
|
|
*cookie = (unsigned long) skb;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-11-09 02:30:21 -07:00
|
|
|
static struct ieee80211_channel *
|
2012-04-03 08:39:58 -06:00
|
|
|
ieee80211_wiphy_get_channel(struct wiphy *wiphy,
|
|
|
|
enum nl80211_channel_type *type)
|
2011-11-09 02:30:21 -07:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = wiphy_priv(wiphy);
|
|
|
|
|
2012-04-03 08:39:58 -06:00
|
|
|
*type = local->_oper_channel_type;
|
2011-11-09 02:30:21 -07:00
|
|
|
return local->oper_channel;
|
|
|
|
}
|
|
|
|
|
2012-04-04 07:05:25 -06:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static void ieee80211_set_wakeup(struct wiphy *wiphy, bool enabled)
|
|
|
|
{
|
|
|
|
drv_set_wakeup(wiphy_priv(wiphy), enabled);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-05 12:45:53 -06:00
|
|
|
struct cfg80211_ops mac80211_config_ops = {
|
|
|
|
.add_virtual_intf = ieee80211_add_iface,
|
|
|
|
.del_virtual_intf = ieee80211_del_iface,
|
2007-09-28 13:52:27 -06:00
|
|
|
.change_virtual_intf = ieee80211_change_iface,
|
2007-12-18 18:03:30 -07:00
|
|
|
.add_key = ieee80211_add_key,
|
|
|
|
.del_key = ieee80211_del_key,
|
2007-12-18 18:03:31 -07:00
|
|
|
.get_key = ieee80211_get_key,
|
2007-12-18 18:03:30 -07:00
|
|
|
.set_default_key = ieee80211_config_default_key,
|
2009-01-08 04:32:02 -07:00
|
|
|
.set_default_mgmt_key = ieee80211_config_default_mgmt_key,
|
2012-02-13 07:17:18 -07:00
|
|
|
.start_ap = ieee80211_start_ap,
|
|
|
|
.change_beacon = ieee80211_change_beacon,
|
|
|
|
.stop_ap = ieee80211_stop_ap,
|
2007-12-18 18:03:35 -07:00
|
|
|
.add_station = ieee80211_add_station,
|
|
|
|
.del_station = ieee80211_del_station,
|
|
|
|
.change_station = ieee80211_change_station,
|
2007-12-18 18:03:37 -07:00
|
|
|
.get_station = ieee80211_get_station,
|
2008-02-23 07:17:17 -07:00
|
|
|
.dump_station = ieee80211_dump_station,
|
2010-04-19 02:23:57 -06:00
|
|
|
.dump_survey = ieee80211_dump_survey,
|
2008-02-23 07:17:17 -07:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
|
|
|
.add_mpath = ieee80211_add_mpath,
|
|
|
|
.del_mpath = ieee80211_del_mpath,
|
|
|
|
.change_mpath = ieee80211_change_mpath,
|
|
|
|
.get_mpath = ieee80211_get_mpath,
|
|
|
|
.dump_mpath = ieee80211_dump_mpath,
|
2010-12-16 18:37:48 -07:00
|
|
|
.update_mesh_config = ieee80211_update_mesh_config,
|
|
|
|
.get_mesh_config = ieee80211_get_mesh_config,
|
2010-12-03 01:20:44 -07:00
|
|
|
.join_mesh = ieee80211_join_mesh,
|
|
|
|
.leave_mesh = ieee80211_leave_mesh,
|
2008-02-23 07:17:17 -07:00
|
|
|
#endif
|
2008-08-07 11:07:01 -06:00
|
|
|
.change_bss = ieee80211_change_bss,
|
2008-10-30 08:59:24 -06:00
|
|
|
.set_txq_params = ieee80211_set_txq_params,
|
2008-11-26 07:15:24 -07:00
|
|
|
.set_channel = ieee80211_set_channel,
|
2009-01-19 09:20:53 -07:00
|
|
|
.suspend = ieee80211_suspend,
|
|
|
|
.resume = ieee80211_resume,
|
2009-02-10 13:25:55 -07:00
|
|
|
.scan = ieee80211_scan,
|
2011-05-11 08:09:36 -06:00
|
|
|
.sched_scan_start = ieee80211_sched_scan_start,
|
|
|
|
.sched_scan_stop = ieee80211_sched_scan_stop,
|
2009-03-19 05:39:22 -06:00
|
|
|
.auth = ieee80211_auth,
|
|
|
|
.assoc = ieee80211_assoc,
|
|
|
|
.deauth = ieee80211_deauth,
|
|
|
|
.disassoc = ieee80211_disassoc,
|
2009-04-19 13:25:43 -06:00
|
|
|
.join_ibss = ieee80211_join_ibss,
|
|
|
|
.leave_ibss = ieee80211_leave_ibss,
|
2009-04-20 10:39:05 -06:00
|
|
|
.set_wiphy_params = ieee80211_set_wiphy_params,
|
2009-06-02 05:01:39 -06:00
|
|
|
.set_tx_power = ieee80211_set_tx_power,
|
|
|
|
.get_tx_power = ieee80211_get_tx_power,
|
2009-07-01 13:26:58 -06:00
|
|
|
.set_wds_peer = ieee80211_set_wds_peer,
|
2009-06-02 05:01:41 -06:00
|
|
|
.rfkill_poll = ieee80211_rfkill_poll,
|
2009-07-01 13:26:51 -06:00
|
|
|
CFG80211_TESTMODE_CMD(ieee80211_testmode_cmd)
|
2011-05-20 10:05:54 -06:00
|
|
|
CFG80211_TESTMODE_DUMP(ieee80211_testmode_dump)
|
2009-07-01 13:26:57 -06:00
|
|
|
.set_power_mgmt = ieee80211_set_power_mgmt,
|
2009-07-01 13:26:59 -06:00
|
|
|
.set_bitrate_mask = ieee80211_set_bitrate_mask,
|
2009-12-23 05:15:42 -07:00
|
|
|
.remain_on_channel = ieee80211_remain_on_channel,
|
|
|
|
.cancel_remain_on_channel = ieee80211_cancel_remain_on_channel,
|
2010-08-12 07:38:38 -06:00
|
|
|
.mgmt_tx = ieee80211_mgmt_tx,
|
2010-11-25 02:02:30 -07:00
|
|
|
.mgmt_tx_cancel_wait = ieee80211_mgmt_tx_cancel_wait,
|
2010-03-23 01:02:34 -06:00
|
|
|
.set_cqm_rssi_config = ieee80211_set_cqm_rssi_config,
|
2010-10-13 04:06:24 -06:00
|
|
|
.mgmt_frame_register = ieee80211_mgmt_frame_register,
|
2010-11-09 20:50:56 -07:00
|
|
|
.set_antenna = ieee80211_set_antenna,
|
|
|
|
.get_antenna = ieee80211_get_antenna,
|
2011-03-07 14:19:18 -07:00
|
|
|
.set_ringparam = ieee80211_set_ringparam,
|
|
|
|
.get_ringparam = ieee80211_get_ringparam,
|
2011-07-05 08:35:41 -06:00
|
|
|
.set_rekey_data = ieee80211_set_rekey_data,
|
2011-09-28 05:12:52 -06:00
|
|
|
.tdls_oper = ieee80211_tdls_oper,
|
|
|
|
.tdls_mgmt = ieee80211_tdls_mgmt,
|
2011-11-04 04:18:16 -06:00
|
|
|
.probe_client = ieee80211_probe_client,
|
2011-11-09 02:30:21 -07:00
|
|
|
.get_channel = ieee80211_wiphy_get_channel,
|
2011-11-18 06:20:44 -07:00
|
|
|
.set_noack_map = ieee80211_set_noack_map,
|
2012-04-04 07:05:25 -06:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
.set_wakeup = ieee80211_set_wakeup,
|
|
|
|
#endif
|
2012-04-23 13:50:30 -06:00
|
|
|
.get_et_sset_count = ieee80211_get_et_sset_count,
|
|
|
|
.get_et_stats = ieee80211_get_et_stats,
|
|
|
|
.get_et_strings = ieee80211_get_et_strings,
|
2007-05-05 12:45:53 -06:00
|
|
|
};
|