- 根目录:
- drivers
- staging
- csr
- csr_wifi_hip_ta_sampling.c
/*****************************************************************************
(c) Cambridge Silicon Radio Limited 2012
All rights reserved and confidential information of CSR
Refer to LICENSE.txt included with this source for details
on the license terms.
*****************************************************************************/
/*
* ---------------------------------------------------------------------------
* FILE: csr_wifi_hip_ta_sampling.c
*
* PURPOSE:
* The traffic analysis sampling module.
* This gathers data which is sent to the SME and used to analyse
* the traffic behaviour.
*
* Provides:
* unifi_ta_sampling_init - Initialise the internal state
* unifi_ta_sample - Sampling function, call this for every data packet
*
* Calls these external functions which must be provided:
* unifi_ta_indicate_sampling - Pass sample data to the SME.
* unifi_ta_indicate_protocol - Report certain data packet types to the SME.
* ---------------------------------------------------------------------------
*/
#include "csr_wifi_hip_card_sdio.h"
/* Maximum number of Tx frames we store each CYCLE_1, for detecting period */
#define TA_MAX_INTERVALS_IN_C1 100
/* Number of intervals in CYCLE_1 (one second), for detecting periodic */
/* Must match size of unifi_TrafficStats.intervals - 1 */
#define TA_INTERVALS_NUM 10
/* Step (in msecs) between intervals, for detecting periodic */
/* We are only interested in periods up to 100ms, i.e. between beacons */
/* This is correct for TA_INTERVALS_NUM=10 */
#define TA_INTERVALS_STEP 10
enum ta_frame_identity
{
TA_FRAME_UNKNOWN,
TA_FRAME_ETHERNET_UNINTERESTING,
TA_FRAME_ETHERNET_INTERESTING
};
#define TA_ETHERNET_TYPE_OFFSET 6
#define TA_LLC_HEADER_SIZE 8
#define TA_IP_TYPE_OFFSET 17
#define TA_UDP_SOURCE_PORT_OFFSET 28
#define TA_UDP_DEST_PORT_OFFSET (TA_UDP_SOURCE_PORT_OFFSET + 2)
#define TA_BOOTP_CLIENT_MAC_ADDR_OFFSET 64
#define TA_DHCP_MESSAGE_TYPE_OFFSET 278
#define TA_DHCP_MESSAGE_TYPE_ACK 0x05
#define TA_PROTO_TYPE_IP 0x0800
#define TA_PROTO_TYPE_EAP 0x888E
#define TA_PROTO_TYPE_WAI 0x8864
#define TA_PROTO_TYPE_ARP 0x0806
#define TA_IP_TYPE_TCP 0x06
#define TA_IP_TYPE_UDP 0x11
#define TA_UDP_PORT_BOOTPC 0x0044
#define TA_UDP_PORT_BOOTPS 0x0043
#define TA_EAPOL_TYPE_OFFSET 9
#define TA_EAPOL_TYPE_START 0x01
#define snap_802_2 0xAAAA0300
#define oui_rfc1042 0x00000000
#define oui_8021h 0x0000f800
static const u8 aironet_snap[5] = { 0x00, 0x40, 0x96, 0x00, 0x00 };
/*
* ---------------------------------------------------------------------------
* ta_detect_protocol
*
* Internal only.
* Detects a specific protocol in a frame and indicates a TA event.
*
* Arguments:
* ta The pointer to the TA module.
* direction The direction of the frame (tx or rx).
* data Pointer to the structure that contains the data.
*
* Returns:
* None
* ---------------------------------------------------------------------------
*/
static enum ta_frame_identity ta_detect_protocol(card_t *card, CsrWifiRouterCtrlProtocolDirection direction,
const bulk_data_desc_t *data,
const u8 *saddr,
const u8 *sta_macaddr)
{
ta_data_t *tad = &card->ta_sampling;
u16 proto;
u16 source_port, dest_port;
CsrWifiMacAddress srcAddress;
u32 snap_hdr, oui_hdr;
if (data->data_length < TA_LLC_HEADER_SIZE)
{
return TA_FRAME_UNKNOWN;
}
snap_hdr = (((u32)data->os_data_ptr[0]) << 24) |
(((u32)data->os_data_ptr[1]) << 16) |
(((u32)data->os_data_ptr[2]) << 8);
if (snap_hdr != snap_802_2)
{
return TA_FRAME_UNKNOWN;
}
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
{
/*
* Here we would use the custom filter to detect interesting frames.
*/
}
oui_hdr = (((u32)data->os_data_ptr[3]) << 24) |
(((u32)data->os_data_ptr[4]) << 16) |
(((u32)data->os_data_ptr[5]) << 8);
if ((oui_hdr == oui_rfc1042) || (oui_hdr == oui_8021h))
{
proto = (data->os_data_ptr[TA_ETHERNET_TYPE_OFFSET] * 256) +
data->os_data_ptr[TA_ETHERNET_TYPE_OFFSET + 1];
/* The only interesting IP frames are the DHCP */
if (proto == TA_PROTO_TYPE_IP)
{
if (data->data_length > TA_IP_TYPE_OFFSET)
{
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
{
ta_l4stats_t *ta_l4stats = &tad->ta_l4stats;
u8 l4proto = data->os_data_ptr[TA_IP_TYPE_OFFSET];
if (l4proto == TA_IP_TYPE_TCP)
{
if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX)
{
ta_l4stats->txTcpBytesCount += data->data_length;
}
else
{
ta_l4stats->rxTcpBytesCount += data->data_length;
}
}
else if (l4proto == TA_IP_TYPE_UDP)
{
if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX)
{
ta_l4stats->txUdpBytesCount += data->data_length;
}
else
{
ta_l4stats->rxUdpBytesCount += data->data_length;
}
}
}
/* detect DHCP frames */
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP)
{
/* DHCP frames are UDP frames with BOOTP ports */
if (data->os_data_ptr[TA_IP_TYPE_OFFSET] == TA_IP_TYPE_UDP)
{
if (data->data_length > TA_UDP_DEST_PORT_OFFSET)
{
source_port = (data->os_data_ptr[TA_UDP_SOURCE_PORT_OFFSET] * 256) +
data->os_data_ptr[TA_UDP_SOURCE_PORT_OFFSET + 1];
dest_port = (data->os_data_ptr[TA_UDP_DEST_PORT_OFFSET] * 256) +
data->os_data_ptr[TA_UDP_DEST_PORT_OFFSET + 1];
if (((source_port == TA_UDP_PORT_BOOTPC) && (dest_port == TA_UDP_PORT_BOOTPS)) ||
((source_port == TA_UDP_PORT_BOOTPS) && (dest_port == TA_UDP_PORT_BOOTPC)))
{
/* The DHCP should have at least a message type (request, ack, nack, etc) */
if (data->data_length > TA_DHCP_MESSAGE_TYPE_OFFSET + 6)
{
UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX)
{
unifi_ta_indicate_protocol(card->ospriv,
CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP,
direction,
&srcAddress);
return TA_FRAME_ETHERNET_UNINTERESTING;
}
/* DHCPACK is a special indication */
if (UNIFI_MAC_ADDRESS_CMP(data->os_data_ptr + TA_BOOTP_CLIENT_MAC_ADDR_OFFSET, sta_macaddr) == TRUE)
{
if (data->os_data_ptr[TA_DHCP_MESSAGE_TYPE_OFFSET] == TA_DHCP_MESSAGE_TYPE_ACK)
{
unifi_ta_indicate_protocol(card->ospriv,
CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP_ACK,
direction,
&srcAddress);
}
else
{
unifi_ta_indicate_protocol(card->ospriv,
CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_DHCP,
direction,
&srcAddress);
}
}
}
}
}
}
}
}
return TA_FRAME_ETHERNET_INTERESTING;
}
/* detect protocol type EAPOL or WAI (treated as equivalent here) */
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL)
{
if (TA_PROTO_TYPE_EAP == proto || TA_PROTO_TYPE_WAI == proto)
{
if ((TA_PROTO_TYPE_WAI == proto) || (direction != CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_TX) ||
(data->os_data_ptr[TA_EAPOL_TYPE_OFFSET] == TA_EAPOL_TYPE_START))
{
UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
unifi_ta_indicate_protocol(card->ospriv,
CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_EAPOL,
direction, &srcAddress);
}
return TA_FRAME_ETHERNET_UNINTERESTING;
}
}
/* detect protocol type 0x0806 (ARP) */
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ARP)
{
if (proto == TA_PROTO_TYPE_ARP)
{
UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
unifi_ta_indicate_protocol(card->ospriv,
CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_ARP,
direction, &srcAddress);
return TA_FRAME_ETHERNET_UNINTERESTING;
}
}
return TA_FRAME_ETHERNET_INTERESTING;
}
else if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_AIRONET)
{
/* detect Aironet frames */
if (!memcmp(data->os_data_ptr + 3, aironet_snap, 5))
{
UNIFI_MAC_ADDRESS_COPY(srcAddress.a, saddr);
unifi_ta_indicate_protocol(card->ospriv, CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_AIRONET,
direction, &srcAddress);
}
}
return TA_FRAME_ETHERNET_UNINTERESTING;
} /* ta_detect_protocol() */
static void tas_reset_data(ta_data_t *tad)
{
s16 i;
for (i = 0; i < (TA_INTERVALS_NUM + 1); i++)
{
tad->stats.intervals[i] = 0;
}
tad->stats.rxFramesNum = 0;
tad->stats.txFramesNum = 0;
tad->stats.rxBytesCount = 0;
tad->stats.txBytesCount = 0;
tad->stats.rxMeanRate = 0;
tad->rx_sum_rate = 0;
tad->ta_l4stats.rxTcpBytesCount = 0;
tad->ta_l4stats.txTcpBytesCount = 0;
tad->ta_l4stats.rxUdpBytesCount = 0;
tad->ta_l4stats.txUdpBytesCount = 0;
} /* tas_reset_data() */
/*
* ---------------------------------------------------------------------------
* API.
* unifi_ta_sampling_init
*
* (Re)Initialise the Traffic Analysis sampling module.
* Resets the counters and timestamps.
*
* Arguments:
* tad Pointer to a ta_data_t structure containing the
* context for this device instance.
* drv_priv An opaque pointer that the TA sampling module will
* pass in call-outs.
*
* Returns:
* None.
* ---------------------------------------------------------------------------
*/
void unifi_ta_sampling_init(card_t *card)
{
(void)unifi_ta_configure(card, CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET, NULL);
card->ta_sampling.packet_filter = CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE;
card->ta_sampling.traffic_type = CSR_WIFI_ROUTER_CTRL_TRAFFIC_TYPE_OCCASIONAL;
} /* unifi_ta_sampling_init() */
/*
* ---------------------------------------------------------------------------
* API.
* unifi_ta_sample
*
* Sample a data frame for the TA module.
* This function stores all the useful information it can extract from
* the frame and detects any specific protocols.
*
* Arguments:
* tad The pointer to the TA sampling context struct.
* direction The direction of the frame (rx, tx)
* data Pointer to the frame data
* saddr Source MAC address of frame.
* timestamp Time (in msecs) that the frame was received.
* rate Reported data rate for the rx frame (0 for tx frames)
*
* Returns:
* None
* ---------------------------------------------------------------------------
*/
void unifi_ta_sample(card_t *card,
CsrWifiRouterCtrlProtocolDirection direction,
const bulk_data_desc_t *data,
const u8 *saddr,
const u8 *sta_macaddr,
u32 timestamp,
u16 rate)
{
ta_data_t *tad = &card->ta_sampling;
enum ta_frame_identity identity;
u32 time_delta;
/* Step1: Check for specific frames */
if (tad->packet_filter != CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_NONE)
{
identity = ta_detect_protocol(card, direction, data, saddr, sta_macaddr);
}
else
{
identity = TA_FRAME_ETHERNET_INTERESTING;
}
/* Step2: Update the information in the current record */
if (direction == CSR_WIFI_ROUTER_CTRL_PROTOCOL_DIRECTION_RX)
{
/* Update the Rx packet count and the throughput count */
tad->stats.rxFramesNum++;
tad->stats.rxBytesCount += data->data_length;
/* Accumulate packet Rx rates for later averaging */
tad->rx_sum_rate += rate;
}
else
{
if (identity == TA_FRAME_ETHERNET_INTERESTING)
{
/*
* Store the period between the last and the current frame.
* There is not point storing more than TA_MAX_INTERVALS_IN_C1 periods,
* the traffic will be bursty or continuous.
*/
if (tad->stats.txFramesNum < TA_MAX_INTERVALS_IN_C1)
{
u32 interval;
u32 index_in_intervals;
interval = timestamp - tad->tx_last_ts;
tad->tx_last_ts = timestamp;
index_in_intervals = (interval + TA_INTERVALS_STEP / 2 - 1) / TA_INTERVALS_STEP;
/* If the interval is interesting, update the t1_intervals count */
if (index_in_intervals <= TA_INTERVALS_NUM)
{
unifi_trace(card->ospriv, UDBG5,
"unifi_ta_sample: TX interval=%d index=%d\n",
interval, index_in_intervals);
tad->stats.intervals[index_in_intervals]++;
}
}
}
/* Update the Tx packet count... */
tad->stats.txFramesNum++;
/* ... and the number of bytes for throughput. */
tad->stats.txBytesCount += data->data_length;
}
/*
* If more than one second has elapsed since the last report, send
* another one.
*/
/* Unsigned subtraction handles wrap-around from 0xFFFFFFFF to 0 */
time_delta = timestamp - tad->last_indication_time;
if (time_delta >= 1000)
{
/*
* rxFramesNum can be flashed in tas_reset_data() by another thread.
* Use a temp to avoid division by zero.
*/
u32 temp_rxFramesNum;
temp_rxFramesNum = tad->stats.rxFramesNum;
/* Calculate this interval's mean frame Rx rate from the sum */
if (temp_rxFramesNum)
{
tad->stats.rxMeanRate = tad->rx_sum_rate / temp_rxFramesNum;
}
unifi_trace(card->ospriv, UDBG5,
"unifi_ta_sample: RX fr=%lu, r=%u, sum=%lu, av=%lu\n",
tad->stats.rxFramesNum, rate,
tad->rx_sum_rate, tad->stats.rxMeanRate);
/*
* Send the information collected in the stats struct
* to the SME and reset the counters.
*/
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
{
u32 rxTcpThroughput = tad->ta_l4stats.rxTcpBytesCount / time_delta;
u32 txTcpThroughput = tad->ta_l4stats.txTcpBytesCount / time_delta;
u32 rxUdpThroughput = tad->ta_l4stats.rxUdpBytesCount / time_delta;
u32 txUdpThroughput = tad->ta_l4stats.txUdpBytesCount / time_delta;
unifi_ta_indicate_l4stats(card->ospriv,
rxTcpThroughput,
txTcpThroughput,
rxUdpThroughput,
txUdpThroughput
);
}
unifi_ta_indicate_sampling(card->ospriv, &tad->stats);
tas_reset_data(tad);
tad->last_indication_time = timestamp;
}
} /* unifi_ta_sample() */
/*
* ---------------------------------------------------------------------------
* External API.
* unifi_ta_configure
*
* Configures the TA module parameters.
*
* Arguments:
* ta The pointer to the TA module.
* config_type The type of the configuration request
* config Pointer to the configuration parameters.
*
* Returns:
* CSR_RESULT_SUCCESS on success, CSR error code otherwise
* ---------------------------------------------------------------------------
*/
CsrResult unifi_ta_configure(card_t *card,
CsrWifiRouterCtrlTrafficConfigType config_type,
const CsrWifiRouterCtrlTrafficConfig *config)
{
ta_data_t *tad = &card->ta_sampling;
/* Reinitialise our data when we are reset */
if (config_type == CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_RESET)
{
/* Reset the stats to zero */
tas_reset_data(tad);
/* Reset the timer variables */
tad->tx_last_ts = 0;
tad->last_indication_time = 0;
return CSR_RESULT_SUCCESS;
}
if (config_type == CSR_WIFI_ROUTER_CTRL_TRAFFIC_CONFIG_TYPE_FILTER)
{
tad->packet_filter = config->packetFilter;
if (tad->packet_filter & CSR_WIFI_ROUTER_CTRL_TRAFFIC_PACKET_TYPE_CUSTOM)
{
tad->custom_filter = config->customFilter;
}
return CSR_RESULT_SUCCESS;
}
return CSR_RESULT_SUCCESS;
} /* unifi_ta_configure() */
/*
* ---------------------------------------------------------------------------
* External API.
* unifi_ta_classification
*
* Configures the current TA classification.
*
* Arguments:
* ta The pointer to the TA module.
* traffic_type The classification type
* period The traffic period if the type is periodic
*
* Returns:
* None
* ---------------------------------------------------------------------------
*/
void unifi_ta_classification(card_t *card,
CsrWifiRouterCtrlTrafficType traffic_type,
u16 period)
{
unifi_trace(card->ospriv, UDBG3,
"Changed current ta classification to: %d\n", traffic_type);
card->ta_sampling.traffic_type = traffic_type;
}