diff --git a/drivers/net/ice/base/ice_acl.h b/drivers/net/ice/base/ice_acl.h
index f87a0aa795..21aa5088f7 100644
--- a/drivers/net/ice/base/ice_acl.h
+++ b/drivers/net/ice/base/ice_acl.h
@@ -47,11 +47,11 @@ struct ice_acl_tbl {
 };
 
 #define ICE_MAX_ACL_TCAM_ENTRY (ICE_AQC_ACL_TCAM_DEPTH * ICE_AQC_ACL_SLICES)
-enum ice_acl_entry_prior {
-	ICE_LOW = 0,
-	ICE_NORMAL,
-	ICE_HIGH,
-	ICE_MAX_PRIOR
+enum ice_acl_entry_prio {
+	ICE_ACL_PRIO_LOW = 0,
+	ICE_ACL_PRIO_NORMAL,
+	ICE_ACL_PRIO_HIGH,
+	ICE_ACL_MAX_PRIO
 };
 
 /* Scenario structure
@@ -74,8 +74,8 @@ struct ice_acl_scen {
 	 * be available in this scenario
 	 */
 	ice_declare_bitmap(entry_bitmap, ICE_MAX_ACL_TCAM_ENTRY);
-	u16 first_idx[ICE_MAX_PRIOR];
-	u16 last_idx[ICE_MAX_PRIOR];
+	u16 first_idx[ICE_ACL_MAX_PRIO];
+	u16 last_idx[ICE_ACL_MAX_PRIO];
 
 	u16 id;
 	u16 start;	/* Number of entry from the start of the parent table */
@@ -192,7 +192,7 @@ ice_aq_query_acl_scen(struct ice_hw *hw, u16 scen_id,
 		      struct ice_aqc_acl_scen *buf, struct ice_sq_cd *cd);
 enum ice_status
 ice_acl_add_entry(struct ice_hw *hw, struct ice_acl_scen *scen,
-		  enum ice_acl_entry_prior prior, u8 *keys, u8 *inverts,
+		  enum ice_acl_entry_prio prio, u8 *keys, u8 *inverts,
 		  struct ice_acl_act_entry *acts, u8 acts_cnt, u16 *entry_idx);
 enum ice_status
 ice_acl_prog_act(struct ice_hw *hw, struct ice_acl_scen *scen,
diff --git a/drivers/net/ice/base/ice_acl_ctrl.c b/drivers/net/ice/base/ice_acl_ctrl.c
index bd09e9d776..3c4d45cc0d 100644
--- a/drivers/net/ice/base/ice_acl_ctrl.c
+++ b/drivers/net/ice/base/ice_acl_ctrl.c
@@ -25,19 +25,21 @@ static void ice_acl_init_entry(struct ice_acl_scen *scen)
 	 * normal priority: start from the highest index, 50% of total entries
 	 * high priority: start from the lowest index, 25% of total entries
 	 */
-	scen->first_idx[ICE_LOW] = scen->num_entry - 1;
-	scen->first_idx[ICE_NORMAL] = scen->num_entry - scen->num_entry / 4 - 1;
-	scen->first_idx[ICE_HIGH] = 0;
+	scen->first_idx[ICE_ACL_PRIO_LOW] = scen->num_entry - 1;
+	scen->first_idx[ICE_ACL_PRIO_NORMAL] = scen->num_entry -
+		scen->num_entry / 4 - 1;
+	scen->first_idx[ICE_ACL_PRIO_HIGH] = 0;
 
-	scen->last_idx[ICE_LOW] = scen->num_entry - scen->num_entry / 4;
-	scen->last_idx[ICE_NORMAL] = scen->num_entry / 4;
-	scen->last_idx[ICE_HIGH] = scen->num_entry / 4 - 1;
+	scen->last_idx[ICE_ACL_PRIO_LOW] = scen->num_entry -
+		scen->num_entry / 4;
+	scen->last_idx[ICE_ACL_PRIO_NORMAL] = scen->num_entry / 4;
+	scen->last_idx[ICE_ACL_PRIO_HIGH] = scen->num_entry / 4 - 1;
 }
 
 /**
  * ice_acl_scen_assign_entry_idx
  * @scen: pointer to the scenario struct
- * @prior: the priority of the flow entry being allocated
+ * @prio: the priority of the flow entry being allocated
  *
  * To find the index of an available entry in scenario
  *
@@ -46,16 +48,16 @@ static void ice_acl_init_entry(struct ice_acl_scen *scen)
  */
 static u16
 ice_acl_scen_assign_entry_idx(struct ice_acl_scen *scen,
-			      enum ice_acl_entry_prior prior)
+			      enum ice_acl_entry_prio prio)
 {
 	u16 first_idx, last_idx, i;
 	s8 step;
 
-	if (prior >= ICE_MAX_PRIOR)
+	if (prio >= ICE_ACL_MAX_PRIO)
 		return ICE_ACL_SCEN_ENTRY_INVAL;
 
-	first_idx = scen->first_idx[prior];
-	last_idx = scen->last_idx[prior];
+	first_idx = scen->first_idx[prio];
+	last_idx = scen->last_idx[prio];
 	step = first_idx <= last_idx ? 1 : -1;
 
 	for (i = first_idx; i != last_idx + step; i += step)
@@ -953,7 +955,7 @@ enum ice_status ice_acl_destroy_tbl(struct ice_hw *hw)
  * ice_acl_add_entry - Add a flow entry to an ACL scenario
  * @hw: pointer to the HW struct
  * @scen: scenario to add the entry to
- * @prior: priority level of the entry being added
+ * @prio: priority level of the entry being added
  * @keys: buffer of the value of the key to be programmed to the ACL entry
  * @inverts: buffer of the value of the key inverts to be programmed
  * @acts: pointer to a buffer containing formatted actions
@@ -967,7 +969,7 @@ enum ice_status ice_acl_destroy_tbl(struct ice_hw *hw)
  */
 enum ice_status
 ice_acl_add_entry(struct ice_hw *hw, struct ice_acl_scen *scen,
-		  enum ice_acl_entry_prior prior, u8 *keys, u8 *inverts,
+		  enum ice_acl_entry_prio prio, u8 *keys, u8 *inverts,
 		  struct ice_acl_act_entry *acts, u8 acts_cnt, u16 *entry_idx)
 {
 	u8 i, entry_tcam, num_cscd, offset;
@@ -978,7 +980,7 @@ ice_acl_add_entry(struct ice_hw *hw, struct ice_acl_scen *scen,
 	if (!scen)
 		return ICE_ERR_DOES_NOT_EXIST;
 
-	*entry_idx = ice_acl_scen_assign_entry_idx(scen, prior);
+	*entry_idx = ice_acl_scen_assign_entry_idx(scen, prio);
 	if (*entry_idx >= scen->num_entry) {
 		*entry_idx = 0;
 		return ICE_ERR_MAX_LIMIT;
diff --git a/drivers/net/ice/base/ice_flow.c b/drivers/net/ice/base/ice_flow.c
index cd3ce82311..de5dfb2288 100644
--- a/drivers/net/ice/base/ice_flow.c
+++ b/drivers/net/ice/base/ice_flow.c
@@ -2715,30 +2715,30 @@ ice_flow_acl_find_scen_entry_cond(struct ice_flow_prof *prof,
 }
 
 /**
- * ice_flow_acl_convert_to_acl_prior - Convert to ACL priority
+ * ice_flow_acl_convert_to_acl_prio - Convert to ACL priority
  * @p: flow priority
  */
-static enum ice_acl_entry_prior
-ice_flow_acl_convert_to_acl_prior(enum ice_flow_priority p)
+static enum ice_acl_entry_prio
+ice_flow_acl_convert_to_acl_prio(enum ice_flow_priority p)
 {
-	enum ice_acl_entry_prior acl_prior;
+	enum ice_acl_entry_prio acl_prio;
 
 	switch (p) {
 	case ICE_FLOW_PRIO_LOW:
-		acl_prior = ICE_LOW;
+		acl_prio = ICE_ACL_PRIO_LOW;
 		break;
 	case ICE_FLOW_PRIO_NORMAL:
-		acl_prior = ICE_NORMAL;
+		acl_prio = ICE_ACL_PRIO_NORMAL;
 		break;
 	case ICE_FLOW_PRIO_HIGH:
-		acl_prior = ICE_HIGH;
+		acl_prio = ICE_ACL_PRIO_HIGH;
 		break;
 	default:
-		acl_prior = ICE_NORMAL;
+		acl_prio = ICE_ACL_PRIO_NORMAL;
 		break;
 	}
 
-	return acl_prior;
+	return acl_prio;
 }
 
 /**
@@ -2878,15 +2878,15 @@ ice_flow_acl_add_scen_entry_sync(struct ice_hw *hw, struct ice_flow_prof *prof,
 			   ICE_NONDMA_TO_NONDMA);
 
 	if (do_add_entry) {
-		enum ice_acl_entry_prior prior;
+		enum ice_acl_entry_prio prio;
 		u8 *keys, *inverts;
 		u16 entry_idx;
 
 		keys = (u8 *)e->entry;
 		inverts = keys + (e->entry_sz / 2);
-		prior = ice_flow_acl_convert_to_acl_prior(e->priority);
+		prio = ice_flow_acl_convert_to_acl_prio(e->priority);
 
-		status = ice_acl_add_entry(hw, prof->cfg.scen, prior, keys,
+		status = ice_acl_add_entry(hw, prof->cfg.scen, prio, keys,
 					   inverts, acts, e->acts_cnt,
 					   &entry_idx);
 		if (status)
@@ -2904,7 +2904,6 @@ ice_flow_acl_add_scen_entry_sync(struct ice_hw *hw, struct ice_flow_prof *prof,
 			exist->acts = (struct ice_flow_action *)
 				ice_calloc(hw, exist->acts_cnt,
 					   sizeof(struct ice_flow_action));
-
 			if (!exist->acts) {
 				status = ICE_ERR_NO_MEMORY;
 				goto out;