2007-07-27 13:43:23 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
|
|
|
|
* Copyright 2007 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.
|
|
|
|
*
|
|
|
|
* utilities for mac80211
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/wireless.h>
|
|
|
|
#include <linux/bitmap.h>
|
2007-09-17 18:56:21 +00:00
|
|
|
#include <net/net_namespace.h>
|
2007-07-27 13:43:23 +00:00
|
|
|
#include <net/cfg80211.h>
|
2007-11-09 00:57:29 +00:00
|
|
|
#include <net/rtnetlink.h>
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
#include "ieee80211_i.h"
|
2008-04-08 19:14:40 +00:00
|
|
|
#include "rate.h"
|
2008-02-23 14:17:11 +00:00
|
|
|
#include "mesh.h"
|
2007-07-27 13:43:23 +00:00
|
|
|
#include "wme.h"
|
|
|
|
|
|
|
|
/* privid for wiphys to determine whether they belong to us or not */
|
|
|
|
void *mac80211_wiphy_privid = &mac80211_wiphy_privid;
|
|
|
|
|
|
|
|
/* See IEEE 802.1H for LLC/SNAP encapsulation/decapsulation */
|
|
|
|
/* Ethernet-II snap header (RFC1042 for most EtherTypes) */
|
2008-05-28 17:45:32 +00:00
|
|
|
const unsigned char rfc1042_header[] __aligned(2) =
|
2007-07-27 13:43:23 +00:00
|
|
|
{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
|
|
|
|
|
|
|
|
/* Bridge-Tunnel header (for EtherTypes ETH_P_AARP and ETH_P_IPX) */
|
2008-05-28 17:45:32 +00:00
|
|
|
const unsigned char bridge_tunnel_header[] __aligned(2) =
|
2007-07-27 13:43:23 +00:00
|
|
|
{ 0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8 };
|
|
|
|
|
2009-01-22 23:05:53 +00:00
|
|
|
struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local;
|
|
|
|
BUG_ON(!wiphy);
|
|
|
|
|
|
|
|
local = wiphy_priv(wiphy);
|
|
|
|
return &local->hw;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2007-12-25 15:00:36 +00:00
|
|
|
u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
|
2008-09-10 22:01:58 +00:00
|
|
|
enum nl80211_iftype type)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-06-11 21:21:58 +00:00
|
|
|
__le16 fc = hdr->frame_control;
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2007-12-18 15:23:53 +00:00
|
|
|
/* drop ACK/CTS frames and incorrect hdr len (ctrl) */
|
|
|
|
if (len < 16)
|
2007-07-27 13:43:23 +00:00
|
|
|
return NULL;
|
|
|
|
|
2008-06-11 21:21:58 +00:00
|
|
|
if (ieee80211_is_data(fc)) {
|
2007-12-18 15:23:53 +00:00
|
|
|
if (len < 24) /* drop incorrect hdr len (data) */
|
|
|
|
return NULL;
|
2008-06-11 21:21:58 +00:00
|
|
|
|
|
|
|
if (ieee80211_has_a4(fc))
|
2007-07-27 13:43:23 +00:00
|
|
|
return NULL;
|
2008-06-11 21:21:58 +00:00
|
|
|
if (ieee80211_has_tods(fc))
|
|
|
|
return hdr->addr1;
|
|
|
|
if (ieee80211_has_fromds(fc))
|
2007-07-27 13:43:23 +00:00
|
|
|
return hdr->addr2;
|
2008-06-11 21:21:58 +00:00
|
|
|
|
|
|
|
return hdr->addr3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_mgmt(fc)) {
|
2007-12-18 15:23:53 +00:00
|
|
|
if (len < 24) /* drop incorrect hdr len (mgmt) */
|
|
|
|
return NULL;
|
2007-07-27 13:43:23 +00:00
|
|
|
return hdr->addr3;
|
2008-06-11 21:21:58 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_ctl(fc)) {
|
|
|
|
if(ieee80211_is_pspoll(fc))
|
2007-07-27 13:43:23 +00:00
|
|
|
return hdr->addr1;
|
2008-06-11 21:21:58 +00:00
|
|
|
|
|
|
|
if (ieee80211_is_back_req(fc)) {
|
2007-12-25 15:00:36 +00:00
|
|
|
switch (type) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_STATION:
|
2007-12-25 15:00:36 +00:00
|
|
|
return hdr->addr2;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2007-12-25 15:00:36 +00:00
|
|
|
return hdr->addr1;
|
|
|
|
default:
|
2008-06-11 21:21:58 +00:00
|
|
|
break; /* fall through to the return */
|
2007-12-25 15:00:36 +00:00
|
|
|
}
|
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-06-11 21:21:57 +00:00
|
|
|
unsigned int ieee80211_hdrlen(__le16 fc)
|
|
|
|
{
|
|
|
|
unsigned int hdrlen = 24;
|
|
|
|
|
|
|
|
if (ieee80211_is_data(fc)) {
|
|
|
|
if (ieee80211_has_a4(fc))
|
|
|
|
hdrlen = 30;
|
|
|
|
if (ieee80211_is_data_qos(fc))
|
|
|
|
hdrlen += IEEE80211_QOS_CTL_LEN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ieee80211_is_ctl(fc)) {
|
|
|
|
/*
|
|
|
|
* ACK and CTS are 10 bytes, all others 16. To see how
|
|
|
|
* to get this condition consider
|
|
|
|
* subtype mask: 0b0000000011110000 (0x00F0)
|
|
|
|
* ACK subtype: 0b0000000011010000 (0x00D0)
|
|
|
|
* CTS subtype: 0b0000000011000000 (0x00C0)
|
|
|
|
* bits that matter: ^^^ (0x00E0)
|
|
|
|
* value of those: 0b0000000011000000 (0x00C0)
|
|
|
|
*/
|
|
|
|
if ((fc & cpu_to_le16(0x00E0)) == cpu_to_le16(0x00C0))
|
|
|
|
hdrlen = 10;
|
|
|
|
else
|
|
|
|
hdrlen = 16;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return hdrlen;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_hdrlen);
|
|
|
|
|
2008-06-11 21:21:57 +00:00
|
|
|
unsigned int ieee80211_get_hdrlen_from_skb(const struct sk_buff *skb)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-06-11 21:21:57 +00:00
|
|
|
const struct ieee80211_hdr *hdr = (const struct ieee80211_hdr *)skb->data;
|
|
|
|
unsigned int hdrlen;
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
if (unlikely(skb->len < 10))
|
|
|
|
return 0;
|
2008-06-11 21:21:57 +00:00
|
|
|
hdrlen = ieee80211_hdrlen(hdr->frame_control);
|
2007-07-27 13:43:23 +00:00
|
|
|
if (unlikely(hdrlen > skb->len))
|
|
|
|
return 0;
|
|
|
|
return hdrlen;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_get_hdrlen_from_skb);
|
|
|
|
|
2008-02-23 14:17:11 +00:00
|
|
|
int ieee80211_get_mesh_hdrlen(struct ieee80211s_hdr *meshhdr)
|
|
|
|
{
|
|
|
|
int ae = meshhdr->flags & IEEE80211S_FLAGS_AE;
|
|
|
|
/* 7.1.3.5a.2 */
|
|
|
|
switch (ae) {
|
|
|
|
case 0:
|
2008-05-05 19:02:35 +00:00
|
|
|
return 6;
|
2008-02-23 14:17:11 +00:00
|
|
|
case 1:
|
2008-05-05 19:02:35 +00:00
|
|
|
return 12;
|
2008-02-23 14:17:11 +00:00
|
|
|
case 2:
|
2008-05-05 19:02:35 +00:00
|
|
|
return 18;
|
2008-02-23 14:17:11 +00:00
|
|
|
case 3:
|
2008-05-05 19:02:35 +00:00
|
|
|
return 24;
|
2008-02-23 14:17:11 +00:00
|
|
|
default:
|
2008-05-05 19:02:35 +00:00
|
|
|
return 6;
|
2008-02-23 14:17:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-25 15:27:43 +00:00
|
|
|
void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2009-03-23 16:28:35 +00:00
|
|
|
struct sk_buff *skb = tx->skb;
|
|
|
|
struct ieee80211_hdr *hdr;
|
|
|
|
|
|
|
|
do {
|
|
|
|
hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
|
|
|
} while ((skb = skb->next));
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int ieee80211_frame_duration(struct ieee80211_local *local, size_t len,
|
|
|
|
int rate, int erp, int short_preamble)
|
|
|
|
{
|
|
|
|
int dur;
|
|
|
|
|
|
|
|
/* calculate duration (in microseconds, rounded up to next higher
|
|
|
|
* integer if it includes a fractional microsecond) to send frame of
|
|
|
|
* len bytes (does not include FCS) at the given rate. Duration will
|
|
|
|
* also include SIFS.
|
|
|
|
*
|
|
|
|
* rate is in 100 kbps, so divident is multiplied by 10 in the
|
|
|
|
* DIV_ROUND_UP() operations.
|
|
|
|
*/
|
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
if (local->hw.conf.channel->band == IEEE80211_BAND_5GHZ || erp) {
|
2007-07-27 13:43:23 +00:00
|
|
|
/*
|
|
|
|
* OFDM:
|
|
|
|
*
|
|
|
|
* N_DBPS = DATARATE x 4
|
|
|
|
* N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
|
|
|
|
* (16 = SIGNAL time, 6 = tail bits)
|
|
|
|
* TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
|
|
|
|
*
|
|
|
|
* T_SYM = 4 usec
|
|
|
|
* 802.11a - 17.5.2: aSIFSTime = 16 usec
|
|
|
|
* 802.11g - 19.8.4: aSIFSTime = 10 usec +
|
|
|
|
* signal ext = 6 usec
|
|
|
|
*/
|
|
|
|
dur = 16; /* SIFS + signal ext */
|
|
|
|
dur += 16; /* 17.3.2.3: T_PREAMBLE = 16 usec */
|
|
|
|
dur += 4; /* 17.3.2.3: T_SIGNAL = 4 usec */
|
|
|
|
dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
|
|
|
|
4 * rate); /* T_SYM x N_SYM */
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* 802.11b or 802.11g with 802.11b compatibility:
|
|
|
|
* 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
|
|
|
|
* Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
|
|
|
|
*
|
|
|
|
* 802.11 (DS): 15.3.3, 802.11b: 18.3.4
|
|
|
|
* aSIFSTime = 10 usec
|
|
|
|
* aPreambleLength = 144 usec or 72 usec with short preamble
|
|
|
|
* aPLCPHeaderLength = 48 usec or 24 usec with short preamble
|
|
|
|
*/
|
|
|
|
dur = 10; /* aSIFSTime = 10 usec */
|
|
|
|
dur += short_preamble ? (72 + 24) : (144 + 48);
|
|
|
|
|
|
|
|
dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
|
|
|
|
}
|
|
|
|
|
|
|
|
return dur;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Exported duration function for driver use */
|
2007-12-19 00:31:26 +00:00
|
|
|
__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2008-01-24 18:38:38 +00:00
|
|
|
size_t frame_len,
|
|
|
|
struct ieee80211_rate *rate)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
2008-09-12 20:52:47 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-07-27 13:43:23 +00:00
|
|
|
u16 dur;
|
|
|
|
int erp;
|
2008-09-12 20:52:47 +00:00
|
|
|
bool short_preamble = false;
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2008-01-24 18:38:38 +00:00
|
|
|
erp = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 23:51:51 +00:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
|
|
|
}
|
2008-01-24 18:38:38 +00:00
|
|
|
|
|
|
|
dur = ieee80211_frame_duration(local, frame_len, rate->bitrate, erp,
|
2008-09-12 20:52:47 +00:00
|
|
|
short_preamble);
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_generic_frame_duration);
|
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif, size_t frame_len,
|
2008-05-15 10:55:29 +00:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-12 20:52:47 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 13:32:58 +00:00
|
|
|
bool short_preamble;
|
2007-07-27 13:43:23 +00:00
|
|
|
int erp;
|
|
|
|
u16 dur;
|
2008-05-15 10:55:27 +00:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2008-09-12 20:52:47 +00:00
|
|
|
short_preamble = false;
|
2007-07-27 13:43:24 +00:00
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-24 18:38:38 +00:00
|
|
|
|
|
|
|
erp = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 23:51:51 +00:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
/* CTS duration */
|
2008-01-24 18:38:38 +00:00
|
|
|
dur = ieee80211_frame_duration(local, 10, rate->bitrate,
|
2007-07-27 13:43:23 +00:00
|
|
|
erp, short_preamble);
|
|
|
|
/* Data frame duration */
|
2008-01-24 18:38:38 +00:00
|
|
|
dur += ieee80211_frame_duration(local, frame_len, rate->bitrate,
|
2007-07-27 13:43:23 +00:00
|
|
|
erp, short_preamble);
|
|
|
|
/* ACK duration */
|
2008-01-24 18:38:38 +00:00
|
|
|
dur += ieee80211_frame_duration(local, 10, rate->bitrate,
|
2007-07-27 13:43:23 +00:00
|
|
|
erp, short_preamble);
|
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_rts_duration);
|
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
|
|
|
|
struct ieee80211_vif *vif,
|
2007-07-27 13:43:23 +00:00
|
|
|
size_t frame_len,
|
2008-05-15 10:55:29 +00:00
|
|
|
const struct ieee80211_tx_info *frame_txctl)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_rate *rate;
|
2008-09-12 20:52:47 +00:00
|
|
|
struct ieee80211_sub_if_data *sdata;
|
2007-12-28 13:32:58 +00:00
|
|
|
bool short_preamble;
|
2007-07-27 13:43:23 +00:00
|
|
|
int erp;
|
|
|
|
u16 dur;
|
2008-05-15 10:55:27 +00:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
2007-07-27 13:43:23 +00:00
|
|
|
|
2008-09-12 20:52:47 +00:00
|
|
|
short_preamble = false;
|
2007-07-27 13:43:24 +00:00
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
|
2008-01-24 18:38:38 +00:00
|
|
|
erp = 0;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (vif) {
|
|
|
|
sdata = vif_to_sdata(vif);
|
2008-10-10 23:51:51 +00:00
|
|
|
short_preamble = sdata->vif.bss_conf.use_short_preamble;
|
2008-09-12 20:52:47 +00:00
|
|
|
if (sdata->flags & IEEE80211_SDATA_OPERATING_GMODE)
|
|
|
|
erp = rate->flags & IEEE80211_RATE_ERP_G;
|
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
|
|
|
|
/* Data frame duration */
|
2008-01-24 18:38:38 +00:00
|
|
|
dur = ieee80211_frame_duration(local, frame_len, rate->bitrate,
|
2007-07-27 13:43:23 +00:00
|
|
|
erp, short_preamble);
|
2008-05-15 10:55:29 +00:00
|
|
|
if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
|
2007-07-27 13:43:23 +00:00
|
|
|
/* ACK duration */
|
2008-01-24 18:38:38 +00:00
|
|
|
dur += ieee80211_frame_duration(local, 10, rate->bitrate,
|
2007-07-27 13:43:23 +00:00
|
|
|
erp, short_preamble);
|
|
|
|
}
|
|
|
|
|
|
|
|
return cpu_to_le16(dur);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_ctstoself_duration);
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2009-03-23 16:28:42 +00:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return;
|
2008-12-18 21:35:20 +00:00
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
__clear_bit(reason, &local->queue_stop_reasons[queue]);
|
|
|
|
|
2009-03-23 16:28:37 +00:00
|
|
|
if (!skb_queue_empty(&local->pending[queue]) &&
|
|
|
|
local->queue_stop_reasons[queue] ==
|
|
|
|
BIT(IEEE80211_QUEUE_STOP_REASON_PENDING))
|
|
|
|
tasklet_schedule(&local->tx_pending_tasklet);
|
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
if (local->queue_stop_reasons[queue] != 0)
|
|
|
|
/* someone still has this queue stopped */
|
|
|
|
return;
|
|
|
|
|
2009-03-23 16:28:37 +00:00
|
|
|
netif_wake_subqueue(local->mdev, queue);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
2008-12-18 21:35:20 +00:00
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2008-12-18 21:35:20 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
__ieee80211_wake_queue(hw, queue, reason);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queue_by_reason(hw, queue,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queue);
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
|
2009-03-23 16:28:42 +00:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
|
2009-03-23 16:28:37 +00:00
|
|
|
/*
|
|
|
|
* Only stop if it was previously running, this is necessary
|
|
|
|
* for correct pending packets handling because there we may
|
|
|
|
* start (but not wake) the queue and rely on that.
|
|
|
|
*/
|
|
|
|
if (!local->queue_stop_reasons[queue])
|
|
|
|
netif_stop_subqueue(local->mdev, queue);
|
2008-12-18 21:35:20 +00:00
|
|
|
|
2009-03-23 16:28:37 +00:00
|
|
|
__set_bit(reason, &local->queue_stop_reasons[queue]);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
2008-12-18 21:35:20 +00:00
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
|
|
|
|
enum queue_stop_reason reason)
|
2008-12-18 21:35:20 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
__ieee80211_stop_queue(hw, queue, reason);
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queue_by_reason(hw, queue,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
|
|
|
}
|
2007-07-27 13:43:23 +00:00
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queue);
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-12-18 21:35:20 +00:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 13:43:23 +00:00
|
|
|
int i;
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2008-12-18 21:35:20 +00:00
|
|
|
__ieee80211_stop_queue(hw, i, reason);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_stop_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
ieee80211_stop_queues_by_reason(hw,
|
|
|
|
IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_stop_queues);
|
|
|
|
|
2008-07-24 18:02:04 +00:00
|
|
|
int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
|
2009-03-23 16:28:42 +00:00
|
|
|
if (WARN_ON(queue >= hw->queues))
|
|
|
|
return true;
|
mac80211: fix aggregation for hardware with ampdu queues
Hardware with AMPDU queues currently has broken aggregation.
This patch fixes it by making all A-MPDUs go over the regular AC queues,
but keeping track of the hardware queues in mac80211. As a first rough
version, it actually stops the AC queue for extended periods of time,
which can be removed by adding buffering internal to mac80211, but is
currently not a huge problem because people rarely use multiple TIDs
that are in the same AC (and iwlwifi currently doesn't operate as AP).
This is a short-term fix, my current medium-term plan, which I hope to
execute soon as well, but am not sure can finish before .30, looks like
this:
1) rework the internal queuing layer in mac80211 that we use for
fragments if the driver stopped queue in the middle of a fragmented
frame to be able to queue more frames at once (rather than just a
single frame with its fragments)
2) instead of stopping the entire AC queue, queue up the frames in a
per-station/per-TID queue during aggregation session initiation,
when the session has come up take all those frames and put them
onto the queue from 1)
3) push the ampdu queue layer abstraction this patch introduces in
mac80211 into the driver, and remove the virtual queue stuff from
mac80211 again
This plan will probably also affect ath9k in that mac80211 queues the
frames instead of passing them down, even when there are no ampdu queues.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-02-11 23:51:53 +00:00
|
|
|
|
2008-07-24 18:02:04 +00:00
|
|
|
return __netif_subqueue_stopped(local->mdev, queue);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_queue_stopped);
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
|
|
|
|
enum queue_stop_reason reason)
|
2007-07-27 13:43:23 +00:00
|
|
|
{
|
2008-12-18 21:35:20 +00:00
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
unsigned long flags;
|
2007-07-27 13:43:23 +00:00
|
|
|
int i;
|
|
|
|
|
2008-12-18 21:35:20 +00:00
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
|
|
|
2009-03-23 16:28:42 +00:00
|
|
|
for (i = 0; i < hw->queues; i++)
|
2008-12-18 21:35:20 +00:00
|
|
|
__ieee80211_wake_queue(hw, i, reason);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_wake_queues(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
ieee80211_wake_queues_by_reason(hw, IEEE80211_QUEUE_STOP_REASON_DRIVER);
|
2007-07-27 13:43:23 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ieee80211_wake_queues);
|
2007-11-09 00:57:29 +00:00
|
|
|
|
2007-12-19 00:31:26 +00:00
|
|
|
void ieee80211_iterate_active_interfaces(
|
|
|
|
struct ieee80211_hw *hw,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
2007-11-09 00:57:29 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_lock(&local->iflist_mtx);
|
2008-05-10 11:40:49 +00:00
|
|
|
|
|
|
|
list_for_each_entry(sdata, &local->interfaces, list) {
|
|
|
|
switch (sdata->vif.type) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case __NL80211_IFTYPE_AFTER_LAST:
|
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2008-05-10 11:40:49 +00:00
|
|
|
continue;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
case NL80211_IFTYPE_WDS:
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2008-05-10 11:40:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (netif_running(sdata->dev))
|
|
|
|
iterator(data, sdata->dev->dev_addr,
|
|
|
|
&sdata->vif);
|
|
|
|
}
|
|
|
|
|
2009-01-23 21:54:03 +00:00
|
|
|
mutex_unlock(&local->iflist_mtx);
|
2008-05-10 11:40:49 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces);
|
|
|
|
|
|
|
|
void ieee80211_iterate_active_interfaces_atomic(
|
|
|
|
struct ieee80211_hw *hw,
|
|
|
|
void (*iterator)(void *data, u8 *mac,
|
|
|
|
struct ieee80211_vif *vif),
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = hw_to_local(hw);
|
|
|
|
struct ieee80211_sub_if_data *sdata;
|
|
|
|
|
2007-11-28 09:55:32 +00:00
|
|
|
rcu_read_lock();
|
2007-11-09 00:57:29 +00:00
|
|
|
|
2007-11-28 09:55:32 +00:00
|
|
|
list_for_each_entry_rcu(sdata, &local->interfaces, list) {
|
2007-12-19 00:31:27 +00:00
|
|
|
switch (sdata->vif.type) {
|
2008-09-10 22:01:58 +00:00
|
|
|
case __NL80211_IFTYPE_AFTER_LAST:
|
|
|
|
case NL80211_IFTYPE_UNSPECIFIED:
|
|
|
|
case NL80211_IFTYPE_MONITOR:
|
|
|
|
case NL80211_IFTYPE_AP_VLAN:
|
2007-11-09 00:57:29 +00:00
|
|
|
continue;
|
2008-09-10 22:01:58 +00:00
|
|
|
case NL80211_IFTYPE_AP:
|
|
|
|
case NL80211_IFTYPE_STATION:
|
|
|
|
case NL80211_IFTYPE_ADHOC:
|
|
|
|
case NL80211_IFTYPE_WDS:
|
|
|
|
case NL80211_IFTYPE_MESH_POINT:
|
2007-11-09 00:57:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (netif_running(sdata->dev))
|
|
|
|
iterator(data, sdata->dev->dev_addr,
|
2007-12-19 00:31:26 +00:00
|
|
|
&sdata->vif);
|
2007-11-09 00:57:29 +00:00
|
|
|
}
|
2007-11-28 09:55:32 +00:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
2007-11-09 00:57:29 +00:00
|
|
|
}
|
2008-05-10 11:40:49 +00:00
|
|
|
EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
|
2008-09-08 14:40:36 +00:00
|
|
|
|
|
|
|
void ieee802_11_parse_elems(u8 *start, size_t len,
|
|
|
|
struct ieee802_11_elems *elems)
|
|
|
|
{
|
|
|
|
size_t left = len;
|
|
|
|
u8 *pos = start;
|
|
|
|
|
|
|
|
memset(elems, 0, sizeof(*elems));
|
|
|
|
elems->ie_start = start;
|
|
|
|
elems->total_len = len;
|
|
|
|
|
|
|
|
while (left >= 2) {
|
|
|
|
u8 id, elen;
|
|
|
|
|
|
|
|
id = *pos++;
|
|
|
|
elen = *pos++;
|
|
|
|
left -= 2;
|
|
|
|
|
|
|
|
if (elen > left)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (id) {
|
|
|
|
case WLAN_EID_SSID:
|
|
|
|
elems->ssid = pos;
|
|
|
|
elems->ssid_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_SUPP_RATES:
|
|
|
|
elems->supp_rates = pos;
|
|
|
|
elems->supp_rates_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_FH_PARAMS:
|
|
|
|
elems->fh_params = pos;
|
|
|
|
elems->fh_params_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_DS_PARAMS:
|
|
|
|
elems->ds_params = pos;
|
|
|
|
elems->ds_params_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CF_PARAMS:
|
|
|
|
elems->cf_params = pos;
|
|
|
|
elems->cf_params_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_TIM:
|
|
|
|
elems->tim = pos;
|
|
|
|
elems->tim_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_IBSS_PARAMS:
|
|
|
|
elems->ibss_params = pos;
|
|
|
|
elems->ibss_params_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CHALLENGE:
|
|
|
|
elems->challenge = pos;
|
|
|
|
elems->challenge_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_WPA:
|
|
|
|
if (elen >= 4 && pos[0] == 0x00 && pos[1] == 0x50 &&
|
|
|
|
pos[2] == 0xf2) {
|
|
|
|
/* Microsoft OUI (00:50:F2) */
|
|
|
|
if (pos[3] == 1) {
|
|
|
|
/* OUI Type 1 - WPA IE */
|
|
|
|
elems->wpa = pos;
|
|
|
|
elems->wpa_len = elen;
|
|
|
|
} else if (elen >= 5 && pos[3] == 2) {
|
|
|
|
if (pos[4] == 0) {
|
|
|
|
elems->wmm_info = pos;
|
|
|
|
elems->wmm_info_len = elen;
|
|
|
|
} else if (pos[4] == 1) {
|
|
|
|
elems->wmm_param = pos;
|
|
|
|
elems->wmm_param_len = elen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case WLAN_EID_RSN:
|
|
|
|
elems->rsn = pos;
|
|
|
|
elems->rsn_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_ERP_INFO:
|
|
|
|
elems->erp_info = pos;
|
|
|
|
elems->erp_info_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_EXT_SUPP_RATES:
|
|
|
|
elems->ext_supp_rates = pos;
|
|
|
|
elems->ext_supp_rates_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_HT_CAPABILITY:
|
2008-10-07 17:31:17 +00:00
|
|
|
if (elen >= sizeof(struct ieee80211_ht_cap))
|
|
|
|
elems->ht_cap_elem = (void *)pos;
|
2008-09-08 14:40:36 +00:00
|
|
|
break;
|
2008-10-09 10:13:49 +00:00
|
|
|
case WLAN_EID_HT_INFORMATION:
|
|
|
|
if (elen >= sizeof(struct ieee80211_ht_info))
|
2008-10-07 17:31:17 +00:00
|
|
|
elems->ht_info_elem = (void *)pos;
|
2008-09-08 14:40:36 +00:00
|
|
|
break;
|
|
|
|
case WLAN_EID_MESH_ID:
|
|
|
|
elems->mesh_id = pos;
|
|
|
|
elems->mesh_id_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_MESH_CONFIG:
|
|
|
|
elems->mesh_config = pos;
|
|
|
|
elems->mesh_config_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PEER_LINK:
|
|
|
|
elems->peer_link = pos;
|
|
|
|
elems->peer_link_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PREQ:
|
|
|
|
elems->preq = pos;
|
|
|
|
elems->preq_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PREP:
|
|
|
|
elems->prep = pos;
|
|
|
|
elems->prep_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PERR:
|
|
|
|
elems->perr = pos;
|
|
|
|
elems->perr_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_CHANNEL_SWITCH:
|
|
|
|
elems->ch_switch_elem = pos;
|
|
|
|
elems->ch_switch_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_QUIET:
|
|
|
|
if (!elems->quiet_elem) {
|
|
|
|
elems->quiet_elem = pos;
|
|
|
|
elems->quiet_elem_len = elen;
|
|
|
|
}
|
|
|
|
elems->num_of_quiet_elem++;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_COUNTRY:
|
|
|
|
elems->country_elem = pos;
|
|
|
|
elems->country_elem_len = elen;
|
|
|
|
break;
|
|
|
|
case WLAN_EID_PWR_CONSTRAINT:
|
|
|
|
elems->pwr_constr_elem = pos;
|
|
|
|
elems->pwr_constr_elem_len = elen;
|
|
|
|
break;
|
2009-01-19 16:48:46 +00:00
|
|
|
case WLAN_EID_TIMEOUT_INTERVAL:
|
|
|
|
elems->timeout_int = pos;
|
|
|
|
elems->timeout_int_len = elen;
|
2009-01-08 11:32:09 +00:00
|
|
|
break;
|
2008-09-08 14:40:36 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
left -= elen;
|
|
|
|
pos += elen;
|
|
|
|
}
|
|
|
|
}
|
2008-09-09 10:56:01 +00:00
|
|
|
|
|
|
|
void ieee80211_set_wmm_default(struct ieee80211_sub_if_data *sdata)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_tx_queue_params qparam;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!local->ops->conf_tx)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memset(&qparam, 0, sizeof(qparam));
|
|
|
|
|
|
|
|
qparam.aifs = 2;
|
|
|
|
|
|
|
|
if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
|
|
|
|
!(sdata->flags & IEEE80211_SDATA_OPERATING_GMODE))
|
|
|
|
qparam.cw_min = 31;
|
|
|
|
else
|
|
|
|
qparam.cw_min = 15;
|
|
|
|
|
|
|
|
qparam.cw_max = 1023;
|
|
|
|
qparam.txop = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < local_to_hw(local)->queues; i++)
|
|
|
|
local->ops->conf_tx(local_to_hw(local), i, &qparam);
|
|
|
|
}
|
2008-09-09 13:07:09 +00:00
|
|
|
|
2009-02-15 11:44:28 +00:00
|
|
|
void ieee80211_sta_def_wmm_params(struct ieee80211_sub_if_data *sdata,
|
|
|
|
const size_t supp_rates_len,
|
|
|
|
const u8 *supp_rates)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
int i, have_higher_than_11mbit = 0;
|
|
|
|
|
|
|
|
/* cf. IEEE 802.11 9.2.12 */
|
|
|
|
for (i = 0; i < supp_rates_len; i++)
|
|
|
|
if ((supp_rates[i] & 0x7f) * 5 > 110)
|
|
|
|
have_higher_than_11mbit = 1;
|
|
|
|
|
|
|
|
if (local->hw.conf.channel->band == IEEE80211_BAND_2GHZ &&
|
|
|
|
have_higher_than_11mbit)
|
|
|
|
sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
|
|
|
|
else
|
|
|
|
sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
|
|
|
|
|
|
|
|
ieee80211_set_wmm_default(sdata);
|
|
|
|
}
|
|
|
|
|
2008-09-09 13:07:09 +00:00
|
|
|
void ieee80211_tx_skb(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb,
|
|
|
|
int encrypt)
|
|
|
|
{
|
|
|
|
skb->dev = sdata->local->mdev;
|
|
|
|
skb_set_mac_header(skb, 0);
|
|
|
|
skb_set_network_header(skb, 0);
|
|
|
|
skb_set_transport_header(skb, 0);
|
|
|
|
|
|
|
|
skb->iif = sdata->dev->ifindex;
|
|
|
|
skb->do_not_encrypt = !encrypt;
|
|
|
|
|
|
|
|
dev_queue_xmit(skb);
|
|
|
|
}
|
2008-09-10 22:01:53 +00:00
|
|
|
|
|
|
|
int ieee80211_set_freq(struct ieee80211_sub_if_data *sdata, int freqMHz)
|
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
struct ieee80211_channel *chan;
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
|
|
|
|
chan = ieee80211_get_channel(local->hw.wiphy, freqMHz);
|
|
|
|
|
|
|
|
if (chan && !(chan->flags & IEEE80211_CHAN_DISABLED)) {
|
2008-09-10 22:01:58 +00:00
|
|
|
if (sdata->vif.type == NL80211_IFTYPE_ADHOC &&
|
2008-10-07 10:04:34 +00:00
|
|
|
chan->flags & IEEE80211_CHAN_NO_IBSS)
|
2008-09-10 22:01:53 +00:00
|
|
|
return ret;
|
|
|
|
local->oper_channel = chan;
|
2008-12-12 06:27:43 +00:00
|
|
|
local->oper_channel_type = NL80211_CHAN_NO_HT;
|
2008-09-10 22:01:53 +00:00
|
|
|
|
2008-09-10 22:01:55 +00:00
|
|
|
if (local->sw_scanning || local->hw_scanning)
|
2008-09-10 22:01:53 +00:00
|
|
|
ret = 0;
|
|
|
|
else
|
2008-10-09 10:18:51 +00:00
|
|
|
ret = ieee80211_hw_config(
|
|
|
|
local, IEEE80211_CONF_CHANGE_CHANNEL);
|
2008-09-10 22:01:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2008-09-10 22:01:57 +00:00
|
|
|
|
2009-01-21 14:13:48 +00:00
|
|
|
u32 ieee80211_mandatory_rates(struct ieee80211_local *local,
|
2008-09-10 22:01:57 +00:00
|
|
|
enum ieee80211_band band)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_rate *bitrates;
|
2009-01-21 14:13:48 +00:00
|
|
|
u32 mandatory_rates;
|
2008-09-10 22:01:57 +00:00
|
|
|
enum ieee80211_rate_flags mandatory_flag;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
|
|
|
if (!sband) {
|
|
|
|
WARN_ON(1);
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (band == IEEE80211_BAND_2GHZ)
|
|
|
|
mandatory_flag = IEEE80211_RATE_MANDATORY_B;
|
|
|
|
else
|
|
|
|
mandatory_flag = IEEE80211_RATE_MANDATORY_A;
|
|
|
|
|
|
|
|
bitrates = sband->bitrates;
|
|
|
|
mandatory_rates = 0;
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++)
|
|
|
|
if (bitrates[i].flags & mandatory_flag)
|
|
|
|
mandatory_rates |= BIT(i);
|
|
|
|
return mandatory_rates;
|
|
|
|
}
|
2009-02-15 11:44:28 +00:00
|
|
|
|
|
|
|
void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
|
|
|
|
u16 transaction, u16 auth_alg,
|
|
|
|
u8 *extra, size_t extra_len,
|
|
|
|
const u8 *bssid, int encrypt)
|
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom +
|
2009-03-20 19:21:16 +00:00
|
|
|
sizeof(*mgmt) + 6 + extra_len);
|
2009-02-15 11:44:28 +00:00
|
|
|
if (!skb) {
|
|
|
|
printk(KERN_DEBUG "%s: failed to allocate buffer for auth "
|
|
|
|
"frame\n", sdata->dev->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24 + 6);
|
|
|
|
memset(mgmt, 0, 24 + 6);
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_AUTH);
|
|
|
|
if (encrypt)
|
|
|
|
mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
|
|
|
|
memcpy(mgmt->da, bssid, ETH_ALEN);
|
|
|
|
memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, bssid, ETH_ALEN);
|
|
|
|
mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
|
|
|
|
mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
|
|
|
|
mgmt->u.auth.status_code = cpu_to_le16(0);
|
|
|
|
if (extra)
|
|
|
|
memcpy(skb_put(skb, extra_len), extra, extra_len);
|
|
|
|
|
|
|
|
ieee80211_tx_skb(sdata, skb, encrypt);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_send_probe_req(struct ieee80211_sub_if_data *sdata, u8 *dst,
|
2009-02-16 17:39:13 +00:00
|
|
|
u8 *ssid, size_t ssid_len,
|
|
|
|
u8 *ie, size_t ie_len)
|
2009-02-15 11:44:28 +00:00
|
|
|
{
|
|
|
|
struct ieee80211_local *local = sdata->local;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct ieee80211_mgmt *mgmt;
|
2009-03-20 19:21:16 +00:00
|
|
|
u8 *pos, *supp_rates, *esupp_rates = NULL;
|
|
|
|
int i;
|
2009-02-15 11:44:28 +00:00
|
|
|
|
|
|
|
skb = dev_alloc_skb(local->hw.extra_tx_headroom + sizeof(*mgmt) + 200 +
|
2009-03-20 19:21:16 +00:00
|
|
|
ie_len);
|
2009-02-15 11:44:28 +00:00
|
|
|
if (!skb) {
|
|
|
|
printk(KERN_DEBUG "%s: failed to allocate buffer for probe "
|
|
|
|
"request\n", sdata->dev->name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
skb_reserve(skb, local->hw.extra_tx_headroom);
|
|
|
|
|
|
|
|
mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
|
|
|
|
memset(mgmt, 0, 24);
|
|
|
|
mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
|
|
|
|
IEEE80211_STYPE_PROBE_REQ);
|
|
|
|
memcpy(mgmt->sa, sdata->dev->dev_addr, ETH_ALEN);
|
|
|
|
if (dst) {
|
|
|
|
memcpy(mgmt->da, dst, ETH_ALEN);
|
|
|
|
memcpy(mgmt->bssid, dst, ETH_ALEN);
|
|
|
|
} else {
|
|
|
|
memset(mgmt->da, 0xff, ETH_ALEN);
|
|
|
|
memset(mgmt->bssid, 0xff, ETH_ALEN);
|
|
|
|
}
|
|
|
|
pos = skb_put(skb, 2 + ssid_len);
|
|
|
|
*pos++ = WLAN_EID_SSID;
|
|
|
|
*pos++ = ssid_len;
|
|
|
|
memcpy(pos, ssid, ssid_len);
|
|
|
|
|
|
|
|
supp_rates = skb_put(skb, 2);
|
|
|
|
supp_rates[0] = WLAN_EID_SUPP_RATES;
|
|
|
|
supp_rates[1] = 0;
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
|
|
|
|
|
|
|
for (i = 0; i < sband->n_bitrates; i++) {
|
|
|
|
struct ieee80211_rate *rate = &sband->bitrates[i];
|
|
|
|
if (esupp_rates) {
|
|
|
|
pos = skb_put(skb, 1);
|
|
|
|
esupp_rates[1]++;
|
|
|
|
} else if (supp_rates[1] == 8) {
|
|
|
|
esupp_rates = skb_put(skb, 3);
|
|
|
|
esupp_rates[0] = WLAN_EID_EXT_SUPP_RATES;
|
|
|
|
esupp_rates[1] = 1;
|
|
|
|
pos = &esupp_rates[2];
|
|
|
|
} else {
|
|
|
|
pos = skb_put(skb, 1);
|
|
|
|
supp_rates[1]++;
|
|
|
|
}
|
|
|
|
*pos = rate->bitrate / 5;
|
|
|
|
}
|
|
|
|
|
2009-03-31 10:12:05 +00:00
|
|
|
/* if adding more here, adjust max_scan_ie_len */
|
|
|
|
|
2009-02-16 17:39:13 +00:00
|
|
|
if (ie)
|
|
|
|
memcpy(skb_put(skb, ie_len), ie, ie_len);
|
2009-02-15 11:44:28 +00:00
|
|
|
|
|
|
|
ieee80211_tx_skb(sdata, skb, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 ieee80211_sta_get_rates(struct ieee80211_local *local,
|
|
|
|
struct ieee802_11_elems *elems,
|
|
|
|
enum ieee80211_band band)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_rate *bitrates;
|
|
|
|
size_t num_rates;
|
|
|
|
u32 supp_rates;
|
|
|
|
int i, j;
|
|
|
|
sband = local->hw.wiphy->bands[band];
|
|
|
|
|
|
|
|
if (!sband) {
|
|
|
|
WARN_ON(1);
|
|
|
|
sband = local->hw.wiphy->bands[local->hw.conf.channel->band];
|
|
|
|
}
|
|
|
|
|
|
|
|
bitrates = sband->bitrates;
|
|
|
|
num_rates = sband->n_bitrates;
|
|
|
|
supp_rates = 0;
|
|
|
|
for (i = 0; i < elems->supp_rates_len +
|
|
|
|
elems->ext_supp_rates_len; i++) {
|
|
|
|
u8 rate = 0;
|
|
|
|
int own_rate;
|
|
|
|
if (i < elems->supp_rates_len)
|
|
|
|
rate = elems->supp_rates[i];
|
|
|
|
else if (elems->ext_supp_rates)
|
|
|
|
rate = elems->ext_supp_rates
|
|
|
|
[i - elems->supp_rates_len];
|
|
|
|
own_rate = 5 * (rate & 0x7f);
|
|
|
|
for (j = 0; j < num_rates; j++)
|
|
|
|
if (bitrates[j].bitrate == own_rate)
|
|
|
|
supp_rates |= BIT(j);
|
|
|
|
}
|
|
|
|
return supp_rates;
|
|
|
|
}
|