| // SPDX-License-Identifier: GPL-2.0 | |
| /* Copyright (C) 2024 Intel Corporation */ | |
| #include "ice_common.h" | |
| struct ice_pkg_sect_hdr { | |
| __le16 count; | |
| __le16 offset; | |
| }; | |
| /** | |
| * ice_parser_sect_item_get - parse an item from a section | |
| * @sect_type: section type | |
| * @section: section object | |
| * @index: index of the item to get | |
| * @offset: dummy as prototype of ice_pkg_enum_entry's last parameter | |
| * | |
| * Return: a pointer to the item or NULL. | |
| */ | |
| static void *ice_parser_sect_item_get(u32 sect_type, void *section, | |
| u32 index, u32 __maybe_unused *offset) | |
| { | |
| size_t data_off = ICE_SEC_DATA_OFFSET; | |
| struct ice_pkg_sect_hdr *hdr; | |
| size_t size; | |
| if (!section) | |
| return NULL; | |
| switch (sect_type) { | |
| case ICE_SID_RXPARSER_IMEM: | |
| size = ICE_SID_RXPARSER_IMEM_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_METADATA_INIT: | |
| size = ICE_SID_RXPARSER_METADATA_INIT_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_CAM: | |
| size = ICE_SID_RXPARSER_CAM_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_PG_SPILL: | |
| size = ICE_SID_RXPARSER_PG_SPILL_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_NOMATCH_CAM: | |
| size = ICE_SID_RXPARSER_NOMATCH_CAM_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_NOMATCH_SPILL: | |
| size = ICE_SID_RXPARSER_NOMATCH_SPILL_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_BOOST_TCAM: | |
| size = ICE_SID_RXPARSER_BOOST_TCAM_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_LBL_RXPARSER_TMEM: | |
| data_off = ICE_SEC_LBL_DATA_OFFSET; | |
| size = ICE_SID_LBL_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_MARKER_PTYPE: | |
| size = ICE_SID_RXPARSER_MARKER_TYPE_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_MARKER_GRP: | |
| size = ICE_SID_RXPARSER_MARKER_GRP_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_PROTO_GRP: | |
| size = ICE_SID_RXPARSER_PROTO_GRP_ENTRY_SIZE; | |
| break; | |
| case ICE_SID_RXPARSER_FLAG_REDIR: | |
| size = ICE_SID_RXPARSER_FLAG_REDIR_ENTRY_SIZE; | |
| break; | |
| default: | |
| return NULL; | |
| } | |
| hdr = section; | |
| if (index >= le16_to_cpu(hdr->count)) | |
| return NULL; | |
| return section + data_off + index * size; | |
| } | |
| /** | |
| * ice_parser_create_table - create an item table from a section | |
| * @hw: pointer to the hardware structure | |
| * @sect_type: section type | |
| * @item_size: item size in bytes | |
| * @length: number of items in the table to create | |
| * @parse_item: the function to parse the item | |
| * @no_offset: ignore header offset, calculate index from 0 | |
| * | |
| * Return: a pointer to the allocated table or ERR_PTR. | |
| */ | |
| static void * | |
| ice_parser_create_table(struct ice_hw *hw, u32 sect_type, | |
| u32 item_size, u32 length, | |
| void (*parse_item)(struct ice_hw *hw, u16 idx, | |
| void *item, void *data, | |
| int size), bool no_offset) | |
| { | |
| struct ice_pkg_enum state = {}; | |
| struct ice_seg *seg = hw->seg; | |
| void *table, *data, *item; | |
| u16 idx = 0; | |
| if (!seg) | |
| return ERR_PTR(-EINVAL); | |
| table = kzalloc(item_size * length, GFP_KERNEL); | |
| if (!table) | |
| return ERR_PTR(-ENOMEM); | |
| do { | |
| data = ice_pkg_enum_entry(seg, &state, sect_type, NULL, | |
| ice_parser_sect_item_get); | |
| seg = NULL; | |
| if (data) { | |
| struct ice_pkg_sect_hdr *hdr = state.sect; | |
| if (!no_offset) | |
| idx = le16_to_cpu(hdr->offset) + | |
| state.entry_idx; | |
| item = (void *)((uintptr_t)table + idx * item_size); | |
| parse_item(hw, idx, item, data, item_size); | |
| if (no_offset) | |
| idx++; | |
| } | |
| } while (data); | |
| return table; | |
| } | |
| /*** ICE_SID_RXPARSER_IMEM section ***/ | |
| static void ice_imem_bst_bm_dump(struct ice_hw *hw, struct ice_bst_main *bm) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "boost main:\n"); | |
| dev_info(dev, "\talu0 = %d\n", bm->alu0); | |
| dev_info(dev, "\talu1 = %d\n", bm->alu1); | |
| dev_info(dev, "\talu2 = %d\n", bm->alu2); | |
| dev_info(dev, "\tpg = %d\n", bm->pg); | |
| } | |
| static void ice_imem_bst_kb_dump(struct ice_hw *hw, | |
| struct ice_bst_keybuilder *kb) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "boost key builder:\n"); | |
| dev_info(dev, "\tpriority = %d\n", kb->prio); | |
| dev_info(dev, "\ttsr_ctrl = %d\n", kb->tsr_ctrl); | |
| } | |
| static void ice_imem_np_kb_dump(struct ice_hw *hw, | |
| struct ice_np_keybuilder *kb) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "next proto key builder:\n"); | |
| dev_info(dev, "\topc = %d\n", kb->opc); | |
| dev_info(dev, "\tstart_or_reg0 = %d\n", kb->start_reg0); | |
| dev_info(dev, "\tlen_or_reg1 = %d\n", kb->len_reg1); | |
| } | |
| static void ice_imem_pg_kb_dump(struct ice_hw *hw, | |
| struct ice_pg_keybuilder *kb) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "parse graph key builder:\n"); | |
| dev_info(dev, "\tflag0_ena = %d\n", kb->flag0_ena); | |
| dev_info(dev, "\tflag1_ena = %d\n", kb->flag1_ena); | |
| dev_info(dev, "\tflag2_ena = %d\n", kb->flag2_ena); | |
| dev_info(dev, "\tflag3_ena = %d\n", kb->flag3_ena); | |
| dev_info(dev, "\tflag0_idx = %d\n", kb->flag0_idx); | |
| dev_info(dev, "\tflag1_idx = %d\n", kb->flag1_idx); | |
| dev_info(dev, "\tflag2_idx = %d\n", kb->flag2_idx); | |
| dev_info(dev, "\tflag3_idx = %d\n", kb->flag3_idx); | |
| dev_info(dev, "\talu_reg_idx = %d\n", kb->alu_reg_idx); | |
| } | |
| static void ice_imem_alu_dump(struct ice_hw *hw, | |
| struct ice_alu *alu, int index) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "alu%d:\n", index); | |
| dev_info(dev, "\topc = %d\n", alu->opc); | |
| dev_info(dev, "\tsrc_start = %d\n", alu->src_start); | |
| dev_info(dev, "\tsrc_len = %d\n", alu->src_len); | |
| dev_info(dev, "\tshift_xlate_sel = %d\n", alu->shift_xlate_sel); | |
| dev_info(dev, "\tshift_xlate_key = %d\n", alu->shift_xlate_key); | |
| dev_info(dev, "\tsrc_reg_id = %d\n", alu->src_reg_id); | |
| dev_info(dev, "\tdst_reg_id = %d\n", alu->dst_reg_id); | |
| dev_info(dev, "\tinc0 = %d\n", alu->inc0); | |
| dev_info(dev, "\tinc1 = %d\n", alu->inc1); | |
| dev_info(dev, "\tproto_offset_opc = %d\n", alu->proto_offset_opc); | |
| dev_info(dev, "\tproto_offset = %d\n", alu->proto_offset); | |
| dev_info(dev, "\tbranch_addr = %d\n", alu->branch_addr); | |
| dev_info(dev, "\timm = %d\n", alu->imm); | |
| dev_info(dev, "\tdst_start = %d\n", alu->dst_start); | |
| dev_info(dev, "\tdst_len = %d\n", alu->dst_len); | |
| dev_info(dev, "\tflags_extr_imm = %d\n", alu->flags_extr_imm); | |
| dev_info(dev, "\tflags_start_imm= %d\n", alu->flags_start_imm); | |
| } | |
| /** | |
| * ice_imem_dump - dump an imem item info | |
| * @hw: pointer to the hardware structure | |
| * @item: imem item to dump | |
| */ | |
| static void ice_imem_dump(struct ice_hw *hw, struct ice_imem_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "index = %d\n", item->idx); | |
| ice_imem_bst_bm_dump(hw, &item->b_m); | |
| ice_imem_bst_kb_dump(hw, &item->b_kb); | |
| dev_info(dev, "pg priority = %d\n", item->pg_prio); | |
| ice_imem_np_kb_dump(hw, &item->np_kb); | |
| ice_imem_pg_kb_dump(hw, &item->pg_kb); | |
| ice_imem_alu_dump(hw, &item->alu0, 0); | |
| ice_imem_alu_dump(hw, &item->alu1, 1); | |
| ice_imem_alu_dump(hw, &item->alu2, 2); | |
| } | |
| #define ICE_IM_BM_ALU0 BIT(0) | |
| #define ICE_IM_BM_ALU1 BIT(1) | |
| #define ICE_IM_BM_ALU2 BIT(2) | |
| #define ICE_IM_BM_PG BIT(3) | |
| /** | |
| * ice_imem_bm_init - parse 4 bits of Boost Main | |
| * @bm: pointer to the Boost Main structure | |
| * @data: Boost Main data to be parsed | |
| */ | |
| static void ice_imem_bm_init(struct ice_bst_main *bm, u8 data) | |
| { | |
| bm->alu0 = FIELD_GET(ICE_IM_BM_ALU0, data); | |
| bm->alu1 = FIELD_GET(ICE_IM_BM_ALU1, data); | |
| bm->alu2 = FIELD_GET(ICE_IM_BM_ALU2, data); | |
| bm->pg = FIELD_GET(ICE_IM_BM_PG, data); | |
| } | |
| #define ICE_IM_BKB_PRIO GENMASK(7, 0) | |
| #define ICE_IM_BKB_TSR_CTRL BIT(8) | |
| /** | |
| * ice_imem_bkb_init - parse 10 bits of Boost Main Build | |
| * @bkb: pointer to the Boost Main Build structure | |
| * @data: Boost Main Build data to be parsed | |
| */ | |
| static void ice_imem_bkb_init(struct ice_bst_keybuilder *bkb, u16 data) | |
| { | |
| bkb->prio = FIELD_GET(ICE_IM_BKB_PRIO, data); | |
| bkb->tsr_ctrl = FIELD_GET(ICE_IM_BKB_TSR_CTRL, data); | |
| } | |
| #define ICE_IM_NPKB_OPC GENMASK(1, 0) | |
| #define ICE_IM_NPKB_S_R0 GENMASK(9, 2) | |
| #define ICE_IM_NPKB_L_R1 GENMASK(17, 10) | |
| /** | |
| * ice_imem_npkb_init - parse 18 bits of Next Protocol Key Build | |
| * @kb: pointer to the Next Protocol Key Build structure | |
| * @data: Next Protocol Key Build data to be parsed | |
| */ | |
| static void ice_imem_npkb_init(struct ice_np_keybuilder *kb, u32 data) | |
| { | |
| kb->opc = FIELD_GET(ICE_IM_NPKB_OPC, data); | |
| kb->start_reg0 = FIELD_GET(ICE_IM_NPKB_S_R0, data); | |
| kb->len_reg1 = FIELD_GET(ICE_IM_NPKB_L_R1, data); | |
| } | |
| #define ICE_IM_PGKB_F0_ENA BIT_ULL(0) | |
| #define ICE_IM_PGKB_F0_IDX GENMASK_ULL(6, 1) | |
| #define ICE_IM_PGKB_F1_ENA BIT_ULL(7) | |
| #define ICE_IM_PGKB_F1_IDX GENMASK_ULL(13, 8) | |
| #define ICE_IM_PGKB_F2_ENA BIT_ULL(14) | |
| #define ICE_IM_PGKB_F2_IDX GENMASK_ULL(20, 15) | |
| #define ICE_IM_PGKB_F3_ENA BIT_ULL(21) | |
| #define ICE_IM_PGKB_F3_IDX GENMASK_ULL(27, 22) | |
| #define ICE_IM_PGKB_AR_IDX GENMASK_ULL(34, 28) | |
| /** | |
| * ice_imem_pgkb_init - parse 35 bits of Parse Graph Key Build | |
| * @kb: pointer to the Parse Graph Key Build structure | |
| * @data: Parse Graph Key Build data to be parsed | |
| */ | |
| static void ice_imem_pgkb_init(struct ice_pg_keybuilder *kb, u64 data) | |
| { | |
| kb->flag0_ena = FIELD_GET(ICE_IM_PGKB_F0_ENA, data); | |
| kb->flag0_idx = FIELD_GET(ICE_IM_PGKB_F0_IDX, data); | |
| kb->flag1_ena = FIELD_GET(ICE_IM_PGKB_F1_ENA, data); | |
| kb->flag1_idx = FIELD_GET(ICE_IM_PGKB_F1_IDX, data); | |
| kb->flag2_ena = FIELD_GET(ICE_IM_PGKB_F2_ENA, data); | |
| kb->flag2_idx = FIELD_GET(ICE_IM_PGKB_F2_IDX, data); | |
| kb->flag3_ena = FIELD_GET(ICE_IM_PGKB_F3_ENA, data); | |
| kb->flag3_idx = FIELD_GET(ICE_IM_PGKB_F3_IDX, data); | |
| kb->alu_reg_idx = FIELD_GET(ICE_IM_PGKB_AR_IDX, data); | |
| } | |
| #define ICE_IM_ALU_OPC GENMASK_ULL(5, 0) | |
| #define ICE_IM_ALU_SS GENMASK_ULL(13, 6) | |
| #define ICE_IM_ALU_SL GENMASK_ULL(18, 14) | |
| #define ICE_IM_ALU_SXS BIT_ULL(19) | |
| #define ICE_IM_ALU_SXK GENMASK_ULL(23, 20) | |
| #define ICE_IM_ALU_SRID GENMASK_ULL(30, 24) | |
| #define ICE_IM_ALU_DRID GENMASK_ULL(37, 31) | |
| #define ICE_IM_ALU_INC0 BIT_ULL(38) | |
| #define ICE_IM_ALU_INC1 BIT_ULL(39) | |
| #define ICE_IM_ALU_POO GENMASK_ULL(41, 40) | |
| #define ICE_IM_ALU_PO GENMASK_ULL(49, 42) | |
| #define ICE_IM_ALU_BA_S 50 /* offset for the 2nd 64-bits field */ | |
| #define ICE_IM_ALU_BA GENMASK_ULL(57 - ICE_IM_ALU_BA_S, \ | |
| 50 - ICE_IM_ALU_BA_S) | |
| #define ICE_IM_ALU_IMM GENMASK_ULL(73 - ICE_IM_ALU_BA_S, \ | |
| 58 - ICE_IM_ALU_BA_S) | |
| #define ICE_IM_ALU_DFE BIT_ULL(74 - ICE_IM_ALU_BA_S) | |
| #define ICE_IM_ALU_DS GENMASK_ULL(80 - ICE_IM_ALU_BA_S, \ | |
| 75 - ICE_IM_ALU_BA_S) | |
| #define ICE_IM_ALU_DL GENMASK_ULL(86 - ICE_IM_ALU_BA_S, \ | |
| 81 - ICE_IM_ALU_BA_S) | |
| #define ICE_IM_ALU_FEI BIT_ULL(87 - ICE_IM_ALU_BA_S) | |
| #define ICE_IM_ALU_FSI GENMASK_ULL(95 - ICE_IM_ALU_BA_S, \ | |
| 88 - ICE_IM_ALU_BA_S) | |
| /** | |
| * ice_imem_alu_init - parse 96 bits of ALU entry | |
| * @alu: pointer to the ALU entry structure | |
| * @data: ALU entry data to be parsed | |
| * @off: offset of the ALU entry data | |
| */ | |
| static void ice_imem_alu_init(struct ice_alu *alu, u8 *data, u8 off) | |
| { | |
| u64 d64; | |
| u8 idd; | |
| d64 = *((u64 *)data) >> off; | |
| alu->opc = FIELD_GET(ICE_IM_ALU_OPC, d64); | |
| alu->src_start = FIELD_GET(ICE_IM_ALU_SS, d64); | |
| alu->src_len = FIELD_GET(ICE_IM_ALU_SL, d64); | |
| alu->shift_xlate_sel = FIELD_GET(ICE_IM_ALU_SXS, d64); | |
| alu->shift_xlate_key = FIELD_GET(ICE_IM_ALU_SXK, d64); | |
| alu->src_reg_id = FIELD_GET(ICE_IM_ALU_SRID, d64); | |
| alu->dst_reg_id = FIELD_GET(ICE_IM_ALU_DRID, d64); | |
| alu->inc0 = FIELD_GET(ICE_IM_ALU_INC0, d64); | |
| alu->inc1 = FIELD_GET(ICE_IM_ALU_INC1, d64); | |
| alu->proto_offset_opc = FIELD_GET(ICE_IM_ALU_POO, d64); | |
| alu->proto_offset = FIELD_GET(ICE_IM_ALU_PO, d64); | |
| idd = (ICE_IM_ALU_BA_S + off) / BITS_PER_BYTE; | |
| off = (ICE_IM_ALU_BA_S + off) % BITS_PER_BYTE; | |
| d64 = *((u64 *)(&data[idd])) >> off; | |
| alu->branch_addr = FIELD_GET(ICE_IM_ALU_BA, d64); | |
| alu->imm = FIELD_GET(ICE_IM_ALU_IMM, d64); | |
| alu->dedicate_flags_ena = FIELD_GET(ICE_IM_ALU_DFE, d64); | |
| alu->dst_start = FIELD_GET(ICE_IM_ALU_DS, d64); | |
| alu->dst_len = FIELD_GET(ICE_IM_ALU_DL, d64); | |
| alu->flags_extr_imm = FIELD_GET(ICE_IM_ALU_FEI, d64); | |
| alu->flags_start_imm = FIELD_GET(ICE_IM_ALU_FSI, d64); | |
| } | |
| #define ICE_IMEM_BM_S 0 | |
| #define ICE_IMEM_BKB_S 4 | |
| #define ICE_IMEM_BKB_IDD (ICE_IMEM_BKB_S / BITS_PER_BYTE) | |
| #define ICE_IMEM_BKB_OFF (ICE_IMEM_BKB_S % BITS_PER_BYTE) | |
| #define ICE_IMEM_PGP GENMASK(15, 14) | |
| #define ICE_IMEM_NPKB_S 16 | |
| #define ICE_IMEM_NPKB_IDD (ICE_IMEM_NPKB_S / BITS_PER_BYTE) | |
| #define ICE_IMEM_NPKB_OFF (ICE_IMEM_NPKB_S % BITS_PER_BYTE) | |
| #define ICE_IMEM_PGKB_S 34 | |
| #define ICE_IMEM_PGKB_IDD (ICE_IMEM_PGKB_S / BITS_PER_BYTE) | |
| #define ICE_IMEM_PGKB_OFF (ICE_IMEM_PGKB_S % BITS_PER_BYTE) | |
| #define ICE_IMEM_ALU0_S 69 | |
| #define ICE_IMEM_ALU0_IDD (ICE_IMEM_ALU0_S / BITS_PER_BYTE) | |
| #define ICE_IMEM_ALU0_OFF (ICE_IMEM_ALU0_S % BITS_PER_BYTE) | |
| #define ICE_IMEM_ALU1_S 165 | |
| #define ICE_IMEM_ALU1_IDD (ICE_IMEM_ALU1_S / BITS_PER_BYTE) | |
| #define ICE_IMEM_ALU1_OFF (ICE_IMEM_ALU1_S % BITS_PER_BYTE) | |
| #define ICE_IMEM_ALU2_S 357 | |
| #define ICE_IMEM_ALU2_IDD (ICE_IMEM_ALU2_S / BITS_PER_BYTE) | |
| #define ICE_IMEM_ALU2_OFF (ICE_IMEM_ALU2_S % BITS_PER_BYTE) | |
| /** | |
| * ice_imem_parse_item - parse 384 bits of IMEM entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of IMEM entry | |
| * @item: item of IMEM entry | |
| * @data: IMEM entry data to be parsed | |
| * @size: size of IMEM entry | |
| */ | |
| static void ice_imem_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_imem_item *ii = item; | |
| u8 *buf = data; | |
| ii->idx = idx; | |
| ice_imem_bm_init(&ii->b_m, *(u8 *)buf); | |
| ice_imem_bkb_init(&ii->b_kb, | |
| *((u16 *)(&buf[ICE_IMEM_BKB_IDD])) >> | |
| ICE_IMEM_BKB_OFF); | |
| ii->pg_prio = FIELD_GET(ICE_IMEM_PGP, *(u16 *)buf); | |
| ice_imem_npkb_init(&ii->np_kb, | |
| *((u32 *)(&buf[ICE_IMEM_NPKB_IDD])) >> | |
| ICE_IMEM_NPKB_OFF); | |
| ice_imem_pgkb_init(&ii->pg_kb, | |
| *((u64 *)(&buf[ICE_IMEM_PGKB_IDD])) >> | |
| ICE_IMEM_PGKB_OFF); | |
| ice_imem_alu_init(&ii->alu0, | |
| &buf[ICE_IMEM_ALU0_IDD], | |
| ICE_IMEM_ALU0_OFF); | |
| ice_imem_alu_init(&ii->alu1, | |
| &buf[ICE_IMEM_ALU1_IDD], | |
| ICE_IMEM_ALU1_OFF); | |
| ice_imem_alu_init(&ii->alu2, | |
| &buf[ICE_IMEM_ALU2_IDD], | |
| ICE_IMEM_ALU2_OFF); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_imem_dump(hw, ii); | |
| } | |
| /** | |
| * ice_imem_table_get - create an imem table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated IMEM table. | |
| */ | |
| static struct ice_imem_item *ice_imem_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_IMEM, | |
| sizeof(struct ice_imem_item), | |
| ICE_IMEM_TABLE_SIZE, | |
| ice_imem_parse_item, false); | |
| } | |
| /*** ICE_SID_RXPARSER_METADATA_INIT section ***/ | |
| /** | |
| * ice_metainit_dump - dump an metainit item info | |
| * @hw: pointer to the hardware structure | |
| * @item: metainit item to dump | |
| */ | |
| static void ice_metainit_dump(struct ice_hw *hw, struct ice_metainit_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "index = %d\n", item->idx); | |
| dev_info(dev, "tsr = %d\n", item->tsr); | |
| dev_info(dev, "ho = %d\n", item->ho); | |
| dev_info(dev, "pc = %d\n", item->pc); | |
| dev_info(dev, "pg_rn = %d\n", item->pg_rn); | |
| dev_info(dev, "cd = %d\n", item->cd); | |
| dev_info(dev, "gpr_a_ctrl = %d\n", item->gpr_a_ctrl); | |
| dev_info(dev, "gpr_a_data_mdid = %d\n", item->gpr_a_data_mdid); | |
| dev_info(dev, "gpr_a_data_start = %d\n", item->gpr_a_data_start); | |
| dev_info(dev, "gpr_a_data_len = %d\n", item->gpr_a_data_len); | |
| dev_info(dev, "gpr_a_id = %d\n", item->gpr_a_id); | |
| dev_info(dev, "gpr_b_ctrl = %d\n", item->gpr_b_ctrl); | |
| dev_info(dev, "gpr_b_data_mdid = %d\n", item->gpr_b_data_mdid); | |
| dev_info(dev, "gpr_b_data_start = %d\n", item->gpr_b_data_start); | |
| dev_info(dev, "gpr_b_data_len = %d\n", item->gpr_b_data_len); | |
| dev_info(dev, "gpr_b_id = %d\n", item->gpr_b_id); | |
| dev_info(dev, "gpr_c_ctrl = %d\n", item->gpr_c_ctrl); | |
| dev_info(dev, "gpr_c_data_mdid = %d\n", item->gpr_c_data_mdid); | |
| dev_info(dev, "gpr_c_data_start = %d\n", item->gpr_c_data_start); | |
| dev_info(dev, "gpr_c_data_len = %d\n", item->gpr_c_data_len); | |
| dev_info(dev, "gpr_c_id = %d\n", item->gpr_c_id); | |
| dev_info(dev, "gpr_d_ctrl = %d\n", item->gpr_d_ctrl); | |
| dev_info(dev, "gpr_d_data_mdid = %d\n", item->gpr_d_data_mdid); | |
| dev_info(dev, "gpr_d_data_start = %d\n", item->gpr_d_data_start); | |
| dev_info(dev, "gpr_d_data_len = %d\n", item->gpr_d_data_len); | |
| dev_info(dev, "gpr_d_id = %d\n", item->gpr_d_id); | |
| dev_info(dev, "flags = 0x%llx\n", (unsigned long long)(item->flags)); | |
| } | |
| #define ICE_MI_TSR GENMASK_ULL(7, 0) | |
| #define ICE_MI_HO GENMASK_ULL(16, 8) | |
| #define ICE_MI_PC GENMASK_ULL(24, 17) | |
| #define ICE_MI_PGRN GENMASK_ULL(35, 25) | |
| #define ICE_MI_CD GENMASK_ULL(38, 36) | |
| #define ICE_MI_GAC BIT_ULL(39) | |
| #define ICE_MI_GADM GENMASK_ULL(44, 40) | |
| #define ICE_MI_GADS GENMASK_ULL(48, 45) | |
| #define ICE_MI_GADL GENMASK_ULL(53, 49) | |
| #define ICE_MI_GAI GENMASK_ULL(59, 56) | |
| #define ICE_MI_GBC BIT_ULL(60) | |
| #define ICE_MI_GBDM_S 61 /* offset for the 2nd 64-bits field */ | |
| #define ICE_MI_GBDM_IDD (ICE_MI_GBDM_S / BITS_PER_BYTE) | |
| #define ICE_MI_GBDM_OFF (ICE_MI_GBDM_S % BITS_PER_BYTE) | |
| #define ICE_MI_GBDM_GENMASK_ULL(high, low) \ | |
| GENMASK_ULL((high) - ICE_MI_GBDM_S, (low) - ICE_MI_GBDM_S) | |
| #define ICE_MI_GBDM ICE_MI_GBDM_GENMASK_ULL(65, 61) | |
| #define ICE_MI_GBDS ICE_MI_GBDM_GENMASK_ULL(69, 66) | |
| #define ICE_MI_GBDL ICE_MI_GBDM_GENMASK_ULL(74, 70) | |
| #define ICE_MI_GBI ICE_MI_GBDM_GENMASK_ULL(80, 77) | |
| #define ICE_MI_GCC BIT_ULL(81 - ICE_MI_GBDM_S) | |
| #define ICE_MI_GCDM ICE_MI_GBDM_GENMASK_ULL(86, 82) | |
| #define ICE_MI_GCDS ICE_MI_GBDM_GENMASK_ULL(90, 87) | |
| #define ICE_MI_GCDL ICE_MI_GBDM_GENMASK_ULL(95, 91) | |
| #define ICE_MI_GCI ICE_MI_GBDM_GENMASK_ULL(101, 98) | |
| #define ICE_MI_GDC BIT_ULL(102 - ICE_MI_GBDM_S) | |
| #define ICE_MI_GDDM ICE_MI_GBDM_GENMASK_ULL(107, 103) | |
| #define ICE_MI_GDDS ICE_MI_GBDM_GENMASK_ULL(111, 108) | |
| #define ICE_MI_GDDL ICE_MI_GBDM_GENMASK_ULL(116, 112) | |
| #define ICE_MI_GDI ICE_MI_GBDM_GENMASK_ULL(122, 119) | |
| #define ICE_MI_FLAG_S 123 /* offset for the 3rd 64-bits field */ | |
| #define ICE_MI_FLAG_IDD (ICE_MI_FLAG_S / BITS_PER_BYTE) | |
| #define ICE_MI_FLAG_OFF (ICE_MI_FLAG_S % BITS_PER_BYTE) | |
| #define ICE_MI_FLAG GENMASK_ULL(186 - ICE_MI_FLAG_S, \ | |
| 123 - ICE_MI_FLAG_S) | |
| /** | |
| * ice_metainit_parse_item - parse 192 bits of Metadata Init entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Metadata Init entry | |
| * @item: item of Metadata Init entry | |
| * @data: Metadata Init entry data to be parsed | |
| * @size: size of Metadata Init entry | |
| */ | |
| static void ice_metainit_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_metainit_item *mi = item; | |
| u8 *buf = data; | |
| u64 d64; | |
| mi->idx = idx; | |
| d64 = *(u64 *)buf; | |
| mi->tsr = FIELD_GET(ICE_MI_TSR, d64); | |
| mi->ho = FIELD_GET(ICE_MI_HO, d64); | |
| mi->pc = FIELD_GET(ICE_MI_PC, d64); | |
| mi->pg_rn = FIELD_GET(ICE_MI_PGRN, d64); | |
| mi->cd = FIELD_GET(ICE_MI_CD, d64); | |
| mi->gpr_a_ctrl = FIELD_GET(ICE_MI_GAC, d64); | |
| mi->gpr_a_data_mdid = FIELD_GET(ICE_MI_GADM, d64); | |
| mi->gpr_a_data_start = FIELD_GET(ICE_MI_GADS, d64); | |
| mi->gpr_a_data_len = FIELD_GET(ICE_MI_GADL, d64); | |
| mi->gpr_a_id = FIELD_GET(ICE_MI_GAI, d64); | |
| mi->gpr_b_ctrl = FIELD_GET(ICE_MI_GBC, d64); | |
| d64 = *((u64 *)&buf[ICE_MI_GBDM_IDD]) >> ICE_MI_GBDM_OFF; | |
| mi->gpr_b_data_mdid = FIELD_GET(ICE_MI_GBDM, d64); | |
| mi->gpr_b_data_start = FIELD_GET(ICE_MI_GBDS, d64); | |
| mi->gpr_b_data_len = FIELD_GET(ICE_MI_GBDL, d64); | |
| mi->gpr_b_id = FIELD_GET(ICE_MI_GBI, d64); | |
| mi->gpr_c_ctrl = FIELD_GET(ICE_MI_GCC, d64); | |
| mi->gpr_c_data_mdid = FIELD_GET(ICE_MI_GCDM, d64); | |
| mi->gpr_c_data_start = FIELD_GET(ICE_MI_GCDS, d64); | |
| mi->gpr_c_data_len = FIELD_GET(ICE_MI_GCDL, d64); | |
| mi->gpr_c_id = FIELD_GET(ICE_MI_GCI, d64); | |
| mi->gpr_d_ctrl = FIELD_GET(ICE_MI_GDC, d64); | |
| mi->gpr_d_data_mdid = FIELD_GET(ICE_MI_GDDM, d64); | |
| mi->gpr_d_data_start = FIELD_GET(ICE_MI_GDDS, d64); | |
| mi->gpr_d_data_len = FIELD_GET(ICE_MI_GDDL, d64); | |
| mi->gpr_d_id = FIELD_GET(ICE_MI_GDI, d64); | |
| d64 = *((u64 *)&buf[ICE_MI_FLAG_IDD]) >> ICE_MI_FLAG_OFF; | |
| mi->flags = FIELD_GET(ICE_MI_FLAG, d64); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_metainit_dump(hw, mi); | |
| } | |
| /** | |
| * ice_metainit_table_get - create a metainit table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Metadata initialization table. | |
| */ | |
| static struct ice_metainit_item *ice_metainit_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_METADATA_INIT, | |
| sizeof(struct ice_metainit_item), | |
| ICE_METAINIT_TABLE_SIZE, | |
| ice_metainit_parse_item, false); | |
| } | |
| /** | |
| * ice_bst_tcam_search - find a TCAM item with specific type | |
| * @tcam_table: the TCAM table | |
| * @lbl_table: the lbl table to search | |
| * @type: the type we need to match against | |
| * @start: start searching from this index | |
| * | |
| * Return: a pointer to the matching BOOST TCAM item or NULL. | |
| */ | |
| struct ice_bst_tcam_item * | |
| ice_bst_tcam_search(struct ice_bst_tcam_item *tcam_table, | |
| struct ice_lbl_item *lbl_table, | |
| enum ice_lbl_type type, u16 *start) | |
| { | |
| u16 i = *start; | |
| for (; i < ICE_BST_TCAM_TABLE_SIZE; i++) { | |
| if (lbl_table[i].type == type) { | |
| *start = i; | |
| return &tcam_table[lbl_table[i].idx]; | |
| } | |
| } | |
| return NULL; | |
| } | |
| /*** ICE_SID_RXPARSER_CAM, ICE_SID_RXPARSER_PG_SPILL, | |
| * ICE_SID_RXPARSER_NOMATCH_CAM and ICE_SID_RXPARSER_NOMATCH_CAM | |
| * sections ***/ | |
| static void ice_pg_cam_key_dump(struct ice_hw *hw, struct ice_pg_cam_key *key) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "key:\n"); | |
| dev_info(dev, "\tvalid = %d\n", key->valid); | |
| dev_info(dev, "\tnode_id = %d\n", key->node_id); | |
| dev_info(dev, "\tflag0 = %d\n", key->flag0); | |
| dev_info(dev, "\tflag1 = %d\n", key->flag1); | |
| dev_info(dev, "\tflag2 = %d\n", key->flag2); | |
| dev_info(dev, "\tflag3 = %d\n", key->flag3); | |
| dev_info(dev, "\tboost_idx = %d\n", key->boost_idx); | |
| dev_info(dev, "\talu_reg = 0x%04x\n", key->alu_reg); | |
| dev_info(dev, "\tnext_proto = 0x%08x\n", key->next_proto); | |
| } | |
| static void ice_pg_nm_cam_key_dump(struct ice_hw *hw, | |
| struct ice_pg_nm_cam_key *key) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "key:\n"); | |
| dev_info(dev, "\tvalid = %d\n", key->valid); | |
| dev_info(dev, "\tnode_id = %d\n", key->node_id); | |
| dev_info(dev, "\tflag0 = %d\n", key->flag0); | |
| dev_info(dev, "\tflag1 = %d\n", key->flag1); | |
| dev_info(dev, "\tflag2 = %d\n", key->flag2); | |
| dev_info(dev, "\tflag3 = %d\n", key->flag3); | |
| dev_info(dev, "\tboost_idx = %d\n", key->boost_idx); | |
| dev_info(dev, "\talu_reg = 0x%04x\n", key->alu_reg); | |
| } | |
| static void ice_pg_cam_action_dump(struct ice_hw *hw, | |
| struct ice_pg_cam_action *action) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "action:\n"); | |
| dev_info(dev, "\tnext_node = %d\n", action->next_node); | |
| dev_info(dev, "\tnext_pc = %d\n", action->next_pc); | |
| dev_info(dev, "\tis_pg = %d\n", action->is_pg); | |
| dev_info(dev, "\tproto_id = %d\n", action->proto_id); | |
| dev_info(dev, "\tis_mg = %d\n", action->is_mg); | |
| dev_info(dev, "\tmarker_id = %d\n", action->marker_id); | |
| dev_info(dev, "\tis_last_round = %d\n", action->is_last_round); | |
| dev_info(dev, "\tho_polarity = %d\n", action->ho_polarity); | |
| dev_info(dev, "\tho_inc = %d\n", action->ho_inc); | |
| } | |
| /** | |
| * ice_pg_cam_dump - dump an parse graph cam info | |
| * @hw: pointer to the hardware structure | |
| * @item: parse graph cam to dump | |
| */ | |
| static void ice_pg_cam_dump(struct ice_hw *hw, struct ice_pg_cam_item *item) | |
| { | |
| dev_info(ice_hw_to_dev(hw), "index = %d\n", item->idx); | |
| ice_pg_cam_key_dump(hw, &item->key); | |
| ice_pg_cam_action_dump(hw, &item->action); | |
| } | |
| /** | |
| * ice_pg_nm_cam_dump - dump an parse graph no match cam info | |
| * @hw: pointer to the hardware structure | |
| * @item: parse graph no match cam to dump | |
| */ | |
| static void ice_pg_nm_cam_dump(struct ice_hw *hw, | |
| struct ice_pg_nm_cam_item *item) | |
| { | |
| dev_info(ice_hw_to_dev(hw), "index = %d\n", item->idx); | |
| ice_pg_nm_cam_key_dump(hw, &item->key); | |
| ice_pg_cam_action_dump(hw, &item->action); | |
| } | |
| #define ICE_PGCA_NN GENMASK_ULL(10, 0) | |
| #define ICE_PGCA_NPC GENMASK_ULL(18, 11) | |
| #define ICE_PGCA_IPG BIT_ULL(19) | |
| #define ICE_PGCA_PID GENMASK_ULL(30, 23) | |
| #define ICE_PGCA_IMG BIT_ULL(31) | |
| #define ICE_PGCA_MID GENMASK_ULL(39, 32) | |
| #define ICE_PGCA_ILR BIT_ULL(40) | |
| #define ICE_PGCA_HOP BIT_ULL(41) | |
| #define ICE_PGCA_HOI GENMASK_ULL(50, 42) | |
| /** | |
| * ice_pg_cam_action_init - parse 55 bits of Parse Graph CAM Action | |
| * @action: pointer to the Parse Graph CAM Action structure | |
| * @data: Parse Graph CAM Action data to be parsed | |
| */ | |
| static void ice_pg_cam_action_init(struct ice_pg_cam_action *action, u64 data) | |
| { | |
| action->next_node = FIELD_GET(ICE_PGCA_NN, data); | |
| action->next_pc = FIELD_GET(ICE_PGCA_NPC, data); | |
| action->is_pg = FIELD_GET(ICE_PGCA_IPG, data); | |
| action->proto_id = FIELD_GET(ICE_PGCA_PID, data); | |
| action->is_mg = FIELD_GET(ICE_PGCA_IMG, data); | |
| action->marker_id = FIELD_GET(ICE_PGCA_MID, data); | |
| action->is_last_round = FIELD_GET(ICE_PGCA_ILR, data); | |
| action->ho_polarity = FIELD_GET(ICE_PGCA_HOP, data); | |
| action->ho_inc = FIELD_GET(ICE_PGCA_HOI, data); | |
| } | |
| #define ICE_PGNCK_VLD BIT_ULL(0) | |
| #define ICE_PGNCK_NID GENMASK_ULL(11, 1) | |
| #define ICE_PGNCK_F0 BIT_ULL(12) | |
| #define ICE_PGNCK_F1 BIT_ULL(13) | |
| #define ICE_PGNCK_F2 BIT_ULL(14) | |
| #define ICE_PGNCK_F3 BIT_ULL(15) | |
| #define ICE_PGNCK_BH BIT_ULL(16) | |
| #define ICE_PGNCK_BI GENMASK_ULL(24, 17) | |
| #define ICE_PGNCK_AR GENMASK_ULL(40, 25) | |
| /** | |
| * ice_pg_nm_cam_key_init - parse 41 bits of Parse Graph NoMatch CAM Key | |
| * @key: pointer to the Parse Graph NoMatch CAM Key structure | |
| * @data: Parse Graph NoMatch CAM Key data to be parsed | |
| */ | |
| static void ice_pg_nm_cam_key_init(struct ice_pg_nm_cam_key *key, u64 data) | |
| { | |
| key->valid = FIELD_GET(ICE_PGNCK_VLD, data); | |
| key->node_id = FIELD_GET(ICE_PGNCK_NID, data); | |
| key->flag0 = FIELD_GET(ICE_PGNCK_F0, data); | |
| key->flag1 = FIELD_GET(ICE_PGNCK_F1, data); | |
| key->flag2 = FIELD_GET(ICE_PGNCK_F2, data); | |
| key->flag3 = FIELD_GET(ICE_PGNCK_F3, data); | |
| if (FIELD_GET(ICE_PGNCK_BH, data)) | |
| key->boost_idx = FIELD_GET(ICE_PGNCK_BI, data); | |
| else | |
| key->boost_idx = 0; | |
| key->alu_reg = FIELD_GET(ICE_PGNCK_AR, data); | |
| } | |
| #define ICE_PGCK_VLD BIT_ULL(0) | |
| #define ICE_PGCK_NID GENMASK_ULL(11, 1) | |
| #define ICE_PGCK_F0 BIT_ULL(12) | |
| #define ICE_PGCK_F1 BIT_ULL(13) | |
| #define ICE_PGCK_F2 BIT_ULL(14) | |
| #define ICE_PGCK_F3 BIT_ULL(15) | |
| #define ICE_PGCK_BH BIT_ULL(16) | |
| #define ICE_PGCK_BI GENMASK_ULL(24, 17) | |
| #define ICE_PGCK_AR GENMASK_ULL(40, 25) | |
| #define ICE_PGCK_NPK_S 41 /* offset for the 2nd 64-bits field */ | |
| #define ICE_PGCK_NPK_IDD (ICE_PGCK_NPK_S / BITS_PER_BYTE) | |
| #define ICE_PGCK_NPK_OFF (ICE_PGCK_NPK_S % BITS_PER_BYTE) | |
| #define ICE_PGCK_NPK GENMASK_ULL(72 - ICE_PGCK_NPK_S, \ | |
| 41 - ICE_PGCK_NPK_S) | |
| /** | |
| * ice_pg_cam_key_init - parse 73 bits of Parse Graph CAM Key | |
| * @key: pointer to the Parse Graph CAM Key structure | |
| * @data: Parse Graph CAM Key data to be parsed | |
| */ | |
| static void ice_pg_cam_key_init(struct ice_pg_cam_key *key, u8 *data) | |
| { | |
| u64 d64 = *(u64 *)data; | |
| key->valid = FIELD_GET(ICE_PGCK_VLD, d64); | |
| key->node_id = FIELD_GET(ICE_PGCK_NID, d64); | |
| key->flag0 = FIELD_GET(ICE_PGCK_F0, d64); | |
| key->flag1 = FIELD_GET(ICE_PGCK_F1, d64); | |
| key->flag2 = FIELD_GET(ICE_PGCK_F2, d64); | |
| key->flag3 = FIELD_GET(ICE_PGCK_F3, d64); | |
| if (FIELD_GET(ICE_PGCK_BH, d64)) | |
| key->boost_idx = FIELD_GET(ICE_PGCK_BI, d64); | |
| else | |
| key->boost_idx = 0; | |
| key->alu_reg = FIELD_GET(ICE_PGCK_AR, d64); | |
| d64 = *((u64 *)&data[ICE_PGCK_NPK_IDD]) >> ICE_PGCK_NPK_OFF; | |
| key->next_proto = FIELD_GET(ICE_PGCK_NPK, d64); | |
| } | |
| #define ICE_PG_CAM_ACT_S 73 | |
| #define ICE_PG_CAM_ACT_IDD (ICE_PG_CAM_ACT_S / BITS_PER_BYTE) | |
| #define ICE_PG_CAM_ACT_OFF (ICE_PG_CAM_ACT_S % BITS_PER_BYTE) | |
| /** | |
| * ice_pg_cam_parse_item - parse 128 bits of Parse Graph CAM Entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Parse Graph CAM Entry | |
| * @item: item of Parse Graph CAM Entry | |
| * @data: Parse Graph CAM Entry data to be parsed | |
| * @size: size of Parse Graph CAM Entry | |
| */ | |
| static void ice_pg_cam_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_pg_cam_item *ci = item; | |
| u8 *buf = data; | |
| u64 d64; | |
| ci->idx = idx; | |
| ice_pg_cam_key_init(&ci->key, buf); | |
| d64 = *((u64 *)&buf[ICE_PG_CAM_ACT_IDD]) >> ICE_PG_CAM_ACT_OFF; | |
| ice_pg_cam_action_init(&ci->action, d64); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_pg_cam_dump(hw, ci); | |
| } | |
| #define ICE_PG_SP_CAM_KEY_S 56 | |
| #define ICE_PG_SP_CAM_KEY_IDD (ICE_PG_SP_CAM_KEY_S / BITS_PER_BYTE) | |
| /** | |
| * ice_pg_sp_cam_parse_item - parse 136 bits of Parse Graph Spill CAM Entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Parse Graph Spill CAM Entry | |
| * @item: item of Parse Graph Spill CAM Entry | |
| * @data: Parse Graph Spill CAM Entry data to be parsed | |
| * @size: size of Parse Graph Spill CAM Entry | |
| */ | |
| static void ice_pg_sp_cam_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_pg_cam_item *ci = item; | |
| u8 *buf = data; | |
| u64 d64; | |
| ci->idx = idx; | |
| d64 = *(u64 *)buf; | |
| ice_pg_cam_action_init(&ci->action, d64); | |
| ice_pg_cam_key_init(&ci->key, &buf[ICE_PG_SP_CAM_KEY_IDD]); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_pg_cam_dump(hw, ci); | |
| } | |
| #define ICE_PG_NM_CAM_ACT_S 41 | |
| #define ICE_PG_NM_CAM_ACT_IDD (ICE_PG_NM_CAM_ACT_S / BITS_PER_BYTE) | |
| #define ICE_PG_NM_CAM_ACT_OFF (ICE_PG_NM_CAM_ACT_S % BITS_PER_BYTE) | |
| /** | |
| * ice_pg_nm_cam_parse_item - parse 96 bits of Parse Graph NoMatch CAM Entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Parse Graph NoMatch CAM Entry | |
| * @item: item of Parse Graph NoMatch CAM Entry | |
| * @data: Parse Graph NoMatch CAM Entry data to be parsed | |
| * @size: size of Parse Graph NoMatch CAM Entry | |
| */ | |
| static void ice_pg_nm_cam_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_pg_nm_cam_item *ci = item; | |
| u8 *buf = data; | |
| u64 d64; | |
| ci->idx = idx; | |
| d64 = *(u64 *)buf; | |
| ice_pg_nm_cam_key_init(&ci->key, d64); | |
| d64 = *((u64 *)&buf[ICE_PG_NM_CAM_ACT_IDD]) >> ICE_PG_NM_CAM_ACT_OFF; | |
| ice_pg_cam_action_init(&ci->action, d64); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_pg_nm_cam_dump(hw, ci); | |
| } | |
| #define ICE_PG_NM_SP_CAM_ACT_S 56 | |
| #define ICE_PG_NM_SP_CAM_ACT_IDD (ICE_PG_NM_SP_CAM_ACT_S / BITS_PER_BYTE) | |
| #define ICE_PG_NM_SP_CAM_ACT_OFF (ICE_PG_NM_SP_CAM_ACT_S % BITS_PER_BYTE) | |
| /** | |
| * ice_pg_nm_sp_cam_parse_item - parse 104 bits of Parse Graph NoMatch Spill | |
| * CAM Entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Parse Graph NoMatch Spill CAM Entry | |
| * @item: item of Parse Graph NoMatch Spill CAM Entry | |
| * @data: Parse Graph NoMatch Spill CAM Entry data to be parsed | |
| * @size: size of Parse Graph NoMatch Spill CAM Entry | |
| */ | |
| static void ice_pg_nm_sp_cam_parse_item(struct ice_hw *hw, u16 idx, | |
| void *item, void *data, | |
| int __maybe_unused size) | |
| { | |
| struct ice_pg_nm_cam_item *ci = item; | |
| u8 *buf = data; | |
| u64 d64; | |
| ci->idx = idx; | |
| d64 = *(u64 *)buf; | |
| ice_pg_cam_action_init(&ci->action, d64); | |
| d64 = *((u64 *)&buf[ICE_PG_NM_SP_CAM_ACT_IDD]) >> | |
| ICE_PG_NM_SP_CAM_ACT_OFF; | |
| ice_pg_nm_cam_key_init(&ci->key, d64); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_pg_nm_cam_dump(hw, ci); | |
| } | |
| /** | |
| * ice_pg_cam_table_get - create a parse graph cam table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Parse Graph CAM table. | |
| */ | |
| static struct ice_pg_cam_item *ice_pg_cam_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_CAM, | |
| sizeof(struct ice_pg_cam_item), | |
| ICE_PG_CAM_TABLE_SIZE, | |
| ice_pg_cam_parse_item, false); | |
| } | |
| /** | |
| * ice_pg_sp_cam_table_get - create a parse graph spill cam table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Parse Graph Spill CAM table. | |
| */ | |
| static struct ice_pg_cam_item *ice_pg_sp_cam_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_PG_SPILL, | |
| sizeof(struct ice_pg_cam_item), | |
| ICE_PG_SP_CAM_TABLE_SIZE, | |
| ice_pg_sp_cam_parse_item, false); | |
| } | |
| /** | |
| * ice_pg_nm_cam_table_get - create a parse graph no match cam table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Parse Graph No Match CAM table. | |
| */ | |
| static struct ice_pg_nm_cam_item *ice_pg_nm_cam_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_NOMATCH_CAM, | |
| sizeof(struct ice_pg_nm_cam_item), | |
| ICE_PG_NM_CAM_TABLE_SIZE, | |
| ice_pg_nm_cam_parse_item, false); | |
| } | |
| /** | |
| * ice_pg_nm_sp_cam_table_get - create a parse graph no match spill cam table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Parse Graph No Match Spill CAM table. | |
| */ | |
| static struct ice_pg_nm_cam_item *ice_pg_nm_sp_cam_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_NOMATCH_SPILL, | |
| sizeof(struct ice_pg_nm_cam_item), | |
| ICE_PG_NM_SP_CAM_TABLE_SIZE, | |
| ice_pg_nm_sp_cam_parse_item, false); | |
| } | |
| static bool __ice_pg_cam_match(struct ice_pg_cam_item *item, | |
| struct ice_pg_cam_key *key) | |
| { | |
| return (item->key.valid && | |
| !memcmp(&item->key.val, &key->val, sizeof(key->val))); | |
| } | |
| static bool __ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *item, | |
| struct ice_pg_cam_key *key) | |
| { | |
| return (item->key.valid && | |
| !memcmp(&item->key.val, &key->val, sizeof(item->key.val))); | |
| } | |
| /** | |
| * ice_pg_cam_match - search parse graph cam table by key | |
| * @table: parse graph cam table to search | |
| * @size: cam table size | |
| * @key: search key | |
| * | |
| * Return: a pointer to the matching PG CAM item or NULL. | |
| */ | |
| struct ice_pg_cam_item *ice_pg_cam_match(struct ice_pg_cam_item *table, | |
| int size, struct ice_pg_cam_key *key) | |
| { | |
| int i; | |
| for (i = 0; i < size; i++) { | |
| struct ice_pg_cam_item *item = &table[i]; | |
| if (__ice_pg_cam_match(item, key)) | |
| return item; | |
| } | |
| return NULL; | |
| } | |
| /** | |
| * ice_pg_nm_cam_match - search parse graph no match cam table by key | |
| * @table: parse graph no match cam table to search | |
| * @size: cam table size | |
| * @key: search key | |
| * | |
| * Return: a pointer to the matching PG No Match CAM item or NULL. | |
| */ | |
| struct ice_pg_nm_cam_item * | |
| ice_pg_nm_cam_match(struct ice_pg_nm_cam_item *table, int size, | |
| struct ice_pg_cam_key *key) | |
| { | |
| int i; | |
| for (i = 0; i < size; i++) { | |
| struct ice_pg_nm_cam_item *item = &table[i]; | |
| if (__ice_pg_nm_cam_match(item, key)) | |
| return item; | |
| } | |
| return NULL; | |
| } | |
| /*** Ternary match ***/ | |
| /* Perform a ternary match on a 1-byte pattern (@pat) given @key and @key_inv | |
| * Rules (per bit): | |
| * Key == 0 and Key_inv == 0 : Never match (Don't care) | |
| * Key == 0 and Key_inv == 1 : Match on bit == 1 | |
| * Key == 1 and Key_inv == 0 : Match on bit == 0 | |
| * Key == 1 and Key_inv == 1 : Always match (Don't care) | |
| * | |
| * Return: true if all bits match, false otherwise. | |
| */ | |
| static bool ice_ternary_match_byte(u8 key, u8 key_inv, u8 pat) | |
| { | |
| u8 bit_key, bit_key_inv, bit_pat; | |
| int i; | |
| for (i = 0; i < BITS_PER_BYTE; i++) { | |
| bit_key = key & BIT(i); | |
| bit_key_inv = key_inv & BIT(i); | |
| bit_pat = pat & BIT(i); | |
| if (bit_key != 0 && bit_key_inv != 0) | |
| continue; | |
| if ((bit_key == 0 && bit_key_inv == 0) || bit_key == bit_pat) | |
| return false; | |
| } | |
| return true; | |
| } | |
| static bool ice_ternary_match(const u8 *key, const u8 *key_inv, | |
| const u8 *pat, int len) | |
| { | |
| int i; | |
| for (i = 0; i < len; i++) | |
| if (!ice_ternary_match_byte(key[i], key_inv[i], pat[i])) | |
| return false; | |
| return true; | |
| } | |
| /*** ICE_SID_RXPARSER_BOOST_TCAM and ICE_SID_LBL_RXPARSER_TMEM sections ***/ | |
| static void ice_bst_np_kb_dump(struct ice_hw *hw, struct ice_np_keybuilder *kb) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "next proto key builder:\n"); | |
| dev_info(dev, "\topc = %d\n", kb->opc); | |
| dev_info(dev, "\tstart_reg0 = %d\n", kb->start_reg0); | |
| dev_info(dev, "\tlen_reg1 = %d\n", kb->len_reg1); | |
| } | |
| static void ice_bst_pg_kb_dump(struct ice_hw *hw, struct ice_pg_keybuilder *kb) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "parse graph key builder:\n"); | |
| dev_info(dev, "\tflag0_ena = %d\n", kb->flag0_ena); | |
| dev_info(dev, "\tflag1_ena = %d\n", kb->flag1_ena); | |
| dev_info(dev, "\tflag2_ena = %d\n", kb->flag2_ena); | |
| dev_info(dev, "\tflag3_ena = %d\n", kb->flag3_ena); | |
| dev_info(dev, "\tflag0_idx = %d\n", kb->flag0_idx); | |
| dev_info(dev, "\tflag1_idx = %d\n", kb->flag1_idx); | |
| dev_info(dev, "\tflag2_idx = %d\n", kb->flag2_idx); | |
| dev_info(dev, "\tflag3_idx = %d\n", kb->flag3_idx); | |
| dev_info(dev, "\talu_reg_idx = %d\n", kb->alu_reg_idx); | |
| } | |
| static void ice_bst_alu_dump(struct ice_hw *hw, struct ice_alu *alu, int idx) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "alu%d:\n", idx); | |
| dev_info(dev, "\topc = %d\n", alu->opc); | |
| dev_info(dev, "\tsrc_start = %d\n", alu->src_start); | |
| dev_info(dev, "\tsrc_len = %d\n", alu->src_len); | |
| dev_info(dev, "\tshift_xlate_sel = %d\n", alu->shift_xlate_sel); | |
| dev_info(dev, "\tshift_xlate_key = %d\n", alu->shift_xlate_key); | |
| dev_info(dev, "\tsrc_reg_id = %d\n", alu->src_reg_id); | |
| dev_info(dev, "\tdst_reg_id = %d\n", alu->dst_reg_id); | |
| dev_info(dev, "\tinc0 = %d\n", alu->inc0); | |
| dev_info(dev, "\tinc1 = %d\n", alu->inc1); | |
| dev_info(dev, "\tproto_offset_opc = %d\n", alu->proto_offset_opc); | |
| dev_info(dev, "\tproto_offset = %d\n", alu->proto_offset); | |
| dev_info(dev, "\tbranch_addr = %d\n", alu->branch_addr); | |
| dev_info(dev, "\timm = %d\n", alu->imm); | |
| dev_info(dev, "\tdst_start = %d\n", alu->dst_start); | |
| dev_info(dev, "\tdst_len = %d\n", alu->dst_len); | |
| dev_info(dev, "\tflags_extr_imm = %d\n", alu->flags_extr_imm); | |
| dev_info(dev, "\tflags_start_imm= %d\n", alu->flags_start_imm); | |
| } | |
| /** | |
| * ice_bst_tcam_dump - dump a boost tcam info | |
| * @hw: pointer to the hardware structure | |
| * @item: boost tcam to dump | |
| */ | |
| static void ice_bst_tcam_dump(struct ice_hw *hw, struct ice_bst_tcam_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| int i; | |
| dev_info(dev, "addr = %d\n", item->addr); | |
| dev_info(dev, "key : "); | |
| for (i = 0; i < ICE_BST_TCAM_KEY_SIZE; i++) | |
| dev_info(dev, "%02x ", item->key[i]); | |
| dev_info(dev, "\n"); | |
| dev_info(dev, "key_inv: "); | |
| for (i = 0; i < ICE_BST_TCAM_KEY_SIZE; i++) | |
| dev_info(dev, "%02x ", item->key_inv[i]); | |
| dev_info(dev, "\n"); | |
| dev_info(dev, "hit_idx_grp = %d\n", item->hit_idx_grp); | |
| dev_info(dev, "pg_prio = %d\n", item->pg_prio); | |
| ice_bst_np_kb_dump(hw, &item->np_kb); | |
| ice_bst_pg_kb_dump(hw, &item->pg_kb); | |
| ice_bst_alu_dump(hw, &item->alu0, ICE_ALU0_IDX); | |
| ice_bst_alu_dump(hw, &item->alu1, ICE_ALU1_IDX); | |
| ice_bst_alu_dump(hw, &item->alu2, ICE_ALU2_IDX); | |
| } | |
| static void ice_lbl_dump(struct ice_hw *hw, struct ice_lbl_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "index = %u\n", item->idx); | |
| dev_info(dev, "type = %u\n", item->type); | |
| dev_info(dev, "label = %s\n", item->label); | |
| } | |
| #define ICE_BST_ALU_OPC GENMASK_ULL(5, 0) | |
| #define ICE_BST_ALU_SS GENMASK_ULL(13, 6) | |
| #define ICE_BST_ALU_SL GENMASK_ULL(18, 14) | |
| #define ICE_BST_ALU_SXS BIT_ULL(19) | |
| #define ICE_BST_ALU_SXK GENMASK_ULL(23, 20) | |
| #define ICE_BST_ALU_SRID GENMASK_ULL(30, 24) | |
| #define ICE_BST_ALU_DRID GENMASK_ULL(37, 31) | |
| #define ICE_BST_ALU_INC0 BIT_ULL(38) | |
| #define ICE_BST_ALU_INC1 BIT_ULL(39) | |
| #define ICE_BST_ALU_POO GENMASK_ULL(41, 40) | |
| #define ICE_BST_ALU_PO GENMASK_ULL(49, 42) | |
| #define ICE_BST_ALU_BA_S 50 /* offset for the 2nd 64-bits field */ | |
| #define ICE_BST_ALU_BA GENMASK_ULL(57 - ICE_BST_ALU_BA_S, \ | |
| 50 - ICE_BST_ALU_BA_S) | |
| #define ICE_BST_ALU_IMM GENMASK_ULL(73 - ICE_BST_ALU_BA_S, \ | |
| 58 - ICE_BST_ALU_BA_S) | |
| #define ICE_BST_ALU_DFE BIT_ULL(74 - ICE_BST_ALU_BA_S) | |
| #define ICE_BST_ALU_DS GENMASK_ULL(80 - ICE_BST_ALU_BA_S, \ | |
| 75 - ICE_BST_ALU_BA_S) | |
| #define ICE_BST_ALU_DL GENMASK_ULL(86 - ICE_BST_ALU_BA_S, \ | |
| 81 - ICE_BST_ALU_BA_S) | |
| #define ICE_BST_ALU_FEI BIT_ULL(87 - ICE_BST_ALU_BA_S) | |
| #define ICE_BST_ALU_FSI GENMASK_ULL(95 - ICE_BST_ALU_BA_S, \ | |
| 88 - ICE_BST_ALU_BA_S) | |
| /** | |
| * ice_bst_alu_init - parse 96 bits of ALU entry | |
| * @alu: pointer to the ALU entry structure | |
| * @data: ALU entry data to be parsed | |
| * @off: offset of the ALU entry data | |
| */ | |
| static void ice_bst_alu_init(struct ice_alu *alu, u8 *data, u8 off) | |
| { | |
| u64 d64; | |
| u8 idd; | |
| d64 = *((u64 *)data) >> off; | |
| alu->opc = FIELD_GET(ICE_BST_ALU_OPC, d64); | |
| alu->src_start = FIELD_GET(ICE_BST_ALU_SS, d64); | |
| alu->src_len = FIELD_GET(ICE_BST_ALU_SL, d64); | |
| alu->shift_xlate_sel = FIELD_GET(ICE_BST_ALU_SXS, d64); | |
| alu->shift_xlate_key = FIELD_GET(ICE_BST_ALU_SXK, d64); | |
| alu->src_reg_id = FIELD_GET(ICE_BST_ALU_SRID, d64); | |
| alu->dst_reg_id = FIELD_GET(ICE_BST_ALU_DRID, d64); | |
| alu->inc0 = FIELD_GET(ICE_BST_ALU_INC0, d64); | |
| alu->inc1 = FIELD_GET(ICE_BST_ALU_INC1, d64); | |
| alu->proto_offset_opc = FIELD_GET(ICE_BST_ALU_POO, d64); | |
| alu->proto_offset = FIELD_GET(ICE_BST_ALU_PO, d64); | |
| idd = (ICE_BST_ALU_BA_S + off) / BITS_PER_BYTE; | |
| off = (ICE_BST_ALU_BA_S + off) % BITS_PER_BYTE; | |
| d64 = *((u64 *)(&data[idd])) >> off; | |
| alu->branch_addr = FIELD_GET(ICE_BST_ALU_BA, d64); | |
| alu->imm = FIELD_GET(ICE_BST_ALU_IMM, d64); | |
| alu->dedicate_flags_ena = FIELD_GET(ICE_BST_ALU_DFE, d64); | |
| alu->dst_start = FIELD_GET(ICE_BST_ALU_DS, d64); | |
| alu->dst_len = FIELD_GET(ICE_BST_ALU_DL, d64); | |
| alu->flags_extr_imm = FIELD_GET(ICE_BST_ALU_FEI, d64); | |
| alu->flags_start_imm = FIELD_GET(ICE_BST_ALU_FSI, d64); | |
| } | |
| #define ICE_BST_PGKB_F0_ENA BIT_ULL(0) | |
| #define ICE_BST_PGKB_F0_IDX GENMASK_ULL(6, 1) | |
| #define ICE_BST_PGKB_F1_ENA BIT_ULL(7) | |
| #define ICE_BST_PGKB_F1_IDX GENMASK_ULL(13, 8) | |
| #define ICE_BST_PGKB_F2_ENA BIT_ULL(14) | |
| #define ICE_BST_PGKB_F2_IDX GENMASK_ULL(20, 15) | |
| #define ICE_BST_PGKB_F3_ENA BIT_ULL(21) | |
| #define ICE_BST_PGKB_F3_IDX GENMASK_ULL(27, 22) | |
| #define ICE_BST_PGKB_AR_IDX GENMASK_ULL(34, 28) | |
| /** | |
| * ice_bst_pgkb_init - parse 35 bits of Parse Graph Key Build | |
| * @kb: pointer to the Parse Graph Key Build structure | |
| * @data: Parse Graph Key Build data to be parsed | |
| */ | |
| static void ice_bst_pgkb_init(struct ice_pg_keybuilder *kb, u64 data) | |
| { | |
| kb->flag0_ena = FIELD_GET(ICE_BST_PGKB_F0_ENA, data); | |
| kb->flag0_idx = FIELD_GET(ICE_BST_PGKB_F0_IDX, data); | |
| kb->flag1_ena = FIELD_GET(ICE_BST_PGKB_F1_ENA, data); | |
| kb->flag1_idx = FIELD_GET(ICE_BST_PGKB_F1_IDX, data); | |
| kb->flag2_ena = FIELD_GET(ICE_BST_PGKB_F2_ENA, data); | |
| kb->flag2_idx = FIELD_GET(ICE_BST_PGKB_F2_IDX, data); | |
| kb->flag3_ena = FIELD_GET(ICE_BST_PGKB_F3_ENA, data); | |
| kb->flag3_idx = FIELD_GET(ICE_BST_PGKB_F3_IDX, data); | |
| kb->alu_reg_idx = FIELD_GET(ICE_BST_PGKB_AR_IDX, data); | |
| } | |
| #define ICE_BST_NPKB_OPC GENMASK(1, 0) | |
| #define ICE_BST_NPKB_S_R0 GENMASK(9, 2) | |
| #define ICE_BST_NPKB_L_R1 GENMASK(17, 10) | |
| /** | |
| * ice_bst_npkb_init - parse 18 bits of Next Protocol Key Build | |
| * @kb: pointer to the Next Protocol Key Build structure | |
| * @data: Next Protocol Key Build data to be parsed | |
| */ | |
| static void ice_bst_npkb_init(struct ice_np_keybuilder *kb, u32 data) | |
| { | |
| kb->opc = FIELD_GET(ICE_BST_NPKB_OPC, data); | |
| kb->start_reg0 = FIELD_GET(ICE_BST_NPKB_S_R0, data); | |
| kb->len_reg1 = FIELD_GET(ICE_BST_NPKB_L_R1, data); | |
| } | |
| #define ICE_BT_KEY_S 32 | |
| #define ICE_BT_KEY_IDD (ICE_BT_KEY_S / BITS_PER_BYTE) | |
| #define ICE_BT_KIV_S 192 | |
| #define ICE_BT_KIV_IDD (ICE_BT_KIV_S / BITS_PER_BYTE) | |
| #define ICE_BT_HIG_S 352 | |
| #define ICE_BT_HIG_IDD (ICE_BT_HIG_S / BITS_PER_BYTE) | |
| #define ICE_BT_PGP_S 360 | |
| #define ICE_BT_PGP_IDD (ICE_BT_PGP_S / BITS_PER_BYTE) | |
| #define ICE_BT_PGP_M GENMASK(361 - ICE_BT_PGP_S, 360 - ICE_BT_PGP_S) | |
| #define ICE_BT_NPKB_S 362 | |
| #define ICE_BT_NPKB_IDD (ICE_BT_NPKB_S / BITS_PER_BYTE) | |
| #define ICE_BT_NPKB_OFF (ICE_BT_NPKB_S % BITS_PER_BYTE) | |
| #define ICE_BT_PGKB_S 380 | |
| #define ICE_BT_PGKB_IDD (ICE_BT_PGKB_S / BITS_PER_BYTE) | |
| #define ICE_BT_PGKB_OFF (ICE_BT_PGKB_S % BITS_PER_BYTE) | |
| #define ICE_BT_ALU0_S 415 | |
| #define ICE_BT_ALU0_IDD (ICE_BT_ALU0_S / BITS_PER_BYTE) | |
| #define ICE_BT_ALU0_OFF (ICE_BT_ALU0_S % BITS_PER_BYTE) | |
| #define ICE_BT_ALU1_S 511 | |
| #define ICE_BT_ALU1_IDD (ICE_BT_ALU1_S / BITS_PER_BYTE) | |
| #define ICE_BT_ALU1_OFF (ICE_BT_ALU1_S % BITS_PER_BYTE) | |
| #define ICE_BT_ALU2_S 607 | |
| #define ICE_BT_ALU2_IDD (ICE_BT_ALU2_S / BITS_PER_BYTE) | |
| #define ICE_BT_ALU2_OFF (ICE_BT_ALU2_S % BITS_PER_BYTE) | |
| /** | |
| * ice_bst_parse_item - parse 704 bits of Boost TCAM entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Boost TCAM entry | |
| * @item: item of Boost TCAM entry | |
| * @data: Boost TCAM entry data to be parsed | |
| * @size: size of Boost TCAM entry | |
| */ | |
| static void ice_bst_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_bst_tcam_item *ti = item; | |
| u8 *buf = (u8 *)data; | |
| int i; | |
| ti->addr = *(u16 *)buf; | |
| for (i = 0; i < ICE_BST_TCAM_KEY_SIZE; i++) { | |
| ti->key[i] = buf[ICE_BT_KEY_IDD + i]; | |
| ti->key_inv[i] = buf[ICE_BT_KIV_IDD + i]; | |
| } | |
| ti->hit_idx_grp = buf[ICE_BT_HIG_IDD]; | |
| ti->pg_prio = buf[ICE_BT_PGP_IDD] & ICE_BT_PGP_M; | |
| ice_bst_npkb_init(&ti->np_kb, | |
| *((u32 *)(&buf[ICE_BT_NPKB_IDD])) >> | |
| ICE_BT_NPKB_OFF); | |
| ice_bst_pgkb_init(&ti->pg_kb, | |
| *((u64 *)(&buf[ICE_BT_PGKB_IDD])) >> | |
| ICE_BT_PGKB_OFF); | |
| ice_bst_alu_init(&ti->alu0, &buf[ICE_BT_ALU0_IDD], ICE_BT_ALU0_OFF); | |
| ice_bst_alu_init(&ti->alu1, &buf[ICE_BT_ALU1_IDD], ICE_BT_ALU1_OFF); | |
| ice_bst_alu_init(&ti->alu2, &buf[ICE_BT_ALU2_IDD], ICE_BT_ALU2_OFF); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_bst_tcam_dump(hw, ti); | |
| } | |
| /** | |
| * ice_bst_tcam_table_get - create a boost tcam table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Boost TCAM table. | |
| */ | |
| static struct ice_bst_tcam_item *ice_bst_tcam_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_BOOST_TCAM, | |
| sizeof(struct ice_bst_tcam_item), | |
| ICE_BST_TCAM_TABLE_SIZE, | |
| ice_bst_parse_item, true); | |
| } | |
| static void ice_parse_lbl_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_lbl_item *lbl_item = item; | |
| struct ice_lbl_item *lbl_data = data; | |
| lbl_item->idx = lbl_data->idx; | |
| memcpy(lbl_item->label, lbl_data->label, sizeof(lbl_item->label)); | |
| if (strstarts(lbl_item->label, ICE_LBL_BST_DVM)) | |
| lbl_item->type = ICE_LBL_BST_TYPE_DVM; | |
| else if (strstarts(lbl_item->label, ICE_LBL_BST_SVM)) | |
| lbl_item->type = ICE_LBL_BST_TYPE_SVM; | |
| else if (strstarts(lbl_item->label, ICE_LBL_TNL_VXLAN)) | |
| lbl_item->type = ICE_LBL_BST_TYPE_VXLAN; | |
| else if (strstarts(lbl_item->label, ICE_LBL_TNL_GENEVE)) | |
| lbl_item->type = ICE_LBL_BST_TYPE_GENEVE; | |
| else if (strstarts(lbl_item->label, ICE_LBL_TNL_UDP_ECPRI)) | |
| lbl_item->type = ICE_LBL_BST_TYPE_UDP_ECPRI; | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_lbl_dump(hw, lbl_item); | |
| } | |
| /** | |
| * ice_bst_lbl_table_get - create a boost label table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Boost label table. | |
| */ | |
| static struct ice_lbl_item *ice_bst_lbl_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_LBL_RXPARSER_TMEM, | |
| sizeof(struct ice_lbl_item), | |
| ICE_BST_TCAM_TABLE_SIZE, | |
| ice_parse_lbl_item, true); | |
| } | |
| /** | |
| * ice_bst_tcam_match - match a pattern on the boost tcam table | |
| * @tcam_table: boost tcam table to search | |
| * @pat: pattern to match | |
| * | |
| * Return: a pointer to the matching Boost TCAM item or NULL. | |
| */ | |
| struct ice_bst_tcam_item * | |
| ice_bst_tcam_match(struct ice_bst_tcam_item *tcam_table, u8 *pat) | |
| { | |
| int i; | |
| for (i = 0; i < ICE_BST_TCAM_TABLE_SIZE; i++) { | |
| struct ice_bst_tcam_item *item = &tcam_table[i]; | |
| if (item->hit_idx_grp == 0) | |
| continue; | |
| if (ice_ternary_match(item->key, item->key_inv, pat, | |
| ICE_BST_TCAM_KEY_SIZE)) | |
| return item; | |
| } | |
| return NULL; | |
| } | |
| /*** ICE_SID_RXPARSER_MARKER_PTYPE section ***/ | |
| /** | |
| * ice_ptype_mk_tcam_dump - dump an ptype marker tcam info | |
| * @hw: pointer to the hardware structure | |
| * @item: ptype marker tcam to dump | |
| */ | |
| static void ice_ptype_mk_tcam_dump(struct ice_hw *hw, | |
| struct ice_ptype_mk_tcam_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| int i; | |
| dev_info(dev, "address = %d\n", item->address); | |
| dev_info(dev, "ptype = %d\n", item->ptype); | |
| dev_info(dev, "key :"); | |
| for (i = 0; i < ICE_PTYPE_MK_TCAM_KEY_SIZE; i++) | |
| dev_info(dev, "%02x ", item->key[i]); | |
| dev_info(dev, "\n"); | |
| dev_info(dev, "key_inv:"); | |
| for (i = 0; i < ICE_PTYPE_MK_TCAM_KEY_SIZE; i++) | |
| dev_info(dev, "%02x ", item->key_inv[i]); | |
| dev_info(dev, "\n"); | |
| } | |
| static void ice_parse_ptype_mk_tcam_item(struct ice_hw *hw, u16 idx, | |
| void *item, void *data, int size) | |
| { | |
| memcpy(item, data, size); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_ptype_mk_tcam_dump(hw, | |
| (struct ice_ptype_mk_tcam_item *)item); | |
| } | |
| /** | |
| * ice_ptype_mk_tcam_table_get - create a ptype marker tcam table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Marker PType TCAM table. | |
| */ | |
| static | |
| struct ice_ptype_mk_tcam_item *ice_ptype_mk_tcam_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_MARKER_PTYPE, | |
| sizeof(struct ice_ptype_mk_tcam_item), | |
| ICE_PTYPE_MK_TCAM_TABLE_SIZE, | |
| ice_parse_ptype_mk_tcam_item, true); | |
| } | |
| /** | |
| * ice_ptype_mk_tcam_match - match a pattern on a ptype marker tcam table | |
| * @table: ptype marker tcam table to search | |
| * @pat: pattern to match | |
| * @len: length of the pattern | |
| * | |
| * Return: a pointer to the matching Marker PType item or NULL. | |
| */ | |
| struct ice_ptype_mk_tcam_item * | |
| ice_ptype_mk_tcam_match(struct ice_ptype_mk_tcam_item *table, | |
| u8 *pat, int len) | |
| { | |
| int i; | |
| for (i = 0; i < ICE_PTYPE_MK_TCAM_TABLE_SIZE; i++) { | |
| struct ice_ptype_mk_tcam_item *item = &table[i]; | |
| if (ice_ternary_match(item->key, item->key_inv, pat, len)) | |
| return item; | |
| } | |
| return NULL; | |
| } | |
| /*** ICE_SID_RXPARSER_MARKER_GRP section ***/ | |
| /** | |
| * ice_mk_grp_dump - dump an marker group item info | |
| * @hw: pointer to the hardware structure | |
| * @item: marker group item to dump | |
| */ | |
| static void ice_mk_grp_dump(struct ice_hw *hw, struct ice_mk_grp_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| int i; | |
| dev_info(dev, "index = %d\n", item->idx); | |
| dev_info(dev, "markers: "); | |
| for (i = 0; i < ICE_MK_COUNT_PER_GRP; i++) | |
| dev_info(dev, "%d ", item->markers[i]); | |
| dev_info(dev, "\n"); | |
| } | |
| static void ice_mk_grp_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_mk_grp_item *grp = item; | |
| u8 *buf = data; | |
| int i; | |
| grp->idx = idx; | |
| for (i = 0; i < ICE_MK_COUNT_PER_GRP; i++) | |
| grp->markers[i] = buf[i]; | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_mk_grp_dump(hw, grp); | |
| } | |
| /** | |
| * ice_mk_grp_table_get - create a marker group table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Marker Group ID table. | |
| */ | |
| static struct ice_mk_grp_item *ice_mk_grp_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_MARKER_GRP, | |
| sizeof(struct ice_mk_grp_item), | |
| ICE_MK_GRP_TABLE_SIZE, | |
| ice_mk_grp_parse_item, false); | |
| } | |
| /*** ICE_SID_RXPARSER_PROTO_GRP section ***/ | |
| static void ice_proto_off_dump(struct ice_hw *hw, | |
| struct ice_proto_off *po, int idx) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "proto %d\n", idx); | |
| dev_info(dev, "\tpolarity = %d\n", po->polarity); | |
| dev_info(dev, "\tproto_id = %d\n", po->proto_id); | |
| dev_info(dev, "\toffset = %d\n", po->offset); | |
| } | |
| /** | |
| * ice_proto_grp_dump - dump a proto group item info | |
| * @hw: pointer to the hardware structure | |
| * @item: proto group item to dump | |
| */ | |
| static void ice_proto_grp_dump(struct ice_hw *hw, | |
| struct ice_proto_grp_item *item) | |
| { | |
| int i; | |
| dev_info(ice_hw_to_dev(hw), "index = %d\n", item->idx); | |
| for (i = 0; i < ICE_PROTO_COUNT_PER_GRP; i++) | |
| ice_proto_off_dump(hw, &item->po[i], i); | |
| } | |
| #define ICE_PO_POL BIT(0) | |
| #define ICE_PO_PID GENMASK(8, 1) | |
| #define ICE_PO_OFF GENMASK(21, 12) | |
| /** | |
| * ice_proto_off_parse - parse 22 bits of Protocol entry | |
| * @po: pointer to the Protocol entry structure | |
| * @data: Protocol entry data to be parsed | |
| */ | |
| static void ice_proto_off_parse(struct ice_proto_off *po, u32 data) | |
| { | |
| po->polarity = FIELD_GET(ICE_PO_POL, data); | |
| po->proto_id = FIELD_GET(ICE_PO_PID, data); | |
| po->offset = FIELD_GET(ICE_PO_OFF, data); | |
| } | |
| /** | |
| * ice_proto_grp_parse_item - parse 192 bits of Protocol Group Table entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Protocol Group Table entry | |
| * @item: item of Protocol Group Table entry | |
| * @data: Protocol Group Table entry data to be parsed | |
| * @size: size of Protocol Group Table entry | |
| */ | |
| static void ice_proto_grp_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_proto_grp_item *grp = item; | |
| u8 *buf = (u8 *)data; | |
| u8 idd, off; | |
| u32 d32; | |
| int i; | |
| grp->idx = idx; | |
| for (i = 0; i < ICE_PROTO_COUNT_PER_GRP; i++) { | |
| idd = (ICE_PROTO_GRP_ITEM_SIZE * i) / BITS_PER_BYTE; | |
| off = (ICE_PROTO_GRP_ITEM_SIZE * i) % BITS_PER_BYTE; | |
| d32 = *((u32 *)&buf[idd]) >> off; | |
| ice_proto_off_parse(&grp->po[i], d32); | |
| } | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_proto_grp_dump(hw, grp); | |
| } | |
| /** | |
| * ice_proto_grp_table_get - create a proto group table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Protocol Group table. | |
| */ | |
| static struct ice_proto_grp_item *ice_proto_grp_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_PROTO_GRP, | |
| sizeof(struct ice_proto_grp_item), | |
| ICE_PROTO_GRP_TABLE_SIZE, | |
| ice_proto_grp_parse_item, false); | |
| } | |
| /*** ICE_SID_RXPARSER_FLAG_REDIR section ***/ | |
| /** | |
| * ice_flg_rd_dump - dump a flag redirect item info | |
| * @hw: pointer to the hardware structure | |
| * @item: flag redirect item to dump | |
| */ | |
| static void ice_flg_rd_dump(struct ice_hw *hw, struct ice_flg_rd_item *item) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| dev_info(dev, "index = %d\n", item->idx); | |
| dev_info(dev, "expose = %d\n", item->expose); | |
| dev_info(dev, "intr_flg_id = %d\n", item->intr_flg_id); | |
| } | |
| #define ICE_FRT_EXPO BIT(0) | |
| #define ICE_FRT_IFID GENMASK(6, 1) | |
| /** | |
| * ice_flg_rd_parse_item - parse 8 bits of Flag Redirect Table entry | |
| * @hw: pointer to the hardware structure | |
| * @idx: index of Flag Redirect Table entry | |
| * @item: item of Flag Redirect Table entry | |
| * @data: Flag Redirect Table entry data to be parsed | |
| * @size: size of Flag Redirect Table entry | |
| */ | |
| static void ice_flg_rd_parse_item(struct ice_hw *hw, u16 idx, void *item, | |
| void *data, int __maybe_unused size) | |
| { | |
| struct ice_flg_rd_item *rdi = item; | |
| u8 d8 = *(u8 *)data; | |
| rdi->idx = idx; | |
| rdi->expose = FIELD_GET(ICE_FRT_EXPO, d8); | |
| rdi->intr_flg_id = FIELD_GET(ICE_FRT_IFID, d8); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_flg_rd_dump(hw, rdi); | |
| } | |
| /** | |
| * ice_flg_rd_table_get - create a flag redirect table | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Flags Redirection table. | |
| */ | |
| static struct ice_flg_rd_item *ice_flg_rd_table_get(struct ice_hw *hw) | |
| { | |
| return ice_parser_create_table(hw, ICE_SID_RXPARSER_FLAG_REDIR, | |
| sizeof(struct ice_flg_rd_item), | |
| ICE_FLG_RD_TABLE_SIZE, | |
| ice_flg_rd_parse_item, false); | |
| } | |
| /** | |
| * ice_flg_redirect - redirect a parser flag to packet flag | |
| * @table: flag redirect table | |
| * @psr_flg: parser flag to redirect | |
| * | |
| * Return: flag or 0 if @psr_flag = 0. | |
| */ | |
| u64 ice_flg_redirect(struct ice_flg_rd_item *table, u64 psr_flg) | |
| { | |
| u64 flg = 0; | |
| int i; | |
| for (i = 0; i < ICE_FLG_RDT_SIZE; i++) { | |
| struct ice_flg_rd_item *item = &table[i]; | |
| if (!item->expose) | |
| continue; | |
| if (psr_flg & BIT(item->intr_flg_id)) | |
| flg |= BIT(i); | |
| } | |
| return flg; | |
| } | |
| /*** ICE_SID_XLT_KEY_BUILDER_SW, ICE_SID_XLT_KEY_BUILDER_ACL, | |
| * ICE_SID_XLT_KEY_BUILDER_FD and ICE_SID_XLT_KEY_BUILDER_RSS | |
| * sections ***/ | |
| static void ice_xlt_kb_entry_dump(struct ice_hw *hw, | |
| struct ice_xlt_kb_entry *entry, int idx) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| int i; | |
| dev_info(dev, "key builder entry %d\n", idx); | |
| dev_info(dev, "\txlt1_ad_sel = %d\n", entry->xlt1_ad_sel); | |
| dev_info(dev, "\txlt2_ad_sel = %d\n", entry->xlt2_ad_sel); | |
| for (i = 0; i < ICE_XLT_KB_FLAG0_14_CNT; i++) | |
| dev_info(dev, "\tflg%d_sel = %d\n", i, entry->flg0_14_sel[i]); | |
| dev_info(dev, "\txlt1_md_sel = %d\n", entry->xlt1_md_sel); | |
| dev_info(dev, "\txlt2_md_sel = %d\n", entry->xlt2_md_sel); | |
| } | |
| /** | |
| * ice_xlt_kb_dump - dump a xlt key build info | |
| * @hw: pointer to the hardware structure | |
| * @kb: key build to dump | |
| */ | |
| static void ice_xlt_kb_dump(struct ice_hw *hw, struct ice_xlt_kb *kb) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| int i; | |
| dev_info(dev, "xlt1_pm = %d\n", kb->xlt1_pm); | |
| dev_info(dev, "xlt2_pm = %d\n", kb->xlt2_pm); | |
| dev_info(dev, "prof_id_pm = %d\n", kb->prof_id_pm); | |
| dev_info(dev, "flag15 lo = 0x%08x\n", (u32)kb->flag15); | |
| dev_info(dev, "flag15 hi = 0x%08x\n", | |
| (u32)(kb->flag15 >> (sizeof(u32) * BITS_PER_BYTE))); | |
| for (i = 0; i < ICE_XLT_KB_TBL_CNT; i++) | |
| ice_xlt_kb_entry_dump(hw, &kb->entries[i], i); | |
| } | |
| #define ICE_XLT_KB_X1AS_S 32 /* offset for the 1st 64-bits field */ | |
| #define ICE_XLT_KB_X1AS_IDD (ICE_XLT_KB_X1AS_S / BITS_PER_BYTE) | |
| #define ICE_XLT_KB_X1AS_OFF (ICE_XLT_KB_X1AS_S % BITS_PER_BYTE) | |
| #define ICE_XLT_KB_X1AS GENMASK_ULL(34 - ICE_XLT_KB_X1AS_S, \ | |
| 32 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_X2AS GENMASK_ULL(37 - ICE_XLT_KB_X1AS_S, \ | |
| 35 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL00 GENMASK_ULL(46 - ICE_XLT_KB_X1AS_S, \ | |
| 38 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL01 GENMASK_ULL(55 - ICE_XLT_KB_X1AS_S, \ | |
| 47 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL02 GENMASK_ULL(64 - ICE_XLT_KB_X1AS_S, \ | |
| 56 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL03 GENMASK_ULL(73 - ICE_XLT_KB_X1AS_S, \ | |
| 65 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL04 GENMASK_ULL(82 - ICE_XLT_KB_X1AS_S, \ | |
| 74 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL05 GENMASK_ULL(91 - ICE_XLT_KB_X1AS_S, \ | |
| 83 - ICE_XLT_KB_X1AS_S) | |
| #define ICE_XLT_KB_FL06_S 92 /* offset for the 2nd 64-bits field */ | |
| #define ICE_XLT_KB_FL06_IDD (ICE_XLT_KB_FL06_S / BITS_PER_BYTE) | |
| #define ICE_XLT_KB_FL06_OFF (ICE_XLT_KB_FL06_S % BITS_PER_BYTE) | |
| #define ICE_XLT_KB_FL06 GENMASK_ULL(100 - ICE_XLT_KB_FL06_S, \ | |
| 92 - ICE_XLT_KB_FL06_S) | |
| #define ICE_XLT_KB_FL07 GENMASK_ULL(109 - ICE_XLT_KB_FL06_S, \ | |
| 101 - ICE_XLT_KB_FL06_S) | |
| #define ICE_XLT_KB_FL08 GENMASK_ULL(118 - ICE_XLT_KB_FL06_S, \ | |
| 110 - ICE_XLT_KB_FL06_S) | |
| #define ICE_XLT_KB_FL09 GENMASK_ULL(127 - ICE_XLT_KB_FL06_S, \ | |
| 119 - ICE_XLT_KB_FL06_S) | |
| #define ICE_XLT_KB_FL10 GENMASK_ULL(136 - ICE_XLT_KB_FL06_S, \ | |
| 128 - ICE_XLT_KB_FL06_S) | |
| #define ICE_XLT_KB_FL11 GENMASK_ULL(145 - ICE_XLT_KB_FL06_S, \ | |
| 137 - ICE_XLT_KB_FL06_S) | |
| #define ICE_XLT_KB_FL12_S 146 /* offset for the 3rd 64-bits field */ | |
| #define ICE_XLT_KB_FL12_IDD (ICE_XLT_KB_FL12_S / BITS_PER_BYTE) | |
| #define ICE_XLT_KB_FL12_OFF (ICE_XLT_KB_FL12_S % BITS_PER_BYTE) | |
| #define ICE_XLT_KB_FL12 GENMASK_ULL(154 - ICE_XLT_KB_FL12_S, \ | |
| 146 - ICE_XLT_KB_FL12_S) | |
| #define ICE_XLT_KB_FL13 GENMASK_ULL(163 - ICE_XLT_KB_FL12_S, \ | |
| 155 - ICE_XLT_KB_FL12_S) | |
| #define ICE_XLT_KB_FL14 GENMASK_ULL(181 - ICE_XLT_KB_FL12_S, \ | |
| 164 - ICE_XLT_KB_FL12_S) | |
| #define ICE_XLT_KB_X1MS GENMASK_ULL(186 - ICE_XLT_KB_FL12_S, \ | |
| 182 - ICE_XLT_KB_FL12_S) | |
| #define ICE_XLT_KB_X2MS GENMASK_ULL(191 - ICE_XLT_KB_FL12_S, \ | |
| 187 - ICE_XLT_KB_FL12_S) | |
| /** | |
| * ice_kb_entry_init - parse 192 bits of XLT Key Builder entry | |
| * @entry: pointer to the XLT Key Builder entry structure | |
| * @data: XLT Key Builder entry data to be parsed | |
| */ | |
| static void ice_kb_entry_init(struct ice_xlt_kb_entry *entry, u8 *data) | |
| { | |
| u8 i = 0; | |
| u64 d64; | |
| d64 = *((u64 *)&data[ICE_XLT_KB_X1AS_IDD]) >> ICE_XLT_KB_X1AS_OFF; | |
| entry->xlt1_ad_sel = FIELD_GET(ICE_XLT_KB_X1AS, d64); | |
| entry->xlt2_ad_sel = FIELD_GET(ICE_XLT_KB_X2AS, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL00, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL01, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL02, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL03, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL04, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL05, d64); | |
| d64 = *((u64 *)&data[ICE_XLT_KB_FL06_IDD]) >> ICE_XLT_KB_FL06_OFF; | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL06, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL07, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL08, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL09, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL10, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL11, d64); | |
| d64 = *((u64 *)&data[ICE_XLT_KB_FL12_IDD]) >> ICE_XLT_KB_FL12_OFF; | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL12, d64); | |
| entry->flg0_14_sel[i++] = FIELD_GET(ICE_XLT_KB_FL13, d64); | |
| entry->flg0_14_sel[i] = FIELD_GET(ICE_XLT_KB_FL14, d64); | |
| entry->xlt1_md_sel = FIELD_GET(ICE_XLT_KB_X1MS, d64); | |
| entry->xlt2_md_sel = FIELD_GET(ICE_XLT_KB_X2MS, d64); | |
| } | |
| #define ICE_XLT_KB_X1PM_OFF 0 | |
| #define ICE_XLT_KB_X2PM_OFF 1 | |
| #define ICE_XLT_KB_PIPM_OFF 2 | |
| #define ICE_XLT_KB_FL15_OFF 4 | |
| #define ICE_XLT_KB_TBL_OFF 12 | |
| /** | |
| * ice_parse_kb_data - parse 204 bits of XLT Key Build Table | |
| * @hw: pointer to the hardware structure | |
| * @kb: pointer to the XLT Key Build Table structure | |
| * @data: XLT Key Build Table data to be parsed | |
| */ | |
| static void ice_parse_kb_data(struct ice_hw *hw, struct ice_xlt_kb *kb, | |
| void *data) | |
| { | |
| u8 *buf = data; | |
| int i; | |
| kb->xlt1_pm = buf[ICE_XLT_KB_X1PM_OFF]; | |
| kb->xlt2_pm = buf[ICE_XLT_KB_X2PM_OFF]; | |
| kb->prof_id_pm = buf[ICE_XLT_KB_PIPM_OFF]; | |
| kb->flag15 = *(u64 *)&buf[ICE_XLT_KB_FL15_OFF]; | |
| for (i = 0; i < ICE_XLT_KB_TBL_CNT; i++) | |
| ice_kb_entry_init(&kb->entries[i], | |
| &buf[ICE_XLT_KB_TBL_OFF + | |
| i * ICE_XLT_KB_TBL_ENTRY_SIZE]); | |
| if (hw->debug_mask & ICE_DBG_PARSER) | |
| ice_xlt_kb_dump(hw, kb); | |
| } | |
| static struct ice_xlt_kb *ice_xlt_kb_get(struct ice_hw *hw, u32 sect_type) | |
| { | |
| struct ice_pkg_enum state = {}; | |
| struct ice_seg *seg = hw->seg; | |
| struct ice_xlt_kb *kb; | |
| void *data; | |
| if (!seg) | |
| return ERR_PTR(-EINVAL); | |
| kb = kzalloc_obj(*kb); | |
| if (!kb) | |
| return ERR_PTR(-ENOMEM); | |
| data = ice_pkg_enum_section(seg, &state, sect_type); | |
| if (!data) { | |
| ice_debug(hw, ICE_DBG_PARSER, "failed to find section type %d.\n", | |
| sect_type); | |
| kfree(kb); | |
| return ERR_PTR(-EINVAL); | |
| } | |
| ice_parse_kb_data(hw, kb, data); | |
| return kb; | |
| } | |
| /** | |
| * ice_xlt_kb_get_sw - create switch xlt key build | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Key Builder table for Switch. | |
| */ | |
| static struct ice_xlt_kb *ice_xlt_kb_get_sw(struct ice_hw *hw) | |
| { | |
| return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_SW); | |
| } | |
| /** | |
| * ice_xlt_kb_get_acl - create acl xlt key build | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Key Builder table for ACL. | |
| */ | |
| static struct ice_xlt_kb *ice_xlt_kb_get_acl(struct ice_hw *hw) | |
| { | |
| return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_ACL); | |
| } | |
| /** | |
| * ice_xlt_kb_get_fd - create fdir xlt key build | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Key Builder table for Flow Director. | |
| */ | |
| static struct ice_xlt_kb *ice_xlt_kb_get_fd(struct ice_hw *hw) | |
| { | |
| return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_FD); | |
| } | |
| /** | |
| * ice_xlt_kb_get_rss - create rss xlt key build | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated Key Builder table for RSS. | |
| */ | |
| static struct ice_xlt_kb *ice_xlt_kb_get_rss(struct ice_hw *hw) | |
| { | |
| return ice_xlt_kb_get(hw, ICE_SID_XLT_KEY_BUILDER_RSS); | |
| } | |
| #define ICE_XLT_KB_MASK GENMASK_ULL(5, 0) | |
| /** | |
| * ice_xlt_kb_flag_get - aggregate 64 bits packet flag into 16 bits xlt flag | |
| * @kb: xlt key build | |
| * @pkt_flag: 64 bits packet flag | |
| * | |
| * Return: XLT flag or 0 if @pkt_flag = 0. | |
| */ | |
| u16 ice_xlt_kb_flag_get(struct ice_xlt_kb *kb, u64 pkt_flag) | |
| { | |
| struct ice_xlt_kb_entry *entry = &kb->entries[0]; | |
| u16 flag = 0; | |
| int i; | |
| /* check flag 15 */ | |
| if (kb->flag15 & pkt_flag) | |
| flag = BIT(ICE_XLT_KB_FLAG0_14_CNT); | |
| /* check flag 0 - 14 */ | |
| for (i = 0; i < ICE_XLT_KB_FLAG0_14_CNT; i++) { | |
| /* only check first entry */ | |
| u16 idx = entry->flg0_14_sel[i] & ICE_XLT_KB_MASK; | |
| if (pkt_flag & BIT(idx)) | |
| flag |= (u16)BIT(i); | |
| } | |
| return flag; | |
| } | |
| /*** Parser API ***/ | |
| /** | |
| * ice_parser_create - create a parser instance | |
| * @hw: pointer to the hardware structure | |
| * | |
| * Return: a pointer to the allocated parser instance or ERR_PTR | |
| * in case of error. | |
| */ | |
| struct ice_parser *ice_parser_create(struct ice_hw *hw) | |
| { | |
| struct ice_parser *p; | |
| void *err; | |
| p = kzalloc_obj(*p); | |
| if (!p) | |
| return ERR_PTR(-ENOMEM); | |
| p->hw = hw; | |
| p->rt.psr = p; | |
| p->imem_table = ice_imem_table_get(hw); | |
| if (IS_ERR(p->imem_table)) { | |
| err = p->imem_table; | |
| goto err; | |
| } | |
| p->mi_table = ice_metainit_table_get(hw); | |
| if (IS_ERR(p->mi_table)) { | |
| err = p->mi_table; | |
| goto err; | |
| } | |
| p->pg_cam_table = ice_pg_cam_table_get(hw); | |
| if (IS_ERR(p->pg_cam_table)) { | |
| err = p->pg_cam_table; | |
| goto err; | |
| } | |
| p->pg_sp_cam_table = ice_pg_sp_cam_table_get(hw); | |
| if (IS_ERR(p->pg_sp_cam_table)) { | |
| err = p->pg_sp_cam_table; | |
| goto err; | |
| } | |
| p->pg_nm_cam_table = ice_pg_nm_cam_table_get(hw); | |
| if (IS_ERR(p->pg_nm_cam_table)) { | |
| err = p->pg_nm_cam_table; | |
| goto err; | |
| } | |
| p->pg_nm_sp_cam_table = ice_pg_nm_sp_cam_table_get(hw); | |
| if (IS_ERR(p->pg_nm_sp_cam_table)) { | |
| err = p->pg_nm_sp_cam_table; | |
| goto err; | |
| } | |
| p->bst_tcam_table = ice_bst_tcam_table_get(hw); | |
| if (IS_ERR(p->bst_tcam_table)) { | |
| err = p->bst_tcam_table; | |
| goto err; | |
| } | |
| p->bst_lbl_table = ice_bst_lbl_table_get(hw); | |
| if (IS_ERR(p->bst_lbl_table)) { | |
| err = p->bst_lbl_table; | |
| goto err; | |
| } | |
| p->ptype_mk_tcam_table = ice_ptype_mk_tcam_table_get(hw); | |
| if (IS_ERR(p->ptype_mk_tcam_table)) { | |
| err = p->ptype_mk_tcam_table; | |
| goto err; | |
| } | |
| p->mk_grp_table = ice_mk_grp_table_get(hw); | |
| if (IS_ERR(p->mk_grp_table)) { | |
| err = p->mk_grp_table; | |
| goto err; | |
| } | |
| p->proto_grp_table = ice_proto_grp_table_get(hw); | |
| if (IS_ERR(p->proto_grp_table)) { | |
| err = p->proto_grp_table; | |
| goto err; | |
| } | |
| p->flg_rd_table = ice_flg_rd_table_get(hw); | |
| if (IS_ERR(p->flg_rd_table)) { | |
| err = p->flg_rd_table; | |
| goto err; | |
| } | |
| p->xlt_kb_sw = ice_xlt_kb_get_sw(hw); | |
| if (IS_ERR(p->xlt_kb_sw)) { | |
| err = p->xlt_kb_sw; | |
| goto err; | |
| } | |
| p->xlt_kb_acl = ice_xlt_kb_get_acl(hw); | |
| if (IS_ERR(p->xlt_kb_acl)) { | |
| err = p->xlt_kb_acl; | |
| goto err; | |
| } | |
| p->xlt_kb_fd = ice_xlt_kb_get_fd(hw); | |
| if (IS_ERR(p->xlt_kb_fd)) { | |
| err = p->xlt_kb_fd; | |
| goto err; | |
| } | |
| p->xlt_kb_rss = ice_xlt_kb_get_rss(hw); | |
| if (IS_ERR(p->xlt_kb_rss)) { | |
| err = p->xlt_kb_rss; | |
| goto err; | |
| } | |
| return p; | |
| err: | |
| ice_parser_destroy(p); | |
| return err; | |
| } | |
| /** | |
| * ice_parser_destroy - destroy a parser instance | |
| * @psr: pointer to a parser instance | |
| */ | |
| void ice_parser_destroy(struct ice_parser *psr) | |
| { | |
| kfree(psr->imem_table); | |
| kfree(psr->mi_table); | |
| kfree(psr->pg_cam_table); | |
| kfree(psr->pg_sp_cam_table); | |
| kfree(psr->pg_nm_cam_table); | |
| kfree(psr->pg_nm_sp_cam_table); | |
| kfree(psr->bst_tcam_table); | |
| kfree(psr->bst_lbl_table); | |
| kfree(psr->ptype_mk_tcam_table); | |
| kfree(psr->mk_grp_table); | |
| kfree(psr->proto_grp_table); | |
| kfree(psr->flg_rd_table); | |
| kfree(psr->xlt_kb_sw); | |
| kfree(psr->xlt_kb_acl); | |
| kfree(psr->xlt_kb_fd); | |
| kfree(psr->xlt_kb_rss); | |
| kfree(psr); | |
| } | |
| /** | |
| * ice_parser_run - parse on a packet in binary and return the result | |
| * @psr: pointer to a parser instance | |
| * @pkt_buf: packet data | |
| * @pkt_len: packet length | |
| * @rslt: input/output parameter to save parser result. | |
| * | |
| * Return: 0 on success or errno. | |
| */ | |
| int ice_parser_run(struct ice_parser *psr, const u8 *pkt_buf, | |
| int pkt_len, struct ice_parser_result *rslt) | |
| { | |
| ice_parser_rt_reset(&psr->rt); | |
| ice_parser_rt_pktbuf_set(&psr->rt, pkt_buf, pkt_len); | |
| return ice_parser_rt_execute(&psr->rt, rslt); | |
| } | |
| /** | |
| * ice_parser_result_dump - dump a parser result info | |
| * @hw: pointer to the hardware structure | |
| * @rslt: parser result info to dump | |
| */ | |
| void ice_parser_result_dump(struct ice_hw *hw, struct ice_parser_result *rslt) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| int i; | |
| dev_info(dev, "ptype = %d\n", rslt->ptype); | |
| for (i = 0; i < rslt->po_num; i++) | |
| dev_info(dev, "proto = %d, offset = %d\n", | |
| rslt->po[i].proto_id, rslt->po[i].offset); | |
| dev_info(dev, "flags_psr = 0x%016llx\n", rslt->flags_psr); | |
| dev_info(dev, "flags_pkt = 0x%016llx\n", rslt->flags_pkt); | |
| dev_info(dev, "flags_sw = 0x%04x\n", rslt->flags_sw); | |
| dev_info(dev, "flags_fd = 0x%04x\n", rslt->flags_fd); | |
| dev_info(dev, "flags_rss = 0x%04x\n", rslt->flags_rss); | |
| } | |
| #define ICE_BT_VLD_KEY 0xFF | |
| #define ICE_BT_INV_KEY 0xFE | |
| static void ice_bst_dvm_set(struct ice_parser *psr, enum ice_lbl_type type, | |
| bool on) | |
| { | |
| u16 i = 0; | |
| while (true) { | |
| struct ice_bst_tcam_item *item; | |
| u8 key; | |
| item = ice_bst_tcam_search(psr->bst_tcam_table, | |
| psr->bst_lbl_table, | |
| type, &i); | |
| if (!item) | |
| break; | |
| key = on ? ICE_BT_VLD_KEY : ICE_BT_INV_KEY; | |
| item->key[ICE_BT_VM_OFF] = key; | |
| item->key_inv[ICE_BT_VM_OFF] = key; | |
| i++; | |
| } | |
| } | |
| /** | |
| * ice_parser_dvm_set - configure double vlan mode for parser | |
| * @psr: pointer to a parser instance | |
| * @on: true to turn on; false to turn off | |
| */ | |
| void ice_parser_dvm_set(struct ice_parser *psr, bool on) | |
| { | |
| ice_bst_dvm_set(psr, ICE_LBL_BST_TYPE_DVM, on); | |
| ice_bst_dvm_set(psr, ICE_LBL_BST_TYPE_SVM, !on); | |
| } | |
| static int ice_tunnel_port_set(struct ice_parser *psr, enum ice_lbl_type type, | |
| u16 udp_port, bool on) | |
| { | |
| u8 *buf = (u8 *)&udp_port; | |
| u16 i = 0; | |
| while (true) { | |
| struct ice_bst_tcam_item *item; | |
| item = ice_bst_tcam_search(psr->bst_tcam_table, | |
| psr->bst_lbl_table, | |
| type, &i); | |
| if (!item) | |
| break; | |
| /* found empty slot to add */ | |
| if (on && item->key[ICE_BT_TUN_PORT_OFF_H] == ICE_BT_INV_KEY && | |
| item->key_inv[ICE_BT_TUN_PORT_OFF_H] == ICE_BT_INV_KEY) { | |
| item->key_inv[ICE_BT_TUN_PORT_OFF_L] = | |
| buf[ICE_UDP_PORT_OFF_L]; | |
| item->key_inv[ICE_BT_TUN_PORT_OFF_H] = | |
| buf[ICE_UDP_PORT_OFF_H]; | |
| item->key[ICE_BT_TUN_PORT_OFF_L] = | |
| ICE_BT_VLD_KEY - buf[ICE_UDP_PORT_OFF_L]; | |
| item->key[ICE_BT_TUN_PORT_OFF_H] = | |
| ICE_BT_VLD_KEY - buf[ICE_UDP_PORT_OFF_H]; | |
| return 0; | |
| /* found a matched slot to delete */ | |
| } else if (!on && | |
| (item->key_inv[ICE_BT_TUN_PORT_OFF_L] == | |
| buf[ICE_UDP_PORT_OFF_L] || | |
| item->key_inv[ICE_BT_TUN_PORT_OFF_H] == | |
| buf[ICE_UDP_PORT_OFF_H])) { | |
| item->key_inv[ICE_BT_TUN_PORT_OFF_L] = ICE_BT_VLD_KEY; | |
| item->key_inv[ICE_BT_TUN_PORT_OFF_H] = ICE_BT_INV_KEY; | |
| item->key[ICE_BT_TUN_PORT_OFF_L] = ICE_BT_VLD_KEY; | |
| item->key[ICE_BT_TUN_PORT_OFF_H] = ICE_BT_INV_KEY; | |
| return 0; | |
| } | |
| i++; | |
| } | |
| return -EINVAL; | |
| } | |
| /** | |
| * ice_parser_vxlan_tunnel_set - configure vxlan tunnel for parser | |
| * @psr: pointer to a parser instance | |
| * @udp_port: vxlan tunnel port in UDP header | |
| * @on: true to turn on; false to turn off | |
| * | |
| * Return: 0 on success or errno on failure. | |
| */ | |
| int ice_parser_vxlan_tunnel_set(struct ice_parser *psr, | |
| u16 udp_port, bool on) | |
| { | |
| return ice_tunnel_port_set(psr, ICE_LBL_BST_TYPE_VXLAN, udp_port, on); | |
| } | |
| /** | |
| * ice_parser_geneve_tunnel_set - configure geneve tunnel for parser | |
| * @psr: pointer to a parser instance | |
| * @udp_port: geneve tunnel port in UDP header | |
| * @on: true to turn on; false to turn off | |
| * | |
| * Return: 0 on success or errno on failure. | |
| */ | |
| int ice_parser_geneve_tunnel_set(struct ice_parser *psr, | |
| u16 udp_port, bool on) | |
| { | |
| return ice_tunnel_port_set(psr, ICE_LBL_BST_TYPE_GENEVE, udp_port, on); | |
| } | |
| /** | |
| * ice_parser_ecpri_tunnel_set - configure ecpri tunnel for parser | |
| * @psr: pointer to a parser instance | |
| * @udp_port: ecpri tunnel port in UDP header | |
| * @on: true to turn on; false to turn off | |
| * | |
| * Return: 0 on success or errno on failure. | |
| */ | |
| int ice_parser_ecpri_tunnel_set(struct ice_parser *psr, | |
| u16 udp_port, bool on) | |
| { | |
| return ice_tunnel_port_set(psr, ICE_LBL_BST_TYPE_UDP_ECPRI, | |
| udp_port, on); | |
| } | |
| /** | |
| * ice_nearest_proto_id - find nearest protocol ID | |
| * @rslt: pointer to a parser result instance | |
| * @offset: a min value for the protocol offset | |
| * @proto_id: the protocol ID (output) | |
| * @proto_off: the protocol offset (output) | |
| * | |
| * From the protocols in @rslt, find the nearest protocol that has offset | |
| * larger than @offset. | |
| * | |
| * Return: if true, the protocol's ID and offset | |
| */ | |
| static bool ice_nearest_proto_id(struct ice_parser_result *rslt, u16 offset, | |
| u8 *proto_id, u16 *proto_off) | |
| { | |
| u16 dist = U16_MAX; | |
| u8 proto = 0; | |
| int i; | |
| for (i = 0; i < rslt->po_num; i++) { | |
| if (offset < rslt->po[i].offset) | |
| continue; | |
| if (offset - rslt->po[i].offset < dist) { | |
| proto = rslt->po[i].proto_id; | |
| dist = offset - rslt->po[i].offset; | |
| } | |
| } | |
| if (dist % 2) | |
| return false; | |
| *proto_id = proto; | |
| *proto_off = dist; | |
| return true; | |
| } | |
| /* default flag mask to cover GTP_EH_PDU, GTP_EH_PDU_LINK and TUN2 | |
| * In future, the flag masks should learn from DDP | |
| */ | |
| #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_SW 0x4002 | |
| #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_ACL 0x0000 | |
| #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_FD 0x6080 | |
| #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_RSS 0x6010 | |
| /** | |
| * ice_parser_profile_init - initialize a FXP profile based on parser result | |
| * @rslt: a instance of a parser result | |
| * @pkt_buf: packet data buffer | |
| * @msk_buf: packet mask buffer | |
| * @buf_len: packet length | |
| * @blk: FXP pipeline stage | |
| * @prof: input/output parameter to save the profile | |
| * | |
| * Return: 0 on success or errno on failure. | |
| */ | |
| int ice_parser_profile_init(struct ice_parser_result *rslt, | |
| const u8 *pkt_buf, const u8 *msk_buf, | |
| int buf_len, enum ice_block blk, | |
| struct ice_parser_profile *prof) | |
| { | |
| u8 proto_id = U8_MAX; | |
| u16 proto_off = 0; | |
| u16 off; | |
| if (rslt->ptype >= ICE_FLOW_PTYPE_MAX) | |
| return -EINVAL; | |
| memset(prof, 0, sizeof(*prof)); | |
| set_bit(rslt->ptype, prof->ptypes); | |
| if (blk == ICE_BLK_SW) { | |
| prof->flags = rslt->flags_sw; | |
| prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_SW; | |
| } else if (blk == ICE_BLK_ACL) { | |
| prof->flags = rslt->flags_acl; | |
| prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_ACL; | |
| } else if (blk == ICE_BLK_FD) { | |
| prof->flags = rslt->flags_fd; | |
| prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_FD; | |
| } else if (blk == ICE_BLK_RSS) { | |
| prof->flags = rslt->flags_rss; | |
| prof->flags_msk = ICE_KEYBUILD_FLAG_MASK_DEFAULT_RSS; | |
| } else { | |
| return -EINVAL; | |
| } | |
| for (off = 0; off < buf_len - 1; off++) { | |
| if (msk_buf[off] == 0 && msk_buf[off + 1] == 0) | |
| continue; | |
| if (!ice_nearest_proto_id(rslt, off, &proto_id, &proto_off)) | |
| continue; | |
| if (prof->fv_num >= ICE_PARSER_FV_MAX) | |
| return -EINVAL; | |
| prof->fv[prof->fv_num].proto_id = proto_id; | |
| prof->fv[prof->fv_num].offset = proto_off; | |
| prof->fv[prof->fv_num].spec = *(const u16 *)&pkt_buf[off]; | |
| prof->fv[prof->fv_num].msk = *(const u16 *)&msk_buf[off]; | |
| prof->fv_num++; | |
| } | |
| return 0; | |
| } | |
| /** | |
| * ice_parser_profile_dump - dump an FXP profile info | |
| * @hw: pointer to the hardware structure | |
| * @prof: profile info to dump | |
| */ | |
| void ice_parser_profile_dump(struct ice_hw *hw, | |
| struct ice_parser_profile *prof) | |
| { | |
| struct device *dev = ice_hw_to_dev(hw); | |
| u16 i; | |
| dev_info(dev, "ptypes:\n"); | |
| for (i = 0; i < ICE_FLOW_PTYPE_MAX; i++) | |
| if (test_bit(i, prof->ptypes)) | |
| dev_info(dev, "\t%u\n", i); | |
| for (i = 0; i < prof->fv_num; i++) | |
| dev_info(dev, "proto = %u, offset = %2u, spec = 0x%04x, mask = 0x%04x\n", | |
| prof->fv[i].proto_id, prof->fv[i].offset, | |
| prof->fv[i].spec, prof->fv[i].msk); | |
| dev_info(dev, "flags = 0x%04x\n", prof->flags); | |
| dev_info(dev, "flags_msk = 0x%04x\n", prof->flags_msk); | |
| } |