2431 lines · c
1// SPDX-License-Identifier: GPL-2.02/* Copyright (C) 2024 Intel Corporation */3 4#include "ice_common.h"5 6struct ice_pkg_sect_hdr {7 __le16 count;8 __le16 offset;9};10 11/**12 * ice_parser_sect_item_get - parse an item from a section13 * @sect_type: section type14 * @section: section object15 * @index: index of the item to get16 * @offset: dummy as prototype of ice_pkg_enum_entry's last parameter17 *18 * Return: a pointer to the item or NULL.19 */20static void *ice_parser_sect_item_get(u32 sect_type, void *section,21 u32 index, u32 __maybe_unused *offset)22{23 size_t data_off = ICE_SEC_DATA_OFFSET;24 struct ice_pkg_sect_hdr *hdr;25 size_t size;26 27 if (!section)28 return NULL;29 30 switch (sect_type) {31 case ICE_SID_RXPARSER_IMEM:32 size = ICE_SID_RXPARSER_IMEM_ENTRY_SIZE;33 break;34 case ICE_SID_RXPARSER_METADATA_INIT:35 size = ICE_SID_RXPARSER_METADATA_INIT_ENTRY_SIZE;36 break;37 case ICE_SID_RXPARSER_CAM:38 size = ICE_SID_RXPARSER_CAM_ENTRY_SIZE;39 break;40 case ICE_SID_RXPARSER_PG_SPILL:41 size = ICE_SID_RXPARSER_PG_SPILL_ENTRY_SIZE;42 break;43 case ICE_SID_RXPARSER_NOMATCH_CAM:44 size = ICE_SID_RXPARSER_NOMATCH_CAM_ENTRY_SIZE;45 break;46 case ICE_SID_RXPARSER_NOMATCH_SPILL:47 size = ICE_SID_RXPARSER_NOMATCH_SPILL_ENTRY_SIZE;48 break;49 case ICE_SID_RXPARSER_BOOST_TCAM:50 size = ICE_SID_RXPARSER_BOOST_TCAM_ENTRY_SIZE;51 break;52 case ICE_SID_LBL_RXPARSER_TMEM:53 data_off = ICE_SEC_LBL_DATA_OFFSET;54 size = ICE_SID_LBL_ENTRY_SIZE;55 break;56 case ICE_SID_RXPARSER_MARKER_PTYPE:57 size = ICE_SID_RXPARSER_MARKER_TYPE_ENTRY_SIZE;58 break;59 case ICE_SID_RXPARSER_MARKER_GRP:60 size = ICE_SID_RXPARSER_MARKER_GRP_ENTRY_SIZE;61 break;62 case ICE_SID_RXPARSER_PROTO_GRP:63 size = ICE_SID_RXPARSER_PROTO_GRP_ENTRY_SIZE;64 break;65 case ICE_SID_RXPARSER_FLAG_REDIR:66 size = ICE_SID_RXPARSER_FLAG_REDIR_ENTRY_SIZE;67 break;68 default:69 return NULL;70 }71 72 hdr = section;73 if (index >= le16_to_cpu(hdr->count))74 return NULL;75 76 return section + data_off + index * size;77}78 79/**80 * ice_parser_create_table - create an item table from a section81 * @hw: pointer to the hardware structure82 * @sect_type: section type83 * @item_size: item size in bytes84 * @length: number of items in the table to create85 * @parse_item: the function to parse the item86 * @no_offset: ignore header offset, calculate index from 087 *88 * Return: a pointer to the allocated table or ERR_PTR.89 */90static void *91ice_parser_create_table(struct ice_hw *hw, u32 sect_type,92 u32 item_size, u32 length,93 void (*parse_item)(struct ice_hw *hw, u16 idx,94 void *item, void *data,95 int size), bool no_offset)96{97 struct ice_pkg_enum state = {};98 struct ice_seg *seg = hw->seg;99 void *table, *data, *item;100 u16 idx = 0;101 102 if (!seg)103 return ERR_PTR(-EINVAL);104 105 table = kzalloc(item_size * length, GFP_KERNEL);106 if (!table)107 return ERR_PTR(-ENOMEM);108 109 do {110 data = ice_pkg_enum_entry(seg, &state, sect_type, NULL,111 ice_parser_sect_item_get);112 seg = NULL;113 if (data) {114 struct ice_pkg_sect_hdr *hdr = state.sect;115 116 if (!no_offset)117 idx = le16_to_cpu(hdr->offset) +118 state.entry_idx;119 120 item = (void *)((uintptr_t)table + idx * item_size);121 parse_item(hw, idx, item, data, item_size);122 123 if (no_offset)124 idx++;125 }126 } while (data);127 128 return table;129}130 131/*** ICE_SID_RXPARSER_IMEM section ***/132static void ice_imem_bst_bm_dump(struct ice_hw *hw, struct ice_bst_main *bm)133{134 struct device *dev = ice_hw_to_dev(hw);135 136 dev_info(dev, "boost main:\n");137 dev_info(dev, "\talu0 = %d\n", bm->alu0);138 dev_info(dev, "\talu1 = %d\n", bm->alu1);139 dev_info(dev, "\talu2 = %d\n", bm->alu2);140 dev_info(dev, "\tpg = %d\n", bm->pg);141}142 143static void ice_imem_bst_kb_dump(struct ice_hw *hw,144 struct ice_bst_keybuilder *kb)145{146 struct device *dev = ice_hw_to_dev(hw);147 148 dev_info(dev, "boost key builder:\n");149 dev_info(dev, "\tpriority = %d\n", kb->prio);150 dev_info(dev, "\ttsr_ctrl = %d\n", kb->tsr_ctrl);151}152 153static void ice_imem_np_kb_dump(struct ice_hw *hw,154 struct ice_np_keybuilder *kb)155{156 struct device *dev = ice_hw_to_dev(hw);157 158 dev_info(dev, "next proto key builder:\n");159 dev_info(dev, "\topc = %d\n", kb->opc);160 dev_info(dev, "\tstart_or_reg0 = %d\n", kb->start_reg0);161 dev_info(dev, "\tlen_or_reg1 = %d\n", kb->len_reg1);162}163 164static void ice_imem_pg_kb_dump(struct ice_hw *hw,165 struct ice_pg_keybuilder *kb)166{167 struct device *dev = ice_hw_to_dev(hw);168 169 dev_info(dev, "parse graph key builder:\n");170 dev_info(dev, "\tflag0_ena = %d\n", kb->flag0_ena);171 dev_info(dev, "\tflag1_ena = %d\n", kb->flag1_ena);172 dev_info(dev, "\tflag2_ena = %d\n", kb->flag2_ena);173 dev_info(dev, "\tflag3_ena = %d\n", kb->flag3_ena);174 dev_info(dev, "\tflag0_idx = %d\n", kb->flag0_idx);175 dev_info(dev, "\tflag1_idx = %d\n", kb->flag1_idx);176 dev_info(dev, "\tflag2_idx = %d\n", kb->flag2_idx);177 dev_info(dev, "\tflag3_idx = %d\n", kb->flag3_idx);178 dev_info(dev, "\talu_reg_idx = %d\n", kb->alu_reg_idx);179}180 181static void ice_imem_alu_dump(struct ice_hw *hw,182 struct ice_alu *alu, int index)183{184 struct device *dev = ice_hw_to_dev(hw);185 186 dev_info(dev, "alu%d:\n", index);187 dev_info(dev, "\topc = %d\n", alu->opc);188 dev_info(dev, "\tsrc_start = %d\n", alu->src_start);189 dev_info(dev, "\tsrc_len = %d\n", alu->src_len);190 dev_info(dev, "\tshift_xlate_sel = %d\n", alu->shift_xlate_sel);191 dev_info(dev, "\tshift_xlate_key = %d\n", alu->shift_xlate_key);192 dev_info(dev, "\tsrc_reg_id = %d\n", alu->src_reg_id);193 dev_info(dev, "\tdst_reg_id = %d\n", alu->dst_reg_id);194 dev_info(dev, "\tinc0 = %d\n", alu->inc0);195 dev_info(dev, "\tinc1 = %d\n", alu->inc1);196 dev_info(dev, "\tproto_offset_opc = %d\n", alu->proto_offset_opc);197 dev_info(dev, "\tproto_offset = %d\n", alu->proto_offset);198 dev_info(dev, "\tbranch_addr = %d\n", alu->branch_addr);199 dev_info(dev, "\timm = %d\n", alu->imm);200 dev_info(dev, "\tdst_start = %d\n", alu->dst_start);201 dev_info(dev, "\tdst_len = %d\n", alu->dst_len);202 dev_info(dev, "\tflags_extr_imm = %d\n", alu->flags_extr_imm);203 dev_info(dev, "\tflags_start_imm= %d\n", alu->flags_start_imm);204}205 206/**207 * ice_imem_dump - dump an imem item info208 * @hw: pointer to the hardware structure209 * @item: imem item to dump210 */211static void ice_imem_dump(struct ice_hw *hw, struct ice_imem_item *item)212{213 struct device *dev = ice_hw_to_dev(hw);214 215 dev_info(dev, "index = %d\n", item->idx);216 ice_imem_bst_bm_dump(hw, &item->b_m);217 ice_imem_bst_kb_dump(hw, &item->b_kb);218 dev_info(dev, "pg priority = %d\n", item->pg_prio);219 ice_imem_np_kb_dump(hw, &item->np_kb);220 ice_imem_pg_kb_dump(hw, &item->pg_kb);221 ice_imem_alu_dump(hw, &item->alu0, 0);222 ice_imem_alu_dump(hw, &item->alu1, 1);223 ice_imem_alu_dump(hw, &item->alu2, 2);224}225 226#define ICE_IM_BM_ALU0 BIT(0)227#define ICE_IM_BM_ALU1 BIT(1)228#define ICE_IM_BM_ALU2 BIT(2)229#define ICE_IM_BM_PG BIT(3)230 231/**232 * ice_imem_bm_init - parse 4 bits of Boost Main233 * @bm: pointer to the Boost Main structure234 * @data: Boost Main data to be parsed235 */236static void ice_imem_bm_init(struct ice_bst_main *bm, u8 data)237{238 bm->alu0 = FIELD_GET(ICE_IM_BM_ALU0, data);239 bm->alu1 = FIELD_GET(ICE_IM_BM_ALU1, data);240 bm->alu2 = FIELD_GET(ICE_IM_BM_ALU2, data);241 bm->pg = FIELD_GET(ICE_IM_BM_PG, data);242}243 244#define ICE_IM_BKB_PRIO GENMASK(7, 0)245#define ICE_IM_BKB_TSR_CTRL BIT(8)246 247/**248 * ice_imem_bkb_init - parse 10 bits of Boost Main Build249 * @bkb: pointer to the Boost Main Build structure250 * @data: Boost Main Build data to be parsed251 */252static void ice_imem_bkb_init(struct ice_bst_keybuilder *bkb, u16 data)253{254 bkb->prio = FIELD_GET(ICE_IM_BKB_PRIO, data);255 bkb->tsr_ctrl = FIELD_GET(ICE_IM_BKB_TSR_CTRL, data);256}257 258#define ICE_IM_NPKB_OPC GENMASK(1, 0)259#define ICE_IM_NPKB_S_R0 GENMASK(9, 2)260#define ICE_IM_NPKB_L_R1 GENMASK(17, 10)261 262/**263 * ice_imem_npkb_init - parse 18 bits of Next Protocol Key Build264 * @kb: pointer to the Next Protocol Key Build structure265 * @data: Next Protocol Key Build data to be parsed266 */267static void ice_imem_npkb_init(struct ice_np_keybuilder *kb, u32 data)268{269 kb->opc = FIELD_GET(ICE_IM_NPKB_OPC, data);270 kb->start_reg0 = FIELD_GET(ICE_IM_NPKB_S_R0, data);271 kb->len_reg1 = FIELD_GET(ICE_IM_NPKB_L_R1, data);272}273 274#define ICE_IM_PGKB_F0_ENA BIT_ULL(0)275#define ICE_IM_PGKB_F0_IDX GENMASK_ULL(6, 1)276#define ICE_IM_PGKB_F1_ENA BIT_ULL(7)277#define ICE_IM_PGKB_F1_IDX GENMASK_ULL(13, 8)278#define ICE_IM_PGKB_F2_ENA BIT_ULL(14)279#define ICE_IM_PGKB_F2_IDX GENMASK_ULL(20, 15)280#define ICE_IM_PGKB_F3_ENA BIT_ULL(21)281#define ICE_IM_PGKB_F3_IDX GENMASK_ULL(27, 22)282#define ICE_IM_PGKB_AR_IDX GENMASK_ULL(34, 28)283 284/**285 * ice_imem_pgkb_init - parse 35 bits of Parse Graph Key Build286 * @kb: pointer to the Parse Graph Key Build structure287 * @data: Parse Graph Key Build data to be parsed288 */289static void ice_imem_pgkb_init(struct ice_pg_keybuilder *kb, u64 data)290{291 kb->flag0_ena = FIELD_GET(ICE_IM_PGKB_F0_ENA, data);292 kb->flag0_idx = FIELD_GET(ICE_IM_PGKB_F0_IDX, data);293 kb->flag1_ena = FIELD_GET(ICE_IM_PGKB_F1_ENA, data);294 kb->flag1_idx = FIELD_GET(ICE_IM_PGKB_F1_IDX, data);295 kb->flag2_ena = FIELD_GET(ICE_IM_PGKB_F2_ENA, data);296 kb->flag2_idx = FIELD_GET(ICE_IM_PGKB_F2_IDX, data);297 kb->flag3_ena = FIELD_GET(ICE_IM_PGKB_F3_ENA, data);298 kb->flag3_idx = FIELD_GET(ICE_IM_PGKB_F3_IDX, data);299 kb->alu_reg_idx = FIELD_GET(ICE_IM_PGKB_AR_IDX, data);300}301 302#define ICE_IM_ALU_OPC GENMASK_ULL(5, 0)303#define ICE_IM_ALU_SS GENMASK_ULL(13, 6)304#define ICE_IM_ALU_SL GENMASK_ULL(18, 14)305#define ICE_IM_ALU_SXS BIT_ULL(19)306#define ICE_IM_ALU_SXK GENMASK_ULL(23, 20)307#define ICE_IM_ALU_SRID GENMASK_ULL(30, 24)308#define ICE_IM_ALU_DRID GENMASK_ULL(37, 31)309#define ICE_IM_ALU_INC0 BIT_ULL(38)310#define ICE_IM_ALU_INC1 BIT_ULL(39)311#define ICE_IM_ALU_POO GENMASK_ULL(41, 40)312#define ICE_IM_ALU_PO GENMASK_ULL(49, 42)313#define ICE_IM_ALU_BA_S 50 /* offset for the 2nd 64-bits field */314#define ICE_IM_ALU_BA GENMASK_ULL(57 - ICE_IM_ALU_BA_S, \315 50 - ICE_IM_ALU_BA_S)316#define ICE_IM_ALU_IMM GENMASK_ULL(73 - ICE_IM_ALU_BA_S, \317 58 - ICE_IM_ALU_BA_S)318#define ICE_IM_ALU_DFE BIT_ULL(74 - ICE_IM_ALU_BA_S)319#define ICE_IM_ALU_DS GENMASK_ULL(80 - ICE_IM_ALU_BA_S, \320 75 - ICE_IM_ALU_BA_S)321#define ICE_IM_ALU_DL GENMASK_ULL(86 - ICE_IM_ALU_BA_S, \322 81 - ICE_IM_ALU_BA_S)323#define ICE_IM_ALU_FEI BIT_ULL(87 - ICE_IM_ALU_BA_S)324#define ICE_IM_ALU_FSI GENMASK_ULL(95 - ICE_IM_ALU_BA_S, \325 88 - ICE_IM_ALU_BA_S)326 327/**328 * ice_imem_alu_init - parse 96 bits of ALU entry329 * @alu: pointer to the ALU entry structure330 * @data: ALU entry data to be parsed331 * @off: offset of the ALU entry data332 */333static void ice_imem_alu_init(struct ice_alu *alu, u8 *data, u8 off)334{335 u64 d64;336 u8 idd;337 338 d64 = *((u64 *)data) >> off;339 340 alu->opc = FIELD_GET(ICE_IM_ALU_OPC, d64);341 alu->src_start = FIELD_GET(ICE_IM_ALU_SS, d64);342 alu->src_len = FIELD_GET(ICE_IM_ALU_SL, d64);343 alu->shift_xlate_sel = FIELD_GET(ICE_IM_ALU_SXS, d64);344 alu->shift_xlate_key = FIELD_GET(ICE_IM_ALU_SXK, d64);345 alu->src_reg_id = FIELD_GET(ICE_IM_ALU_SRID, d64);346 alu->dst_reg_id = FIELD_GET(ICE_IM_ALU_DRID, d64);347 alu->inc0 = FIELD_GET(ICE_IM_ALU_INC0, d64);348 alu->inc1 = FIELD_GET(ICE_IM_ALU_INC1, d64);349 alu->proto_offset_opc = FIELD_GET(ICE_IM_ALU_POO, d64);350 alu->proto_offset = FIELD_GET(ICE_IM_ALU_PO, d64);351 352 idd = (ICE_IM_ALU_BA_S + off) / BITS_PER_BYTE;353 off = (ICE_IM_ALU_BA_S + off) % BITS_PER_BYTE;354 d64 = *((u64 *)(&data[idd])) >> off;355 356 alu->branch_addr = FIELD_GET(ICE_IM_ALU_BA, d64);357 alu->imm = FIELD_GET(ICE_IM_ALU_IMM, d64);358 alu->dedicate_flags_ena = FIELD_GET(ICE_IM_ALU_DFE, d64);359 alu->dst_start = FIELD_GET(ICE_IM_ALU_DS, d64);360 alu->dst_len = FIELD_GET(ICE_IM_ALU_DL, d64);361 alu->flags_extr_imm = FIELD_GET(ICE_IM_ALU_FEI, d64);362 alu->flags_start_imm = FIELD_GET(ICE_IM_ALU_FSI, d64);363}364 365#define ICE_IMEM_BM_S 0366#define ICE_IMEM_BKB_S 4367#define ICE_IMEM_BKB_IDD (ICE_IMEM_BKB_S / BITS_PER_BYTE)368#define ICE_IMEM_BKB_OFF (ICE_IMEM_BKB_S % BITS_PER_BYTE)369#define ICE_IMEM_PGP GENMASK(15, 14)370#define ICE_IMEM_NPKB_S 16371#define ICE_IMEM_NPKB_IDD (ICE_IMEM_NPKB_S / BITS_PER_BYTE)372#define ICE_IMEM_NPKB_OFF (ICE_IMEM_NPKB_S % BITS_PER_BYTE)373#define ICE_IMEM_PGKB_S 34374#define ICE_IMEM_PGKB_IDD (ICE_IMEM_PGKB_S / BITS_PER_BYTE)375#define ICE_IMEM_PGKB_OFF (ICE_IMEM_PGKB_S % BITS_PER_BYTE)376#define ICE_IMEM_ALU0_S 69377#define ICE_IMEM_ALU0_IDD (ICE_IMEM_ALU0_S / BITS_PER_BYTE)378#define ICE_IMEM_ALU0_OFF (ICE_IMEM_ALU0_S % BITS_PER_BYTE)379#define ICE_IMEM_ALU1_S 165380#define ICE_IMEM_ALU1_IDD (ICE_IMEM_ALU1_S / BITS_PER_BYTE)381#define ICE_IMEM_ALU1_OFF (ICE_IMEM_ALU1_S % BITS_PER_BYTE)382#define ICE_IMEM_ALU2_S 357383#define ICE_IMEM_ALU2_IDD (ICE_IMEM_ALU2_S / BITS_PER_BYTE)384#define ICE_IMEM_ALU2_OFF (ICE_IMEM_ALU2_S % BITS_PER_BYTE)385 386/**387 * ice_imem_parse_item - parse 384 bits of IMEM entry388 * @hw: pointer to the hardware structure389 * @idx: index of IMEM entry390 * @item: item of IMEM entry391 * @data: IMEM entry data to be parsed392 * @size: size of IMEM entry393 */394static void ice_imem_parse_item(struct ice_hw *hw, u16 idx, void *item,395 void *data, int __maybe_unused size)396{397 struct ice_imem_item *ii = item;398 u8 *buf = data;399 400 ii->idx = idx;401 402 ice_imem_bm_init(&ii->b_m, *(u8 *)buf);403 ice_imem_bkb_init(&ii->b_kb,404 *((u16 *)(&buf[ICE_IMEM_BKB_IDD])) >>405 ICE_IMEM_BKB_OFF);406 407 ii->pg_prio = FIELD_GET(ICE_IMEM_PGP, *(u16 *)buf);408 409 ice_imem_npkb_init(&ii->np_kb,410 *((u32 *)(&buf[ICE_IMEM_NPKB_IDD])) >>411 ICE_IMEM_NPKB_OFF);412 ice_imem_pgkb_init(&ii->pg_kb,413 *((u64 *)(&buf[ICE_IMEM_PGKB_IDD])) >>414 ICE_IMEM_PGKB_OFF);415 416 ice_imem_alu_init(&ii->alu0,417 &buf[ICE_IMEM_ALU0_IDD],418 ICE_IMEM_ALU0_OFF);419 ice_imem_alu_init(&ii->alu1,420 &buf[ICE_IMEM_ALU1_IDD],421 ICE_IMEM_ALU1_OFF);422 ice_imem_alu_init(&ii->alu2,423 &buf[ICE_IMEM_ALU2_IDD],424 ICE_IMEM_ALU2_OFF);425 426 if (hw->debug_mask & ICE_DBG_PARSER)427 ice_imem_dump(hw, ii);428}429 430/**431 * ice_imem_table_get - create an imem table432 * @hw: pointer to the hardware structure433 *434 * Return: a pointer to the allocated IMEM table.435 */436static struct ice_imem_item *ice_imem_table_get(struct ice_hw *hw)437{438 return ice_parser_create_table(hw, ICE_SID_RXPARSER_IMEM,439 sizeof(struct ice_imem_item),440 ICE_IMEM_TABLE_SIZE,441 ice_imem_parse_item, false);442}443 444/*** ICE_SID_RXPARSER_METADATA_INIT section ***/445/**446 * ice_metainit_dump - dump an metainit item info447 * @hw: pointer to the hardware structure448 * @item: metainit item to dump449 */450static void ice_metainit_dump(struct ice_hw *hw, struct ice_metainit_item *item)451{452 struct device *dev = ice_hw_to_dev(hw);453 454 dev_info(dev, "index = %d\n", item->idx);455 456 dev_info(dev, "tsr = %d\n", item->tsr);457 dev_info(dev, "ho = %d\n", item->ho);458 dev_info(dev, "pc = %d\n", item->pc);459 dev_info(dev, "pg_rn = %d\n", item->pg_rn);460 dev_info(dev, "cd = %d\n", item->cd);461 462 dev_info(dev, "gpr_a_ctrl = %d\n", item->gpr_a_ctrl);463 dev_info(dev, "gpr_a_data_mdid = %d\n", item->gpr_a_data_mdid);464 dev_info(dev, "gpr_a_data_start = %d\n", item->gpr_a_data_start);465 dev_info(dev, "gpr_a_data_len = %d\n", item->gpr_a_data_len);466 dev_info(dev, "gpr_a_id = %d\n", item->gpr_a_id);467 468 dev_info(dev, "gpr_b_ctrl = %d\n", item->gpr_b_ctrl);469 dev_info(dev, "gpr_b_data_mdid = %d\n", item->gpr_b_data_mdid);470 dev_info(dev, "gpr_b_data_start = %d\n", item->gpr_b_data_start);471 dev_info(dev, "gpr_b_data_len = %d\n", item->gpr_b_data_len);472 dev_info(dev, "gpr_b_id = %d\n", item->gpr_b_id);473 474 dev_info(dev, "gpr_c_ctrl = %d\n", item->gpr_c_ctrl);475 dev_info(dev, "gpr_c_data_mdid = %d\n", item->gpr_c_data_mdid);476 dev_info(dev, "gpr_c_data_start = %d\n", item->gpr_c_data_start);477 dev_info(dev, "gpr_c_data_len = %d\n", item->gpr_c_data_len);478 dev_info(dev, "gpr_c_id = %d\n", item->gpr_c_id);479 480 dev_info(dev, "gpr_d_ctrl = %d\n", item->gpr_d_ctrl);481 dev_info(dev, "gpr_d_data_mdid = %d\n", item->gpr_d_data_mdid);482 dev_info(dev, "gpr_d_data_start = %d\n", item->gpr_d_data_start);483 dev_info(dev, "gpr_d_data_len = %d\n", item->gpr_d_data_len);484 dev_info(dev, "gpr_d_id = %d\n", item->gpr_d_id);485 486 dev_info(dev, "flags = 0x%llx\n", (unsigned long long)(item->flags));487}488 489#define ICE_MI_TSR GENMASK_ULL(7, 0)490#define ICE_MI_HO GENMASK_ULL(16, 8)491#define ICE_MI_PC GENMASK_ULL(24, 17)492#define ICE_MI_PGRN GENMASK_ULL(35, 25)493#define ICE_MI_CD GENMASK_ULL(38, 36)494#define ICE_MI_GAC BIT_ULL(39)495#define ICE_MI_GADM GENMASK_ULL(44, 40)496#define ICE_MI_GADS GENMASK_ULL(48, 45)497#define ICE_MI_GADL GENMASK_ULL(53, 49)498#define ICE_MI_GAI GENMASK_ULL(59, 56)499#define ICE_MI_GBC BIT_ULL(60)500#define ICE_MI_GBDM_S 61 /* offset for the 2nd 64-bits field */501#define ICE_MI_GBDM_IDD (ICE_MI_GBDM_S / BITS_PER_BYTE)502#define ICE_MI_GBDM_OFF (ICE_MI_GBDM_S % BITS_PER_BYTE)503 504#define ICE_MI_GBDM_GENMASK_ULL(high, low) \505 GENMASK_ULL((high) - ICE_MI_GBDM_S, (low) - ICE_MI_GBDM_S)506#define ICE_MI_GBDM ICE_MI_GBDM_GENMASK_ULL(65, 61)507#define ICE_MI_GBDS ICE_MI_GBDM_GENMASK_ULL(69, 66)508#define ICE_MI_GBDL ICE_MI_GBDM_GENMASK_ULL(74, 70)509#define ICE_MI_GBI ICE_MI_GBDM_GENMASK_ULL(80, 77)510#define ICE_MI_GCC BIT_ULL(81 - ICE_MI_GBDM_S)511#define ICE_MI_GCDM ICE_MI_GBDM_GENMASK_ULL(86, 82)512#define ICE_MI_GCDS ICE_MI_GBDM_GENMASK_ULL(90, 87)513#define ICE_MI_GCDL ICE_MI_GBDM_GENMASK_ULL(95, 91)514#define ICE_MI_GCI ICE_MI_GBDM_GENMASK_ULL(101, 98)515#define ICE_MI_GDC BIT_ULL(102 - ICE_MI_GBDM_S)516#define ICE_MI_GDDM ICE_MI_GBDM_GENMASK_ULL(107, 103)517#define ICE_MI_GDDS ICE_MI_GBDM_GENMASK_ULL(111, 108)518#define ICE_MI_GDDL ICE_MI_GBDM_GENMASK_ULL(116, 112)519#define ICE_MI_GDI ICE_MI_GBDM_GENMASK_ULL(122, 119)520#define ICE_MI_FLAG_S 123 /* offset for the 3rd 64-bits field */521#define ICE_MI_FLAG_IDD (ICE_MI_FLAG_S / BITS_PER_BYTE)522#define ICE_MI_FLAG_OFF (ICE_MI_FLAG_S % BITS_PER_BYTE)523#define ICE_MI_FLAG GENMASK_ULL(186 - ICE_MI_FLAG_S, \524 123 - ICE_MI_FLAG_S)525 526/**527 * ice_metainit_parse_item - parse 192 bits of Metadata Init entry528 * @hw: pointer to the hardware structure529 * @idx: index of Metadata Init entry530 * @item: item of Metadata Init entry531 * @data: Metadata Init entry data to be parsed532 * @size: size of Metadata Init entry533 */534static void ice_metainit_parse_item(struct ice_hw *hw, u16 idx, void *item,535 void *data, int __maybe_unused size)536{537 struct ice_metainit_item *mi = item;538 u8 *buf = data;539 u64 d64;540 541 mi->idx = idx;542 543 d64 = *(u64 *)buf;544 545 mi->tsr = FIELD_GET(ICE_MI_TSR, d64);546 mi->ho = FIELD_GET(ICE_MI_HO, d64);547 mi->pc = FIELD_GET(ICE_MI_PC, d64);548 mi->pg_rn = FIELD_GET(ICE_MI_PGRN, d64);549 mi->cd = FIELD_GET(ICE_MI_CD, d64);550 551 mi->gpr_a_ctrl = FIELD_GET(ICE_MI_GAC, d64);552 mi->gpr_a_data_mdid = FIELD_GET(ICE_MI_GADM, d64);553 mi->gpr_a_data_start = FIELD_GET(ICE_MI_GADS, d64);554 mi->gpr_a_data_len = FIELD_GET(ICE_MI_GADL, d64);555 mi->gpr_a_id = FIELD_GET(ICE_MI_GAI, d64);556 557 mi->gpr_b_ctrl = FIELD_GET(ICE_MI_GBC, d64);558 559 d64 = *((u64 *)&buf[ICE_MI_GBDM_IDD]) >> ICE_MI_GBDM_OFF;560 561 mi->gpr_b_data_mdid = FIELD_GET(ICE_MI_GBDM, d64);562 mi->gpr_b_data_start = FIELD_GET(ICE_MI_GBDS, d64);563 mi->gpr_b_data_len = FIELD_GET(ICE_MI_GBDL, d64);564 mi->gpr_b_id = FIELD_GET(ICE_MI_GBI, d64);565 566 mi->gpr_c_ctrl = FIELD_GET(ICE_MI_GCC, d64);567 mi->gpr_c_data_mdid = FIELD_GET(ICE_MI_GCDM, d64);568 mi->gpr_c_data_start = FIELD_GET(ICE_MI_GCDS, d64);569 mi->gpr_c_data_len = FIELD_GET(ICE_MI_GCDL, d64);570 mi->gpr_c_id = FIELD_GET(ICE_MI_GCI, d64);571 572 mi->gpr_d_ctrl = FIELD_GET(ICE_MI_GDC, d64);573 mi->gpr_d_data_mdid = FIELD_GET(ICE_MI_GDDM, d64);574 mi->gpr_d_data_start = FIELD_GET(ICE_MI_GDDS, d64);575 mi->gpr_d_data_len = FIELD_GET(ICE_MI_GDDL, d64);576 mi->gpr_d_id = FIELD_GET(ICE_MI_GDI, d64);577 578 d64 = *((u64 *)&buf[ICE_MI_FLAG_IDD]) >> ICE_MI_FLAG_OFF;579 580 mi->flags = FIELD_GET(ICE_MI_FLAG, d64);581 582 if (hw->debug_mask & ICE_DBG_PARSER)583 ice_metainit_dump(hw, mi);584}585 586/**587 * ice_metainit_table_get - create a metainit table588 * @hw: pointer to the hardware structure589 *590 * Return: a pointer to the allocated Metadata initialization table.591 */592static struct ice_metainit_item *ice_metainit_table_get(struct ice_hw *hw)593{594 return ice_parser_create_table(hw, ICE_SID_RXPARSER_METADATA_INIT,595 sizeof(struct ice_metainit_item),596 ICE_METAINIT_TABLE_SIZE,597 ice_metainit_parse_item, false);598}599 600/**601 * ice_bst_tcam_search - find a TCAM item with specific type602 * @tcam_table: the TCAM table603 * @lbl_table: the lbl table to search604 * @type: the type we need to match against605 * @start: start searching from this index606 *607 * Return: a pointer to the matching BOOST TCAM item or NULL.608 */609struct ice_bst_tcam_item *610ice_bst_tcam_search(struct ice_bst_tcam_item *tcam_table,611 struct ice_lbl_item *lbl_table,612 enum ice_lbl_type type, u16 *start)613{614 u16 i = *start;615 616 for (; i < ICE_BST_TCAM_TABLE_SIZE; i++) {617 if (lbl_table[i].type == type) {618 *start = i;619 return &tcam_table[lbl_table[i].idx];620 }621 }622 623 return NULL;624}625 626/*** ICE_SID_RXPARSER_CAM, ICE_SID_RXPARSER_PG_SPILL,627 * ICE_SID_RXPARSER_NOMATCH_CAM and ICE_SID_RXPARSER_NOMATCH_CAM628 * sections ***/629static void ice_pg_cam_key_dump(struct ice_hw *hw, struct ice_pg_cam_key *key)630{631 struct device *dev = ice_hw_to_dev(hw);632 633 dev_info(dev, "key:\n");634 dev_info(dev, "\tvalid = %d\n", key->valid);635 dev_info(dev, "\tnode_id = %d\n", key->node_id);636 dev_info(dev, "\tflag0 = %d\n", key->flag0);637 dev_info(dev, "\tflag1 = %d\n", key->flag1);638 dev_info(dev, "\tflag2 = %d\n", key->flag2);639 dev_info(dev, "\tflag3 = %d\n", key->flag3);640 dev_info(dev, "\tboost_idx = %d\n", key->boost_idx);641 dev_info(dev, "\talu_reg = 0x%04x\n", key->alu_reg);642 dev_info(dev, "\tnext_proto = 0x%08x\n", key->next_proto);643}644 645static void ice_pg_nm_cam_key_dump(struct ice_hw *hw,646 struct ice_pg_nm_cam_key *key)647{648 struct device *dev = ice_hw_to_dev(hw);649 650 dev_info(dev, "key:\n");651 dev_info(dev, "\tvalid = %d\n", key->valid);652 dev_info(dev, "\tnode_id = %d\n", key->node_id);653 dev_info(dev, "\tflag0 = %d\n", key->flag0);654 dev_info(dev, "\tflag1 = %d\n", key->flag1);655 dev_info(dev, "\tflag2 = %d\n", key->flag2);656 dev_info(dev, "\tflag3 = %d\n", key->flag3);657 dev_info(dev, "\tboost_idx = %d\n", key->boost_idx);658 dev_info(dev, "\talu_reg = 0x%04x\n", key->alu_reg);659}660 661static void ice_pg_cam_action_dump(struct ice_hw *hw,662 struct ice_pg_cam_action *action)663{664 struct device *dev = ice_hw_to_dev(hw);665 666 dev_info(dev, "action:\n");667 dev_info(dev, "\tnext_node = %d\n", action->next_node);668 dev_info(dev, "\tnext_pc = %d\n", action->next_pc);669 dev_info(dev, "\tis_pg = %d\n", action->is_pg);670 dev_info(dev, "\tproto_id = %d\n", action->proto_id);671 dev_info(dev, "\tis_mg = %d\n", action->is_mg);672 dev_info(dev, "\tmarker_id = %d\n", action->marker_id);673 dev_info(dev, "\tis_last_round = %d\n", action->is_last_round);674 dev_info(dev, "\tho_polarity = %d\n", action->ho_polarity);675 dev_info(dev, "\tho_inc = %d\n", action->ho_inc);676}677 678/**679 * ice_pg_cam_dump - dump an parse graph cam info680 * @hw: pointer to the hardware structure681 * @item: parse graph cam to dump682 */683static void ice_pg_cam_dump(struct ice_hw *hw, struct ice_pg_cam_item *item)684{685 dev_info(ice_hw_to_dev(hw), "index = %d\n", item->idx);686 ice_pg_cam_key_dump(hw, &item->key);687 ice_pg_cam_action_dump(hw, &item->action);688}689 690/**691 * ice_pg_nm_cam_dump - dump an parse graph no match cam info692 * @hw: pointer to the hardware structure693 * @item: parse graph no match cam to dump694 */695static void ice_pg_nm_cam_dump(struct ice_hw *hw,696 struct ice_pg_nm_cam_item *item)697{698 dev_info(ice_hw_to_dev(hw), "index = %d\n", item->idx);699 ice_pg_nm_cam_key_dump(hw, &item->key);700 ice_pg_cam_action_dump(hw, &item->action);701}702 703#define ICE_PGCA_NN GENMASK_ULL(10, 0)704#define ICE_PGCA_NPC GENMASK_ULL(18, 11)705#define ICE_PGCA_IPG BIT_ULL(19)706#define ICE_PGCA_PID GENMASK_ULL(30, 23)707#define ICE_PGCA_IMG BIT_ULL(31)708#define ICE_PGCA_MID GENMASK_ULL(39, 32)709#define ICE_PGCA_ILR BIT_ULL(40)710#define ICE_PGCA_HOP BIT_ULL(41)711#define ICE_PGCA_HOI GENMASK_ULL(50, 42)712 713/**714 * ice_pg_cam_action_init - parse 55 bits of Parse Graph CAM Action715 * @action: pointer to the Parse Graph CAM Action structure716 * @data: Parse Graph CAM Action data to be parsed717 */718static void ice_pg_cam_action_init(struct ice_pg_cam_action *action, u64 data)719{720 action->next_node = FIELD_GET(ICE_PGCA_NN, data);721 action->next_pc = FIELD_GET(ICE_PGCA_NPC, data);722 action->is_pg = FIELD_GET(ICE_PGCA_IPG, data);723 action->proto_id = FIELD_GET(ICE_PGCA_PID, data);724 action->is_mg = FIELD_GET(ICE_PGCA_IMG, data);725 action->marker_id = FIELD_GET(ICE_PGCA_MID, data);726 action->is_last_round = FIELD_GET(ICE_PGCA_ILR, data);727 action->ho_polarity = FIELD_GET(ICE_PGCA_HOP, data);728 action->ho_inc = FIELD_GET(ICE_PGCA_HOI, data);729}730 731#define ICE_PGNCK_VLD BIT_ULL(0)732#define ICE_PGNCK_NID GENMASK_ULL(11, 1)733#define ICE_PGNCK_F0 BIT_ULL(12)734#define ICE_PGNCK_F1 BIT_ULL(13)735#define ICE_PGNCK_F2 BIT_ULL(14)736#define ICE_PGNCK_F3 BIT_ULL(15)737#define ICE_PGNCK_BH BIT_ULL(16)738#define ICE_PGNCK_BI GENMASK_ULL(24, 17)739#define ICE_PGNCK_AR GENMASK_ULL(40, 25)740 741/**742 * ice_pg_nm_cam_key_init - parse 41 bits of Parse Graph NoMatch CAM Key743 * @key: pointer to the Parse Graph NoMatch CAM Key structure744 * @data: Parse Graph NoMatch CAM Key data to be parsed745 */746static void ice_pg_nm_cam_key_init(struct ice_pg_nm_cam_key *key, u64 data)747{748 key->valid = FIELD_GET(ICE_PGNCK_VLD, data);749 key->node_id = FIELD_GET(ICE_PGNCK_NID, data);750 key->flag0 = FIELD_GET(ICE_PGNCK_F0, data);751 key->flag1 = FIELD_GET(ICE_PGNCK_F1, data);752 key->flag2 = FIELD_GET(ICE_PGNCK_F2, data);753 key->flag3 = FIELD_GET(ICE_PGNCK_F3, data);754 755 if (FIELD_GET(ICE_PGNCK_BH, data))756 key->boost_idx = FIELD_GET(ICE_PGNCK_BI, data);757 else758 key->boost_idx = 0;759 760 key->alu_reg = FIELD_GET(ICE_PGNCK_AR, data);761}762 763#define ICE_PGCK_VLD BIT_ULL(0)764#define ICE_PGCK_NID GENMASK_ULL(11, 1)765#define ICE_PGCK_F0 BIT_ULL(12)766#define ICE_PGCK_F1 BIT_ULL(13)767#define ICE_PGCK_F2 BIT_ULL(14)768#define ICE_PGCK_F3 BIT_ULL(15)769#define ICE_PGCK_BH BIT_ULL(16)770#define ICE_PGCK_BI GENMASK_ULL(24, 17)771#define ICE_PGCK_AR GENMASK_ULL(40, 25)772#define ICE_PGCK_NPK_S 41 /* offset for the 2nd 64-bits field */773#define ICE_PGCK_NPK_IDD (ICE_PGCK_NPK_S / BITS_PER_BYTE)774#define ICE_PGCK_NPK_OFF (ICE_PGCK_NPK_S % BITS_PER_BYTE)775#define ICE_PGCK_NPK GENMASK_ULL(72 - ICE_PGCK_NPK_S, \776 41 - ICE_PGCK_NPK_S)777 778/**779 * ice_pg_cam_key_init - parse 73 bits of Parse Graph CAM Key780 * @key: pointer to the Parse Graph CAM Key structure781 * @data: Parse Graph CAM Key data to be parsed782 */783static void ice_pg_cam_key_init(struct ice_pg_cam_key *key, u8 *data)784{785 u64 d64 = *(u64 *)data;786 787 key->valid = FIELD_GET(ICE_PGCK_VLD, d64);788 key->node_id = FIELD_GET(ICE_PGCK_NID, d64);789 key->flag0 = FIELD_GET(ICE_PGCK_F0, d64);790 key->flag1 = FIELD_GET(ICE_PGCK_F1, d64);791 key->flag2 = FIELD_GET(ICE_PGCK_F2, d64);792 key->flag3 = FIELD_GET(ICE_PGCK_F3, d64);793 794 if (FIELD_GET(ICE_PGCK_BH, d64))795 key->boost_idx = FIELD_GET(ICE_PGCK_BI, d64);796 else797 key->boost_idx = 0;798 799 key->alu_reg = FIELD_GET(ICE_PGCK_AR, d64);800 801 d64 = *((u64 *)&data[ICE_PGCK_NPK_IDD]) >> ICE_PGCK_NPK_OFF;802 803 key->next_proto = FIELD_GET(ICE_PGCK_NPK, d64);804}805 806#define ICE_PG_CAM_ACT_S 73807#define ICE_PG_CAM_ACT_IDD (ICE_PG_CAM_ACT_S / BITS_PER_BYTE)808#define ICE_PG_CAM_ACT_OFF (ICE_PG_CAM_ACT_S % BITS_PER_BYTE)809 810/**811 * ice_pg_cam_parse_item - parse 128 bits of Parse Graph CAM Entry812 * @hw: pointer to the hardware structure813 * @idx: index of Parse Graph CAM Entry814 * @item: item of Parse Graph CAM Entry815 * @data: Parse Graph CAM Entry data to be parsed816 * @size: size of Parse Graph CAM Entry817 */818static void ice_pg_cam_parse_item(struct ice_hw *hw, u16 idx, void *item,819 void *data, int __maybe_unused size)820{821 struct ice_pg_cam_item *ci = item;822 u8 *buf = data;823 u64 d64;824 825 ci->idx = idx;826 827 ice_pg_cam_key_init(&ci->key, buf);828 829 d64 = *((u64 *)&buf[ICE_PG_CAM_ACT_IDD]) >> ICE_PG_CAM_ACT_OFF;830 ice_pg_cam_action_init(&ci->action, d64);831 832 if (hw->debug_mask & ICE_DBG_PARSER)833 ice_pg_cam_dump(hw, ci);834}835 836#define ICE_PG_SP_CAM_KEY_S 56837#define ICE_PG_SP_CAM_KEY_IDD (ICE_PG_SP_CAM_KEY_S / BITS_PER_BYTE)838 839/**840 * ice_pg_sp_cam_parse_item - parse 136 bits of Parse Graph Spill CAM Entry841 * @hw: pointer to the hardware structure842 * @idx: index of Parse Graph Spill CAM Entry843 * @item: item of Parse Graph Spill CAM Entry844 * @data: Parse Graph Spill CAM Entry data to be parsed845 * @size: size of Parse Graph Spill CAM Entry846 */847static void ice_pg_sp_cam_parse_item(struct ice_hw *hw, u16 idx, void *item,848 void *data, int __maybe_unused size)849{850 struct ice_pg_cam_item *ci = item;851 u8 *buf = data;852 u64 d64;853 854 ci->idx = idx;855 856 d64 = *(u64 *)buf;857 ice_pg_cam_action_init(&ci->action, d64);858 859 ice_pg_cam_key_init(&ci->key, &buf[ICE_PG_SP_CAM_KEY_IDD]);860 861 if (hw->debug_mask & ICE_DBG_PARSER)862 ice_pg_cam_dump(hw, ci);863}864 865#define ICE_PG_NM_CAM_ACT_S 41866#define ICE_PG_NM_CAM_ACT_IDD (ICE_PG_NM_CAM_ACT_S / BITS_PER_BYTE)867#define ICE_PG_NM_CAM_ACT_OFF (ICE_PG_NM_CAM_ACT_S % BITS_PER_BYTE)868 869/**870 * ice_pg_nm_cam_parse_item - parse 96 bits of Parse Graph NoMatch CAM Entry871 * @hw: pointer to the hardware structure872 * @idx: index of Parse Graph NoMatch CAM Entry873 * @item: item of Parse Graph NoMatch CAM Entry874 * @data: Parse Graph NoMatch CAM Entry data to be parsed875 * @size: size of Parse Graph NoMatch CAM Entry876 */877static void ice_pg_nm_cam_parse_item(struct ice_hw *hw, u16 idx, void *item,878 void *data, int __maybe_unused size)879{880 struct ice_pg_nm_cam_item *ci = item;881 u8 *buf = data;882 u64 d64;883 884 ci->idx = idx;885 886 d64 = *(u64 *)buf;887 ice_pg_nm_cam_key_init(&ci->key, d64);888 889 d64 = *((u64 *)&buf[ICE_PG_NM_CAM_ACT_IDD]) >> ICE_PG_NM_CAM_ACT_OFF;890 ice_pg_cam_action_init(&ci->action, d64);891 892 if (hw->debug_mask & ICE_DBG_PARSER)893 ice_pg_nm_cam_dump(hw, ci);894}895 896#define ICE_PG_NM_SP_CAM_ACT_S 56897#define ICE_PG_NM_SP_CAM_ACT_IDD (ICE_PG_NM_SP_CAM_ACT_S / BITS_PER_BYTE)898#define ICE_PG_NM_SP_CAM_ACT_OFF (ICE_PG_NM_SP_CAM_ACT_S % BITS_PER_BYTE)899 900/**901 * ice_pg_nm_sp_cam_parse_item - parse 104 bits of Parse Graph NoMatch Spill902 * CAM Entry903 * @hw: pointer to the hardware structure904 * @idx: index of Parse Graph NoMatch Spill CAM Entry905 * @item: item of Parse Graph NoMatch Spill CAM Entry906 * @data: Parse Graph NoMatch Spill CAM Entry data to be parsed907 * @size: size of Parse Graph NoMatch Spill CAM Entry908 */909static void ice_pg_nm_sp_cam_parse_item(struct ice_hw *hw, u16 idx,910 void *item, void *data,911 int __maybe_unused size)912{913 struct ice_pg_nm_cam_item *ci = item;914 u8 *buf = data;915 u64 d64;916 917 ci->idx = idx;918 919 d64 = *(u64 *)buf;920 ice_pg_cam_action_init(&ci->action, d64);921 922 d64 = *((u64 *)&buf[ICE_PG_NM_SP_CAM_ACT_IDD]) >>923 ICE_PG_NM_SP_CAM_ACT_OFF;924 ice_pg_nm_cam_key_init(&ci->key, d64);925 926 if (hw->debug_mask & ICE_DBG_PARSER)927 ice_pg_nm_cam_dump(hw, ci);928}929 930/**931 * ice_pg_cam_table_get - create a parse graph cam table932 * @hw: pointer to the hardware structure933 *934 * Return: a pointer to the allocated Parse Graph CAM table.935 */936static struct ice_pg_cam_item *ice_pg_cam_table_get(struct ice_hw *hw)937{938 return ice_parser_create_table(hw, ICE_SID_RXPARSER_CAM,939 sizeof(struct ice_pg_cam_item),940 ICE_PG_CAM_TABLE_SIZE,941 ice_pg_cam_parse_item, false);942}943 944/**945 * ice_pg_sp_cam_table_get - create a parse graph spill cam table946 * @hw: pointer to the hardware structure947 *948 * Return: a pointer to the allocated Parse Graph Spill CAM table.949 */950static struct ice_pg_cam_item *ice_pg_sp_cam_table_get(struct ice_hw *hw)951{952 return ice_parser_create_table(hw, ICE_SID_RXPARSER_PG_SPILL,953 sizeof(struct ice_pg_cam_item),954 ICE_PG_SP_CAM_TABLE_SIZE,955 ice_pg_sp_cam_parse_item, false);956}957 958/**959 * ice_pg_nm_cam_table_get - create a parse graph no match cam table960 * @hw: pointer to the hardware structure961 *962 * Return: a pointer to the allocated Parse Graph No Match CAM table.963 */964static struct ice_pg_nm_cam_item *ice_pg_nm_cam_table_get(struct ice_hw *hw)965{966 return ice_parser_create_table(hw, ICE_SID_RXPARSER_NOMATCH_CAM,967 sizeof(struct ice_pg_nm_cam_item),968 ICE_PG_NM_CAM_TABLE_SIZE,969 ice_pg_nm_cam_parse_item, false);970}971 972/**973 * ice_pg_nm_sp_cam_table_get - create a parse graph no match spill cam table974 * @hw: pointer to the hardware structure975 *976 * Return: a pointer to the allocated Parse Graph No Match Spill CAM table.977 */978static struct ice_pg_nm_cam_item *ice_pg_nm_sp_cam_table_get(struct ice_hw *hw)979{980 return ice_parser_create_table(hw, ICE_SID_RXPARSER_NOMATCH_SPILL,981 sizeof(struct ice_pg_nm_cam_item),982 ICE_PG_NM_SP_CAM_TABLE_SIZE,983 ice_pg_nm_sp_cam_parse_item, false);984}985 986static bool __ice_pg_cam_match(struct ice_pg_cam_item *item,987 struct ice_pg_cam_key *key)988{989 return (item->key.valid &&990 !memcmp(&item->key.val, &key->val, sizeof(key->val)));991}992 993static bool __ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *item,994 struct ice_pg_cam_key *key)995{996 return (item->key.valid &&997 !memcmp(&item->key.val, &key->val, sizeof(item->key.val)));998}999 1000/**1001 * ice_pg_cam_match - search parse graph cam table by key1002 * @table: parse graph cam table to search1003 * @size: cam table size1004 * @key: search key1005 *1006 * Return: a pointer to the matching PG CAM item or NULL.1007 */1008struct ice_pg_cam_item *ice_pg_cam_match(struct ice_pg_cam_item *table,1009 int size, struct ice_pg_cam_key *key)1010{1011 int i;1012 1013 for (i = 0; i < size; i++) {1014 struct ice_pg_cam_item *item = &table[i];1015 1016 if (__ice_pg_cam_match(item, key))1017 return item;1018 }1019 1020 return NULL;1021}1022 1023/**1024 * ice_pg_nm_cam_match - search parse graph no match cam table by key1025 * @table: parse graph no match cam table to search1026 * @size: cam table size1027 * @key: search key1028 *1029 * Return: a pointer to the matching PG No Match CAM item or NULL.1030 */1031struct ice_pg_nm_cam_item *1032ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *table, int size,1033 struct ice_pg_cam_key *key)1034{1035 int i;1036 1037 for (i = 0; i < size; i++) {1038 struct ice_pg_nm_cam_item *item = &table[i];1039 1040 if (__ice_pg_nm_cam_match(item, key))1041 return item;1042 }1043 1044 return NULL;1045}1046 1047/*** Ternary match ***/1048/* Perform a ternary match on a 1-byte pattern (@pat) given @key and @key_inv1049 * Rules (per bit):1050 * Key == 0 and Key_inv == 0 : Never match (Don't care)1051 * Key == 0 and Key_inv == 1 : Match on bit == 11052 * Key == 1 and Key_inv == 0 : Match on bit == 01053 * Key == 1 and Key_inv == 1 : Always match (Don't care)1054 *1055 * Return: true if all bits match, false otherwise.1056 */1057static bool ice_ternary_match_byte(u8 key, u8 key_inv, u8 pat)1058{1059 u8 bit_key, bit_key_inv, bit_pat;1060 int i;1061 1062 for (i = 0; i < BITS_PER_BYTE; i++) {1063 bit_key = key & BIT(i);1064 bit_key_inv = key_inv & BIT(i);1065 bit_pat = pat & BIT(i);1066 1067 if (bit_key != 0 && bit_key_inv != 0)1068 continue;1069 1070 if ((bit_key == 0 && bit_key_inv == 0) || bit_key == bit_pat)1071 return false;1072 }1073 1074 return true;1075}1076 1077static bool ice_ternary_match(const u8 *key, const u8 *key_inv,1078 const u8 *pat, int len)1079{1080 int i;1081 1082 for (i = 0; i < len; i++)1083 if (!ice_ternary_match_byte(key[i], key_inv[i], pat[i]))1084 return false;1085 1086 return true;1087}1088 1089/*** ICE_SID_RXPARSER_BOOST_TCAM and ICE_SID_LBL_RXPARSER_TMEM sections ***/1090static void ice_bst_np_kb_dump(struct ice_hw *hw, struct ice_np_keybuilder *kb)1091{1092 struct device *dev = ice_hw_to_dev(hw);1093 1094 dev_info(dev, "next proto key builder:\n");1095 dev_info(dev, "\topc = %d\n", kb->opc);1096 dev_info(dev, "\tstart_reg0 = %d\n", kb->start_reg0);1097 dev_info(dev, "\tlen_reg1 = %d\n", kb->len_reg1);1098}1099 1100static void ice_bst_pg_kb_dump(struct ice_hw *hw, struct ice_pg_keybuilder *kb)1101{1102 struct device *dev = ice_hw_to_dev(hw);1103 1104 dev_info(dev, "parse graph key builder:\n");1105 dev_info(dev, "\tflag0_ena = %d\n", kb->flag0_ena);1106 dev_info(dev, "\tflag1_ena = %d\n", kb->flag1_ena);1107 dev_info(dev, "\tflag2_ena = %d\n", kb->flag2_ena);1108 dev_info(dev, "\tflag3_ena = %d\n", kb->flag3_ena);1109 dev_info(dev, "\tflag0_idx = %d\n", kb->flag0_idx);1110 dev_info(dev, "\tflag1_idx = %d\n", kb->flag1_idx);1111 dev_info(dev, "\tflag2_idx = %d\n", kb->flag2_idx);1112 dev_info(dev, "\tflag3_idx = %d\n", kb->flag3_idx);1113 dev_info(dev, "\talu_reg_idx = %d\n", kb->alu_reg_idx);1114}1115 1116static void ice_bst_alu_dump(struct ice_hw *hw, struct ice_alu *alu, int idx)1117{1118 struct device *dev = ice_hw_to_dev(hw);1119 1120 dev_info(dev, "alu%d:\n", idx);1121 dev_info(dev, "\topc = %d\n", alu->opc);1122 dev_info(dev, "\tsrc_start = %d\n", alu->src_start);1123 dev_info(dev, "\tsrc_len = %d\n", alu->src_len);1124 dev_info(dev, "\tshift_xlate_sel = %d\n", alu->shift_xlate_sel);1125 dev_info(dev, "\tshift_xlate_key = %d\n", alu->shift_xlate_key);1126 dev_info(dev, "\tsrc_reg_id = %d\n", alu->src_reg_id);1127 dev_info(dev, "\tdst_reg_id = %d\n", alu->dst_reg_id);1128 dev_info(dev, "\tinc0 = %d\n", alu->inc0);1129 dev_info(dev, "\tinc1 = %d\n", alu->inc1);1130 dev_info(dev, "\tproto_offset_opc = %d\n", alu->proto_offset_opc);1131 dev_info(dev, "\tproto_offset = %d\n", alu->proto_offset);1132 dev_info(dev, "\tbranch_addr = %d\n", alu->branch_addr);1133 dev_info(dev, "\timm = %d\n", alu->imm);1134 dev_info(dev, "\tdst_start = %d\n", alu->dst_start);1135 dev_info(dev, "\tdst_len = %d\n", alu->dst_len);1136 dev_info(dev, "\tflags_extr_imm = %d\n", alu->flags_extr_imm);1137 dev_info(dev, "\tflags_start_imm= %d\n", alu->flags_start_imm);1138}1139 1140/**1141 * ice_bst_tcam_dump - dump a boost tcam info1142 * @hw: pointer to the hardware structure1143 * @item: boost tcam to dump1144 */1145static void ice_bst_tcam_dump(struct ice_hw *hw, struct ice_bst_tcam_item *item)1146{1147 struct device *dev = ice_hw_to_dev(hw);1148 int i;1149 1150 dev_info(dev, "addr = %d\n", item->addr);1151 1152 dev_info(dev, "key : ");1153 for (i = 0; i < ICE_BST_TCAM_KEY_SIZE; i++)1154 dev_info(dev, "%02x ", item->key[i]);1155 1156 dev_info(dev, "\n");1157 1158 dev_info(dev, "key_inv: ");1159 for (i = 0; i < ICE_BST_TCAM_KEY_SIZE; i++)1160 dev_info(dev, "%02x ", item->key_inv[i]);1161 1162 dev_info(dev, "\n");1163 1164 dev_info(dev, "hit_idx_grp = %d\n", item->hit_idx_grp);1165 dev_info(dev, "pg_prio = %d\n", item->pg_prio);1166 1167 ice_bst_np_kb_dump(hw, &item->np_kb);1168 ice_bst_pg_kb_dump(hw, &item->pg_kb);1169 1170 ice_bst_alu_dump(hw, &item->alu0, ICE_ALU0_IDX);1171 ice_bst_alu_dump(hw, &item->alu1, ICE_ALU1_IDX);1172 ice_bst_alu_dump(hw, &item->alu2, ICE_ALU2_IDX);1173}1174 1175static void ice_lbl_dump(struct ice_hw *hw, struct ice_lbl_item *item)1176{1177 struct device *dev = ice_hw_to_dev(hw);1178 1179 dev_info(dev, "index = %u\n", item->idx);1180 dev_info(dev, "type = %u\n", item->type);1181 dev_info(dev, "label = %s\n", item->label);1182}1183 1184#define ICE_BST_ALU_OPC GENMASK_ULL(5, 0)1185#define ICE_BST_ALU_SS GENMASK_ULL(13, 6)1186#define ICE_BST_ALU_SL GENMASK_ULL(18, 14)1187#define ICE_BST_ALU_SXS BIT_ULL(19)1188#define ICE_BST_ALU_SXK GENMASK_ULL(23, 20)1189#define ICE_BST_ALU_SRID GENMASK_ULL(30, 24)1190#define ICE_BST_ALU_DRID GENMASK_ULL(37, 31)1191#define ICE_BST_ALU_INC0 BIT_ULL(38)1192#define ICE_BST_ALU_INC1 BIT_ULL(39)1193#define ICE_BST_ALU_POO GENMASK_ULL(41, 40)1194#define ICE_BST_ALU_PO GENMASK_ULL(49, 42)1195#define ICE_BST_ALU_BA_S 50 /* offset for the 2nd 64-bits field */1196#define ICE_BST_ALU_BA GENMASK_ULL(57 - ICE_BST_ALU_BA_S, \1197 50 - ICE_BST_ALU_BA_S)1198#define ICE_BST_ALU_IMM GENMASK_ULL(73 - ICE_BST_ALU_BA_S, \1199 58 - ICE_BST_ALU_BA_S)1200#define ICE_BST_ALU_DFE BIT_ULL(74 - ICE_BST_ALU_BA_S)1201#define ICE_BST_ALU_DS GENMASK_ULL(80 - ICE_BST_ALU_BA_S, \1202 75 - ICE_BST_ALU_BA_S)1203#define ICE_BST_ALU_DL GENMASK_ULL(86 - ICE_BST_ALU_BA_S, \1204 81 - ICE_BST_ALU_BA_S)1205#define ICE_BST_ALU_FEI BIT_ULL(87 - ICE_BST_ALU_BA_S)1206#define ICE_BST_ALU_FSI GENMASK_ULL(95 - ICE_BST_ALU_BA_S, \1207 88 - ICE_BST_ALU_BA_S)1208 1209/**1210 * ice_bst_alu_init - parse 96 bits of ALU entry1211 * @alu: pointer to the ALU entry structure1212 * @data: ALU entry data to be parsed1213 * @off: offset of the ALU entry data1214 */1215static void ice_bst_alu_init(struct ice_alu *alu, u8 *data, u8 off)1216{1217 u64 d64;1218 u8 idd;1219 1220 d64 = *((u64 *)data) >> off;1221 1222 alu->opc = FIELD_GET(ICE_BST_ALU_OPC, d64);1223 alu->src_start = FIELD_GET(ICE_BST_ALU_SS, d64);1224 alu->src_len = FIELD_GET(ICE_BST_ALU_SL, d64);1225 alu->shift_xlate_sel = FIELD_GET(ICE_BST_ALU_SXS, d64);1226 alu->shift_xlate_key = FIELD_GET(ICE_BST_ALU_SXK, d64);1227 alu->src_reg_id = FIELD_GET(ICE_BST_ALU_SRID, d64);1228 alu->dst_reg_id = FIELD_GET(ICE_BST_ALU_DRID, d64);1229 alu->inc0 = FIELD_GET(ICE_BST_ALU_INC0, d64);1230 alu->inc1 = FIELD_GET(ICE_BST_ALU_INC1, d64);1231 alu->proto_offset_opc = FIELD_GET(ICE_BST_ALU_POO, d64);1232 alu->proto_offset = FIELD_GET(ICE_BST_ALU_PO, d64);1233 1234 idd = (ICE_BST_ALU_BA_S + off) / BITS_PER_BYTE;1235 off = (ICE_BST_ALU_BA_S + off) % BITS_PER_BYTE;1236 d64 = *((u64 *)(&data[idd])) >> off;1237 1238 alu->branch_addr = FIELD_GET(ICE_BST_ALU_BA, d64);1239 alu->imm = FIELD_GET(ICE_BST_ALU_IMM, d64);1240 alu->dedicate_flags_ena = FIELD_GET(ICE_BST_ALU_DFE, d64);1241 alu->dst_start = FIELD_GET(ICE_BST_ALU_DS, d64);1242 alu->dst_len = FIELD_GET(ICE_BST_ALU_DL, d64);1243 alu->flags_extr_imm = FIELD_GET(ICE_BST_ALU_FEI, d64);1244 alu->flags_start_imm = FIELD_GET(ICE_BST_ALU_FSI, d64);1245}1246 1247#define ICE_BST_PGKB_F0_ENA BIT_ULL(0)1248#define ICE_BST_PGKB_F0_IDX GENMASK_ULL(6, 1)1249#define ICE_BST_PGKB_F1_ENA BIT_ULL(7)1250#define ICE_BST_PGKB_F1_IDX GENMASK_ULL(13, 8)1251#define ICE_BST_PGKB_F2_ENA BIT_ULL(14)1252#define ICE_BST_PGKB_F2_IDX GENMASK_ULL(20, 15)1253#define ICE_BST_PGKB_F3_ENA BIT_ULL(21)1254#define ICE_BST_PGKB_F3_IDX GENMASK_ULL(27, 22)1255#define ICE_BST_PGKB_AR_IDX GENMASK_ULL(34, 28)1256 1257/**1258 * ice_bst_pgkb_init - parse 35 bits of Parse Graph Key Build1259 * @kb: pointer to the Parse Graph Key Build structure1260 * @data: Parse Graph Key Build data to be parsed1261 */1262static void ice_bst_pgkb_init(struct ice_pg_keybuilder *kb, u64 data)1263{1264 kb->flag0_ena = FIELD_GET(ICE_BST_PGKB_F0_ENA, data);1265 kb->flag0_idx = FIELD_GET(ICE_BST_PGKB_F0_IDX, data);1266 kb->flag1_ena = FIELD_GET(ICE_BST_PGKB_F1_ENA, data);1267 kb->flag1_idx = FIELD_GET(ICE_BST_PGKB_F1_IDX, data);1268 kb->flag2_ena = FIELD_GET(ICE_BST_PGKB_F2_ENA, data);1269 kb->flag2_idx = FIELD_GET(ICE_BST_PGKB_F2_IDX, data);1270 kb->flag3_ena = FIELD_GET(ICE_BST_PGKB_F3_ENA, data);1271 kb->flag3_idx = FIELD_GET(ICE_BST_PGKB_F3_IDX, data);1272 kb->alu_reg_idx = FIELD_GET(ICE_BST_PGKB_AR_IDX, data);1273}1274 1275#define ICE_BST_NPKB_OPC GENMASK(1, 0)1276#define ICE_BST_NPKB_S_R0 GENMASK(9, 2)1277#define ICE_BST_NPKB_L_R1 GENMASK(17, 10)1278 1279/**1280 * ice_bst_npkb_init - parse 18 bits of Next Protocol Key Build1281 * @kb: pointer to the Next Protocol Key Build structure1282 * @data: Next Protocol Key Build data to be parsed1283 */1284static void ice_bst_npkb_init(struct ice_np_keybuilder *kb, u32 data)1285{1286 kb->opc = FIELD_GET(ICE_BST_NPKB_OPC, data);1287 kb->start_reg0 = FIELD_GET(ICE_BST_NPKB_S_R0, data);1288 kb->len_reg1 = FIELD_GET(ICE_BST_NPKB_L_R1, data);1289}1290 1291#define ICE_BT_KEY_S 321292#define ICE_BT_KEY_IDD (ICE_BT_KEY_S / BITS_PER_BYTE)1293#define ICE_BT_KIV_S 1921294#define ICE_BT_KIV_IDD (ICE_BT_KIV_S / BITS_PER_BYTE)1295#define ICE_BT_HIG_S 3521296#define ICE_BT_HIG_IDD (ICE_BT_HIG_S / BITS_PER_BYTE)1297#define ICE_BT_PGP_S 3601298#define ICE_BT_PGP_IDD (ICE_BT_PGP_S / BITS_PER_BYTE)1299#define ICE_BT_PGP_M GENMASK(361 - ICE_BT_PGP_S, 360 - ICE_BT_PGP_S)1300#define ICE_BT_NPKB_S 3621301#define ICE_BT_NPKB_IDD (ICE_BT_NPKB_S / BITS_PER_BYTE)1302#define ICE_BT_NPKB_OFF (ICE_BT_NPKB_S % BITS_PER_BYTE)1303#define ICE_BT_PGKB_S 3801304#define ICE_BT_PGKB_IDD (ICE_BT_PGKB_S / BITS_PER_BYTE)1305#define ICE_BT_PGKB_OFF (ICE_BT_PGKB_S % BITS_PER_BYTE)1306#define ICE_BT_ALU0_S 4151307#define ICE_BT_ALU0_IDD (ICE_BT_ALU0_S / BITS_PER_BYTE)1308#define ICE_BT_ALU0_OFF (ICE_BT_ALU0_S % BITS_PER_BYTE)1309#define ICE_BT_ALU1_S 5111310#define ICE_BT_ALU1_IDD (ICE_BT_ALU1_S / BITS_PER_BYTE)1311#define ICE_BT_ALU1_OFF (ICE_BT_ALU1_S % BITS_PER_BYTE)1312#define ICE_BT_ALU2_S 6071313#define ICE_BT_ALU2_IDD (ICE_BT_ALU2_S / BITS_PER_BYTE)1314#define ICE_BT_ALU2_OFF (ICE_BT_ALU2_S % BITS_PER_BYTE)1315 1316/**1317 * ice_bst_parse_item - parse 704 bits of Boost TCAM entry1318 * @hw: pointer to the hardware structure1319 * @idx: index of Boost TCAM entry1320 * @item: item of Boost TCAM entry1321 * @data: Boost TCAM entry data to be parsed1322 * @size: size of Boost TCAM entry1323 */1324static void ice_bst_parse_item(struct ice_hw *hw, u16 idx, void *item,1325 void *data, int __maybe_unused size)1326{1327 struct ice_bst_tcam_item *ti = item;1328 u8 *buf = (u8 *)data;1329 int i;1330 1331 ti->addr = *(u16 *)buf;1332 1333 for (i = 0; i < ICE_BST_TCAM_KEY_SIZE; i++) {1334 ti->key[i] = buf[ICE_BT_KEY_IDD + i];1335 ti->key_inv[i] = buf[ICE_BT_KIV_IDD + i];1336 }1337 ti->hit_idx_grp = buf[ICE_BT_HIG_IDD];1338 ti->pg_prio = buf[ICE_BT_PGP_IDD] & ICE_BT_PGP_M;1339 1340 ice_bst_npkb_init(&ti->np_kb,1341 *((u32 *)(&buf[ICE_BT_NPKB_IDD])) >>1342 ICE_BT_NPKB_OFF);1343 ice_bst_pgkb_init(&ti->pg_kb,1344 *((u64 *)(&buf[ICE_BT_PGKB_IDD])) >>1345 ICE_BT_PGKB_OFF);1346 1347 ice_bst_alu_init(&ti->alu0, &buf[ICE_BT_ALU0_IDD], ICE_BT_ALU0_OFF);1348 ice_bst_alu_init(&ti->alu1, &buf[ICE_BT_ALU1_IDD], ICE_BT_ALU1_OFF);1349 ice_bst_alu_init(&ti->alu2, &buf[ICE_BT_ALU2_IDD], ICE_BT_ALU2_OFF);1350 1351 if (hw->debug_mask & ICE_DBG_PARSER)1352 ice_bst_tcam_dump(hw, ti);1353}1354 1355/**1356 * ice_bst_tcam_table_get - create a boost tcam table1357 * @hw: pointer to the hardware structure1358 *1359 * Return: a pointer to the allocated Boost TCAM table.1360 */1361static struct ice_bst_tcam_item *ice_bst_tcam_table_get(struct ice_hw *hw)1362{1363 return ice_parser_create_table(hw, ICE_SID_RXPARSER_BOOST_TCAM,1364 sizeof(struct ice_bst_tcam_item),1365 ICE_BST_TCAM_TABLE_SIZE,1366 ice_bst_parse_item, true);1367}1368 1369static void ice_parse_lbl_item(struct ice_hw *hw, u16 idx, void *item,1370 void *data, int __maybe_unused size)1371{1372 struct ice_lbl_item *lbl_item = item;1373 struct ice_lbl_item *lbl_data = data;1374 1375 lbl_item->idx = lbl_data->idx;1376 memcpy(lbl_item->label, lbl_data->label, sizeof(lbl_item->label));1377 1378 if (strstarts(lbl_item->label, ICE_LBL_BST_DVM))1379 lbl_item->type = ICE_LBL_BST_TYPE_DVM;1380 else if (strstarts(lbl_item->label, ICE_LBL_BST_SVM))1381 lbl_item->type = ICE_LBL_BST_TYPE_SVM;1382 else if (strstarts(lbl_item->label, ICE_LBL_TNL_VXLAN))1383 lbl_item->type = ICE_LBL_BST_TYPE_VXLAN;1384 else if (strstarts(lbl_item->label, ICE_LBL_TNL_GENEVE))1385 lbl_item->type = ICE_LBL_BST_TYPE_GENEVE;1386 else if (strstarts(lbl_item->label, ICE_LBL_TNL_UDP_ECPRI))1387 lbl_item->type = ICE_LBL_BST_TYPE_UDP_ECPRI;1388 1389 if (hw->debug_mask & ICE_DBG_PARSER)1390 ice_lbl_dump(hw, lbl_item);1391}1392 1393/**1394 * ice_bst_lbl_table_get - create a boost label table1395 * @hw: pointer to the hardware structure1396 *1397 * Return: a pointer to the allocated Boost label table.1398 */1399static struct ice_lbl_item *ice_bst_lbl_table_get(struct ice_hw *hw)1400{1401 return ice_parser_create_table(hw, ICE_SID_LBL_RXPARSER_TMEM,1402 sizeof(struct ice_lbl_item),1403 ICE_BST_TCAM_TABLE_SIZE,1404 ice_parse_lbl_item, true);1405}1406 1407/**1408 * ice_bst_tcam_match - match a pattern on the boost tcam table1409 * @tcam_table: boost tcam table to search1410 * @pat: pattern to match1411 *1412 * Return: a pointer to the matching Boost TCAM item or NULL.1413 */1414struct ice_bst_tcam_item *1415ice_bst_tcam_match(struct ice_bst_tcam_item *tcam_table, u8 *pat)1416{1417 int i;1418 1419 for (i = 0; i < ICE_BST_TCAM_TABLE_SIZE; i++) {1420 struct ice_bst_tcam_item *item = &tcam_table[i];1421 1422 if (item->hit_idx_grp == 0)1423 continue;1424 if (ice_ternary_match(item->key, item->key_inv, pat,1425 ICE_BST_TCAM_KEY_SIZE))1426 return item;1427 }1428 1429 return NULL;1430}1431 1432/*** ICE_SID_RXPARSER_MARKER_PTYPE section ***/1433/**1434 * ice_ptype_mk_tcam_dump - dump an ptype marker tcam info1435 * @hw: pointer to the hardware structure1436 * @item: ptype marker tcam to dump1437 */1438static void ice_ptype_mk_tcam_dump(struct ice_hw *hw,1439 struct ice_ptype_mk_tcam_item *item)1440{1441 struct device *dev = ice_hw_to_dev(hw);1442 int i;1443 1444 dev_info(dev, "address = %d\n", item->address);1445 dev_info(dev, "ptype = %d\n", item->ptype);1446 1447 dev_info(dev, "key :");1448 for (i = 0; i < ICE_PTYPE_MK_TCAM_KEY_SIZE; i++)1449 dev_info(dev, "%02x ", item->key[i]);1450 1451 dev_info(dev, "\n");1452 1453 dev_info(dev, "key_inv:");1454 for (i = 0; i < ICE_PTYPE_MK_TCAM_KEY_SIZE; i++)1455 dev_info(dev, "%02x ", item->key_inv[i]);1456 1457 dev_info(dev, "\n");1458}1459 1460static void ice_parse_ptype_mk_tcam_item(struct ice_hw *hw, u16 idx,1461 void *item, void *data, int size)1462{1463 memcpy(item, data, size);1464 1465 if (hw->debug_mask & ICE_DBG_PARSER)1466 ice_ptype_mk_tcam_dump(hw,1467 (struct ice_ptype_mk_tcam_item *)item);1468}1469 1470/**1471 * ice_ptype_mk_tcam_table_get - create a ptype marker tcam table1472 * @hw: pointer to the hardware structure1473 *1474 * Return: a pointer to the allocated Marker PType TCAM table.1475 */1476static1477struct ice_ptype_mk_tcam_item *ice_ptype_mk_tcam_table_get(struct ice_hw *hw)1478{1479 return ice_parser_create_table(hw, ICE_SID_RXPARSER_MARKER_PTYPE,1480 sizeof(struct ice_ptype_mk_tcam_item),1481 ICE_PTYPE_MK_TCAM_TABLE_SIZE,1482 ice_parse_ptype_mk_tcam_item, true);1483}1484 1485/**1486 * ice_ptype_mk_tcam_match - match a pattern on a ptype marker tcam table1487 * @table: ptype marker tcam table to search1488 * @pat: pattern to match1489 * @len: length of the pattern1490 *1491 * Return: a pointer to the matching Marker PType item or NULL.1492 */1493struct ice_ptype_mk_tcam_item *1494ice_ptype_mk_tcam_match(struct ice_ptype_mk_tcam_item *table,1495 u8 *pat, int len)1496{1497 int i;1498 1499 for (i = 0; i < ICE_PTYPE_MK_TCAM_TABLE_SIZE; i++) {1500 struct ice_ptype_mk_tcam_item *item = &table[i];1501 1502 if (ice_ternary_match(item->key, item->key_inv, pat, len))1503 return item;1504 }1505 1506 return NULL;1507}1508 1509/*** ICE_SID_RXPARSER_MARKER_GRP section ***/1510/**1511 * ice_mk_grp_dump - dump an marker group item info1512 * @hw: pointer to the hardware structure1513 * @item: marker group item to dump1514 */1515static void ice_mk_grp_dump(struct ice_hw *hw, struct ice_mk_grp_item *item)1516{1517 struct device *dev = ice_hw_to_dev(hw);1518 int i;1519 1520 dev_info(dev, "index = %d\n", item->idx);1521 1522 dev_info(dev, "markers: ");1523 for (i = 0; i < ICE_MK_COUNT_PER_GRP; i++)1524 dev_info(dev, "%d ", item->markers[i]);1525 1526 dev_info(dev, "\n");1527}1528 1529static void ice_mk_grp_parse_item(struct ice_hw *hw, u16 idx, void *item,1530 void *data, int __maybe_unused size)1531{1532 struct ice_mk_grp_item *grp = item;1533 u8 *buf = data;1534 int i;1535 1536 grp->idx = idx;1537 1538 for (i = 0; i < ICE_MK_COUNT_PER_GRP; i++)1539 grp->markers[i] = buf[i];1540 1541 if (hw->debug_mask & ICE_DBG_PARSER)1542 ice_mk_grp_dump(hw, grp);1543}1544 1545/**1546 * ice_mk_grp_table_get - create a marker group table1547 * @hw: pointer to the hardware structure1548 *1549 * Return: a pointer to the allocated Marker Group ID table.1550 */1551static struct ice_mk_grp_item *ice_mk_grp_table_get(struct ice_hw *hw)1552{1553 return ice_parser_create_table(hw, ICE_SID_RXPARSER_MARKER_GRP,1554 sizeof(struct ice_mk_grp_item),1555 ICE_MK_GRP_TABLE_SIZE,1556 ice_mk_grp_parse_item, false);1557}1558 1559/*** ICE_SID_RXPARSER_PROTO_GRP section ***/1560static void ice_proto_off_dump(struct ice_hw *hw,1561 struct ice_proto_off *po, int idx)1562{1563 struct device *dev = ice_hw_to_dev(hw);1564 1565 dev_info(dev, "proto %d\n", idx);1566 dev_info(dev, "\tpolarity = %d\n", po->polarity);1567 dev_info(dev, "\tproto_id = %d\n", po->proto_id);1568 dev_info(dev, "\toffset = %d\n", po->offset);1569}1570 1571/**1572 * ice_proto_grp_dump - dump a proto group item info1573 * @hw: pointer to the hardware structure1574 * @item: proto group item to dump1575 */1576static void ice_proto_grp_dump(struct ice_hw *hw,1577 struct ice_proto_grp_item *item)1578{1579 int i;1580 1581 dev_info(ice_hw_to_dev(hw), "index = %d\n", item->idx);1582 1583 for (i = 0; i < ICE_PROTO_COUNT_PER_GRP; i++)1584 ice_proto_off_dump(hw, &item->po[i], i);1585}1586 1587#define ICE_PO_POL BIT(0)1588#define ICE_PO_PID GENMASK(8, 1)1589#define ICE_PO_OFF GENMASK(21, 12)1590 1591/**1592 * ice_proto_off_parse - parse 22 bits of Protocol entry1593 * @po: pointer to the Protocol entry structure1594 * @data: Protocol entry data to be parsed1595 */1596static void ice_proto_off_parse(struct ice_proto_off *po, u32 data)1597{1598 po->polarity = FIELD_GET(ICE_PO_POL, data);1599 po->proto_id = FIELD_GET(ICE_PO_PID, data);1600 po->offset = FIELD_GET(ICE_PO_OFF, data);1601}1602 1603/**1604 * ice_proto_grp_parse_item - parse 192 bits of Protocol Group Table entry1605 * @hw: pointer to the hardware structure1606 * @idx: index of Protocol Group Table entry1607 * @item: item of Protocol Group Table entry1608 * @data: Protocol Group Table entry data to be parsed1609 * @size: size of Protocol Group Table entry1610 */1611static void ice_proto_grp_parse_item(struct ice_hw *hw, u16 idx, void *item,1612 void *data, int __maybe_unused size)1613{1614 struct ice_proto_grp_item *grp = item;1615 u8 *buf = (u8 *)data;1616 u8 idd, off;1617 u32 d32;1618 int i;1619 1620 grp->idx = idx;1621 1622 for (i = 0; i < ICE_PROTO_COUNT_PER_GRP; i++) {1623 idd = (ICE_PROTO_GRP_ITEM_SIZE * i) / BITS_PER_BYTE;1624 off = (ICE_PROTO_GRP_ITEM_SIZE * i) % BITS_PER_BYTE;1625 d32 = *((u32 *)&buf[idd]) >> off;1626 ice_proto_off_parse(&grp->po[i], d32);1627 }1628 1629 if (hw->debug_mask & ICE_DBG_PARSER)1630 ice_proto_grp_dump(hw, grp);1631}1632 1633/**1634 * ice_proto_grp_table_get - create a proto group table1635 * @hw: pointer to the hardware structure1636 *1637 * Return: a pointer to the allocated Protocol Group table.1638 */1639static struct ice_proto_grp_item *ice_proto_grp_table_get(struct ice_hw *hw)1640{1641 return ice_parser_create_table(hw, ICE_SID_RXPARSER_PROTO_GRP,1642 sizeof(struct ice_proto_grp_item),1643 ICE_PROTO_GRP_TABLE_SIZE,1644 ice_proto_grp_parse_item, false);1645}1646 1647/*** ICE_SID_RXPARSER_FLAG_REDIR section ***/1648/**1649 * ice_flg_rd_dump - dump a flag redirect item info1650 * @hw: pointer to the hardware structure1651 * @item: flag redirect item to dump1652 */1653static void ice_flg_rd_dump(struct ice_hw *hw, struct ice_flg_rd_item *item)1654{1655 struct device *dev = ice_hw_to_dev(hw);1656 1657 dev_info(dev, "index = %d\n", item->idx);1658 dev_info(dev, "expose = %d\n", item->expose);1659 dev_info(dev, "intr_flg_id = %d\n", item->intr_flg_id);1660}1661 1662#define ICE_FRT_EXPO BIT(0)1663#define ICE_FRT_IFID GENMASK(6, 1)1664 1665/**1666 * ice_flg_rd_parse_item - parse 8 bits of Flag Redirect Table entry1667 * @hw: pointer to the hardware structure1668 * @idx: index of Flag Redirect Table entry1669 * @item: item of Flag Redirect Table entry1670 * @data: Flag Redirect Table entry data to be parsed1671 * @size: size of Flag Redirect Table entry1672 */1673static void ice_flg_rd_parse_item(struct ice_hw *hw, u16 idx, void *item,1674 void *data, int __maybe_unused size)1675{1676 struct ice_flg_rd_item *rdi = item;1677 u8 d8 = *(u8 *)data;1678 1679 rdi->idx = idx;1680 rdi->expose = FIELD_GET(ICE_FRT_EXPO, d8);1681 rdi->intr_flg_id = FIELD_GET(ICE_FRT_IFID, d8);1682 1683 if (hw->debug_mask & ICE_DBG_PARSER)1684 ice_flg_rd_dump(hw, rdi);1685}1686 1687/**1688 * ice_flg_rd_table_get - create a flag redirect table1689 * @hw: pointer to the hardware structure1690 *1691 * Return: a pointer to the allocated Flags Redirection table.1692 */1693static struct ice_flg_rd_item *ice_flg_rd_table_get(struct ice_hw *hw)1694{1695 return ice_parser_create_table(hw, ICE_SID_RXPARSER_FLAG_REDIR,1696 sizeof(struct ice_flg_rd_item),1697 ICE_FLG_RD_TABLE_SIZE,1698 ice_flg_rd_parse_item, false);1699}1700 1701/**1702 * ice_flg_redirect - redirect a parser flag to packet flag1703 * @table: flag redirect table1704 * @psr_flg: parser flag to redirect1705 *1706 * Return: flag or 0 if @psr_flag = 0.1707 */1708u64 ice_flg_redirect(struct ice_flg_rd_item *table, u64 psr_flg)1709{1710 u64 flg = 0;1711 int i;1712 1713 for (i = 0; i < ICE_FLG_RDT_SIZE; i++) {1714 struct ice_flg_rd_item *item = &table[i];1715 1716 if (!item->expose)1717 continue;1718 1719 if (psr_flg & BIT(item->intr_flg_id))1720 flg |= BIT(i);1721 }1722 1723 return flg;1724}1725 1726/*** ICE_SID_XLT_KEY_BUILDER_SW, ICE_SID_XLT_KEY_BUILDER_ACL,1727 * ICE_SID_XLT_KEY_BUILDER_FD and ICE_SID_XLT_KEY_BUILDER_RSS1728 * sections ***/1729static void ice_xlt_kb_entry_dump(struct ice_hw *hw,1730 struct ice_xlt_kb_entry *entry, int idx)1731{1732 struct device *dev = ice_hw_to_dev(hw);1733 int i;1734 1735 dev_info(dev, "key builder entry %d\n", idx);1736 dev_info(dev, "\txlt1_ad_sel = %d\n", entry->xlt1_ad_sel);1737 dev_info(dev, "\txlt2_ad_sel = %d\n", entry->xlt2_ad_sel);1738 1739 for (i = 0; i < ICE_XLT_KB_FLAG0_14_CNT; i++)1740 dev_info(dev, "\tflg%d_sel = %d\n", i, entry->flg0_14_sel[i]);1741 1742 dev_info(dev, "\txlt1_md_sel = %d\n", entry->xlt1_md_sel);1743 dev_info(dev, "\txlt2_md_sel = %d\n", entry->xlt2_md_sel);1744}1745 1746/**1747 * ice_xlt_kb_dump - dump a xlt key build info1748 * @hw: pointer to the hardware structure1749 * @kb: key build to dump1750 */1751static void ice_xlt_kb_dump(struct ice_hw *hw, struct ice_xlt_kb *kb)1752{1753 struct device *dev = ice_hw_to_dev(hw);1754 int i;1755 1756 dev_info(dev, "xlt1_pm = %d\n", kb->xlt1_pm);1757 dev_info(dev, "xlt2_pm = %d\n", kb->xlt2_pm);1758 dev_info(dev, "prof_id_pm = %d\n", kb->prof_id_pm);1759 dev_info(dev, "flag15 lo = 0x%08x\n", (u32)kb->flag15);1760 dev_info(dev, "flag15 hi = 0x%08x\n",1761 (u32)(kb->flag15 >> (sizeof(u32) * BITS_PER_BYTE)));1762 1763 for (i = 0; i < ICE_XLT_KB_TBL_CNT; i++)1764 ice_xlt_kb_entry_dump(hw, &kb->entries[i], i);1765}1766 1767#define ICE_XLT_KB_X1AS_S 32 /* offset for the 1st 64-bits field */1768#define ICE_XLT_KB_X1AS_IDD (ICE_XLT_KB_X1AS_S / BITS_PER_BYTE)1769#define ICE_XLT_KB_X1AS_OFF (ICE_XLT_KB_X1AS_S % BITS_PER_BYTE)1770#define ICE_XLT_KB_X1AS GENMASK_ULL(34 - ICE_XLT_KB_X1AS_S, \1771 32 - ICE_XLT_KB_X1AS_S)1772#define ICE_XLT_KB_X2AS GENMASK_ULL(37 - ICE_XLT_KB_X1AS_S, \1773 35 - ICE_XLT_KB_X1AS_S)1774#define ICE_XLT_KB_FL00 GENMASK_ULL(46 - ICE_XLT_KB_X1AS_S, \1775 38 - ICE_XLT_KB_X1AS_S)1776#define ICE_XLT_KB_FL01 GENMASK_ULL(55 - ICE_XLT_KB_X1AS_S, \1777 47 - ICE_XLT_KB_X1AS_S)1778#define ICE_XLT_KB_FL02 GENMASK_ULL(64 - ICE_XLT_KB_X1AS_S, \1779 56 - ICE_XLT_KB_X1AS_S)1780#define ICE_XLT_KB_FL03 GENMASK_ULL(73 - ICE_XLT_KB_X1AS_S, \1781 65 - ICE_XLT_KB_X1AS_S)1782#define ICE_XLT_KB_FL04 GENMASK_ULL(82 - ICE_XLT_KB_X1AS_S, \1783 74 - ICE_XLT_KB_X1AS_S)1784#define ICE_XLT_KB_FL05 GENMASK_ULL(91 - ICE_XLT_KB_X1AS_S, \1785 83 - ICE_XLT_KB_X1AS_S)1786#define ICE_XLT_KB_FL06_S 92 /* offset for the 2nd 64-bits field */1787#define ICE_XLT_KB_FL06_IDD (ICE_XLT_KB_FL06_S / BITS_PER_BYTE)1788#define ICE_XLT_KB_FL06_OFF (ICE_XLT_KB_FL06_S % BITS_PER_BYTE)1789#define ICE_XLT_KB_FL06 GENMASK_ULL(100 - ICE_XLT_KB_FL06_S, \1790 92 - ICE_XLT_KB_FL06_S)1791#define ICE_XLT_KB_FL07 GENMASK_ULL(109 - ICE_XLT_KB_FL06_S, \1792 101 - ICE_XLT_KB_FL06_S)1793#define ICE_XLT_KB_FL08 GENMASK_ULL(118 - ICE_XLT_KB_FL06_S, \1794 110 - ICE_XLT_KB_FL06_S)1795#define ICE_XLT_KB_FL09 GENMASK_ULL(127 - ICE_XLT_KB_FL06_S, \1796 119 - ICE_XLT_KB_FL06_S)1797#define ICE_XLT_KB_FL10 GENMASK_ULL(136 - ICE_XLT_KB_FL06_S, \1798 128 - ICE_XLT_KB_FL06_S)1799#define ICE_XLT_KB_FL11 GENMASK_ULL(145 - ICE_XLT_KB_FL06_S, \1800 137 - ICE_XLT_KB_FL06_S)1801#define ICE_XLT_KB_FL12_S 146 /* offset for the 3rd 64-bits field */1802#define ICE_XLT_KB_FL12_IDD (ICE_XLT_KB_FL12_S / BITS_PER_BYTE)1803#define ICE_XLT_KB_FL12_OFF (ICE_XLT_KB_FL12_S % BITS_PER_BYTE)1804#define ICE_XLT_KB_FL12 GENMASK_ULL(154 - ICE_XLT_KB_FL12_S, \1805 146 - ICE_XLT_KB_FL12_S)1806#define ICE_XLT_KB_FL13 GENMASK_ULL(163 - ICE_XLT_KB_FL12_S, \1807 155 - ICE_XLT_KB_FL12_S)1808#define ICE_XLT_KB_FL14 GENMASK_ULL(181 - ICE_XLT_KB_FL12_S, \1809 164 - ICE_XLT_KB_FL12_S)1810#define ICE_XLT_KB_X1MS GENMASK_ULL(186 - ICE_XLT_KB_FL12_S, \1811 182 - ICE_XLT_KB_FL12_S)1812#define ICE_XLT_KB_X2MS GENMASK_ULL(191 - ICE_XLT_KB_FL12_S, \1813 187 - ICE_XLT_KB_FL12_S)1814 1815/**1816 * ice_kb_entry_init - parse 192 bits of XLT Key Builder entry1817 * @entry: pointer to the XLT Key Builder entry structure1818 * @data: XLT Key Builder entry data to be parsed1819 */1820static void ice_kb_entry_init(struct ice_xlt_kb_entry *entry, u8 *data)1821{1822 u8 i = 0;1823 u64 d64;1824 1825 d64 = *((u64 *)&data[ICE_XLT_KB_X1AS_IDD]) >> ICE_XLT_KB_X1AS_OFF;1826 1827 entry->xlt1_ad_sel = FIELD_GET(ICE_XLT_KB_X1AS, d64);1828 entry->xlt2_ad_sel = FIELD_GET(ICE_XLT_KB_X2AS, d64);1829 1830 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL00, d64);1831 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL01, d64);1832 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL02, d64);1833 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL03, d64);1834 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL04, d64);1835 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL05, d64);1836 1837 d64 = *((u64 *)&data[ICE_XLT_KB_FL06_IDD]) >> ICE_XLT_KB_FL06_OFF;1838 1839 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL06, d64);1840 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL07, d64);1841 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL08, d64);1842 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL09, d64);1843 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL10, d64);1844 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL11, d64);1845 1846 d64 = *((u64 *)&data[ICE_XLT_KB_FL12_IDD]) >> ICE_XLT_KB_FL12_OFF;1847 1848 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL12, d64);1849 entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL13, d64);1850 entry->flg0_14_sel[i] = FIELD_GET(ICE_XLT_KB_FL14, d64);1851 1852 entry->xlt1_md_sel = FIELD_GET(ICE_XLT_KB_X1MS, d64);1853 entry->xlt2_md_sel = FIELD_GET(ICE_XLT_KB_X2MS, d64);1854}1855 1856#define ICE_XLT_KB_X1PM_OFF 01857#define ICE_XLT_KB_X2PM_OFF 11858#define ICE_XLT_KB_PIPM_OFF 21859#define ICE_XLT_KB_FL15_OFF 41860#define ICE_XLT_KB_TBL_OFF 121861 1862/**1863 * ice_parse_kb_data - parse 204 bits of XLT Key Build Table1864 * @hw: pointer to the hardware structure1865 * @kb: pointer to the XLT Key Build Table structure1866 * @data: XLT Key Build Table data to be parsed1867 */1868static void ice_parse_kb_data(struct ice_hw *hw, struct ice_xlt_kb *kb,1869 void *data)1870{1871 u8 *buf = data;1872 int i;1873 1874 kb->xlt1_pm = buf[ICE_XLT_KB_X1PM_OFF];1875 kb->xlt2_pm = buf[ICE_XLT_KB_X2PM_OFF];1876 kb->prof_id_pm = buf[ICE_XLT_KB_PIPM_OFF];1877 1878 kb->flag15 = *(u64 *)&buf[ICE_XLT_KB_FL15_OFF];1879 for (i = 0; i < ICE_XLT_KB_TBL_CNT; i++)1880 ice_kb_entry_init(&kb->entries[i],1881 &buf[ICE_XLT_KB_TBL_OFF +1882 i * ICE_XLT_KB_TBL_ENTRY_SIZE]);1883 1884 if (hw->debug_mask & ICE_DBG_PARSER)1885 ice_xlt_kb_dump(hw, kb);1886}1887 1888static struct ice_xlt_kb *ice_xlt_kb_get(struct ice_hw *hw, u32 sect_type)1889{1890 struct ice_pkg_enum state = {};1891 struct ice_seg *seg = hw->seg;1892 struct ice_xlt_kb *kb;1893 void *data;1894 1895 if (!seg)1896 return ERR_PTR(-EINVAL);1897 1898 kb = kzalloc(sizeof(*kb), GFP_KERNEL);1899 if (!kb)1900 return ERR_PTR(-ENOMEM);1901 1902 data = ice_pkg_enum_section(seg, &state, sect_type);1903 if (!data) {1904 ice_debug(hw, ICE_DBG_PARSER, "failed to find section type %d.\n",1905 sect_type);1906 kfree(kb);1907 return ERR_PTR(-EINVAL);1908 }1909 1910 ice_parse_kb_data(hw, kb, data);1911 1912 return kb;1913}1914 1915/**1916 * ice_xlt_kb_get_sw - create switch xlt key build1917 * @hw: pointer to the hardware structure1918 *1919 * Return: a pointer to the allocated Key Builder table for Switch.1920 */1921static struct ice_xlt_kb *ice_xlt_kb_get_sw(struct ice_hw *hw)1922{1923 return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_SW);1924}1925 1926/**1927 * ice_xlt_kb_get_acl - create acl xlt key build1928 * @hw: pointer to the hardware structure1929 *1930 * Return: a pointer to the allocated Key Builder table for ACL.1931 */1932static struct ice_xlt_kb *ice_xlt_kb_get_acl(struct ice_hw *hw)1933{1934 return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_ACL);1935}1936 1937/**1938 * ice_xlt_kb_get_fd - create fdir xlt key build1939 * @hw: pointer to the hardware structure1940 *1941 * Return: a pointer to the allocated Key Builder table for Flow Director.1942 */1943static struct ice_xlt_kb *ice_xlt_kb_get_fd(struct ice_hw *hw)1944{1945 return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_FD);1946}1947 1948/**1949 * ice_xlt_kb_get_rss - create rss xlt key build1950 * @hw: pointer to the hardware structure1951 *1952 * Return: a pointer to the allocated Key Builder table for RSS.1953 */1954static struct ice_xlt_kb *ice_xlt_kb_get_rss(struct ice_hw *hw)1955{1956 return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_RSS);1957}1958 1959#define ICE_XLT_KB_MASK GENMASK_ULL(5, 0)1960 1961/**1962 * ice_xlt_kb_flag_get - aggregate 64 bits packet flag into 16 bits xlt flag1963 * @kb: xlt key build1964 * @pkt_flag: 64 bits packet flag1965 *1966 * Return: XLT flag or 0 if @pkt_flag = 0.1967 */1968u16 ice_xlt_kb_flag_get(struct ice_xlt_kb *kb, u64 pkt_flag)1969{1970 struct ice_xlt_kb_entry *entry = &kb->entries[0];1971 u16 flag = 0;1972 int i;1973 1974 /* check flag 15 */1975 if (kb->flag15 & pkt_flag)1976 flag = BIT(ICE_XLT_KB_FLAG0_14_CNT);1977 1978 /* check flag 0 - 14 */1979 for (i = 0; i < ICE_XLT_KB_FLAG0_14_CNT; i++) {1980 /* only check first entry */1981 u16 idx = entry->flg0_14_sel[i] & ICE_XLT_KB_MASK;1982 1983 if (pkt_flag & BIT(idx))1984 flag |= (u16)BIT(i);1985 }1986 1987 return flag;1988}1989 1990/*** Parser API ***/1991/**1992 * ice_parser_create - create a parser instance1993 * @hw: pointer to the hardware structure1994 *1995 * Return: a pointer to the allocated parser instance or ERR_PTR1996 * in case of error.1997 */1998struct ice_parser *ice_parser_create(struct ice_hw *hw)1999{2000 struct ice_parser *p;2001 void *err;2002 2003 p = kzalloc(sizeof(*p), GFP_KERNEL);2004 if (!p)2005 return ERR_PTR(-ENOMEM);2006 2007 p->hw = hw;2008 p->rt.psr = p;2009 2010 p->imem_table = ice_imem_table_get(hw);2011 if (IS_ERR(p->imem_table)) {2012 err = p->imem_table;2013 goto err;2014 }2015 2016 p->mi_table = ice_metainit_table_get(hw);2017 if (IS_ERR(p->mi_table)) {2018 err = p->mi_table;2019 goto err;2020 }2021 2022 p->pg_cam_table = ice_pg_cam_table_get(hw);2023 if (IS_ERR(p->pg_cam_table)) {2024 err = p->pg_cam_table;2025 goto err;2026 }2027 2028 p->pg_sp_cam_table = ice_pg_sp_cam_table_get(hw);2029 if (IS_ERR(p->pg_sp_cam_table)) {2030 err = p->pg_sp_cam_table;2031 goto err;2032 }2033 2034 p->pg_nm_cam_table = ice_pg_nm_cam_table_get(hw);2035 if (IS_ERR(p->pg_nm_cam_table)) {2036 err = p->pg_nm_cam_table;2037 goto err;2038 }2039 2040 p->pg_nm_sp_cam_table = ice_pg_nm_sp_cam_table_get(hw);2041 if (IS_ERR(p->pg_nm_sp_cam_table)) {2042 err = p->pg_nm_sp_cam_table;2043 goto err;2044 }2045 2046 p->bst_tcam_table = ice_bst_tcam_table_get(hw);2047 if (IS_ERR(p->bst_tcam_table)) {2048 err = p->bst_tcam_table;2049 goto err;2050 }2051 2052 p->bst_lbl_table = ice_bst_lbl_table_get(hw);2053 if (IS_ERR(p->bst_lbl_table)) {2054 err = p->bst_lbl_table;2055 goto err;2056 }2057 2058 p->ptype_mk_tcam_table = ice_ptype_mk_tcam_table_get(hw);2059 if (IS_ERR(p->ptype_mk_tcam_table)) {2060 err = p->ptype_mk_tcam_table;2061 goto err;2062 }2063 2064 p->mk_grp_table = ice_mk_grp_table_get(hw);2065 if (IS_ERR(p->mk_grp_table)) {2066 err = p->mk_grp_table;2067 goto err;2068 }2069 2070 p->proto_grp_table = ice_proto_grp_table_get(hw);2071 if (IS_ERR(p->proto_grp_table)) {2072 err = p->proto_grp_table;2073 goto err;2074 }2075 2076 p->flg_rd_table = ice_flg_rd_table_get(hw);2077 if (IS_ERR(p->flg_rd_table)) {2078 err = p->flg_rd_table;2079 goto err;2080 }2081 2082 p->xlt_kb_sw = ice_xlt_kb_get_sw(hw);2083 if (IS_ERR(p->xlt_kb_sw)) {2084 err = p->xlt_kb_sw;2085 goto err;2086 }2087 2088 p->xlt_kb_acl = ice_xlt_kb_get_acl(hw);2089 if (IS_ERR(p->xlt_kb_acl)) {2090 err = p->xlt_kb_acl;2091 goto err;2092 }2093 2094 p->xlt_kb_fd = ice_xlt_kb_get_fd(hw);2095 if (IS_ERR(p->xlt_kb_fd)) {2096 err = p->xlt_kb_fd;2097 goto err;2098 }2099 2100 p->xlt_kb_rss = ice_xlt_kb_get_rss(hw);2101 if (IS_ERR(p->xlt_kb_rss)) {2102 err = p->xlt_kb_rss;2103 goto err;2104 }2105 2106 return p;2107err:2108 ice_parser_destroy(p);2109 return err;2110}2111 2112/**2113 * ice_parser_destroy - destroy a parser instance2114 * @psr: pointer to a parser instance2115 */2116void ice_parser_destroy(struct ice_parser *psr)2117{2118 kfree(psr->imem_table);2119 kfree(psr->mi_table);2120 kfree(psr->pg_cam_table);2121 kfree(psr->pg_sp_cam_table);2122 kfree(psr->pg_nm_cam_table);2123 kfree(psr->pg_nm_sp_cam_table);2124 kfree(psr->bst_tcam_table);2125 kfree(psr->bst_lbl_table);2126 kfree(psr->ptype_mk_tcam_table);2127 kfree(psr->mk_grp_table);2128 kfree(psr->proto_grp_table);2129 kfree(psr->flg_rd_table);2130 kfree(psr->xlt_kb_sw);2131 kfree(psr->xlt_kb_acl);2132 kfree(psr->xlt_kb_fd);2133 kfree(psr->xlt_kb_rss);2134 2135 kfree(psr);2136}2137 2138/**2139 * ice_parser_run - parse on a packet in binary and return the result2140 * @psr: pointer to a parser instance2141 * @pkt_buf: packet data2142 * @pkt_len: packet length2143 * @rslt: input/output parameter to save parser result.2144 *2145 * Return: 0 on success or errno.2146 */2147int ice_parser_run(struct ice_parser *psr, const u8 *pkt_buf,2148 int pkt_len, struct ice_parser_result *rslt)2149{2150 ice_parser_rt_reset(&psr->rt);2151 ice_parser_rt_pktbuf_set(&psr->rt, pkt_buf, pkt_len);2152 2153 return ice_parser_rt_execute(&psr->rt, rslt);2154}2155 2156/**2157 * ice_parser_result_dump - dump a parser result info2158 * @hw: pointer to the hardware structure2159 * @rslt: parser result info to dump2160 */2161void ice_parser_result_dump(struct ice_hw *hw, struct ice_parser_result *rslt)2162{2163 struct device *dev = ice_hw_to_dev(hw);2164 int i;2165 2166 dev_info(dev, "ptype = %d\n", rslt->ptype);2167 for (i = 0; i < rslt->po_num; i++)2168 dev_info(dev, "proto = %d, offset = %d\n",2169 rslt->po[i].proto_id, rslt->po[i].offset);2170 2171 dev_info(dev, "flags_psr = 0x%016llx\n", rslt->flags_psr);2172 dev_info(dev, "flags_pkt = 0x%016llx\n", rslt->flags_pkt);2173 dev_info(dev, "flags_sw = 0x%04x\n", rslt->flags_sw);2174 dev_info(dev, "flags_fd = 0x%04x\n", rslt->flags_fd);2175 dev_info(dev, "flags_rss = 0x%04x\n", rslt->flags_rss);2176}2177 2178#define ICE_BT_VLD_KEY 0xFF2179#define ICE_BT_INV_KEY 0xFE2180 2181static void ice_bst_dvm_set(struct ice_parser *psr, enum ice_lbl_type type,2182 bool on)2183{2184 u16 i = 0;2185 2186 while (true) {2187 struct ice_bst_tcam_item *item;2188 u8 key;2189 2190 item = ice_bst_tcam_search(psr->bst_tcam_table,2191 psr->bst_lbl_table,2192 type, &i);2193 if (!item)2194 break;2195 2196 key = on ? ICE_BT_VLD_KEY : ICE_BT_INV_KEY;2197 item->key[ICE_BT_VM_OFF] = key;2198 item->key_inv[ICE_BT_VM_OFF] = key;2199 i++;2200 }2201}2202 2203/**2204 * ice_parser_dvm_set - configure double vlan mode for parser2205 * @psr: pointer to a parser instance2206 * @on: true to turn on; false to turn off2207 */2208void ice_parser_dvm_set(struct ice_parser *psr, bool on)2209{2210 ice_bst_dvm_set(psr, ICE_LBL_BST_TYPE_DVM, on);2211 ice_bst_dvm_set(psr, ICE_LBL_BST_TYPE_SVM, !on);2212}2213 2214static int ice_tunnel_port_set(struct ice_parser *psr, enum ice_lbl_type type,2215 u16 udp_port, bool on)2216{2217 u8 *buf = (u8 *)&udp_port;2218 u16 i = 0;2219 2220 while (true) {2221 struct ice_bst_tcam_item *item;2222 2223 item = ice_bst_tcam_search(psr->bst_tcam_table,2224 psr->bst_lbl_table,2225 type, &i);2226 if (!item)2227 break;2228 2229 /* found empty slot to add */2230 if (on && item->key[ICE_BT_TUN_PORT_OFF_H] == ICE_BT_INV_KEY &&2231 item->key_inv[ICE_BT_TUN_PORT_OFF_H] == ICE_BT_INV_KEY) {2232 item->key_inv[ICE_BT_TUN_PORT_OFF_L] =2233 buf[ICE_UDP_PORT_OFF_L];2234 item->key_inv[ICE_BT_TUN_PORT_OFF_H] =2235 buf[ICE_UDP_PORT_OFF_H];2236 2237 item->key[ICE_BT_TUN_PORT_OFF_L] =2238 ICE_BT_VLD_KEY - buf[ICE_UDP_PORT_OFF_L];2239 item->key[ICE_BT_TUN_PORT_OFF_H] =2240 ICE_BT_VLD_KEY - buf[ICE_UDP_PORT_OFF_H];2241 2242 return 0;2243 /* found a matched slot to delete */2244 } else if (!on &&2245 (item->key_inv[ICE_BT_TUN_PORT_OFF_L] ==2246 buf[ICE_UDP_PORT_OFF_L] ||2247 item->key_inv[ICE_BT_TUN_PORT_OFF_H] ==2248 buf[ICE_UDP_PORT_OFF_H])) {2249 item->key_inv[ICE_BT_TUN_PORT_OFF_L] = ICE_BT_VLD_KEY;2250 item->key_inv[ICE_BT_TUN_PORT_OFF_H] = ICE_BT_INV_KEY;2251 2252 item->key[ICE_BT_TUN_PORT_OFF_L] = ICE_BT_VLD_KEY;2253 item->key[ICE_BT_TUN_PORT_OFF_H] = ICE_BT_INV_KEY;2254 2255 return 0;2256 }2257 i++;2258 }2259 2260 return -EINVAL;2261}2262 2263/**2264 * ice_parser_vxlan_tunnel_set - configure vxlan tunnel for parser2265 * @psr: pointer to a parser instance2266 * @udp_port: vxlan tunnel port in UDP header2267 * @on: true to turn on; false to turn off2268 *2269 * Return: 0 on success or errno on failure.2270 */2271int ice_parser_vxlan_tunnel_set(struct ice_parser *psr,2272 u16 udp_port, bool on)2273{2274 return ice_tunnel_port_set(psr, ICE_LBL_BST_TYPE_VXLAN, udp_port, on);2275}2276 2277/**2278 * ice_parser_geneve_tunnel_set - configure geneve tunnel for parser2279 * @psr: pointer to a parser instance2280 * @udp_port: geneve tunnel port in UDP header2281 * @on: true to turn on; false to turn off2282 *2283 * Return: 0 on success or errno on failure.2284 */2285int ice_parser_geneve_tunnel_set(struct ice_parser *psr,2286 u16 udp_port, bool on)2287{2288 return ice_tunnel_port_set(psr, ICE_LBL_BST_TYPE_GENEVE, udp_port, on);2289}2290 2291/**2292 * ice_parser_ecpri_tunnel_set - configure ecpri tunnel for parser2293 * @psr: pointer to a parser instance2294 * @udp_port: ecpri tunnel port in UDP header2295 * @on: true to turn on; false to turn off2296 *2297 * Return: 0 on success or errno on failure.2298 */2299int ice_parser_ecpri_tunnel_set(struct ice_parser *psr,2300 u16 udp_port, bool on)2301{2302 return ice_tunnel_port_set(psr, ICE_LBL_BST_TYPE_UDP_ECPRI,2303 udp_port, on);2304}2305 2306/**2307 * ice_nearest_proto_id - find nearest protocol ID2308 * @rslt: pointer to a parser result instance2309 * @offset: a min value for the protocol offset2310 * @proto_id: the protocol ID (output)2311 * @proto_off: the protocol offset (output)2312 *2313 * From the protocols in @rslt, find the nearest protocol that has offset2314 * larger than @offset.2315 *2316 * Return: if true, the protocol's ID and offset2317 */2318static bool ice_nearest_proto_id(struct ice_parser_result *rslt, u16 offset,2319 u8 *proto_id, u16 *proto_off)2320{2321 u16 dist = U16_MAX;2322 u8 proto = 0;2323 int i;2324 2325 for (i = 0; i < rslt->po_num; i++) {2326 if (offset < rslt->po[i].offset)2327 continue;2328 if (offset - rslt->po[i].offset < dist) {2329 proto = rslt->po[i].proto_id;2330 dist = offset - rslt->po[i].offset;2331 }2332 }2333 2334 if (dist % 2)2335 return false;2336 2337 *proto_id = proto;2338 *proto_off = dist;2339 2340 return true;2341}2342 2343/* default flag mask to cover GTP_EH_PDU, GTP_EH_PDU_LINK and TUN22344 * In future, the flag masks should learn from DDP2345 */2346#define ICE_KEYBUILD_FLAG_MASK_DEFAULT_SW 0x40022347#define ICE_KEYBUILD_FLAG_MASK_DEFAULT_ACL 0x00002348#define ICE_KEYBUILD_FLAG_MASK_DEFAULT_FD 0x60802349#define ICE_KEYBUILD_FLAG_MASK_DEFAULT_RSS 0x60102350 2351/**2352 * ice_parser_profile_init - initialize a FXP profile based on parser result2353 * @rslt: a instance of a parser result2354 * @pkt_buf: packet data buffer2355 * @msk_buf: packet mask buffer2356 * @buf_len: packet length2357 * @blk: FXP pipeline stage2358 * @prof: input/output parameter to save the profile2359 *2360 * Return: 0 on success or errno on failure.2361 */2362int ice_parser_profile_init(struct ice_parser_result *rslt,2363 const u8 *pkt_buf, const u8 *msk_buf,2364 int buf_len, enum ice_block blk,2365 struct ice_parser_profile *prof)2366{2367 u8 proto_id = U8_MAX;2368 u16 proto_off = 0;2369 u16 off;2370 2371 memset(prof, 0, sizeof(*prof));2372 set_bit(rslt->ptype, prof->ptypes);2373 if (blk == ICE_BLK_SW) {2374 prof->flags = rslt->flags_sw;2375 prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_SW;2376 } else if (blk == ICE_BLK_ACL) {2377 prof->flags = rslt->flags_acl;2378 prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_ACL;2379 } else if (blk == ICE_BLK_FD) {2380 prof->flags = rslt->flags_fd;2381 prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_FD;2382 } else if (blk == ICE_BLK_RSS) {2383 prof->flags = rslt->flags_rss;2384 prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_RSS;2385 } else {2386 return -EINVAL;2387 }2388 2389 for (off = 0; off < buf_len - 1; off++) {2390 if (msk_buf[off] == 0 && msk_buf[off + 1] == 0)2391 continue;2392 if (!ice_nearest_proto_id(rslt, off, &proto_id, &proto_off))2393 continue;2394 if (prof->fv_num >= ICE_PARSER_FV_MAX)2395 return -EINVAL;2396 2397 prof->fv[prof->fv_num].proto_id = proto_id;2398 prof->fv[prof->fv_num].offset = proto_off;2399 prof->fv[prof->fv_num].spec = *(const u16 *)&pkt_buf[off];2400 prof->fv[prof->fv_num].msk = *(const u16 *)&msk_buf[off];2401 prof->fv_num++;2402 }2403 2404 return 0;2405}2406 2407/**2408 * ice_parser_profile_dump - dump an FXP profile info2409 * @hw: pointer to the hardware structure2410 * @prof: profile info to dump2411 */2412void ice_parser_profile_dump(struct ice_hw *hw,2413 struct ice_parser_profile *prof)2414{2415 struct device *dev = ice_hw_to_dev(hw);2416 u16 i;2417 2418 dev_info(dev, "ptypes:\n");2419 for (i = 0; i < ICE_FLOW_PTYPE_MAX; i++)2420 if (test_bit(i, prof->ptypes))2421 dev_info(dev, "\t%u\n", i);2422 2423 for (i = 0; i < prof->fv_num; i++)2424 dev_info(dev, "proto = %u, offset = %2u, spec = 0x%04x, mask = 0x%04x\n",2425 prof->fv[i].proto_id, prof->fv[i].offset,2426 prof->fv[i].spec, prof->fv[i].msk);2427 2428 dev_info(dev, "flags = 0x%04x\n", prof->flags);2429 dev_info(dev, "flags_msk = 0x%04x\n", prof->flags_msk);2430}2431