| /*SH0 |
| ******************************************************************************* |
| ** ** |
| ** Copyright (c) 2012-2013 Quantenna Communications, Inc. ** |
| ** All Rights Reserved ** |
| ** ** |
| ** File : qvsp_data.h ** |
| ** Description : Video Stream Protection ** |
| ** ** |
| ******************************************************************************* |
| EH0*/ |
| |
| #ifndef __QTN_QVSP_DATA_H__ |
| #define __QTN_QVSP_DATA_H__ |
| |
| #include <net80211/_ieee80211.h> |
| #include <qtn/qvsp_common.h> |
| #if defined(__KERNEL__) |
| #include "compat.h" |
| #include <linux/in6.h> |
| #elif defined(MUC_BUILD) |
| #else |
| #include <netinet/in.h> |
| #include <sys/param.h> |
| #define MSEC_PER_SEC 1000L |
| #endif |
| |
| /* |
| * Minimum rate at which to calculate node cost. |
| * If throughput is not sufficiently high, only small aggregates get transmitted which gives an |
| * artificially high and noisy node cost estimate. |
| * The threshold should be lower than QVSP_CFG_STRM_DISABLED_MAX, so that node cost continues to |
| * be updated when streams are disabled. |
| */ |
| #define QVSP_MIN_NODE_KBPS_UPDATE_DFLT 480 |
| #define QVSP_STRM_DISABLED_MAX_DFLT (QVSP_MIN_NODE_KBPS_UPDATE_DFLT + 20) |
| |
| /* Log levels */ |
| #define LL_0 0x00 |
| #define LL_1 0x01 |
| #define LL_2 0x02 |
| #define LL_3 0x03 |
| #define LL_4 0x04 |
| #define LL_5 0x05 |
| #define LL_6 0x06 |
| #define LL_7 0x07 |
| #define LL_8 0x08 |
| #define LL_9 0x09 |
| |
| enum qvsp_ioctl_state { |
| QVSP_STATE_FAT, |
| QVSP_STATE_FAT_AVAIL, |
| QVSP_STATE_FAT_INTF, |
| QVSP_STATE_STRM_TOT, |
| QVSP_STATE_STRM_QTN, |
| QVSP_STATE_STRM_ENA, |
| QVSP_STATE_STRM_DIS, |
| QVSP_STATE_STRM_DMT, |
| QVSP_STATE_READ_MAX, |
| QVSP_STATE_RESET, |
| QVSP_STATE_TEST_FAT, |
| QVSP_STATE_ALL_MAX |
| }; |
| |
| #ifndef DOXYGEN_EXCLUDE |
| |
| /* |
| * Restrictions: |
| * this structure must be kept in sync with qvsp_cfg_params and qvspdoc_enumstr_cfg |
| * _AC[0-3] fields must follow the 'global' equivalent (for macro assumptions) |
| */ |
| enum qvsp_cfg_param_e { |
| QVSP_CFG_ENABLED, |
| QVSP_CFG_ENABLED_ALWAYS, |
| QVSP_CFG_FAT_MIN, |
| QVSP_CFG_FAT_MIN_SOFT, |
| QVSP_CFG_FAT_MIN_SOFT_CONSEC, |
| QVSP_CFG_FAT_MIN_SAFE, |
| QVSP_CFG_FAT_MIN_CHECK_INTV, |
| QVSP_CFG_FAT_MAX_SOFT, |
| QVSP_CFG_FAT_MAX_SOFT_CONSEC, |
| QVSP_CFG_FAT_MAX_SAFE, |
| QVSP_CFG_FAT_MAX_CHECK_INTV, |
| QVSP_CFG_NODE_DATA_MIN, |
| QVSP_CFG_DISABLE_DEMOTE, |
| QVSP_CFG_DISABLE_DEMOTE_FIX_FAT, |
| QVSP_CFG_DISABLE_WAIT, |
| QVSP_CFG_DISABLE_PER_EVENT_MAX, |
| QVSP_CFG_ENABLE_WAIT, |
| QVSP_CFG_ENABLE_PER_EVENT_MAX, |
| QVSP_CFG_STRM_RMT_DIS_TCP, |
| QVSP_CFG_STRM_RMT_DIS_UDP, |
| QVSP_CFG_STRM_TPUT_MIN, |
| QVSP_CFG_STRM_DISABLED_MAX, |
| QVSP_CFG_STRM_ADPT_THROT, |
| QVSP_CFG_STRM_ADPT_THROT_STEP, |
| QVSP_CFG_STRM_ADPT_THROT_MARGIN, |
| QVSP_CFG_STRM_TPUT_SMPL_MIN, |
| QVSP_CFG_STRM_COST_RC_ADJUST, |
| QVSP_CFG_STRM_MAX, |
| QVSP_CFG_STRM_MAX_AC0, |
| QVSP_CFG_STRM_MAX_AC1, |
| QVSP_CFG_STRM_MAX_AC2, |
| QVSP_CFG_STRM_MAX_AC3, |
| QVSP_CFG_STRM_MIN, |
| QVSP_CFG_STRM_MIN_AC0, |
| QVSP_CFG_STRM_MIN_AC1, |
| QVSP_CFG_STRM_MIN_AC2, |
| QVSP_CFG_STRM_MIN_AC3, |
| QVSP_CFG_STRM_TPUT_MAX_TCP, |
| QVSP_CFG_STRM_TPUT_MAX_FIRST = QVSP_CFG_STRM_TPUT_MAX_TCP, |
| QVSP_CFG_STRM_TPUT_MAX_TCP_AC0, |
| QVSP_CFG_STRM_TPUT_MAX_TCP_AC1, |
| QVSP_CFG_STRM_TPUT_MAX_TCP_AC2, |
| QVSP_CFG_STRM_TPUT_MAX_TCP_AC3, |
| QVSP_CFG_STRM_TPUT_MAX_UDP, |
| QVSP_CFG_STRM_TPUT_MAX_UDP_AC0, |
| QVSP_CFG_STRM_TPUT_MAX_UDP_AC1, |
| QVSP_CFG_STRM_TPUT_MAX_UDP_AC2, |
| QVSP_CFG_STRM_TPUT_MAX_UDP_AC3, |
| QVSP_CFG_STRM_TPUT_MAX_LAST = QVSP_CFG_STRM_TPUT_MAX_UDP_AC3, |
| QVSP_CFG_STRM_ENABLE_WAIT, |
| QVSP_CFG_STRM_AGE_MAX, |
| QVSP_CFG_AGE_CHK_INTV, |
| QVSP_CFG_3RDPT_CTL, |
| QVSP_CFG_3RDPT_LOCAL_THROT, |
| QVSP_CFG_3RDPT_QTN, /* treat qtn client as 3rd party client, debug use only */ |
| QVSP_CFG_BA_THROT_INTV, |
| QVSP_CFG_BA_THROT_DUR_MIN, |
| QVSP_CFG_BA_THROT_DUR_STEP, |
| QVSP_CFG_BA_THROT_WINSIZE_MIN, |
| QVSP_CFG_BA_THROT_WINSIZE_MAX, |
| QVSP_CFG_WME_THROT_AC, |
| QVSP_CFG_WME_THROT_AIFSN, |
| QVSP_CFG_WME_THROT_ECWMIN, |
| QVSP_CFG_WME_THROT_ECWMAX, |
| QVSP_CFG_WME_THROT_TXOPLIMIT, |
| QVSP_CFG_WME_THROT_THRSH_DISABLED, |
| QVSP_CFG_WME_THROT_THRSH_VICTIM, |
| QVSP_CFG_EVENT_LOG_LVL, |
| QVSP_CFG_DEBUG_LOG_LVL, |
| QVSP_CFG_MAX, |
| }; |
| |
| struct qvsp_cfg_param { |
| const char *name; |
| const char *desc; |
| const char *units; |
| uint32_t default_val; |
| uint32_t min_val; |
| uint32_t max_val; |
| }; |
| |
| #define QVSP_CFG_PARAMS { \ |
| { "enabled", "QTM enabled", "number", 0, 0, 1}, \ |
| { "enabled_always", "QTM enabled when no QTM peers", "number", 0, 0, 1}, \ |
| { "fat_min", "Min free airtime", "msps", 100, 1, 1000 }, \ |
| { "fat_min_soft", "Soft min free airtime", "msps", 170, 1, 1000 }, \ |
| { "fat_min_soft_consec","Consecutive soft min free airtime", "number", 3, 1, 255 }, \ |
| { "fat_min_safe", "Safe min free airtime", "msps", 200, 1, 1000 }, \ |
| { "fat_min_check_intv", "Oversubscription check interval", "ms", 2000, 100, 60000 },\ |
| { "fat_max_soft", "Soft max free airtime", "msps", 350, 1, 1000 }, \ |
| { "fat_max_soft_consec","Consecutive soft max free airtime", "number", 5, 1, 255 }, \ |
| { "fat_max_safe", "Safe max free airtime", "msps", 250, 1, 1000 }, \ |
| { "fat_max_check_intv", "Undersubscription check interval", "ms", 2000, 100, 86400000 },\ |
| { "node_data_min", "Min data for node cost update", "Kbps", \ |
| QVSP_MIN_NODE_KBPS_UPDATE_DFLT, 1, 10000 },\ |
| { "disable_demote", "Demote stream to disable", "number", 1, 0, 1 }, \ |
| { "disable_demote_fat_fix", "Adjust FAT when demoting streams",\ |
| "number", 0, 0, 1 }, \ |
| { "disable_wait", "Min re-disable wait time", "secs", 3, 1, 86400 },\ |
| { "disable_event_max", "Max streams disabled per event", "number", 1, 1, 256 }, \ |
| { "enable_wait", "Min re-enable wait time", "secs", 15, 1, 86400 },\ |
| { "enable_event_max", "Max streams enabled per event", "number", 1, 1, 256 }, \ |
| { "rmt_disable_tcp", "Disable Rx TCP streams at STA", "number", 1, 0, 1 }, \ |
| { "rmt_disable_udp", "Disable Rx UDP streams at STA", "number", 1, 0, 1 }, \ |
| { "strm_tput_min", "Min throughput for a real stream", "Kbps", 1000, 1, 10000 },\ |
| { "strm_disabled_max", "Max throughput when disabled", "Kbps", \ |
| QVSP_STRM_DISABLED_MAX_DFLT, 20, 10000 },\ |
| { "strm_adpt_throt", "Adaptive throttling enabled", "number", 1, 0, 1 }, \ |
| { "strm_adpt_throt_step", "Adaptive throttling cost step", \ |
| "percent", 40, 1, 100 },\ |
| { "strm_adpt_throt_margin", "Adaptive throttling margin", \ |
| "Kbps", 10000, 0, 100000 },\ |
| { "strm_tput_smpl_min", "Min throughput sampling ms", "ms", 20, 1, 1000 },\ |
| { "strm_cost_rc_adjust","Adjust stream cost for rate change", "number", 1, 0, 1 },\ |
| { "strm_max", "Max streams", "cnt", 256, 1, 256 }, \ |
| { "strm_max_ac0", "Max streams for AC 0", "cnt", 0, 0, 256 }, \ |
| { "strm_max_ac1", "Max streams for AC 1", "cnt", 0, 0, 256 }, \ |
| { "strm_max_ac2", "Max streams for AC 2", "cnt", 0, 0, 256 }, \ |
| { "strm_max_ac3", "Max streams for AC 3", "cnt", 0, 0, 256 }, \ |
| { "strm_min", "Min streams", "cnt", 1, 1, 1000 }, \ |
| { "strm_min_ac0", "Min streams for AC 0", "cnt", 0, 1, 1000 }, \ |
| { "strm_min_ac1", "Min streams for AC 1", "cnt", 0, 1, 1000 }, \ |
| { "strm_min_ac2", "Min streams for AC 2", "cnt", 0, 1, 1000 }, \ |
| { "strm_min_ac3", "Min streams for AC 3", "cnt", 0, 1, 1000 }, \ |
| { "strm_tput_max_tcp", "Max stream throughput for TCP", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_tcp_ac0","Max stream throughput for TCP AC 0", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_tcp_ac1","Max stream throughput for TCP AC 1", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_tcp_ac2","Max stream throughput for TCP AC 2", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_tcp_ac3","Max stream throughput for TCP AC 3", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_udp", "Max stream throughput for UDP", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_udp_ac0","Max stream throughput for UDP AC 0", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_udp_ac1","Max stream throughput for UDP AC 1", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_udp_ac2","Max stream throughput for UDP AC 2", "Mbps", 0, 0, 10000 },\ |
| { "strm_tput_max_udp_ac3","Max stream throughput for UDP AC 3", "Mbps", 0, 0, 10000 },\ |
| { "strm_enable_wait", "Min stream re-enable wait time", "secs", 30, 1, 86400 },\ |
| { "strm_age_max", "Max stream age", "secs", 5, 1, 86400 },\ |
| { "age_check_intv", "Age check interval", "secs", 10, 1, 86400 },\ |
| { "3rd_party_ctl", "Enable 3rd party client control", "number", 0, 0, 1 }, \ |
| { "3rd_party_local_throt", "Throttling 3rd party client packet also in local",\ |
| "number", 0, 0, 1 }, \ |
| { "3rd_party_qtn", "Treat qtn client as 3rd party client", "number", 0, 0, 1 }, \ |
| { "ba_throt_intv", "BA throttling interval", "ms", 1000, 0, 10000 },\ |
| { "ba_throt_dur_min", "BA throttling min duration", "ms", 50, 0, 10000 },\ |
| { "ba_throt_dur_step", "BA throttling duration step", "ms", 100, 50, 10000 },\ |
| { "ba_throt_winsize_min", "BA throttling min winsize", "number", 1, 0, 256 },\ |
| { "ba_throt_winsize_max", "BA throttling max winsize", "number", 16, 1, 256 },\ |
| { "wme_throt_ac", "WME throttling AC bitmap", "number", 3, 0, 15 },\ |
| { "wme_throt_aifsn", "WME throttling AIFSN", "number", 15, 0, 15 },\ |
| { "wme_throt_ecwmin", "WME throttling encoded cwmin", "number", 14, 1, 14 },\ |
| { "wme_throt_ecwmax", "WME throttling encoded cwmax", "number", 15, 1, 15 },\ |
| { "wme_throt_txoplimit","WME throttling TXOP limit", "number", 0, 0, 65535 },\ |
| { "wme_throt_thrsh_disabled", "WME throttling disabled stream cost threshold",\ |
| "number", 150, 0, 1000 },\ |
| { "wme_throt_thrsh_victim", "WME throttling victim stream cost threshold",\ |
| "number", 150, 0, 1000 },\ |
| { "event_level", "Event log level", "number", LL_0, LL_0, LL_9 },\ |
| { "debug_level", "Debug log level", "number", LL_3, LL_0, LL_9 },\ |
| } |
| |
| /* Must be in sync with call_qcsapi_vsp_if_desc */ |
| enum qvsp_if_e { |
| QVSP_IF_ETH_RX, |
| QVSP_IF_QDRV_TX, |
| QVSP_IF_QDRV_RX, |
| QVSP_IF_PCIE_RX, |
| QVSP_IF_MAX |
| }; |
| |
| #define QVSP_IF_DESCS { \ |
| "eth_rx", \ |
| "qdrv_tx", \ |
| "qdrv_rx", \ |
| "pcie_rx", \ |
| "invalid" \ |
| } |
| |
| /* |
| * These must be kept in sync with QVSP_STRM_THROT_DESCS and QVSP_STRM_THROT_DESCS_ABBR. |
| */ |
| enum qvsp_strm_throt_policy { |
| QVSP_STRM_THROT_NONE = 0, |
| QVSP_STRM_THROT_BINARY = 1, |
| QVSP_STRM_THROT_ADPT = 2, |
| QVSP_STRM_THROT_MAX, |
| }; |
| |
| #define QVSP_STRM_THROT_DESCS { \ |
| "None", \ |
| "Binary", \ |
| "Adaptive", \ |
| } |
| |
| #define QVSP_STRM_THROT_DESCS_ABBR { \ |
| "N/A", \ |
| "BIN", \ |
| "ADP", \ |
| } |
| |
| enum qvsp_rule_dir_e { |
| QVSP_RULE_DIR_ANY, |
| QVSP_RULE_DIR_TX, |
| QVSP_RULE_DIR_RX, |
| }; |
| |
| #define QVSP_RULE_DIR_DESCS { \ |
| "Any", \ |
| "Tx", \ |
| "Rx", \ |
| } |
| |
| enum qvsp_rule_param_e { |
| QVSP_RULE_PARAM_DIR, |
| QVSP_RULE_PARAM_VAPPRI, |
| QVSP_RULE_PARAM_AC, |
| QVSP_RULE_PARAM_PROTOCOL, |
| QVSP_RULE_PARAM_TPUT_MIN, |
| QVSP_RULE_PARAM_TPUT_MAX, |
| QVSP_RULE_PARAM_COST_MIN, |
| QVSP_RULE_PARAM_COST_MAX, |
| QVSP_RULE_PARAM_ORDER, |
| QVSP_RULE_PARAM_THROT_POLICY, |
| QVSP_RULE_PARAM_DEMOTE, |
| QVSP_RULE_PARAM_MAX, |
| }; |
| |
| struct qvsp_rule_param { |
| const char *name; |
| const char *desc; |
| const char *units; |
| uint32_t min_val; |
| uint32_t max_val; |
| }; |
| |
| #define QVSP_RULE_PARAMS { \ |
| { "dir", "Direction", "val", 0, 2 }, \ |
| { "vappri", "VAP Priority", "bitmap", 0x1, 0xf }, \ |
| { "ac", "Access Classes", "bitmap", 0x1, 0xf }, \ |
| { "protocol", "IP protocol - TCP(6) or UDP(17)", "val", 6, 17 }, \ |
| { "tp_min", "Min throughput", "Mbps", 1, 10000 }, \ |
| { "tp_max", "Max throughput", "Mbps", 1, 10000 }, \ |
| { "cost_min", "Cost min", "msps", 1, 1000 }, \ |
| { "cost_max", "Cost max", "msps", 1, 1000 }, \ |
| { "order", "Match order", "val", 0, QVSP_RULE_ORDER_MAX - 1 },\ |
| { "throt_policy", "Throttling policy - binary(1) or adaptive(2)", \ |
| "val", 1, QVSP_STRM_THROT_MAX - 1 },\ |
| { "demote", "Demote stream", "val", 0, 1}, \ |
| } |
| |
| /* |
| * These must be kept in sync with QVSP_RULE_ORDER_DESCS and QVSP_RULE_ORDER_DESCS_ABBR. |
| */ |
| enum qvsp_rule_order_e { |
| QVSP_RULE_ORDER_GREATEST_COST_NODE, |
| QVSP_RULE_ORDER_LEAST_COST_NODE, |
| QVSP_RULE_ORDER_GREATEST_NODE_INV_PHY_RATE, |
| QVSP_RULE_ORDER_LEAST_NODE_INV_PHY_RATE, |
| QVSP_RULE_ORDER_GREATEST_COST_STREAM, |
| QVSP_RULE_ORDER_LEAST_COST_STREAM, |
| QVSP_RULE_ORDER_NEWEST, |
| QVSP_RULE_ORDER_OLDEST, |
| QVSP_RULE_ORDER_LOWEST_TPUT, |
| QVSP_RULE_ORDER_HIGHEST_TPUT, |
| QVSP_RULE_ORDER_MAX |
| }; |
| |
| #define QVSP_RULE_ORDER_DESCS { \ |
| "greatest cost node first", \ |
| "least cost node first", \ |
| "greatest inverse PHY rate node first", \ |
| "least inverse PHY rate node first", \ |
| "greatest cost stream first", \ |
| "least cost stream first", \ |
| "newest first", \ |
| "oldest first", \ |
| "lowest throughput first", \ |
| "highest throughput first", \ |
| } |
| |
| #define QVSP_RULE_ORDER_DESCS_ABBR { \ |
| "GCN", \ |
| "LCN", \ |
| "GIPR", \ |
| "LIPR", \ |
| "GCS", \ |
| "LCS", \ |
| "NS", \ |
| "OS", \ |
| "LT", \ |
| "HT", \ |
| } |
| |
| enum qvsp_strm_state_e { |
| QVSP_STRM_STATE_NONE, |
| QVSP_STRM_STATE_DISABLED, |
| QVSP_STRM_STATE_LOW_TPUT, |
| QVSP_STRM_STATE_PRE_ENABLED, |
| QVSP_STRM_STATE_ENABLED, |
| QVSP_STRM_STATE_DELETED, |
| QVSP_STRM_STATE_MAX |
| }; |
| |
| enum qvsp_hairpin_e { |
| QVSP_HAIRPIN_NONE, |
| QVSP_HAIRPIN_UCAST, |
| QVSP_HAIRPIN_MCAST, |
| }; |
| |
| #define QVSP_RULE_DIR_DESCS { \ |
| "Any", \ |
| "Tx", \ |
| "Rx", \ |
| } |
| |
| /* This definition must be kept in sync with the qvsp_ext_s struct */ |
| #define QVSP_INACTIVE_REASON { \ |
| "Config", \ |
| "WDS", \ |
| "CoC" \ |
| } |
| |
| #define QVSP_3RDPT_STR "3" |
| |
| #ifndef MUC_BUILD |
| |
| /** \addtogroup vsp_group |
| * @{ |
| */ |
| |
| /** |
| * Defines a stream based on source and destination |
| */ |
| struct qvsp_hash_flds_ipv4 { |
| /** IP source address */ |
| __be32 saddr; |
| |
| /** IP destination address */ |
| __be32 daddr; |
| |
| /** UDP/TCP source port */ |
| __be16 sport; |
| |
| /** UDP/TCP destination port */ |
| __be16 dport; |
| }; |
| |
| struct qvsp_hash_flds_ipv6 { |
| /** IP source address */ |
| struct in6_addr saddr; |
| |
| /** IP destination address */ |
| struct in6_addr daddr; |
| |
| /** UDP/TCP source port */ |
| __be16 sport; |
| |
| /** UDP/TCP destination port */ |
| __be16 dport; |
| }; |
| |
| union qvsp_hash_flds { |
| struct qvsp_hash_flds_ipv4 ipv4; |
| struct qvsp_hash_flds_ipv6 ipv6; |
| }; |
| |
| /** |
| * Whitelist definition. Passing streams are compared with |
| * the stream defined in 'hflds', ANDed with netmasks |
| */ |
| struct qvsp_wl_flds { |
| union qvsp_hash_flds hflds; |
| |
| /** IP source CIDR bitcount */ |
| uint8_t s_cidr_bits; |
| |
| /** IP destination CIDR bitcount */ |
| uint8_t d_cidr_bits; |
| |
| /** IP version */ |
| uint8_t ip_version; |
| }; |
| |
| /** |
| * IPv4 whitelist tricks for netmask; store netmasks in the hashfield union |
| */ |
| static inline __be32 * qvsp_wl_ipv4_netmask_src(struct qvsp_wl_flds *wl) |
| { |
| struct qvsp_hash_flds_ipv4 *ipv4 = &wl->hflds.ipv4; |
| return (__be32 *)&ipv4[1]; |
| } |
| |
| static inline __be32 * qvsp_wl_ipv4_netmask_dst(struct qvsp_wl_flds *wl) |
| { |
| return &(qvsp_wl_ipv4_netmask_src(wl))[1]; |
| } |
| |
| struct qvsp_rule_flds { |
| uint32_t param[QVSP_RULE_PARAM_MAX]; |
| }; |
| |
| struct qvsp_strm_stats { |
| unsigned long first_ref; |
| uint32_t pkts; |
| uint32_t bytes; |
| uint32_t bytes_sent; |
| uint32_t pkts_sent; |
| }; |
| |
| struct qvsp_stats_if { |
| uint32_t strm_add; |
| uint32_t strm_none; |
| uint32_t pkt_chk; |
| uint32_t pkt_tcp; |
| uint32_t pkt_udp; |
| uint32_t pkt_other; |
| uint32_t pkt_ignore; |
| uint32_t pkt_sent; |
| uint32_t pkt_drop_throttle; |
| uint32_t pkt_drop_disabled; |
| uint32_t pkt_demoted; |
| uint32_t pkt_frag_found; |
| uint32_t pkt_frag_not_found; |
| }; |
| |
| struct qvsp_stats { |
| uint32_t is_qtm; /* 0: VSP or 1: QTM */ |
| uint32_t strm_enable; |
| uint32_t strm_disable; |
| uint32_t strm_disable_remote; |
| uint32_t strm_reenable; |
| uint32_t fat_over; |
| uint32_t fat_under; |
| uint32_t fat_chk_disable; |
| uint32_t fat_chk_reenable; |
| uint32_t fat_chk_squeeze; |
| uint32_t fat_chk_loosen; |
| struct qvsp_stats_if stats_if[QVSP_IF_MAX]; |
| }; |
| |
| /* This structure is being deprecated and replaced with the endian-safe qvsp_strm_entry_s */ |
| struct qvsp_strm_info { |
| union qvsp_hash_flds hash_flds; |
| uint16_t node_idx; |
| uint8_t node_mac[6]; |
| uint8_t vap_pri; |
| uint8_t tid; |
| uint16_t hairpin_id; |
| uint16_t hairpin_type; |
| uint8_t ip_version; |
| uint8_t ip_proto; |
| uint8_t ac_in; |
| uint8_t ac_out; |
| uint8_t strm_state; |
| uint8_t disable_remote; |
| uint8_t is_3rdpt_udp_us; |
| uint16_t last_ref_secs; |
| uint32_t ni_inv_phy_rate; |
| uint32_t phy_rate_disabled; |
| uint32_t bytes_max; |
| uint32_t ni_cost; |
| uint16_t cost_current; |
| uint16_t cost_max; |
| uint8_t hash; |
| uint8_t dir; |
| uint32_t throt_policy; |
| uint32_t throt_rate; |
| uint32_t demote_rule; |
| /* current state, might be different from demote_rule when recovering */ |
| uint32_t demote_state; |
| struct qvsp_strm_stats prev_stats; |
| }; |
| |
| /* Endian-safe version of qvsp_strm_info */ |
| struct qvsp_strm_info_safe { |
| uint16_t node_idx; |
| uint8_t node_mac[6]; |
| uint8_t vap_pri; |
| uint8_t tid; |
| uint16_t hairpin_id; |
| uint16_t hairpin_type; |
| uint8_t ac_in; |
| uint8_t ac_out; |
| uint8_t strm_state; |
| uint8_t disable_remote; |
| uint8_t is_3rdpt_udp_us; |
| uint16_t last_ref_secs; |
| uint32_t ni_inv_phy_rate; |
| uint32_t phy_rate_disabled; |
| uint32_t bytes_max; |
| uint32_t ni_cost; |
| uint16_t cost_current; |
| uint16_t cost_max; |
| uint8_t hash; |
| uint8_t dir; |
| uint32_t throt_policy; |
| uint32_t throt_rate; |
| uint32_t demote_rule; |
| /* current state, might be different from demote_rule when recovering */ |
| uint32_t demote_state; |
| struct qvsp_strm_stats prev_stats; |
| }; |
| |
| #define QVSP_STRM_MAX_ENTRIES 256 |
| struct qvsp_strms { |
| struct qvsp_strm_info_safe strms[QVSP_STRM_MAX_ENTRIES]; |
| }; |
| |
| /** @}*/ |
| |
| #endif /* MUC_BUILD */ |
| |
| /* |
| * Convert kilobits (Kb) to bytes |
| */ |
| static __inline__ uint32_t |
| qvsp_kbit2b(uint32_t kbps) |
| { |
| return kbps * 1000 / NBBY; |
| } |
| |
| /* |
| * Convert bytes to kilobits (Kb) |
| */ |
| static __inline__ uint32_t |
| qvsp_b2kbit(uint32_t bytes) |
| { |
| return bytes * NBBY / 1000; |
| } |
| |
| /* |
| * Convert bytes over an interval into to kilobits per second |
| */ |
| static __inline__ uint32_t |
| qvsp_b2kbitps(uint32_t bytes, unsigned long interval) |
| { |
| /* bytes * NBBY / 1000 / 1000 * interval */ |
| return bytes * NBBY / interval; |
| } |
| |
| /* |
| * Convert bytes to megabits (Mb) |
| */ |
| static __inline__ uint32_t |
| qvsp_b2mbit(uint32_t bytes) |
| { |
| return bytes * NBBY / 1000000; |
| } |
| |
| /* |
| * Convert inverse PHY rate to PHY rate |
| */ |
| static __inline__ uint32_t |
| qvsp_inv2phy(uint32_t inv_phy) |
| { |
| return (inv_phy == 0) ? 0 : (65536 / inv_phy); |
| } |
| |
| /* |
| * Convert faked IP addr to Node/Tid. |
| * @ip is network/big endian. |
| */ |
| static __inline__ void |
| qvsp_fake_ip2nodetid(const uint32_t *ip, uint8_t *node, uint8_t *tid) |
| { |
| *node = ((uint8_t*)ip)[2]; |
| *tid = ((uint8_t*)ip)[3]; |
| } |
| |
| #define QVSP_TID_FAKE_IP_VERSION 4 |
| #define QVSP_TID_FAKE_IP_PROTO IPPROTO_UDP |
| |
| /* |
| * Convert Node/Tid to faked IP addr |
| * Returned IP addr is network/big endian. |
| */ |
| static __inline__ void |
| qvsp_fake_nodetid2ip(uint32_t *ip, const uint8_t node, const uint8_t tid) |
| { |
| ((uint8_t*)ip)[0] = 192; |
| ((uint8_t*)ip)[1] = 168; |
| ((uint8_t*)ip)[2] = node; |
| ((uint8_t*)ip)[3] = tid; |
| } |
| |
| #ifndef NIPQUAD_FMT |
| #define NIPQUAD_FMT "%d.%d.%d.%d" |
| #endif |
| |
| #ifndef NIPQUAD_LEN |
| #define NIPQUAD_LEN 15 |
| #endif |
| |
| #ifndef NIPQUAD |
| #define NIPQUAD(addr) \ |
| ((unsigned char *)&addr)[0], \ |
| ((unsigned char *)&addr)[1], \ |
| ((unsigned char *)&addr)[2], \ |
| ((unsigned char *)&addr)[3] |
| #endif |
| |
| #define QVSP_CFG_SHOW_ANYSTR "Any" |
| |
| #endif /* DOXYGEN_EXCLUDE */ |
| |
| #endif /* __QTN_QVSP_DATA_H__ */ |
| |