2007-05-05 18:45:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/if_arp.h>
|
2007-12-17 14:07:43 +00:00
|
|
|
#include <linux/timer.h>
|
2008-02-25 15:27:46 +00:00
|
|
|
#include <linux/rtnetlink.h>
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include "ieee80211_i.h"
|
2009-04-23 16:52:52 +00:00
|
|
|
#include "driver-ops.h"
|
2008-04-08 19:14:40 +00:00
|
|
|
#include "rate.h"
|
2007-05-05 18:45:53 +00:00
|
|
|
#include "sta_info.h"
|
2007-05-05 18:46:38 +00:00
|
|
|
#include "debugfs_sta.h"
|
2008-02-23 14:17:11 +00:00
|
|
|
#include "mesh.h"
|
2011-09-29 14:04:34 +00:00
|
|
|
#include "wme.h"
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-02-25 15:27:46 +00:00
|
|
|
/**
|
|
|
|
* DOC: STA information lifetime rules
|
|
|
|
*
|
|
|
|
* STA info structures (&struct sta_info) are managed in a hash table
|
|
|
|
* for faster lookup and a list for iteration. They are managed using
|
|
|
|
* RCU, i.e. access to the list and hash table is protected by RCU.
|
|
|
|
*
|
2010-02-03 12:59:58 +00:00
|
|
|
* Upon allocating a STA info structure with sta_info_alloc(), the caller
|
|
|
|
* owns that structure. It must then insert it into the hash table using
|
|
|
|
* either sta_info_insert() or sta_info_insert_rcu(); only in the latter
|
|
|
|
* case (which acquires an rcu read section but must not be called from
|
|
|
|
* within one) will the pointer still be valid after the call. Note that
|
|
|
|
* the caller may not do much with the STA info before inserting it, in
|
|
|
|
* particular, it may not start any mesh peer link management or add
|
|
|
|
* encryption keys.
|
2008-04-01 13:21:00 +00:00
|
|
|
*
|
|
|
|
* When the insertion fails (sta_info_insert()) returns non-zero), the
|
|
|
|
* structure will have been freed by sta_info_insert()!
|
2008-02-25 15:27:46 +00:00
|
|
|
*
|
2010-02-03 12:59:58 +00:00
|
|
|
* Station entries are added by mac80211 when you establish a link with a
|
2009-06-02 22:38:14 +00:00
|
|
|
* peer. This means different things for the different type of interfaces
|
|
|
|
* we support. For a regular station this mean we add the AP sta when we
|
2011-03-31 01:57:33 +00:00
|
|
|
* receive an association response from the AP. For IBSS this occurs when
|
2010-02-03 12:59:58 +00:00
|
|
|
* get to know about a peer on the same IBSS. For WDS we add the sta for
|
2011-03-31 01:57:33 +00:00
|
|
|
* the peer immediately upon device open. When using AP mode we add stations
|
2010-02-03 12:59:58 +00:00
|
|
|
* for each respective station upon request from userspace through nl80211.
|
2009-06-02 22:38:14 +00:00
|
|
|
*
|
2010-02-03 12:59:58 +00:00
|
|
|
* In order to remove a STA info structure, various sta_info_destroy_*()
|
|
|
|
* calls are available.
|
2008-02-25 15:27:46 +00:00
|
|
|
*
|
2010-02-03 12:59:58 +00:00
|
|
|
* There is no concept of ownership on a STA entry, each structure is
|
|
|
|
* owned by the global hash table/list until it is removed. All users of
|
|
|
|
* the structure need to be RCU protected so that the structure won't be
|
|
|
|
* freed before they are done using it.
|
2008-02-25 15:27:46 +00:00
|
|
|
*/
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
/* Caller must hold local->sta_mtx */
|
2007-07-27 13:43:23 +00:00
|
|
|
static int sta_info_hash_del(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
|
|
|
struct sta_info *s;
|
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
s = rcu_dereference_protected(local->sta_hash[STA_HASH(sta->sta.addr)],
|
2011-12-15 10:24:20 +00:00
|
|
|
lockdep_is_held(&local->sta_mtx));
|
2007-05-05 18:45:53 +00:00
|
|
|
if (!s)
|
2007-07-27 13:43:23 +00:00
|
|
|
return -ENOENT;
|
|
|
|
if (s == sta) {
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)],
|
2008-02-25 15:27:46 +00:00
|
|
|
s->hnext);
|
2007-07-27 13:43:23 +00:00
|
|
|
return 0;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2011-05-13 12:15:49 +00:00
|
|
|
while (rcu_access_pointer(s->hnext) &&
|
|
|
|
rcu_access_pointer(s->hnext) != sta)
|
|
|
|
s = rcu_dereference_protected(s->hnext,
|
2011-12-15 10:24:20 +00:00
|
|
|
lockdep_is_held(&local->sta_mtx));
|
2011-05-13 12:15:49 +00:00
|
|
|
if (rcu_access_pointer(s->hnext)) {
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(s->hnext, sta->hnext);
|
2007-07-27 13:43:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2007-07-27 13:43:23 +00:00
|
|
|
return -ENOENT;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2008-02-25 15:27:46 +00:00
|
|
|
/* protected by RCU */
|
2009-11-25 16:46:18 +00:00
|
|
|
struct sta_info *sta_info_get(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *addr)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2009-11-25 16:46:18 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct sta_info *sta;
|
|
|
|
|
2011-08-17 12:18:15 +00:00
|
|
|
sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)],
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
|
|
|
while (sta) {
|
|
|
|
if (sta->sdata == sdata && !sta->dummy &&
|
|
|
|
memcmp(sta->sta.addr, addr, ETH_ALEN) == 0)
|
|
|
|
break;
|
|
|
|
sta = rcu_dereference_check(sta->hnext,
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
|
|
|
}
|
|
|
|
return sta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get a station info entry even if it is a dummy station*/
|
|
|
|
struct sta_info *sta_info_get_rx(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *addr)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
2010-04-06 09:18:42 +00:00
|
|
|
sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)],
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
2007-05-05 18:45:53 +00:00
|
|
|
while (sta) {
|
2009-11-25 16:46:18 +00:00
|
|
|
if (sta->sdata == sdata &&
|
|
|
|
memcmp(sta->sta.addr, addr, ETH_ALEN) == 0)
|
2007-05-05 18:45:53 +00:00
|
|
|
break;
|
2010-04-06 09:18:42 +00:00
|
|
|
sta = rcu_dereference_check(sta->hnext,
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
2008-02-21 13:09:30 +00:00
|
|
|
return sta;
|
|
|
|
}
|
|
|
|
|
2010-01-08 17:10:58 +00:00
|
|
|
/*
|
|
|
|
* Get sta info either from the specified interface
|
|
|
|
* or from one of its vlans
|
|
|
|
*/
|
|
|
|
struct sta_info *sta_info_get_bss(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *addr)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
2011-08-17 12:18:15 +00:00
|
|
|
sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)],
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
|
|
|
while (sta) {
|
|
|
|
if ((sta->sdata == sdata ||
|
|
|
|
(sta->sdata->bss && sta->sdata->bss == sdata->bss)) &&
|
|
|
|
!sta->dummy &&
|
|
|
|
memcmp(sta->sta.addr, addr, ETH_ALEN) == 0)
|
|
|
|
break;
|
|
|
|
sta = rcu_dereference_check(sta->hnext,
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
|
|
|
}
|
|
|
|
return sta;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get sta info either from the specified interface
|
|
|
|
* or from one of its vlans (including dummy stations)
|
|
|
|
*/
|
|
|
|
struct sta_info *sta_info_get_bss_rx(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *addr)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
2010-04-06 09:18:42 +00:00
|
|
|
sta = rcu_dereference_check(local->sta_hash[STA_HASH(addr)],
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
2010-01-08 17:10:58 +00:00
|
|
|
while (sta) {
|
|
|
|
if ((sta->sdata == sdata ||
|
2010-09-14 19:34:14 +00:00
|
|
|
(sta->sdata->bss && sta->sdata->bss == sdata->bss)) &&
|
2010-01-08 17:10:58 +00:00
|
|
|
memcmp(sta->sta.addr, addr, ETH_ALEN) == 0)
|
|
|
|
break;
|
2010-04-06 09:18:42 +00:00
|
|
|
sta = rcu_dereference_check(sta->hnext,
|
|
|
|
lockdep_is_held(&local->sta_mtx));
|
2010-01-08 17:10:58 +00:00
|
|
|
}
|
|
|
|
return sta;
|
|
|
|
}
|
|
|
|
|
2009-11-16 11:00:37 +00:00
|
|
|
struct sta_info *sta_info_get_by_idx(struct ieee80211_sub_if_data *sdata,
|
|
|
|
int idx)
|
2008-02-23 14:17:11 +00:00
|
|
|
{
|
2009-11-16 11:00:37 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2008-02-23 14:17:11 +00:00
|
|
|
struct sta_info *sta;
|
|
|
|
int i = 0;
|
|
|
|
|
2008-02-25 15:27:46 +00:00
|
|
|
list_for_each_entry_rcu(sta, &local->sta_list, list) {
|
2009-11-16 11:00:37 +00:00
|
|
|
if (sdata != sta->sdata)
|
2008-03-01 01:51:25 +00:00
|
|
|
continue;
|
2008-02-23 14:17:11 +00:00
|
|
|
if (i < idx) {
|
|
|
|
++i;
|
|
|
|
continue;
|
|
|
|
}
|
2008-03-01 01:51:25 +00:00
|
|
|
return sta;
|
2008-02-23 14:17:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-04-01 13:21:00 +00:00
|
|
|
/**
|
2011-12-14 11:35:30 +00:00
|
|
|
* sta_info_free - free STA
|
2008-04-01 13:21:00 +00:00
|
|
|
*
|
2008-07-03 20:52:18 +00:00
|
|
|
* @local: pointer to the global information
|
2008-04-01 13:21:00 +00:00
|
|
|
* @sta: STA info to free
|
|
|
|
*
|
|
|
|
* This function must undo everything done by sta_info_alloc()
|
2011-12-14 11:35:30 +00:00
|
|
|
* that may happen before sta_info_insert(). It may only be
|
|
|
|
* called when sta_info_insert() has not been attempted (and
|
|
|
|
* if that fails, the station is freed anyway.)
|
2008-04-01 13:21:00 +00:00
|
|
|
*/
|
2011-12-14 11:35:30 +00:00
|
|
|
void sta_info_free(struct ieee80211_local *local, struct sta_info *sta)
|
2008-04-01 13:21:00 +00:00
|
|
|
{
|
2012-01-17 09:33:29 +00:00
|
|
|
if (sta->rate_ctrl)
|
2009-11-17 17:18:36 +00:00
|
|
|
rate_control_free_sta(sta);
|
2008-04-01 13:21:00 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
|
2010-08-20 23:25:38 +00:00
|
|
|
wiphy_debug(local->hw.wiphy, "Destroyed STA %pM\n", sta->sta.addr);
|
2008-04-01 13:21:00 +00:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
|
|
|
|
|
|
|
|
kfree(sta);
|
|
|
|
}
|
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
/* Caller must hold local->sta_mtx */
|
2008-02-25 15:27:46 +00:00
|
|
|
static void sta_info_hash_add(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2011-12-15 10:24:20 +00:00
|
|
|
lockdep_assert_held(&local->sta_mtx);
|
2008-09-10 22:02:02 +00:00
|
|
|
sta->hnext = local->sta_hash[STA_HASH(sta->sta.addr)];
|
2012-01-12 04:41:32 +00:00
|
|
|
rcu_assign_pointer(local->sta_hash[STA_HASH(sta->sta.addr)], sta);
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
static void sta_unblock(struct work_struct *wk)
|
|
|
|
{
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
sta = container_of(wk, struct sta_info, drv_unblock_wk);
|
|
|
|
|
|
|
|
if (sta->dead)
|
|
|
|
return;
|
|
|
|
|
2012-01-17 08:22:49 +00:00
|
|
|
if (!test_sta_flag(sta, WLAN_STA_PS_STA)) {
|
|
|
|
local_bh_disable();
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
ieee80211_sta_ps_deliver_wakeup(sta);
|
2012-01-17 08:22:49 +00:00
|
|
|
local_bh_enable();
|
|
|
|
} else if (test_and_clear_sta_flag(sta, WLAN_STA_PSPOLL)) {
|
2011-09-29 14:04:36 +00:00
|
|
|
clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
|
2011-09-29 14:04:34 +00:00
|
|
|
|
|
|
|
local_bh_disable();
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
ieee80211_sta_ps_deliver_poll_response(sta);
|
2011-09-29 14:04:34 +00:00
|
|
|
local_bh_enable();
|
2011-09-29 14:04:36 +00:00
|
|
|
} else if (test_and_clear_sta_flag(sta, WLAN_STA_UAPSD)) {
|
|
|
|
clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
|
2011-09-29 14:04:34 +00:00
|
|
|
|
|
|
|
local_bh_disable();
|
2011-09-29 14:04:33 +00:00
|
|
|
ieee80211_sta_ps_deliver_uapsd(sta);
|
2011-09-29 14:04:34 +00:00
|
|
|
local_bh_enable();
|
2010-11-16 19:50:28 +00:00
|
|
|
} else
|
2011-09-29 14:04:36 +00:00
|
|
|
clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
}
|
|
|
|
|
2009-11-17 17:18:36 +00:00
|
|
|
static int sta_prepare_rate_control(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta, gfp_t gfp)
|
|
|
|
{
|
|
|
|
if (local->hw.flags & IEEE80211_HW_HAS_RATE_CONTROL)
|
|
|
|
return 0;
|
|
|
|
|
2012-01-17 09:33:29 +00:00
|
|
|
sta->rate_ctrl = local->rate_ctrl;
|
2009-11-17 17:18:36 +00:00
|
|
|
sta->rate_ctrl_priv = rate_control_alloc_sta(sta->rate_ctrl,
|
|
|
|
&sta->sta, gfp);
|
2012-01-17 09:33:29 +00:00
|
|
|
if (!sta->rate_ctrl_priv)
|
2009-11-17 17:18:36 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-02-25 15:27:47 +00:00
|
|
|
struct sta_info *sta_info_alloc(struct ieee80211_sub_if_data *sdata,
|
2011-12-14 12:28:46 +00:00
|
|
|
const u8 *addr, gfp_t gfp)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2008-02-25 15:27:46 +00:00
|
|
|
struct ieee80211_local *local = sdata->local;
|
2007-05-05 18:45:53 +00:00
|
|
|
struct sta_info *sta;
|
2011-04-08 15:54:24 +00:00
|
|
|
struct timespec uptime;
|
2007-12-25 15:00:34 +00:00
|
|
|
int i;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-09-10 22:02:02 +00:00
|
|
|
sta = kzalloc(sizeof(*sta) + local->hw.sta_data_size, gfp);
|
2007-05-05 18:45:53 +00:00
|
|
|
if (!sta)
|
2008-02-25 15:27:47 +00:00
|
|
|
return NULL;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-05-02 23:02:02 +00:00
|
|
|
spin_lock_init(&sta->lock);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
INIT_WORK(&sta->drv_unblock_wk, sta_unblock);
|
2010-06-10 08:21:43 +00:00
|
|
|
INIT_WORK(&sta->ampdu_mlme.work, ieee80211_ba_session_work);
|
2010-06-10 08:21:46 +00:00
|
|
|
mutex_init(&sta->ampdu_mlme.mtx);
|
2008-05-02 23:02:02 +00:00
|
|
|
|
2008-09-10 22:02:02 +00:00
|
|
|
memcpy(sta->sta.addr, addr, ETH_ALEN);
|
2008-02-25 15:27:46 +00:00
|
|
|
sta->local = local;
|
|
|
|
sta->sdata = sdata;
|
2011-03-21 19:01:00 +00:00
|
|
|
sta->last_rx = jiffies;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2012-01-20 12:55:20 +00:00
|
|
|
sta->sta_state = IEEE80211_STA_NONE;
|
|
|
|
|
2011-04-08 15:54:24 +00:00
|
|
|
do_posix_clock_monotonic_gettime(&uptime);
|
|
|
|
sta->last_connected = uptime.tv_sec;
|
2010-12-02 10:12:43 +00:00
|
|
|
ewma_init(&sta->avg_signal, 1024, 8);
|
|
|
|
|
2009-11-17 17:18:36 +00:00
|
|
|
if (sta_prepare_rate_control(local, sta, gfp)) {
|
2007-05-05 18:45:53 +00:00
|
|
|
kfree(sta);
|
2008-02-25 15:27:47 +00:00
|
|
|
return NULL;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2007-12-25 15:00:34 +00:00
|
|
|
for (i = 0; i < STA_TID_NUM; i++) {
|
2010-06-10 08:21:39 +00:00
|
|
|
/*
|
|
|
|
* timer_to_tid must be initialized with identity mapping
|
|
|
|
* to enable session_timer's data differentiation. See
|
|
|
|
* sta_rx_agg_session_timer_expired for usage.
|
|
|
|
*/
|
2007-12-25 15:00:34 +00:00
|
|
|
sta->timer_to_tid[i] = i;
|
|
|
|
}
|
2011-09-29 14:04:29 +00:00
|
|
|
for (i = 0; i < IEEE80211_NUM_ACS; i++) {
|
|
|
|
skb_queue_head_init(&sta->ps_tx_buf[i]);
|
|
|
|
skb_queue_head_init(&sta->tx_filtered[i]);
|
|
|
|
}
|
2008-02-25 15:27:47 +00:00
|
|
|
|
2009-05-14 13:12:08 +00:00
|
|
|
for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
|
2010-05-24 21:33:03 +00:00
|
|
|
sta->last_seq_ctrl[i] = cpu_to_le16(USHRT_MAX);
|
2009-05-14 13:12:08 +00:00
|
|
|
|
2008-02-25 15:27:47 +00:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
|
2010-08-20 23:25:38 +00:00
|
|
|
wiphy_debug(local->hw.wiphy, "Allocated STA %pM\n", sta->sta.addr);
|
2008-02-25 15:27:47 +00:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
|
|
|
|
|
2008-02-27 08:56:40 +00:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2011-05-13 17:45:43 +00:00
|
|
|
sta->plink_state = NL80211_PLINK_LISTEN;
|
2008-02-27 08:56:40 +00:00
|
|
|
init_timer(&sta->plink_timer);
|
|
|
|
#endif
|
|
|
|
|
2008-02-25 15:27:47 +00:00
|
|
|
return sta;
|
|
|
|
}
|
|
|
|
|
2011-08-17 12:18:14 +00:00
|
|
|
static int sta_info_insert_check(struct sta_info *sta)
|
2010-02-03 12:59:58 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
|
|
|
|
2008-02-27 08:56:40 +00:00
|
|
|
/*
|
|
|
|
* Can't be a WARN_ON because it can be triggered through a race:
|
|
|
|
* something inserts a STA (on one CPU) without holding the RTNL
|
|
|
|
* and another CPU turns off the net device.
|
|
|
|
*/
|
2011-08-17 12:18:14 +00:00
|
|
|
if (unlikely(!ieee80211_sdata_running(sdata)))
|
|
|
|
return -ENETDOWN;
|
2008-02-27 08:56:40 +00:00
|
|
|
|
2009-11-25 16:46:19 +00:00
|
|
|
if (WARN_ON(compare_ether_addr(sta->sta.addr, sdata->vif.addr) == 0 ||
|
2011-08-17 12:18:14 +00:00
|
|
|
is_multicast_ether_addr(sta->sta.addr)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* should be called with sta_mtx locked
|
|
|
|
* this function replaces the mutex lock
|
|
|
|
* with a RCU lock
|
|
|
|
*/
|
2011-12-15 10:24:20 +00:00
|
|
|
static int sta_info_insert_finish(struct sta_info *sta) __acquires(RCU)
|
2011-08-17 12:18:14 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2011-08-17 12:18:15 +00:00
|
|
|
struct sta_info *exist_sta;
|
|
|
|
bool dummy_reinsert = false;
|
2011-08-17 12:18:14 +00:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
lockdep_assert_held(&local->sta_mtx);
|
2010-02-03 12:59:58 +00:00
|
|
|
|
2011-08-17 12:18:15 +00:00
|
|
|
/*
|
|
|
|
* check if STA exists already.
|
2011-12-15 10:24:20 +00:00
|
|
|
* only accept a scenario of a second call to sta_info_insert_finish
|
2011-08-17 12:18:15 +00:00
|
|
|
* with a dummy station entry that was inserted earlier
|
|
|
|
* in that case - assume that the dummy station flag should
|
|
|
|
* be removed.
|
|
|
|
*/
|
|
|
|
exist_sta = sta_info_get_bss_rx(sdata, sta->sta.addr);
|
|
|
|
if (exist_sta) {
|
|
|
|
if (exist_sta == sta && sta->dummy) {
|
|
|
|
dummy_reinsert = true;
|
|
|
|
} else {
|
2011-12-15 10:24:20 +00:00
|
|
|
err = -EEXIST;
|
|
|
|
goto out_err;
|
2011-08-17 12:18:15 +00:00
|
|
|
}
|
2008-02-21 13:09:30 +00:00
|
|
|
}
|
2007-12-19 00:31:26 +00:00
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
if (!sta->dummy || dummy_reinsert) {
|
|
|
|
/* notify driver */
|
|
|
|
err = drv_sta_add(local, sdata, &sta->sta);
|
|
|
|
if (err) {
|
|
|
|
if (sdata->vif.type != NL80211_IFTYPE_ADHOC)
|
|
|
|
goto out_err;
|
|
|
|
printk(KERN_DEBUG "%s: failed to add IBSS STA %pM to "
|
|
|
|
"driver (%d) - keeping it anyway.\n",
|
|
|
|
sdata->name, sta->sta.addr, err);
|
|
|
|
} else
|
|
|
|
sta->uploaded = true;
|
|
|
|
}
|
2007-12-19 00:31:26 +00:00
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
if (!dummy_reinsert) {
|
|
|
|
local->num_sta++;
|
|
|
|
local->sta_generation++;
|
|
|
|
smp_mb();
|
|
|
|
|
|
|
|
/* make the station visible */
|
|
|
|
sta_info_hash_add(local, sta);
|
|
|
|
|
|
|
|
list_add(&sta->list, &local->sta_list);
|
2012-01-12 08:31:10 +00:00
|
|
|
|
|
|
|
set_sta_flag(sta, WLAN_STA_INSERTED);
|
2011-12-15 10:24:20 +00:00
|
|
|
} else {
|
|
|
|
sta->dummy = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!sta->dummy) {
|
|
|
|
struct station_info sinfo;
|
|
|
|
|
|
|
|
ieee80211_sta_debugfs_add(sta);
|
|
|
|
rate_control_add_sta_debugfs(sta);
|
|
|
|
|
|
|
|
memset(&sinfo, 0, sizeof(sinfo));
|
|
|
|
sinfo.filled = 0;
|
|
|
|
sinfo.generation = local->sta_generation;
|
|
|
|
cfg80211_new_sta(sdata->dev, sta->sta.addr, &sinfo, GFP_KERNEL);
|
2007-12-19 00:31:26 +00:00
|
|
|
}
|
2008-02-25 15:27:46 +00:00
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
|
2011-08-17 12:18:15 +00:00
|
|
|
wiphy_debug(local->hw.wiphy, "Inserted %sSTA %pM\n",
|
|
|
|
sta->dummy ? "dummy " : "", sta->sta.addr);
|
2007-05-05 18:45:53 +00:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
/* move reference to rcu-protected */
|
|
|
|
rcu_read_lock();
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
2007-05-05 18:46:38 +00:00
|
|
|
|
2008-02-25 15:27:47 +00:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
|
|
|
mesh_accept_plinks_update(sdata);
|
|
|
|
|
2011-08-17 12:18:14 +00:00
|
|
|
return 0;
|
2011-12-15 10:24:20 +00:00
|
|
|
out_err:
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
rcu_read_lock();
|
|
|
|
return err;
|
2011-08-17 12:18:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int sta_info_insert_rcu(struct sta_info *sta) __acquires(RCU)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
int err = 0;
|
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
might_sleep();
|
|
|
|
|
2011-08-17 12:18:14 +00:00
|
|
|
err = sta_info_insert_check(sta);
|
|
|
|
if (err) {
|
|
|
|
rcu_read_lock();
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(&local->sta_mtx);
|
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
err = sta_info_insert_finish(sta);
|
2011-08-17 12:18:14 +00:00
|
|
|
if (err)
|
|
|
|
goto out_free;
|
|
|
|
|
2008-02-25 15:27:47 +00:00
|
|
|
return 0;
|
2008-04-01 13:21:00 +00:00
|
|
|
out_free:
|
|
|
|
BUG_ON(!err);
|
2011-12-14 11:35:30 +00:00
|
|
|
sta_info_free(local, sta);
|
2008-04-01 13:21:00 +00:00
|
|
|
return err;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
int sta_info_insert(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
int err = sta_info_insert_rcu(sta);
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-08-17 12:18:15 +00:00
|
|
|
/* Caller must hold sta->local->sta_mtx */
|
|
|
|
int sta_info_reinsert(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
err = sta_info_insert_check(sta);
|
|
|
|
if (err) {
|
|
|
|
mutex_unlock(&local->sta_mtx);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
might_sleep();
|
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
err = sta_info_insert_finish(sta);
|
2011-08-17 12:18:15 +00:00
|
|
|
rcu_read_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-02-20 10:21:35 +00:00
|
|
|
static inline void __bss_tim_set(struct ieee80211_if_ap *bss, u16 aid)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This format has been mandated by the IEEE specifications,
|
|
|
|
* so this line may not be changed to use the __set_bit() format.
|
|
|
|
*/
|
|
|
|
bss->tim[aid / 8] |= (1 << (aid % 8));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void __bss_tim_clear(struct ieee80211_if_ap *bss, u16 aid)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This format has been mandated by the IEEE specifications,
|
|
|
|
* so this line may not be changed to use the __clear_bit() format.
|
|
|
|
*/
|
|
|
|
bss->tim[aid / 8] &= ~(1 << (aid % 8));
|
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
static unsigned long ieee80211_tids_for_ac(int ac)
|
2008-02-20 10:21:35 +00:00
|
|
|
{
|
2011-09-29 14:04:29 +00:00
|
|
|
/* If we ever support TIDs > 7, this obviously needs to be adjusted */
|
|
|
|
switch (ac) {
|
|
|
|
case IEEE80211_AC_VO:
|
|
|
|
return BIT(6) | BIT(7);
|
|
|
|
case IEEE80211_AC_VI:
|
|
|
|
return BIT(4) | BIT(5);
|
|
|
|
case IEEE80211_AC_BE:
|
|
|
|
return BIT(0) | BIT(3);
|
|
|
|
case IEEE80211_AC_BK:
|
|
|
|
return BIT(1) | BIT(2);
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
return 0;
|
2008-02-25 15:27:46 +00:00
|
|
|
}
|
2008-02-20 10:21:35 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
void sta_info_recalc_tim(struct sta_info *sta)
|
2008-02-20 10:21:35 +00:00
|
|
|
{
|
2011-09-29 14:04:27 +00:00
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
struct ieee80211_if_ap *bss = sta->sdata->bss;
|
2008-02-25 15:27:46 +00:00
|
|
|
unsigned long flags;
|
2011-09-29 14:04:29 +00:00
|
|
|
bool indicate_tim = false;
|
|
|
|
u8 ignore_for_tim = sta->sta.uapsd_queues;
|
|
|
|
int ac;
|
2008-02-20 10:21:35 +00:00
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
if (WARN_ON_ONCE(!sta->sdata->bss))
|
|
|
|
return;
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
/* No need to do anything if the driver does all */
|
|
|
|
if (local->hw.flags & IEEE80211_HW_AP_LINK_PS)
|
|
|
|
return;
|
2008-02-20 10:21:35 +00:00
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
if (sta->dead)
|
|
|
|
goto done;
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
/*
|
|
|
|
* If all ACs are delivery-enabled then we should build
|
|
|
|
* the TIM bit for all ACs anyway; if only some are then
|
|
|
|
* we ignore those and build the TIM bit using only the
|
|
|
|
* non-enabled ones.
|
|
|
|
*/
|
|
|
|
if (ignore_for_tim == BIT(IEEE80211_NUM_ACS) - 1)
|
|
|
|
ignore_for_tim = 0;
|
|
|
|
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
unsigned long tids;
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
if (ignore_for_tim & BIT(ac))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
indicate_tim |= !skb_queue_empty(&sta->tx_filtered[ac]) ||
|
|
|
|
!skb_queue_empty(&sta->ps_tx_buf[ac]);
|
|
|
|
if (indicate_tim)
|
|
|
|
break;
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
tids = ieee80211_tids_for_ac(ac);
|
|
|
|
|
|
|
|
indicate_tim |=
|
|
|
|
sta->driver_buffered_tids & tids;
|
2008-02-25 15:27:46 +00:00
|
|
|
}
|
2008-02-20 10:21:35 +00:00
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
done:
|
2011-12-15 10:24:20 +00:00
|
|
|
spin_lock_irqsave(&local->tim_lock, flags);
|
2008-02-20 10:21:35 +00:00
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
if (indicate_tim)
|
2011-09-29 14:04:27 +00:00
|
|
|
__bss_tim_set(bss, sta->sta.aid);
|
|
|
|
else
|
|
|
|
__bss_tim_clear(bss, sta->sta.aid);
|
2008-02-20 10:21:35 +00:00
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
if (local->ops->set_tim) {
|
|
|
|
local->tim_in_locked_section = true;
|
2011-09-29 14:04:29 +00:00
|
|
|
drv_set_tim(local, &sta->sta, indicate_tim);
|
2011-09-29 14:04:27 +00:00
|
|
|
local->tim_in_locked_section = false;
|
|
|
|
}
|
mac80211: make master netdev handling sane
Currently, almost every interface type has a 'bss' pointer
pointing to BSS information. This BSS information, however,
is for a _local_ BSS, not for the BSS we joined, so having
it on a STA mode interface makes little sense, but now they
have it pointing to the master device, which is an AP mode
virtual interface. However, except for some bitrate control
data, this pointer is only used in AP/VLAN modes (for power
saving stations.)
Overall, it is not necessary to even have the master netdev
be a valid virtual interface, and it doesn't have to be on
the list of interfaces either.
This patch changes the master netdev to be special, it now
- no longer is on the list of virtual interfaces, which
lets me remove a lot of tests for that
- no longer has sub_if_data attached, since that isn't used
Additionally, this patch changes some vlan/ap mode handling
that is related to these 'bss' pointers described above (but
in the VLAN case they actually make sense because there they
point to the AP they belong to); it also adds some debugging
code to IEEE80211_DEV_TO_SUB_IF to validate it is not called
on the master netdev any more.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-07-09 12:40:34 +00:00
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
spin_unlock_irqrestore(&local->tim_lock, flags);
|
2008-02-20 10:21:35 +00:00
|
|
|
}
|
|
|
|
|
2011-09-06 12:13:06 +00:00
|
|
|
static bool sta_info_buffer_expired(struct sta_info *sta, struct sk_buff *skb)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2008-05-15 10:55:29 +00:00
|
|
|
struct ieee80211_tx_info *info;
|
2007-05-05 18:45:53 +00:00
|
|
|
int timeout;
|
|
|
|
|
|
|
|
if (!skb)
|
2011-09-06 12:13:06 +00:00
|
|
|
return false;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
info = IEEE80211_SKB_CB(skb);
|
2007-05-05 18:45:53 +00:00
|
|
|
|
|
|
|
/* Timeout: (2 * listen_interval * beacon_int * 1024 / 1000000) sec */
|
2009-04-23 14:10:04 +00:00
|
|
|
timeout = (sta->listen_interval *
|
|
|
|
sta->sdata->vif.bss_conf.beacon_int *
|
|
|
|
32 / 15625) * HZ;
|
2007-05-05 18:45:53 +00:00
|
|
|
if (timeout < STA_TX_BUFFER_EXPIRE)
|
|
|
|
timeout = STA_TX_BUFFER_EXPIRE;
|
2008-05-15 10:55:29 +00:00
|
|
|
return time_after(jiffies, info->control.jiffies + timeout);
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
static bool sta_info_cleanup_expire_buffered_ac(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta, int ac)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
2011-09-29 14:04:28 +00:00
|
|
|
/*
|
|
|
|
* First check for frames that should expire on the filtered
|
|
|
|
* queue. Frames here were rejected by the driver and are on
|
|
|
|
* a separate queue to avoid reordering with normal PS-buffered
|
|
|
|
* frames. They also aren't accounted for right now in the
|
|
|
|
* total_ps_buffered counter.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
2011-09-29 14:04:29 +00:00
|
|
|
spin_lock_irqsave(&sta->tx_filtered[ac].lock, flags);
|
|
|
|
skb = skb_peek(&sta->tx_filtered[ac]);
|
2011-09-29 14:04:28 +00:00
|
|
|
if (sta_info_buffer_expired(sta, skb))
|
2011-09-29 14:04:29 +00:00
|
|
|
skb = __skb_dequeue(&sta->tx_filtered[ac]);
|
2011-09-29 14:04:28 +00:00
|
|
|
else
|
|
|
|
skb = NULL;
|
2011-09-29 14:04:29 +00:00
|
|
|
spin_unlock_irqrestore(&sta->tx_filtered[ac].lock, flags);
|
2011-09-29 14:04:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Frames are queued in order, so if this one
|
|
|
|
* hasn't expired yet we can stop testing. If
|
|
|
|
* we actually reached the end of the queue we
|
|
|
|
* also need to stop, of course.
|
|
|
|
*/
|
|
|
|
if (!skb)
|
|
|
|
break;
|
|
|
|
dev_kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now also check the normal PS-buffered queue, this will
|
|
|
|
* only find something if the filtered queue was emptied
|
|
|
|
* since the filtered frames are all before the normal PS
|
|
|
|
* buffered frames.
|
|
|
|
*/
|
2007-05-05 18:45:53 +00:00
|
|
|
for (;;) {
|
2011-09-29 14:04:29 +00:00
|
|
|
spin_lock_irqsave(&sta->ps_tx_buf[ac].lock, flags);
|
|
|
|
skb = skb_peek(&sta->ps_tx_buf[ac]);
|
2009-04-23 14:10:04 +00:00
|
|
|
if (sta_info_buffer_expired(sta, skb))
|
2011-09-29 14:04:29 +00:00
|
|
|
skb = __skb_dequeue(&sta->ps_tx_buf[ac]);
|
2008-02-20 01:07:21 +00:00
|
|
|
else
|
2007-05-05 18:45:53 +00:00
|
|
|
skb = NULL;
|
2011-09-29 14:04:29 +00:00
|
|
|
spin_unlock_irqrestore(&sta->ps_tx_buf[ac].lock, flags);
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2011-09-29 14:04:28 +00:00
|
|
|
/*
|
|
|
|
* frames are queued in order, so if this one
|
|
|
|
* hasn't expired yet (or we reached the end of
|
|
|
|
* the queue) we can stop testing
|
|
|
|
*/
|
2008-02-20 01:07:21 +00:00
|
|
|
if (!skb)
|
2007-05-05 18:45:53 +00:00
|
|
|
break;
|
2008-02-20 01:07:21 +00:00
|
|
|
|
|
|
|
local->total_ps_buffered--;
|
2008-06-30 13:10:46 +00:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
|
2008-10-27 22:56:10 +00:00
|
|
|
printk(KERN_DEBUG "Buffered frame expired (STA %pM)\n",
|
|
|
|
sta->sta.addr);
|
2008-06-30 13:10:46 +00:00
|
|
|
#endif
|
2008-02-20 01:07:21 +00:00
|
|
|
dev_kfree_skb(skb);
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
2010-04-19 07:12:52 +00:00
|
|
|
|
2011-09-29 14:04:28 +00:00
|
|
|
/*
|
|
|
|
* Finally, recalculate the TIM bit for this station -- it might
|
|
|
|
* now be clear because the station was too slow to retrieve its
|
|
|
|
* frames.
|
|
|
|
*/
|
|
|
|
sta_info_recalc_tim(sta);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return whether there are any frames still buffered, this is
|
|
|
|
* used to check whether the cleanup timer still needs to run,
|
|
|
|
* if there are no frames we don't need to rearm the timer.
|
|
|
|
*/
|
2011-09-29 14:04:29 +00:00
|
|
|
return !(skb_queue_empty(&sta->ps_tx_buf[ac]) &&
|
|
|
|
skb_queue_empty(&sta->tx_filtered[ac]));
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool sta_info_cleanup_expire_buffered(struct ieee80211_local *local,
|
|
|
|
struct sta_info *sta)
|
|
|
|
{
|
|
|
|
bool have_buffered = false;
|
|
|
|
int ac;
|
|
|
|
|
|
|
|
/* This is only necessary for stations on BSS interfaces */
|
|
|
|
if (!sta->sdata->bss)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
|
|
|
|
have_buffered |=
|
|
|
|
sta_info_cleanup_expire_buffered_ac(local, sta, ac);
|
|
|
|
|
|
|
|
return have_buffered;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
2012-01-12 08:31:10 +00:00
|
|
|
int __must_check __sta_info_destroy(struct sta_info *sta)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
2010-02-03 12:59:58 +00:00
|
|
|
struct ieee80211_local *local;
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2011-09-29 14:04:29 +00:00
|
|
|
int ret, i, ac;
|
2011-12-08 09:26:15 +00:00
|
|
|
struct tid_ampdu_tx *tid_tx;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
might_sleep();
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
if (!sta)
|
|
|
|
return -ENOENT;
|
2009-05-17 09:40:42 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
local = sta->local;
|
|
|
|
sdata = sta->sdata;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2012-01-12 08:31:10 +00:00
|
|
|
lockdep_assert_held(&local->sta_mtx);
|
|
|
|
|
2010-04-06 09:18:47 +00:00
|
|
|
/*
|
|
|
|
* Before removing the station from the driver and
|
|
|
|
* rate control, it might still start new aggregation
|
|
|
|
* sessions -- block that to make sure the tear-down
|
|
|
|
* will be sufficient.
|
|
|
|
*/
|
2011-09-29 14:04:36 +00:00
|
|
|
set_sta_flag(sta, WLAN_STA_BLOCK_BA);
|
2010-10-05 17:37:40 +00:00
|
|
|
ieee80211_sta_tear_down_BA_sessions(sta, true);
|
2010-04-06 09:18:47 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
ret = sta_info_hash_del(local, sta);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2011-12-15 10:24:20 +00:00
|
|
|
list_del(&sta->list);
|
|
|
|
|
2011-05-12 13:07:15 +00:00
|
|
|
mutex_lock(&local->key_mtx);
|
2010-10-05 17:39:30 +00:00
|
|
|
for (i = 0; i < NUM_DEFAULT_KEYS; i++)
|
2011-05-13 12:15:49 +00:00
|
|
|
__ieee80211_key_free(key_mtx_dereference(local, sta->gtk[i]));
|
2010-10-05 17:39:30 +00:00
|
|
|
if (sta->ptk)
|
2011-05-13 12:15:49 +00:00
|
|
|
__ieee80211_key_free(key_mtx_dereference(local, sta->ptk));
|
2011-05-12 13:07:15 +00:00
|
|
|
mutex_unlock(&local->key_mtx);
|
2010-02-03 12:59:58 +00:00
|
|
|
|
|
|
|
sta->dead = true;
|
|
|
|
|
|
|
|
local->num_sta--;
|
|
|
|
local->sta_generation++;
|
|
|
|
|
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
|
2011-08-01 16:19:00 +00:00
|
|
|
RCU_INIT_POINTER(sdata->u.vlan.sta, NULL);
|
2010-02-03 12:59:58 +00:00
|
|
|
|
2012-01-12 08:31:10 +00:00
|
|
|
while (sta->sta_state > IEEE80211_STA_NONE) {
|
|
|
|
int err = sta_info_move_state(sta, sta->sta_state - 1);
|
|
|
|
if (err) {
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-12-14 11:35:30 +00:00
|
|
|
|
2012-01-20 12:55:18 +00:00
|
|
|
if (sta->uploaded)
|
2010-02-03 12:59:58 +00:00
|
|
|
drv_sta_remove(local, sdata, &sta->sta);
|
|
|
|
|
2010-04-06 09:18:43 +00:00
|
|
|
/*
|
|
|
|
* At this point, after we wait for an RCU grace period,
|
|
|
|
* neither mac80211 nor the driver can reference this
|
|
|
|
* sta struct any more except by still existing timers
|
|
|
|
* associated with this station that we clean up below.
|
|
|
|
*/
|
|
|
|
synchronize_rcu();
|
|
|
|
|
2012-01-27 10:02:53 +00:00
|
|
|
if (test_sta_flag(sta, WLAN_STA_PS_STA)) {
|
|
|
|
BUG_ON(!sdata->bss);
|
|
|
|
|
|
|
|
clear_sta_flag(sta, WLAN_STA_PS_STA);
|
|
|
|
|
|
|
|
atomic_dec(&sdata->bss->num_sta_ps);
|
|
|
|
sta_info_recalc_tim(sta);
|
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
local->total_ps_buffered -= skb_queue_len(&sta->ps_tx_buf[ac]);
|
|
|
|
__skb_queue_purge(&sta->ps_tx_buf[ac]);
|
|
|
|
__skb_queue_purge(&sta->tx_filtered[ac]);
|
|
|
|
}
|
2011-09-29 14:04:27 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
2010-04-06 09:18:43 +00:00
|
|
|
if (ieee80211_vif_is_mesh(&sdata->vif))
|
2010-02-03 12:59:58 +00:00
|
|
|
mesh_accept_plinks_update(sdata);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_DEBUG
|
2010-08-20 23:25:38 +00:00
|
|
|
wiphy_debug(local->hw.wiphy, "Removed STA %pM\n", sta->sta.addr);
|
2010-02-03 12:59:58 +00:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
|
|
|
|
cancel_work_sync(&sta->drv_unblock_wk);
|
|
|
|
|
2011-03-23 13:29:52 +00:00
|
|
|
cfg80211_del_sta(sdata->dev, sta->sta.addr, GFP_KERNEL);
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
rate_control_remove_sta_debugfs(sta);
|
|
|
|
ieee80211_sta_debugfs_remove(sta);
|
|
|
|
|
|
|
|
#ifdef CONFIG_MAC80211_MESH
|
|
|
|
if (ieee80211_vif_is_mesh(&sta->sdata->vif)) {
|
|
|
|
mesh_plink_deactivate(sta);
|
|
|
|
del_timer_sync(&sta->plink_timer);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-01-17 09:30:01 +00:00
|
|
|
/*
|
|
|
|
* Destroy aggregation state here. It would be nice to wait for the
|
|
|
|
* driver to finish aggregation stop and then clean up, but for now
|
|
|
|
* drivers have to handle aggregation stop being requested, followed
|
|
|
|
* directly by station destruction.
|
2011-12-08 09:26:15 +00:00
|
|
|
*/
|
|
|
|
for (i = 0; i < STA_TID_NUM; i++) {
|
2012-01-17 09:30:01 +00:00
|
|
|
tid_tx = rcu_dereference_raw(sta->ampdu_mlme.tid_tx[i]);
|
2011-12-16 06:17:15 +00:00
|
|
|
if (!tid_tx)
|
2011-12-08 09:26:15 +00:00
|
|
|
continue;
|
2012-01-17 09:30:01 +00:00
|
|
|
__skb_queue_purge(&tid_tx->pending);
|
|
|
|
kfree(tid_tx);
|
2011-12-08 09:26:15 +00:00
|
|
|
}
|
|
|
|
|
2011-12-14 11:35:30 +00:00
|
|
|
sta_info_free(local, sta);
|
2010-02-03 12:59:58 +00:00
|
|
|
|
|
|
|
return 0;
|
2008-04-07 19:53:49 +00:00
|
|
|
}
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
int sta_info_destroy_addr(struct ieee80211_sub_if_data *sdata, const u8 *addr)
|
2008-04-07 19:53:49 +00:00
|
|
|
{
|
2010-02-03 12:59:58 +00:00
|
|
|
struct sta_info *sta;
|
|
|
|
int ret;
|
2008-04-07 19:53:49 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_lock(&sdata->local->sta_mtx);
|
2011-08-17 12:18:15 +00:00
|
|
|
sta = sta_info_get_rx(sdata, addr);
|
2010-02-03 12:59:58 +00:00
|
|
|
ret = __sta_info_destroy(sta);
|
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
2008-04-07 19:53:49 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
int sta_info_destroy_addr_bss(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const u8 *addr)
|
2007-05-05 18:46:38 +00:00
|
|
|
{
|
2010-02-03 12:59:58 +00:00
|
|
|
struct sta_info *sta;
|
|
|
|
int ret;
|
2007-05-05 18:46:38 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_lock(&sdata->local->sta_mtx);
|
2011-08-17 12:18:15 +00:00
|
|
|
sta = sta_info_get_bss_rx(sdata, addr);
|
2010-02-03 12:59:58 +00:00
|
|
|
ret = __sta_info_destroy(sta);
|
|
|
|
mutex_unlock(&sdata->local->sta_mtx);
|
2008-02-25 15:27:46 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2007-05-05 18:46:38 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
static void sta_info_cleanup(unsigned long data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = (struct ieee80211_local *) data;
|
|
|
|
struct sta_info *sta;
|
2010-04-19 07:12:52 +00:00
|
|
|
bool timer_needed = false;
|
2010-02-03 12:59:58 +00:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
list_for_each_entry_rcu(sta, &local->sta_list, list)
|
2010-04-19 07:12:52 +00:00
|
|
|
if (sta_info_cleanup_expire_buffered(local, sta))
|
|
|
|
timer_needed = true;
|
2010-02-03 12:59:58 +00:00
|
|
|
rcu_read_unlock();
|
2007-05-05 18:46:38 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
if (local->quiescing)
|
|
|
|
return;
|
2008-02-25 15:27:46 +00:00
|
|
|
|
2010-04-19 07:12:52 +00:00
|
|
|
if (!timer_needed)
|
|
|
|
return;
|
|
|
|
|
2011-04-01 11:52:48 +00:00
|
|
|
mod_timer(&local->sta_cleanup,
|
|
|
|
round_jiffies(jiffies + STA_INFO_CLEANUP_INTERVAL));
|
2007-05-05 18:46:38 +00:00
|
|
|
}
|
|
|
|
|
2007-05-05 18:45:53 +00:00
|
|
|
void sta_info_init(struct ieee80211_local *local)
|
|
|
|
{
|
2011-12-15 10:24:20 +00:00
|
|
|
spin_lock_init(&local->tim_lock);
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_init(&local->sta_mtx);
|
2007-05-05 18:45:53 +00:00
|
|
|
INIT_LIST_HEAD(&local->sta_list);
|
|
|
|
|
2008-01-24 05:20:07 +00:00
|
|
|
setup_timer(&local->sta_cleanup, sta_info_cleanup,
|
|
|
|
(unsigned long)local);
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void sta_info_stop(struct ieee80211_local *local)
|
|
|
|
{
|
|
|
|
del_timer(&local->sta_cleanup);
|
2007-07-27 13:43:23 +00:00
|
|
|
sta_info_flush(local, NULL);
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sta_info_flush - flush matching STA entries from the STA table
|
2008-02-25 15:27:49 +00:00
|
|
|
*
|
|
|
|
* Returns the number of removed STA entries.
|
|
|
|
*
|
2007-05-05 18:45:53 +00:00
|
|
|
* @local: local interface data
|
2008-02-25 15:27:46 +00:00
|
|
|
* @sdata: matching rule for the net device (sta->dev) or %NULL to match all STAs
|
2007-05-05 18:45:53 +00:00
|
|
|
*/
|
2008-02-25 15:27:49 +00:00
|
|
|
int sta_info_flush(struct ieee80211_local *local,
|
2009-04-19 19:25:43 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata)
|
2007-05-05 18:45:53 +00:00
|
|
|
{
|
|
|
|
struct sta_info *sta, *tmp;
|
2008-02-25 15:27:49 +00:00
|
|
|
int ret = 0;
|
2007-05-05 18:45:53 +00:00
|
|
|
|
2008-02-25 15:27:46 +00:00
|
|
|
might_sleep();
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_lock(&local->sta_mtx);
|
2008-02-25 15:27:46 +00:00
|
|
|
list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
|
2010-02-03 12:59:58 +00:00
|
|
|
if (!sdata || sdata == sta->sdata)
|
|
|
|
WARN_ON(__sta_info_destroy(sta));
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2008-02-25 15:27:49 +00:00
|
|
|
|
|
|
|
return ret;
|
2007-05-05 18:45:53 +00:00
|
|
|
}
|
2008-03-31 17:23:03 +00:00
|
|
|
|
2008-09-10 22:01:46 +00:00
|
|
|
void ieee80211_sta_expire(struct ieee80211_sub_if_data *sdata,
|
|
|
|
unsigned long exp_time)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sta_info *sta, *tmp;
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_lock(&local->sta_mtx);
|
2011-12-26 05:13:29 +00:00
|
|
|
|
|
|
|
list_for_each_entry_safe(sta, tmp, &local->sta_list, list) {
|
2011-12-20 15:16:52 +00:00
|
|
|
if (sdata != sta->sdata)
|
|
|
|
continue;
|
|
|
|
|
2008-09-10 22:01:46 +00:00
|
|
|
if (time_after(jiffies, sta->last_rx + exp_time)) {
|
|
|
|
#ifdef CONFIG_MAC80211_IBSS_DEBUG
|
2008-10-27 22:56:10 +00:00
|
|
|
printk(KERN_DEBUG "%s: expiring inactive STA %pM\n",
|
2009-11-25 16:46:19 +00:00
|
|
|
sdata->name, sta->sta.addr);
|
2008-09-10 22:01:46 +00:00
|
|
|
#endif
|
2010-02-03 12:59:58 +00:00
|
|
|
WARN_ON(__sta_info_destroy(sta));
|
2008-09-10 22:01:46 +00:00
|
|
|
}
|
2011-12-26 05:13:29 +00:00
|
|
|
}
|
|
|
|
|
2010-02-03 12:59:58 +00:00
|
|
|
mutex_unlock(&local->sta_mtx);
|
2008-09-10 22:01:46 +00:00
|
|
|
}
|
2008-09-10 22:02:02 +00:00
|
|
|
|
2010-09-23 16:44:36 +00:00
|
|
|
struct ieee80211_sta *ieee80211_find_sta_by_ifaddr(struct ieee80211_hw *hw,
|
|
|
|
const u8 *addr,
|
|
|
|
const u8 *localaddr)
|
2008-09-10 22:02:02 +00:00
|
|
|
{
|
2009-11-25 16:46:18 +00:00
|
|
|
struct sta_info *sta, *nxt;
|
2008-09-10 22:02:02 +00:00
|
|
|
|
2010-09-23 16:44:36 +00:00
|
|
|
/*
|
|
|
|
* Just return a random station if localaddr is NULL
|
|
|
|
* ... first in list.
|
|
|
|
*/
|
2010-04-30 11:48:36 +00:00
|
|
|
for_each_sta_info(hw_to_local(hw), addr, sta, nxt) {
|
2010-09-23 16:44:36 +00:00
|
|
|
if (localaddr &&
|
|
|
|
compare_ether_addr(sta->sdata->vif.addr, localaddr) != 0)
|
|
|
|
continue;
|
2010-04-30 11:48:36 +00:00
|
|
|
if (!sta->uploaded)
|
|
|
|
return NULL;
|
2009-11-25 16:46:18 +00:00
|
|
|
return &sta->sta;
|
2010-04-30 11:48:36 +00:00
|
|
|
}
|
|
|
|
|
2009-11-25 16:46:18 +00:00
|
|
|
return NULL;
|
2008-09-10 22:02:02 +00:00
|
|
|
}
|
2010-09-23 16:44:36 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_find_sta_by_ifaddr);
|
2009-11-04 13:42:28 +00:00
|
|
|
|
|
|
|
struct ieee80211_sta *ieee80211_find_sta(struct ieee80211_vif *vif,
|
|
|
|
const u8 *addr)
|
|
|
|
{
|
2010-04-30 11:48:36 +00:00
|
|
|
struct sta_info *sta;
|
2009-11-04 13:42:28 +00:00
|
|
|
|
|
|
|
if (!vif)
|
|
|
|
return NULL;
|
|
|
|
|
2010-04-30 11:48:36 +00:00
|
|
|
sta = sta_info_get_bss(vif_to_sdata(vif), addr);
|
|
|
|
if (!sta)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!sta->uploaded)
|
|
|
|
return NULL;
|
2009-11-04 13:42:28 +00:00
|
|
|
|
2010-04-30 11:48:36 +00:00
|
|
|
return &sta->sta;
|
2009-11-04 13:42:28 +00:00
|
|
|
}
|
2008-09-10 22:02:02 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_find_sta);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2010-11-16 19:50:28 +00:00
|
|
|
static void clear_sta_ps_flags(void *_sta)
|
|
|
|
{
|
|
|
|
struct sta_info *sta = _sta;
|
2012-01-30 14:18:00 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
2010-11-16 19:50:28 +00:00
|
|
|
|
2011-09-29 14:04:36 +00:00
|
|
|
clear_sta_flag(sta, WLAN_STA_PS_DRIVER);
|
2012-01-30 14:18:00 +00:00
|
|
|
if (test_and_clear_sta_flag(sta, WLAN_STA_PS_STA))
|
|
|
|
atomic_dec(&sdata->bss->num_sta_ps);
|
2010-11-16 19:50:28 +00:00
|
|
|
}
|
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
/* powersave support code */
|
|
|
|
void ieee80211_sta_ps_deliver_wakeup(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2011-09-29 14:04:29 +00:00
|
|
|
struct sk_buff_head pending;
|
|
|
|
int filtered = 0, buffered = 0, ac;
|
|
|
|
|
2011-09-29 14:04:36 +00:00
|
|
|
clear_sta_flag(sta, WLAN_STA_SP);
|
2011-09-29 14:04:33 +00:00
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
BUILD_BUG_ON(BITS_TO_LONGS(STA_TID_NUM) > 1);
|
|
|
|
sta->driver_buffered_tids = 0;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-01-31 20:29:13 +00:00
|
|
|
if (!(local->hw.flags & IEEE80211_HW_AP_LINK_PS))
|
|
|
|
drv_sta_notify(local, sdata, STA_NOTIFY_AWAKE, &sta->sta);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
skb_queue_head_init(&pending);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
|
|
|
/* Send all buffered frames to the station */
|
2011-09-29 14:04:29 +00:00
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
|
|
|
int count = skb_queue_len(&pending), tmp;
|
|
|
|
|
|
|
|
skb_queue_splice_tail_init(&sta->tx_filtered[ac], &pending);
|
|
|
|
tmp = skb_queue_len(&pending);
|
|
|
|
filtered += tmp - count;
|
|
|
|
count = tmp;
|
|
|
|
|
|
|
|
skb_queue_splice_tail_init(&sta->ps_tx_buf[ac], &pending);
|
|
|
|
tmp = skb_queue_len(&pending);
|
|
|
|
buffered += tmp - count;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_add_pending_skbs_fn(local, &pending, clear_sta_ps_flags, sta);
|
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
local->total_ps_buffered -= buffered;
|
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
sta_info_recalc_tim(sta);
|
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
#ifdef CONFIG_MAC80211_VERBOSE_PS_DEBUG
|
|
|
|
printk(KERN_DEBUG "%s: STA %pM aid %d sending %d filtered/%d PS frames "
|
2009-11-25 16:46:19 +00:00
|
|
|
"since STA not sleeping anymore\n", sdata->name,
|
2011-09-29 14:04:29 +00:00
|
|
|
sta->sta.addr, sta->sta.aid, filtered, buffered);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
#endif /* CONFIG_MAC80211_VERBOSE_PS_DEBUG */
|
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:34 +00:00
|
|
|
static void ieee80211_send_null_response(struct ieee80211_sub_if_data *sdata,
|
|
|
|
struct sta_info *sta, int tid,
|
2011-09-29 14:04:38 +00:00
|
|
|
enum ieee80211_frame_release_type reason)
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2011-09-29 14:04:34 +00:00
|
|
|
struct ieee80211_qos_hdr *nullfunc;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
struct sk_buff *skb;
|
2011-09-29 14:04:34 +00:00
|
|
|
int size = sizeof(*nullfunc);
|
|
|
|
__le16 fc;
|
2011-09-29 14:04:36 +00:00
|
|
|
bool qos = test_sta_flag(sta, WLAN_STA_WME);
|
2011-09-29 14:04:34 +00:00
|
|
|
struct ieee80211_tx_info *info;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:34 +00: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);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:34 +00:00
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + size);
|
|
|
|
if (!skb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2011-10-13 11:19:19 +00:00
|
|
|
skb->priority = tid;
|
|
|
|
skb_set_queue_mapping(skb, ieee802_1d_to_ac[tid]);
|
2011-09-29 14:04:34 +00:00
|
|
|
if (qos) {
|
|
|
|
nullfunc->qos_ctrl = cpu_to_le16(tid);
|
|
|
|
|
2011-09-29 14:04:38 +00:00
|
|
|
if (reason == IEEE80211_FRAME_RELEASE_UAPSD)
|
2011-09-29 14:04:34 +00:00
|
|
|
nullfunc->qos_ctrl |=
|
|
|
|
cpu_to_le16(IEEE80211_QOS_CTL_EOSP);
|
|
|
|
}
|
|
|
|
|
|
|
|
info = IEEE80211_SKB_CB(skb);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Tell TX path to send this frame even though the
|
|
|
|
* STA may still remain is PS mode after this frame
|
2011-09-29 14:04:35 +00:00
|
|
|
* exchange. Also set EOSP to indicate this packet
|
|
|
|
* ends the poll/service period.
|
2011-09-29 14:04:34 +00:00
|
|
|
*/
|
2011-09-29 14:04:35 +00:00
|
|
|
info->flags |= IEEE80211_TX_CTL_POLL_RESPONSE |
|
|
|
|
IEEE80211_TX_STATUS_EOSP |
|
|
|
|
IEEE80211_TX_CTL_REQ_TX_STATUS;
|
2011-09-29 14:04:34 +00:00
|
|
|
|
2011-09-29 14:04:38 +00:00
|
|
|
drv_allow_buffered_frames(local, sta, BIT(tid), 1, reason, false);
|
|
|
|
|
2011-09-29 14:04:34 +00:00
|
|
|
ieee80211_xmit(sdata, skb);
|
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
static void
|
|
|
|
ieee80211_sta_ps_deliver_response(struct sta_info *sta,
|
|
|
|
int n_frames, u8 ignored_acs,
|
|
|
|
enum ieee80211_frame_release_type reason)
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_sub_if_data *sdata = sta->sdata;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
2011-09-29 14:04:32 +00:00
|
|
|
bool found = false;
|
2011-09-29 14:04:29 +00:00
|
|
|
bool more_data = false;
|
|
|
|
int ac;
|
2011-09-29 14:04:32 +00:00
|
|
|
unsigned long driver_release_tids = 0;
|
2011-09-29 14:04:33 +00:00
|
|
|
struct sk_buff_head frames;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:35 +00:00
|
|
|
/* Service or PS-Poll period starts */
|
2011-09-29 14:04:36 +00:00
|
|
|
set_sta_flag(sta, WLAN_STA_SP);
|
2011-09-29 14:04:35 +00:00
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
__skb_queue_head_init(&frames);
|
2011-09-29 14:04:29 +00:00
|
|
|
|
|
|
|
/*
|
2011-09-29 14:04:33 +00:00
|
|
|
* Get response frame(s) and more data bit for it.
|
2011-09-29 14:04:29 +00:00
|
|
|
*/
|
|
|
|
for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
|
2011-09-29 14:04:32 +00:00
|
|
|
unsigned long tids;
|
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
if (ignored_acs & BIT(ac))
|
2011-09-29 14:04:29 +00:00
|
|
|
continue;
|
|
|
|
|
2011-09-29 14:04:32 +00:00
|
|
|
tids = ieee80211_tids_for_ac(ac);
|
|
|
|
|
|
|
|
if (!found) {
|
|
|
|
driver_release_tids = sta->driver_buffered_tids & tids;
|
|
|
|
if (driver_release_tids) {
|
|
|
|
found = true;
|
|
|
|
} else {
|
2011-09-29 14:04:33 +00:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
while (n_frames > 0) {
|
|
|
|
skb = skb_dequeue(&sta->tx_filtered[ac]);
|
|
|
|
if (!skb) {
|
|
|
|
skb = skb_dequeue(
|
|
|
|
&sta->ps_tx_buf[ac]);
|
|
|
|
if (skb)
|
|
|
|
local->total_ps_buffered--;
|
|
|
|
}
|
|
|
|
if (!skb)
|
|
|
|
break;
|
|
|
|
n_frames--;
|
2011-09-29 14:04:32 +00:00
|
|
|
found = true;
|
2011-09-29 14:04:33 +00:00
|
|
|
__skb_queue_tail(&frames, skb);
|
|
|
|
}
|
2011-09-29 14:04:29 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:32 +00:00
|
|
|
/*
|
|
|
|
* If the driver has data on more than one TID then
|
|
|
|
* certainly there's more data if we release just a
|
|
|
|
* single frame now (from a single TID).
|
|
|
|
*/
|
2011-09-29 14:04:33 +00:00
|
|
|
if (reason == IEEE80211_FRAME_RELEASE_PSPOLL &&
|
|
|
|
hweight16(driver_release_tids) > 1) {
|
2011-09-29 14:04:32 +00:00
|
|
|
more_data = true;
|
|
|
|
driver_release_tids =
|
|
|
|
BIT(ffs(driver_release_tids) - 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-09-29 14:04:29 +00:00
|
|
|
|
|
|
|
if (!skb_queue_empty(&sta->tx_filtered[ac]) ||
|
|
|
|
!skb_queue_empty(&sta->ps_tx_buf[ac])) {
|
|
|
|
more_data = true;
|
|
|
|
break;
|
|
|
|
}
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:32 +00:00
|
|
|
if (!found) {
|
2011-09-29 14:04:34 +00:00
|
|
|
int tid;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
|
|
|
/*
|
2011-09-29 14:04:34 +00:00
|
|
|
* For PS-Poll, this can only happen due to a race condition
|
|
|
|
* when we set the TIM bit and the station notices it, but
|
|
|
|
* before it can poll for the frame we expire it.
|
|
|
|
*
|
|
|
|
* For uAPSD, this is said in the standard (11.2.1.5 h):
|
|
|
|
* At each unscheduled SP for a non-AP STA, the AP shall
|
|
|
|
* attempt to transmit at least one MSDU or MMPDU, but no
|
|
|
|
* more than the value specified in the Max SP Length field
|
|
|
|
* in the QoS Capability element from delivery-enabled ACs,
|
|
|
|
* that are destined for the non-AP STA.
|
|
|
|
*
|
|
|
|
* Since we have no other MSDU/MMPDU, transmit a QoS null frame.
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
*/
|
|
|
|
|
2011-09-29 14:04:34 +00:00
|
|
|
/* This will evaluate to 1, 3, 5 or 7. */
|
|
|
|
tid = 7 - ((ffs(~ignored_acs) - 1) << 1);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:38 +00:00
|
|
|
ieee80211_send_null_response(sdata, sta, tid, reason);
|
2011-09-29 14:04:32 +00:00
|
|
|
return;
|
|
|
|
}
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
if (!driver_release_tids) {
|
|
|
|
struct sk_buff_head pending;
|
|
|
|
struct sk_buff *skb;
|
2011-09-29 14:04:38 +00:00
|
|
|
int num = 0;
|
|
|
|
u16 tids = 0;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
skb_queue_head_init(&pending);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
while ((skb = __skb_dequeue(&frames))) {
|
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
|
|
|
struct ieee80211_hdr *hdr = (void *) skb->data;
|
2011-09-29 14:04:38 +00:00
|
|
|
u8 *qoshdr = NULL;
|
|
|
|
|
|
|
|
num++;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
/*
|
|
|
|
* Tell TX path to send this frame even though the
|
|
|
|
* STA may still remain is PS mode after this frame
|
|
|
|
* exchange.
|
|
|
|
*/
|
|
|
|
info->flags |= IEEE80211_TX_CTL_POLL_RESPONSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Use MoreData flag to indicate whether there are
|
|
|
|
* more buffered frames for this STA
|
|
|
|
*/
|
2011-11-07 07:47:47 +00:00
|
|
|
if (more_data || !skb_queue_empty(&frames))
|
2011-09-29 14:04:33 +00:00
|
|
|
hdr->frame_control |=
|
|
|
|
cpu_to_le16(IEEE80211_FCTL_MOREDATA);
|
2011-11-07 07:47:47 +00:00
|
|
|
else
|
|
|
|
hdr->frame_control &=
|
|
|
|
cpu_to_le16(~IEEE80211_FCTL_MOREDATA);
|
2011-09-29 14:04:33 +00:00
|
|
|
|
2011-09-29 14:04:38 +00:00
|
|
|
if (ieee80211_is_data_qos(hdr->frame_control) ||
|
|
|
|
ieee80211_is_qos_nullfunc(hdr->frame_control))
|
|
|
|
qoshdr = ieee80211_get_qos_ctl(hdr);
|
|
|
|
|
|
|
|
/* set EOSP for the frame */
|
2011-09-29 14:04:33 +00:00
|
|
|
if (reason == IEEE80211_FRAME_RELEASE_UAPSD &&
|
2011-09-29 14:04:38 +00:00
|
|
|
qoshdr && skb_queue_empty(&frames))
|
|
|
|
*qoshdr |= IEEE80211_QOS_CTL_EOSP;
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:35 +00:00
|
|
|
info->flags |= IEEE80211_TX_STATUS_EOSP |
|
|
|
|
IEEE80211_TX_CTL_REQ_TX_STATUS;
|
|
|
|
|
2011-09-29 14:04:38 +00:00
|
|
|
if (qoshdr)
|
|
|
|
tids |= BIT(*qoshdr & IEEE80211_QOS_CTL_TID_MASK);
|
|
|
|
else
|
|
|
|
tids |= BIT(0);
|
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
__skb_queue_tail(&pending, skb);
|
|
|
|
}
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:38 +00:00
|
|
|
drv_allow_buffered_frames(local, sta, tids, num,
|
|
|
|
reason, more_data);
|
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
ieee80211_add_pending_skbs(local, &pending);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
sta_info_recalc_tim(sta);
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
} else {
|
|
|
|
/*
|
2011-09-29 14:04:32 +00:00
|
|
|
* We need to release a frame that is buffered somewhere in the
|
|
|
|
* driver ... it'll have to handle that.
|
|
|
|
* Note that, as per the comment above, it'll also have to see
|
|
|
|
* if there is more than just one frame on the specific TID that
|
|
|
|
* we're releasing from, and it needs to set the more-data bit
|
|
|
|
* accordingly if we tell it that there's no more data. If we do
|
|
|
|
* tell it there's more data, then of course the more-data bit
|
|
|
|
* needs to be set anyway.
|
|
|
|
*/
|
|
|
|
drv_release_buffered_frames(local, sta, driver_release_tids,
|
2011-09-29 14:04:33 +00:00
|
|
|
n_frames, reason, more_data);
|
2011-09-29 14:04:32 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that we don't recalculate the TIM bit here as it would
|
|
|
|
* most likely have no effect at all unless the driver told us
|
|
|
|
* that the TID became empty before returning here from the
|
|
|
|
* release function.
|
|
|
|
* Either way, however, when the driver tells us that the TID
|
|
|
|
* became empty we'll do the TIM recalculation.
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-29 14:04:33 +00:00
|
|
|
void ieee80211_sta_ps_deliver_poll_response(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
u8 ignore_for_response = sta->sta.uapsd_queues;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If all ACs are delivery-enabled then we should reply
|
|
|
|
* from any of them, if only some are enabled we reply
|
|
|
|
* only from the non-enabled ones.
|
|
|
|
*/
|
|
|
|
if (ignore_for_response == BIT(IEEE80211_NUM_ACS) - 1)
|
|
|
|
ignore_for_response = 0;
|
|
|
|
|
|
|
|
ieee80211_sta_ps_deliver_response(sta, 1, ignore_for_response,
|
|
|
|
IEEE80211_FRAME_RELEASE_PSPOLL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sta_ps_deliver_uapsd(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
int n_frames = sta->sta.max_sp;
|
|
|
|
u8 delivery_enabled = sta->sta.uapsd_queues;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we ever grow support for TSPEC this might happen if
|
|
|
|
* the TSPEC update from hostapd comes in between a trigger
|
|
|
|
* frame setting WLAN_STA_UAPSD in the RX path and this
|
|
|
|
* actually getting called.
|
|
|
|
*/
|
|
|
|
if (!delivery_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (sta->sta.max_sp) {
|
|
|
|
case 1:
|
|
|
|
n_frames = 2;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
n_frames = 4;
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
n_frames = 6;
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
/* XXX: what is a good value? */
|
|
|
|
n_frames = 8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_sta_ps_deliver_response(sta, n_frames, ~delivery_enabled,
|
|
|
|
IEEE80211_FRAME_RELEASE_UAPSD);
|
|
|
|
}
|
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
void ieee80211_sta_block_awake(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_sta *pubsta, bool block)
|
|
|
|
{
|
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
|
2010-04-07 14:48:40 +00:00
|
|
|
trace_api_sta_block_awake(sta->local, pubsta, block);
|
|
|
|
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
if (block)
|
2011-09-29 14:04:36 +00:00
|
|
|
set_sta_flag(sta, WLAN_STA_PS_DRIVER);
|
|
|
|
else if (test_sta_flag(sta, WLAN_STA_PS_DRIVER))
|
mac80211: async station powersave handling
Some devices require that all frames to a station
are flushed when that station goes into powersave
mode before being able to send frames to that
station again when it wakes up or polls -- all in
order to avoid reordering and too many or too few
frames being sent to the station when it polls.
Normally, this is the case unless the station
goes to sleep and wakes up very quickly again.
But in that case, frames for it may be pending
on the hardware queues, and thus races could
happen in the case of multiple hardware queues
used for QoS/WMM. Normally this isn't a problem,
but with the iwlwifi mechanism we need to make
sure the race doesn't happen.
This makes mac80211 able to cope with the race
with driver help by a new WLAN_STA_PS_DRIVER
per-station flag that can be controlled by the
driver and tells mac80211 whether it can transmit
frames or not. This flag must be set according to
very specific rules outlined in the documentation
for the function that controls it.
When we buffer new frames for the station, we
normally set the TIM bit right away, but while
the driver has blocked transmission to that sta
we need to avoid that as well since we cannot
respond to the station if it wakes up due to the
TIM bit. Once the driver unblocks, we can set
the TIM bit.
Similarly, when the station just wakes up, we
need to wait until all other frames are flushed
before we can transmit frames to that station,
so the same applies here, we need to wait for
the driver to give the OK.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-11-06 10:35:50 +00:00
|
|
|
ieee80211_queue_work(hw, &sta->drv_unblock_wk);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_sta_block_awake);
|
2011-04-17 15:45:00 +00:00
|
|
|
|
2011-09-29 14:04:39 +00:00
|
|
|
void ieee80211_sta_eosp_irqsafe(struct ieee80211_sta *pubsta)
|
|
|
|
{
|
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
struct ieee80211_local *local = sta->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct skb_eosp_msg_data *data;
|
|
|
|
|
|
|
|
trace_api_eosp(local, pubsta);
|
|
|
|
|
|
|
|
skb = alloc_skb(0, GFP_ATOMIC);
|
|
|
|
if (!skb) {
|
|
|
|
/* too bad ... but race is better than loss */
|
|
|
|
clear_sta_flag(sta, WLAN_STA_SP);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data = (void *)skb->cb;
|
|
|
|
memcpy(data->sta, pubsta->addr, ETH_ALEN);
|
|
|
|
memcpy(data->iface, sta->sdata->vif.addr, ETH_ALEN);
|
|
|
|
skb->pkt_type = IEEE80211_EOSP_MSG;
|
|
|
|
skb_queue_tail(&local->skb_queue, skb);
|
|
|
|
tasklet_schedule(&local->tasklet);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_sta_eosp_irqsafe);
|
|
|
|
|
2011-09-29 14:04:26 +00:00
|
|
|
void ieee80211_sta_set_buffered(struct ieee80211_sta *pubsta,
|
|
|
|
u8 tid, bool buffered)
|
2011-04-17 15:45:00 +00:00
|
|
|
{
|
|
|
|
struct sta_info *sta = container_of(pubsta, struct sta_info, sta);
|
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
if (WARN_ON(tid >= STA_TID_NUM))
|
2011-09-29 14:04:26 +00:00
|
|
|
return;
|
|
|
|
|
2011-09-29 14:04:29 +00:00
|
|
|
if (buffered)
|
|
|
|
set_bit(tid, &sta->driver_buffered_tids);
|
|
|
|
else
|
|
|
|
clear_bit(tid, &sta->driver_buffered_tids);
|
|
|
|
|
2011-09-29 14:04:27 +00:00
|
|
|
sta_info_recalc_tim(sta);
|
2011-04-17 15:45:00 +00:00
|
|
|
}
|
2011-09-29 14:04:26 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_sta_set_buffered);
|
2011-12-14 11:35:30 +00:00
|
|
|
|
2012-01-12 08:31:10 +00:00
|
|
|
int sta_info_move_state(struct sta_info *sta,
|
|
|
|
enum ieee80211_sta_state new_state)
|
2011-12-14 11:35:30 +00:00
|
|
|
{
|
2011-12-15 10:17:37 +00:00
|
|
|
might_sleep();
|
2011-12-14 11:35:30 +00:00
|
|
|
|
|
|
|
if (sta->sta_state == new_state)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (new_state) {
|
|
|
|
case IEEE80211_STA_NONE:
|
|
|
|
if (sta->sta_state == IEEE80211_STA_AUTH)
|
|
|
|
clear_bit(WLAN_STA_AUTH, &sta->_flags);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
case IEEE80211_STA_AUTH:
|
|
|
|
if (sta->sta_state == IEEE80211_STA_NONE)
|
|
|
|
set_bit(WLAN_STA_AUTH, &sta->_flags);
|
|
|
|
else if (sta->sta_state == IEEE80211_STA_ASSOC)
|
|
|
|
clear_bit(WLAN_STA_ASSOC, &sta->_flags);
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
case IEEE80211_STA_ASSOC:
|
2011-12-14 11:20:31 +00:00
|
|
|
if (sta->sta_state == IEEE80211_STA_AUTH) {
|
2011-12-14 11:35:30 +00:00
|
|
|
set_bit(WLAN_STA_ASSOC, &sta->_flags);
|
2011-12-14 11:20:31 +00:00
|
|
|
} else if (sta->sta_state == IEEE80211_STA_AUTHORIZED) {
|
|
|
|
if (sta->sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
atomic_dec(&sta->sdata->u.ap.num_sta_authorized);
|
2011-12-14 11:35:30 +00:00
|
|
|
clear_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
|
2011-12-14 11:20:31 +00:00
|
|
|
} else
|
2011-12-14 11:35:30 +00:00
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
case IEEE80211_STA_AUTHORIZED:
|
2011-12-14 11:20:31 +00:00
|
|
|
if (sta->sta_state == IEEE80211_STA_ASSOC) {
|
|
|
|
if (sta->sdata->vif.type == NL80211_IFTYPE_AP)
|
|
|
|
atomic_inc(&sta->sdata->u.ap.num_sta_authorized);
|
2011-12-14 11:35:30 +00:00
|
|
|
set_bit(WLAN_STA_AUTHORIZED, &sta->_flags);
|
2011-12-14 11:20:31 +00:00
|
|
|
} else
|
2011-12-14 11:35:30 +00:00
|
|
|
return -EINVAL;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
WARN(1, "invalid state %d", new_state);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_DEBUG "%s: moving STA %pM to state %d\n",
|
|
|
|
sta->sdata->name, sta->sta.addr, new_state);
|
|
|
|
sta->sta_state = new_state;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|