2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
22 #include <vlib/vlib.h>
23 #include <vnet/vnet.h>
25 #include <vnet/policer/xlate.h>
26 #include <vnet/policer/police.h>
31 #define SSE2_QOS_DEBUG_ERROR(msg, args...) \
32 fformat(stderr, msg "\n", ##args);
34 #define SSE2_QOS_DEBUG_INFO(msg, args...) \
35 fformat(stderr, msg "\n", ##args);
38 #define SSE2_QOS_TR_ERR(TpParms...)
42 #define SSE2_QOS_TR_INFO(TpParms...)
45 #define MIN(x,y) (((x)<(y))?(x):(y))
49 #define MAX(x,y) (((x)>(y))?(x):(y))
52 #define IPE_POLICER_FULL_WRITE_REQUEST_M40AH_OFFSET 0
53 #define IPE_POLICER_FULL_WRITE_REQUEST_M40AH_MASK 8
54 #define IPE_POLICER_FULL_WRITE_REQUEST_M40AH_SHIFT 24
56 #define IPE_POLICER_FULL_WRITE_REQUEST_TYPE_OFFSET 2
57 #define IPE_POLICER_FULL_WRITE_REQUEST_TYPE_MASK 2
58 #define IPE_POLICER_FULL_WRITE_REQUEST_TYPE_SHIFT 10
60 #define IPE_POLICER_FULL_WRITE_REQUEST_CMD_OFFSET 3
61 #define IPE_POLICER_FULL_WRITE_REQUEST_CMD_MASK 2
62 #define IPE_POLICER_FULL_WRITE_REQUEST_CMD_SHIFT 0
64 #define IPE_POLICER_FULL_WRITE_REQUEST_M40AL_OFFSET 4
65 #define IPE_POLICER_FULL_WRITE_REQUEST_M40AL_MASK 32
66 #define IPE_POLICER_FULL_WRITE_REQUEST_M40AL_SHIFT 0
68 #define IPE_POLICER_FULL_WRITE_REQUEST_RFC_OFFSET 8
69 #define IPE_POLICER_FULL_WRITE_REQUEST_RFC_MASK 2
70 #define IPE_POLICER_FULL_WRITE_REQUEST_RFC_SHIFT 30
72 #define IPE_POLICER_FULL_WRITE_REQUEST_AN_OFFSET 8
73 #define IPE_POLICER_FULL_WRITE_REQUEST_AN_MASK 1
74 #define IPE_POLICER_FULL_WRITE_REQUEST_AN_SHIFT 29
76 #define IPE_POLICER_FULL_WRITE_REQUEST_REXP_OFFSET 8
77 #define IPE_POLICER_FULL_WRITE_REQUEST_REXP_MASK 4
78 #define IPE_POLICER_FULL_WRITE_REQUEST_REXP_SHIFT 22
80 #define IPE_POLICER_FULL_WRITE_REQUEST_ARM_OFFSET 9
81 #define IPE_POLICER_FULL_WRITE_REQUEST_ARM_MASK 11
82 #define IPE_POLICER_FULL_WRITE_REQUEST_ARM_SHIFT 11
84 #define IPE_POLICER_FULL_WRITE_REQUEST_PRM_OFFSET 10
85 #define IPE_POLICER_FULL_WRITE_REQUEST_PRM_MASK 11
86 #define IPE_POLICER_FULL_WRITE_REQUEST_PRM_SHIFT 0
88 #define IPE_POLICER_FULL_WRITE_REQUEST_CBLE_OFFSET 12
89 #define IPE_POLICER_FULL_WRITE_REQUEST_CBLE_MASK 5
90 #define IPE_POLICER_FULL_WRITE_REQUEST_CBLE_SHIFT 27
92 #define IPE_POLICER_FULL_WRITE_REQUEST_CBLM_OFFSET 12
93 #define IPE_POLICER_FULL_WRITE_REQUEST_CBLM_MASK 7
94 #define IPE_POLICER_FULL_WRITE_REQUEST_CBLM_SHIFT 20
96 #define IPE_POLICER_FULL_WRITE_REQUEST_EBLE_OFFSET 13
97 #define IPE_POLICER_FULL_WRITE_REQUEST_EBLE_MASK 5
98 #define IPE_POLICER_FULL_WRITE_REQUEST_EBLE_SHIFT 15
100 #define IPE_POLICER_FULL_WRITE_REQUEST_EBLM_OFFSET 14
101 #define IPE_POLICER_FULL_WRITE_REQUEST_EBLM_MASK 7
102 #define IPE_POLICER_FULL_WRITE_REQUEST_EBLM_SHIFT 8
104 #define IPE_POLICER_FULL_WRITE_REQUEST_CB_OFFSET 16
105 #define IPE_POLICER_FULL_WRITE_REQUEST_CB_MASK 31
106 #define IPE_POLICER_FULL_WRITE_REQUEST_CB_SHIFT 0
108 #define IPE_POLICER_FULL_WRITE_REQUEST_EB_OFFSET 20
109 #define IPE_POLICER_FULL_WRITE_REQUEST_EB_MASK 31
110 #define IPE_POLICER_FULL_WRITE_REQUEST_EB_SHIFT 0
112 #define IPE_RFC_RFC2697 0x00000000
113 #define IPE_RFC_RFC2698 0x00000001
114 #define IPE_RFC_RFC4115 0x00000002
115 #define IPE_RFC_MEF5CF1 0x00000003
117 /* End of constants copied from sse_ipe_desc_fmt.h */
119 /* Misc Policer specific definitions */
120 #define SSE2_QOS_POLICER_FIXED_PKT_SIZE 256
122 // TODO check what can be provided by hw macro based on ASIC
123 #define SSE2_QOS_POL_TICKS_PER_SEC 1000LL /* 1 tick = 1 ms */
126 * Default burst, in ms (byte format)
128 #define SSE2_QOS_POL_DEF_BURST_BYTE 100
131 * Minimum burst needs to be such that the largest packet size is accommodated
133 // Do we need to get it from some lib?
134 #define SSE2_QOS_POL_MIN_BURST_BYTE 9*1024
138 * Flag to indicate if AN is employed or not
139 * 1 - TRUE, 0 - FALSE
141 #define SSE2_QOS_POL_ALLOW_NEGATIVE 1
143 // Various Macros to take care of policer calculations
145 #define SSE2_QOS_POL_COMM_BKT_MAX \
146 (1<<IPE_POLICER_FULL_WRITE_REQUEST_CB_MASK)
147 #define SSE2_QOS_POL_EXTD_BKT_MAX \
148 (1<<IPE_POLICER_FULL_WRITE_REQUEST_EB_MASK)
150 #define SSE2_QOS_POL_RATE_EXP_SIZE \
151 (IPE_POLICER_FULL_WRITE_REQUEST_REXP_MASK)
152 #define SSE2_QOS_POL_RATE_EXP_MAX ((1<<SSE2_QOS_POL_RATE_EXP_SIZE) - 1)
153 #define SSE2_QOS_POL_AVG_RATE_MANT_SIZE \
154 (IPE_POLICER_FULL_WRITE_REQUEST_ARM_MASK)
155 #define SSE2_QOS_POL_AVG_RATE_MANT_MAX \
156 ((1<< SSE2_QOS_POL_AVG_RATE_MANT_SIZE) - 1)
157 #define SSE2_QOS_POL_AVG_RATE_MAX \
158 (SSE2_QOS_POL_AVG_RATE_MANT_MAX << \
159 SSE2_QOS_POL_RATE_EXP_MAX)
161 #define SSE2_QOS_POL_PEAK_RATE_MANT_SIZE \
162 (IPE_POLICER_FULL_WRITE_REQUEST_PRM_MASK)
163 #define SSE2_QOS_POL_PEAK_RATE_MANT_MAX \
164 ((1<<SSE2_QOS_POL_PEAK_RATE_MANT_SIZE) - 1)
165 #define SSE2_QOS_POL_PEAK_RATE_MAX \
166 (SSE2_QOS_POL_PEAK_RATE_MANT_MAX << \
167 SSE2_QOS_POL_RATE_EXP_MAX)
169 #define SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_SIZE \
170 (IPE_POLICER_FULL_WRITE_REQUEST_CBLM_MASK)
171 #define SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX \
172 ((1<<SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_SIZE) - 1)
173 #define SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_SIZE \
174 (IPE_POLICER_FULL_WRITE_REQUEST_CBLE_MASK)
175 #define SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX \
176 ((1<<SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_SIZE) - 1)
177 #define SSE2_QOS_POL_COMM_BKT_LIMIT_MAX \
178 ((u64)SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX << \
179 (u64)SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX)
181 #define SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_SIZE \
182 (IPE_POLICER_FULL_WRITE_REQUEST_EBLM_MASK)
183 #define SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX \
184 ((1<<SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_SIZE) - 1)
185 #define SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_SIZE \
186 (IPE_POLICER_FULL_WRITE_REQUEST_EBLE_MASK)
187 #define SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX \
188 ((1<<SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_SIZE) - 1)
189 #define SSE2_QOS_POL_EXT_BKT_LIMIT_MAX \
190 ((u64)SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX << \
191 (u64)SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX)
194 * Rates determine the units of the bucket
195 * 256.114688 Gbps < Rate 8 byte units
196 * 128.057344 Gbps < Rate <= 256.114688 Gbps 4 byte units
197 * 64.028672 Gbps < Rate <= 128.057344 Gbps 2 byte units
198 * Rate <= 64.028672 Gbps 1 byte units
200 * The code uses bytes per tick as oppose to Gigabits per second.
202 #define RATE256 (256114688000LL / 8LL / SSE2_QOS_POL_TICKS_PER_SEC)
203 #define RATE128 (128057344000LL / 8LL / SSE2_QOS_POL_TICKS_PER_SEC)
204 #define RATE64 ( 64028672000LL / 8LL / SSE2_QOS_POL_TICKS_PER_SEC)
206 #define RATE_OVER256_UNIT 8LL
207 #define RATE_128TO256_UNIT 4LL
208 #define RATE_64TO128_UNIT 2LL
211 sse2_qos_pol_round (u64 numerator,
213 u64 * rounded_value, sse2_qos_round_type_en round_type)
217 if (denominator == 0)
219 SSE2_QOS_DEBUG_ERROR ("Illegal denominator");
220 SSE2_QOS_TR_ERR (SSE2_QOSRM_TP_ERR_59);
226 case SSE2_QOS_ROUND_TO_CLOSEST:
227 *rounded_value = ((numerator + (denominator >> 1)) / denominator);
230 case SSE2_QOS_ROUND_TO_UP:
231 *rounded_value = (numerator / denominator);
232 if ((*rounded_value * denominator) < numerator)
238 case SSE2_QOS_ROUND_TO_DOWN:
239 *rounded_value = (numerator / denominator);
242 case SSE2_QOS_ROUND_INVALID:
244 SSE2_QOS_DEBUG_ERROR ("Illegal round type");
245 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_60, round_type);
254 sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st * cfg)
256 u64 numer, denom, rnd_value;
260 if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) &&
261 (cfg->rb.kbps.eir_kbps < cfg->rb.kbps.cir_kbps))
263 SSE2_QOS_DEBUG_ERROR ("CIR (%u kbps) is greater than PIR (%u kbps)",
264 cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps);
265 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_39, cfg->rb.kbps.cir_kbps,
266 cfg->rb.kbps.eir_kbps);
271 * convert rates to bytes-per-tick
273 numer = (u64) (cfg->rb.kbps.cir_kbps);
274 denom = (u64) (8 * SSE2_QOS_POL_TICKS_PER_SEC) / 1000;
275 rc = sse2_qos_pol_round (numer, denom, &rnd_value,
276 (sse2_qos_round_type_en) cfg->rnd_type);
279 SSE2_QOS_DEBUG_ERROR ("Unable to convert CIR to bytes/tick format");
283 cir_hw = (u32) rnd_value;
285 numer = (u64) (cfg->rb.kbps.eir_kbps);
286 rc = sse2_qos_pol_round (numer, denom, &rnd_value,
287 (sse2_qos_round_type_en) cfg->rnd_type);
290 SSE2_QOS_DEBUG_ERROR ("Unable to convert EIR to bytes/tick format");
294 eir_hw = (u32) rnd_value;
296 if (cir_hw > SSE2_QOS_POL_AVG_RATE_MAX)
298 SSE2_QOS_DEBUG_ERROR ("hw cir (%u bytes/tick) is greater than the "
299 "max supported value (%u)", cir_hw,
300 SSE2_QOS_POL_AVG_RATE_MAX);
301 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_84, cir_hw, SSE2_QOS_POL_AVG_RATE_MAX);
305 if (eir_hw > SSE2_QOS_POL_PEAK_RATE_MAX)
307 SSE2_QOS_DEBUG_ERROR ("hw eir (%u bytes/tick) is greater than the "
308 "max supported value (%u). Capping it to the max. "
309 "supported value", eir_hw,
310 SSE2_QOS_POL_PEAK_RATE_MAX);
311 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_85, eir_hw,
312 SSE2_QOS_POL_PEAK_RATE_MAX);
316 * CIR = 0, with bc != 0 is not allowed
318 if ((cfg->rb.kbps.cir_kbps == 0) && cfg->rb.kbps.cb_bytes)
320 SSE2_QOS_DEBUG_ERROR ("CIR = 0 with bc != 0");
321 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_55);
325 if ((cfg->rb.kbps.eir_kbps == 0) &&
326 (cfg->rfc > SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697))
328 SSE2_QOS_DEBUG_ERROR ("EIR = 0 for a 2R3C policer (rfc: %u)", cfg->rfc);
329 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_23, cfg->rb.kbps.eir_kbps, cfg->rfc);
333 if (cfg->rb.kbps.eir_kbps &&
334 (cfg->rfc < SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698))
336 SSE2_QOS_DEBUG_ERROR ("EIR: %u kbps for a 1-rate policer (rfc: %u)",
337 cfg->rb.kbps.eir_kbps, cfg->rfc);
338 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_23, cfg->rb.kbps.eir_kbps, cfg->rfc);
342 if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes)
344 SSE2_QOS_DEBUG_ERROR ("For a 1R1B policer, EB burst cannot be > 0");
345 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_56);
353 sse2_qos_convert_value_to_exp_mant_fmt (u64 value,
356 sse2_qos_round_type_en type,
357 u8 * exp, u32 * mant)
364 * Select the lowest possible exp, and the largest possible mant
368 while (temp_exp <= max_exp_value)
370 if (temp_mant <= max_mant_value)
377 (void) sse2_qos_pol_round ((u64) value, (u64) (1 << temp_exp),
379 temp_mant = rnd_value;
382 if (temp_exp > max_exp_value)
385 * CAP mant to its max value, and decrement exp
388 temp_mant = max_mant_value;
392 *mant = (u32) temp_mant;
394 SSE2_QOS_DEBUG_INFO ("value: 0x%llx, mant: %u, exp: %u", value, *mant,
400 sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg,
401 sse2_qos_pol_hw_params_st * hw)
404 u32 cir_hw, eir_hw, hi_mant, hi_rate, cir_rnded, eir_rnded, eir_kbps;
405 u64 numer, denom, rnd_value;
409 * convert rates to bytes-per-tick (tick is 1ms)
410 * For rate conversion, the denominator is gonna be the same
412 denom = (u64) ((SSE2_QOS_POL_TICKS_PER_SEC * 8) / 1000);
413 numer = (u64) (cfg->rb.kbps.cir_kbps);
414 rc = sse2_qos_pol_round (numer, denom, &rnd_value,
415 (sse2_qos_round_type_en) cfg->rnd_type);
419 ("Rounding error, rate: %d kbps, rounding_type: %d",
420 cfg->rb.kbps.cir_kbps, cfg->rnd_type);
424 cir_hw = (u32) rnd_value;
426 if (cfg->rb.kbps.cir_kbps && (cir_hw == 0))
429 * After rounding, cir_hw = 0. Bump it up
434 if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C)
438 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
440 eir_kbps = cfg->rb.kbps.cir_kbps;
442 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
444 eir_kbps = cfg->rb.kbps.eir_kbps - cfg->rb.kbps.cir_kbps;
448 eir_kbps = cfg->rb.kbps.eir_kbps;
451 numer = (u64) eir_kbps;
452 rc = sse2_qos_pol_round (numer, denom, &rnd_value,
453 (sse2_qos_round_type_en) cfg->rnd_type);
457 ("Rounding error, rate: %d kbps, rounding_type: %d", eir_kbps,
462 eir_hw = (u32) rnd_value;
464 if (eir_kbps && (eir_hw == 0))
467 * After rounding, eir_hw = 0. Bump it up
472 SSE2_QOS_DEBUG_INFO ("cir_hw: %u bytes/tick, eir_hw: %u bytes/tick", cir_hw,
484 if ((cir_hw == 0) && (eir_hw == 0))
487 * Both the rates are 0. Use exp = 15, and set the RFC to 4115. Also
490 exp = (u8) SSE2_QOS_POL_RATE_EXP_MAX;
492 hw->rfc = IPE_RFC_RFC4115;
493 hw->allow_negative = 0;
497 sse2_qos_convert_value_to_exp_mant_fmt (hi_rate,
498 (u16) SSE2_QOS_POL_RATE_EXP_MAX,
500 SSE2_QOS_POL_AVG_RATE_MANT_MAX,
501 (sse2_qos_round_type_en)
502 cfg->rnd_type, &exp, &hi_mant);
505 denom = (1ULL << exp);
506 if (hi_rate == eir_hw)
508 hw->peak_rate_man = (u16) hi_mant;
509 rc = sse2_qos_pol_round ((u64) cir_hw, denom, &rnd_value,
510 (sse2_qos_round_type_en) cfg->rnd_type);
511 hw->avg_rate_man = (u16) rnd_value;
515 hw->avg_rate_man = (u16) hi_mant;
516 rc = sse2_qos_pol_round ((u64) eir_hw, denom, &rnd_value,
517 (sse2_qos_round_type_en) cfg->rnd_type);
518 hw->peak_rate_man = (u16) rnd_value;
522 SSE2_QOS_DEBUG_ERROR ("Rounding error");
528 if ((hw->avg_rate_man == 0) && (cfg->rb.kbps.cir_kbps))
531 * cir was reduced to 0 during rounding. Bump it up
533 hw->avg_rate_man = 1;
534 SSE2_QOS_DEBUG_INFO ("CIR = 0 during rounding. Bump it up to %u "
535 "bytes/tick", (hw->avg_rate_man << hw->rate_exp));
538 if ((hw->peak_rate_man == 0) && eir_kbps)
541 * eir was reduced to 0 during rounding. Bump it up
543 hw->peak_rate_man = 1;
544 SSE2_QOS_DEBUG_INFO ("EIR = 0 during rounding. Bump it up to %u "
545 "bytes/tick", (hw->peak_rate_man << hw->rate_exp));
548 cir_rnded = (hw->avg_rate_man << hw->rate_exp);
549 eir_rnded = (hw->peak_rate_man << hw->rate_exp);
551 SSE2_QOS_DEBUG_INFO ("Configured(rounded) values, cir: %u "
552 "kbps (mant: %u, exp: %u, rate: %u bytes/tick)",
553 cfg->rb.kbps.cir_kbps, hw->avg_rate_man,
554 hw->rate_exp, cir_rnded);
556 SSE2_QOS_DEBUG_INFO ("Configured(rounded) values, eir: %u "
557 "kbps (mant: %u, exp: %u, rate: %u bytes/tick)",
558 cfg->rb.kbps.eir_kbps, hw->peak_rate_man,
559 hw->rate_exp, eir_rnded);
566 * sse2_pol_get_bkt_max
569 * rate_hw - either the average rate or peak rate
570 * bkt_max - bit width in the current bucket or extended bucket
573 * u64 - maximum token bytes for the current or extended bucket
576 * The current bucket or extended bucket fields are in units of either
577 * 1,2,4,8 bytes based on the average or peak rate respective to current
578 * or extended bucket.
580 * To get the actual maximum number of bytes that can be stored in the
581 * field, the value must be multiplied by the units of either 1,2,4,8
582 * bytes based on the rate.
585 sse2_pol_get_bkt_max (u64 rate_hw, u64 bkt_max)
587 if (rate_hw <= RATE64)
589 return (bkt_max - 1);
591 else if (rate_hw <= RATE128)
593 return ((bkt_max * RATE_64TO128_UNIT) - RATE_64TO128_UNIT);
595 else if (rate_hw <= RATE256)
597 return ((bkt_max * RATE_128TO256_UNIT) - RATE_128TO256_UNIT);
599 /* rate must be over 256 */
600 return ((bkt_max * RATE_OVER256_UNIT) - RATE_OVER256_UNIT);
605 * sse2_pol_get_bkt_value
608 * rate_hw - either the average rate or peak rate
609 * byte_value - bytes for this token bucket
612 * u64 - unit value for the current or extended bucket field
615 * The current bucket or extended bucket fields are in units of either
616 * 1,2,4,8 bytes based on the average or peak rate respective to current
617 * or extended bucket.
619 * To get the units that can be stored in the field, the byte value must
620 * be divided by the units of either 1,2,4,8 bytes based on the rate.
623 sse2_pol_get_bkt_value (u64 rate_hw, u64 byte_value)
625 if (rate_hw <= RATE64)
629 else if (rate_hw <= RATE128)
631 return (byte_value / RATE_64TO128_UNIT);
633 else if (rate_hw <= RATE256)
635 return (byte_value / RATE_128TO256_UNIT);
637 /* rate must be over 256 */
638 return (byte_value / RATE_OVER256_UNIT);
642 sse2_pol_rnd_burst_byte_fmt (u64 cfg_burst,
647 u8 * exp, u32 * mant, u32 * bkt_value)
649 u64 bkt_max = max_bkt_value;
654 bkt_limit_max = ((u64) max_mant_value << (u64) max_exp_value);
655 bkt_max = sse2_pol_get_bkt_max (rate_hw, bkt_max);
656 bkt_max = MIN (bkt_max, bkt_limit_max);
660 * If configured burst = 0, compute the burst to be 100ms at a given
661 * rate. Note that for rate_hw = 0, exp = mant = 0.
663 cfg_burst = (u64) rate_hw *(u64) SSE2_QOS_POL_DEF_BURST_BYTE;
666 if (cfg_burst > bkt_max)
668 SSE2_QOS_DEBUG_ERROR ("burst 0x%llx bytes is greater than the max. "
669 "supported value 0x%llx bytes. Capping it to the "
670 "max", cfg_burst, bkt_max);
671 SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_38,
672 (uint) cfg_burst, (uint) bkt_max);
676 if (cfg_burst < SSE2_QOS_POL_MIN_BURST_BYTE)
679 * Bump up the burst value ONLY if the cfg_burst is non-zero AND
680 * less than the min. supported value
682 SSE2_QOS_DEBUG_INFO ("burst 0x%llx bytes is less than the min "
683 "supported value %u bytes. Rounding it up to "
684 "the min", cfg_burst, SSE2_QOS_POL_MIN_BURST_BYTE);
685 SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_39, (uint) cfg_burst,
686 SSE2_QOS_POL_MIN_BURST_BYTE);
687 cfg_burst = SSE2_QOS_POL_MIN_BURST_BYTE;
690 sse2_qos_convert_value_to_exp_mant_fmt (cfg_burst,
693 SSE2_QOS_ROUND_TO_DOWN, exp, mant);
695 /* Bucket value is based on rate. */
696 rnd_burst = ((u64) (*mant) << (u64) (*exp));
697 temp_bkt_value = sse2_pol_get_bkt_value (rate_hw, rnd_burst);
698 *bkt_value = (u32) temp_bkt_value;
702 sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg,
703 sse2_qos_pol_hw_params_st * hw)
706 u32 temp_mant, rate_hw;
711 * compute Committed Burst
713 SSE2_QOS_DEBUG_INFO ("Compute commit burst ...");
714 rate_hw = (hw->avg_rate_man) << (hw->rate_exp);
715 sse2_pol_rnd_burst_byte_fmt (cfg->rb.kbps.cb_bytes,
716 (u16) SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX,
717 (u16) SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX,
718 (u32) SSE2_QOS_POL_COMM_BKT_MAX,
719 rate_hw, &temp_exp, &temp_mant, &bkt_value);
720 SSE2_QOS_DEBUG_INFO ("Committed burst, burst_limit: 0x%llx mant : %u, "
721 "exp: %u, rnded: 0x%llx cb:%u bytes",
722 cfg->rb.kbps.cb_bytes, temp_mant, temp_exp,
723 ((u64) temp_mant << (u64) temp_exp), bkt_value);
725 hw->comm_bkt_limit_exp = temp_exp;
726 hw->comm_bkt_limit_man = (u8) temp_mant;
727 hw->comm_bkt = bkt_value;
730 * compute Exceed Burst
732 SSE2_QOS_DEBUG_INFO ("Compute exceed burst ...");
734 if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C)
737 * For 1R2C, hw uses 2R3C (RFC-4115). As such, the Exceed Bucket
738 * params are set to 0. Recommendation is to use EB_exp = max_exp (=15)
741 hw->extd_bkt_limit_exp = (u8) SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX;
742 hw->extd_bkt_limit_man = 0;
743 SSE2_QOS_DEBUG_INFO ("Excess burst, burst: 0x%llx mant: %u, "
744 "exp: %u, rnded: 0x%llx bytes",
745 cfg->rb.kbps.eb_bytes, hw->extd_bkt_limit_man,
746 hw->extd_bkt_limit_exp,
747 ((u64) hw->extd_bkt_limit_man <<
748 (u64) hw->extd_bkt_limit_exp));
749 SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_20, (uint) cfg->rb.kbps.eb_bytes,
750 hw->extd_bkt_limit_man, hw->extd_bkt_limit_exp);
754 if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
756 eb_bytes = cfg->rb.kbps.cb_bytes + cfg->rb.kbps.eb_bytes;
758 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
760 eb_bytes = cfg->rb.kbps.eb_bytes - cfg->rb.kbps.cb_bytes;
764 eb_bytes = cfg->rb.kbps.eb_bytes;
767 rate_hw = (hw->peak_rate_man) << (hw->rate_exp);
768 sse2_pol_rnd_burst_byte_fmt (eb_bytes,
769 (u16) SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX,
770 (u16) SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX,
771 (u32) SSE2_QOS_POL_EXTD_BKT_MAX,
772 rate_hw, &temp_exp, &temp_mant, &bkt_value);
774 SSE2_QOS_DEBUG_INFO ("Excess burst, burst_limit: 0x%llx mant: %u, "
775 "exp: %u, rnded: 0x%llx eb:%u bytes",
776 cfg->rb.kbps.eb_bytes, temp_mant, temp_exp,
777 ((u64) temp_mant << (u64) temp_exp), bkt_value);
779 hw->extd_bkt_limit_exp = (u8) temp_exp;
780 hw->extd_bkt_limit_man = (u8) temp_mant;
781 hw->extd_bkt = bkt_value;
788 * Input: configured parameter values in 'cfg'.
789 * Output: h/w programmable parameter values in 'hw'.
790 * Return: success or failure code.
793 sse2_pol_convert_cfg_to_hw_params (sse2_qos_pol_cfg_params_st * cfg,
794 sse2_qos_pol_hw_params_st * hw)
799 * clear the hw_params
801 memset (hw, 0, sizeof (sse2_qos_pol_hw_params_st));
803 hw->allow_negative = SSE2_QOS_POL_ALLOW_NEGATIVE;
805 if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) ||
806 (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115))
808 hw->rfc = IPE_RFC_RFC4115;
810 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
812 hw->rfc = IPE_RFC_RFC2697;
814 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
816 hw->rfc = IPE_RFC_RFC2698;
818 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1)
820 hw->rfc = IPE_RFC_MEF5CF1;
824 SSE2_QOS_DEBUG_ERROR ("Invalid RFC type %d\n", cfg->rfc);
825 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_61, cfg->rfc);
829 rc = sse2_pol_convert_cfg_rates_to_hw (cfg, hw);
832 SSE2_QOS_DEBUG_ERROR ("Unable to convert config rates to hw. Error: %d",
838 rc = sse2_pol_convert_cfg_burst_to_hw (cfg, hw);
841 SSE2_QOS_DEBUG_ERROR ("Unable to convert config burst to hw. Error: %d",
852 sse2_qos_convert_pps_to_kbps (u32 rate_pps)
854 // sse2_qos_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
855 // SSE2_QOS_SHIP_CNT_POL_CONV_PPS_TO_KBPS);
857 u64 numer, rnd_value = 0;
859 numer = (u64) ((u64) rate_pps *
860 (u64) SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL);
861 (void) sse2_qos_pol_round (numer, 1000LL, &rnd_value,
862 SSE2_QOS_ROUND_TO_CLOSEST);
864 return ((u32) rnd_value);
868 sse2_qos_convert_burst_ms_to_bytes (u32 burst_ms, u32 rate_kbps)
870 u64 numer, rnd_value = 0;
872 //sse2_qos_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
873 // SSE2_QOS_SHIP_CNT_POL_CONV_BURST_MS_TO_BYTES);
875 numer = (u64) ((u64) burst_ms * (u64) rate_kbps);
877 (void) sse2_qos_pol_round (numer, 8LL, &rnd_value,
878 SSE2_QOS_ROUND_TO_CLOSEST);
880 return ((u32) rnd_value);
885 * Input: configured parameters in 'cfg'.
886 * Output: h/w parameters are returned in 'hw',
887 * Return: Status, success or failure code.
890 sse2_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg,
891 sse2_qos_pol_hw_params_st * hw)
897 SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
902 * Validate the police config params being presented to RM
904 rc = sse2_pol_validate_cfg_params (cfg);
907 SSE2_QOS_DEBUG_ERROR ("Config parameter validation failed. Error: %d",
914 * first round configured values to h/w supported values. This func
915 * also determines whether 'tick' or 'byte' format
917 rc = sse2_pol_convert_cfg_to_hw_params (cfg, hw);
920 SSE2_QOS_DEBUG_ERROR ("Unable to convert config params to hw params. "
922 SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_53, rc);
930 #if defined (INTERNAL_SS) || defined (X86)
932 // For initializing the x86 policer format
935 * Return the number of hardware TSC timer ticks per second for the dataplane.
936 * This is approximately, but not exactly, the clock speed.
943 cpu_freq = os_cpu_clock_frequency ();
944 return (u64) cpu_freq;
948 * Convert rates into bytes_per_period and scale.
949 * Return 0 if ok or 1 if error.
952 compute_policer_params (u64 hz, // CPU speed in clocks per second
953 u64 cir_rate, // in bytes per second
954 u64 pir_rate, // in bytes per second
955 u32 * current_limit, // in bytes, output may scale the input
956 u32 * extended_limit, // in bytes, output may scale the input
957 u32 * cir_bytes_per_period,
958 u32 * pir_bytes_per_period, u32 * scale)
961 double internal_cir_bytes_per_period;
962 double internal_pir_bytes_per_period;
966 u32 __attribute__ ((unused)) orig_current_limit = *current_limit;
968 // Compute period. For 1Ghz-to-8Ghz CPUs, the period will be in
969 // the range of 16 to 116 usec.
970 period = ((double) hz) / ((double) POLICER_TICKS_PER_PERIOD);
972 // Determine bytes per period for each rate
973 internal_cir_bytes_per_period = (double) cir_rate / period;
974 internal_pir_bytes_per_period = (double) pir_rate / period;
976 // Scale if possible. Scaling helps rate accuracy, but is constrained
977 // by the scaled rates and limits fitting in 32-bits.
978 // In addition, we need to insure the scaled rate is no larger than
979 // 2^22 tokens per period. This allows the dataplane to ignore overflow
980 // in the tokens-per-period multiplication since it could only
981 // happen if the policer were idle for more than a year.
982 // This is not really a constraint because 100Gbps at 1Ghz is only
983 // 1.6M tokens per period.
984 #define MAX_RATE_SHIFT 10
985 max = MAX (*current_limit, *extended_limit);
986 max = MAX (max, (u32) internal_cir_bytes_per_period << MAX_RATE_SHIFT);
987 max = MAX (max, (u32) internal_pir_bytes_per_period << MAX_RATE_SHIFT);
988 scale_shift = __builtin_clz (max);
990 scale_amount = 1 << scale_shift;
991 *scale = scale_shift;
994 *current_limit = *current_limit << scale_shift;
995 *extended_limit = *extended_limit << scale_shift;
998 internal_cir_bytes_per_period =
999 internal_cir_bytes_per_period * ((double) scale_amount);
1000 internal_pir_bytes_per_period =
1001 internal_pir_bytes_per_period * ((double) scale_amount);
1003 // Make sure the new rates are reasonable
1004 // Only needed for very low rates with large bursts
1005 if (internal_cir_bytes_per_period < 1.0)
1007 internal_cir_bytes_per_period = 1.0;
1009 if (internal_pir_bytes_per_period < 1.0)
1011 internal_pir_bytes_per_period = 1.0;
1014 *cir_bytes_per_period = (u32) internal_cir_bytes_per_period;
1015 *pir_bytes_per_period = (u32) internal_pir_bytes_per_period;
1017 // #define PRINT_X86_POLICE_PARAMS
1018 #ifdef PRINT_X86_POLICE_PARAMS
1022 // This value actually slightly conservative because it doesn't take into account
1023 // the partial period at the end of a second. This really matters only for very low
1026 (((u64) (*cir_bytes_per_period * (u64) period)) >> *scale);
1028 printf ("hz=%llu, cir_rate=%llu, limit=%u => "
1029 "periods-per-sec=%d usec-per-period=%d => "
1030 "scale=%d cir_BPP=%u, scaled_limit=%u => "
1031 "effective BPS=%llu, accuracy=%f\n",
1033 (unsigned long long) hz,
1034 (unsigned long long) cir_rate, orig_current_limit,
1036 (u32) (period), // periods per second
1037 (u32) (1000.0 * 1000.0 / period), // in usec
1038 *scale, *cir_bytes_per_period, *current_limit,
1040 (unsigned long long) effective_BPS,
1041 (double) cir_rate / (double) effective_BPS);
1050 * Input: configured parameters in 'cfg'.
1051 * Output: h/w parameters are returned in 'hw',
1052 * Return: Status, success or failure code.
1055 x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg,
1056 policer_read_response_type_st * hw)
1058 const int BYTES_PER_KBIT = (1000 / 8);
1064 SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
1069 hw->last_update_time = 0;
1071 // Cap the bursts to 32-bits. This allows up to almost one second of
1072 // burst on a 40GE interface, which should be fine for x86.
1074 (cfg->rb.kbps.cb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.cb_bytes;
1075 hw->current_limit = cap;
1077 (cfg->rb.kbps.eb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.eb_bytes;
1078 hw->extended_limit = cap;
1080 if ((cfg->rb.kbps.cir_kbps == 0) && (cfg->rb.kbps.cb_bytes == 0)
1081 && (cfg->rb.kbps.eb_bytes == 0))
1083 // This is a uninitialized, always-violate policer
1084 hw->single_rate = 1;
1085 hw->cir_tokens_per_period = 0;
1089 if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) ||
1090 (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697))
1092 // Single-rate policer
1094 hw->single_rate = 1;
1096 if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes)
1098 SSE2_QOS_DEBUG_ERROR
1099 ("Policer parameter validation failed -- 1R2C.");
1103 if ((cfg->rb.kbps.cir_kbps == 0) ||
1104 (cfg->rb.kbps.eir_kbps != 0) ||
1105 ((cfg->rb.kbps.cb_bytes == 0) && (cfg->rb.kbps.eb_bytes == 0)))
1107 SSE2_QOS_DEBUG_ERROR ("Policer parameter validation failed -- 1R.");
1111 if (compute_policer_params (hz,
1112 (u64) cfg->rb.kbps.cir_kbps *
1113 BYTES_PER_KBIT, 0, &hw->current_limit,
1114 &hw->extended_limit,
1115 &hw->cir_tokens_per_period,
1116 &hw->pir_tokens_per_period, &hw->scale))
1118 SSE2_QOS_DEBUG_ERROR ("Policer parameter computation failed.");
1123 else if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) ||
1124 (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115))
1128 if ((cfg->rb.kbps.cir_kbps == 0) || (cfg->rb.kbps.eir_kbps == 0)
1129 || (cfg->rb.kbps.eir_kbps < cfg->rb.kbps.cir_kbps)
1130 || (cfg->rb.kbps.cb_bytes == 0) || (cfg->rb.kbps.eb_bytes == 0))
1132 SSE2_QOS_DEBUG_ERROR ("Config parameter validation failed.");
1136 if (compute_policer_params (hz,
1137 (u64) cfg->rb.kbps.cir_kbps *
1139 (u64) cfg->rb.kbps.eir_kbps *
1140 BYTES_PER_KBIT, &hw->current_limit,
1141 &hw->extended_limit,
1142 &hw->cir_tokens_per_period,
1143 &hw->pir_tokens_per_period, &hw->scale))
1145 SSE2_QOS_DEBUG_ERROR ("Policer parameter computation failed.");
1152 SSE2_QOS_DEBUG_ERROR
1153 ("Config parameter validation failed. RFC not supported");
1157 hw->current_bucket = hw->current_limit;
1158 hw->extended_bucket = hw->extended_limit;
1166 * Input: configured parameters in 'cfg'.
1167 * Output: physical structure is returned in 'phys',
1168 * Return: Status, success or failure code.
1171 sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg,
1172 policer_read_response_type_st * phys)
1175 sse2_qos_pol_cfg_params_st kbps_cfg;
1177 memset (phys, 0, sizeof (policer_read_response_type_st));
1178 memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
1182 SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
1186 switch (cfg->rate_type)
1188 case SSE2_QOS_RATE_KBPS:
1189 /* copy all the data into kbps_cfg */
1190 kbps_cfg.rb.kbps.cir_kbps = cfg->rb.kbps.cir_kbps;
1191 kbps_cfg.rb.kbps.eir_kbps = cfg->rb.kbps.eir_kbps;
1192 kbps_cfg.rb.kbps.cb_bytes = cfg->rb.kbps.cb_bytes;
1193 kbps_cfg.rb.kbps.eb_bytes = cfg->rb.kbps.eb_bytes;
1195 case SSE2_QOS_RATE_PPS:
1196 kbps_cfg.rb.kbps.cir_kbps =
1197 sse2_qos_convert_pps_to_kbps (cfg->rb.pps.cir_pps);
1198 kbps_cfg.rb.kbps.eir_kbps =
1199 sse2_qos_convert_pps_to_kbps (cfg->rb.pps.eir_pps);
1200 kbps_cfg.rb.kbps.cb_bytes = sse2_qos_convert_burst_ms_to_bytes ((u32)
1205 kbps_cfg.rb.kbps.eb_bytes =
1206 sse2_qos_convert_burst_ms_to_bytes ((u32) cfg->rb.pps.eb_ms,
1207 kbps_cfg.rb.kbps.eir_kbps);
1210 SSE2_QOS_DEBUG_ERROR ("Illegal rate type");
1214 /* rate type is now converted to kbps */
1215 kbps_cfg.rate_type = SSE2_QOS_RATE_KBPS;
1216 kbps_cfg.rnd_type = cfg->rnd_type;
1217 kbps_cfg.rfc = cfg->rfc;
1219 phys->action[POLICE_CONFORM] = cfg->conform_action.action_type;
1220 phys->mark_dscp[POLICE_CONFORM] = cfg->conform_action.dscp;
1221 phys->action[POLICE_EXCEED] = cfg->exceed_action.action_type;
1222 phys->mark_dscp[POLICE_EXCEED] = cfg->exceed_action.dscp;
1223 phys->action[POLICE_VIOLATE] = cfg->violate_action.action_type;
1224 phys->mark_dscp[POLICE_VIOLATE] = cfg->violate_action.dscp;
1226 phys->color_aware = cfg->color_aware;
1228 #if !defined (INTERNAL_SS) && !defined (X86)
1229 // convert logical into hw params which involves qos calculations
1230 rc = sse2_pol_compute_hw_params (&kbps_cfg, &pol_hw);
1233 SSE2_QOS_DEBUG_ERROR ("Unable to compute hw param. Error: %d", rc);
1237 // convert hw params into the physical
1238 phys->rfc = pol_hw.rfc;
1239 phys->an = pol_hw.allow_negative;
1240 phys->rexp = pol_hw.rate_exp;
1241 phys->arm = pol_hw.avg_rate_man;
1242 phys->prm = pol_hw.peak_rate_man;
1243 phys->cble = pol_hw.comm_bkt_limit_exp;
1244 phys->cblm = pol_hw.comm_bkt_limit_man;
1245 phys->eble = pol_hw.extd_bkt_limit_exp;
1246 phys->eblm = pol_hw.extd_bkt_limit_man;
1247 phys->cb = pol_hw.comm_bkt;
1248 phys->eb = pol_hw.extd_bkt;
1250 /* for debugging purposes, the bucket token values can be overwritten */
1251 if (cfg->overwrite_bucket)
1253 phys->cb = cfg->current_bucket;
1254 phys->eb = cfg->extended_bucket;
1257 // convert logical into hw params which involves qos calculations
1258 rc = x86_pol_compute_hw_params (&kbps_cfg, phys);
1261 SSE2_QOS_DEBUG_ERROR ("Unable to compute hw param. Error: %d", rc);
1265 /* for debugging purposes, the bucket token values can be overwritten */
1266 if (cfg->overwrite_bucket)
1268 phys->current_bucket = cfg->current_bucket;
1269 phys->extended_bucket = cfg->extended_bucket;
1272 #endif // if !defined (INTERNAL_SS) && !defined (X86)
1279 sse2_qos_convert_pol_bucket_to_hw_fmt (policer_read_response_type_st * bkt,
1280 sse2_qos_pol_hw_params_st * hw_fmt)
1282 memset (hw_fmt, 0, sizeof (sse2_qos_pol_hw_params_st));
1283 #if !defined (INTERNAL_SS) && !defined (X86)
1284 hw_fmt->rfc = (u8) bkt->rfc;
1285 hw_fmt->allow_negative = (u8) bkt->an;
1286 hw_fmt->rate_exp = (u8) bkt->rexp;
1287 hw_fmt->avg_rate_man = (u16) bkt->arm;
1288 hw_fmt->peak_rate_man = (u16) bkt->prm;
1289 hw_fmt->comm_bkt_limit_man = (u8) bkt->cblm;
1290 hw_fmt->comm_bkt_limit_exp = (u8) bkt->cble;
1291 hw_fmt->extd_bkt_limit_man = (u8) bkt->eblm;
1292 hw_fmt->extd_bkt_limit_exp = (u8) bkt->eble;
1293 hw_fmt->extd_bkt = bkt->eb;
1294 hw_fmt->comm_bkt = bkt->cb;
1295 #endif // if !defined (INTERNAL_SS) && !defined (X86)
1299 * Input: h/w programmable parameter values in 'hw'
1300 * Output: configured parameter values in 'cfg'
1301 * Return: Status, success or failure code.
1304 sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw,
1305 sse2_qos_pol_cfg_params_st * cfg)
1309 if ((hw == NULL) || (cfg == NULL))
1314 if ((hw->rfc == IPE_RFC_RFC4115) &&
1315 (hw->peak_rate_man << hw->rate_exp) == 0 && !(hw->extd_bkt_limit_man))
1318 * For a 1R2C, we set EIR = 0, EB = 0
1320 cfg->rfc = SSE2_QOS_POLICER_TYPE_1R2C;
1322 else if (hw->rfc == IPE_RFC_RFC2697)
1324 cfg->rfc = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
1326 else if (hw->rfc == IPE_RFC_RFC2698)
1328 cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
1330 else if (hw->rfc == IPE_RFC_RFC4115)
1332 cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
1334 else if (hw->rfc == IPE_RFC_MEF5CF1)
1336 cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
1343 temp_rate = (((u64) hw->avg_rate_man << hw->rate_exp) * 8LL *
1344 SSE2_QOS_POL_TICKS_PER_SEC) / 1000;
1345 cfg->rb.kbps.cir_kbps = (u32) temp_rate;
1347 temp_rate = (((u64) hw->peak_rate_man << hw->rate_exp) * 8LL *
1348 SSE2_QOS_POL_TICKS_PER_SEC) / 1000;
1349 cfg->rb.kbps.eir_kbps = (u32) temp_rate;
1351 cfg->rb.kbps.cb_bytes = ((u64) hw->comm_bkt_limit_man <<
1352 (u64) hw->comm_bkt_limit_exp);
1353 cfg->rb.kbps.eb_bytes = ((u64) hw->extd_bkt_limit_man <<
1354 (u64) hw->extd_bkt_limit_exp);
1356 if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
1359 * For 1R3C in the hardware, EB = sum(CB, EB). Also, EIR = CIR. Restore
1360 * values such that the configured params don't reflect this adjustment
1362 cfg->rb.kbps.eb_bytes = (cfg->rb.kbps.eb_bytes - cfg->rb.kbps.cb_bytes);
1363 cfg->rb.kbps.eir_kbps = 0;
1365 else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
1368 * For 4115 in the hardware is excess rate and burst, but EA provides
1369 * peak-rate, so adjust it to be eir
1371 cfg->rb.kbps.eir_kbps += cfg->rb.kbps.cir_kbps;
1372 cfg->rb.kbps.eb_bytes += cfg->rb.kbps.cb_bytes;
1374 /* h/w conversion to cfg is in kbps */
1375 cfg->rate_type = SSE2_QOS_RATE_KBPS;
1376 cfg->overwrite_bucket = 0;
1377 cfg->current_bucket = hw->comm_bkt;
1378 cfg->extended_bucket = hw->extd_bkt;
1380 SSE2_QOS_DEBUG_INFO ("configured params, cir: %u kbps, eir: %u kbps, cb "
1381 "burst: 0x%llx bytes, eb burst: 0x%llx bytes",
1382 cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps,
1383 cfg->rb.kbps.cb_bytes, cfg->rb.kbps.eb_bytes);
1384 SSE2_QOS_TR_INFO (SSE2_QOS_TP_INFO_22, cfg->rb.kbps.cir_kbps,
1385 cfg->rb.kbps.eir_kbps,
1386 (uint) cfg->rb.kbps.cb_bytes,
1387 (uint) cfg->rb.kbps.eb_bytes);
1393 sse2_qos_convert_kbps_to_pps (u32 rate_kbps)
1395 u64 numer, denom, rnd_value = 0;
1397 // sse_qosrm_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
1398 // SSE2_QOS_SHIP_CNT_POL_CONV_KBPS_TO_PPS);
1400 numer = (u64) ((u64) rate_kbps * 1000LL);
1401 denom = (u64) ((u64) SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL);
1403 (void) sse2_qos_pol_round (numer, denom, &rnd_value,
1404 SSE2_QOS_ROUND_TO_CLOSEST);
1406 return ((u32) rnd_value);
1410 sse2_qos_convert_burst_bytes_to_ms (u64 burst_bytes, u32 rate_kbps)
1412 u64 numer, denom, rnd_value = 0;
1414 //sse_qosrm_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
1415 // SSE2_QOS_SHIP_CNT_POL_CONV_BYTES_TO_BURST_MS);
1417 numer = burst_bytes * 8LL;
1418 denom = (u64) rate_kbps;
1420 (void) sse2_qos_pol_round (numer, denom, &rnd_value,
1421 SSE2_QOS_ROUND_TO_CLOSEST);
1423 return ((u32) rnd_value);
1427 * Input: physical structure in 'phys', rate_type in cfg
1428 * Output: configured parameters in 'cfg'.
1429 * Return: Status, success or failure code.
1432 sse2_pol_physical_2_logical (policer_read_response_type_st * phys,
1433 sse2_qos_pol_cfg_params_st * cfg)
1436 sse2_qos_pol_hw_params_st pol_hw;
1437 sse2_qos_pol_cfg_params_st kbps_cfg;
1439 memset (&pol_hw, 0, sizeof (sse2_qos_pol_hw_params_st));
1440 memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
1444 SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
1448 sse2_qos_convert_pol_bucket_to_hw_fmt (phys, &pol_hw);
1450 rc = sse2_pol_convert_hw_to_cfg_params (&pol_hw, &kbps_cfg);
1453 SSE2_QOS_DEBUG_ERROR ("Unable to convert hw params to config params. "
1458 /* check what rate type is required */
1459 switch (cfg->rate_type)
1461 case SSE2_QOS_RATE_KBPS:
1462 /* copy all the data into kbps_cfg */
1463 cfg->rb.kbps.cir_kbps = kbps_cfg.rb.kbps.cir_kbps;
1464 cfg->rb.kbps.eir_kbps = kbps_cfg.rb.kbps.eir_kbps;
1465 cfg->rb.kbps.cb_bytes = kbps_cfg.rb.kbps.cb_bytes;
1466 cfg->rb.kbps.eb_bytes = kbps_cfg.rb.kbps.eb_bytes;
1468 case SSE2_QOS_RATE_PPS:
1469 cfg->rb.pps.cir_pps =
1470 sse2_qos_convert_kbps_to_pps (kbps_cfg.rb.kbps.cir_kbps);
1471 cfg->rb.pps.eir_pps =
1472 sse2_qos_convert_kbps_to_pps (kbps_cfg.rb.kbps.eir_kbps);
1474 sse2_qos_convert_burst_bytes_to_ms (kbps_cfg.rb.kbps.cb_bytes,
1475 kbps_cfg.rb.kbps.cir_kbps);
1477 sse2_qos_convert_burst_bytes_to_ms (kbps_cfg.rb.kbps.eb_bytes,
1478 kbps_cfg.rb.kbps.eir_kbps);
1481 SSE2_QOS_DEBUG_ERROR ("Illegal rate type");
1485 /* cfg->rate_type remains what it was */
1486 cfg->rnd_type = kbps_cfg.rnd_type;
1487 cfg->rfc = kbps_cfg.rfc;
1488 cfg->overwrite_bucket = kbps_cfg.overwrite_bucket;
1489 cfg->current_bucket = kbps_cfg.current_bucket;
1490 cfg->extended_bucket = kbps_cfg.extended_bucket;
1496 * fd.io coding-style-patch-verification: ON
1499 * eval: (c-set-style "gnu")