![Stanislaw Gruszka](/assets/img/avatar_default.png)
Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
371 lines
8.3 KiB
C
371 lines
8.3 KiB
C
/*
|
|
* mac80211 work implementation
|
|
*
|
|
* Copyright 2003-2008, Jouni Malinen <j@w1.fi>
|
|
* Copyright 2004, Instant802 Networks, Inc.
|
|
* Copyright 2005, Devicescape Software, Inc.
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
* Copyright 2007, Michael Wu <flamingice@sourmilk.net>
|
|
* Copyright 2009, Johannes Berg <johannes@sipsolutions.net>
|
|
*
|
|
* 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/delay.h>
|
|
#include <linux/if_ether.h>
|
|
#include <linux/skbuff.h>
|
|
#include <linux/if_arp.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/crc32.h>
|
|
#include <linux/slab.h>
|
|
#include <net/mac80211.h>
|
|
#include <asm/unaligned.h>
|
|
|
|
#include "ieee80211_i.h"
|
|
#include "rate.h"
|
|
#include "driver-ops.h"
|
|
|
|
enum work_action {
|
|
WORK_ACT_NONE,
|
|
WORK_ACT_TIMEOUT,
|
|
};
|
|
|
|
|
|
/* utils */
|
|
static inline void ASSERT_WORK_MTX(struct ieee80211_local *local)
|
|
{
|
|
lockdep_assert_held(&local->mtx);
|
|
}
|
|
|
|
/*
|
|
* We can have multiple work items (and connection probing)
|
|
* scheduling this timer, but we need to take care to only
|
|
* reschedule it when it should fire _earlier_ than it was
|
|
* asked for before, or if it's not pending right now. This
|
|
* function ensures that. Note that it then is required to
|
|
* run this function for all timeouts after the first one
|
|
* has happened -- the work that runs from this timer will
|
|
* do that.
|
|
*/
|
|
static void run_again(struct ieee80211_local *local,
|
|
unsigned long timeout)
|
|
{
|
|
ASSERT_WORK_MTX(local);
|
|
|
|
if (!timer_pending(&local->work_timer) ||
|
|
time_before(timeout, local->work_timer.expires))
|
|
mod_timer(&local->work_timer, timeout);
|
|
}
|
|
|
|
void free_work(struct ieee80211_work *wk)
|
|
{
|
|
kfree_rcu(wk, rcu_head);
|
|
}
|
|
|
|
static enum work_action __must_check
|
|
ieee80211_remain_on_channel_timeout(struct ieee80211_work *wk)
|
|
{
|
|
/*
|
|
* First time we run, do nothing -- the generic code will
|
|
* have switched to the right channel etc.
|
|
*/
|
|
if (!wk->started) {
|
|
wk->timeout = jiffies + msecs_to_jiffies(wk->remain.duration);
|
|
|
|
cfg80211_ready_on_channel(wk->sdata->dev, (unsigned long) wk,
|
|
wk->chan, wk->chan_type,
|
|
wk->remain.duration, GFP_KERNEL);
|
|
|
|
return WORK_ACT_NONE;
|
|
}
|
|
|
|
return WORK_ACT_TIMEOUT;
|
|
}
|
|
|
|
static enum work_action __must_check
|
|
ieee80211_offchannel_tx(struct ieee80211_work *wk)
|
|
{
|
|
if (!wk->started) {
|
|
wk->timeout = jiffies + msecs_to_jiffies(wk->offchan_tx.wait);
|
|
|
|
/*
|
|
* After this, offchan_tx.frame remains but now is no
|
|
* longer a valid pointer -- we still need it as the
|
|
* cookie for canceling this work/status matching.
|
|
*/
|
|
ieee80211_tx_skb(wk->sdata, wk->offchan_tx.frame);
|
|
|
|
return WORK_ACT_NONE;
|
|
}
|
|
|
|
return WORK_ACT_TIMEOUT;
|
|
}
|
|
|
|
static void ieee80211_work_timer(unsigned long data)
|
|
{
|
|
struct ieee80211_local *local = (void *) data;
|
|
|
|
if (local->quiescing)
|
|
return;
|
|
|
|
ieee80211_queue_work(&local->hw, &local->work_work);
|
|
}
|
|
|
|
static void ieee80211_work_work(struct work_struct *work)
|
|
{
|
|
struct ieee80211_local *local =
|
|
container_of(work, struct ieee80211_local, work_work);
|
|
struct ieee80211_work *wk, *tmp;
|
|
LIST_HEAD(free_work);
|
|
enum work_action rma;
|
|
bool remain_off_channel = false;
|
|
|
|
/*
|
|
* ieee80211_queue_work() should have picked up most cases,
|
|
* here we'll pick the rest.
|
|
*/
|
|
if (WARN(local->suspended, "work scheduled while going to suspend\n"))
|
|
return;
|
|
|
|
mutex_lock(&local->mtx);
|
|
|
|
if (local->scanning) {
|
|
mutex_unlock(&local->mtx);
|
|
return;
|
|
}
|
|
|
|
ieee80211_recalc_idle(local);
|
|
|
|
list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
|
|
bool started = wk->started;
|
|
|
|
/* mark work as started if it's on the current off-channel */
|
|
if (!started && local->tmp_channel &&
|
|
wk->chan == local->tmp_channel &&
|
|
wk->chan_type == local->tmp_channel_type) {
|
|
started = true;
|
|
wk->timeout = jiffies;
|
|
}
|
|
|
|
if (!started && !local->tmp_channel) {
|
|
ieee80211_offchannel_stop_vifs(local, true);
|
|
|
|
local->tmp_channel = wk->chan;
|
|
local->tmp_channel_type = wk->chan_type;
|
|
|
|
ieee80211_hw_config(local, 0);
|
|
|
|
started = true;
|
|
wk->timeout = jiffies;
|
|
}
|
|
|
|
/* don't try to work with items that aren't started */
|
|
if (!started)
|
|
continue;
|
|
|
|
if (time_is_after_jiffies(wk->timeout)) {
|
|
/*
|
|
* This work item isn't supposed to be worked on
|
|
* right now, but take care to adjust the timer
|
|
* properly.
|
|
*/
|
|
run_again(local, wk->timeout);
|
|
continue;
|
|
}
|
|
|
|
switch (wk->type) {
|
|
default:
|
|
WARN_ON(1);
|
|
/* nothing */
|
|
rma = WORK_ACT_NONE;
|
|
break;
|
|
case IEEE80211_WORK_ABORT:
|
|
rma = WORK_ACT_TIMEOUT;
|
|
break;
|
|
case IEEE80211_WORK_REMAIN_ON_CHANNEL:
|
|
rma = ieee80211_remain_on_channel_timeout(wk);
|
|
break;
|
|
case IEEE80211_WORK_OFFCHANNEL_TX:
|
|
rma = ieee80211_offchannel_tx(wk);
|
|
break;
|
|
}
|
|
|
|
wk->started = started;
|
|
|
|
switch (rma) {
|
|
case WORK_ACT_NONE:
|
|
/* might have changed the timeout */
|
|
run_again(local, wk->timeout);
|
|
break;
|
|
case WORK_ACT_TIMEOUT:
|
|
list_del_rcu(&wk->list);
|
|
synchronize_rcu();
|
|
list_add(&wk->list, &free_work);
|
|
break;
|
|
default:
|
|
WARN(1, "unexpected: %d", rma);
|
|
}
|
|
}
|
|
|
|
list_for_each_entry(wk, &local->work_list, list) {
|
|
if (!wk->started)
|
|
continue;
|
|
if (wk->chan != local->tmp_channel ||
|
|
wk->chan_type != local->tmp_channel_type)
|
|
continue;
|
|
remain_off_channel = true;
|
|
}
|
|
|
|
if (!remain_off_channel && local->tmp_channel) {
|
|
local->tmp_channel = NULL;
|
|
ieee80211_hw_config(local, 0);
|
|
|
|
ieee80211_offchannel_return(local, true);
|
|
|
|
/* give connection some time to breathe */
|
|
run_again(local, jiffies + HZ/2);
|
|
}
|
|
|
|
ieee80211_recalc_idle(local);
|
|
ieee80211_run_deferred_scan(local);
|
|
|
|
mutex_unlock(&local->mtx);
|
|
|
|
list_for_each_entry_safe(wk, tmp, &free_work, list) {
|
|
wk->done(wk, NULL);
|
|
list_del(&wk->list);
|
|
kfree(wk);
|
|
}
|
|
}
|
|
|
|
void ieee80211_add_work(struct ieee80211_work *wk)
|
|
{
|
|
struct ieee80211_local *local;
|
|
|
|
if (WARN_ON(!wk->chan))
|
|
return;
|
|
|
|
if (WARN_ON(!wk->sdata))
|
|
return;
|
|
|
|
if (WARN_ON(!wk->done))
|
|
return;
|
|
|
|
if (WARN_ON(!ieee80211_sdata_running(wk->sdata)))
|
|
return;
|
|
|
|
wk->started = false;
|
|
|
|
local = wk->sdata->local;
|
|
mutex_lock(&local->mtx);
|
|
list_add_tail(&wk->list, &local->work_list);
|
|
mutex_unlock(&local->mtx);
|
|
|
|
ieee80211_queue_work(&local->hw, &local->work_work);
|
|
}
|
|
|
|
void ieee80211_work_init(struct ieee80211_local *local)
|
|
{
|
|
INIT_LIST_HEAD(&local->work_list);
|
|
setup_timer(&local->work_timer, ieee80211_work_timer,
|
|
(unsigned long)local);
|
|
INIT_WORK(&local->work_work, ieee80211_work_work);
|
|
}
|
|
|
|
void ieee80211_work_purge(struct ieee80211_sub_if_data *sdata)
|
|
{
|
|
struct ieee80211_local *local = sdata->local;
|
|
struct ieee80211_work *wk;
|
|
bool cleanup = false;
|
|
|
|
mutex_lock(&local->mtx);
|
|
list_for_each_entry(wk, &local->work_list, list) {
|
|
if (wk->sdata != sdata)
|
|
continue;
|
|
cleanup = true;
|
|
wk->type = IEEE80211_WORK_ABORT;
|
|
wk->started = true;
|
|
wk->timeout = jiffies;
|
|
}
|
|
mutex_unlock(&local->mtx);
|
|
|
|
/* run cleanups etc. */
|
|
if (cleanup)
|
|
ieee80211_work_work(&local->work_work);
|
|
|
|
mutex_lock(&local->mtx);
|
|
list_for_each_entry(wk, &local->work_list, list) {
|
|
if (wk->sdata != sdata)
|
|
continue;
|
|
WARN_ON(1);
|
|
break;
|
|
}
|
|
mutex_unlock(&local->mtx);
|
|
}
|
|
|
|
static enum work_done_result ieee80211_remain_done(struct ieee80211_work *wk,
|
|
struct sk_buff *skb)
|
|
{
|
|
/*
|
|
* We are done serving the remain-on-channel command.
|
|
*/
|
|
cfg80211_remain_on_channel_expired(wk->sdata->dev, (unsigned long) wk,
|
|
wk->chan, wk->chan_type,
|
|
GFP_KERNEL);
|
|
|
|
return WORK_DONE_DESTROY;
|
|
}
|
|
|
|
int ieee80211_wk_remain_on_channel(struct ieee80211_sub_if_data *sdata,
|
|
struct ieee80211_channel *chan,
|
|
enum nl80211_channel_type channel_type,
|
|
unsigned int duration, u64 *cookie)
|
|
{
|
|
struct ieee80211_work *wk;
|
|
|
|
wk = kzalloc(sizeof(*wk), GFP_KERNEL);
|
|
if (!wk)
|
|
return -ENOMEM;
|
|
|
|
wk->type = IEEE80211_WORK_REMAIN_ON_CHANNEL;
|
|
wk->chan = chan;
|
|
wk->chan_type = channel_type;
|
|
wk->sdata = sdata;
|
|
wk->done = ieee80211_remain_done;
|
|
|
|
wk->remain.duration = duration;
|
|
|
|
*cookie = (unsigned long) wk;
|
|
|
|
ieee80211_add_work(wk);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ieee80211_wk_cancel_remain_on_channel(struct ieee80211_sub_if_data *sdata,
|
|
u64 cookie)
|
|
{
|
|
struct ieee80211_local *local = sdata->local;
|
|
struct ieee80211_work *wk, *tmp;
|
|
bool found = false;
|
|
|
|
mutex_lock(&local->mtx);
|
|
list_for_each_entry_safe(wk, tmp, &local->work_list, list) {
|
|
if ((unsigned long) wk == cookie) {
|
|
wk->timeout = jiffies;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
mutex_unlock(&local->mtx);
|
|
|
|
if (!found)
|
|
return -ENOENT;
|
|
|
|
ieee80211_queue_work(&local->hw, &local->work_work);
|
|
|
|
return 0;
|
|
}
|