policer: replace uintX_t with uX, fix style

Change-Id: Ie4a0ba57d5c672ab04fe37801836f65d8731a90a
Signed-off-by: Damjan Marion <damarion@cisco.com>

8 files changed, 1926 insertions, 1764 deletions

diff --git a/vnet/Makefile.am b/vnet/Makefile.am
index 1c5d5b51781..f35ec1372db 100644
--- a/vnet/Makefile.am
+++ b/vnet/Makefile.am
@@ -66,7 +66,6 @@ libvnet_la_SOURCES +=				\
 nobase_include_HEADERS +=			\
   vnet/policer/police.h				\
   vnet/policer/policer.h			\
-  vnet/policer/fix_types.h			\
   vnet/policer/xlate.h
 
 ########################################
diff --git a/vnet/vnet/policer/fix_types.h b/vnet/vnet/policer/fix_types.h
deleted file mode 100644
index 71a4173108a..00000000000
--- a/vnet/vnet/policer/fix_types.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright (c) 2015 Cisco and/or its affiliates.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at:
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef __included_fix_types_h__
-#define __included_fix_types_h__
-
-/* deal with various imported type choices */
-#define cerrno int
-#define trans_layer_rc int
-#define EOK 0
-#define CERR_IS_NOTOK(a) (a != EOK)
-#define PACKED
-#define OK_pushHW EOK
-#define Not_OK (-1)
-
-typedef unsigned char uint8_t;
-typedef unsigned short int uint16_t;
-typedef unsigned int uint32_t;
-
-#ifdef __powerpc64__
-typedef unsigned long uint64_t;
-#endif
-
-#endif /* __included_fix_types_h__ */
diff --git a/vnet/vnet/policer/node_funcs.c b/vnet/vnet/policer/node_funcs.c
index 61a29733117..1f4997ff669 100644
--- a/vnet/vnet/policer/node_funcs.c
+++ b/vnet/vnet/policer/node_funcs.c
@@ -29,21 +29,23 @@
 
 /* Dispatch functions meant to be instantiated elsewhere */
 
-typedef struct {
+typedef struct
+{
   u32 next_index;
   u32 sw_if_index;
   u32 policer_index;
 } vnet_policer_trace_t;
 
 /* packet trace format function */
-static u8 * format_policer_trace (u8 * s, va_list * args)
+static u8 *
+format_policer_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  vnet_policer_trace_t * t = va_arg (*args, vnet_policer_trace_t *);
-  
+  vnet_policer_trace_t *t = va_arg (*args, vnet_policer_trace_t *);
+
   s = format (s, "VNET_POLICER: sw_if_index %d policer_index %d next %d",
-              t->sw_if_index, t->policer_index, t->next_index);
+	      t->sw_if_index, t->policer_index, t->next_index);
   return s;
 }
 
@@ -51,89 +53,87 @@ static u8 * format_policer_trace (u8 * s, va_list * args)
 _(TRANSMIT, "Packets Transmitted")              \
 _(DROP, "Packets Dropped")
 
-typedef enum {
+typedef enum
+{
 #define _(sym,str) VNET_POLICER_ERROR_##sym,
   foreach_vnet_policer_error
 #undef _
-  VNET_POLICER_N_ERROR,
+    VNET_POLICER_N_ERROR,
 } vnet_policer_error_t;
 
-static char * vnet_policer_error_strings[] = {
+static char *vnet_policer_error_strings[] = {
 #define _(sym,string) string,
   foreach_vnet_policer_error
 #undef _
 };
 
-static_always_inline
-void vnet_policer_mark (vlib_buffer_t * b, u8 dscp)
+static_always_inline void
+vnet_policer_mark (vlib_buffer_t * b, u8 dscp)
 {
-  ethernet_header_t * eh;
-  ip4_header_t * ip4h;
-  ip6_header_t * ip6h;
+  ethernet_header_t *eh;
+  ip4_header_t *ip4h;
+  ip6_header_t *ip6h;
   u16 type;
 
   eh = (ethernet_header_t *) b->data;
   type = clib_net_to_host_u16 (eh->type);
 
-  if (PREDICT_TRUE(type == ETHERNET_TYPE_IP4))
+  if (PREDICT_TRUE (type == ETHERNET_TYPE_IP4))
     {
-      ip4h = (ip4_header_t *) &(b->data[sizeof(ethernet_header_t)]);;
+      ip4h = (ip4_header_t *) & (b->data[sizeof (ethernet_header_t)]);;
       ip4h->tos &= IP4_NON_DSCP_BITS;
       ip4h->tos |= dscp << IP4_DSCP_SHIFT;
       ip4h->checksum = ip4_header_checksum (ip4h);
     }
   else
     {
-      if (PREDICT_TRUE(type == ETHERNET_TYPE_IP6))
-        {
-          ip6h = (ip6_header_t *) &(b->data[sizeof(ethernet_header_t)]);
-          ip6h->ip_version_traffic_class_and_flow_label &=
-            clib_host_to_net_u32(IP6_NON_DSCP_BITS);
-          ip6h->ip_version_traffic_class_and_flow_label |=
-            clib_host_to_net_u32(dscp << IP6_DSCP_SHIFT);
-        }
+      if (PREDICT_TRUE (type == ETHERNET_TYPE_IP6))
+	{
+	  ip6h = (ip6_header_t *) & (b->data[sizeof (ethernet_header_t)]);
+	  ip6h->ip_version_traffic_class_and_flow_label &=
+	    clib_host_to_net_u32 (IP6_NON_DSCP_BITS);
+	  ip6h->ip_version_traffic_class_and_flow_label |=
+	    clib_host_to_net_u32 (dscp << IP6_DSCP_SHIFT);
+	}
     }
 }
 
 static_always_inline
-u8 vnet_policer_police (vlib_main_t * vm,
-                        vlib_buffer_t * b,
-                        u32 policer_index,
-                        u64 time_in_policer_periods,
-                        policer_result_e packet_color)
+  u8 vnet_policer_police (vlib_main_t * vm,
+			  vlib_buffer_t * b,
+			  u32 policer_index,
+			  u64 time_in_policer_periods,
+			  policer_result_e packet_color)
 {
   u8 act;
   u32 len;
   u32 col;
   policer_read_response_type_st *pol;
-  vnet_policer_main_t * pm = &vnet_policer_main;
+  vnet_policer_main_t *pm = &vnet_policer_main;
 
   len = vlib_buffer_length_in_chain (vm, b);
-  pol = &pm->policers [policer_index];
-  col = vnet_police_packet (pol, len,
-                            packet_color,
-                            time_in_policer_periods);
+  pol = &pm->policers[policer_index];
+  col = vnet_police_packet (pol, len, packet_color, time_in_policer_periods);
   act = pol->action[col];
-  if (PREDICT_TRUE(act == SSE2_QOS_ACTION_MARK_AND_TRANSMIT))
-      vnet_policer_mark(b, pol->mark_dscp[col]);
+  if (PREDICT_TRUE (act == SSE2_QOS_ACTION_MARK_AND_TRANSMIT))
+    vnet_policer_mark (b, pol->mark_dscp[col]);
 
   return act;
- }
+}
 
-static inline
-uword vnet_policer_inline (vlib_main_t * vm,
-                           vlib_node_runtime_t * node,
-                           vlib_frame_t * frame,
-                           vnet_policer_index_t which)
+static inline uword
+vnet_policer_inline (vlib_main_t * vm,
+		     vlib_node_runtime_t * node,
+		     vlib_frame_t * frame, vnet_policer_index_t which)
 {
-  u32 n_left_from, * from, * to_next;
+  u32 n_left_from, *from, *to_next;
   vnet_policer_next_t next_index;
-  vnet_policer_main_t * pm = &vnet_policer_main;
+  vnet_policer_main_t *pm = &vnet_policer_main;
   u64 time_in_policer_periods;
   u32 transmitted = 0;
 
-  time_in_policer_periods = 
-    clib_cpu_time_now() >> POLICER_TICKS_PER_PERIOD_SHIFT;
+  time_in_policer_periods =
+    clib_cpu_time_now () >> POLICER_TICKS_PER_PERIOD_SHIFT;
 
   from = vlib_frame_vector_args (frame);
   n_left_from = frame->n_vectors;
@@ -143,30 +143,29 @@ uword vnet_policer_inline (vlib_main_t * vm,
     {
       u32 n_left_to_next;
 
-      vlib_get_next_frame (vm, node, next_index,
-			   to_next, n_left_to_next);
+      vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 
       while (n_left_from >= 4 && n_left_to_next >= 2)
 	{
-          u32 bi0, bi1;
-	  vlib_buffer_t * b0, * b1;
-          u32 next0, next1;
-          u32 sw_if_index0, sw_if_index1;
-          u32 pi0 = 0, pi1 = 0;
-          u8 act0, act1;
-          
+	  u32 bi0, bi1;
+	  vlib_buffer_t *b0, *b1;
+	  u32 next0, next1;
+	  u32 sw_if_index0, sw_if_index1;
+	  u32 pi0 = 0, pi1 = 0;
+	  u8 act0, act1;
+
 	  /* Prefetch next iteration. */
 	  {
-	    vlib_buffer_t * b2, * b3;
-            
+	    vlib_buffer_t *b2, *b3;
+
 	    b2 = vlib_get_buffer (vm, from[2]);
 	    b3 = vlib_get_buffer (vm, from[3]);
-            
+
 	    vlib_prefetch_buffer_header (b2, LOAD);
 	    vlib_prefetch_buffer_header (b3, LOAD);
 	  }
 
-          /* speculatively enqueue b0 and b1 to the current next frame */
+	  /* speculatively enqueue b0 and b1 to the current next frame */
 	  to_next[0] = bi0 = from[0];
 	  to_next[1] = bi1 = from[1];
 	  from += 2;
@@ -177,94 +176,94 @@ uword vnet_policer_inline (vlib_main_t * vm,
 	  b0 = vlib_get_buffer (vm, bi0);
 	  b1 = vlib_get_buffer (vm, bi1);
 
-          sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
-          next0 = VNET_POLICER_NEXT_TRANSMIT;
-
-          sw_if_index1 = vnet_buffer(b1)->sw_if_index[VLIB_RX];
-          next1 = VNET_POLICER_NEXT_TRANSMIT;
-
-
-          if (which == VNET_POLICER_INDEX_BY_SW_IF_INDEX)
-            {
-              pi0 = pm->policer_index_by_sw_if_index[sw_if_index0];
-              pi1 = pm->policer_index_by_sw_if_index[sw_if_index1];
-            }
-
-          if (which == VNET_POLICER_INDEX_BY_OPAQUE)
-            {
-              pi0 = vnet_buffer(b0)->policer.index;
-              pi1 = vnet_buffer(b1)->policer.index;
-            }
-
-          if (which == VNET_POLICER_INDEX_BY_EITHER)
-            {
-              pi0 = vnet_buffer(b0)->policer.index;
-              pi0 = (pi0 != ~0) ? pi0 : 
-                pm->policer_index_by_sw_if_index [sw_if_index0];
-              pi1 = vnet_buffer(b1)->policer.index;
-              pi1 = (pi1 != ~0) ? pi1 : 
-                pm->policer_index_by_sw_if_index [sw_if_index1];
-            }
-
-          act0 = vnet_policer_police(vm, b0, pi0, time_in_policer_periods,
-            POLICE_CONFORM /* no chaining */);
-
-          act1 = vnet_policer_police(vm, b1, pi1, time_in_policer_periods,
-            POLICE_CONFORM /* no chaining */);
-
-          if (PREDICT_FALSE(act0 == SSE2_QOS_ACTION_DROP)) /* drop action */
-            {
-              next0 = VNET_POLICER_NEXT_DROP;
-              b0->error = node->errors[VNET_POLICER_ERROR_DROP];
-            }
-          else /* transmit or mark-and-transmit action */
-            {
-              transmitted++;
-            }
-
-          if (PREDICT_FALSE(act1 == SSE2_QOS_ACTION_DROP)) /* drop action */
-            {
-              next1 = VNET_POLICER_NEXT_DROP;
-              b1->error = node->errors[VNET_POLICER_ERROR_DROP];
-            }
-          else /* transmit or mark-and-transmit action */
-            {
-              transmitted++;
-            }
-
-
-          if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)))
-            {
-              if (b0->flags & VLIB_BUFFER_IS_TRACED) 
-                {
-                  vnet_policer_trace_t *t = 
-                    vlib_add_trace (vm, node, b0, sizeof (*t));
-                  t->sw_if_index = sw_if_index0;
-                  t->next_index = next0;
-                }
-              if (b1->flags & VLIB_BUFFER_IS_TRACED) 
-                {
-                  vnet_policer_trace_t *t = 
-                    vlib_add_trace (vm, node, b1, sizeof (*t));
-                  t->sw_if_index = sw_if_index1;
-                  t->next_index = next1;
-                }
-            }
-            
-          /* verify speculative enqueues, maybe switch current next frame */
-          vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
-                                           to_next, n_left_to_next,
-                                           bi0, bi1, next0, next1);
-        }
-      
+	  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+	  next0 = VNET_POLICER_NEXT_TRANSMIT;
+
+	  sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
+	  next1 = VNET_POLICER_NEXT_TRANSMIT;
+
+
+	  if (which == VNET_POLICER_INDEX_BY_SW_IF_INDEX)
+	    {
+	      pi0 = pm->policer_index_by_sw_if_index[sw_if_index0];
+	      pi1 = pm->policer_index_by_sw_if_index[sw_if_index1];
+	    }
+
+	  if (which == VNET_POLICER_INDEX_BY_OPAQUE)
+	    {
+	      pi0 = vnet_buffer (b0)->policer.index;
+	      pi1 = vnet_buffer (b1)->policer.index;
+	    }
+
+	  if (which == VNET_POLICER_INDEX_BY_EITHER)
+	    {
+	      pi0 = vnet_buffer (b0)->policer.index;
+	      pi0 = (pi0 != ~0) ? pi0 :
+		pm->policer_index_by_sw_if_index[sw_if_index0];
+	      pi1 = vnet_buffer (b1)->policer.index;
+	      pi1 = (pi1 != ~0) ? pi1 :
+		pm->policer_index_by_sw_if_index[sw_if_index1];
+	    }
+
+	  act0 = vnet_policer_police (vm, b0, pi0, time_in_policer_periods,
+				      POLICE_CONFORM /* no chaining */ );
+
+	  act1 = vnet_policer_police (vm, b1, pi1, time_in_policer_periods,
+				      POLICE_CONFORM /* no chaining */ );
+
+	  if (PREDICT_FALSE (act0 == SSE2_QOS_ACTION_DROP))	/* drop action */
+	    {
+	      next0 = VNET_POLICER_NEXT_DROP;
+	      b0->error = node->errors[VNET_POLICER_ERROR_DROP];
+	    }
+	  else			/* transmit or mark-and-transmit action */
+	    {
+	      transmitted++;
+	    }
+
+	  if (PREDICT_FALSE (act1 == SSE2_QOS_ACTION_DROP))	/* drop action */
+	    {
+	      next1 = VNET_POLICER_NEXT_DROP;
+	      b1->error = node->errors[VNET_POLICER_ERROR_DROP];
+	    }
+	  else			/* transmit or mark-and-transmit action */
+	    {
+	      transmitted++;
+	    }
+
+
+	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)))
+	    {
+	      if (b0->flags & VLIB_BUFFER_IS_TRACED)
+		{
+		  vnet_policer_trace_t *t =
+		    vlib_add_trace (vm, node, b0, sizeof (*t));
+		  t->sw_if_index = sw_if_index0;
+		  t->next_index = next0;
+		}
+	      if (b1->flags & VLIB_BUFFER_IS_TRACED)
+		{
+		  vnet_policer_trace_t *t =
+		    vlib_add_trace (vm, node, b1, sizeof (*t));
+		  t->sw_if_index = sw_if_index1;
+		  t->next_index = next1;
+		}
+	    }
+
+	  /* verify speculative enqueues, maybe switch current next frame */
+	  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
+					   to_next, n_left_to_next,
+					   bi0, bi1, next0, next1);
+	}
+
       while (n_left_from > 0 && n_left_to_next > 0)
 	{
-          u32 bi0;
-	  vlib_buffer_t * b0;
-          u32 next0;
-          u32 sw_if_index0;
-          u32 pi0 = 0;
-          u8 act0;
+	  u32 bi0;
+	  vlib_buffer_t *b0;
+	  u32 next0;
+	  u32 sw_if_index0;
+	  u32 pi0 = 0;
+	  u8 act0;
 
 	  bi0 = from[0];
 	  to_next[0] = bi0;
@@ -275,46 +274,46 @@ uword vnet_policer_inline (vlib_main_t * vm,
 
 	  b0 = vlib_get_buffer (vm, bi0);
 
-          sw_if_index0 = vnet_buffer(b0)->sw_if_index[VLIB_RX];
-          next0 = VNET_POLICER_NEXT_TRANSMIT;
-
-          if (which == VNET_POLICER_INDEX_BY_SW_IF_INDEX)
-            pi0 = pm->policer_index_by_sw_if_index[sw_if_index0];
-
-          if (which == VNET_POLICER_INDEX_BY_OPAQUE)
-            pi0 = vnet_buffer(b0)->policer.index;
-
-          if (which == VNET_POLICER_INDEX_BY_EITHER)
-            {
-              pi0 = vnet_buffer(b0)->policer.index;
-              pi0 = (pi0 != ~0) ? pi0 : 
-                pm->policer_index_by_sw_if_index [sw_if_index0];
-            }
-
-          act0 = vnet_policer_police(vm, b0, pi0, time_in_policer_periods,
-            POLICE_CONFORM /* no chaining */);
-
-          if (PREDICT_FALSE(act0 == SSE2_QOS_ACTION_DROP)) /* drop action */
-            {
-              next0 = VNET_POLICER_NEXT_DROP;
-              b0->error = node->errors[VNET_POLICER_ERROR_DROP];
-            }
-          else /* transmit or mark-and-transmit action */
-            {
-              transmitted++;
-            }
-          
-          if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE) 
-                            && (b0->flags & VLIB_BUFFER_IS_TRACED))) 
-            {
-              vnet_policer_trace_t *t = 
-                vlib_add_trace (vm, node, b0, sizeof (*t));
-              t->sw_if_index = sw_if_index0;
-              t->next_index = next0;
-              t->policer_index = pi0;
-            }
-            
-          /* verify speculative enqueue, maybe switch current next frame */
+	  sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+	  next0 = VNET_POLICER_NEXT_TRANSMIT;
+
+	  if (which == VNET_POLICER_INDEX_BY_SW_IF_INDEX)
+	    pi0 = pm->policer_index_by_sw_if_index[sw_if_index0];
+
+	  if (which == VNET_POLICER_INDEX_BY_OPAQUE)
+	    pi0 = vnet_buffer (b0)->policer.index;
+
+	  if (which == VNET_POLICER_INDEX_BY_EITHER)
+	    {
+	      pi0 = vnet_buffer (b0)->policer.index;
+	      pi0 = (pi0 != ~0) ? pi0 :
+		pm->policer_index_by_sw_if_index[sw_if_index0];
+	    }
+
+	  act0 = vnet_policer_police (vm, b0, pi0, time_in_policer_periods,
+				      POLICE_CONFORM /* no chaining */ );
+
+	  if (PREDICT_FALSE (act0 == SSE2_QOS_ACTION_DROP))	/* drop action */
+	    {
+	      next0 = VNET_POLICER_NEXT_DROP;
+	      b0->error = node->errors[VNET_POLICER_ERROR_DROP];
+	    }
+	  else			/* transmit or mark-and-transmit action */
+	    {
+	      transmitted++;
+	    }
+
+	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+			     && (b0->flags & VLIB_BUFFER_IS_TRACED)))
+	    {
+	      vnet_policer_trace_t *t =
+		vlib_add_trace (vm, node, b0, sizeof (*t));
+	      t->sw_if_index = sw_if_index0;
+	      t->next_index = next0;
+	      t->policer_index = pi0;
+	    }
+
+	  /* verify speculative enqueue, maybe switch current next frame */
 	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
 					   to_next, n_left_to_next,
 					   bi0, next0);
@@ -323,53 +322,54 @@ uword vnet_policer_inline (vlib_main_t * vm,
       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
     }
 
-  vlib_node_increment_counter (vm, node->node_index, 
-                               VNET_POLICER_ERROR_TRANSMIT, 
-                               transmitted);
+  vlib_node_increment_counter (vm, node->node_index,
+			       VNET_POLICER_ERROR_TRANSMIT, transmitted);
   return frame->n_vectors;
 }
 
-uword vnet_policer_by_sw_if_index (vlib_main_t * vm,
-                                   vlib_node_runtime_t * node,
-                                   vlib_frame_t * frame)
+uword
+vnet_policer_by_sw_if_index (vlib_main_t * vm,
+			     vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  return vnet_policer_inline (vm, node, frame, 
-                              VNET_POLICER_INDEX_BY_SW_IF_INDEX);
+  return vnet_policer_inline (vm, node, frame,
+			      VNET_POLICER_INDEX_BY_SW_IF_INDEX);
 }
 
-uword vnet_policer_by_opaque (vlib_main_t * vm,
-                              vlib_node_runtime_t * node,
-                              vlib_frame_t * frame)
+uword
+vnet_policer_by_opaque (vlib_main_t * vm,
+			vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  return vnet_policer_inline (vm, node, frame, 
-                              VNET_POLICER_INDEX_BY_OPAQUE);
+  return vnet_policer_inline (vm, node, frame, VNET_POLICER_INDEX_BY_OPAQUE);
 }
 
-uword vnet_policer_by_either (vlib_main_t * vm,
-                              vlib_node_runtime_t * node,
-                              vlib_frame_t * frame)
+uword
+vnet_policer_by_either (vlib_main_t * vm,
+			vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  return vnet_policer_inline (vm, node, frame, 
-                              VNET_POLICER_INDEX_BY_EITHER);
+  return vnet_policer_inline (vm, node, frame, VNET_POLICER_INDEX_BY_EITHER);
 }
 
-void vnet_policer_node_funcs_reference (void) { }
+void
+vnet_policer_node_funcs_reference (void)
+{
+}
 
 
 #define TEST_CODE 1
 
 #ifdef TEST_CODE
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (policer_by_sw_if_index_node, static) = {
   .function = vnet_policer_by_sw_if_index,
   .name = "policer-by-sw-if-index",
   .vector_size = sizeof (u32),
   .format_trace = format_policer_trace,
   .type = VLIB_NODE_TYPE_INTERNAL,
-  
+
   .n_errors = ARRAY_LEN(vnet_policer_error_strings),
   .error_strings = vnet_policer_error_strings,
-  
+
   .n_next_nodes = VNET_POLICER_N_NEXT,
 
   /* edit / add dispositions here */
@@ -381,16 +381,17 @@ VLIB_REGISTER_NODE (policer_by_sw_if_index_node, static) = {
 
 VLIB_NODE_FUNCTION_MULTIARCH (policer_by_sw_if_index_node,
 			      vnet_policer_by_sw_if_index);
+/* *INDENT-ON* */
 
 
-int test_policer_add_del (u32 rx_sw_if_index, u8 *config_name,
-                          int is_add)
+int
+test_policer_add_del (u32 rx_sw_if_index, u8 * config_name, int is_add)
 {
-  vnet_policer_main_t * pm = &vnet_policer_main;  
-  policer_read_response_type_st * template;
-  policer_read_response_type_st * policer;
-  vnet_hw_interface_t * rxhi;
-  uword * p;
+  vnet_policer_main_t *pm = &vnet_policer_main;
+  policer_read_response_type_st *template;
+  policer_read_response_type_st *policer;
+  vnet_hw_interface_t *rxhi;
+  uword *p;
 
   rxhi = vnet_get_sup_hw_interface (pm->vnet_main, rx_sw_if_index);
 
@@ -400,72 +401,70 @@ int test_policer_add_del (u32 rx_sw_if_index, u8 *config_name,
 
   if (is_add)
     {
-      
+
       p = hash_get_mem (pm->policer_config_by_name, config_name);
 
       if (p == 0)
-        return -2;
+	return -2;
 
       template = pool_elt_at_index (pm->policer_templates, p[0]);
 
-      vnet_hw_interface_rx_redirect_to_node 
-        (pm->vnet_main, 
-         rxhi->hw_if_index,
-         policer_by_sw_if_index_node.index);
+      vnet_hw_interface_rx_redirect_to_node
+	(pm->vnet_main, rxhi->hw_if_index, policer_by_sw_if_index_node.index);
 
       pool_get_aligned (pm->policers, policer, CLIB_CACHE_LINE_BYTES);
 
       policer[0] = template[0];
 
       vec_validate (pm->policer_index_by_sw_if_index, rx_sw_if_index);
-      pm->policer_index_by_sw_if_index[rx_sw_if_index] 
-          = policer - pm->policers;
+      pm->policer_index_by_sw_if_index[rx_sw_if_index]
+	= policer - pm->policers;
     }
   else
     {
       u32 pi;
-      vnet_hw_interface_rx_redirect_to_node (pm->vnet_main, 
-                                             rxhi->hw_if_index,
-                                             ~0 /* disable */);
+      vnet_hw_interface_rx_redirect_to_node (pm->vnet_main,
+					     rxhi->hw_if_index,
+					     ~0 /* disable */ );
 
       pi = pm->policer_index_by_sw_if_index[rx_sw_if_index];
       pm->policer_index_by_sw_if_index[rx_sw_if_index] = ~0;
       pool_put_index (pm->policers, pi);
     }
-  
+
   return 0;
 }
 
 static clib_error_t *
 test_policer_command_fn (vlib_main_t * vm,
-                         unformat_input_t * input,
-                         vlib_cli_command_t * cmd)
+			 unformat_input_t * input, vlib_cli_command_t * cmd)
 {
-  vnet_policer_main_t * pm = &vnet_policer_main;  
-  unformat_input_t _line_input, * line_input = &_line_input;
+  vnet_policer_main_t *pm = &vnet_policer_main;
+  unformat_input_t _line_input, *line_input = &_line_input;
   u32 rx_sw_if_index;
   int rv;
-  u8 * config_name = 0;
+  u8 *config_name = 0;
   int rx_set = 0;
   int is_add = 1;
   int is_show = 0;
 
   /* Get a line of input. */
-  if (! unformat_user (input, unformat_line_input, line_input))
+  if (!unformat_user (input, unformat_line_input, line_input))
     return 0;
 
   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (line_input, "intfc %U", unformat_vnet_sw_interface,
-                    pm->vnet_main, &rx_sw_if_index))
-        rx_set = 1;
+		    pm->vnet_main, &rx_sw_if_index))
+	rx_set = 1;
       else if (unformat (line_input, "show"))
-        is_show=1;
+	is_show = 1;
       else if (unformat (line_input, "policer %s", &config_name))
-        ;
+	;
       else if (unformat (line_input, "del"))
-        is_add = 0;
-      else break;
+	is_add = 0;
+      else
+	break;
     }
 
   if (rx_set == 0)
@@ -474,9 +473,9 @@ test_policer_command_fn (vlib_main_t * vm,
   if (is_show)
     {
       u32 pi = pm->policer_index_by_sw_if_index[rx_sw_if_index];
-      policer_read_response_type_st * policer;
+      policer_read_response_type_st *policer;
       policer = pool_elt_at_index (pm->policers, pi);
-      
+
       vlib_cli_output (vm, "%U", format_policer_instance, policer);
       return 0;
     }
@@ -494,25 +493,27 @@ test_policer_command_fn (vlib_main_t * vm,
       break;
 
     default:
-      return clib_error_return 
-        (0, "WARNING: vnet_vnet_policer_add_del returned %d", rv);
+      return clib_error_return
+	(0, "WARNING: vnet_vnet_policer_add_del returned %d", rv);
     }
-  
+
   return 0;
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (test_patch_command, static) = {
     .path = "test policer",
-    .short_help = 
+    .short_help =
     "intfc <intfc> policer <policer-config-name> [del]",
     .function = test_policer_command_fn,
 };
-
+/* *INDENT-ON* */
 
 #endif /* TEST_CODE */
 
 
-typedef struct {
+typedef struct
+{
   u32 sw_if_index;
   u32 next_index;
   u32 table_index;
@@ -525,12 +526,12 @@ format_policer_classify_trace (u8 * s, va_list * args)
 {
   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
   CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
-  policer_classify_trace_t * t = va_arg (*args, policer_classify_trace_t *);
+  policer_classify_trace_t *t = va_arg (*args, policer_classify_trace_t *);
 
   s = format (s, "POLICER_CLASSIFY: sw_if_index %d next %d table %d offset %d"
-              " policer_index %d",
-              t->sw_if_index, t->next_index, t->table_index, t->offset,
-              t->policer_index);
+	      " policer_index %d",
+	      t->sw_if_index, t->next_index, t->table_index, t->offset,
+	      t->policer_index);
   return s;
 }
 
@@ -540,14 +541,15 @@ _(HIT, "Policer classify hits")                        \
 _(CHAIN_HIT, "Polcier classify hits after chain walk") \
 _(DROP, "Policer classify action drop")
 
-typedef enum {
+typedef enum
+{
 #define _(sym,str) POLICER_CLASSIFY_ERROR_##sym,
   foreach_policer_classify_error
 #undef _
-  POLICER_CLASSIFY_N_ERROR,
+    POLICER_CLASSIFY_N_ERROR,
 } policer_classify_error_t;
 
-static char * policer_classify_error_strings[] = {
+static char *policer_classify_error_strings[] = {
 #define _(sym,string) string,
   foreach_policer_classify_error
 #undef _
@@ -555,14 +557,14 @@ static char * policer_classify_error_strings[] = {
 
 static inline uword
 policer_classify_inline (vlib_main_t * vm,
-                         vlib_node_runtime_t * node,
-                         vlib_frame_t * frame,
-                         policer_classify_table_id_t tid)
+			 vlib_node_runtime_t * node,
+			 vlib_frame_t * frame,
+			 policer_classify_table_id_t tid)
 {
-  u32 n_left_from, * from, * to_next;
+  u32 n_left_from, *from, *to_next;
   policer_classify_next_index_t next_index;
-  policer_classify_main_t * pcm = &policer_classify_main;
-  vnet_classify_main_t * vcm = pcm->vnet_classify_main;
+  policer_classify_main_t *pcm = &policer_classify_main;
+  vnet_classify_main_t *vcm = pcm->vnet_classify_main;
   f64 now = vlib_time_now (vm);
   u32 hits = 0;
   u32 misses = 0;
@@ -572,7 +574,7 @@ policer_classify_inline (vlib_main_t * vm,
   u64 time_in_policer_periods;
 
   time_in_policer_periods =
-    clib_cpu_time_now() >> POLICER_TICKS_PER_PERIOD_SHIFT;
+    clib_cpu_time_now () >> POLICER_TICKS_PER_PERIOD_SHIFT;
 
   n_next_nodes = node->n_next_nodes;
 
@@ -582,24 +584,24 @@ policer_classify_inline (vlib_main_t * vm,
   /* First pass: compute hashes */
   while (n_left_from > 2)
     {
-      vlib_buffer_t * b0, * b1;
+      vlib_buffer_t *b0, *b1;
       u32 bi0, bi1;
-      u8 * h0, * h1;
+      u8 *h0, *h1;
       u32 sw_if_index0, sw_if_index1;
       u32 table_index0, table_index1;
-      vnet_classify_table_t * t0, * t1;
+      vnet_classify_table_t *t0, *t1;
 
       /* Prefetch next iteration */
       {
-        vlib_buffer_t * p1, * p2;
+	vlib_buffer_t *p1, *p2;
 
-        p1 = vlib_get_buffer (vm, from[1]);
-        p2 = vlib_get_buffer (vm, from[2]);
+	p1 = vlib_get_buffer (vm, from[1]);
+	p2 = vlib_get_buffer (vm, from[2]);
 
-        vlib_prefetch_buffer_header (p1, STORE);
-        CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE);
-        vlib_prefetch_buffer_header (p2, STORE);
-        CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
+	vlib_prefetch_buffer_header (p1, STORE);
+	CLIB_PREFETCH (p1->data, CLIB_CACHE_LINE_BYTES, STORE);
+	vlib_prefetch_buffer_header (p2, STORE);
+	CLIB_PREFETCH (p2->data, CLIB_CACHE_LINE_BYTES, STORE);
       }
 
       bi0 = from[0];
@@ -611,28 +613,30 @@ policer_classify_inline (vlib_main_t * vm,
       h1 = b1->data;
 
       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
-      table_index0 = pcm->classify_table_index_by_sw_if_index[tid][sw_if_index0];
+      table_index0 =
+	pcm->classify_table_index_by_sw_if_index[tid][sw_if_index0];
 
       sw_if_index1 = vnet_buffer (b1)->sw_if_index[VLIB_RX];
-      table_index1 = pcm->classify_table_index_by_sw_if_index[tid][sw_if_index1];
+      table_index1 =
+	pcm->classify_table_index_by_sw_if_index[tid][sw_if_index1];
 
       t0 = pool_elt_at_index (vcm->tables, table_index0);
 
       t1 = pool_elt_at_index (vcm->tables, table_index1);
 
-      vnet_buffer(b0)->l2_classify.hash =
-        vnet_classify_hash_packet (t0, (u8 *) h0);
+      vnet_buffer (b0)->l2_classify.hash =
+	vnet_classify_hash_packet (t0, (u8 *) h0);
 
-      vnet_classify_prefetch_bucket (t0, vnet_buffer(b0)->l2_classify.hash);
+      vnet_classify_prefetch_bucket (t0, vnet_buffer (b0)->l2_classify.hash);
 
-      vnet_buffer(b1)->l2_classify.hash =
-        vnet_classify_hash_packet (t1, (u8 *) h1);
+      vnet_buffer (b1)->l2_classify.hash =
+	vnet_classify_hash_packet (t1, (u8 *) h1);
 
-      vnet_classify_prefetch_bucket (t1, vnet_buffer(b1)->l2_classify.hash);
+      vnet_classify_prefetch_bucket (t1, vnet_buffer (b1)->l2_classify.hash);
 
-      vnet_buffer(b0)->l2_classify.table_index = table_index0;
+      vnet_buffer (b0)->l2_classify.table_index = table_index0;
 
-      vnet_buffer(b1)->l2_classify.table_index = table_index1;
+      vnet_buffer (b1)->l2_classify.table_index = table_index1;
 
       from += 2;
       n_left_from -= 2;
@@ -640,26 +644,27 @@ policer_classify_inline (vlib_main_t * vm,
 
   while (n_left_from > 0)
     {
-      vlib_buffer_t * b0;
+      vlib_buffer_t *b0;
       u32 bi0;
-      u8 * h0;
+      u8 *h0;
       u32 sw_if_index0;
       u32 table_index0;
-      vnet_classify_table_t * t0;
+      vnet_classify_table_t *t0;
 
       bi0 = from[0];
       b0 = vlib_get_buffer (vm, bi0);
       h0 = b0->data;
 
       sw_if_index0 = vnet_buffer (b0)->sw_if_index[VLIB_RX];
-      table_index0 = pcm->classify_table_index_by_sw_if_index[tid][sw_if_index0];
+      table_index0 =
+	pcm->classify_table_index_by_sw_if_index[tid][sw_if_index0];
 
       t0 = pool_elt_at_index (vcm->tables, table_index0);
-      vnet_buffer(b0)->l2_classify.hash =
-        vnet_classify_hash_packet (t0, (u8 *) h0);
+      vnet_buffer (b0)->l2_classify.hash =
+	vnet_classify_hash_packet (t0, (u8 *) h0);
 
-      vnet_buffer(b0)->l2_classify.table_index = table_index0;
-      vnet_classify_prefetch_bucket (t0, vnet_buffer(b0)->l2_classify.hash);
+      vnet_buffer (b0)->l2_classify.table_index = table_index0;
+      vnet_classify_prefetch_bucket (t0, vnet_buffer (b0)->l2_classify.hash);
 
       from++;
       n_left_from--;
@@ -677,169 +682,170 @@ policer_classify_inline (vlib_main_t * vm,
 
       /* Not enough load/store slots to dual loop... */
       while (n_left_from > 0 && n_left_to_next > 0)
-        {
-          u32 bi0;
-          vlib_buffer_t * b0;
-          u32 next0 = POLICER_CLASSIFY_NEXT_INDEX_DROP;
-          u32 table_index0;
-          vnet_classify_table_t * t0;
-          vnet_classify_entry_t * e0;
-          u64 hash0;
-          u8 * h0;
-          u8 act0;
-
-          /* Stride 3 seems to work best */
-          if (PREDICT_TRUE (n_left_from > 3))
-            {
-              vlib_buffer_t * p1 = vlib_get_buffer(vm, from[3]);
-              vnet_classify_table_t * tp1;
-              u32 table_index1;
-              u64 phash1;
-
-              table_index1 = vnet_buffer(p1)->l2_classify.table_index;
-
-              if (PREDICT_TRUE (table_index1 != ~0))
-                {
-                  tp1 = pool_elt_at_index (vcm->tables, table_index1);
-                  phash1 = vnet_buffer(p1)->l2_classify.hash;
-                  vnet_classify_prefetch_entry (tp1, phash1);
-                }
-            }
-
-          /* Speculatively enqueue b0 to the current next frame */
-          bi0 = from[0];
-          to_next[0] = bi0;
-          from += 1;
-          to_next += 1;
-          n_left_from -= 1;
-          n_left_to_next -= 1;
-
-          b0 = vlib_get_buffer (vm, bi0);
-          h0 = b0->data;
-          table_index0 = vnet_buffer(b0)->l2_classify.table_index;
-          e0 = 0;
-          t0 = 0;
-
-          if (tid == POLICER_CLASSIFY_TABLE_L2)
-            {
-              /* Feature bitmap update */
-              vnet_buffer(b0)->l2.feature_bitmap &= ~L2INPUT_FEAT_POLICER_CLAS;
-              /* Determine the next node */
-              next0 = feat_bitmap_get_next_node_index(pcm->feat_next_node_index,
-                vnet_buffer(b0)->l2.feature_bitmap);
-            }
-          else
-            vnet_get_config_data (pcm->vnet_config_main[tid],
-                                  &b0->current_config_index,
-                                  &next0,
-                                  /* # bytes of config data */ 0);
-
-          vnet_buffer(b0)->l2_classify.opaque_index = ~0;
-
-          if (PREDICT_TRUE(table_index0 != ~0))
-            {
-              hash0 = vnet_buffer(b0)->l2_classify.hash;
-              t0 = pool_elt_at_index (vcm->tables, table_index0);
-              e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
-
-              if (e0)
-                {
-                  act0 = vnet_policer_police(vm,
-                                             b0,
-                                             e0->next_index,
-                                             time_in_policer_periods,
-                                             e0->opaque_index);
-                  if (PREDICT_FALSE(act0 == SSE2_QOS_ACTION_DROP))
-                    {
-                      next0 = POLICER_CLASSIFY_NEXT_INDEX_DROP;
-                      b0->error = node->errors[POLICER_CLASSIFY_ERROR_DROP];
-                      drop++;
-                    }
-                  hits++;
-                }
-              else
-                {
-                  while (1)
-                    {
-                      if (PREDICT_TRUE(t0->next_table_index != ~0))
-                        {
-                          t0 = pool_elt_at_index (vcm->tables,
-                                                  t0->next_table_index);
-                        }
-                      else
-                        {
-                          next0 = (t0->miss_next_index < n_next_nodes)?
-                                   t0->miss_next_index:next0;
-                          misses++;
-                          break;
-                        }
-
-                      hash0 = vnet_classify_hash_packet (t0, (u8 *) h0);
-                      e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
-                      if (e0)
-                        {
-                          act0 = vnet_policer_police(vm,
-                                                     b0,
-                                                     e0->next_index,
-                                                     time_in_policer_periods,
-                                                     e0->opaque_index);
-                          if (PREDICT_FALSE(act0 == SSE2_QOS_ACTION_DROP))
-                            {
-                              next0 = POLICER_CLASSIFY_NEXT_INDEX_DROP;
-                              b0->error = node->errors[POLICER_CLASSIFY_ERROR_DROP];
-                              drop++;
-                            }
-                          hits++;
-                          chain_hits++;
-                          break;
-                        }
-                    }
-                }
-            }
-          if (PREDICT_FALSE((node->flags & VLIB_NODE_FLAG_TRACE)
-                            && (b0->flags & VLIB_BUFFER_IS_TRACED)))
-            {
-              policer_classify_trace_t * t =
-                vlib_add_trace (vm, node, b0, sizeof (*t));
-              t->sw_if_index = vnet_buffer(b0)->sw_if_index[VLIB_RX];
-              t->next_index = next0;
-              t->table_index = t0 ? t0 - vcm->tables : ~0;
-              t->offset = (e0 && t0) ? vnet_classify_get_offset (t0, e0): ~0;
-              t->policer_index = e0 ? e0->next_index: ~0;
-            }
-
-          /* Verify speculative enqueue, maybe switch current next frame */
-          vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
-                                           n_left_to_next, bi0, next0);
-        }
+	{
+	  u32 bi0;
+	  vlib_buffer_t *b0;
+	  u32 next0 = POLICER_CLASSIFY_NEXT_INDEX_DROP;
+	  u32 table_index0;
+	  vnet_classify_table_t *t0;
+	  vnet_classify_entry_t *e0;
+	  u64 hash0;
+	  u8 *h0;
+	  u8 act0;
+
+	  /* Stride 3 seems to work best */
+	  if (PREDICT_TRUE (n_left_from > 3))
+	    {
+	      vlib_buffer_t *p1 = vlib_get_buffer (vm, from[3]);
+	      vnet_classify_table_t *tp1;
+	      u32 table_index1;
+	      u64 phash1;
+
+	      table_index1 = vnet_buffer (p1)->l2_classify.table_index;
+
+	      if (PREDICT_TRUE (table_index1 != ~0))
+		{
+		  tp1 = pool_elt_at_index (vcm->tables, table_index1);
+		  phash1 = vnet_buffer (p1)->l2_classify.hash;
+		  vnet_classify_prefetch_entry (tp1, phash1);
+		}
+	    }
+
+	  /* Speculatively enqueue b0 to the current next frame */
+	  bi0 = from[0];
+	  to_next[0] = bi0;
+	  from += 1;
+	  to_next += 1;
+	  n_left_from -= 1;
+	  n_left_to_next -= 1;
+
+	  b0 = vlib_get_buffer (vm, bi0);
+	  h0 = b0->data;
+	  table_index0 = vnet_buffer (b0)->l2_classify.table_index;
+	  e0 = 0;
+	  t0 = 0;
+
+	  if (tid == POLICER_CLASSIFY_TABLE_L2)
+	    {
+	      /* Feature bitmap update */
+	      vnet_buffer (b0)->l2.feature_bitmap &=
+		~L2INPUT_FEAT_POLICER_CLAS;
+	      /* Determine the next node */
+	      next0 =
+		feat_bitmap_get_next_node_index (pcm->feat_next_node_index,
+						 vnet_buffer (b0)->
+						 l2.feature_bitmap);
+	    }
+	  else
+	    vnet_get_config_data (pcm->vnet_config_main[tid],
+				  &b0->current_config_index, &next0,
+				  /* # bytes of config data */ 0);
+
+	  vnet_buffer (b0)->l2_classify.opaque_index = ~0;
+
+	  if (PREDICT_TRUE (table_index0 != ~0))
+	    {
+	      hash0 = vnet_buffer (b0)->l2_classify.hash;
+	      t0 = pool_elt_at_index (vcm->tables, table_index0);
+	      e0 = vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
+
+	      if (e0)
+		{
+		  act0 = vnet_policer_police (vm,
+					      b0,
+					      e0->next_index,
+					      time_in_policer_periods,
+					      e0->opaque_index);
+		  if (PREDICT_FALSE (act0 == SSE2_QOS_ACTION_DROP))
+		    {
+		      next0 = POLICER_CLASSIFY_NEXT_INDEX_DROP;
+		      b0->error = node->errors[POLICER_CLASSIFY_ERROR_DROP];
+		      drop++;
+		    }
+		  hits++;
+		}
+	      else
+		{
+		  while (1)
+		    {
+		      if (PREDICT_TRUE (t0->next_table_index != ~0))
+			{
+			  t0 = pool_elt_at_index (vcm->tables,
+						  t0->next_table_index);
+			}
+		      else
+			{
+			  next0 = (t0->miss_next_index < n_next_nodes) ?
+			    t0->miss_next_index : next0;
+			  misses++;
+			  break;
+			}
+
+		      hash0 = vnet_classify_hash_packet (t0, (u8 *) h0);
+		      e0 =
+			vnet_classify_find_entry (t0, (u8 *) h0, hash0, now);
+		      if (e0)
+			{
+			  act0 = vnet_policer_police (vm,
+						      b0,
+						      e0->next_index,
+						      time_in_policer_periods,
+						      e0->opaque_index);
+			  if (PREDICT_FALSE (act0 == SSE2_QOS_ACTION_DROP))
+			    {
+			      next0 = POLICER_CLASSIFY_NEXT_INDEX_DROP;
+			      b0->error =
+				node->errors[POLICER_CLASSIFY_ERROR_DROP];
+			      drop++;
+			    }
+			  hits++;
+			  chain_hits++;
+			  break;
+			}
+		    }
+		}
+	    }
+	  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE)
+			     && (b0->flags & VLIB_BUFFER_IS_TRACED)))
+	    {
+	      policer_classify_trace_t *t =
+		vlib_add_trace (vm, node, b0, sizeof (*t));
+	      t->sw_if_index = vnet_buffer (b0)->sw_if_index[VLIB_RX];
+	      t->next_index = next0;
+	      t->table_index = t0 ? t0 - vcm->tables : ~0;
+	      t->offset = (e0 && t0) ? vnet_classify_get_offset (t0, e0) : ~0;
+	      t->policer_index = e0 ? e0->next_index : ~0;
+	    }
+
+	  /* Verify speculative enqueue, maybe switch current next frame */
+	  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
+					   n_left_to_next, bi0, next0);
+	}
 
       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
     }
 
   vlib_node_increment_counter (vm, node->node_index,
-                               POLICER_CLASSIFY_ERROR_MISS,
-                               misses);
+			       POLICER_CLASSIFY_ERROR_MISS, misses);
   vlib_node_increment_counter (vm, node->node_index,
-                               POLICER_CLASSIFY_ERROR_HIT,
-                               hits);
+			       POLICER_CLASSIFY_ERROR_HIT, hits);
   vlib_node_increment_counter (vm, node->node_index,
-                               POLICER_CLASSIFY_ERROR_CHAIN_HIT,
-                               chain_hits);
+			       POLICER_CLASSIFY_ERROR_CHAIN_HIT, chain_hits);
   vlib_node_increment_counter (vm, node->node_index,
-                               POLICER_CLASSIFY_ERROR_DROP,
-                               drop);
+			       POLICER_CLASSIFY_ERROR_DROP, drop);
 
   return frame->n_vectors;
 }
 
 static uword
 ip4_policer_classify (vlib_main_t * vm,
-                      vlib_node_runtime_t * node,
-                      vlib_frame_t * frame)
+		      vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  return policer_classify_inline(vm, node, frame, POLICER_CLASSIFY_TABLE_IP4);
+  return policer_classify_inline (vm, node, frame,
+				  POLICER_CLASSIFY_TABLE_IP4);
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (ip4_policer_classify_node) = {
   .function = ip4_policer_classify,
   .name = "ip4-policer-classify",
@@ -854,15 +860,17 @@ VLIB_REGISTER_NODE (ip4_policer_classify_node) = {
 };
 
 VLIB_NODE_FUNCTION_MULTIARCH (ip4_policer_classify_node, ip4_policer_classify);
+/* *INDENT-ON* */
 
 static uword
 ip6_policer_classify (vlib_main_t * vm,
-                      vlib_node_runtime_t * node,
-                      vlib_frame_t * frame)
+		      vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  return policer_classify_inline(vm, node, frame, POLICER_CLASSIFY_TABLE_IP6);
+  return policer_classify_inline (vm, node, frame,
+				  POLICER_CLASSIFY_TABLE_IP6);
 }
 
+/* *INDENT-OFF* */
 VLIB_REGISTER_NODE (ip6_policer_classify_node) = {
   .function = ip6_policer_classify,
   .name = "ip6-policer-classify",
@@ -877,48 +885,54 @@ VLIB_REGISTER_NODE (ip6_policer_classify_node) = {
 };
 
 VLIB_NODE_FUNCTION_MULTIARCH (ip6_policer_classify_node, ip6_policer_classify);
+/* *INDENT-ON* */
 
 static uword
 l2_policer_classify (vlib_main_t * vm,
-                     vlib_node_runtime_t * node,
-                     vlib_frame_t * frame)
+		     vlib_node_runtime_t * node, vlib_frame_t * frame)
 {
-  return policer_classify_inline(vm, node, frame, POLICER_CLASSIFY_TABLE_L2);
+  return policer_classify_inline (vm, node, frame, POLICER_CLASSIFY_TABLE_L2);
 }
 
-VLIB_REGISTER_NODE (l2_policer_classify_node) = {
-  .function = l2_policer_classify,
-  .name = "l2-policer-classify",
-  .vector_size = sizeof (u32),
-  .format_trace = format_policer_classify_trace,
-  .n_errors = ARRAY_LEN(policer_classify_error_strings),
-  .error_strings = policer_classify_error_strings,
-  .n_next_nodes = POLICER_CLASSIFY_NEXT_INDEX_N_NEXT,
-  .next_nodes = {
-    [POLICER_CLASSIFY_NEXT_INDEX_DROP] = "error-drop",
-  },
-};
+VLIB_REGISTER_NODE (l2_policer_classify_node) =
+{
+  .function = l2_policer_classify,.name = "l2-policer-classify",.vector_size =
+    sizeof (u32),.format_trace = format_policer_classify_trace,.n_errors =
+    ARRAY_LEN (policer_classify_error_strings),.error_strings =
+    policer_classify_error_strings,.n_next_nodes =
+    POLICER_CLASSIFY_NEXT_INDEX_N_NEXT,.next_nodes =
+  {
+  [POLICER_CLASSIFY_NEXT_INDEX_DROP] = "error-drop",}
+,};
 
 VLIB_NODE_FUNCTION_MULTIARCH (l2_policer_classify_node, l2_policer_classify);
 
 
 static clib_error_t *
-policer_classify_init (vlib_main_t *vm)
+policer_classify_init (vlib_main_t * vm)
 {
-  policer_classify_main_t * pcm = &policer_classify_main;
+  policer_classify_main_t *pcm = &policer_classify_main;
 
   pcm->vlib_main = vm;
-  pcm->vnet_main = vnet_get_main();
+  pcm->vnet_main = vnet_get_main ();
   pcm->vnet_classify_main = &vnet_classify_main;
 
   /* Initialize L2 feature next-node indexes */
-  feat_bitmap_init_next_nodes(vm,
-                              l2_policer_classify_node.index,
-                              L2INPUT_N_FEAT,
-                              l2input_get_feat_names(),
-                              pcm->feat_next_node_index);
+  feat_bitmap_init_next_nodes (vm,
+			       l2_policer_classify_node.index,
+			       L2INPUT_N_FEAT,
+			       l2input_get_feat_names (),
+			       pcm->feat_next_node_index);
 
   return 0;
 }
 
 VLIB_INIT_FUNCTION (policer_classify_init);
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/policer/police.h b/vnet/vnet/policer/police.h
index 89f5ffee2ad..34bcf9ca5a8 100644
--- a/vnet/vnet/policer/police.h
+++ b/vnet/vnet/policer/police.h
@@ -15,15 +15,16 @@
 #ifndef __POLICE_H__
 #define __POLICE_H__
 
-typedef enum {
-    POLICE_CONFORM = 0,
-    POLICE_EXCEED  = 1,
-    POLICE_VIOLATE = 2,
+typedef enum
+{
+  POLICE_CONFORM = 0,
+  POLICE_EXCEED = 1,
+  POLICE_VIOLATE = 2,
 } policer_result_e;
 
 // This is the hardware representation of the policer.
 // To be multithread-safe, the policer is accessed through a spin-lock
-// on the lock field. (For a policer update operation, 24B needs to be 
+// on the lock field. (For a policer update operation, 24B needs to be
 // modified and this would be a challenge to do with atomic instructions.)
 // The structure is padded so that no other data is put into the same
 // 64B cache-line. This reduces cache-thrashing between threads.
@@ -33,148 +34,181 @@ typedef enum {
 // This is shifted to create a larger period, with a goal to be around 50usec.
 // The period time will vary based on CPU clock speed.
 // CPU speeds of 1Ghz to 8Ghz are targetted.
-// The shift amount is a constant 17 bits, resulting in a period between 
+// The shift amount is a constant 17 bits, resulting in a period between
 // 16usec (8Ghz CPU) and 131usec (1Ghz CPU).
 // The token_per_period computation takes into account the clock speed.
 //
 // The 32-bit bucket/limit supports about 850ms of burst on a 40GE port,
-// or 340ms on a 100GE port. If a larger burst is configued, then the 
-// programmed value is simply capped at 2^32-1. If we needed to support 
+// or 340ms on a 100GE port. If a larger burst is configued, then the
+// programmed value is simply capped at 2^32-1. If we needed to support
 // more than that, the bucket and limit fields could be expanded.
 //
 // tokens_per_period should be > 1000 to support 0.1% granularity.
-// To support lower rates (which would not meet this requirement), the packet 
+// To support lower rates (which would not meet this requirement), the packet
 // length, bucket, and limit values can be scaled. The scale is a power of 2
-// so the multiplication can be implemented as a shift. The control plane 
-// computes the shift amount be the largest possible that still supports the 
-// burst size. This makes the rate accuracy as high as possible. 
+// so the multiplication can be implemented as a shift. The control plane
+// computes the shift amount be the largest possible that still supports the
+// burst size. This makes the rate accuracy as high as possible.
 //
 // The 64-bit last_update_time supports a 4Ghz CPU without rollover for 100 years
 //
-// The lock field should be used for a spin-lock on the struct. 
+// The lock field should be used for a spin-lock on the struct.
 
 #define POLICER_TICKS_PER_PERIOD_SHIFT 17
 #define POLICER_TICKS_PER_PERIOD       (1 << POLICER_TICKS_PER_PERIOD_SHIFT)
 
-typedef struct {
+typedef struct
+{
 
-    uint32_t lock;           // for exclusive access to the struct
+  u32 lock;			// for exclusive access to the struct
 
-    uint32_t single_rate;    // 1 = single rate policer, 0 = two rate policer
-    uint32_t color_aware;    // for hierarchical policing
-    uint32_t scale;          // power-of-2 shift amount for lower rates
-    uint8_t action[3];
-    uint8_t mark_dscp[3];
-    uint8_t pad[2];
+  u32 single_rate;		// 1 = single rate policer, 0 = two rate policer
+  u32 color_aware;		// for hierarchical policing
+  u32 scale;			// power-of-2 shift amount for lower rates
+  u8 action[3];
+  u8 mark_dscp[3];
+  u8 pad[2];
 
-    // Fields are marked as 2R if they are only used for a 2-rate policer,
-    // and MOD if they are modified as part of the update operation.
-    // 1 token = 1 byte.
+  // Fields are marked as 2R if they are only used for a 2-rate policer,
+  // and MOD if they are modified as part of the update operation.
+  // 1 token = 1 byte.
 
-    uint32_t cir_tokens_per_period;      // # of tokens for each period
-    uint32_t pir_tokens_per_period;      // 2R
+  u32 cir_tokens_per_period;	// # of tokens for each period
+  u32 pir_tokens_per_period;	// 2R
 
-    uint32_t current_limit;
-    uint32_t current_bucket;             // MOD
-    uint32_t extended_limit;
-    uint32_t extended_bucket;            // MOD
+  u32 current_limit;
+  u32 current_bucket;		// MOD
+  u32 extended_limit;
+  u32 extended_bucket;		// MOD
 
-    uint64_t last_update_time;           // MOD
-    uint64_t pad64;
+  u64 last_update_time;		// MOD
+  u64 pad64;
 
 } policer_read_response_type_st;
 
 static inline policer_result_e
-vnet_police_packet (policer_read_response_type_st *policer,
-                    uint32_t packet_length,
-                    policer_result_e packet_color,
-                    uint64_t time)
+vnet_police_packet (policer_read_response_type_st * policer,
+		    u32 packet_length,
+		    policer_result_e packet_color, u64 time)
 {
-  uint64_t n_periods;
-  uint64_t current_tokens, extended_tokens; 
+  u64 n_periods;
+  u64 current_tokens, extended_tokens;
   policer_result_e result;
-    
+
   // Scale packet length to support a wide range of speeds
   packet_length = packet_length << policer->scale;
 
   // Compute the number of policer periods that have passed since the last
-  // operation. 
+  // operation.
   n_periods = time - policer->last_update_time;
   policer->last_update_time = time;
 
-  // Since there is no background last-update-time adjustment, n_periods 
+  // Since there is no background last-update-time adjustment, n_periods
   // could grow large if the policer is idle for a long time. This could
   // cause a 64-bit overflow when computing tokens_per_period * num_periods.
   // It will overflow if log2(n_periods) + log2(tokens_per_period) > 64.
   //
   // To mitigate this, the policer configuration algorithm insures that
   // tokens_per_period is less than 2^22, i.e. this is a 22 bit value not
-  // a 32-bit value. Thus overflow will only occur if n_periods > 64-22 or 
+  // a 32-bit value. Thus overflow will only occur if n_periods > 64-22 or
   // 42. 2^42 min-sized periods is 16us * 2^42, or 2 years. So this can
-  // rarely occur. If overflow does happen, the only effect will be that 
+  // rarely occur. If overflow does happen, the only effect will be that
   // fewer tokens than the max burst will be added to the bucket for this
   // packet. This constraint on tokens_per_period lets the ucode omit
   // code to dynamically check for or prevent the overflow.
 
-  if (policer->single_rate) {
-
-    // Compute number of tokens for this time period
-    current_tokens = policer->current_bucket + n_periods * policer->cir_tokens_per_period;
-    if (current_tokens > policer->current_limit) {
-      current_tokens = policer->current_limit;
-    }
-
-    extended_tokens = policer->extended_bucket + n_periods * policer->cir_tokens_per_period;
-    if (extended_tokens > policer->extended_limit) {
-      extended_tokens = policer->extended_limit;
-    }
-
-    // Determine color
-
-    if ((!policer->color_aware || (packet_color == POLICE_CONFORM)) && (current_tokens >= packet_length)) {
-      policer->current_bucket = current_tokens - packet_length;
-      policer->extended_bucket = extended_tokens - packet_length;
-      result = POLICE_CONFORM;
-    } else if ((!policer->color_aware || (packet_color != POLICE_VIOLATE)) && (extended_tokens >= packet_length)) {
-      policer->current_bucket = current_tokens;
-      policer->extended_bucket = extended_tokens - packet_length;
-      result = POLICE_EXCEED;
-    } else {
-      policer->current_bucket = current_tokens;
-      policer->extended_bucket = extended_tokens;
-      result = POLICE_VIOLATE;
-    }
-
-  } else {
-    // Two-rate policer
+  if (policer->single_rate)
+    {
+
+      // Compute number of tokens for this time period
+      current_tokens =
+	policer->current_bucket + n_periods * policer->cir_tokens_per_period;
+      if (current_tokens > policer->current_limit)
+	{
+	  current_tokens = policer->current_limit;
+	}
+
+      extended_tokens =
+	policer->extended_bucket + n_periods * policer->cir_tokens_per_period;
+      if (extended_tokens > policer->extended_limit)
+	{
+	  extended_tokens = policer->extended_limit;
+	}
+
+      // Determine color
+
+      if ((!policer->color_aware || (packet_color == POLICE_CONFORM))
+	  && (current_tokens >= packet_length))
+	{
+	  policer->current_bucket = current_tokens - packet_length;
+	  policer->extended_bucket = extended_tokens - packet_length;
+	  result = POLICE_CONFORM;
+	}
+      else if ((!policer->color_aware || (packet_color != POLICE_VIOLATE))
+	       && (extended_tokens >= packet_length))
+	{
+	  policer->current_bucket = current_tokens;
+	  policer->extended_bucket = extended_tokens - packet_length;
+	  result = POLICE_EXCEED;
+	}
+      else
+	{
+	  policer->current_bucket = current_tokens;
+	  policer->extended_bucket = extended_tokens;
+	  result = POLICE_VIOLATE;
+	}
 
-    // Compute number of tokens for this time period
-    current_tokens = policer->current_bucket + n_periods * policer->cir_tokens_per_period;
-    extended_tokens = policer->extended_bucket + n_periods * policer->pir_tokens_per_period;
-    if (current_tokens > policer->current_limit) {
-      current_tokens = policer->current_limit;
     }
-    if (extended_tokens > policer->extended_limit) {
-      extended_tokens = policer->extended_limit;
-    }
-
-    // Determine color
-
-    if ((policer->color_aware && (packet_color == POLICE_VIOLATE)) || (extended_tokens < packet_length)) {
-      policer->current_bucket = current_tokens;
-      policer->extended_bucket = extended_tokens;
-      result = POLICE_VIOLATE;
-    } else if ((policer->color_aware && (packet_color == POLICE_EXCEED)) || (current_tokens < packet_length)) {
-      policer->current_bucket = current_tokens;
-      policer->extended_bucket = extended_tokens - packet_length;
-      result = POLICE_EXCEED;
-    } else {
-      policer->current_bucket = current_tokens - packet_length;
-      policer->extended_bucket = extended_tokens - packet_length;
-      result = POLICE_CONFORM;
+  else
+    {
+      // Two-rate policer
+
+      // Compute number of tokens for this time period
+      current_tokens =
+	policer->current_bucket + n_periods * policer->cir_tokens_per_period;
+      extended_tokens =
+	policer->extended_bucket + n_periods * policer->pir_tokens_per_period;
+      if (current_tokens > policer->current_limit)
+	{
+	  current_tokens = policer->current_limit;
+	}
+      if (extended_tokens > policer->extended_limit)
+	{
+	  extended_tokens = policer->extended_limit;
+	}
+
+      // Determine color
+
+      if ((policer->color_aware && (packet_color == POLICE_VIOLATE))
+	  || (extended_tokens < packet_length))
+	{
+	  policer->current_bucket = current_tokens;
+	  policer->extended_bucket = extended_tokens;
+	  result = POLICE_VIOLATE;
+	}
+      else if ((policer->color_aware && (packet_color == POLICE_EXCEED))
+	       || (current_tokens < packet_length))
+	{
+	  policer->current_bucket = current_tokens;
+	  policer->extended_bucket = extended_tokens - packet_length;
+	  result = POLICE_EXCEED;
+	}
+      else
+	{
+	  policer->current_bucket = current_tokens - packet_length;
+	  policer->extended_bucket = extended_tokens - packet_length;
+	  result = POLICE_CONFORM;
+	}
     }
-  }
   return result;
 }
 
 #endif // __POLICE_H__
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/policer/policer.c b/vnet/vnet/policer/policer.c
index f60f7a74ebd..290a6af57e2 100644
--- a/vnet/vnet/policer/policer.c
+++ b/vnet/vnet/policer/policer.c
@@ -17,16 +17,15 @@
 #include <vnet/classify/vnet_classify.h>
 
 clib_error_t *
-policer_add_del (vlib_main_t *vm,
-                 u8 * name,
-                 sse2_qos_pol_cfg_params_st * cfg,
-                 u32 * policer_index,
-                 u8 is_add)
+policer_add_del (vlib_main_t * vm,
+		 u8 * name,
+		 sse2_qos_pol_cfg_params_st * cfg,
+		 u32 * policer_index, u8 is_add)
 {
   vnet_policer_main_t *pm = &vnet_policer_main;
   policer_read_response_type_st test_policer;
-  policer_read_response_type_st * policer;
-  uword * p;
+  policer_read_response_type_st *policer;
+  uword *p;
   u32 pi;
   int rv;
 
@@ -35,19 +34,19 @@ policer_add_del (vlib_main_t *vm,
   if (is_add == 0)
     {
       if (p == 0)
-        {
-          vec_free(name);
-          return clib_error_return (0, "No such policer configuration");
-        }
+	{
+	  vec_free (name);
+	  return clib_error_return (0, "No such policer configuration");
+	}
       hash_unset_mem (pm->policer_config_by_name, name);
       hash_unset_mem (pm->policer_index_by_name, name);
-      vec_free(name);
+      vec_free (name);
       return 0;
     }
 
   if (p != 0)
     {
-      vec_free(name);
+      vec_free (name);
       return clib_error_return (0, "Policer already exists");
     }
 
@@ -83,33 +82,31 @@ policer_add_del (vlib_main_t *vm,
   return 0;
 }
 
-u8 * format_policer_instance (u8 * s, va_list * va)
+u8 *
+format_policer_instance (u8 * s, va_list * va)
 {
-  policer_read_response_type_st * i 
+  policer_read_response_type_st *i
     = va_arg (*va, policer_read_response_type_st *);
 
-  s = format (s, "policer at %llx: %s rate, %s color-aware\n", 
-              i, i->single_rate ? "single" : "dual",
-              i->color_aware ? "is" : "not");
+  s = format (s, "policer at %llx: %s rate, %s color-aware\n",
+	      i, i->single_rate ? "single" : "dual",
+	      i->color_aware ? "is" : "not");
   s = format (s, "cir %u tok/period, pir %u tok/period, scale %u\n",
-              i->cir_tokens_per_period, i->pir_tokens_per_period, 
-              i->scale);
+	      i->cir_tokens_per_period, i->pir_tokens_per_period, i->scale);
   s = format (s, "cur lim %u, cur bkt %u, ext lim %u, ext bkt %u\n",
-              i->current_limit,
-              i->current_bucket,
-              i->extended_limit,
-              i->extended_bucket);
+	      i->current_limit,
+	      i->current_bucket, i->extended_limit, i->extended_bucket);
   s = format (s, "last update %llu\n", i->last_update_time);
   return s;
-}              
+}
 
-static u8 * format_policer_round_type (u8 * s, va_list * va)
+static u8 *
+format_policer_round_type (u8 * s, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (c->rnd_type == SSE2_QOS_ROUND_TO_CLOSEST)
-    s = format(s, "closest");
+    s = format (s, "closest");
   else if (c->rnd_type == SSE2_QOS_ROUND_TO_UP)
     s = format (s, "up");
   else if (c->rnd_type == SSE2_QOS_ROUND_TO_DOWN)
@@ -120,28 +117,28 @@ static u8 * format_policer_round_type (u8 * s, va_list * va)
 }
 
 
-static u8 * format_policer_rate_type (u8 * s, va_list * va)
+static u8 *
+format_policer_rate_type (u8 * s, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (c->rate_type == SSE2_QOS_RATE_KBPS)
     s = format (s, "kbps");
   else if (c->rate_type == SSE2_QOS_RATE_PPS)
-    s = format(s, "pps");
+    s = format (s, "pps");
   else
     s = format (s, "ILLEGAL");
   return s;
 }
 
-static u8 * format_policer_type (u8 * s, va_list * va)
+static u8 *
+format_policer_type (u8 * s, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
-  
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+
   if (c->rfc == SSE2_QOS_POLICER_TYPE_1R2C)
     s = format (s, "1r2c");
-      
+
   else if (c->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
     s = format (s, "1r3c");
 
@@ -158,25 +155,28 @@ static u8 * format_policer_type (u8 * s, va_list * va)
   return s;
 }
 
-static u8 * format_dscp (u8 * s, va_list * va)
+static u8 *
+format_dscp (u8 * s, va_list * va)
 {
   u32 i = va_arg (*va, u32);
-  char * t = 0;
+  char *t = 0;
 
-  switch (i) {
-  #define _(v,f,str) case VNET_DSCP_##f: t = str; break;
-    foreach_vnet_dscp
-  #undef _
+  switch (i)
+    {
+#define _(v,f,str) case VNET_DSCP_##f: t = str; break;
+      foreach_vnet_dscp
+#undef _
     default:
       return format (s, "ILLEGAL");
-  }
+    }
   s = format (s, "%s", t);
   return s;
 }
 
-static u8 * format_policer_action_type (u8 * s, va_list * va)
+static u8 *
+format_policer_action_type (u8 * s, va_list * va)
 {
-  sse2_qos_pol_action_params_st * a
+  sse2_qos_pol_action_params_st *a
     = va_arg (*va, sse2_qos_pol_action_params_st *);
 
   if (a->action_type == SSE2_QOS_ACTION_DROP)
@@ -190,32 +190,28 @@ static u8 * format_policer_action_type (u8 * s, va_list * va)
   return s;
 }
 
-u8 * format_policer_config (u8 * s, va_list * va)
+u8 *
+format_policer_config (u8 * s, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   s = format (s, "type %U cir %u eir %u cb %u eb %u\n",
-              format_policer_type, c, 
-              c->rb.kbps.cir_kbps,
-              c->rb.kbps.eir_kbps,
-              c->rb.kbps.cb_bytes,
-              c->rb.kbps.eb_bytes);
+	      format_policer_type, c,
+	      c->rb.kbps.cir_kbps,
+	      c->rb.kbps.eir_kbps, c->rb.kbps.cb_bytes, c->rb.kbps.eb_bytes);
   s = format (s, "rate type %U, round type %U\n",
-              format_policer_rate_type, c,
-              format_policer_round_type, c);
+	      format_policer_rate_type, c, format_policer_round_type, c);
   s = format (s, "conform action %U, exceed action %U, violate action %U\n",
-              format_policer_action_type, &c->conform_action,
-              format_policer_action_type, &c->exceed_action,
-              format_policer_action_type, &c->violate_action);
+	      format_policer_action_type, &c->conform_action,
+	      format_policer_action_type, &c->exceed_action,
+	      format_policer_action_type, &c->violate_action);
   return s;
 }
 
 static uword
 unformat_policer_type (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (!unformat (input, "type"))
     return 0;
@@ -238,13 +234,12 @@ unformat_policer_type (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_round_type (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
-  if (!unformat(input, "round"))
+  if (!unformat (input, "round"))
     return 0;
 
-  if (unformat(input, "closest"))
+  if (unformat (input, "closest"))
     c->rnd_type = SSE2_QOS_ROUND_TO_CLOSEST;
   else if (unformat (input, "up"))
     c->rnd_type = SSE2_QOS_ROUND_TO_UP;
@@ -258,15 +253,14 @@ unformat_policer_round_type (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_rate_type (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
-  if (!unformat(input, "rate"))
+  if (!unformat (input, "rate"))
     return 0;
 
   if (unformat (input, "kbps"))
     c->rate_type = SSE2_QOS_RATE_KBPS;
-  else if (unformat(input, "pps"))
+  else if (unformat (input, "pps"))
     c->rate_type = SSE2_QOS_RATE_PPS;
   else
     return 0;
@@ -276,8 +270,7 @@ unformat_policer_rate_type (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_cir (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (unformat (input, "cir %u", &c->rb.kbps.cir_kbps))
     return 1;
@@ -287,8 +280,7 @@ unformat_policer_cir (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_eir (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (unformat (input, "eir %u", &c->rb.kbps.eir_kbps))
     return 1;
@@ -298,8 +290,7 @@ unformat_policer_eir (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_cb (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (unformat (input, "cb %u", &c->rb.kbps.cb_bytes))
     return 1;
@@ -309,8 +300,7 @@ unformat_policer_cb (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_eb (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c 
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (unformat (input, "eb %u", &c->rb.kbps.eb_bytes))
     return 1;
@@ -320,13 +310,13 @@ unformat_policer_eb (unformat_input_t * input, va_list * va)
 static uword
 unformat_dscp (unformat_input_t * input, va_list * va)
 {
-  u8 * r = va_arg (*va, u8 *);
+  u8 *r = va_arg (*va, u8 *);
 
-  if (0) ;
+  if (0);
 #define _(v,f,str) else if (unformat (input, str)) *r = VNET_DSCP_##f;
-      foreach_vnet_dscp
+  foreach_vnet_dscp
 #undef _
-  else
+    else
     return 0;
   return 1;
 }
@@ -334,7 +324,7 @@ unformat_dscp (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_action_type (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_action_params_st * a
+  sse2_qos_pol_action_params_st *a
     = va_arg (*va, sse2_qos_pol_action_params_st *);
 
   if (unformat (input, "drop"))
@@ -351,17 +341,16 @@ unformat_policer_action_type (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_action (unformat_input_t * input, va_list * va)
 {
-  sse2_qos_pol_cfg_params_st * c
-    = va_arg (*va, sse2_qos_pol_cfg_params_st *);
+  sse2_qos_pol_cfg_params_st *c = va_arg (*va, sse2_qos_pol_cfg_params_st *);
 
   if (unformat (input, "conform-action %U", unformat_policer_action_type,
-      &c->conform_action))
+		&c->conform_action))
     return 1;
   else if (unformat (input, "exceed-action %U", unformat_policer_action_type,
-      &c->exceed_action))
+		     &c->exceed_action))
     return 1;
   else if (unformat (input, "violate-action %U", unformat_policer_action_type,
-      &c->violate_action))
+		     &c->violate_action))
     return 1;
   return 0;
 }
@@ -369,10 +358,10 @@ unformat_policer_action (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_classify_next_index (unformat_input_t * input, va_list * va)
 {
-  u32 * r = va_arg (*va, u32 *);
+  u32 *r = va_arg (*va, u32 *);
   vnet_policer_main_t *pm = &vnet_policer_main;
-  uword * p;
-  u8 * match_name = 0;
+  uword *p;
+  u8 *match_name = 0;
 
   if (unformat (input, "%s", &match_name))
     ;
@@ -392,7 +381,7 @@ unformat_policer_classify_next_index (unformat_input_t * input, va_list * va)
 static uword
 unformat_policer_classify_precolor (unformat_input_t * input, va_list * va)
 {
-  u32 * r = va_arg (*va, u32 *);
+  u32 *r = va_arg (*va, u32 *);
 
   if (unformat (input, "conform-color"))
     *r = POLICE_CONFORM;
@@ -416,66 +405,66 @@ _(action)
 
 static clib_error_t *
 configure_policer_command_fn (vlib_main_t * vm,
-                              unformat_input_t * input,
-                              vlib_cli_command_t * cmd)
+			      unformat_input_t * input,
+			      vlib_cli_command_t * cmd)
 {
   sse2_qos_pol_cfg_params_st c;
-  unformat_input_t _line_input, * line_input = &_line_input;
+  unformat_input_t _line_input, *line_input = &_line_input;
   u8 is_add = 1;
-  u8 * name = 0;
+  u8 *name = 0;
   u32 pi;
 
   /* Get a line of input. */
-  if (! unformat_user (input, unformat_line_input, line_input))
+  if (!unformat_user (input, unformat_line_input, line_input))
     return 0;
 
   memset (&c, 0, sizeof (c));
 
-  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT) 
+  while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
     {
       if (unformat (line_input, "del"))
-        is_add = 0;
-      else if (unformat(line_input, "name %s", &name))
-        ;
-      else if (unformat(line_input, "color-aware"))
-        c.color_aware = 1;
+	is_add = 0;
+      else if (unformat (line_input, "name %s", &name))
+	;
+      else if (unformat (line_input, "color-aware"))
+	c.color_aware = 1;
 
 #define _(a) else if (unformat (line_input, "%U", unformat_policer_##a, &c)) ;
       foreach_config_param
 #undef _
-
-      else
-        return clib_error_return (0, "unknown input `%U'",
-                                  format_unformat_error, line_input);
+	else
+	return clib_error_return (0, "unknown input `%U'",
+				  format_unformat_error, line_input);
     }
 
   unformat_free (line_input);
 
-  return policer_add_del(vm, name, &c, &pi, is_add);
+  return policer_add_del (vm, name, &c, &pi, is_add);
 }
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (configure_policer_command, static) = {
     .path = "configure policer",
     .short_help = "configure policer name <name> <params> ",
     .function = configure_policer_command_fn,
 };
-
+/* *INDENT-ON* */
 
 static clib_error_t *
 show_policer_command_fn (vlib_main_t * vm,
-                              unformat_input_t * input,
-                              vlib_cli_command_t * cmd)
+			 unformat_input_t * input, vlib_cli_command_t * cmd)
 {
   vnet_policer_main_t *pm = &vnet_policer_main;
-  hash_pair_t * p;
+  hash_pair_t *p;
   u32 pool_index;
-  u8 * match_name = 0;
-  u8 * name;
+  u8 *match_name = 0;
+  u8 *name;
   sse2_qos_pol_cfg_params_st *config;
   policer_read_response_type_st *templ;
 
   (void) unformat (input, "name %s", &match_name);
 
+  /* *INDENT-OFF* */
   hash_foreach_pair (p, pm->policer_config_by_name,
   ({
     name = (u8 *) p->key;
@@ -484,32 +473,36 @@ show_policer_command_fn (vlib_main_t * vm,
         pool_index = p->value[0];
         config = pool_elt_at_index (pm->configs, pool_index);
         templ = pool_elt_at_index (pm->policer_templates, pool_index);
-        vlib_cli_output (vm, "Name \"%s\" %U ", 
+        vlib_cli_output (vm, "Name \"%s\" %U ",
                          name, format_policer_config, config);
-        vlib_cli_output (vm, "Template %U", 
+        vlib_cli_output (vm, "Template %U",
                          format_policer_instance, templ);
         vlib_cli_output (vm, "-----------");
       }
   }));
+  /* *INDENT-ON* */
   return 0;
 }
 
 
+/* *INDENT-OFF* */
 VLIB_CLI_COMMAND (show_policer_command, static) = {
     .path = "show policer",
     .short_help = "show policer [name]",
     .function = show_policer_command_fn,
 };
+/* *INDENT-ON* */
 
-clib_error_t *policer_init (vlib_main_t * vm)
+clib_error_t *
+policer_init (vlib_main_t * vm)
 {
-  vnet_policer_main_t * pm = &vnet_policer_main;
-  void vnet_policer_node_funcs_reference(void);
+  vnet_policer_main_t *pm = &vnet_policer_main;
+  void vnet_policer_node_funcs_reference (void);
+
+  vnet_policer_node_funcs_reference ();
 
-  vnet_policer_node_funcs_reference();
-  
   pm->vlib_main = vm;
-  pm->vnet_main = vnet_get_main();
+  pm->vnet_main = vnet_get_main ();
 
   pm->policer_config_by_name = hash_create_string (0, sizeof (uword));
   pm->policer_index_by_name = hash_create_string (0, sizeof (uword));
@@ -522,6 +515,14 @@ clib_error_t *policer_init (vlib_main_t * vm)
   return 0;
 }
 
-VLIB_INIT_FUNCTION(policer_init);
+VLIB_INIT_FUNCTION (policer_init);
+
 
 
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/policer/policer.h b/vnet/vnet/policer/policer.h
index beef5b644dc..8e2d7c79b7c 100644
--- a/vnet/vnet/policer/policer.h
+++ b/vnet/vnet/policer/policer.h
@@ -21,37 +21,40 @@
 #include <vnet/policer/xlate.h>
 #include <vnet/policer/police.h>
 
-typedef struct {
+typedef struct
+{
   /* policer pool, aligned */
-  policer_read_response_type_st  * policers;
+  policer_read_response_type_st *policers;
 
   /* config + template h/w policer instance parallel pools */
-  sse2_qos_pol_cfg_params_st * configs;
-  policer_read_response_type_st * policer_templates;
-  
+  sse2_qos_pol_cfg_params_st *configs;
+  policer_read_response_type_st *policer_templates;
+
   /* Config by name hash */
-  uword * policer_config_by_name;
+  uword *policer_config_by_name;
 
   /* Policer by name hash */
-  uword * policer_index_by_name;
+  uword *policer_index_by_name;
 
   /* Policer by sw_if_index vector */
-  u32 * policer_index_by_sw_if_index;
+  u32 *policer_index_by_sw_if_index;
 
   /* convenience */
-  vlib_main_t * vlib_main;
-  vnet_main_t * vnet_main;
+  vlib_main_t *vlib_main;
+  vnet_main_t *vnet_main;
 } vnet_policer_main_t;
 
 vnet_policer_main_t vnet_policer_main;
 
-typedef enum {
+typedef enum
+{
   VNET_POLICER_INDEX_BY_SW_IF_INDEX,
   VNET_POLICER_INDEX_BY_OPAQUE,
   VNET_POLICER_INDEX_BY_EITHER,
 } vnet_policer_index_t;
 
-typedef enum {
+typedef enum
+{
   VNET_POLICER_NEXT_TRANSMIT,
   VNET_POLICER_NEXT_DROP,
   VNET_POLICER_N_NEXT,
@@ -80,17 +83,25 @@ typedef enum {
   _(48, CS6,  "CS6")  \
   _(50, CS7,  "CS7")
 
-typedef enum {
+typedef enum
+{
 #define _(v,f,str) VNET_DSCP_##f = v,
   foreach_vnet_dscp
 #undef _
 } vnet_dscp_t;
 
-u8 * format_policer_instance (u8 * s, va_list * va);
-clib_error_t * policer_add_del (vlib_main_t *vm,
-                                u8 * name,
-                                sse2_qos_pol_cfg_params_st * cfg,
-                                u32 * policer_index,
-                                u8 is_add);
+u8 *format_policer_instance (u8 * s, va_list * va);
+clib_error_t *policer_add_del (vlib_main_t * vm,
+			       u8 * name,
+			       sse2_qos_pol_cfg_params_st * cfg,
+			       u32 * policer_index, u8 is_add);
 
 #endif /* __included_policer_h__ */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/policer/xlate.c b/vnet/vnet/policer/xlate.c
index c9250eb8d87..74a6eb23d0a 100644
--- a/vnet/vnet/policer/xlate.c
+++ b/vnet/vnet/policer/xlate.c
@@ -120,7 +120,7 @@
 #define SSE2_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 SSE2_QOS_POL_TICKS_PER_SEC     1000LL	/* 1 tick = 1 ms */
 
 /*
  * Default burst, in ms (byte format)
@@ -153,7 +153,7 @@
 #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) 
+                            ((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)
@@ -161,7 +161,7 @@
 #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) 
+                            ((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)
@@ -175,8 +175,8 @@
 #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 \
-                        ((uint64_t)SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX << \
-                         (uint64_t)SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_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)
@@ -187,8 +187,8 @@
 #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 \
-                        ((uint64_t)SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX << \
-                         (uint64_t)SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX)
+                        ((u64)SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX << \
+                         (u64)SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX)
 
 /*
  * Rates determine the units of the bucket
@@ -207,318 +207,358 @@
 #define RATE_128TO256_UNIT 4LL
 #define RATE_64TO128_UNIT  2LL
 
-static cerrno
-sse2_qos_pol_round (uint64_t numerator,
-                      uint64_t denominator,
-                      uint64_t *rounded_value,
-                      sse2_qos_round_type_en round_type)
+static int
+sse2_qos_pol_round (u64 numerator,
+		    u64 denominator,
+		    u64 * rounded_value, sse2_qos_round_type_en round_type)
 {
-    cerrno rc = EOK;
+  int rc = 0;
 
-    if (denominator == 0) {
-        SSE2_QOS_DEBUG_ERROR("Illegal denominator");
-        SSE2_QOS_TR_ERR(SSE2_QOSRM_TP_ERR_59);
-        return(EINVAL);
+  if (denominator == 0)
+    {
+      SSE2_QOS_DEBUG_ERROR ("Illegal denominator");
+      SSE2_QOS_TR_ERR (SSE2_QOSRM_TP_ERR_59);
+      return (EINVAL);
     }
 
-    switch (round_type) {
+  switch (round_type)
+    {
     case SSE2_QOS_ROUND_TO_CLOSEST:
-        *rounded_value = ((numerator + (denominator >> 1)) / denominator);
-        break;
+      *rounded_value = ((numerator + (denominator >> 1)) / denominator);
+      break;
 
     case SSE2_QOS_ROUND_TO_UP:
-        *rounded_value = (numerator / denominator);
-        if ((*rounded_value * denominator) < numerator) {
-            *rounded_value += 1;
-        }
-        break;
+      *rounded_value = (numerator / denominator);
+      if ((*rounded_value * denominator) < numerator)
+	{
+	  *rounded_value += 1;
+	}
+      break;
 
     case SSE2_QOS_ROUND_TO_DOWN:
-        *rounded_value = (numerator / denominator);
-        break;
+      *rounded_value = (numerator / denominator);
+      break;
 
     case SSE2_QOS_ROUND_INVALID:
     default:
-        SSE2_QOS_DEBUG_ERROR("Illegal round type");
-        SSE2_QOS_TR_ERR(SSE2_QOS_TP_ERR_60, round_type);
-        rc = EINVAL;
-        break;
+      SSE2_QOS_DEBUG_ERROR ("Illegal round type");
+      SSE2_QOS_TR_ERR (SSE2_QOS_TP_ERR_60, round_type);
+      rc = EINVAL;
+      break;
     }
-    return(rc);
+  return (rc);
 }
 
 
-static cerrno
-sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st *cfg)
+static int
+sse2_pol_validate_cfg_params (sse2_qos_pol_cfg_params_st * cfg)
 {
-    uint64_t numer, denom, rnd_value;
-    uint32_t cir_hw, eir_hw;
-    cerrno rc = EOK;
-
-    if ((cfg->rfc == SSE2_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);
-        return(EINVAL);
-    }
-
-    /*
-     * convert rates to bytes-per-tick
-     */
-    numer = (uint64_t)(cfg->rb.kbps.cir_kbps);
-    denom = (uint64_t)(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);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Unable to convert CIR to bytes/tick format");
-        // Error traced
-        return(rc);
-    }
-    cir_hw = (uint32_t)rnd_value;
-
-    numer = (uint64_t)(cfg->rb.kbps.eir_kbps);
-    rc = sse2_qos_pol_round(numer, denom, &rnd_value,
-                            (sse2_qos_round_type_en) cfg->rnd_type);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Unable to convert EIR to bytes/tick format");
-        // Error traced
-        return(rc);
-    }
-    eir_hw = (uint32_t)rnd_value;
-
-    if (cir_hw > SSE2_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);
-        return(EINVAL);
-    }
-
-    if (eir_hw > SSE2_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);
-        return(EINVAL);
-    }
-    /*
-     * CIR = 0, with bc != 0 is not allowed
-     */
-    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);
-        return(EINVAL);
-    }
-
-    if ((cfg->rb.kbps.eir_kbps == 0) &&
-        (cfg->rfc > SSE2_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);
-        return(EINVAL);
-    }
-
-    if (cfg->rb.kbps.eir_kbps &&
-       (cfg->rfc < SSE2_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);
-        return(EINVAL);
-    }
-
-    if ((cfg->rfc == SSE2_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);
-        return(EINVAL);
-    }
-
-    return(EOK);
+  u64 numer, denom, rnd_value;
+  u32 cir_hw, eir_hw;
+  int rc = 0;
+
+  if ((cfg->rfc == SSE2_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);
+      return (EINVAL);
+    }
+
+  /*
+   * 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);
+  if (rc != 0)
+    {
+      SSE2_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);
+  if (rc != 0)
+    {
+      SSE2_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)
+    {
+      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);
+      return (EINVAL);
+    }
+
+  if (eir_hw > SSE2_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);
+      return (EINVAL);
+    }
+  /*
+   * CIR = 0, with bc != 0 is not allowed
+   */
+  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);
+      return (EINVAL);
+    }
+
+  if ((cfg->rb.kbps.eir_kbps == 0) &&
+      (cfg->rfc > SSE2_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);
+      return (EINVAL);
+    }
+
+  if (cfg->rb.kbps.eir_kbps &&
+      (cfg->rfc < SSE2_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);
+      return (EINVAL);
+    }
+
+  if ((cfg->rfc == SSE2_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);
+      return (EINVAL);
+    }
+
+  return (0);
 }
 
 static void
-sse2_qos_convert_value_to_exp_mant_fmt (uint64_t       value,
-                                        uint16_t       max_exp_value,
-                                        uint16_t       max_mant_value,
-                                        sse2_qos_round_type_en type,
-                                        uint8_t        *exp,
-                                        uint32_t       *mant)
+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)
 {
-    uint64_t rnd_value;
-    uint64_t temp_mant;
-    uint8_t temp_exp;
-
-    /*
-     * Select the lowest possible exp, and the largest possible mant
-     */
-    temp_exp = 0;
-    temp_mant = value;
-    while (temp_exp <= max_exp_value) {
-        if (temp_mant <= max_mant_value) {
-            break;
-        }
-
-        temp_exp++;
-        rnd_value = 0;
-        (void)sse2_qos_pol_round((uint64_t)value, (uint64_t)(1 << temp_exp),
-                               &rnd_value, type);
-        temp_mant = rnd_value;
-    }
-
-    if (temp_exp > max_exp_value) {
-        /*
-         * CAP mant to its max value, and decrement exp
-         */
-        temp_exp--;
-        temp_mant = max_mant_value;
-    }
-
-    *exp = temp_exp;
-    *mant = (uint32_t)temp_mant;
-
-    SSE2_QOS_DEBUG_INFO("value: 0x%llx, mant: %u, exp: %u", value, *mant, *exp);
-    return;
+  u64 rnd_value;
+  u64 temp_mant;
+  u8 temp_exp;
+
+  /*
+   * Select the lowest possible exp, and the largest possible mant
+   */
+  temp_exp = 0;
+  temp_mant = value;
+  while (temp_exp <= max_exp_value)
+    {
+      if (temp_mant <= max_mant_value)
+	{
+	  break;
+	}
+
+      temp_exp++;
+      rnd_value = 0;
+      (void) sse2_qos_pol_round ((u64) value, (u64) (1 << temp_exp),
+				 &rnd_value, type);
+      temp_mant = rnd_value;
+    }
+
+  if (temp_exp > max_exp_value)
+    {
+      /*
+       * CAP mant to its max value, and decrement exp
+       */
+      temp_exp--;
+      temp_mant = max_mant_value;
+    }
+
+  *exp = temp_exp;
+  *mant = (u32) temp_mant;
+
+  SSE2_QOS_DEBUG_INFO ("value: 0x%llx, mant: %u, exp: %u", value, *mant,
+		       *exp);
+  return;
 }
 
-static cerrno
-sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st *cfg,
-                                  sse2_qos_pol_hw_params_st  *hw)
+static int
+sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st * cfg,
+				  sse2_qos_pol_hw_params_st * hw)
 {
-    cerrno rc = EOK;
-    uint32_t cir_hw, eir_hw, hi_mant, hi_rate, cir_rnded, eir_rnded, eir_kbps;
-    uint64_t numer, denom, rnd_value;
-    uint8_t exp;
-
-    /*
-     * convert rates to bytes-per-tick (tick is 1ms)
-     * For rate conversion, the denominator is gonna be the same
-     */
-    denom = (uint64_t)((SSE2_QOS_POL_TICKS_PER_SEC * 8) / 1000);
-    numer = (uint64_t)(cfg->rb.kbps.cir_kbps);
-    rc = sse2_qos_pol_round(numer, denom, &rnd_value,
-                            (sse2_qos_round_type_en) cfg->rnd_type);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Rounding error, rate: %d kbps, rounding_type: %d",
-                            cfg->rb.kbps.cir_kbps, cfg->rnd_type);
-        // Error is traced
-        return(rc);
-    }
-    cir_hw = (uint32_t)rnd_value;
-
-    if (cfg->rb.kbps.cir_kbps && (cir_hw == 0)) {
-        /*
-         * After rounding, cir_hw = 0. Bump it up
-         */
-        cir_hw = 1;
-    }
-
-    if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) {
-        eir_kbps = 0;
-    } else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) {
-        eir_kbps = cfg->rb.kbps.cir_kbps;
-    } else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115) {
-        eir_kbps = cfg->rb.kbps.eir_kbps - cfg->rb.kbps.cir_kbps;
-    } else {
-        eir_kbps = cfg->rb.kbps.eir_kbps;
-    }
-
-    numer = (uint64_t)eir_kbps;
-    rc = sse2_qos_pol_round(numer, denom, &rnd_value,
-                            (sse2_qos_round_type_en) cfg->rnd_type);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Rounding error, rate: %d kbps, rounding_type: %d",
-                              eir_kbps, cfg->rnd_type);
-        // Error is traced
-        return(rc);
-    }
-    eir_hw = (uint32_t)rnd_value;
-
-    if (eir_kbps && (eir_hw == 0)) {
-        /*
-         * After rounding, eir_hw = 0. Bump it up
-         */
-        eir_hw = 1;
-    }
-
-    SSE2_QOS_DEBUG_INFO("cir_hw: %u bytes/tick, eir_hw: %u bytes/tick", cir_hw,
-                         eir_hw);
-
-    if (cir_hw > eir_hw) {
-        hi_rate = cir_hw;
-    } else {
-        hi_rate = eir_hw;
-    }
-
-    if ((cir_hw == 0) && (eir_hw == 0)) {
-        /*
-         * Both the rates are 0. Use exp = 15, and set the RFC to 4115. Also
-         * set AN = 0
-         */
-        exp = (uint8_t)SSE2_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, 
-                            (uint16_t)SSE2_QOS_POL_RATE_EXP_MAX,
-                            (uint16_t)SSE2_QOS_POL_AVG_RATE_MANT_MAX,
-                            (sse2_qos_round_type_en) cfg->rnd_type,
-                            &exp, &hi_mant);
-    }
-
-    denom = (1ULL << exp);
-    if (hi_rate == eir_hw) {
-        hw->peak_rate_man = (uint16_t)hi_mant;
-        rc = sse2_qos_pol_round((uint64_t)cir_hw, denom, &rnd_value,
-                                (sse2_qos_round_type_en) cfg->rnd_type);
-        hw->avg_rate_man = (uint16_t)rnd_value;
-    } else {
-        hw->avg_rate_man = (uint16_t)hi_mant;
-        rc = sse2_qos_pol_round((uint64_t)eir_hw, denom, &rnd_value,
-                                (sse2_qos_round_type_en) cfg->rnd_type);
-        hw->peak_rate_man = (uint16_t)rnd_value;
-    }
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Rounding error");
-        // Error is traced
-        return(rc);
-    }
-    hw->rate_exp = exp;
-
-    if ((hw->avg_rate_man == 0) && (cfg->rb.kbps.cir_kbps)) {
-        /*
-         * 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));
-    }
-
-    if ((hw->peak_rate_man == 0) && eir_kbps) {
-        /*
-         * 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));
-    }
-
-    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);
-
-    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);
-
-    return(rc);
+  int rc = 0;
+  u32 cir_hw, eir_hw, hi_mant, hi_rate, cir_rnded, eir_rnded, eir_kbps;
+  u64 numer, denom, rnd_value;
+  u8 exp;
+
+  /*
+   * 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);
+  numer = (u64) (cfg->rb.kbps.cir_kbps);
+  rc = sse2_qos_pol_round (numer, denom, &rnd_value,
+			   (sse2_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);
+      // Error is traced
+      return (rc);
+    }
+  cir_hw = (u32) rnd_value;
+
+  if (cfg->rb.kbps.cir_kbps && (cir_hw == 0))
+    {
+      /*
+       * After rounding, cir_hw = 0. Bump it up
+       */
+      cir_hw = 1;
+    }
+
+  if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C)
+    {
+      eir_kbps = 0;
+    }
+  else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
+    {
+      eir_kbps = cfg->rb.kbps.cir_kbps;
+    }
+  else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)
+    {
+      eir_kbps = cfg->rb.kbps.eir_kbps - cfg->rb.kbps.cir_kbps;
+    }
+  else
+    {
+      eir_kbps = cfg->rb.kbps.eir_kbps;
+    }
+
+  numer = (u64) eir_kbps;
+  rc = sse2_qos_pol_round (numer, denom, &rnd_value,
+			   (sse2_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);
+      // Error is traced
+      return (rc);
+    }
+  eir_hw = (u32) rnd_value;
+
+  if (eir_kbps && (eir_hw == 0))
+    {
+      /*
+       * After rounding, eir_hw = 0. Bump it up
+       */
+      eir_hw = 1;
+    }
+
+  SSE2_QOS_DEBUG_INFO ("cir_hw: %u bytes/tick, eir_hw: %u bytes/tick", cir_hw,
+		       eir_hw);
+
+  if (cir_hw > eir_hw)
+    {
+      hi_rate = cir_hw;
+    }
+  else
+    {
+      hi_rate = eir_hw;
+    }
+
+  if ((cir_hw == 0) && (eir_hw == 0))
+    {
+      /*
+       * 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;
+      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);
+    }
+
+  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);
+      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);
+      hw->peak_rate_man = (u16) rnd_value;
+    }
+  if (rc != 0)
+    {
+      SSE2_QOS_DEBUG_ERROR ("Rounding error");
+      // Error is traced
+      return (rc);
+    }
+  hw->rate_exp = exp;
+
+  if ((hw->avg_rate_man == 0) && (cfg->rb.kbps.cir_kbps))
+    {
+      /*
+       * 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));
+    }
+
+  if ((hw->peak_rate_man == 0) && eir_kbps)
+    {
+      /*
+       * 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));
+    }
+
+  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);
+
+  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);
+
+  return (rc);
 }
 
 /*****
@@ -530,7 +570,7 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st *cfg,
  *  bkt_max    - bit width in the current bucket or extended bucket
  *
  * RETURNS
- *  uint64_t   - maximum token bytes for the current or extended bucket
+ *  u64   - maximum token bytes for the current or extended bucket
  *
  * DESCRIPTION
  *  The current bucket or extended bucket fields are in units of either
@@ -541,18 +581,23 @@ sse2_pol_convert_cfg_rates_to_hw (sse2_qos_pol_cfg_params_st *cfg,
  *  field, the value must be multiplied by the units of either 1,2,4,8
  *  bytes based on the rate.
  *****/
-uint64_t
-sse2_pol_get_bkt_max (uint64_t rate_hw, uint64_t bkt_max)
+u64
+sse2_pol_get_bkt_max (u64 rate_hw, u64 bkt_max)
 {
-    if (rate_hw <= RATE64) {
-        return (bkt_max - 1);
-    } else if (rate_hw <= RATE128) {
-        return ((bkt_max * RATE_64TO128_UNIT) - RATE_64TO128_UNIT);
-    } else if (rate_hw <= RATE256) {
-        return ((bkt_max * RATE_128TO256_UNIT) - RATE_128TO256_UNIT);
-    }
-    /* rate must be over 256 */
-    return ((bkt_max * RATE_OVER256_UNIT) - RATE_OVER256_UNIT);
+  if (rate_hw <= RATE64)
+    {
+      return (bkt_max - 1);
+    }
+  else if (rate_hw <= RATE128)
+    {
+      return ((bkt_max * RATE_64TO128_UNIT) - RATE_64TO128_UNIT);
+    }
+  else if (rate_hw <= RATE256)
+    {
+      return ((bkt_max * RATE_128TO256_UNIT) - RATE_128TO256_UNIT);
+    }
+  /* rate must be over 256 */
+  return ((bkt_max * RATE_OVER256_UNIT) - RATE_OVER256_UNIT);
 }
 
 /*****
@@ -564,7 +609,7 @@ sse2_pol_get_bkt_max (uint64_t rate_hw, uint64_t bkt_max)
  *  byte_value - bytes for this token bucket
  *
  * RETURNS
- *  uint64_t   - unit value for the current or extended bucket field
+ *  u64   - unit value for the current or extended bucket field
  *
  * DESCRIPTION
  *  The current bucket or extended bucket fields are in units of either
@@ -574,158 +619,168 @@ sse2_pol_get_bkt_max (uint64_t rate_hw, uint64_t bkt_max)
  *  To get the units that can be stored in the field, the byte value must
  *  be divided by the units of either 1,2,4,8 bytes based on the rate.
  *****/
-uint64_t
-sse2_pol_get_bkt_value (uint64_t rate_hw, uint64_t byte_value)
+u64
+sse2_pol_get_bkt_value (u64 rate_hw, u64 byte_value)
 {
-    if (rate_hw <= RATE64) {
-        return (byte_value);
-    } else if (rate_hw <= RATE128) {
-        return (byte_value / RATE_64TO128_UNIT);
-    } else if (rate_hw <= RATE256) {
-        return (byte_value / RATE_128TO256_UNIT);
-    }
-    /* rate must be over 256 */
-    return (byte_value / RATE_OVER256_UNIT);
+  if (rate_hw <= RATE64)
+    {
+      return (byte_value);
+    }
+  else if (rate_hw <= RATE128)
+    {
+      return (byte_value / RATE_64TO128_UNIT);
+    }
+  else if (rate_hw <= RATE256)
+    {
+      return (byte_value / RATE_128TO256_UNIT);
+    }
+  /* rate must be over 256 */
+  return (byte_value / RATE_OVER256_UNIT);
 }
 
 static void
-sse2_pol_rnd_burst_byte_fmt (uint64_t cfg_burst,
-                             uint16_t max_exp_value,
-                             uint16_t max_mant_value,
-                             uint32_t max_bkt_value,
-                             uint32_t rate_hw,
-                             uint8_t *exp,
-                             uint32_t *mant,
-                             uint32_t *bkt_value)
+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)
 {
-    uint64_t    bkt_max=max_bkt_value;
-    uint64_t    bkt_limit_max;
-    uint64_t    rnd_burst;
-    uint64_t    temp_bkt_value;
-
-    bkt_limit_max = ((uint64_t)max_mant_value<<(uint64_t)max_exp_value);
-    bkt_max = sse2_pol_get_bkt_max(rate_hw, bkt_max);
-    bkt_max=MIN(bkt_max, bkt_limit_max);
-    if (!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 = (uint64_t)rate_hw * (uint64_t)SSE2_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);
-        cfg_burst = bkt_max;
-    }
-
-    if (cfg_burst < SSE2_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;
-    }
-
-    sse2_qos_convert_value_to_exp_mant_fmt(cfg_burst,
-                                             max_exp_value,
-                                             max_mant_value, 
-                                             SSE2_QOS_ROUND_TO_DOWN,
-                                             exp,
-                                             mant);
-
-    /* Bucket value is based on rate. */
-    rnd_burst = ((uint64_t)(*mant) << (uint64_t)(*exp));
-    temp_bkt_value = sse2_pol_get_bkt_value(rate_hw, rnd_burst);
-    *bkt_value = (uint32_t)temp_bkt_value;
+  u64 bkt_max = max_bkt_value;
+  u64 bkt_limit_max;
+  u64 rnd_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 = MIN (bkt_max, bkt_limit_max);
+  if (!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;
+    }
+
+  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);
+      cfg_burst = bkt_max;
+    }
+
+  if (cfg_burst < SSE2_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;
+    }
+
+  sse2_qos_convert_value_to_exp_mant_fmt (cfg_burst,
+					  max_exp_value,
+					  max_mant_value,
+					  SSE2_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);
+  *bkt_value = (u32) temp_bkt_value;
 }
 
-static cerrno
-sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st *cfg,
-                                  sse2_qos_pol_hw_params_st  *hw)
+static int
+sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st * cfg,
+				  sse2_qos_pol_hw_params_st * hw)
 {
-    uint8_t  temp_exp;
-    uint32_t temp_mant, rate_hw; 
-    uint64_t eb_bytes;
-    uint32_t bkt_value;
-
-    /*
-     * compute Committed Burst
-     */
-    SSE2_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, 
-                           (uint16_t)SSE2_QOS_POL_COMM_BKT_LIMIT_EXP_MAX,
-                           (uint16_t)SSE2_QOS_POL_COMM_BKT_LIMIT_MANT_MAX,
-                           (uint32_t)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, 
-                       ((uint64_t)temp_mant << (uint64_t)temp_exp), bkt_value);
-
-    hw->comm_bkt_limit_exp = temp_exp;
-    hw->comm_bkt_limit_man = (uint8_t)temp_mant;
-    hw->comm_bkt = bkt_value;
-
-    /*
-     * compute Exceed Burst
-     */
-    SSE2_QOS_DEBUG_INFO("Compute exceed burst ...");
-
-    if (cfg->rfc == SSE2_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 = (uint8_t)SSE2_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,
-               ((uint64_t)hw->extd_bkt_limit_man <<
-                (uint64_t)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);
-        return(EOK);
-    }
-
-    if (cfg->rfc == SSE2_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) {
-        eb_bytes = cfg->rb.kbps.eb_bytes - cfg->rb.kbps.cb_bytes;
-    } else {
-        eb_bytes = cfg->rb.kbps.eb_bytes;
-    }
-
-    rate_hw = (hw->peak_rate_man) << (hw->rate_exp);
-    sse2_pol_rnd_burst_byte_fmt(eb_bytes, 
-                           (uint16_t)SSE2_QOS_POL_EXTD_BKT_LIMIT_EXP_MAX,
-                           (uint16_t)SSE2_QOS_POL_EXTD_BKT_LIMIT_MANT_MAX,
-                           (uint32_t)SSE2_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,
-                       ((uint64_t)temp_mant << (uint64_t)temp_exp), bkt_value);
-
-    hw->extd_bkt_limit_exp = (uint8_t)temp_exp;
-    hw->extd_bkt_limit_man = (uint8_t)temp_mant;
-    hw->extd_bkt = bkt_value;
-
-    return(EOK);
+  u8 temp_exp;
+  u32 temp_mant, rate_hw;
+  u64 eb_bytes;
+  u32 bkt_value;
+
+  /*
+   * compute Committed Burst
+   */
+  SSE2_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);
+
+  hw->comm_bkt_limit_exp = temp_exp;
+  hw->comm_bkt_limit_man = (u8) temp_mant;
+  hw->comm_bkt = bkt_value;
+
+  /*
+   * compute Exceed Burst
+   */
+  SSE2_QOS_DEBUG_INFO ("Compute exceed burst ...");
+
+  if (cfg->rfc == SSE2_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_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);
+      return (0);
+    }
+
+  if (cfg->rfc == SSE2_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)
+    {
+      eb_bytes = cfg->rb.kbps.eb_bytes - cfg->rb.kbps.cb_bytes;
+    }
+  else
+    {
+      eb_bytes = cfg->rb.kbps.eb_bytes;
+    }
+
+  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);
+
+  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);
+
+  hw->extd_bkt_limit_exp = (u8) temp_exp;
+  hw->extd_bkt_limit_man = (u8) temp_mant;
+  hw->extd_bkt = bkt_value;
+
+  return (0);
 }
 
 
@@ -734,85 +789,95 @@ sse2_pol_convert_cfg_burst_to_hw (sse2_qos_pol_cfg_params_st *cfg,
  * Output: h/w programmable parameter values in 'hw'.
  * Return: success or failure code.
  */
-static cerrno
-sse2_pol_convert_cfg_to_hw_params (sse2_qos_pol_cfg_params_st *cfg,
-                                   sse2_qos_pol_hw_params_st  *hw)
+static int
+sse2_pol_convert_cfg_to_hw_params (sse2_qos_pol_cfg_params_st * cfg,
+				   sse2_qos_pol_hw_params_st * hw)
 {
-    cerrno rc = EOK;
-
-    /*
-     * clear the hw_params
-     */
-    memset(hw, 0, sizeof(sse2_qos_pol_hw_params_st));
-
-    hw->allow_negative = SSE2_QOS_POL_ALLOW_NEGATIVE;
-
-    if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) ||
-        (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)) {
-        hw->rfc = IPE_RFC_RFC4115;
-    } else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) {
-        hw->rfc = IPE_RFC_RFC2697;
-    } else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) {
-        hw->rfc = IPE_RFC_RFC2698;
-    } else if (cfg->rfc == SSE2_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);
-        return(EINVAL);
-    }
-
-    rc = sse2_pol_convert_cfg_rates_to_hw(cfg, hw);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_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);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Unable to convert config burst to hw. Error: %d",
-                              rc);
-        // Error is traced
-        return(rc);
-    }
-
-    return OK_pushHW;
+  int rc = 0;
+
+  /*
+   * clear the hw_params
+   */
+  memset (hw, 0, sizeof (sse2_qos_pol_hw_params_st));
+
+  hw->allow_negative = SSE2_QOS_POL_ALLOW_NEGATIVE;
+
+  if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) ||
+      (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115))
+    {
+      hw->rfc = IPE_RFC_RFC4115;
+    }
+  else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697)
+    {
+      hw->rfc = IPE_RFC_RFC2697;
+    }
+  else if (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698)
+    {
+      hw->rfc = IPE_RFC_RFC2698;
+    }
+  else if (cfg->rfc == SSE2_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);
+      return (EINVAL);
+    }
+
+  rc = sse2_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
+      return (rc);
+    }
+
+  rc = sse2_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
+      return (rc);
+    }
+
+  return 0;
 }
 
 
-uint32_t
-sse2_qos_convert_pps_to_kbps (uint32_t rate_pps)
+u32
+sse2_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);
+  // sse2_qos_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                            SSE2_QOS_SHIP_CNT_POL_CONV_PPS_TO_KBPS);
 
-    uint64_t numer, rnd_value = 0;
+  u64 numer, rnd_value = 0;
 
-    numer = (uint64_t)((uint64_t)rate_pps *
-            (uint64_t)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) SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL);
+  (void) sse2_qos_pol_round (numer, 1000LL, &rnd_value,
+			     SSE2_QOS_ROUND_TO_CLOSEST);
 
-    return ((uint32_t)rnd_value);
+  return ((u32) rnd_value);
 }
 
-uint32_t
-sse2_qos_convert_burst_ms_to_bytes (uint32_t burst_ms,
-                                     uint32_t rate_kbps)
+u32
+sse2_qos_convert_burst_ms_to_bytes (u32 burst_ms, u32 rate_kbps)
 {
-    uint64_t numer, rnd_value = 0;
+  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);
+  //sse2_qos_ship_inc_counter(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                          SSE2_QOS_SHIP_CNT_POL_CONV_BURST_MS_TO_BYTES);
 
-    numer = (uint64_t)((uint64_t)burst_ms * (uint64_t)rate_kbps);
+  numer = (u64) ((u64) burst_ms * (u64) rate_kbps);
 
-    (void)sse2_qos_pol_round(numer, 8LL, &rnd_value,
-                             SSE2_QOS_ROUND_TO_CLOSEST);
+  (void) sse2_qos_pol_round (numer, 8LL, &rnd_value,
+			     SSE2_QOS_ROUND_TO_CLOSEST);
 
-    return ((uint32_t)rnd_value);
+  return ((u32) rnd_value);
 }
 
 
@@ -821,41 +886,44 @@ sse2_qos_convert_burst_ms_to_bytes (uint32_t burst_ms,
  * Output: h/w parameters are returned in 'hw',
  * Return: Status, success or failure code.
  */
-trans_layer_rc
-sse2_pol_compute_hw_params (sse2_qos_pol_cfg_params_st *cfg,
-                            sse2_qos_pol_hw_params_st  *hw)
+int
+sse2_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg,
+			    sse2_qos_pol_hw_params_st * hw)
 {
-    cerrno rc = EOK;
+  int rc = 0;
 
-    if (!cfg || !hw) {
-        SSE2_QOS_DEBUG_ERROR("Illegal parameters");
-        return(Not_OK);
+  if (!cfg || !hw)
+    {
+      SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
+      return (-1);
     }
 
-    /*
-     * Validate the police config params being presented to RM
-     */
-    rc = sse2_pol_validate_cfg_params(cfg);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Config parameter validation failed. Error: %d",
-                            rc);
-        // Error is traced
-        return(Not_OK);
+  /*
+   * Validate the police config params being presented to RM
+   */
+  rc = sse2_pol_validate_cfg_params (cfg);
+  if (rc != 0)
+    {
+      SSE2_QOS_DEBUG_ERROR ("Config parameter validation failed. Error: %d",
+			    rc);
+      // Error is traced
+      return (-1);
     }
 
-    /*
-     * 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);
-    if (CERR_IS_NOTOK(rc)) {
-        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);
-        return(Not_OK);
+  /*
+   * 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);
+  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);
+      return (-1);
     }
 
-    return OK_pushHW;
+  return 0;
 }
 
 
@@ -867,112 +935,114 @@ sse2_pol_compute_hw_params (sse2_qos_pol_cfg_params_st *cfg,
  * Return the number of hardware TSC timer ticks per second for the dataplane.
  * This is approximately, but not exactly, the clock speed.
  */
-static uint64_t get_tsc_hz(void) 
+static u64
+get_tsc_hz (void)
 {
-    f64 cpu_freq;
+  f64 cpu_freq;
 
-    cpu_freq = os_cpu_clock_frequency();
-    return (uint64_t) cpu_freq;
+  cpu_freq = os_cpu_clock_frequency ();
+  return (u64) cpu_freq;
 }
 
 /*
  * Convert rates into bytes_per_period and scale.
  * Return 0 if ok or 1 if error.
  */
-static int 
-compute_policer_params (uint64_t hz,                 // CPU speed in clocks per second
-                        uint64_t cir_rate,           // in bytes per second
-                        uint64_t pir_rate,           // in bytes per second
-                        uint32_t *current_limit,     // in bytes, output may scale the input
-                        uint32_t *extended_limit,    // in bytes, output may scale the input
-                        uint32_t *cir_bytes_per_period,
-                        uint32_t *pir_bytes_per_period,
-                        uint32_t *scale)
+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)
 {
-    double period;
-    double internal_cir_bytes_per_period;
-    double internal_pir_bytes_per_period;
-    uint32_t max;
-    uint32_t scale_shift;
-    uint32_t scale_amount;
-    uint32_t __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.
-    period = ((double) hz) / ((double) POLICER_TICKS_PER_PERIOD);
-
-    // 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 contrained 
-    // 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.
+  double period;
+  double internal_cir_bytes_per_period;
+  double internal_pir_bytes_per_period;
+  u32 max;
+  u32 scale_shift;
+  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.
+  period = ((double) hz) / ((double) POLICER_TICKS_PER_PERIOD);
+
+  // 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 contrained
+  // 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, (uint32_t)internal_cir_bytes_per_period << MAX_RATE_SHIFT);
-    max = MAX(max, (uint32_t)internal_pir_bytes_per_period << MAX_RATE_SHIFT);
-    scale_shift = __builtin_clz(max);
-    
-    scale_amount = 1 << scale_shift;
-    *scale = scale_shift;
-    
-    // Scale the limits
-    *current_limit = *current_limit << scale_shift;
-    *extended_limit = *extended_limit << scale_shift;
-
-    // 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
-    if (internal_cir_bytes_per_period < 1.0) {
-        internal_cir_bytes_per_period = 1.0;
-    }
-    if (internal_pir_bytes_per_period < 1.0) {
-        internal_pir_bytes_per_period = 1.0;
-    }
-
-    *cir_bytes_per_period = (uint32_t)internal_cir_bytes_per_period;
-    *pir_bytes_per_period = (uint32_t)internal_pir_bytes_per_period;
-
-// #define PRINT_X86_POLICE_PARAMS 
-#ifdef PRINT_X86_POLICE_PARAMS
+  max = MAX (*current_limit, *extended_limit);
+  max = MAX (max, (u32) internal_cir_bytes_per_period << MAX_RATE_SHIFT);
+  max = MAX (max, (u32) internal_pir_bytes_per_period << MAX_RATE_SHIFT);
+  scale_shift = __builtin_clz (max);
+
+  scale_amount = 1 << scale_shift;
+  *scale = scale_shift;
+
+  // Scale the limits
+  *current_limit = *current_limit << scale_shift;
+  *extended_limit = *extended_limit << scale_shift;
+
+  // 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
+  if (internal_cir_bytes_per_period < 1.0)
+    {
+      internal_cir_bytes_per_period = 1.0;
+    }
+  if (internal_pir_bytes_per_period < 1.0)
     {
-        uint64_t 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 = (((uint64_t) (*cir_bytes_per_period * (uint64_t)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
-            (uint32_t)(period),                   // periods per second 
-            (uint32_t)(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);
+      internal_pir_bytes_per_period = 1.0;
     }
+
+  *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;			// ok
 }
 
 
@@ -981,97 +1051,113 @@ compute_policer_params (uint64_t hz,                 // CPU speed in clocks per
  * Output: h/w parameters are returned in 'hw',
  * Return: Status, success or failure code.
  */
-trans_layer_rc
-x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st *cfg,
-                           policer_read_response_type_st *hw)
+int
+x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st * cfg,
+			   policer_read_response_type_st * hw)
 {
-    const int BYTES_PER_KBIT = (1000 / 8);
-    uint64_t hz;
-    uint32_t cap;
-
-    if (!cfg || !hw) {
-        SSE2_QOS_DEBUG_ERROR("Illegal parameters");
-        return(Not_OK);
-    }
-
-    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 = (cfg->rb.kbps.cb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.cb_bytes;
-    hw->current_limit = cap;
-    cap = (cfg->rb.kbps.eb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.eb_bytes;
-    hw->extended_limit = cap;
-
-    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
-        hw->single_rate = 1;
-        hw->cir_tokens_per_period = 0;
-        return OK_pushHW;
-    }
-
-    if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) ||
-        (cfg->rfc == SSE2_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) {
-            SSE2_QOS_DEBUG_ERROR("Policer parameter validation failed -- 1R2C.");
-            return(Not_OK);
-        }
-
-        if ((cfg->rb.kbps.cir_kbps == 0) ||
-            (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.");
-            return(Not_OK);
-        }
-
-        if (compute_policer_params(hz, 
-                                   (uint64_t)cfg->rb.kbps.cir_kbps * BYTES_PER_KBIT, 
-                                   0,
-                                   &hw->current_limit, 
-                                   &hw->extended_limit,
-                                   &hw->cir_tokens_per_period,
-                                   &hw->pir_tokens_per_period, 
-                                   &hw->scale)) {
-            SSE2_QOS_DEBUG_ERROR("Policer parameter computation failed.");
-            return(Not_OK);
-        }
-
-    } else if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698) ||
-               (cfg->rfc == SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115)) {
-        // 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.");
-            return(Not_OK);
-        }
-
-        if (compute_policer_params(hz, 
-                                   (uint64_t)cfg->rb.kbps.cir_kbps * BYTES_PER_KBIT, 
-                                   (uint64_t)cfg->rb.kbps.eir_kbps * BYTES_PER_KBIT, 
-                                   &hw->current_limit, 
-                                   &hw->extended_limit,
-                                   &hw->cir_tokens_per_period,
-                                   &hw->pir_tokens_per_period, 
-                                   &hw->scale)) {
-            SSE2_QOS_DEBUG_ERROR("Policer parameter computation failed.");
-            return(Not_OK);
-        }
-
-    } else {
-        SSE2_QOS_DEBUG_ERROR("Config parameter validation failed. RFC not supported");
-        return(Not_OK);
-    }
-
-    hw->current_bucket = hw->current_limit;
-    hw->extended_bucket = hw->extended_limit;
-
-    return OK_pushHW;
+  const int BYTES_PER_KBIT = (1000 / 8);
+  u64 hz;
+  u32 cap;
+
+  if (!cfg || !hw)
+    {
+      SSE2_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 =
+    (cfg->rb.kbps.cb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.cb_bytes;
+  hw->current_limit = cap;
+  cap =
+    (cfg->rb.kbps.eb_bytes > 0xFFFFFFFF) ? 0xFFFFFFFF : cfg->rb.kbps.eb_bytes;
+  hw->extended_limit = cap;
+
+  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
+      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))
+    {
+      // Single-rate policer
+
+      hw->single_rate = 1;
+
+      if ((cfg->rfc == SSE2_QOS_POLICER_TYPE_1R2C) && cfg->rb.kbps.eb_bytes)
+	{
+	  SSE2_QOS_DEBUG_ERROR
+	    ("Policer parameter validation failed -- 1R2C.");
+	  return (-1);
+	}
+
+      if ((cfg->rb.kbps.cir_kbps == 0) ||
+	  (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.");
+	  return (-1);
+	}
+
+      if (compute_policer_params (hz,
+				  (u64) cfg->rb.kbps.cir_kbps *
+				  BYTES_PER_KBIT, 0, &hw->current_limit,
+				  &hw->extended_limit,
+				  &hw->cir_tokens_per_period,
+				  &hw->pir_tokens_per_period, &hw->scale))
+	{
+	  SSE2_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))
+    {
+      // 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.");
+	  return (-1);
+	}
+
+      if (compute_policer_params (hz,
+				  (u64) cfg->rb.kbps.cir_kbps *
+				  BYTES_PER_KBIT,
+				  (u64) cfg->rb.kbps.eir_kbps *
+				  BYTES_PER_KBIT, &hw->current_limit,
+				  &hw->extended_limit,
+				  &hw->cir_tokens_per_period,
+				  &hw->pir_tokens_per_period, &hw->scale))
+	{
+	  SSE2_QOS_DEBUG_ERROR ("Policer parameter computation failed.");
+	  return (-1);
+	}
+
+    }
+  else
+    {
+      SSE2_QOS_DEBUG_ERROR
+	("Config parameter validation failed. RFC not supported");
+      return (-1);
+    }
+
+  hw->current_bucket = hw->current_limit;
+  hw->extended_bucket = hw->extended_limit;
+
+  return 0;
 }
 #endif
 
@@ -1081,126 +1167,135 @@ x86_pol_compute_hw_params (sse2_qos_pol_cfg_params_st *cfg,
  * Output: physical structure is returned in 'phys',
  * Return: Status, success or failure code.
  */
-trans_layer_rc
-sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st    *cfg,
-                             policer_read_response_type_st *phys)
+int
+sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg,
+			     policer_read_response_type_st * phys)
 {
-    trans_layer_rc rc;
-    sse2_qos_pol_hw_params_st pol_hw;
-    sse2_qos_pol_cfg_params_st kbps_cfg;
+  int rc;
+  sse2_qos_pol_hw_params_st pol_hw;
+  sse2_qos_pol_cfg_params_st kbps_cfg;
 
-    memset(phys, 0, sizeof(policer_read_response_type_st));
-    memset(&kbps_cfg, 0, sizeof(sse2_qos_pol_cfg_params_st));
+  memset (phys, 0, sizeof (policer_read_response_type_st));
+  memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
 
-    if (!cfg) {
-        SSE2_QOS_DEBUG_ERROR("Illegal parameters");
-        return(Not_OK);
+  if (!cfg)
+    {
+      SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
+      return (-1);
     }
 
-    switch (cfg->rate_type) {
+  switch (cfg->rate_type)
+    {
     case SSE2_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;
+      /* 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:
-        kbps_cfg.rb.kbps.cir_kbps =
-            sse2_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(
-            (uint32_t) cfg->rb.pps.cb_ms, kbps_cfg.rb.kbps.cir_kbps);
-        kbps_cfg.rb.kbps.eb_bytes = sse2_qos_convert_burst_ms_to_bytes(
-            (uint32_t) cfg->rb.pps.eb_ms, kbps_cfg.rb.kbps.eir_kbps);
-        break;
+      kbps_cfg.rb.kbps.cir_kbps =
+	sse2_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);
+      break;
     default:
-        SSE2_QOS_DEBUG_ERROR("Illegal rate type");
-        return(Not_OK);
+      SSE2_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.rnd_type  = cfg->rnd_type;
-    kbps_cfg.rfc       = cfg->rfc;
+  /* rate type is now converted to kbps */
+  kbps_cfg.rate_type = SSE2_QOS_RATE_KBPS;
+  kbps_cfg.rnd_type = cfg->rnd_type;
+  kbps_cfg.rfc = cfg->rfc;
 
-    phys->action[POLICE_CONFORM]    = cfg->conform_action.action_type;
-    phys->mark_dscp[POLICE_CONFORM] = cfg->conform_action.dscp;
-    phys->action[POLICE_EXCEED]     = cfg->exceed_action.action_type;
-    phys->mark_dscp[POLICE_EXCEED]  = cfg->exceed_action.dscp;
-    phys->action[POLICE_VIOLATE]    = cfg->violate_action.action_type;
-    phys->mark_dscp[POLICE_VIOLATE] = cfg->violate_action.dscp;
+  phys->action[POLICE_CONFORM] = cfg->conform_action.action_type;
+  phys->mark_dscp[POLICE_CONFORM] = cfg->conform_action.dscp;
+  phys->action[POLICE_EXCEED] = cfg->exceed_action.action_type;
+  phys->mark_dscp[POLICE_EXCEED] = cfg->exceed_action.dscp;
+  phys->action[POLICE_VIOLATE] = cfg->violate_action.action_type;
+  phys->mark_dscp[POLICE_VIOLATE] = cfg->violate_action.dscp;
 
-    phys->color_aware = cfg->color_aware;
+  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 == Not_OK) {
-        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;
+  // 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
-    rc = x86_pol_compute_hw_params(&kbps_cfg, phys);
-    if (rc == Not_OK) {
-        SSE2_QOS_DEBUG_ERROR("Unable to compute hw param. Error: %d", rc);
-        return (rc);
+  // 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);
+      return (rc);
     }
 
-    /* for debugging purposes, the bucket token values can be overwritten */
-    if (cfg->overwrite_bucket) {
-        phys->current_bucket = cfg->current_bucket;
-        phys->extended_bucket = cfg->extended_bucket;
+  /* for debugging purposes, the bucket token values can be overwritten */
+  if (cfg->overwrite_bucket)
+    {
+      phys->current_bucket = cfg->current_bucket;
+      phys->extended_bucket = cfg->extended_bucket;
     }
 
-    // Touch to avoid compiler warning for X86
-    pol_hw.allow_negative = pol_hw.allow_negative;
+  // Touch to avoid compiler warning for X86
+  pol_hw.allow_negative = pol_hw.allow_negative;
 
 #endif // if !defined (INTERNAL_SS) && !defined (X86)
 
-    return OK_pushHW;
+  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)
+sse2_qos_convert_pol_bucket_to_hw_fmt (policer_read_response_type_st * bkt,
+				       sse2_qos_pol_hw_params_st * hw_fmt)
 {
-    memset(hw_fmt, 0, sizeof(sse2_qos_pol_hw_params_st));
+  memset (hw_fmt, 0, sizeof (sse2_qos_pol_hw_params_st));
 #if !defined (INTERNAL_SS) && !defined (X86)
-    hw_fmt->rfc = (uint8_t)bkt->rfc;
-    hw_fmt->allow_negative = (uint8_t)bkt->an;
-    hw_fmt->rate_exp = (uint8_t)bkt->rexp;
-    hw_fmt->avg_rate_man = (uint16_t)bkt->arm;
-    hw_fmt->peak_rate_man = (uint16_t)bkt->prm;
-    hw_fmt->comm_bkt_limit_man = (uint8_t)bkt->cblm;
-    hw_fmt->comm_bkt_limit_exp = (uint8_t)bkt->cble;
-    hw_fmt->extd_bkt_limit_man = (uint8_t)bkt->eblm;
-    hw_fmt->extd_bkt_limit_exp = (uint8_t)bkt->eble;
-    hw_fmt->extd_bkt = bkt->eb;
-    hw_fmt->comm_bkt = bkt->cb;
+  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)
 }
 
@@ -1209,114 +1304,127 @@ sse2_qos_convert_pol_bucket_to_hw_fmt (
  * Output: configured parameter values in 'cfg'
  * Return: Status, success or failure code.
  */
-static cerrno
-sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st  *hw,
-                                   sse2_qos_pol_cfg_params_st *cfg)
+static int
+sse2_pol_convert_hw_to_cfg_params (sse2_qos_pol_hw_params_st * hw,
+				   sse2_qos_pol_cfg_params_st * cfg)
 {
-    uint64_t temp_rate;
-
-    if ((hw == NULL) || (cfg == NULL)) {
-        return EINVAL;
-    }
-
-    if ((hw->rfc == IPE_RFC_RFC4115) &&
-        !(hw->peak_rate_man << hw->rate_exp) &&
-        !(hw->extd_bkt_limit_man)) {
-        /*
-         * For a 1R2C, we set EIR = 0, EB = 0
-         */
-        cfg->rfc = SSE2_QOS_POLICER_TYPE_1R2C;
-    } else if (hw->rfc == IPE_RFC_RFC2697) {
-        cfg->rfc = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
-    } else if (hw->rfc == IPE_RFC_RFC2698) {
-        cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
-    } else if (hw->rfc == IPE_RFC_RFC4115) {
-        cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
-    } else if (hw->rfc == IPE_RFC_MEF5CF1) {
-        cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1;
-    } else {
-        return EINVAL;
-    }
-
-    temp_rate = (((uint64_t) hw->avg_rate_man << hw->rate_exp) * 8LL *
-                SSE2_QOS_POL_TICKS_PER_SEC)/1000;
-    cfg->rb.kbps.cir_kbps = (uint32_t)temp_rate;
-
-    temp_rate = (((uint64_t) hw->peak_rate_man << hw->rate_exp) * 8LL *
-                SSE2_QOS_POL_TICKS_PER_SEC)/1000;
-    cfg->rb.kbps.eir_kbps = (uint32_t)temp_rate;
-
-    cfg->rb.kbps.cb_bytes = ((uint64_t)hw->comm_bkt_limit_man << 
-                            (uint64_t)hw->comm_bkt_limit_exp);
-    cfg->rb.kbps.eb_bytes = ((uint64_t)hw->extd_bkt_limit_man << 
-                            (uint64_t)hw->extd_bkt_limit_exp);
-
-    if (cfg->rfc == SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697) {
-       /*
-        * For 1R3C in the hardware, EB = sum(CB, EB). Also, EIR = CIR. Restore
-        * values such that the configured params don't reflect this adjustment
-        */
-        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) {
-       /*
-        * For 4115 in the hardware is excess rate and burst, but EA provides
-        * peak-rate, so adjust it to be eir
-        */
-        cfg->rb.kbps.eir_kbps += cfg->rb.kbps.cir_kbps;
-        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->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);
-
-    return EOK;
+  u64 temp_rate;
+
+  if ((hw == NULL) || (cfg == NULL))
+    {
+      return EINVAL;
+    }
+
+  if ((hw->rfc == IPE_RFC_RFC4115) &&
+      !(hw->peak_rate_man << hw->rate_exp) && !(hw->extd_bkt_limit_man))
+    {
+      /*
+       * For a 1R2C, we set EIR = 0, EB = 0
+       */
+      cfg->rfc = SSE2_QOS_POLICER_TYPE_1R2C;
+    }
+  else if (hw->rfc == IPE_RFC_RFC2697)
+    {
+      cfg->rfc = SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697;
+    }
+  else if (hw->rfc == IPE_RFC_RFC2698)
+    {
+      cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698;
+    }
+  else if (hw->rfc == IPE_RFC_RFC4115)
+    {
+      cfg->rfc = SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115;
+    }
+  else if (hw->rfc == IPE_RFC_MEF5CF1)
+    {
+      cfg->rfc = SSE2_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;
+  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;
+  cfg->rb.kbps.eir_kbps = (u32) temp_rate;
+
+  cfg->rb.kbps.cb_bytes = ((u64) hw->comm_bkt_limit_man <<
+			   (u64) hw->comm_bkt_limit_exp);
+  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)
+    {
+      /*
+       * For 1R3C in the hardware, EB = sum(CB, EB). Also, EIR = CIR. Restore
+       * values such that the configured params don't reflect this adjustment
+       */
+      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)
+    {
+      /*
+       * For 4115 in the hardware is excess rate and burst, but EA provides
+       * peak-rate, so adjust it to be eir
+       */
+      cfg->rb.kbps.eir_kbps += cfg->rb.kbps.cir_kbps;
+      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->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);
+
+  return 0;
 }
 
-uint32_t
-sse2_qos_convert_kbps_to_pps (uint32_t rate_kbps)
+u32
+sse2_qos_convert_kbps_to_pps (u32 rate_kbps)
 {
-    uint64_t numer, denom, rnd_value = 0;
+  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(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                            SSE2_QOS_SHIP_CNT_POL_CONV_KBPS_TO_PPS);
 
-    numer = (uint64_t)((uint64_t)rate_kbps * 1000LL);
-    denom = (uint64_t)((uint64_t)SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL);
+  numer = (u64) ((u64) rate_kbps * 1000LL);
+  denom = (u64) ((u64) SSE2_QOS_POLICER_FIXED_PKT_SIZE * 8LL);
 
-    (void)sse2_qos_pol_round(numer, denom, &rnd_value,
-                             SSE2_QOS_ROUND_TO_CLOSEST);
+  (void) sse2_qos_pol_round (numer, denom, &rnd_value,
+			     SSE2_QOS_ROUND_TO_CLOSEST);
 
-    return((uint32_t)rnd_value);
+  return ((u32) rnd_value);
 }
 
-uint32_t
-sse2_qos_convert_burst_bytes_to_ms (uint64_t burst_bytes,
-                                    uint32_t rate_kbps)
+u32
+sse2_qos_convert_burst_bytes_to_ms (u64 burst_bytes, u32 rate_kbps)
 {
-    uint64_t numer, denom, rnd_value = 0;
+  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(SSE2_QOS_SHIP_COUNTER_TYPE_API_CNT,
+  //                         SSE2_QOS_SHIP_CNT_POL_CONV_BYTES_TO_BURST_MS);
 
-    numer = burst_bytes * 8LL;
-    denom = (uint64_t)rate_kbps;
+  numer = burst_bytes * 8LL;
+  denom = (u64) rate_kbps;
 
-    (void)sse2_qos_pol_round(numer, denom, &rnd_value,
-                             SSE2_QOS_ROUND_TO_CLOSEST);
+  (void) sse2_qos_pol_round (numer, denom, &rnd_value,
+			     SSE2_QOS_ROUND_TO_CLOSEST);
 
-    return((uint32_t)rnd_value);
+  return ((u32) rnd_value);
 }
 
 /*
@@ -1324,61 +1432,74 @@ sse2_qos_convert_burst_bytes_to_ms (uint64_t burst_bytes,
  * Output: configured parameters in 'cfg'.
  * Return: Status, success or failure code.
  */
-trans_layer_rc
-sse2_pol_physical_2_logical (policer_read_response_type_st *phys,
-                             sse2_qos_pol_cfg_params_st    *cfg)
+int
+sse2_pol_physical_2_logical (policer_read_response_type_st * phys,
+			     sse2_qos_pol_cfg_params_st * cfg)
 {
-    cerrno rc;
-    sse2_qos_pol_hw_params_st pol_hw;
-    sse2_qos_pol_cfg_params_st kbps_cfg;
+  int rc;
+  sse2_qos_pol_hw_params_st pol_hw;
+  sse2_qos_pol_cfg_params_st kbps_cfg;
 
-    memset(&pol_hw, 0, sizeof(sse2_qos_pol_hw_params_st));
-    memset(&kbps_cfg, 0, sizeof(sse2_qos_pol_cfg_params_st));
+  memset (&pol_hw, 0, sizeof (sse2_qos_pol_hw_params_st));
+  memset (&kbps_cfg, 0, sizeof (sse2_qos_pol_cfg_params_st));
 
-    if (!phys) {
-        SSE2_QOS_DEBUG_ERROR("Illegal parameters");
-        return(Not_OK);
+  if (!phys)
+    {
+      SSE2_QOS_DEBUG_ERROR ("Illegal parameters");
+      return (-1);
     }
 
-    sse2_qos_convert_pol_bucket_to_hw_fmt (phys, &pol_hw);
+  sse2_qos_convert_pol_bucket_to_hw_fmt (phys, &pol_hw);
 
-    rc = sse2_pol_convert_hw_to_cfg_params(&pol_hw, &kbps_cfg);
-    if (CERR_IS_NOTOK(rc)) {
-        SSE2_QOS_DEBUG_ERROR("Unable to convert hw params to config params. "
-                            "Error: %d", rc);
-        return(Not_OK);
+  rc = sse2_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);
+      return (-1);
     }
 
-    /* check what rate type is required */
-    switch (cfg->rate_type) {
+  /* check what rate type is required */
+  switch (cfg->rate_type)
+    {
     case SSE2_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;
+      /* 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:
-        cfg->rb.pps.cir_pps =
-            sse2_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);
-        break;
+      cfg->rb.pps.cir_pps =
+	sse2_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);
+      break;
     default:
-        SSE2_QOS_DEBUG_ERROR("Illegal rate type");
-        return(Not_OK);
+      SSE2_QOS_DEBUG_ERROR ("Illegal rate type");
+      return (-1);
     }
 
-    /* cfg->rate_type remains what it was */
-    cfg->rnd_type         = kbps_cfg.rnd_type;
-    cfg->rfc              = kbps_cfg.rfc;
-    cfg->overwrite_bucket = kbps_cfg.overwrite_bucket;
-    cfg->current_bucket   = kbps_cfg.current_bucket;
-    cfg->extended_bucket  = kbps_cfg.extended_bucket;
+  /* cfg->rate_type remains what it was */
+  cfg->rnd_type = kbps_cfg.rnd_type;
+  cfg->rfc = kbps_cfg.rfc;
+  cfg->overwrite_bucket = kbps_cfg.overwrite_bucket;
+  cfg->current_bucket = kbps_cfg.current_bucket;
+  cfg->extended_bucket = kbps_cfg.extended_bucket;
 
-    return OK_pushHW;
+  return 0;
 }
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */
diff --git a/vnet/vnet/policer/xlate.h b/vnet/vnet/policer/xlate.h
index 69a58d25efb..16742f80a47 100644
--- a/vnet/vnet/policer/xlate.h
+++ b/vnet/vnet/policer/xlate.h
@@ -20,31 +20,32 @@
 #ifndef __included_xlate_h__
 #define __included_xlate_h__
 
-#include <vnet/policer/fix_types.h>
 #include <vnet/policer/police.h>
 
 /*
  * edt: * enum sse2_qos_policer_type_en
  *  Defines type of policer to be allocated
  */
-typedef enum sse2_qos_policer_type_en_ {
-    SSE2_QOS_POLICER_TYPE_1R2C = 0,
-    SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697 = 1,
-    SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698 = 2,
-    SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115 = 3,
-    SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1 = 4,
-    SSE2_QOS_POLICER_TYPE_MAX
+typedef enum sse2_qos_policer_type_en_
+{
+  SSE2_QOS_POLICER_TYPE_1R2C = 0,
+  SSE2_QOS_POLICER_TYPE_1R3C_RFC_2697 = 1,
+  SSE2_QOS_POLICER_TYPE_2R3C_RFC_2698 = 2,
+  SSE2_QOS_POLICER_TYPE_2R3C_RFC_4115 = 3,
+  SSE2_QOS_POLICER_TYPE_2R3C_RFC_MEF5CF1 = 4,
+  SSE2_QOS_POLICER_TYPE_MAX
 } sse2_qos_policer_type_en;
 
 /*
  * edt: * enum
  *  Enum used to define type of rounding used when calculating policer values
  */
-typedef enum {
-    SSE2_QOS_ROUND_TO_CLOSEST = 0,
-    SSE2_QOS_ROUND_TO_UP,
-    SSE2_QOS_ROUND_TO_DOWN,
-    SSE2_QOS_ROUND_INVALID
+typedef enum
+{
+  SSE2_QOS_ROUND_TO_CLOSEST = 0,
+  SSE2_QOS_ROUND_TO_UP,
+  SSE2_QOS_ROUND_TO_DOWN,
+  SSE2_QOS_ROUND_INVALID
 } sse2_qos_round_type_en;
 
 /*
@@ -57,20 +58,22 @@ typedef enum {
  *  of units_in_bits field in sse2_static_policer_parameters_st, which is
  *  inline with sse_punt_drop.h.
  */
-typedef enum {
-    SSE2_QOS_RATE_KBPS = 0,
-    SSE2_QOS_RATE_PPS,
-    SSE2_QOS_RATE_INVALID
+typedef enum
+{
+  SSE2_QOS_RATE_KBPS = 0,
+  SSE2_QOS_RATE_PPS,
+  SSE2_QOS_RATE_INVALID
 } sse2_qos_rate_type_en;
 
 /*
  * edt: * enum
  * Defines type of policer actions.
  */
-typedef enum {
-    SSE2_QOS_ACTION_DROP = 0,
-    SSE2_QOS_ACTION_TRANSMIT,
-    SSE2_QOS_ACTION_MARK_AND_TRANSMIT
+typedef enum
+{
+  SSE2_QOS_ACTION_DROP = 0,
+  SSE2_QOS_ACTION_TRANSMIT,
+  SSE2_QOS_ACTION_MARK_AND_TRANSMIT
 } sse2_qos_action_type_en;
 
 /*
@@ -82,88 +85,102 @@ typedef enum {
  * elemtnt: dscp
  *      DSCP value to set when action is SSE2_QOS_ACTION_MARK_AND_TRANSMIT.
  */
-typedef struct sse2_qos_pol_action_params_st_ {
-    uint8_t  action_type;
-    uint8_t  dscp;
+typedef struct sse2_qos_pol_action_params_st_
+{
+  u8 action_type;
+  u8 dscp;
 } sse2_qos_pol_action_params_st;
 
-/* 
+/*
  * edt: * struct sse2_qos_pol_cfg_params_st
  *
- * Description: 
- * This structure is used to hold user configured policing parameters. 
- * 
- * element: cir_kbps 
+ * Description:
+ * This structure is used to hold user configured policing parameters.
+ *
+ * element: cir_kbps
  *      CIR in kbps.
- * element: eir_kbps 
+ * element: eir_kbps
  *      EIR or PIR in kbps.
- * element: cb_bytes 
+ * element: cb_bytes
  *      Committed Burst in bytes.
- * element: eb_bytes 
+ * element: eb_bytes
  *      Excess or Peak Burst in bytes.
- * element: cir_pps 
+ * element: cir_pps
  *      CIR in pps.
- * element: eir_pps 
+ * element: eir_pps
  *      EIR or PIR in pps.
- * element: cb_ms 
+ * element: cb_ms
  *      Committed Burst in milliseconds.
- * element: eb_ms 
+ * element: eb_ms
  *      Excess or Peak Burst in milliseconds.
- * element: rate_type 
+ * element: rate_type
  *      Indicates the union if in kbps/bytes or pps/ms.
- * element: rfc 
+ * element: rfc
  *      Policer algorithm - 1R2C, 1R3C (2697), 2R3C (2698) or 2R3C (4115). See
  *      sse_qos_policer_type_en
  * element: rnd_type
  *      Rounding type (see sse_qos_round_type_en). Needed when policer values
  *      need to be rounded. Caller can decide on type of rounding used
  */
-typedef struct sse2_qos_pol_cfg_params_st_ {
-    union {
-        struct {
-            uint32_t cir_kbps;
-            uint32_t eir_kbps;
-            uint64_t cb_bytes;
-            uint64_t eb_bytes;
-        } PACKED kbps;
-        struct {
-            uint32_t cir_pps;
-            uint32_t eir_pps;
-            uint64_t cb_ms;
-            uint64_t eb_ms;
-        } PACKED pps;
-    } PACKED rb;               /* rate burst config */
-    uint8_t  rate_type;        /* sse2_qos_rate_type_en */
-    uint8_t  rnd_type;         /* sse2_qos_round_type_en */
-    uint8_t  rfc;              /* sse2_qos_policer_type_en */
-    uint8_t  color_aware;
-    uint8_t  overwrite_bucket; /* for debugging purposes */
-    uint32_t current_bucket;   /* for debugging purposes */
-    uint32_t extended_bucket;  /* for debugging purposes */
-    sse2_qos_pol_action_params_st conform_action;
-    sse2_qos_pol_action_params_st exceed_action;
-    sse2_qos_pol_action_params_st violate_action;
+typedef struct sse2_qos_pol_cfg_params_st_
+{
+  union
+  {
+    struct
+    {
+      u32 cir_kbps;
+      u32 eir_kbps;
+      u64 cb_bytes;
+      u64 eb_bytes;
+    } kbps;
+    struct
+    {
+      u32 cir_pps;
+      u32 eir_pps;
+      u64 cb_ms;
+      u64 eb_ms;
+    } pps;
+  } rb;				/* rate burst config */
+  u8 rate_type;			/* sse2_qos_rate_type_en */
+  u8 rnd_type;			/* sse2_qos_round_type_en */
+  u8 rfc;			/* sse2_qos_policer_type_en */
+  u8 color_aware;
+  u8 overwrite_bucket;		/* for debugging purposes */
+  u32 current_bucket;		/* for debugging purposes */
+  u32 extended_bucket;		/* for debugging purposes */
+  sse2_qos_pol_action_params_st conform_action;
+  sse2_qos_pol_action_params_st exceed_action;
+  sse2_qos_pol_action_params_st violate_action;
 } sse2_qos_pol_cfg_params_st;
 
 
-typedef struct sse2_qos_pol_hw_params_st_ {
-    uint8_t  rfc;
-    uint8_t  allow_negative;
-    uint8_t  rate_exp;
-    uint16_t avg_rate_man;
-    uint16_t peak_rate_man;
-    uint8_t  comm_bkt_limit_exp;
-    uint8_t  comm_bkt_limit_man;
-    uint8_t  extd_bkt_limit_exp;
-    uint8_t  extd_bkt_limit_man;
-    uint32_t comm_bkt;
-    uint32_t extd_bkt;
+typedef struct sse2_qos_pol_hw_params_st_
+{
+  u8 rfc;
+  u8 allow_negative;
+  u8 rate_exp;
+  u16 avg_rate_man;
+  u16 peak_rate_man;
+  u8 comm_bkt_limit_exp;
+  u8 comm_bkt_limit_man;
+  u8 extd_bkt_limit_exp;
+  u8 extd_bkt_limit_man;
+  u32 comm_bkt;
+  u32 extd_bkt;
 } sse2_qos_pol_hw_params_st;
 
 
-trans_layer_rc
-sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st    *cfg,
-                             policer_read_response_type_st *phys);
+int
+sse2_pol_logical_2_physical (sse2_qos_pol_cfg_params_st * cfg,
+			     policer_read_response_type_st * phys);
 
 
 #endif /* __included_xlate_h__ */
+
+/*
+ * fd.io coding-style-patch-verification: ON
+ *
+ * Local Variables:
+ * eval: (c-set-style "gnu")
+ * End:
+ */