policer: remove SSE2 prefix

The policer code uses a naming convention of prefixing a lot of
its definitions with "SSE2" when in fact there is nothing SSE2
specific about them. This is confusing so remove the prefix.

Unfortunately it has to stay in the API definitions for backward
compatibility.

Type: improvement
Signed-off-by: Brian Russell <brian@graphiant.com>
Change-Id: I59a7df9fd5ded2575f2e587b2768a025a213b07c

1 files changed, 316 insertions, 364 deletions

diff --git a/src/vnet/policer/xlate.c b/src/vnet/policer/xlate.c
index afc0c05c376..2ef99225017 100644
--- a/src/vnet/policer/xlate.c
+++ b/src/vnet/policer/xlate.c
@@ -28,18 +28,15 @@
 #define INTERNAL_SS 1
 
 /* debugs */
-#define SSE2_QOS_DEBUG_ERROR(msg, args...) \
-    fformat(stderr, msg "\n", ##args);
+#define 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_INFO(msg, args...) fformat (stderr, msg "\n", ##args);
 
-
-#define SSE2_QOS_TR_ERR(TpParms...)
+#define QOS_TR_ERR(TpParms...)
 // {
 // }
 
-#define SSE2_QOS_TR_INFO(TpParms...)
+#define QOS_TR_INFO(TpParms...)
 
 #ifndef MIN
 #define MIN(x,y)            (((x)<(y))?(x):(y))
@@ -117,78 +114,68 @@
 /* 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
+#define QOS_POL_ALLOW_NEGATIVE 1
 
 // Various Macros to take care of policer calculations
 
-#define SSE2_QOS_POL_COMM_BKT_MAX \
-                            (1<<IPE_POLICER_FULL_WRITE_REQUEST_CB_MASK)
-#define SSE2_QOS_POL_EXTD_BKT_MAX \
-                            (1<<IPE_POLICER_FULL_WRITE_REQUEST_EB_MASK)
-
-#define SSE2_QOS_POL_RATE_EXP_SIZE \
-                            (IPE_POLICER_FULL_WRITE_REQUEST_REXP_MASK)
-#define SSE2_QOS_POL_RATE_EXP_MAX  ((1<<SSE2_QOS_POL_RATE_EXP_SIZE) - 1)
-#define SSE2_QOS_POL_AVG_RATE_MANT_SIZE \
-                            (IPE_POLICER_FULL_WRITE_REQUEST_ARM_MASK)
-#define SSE2_QOS_POL_AVG_RATE_MANT_MAX    \
-                            ((1<< SSE2_QOS_POL_AVG_RATE_MANT_SIZE) - 1)
-#define SSE2_QOS_POL_AVG_RATE_MAX \
-                            (SSE2_QOS_POL_AVG_RATE_MANT_MAX << \
-                             SSE2_QOS_POL_RATE_EXP_MAX)
-
-#define SSE2_QOS_POL_PEAK_RATE_MANT_SIZE   \
-                            (IPE_POLICER_FULL_WRITE_REQUEST_PRM_MASK)
-#define SSE2_QOS_POL_PEAK_RATE_MANT_MAX    \
-                            ((1<<SSE2_QOS_POL_PEAK_RATE_MANT_SIZE) - 1)
-#define SSE2_QOS_POL_PEAK_RATE_MAX \
-                            (SSE2_QOS_POL_PEAK_RATE_MANT_MAX << \
-                             SSE2_QOS_POL_RATE_EXP_MAX)
-
-#define SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_SIZE   \
-                        (IPE_POLICER_FULL_WRITE_REQUEST_CBLM_MASK)
-#define SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX   \
-                        ((1<<SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_SIZE) - 1)
-#define SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_SIZE   \
-                        (IPE_POLICER_FULL_WRITE_REQUEST_CBLE_MASK)
-#define SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX   \
-                        ((1<<SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_SIZE) - 1)
-#define SSE2_QOS_POL_COMM_BKT_LIMIT_MAX \
-                        ((u64)SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX << \
-                         (u64)SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX)
-
-#define SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_SIZE   \
-                        (IPE_POLICER_FULL_WRITE_REQUEST_EBLM_MASK)
-#define SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX   \
-                        ((1<<SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_SIZE) - 1)
-#define SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_SIZE   \
-                        (IPE_POLICER_FULL_WRITE_REQUEST_EBLE_MASK)
-#define SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX   \
-                        ((1<<SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_SIZE) - 1)
-#define SSE2_QOS_POL_EXT_BKT_LIMIT_MAX \
-                        ((u64)SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX << \
-                         (u64)SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX)
+#define QOS_POL_COMM_BKT_MAX (1 << IPE_POLICER_FULL_WRITE_REQUEST_CB_MASK)
+#define QOS_POL_EXTD_BKT_MAX (1 << IPE_POLICER_FULL_WRITE_REQUEST_EB_MASK)
+
+#define QOS_POL_RATE_EXP_SIZE	   (IPE_POLICER_FULL_WRITE_REQUEST_REXP_MASK)
+#define QOS_POL_RATE_EXP_MAX	   ((1 << QOS_POL_RATE_EXP_SIZE) - 1)
+#define QOS_POL_AVG_RATE_MANT_SIZE (IPE_POLICER_FULL_WRITE_REQUEST_ARM_MASK)
+#define QOS_POL_AVG_RATE_MANT_MAX  ((1 << QOS_POL_AVG_RATE_MANT_SIZE) - 1)
+#define QOS_POL_AVG_RATE_MAX                                                  \
+  (QOS_POL_AVG_RATE_MANT_MAX << QOS_POL_RATE_EXP_MAX)
+
+#define QOS_POL_PEAK_RATE_MANT_SIZE (IPE_POLICER_FULL_WRITE_REQUEST_PRM_MASK)
+#define QOS_POL_PEAK_RATE_MANT_MAX  ((1 << QOS_POL_PEAK_RATE_MANT_SIZE) - 1)
+#define QOS_POL_PEAK_RATE_MAX                                                 \
+  (QOS_POL_PEAK_RATE_MANT_MAX << QOS_POL_RATE_EXP_MAX)
+
+#define QOS_POL_COMM_BKT_LIMIT_MANT_SIZE                                      \
+  (IPE_POLICER_FULL_WRITE_REQUEST_CBLM_MASK)
+#define QOS_POL_COMM_BKT_LIMIT_MANT_MAX                                       \
+  ((1 << QOS_POL_COMM_BKT_LIMIT_MANT_SIZE) - 1)
+#define QOS_POL_COMM_BKT_LIMIT_EXP_SIZE                                       \
+  (IPE_POLICER_FULL_WRITE_REQUEST_CBLE_MASK)
+#define QOS_POL_COMM_BKT_LIMIT_EXP_MAX                                        \
+  ((1 << QOS_POL_COMM_BKT_LIMIT_EXP_SIZE) - 1)
+#define QOS_POL_COMM_BKT_LIMIT_MAX                                            \
+  ((u64) QOS_POL_COMM_BKT_LIMIT_MANT_MAX                                      \
+   << (u64) QOS_POL_COMM_BKT_LIMIT_EXP_MAX)
+
+#define QOS_POL_EXTD_BKT_LIMIT_MANT_SIZE                                      \
+  (IPE_POLICER_FULL_WRITE_REQUEST_EBLM_MASK)
+#define QOS_POL_EXTD_BKT_LIMIT_MANT_MAX                                       \
+  ((1 << QOS_POL_EXTD_BKT_LIMIT_MANT_SIZE) - 1)
+#define QOS_POL_EXTD_BKT_LIMIT_EXP_SIZE                                       \
+  (IPE_POLICER_FULL_WRITE_REQUEST_EBLE_MASK)
+#define QOS_POL_EXTD_BKT_LIMIT_EXP_MAX                                        \
+  ((1 << QOS_POL_EXTD_BKT_LIMIT_EXP_SIZE) - 1)
+#define QOS_POL_EXT_BKT_LIMIT_MAX                                             \
+  ((u64) QOS_POL_EXTD_BKT_LIMIT_MANT_MAX                                      \
+   << (u64) QOS_POL_EXTD_BKT_LIMIT_EXP_MAX)
 
 /*
  * Rates determine the units of the bucket
@@ -199,35 +186,34 @@
  *
  * The code uses bytes per tick as oppose to Gigabits per second.
  */
-#define RATE256 (256114688000LL / 8LL / SSE2_QOS_POL_TICKS_PER_SEC)
-#define RATE128 (128057344000LL / 8LL / SSE2_QOS_POL_TICKS_PER_SEC)
-#define RATE64  ( 64028672000LL / 8LL / SSE2_QOS_POL_TICKS_PER_SEC)
+#define RATE256 (256114688000LL / 8LL / QOS_POL_TICKS_PER_SEC)
+#define RATE128 (128057344000LL / 8LL / QOS_POL_TICKS_PER_SEC)
+#define RATE64	(64028672000LL / 8LL / QOS_POL_TICKS_PER_SEC)
 
 #define RATE_OVER256_UNIT  8LL
 #define RATE_128TO256_UNIT 4LL
 #define RATE_64TO128_UNIT  2LL
 
 static int
-sse2_qos_pol_round (u64 numerator,
-		    u64 denominator,
-		    u64 * rounded_value, sse2_qos_round_type_en round_type)
+qos_pol_round (u64 numerator, u64 denominator, u64 *rounded_value,
+	       qos_round_type_en round_type)
 {
   int rc = 0;
 
   if (denominator == 0)
     {
-      SSE2_QOS_DEBUG_ERROR ("Illegal denominator");
-      SSE2_QOS_TR_ERR (SSE2_QOSRM_TP_ERR_59);
+      QOS_DEBUG_ERROR ("Illegal denominator");
+      QOS_TR_ERR (QOSRM_TP_ERR_59);
       return (EINVAL);
     }
 
   switch (round_type)
     {
-    case SSE2_QOS_ROUND_TO_CLOSEST:
+    case QOS_ROUND_TO_CLOSEST:
       *rounded_value = ((numerator + (denominator >> 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 +221,33 @@ 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");
+      QOS_TR_ERR (QOS_TP_ERR_60, 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);
+      QOS_TR_ERR (QOS_TP_ERR_39, cfg->rb.kbps.cir_kbps, cfg->rb.kbps.eir_kbps);
       return (EINVAL);
     }
 
@@ -271,45 +255,44 @@ 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,
+		      (qos_round_type_en) cfg->rnd_type);
   if (rc != 0)
     {
-      SSE2_QOS_DEBUG_ERROR ("Unable to convert CIR to bytes/tick format");
+      QOS_DEBUG_ERROR ("Unable to convert CIR to bytes/tick format");
       // Error traced
       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,
+		      (qos_round_type_en) cfg->rnd_type);
   if (rc != 0)
     {
-      SSE2_QOS_DEBUG_ERROR ("Unable to convert EIR to bytes/tick format");
+      QOS_DEBUG_ERROR ("Unable to convert EIR to bytes/tick format");
       // Error traced
       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);
+      QOS_TR_ERR (QOS_TP_ERR_84, 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);
+      QOS_TR_ERR (QOS_TP_ERR_85, eir_hw, QOS_POL_PEAK_RATE_MAX);
       return (EINVAL);
     }
   /*
@@ -317,32 +300,31 @@ 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");
+      QOS_TR_ERR (QOS_TP_ERR_55);
       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);
+      QOS_TR_ERR (QOS_TP_ERR_23, cfg->rb.kbps.eir_kbps, 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);
+      QOS_TR_ERR (QOS_TP_ERR_23, 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");
+      QOS_TR_ERR (QOS_TP_ERR_56);
       return (EINVAL);
     }
 
@@ -350,11 +332,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 +354,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 +371,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,15 +388,14 @@ 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,
+		      (qos_round_type_en) 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);
+      QOS_DEBUG_ERROR ("Rounding error, rate: %d kbps, rounding_type: %d",
+		       cfg->rb.kbps.cir_kbps, cfg->rnd_type);
       // Error is traced
       return (rc);
     }
@@ -431,15 +409,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,13 +427,12 @@ 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,
+		      (qos_round_type_en) cfg->rnd_type);
   if (rc != 0)
     {
-      SSE2_QOS_DEBUG_ERROR
-	("Rounding error, rate: %d kbps, rounding_type: %d", eir_kbps,
-	 cfg->rnd_type);
+      QOS_DEBUG_ERROR ("Rounding error, rate: %d kbps, rounding_type: %d",
+		       eir_kbps, cfg->rnd_type);
       // Error is traced
       return (rc);
     }
@@ -469,8 +446,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,39 +464,36 @@ 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,
+	(qos_round_type_en) 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,
+			  (qos_round_type_en) 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,
+			  (qos_round_type_en) cfg->rnd_type);
       hw->peak_rate_man = (u16) rnd_value;
     }
   if (rc != 0)
     {
-      SSE2_QOS_DEBUG_ERROR ("Rounding error");
+      QOS_DEBUG_ERROR ("Rounding error");
       // Error is traced
       return (rc);
     }
@@ -531,8 +505,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 +516,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 +558,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 +578,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 +596,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 +615,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 +625,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 +633,45 @@ 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);
+      QOS_TR_INFO (QOS_TP_INFO_38, (uint) cfg_burst, (uint) 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);
+      QOS_TR_INFO (QOS_TP_INFO_39, (uint) 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 +681,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 +699,32 @@ 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));
+      QOS_TR_INFO (QOS_TP_INFO_20, (uint) cfg->rb.kbps.eb_bytes,
+		   hw->extd_bkt_limit_man, 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 +734,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,56 +758,54 @@ 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);
+      QOS_TR_ERR (QOS_TP_ERR_61, 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);
+      QOS_DEBUG_ERROR ("Unable to convert config rates to hw. Error: %d", rc);
       // Error is traced
       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);
+      QOS_DEBUG_ERROR ("Unable to convert config burst to hw. Error: %d", rc);
       // Error is traced
       return (rc);
     }
@@ -847,35 +813,31 @@ sse2_pol_convert_cfg_to_hw_params (sse2_qos_pol_cfg_params_st * cfg,
   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);
+  // qos_ship_inc_counter(QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                            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);
+  // qos_ship_inc_counter(QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                          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,25 +849,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);
+      QOS_DEBUG_ERROR ("Config parameter validation failed. Error: %d", rc);
       // Error is traced
       return (-1);
     }
@@ -914,12 +874,13 @@ 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);
+      QOS_TR_ERR (QOS_TP_ERR_53, rc);
       return (-1);
     }
 
@@ -1052,8 +1013,8 @@ 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_read_response_type_st *hw)
 {
   const int BYTES_PER_KBIT = (1000 / 8);
   u64 hz;
@@ -1061,7 +1022,7 @@ 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);
     }
 
@@ -1086,17 +1047,16 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg,
       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
 
       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 +1064,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,13 +1075,13 @@ 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
 
@@ -1129,7 +1089,7 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg,
 	  || (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 +1102,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);
     }
 
@@ -1168,51 +1128,47 @@ 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_read_response_type_st *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 (&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;
 
@@ -1227,10 +1183,10 @@ sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg,
 
 #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);
+  rc = pol_compute_hw_params (&kbps_cfg, &pol_hw);
   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);
     }
 
@@ -1258,7 +1214,7 @@ sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg,
   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);
     }
 
@@ -1274,12 +1230,11 @@ sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg,
   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_read_response_type_st *bkt,
+				  qos_pol_hw_params_st *hw_fmt)
 {
-  clib_memset (hw_fmt, 0, sizeof (sse2_qos_pol_hw_params_st));
+  clib_memset (hw_fmt, 0, sizeof (qos_pol_hw_params_st));
 #if !defined (INTERNAL_SS) && !defined (X86)
   hw_fmt->rfc = (u8) bkt->rfc;
   hw_fmt->allow_negative = (u8) bkt->an;
@@ -1301,8 +1256,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 +1272,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 +1310,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 +1319,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 +1329,49 @@ 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);
+  QOS_TR_INFO (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);
 
   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);
+  // sse_qosrm_ship_inc_counter(QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                            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);
+  // sse_qosrm_ship_inc_counter(QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                         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 +1382,55 @@ 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_read_response_type_st *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);
     }