/***************************************************************************** (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; }