| /* |
| * Copyright (c) 2016-2017, 2021, The Linux Foundation. All rights reserved. |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all copies. |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
| * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
| * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT |
| * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| |
| /** |
| * @defgroup |
| * @{ |
| */ |
| #include "sw.h" |
| #include "hppe_policer_reg.h" |
| #include "hppe_policer.h" |
| #include "adpt.h" |
| |
| #define NR_ADPT_HPPE_POLICER_METER_UNIT 2 |
| #define NR_ADPT_HPPE_POLICER_METER_TOKEN_UNIT 8 |
| #define ADPT_HPPE_POLICER_METER_UNIT_BYTE 0 |
| #define ADPT_HPPE_POLICER_METER_UNIT_FRAME 1 |
| #define ADPT_HPPE_FREQUENCY 300 /*MHZ*/ |
| #define ADPT_HPPE_POLICER_BURST_SIZE_UNIT 65536 |
| #define ADPT_HPPE_POLICER_REFRESH_BITS 18 |
| #define ADPT_HPPE_POLICER_BUCKET_SIZE_BITS 16 |
| #define ADPT_HPPE_POLICER_REFRESH_MAX ((1 << ADPT_HPPE_POLICER_REFRESH_BITS) - 1) |
| #define ADPT_HPPE_POLICER_BUCKET_SIZE_MAX ((1 << ADPT_HPPE_POLICER_BUCKET_SIZE_BITS) - 1) |
| #define BYTE_POLICER_MAX_RATE 10000000 |
| #define BYTE_POLICER_MIN_RATE 64 |
| #define FRAME_POLICER_MAX_RATE 14881000 |
| #define FRAME_POLICER_MIN_RATE 6 |
| |
| |
| static a_uint32_t hppe_policer_token_unit[NR_ADPT_HPPE_POLICER_METER_UNIT] |
| [NR_ADPT_HPPE_POLICER_METER_TOKEN_UNIT] = {{2048 * 8, |
| 512 * 8,128 * 8,32 * 8,8 * 8,2 * 8, 4, 1}, |
| {2097152,524288,131072,32768,8192,2048,512,128}}; |
| |
| typedef struct |
| { |
| a_uint64_t rate_1bit; |
| a_uint64_t rate_max; |
| } adpt_hppe_policer_rate_t; |
| |
| typedef struct |
| { |
| a_uint64_t burst_size_1bit; |
| a_uint64_t burst_size_max; |
| } adpt_hppe_policer_burst_size_t; |
| |
| static adpt_hppe_policer_rate_t |
| hppe_policer_rate[NR_ADPT_HPPE_POLICER_METER_UNIT][NR_ADPT_HPPE_POLICER_METER_TOKEN_UNIT] = |
| { |
| /* byte based*/ |
| { |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| }, |
| |
| /*frame based */ |
| { |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| }, |
| }; |
| |
| static adpt_hppe_policer_burst_size_t |
| hppe_policer_burst_size[NR_ADPT_HPPE_POLICER_METER_UNIT][NR_ADPT_HPPE_POLICER_METER_TOKEN_UNIT] = |
| { |
| { {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| }, |
| { {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| {0,0}, |
| }, |
| }; |
| |
| #ifndef IN_POLICER_MINI |
| sw_error_t |
| adpt_hppe_acl_policer_counter_get(a_uint32_t dev_id, a_uint32_t index, |
| fal_policer_counter_t *counter) |
| { |
| union in_acl_meter_cnt_tbl_u in_acl_meter_cnt_tbl; |
| |
| memset(&in_acl_meter_cnt_tbl, 0, sizeof(in_acl_meter_cnt_tbl)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(counter); |
| |
| if (index < 0 || index > 511) |
| return SW_BAD_PARAM; |
| |
| hppe_in_acl_meter_cnt_tbl_get(dev_id, index * 3, &in_acl_meter_cnt_tbl); |
| counter->green_packet_counter = in_acl_meter_cnt_tbl.bf.pkt_cnt; |
| counter->green_byte_counter = in_acl_meter_cnt_tbl.bf.byte_cnt_1; |
| counter->green_byte_counter = (counter->green_byte_counter << 32) | in_acl_meter_cnt_tbl.bf.byte_cnt_0; |
| |
| hppe_in_acl_meter_cnt_tbl_get(dev_id, index * 3 + 1, &in_acl_meter_cnt_tbl); |
| counter->yellow_packet_counter = in_acl_meter_cnt_tbl.bf.pkt_cnt; |
| counter->yellow_byte_counter = in_acl_meter_cnt_tbl.bf.byte_cnt_1; |
| counter->yellow_byte_counter = (counter->yellow_byte_counter << 32) | in_acl_meter_cnt_tbl.bf.byte_cnt_0; |
| |
| hppe_in_acl_meter_cnt_tbl_get(dev_id, index * 3 + 2, &in_acl_meter_cnt_tbl); |
| counter->red_packet_counter = in_acl_meter_cnt_tbl.bf.pkt_cnt; |
| counter->red_byte_counter = in_acl_meter_cnt_tbl.bf.byte_cnt_1; |
| counter->red_byte_counter = (counter->red_byte_counter << 32) | in_acl_meter_cnt_tbl.bf.byte_cnt_0; |
| |
| return SW_OK; |
| } |
| |
| sw_error_t |
| adpt_hppe_port_policer_counter_get(a_uint32_t dev_id, fal_port_t port_id, |
| fal_policer_counter_t *counter) |
| { |
| union in_port_meter_cnt_tbl_u in_port_meter_cnt_tbl; |
| |
| memset(&in_port_meter_cnt_tbl, 0, sizeof(in_port_meter_cnt_tbl)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(counter); |
| |
| if (port_id < 0 || port_id > 7) |
| return SW_BAD_PARAM; |
| |
| hppe_in_port_meter_cnt_tbl_get(dev_id, port_id * 3, &in_port_meter_cnt_tbl); |
| counter->green_packet_counter = in_port_meter_cnt_tbl.bf.pkt_cnt; |
| counter->green_byte_counter = in_port_meter_cnt_tbl.bf.byte_cnt_1; |
| counter->green_byte_counter = (counter->green_byte_counter << 32) | in_port_meter_cnt_tbl.bf.byte_cnt_0; |
| |
| hppe_in_port_meter_cnt_tbl_get(dev_id, port_id * 3 + 1, &in_port_meter_cnt_tbl); |
| counter->yellow_packet_counter = in_port_meter_cnt_tbl.bf.pkt_cnt; |
| counter->yellow_byte_counter = in_port_meter_cnt_tbl.bf.byte_cnt_1; |
| counter->yellow_byte_counter = (counter->yellow_byte_counter << 32) | in_port_meter_cnt_tbl.bf.byte_cnt_0; |
| |
| hppe_in_port_meter_cnt_tbl_get(dev_id, port_id * 3 + 2, &in_port_meter_cnt_tbl); |
| counter->red_packet_counter = in_port_meter_cnt_tbl.bf.pkt_cnt; |
| counter->red_byte_counter = in_port_meter_cnt_tbl.bf.byte_cnt_1; |
| counter->red_byte_counter = (counter->red_byte_counter << 32) | in_port_meter_cnt_tbl.bf.byte_cnt_0; |
| |
| return SW_OK; |
| } |
| |
| sw_error_t |
| adpt_hppe_port_compensation_byte_get(a_uint32_t dev_id, fal_port_t port_id, |
| a_uint32_t *length) |
| { |
| sw_error_t rv = SW_OK; |
| union meter_cmpst_length_reg_u meter_cmpst_length_reg; |
| |
| memset(&meter_cmpst_length_reg, 0, sizeof(meter_cmpst_length_reg)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(length); |
| |
| if (port_id < 0 || port_id > 7) |
| return SW_BAD_PARAM; |
| |
| rv = hppe_meter_cmpst_length_reg_get(dev_id, port_id, &meter_cmpst_length_reg); |
| |
| if( rv != SW_OK ) |
| return rv; |
| |
| *length = meter_cmpst_length_reg.bf.cmpst_length; |
| |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| __adpt_hppe_policer_rate_to_refresh(a_uint32_t rate, |
| a_uint32_t *refresh, |
| a_bool_t meter_unit, |
| a_uint32_t token_unit) |
| { |
| a_uint32_t temp_refresh; |
| a_uint64_t temp_rate; |
| |
| if(hppe_policer_rate[meter_unit][token_unit].rate_1bit > 0) |
| { |
| temp_rate = ((a_uint64_t)rate) * 1000; |
| do_div(temp_rate, hppe_policer_rate[meter_unit][token_unit].rate_1bit); |
| temp_refresh = temp_rate; |
| } |
| else |
| { |
| return SW_BAD_PARAM;; |
| } |
| |
| if (temp_refresh > ADPT_HPPE_POLICER_REFRESH_MAX) |
| { |
| temp_refresh = ADPT_HPPE_POLICER_REFRESH_MAX; |
| } |
| |
| *refresh = temp_refresh; |
| |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| __adpt_hppe_policer_burst_size_to_bucket_size(a_uint32_t burst_size, |
| a_uint32_t *bucket_size, |
| a_bool_t meter_unit, |
| a_uint32_t token_unit) |
| { |
| a_uint32_t temp_bucket_size; |
| a_uint64_t temp_burst_size; |
| |
| if(hppe_policer_burst_size[meter_unit][token_unit].burst_size_1bit > 0) |
| { |
| temp_burst_size = ((a_uint64_t)burst_size) * 1000; |
| do_div(temp_burst_size, hppe_policer_burst_size[meter_unit][token_unit].burst_size_1bit); |
| temp_bucket_size = temp_burst_size; |
| } |
| else |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| if(temp_bucket_size > ADPT_HPPE_POLICER_BUCKET_SIZE_MAX) |
| { |
| temp_bucket_size = ADPT_HPPE_POLICER_BUCKET_SIZE_MAX; |
| } |
| |
| *bucket_size = temp_bucket_size; |
| |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| __adpt_hppe_policer_refresh_to_rate(a_uint32_t refresh, |
| a_uint32_t *rate, |
| a_bool_t meter_unit, |
| a_uint32_t token_unit) |
| { |
| a_uint32_t temp_rate; |
| a_uint64_t temp_refresh; |
| |
| if(hppe_policer_rate[meter_unit][token_unit].rate_1bit > 0) |
| { |
| temp_refresh = ((a_uint64_t)refresh) * hppe_policer_rate[meter_unit][token_unit].rate_1bit; |
| do_div(temp_refresh, 1000); |
| temp_rate = temp_refresh; |
| } |
| else |
| { |
| return SW_BAD_PARAM;; |
| } |
| |
| *rate = temp_rate; |
| |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| __adpt_hppe_policer_bucket_size_to_burst_size(a_uint32_t bucket_size, |
| a_uint32_t *burst_size, |
| a_bool_t meter_unit, |
| a_uint32_t token_unit) |
| { |
| a_uint32_t temp_burst_size; |
| a_uint64_t temp_bucket_size; |
| |
| if(hppe_policer_burst_size[meter_unit][token_unit].burst_size_1bit > 0) |
| { |
| temp_bucket_size = ((a_uint64_t)bucket_size) * hppe_policer_burst_size[meter_unit][token_unit].burst_size_1bit; |
| do_div(temp_bucket_size, 1000); |
| temp_burst_size = temp_bucket_size; |
| } |
| else |
| { |
| return SW_BAD_PARAM; |
| } |
| |
| *burst_size = temp_burst_size; |
| |
| return SW_OK; |
| } |
| #endif |
| |
| static sw_error_t |
| __adpt_hppe_policer_max_rate(a_uint32_t time_slot) |
| { |
| a_uint32_t i = 0, j = 0; |
| a_uint32_t time_cycle = 0; |
| a_uint64_t temp = 0, temp1 = 0, temp2 = 0; |
| |
| |
| /* time_cycle is ns*/ |
| time_cycle = ( time_slot * 8)/ ADPT_HPPE_FREQUENCY; |
| |
| for (j = 0; j < 8; j++) |
| { |
| /*max rate is bps*/ |
| temp1 = (a_uint64_t)(ADPT_HPPE_POLICER_REFRESH_MAX * 1000 * 8) * 1000; |
| temp2 = hppe_policer_token_unit[i][j] * time_cycle; |
| |
| do_div(temp1, temp2); |
| hppe_policer_rate[i][j].rate_max= temp1; |
| |
| temp = temp1; |
| do_div(temp, ADPT_HPPE_POLICER_REFRESH_MAX); |
| hppe_policer_rate[i][j].rate_1bit = temp; |
| |
| // printk("hppe policer byte max_rate generating =%llu\n", hppe_policer_rate[i][j].rate_max); |
| // printk("hppe policer byte based step =%llu\n", hppe_policer_rate[i][j].rate_1bit); |
| } |
| |
| i = i + 1; |
| for (j = 0; j < 8; j++) |
| { |
| /* max rate unit is 1/1000 pps*/ |
| temp1 = (a_uint64_t)(ADPT_HPPE_POLICER_REFRESH_MAX * 1000) * 1000 * 1000; |
| temp2 = (a_uint64_t)hppe_policer_token_unit[i][j] * time_cycle; |
| |
| do_div(temp1, temp2); |
| hppe_policer_rate[i][j].rate_max = temp1; |
| |
| temp = temp1; |
| do_div(temp, ADPT_HPPE_POLICER_REFRESH_MAX); |
| hppe_policer_rate[i][j].rate_1bit = temp; |
| |
| // printk("policer frame hppe_max_rate generating =%llu\n", hppe_policer_rate[i][j].rate_max); |
| // printk("policer frame step rate =%llu\n", hppe_policer_rate[i][j].rate_1bit); |
| } |
| |
| return SW_OK; |
| } |
| |
| static sw_error_t |
| __adpt_hppe_policer_max_burst_size(void) |
| { |
| a_uint32_t i = 0, j = 0; |
| a_uint64_t temp = 0, temp1 = 0; |
| |
| |
| for (j = 0; j < 8; j++) |
| { |
| /*max size unit is 1/1000 byte based*/ |
| temp = ((a_uint64_t)(ADPT_HPPE_POLICER_BURST_SIZE_UNIT)) * |
| ADPT_HPPE_POLICER_BUCKET_SIZE_MAX; |
| do_div(temp, hppe_policer_token_unit[i][j]); |
| hppe_policer_burst_size[i][j].burst_size_max = (a_uint64_t)(temp * 1000); |
| |
| temp1 = hppe_policer_burst_size[i][j].burst_size_max; |
| do_div(temp1, ADPT_HPPE_POLICER_BUCKET_SIZE_MAX); |
| hppe_policer_burst_size[i][j].burst_size_1bit = temp1; |
| |
| /* |
| printk("policer byte hppe_max_burst_size generating =%llu\n", |
| hppe_policer_burst_size[i][j].burst_size_max); |
| printk("policer byte hppe_max_burst_size step =%llu\n", |
| hppe_policer_burst_size[i][j].burst_size_1bit); |
| */ |
| |
| } |
| |
| i = i + 1; |
| for (j = 0; j < 8; j++) |
| { |
| /* max size unit is 1/1000 frame based */ |
| temp = ((a_uint64_t)(ADPT_HPPE_POLICER_BURST_SIZE_UNIT)) * |
| ADPT_HPPE_POLICER_BUCKET_SIZE_MAX; |
| do_div(temp, hppe_policer_token_unit[i][j]); |
| hppe_policer_burst_size[i][j].burst_size_max = (a_uint64_t)(temp * 1000); |
| |
| temp1 = hppe_policer_burst_size[i][j].burst_size_max; |
| do_div(temp1, ADPT_HPPE_POLICER_BUCKET_SIZE_MAX); |
| hppe_policer_burst_size[i][j].burst_size_1bit = temp1; |
| |
| /* |
| printk("policer frame hppe_max_burst_size generating =%llu\n", |
| hppe_policer_burst_size[i][j].burst_size_max); |
| printk("policer frame hppe_max_burst_size step =%llu\n", |
| hppe_policer_burst_size[i][j].burst_size_1bit); |
| */ |
| |
| } |
| |
| return SW_OK; |
| } |
| |
| #ifndef IN_POLICER_MINI |
| static sw_error_t |
| __adpt_hppe_policer_two_bucket_parameter_select(a_uint64_t c_rate, |
| a_uint64_t c_burst_size, |
| a_uint64_t e_rate, |
| a_uint64_t e_burst_size, |
| a_uint32_t meter_unit, |
| a_uint32_t *token_unit) |
| { |
| a_uint32_t temp_token_unit; |
| a_uint32_t match = A_FALSE; |
| a_uint64_t temp_rate = 0, temp_burst_size = 0; |
| |
| if(c_rate > e_rate) |
| temp_rate = c_rate; |
| else |
| temp_rate = e_rate; |
| |
| if(c_burst_size > e_burst_size) |
| temp_burst_size = c_burst_size; |
| else |
| temp_burst_size = e_burst_size; |
| |
| for (temp_token_unit = 0; temp_token_unit < 8; temp_token_unit++) |
| { |
| if (temp_rate > hppe_policer_rate[meter_unit][temp_token_unit].rate_max) |
| { |
| continue; |
| } |
| else if(temp_burst_size <= hppe_policer_burst_size[meter_unit][temp_token_unit].burst_size_max) |
| { |
| *token_unit = temp_token_unit; |
| match = A_TRUE; |
| break; |
| } |
| } |
| |
| if (match == A_FALSE) |
| { |
| printk("Not match C and E token bucket parameter rate configuration \n"); |
| return SW_BAD_PARAM; |
| } |
| |
| return SW_OK; |
| } |
| |
| #if 0 |
| static sw_error_t |
| __adpt_hppe_policer_one_bucket_parameter_select(a_uint64_t c_rate, |
| a_uint64_t c_burst_size, |
| a_uint32_t meter_unit, |
| a_uint32_t *token_unit) |
| { |
| a_uint32_t temp_token_unit; |
| a_uint32_t match = A_FALSE; |
| |
| for (temp_token_unit = 0; temp_token_unit < 8; temp_token_unit++) |
| { |
| if (c_rate > hppe_policer_rate[meter_unit][temp_token_unit].rate_max) |
| { |
| continue; |
| } |
| else if (c_burst_size <= hppe_policer_burst_size[meter_unit][temp_token_unit].burst_size_max) |
| { |
| *token_unit = temp_token_unit; |
| match = A_TRUE; |
| break; |
| } |
| } |
| |
| if (match == A_FALSE) |
| { |
| printk("Not match policer C token bucket parameter rate configuration \n"); |
| return SW_BAD_PARAM; |
| } |
| |
| return SW_OK; |
| } |
| #endif |
| |
| sw_error_t |
| adpt_hppe_port_policer_entry_get(a_uint32_t dev_id, fal_port_t port_id, |
| fal_policer_config_t *policer, fal_policer_action_t *action) |
| { |
| union in_port_meter_cfg_tbl_u in_port_meter_cfg_tbl; |
| a_uint32_t hppe_cir =0, hppe_cbs = 0, hppe_eir = 0,hppe_ebs = 0; |
| |
| memset(&in_port_meter_cfg_tbl, 0, sizeof(in_port_meter_cfg_tbl)); |
| |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(policer); |
| ADPT_NULL_POINT_CHECK(action); |
| |
| if (port_id < 0 || port_id > 7) |
| return SW_BAD_PARAM; |
| |
| hppe_in_port_meter_cfg_tbl_get(dev_id, port_id, &in_port_meter_cfg_tbl); |
| |
| hppe_cir = (in_port_meter_cfg_tbl.bf.cir_1 << 3) | in_port_meter_cfg_tbl.bf.cir_0; |
| hppe_cbs = in_port_meter_cfg_tbl.bf.cbs; |
| hppe_eir = (in_port_meter_cfg_tbl.bf.eir_1 << 1) | in_port_meter_cfg_tbl.bf.eir_0; |
| hppe_ebs = in_port_meter_cfg_tbl.bf.ebs; |
| |
| |
| __adpt_hppe_policer_refresh_to_rate(hppe_cir, |
| &policer->cir, |
| in_port_meter_cfg_tbl.bf.meter_unit, |
| in_port_meter_cfg_tbl.bf.token_unit); |
| |
| __adpt_hppe_policer_refresh_to_rate(hppe_eir, |
| &policer->eir, |
| in_port_meter_cfg_tbl.bf.meter_unit, |
| in_port_meter_cfg_tbl.bf.token_unit); |
| |
| __adpt_hppe_policer_bucket_size_to_burst_size(hppe_cbs, |
| &policer->cbs, |
| in_port_meter_cfg_tbl.bf.meter_unit, |
| in_port_meter_cfg_tbl.bf.token_unit); |
| |
| __adpt_hppe_policer_bucket_size_to_burst_size(hppe_ebs, |
| &policer->ebs, |
| in_port_meter_cfg_tbl.bf.meter_unit, |
| in_port_meter_cfg_tbl.bf.token_unit); |
| |
| policer->meter_en = in_port_meter_cfg_tbl.bf.meter_en; |
| policer->color_mode = in_port_meter_cfg_tbl.bf.color_mode; |
| policer->frame_type = in_port_meter_cfg_tbl.bf.meter_flag; |
| policer->couple_en = in_port_meter_cfg_tbl.bf.coupling_flag; |
| policer->meter_mode = in_port_meter_cfg_tbl.bf.meter_mode; |
| policer->meter_unit = in_port_meter_cfg_tbl.bf.meter_unit; |
| action->yellow_priority_en = in_port_meter_cfg_tbl.bf.exceed_chg_pri_cmd; |
| action->yellow_drop_priority_en = in_port_meter_cfg_tbl.bf.exceed_chg_dp_cmd; |
| action->yellow_pcp_en = in_port_meter_cfg_tbl.bf.exceed_chg_pcp_cmd; |
| action->yellow_dei_en = in_port_meter_cfg_tbl.bf.exceed_chg_dei_cmd; |
| action->yellow_priority = in_port_meter_cfg_tbl.bf.exceed_pri; |
| action->yellow_drop_priority = in_port_meter_cfg_tbl.bf.exceed_dp; |
| action->yellow_pcp = in_port_meter_cfg_tbl.bf.exceed_pcp; |
| action->yellow_dei = in_port_meter_cfg_tbl.bf.exceed_dei; |
| if (in_port_meter_cfg_tbl.bf.violate_cmd == 0) |
| action->red_action = FAL_MAC_DROP; |
| else |
| action->red_action = FAL_MAC_FRWRD; |
| action->red_priority_en = in_port_meter_cfg_tbl.bf.violate_chg_pri_cmd; |
| action->red_drop_priority_en = in_port_meter_cfg_tbl.bf.violate_chg_dp_cmd; |
| action->red_pcp_en = in_port_meter_cfg_tbl.bf.violate_chg_pcp_cmd; |
| action->red_dei_en = in_port_meter_cfg_tbl.bf.violate_chg_dei_cmd; |
| action->red_priority = in_port_meter_cfg_tbl.bf.violate_pri; |
| action->red_drop_priority = in_port_meter_cfg_tbl.bf.violate_dp; |
| action->red_pcp = in_port_meter_cfg_tbl.bf.violate_pcp; |
| action->red_dei = in_port_meter_cfg_tbl.bf.violate_dei; |
| |
| return SW_OK; |
| } |
| |
| sw_error_t |
| adpt_hppe_port_policer_entry_set(a_uint32_t dev_id, fal_port_t port_id, |
| fal_policer_config_t *policer, fal_policer_action_t *action) |
| { |
| union in_port_meter_cfg_tbl_u in_port_meter_cfg_tbl; |
| a_uint32_t hppe_cir = 0, hppe_cbs = 0, hppe_eir = 0,hppe_ebs = 0; |
| a_uint64_t temp_cir = 0, temp_eir =0, temp_cbs =0, temp_ebs = 0; |
| a_uint32_t token_unit = 0; |
| sw_error_t rv = SW_OK; |
| |
| memset(&in_port_meter_cfg_tbl, 0, sizeof(in_port_meter_cfg_tbl)); |
| |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(policer); |
| ADPT_NULL_POINT_CHECK(action); |
| |
| if (port_id < 0 || port_id > 7) |
| return SW_BAD_PARAM; |
| |
| if(ADPT_HPPE_POLICER_METER_UNIT_BYTE == policer->meter_unit) |
| { |
| if ((policer->cir > BYTE_POLICER_MAX_RATE) || (policer->eir > BYTE_POLICER_MAX_RATE)) |
| return SW_BAD_PARAM; |
| if ((policer->cir < BYTE_POLICER_MIN_RATE) && (policer->cir != 0)) |
| return SW_BAD_PARAM; |
| if ((policer->eir < BYTE_POLICER_MIN_RATE) && (policer->eir != 0)) |
| return SW_BAD_PARAM; |
| } |
| |
| if(ADPT_HPPE_POLICER_METER_UNIT_FRAME == policer->meter_unit) |
| { |
| if ((policer->cir > FRAME_POLICER_MAX_RATE) || (policer->eir > FRAME_POLICER_MAX_RATE)) |
| return SW_BAD_PARAM; |
| if ((policer->cir < FRAME_POLICER_MIN_RATE) && (policer->cir != 0)) |
| return SW_BAD_PARAM; |
| if ((policer->eir < FRAME_POLICER_MIN_RATE) && (policer->eir != 0)) |
| return SW_BAD_PARAM; |
| } |
| |
| if((0 == policer->meter_mode) && (policer->cir > policer->eir)) |
| return SW_BAD_PARAM; |
| |
| temp_cir = ((a_uint64_t)policer->cir) * 1000; |
| temp_cbs = ((a_uint64_t)policer->cbs) * 1000; |
| temp_eir = ((a_uint64_t)policer->eir) * 1000; |
| temp_ebs = ((a_uint64_t)policer->ebs) * 1000; |
| |
| rv = __adpt_hppe_policer_two_bucket_parameter_select(temp_cir, |
| temp_cbs, |
| temp_eir, |
| temp_ebs, |
| policer->meter_unit, |
| &token_unit); |
| if( rv != SW_OK ) |
| return rv; |
| |
| // printk("current meter unit is = %d\n", policer->meter_unit); |
| // printk("current token unit is = %d\n", token_unit); |
| |
| __adpt_hppe_policer_rate_to_refresh(policer->cir, |
| &hppe_cir, |
| policer->meter_unit, |
| token_unit); |
| |
| __adpt_hppe_policer_rate_to_refresh(policer->eir, |
| &hppe_eir, |
| policer->meter_unit, |
| token_unit); |
| |
| __adpt_hppe_policer_burst_size_to_bucket_size(policer->cbs, |
| &hppe_cbs, |
| policer->meter_unit, |
| token_unit); |
| |
| __adpt_hppe_policer_burst_size_to_bucket_size(policer->ebs, |
| &hppe_ebs, |
| policer->meter_unit, |
| token_unit); |
| |
| in_port_meter_cfg_tbl.bf.meter_en = policer->meter_en; |
| in_port_meter_cfg_tbl.bf.color_mode = policer->color_mode; |
| in_port_meter_cfg_tbl.bf.meter_flag = policer->frame_type; |
| in_port_meter_cfg_tbl.bf.coupling_flag = policer->couple_en; |
| in_port_meter_cfg_tbl.bf.meter_mode = policer->meter_mode; |
| in_port_meter_cfg_tbl.bf.token_unit = token_unit; |
| in_port_meter_cfg_tbl.bf.meter_unit = (a_uint32_t)policer->meter_unit; |
| in_port_meter_cfg_tbl.bf.cbs = hppe_cbs; |
| in_port_meter_cfg_tbl.bf.cir_0 = hppe_cir & 0x7; |
| in_port_meter_cfg_tbl.bf.cir_1 = hppe_cir >> 3; |
| in_port_meter_cfg_tbl.bf.ebs = hppe_ebs; |
| in_port_meter_cfg_tbl.bf.eir_0 = hppe_eir & 0x1; |
| in_port_meter_cfg_tbl.bf.eir_1 = hppe_eir >> 1; |
| in_port_meter_cfg_tbl.bf.exceed_chg_pri_cmd = action->yellow_priority_en; |
| in_port_meter_cfg_tbl.bf.exceed_chg_dp_cmd = action->yellow_drop_priority_en; |
| in_port_meter_cfg_tbl.bf.exceed_chg_pcp_cmd = action->yellow_pcp_en; |
| in_port_meter_cfg_tbl.bf.exceed_chg_dei_cmd = action->yellow_dei_en; |
| in_port_meter_cfg_tbl.bf.exceed_pri = action->yellow_priority; |
| in_port_meter_cfg_tbl.bf.exceed_dp = action->yellow_drop_priority; |
| in_port_meter_cfg_tbl.bf.exceed_pcp = action->yellow_pcp; |
| in_port_meter_cfg_tbl.bf.exceed_dei = action->yellow_dei; |
| if (action->red_action == FAL_MAC_DROP) |
| in_port_meter_cfg_tbl.bf.violate_cmd = 0; |
| else |
| in_port_meter_cfg_tbl.bf.violate_cmd = 1; |
| in_port_meter_cfg_tbl.bf.violate_chg_pri_cmd = action->red_priority_en; |
| in_port_meter_cfg_tbl.bf.violate_chg_dp_cmd = action->red_drop_priority_en; |
| in_port_meter_cfg_tbl.bf.violate_chg_pcp_cmd = action->red_pcp_en; |
| in_port_meter_cfg_tbl.bf.violate_chg_dei_cmd = action->red_dei_en; |
| in_port_meter_cfg_tbl.bf.violate_pri = action->red_priority; |
| in_port_meter_cfg_tbl.bf.violate_dp = action->red_drop_priority; |
| in_port_meter_cfg_tbl.bf.violate_pcp = action->red_pcp; |
| in_port_meter_cfg_tbl.bf.violate_dei = action->red_dei; |
| |
| hppe_in_port_meter_cfg_tbl_set(dev_id, port_id, &in_port_meter_cfg_tbl); |
| |
| return SW_OK; |
| |
| } |
| sw_error_t |
| adpt_hppe_acl_policer_entry_get(a_uint32_t dev_id, a_uint32_t index, |
| fal_policer_config_t *policer, fal_policer_action_t *action) |
| { |
| union in_acl_meter_cfg_tbl_u in_acl_meter_cfg_tbl; |
| a_uint32_t hppe_cir =0, hppe_cbs = 0, hppe_eir = 0,hppe_ebs = 0; |
| |
| memset(&in_acl_meter_cfg_tbl, 0, sizeof(in_acl_meter_cfg_tbl)); |
| |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(policer); |
| ADPT_NULL_POINT_CHECK(action); |
| |
| if (index < 0 || index > 511) |
| return SW_BAD_PARAM; |
| |
| hppe_in_acl_meter_cfg_tbl_get(dev_id, index, &in_acl_meter_cfg_tbl); |
| |
| hppe_cir = (in_acl_meter_cfg_tbl.bf.cir_1 << 8) | in_acl_meter_cfg_tbl.bf.cir_0; |
| hppe_cbs = in_acl_meter_cfg_tbl.bf.cbs; |
| hppe_eir = (in_acl_meter_cfg_tbl.bf.eir_1 << 6) | in_acl_meter_cfg_tbl.bf.eir_0; |
| hppe_ebs = in_acl_meter_cfg_tbl.bf.ebs; |
| |
| __adpt_hppe_policer_refresh_to_rate(hppe_cir, |
| &policer->cir, |
| in_acl_meter_cfg_tbl.bf.meter_unit, |
| in_acl_meter_cfg_tbl.bf.token_unit); |
| |
| __adpt_hppe_policer_refresh_to_rate(hppe_eir, |
| &policer->eir, |
| in_acl_meter_cfg_tbl.bf.meter_unit, |
| in_acl_meter_cfg_tbl.bf.token_unit); |
| |
| __adpt_hppe_policer_bucket_size_to_burst_size(hppe_cbs, |
| &policer->cbs, |
| in_acl_meter_cfg_tbl.bf.meter_unit, |
| in_acl_meter_cfg_tbl.bf.token_unit); |
| |
| __adpt_hppe_policer_bucket_size_to_burst_size(hppe_ebs, |
| &policer->ebs, |
| in_acl_meter_cfg_tbl.bf.meter_unit, |
| in_acl_meter_cfg_tbl.bf.token_unit); |
| |
| policer->meter_en = in_acl_meter_cfg_tbl.bf.meter_en; |
| policer->color_mode = in_acl_meter_cfg_tbl.bf.color_mode; |
| policer->couple_en= in_acl_meter_cfg_tbl.bf.coupling_flag; |
| policer->meter_mode = in_acl_meter_cfg_tbl.bf.meter_mode; |
| policer->meter_unit = in_acl_meter_cfg_tbl.bf.meter_unit; |
| action->yellow_priority_en = in_acl_meter_cfg_tbl.bf.exceed_chg_pri_cmd; |
| action->yellow_drop_priority_en = in_acl_meter_cfg_tbl.bf.exceed_chg_dp_cmd; |
| action->yellow_pcp_en = in_acl_meter_cfg_tbl.bf.exceed_chg_pcp_cmd; |
| action->yellow_dei_en = in_acl_meter_cfg_tbl.bf.exceed_chg_dei_cmd; |
| action->yellow_priority = in_acl_meter_cfg_tbl.bf.exceed_pri; |
| action->yellow_drop_priority = in_acl_meter_cfg_tbl.bf.exceed_dp; |
| action->yellow_pcp = in_acl_meter_cfg_tbl.bf.exceed_pcp; |
| action->yellow_dei = in_acl_meter_cfg_tbl.bf.exceed_dei; |
| if (in_acl_meter_cfg_tbl.bf.violate_cmd == 0) |
| action->red_action = FAL_MAC_DROP; |
| else |
| action->red_action = FAL_MAC_FRWRD; |
| action->red_priority_en = in_acl_meter_cfg_tbl.bf.violate_chg_pri_cmd; |
| action->red_drop_priority_en = in_acl_meter_cfg_tbl.bf.violate_chg_dp_cmd; |
| action->red_pcp_en = in_acl_meter_cfg_tbl.bf.violate_chg_pcp_cmd; |
| action->red_dei_en = in_acl_meter_cfg_tbl.bf.violate_chg_dei_cmd; |
| action->red_priority = (in_acl_meter_cfg_tbl.bf.violate_pri_1 << 1) |in_acl_meter_cfg_tbl.bf.violate_pri_0; |
| action->red_drop_priority = in_acl_meter_cfg_tbl.bf.violate_dp; |
| action->red_pcp = in_acl_meter_cfg_tbl.bf.violate_pcp; |
| action->red_dei = in_acl_meter_cfg_tbl.bf.violate_dei; |
| |
| return SW_OK; |
| } |
| |
| sw_error_t |
| adpt_hppe_acl_policer_entry_set(a_uint32_t dev_id, a_uint32_t index, |
| fal_policer_config_t *policer, fal_policer_action_t *action) |
| { |
| union in_acl_meter_cfg_tbl_u in_acl_meter_cfg_tbl; |
| a_uint32_t hppe_cir =0, hppe_cbs = 0, hppe_eir = 0,hppe_ebs = 0; |
| a_uint64_t temp_cir = 0, temp_eir =0, temp_cbs =0, temp_ebs = 0; |
| a_uint32_t token_unit = 0; |
| sw_error_t rv = SW_OK; |
| |
| memset(&in_acl_meter_cfg_tbl, 0, sizeof(in_acl_meter_cfg_tbl)); |
| |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(policer); |
| ADPT_NULL_POINT_CHECK(action); |
| |
| if (index < 0 || index > 511) |
| return SW_BAD_PARAM; |
| |
| if(ADPT_HPPE_POLICER_METER_UNIT_BYTE == policer->meter_unit) |
| { |
| if ((policer->cir > BYTE_POLICER_MAX_RATE) || (policer->eir > BYTE_POLICER_MAX_RATE)) |
| return SW_BAD_PARAM; |
| if ((policer->cir < BYTE_POLICER_MIN_RATE) && (policer->cir != 0)) |
| return SW_BAD_PARAM; |
| if ((policer->eir < BYTE_POLICER_MIN_RATE) && (policer->eir != 0)) |
| return SW_BAD_PARAM; |
| } |
| |
| if(ADPT_HPPE_POLICER_METER_UNIT_FRAME == policer->meter_unit) |
| { |
| if ((policer->cir > FRAME_POLICER_MAX_RATE) || (policer->eir > FRAME_POLICER_MAX_RATE)) |
| return SW_BAD_PARAM; |
| if ((policer->cir < FRAME_POLICER_MIN_RATE) && (policer->cir != 0)) |
| return SW_BAD_PARAM; |
| if ((policer->eir < FRAME_POLICER_MIN_RATE) && (policer->eir != 0)) |
| return SW_BAD_PARAM; |
| } |
| |
| if((0 == policer->meter_mode) && (policer->cir > policer->eir)) |
| return SW_BAD_PARAM; |
| |
| temp_cir = ((a_uint64_t)policer->cir) * 1000; |
| temp_cbs = ((a_uint64_t)policer->cbs) * 1000; |
| temp_eir = ((a_uint64_t)policer->eir) * 1000; |
| temp_ebs = ((a_uint64_t)policer->ebs) * 1000; |
| |
| rv = __adpt_hppe_policer_two_bucket_parameter_select(temp_cir, |
| temp_cbs, |
| temp_eir, |
| temp_ebs, |
| policer->meter_unit, |
| &token_unit); |
| if( rv != SW_OK ) |
| return rv; |
| |
| // printk("current meter unit is = %d\n", policer->meter_unit); |
| // printk("current token unit is = %d\n", token_unit); |
| |
| __adpt_hppe_policer_rate_to_refresh(policer->cir, |
| &hppe_cir, |
| policer->meter_unit, |
| token_unit); |
| |
| __adpt_hppe_policer_rate_to_refresh(policer->eir, |
| &hppe_eir, |
| policer->meter_unit, |
| token_unit); |
| |
| __adpt_hppe_policer_burst_size_to_bucket_size(policer->cbs, |
| &hppe_cbs, |
| policer->meter_unit, |
| token_unit); |
| |
| __adpt_hppe_policer_burst_size_to_bucket_size(policer->ebs, |
| &hppe_ebs, |
| policer->meter_unit, |
| token_unit); |
| |
| in_acl_meter_cfg_tbl.bf.meter_en = policer->meter_en; |
| in_acl_meter_cfg_tbl.bf.color_mode = policer->color_mode; |
| in_acl_meter_cfg_tbl.bf.coupling_flag = policer->couple_en; |
| in_acl_meter_cfg_tbl.bf.meter_mode = policer->meter_mode; |
| in_acl_meter_cfg_tbl.bf.token_unit = token_unit; |
| in_acl_meter_cfg_tbl.bf.meter_unit = policer->meter_unit; |
| in_acl_meter_cfg_tbl.bf.cbs = hppe_cbs; |
| in_acl_meter_cfg_tbl.bf.cir_0 = hppe_cir & 0xff; |
| in_acl_meter_cfg_tbl.bf.cir_1 = hppe_cir >> 8; |
| in_acl_meter_cfg_tbl.bf.ebs = hppe_ebs; |
| in_acl_meter_cfg_tbl.bf.eir_0 = hppe_eir & 0x3f; |
| in_acl_meter_cfg_tbl.bf.eir_1 = hppe_eir >> 6; |
| in_acl_meter_cfg_tbl.bf.exceed_chg_pri_cmd = action->yellow_priority_en; |
| in_acl_meter_cfg_tbl.bf.exceed_chg_dp_cmd = action->yellow_drop_priority_en; |
| in_acl_meter_cfg_tbl.bf.exceed_chg_pcp_cmd = action->yellow_pcp_en; |
| in_acl_meter_cfg_tbl.bf.exceed_chg_dei_cmd = action->yellow_dei_en; |
| in_acl_meter_cfg_tbl.bf.exceed_pri = action->yellow_priority; |
| in_acl_meter_cfg_tbl.bf.exceed_dp = action->yellow_drop_priority; |
| in_acl_meter_cfg_tbl.bf.exceed_pcp = action->yellow_pcp; |
| in_acl_meter_cfg_tbl.bf.exceed_dei = action->yellow_dei; |
| if (action->red_action == FAL_MAC_DROP) |
| in_acl_meter_cfg_tbl.bf.violate_cmd = 0; |
| else |
| in_acl_meter_cfg_tbl.bf.violate_cmd = 1; |
| in_acl_meter_cfg_tbl.bf.violate_chg_pri_cmd = action->red_priority_en; |
| in_acl_meter_cfg_tbl.bf.violate_chg_dp_cmd = action->red_drop_priority_en; |
| in_acl_meter_cfg_tbl.bf.violate_chg_pcp_cmd = action->red_pcp_en; |
| in_acl_meter_cfg_tbl.bf.violate_chg_dei_cmd = action->red_dei_en; |
| in_acl_meter_cfg_tbl.bf.violate_pri_0 = action->red_priority & 0x1; |
| in_acl_meter_cfg_tbl.bf.violate_pri_1 = action->red_priority >>1; |
| in_acl_meter_cfg_tbl.bf.violate_dp = action->red_drop_priority; |
| in_acl_meter_cfg_tbl.bf.violate_pcp = action->red_pcp; |
| in_acl_meter_cfg_tbl.bf.violate_dei = action->red_dei; |
| |
| hppe_in_acl_meter_cfg_tbl_set(dev_id, index, &in_acl_meter_cfg_tbl); |
| |
| return SW_OK; |
| } |
| |
| sw_error_t |
| adpt_hppe_policer_time_slot_get(a_uint32_t dev_id, a_uint32_t *time_slot) |
| { |
| sw_error_t rv = SW_OK; |
| union time_slot_reg_u time_slot_reg; |
| |
| memset(&time_slot_reg, 0, sizeof(time_slot_reg)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(time_slot); |
| |
| |
| rv = hppe_time_slot_reg_get(dev_id, &time_slot_reg); |
| |
| if( rv != SW_OK ) |
| return rv; |
| |
| *time_slot = time_slot_reg.bf.time_slot; |
| |
| return SW_OK; |
| } |
| #endif |
| |
| sw_error_t |
| adpt_hppe_port_compensation_byte_set(a_uint32_t dev_id, fal_port_t port_id, |
| a_uint32_t length) |
| { |
| union meter_cmpst_length_reg_u meter_cmpst_length_reg; |
| |
| memset(&meter_cmpst_length_reg, 0, sizeof(meter_cmpst_length_reg)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| |
| if (port_id < 0 || port_id > 7) |
| return SW_BAD_PARAM; |
| |
| if (length > 0x1f) |
| return SW_BAD_PARAM; |
| |
| hppe_meter_cmpst_length_reg_get(dev_id, port_id, &meter_cmpst_length_reg); |
| meter_cmpst_length_reg.bf.cmpst_length = length; |
| |
| hppe_meter_cmpst_length_reg_set(dev_id, port_id, &meter_cmpst_length_reg); |
| |
| return SW_OK; |
| } |
| sw_error_t |
| adpt_hppe_policer_time_slot_set(a_uint32_t dev_id, a_uint32_t time_slot) |
| { |
| union time_slot_reg_u time_slot_reg; |
| |
| memset(&time_slot_reg, 0, sizeof(time_slot_reg)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| |
| if ((time_slot > 1024) || (time_slot < 512)) |
| return SW_BAD_PARAM; |
| |
| time_slot_reg.bf.time_slot = time_slot; |
| hppe_time_slot_reg_set(dev_id, &time_slot_reg); |
| |
| __adpt_hppe_policer_max_rate(time_slot); |
| |
| __adpt_hppe_policer_max_burst_size(); |
| |
| return SW_OK; |
| } |
| #ifndef IN_POLICER_MINI |
| sw_error_t |
| adpt_hppe_policer_global_counter_get(a_uint32_t dev_id, |
| fal_policer_global_counter_t *counter) |
| { |
| union pc_global_cnt_tbl_u pc_global_cnt_tbl; |
| a_uint32_t index = 0; |
| |
| memset(&pc_global_cnt_tbl, 0, sizeof(pc_global_cnt_tbl)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(counter); |
| |
| hppe_pc_global_cnt_tbl_get(dev_id, index, &pc_global_cnt_tbl); |
| counter->policer_drop_packet_counter = pc_global_cnt_tbl.bf.pkt_cnt; |
| counter->policer_drop_byte_counter = pc_global_cnt_tbl.bf.byte_cnt_1; |
| counter->policer_drop_byte_counter = (counter->policer_drop_byte_counter << 32) | |
| pc_global_cnt_tbl.bf.byte_cnt_0; |
| |
| hppe_pc_global_cnt_tbl_get(dev_id, index + 1, &pc_global_cnt_tbl); |
| counter->policer_forward_packet_counter = pc_global_cnt_tbl.bf.pkt_cnt; |
| counter->policer_forward_byte_counter = pc_global_cnt_tbl.bf.byte_cnt_1; |
| counter->policer_forward_byte_counter = (counter->policer_forward_byte_counter << 32) | |
| pc_global_cnt_tbl.bf.byte_cnt_0; |
| |
| hppe_pc_global_cnt_tbl_get(dev_id, index + 2, &pc_global_cnt_tbl); |
| counter->policer_bypass_packet_counter = pc_global_cnt_tbl.bf.pkt_cnt; |
| counter->policer_bypass_byte_counter = pc_global_cnt_tbl.bf.byte_cnt_1; |
| counter->policer_bypass_byte_counter = (counter->policer_bypass_byte_counter << 32) | |
| pc_global_cnt_tbl.bf.byte_cnt_0; |
| |
| return SW_OK; |
| } |
| |
| sw_error_t |
| adpt_hppe_policer_bypass_en_get(a_uint32_t dev_id, fal_policer_frame_type_t frame_type, |
| a_bool_t *enable) |
| { |
| sw_error_t rv = SW_OK; |
| union pc_drop_bypass_reg_u drop_bypass_reg; |
| |
| memset(&drop_bypass_reg, 0, sizeof(drop_bypass_reg)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| ADPT_NULL_POINT_CHECK(enable); |
| |
| rv = hppe_pc_drop_bypass_reg_get(dev_id, &drop_bypass_reg); |
| SW_RTN_ON_ERROR (rv); |
| |
| if (frame_type == FAL_FRAME_DROPPED) { |
| *enable = drop_bypass_reg.bf.drop_bypass_en; |
| } else { |
| return SW_BAD_PARAM; |
| } |
| |
| return SW_OK; |
| } |
| |
| #endif |
| |
| sw_error_t |
| adpt_hppe_policer_bypass_en_set(a_uint32_t dev_id, fal_policer_frame_type_t frame_type, |
| a_bool_t enable) |
| { |
| sw_error_t rv = SW_OK; |
| union pc_drop_bypass_reg_u drop_bypass_reg; |
| |
| memset(&drop_bypass_reg, 0, sizeof(drop_bypass_reg)); |
| ADPT_DEV_ID_CHECK(dev_id); |
| |
| if (frame_type == FAL_FRAME_DROPPED) { |
| drop_bypass_reg.bf.drop_bypass_en = enable; |
| } else { |
| return SW_BAD_PARAM; |
| } |
| |
| rv = hppe_pc_drop_bypass_reg_set(dev_id, &drop_bypass_reg); |
| SW_RTN_ON_ERROR (rv); |
| |
| return SW_OK; |
| } |
| |
| void adpt_hppe_policer_func_bitmap_init(a_uint32_t dev_id) |
| { |
| adpt_api_t *p_adpt_api = NULL; |
| |
| p_adpt_api = adpt_api_ptr_get(dev_id); |
| |
| if(p_adpt_api == NULL) |
| return; |
| |
| p_adpt_api->adpt_policer_func_bitmap = ((1 << FUNC_ADPT_ACL_POLICER_COUNTER_GET)| |
| (1 << FUNC_ADPT_PORT_POLICER_COUNTER_GET)| |
| (1 << FUNC_ADPT_PORT_COMPENSATION_BYTE_GET)| |
| (1 << FUNC_ADPT_PORT_POLICER_ENTRY_GET)| |
| (1 << FUNC_ADPT_PORT_POLICER_ENTRY_SET)| |
| (1 << FUNC_ADPT_ACL_POLICER_ENTRY_GET)| |
| (1 << FUNC_ADPT_ACL_POLICER_ENTRY_SET)| |
| (1 << FUNC_ADPT_POLICER_TIME_SLOT_GET)| |
| (1 << FUNC_ADPT_PORT_COMPENSATION_BYTE_SET)| |
| (1 << FUNC_ADPT_POLICER_TIME_SLOT_SET) | |
| (1 << FUNC_ADPT_POLICER_GLOBAL_COUNTER_GET)| |
| (1 << FUNC_ADPT_POLICER_BYPASS_EN_SET)| |
| (1 << FUNC_ADPT_POLICER_BYPASS_EN_GET)); |
| |
| return; |
| |
| } |
| |
| static void adpt_hppe_policer_func_unregister(a_uint32_t dev_id, adpt_api_t *p_adpt_api) |
| { |
| if(p_adpt_api == NULL) |
| return; |
| |
| p_adpt_api->adpt_acl_policer_counter_get = NULL; |
| p_adpt_api->adpt_port_policer_counter_get = NULL; |
| p_adpt_api->adpt_port_compensation_byte_get = NULL; |
| p_adpt_api->adpt_port_policer_entry_get = NULL; |
| p_adpt_api->adpt_port_policer_entry_set = NULL; |
| p_adpt_api->adpt_acl_policer_entry_get = NULL; |
| p_adpt_api->adpt_acl_policer_entry_set = NULL; |
| p_adpt_api->adpt_policer_time_slot_get = NULL; |
| p_adpt_api->adpt_port_compensation_byte_set = NULL; |
| p_adpt_api->adpt_policer_time_slot_set = NULL; |
| p_adpt_api->adpt_policer_global_counter_get = NULL; |
| p_adpt_api->adpt_policer_bypass_en_set = NULL; |
| p_adpt_api->adpt_policer_bypass_en_get = NULL; |
| |
| return; |
| |
| } |
| |
| |
| sw_error_t adpt_hppe_policer_init(a_uint32_t dev_id) |
| { |
| adpt_api_t *p_adpt_api = NULL; |
| |
| p_adpt_api = adpt_api_ptr_get(dev_id); |
| |
| if(p_adpt_api == NULL) |
| return SW_FAIL; |
| |
| adpt_hppe_policer_func_unregister(dev_id, p_adpt_api); |
| |
| #ifndef IN_POLICER_MINI |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_ACL_POLICER_COUNTER_GET)) |
| { |
| p_adpt_api->adpt_acl_policer_counter_get = adpt_hppe_acl_policer_counter_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_PORT_POLICER_COUNTER_GET)) |
| { |
| p_adpt_api->adpt_port_policer_counter_get = adpt_hppe_port_policer_counter_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_PORT_COMPENSATION_BYTE_GET)) |
| { |
| p_adpt_api->adpt_port_compensation_byte_get = adpt_hppe_port_compensation_byte_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_PORT_POLICER_ENTRY_GET)) |
| { |
| p_adpt_api->adpt_port_policer_entry_get = adpt_hppe_port_policer_entry_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_PORT_POLICER_ENTRY_SET)) |
| { |
| p_adpt_api->adpt_port_policer_entry_set = adpt_hppe_port_policer_entry_set; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_ACL_POLICER_ENTRY_GET)) |
| { |
| p_adpt_api->adpt_acl_policer_entry_get = adpt_hppe_acl_policer_entry_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_ACL_POLICER_ENTRY_SET)) |
| { |
| p_adpt_api->adpt_acl_policer_entry_set = adpt_hppe_acl_policer_entry_set; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_POLICER_TIME_SLOT_GET)) |
| { |
| p_adpt_api->adpt_policer_time_slot_get = adpt_hppe_policer_time_slot_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_POLICER_GLOBAL_COUNTER_GET)) |
| { |
| p_adpt_api->adpt_policer_global_counter_get = adpt_hppe_policer_global_counter_get; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_POLICER_BYPASS_EN_GET)) |
| { |
| p_adpt_api->adpt_policer_bypass_en_get = adpt_hppe_policer_bypass_en_get; |
| } |
| #endif |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_PORT_COMPENSATION_BYTE_SET)) |
| { |
| p_adpt_api->adpt_port_compensation_byte_set = adpt_hppe_port_compensation_byte_set; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_POLICER_TIME_SLOT_SET)) |
| { |
| p_adpt_api->adpt_policer_time_slot_set = adpt_hppe_policer_time_slot_set; |
| } |
| if(p_adpt_api->adpt_policer_func_bitmap & (1 << FUNC_ADPT_POLICER_BYPASS_EN_SET)) |
| { |
| p_adpt_api->adpt_policer_bypass_en_set = adpt_hppe_policer_bypass_en_set; |
| } |
| |
| return SW_OK; |
| } |
| |
| /** |
| * @} |
| */ |
| |
