1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2024 Intel Corporation */ 3 4 #include "ice_common.h" 5 6 struct ice_pkg_sect_hdr { 7 __le16 count; 8 __le16 offset; 9 }; 10 11 /** 12 * ice_parser_sect_item_get - parse an item from a section 13 * @sect_type: section type 14 * @section: section object 15 * @index: index of the item to get 16 * @offset: dummy as prototype of ice_pkg_enum_entry's last parameter 17 * 18 * Return: a pointer to the item or NULL. 19 */ ice_parser_sect_item_get(u32 sect_type,void * section,u32 index,u32 __maybe_unused * offset)20 static 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 section 81 * @hw: pointer to the hardware structure 82 * @sect_type: section type 83 * @item_size: item size in bytes 84 * @length: number of items in the table to create 85 * @parse_item: the function to parse the item 86 * @no_offset: ignore header offset, calculate index from 0 87 * 88 * Return: a pointer to the allocated table or ERR_PTR. 89 */ 90 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)91 ice_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 ***/ ice_imem_bst_bm_dump(struct ice_hw * hw,struct ice_bst_main * bm)132 static 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 ice_imem_bst_kb_dump(struct ice_hw * hw,struct ice_bst_keybuilder * kb)143 static 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 ice_imem_np_kb_dump(struct ice_hw * hw,struct ice_np_keybuilder * kb)153 static 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 ice_imem_pg_kb_dump(struct ice_hw * hw,struct ice_pg_keybuilder * kb)164 static 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 ice_imem_alu_dump(struct ice_hw * hw,struct ice_alu * alu,int index)181 static 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 info 208 * @hw: pointer to the hardware structure 209 * @item: imem item to dump 210 */ ice_imem_dump(struct ice_hw * hw,struct ice_imem_item * item)211 static 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 Main 233 * @bm: pointer to the Boost Main structure 234 * @data: Boost Main data to be parsed 235 */ ice_imem_bm_init(struct ice_bst_main * bm,u8 data)236 static 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 Build 249 * @bkb: pointer to the Boost Main Build structure 250 * @data: Boost Main Build data to be parsed 251 */ ice_imem_bkb_init(struct ice_bst_keybuilder * bkb,u16 data)252 static 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 Build 264 * @kb: pointer to the Next Protocol Key Build structure 265 * @data: Next Protocol Key Build data to be parsed 266 */ ice_imem_npkb_init(struct ice_np_keybuilder * kb,u32 data)267 static 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 Build 286 * @kb: pointer to the Parse Graph Key Build structure 287 * @data: Parse Graph Key Build data to be parsed 288 */ ice_imem_pgkb_init(struct ice_pg_keybuilder * kb,u64 data)289 static 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 entry 329 * @alu: pointer to the ALU entry structure 330 * @data: ALU entry data to be parsed 331 * @off: offset of the ALU entry data 332 */ ice_imem_alu_init(struct ice_alu * alu,u8 * data,u8 off)333 static 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 0 366 #define ICE_IMEM_BKB_S 4 367 #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 16 371 #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 34 374 #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 69 377 #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 165 380 #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 357 383 #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 entry 388 * @hw: pointer to the hardware structure 389 * @idx: index of IMEM entry 390 * @item: item of IMEM entry 391 * @data: IMEM entry data to be parsed 392 * @size: size of IMEM entry 393 */ ice_imem_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)394 static 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 table 432 * @hw: pointer to the hardware structure 433 * 434 * Return: a pointer to the allocated IMEM table. 435 */ ice_imem_table_get(struct ice_hw * hw)436 static 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 info 447 * @hw: pointer to the hardware structure 448 * @item: metainit item to dump 449 */ ice_metainit_dump(struct ice_hw * hw,struct ice_metainit_item * item)450 static 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 entry 528 * @hw: pointer to the hardware structure 529 * @idx: index of Metadata Init entry 530 * @item: item of Metadata Init entry 531 * @data: Metadata Init entry data to be parsed 532 * @size: size of Metadata Init entry 533 */ ice_metainit_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)534 static 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 table 588 * @hw: pointer to the hardware structure 589 * 590 * Return: a pointer to the allocated Metadata initialization table. 591 */ ice_metainit_table_get(struct ice_hw * hw)592 static 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 type 602 * @tcam_table: the TCAM table 603 * @lbl_table: the lbl table to search 604 * @type: the type we need to match against 605 * @start: start searching from this index 606 * 607 * Return: a pointer to the matching BOOST TCAM item or NULL. 608 */ 609 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)610 ice_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_CAM 628 * sections ***/ ice_pg_cam_key_dump(struct ice_hw * hw,struct ice_pg_cam_key * key)629 static 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 ice_pg_nm_cam_key_dump(struct ice_hw * hw,struct ice_pg_nm_cam_key * key)645 static 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 ice_pg_cam_action_dump(struct ice_hw * hw,struct ice_pg_cam_action * action)661 static 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 info 680 * @hw: pointer to the hardware structure 681 * @item: parse graph cam to dump 682 */ ice_pg_cam_dump(struct ice_hw * hw,struct ice_pg_cam_item * item)683 static 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 info 692 * @hw: pointer to the hardware structure 693 * @item: parse graph no match cam to dump 694 */ ice_pg_nm_cam_dump(struct ice_hw * hw,struct ice_pg_nm_cam_item * item)695 static 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 Action 715 * @action: pointer to the Parse Graph CAM Action structure 716 * @data: Parse Graph CAM Action data to be parsed 717 */ ice_pg_cam_action_init(struct ice_pg_cam_action * action,u64 data)718 static 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 Key 743 * @key: pointer to the Parse Graph NoMatch CAM Key structure 744 * @data: Parse Graph NoMatch CAM Key data to be parsed 745 */ ice_pg_nm_cam_key_init(struct ice_pg_nm_cam_key * key,u64 data)746 static 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 else 758 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 Key 780 * @key: pointer to the Parse Graph CAM Key structure 781 * @data: Parse Graph CAM Key data to be parsed 782 */ ice_pg_cam_key_init(struct ice_pg_cam_key * key,u8 * data)783 static 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 else 797 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 73 807 #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 Entry 812 * @hw: pointer to the hardware structure 813 * @idx: index of Parse Graph CAM Entry 814 * @item: item of Parse Graph CAM Entry 815 * @data: Parse Graph CAM Entry data to be parsed 816 * @size: size of Parse Graph CAM Entry 817 */ ice_pg_cam_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)818 static 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 56 837 #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 Entry 841 * @hw: pointer to the hardware structure 842 * @idx: index of Parse Graph Spill CAM Entry 843 * @item: item of Parse Graph Spill CAM Entry 844 * @data: Parse Graph Spill CAM Entry data to be parsed 845 * @size: size of Parse Graph Spill CAM Entry 846 */ ice_pg_sp_cam_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)847 static 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 41 866 #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 Entry 871 * @hw: pointer to the hardware structure 872 * @idx: index of Parse Graph NoMatch CAM Entry 873 * @item: item of Parse Graph NoMatch CAM Entry 874 * @data: Parse Graph NoMatch CAM Entry data to be parsed 875 * @size: size of Parse Graph NoMatch CAM Entry 876 */ ice_pg_nm_cam_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)877 static 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 56 897 #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 Spill 902 * CAM Entry 903 * @hw: pointer to the hardware structure 904 * @idx: index of Parse Graph NoMatch Spill CAM Entry 905 * @item: item of Parse Graph NoMatch Spill CAM Entry 906 * @data: Parse Graph NoMatch Spill CAM Entry data to be parsed 907 * @size: size of Parse Graph NoMatch Spill CAM Entry 908 */ ice_pg_nm_sp_cam_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)909 static 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 table 932 * @hw: pointer to the hardware structure 933 * 934 * Return: a pointer to the allocated Parse Graph CAM table. 935 */ ice_pg_cam_table_get(struct ice_hw * hw)936 static 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 table 946 * @hw: pointer to the hardware structure 947 * 948 * Return: a pointer to the allocated Parse Graph Spill CAM table. 949 */ ice_pg_sp_cam_table_get(struct ice_hw * hw)950 static 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 table 960 * @hw: pointer to the hardware structure 961 * 962 * Return: a pointer to the allocated Parse Graph No Match CAM table. 963 */ ice_pg_nm_cam_table_get(struct ice_hw * hw)964 static 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 table 974 * @hw: pointer to the hardware structure 975 * 976 * Return: a pointer to the allocated Parse Graph No Match Spill CAM table. 977 */ ice_pg_nm_sp_cam_table_get(struct ice_hw * hw)978 static 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 __ice_pg_cam_match(struct ice_pg_cam_item * item,struct ice_pg_cam_key * key)986 static 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 __ice_pg_nm_cam_match(struct ice_pg_nm_cam_item * item,struct ice_pg_cam_key * key)993 static 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 key 1002 * @table: parse graph cam table to search 1003 * @size: cam table size 1004 * @key: search key 1005 * 1006 * Return: a pointer to the matching PG CAM item or NULL. 1007 */ ice_pg_cam_match(struct ice_pg_cam_item * table,int size,struct ice_pg_cam_key * key)1008 struct 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 key 1025 * @table: parse graph no match cam table to search 1026 * @size: cam table size 1027 * @key: search key 1028 * 1029 * Return: a pointer to the matching PG No Match CAM item or NULL. 1030 */ 1031 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)1032 ice_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_inv 1049 * 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 == 1 1052 * Key == 1 and Key_inv == 0 : Match on bit == 0 1053 * Key == 1 and Key_inv == 1 : Always match (Don't care) 1054 * 1055 * Return: true if all bits match, false otherwise. 1056 */ ice_ternary_match_byte(u8 key,u8 key_inv,u8 pat)1057 static 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 ice_ternary_match(const u8 * key,const u8 * key_inv,const u8 * pat,int len)1077 static 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 ***/ ice_bst_np_kb_dump(struct ice_hw * hw,struct ice_np_keybuilder * kb)1090 static 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 ice_bst_pg_kb_dump(struct ice_hw * hw,struct ice_pg_keybuilder * kb)1100 static 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 ice_bst_alu_dump(struct ice_hw * hw,struct ice_alu * alu,int idx)1116 static 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 info 1142 * @hw: pointer to the hardware structure 1143 * @item: boost tcam to dump 1144 */ ice_bst_tcam_dump(struct ice_hw * hw,struct ice_bst_tcam_item * item)1145 static 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 ice_lbl_dump(struct ice_hw * hw,struct ice_lbl_item * item)1175 static 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 entry 1211 * @alu: pointer to the ALU entry structure 1212 * @data: ALU entry data to be parsed 1213 * @off: offset of the ALU entry data 1214 */ ice_bst_alu_init(struct ice_alu * alu,u8 * data,u8 off)1215 static 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 Build 1259 * @kb: pointer to the Parse Graph Key Build structure 1260 * @data: Parse Graph Key Build data to be parsed 1261 */ ice_bst_pgkb_init(struct ice_pg_keybuilder * kb,u64 data)1262 static 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 Build 1281 * @kb: pointer to the Next Protocol Key Build structure 1282 * @data: Next Protocol Key Build data to be parsed 1283 */ ice_bst_npkb_init(struct ice_np_keybuilder * kb,u32 data)1284 static 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 32 1292 #define ICE_BT_KEY_IDD (ICE_BT_KEY_S / BITS_PER_BYTE) 1293 #define ICE_BT_KIV_S 192 1294 #define ICE_BT_KIV_IDD (ICE_BT_KIV_S / BITS_PER_BYTE) 1295 #define ICE_BT_HIG_S 352 1296 #define ICE_BT_HIG_IDD (ICE_BT_HIG_S / BITS_PER_BYTE) 1297 #define ICE_BT_PGP_S 360 1298 #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 362 1301 #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 380 1304 #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 415 1307 #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 511 1310 #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 607 1313 #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 entry 1318 * @hw: pointer to the hardware structure 1319 * @idx: index of Boost TCAM entry 1320 * @item: item of Boost TCAM entry 1321 * @data: Boost TCAM entry data to be parsed 1322 * @size: size of Boost TCAM entry 1323 */ ice_bst_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)1324 static 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 table 1357 * @hw: pointer to the hardware structure 1358 * 1359 * Return: a pointer to the allocated Boost TCAM table. 1360 */ ice_bst_tcam_table_get(struct ice_hw * hw)1361 static 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 ice_parse_lbl_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)1369 static 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 table 1395 * @hw: pointer to the hardware structure 1396 * 1397 * Return: a pointer to the allocated Boost label table. 1398 */ ice_bst_lbl_table_get(struct ice_hw * hw)1399 static 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 table 1409 * @tcam_table: boost tcam table to search 1410 * @pat: pattern to match 1411 * 1412 * Return: a pointer to the matching Boost TCAM item or NULL. 1413 */ 1414 struct ice_bst_tcam_item * ice_bst_tcam_match(struct ice_bst_tcam_item * tcam_table,u8 * pat)1415 ice_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 info 1435 * @hw: pointer to the hardware structure 1436 * @item: ptype marker tcam to dump 1437 */ ice_ptype_mk_tcam_dump(struct ice_hw * hw,struct ice_ptype_mk_tcam_item * item)1438 static 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 ice_parse_ptype_mk_tcam_item(struct ice_hw * hw,u16 idx,void * item,void * data,int size)1460 static 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 table 1472 * @hw: pointer to the hardware structure 1473 * 1474 * Return: a pointer to the allocated Marker PType TCAM table. 1475 */ 1476 static ice_ptype_mk_tcam_table_get(struct ice_hw * hw)1477 struct 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 table 1487 * @table: ptype marker tcam table to search 1488 * @pat: pattern to match 1489 * @len: length of the pattern 1490 * 1491 * Return: a pointer to the matching Marker PType item or NULL. 1492 */ 1493 struct ice_ptype_mk_tcam_item * ice_ptype_mk_tcam_match(struct ice_ptype_mk_tcam_item * table,u8 * pat,int len)1494 ice_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 info 1512 * @hw: pointer to the hardware structure 1513 * @item: marker group item to dump 1514 */ ice_mk_grp_dump(struct ice_hw * hw,struct ice_mk_grp_item * item)1515 static 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 ice_mk_grp_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)1529 static 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 table 1547 * @hw: pointer to the hardware structure 1548 * 1549 * Return: a pointer to the allocated Marker Group ID table. 1550 */ ice_mk_grp_table_get(struct ice_hw * hw)1551 static 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 ***/ ice_proto_off_dump(struct ice_hw * hw,struct ice_proto_off * po,int idx)1560 static 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 info 1573 * @hw: pointer to the hardware structure 1574 * @item: proto group item to dump 1575 */ ice_proto_grp_dump(struct ice_hw * hw,struct ice_proto_grp_item * item)1576 static 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 entry 1593 * @po: pointer to the Protocol entry structure 1594 * @data: Protocol entry data to be parsed 1595 */ ice_proto_off_parse(struct ice_proto_off * po,u32 data)1596 static 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 entry 1605 * @hw: pointer to the hardware structure 1606 * @idx: index of Protocol Group Table entry 1607 * @item: item of Protocol Group Table entry 1608 * @data: Protocol Group Table entry data to be parsed 1609 * @size: size of Protocol Group Table entry 1610 */ ice_proto_grp_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)1611 static 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 table 1635 * @hw: pointer to the hardware structure 1636 * 1637 * Return: a pointer to the allocated Protocol Group table. 1638 */ ice_proto_grp_table_get(struct ice_hw * hw)1639 static 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 info 1650 * @hw: pointer to the hardware structure 1651 * @item: flag redirect item to dump 1652 */ ice_flg_rd_dump(struct ice_hw * hw,struct ice_flg_rd_item * item)1653 static 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 entry 1667 * @hw: pointer to the hardware structure 1668 * @idx: index of Flag Redirect Table entry 1669 * @item: item of Flag Redirect Table entry 1670 * @data: Flag Redirect Table entry data to be parsed 1671 * @size: size of Flag Redirect Table entry 1672 */ ice_flg_rd_parse_item(struct ice_hw * hw,u16 idx,void * item,void * data,int __maybe_unused size)1673 static 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 table 1689 * @hw: pointer to the hardware structure 1690 * 1691 * Return: a pointer to the allocated Flags Redirection table. 1692 */ ice_flg_rd_table_get(struct ice_hw * hw)1693 static 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 flag 1703 * @table: flag redirect table 1704 * @psr_flg: parser flag to redirect 1705 * 1706 * Return: flag or 0 if @psr_flag = 0. 1707 */ ice_flg_redirect(struct ice_flg_rd_item * table,u64 psr_flg)1708 u64 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_RSS 1728 * sections ***/ ice_xlt_kb_entry_dump(struct ice_hw * hw,struct ice_xlt_kb_entry * entry,int idx)1729 static 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 info 1748 * @hw: pointer to the hardware structure 1749 * @kb: key build to dump 1750 */ ice_xlt_kb_dump(struct ice_hw * hw,struct ice_xlt_kb * kb)1751 static 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 entry 1817 * @entry: pointer to the XLT Key Builder entry structure 1818 * @data: XLT Key Builder entry data to be parsed 1819 */ ice_kb_entry_init(struct ice_xlt_kb_entry * entry,u8 * data)1820 static 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 0 1857 #define ICE_XLT_KB_X2PM_OFF 1 1858 #define ICE_XLT_KB_PIPM_OFF 2 1859 #define ICE_XLT_KB_FL15_OFF 4 1860 #define ICE_XLT_KB_TBL_OFF 12 1861 1862 /** 1863 * ice_parse_kb_data - parse 204 bits of XLT Key Build Table 1864 * @hw: pointer to the hardware structure 1865 * @kb: pointer to the XLT Key Build Table structure 1866 * @data: XLT Key Build Table data to be parsed 1867 */ ice_parse_kb_data(struct ice_hw * hw,struct ice_xlt_kb * kb,void * data)1868 static 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 ice_xlt_kb_get(struct ice_hw * hw,u32 sect_type)1888 static 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 build 1917 * @hw: pointer to the hardware structure 1918 * 1919 * Return: a pointer to the allocated Key Builder table for Switch. 1920 */ ice_xlt_kb_get_sw(struct ice_hw * hw)1921 static 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 build 1928 * @hw: pointer to the hardware structure 1929 * 1930 * Return: a pointer to the allocated Key Builder table for ACL. 1931 */ ice_xlt_kb_get_acl(struct ice_hw * hw)1932 static 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 build 1939 * @hw: pointer to the hardware structure 1940 * 1941 * Return: a pointer to the allocated Key Builder table for Flow Director. 1942 */ ice_xlt_kb_get_fd(struct ice_hw * hw)1943 static 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 build 1950 * @hw: pointer to the hardware structure 1951 * 1952 * Return: a pointer to the allocated Key Builder table for RSS. 1953 */ ice_xlt_kb_get_rss(struct ice_hw * hw)1954 static 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 flag 1963 * @kb: xlt key build 1964 * @pkt_flag: 64 bits packet flag 1965 * 1966 * Return: XLT flag or 0 if @pkt_flag = 0. 1967 */ ice_xlt_kb_flag_get(struct ice_xlt_kb * kb,u64 pkt_flag)1968 u16 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 instance 1993 * @hw: pointer to the hardware structure 1994 * 1995 * Return: a pointer to the allocated parser instance or ERR_PTR 1996 * in case of error. 1997 */ ice_parser_create(struct ice_hw * hw)1998 struct 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; 2107 err: 2108 ice_parser_destroy(p); 2109 return err; 2110 } 2111 2112 /** 2113 * ice_parser_destroy - destroy a parser instance 2114 * @psr: pointer to a parser instance 2115 */ ice_parser_destroy(struct ice_parser * psr)2116 void 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 result 2140 * @psr: pointer to a parser instance 2141 * @pkt_buf: packet data 2142 * @pkt_len: packet length 2143 * @rslt: input/output parameter to save parser result. 2144 * 2145 * Return: 0 on success or errno. 2146 */ ice_parser_run(struct ice_parser * psr,const u8 * pkt_buf,int pkt_len,struct ice_parser_result * rslt)2147 int 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 info 2158 * @hw: pointer to the hardware structure 2159 * @rslt: parser result info to dump 2160 */ ice_parser_result_dump(struct ice_hw * hw,struct ice_parser_result * rslt)2161 void 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 0xFF 2179 #define ICE_BT_INV_KEY 0xFE 2180 ice_bst_dvm_set(struct ice_parser * psr,enum ice_lbl_type type,bool on)2181 static 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 parser 2205 * @psr: pointer to a parser instance 2206 * @on: true to turn on; false to turn off 2207 */ ice_parser_dvm_set(struct ice_parser * psr,bool on)2208 void 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 ice_tunnel_port_set(struct ice_parser * psr,enum ice_lbl_type type,u16 udp_port,bool on)2214 static 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 parser 2265 * @psr: pointer to a parser instance 2266 * @udp_port: vxlan tunnel port in UDP header 2267 * @on: true to turn on; false to turn off 2268 * 2269 * Return: 0 on success or errno on failure. 2270 */ ice_parser_vxlan_tunnel_set(struct ice_parser * psr,u16 udp_port,bool on)2271 int 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 parser 2279 * @psr: pointer to a parser instance 2280 * @udp_port: geneve tunnel port in UDP header 2281 * @on: true to turn on; false to turn off 2282 * 2283 * Return: 0 on success or errno on failure. 2284 */ ice_parser_geneve_tunnel_set(struct ice_parser * psr,u16 udp_port,bool on)2285 int 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 parser 2293 * @psr: pointer to a parser instance 2294 * @udp_port: ecpri tunnel port in UDP header 2295 * @on: true to turn on; false to turn off 2296 * 2297 * Return: 0 on success or errno on failure. 2298 */ ice_parser_ecpri_tunnel_set(struct ice_parser * psr,u16 udp_port,bool on)2299 int 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 ID 2308 * @rslt: pointer to a parser result instance 2309 * @offset: a min value for the protocol offset 2310 * @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 offset 2314 * larger than @offset. 2315 * 2316 * Return: if true, the protocol's ID and offset 2317 */ ice_nearest_proto_id(struct ice_parser_result * rslt,u16 offset,u8 * proto_id,u16 * proto_off)2318 static 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 TUN2 2344 * In future, the flag masks should learn from DDP 2345 */ 2346 #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_SW 0x4002 2347 #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_ACL 0x0000 2348 #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_FD 0x6080 2349 #define ICE_KEYBUILD_FLAG_MASK_DEFAULT_RSS 0x6010 2350 2351 /** 2352 * ice_parser_profile_init - initialize a FXP profile based on parser result 2353 * @rslt: a instance of a parser result 2354 * @pkt_buf: packet data buffer 2355 * @msk_buf: packet mask buffer 2356 * @buf_len: packet length 2357 * @blk: FXP pipeline stage 2358 * @prof: input/output parameter to save the profile 2359 * 2360 * Return: 0 on success or errno on failure. 2361 */ 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)2362 int 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 info 2409 * @hw: pointer to the hardware structure 2410 * @prof: profile info to dump 2411 */ ice_parser_profile_dump(struct ice_hw * hw,struct ice_parser_profile * prof)2412 void 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