X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fpolicer%2Fxlate.c;h=9c4d76fd9900e6034200285a4165dd917e1780d2;hb=7cd35f5d688d9e3bddf66602655274dae944b086;hp=afc0c05c3760593f17c582c24871c31bbdebc0db;hpb=b7b929931a07fbb27b43d5cd105f366c3e29807e;p=vpp.git diff --git a/src/vnet/policer/xlate.c b/src/vnet/policer/xlate.c index afc0c05c376..9c4d76fd990 100644 --- a/src/vnet/policer/xlate.c +++ b/src/vnet/policer/xlate.c @@ -22,24 +22,14 @@ #include #include -#include -#include - -#define INTERNAL_SS 1 +#include /* debugs */ -#define SSE2_QOS_DEBUG_ERROR(msg, args...) \ - fformat(stderr, msg "\n", ##args); - -#define SSE2_QOS_DEBUG_INFO(msg, args...) \ - fformat(stderr, msg "\n", ##args); - +#define QOS_DEBUG_ERROR(msg, args...) \ + vlib_log_err (vnet_policer_main.log_class, msg, ##args); -#define SSE2_QOS_TR_ERR(TpParms...) -// { -// } - -#define SSE2_QOS_TR_INFO(TpParms...) +#define QOS_DEBUG_INFO(msg, args...) \ + vlib_log_info (vnet_policer_main.log_class, msg, ##args); #ifndef MIN #define MIN(x,y) (((x)<(y))?(x):(y)) @@ -117,78 +107,66 @@ /* End of constants copied from sse_ipe_desc_fmt.h */ /* Misc Policer specific definitions */ -#define SSE2_QOS_POLICER_FIXED_PKT_SIZE 256 +#define QOS_POLICER_FIXED_PKT_SIZE 256 -// TODO check what can be provided by hw macro based on ASIC -#define SSE2_QOS_POL_TICKS_PER_SEC 1000LL /* 1 tick = 1 ms */ +#define QOS_POL_TICKS_PER_SEC 1000LL /* 1 tick = 1 ms */ /* * Default burst, in ms (byte format) */ -#define SSE2_QOS_POL_DEF_BURST_BYTE 100 +#define QOS_POL_DEF_BURST_BYTE 100 /* * Minimum burst needs to be such that the largest packet size is accommodated */ -// Do we need to get it from some lib? -#define SSE2_QOS_POL_MIN_BURST_BYTE 9*1024 - +#define QOS_POL_MIN_BURST_BYTE 9 * 1024 /* * Flag to indicate if AN is employed or not * 1 - TRUE, 0 - FALSE */ -#define SSE2_QOS_POL_ALLOW_NEGATIVE 1 - -// Various Macros to take care of policer calculations - -#define SSE2_QOS_POL_COMM_BKT_MAX \ - (1<> 1)) / denominator); break; - case SSE2_QOS_ROUND_TO_UP: + case QOS_ROUND_TO_UP: *rounded_value = (numerator / denominator); if ((*rounded_value * denominator) < numerator) { @@ -235,35 +211,31 @@ sse2_qos_pol_round (u64 numerator, } break; - case SSE2_QOS_ROUND_TO_DOWN: + case QOS_ROUND_TO_DOWN: *rounded_value = (numerator / denominator); break; - case SSE2_QOS_ROUND_INVALID: + case QOS_ROUND_INVALID: default: - SSE2_QOS_DEBUG_ERROR ("Illegal round type"); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_60, round_type); + QOS_DEBUG_ERROR ("Illegal round type"); rc = EINVAL; break; } return (rc); } - static int -sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st * cfg) +pol_validate_cfg_params (qos_pol_cfg_params_st *cfg) { u64 numer, denom, rnd_value; u32 cir_hw, eir_hw; int rc = 0; - if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) && + if ((cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_2698) && (cfg->rb.kbps.eir_kbps < cfg->rb.kbps.cir_kbps)) { - SSE2_QOS_DEBUG_ERROR ("CIR (%u kbps) is greater than PIR (%u kbps)", - cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_39, cfg->rb.kbps.cir_kbps, - cfg->rb.kbps.eir_kbps); + QOS_DEBUG_ERROR ("CIR (%u kbps) is greater than PIR (%u kbps)", + cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps); return (EINVAL); } @@ -271,45 +243,38 @@ sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st * cfg) * convert rates to bytes-per-tick */ numer = (u64) (cfg->rb.kbps.cir_kbps); - denom = (u64) (8 * SSE2_QOS_POL_TICKS_PER_SEC) / 1000; - rc = sse2_qos_pol_round (numer, denom, &rnd_value, - (sse2_qos_round_type_en) cfg->rnd_type); + denom = (u64) (8 * QOS_POL_TICKS_PER_SEC) / 1000; + rc = qos_pol_round (numer, denom, &rnd_value, cfg->rnd_type); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Unable to convert CIR to bytes/tick format"); - // Error traced + QOS_DEBUG_ERROR ("Unable to convert CIR to bytes/tick format"); return (rc); } cir_hw = (u32) rnd_value; numer = (u64) (cfg->rb.kbps.eir_kbps); - rc = sse2_qos_pol_round (numer, denom, &rnd_value, - (sse2_qos_round_type_en) cfg->rnd_type); + rc = qos_pol_round (numer, denom, &rnd_value, cfg->rnd_type); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Unable to convert EIR to bytes/tick format"); - // Error traced + QOS_DEBUG_ERROR ("Unable to convert EIR to bytes/tick format"); return (rc); } eir_hw = (u32) rnd_value; - if (cir_hw > SSE2_QOS_POL_AVG_RATE_MAX) + if (cir_hw > QOS_POL_AVG_RATE_MAX) { - SSE2_QOS_DEBUG_ERROR ("hw cir (%u bytes/tick) is greater than the " - "max supported value (%u)", cir_hw, - SSE2_QOS_POL_AVG_RATE_MAX); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_84, cir_hw, SSE2_QOS_POL_AVG_RATE_MAX); + QOS_DEBUG_ERROR ("hw cir (%u bytes/tick) is greater than the " + "max supported value (%u)", + cir_hw, QOS_POL_AVG_RATE_MAX); return (EINVAL); } - if (eir_hw > SSE2_QOS_POL_PEAK_RATE_MAX) + if (eir_hw > QOS_POL_PEAK_RATE_MAX) { - SSE2_QOS_DEBUG_ERROR ("hw eir (%u bytes/tick) is greater than the " - "max supported value (%u). Capping it to the max. " - "supported value", eir_hw, - SSE2_QOS_POL_PEAK_RATE_MAX); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_85, eir_hw, - SSE2_QOS_POL_PEAK_RATE_MAX); + QOS_DEBUG_ERROR ("hw eir (%u bytes/tick) is greater than the " + "max supported value (%u). Capping it to the max. " + "supported value", + eir_hw, QOS_POL_PEAK_RATE_MAX); return (EINVAL); } /* @@ -317,32 +282,27 @@ sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st * cfg) */ if ((cfg->rb.kbps.cir_kbps == 0) && cfg->rb.kbps.cb_bytes) { - SSE2_QOS_DEBUG_ERROR ("CIR = 0 with bc != 0"); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_55); + QOS_DEBUG_ERROR ("CIR = 0 with bc != 0"); return (EINVAL); } if ((cfg->rb.kbps.eir_kbps == 0) && - (cfg->rfc > SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)) + (cfg->rfc > QOS_POLICER_TYPE_1R3C_RFC_2697)) { - SSE2_QOS_DEBUG_ERROR ("EIR = 0 for a 2R3C policer (rfc: %u)", cfg->rfc); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_23, cfg->rb.kbps.eir_kbps, cfg->rfc); + QOS_DEBUG_ERROR ("EIR = 0 for a 2R3C policer (rfc: %u)", cfg->rfc); return (EINVAL); } - if (cfg->rb.kbps.eir_kbps && - (cfg->rfc < SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)) + if (cfg->rb.kbps.eir_kbps && (cfg->rfc < QOS_POLICER_TYPE_2R3C_RFC_2698)) { - SSE2_QOS_DEBUG_ERROR ("EIR: %u kbps for a 1-rate policer (rfc: %u)", - cfg->rb.kbps.eir_kbps, cfg->rfc); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_23, cfg->rb.kbps.eir_kbps, cfg->rfc); + QOS_DEBUG_ERROR ("EIR: %u kbps for a 1-rate policer (rfc: %u)", + cfg->rb.kbps.eir_kbps, cfg->rfc); return (EINVAL); } - if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes) + if ((cfg->rfc == QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes) { - SSE2_QOS_DEBUG_ERROR ("For a 1R1B policer, EB burst cannot be > 0"); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_56); + QOS_DEBUG_ERROR ("For a 1R1B policer, EB burst cannot be > 0"); return (EINVAL); } @@ -350,11 +310,9 @@ sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st * cfg) } static void -sse2_qos_convert_value_to_exp_mant_fmt (u64 value, - u16 max_exp_value, - u16 max_mant_value, - sse2_qos_round_type_en type, - u8 * exp, u32 * mant) +qos_convert_value_to_exp_mant_fmt (u64 value, u16 max_exp_value, + u16 max_mant_value, qos_round_type_en type, + u8 *exp, u32 *mant) { u64 rnd_value; u64 temp_mant; @@ -374,8 +332,8 @@ sse2_qos_convert_value_to_exp_mant_fmt (u64 value, temp_exp++; rnd_value = 0; - (void) sse2_qos_pol_round ((u64) value, (u64) (1 << temp_exp), - &rnd_value, type); + (void) qos_pol_round ((u64) value, (u64) (1 << temp_exp), &rnd_value, + type); temp_mant = rnd_value; } @@ -391,14 +349,13 @@ sse2_qos_convert_value_to_exp_mant_fmt (u64 value, *exp = temp_exp; *mant = (u32) temp_mant; - SSE2_QOS_DEBUG_INFO ("value: 0x%llx, mant: %u, exp: %u", value, *mant, - *exp); + QOS_DEBUG_INFO ("value: 0x%llx, mant: %u, exp: %u", value, *mant, *exp); return; } static int -sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, - sse2_qos_pol_hw_params_st * hw) +pol_convert_cfg_rates_to_hw (qos_pol_cfg_params_st *cfg, + qos_pol_hw_params_st *hw) { int rc = 0; u32 cir_hw, eir_hw, hi_mant, hi_rate, cir_rnded, eir_rnded, eir_kbps; @@ -409,16 +366,13 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, * convert rates to bytes-per-tick (tick is 1ms) * For rate conversion, the denominator is gonna be the same */ - denom = (u64) ((SSE2_QOS_POL_TICKS_PER_SEC * 8) / 1000); + denom = (u64) ((QOS_POL_TICKS_PER_SEC * 8) / 1000); numer = (u64) (cfg->rb.kbps.cir_kbps); - rc = sse2_qos_pol_round (numer, denom, &rnd_value, - (sse2_qos_round_type_en) cfg->rnd_type); + rc = qos_pol_round (numer, denom, &rnd_value, cfg->rnd_type); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR - ("Rounding error, rate: %d kbps, rounding_type: %d", - cfg->rb.kbps.cir_kbps, cfg->rnd_type); - // Error is traced + QOS_DEBUG_ERROR ("Rounding error, rate: %d kbps, rounding_type: %d", + cfg->rb.kbps.cir_kbps, cfg->rnd_type); return (rc); } cir_hw = (u32) rnd_value; @@ -431,15 +385,15 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, cir_hw = 1; } - if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) + if (cfg->rfc == QOS_POLICER_TYPE_1R2C) { eir_kbps = 0; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) + else if (cfg->rfc == QOS_POLICER_TYPE_1R3C_RFC_2697) { eir_kbps = cfg->rb.kbps.cir_kbps; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115) + else if (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_4115) { eir_kbps = cfg->rb.kbps.eir_kbps - cfg->rb.kbps.cir_kbps; } @@ -449,14 +403,11 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, } numer = (u64) eir_kbps; - rc = sse2_qos_pol_round (numer, denom, &rnd_value, - (sse2_qos_round_type_en) cfg->rnd_type); + rc = qos_pol_round (numer, denom, &rnd_value, cfg->rnd_type); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR - ("Rounding error, rate: %d kbps, rounding_type: %d", eir_kbps, - cfg->rnd_type); - // Error is traced + QOS_DEBUG_ERROR ("Rounding error, rate: %d kbps, rounding_type: %d", + eir_kbps, cfg->rnd_type); return (rc); } eir_hw = (u32) rnd_value; @@ -469,8 +420,8 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, eir_hw = 1; } - SSE2_QOS_DEBUG_INFO ("cir_hw: %u bytes/tick, eir_hw: %u bytes/tick", cir_hw, - eir_hw); + QOS_DEBUG_INFO ("cir_hw: %u bytes/tick, eir_hw: %u bytes/tick", cir_hw, + eir_hw); if (cir_hw > eir_hw) { @@ -487,40 +438,34 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, * Both the rates are 0. Use exp = 15, and set the RFC to 4115. Also * set AN = 0 */ - exp = (u8) SSE2_QOS_POL_RATE_EXP_MAX; + exp = (u8) QOS_POL_RATE_EXP_MAX; hi_mant = 0; hw->rfc = IPE_RFC_RFC4115; hw->allow_negative = 0; } else { - sse2_qos_convert_value_to_exp_mant_fmt (hi_rate, - (u16) SSE2_QOS_POL_RATE_EXP_MAX, - (u16) - SSE2_QOS_POL_AVG_RATE_MANT_MAX, - (sse2_qos_round_type_en) - cfg->rnd_type, &exp, &hi_mant); + qos_convert_value_to_exp_mant_fmt (hi_rate, (u16) QOS_POL_RATE_EXP_MAX, + (u16) QOS_POL_AVG_RATE_MANT_MAX, + cfg->rnd_type, &exp, &hi_mant); } denom = (1ULL << exp); if (hi_rate == eir_hw) { hw->peak_rate_man = (u16) hi_mant; - rc = sse2_qos_pol_round ((u64) cir_hw, denom, &rnd_value, - (sse2_qos_round_type_en) cfg->rnd_type); + rc = qos_pol_round ((u64) cir_hw, denom, &rnd_value, cfg->rnd_type); hw->avg_rate_man = (u16) rnd_value; } else { hw->avg_rate_man = (u16) hi_mant; - rc = sse2_qos_pol_round ((u64) eir_hw, denom, &rnd_value, - (sse2_qos_round_type_en) cfg->rnd_type); + rc = qos_pol_round ((u64) eir_hw, denom, &rnd_value, cfg->rnd_type); hw->peak_rate_man = (u16) rnd_value; } if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Rounding error"); - // Error is traced + QOS_DEBUG_ERROR ("Rounding error"); return (rc); } hw->rate_exp = exp; @@ -531,8 +476,9 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, * cir was reduced to 0 during rounding. Bump it up */ hw->avg_rate_man = 1; - SSE2_QOS_DEBUG_INFO ("CIR = 0 during rounding. Bump it up to %u " - "bytes/tick", (hw->avg_rate_man << hw->rate_exp)); + QOS_DEBUG_INFO ("CIR = 0 during rounding. Bump it up to %u " + "bytes/tick", + (hw->avg_rate_man << hw->rate_exp)); } if ((hw->peak_rate_man == 0) && eir_kbps) @@ -541,29 +487,30 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, * eir was reduced to 0 during rounding. Bump it up */ hw->peak_rate_man = 1; - SSE2_QOS_DEBUG_INFO ("EIR = 0 during rounding. Bump it up to %u " - "bytes/tick", (hw->peak_rate_man << hw->rate_exp)); + QOS_DEBUG_INFO ("EIR = 0 during rounding. Bump it up to %u " + "bytes/tick", + (hw->peak_rate_man << hw->rate_exp)); } cir_rnded = (hw->avg_rate_man << hw->rate_exp); eir_rnded = (hw->peak_rate_man << hw->rate_exp); - SSE2_QOS_DEBUG_INFO ("Configured(rounded) values, cir: %u " - "kbps (mant: %u, exp: %u, rate: %u bytes/tick)", - cfg->rb.kbps.cir_kbps, hw->avg_rate_man, - hw->rate_exp, cir_rnded); + QOS_DEBUG_INFO ("Configured(rounded) values, cir: %u " + "kbps (mant: %u, exp: %u, rate: %u bytes/tick)", + cfg->rb.kbps.cir_kbps, hw->avg_rate_man, hw->rate_exp, + cir_rnded); - SSE2_QOS_DEBUG_INFO ("Configured(rounded) values, eir: %u " - "kbps (mant: %u, exp: %u, rate: %u bytes/tick)", - cfg->rb.kbps.eir_kbps, hw->peak_rate_man, - hw->rate_exp, eir_rnded); + QOS_DEBUG_INFO ("Configured(rounded) values, eir: %u " + "kbps (mant: %u, exp: %u, rate: %u bytes/tick)", + cfg->rb.kbps.eir_kbps, hw->peak_rate_man, hw->rate_exp, + eir_rnded); return (rc); } /***** * NAME - * sse2_pol_get_bkt_max + * pol_get_bkt_max * * PARAMETERS * rate_hw - either the average rate or peak rate @@ -582,7 +529,7 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg, * bytes based on the rate. *****/ u64 -sse2_pol_get_bkt_max (u64 rate_hw, u64 bkt_max) +pol_get_bkt_max (u64 rate_hw, u64 bkt_max) { if (rate_hw <= RATE64) { @@ -602,7 +549,7 @@ sse2_pol_get_bkt_max (u64 rate_hw, u64 bkt_max) /***** * NAME - * sse2_pol_get_bkt_value + * pol_get_bkt_value * * PARAMETERS * rate_hw - either the average rate or peak rate @@ -620,7 +567,7 @@ sse2_pol_get_bkt_max (u64 rate_hw, u64 bkt_max) * be divided by the units of either 1,2,4,8 bytes based on the rate. *****/ u64 -sse2_pol_get_bkt_value (u64 rate_hw, u64 byte_value) +pol_get_bkt_value (u64 rate_hw, u64 byte_value) { if (rate_hw <= RATE64) { @@ -639,12 +586,9 @@ sse2_pol_get_bkt_value (u64 rate_hw, u64 byte_value) } static void -sse2_pol_rnd_burst_byte_fmt (u64 cfg_burst, - u16 max_exp_value, - u16 max_mant_value, - u32 max_bkt_value, - u32 rate_hw, - u8 * exp, u32 * mant, u32 * bkt_value) +pol_rnd_burst_byte_fmt (u64 cfg_burst, u16 max_exp_value, u16 max_mant_value, + u32 max_bkt_value, u32 rate_hw, u8 *exp, u32 *mant, + u32 *bkt_value) { u64 bkt_max = max_bkt_value; u64 bkt_limit_max; @@ -652,7 +596,7 @@ sse2_pol_rnd_burst_byte_fmt (u64 cfg_burst, u64 temp_bkt_value; bkt_limit_max = ((u64) max_mant_value << (u64) max_exp_value); - bkt_max = sse2_pol_get_bkt_max (rate_hw, bkt_max); + bkt_max = pol_get_bkt_max (rate_hw, bkt_max); bkt_max = MIN (bkt_max, bkt_limit_max); if (!cfg_burst) { @@ -660,47 +604,43 @@ sse2_pol_rnd_burst_byte_fmt (u64 cfg_burst, * If configured burst = 0, compute the burst to be 100ms at a given * rate. Note that for rate_hw = 0, exp = mant = 0. */ - cfg_burst = (u64) rate_hw *(u64) SSE2_QOS_POL_DEF_BURST_BYTE; + cfg_burst = (u64) rate_hw * (u64) QOS_POL_DEF_BURST_BYTE; } if (cfg_burst > bkt_max) { - SSE2_QOS_DEBUG_ERROR ("burst 0x%llx bytes is greater than the max. " - "supported value 0x%llx bytes. Capping it to the " - "max", cfg_burst, bkt_max); - SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_38, - (uint) cfg_burst, (uint) bkt_max); + QOS_DEBUG_ERROR ("burst 0x%llx bytes is greater than the max. " + "supported value 0x%llx bytes. Capping it to the " + "max", + cfg_burst, bkt_max); cfg_burst = bkt_max; } - if (cfg_burst < SSE2_QOS_POL_MIN_BURST_BYTE) + if (cfg_burst < QOS_POL_MIN_BURST_BYTE) { /* * Bump up the burst value ONLY if the cfg_burst is non-zero AND * less than the min. supported value */ - SSE2_QOS_DEBUG_INFO ("burst 0x%llx bytes is less than the min " - "supported value %u bytes. Rounding it up to " - "the min", cfg_burst, SSE2_QOS_POL_MIN_BURST_BYTE); - SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_39, (uint) cfg_burst, - SSE2_QOS_POL_MIN_BURST_BYTE); - cfg_burst = SSE2_QOS_POL_MIN_BURST_BYTE; + QOS_DEBUG_INFO ("burst 0x%llx bytes is less than the min " + "supported value %u bytes. Rounding it up to " + "the min", + cfg_burst, QOS_POL_MIN_BURST_BYTE); + cfg_burst = QOS_POL_MIN_BURST_BYTE; } - sse2_qos_convert_value_to_exp_mant_fmt (cfg_burst, - max_exp_value, - max_mant_value, - SSE2_QOS_ROUND_TO_DOWN, exp, mant); + qos_convert_value_to_exp_mant_fmt (cfg_burst, max_exp_value, max_mant_value, + QOS_ROUND_TO_DOWN, exp, mant); /* Bucket value is based on rate. */ rnd_burst = ((u64) (*mant) << (u64) (*exp)); - temp_bkt_value = sse2_pol_get_bkt_value (rate_hw, rnd_burst); + temp_bkt_value = pol_get_bkt_value (rate_hw, rnd_burst); *bkt_value = (u32) temp_bkt_value; } static int -sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg, - sse2_qos_pol_hw_params_st * hw) +pol_convert_cfg_burst_to_hw (qos_pol_cfg_params_st *cfg, + qos_pol_hw_params_st *hw) { u8 temp_exp; u32 temp_mant, rate_hw; @@ -710,17 +650,16 @@ sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg, /* * compute Committed Burst */ - SSE2_QOS_DEBUG_INFO ("Compute commit burst ..."); + QOS_DEBUG_INFO ("Compute commit burst ..."); rate_hw = (hw->avg_rate_man) << (hw->rate_exp); - sse2_pol_rnd_burst_byte_fmt (cfg->rb.kbps.cb_bytes, - (u16) SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX, - (u16) SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX, - (u32) SSE2_QOS_POL_COMM_BKT_MAX, - rate_hw, &temp_exp, &temp_mant, &bkt_value); - SSE2_QOS_DEBUG_INFO ("Committed burst, burst_limit: 0x%llx mant : %u, " - "exp: %u, rnded: 0x%llx cb:%u bytes", - cfg->rb.kbps.cb_bytes, temp_mant, temp_exp, - ((u64) temp_mant << (u64) temp_exp), bkt_value); + pol_rnd_burst_byte_fmt ( + cfg->rb.kbps.cb_bytes, (u16) QOS_POL_COMM_BKT_LIMIT_EXP_MAX, + (u16) QOS_POL_COMM_BKT_LIMIT_MANT_MAX, (u32) QOS_POL_COMM_BKT_MAX, rate_hw, + &temp_exp, &temp_mant, &bkt_value); + QOS_DEBUG_INFO ("Committed burst, burst_limit: 0x%llx mant : %u, " + "exp: %u, rnded: 0x%llx cb:%u bytes", + cfg->rb.kbps.cb_bytes, temp_mant, temp_exp, + ((u64) temp_mant << (u64) temp_exp), bkt_value); hw->comm_bkt_limit_exp = temp_exp; hw->comm_bkt_limit_man = (u8) temp_mant; @@ -729,33 +668,30 @@ sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg, /* * compute Exceed Burst */ - SSE2_QOS_DEBUG_INFO ("Compute exceed burst ..."); + QOS_DEBUG_INFO ("Compute exceed burst ..."); - if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) + if (cfg->rfc == QOS_POLICER_TYPE_1R2C) { /* * For 1R2C, hw uses 2R3C (RFC-4115). As such, the Exceed Bucket * params are set to 0. Recommendation is to use EB_exp = max_exp (=15) * and EB_mant = 0 */ - hw->extd_bkt_limit_exp = (u8) SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX; + hw->extd_bkt_limit_exp = (u8) QOS_POL_EXTD_BKT_LIMIT_EXP_MAX; hw->extd_bkt_limit_man = 0; - SSE2_QOS_DEBUG_INFO ("Excess burst, burst: 0x%llx mant: %u, " - "exp: %u, rnded: 0x%llx bytes", - cfg->rb.kbps.eb_bytes, hw->extd_bkt_limit_man, - hw->extd_bkt_limit_exp, - ((u64) hw->extd_bkt_limit_man << - (u64) hw->extd_bkt_limit_exp)); - SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_20, (uint) cfg->rb.kbps.eb_bytes, - hw->extd_bkt_limit_man, hw->extd_bkt_limit_exp); + QOS_DEBUG_INFO ( + "Excess burst, burst: 0x%llx mant: %u, " + "exp: %u, rnded: 0x%llx bytes", + cfg->rb.kbps.eb_bytes, hw->extd_bkt_limit_man, hw->extd_bkt_limit_exp, + ((u64) hw->extd_bkt_limit_man << (u64) hw->extd_bkt_limit_exp)); return (0); } - if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) + if (cfg->rfc == QOS_POLICER_TYPE_1R3C_RFC_2697) { eb_bytes = cfg->rb.kbps.cb_bytes + cfg->rb.kbps.eb_bytes; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115) + else if (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_4115) { eb_bytes = cfg->rb.kbps.eb_bytes - cfg->rb.kbps.cb_bytes; } @@ -765,16 +701,15 @@ sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg, } rate_hw = (hw->peak_rate_man) << (hw->rate_exp); - sse2_pol_rnd_burst_byte_fmt (eb_bytes, - (u16) SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX, - (u16) SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX, - (u32) SSE2_QOS_POL_EXTD_BKT_MAX, - rate_hw, &temp_exp, &temp_mant, &bkt_value); + pol_rnd_burst_byte_fmt (eb_bytes, (u16) QOS_POL_EXTD_BKT_LIMIT_EXP_MAX, + (u16) QOS_POL_EXTD_BKT_LIMIT_MANT_MAX, + (u32) QOS_POL_EXTD_BKT_MAX, rate_hw, &temp_exp, + &temp_mant, &bkt_value); - SSE2_QOS_DEBUG_INFO ("Excess burst, burst_limit: 0x%llx mant: %u, " - "exp: %u, rnded: 0x%llx eb:%u bytes", - cfg->rb.kbps.eb_bytes, temp_mant, temp_exp, - ((u64) temp_mant << (u64) temp_exp), bkt_value); + QOS_DEBUG_INFO ("Excess burst, burst_limit: 0x%llx mant: %u, " + "exp: %u, rnded: 0x%llx eb:%u bytes", + cfg->rb.kbps.eb_bytes, temp_mant, temp_exp, + ((u64) temp_mant << (u64) temp_exp), bkt_value); hw->extd_bkt_limit_exp = (u8) temp_exp; hw->extd_bkt_limit_man = (u8) temp_mant; @@ -790,92 +725,77 @@ sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg, * Return: success or failure code. */ static int -sse2_pol_convert_cfg_to_hw_params (sse2_qos_pol_cfg_params_st * cfg, - sse2_qos_pol_hw_params_st * hw) +pol_convert_cfg_to_hw_params (qos_pol_cfg_params_st *cfg, + qos_pol_hw_params_st *hw) { int rc = 0; /* * clear the hw_params */ - clib_memset (hw, 0, sizeof (sse2_qos_pol_hw_params_st)); + clib_memset (hw, 0, sizeof (qos_pol_hw_params_st)); - hw->allow_negative = SSE2_QOS_POL_ALLOW_NEGATIVE; + hw->allow_negative = QOS_POL_ALLOW_NEGATIVE; - if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) || - (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)) + if ((cfg->rfc == QOS_POLICER_TYPE_1R2C) || + (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_4115)) { hw->rfc = IPE_RFC_RFC4115; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) + else if (cfg->rfc == QOS_POLICER_TYPE_1R3C_RFC_2697) { hw->rfc = IPE_RFC_RFC2697; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) + else if (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_2698) { hw->rfc = IPE_RFC_RFC2698; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1) + else if (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1) { hw->rfc = IPE_RFC_MEF5CF1; } else { - SSE2_QOS_DEBUG_ERROR ("Invalid RFC type %d\n", cfg->rfc); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_61, cfg->rfc); + QOS_DEBUG_ERROR ("Invalid RFC type %d\n", cfg->rfc); return (EINVAL); } - rc = sse2_pol_convert_cfg_rates_to_hw (cfg, hw); + rc = pol_convert_cfg_rates_to_hw (cfg, hw); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Unable to convert config rates to hw. Error: %d", - rc); - // Error is traced + QOS_DEBUG_ERROR ("Unable to convert config rates to hw. Error: %d", rc); return (rc); } - rc = sse2_pol_convert_cfg_burst_to_hw (cfg, hw); + rc = pol_convert_cfg_burst_to_hw (cfg, hw); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Unable to convert config burst to hw. Error: %d", - rc); - // Error is traced + QOS_DEBUG_ERROR ("Unable to convert config burst to hw. Error: %d", rc); return (rc); } return 0; } - u32 -sse2_qos_convert_pps_to_kbps (u32 rate_pps) +qos_convert_pps_to_kbps (u32 rate_pps) { - // sse2_qos_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT, - // SSE2_QOS_SHIP_CNT_POL_CONV_PPS_TO_KBPS); - u64 numer, rnd_value = 0; - numer = (u64) ((u64) rate_pps * - (u64) SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL); - (void) sse2_qos_pol_round (numer, 1000LL, &rnd_value, - SSE2_QOS_ROUND_TO_CLOSEST); + numer = (u64) ((u64) rate_pps * (u64) QOS_POLICER_FIXED_PKT_SIZE * 8LL); + (void) qos_pol_round (numer, 1000LL, &rnd_value, QOS_ROUND_TO_CLOSEST); return ((u32) rnd_value); } u32 -sse2_qos_convert_burst_ms_to_bytes (u32 burst_ms, u32 rate_kbps) +qos_convert_burst_ms_to_bytes (u32 burst_ms, u32 rate_kbps) { u64 numer, rnd_value = 0; - //sse2_qos_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT, - // SSE2_QOS_SHIP_CNT_POL_CONV_BURST_MS_TO_BYTES); - numer = (u64) ((u64) burst_ms * (u64) rate_kbps); - (void) sse2_qos_pol_round (numer, 8LL, &rnd_value, - SSE2_QOS_ROUND_TO_CLOSEST); + (void) qos_pol_round (numer, 8LL, &rnd_value, QOS_ROUND_TO_CLOSEST); return ((u32) rnd_value); } @@ -887,26 +807,23 @@ sse2_qos_convert_burst_ms_to_bytes (u32 burst_ms, u32 rate_kbps) * Return: Status, success or failure code. */ int -sse2_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, - sse2_qos_pol_hw_params_st * hw) +pol_compute_hw_params (qos_pol_cfg_params_st *cfg, qos_pol_hw_params_st *hw) { int rc = 0; if (!cfg || !hw) { - SSE2_QOS_DEBUG_ERROR ("Illegal parameters"); + QOS_DEBUG_ERROR ("Illegal parameters"); return (-1); } /* * Validate the police config params being presented to RM */ - rc = sse2_pol_validate_cfg_params (cfg); + rc = pol_validate_cfg_params (cfg); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Config parameter validation failed. Error: %d", - rc); - // Error is traced + QOS_DEBUG_ERROR ("Config parameter validation failed. Error: %d", rc); return (-1); } @@ -914,23 +831,18 @@ sse2_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, * first round configured values to h/w supported values. This func * also determines whether 'tick' or 'byte' format */ - rc = sse2_pol_convert_cfg_to_hw_params (cfg, hw); + rc = pol_convert_cfg_to_hw_params (cfg, hw); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Unable to convert config params to hw params. " - "Error: %d", rc); - SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_53, rc); + QOS_DEBUG_ERROR ("Unable to convert config params to hw params. " + "Error: %d", + rc); return (-1); } return 0; } - -#if defined (INTERNAL_SS) || defined (X86) - -// For initializing the x86 policer format - /* * Return the number of hardware TSC timer ticks per second for the dataplane. * This is approximately, but not exactly, the clock speed. @@ -949,13 +861,17 @@ get_tsc_hz (void) * Return 0 if ok or 1 if error. */ static int -compute_policer_params (u64 hz, // CPU speed in clocks per second - u64 cir_rate, // in bytes per second - u64 pir_rate, // in bytes per second - u32 * current_limit, // in bytes, output may scale the input - u32 * extended_limit, // in bytes, output may scale the input - u32 * cir_bytes_per_period, - u32 * pir_bytes_per_period, u32 * scale) +compute_policer_params (u64 hz, /* CPU speed in clocks per second */ + u64 cir_rate, /* in bytes per second */ + u64 pir_rate, /* in bytes per second */ + u32 *current_limit, /* in bytes, output may scale + * the input + */ + u32 *extended_limit, /* in bytes, output may scale + * the input + */ + u32 *cir_bytes_per_period, u32 *pir_bytes_per_period, + u32 *scale) { double period; double internal_cir_bytes_per_period; @@ -965,22 +881,26 @@ compute_policer_params (u64 hz, // CPU speed in clocks per second u32 scale_amount; u32 __attribute__ ((unused)) orig_current_limit = *current_limit; - // Compute period. For 1Ghz-to-8Ghz CPUs, the period will be in - // the range of 16 to 116 usec. + /* + * Compute period. For 1Ghz-to-8Ghz CPUs, the period will be in + * the range of 16 to 116 usec. + */ period = ((double) hz) / ((double) POLICER_TICKS_PER_PERIOD); - // Determine bytes per period for each rate + /* Determine bytes per period for each rate */ internal_cir_bytes_per_period = (double) cir_rate / period; internal_pir_bytes_per_period = (double) pir_rate / period; - // Scale if possible. Scaling helps rate accuracy, but is constrained - // by the scaled rates and limits fitting in 32-bits. - // In addition, we need to insure the scaled rate is no larger than - // 2^22 tokens per period. This allows the dataplane to ignore overflow - // in the tokens-per-period multiplication since it could only - // happen if the policer were idle for more than a year. - // This is not really a constraint because 100Gbps at 1Ghz is only - // 1.6M tokens per period. + /* + * Scale if possible. Scaling helps rate accuracy, but is constrained + * by the scaled rates and limits fitting in 32-bits. + * In addition, we need to insure the scaled rate is no larger than + * 2^22 tokens per period. This allows the dataplane to ignore overflow + * in the tokens-per-period multiplication since it could only + * happen if the policer were idle for more than a year. + * This is not really a constraint because 100Gbps at 1Ghz is only + * 1.6M tokens per period. + */ #define MAX_RATE_SHIFT 10 max = MAX (*current_limit, *extended_limit); max = MAX (max, (u32) internal_cir_bytes_per_period << MAX_RATE_SHIFT); @@ -990,18 +910,20 @@ compute_policer_params (u64 hz, // CPU speed in clocks per second scale_amount = 1 << scale_shift; *scale = scale_shift; - // Scale the limits + /* Scale the limits */ *current_limit = *current_limit << scale_shift; *extended_limit = *extended_limit << scale_shift; - // Scale the rates + /* Scale the rates */ internal_cir_bytes_per_period = internal_cir_bytes_per_period * ((double) scale_amount); internal_pir_bytes_per_period = internal_pir_bytes_per_period * ((double) scale_amount); - // Make sure the new rates are reasonable - // Only needed for very low rates with large bursts + /* + * Make sure the new rates are reasonable + * Only needed for very low rates with large bursts + */ if (internal_cir_bytes_per_period < 1.0) { internal_cir_bytes_per_period = 1.0; @@ -1014,35 +936,7 @@ compute_policer_params (u64 hz, // CPU speed in clocks per second *cir_bytes_per_period = (u32) internal_cir_bytes_per_period; *pir_bytes_per_period = (u32) internal_pir_bytes_per_period; -// #define PRINT_X86_POLICE_PARAMS -#ifdef PRINT_X86_POLICE_PARAMS - { - u64 effective_BPS; - - // This value actually slightly conservative because it doesn't take into account - // the partial period at the end of a second. This really matters only for very low - // rates. - effective_BPS = - (((u64) (*cir_bytes_per_period * (u64) period)) >> *scale); - - printf ("hz=%llu, cir_rate=%llu, limit=%u => " - "periods-per-sec=%d usec-per-period=%d => " - "scale=%d cir_BPP=%u, scaled_limit=%u => " - "effective BPS=%llu, accuracy=%f\n", - // input values - (unsigned long long) hz, - (unsigned long long) cir_rate, orig_current_limit, - // computed values - (u32) (period), // periods per second - (u32) (1000.0 * 1000.0 / period), // in usec - *scale, *cir_bytes_per_period, *current_limit, - // accuracy - (unsigned long long) effective_BPS, - (double) cir_rate / (double) effective_BPS); - } -#endif - - return 0; // ok + return 0; } @@ -1052,8 +946,7 @@ compute_policer_params (u64 hz, // CPU speed in clocks per second * Return: Status, success or failure code. */ int -x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, - policer_read_response_type_st * hw) +x86_pol_compute_hw_params (qos_pol_cfg_params_st *cfg, policer_t *hw) { const int BYTES_PER_KBIT = (1000 / 8); u64 hz; @@ -1061,15 +954,17 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, if (!cfg || !hw) { - SSE2_QOS_DEBUG_ERROR ("Illegal parameters"); + QOS_DEBUG_ERROR ("Illegal parameters"); return (-1); } hz = get_tsc_hz (); hw->last_update_time = 0; - // Cap the bursts to 32-bits. This allows up to almost one second of - // burst on a 40GE interface, which should be fine for x86. + /* + * Cap the bursts to 32-bits. This allows up to almost one second of + * burst on a 40GE interface, which should be fine for x86. + */ cap = (cfg->rb.kbps.cb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.cb_bytes; hw->current_limit = cap; @@ -1080,23 +975,21 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, if ((cfg->rb.kbps.cir_kbps == 0) && (cfg->rb.kbps.cb_bytes == 0) && (cfg->rb.kbps.eb_bytes == 0)) { - // This is a uninitialized, always-violate policer + /* This is a uninitialized, always-violate policer */ hw->single_rate = 1; hw->cir_tokens_per_period = 0; return 0; } - if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) || - (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)) + if ((cfg->rfc == QOS_POLICER_TYPE_1R2C) || + (cfg->rfc == QOS_POLICER_TYPE_1R3C_RFC_2697)) { - // Single-rate policer - + /* Single-rate policer */ hw->single_rate = 1; - if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes) + if ((cfg->rfc == QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes) { - SSE2_QOS_DEBUG_ERROR - ("Policer parameter validation failed -- 1R2C."); + QOS_DEBUG_ERROR ("Policer parameter validation failed -- 1R2C."); return (-1); } @@ -1104,7 +997,7 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, (cfg->rb.kbps.eir_kbps != 0) || ((cfg->rb.kbps.cb_bytes == 0) && (cfg->rb.kbps.eb_bytes == 0))) { - SSE2_QOS_DEBUG_ERROR ("Policer parameter validation failed -- 1R."); + QOS_DEBUG_ERROR ("Policer parameter validation failed -- 1R."); return (-1); } @@ -1115,21 +1008,20 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, &hw->cir_tokens_per_period, &hw->pir_tokens_per_period, &hw->scale)) { - SSE2_QOS_DEBUG_ERROR ("Policer parameter computation failed."); + QOS_DEBUG_ERROR ("Policer parameter computation failed."); return (-1); } } - else if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) || - (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)) + else if ((cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_2698) || + (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_4115)) { - // Two-rate policer - + /* Two-rate policer */ if ((cfg->rb.kbps.cir_kbps == 0) || (cfg->rb.kbps.eir_kbps == 0) || (cfg->rb.kbps.eir_kbps < cfg->rb.kbps.cir_kbps) || (cfg->rb.kbps.cb_bytes == 0) || (cfg->rb.kbps.eb_bytes == 0)) { - SSE2_QOS_DEBUG_ERROR ("Config parameter validation failed."); + QOS_DEBUG_ERROR ("Config parameter validation failed."); return (-1); } @@ -1142,15 +1034,15 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, &hw->cir_tokens_per_period, &hw->pir_tokens_per_period, &hw->scale)) { - SSE2_QOS_DEBUG_ERROR ("Policer parameter computation failed."); + QOS_DEBUG_ERROR ("Policer parameter computation failed."); return (-1); } } else { - SSE2_QOS_DEBUG_ERROR - ("Config parameter validation failed. RFC not supported"); + QOS_DEBUG_ERROR ( + "Config parameter validation failed. RFC not supported"); return (-1); } @@ -1159,8 +1051,6 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, return 0; } -#endif - /* * Input: configured parameters in 'cfg'. @@ -1168,51 +1058,46 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg, * Return: Status, success or failure code. */ int -sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg, - policer_read_response_type_st * phys) +pol_logical_2_physical (qos_pol_cfg_params_st *cfg, policer_t *phys) { int rc; - sse2_qos_pol_cfg_params_st kbps_cfg; + qos_pol_cfg_params_st kbps_cfg; - clib_memset (phys, 0, sizeof (policer_read_response_type_st)); - clib_memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st)); + clib_memset (phys, 0, sizeof (policer_t)); + clib_memset (&kbps_cfg, 0, sizeof (qos_pol_cfg_params_st)); if (!cfg) { - SSE2_QOS_DEBUG_ERROR ("Illegal parameters"); + QOS_DEBUG_ERROR ("Illegal parameters"); return (-1); } switch (cfg->rate_type) { - case SSE2_QOS_RATE_KBPS: + case QOS_RATE_KBPS: /* copy all the data into kbps_cfg */ kbps_cfg.rb.kbps.cir_kbps = cfg->rb.kbps.cir_kbps; kbps_cfg.rb.kbps.eir_kbps = cfg->rb.kbps.eir_kbps; kbps_cfg.rb.kbps.cb_bytes = cfg->rb.kbps.cb_bytes; kbps_cfg.rb.kbps.eb_bytes = cfg->rb.kbps.eb_bytes; break; - case SSE2_QOS_RATE_PPS: + case QOS_RATE_PPS: kbps_cfg.rb.kbps.cir_kbps = - sse2_qos_convert_pps_to_kbps (cfg->rb.pps.cir_pps); + qos_convert_pps_to_kbps (cfg->rb.pps.cir_pps); kbps_cfg.rb.kbps.eir_kbps = - sse2_qos_convert_pps_to_kbps (cfg->rb.pps.eir_pps); - kbps_cfg.rb.kbps.cb_bytes = sse2_qos_convert_burst_ms_to_bytes ((u32) - cfg-> - rb.pps.cb_ms, - kbps_cfg.rb. - kbps.cir_kbps); - kbps_cfg.rb.kbps.eb_bytes = - sse2_qos_convert_burst_ms_to_bytes ((u32) cfg->rb.pps.eb_ms, - kbps_cfg.rb.kbps.eir_kbps); + qos_convert_pps_to_kbps (cfg->rb.pps.eir_pps); + kbps_cfg.rb.kbps.cb_bytes = qos_convert_burst_ms_to_bytes ( + (u32) cfg->rb.pps.cb_ms, kbps_cfg.rb.kbps.cir_kbps); + kbps_cfg.rb.kbps.eb_bytes = qos_convert_burst_ms_to_bytes ( + (u32) cfg->rb.pps.eb_ms, kbps_cfg.rb.kbps.eir_kbps); break; default: - SSE2_QOS_DEBUG_ERROR ("Illegal rate type"); + QOS_DEBUG_ERROR ("Illegal rate type"); return (-1); } /* rate type is now converted to kbps */ - kbps_cfg.rate_type = SSE2_QOS_RATE_KBPS; + kbps_cfg.rate_type = QOS_RATE_KBPS; kbps_cfg.rnd_type = cfg->rnd_type; kbps_cfg.rfc = cfg->rfc; @@ -1225,40 +1110,11 @@ sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg, phys->color_aware = cfg->color_aware; -#if !defined (INTERNAL_SS) && !defined (X86) - // convert logical into hw params which involves qos calculations - rc = sse2_pol_compute_hw_params (&kbps_cfg, &pol_hw); - if (rc == -1) - { - SSE2_QOS_DEBUG_ERROR ("Unable to compute hw param. Error: %d", rc); - return (rc); - } - - // convert hw params into the physical - phys->rfc = pol_hw.rfc; - phys->an = pol_hw.allow_negative; - phys->rexp = pol_hw.rate_exp; - phys->arm = pol_hw.avg_rate_man; - phys->prm = pol_hw.peak_rate_man; - phys->cble = pol_hw.comm_bkt_limit_exp; - phys->cblm = pol_hw.comm_bkt_limit_man; - phys->eble = pol_hw.extd_bkt_limit_exp; - phys->eblm = pol_hw.extd_bkt_limit_man; - phys->cb = pol_hw.comm_bkt; - phys->eb = pol_hw.extd_bkt; - - /* for debugging purposes, the bucket token values can be overwritten */ - if (cfg->overwrite_bucket) - { - phys->cb = cfg->current_bucket; - phys->eb = cfg->extended_bucket; - } -#else - // convert logical into hw params which involves qos calculations + /* convert logical into hw params which involves qos calculations */ rc = x86_pol_compute_hw_params (&kbps_cfg, phys); if (rc == -1) { - SSE2_QOS_DEBUG_ERROR ("Unable to compute hw param. Error: %d", rc); + QOS_DEBUG_ERROR ("Unable to compute hw param. Error: %d", rc); return (rc); } @@ -1269,30 +1125,13 @@ sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg, phys->extended_bucket = cfg->extended_bucket; } -#endif // if !defined (INTERNAL_SS) && !defined (X86) - return 0; } - static void -sse2_qos_convert_pol_bucket_to_hw_fmt (policer_read_response_type_st * bkt, - sse2_qos_pol_hw_params_st * hw_fmt) +qos_convert_pol_bucket_to_hw_fmt (policer_t *bkt, qos_pol_hw_params_st *hw_fmt) { - clib_memset (hw_fmt, 0, sizeof (sse2_qos_pol_hw_params_st)); -#if !defined (INTERNAL_SS) && !defined (X86) - hw_fmt->rfc = (u8) bkt->rfc; - hw_fmt->allow_negative = (u8) bkt->an; - hw_fmt->rate_exp = (u8) bkt->rexp; - hw_fmt->avg_rate_man = (u16) bkt->arm; - hw_fmt->peak_rate_man = (u16) bkt->prm; - hw_fmt->comm_bkt_limit_man = (u8) bkt->cblm; - hw_fmt->comm_bkt_limit_exp = (u8) bkt->cble; - hw_fmt->extd_bkt_limit_man = (u8) bkt->eblm; - hw_fmt->extd_bkt_limit_exp = (u8) bkt->eble; - hw_fmt->extd_bkt = bkt->eb; - hw_fmt->comm_bkt = bkt->cb; -#endif // if !defined (INTERNAL_SS) && !defined (X86) + clib_memset (hw_fmt, 0, sizeof (qos_pol_hw_params_st)); } /* @@ -1301,8 +1140,8 @@ sse2_qos_convert_pol_bucket_to_hw_fmt (policer_read_response_type_st * bkt, * Return: Status, success or failure code. */ static int -sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw, - sse2_qos_pol_cfg_params_st * cfg) +pol_convert_hw_to_cfg_params (qos_pol_hw_params_st *hw, + qos_pol_cfg_params_st *cfg) { u64 temp_rate; @@ -1317,35 +1156,37 @@ sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw, /* * For a 1R2C, we set EIR = 0, EB = 0 */ - cfg->rfc = SSE2_QOS_POLICER_TYPE_1R2C; + cfg->rfc = QOS_POLICER_TYPE_1R2C; } else if (hw->rfc == IPE_RFC_RFC2697) { - cfg->rfc = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697; + cfg->rfc = QOS_POLICER_TYPE_1R3C_RFC_2697; } else if (hw->rfc == IPE_RFC_RFC2698) { - cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698; + cfg->rfc = QOS_POLICER_TYPE_2R3C_RFC_2698; } else if (hw->rfc == IPE_RFC_RFC4115) { - cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115; + cfg->rfc = QOS_POLICER_TYPE_2R3C_RFC_4115; } else if (hw->rfc == IPE_RFC_MEF5CF1) { - cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1; + cfg->rfc = QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1; } else { return EINVAL; } - temp_rate = (((u64) hw->avg_rate_man << hw->rate_exp) * 8LL * - SSE2_QOS_POL_TICKS_PER_SEC) / 1000; + temp_rate = + (((u64) hw->avg_rate_man << hw->rate_exp) * 8LL * QOS_POL_TICKS_PER_SEC) / + 1000; cfg->rb.kbps.cir_kbps = (u32) temp_rate; - temp_rate = (((u64) hw->peak_rate_man << hw->rate_exp) * 8LL * - SSE2_QOS_POL_TICKS_PER_SEC) / 1000; + temp_rate = + (((u64) hw->peak_rate_man << hw->rate_exp) * 8LL * QOS_POL_TICKS_PER_SEC) / + 1000; cfg->rb.kbps.eir_kbps = (u32) temp_rate; cfg->rb.kbps.cb_bytes = ((u64) hw->comm_bkt_limit_man << @@ -1353,7 +1194,7 @@ sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw, cfg->rb.kbps.eb_bytes = ((u64) hw->extd_bkt_limit_man << (u64) hw->extd_bkt_limit_exp); - if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) + if (cfg->rfc == QOS_POLICER_TYPE_1R3C_RFC_2697) { /* * For 1R3C in the hardware, EB = sum(CB, EB). Also, EIR = CIR. Restore @@ -1362,7 +1203,7 @@ sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw, cfg->rb.kbps.eb_bytes = (cfg->rb.kbps.eb_bytes - cfg->rb.kbps.cb_bytes); cfg->rb.kbps.eir_kbps = 0; } - else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115) + else if (cfg->rfc == QOS_POLICER_TYPE_2R3C_RFC_4115) { /* * For 4115 in the hardware is excess rate and burst, but EA provides @@ -1372,53 +1213,41 @@ sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw, cfg->rb.kbps.eb_bytes += cfg->rb.kbps.cb_bytes; } /* h/w conversion to cfg is in kbps */ - cfg->rate_type = SSE2_QOS_RATE_KBPS; + cfg->rate_type = QOS_RATE_KBPS; cfg->overwrite_bucket = 0; cfg->current_bucket = hw->comm_bkt; cfg->extended_bucket = hw->extd_bkt; - SSE2_QOS_DEBUG_INFO ("configured params, cir: %u kbps, eir: %u kbps, cb " - "burst: 0x%llx bytes, eb burst: 0x%llx bytes", - cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps, - cfg->rb.kbps.cb_bytes, cfg->rb.kbps.eb_bytes); - SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_22, cfg->rb.kbps.cir_kbps, - cfg->rb.kbps.eir_kbps, - (uint) cfg->rb.kbps.cb_bytes, - (uint) cfg->rb.kbps.eb_bytes); + QOS_DEBUG_INFO ("configured params, cir: %u kbps, eir: %u kbps, cb " + "burst: 0x%llx bytes, eb burst: 0x%llx bytes", + cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps, + cfg->rb.kbps.cb_bytes, cfg->rb.kbps.eb_bytes); return 0; } u32 -sse2_qos_convert_kbps_to_pps (u32 rate_kbps) +qos_convert_kbps_to_pps (u32 rate_kbps) { u64 numer, denom, rnd_value = 0; - // sse_qosrm_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT, - // SSE2_QOS_SHIP_CNT_POL_CONV_KBPS_TO_PPS); - numer = (u64) ((u64) rate_kbps * 1000LL); - denom = (u64) ((u64) SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL); + denom = (u64) ((u64) QOS_POLICER_FIXED_PKT_SIZE * 8LL); - (void) sse2_qos_pol_round (numer, denom, &rnd_value, - SSE2_QOS_ROUND_TO_CLOSEST); + (void) qos_pol_round (numer, denom, &rnd_value, QOS_ROUND_TO_CLOSEST); return ((u32) rnd_value); } u32 -sse2_qos_convert_burst_bytes_to_ms (u64 burst_bytes, u32 rate_kbps) +qos_convert_burst_bytes_to_ms (u64 burst_bytes, u32 rate_kbps) { u64 numer, denom, rnd_value = 0; - //sse_qosrm_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT, - // SSE2_QOS_SHIP_CNT_POL_CONV_BYTES_TO_BURST_MS); - numer = burst_bytes * 8LL; denom = (u64) rate_kbps; - (void) sse2_qos_pol_round (numer, denom, &rnd_value, - SSE2_QOS_ROUND_TO_CLOSEST); + (void) qos_pol_round (numer, denom, &rnd_value, QOS_ROUND_TO_CLOSEST); return ((u32) rnd_value); } @@ -1429,56 +1258,54 @@ sse2_qos_convert_burst_bytes_to_ms (u64 burst_bytes, u32 rate_kbps) * Return: Status, success or failure code. */ int -sse2_pol_physical_2_logical (policer_read_response_type_st * phys, - sse2_qos_pol_cfg_params_st * cfg) +pol_physical_2_logical (policer_t *phys, qos_pol_cfg_params_st *cfg) { int rc; - sse2_qos_pol_hw_params_st pol_hw; - sse2_qos_pol_cfg_params_st kbps_cfg; + qos_pol_hw_params_st pol_hw; + qos_pol_cfg_params_st kbps_cfg; - clib_memset (&pol_hw, 0, sizeof (sse2_qos_pol_hw_params_st)); - clib_memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st)); + clib_memset (&pol_hw, 0, sizeof (qos_pol_hw_params_st)); + clib_memset (&kbps_cfg, 0, sizeof (qos_pol_cfg_params_st)); if (!phys) { - SSE2_QOS_DEBUG_ERROR ("Illegal parameters"); + QOS_DEBUG_ERROR ("Illegal parameters"); return (-1); } - sse2_qos_convert_pol_bucket_to_hw_fmt (phys, &pol_hw); + qos_convert_pol_bucket_to_hw_fmt (phys, &pol_hw); - rc = sse2_pol_convert_hw_to_cfg_params (&pol_hw, &kbps_cfg); + rc = pol_convert_hw_to_cfg_params (&pol_hw, &kbps_cfg); if (rc != 0) { - SSE2_QOS_DEBUG_ERROR ("Unable to convert hw params to config params. " - "Error: %d", rc); + QOS_DEBUG_ERROR ("Unable to convert hw params to config params. " + "Error: %d", + rc); return (-1); } /* check what rate type is required */ switch (cfg->rate_type) { - case SSE2_QOS_RATE_KBPS: + case QOS_RATE_KBPS: /* copy all the data into kbps_cfg */ cfg->rb.kbps.cir_kbps = kbps_cfg.rb.kbps.cir_kbps; cfg->rb.kbps.eir_kbps = kbps_cfg.rb.kbps.eir_kbps; cfg->rb.kbps.cb_bytes = kbps_cfg.rb.kbps.cb_bytes; cfg->rb.kbps.eb_bytes = kbps_cfg.rb.kbps.eb_bytes; break; - case SSE2_QOS_RATE_PPS: + case QOS_RATE_PPS: cfg->rb.pps.cir_pps = - sse2_qos_convert_kbps_to_pps (kbps_cfg.rb.kbps.cir_kbps); + qos_convert_kbps_to_pps (kbps_cfg.rb.kbps.cir_kbps); cfg->rb.pps.eir_pps = - sse2_qos_convert_kbps_to_pps (kbps_cfg.rb.kbps.eir_kbps); - cfg->rb.pps.cb_ms = - sse2_qos_convert_burst_bytes_to_ms (kbps_cfg.rb.kbps.cb_bytes, - kbps_cfg.rb.kbps.cir_kbps); - cfg->rb.pps.eb_ms = - sse2_qos_convert_burst_bytes_to_ms (kbps_cfg.rb.kbps.eb_bytes, - kbps_cfg.rb.kbps.eir_kbps); + qos_convert_kbps_to_pps (kbps_cfg.rb.kbps.eir_kbps); + cfg->rb.pps.cb_ms = qos_convert_burst_bytes_to_ms ( + kbps_cfg.rb.kbps.cb_bytes, kbps_cfg.rb.kbps.cir_kbps); + cfg->rb.pps.eb_ms = qos_convert_burst_bytes_to_ms ( + kbps_cfg.rb.kbps.eb_bytes, kbps_cfg.rb.kbps.eir_kbps); break; default: - SSE2_QOS_DEBUG_ERROR ("Illegal rate type"); + QOS_DEBUG_ERROR ("Illegal rate type"); return (-1); }