2007-05-05 12:46:38 -06:00
|
|
|
/*
|
|
|
|
* Copyright 2003-2005 Devicescape Software, Inc.
|
|
|
|
* Copyright (c) 2006 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/ieee80211.h>
|
|
|
|
#include "ieee80211_i.h"
|
|
|
|
#include "debugfs.h"
|
|
|
|
#include "debugfs_sta.h"
|
|
|
|
#include "sta_info.h"
|
|
|
|
|
|
|
|
/* sta attributtes */
|
|
|
|
|
|
|
|
#define STA_READ(name, buflen, field, format_string) \
|
|
|
|
static ssize_t sta_ ##name## _read(struct file *file, \
|
|
|
|
char __user *userbuf, \
|
|
|
|
size_t count, loff_t *ppos) \
|
|
|
|
{ \
|
|
|
|
int res; \
|
|
|
|
struct sta_info *sta = file->private_data; \
|
|
|
|
char buf[buflen]; \
|
|
|
|
res = scnprintf(buf, buflen, format_string, sta->field); \
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
|
|
|
|
}
|
|
|
|
#define STA_READ_D(name, field) STA_READ(name, 20, field, "%d\n")
|
|
|
|
#define STA_READ_U(name, field) STA_READ(name, 20, field, "%u\n")
|
|
|
|
#define STA_READ_LU(name, field) STA_READ(name, 20, field, "%lu\n")
|
|
|
|
#define STA_READ_S(name, field) STA_READ(name, 20, field, "%s\n")
|
|
|
|
|
|
|
|
#define STA_OPS(name) \
|
|
|
|
static const struct file_operations sta_ ##name## _ops = { \
|
|
|
|
.read = sta_##name##_read, \
|
|
|
|
.open = mac80211_open_file_generic, \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define STA_FILE(name, field, format) \
|
|
|
|
STA_READ_##format(name, field) \
|
|
|
|
STA_OPS(name)
|
|
|
|
|
2008-09-10 16:02:02 -06:00
|
|
|
STA_FILE(aid, sta.aid, D);
|
2009-11-25 09:46:19 -07:00
|
|
|
STA_FILE(dev, sdata->name, S);
|
2007-05-05 12:46:38 -06:00
|
|
|
STA_FILE(rx_packets, rx_packets, LU);
|
|
|
|
STA_FILE(tx_packets, tx_packets, LU);
|
|
|
|
STA_FILE(rx_bytes, rx_bytes, LU);
|
|
|
|
STA_FILE(tx_bytes, tx_bytes, LU);
|
|
|
|
STA_FILE(rx_duplicates, num_duplicates, LU);
|
|
|
|
STA_FILE(rx_fragments, rx_fragments, LU);
|
|
|
|
STA_FILE(rx_dropped, rx_dropped, LU);
|
|
|
|
STA_FILE(tx_fragments, tx_fragments, LU);
|
|
|
|
STA_FILE(tx_filtered, tx_filtered_count, LU);
|
|
|
|
STA_FILE(tx_retry_failed, tx_retry_failed, LU);
|
|
|
|
STA_FILE(tx_retry_count, tx_retry_count, LU);
|
|
|
|
STA_FILE(last_signal, last_signal, D);
|
|
|
|
STA_FILE(last_noise, last_noise, D);
|
2008-02-25 08:27:48 -07:00
|
|
|
STA_FILE(wep_weak_iv_count, wep_weak_iv_count, LU);
|
2007-05-05 12:46:38 -06:00
|
|
|
|
|
|
|
static ssize_t sta_flags_read(struct file *file, char __user *userbuf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[100];
|
|
|
|
struct sta_info *sta = file->private_data;
|
2008-05-02 17:02:02 -06:00
|
|
|
u32 staflags = get_sta_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 03:35:50 -07:00
|
|
|
int res = scnprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s",
|
2008-05-02 17:02:02 -06:00
|
|
|
staflags & WLAN_STA_AUTH ? "AUTH\n" : "",
|
|
|
|
staflags & WLAN_STA_ASSOC ? "ASSOC\n" : "",
|
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 03:35:50 -07:00
|
|
|
staflags & WLAN_STA_PS_STA ? "PS (sta)\n" : "",
|
|
|
|
staflags & WLAN_STA_PS_DRIVER ? "PS (driver)\n" : "",
|
2008-05-02 17:02:02 -06:00
|
|
|
staflags & WLAN_STA_AUTHORIZED ? "AUTHORIZED\n" : "",
|
|
|
|
staflags & WLAN_STA_SHORT_PREAMBLE ? "SHORT PREAMBLE\n" : "",
|
|
|
|
staflags & WLAN_STA_WME ? "WME\n" : "",
|
2009-01-08 04:31:59 -07:00
|
|
|
staflags & WLAN_STA_WDS ? "WDS\n" : "",
|
|
|
|
staflags & WLAN_STA_MFP ? "MFP\n" : "");
|
2007-05-05 12:46:38 -06:00
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, res);
|
|
|
|
}
|
|
|
|
STA_OPS(flags);
|
|
|
|
|
|
|
|
static ssize_t sta_num_ps_buf_frames_read(struct file *file,
|
|
|
|
char __user *userbuf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[20];
|
|
|
|
struct sta_info *sta = file->private_data;
|
|
|
|
int res = scnprintf(buf, sizeof(buf), "%u\n",
|
|
|
|
skb_queue_len(&sta->ps_tx_buf));
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, res);
|
|
|
|
}
|
|
|
|
STA_OPS(num_ps_buf_frames);
|
|
|
|
|
|
|
|
static ssize_t sta_inactive_ms_read(struct file *file, char __user *userbuf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[20];
|
|
|
|
struct sta_info *sta = file->private_data;
|
|
|
|
int res = scnprintf(buf, sizeof(buf), "%d\n",
|
|
|
|
jiffies_to_msecs(jiffies - sta->last_rx));
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, res);
|
|
|
|
}
|
|
|
|
STA_OPS(inactive_ms);
|
|
|
|
|
|
|
|
static ssize_t sta_last_seq_ctrl_read(struct file *file, char __user *userbuf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[15*NUM_RX_DATA_QUEUES], *p = buf;
|
|
|
|
int i;
|
|
|
|
struct sta_info *sta = file->private_data;
|
|
|
|
for (i = 0; i < NUM_RX_DATA_QUEUES; i++)
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "%x ",
|
2007-07-27 07:43:23 -06:00
|
|
|
le16_to_cpu(sta->last_seq_ctrl[i]));
|
2007-05-05 12:46:38 -06:00
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "\n");
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
|
|
|
|
}
|
|
|
|
STA_OPS(last_seq_ctrl);
|
|
|
|
|
2008-01-28 05:07:20 -07:00
|
|
|
static ssize_t sta_agg_status_read(struct file *file, char __user *userbuf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
2009-06-17 09:28:45 -06:00
|
|
|
char buf[30 + STA_TID_NUM * 70], *p = buf;
|
2008-01-28 05:07:20 -07:00
|
|
|
int i;
|
|
|
|
struct sta_info *sta = file->private_data;
|
|
|
|
|
2009-06-17 09:28:45 -06:00
|
|
|
spin_lock_bh(&sta->lock);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "next dialog_token is %#02x\n",
|
|
|
|
sta->ampdu_mlme.dialog_token_allocator + 1);
|
|
|
|
for (i = 0; i < STA_TID_NUM; i++) {
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "TID %02d:", i);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, " RX=%x",
|
|
|
|
sta->ampdu_mlme.tid_state_rx[i]);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "/DTKN=%#.2x",
|
|
|
|
sta->ampdu_mlme.tid_state_rx[i] ?
|
|
|
|
sta->ampdu_mlme.tid_rx[i]->dialog_token : 0);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "/SSN=%#.3x",
|
|
|
|
sta->ampdu_mlme.tid_state_rx[i] ?
|
|
|
|
sta->ampdu_mlme.tid_rx[i]->ssn : 0);
|
|
|
|
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, " TX=%x",
|
|
|
|
sta->ampdu_mlme.tid_state_tx[i]);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "/DTKN=%#.2x",
|
|
|
|
sta->ampdu_mlme.tid_state_tx[i] ?
|
|
|
|
sta->ampdu_mlme.tid_tx[i]->dialog_token : 0);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "/SSN=%#.3x",
|
|
|
|
sta->ampdu_mlme.tid_state_tx[i] ?
|
|
|
|
sta->ampdu_mlme.tid_tx[i]->ssn : 0);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "/pending=%03d",
|
|
|
|
sta->ampdu_mlme.tid_state_tx[i] ?
|
|
|
|
skb_queue_len(&sta->ampdu_mlme.tid_tx[i]->pending) : 0);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "\n");
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&sta->lock);
|
2008-01-28 05:07:20 -07:00
|
|
|
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
|
|
|
|
}
|
2008-10-07 04:04:30 -06:00
|
|
|
STA_OPS(agg_status);
|
2008-01-28 05:07:20 -07:00
|
|
|
|
2009-11-19 06:26:11 -07:00
|
|
|
static ssize_t sta_ht_capa_read(struct file *file, char __user *userbuf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
char buf[200], *p = buf;
|
|
|
|
int i;
|
|
|
|
struct sta_info *sta = file->private_data;
|
|
|
|
struct ieee80211_sta_ht_cap *htc = &sta->sta.ht_cap;
|
|
|
|
|
|
|
|
p += scnprintf(p, sizeof(buf) + buf - p, "ht %ssupported\n",
|
|
|
|
htc->ht_supported ? "" : "not ");
|
|
|
|
if (htc->ht_supported) {
|
2009-12-07 12:01:28 -07:00
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "cap: %#.4x\n", htc->cap);
|
2009-11-19 06:26:11 -07:00
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "ampdu factor/density: %d/%d\n",
|
|
|
|
htc->ampdu_factor, htc->ampdu_density);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "MCS mask:");
|
|
|
|
for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, " %.2x",
|
|
|
|
htc->mcs.rx_mask[i]);
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "\nMCS rx highest: %d\n",
|
|
|
|
le16_to_cpu(htc->mcs.rx_highest));
|
|
|
|
p += scnprintf(p, sizeof(buf)+buf-p, "MCS tx params: %x\n",
|
|
|
|
htc->mcs.tx_params);
|
|
|
|
}
|
|
|
|
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, p - buf);
|
|
|
|
}
|
|
|
|
STA_OPS(ht_capa);
|
|
|
|
|
2007-05-05 12:46:38 -06:00
|
|
|
#define DEBUGFS_ADD(name) \
|
2009-10-27 05:59:03 -06:00
|
|
|
debugfs_create_file(#name, 0400, \
|
2007-05-05 12:46:38 -06:00
|
|
|
sta->debugfs.dir, sta, &sta_ ##name## _ops);
|
|
|
|
|
|
|
|
|
|
|
|
void ieee80211_sta_debugfs_add(struct sta_info *sta)
|
|
|
|
{
|
|
|
|
struct dentry *stations_dir = sta->local->debugfs.stations;
|
2008-10-27 16:56:10 -06:00
|
|
|
u8 mac[3*ETH_ALEN];
|
2007-05-05 12:46:38 -06:00
|
|
|
|
2008-10-07 04:04:29 -06:00
|
|
|
sta->debugfs.add_has_run = true;
|
|
|
|
|
2007-05-05 12:46:38 -06:00
|
|
|
if (!stations_dir)
|
|
|
|
return;
|
|
|
|
|
2008-10-27 16:56:10 -06:00
|
|
|
snprintf(mac, sizeof(mac), "%pM", sta->sta.addr);
|
2007-05-05 12:46:38 -06:00
|
|
|
|
2008-10-07 04:04:29 -06:00
|
|
|
/*
|
|
|
|
* This might fail due to a race condition:
|
|
|
|
* When mac80211 unlinks a station, the debugfs entries
|
|
|
|
* remain, but it is already possible to link a new
|
|
|
|
* station with the same address which triggers adding
|
|
|
|
* it to debugfs; therefore, if the old station isn't
|
|
|
|
* destroyed quickly enough the old station's debugfs
|
|
|
|
* dir might still be around.
|
|
|
|
*/
|
2007-10-03 18:59:30 -06:00
|
|
|
sta->debugfs.dir = debugfs_create_dir(mac, stations_dir);
|
2007-05-05 12:46:38 -06:00
|
|
|
if (!sta->debugfs.dir)
|
|
|
|
return;
|
|
|
|
|
|
|
|
DEBUGFS_ADD(flags);
|
|
|
|
DEBUGFS_ADD(num_ps_buf_frames);
|
|
|
|
DEBUGFS_ADD(inactive_ms);
|
|
|
|
DEBUGFS_ADD(last_seq_ctrl);
|
2008-01-28 05:07:20 -07:00
|
|
|
DEBUGFS_ADD(agg_status);
|
2009-06-17 09:28:45 -06:00
|
|
|
DEBUGFS_ADD(dev);
|
|
|
|
DEBUGFS_ADD(rx_packets);
|
|
|
|
DEBUGFS_ADD(tx_packets);
|
|
|
|
DEBUGFS_ADD(rx_bytes);
|
|
|
|
DEBUGFS_ADD(tx_bytes);
|
|
|
|
DEBUGFS_ADD(rx_duplicates);
|
|
|
|
DEBUGFS_ADD(rx_fragments);
|
|
|
|
DEBUGFS_ADD(rx_dropped);
|
|
|
|
DEBUGFS_ADD(tx_fragments);
|
|
|
|
DEBUGFS_ADD(tx_filtered);
|
|
|
|
DEBUGFS_ADD(tx_retry_failed);
|
|
|
|
DEBUGFS_ADD(tx_retry_count);
|
|
|
|
DEBUGFS_ADD(last_signal);
|
|
|
|
DEBUGFS_ADD(last_noise);
|
|
|
|
DEBUGFS_ADD(wep_weak_iv_count);
|
2009-11-19 06:26:11 -07:00
|
|
|
DEBUGFS_ADD(ht_capa);
|
2007-05-05 12:46:38 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
void ieee80211_sta_debugfs_remove(struct sta_info *sta)
|
|
|
|
{
|
2009-10-27 05:59:03 -06:00
|
|
|
debugfs_remove_recursive(sta->debugfs.dir);
|
2007-05-05 12:46:38 -06:00
|
|
|
sta->debugfs.dir = NULL;
|
|
|
|
}
|