ice_parser_rt.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859
  1. // SPDX-License-Identifier: GPL-2.0
  2. /* Copyright (C) 2024 Intel Corporation */
  3. #include "ice_common.h"
  4. static void ice_rt_tsr_set(struct ice_parser_rt *rt, u16 tsr)
  5. {
  6. rt->gpr[ICE_GPR_TSR_IDX] = tsr;
  7. }
  8. static void ice_rt_ho_set(struct ice_parser_rt *rt, u16 ho)
  9. {
  10. rt->gpr[ICE_GPR_HO_IDX] = ho;
  11. memcpy(&rt->gpr[ICE_GPR_HV_IDX], &rt->pkt_buf[ho], ICE_GPR_HV_SIZE);
  12. }
  13. static void ice_rt_np_set(struct ice_parser_rt *rt, u16 pc)
  14. {
  15. rt->gpr[ICE_GPR_NP_IDX] = pc;
  16. }
  17. static void ice_rt_nn_set(struct ice_parser_rt *rt, u16 node)
  18. {
  19. rt->gpr[ICE_GPR_NN_IDX] = node;
  20. }
  21. static void
  22. ice_rt_flag_set(struct ice_parser_rt *rt, unsigned int idx, bool set)
  23. {
  24. struct ice_hw *hw = rt->psr->hw;
  25. unsigned int word, id;
  26. word = idx / ICE_GPR_FLG_SIZE;
  27. id = idx % ICE_GPR_FLG_SIZE;
  28. if (set) {
  29. rt->gpr[ICE_GPR_FLG_IDX + word] |= (u16)BIT(id);
  30. ice_debug(hw, ICE_DBG_PARSER, "Set parser flag %u\n", idx);
  31. } else {
  32. rt->gpr[ICE_GPR_FLG_IDX + word] &= ~(u16)BIT(id);
  33. ice_debug(hw, ICE_DBG_PARSER, "Clear parser flag %u\n", idx);
  34. }
  35. }
  36. static void ice_rt_gpr_set(struct ice_parser_rt *rt, int idx, u16 val)
  37. {
  38. struct ice_hw *hw = rt->psr->hw;
  39. if (idx == ICE_GPR_HO_IDX)
  40. ice_rt_ho_set(rt, val);
  41. else
  42. rt->gpr[idx] = val;
  43. ice_debug(hw, ICE_DBG_PARSER, "Set GPR %d value %d\n", idx, val);
  44. }
  45. static void ice_rt_err_set(struct ice_parser_rt *rt, unsigned int idx, bool set)
  46. {
  47. struct ice_hw *hw = rt->psr->hw;
  48. if (set) {
  49. rt->gpr[ICE_GPR_ERR_IDX] |= (u16)BIT(idx);
  50. ice_debug(hw, ICE_DBG_PARSER, "Set parser error %u\n", idx);
  51. } else {
  52. rt->gpr[ICE_GPR_ERR_IDX] &= ~(u16)BIT(idx);
  53. ice_debug(hw, ICE_DBG_PARSER, "Reset parser error %u\n", idx);
  54. }
  55. }
  56. /**
  57. * ice_parser_rt_reset - reset the parser runtime
  58. * @rt: pointer to the parser runtime
  59. */
  60. void ice_parser_rt_reset(struct ice_parser_rt *rt)
  61. {
  62. struct ice_parser *psr = rt->psr;
  63. struct ice_metainit_item *mi;
  64. unsigned int i;
  65. mi = &psr->mi_table[0];
  66. memset(rt, 0, sizeof(*rt));
  67. rt->psr = psr;
  68. ice_rt_tsr_set(rt, mi->tsr);
  69. ice_rt_ho_set(rt, mi->ho);
  70. ice_rt_np_set(rt, mi->pc);
  71. ice_rt_nn_set(rt, mi->pg_rn);
  72. for (i = 0; i < ICE_PARSER_FLG_NUM; i++) {
  73. if (mi->flags & BIT(i))
  74. ice_rt_flag_set(rt, i, true);
  75. }
  76. }
  77. /**
  78. * ice_parser_rt_pktbuf_set - set a packet into parser runtime
  79. * @rt: pointer to the parser runtime
  80. * @pkt_buf: buffer with packet data
  81. * @pkt_len: packet buffer length
  82. */
  83. void ice_parser_rt_pktbuf_set(struct ice_parser_rt *rt, const u8 *pkt_buf,
  84. int pkt_len)
  85. {
  86. int len = min(ICE_PARSER_MAX_PKT_LEN, pkt_len);
  87. u16 ho = rt->gpr[ICE_GPR_HO_IDX];
  88. memcpy(rt->pkt_buf, pkt_buf, len);
  89. rt->pkt_len = pkt_len;
  90. memcpy(&rt->gpr[ICE_GPR_HV_IDX], &rt->pkt_buf[ho], ICE_GPR_HV_SIZE);
  91. }
  92. static void ice_bst_key_init(struct ice_parser_rt *rt,
  93. struct ice_imem_item *imem)
  94. {
  95. u8 tsr = (u8)rt->gpr[ICE_GPR_TSR_IDX];
  96. u16 ho = rt->gpr[ICE_GPR_HO_IDX];
  97. u8 *key = rt->bst_key;
  98. int idd, i;
  99. idd = ICE_BST_TCAM_KEY_SIZE - 1;
  100. if (imem->b_kb.tsr_ctrl)
  101. key[idd] = tsr;
  102. else
  103. key[idd] = imem->b_kb.prio;
  104. idd = ICE_BST_TCAM_KEY_SIZE - 2;
  105. for (i = idd; i >= 0; i--) {
  106. int j;
  107. j = ho + idd - i;
  108. if (j < ICE_PARSER_MAX_PKT_LEN)
  109. key[i] = rt->pkt_buf[j];
  110. else
  111. key[i] = 0;
  112. }
  113. ice_debug_array_w_prefix(rt->psr->hw, ICE_DBG_PARSER,
  114. KBUILD_MODNAME ": Generated Boost TCAM Key",
  115. key, ICE_BST_TCAM_KEY_SIZE);
  116. }
  117. static u16 ice_bit_rev_u16(u16 v, int len)
  118. {
  119. return bitrev16(v) >> (BITS_PER_TYPE(v) - len);
  120. }
  121. static u32 ice_bit_rev_u32(u32 v, int len)
  122. {
  123. return bitrev32(v) >> (BITS_PER_TYPE(v) - len);
  124. }
  125. static u32 ice_hv_bit_sel(struct ice_parser_rt *rt, int start, int len)
  126. {
  127. int offset;
  128. u32 buf[2];
  129. u64 val;
  130. offset = ICE_GPR_HV_IDX + (start / BITS_PER_TYPE(u16));
  131. memcpy(buf, &rt->gpr[offset], sizeof(buf));
  132. buf[0] = bitrev8x4(buf[0]);
  133. buf[1] = bitrev8x4(buf[1]);
  134. val = *(u64 *)buf;
  135. val >>= start % BITS_PER_TYPE(u16);
  136. return ice_bit_rev_u32(val, len);
  137. }
  138. static u32 ice_pk_build(struct ice_parser_rt *rt,
  139. struct ice_np_keybuilder *kb)
  140. {
  141. if (kb->opc == ICE_NPKB_OPC_EXTRACT)
  142. return ice_hv_bit_sel(rt, kb->start_reg0, kb->len_reg1);
  143. else if (kb->opc == ICE_NPKB_OPC_BUILD)
  144. return rt->gpr[kb->start_reg0] |
  145. ((u32)rt->gpr[kb->len_reg1] << BITS_PER_TYPE(u16));
  146. else if (kb->opc == ICE_NPKB_OPC_BYPASS)
  147. return 0;
  148. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Unsupported OP Code %u\n",
  149. kb->opc);
  150. return U32_MAX;
  151. }
  152. static bool ice_flag_get(struct ice_parser_rt *rt, unsigned int index)
  153. {
  154. int word = index / ICE_GPR_FLG_SIZE;
  155. int id = index % ICE_GPR_FLG_SIZE;
  156. return !!(rt->gpr[ICE_GPR_FLG_IDX + word] & (u16)BIT(id));
  157. }
  158. static int ice_imem_pgk_init(struct ice_parser_rt *rt,
  159. struct ice_imem_item *imem)
  160. {
  161. memset(&rt->pg_key, 0, sizeof(rt->pg_key));
  162. rt->pg_key.next_proto = ice_pk_build(rt, &imem->np_kb);
  163. if (rt->pg_key.next_proto == U32_MAX)
  164. return -EINVAL;
  165. if (imem->pg_kb.flag0_ena)
  166. rt->pg_key.flag0 = ice_flag_get(rt, imem->pg_kb.flag0_idx);
  167. if (imem->pg_kb.flag1_ena)
  168. rt->pg_key.flag1 = ice_flag_get(rt, imem->pg_kb.flag1_idx);
  169. if (imem->pg_kb.flag2_ena)
  170. rt->pg_key.flag2 = ice_flag_get(rt, imem->pg_kb.flag2_idx);
  171. if (imem->pg_kb.flag3_ena)
  172. rt->pg_key.flag3 = ice_flag_get(rt, imem->pg_kb.flag3_idx);
  173. rt->pg_key.alu_reg = rt->gpr[imem->pg_kb.alu_reg_idx];
  174. rt->pg_key.node_id = rt->gpr[ICE_GPR_NN_IDX];
  175. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Generate Parse Graph Key: node_id(%d), flag0-3(%d,%d,%d,%d), boost_idx(%d), alu_reg(0x%04x), next_proto(0x%08x)\n",
  176. rt->pg_key.node_id,
  177. rt->pg_key.flag0,
  178. rt->pg_key.flag1,
  179. rt->pg_key.flag2,
  180. rt->pg_key.flag3,
  181. rt->pg_key.boost_idx,
  182. rt->pg_key.alu_reg,
  183. rt->pg_key.next_proto);
  184. return 0;
  185. }
  186. static void ice_imem_alu0_set(struct ice_parser_rt *rt,
  187. struct ice_imem_item *imem)
  188. {
  189. rt->alu0 = &imem->alu0;
  190. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load ALU0 from imem pc %d\n",
  191. imem->idx);
  192. }
  193. static void ice_imem_alu1_set(struct ice_parser_rt *rt,
  194. struct ice_imem_item *imem)
  195. {
  196. rt->alu1 = &imem->alu1;
  197. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load ALU1 from imem pc %d\n",
  198. imem->idx);
  199. }
  200. static void ice_imem_alu2_set(struct ice_parser_rt *rt,
  201. struct ice_imem_item *imem)
  202. {
  203. rt->alu2 = &imem->alu2;
  204. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load ALU2 from imem pc %d\n",
  205. imem->idx);
  206. }
  207. static void ice_imem_pgp_set(struct ice_parser_rt *rt,
  208. struct ice_imem_item *imem)
  209. {
  210. rt->pg_prio = imem->pg_prio;
  211. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load PG priority %d from imem pc %d\n",
  212. rt->pg_prio, imem->idx);
  213. }
  214. static int ice_bst_pgk_init(struct ice_parser_rt *rt,
  215. struct ice_bst_tcam_item *bst)
  216. {
  217. memset(&rt->pg_key, 0, sizeof(rt->pg_key));
  218. rt->pg_key.boost_idx = bst->hit_idx_grp;
  219. rt->pg_key.next_proto = ice_pk_build(rt, &bst->np_kb);
  220. if (rt->pg_key.next_proto == U32_MAX)
  221. return -EINVAL;
  222. if (bst->pg_kb.flag0_ena)
  223. rt->pg_key.flag0 = ice_flag_get(rt, bst->pg_kb.flag0_idx);
  224. if (bst->pg_kb.flag1_ena)
  225. rt->pg_key.flag1 = ice_flag_get(rt, bst->pg_kb.flag1_idx);
  226. if (bst->pg_kb.flag2_ena)
  227. rt->pg_key.flag2 = ice_flag_get(rt, bst->pg_kb.flag2_idx);
  228. if (bst->pg_kb.flag3_ena)
  229. rt->pg_key.flag3 = ice_flag_get(rt, bst->pg_kb.flag3_idx);
  230. rt->pg_key.alu_reg = rt->gpr[bst->pg_kb.alu_reg_idx];
  231. rt->pg_key.node_id = rt->gpr[ICE_GPR_NN_IDX];
  232. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Generate Parse Graph Key: node_id(%d), flag0-3(%d,%d,%d,%d), boost_idx(%d), alu_reg(0x%04x), next_proto(0x%08x)\n",
  233. rt->pg_key.node_id,
  234. rt->pg_key.flag0,
  235. rt->pg_key.flag1,
  236. rt->pg_key.flag2,
  237. rt->pg_key.flag3,
  238. rt->pg_key.boost_idx,
  239. rt->pg_key.alu_reg,
  240. rt->pg_key.next_proto);
  241. return 0;
  242. }
  243. static void ice_bst_alu0_set(struct ice_parser_rt *rt,
  244. struct ice_bst_tcam_item *bst)
  245. {
  246. rt->alu0 = &bst->alu0;
  247. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load ALU0 from boost address %d\n",
  248. bst->addr);
  249. }
  250. static void ice_bst_alu1_set(struct ice_parser_rt *rt,
  251. struct ice_bst_tcam_item *bst)
  252. {
  253. rt->alu1 = &bst->alu1;
  254. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load ALU1 from boost address %d\n",
  255. bst->addr);
  256. }
  257. static void ice_bst_alu2_set(struct ice_parser_rt *rt,
  258. struct ice_bst_tcam_item *bst)
  259. {
  260. rt->alu2 = &bst->alu2;
  261. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load ALU2 from boost address %d\n",
  262. bst->addr);
  263. }
  264. static void ice_bst_pgp_set(struct ice_parser_rt *rt,
  265. struct ice_bst_tcam_item *bst)
  266. {
  267. rt->pg_prio = bst->pg_prio;
  268. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load PG priority %d from boost address %d\n",
  269. rt->pg_prio, bst->addr);
  270. }
  271. static struct ice_pg_cam_item *ice_rt_pg_cam_match(struct ice_parser_rt *rt)
  272. {
  273. struct ice_parser *psr = rt->psr;
  274. struct ice_pg_cam_item *item;
  275. item = ice_pg_cam_match(psr->pg_cam_table, ICE_PG_CAM_TABLE_SIZE,
  276. &rt->pg_key);
  277. if (!item)
  278. item = ice_pg_cam_match(psr->pg_sp_cam_table,
  279. ICE_PG_SP_CAM_TABLE_SIZE, &rt->pg_key);
  280. return item;
  281. }
  282. static
  283. struct ice_pg_nm_cam_item *ice_rt_pg_nm_cam_match(struct ice_parser_rt *rt)
  284. {
  285. struct ice_parser *psr = rt->psr;
  286. struct ice_pg_nm_cam_item *item;
  287. item = ice_pg_nm_cam_match(psr->pg_nm_cam_table,
  288. ICE_PG_NM_CAM_TABLE_SIZE, &rt->pg_key);
  289. if (!item)
  290. item = ice_pg_nm_cam_match(psr->pg_nm_sp_cam_table,
  291. ICE_PG_NM_SP_CAM_TABLE_SIZE,
  292. &rt->pg_key);
  293. return item;
  294. }
  295. static void ice_gpr_add(struct ice_parser_rt *rt, int idx, u16 val)
  296. {
  297. rt->pu.gpr_val_upd[idx] = true;
  298. rt->pu.gpr_val[idx] = val;
  299. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Pending update for register %d value %d\n",
  300. idx, val);
  301. }
  302. static void ice_pg_exe(struct ice_parser_rt *rt)
  303. {
  304. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ParseGraph action ...\n");
  305. ice_gpr_add(rt, ICE_GPR_NP_IDX, rt->action->next_pc);
  306. ice_gpr_add(rt, ICE_GPR_NN_IDX, rt->action->next_node);
  307. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ParseGraph action done.\n");
  308. }
  309. static void ice_flg_add(struct ice_parser_rt *rt, int idx, bool val)
  310. {
  311. rt->pu.flg_msk |= BIT_ULL(idx);
  312. if (val)
  313. rt->pu.flg_val |= BIT_ULL(idx);
  314. else
  315. rt->pu.flg_val &= ~BIT_ULL(idx);
  316. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Pending update for flag %d value %d\n",
  317. idx, val);
  318. }
  319. static void ice_flg_update(struct ice_parser_rt *rt, struct ice_alu *alu)
  320. {
  321. u32 hv_bit_sel;
  322. int i;
  323. if (!alu->dedicate_flags_ena)
  324. return;
  325. if (alu->flags_extr_imm) {
  326. for (i = 0; i < alu->dst_len; i++)
  327. ice_flg_add(rt, alu->dst_start + i,
  328. !!(alu->flags_start_imm & BIT(i)));
  329. } else {
  330. for (i = 0; i < alu->dst_len; i++) {
  331. hv_bit_sel = ice_hv_bit_sel(rt,
  332. alu->flags_start_imm + i,
  333. 1);
  334. ice_flg_add(rt, alu->dst_start + i, !!hv_bit_sel);
  335. }
  336. }
  337. }
  338. static void ice_po_update(struct ice_parser_rt *rt, struct ice_alu *alu)
  339. {
  340. if (alu->proto_offset_opc == ICE_PO_OFF_HDR_ADD)
  341. rt->po = (u16)(rt->gpr[ICE_GPR_HO_IDX] + alu->proto_offset);
  342. else if (alu->proto_offset_opc == ICE_PO_OFF_HDR_SUB)
  343. rt->po = (u16)(rt->gpr[ICE_GPR_HO_IDX] - alu->proto_offset);
  344. else if (alu->proto_offset_opc == ICE_PO_OFF_REMAIN)
  345. rt->po = rt->gpr[ICE_GPR_HO_IDX];
  346. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Update Protocol Offset = %d\n",
  347. rt->po);
  348. }
  349. static u16 ice_reg_bit_sel(struct ice_parser_rt *rt, int reg_idx,
  350. int start, int len)
  351. {
  352. int offset;
  353. u32 val;
  354. offset = ICE_GPR_HV_IDX + (start / BITS_PER_TYPE(u16));
  355. memcpy(&val, &rt->gpr[offset], sizeof(val));
  356. val = bitrev8x4(val);
  357. val >>= start % BITS_PER_TYPE(u16);
  358. return ice_bit_rev_u16(val, len);
  359. }
  360. static void ice_err_add(struct ice_parser_rt *rt, int idx, bool val)
  361. {
  362. rt->pu.err_msk |= (u16)BIT(idx);
  363. if (val)
  364. rt->pu.flg_val |= (u64)BIT_ULL(idx);
  365. else
  366. rt->pu.flg_val &= ~(u64)BIT_ULL(idx);
  367. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Pending update for error %d value %d\n",
  368. idx, val);
  369. }
  370. static void ice_dst_reg_bit_set(struct ice_parser_rt *rt, struct ice_alu *alu,
  371. bool val)
  372. {
  373. u16 flg_idx;
  374. if (alu->dedicate_flags_ena) {
  375. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "DedicatedFlagsEnable should not be enabled in opcode %d\n",
  376. alu->opc);
  377. return;
  378. }
  379. if (alu->dst_reg_id == ICE_GPR_ERR_IDX) {
  380. if (alu->dst_start >= ICE_PARSER_ERR_NUM) {
  381. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Invalid error %d\n",
  382. alu->dst_start);
  383. return;
  384. }
  385. ice_err_add(rt, alu->dst_start, val);
  386. } else if (alu->dst_reg_id >= ICE_GPR_FLG_IDX) {
  387. flg_idx = (u16)(((alu->dst_reg_id - ICE_GPR_FLG_IDX) << 4) +
  388. alu->dst_start);
  389. if (flg_idx >= ICE_PARSER_FLG_NUM) {
  390. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Invalid flag %d\n",
  391. flg_idx);
  392. return;
  393. }
  394. ice_flg_add(rt, flg_idx, val);
  395. } else {
  396. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Unexpected Dest Register Bit set, RegisterID %d Start %d\n",
  397. alu->dst_reg_id, alu->dst_start);
  398. }
  399. }
  400. static void ice_alu_exe(struct ice_parser_rt *rt, struct ice_alu *alu)
  401. {
  402. u16 dst, src, shift, imm;
  403. if (alu->shift_xlate_sel) {
  404. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "shift_xlate_sel != 0 is not expected\n");
  405. return;
  406. }
  407. ice_po_update(rt, alu);
  408. ice_flg_update(rt, alu);
  409. dst = rt->gpr[alu->dst_reg_id];
  410. src = ice_reg_bit_sel(rt, alu->src_reg_id,
  411. alu->src_start, alu->src_len);
  412. shift = alu->shift_xlate_key;
  413. imm = alu->imm;
  414. switch (alu->opc) {
  415. case ICE_ALU_PARK:
  416. break;
  417. case ICE_ALU_MOV_ADD:
  418. dst = (src << shift) + imm;
  419. ice_gpr_add(rt, alu->dst_reg_id, dst);
  420. break;
  421. case ICE_ALU_ADD:
  422. dst += (src << shift) + imm;
  423. ice_gpr_add(rt, alu->dst_reg_id, dst);
  424. break;
  425. case ICE_ALU_ORLT:
  426. if (src < imm)
  427. ice_dst_reg_bit_set(rt, alu, true);
  428. ice_gpr_add(rt, ICE_GPR_NP_IDX, alu->branch_addr);
  429. break;
  430. case ICE_ALU_OREQ:
  431. if (src == imm)
  432. ice_dst_reg_bit_set(rt, alu, true);
  433. ice_gpr_add(rt, ICE_GPR_NP_IDX, alu->branch_addr);
  434. break;
  435. case ICE_ALU_SETEQ:
  436. ice_dst_reg_bit_set(rt, alu, src == imm);
  437. ice_gpr_add(rt, ICE_GPR_NP_IDX, alu->branch_addr);
  438. break;
  439. case ICE_ALU_MOV_XOR:
  440. dst = (src << shift) ^ imm;
  441. ice_gpr_add(rt, alu->dst_reg_id, dst);
  442. break;
  443. default:
  444. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Unsupported ALU instruction %d\n",
  445. alu->opc);
  446. break;
  447. }
  448. }
  449. static void ice_alu0_exe(struct ice_parser_rt *rt)
  450. {
  451. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ALU0 ...\n");
  452. ice_alu_exe(rt, rt->alu0);
  453. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ALU0 done.\n");
  454. }
  455. static void ice_alu1_exe(struct ice_parser_rt *rt)
  456. {
  457. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ALU1 ...\n");
  458. ice_alu_exe(rt, rt->alu1);
  459. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ALU1 done.\n");
  460. }
  461. static void ice_alu2_exe(struct ice_parser_rt *rt)
  462. {
  463. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ALU2 ...\n");
  464. ice_alu_exe(rt, rt->alu2);
  465. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Executing ALU2 done.\n");
  466. }
  467. static void ice_pu_exe(struct ice_parser_rt *rt)
  468. {
  469. struct ice_gpr_pu *pu = &rt->pu;
  470. unsigned int i;
  471. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Updating Registers ...\n");
  472. for (i = 0; i < ICE_PARSER_GPR_NUM; i++) {
  473. if (pu->gpr_val_upd[i])
  474. ice_rt_gpr_set(rt, i, pu->gpr_val[i]);
  475. }
  476. for (i = 0; i < ICE_PARSER_FLG_NUM; i++) {
  477. if (pu->flg_msk & BIT(i))
  478. ice_rt_flag_set(rt, i, pu->flg_val & BIT(i));
  479. }
  480. for (i = 0; i < ICE_PARSER_ERR_NUM; i++) {
  481. if (pu->err_msk & BIT(i))
  482. ice_rt_err_set(rt, i, pu->err_val & BIT(i));
  483. }
  484. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Updating Registers done.\n");
  485. }
  486. static void ice_alu_pg_exe(struct ice_parser_rt *rt)
  487. {
  488. memset(&rt->pu, 0, sizeof(rt->pu));
  489. switch (rt->pg_prio) {
  490. case (ICE_PG_P0):
  491. ice_pg_exe(rt);
  492. ice_alu0_exe(rt);
  493. ice_alu1_exe(rt);
  494. ice_alu2_exe(rt);
  495. break;
  496. case (ICE_PG_P1):
  497. ice_alu0_exe(rt);
  498. ice_pg_exe(rt);
  499. ice_alu1_exe(rt);
  500. ice_alu2_exe(rt);
  501. break;
  502. case (ICE_PG_P2):
  503. ice_alu0_exe(rt);
  504. ice_alu1_exe(rt);
  505. ice_pg_exe(rt);
  506. ice_alu2_exe(rt);
  507. break;
  508. case (ICE_PG_P3):
  509. ice_alu0_exe(rt);
  510. ice_alu1_exe(rt);
  511. ice_alu2_exe(rt);
  512. ice_pg_exe(rt);
  513. break;
  514. }
  515. ice_pu_exe(rt);
  516. if (rt->action->ho_inc == 0)
  517. return;
  518. if (rt->action->ho_polarity)
  519. ice_rt_ho_set(rt, rt->gpr[ICE_GPR_HO_IDX] + rt->action->ho_inc);
  520. else
  521. ice_rt_ho_set(rt, rt->gpr[ICE_GPR_HO_IDX] - rt->action->ho_inc);
  522. }
  523. static void ice_proto_off_update(struct ice_parser_rt *rt)
  524. {
  525. struct ice_parser *psr = rt->psr;
  526. if (rt->action->is_pg) {
  527. struct ice_proto_grp_item *proto_grp =
  528. &psr->proto_grp_table[rt->action->proto_id];
  529. u16 po;
  530. int i;
  531. for (i = 0; i < ICE_PROTO_COUNT_PER_GRP; i++) {
  532. struct ice_proto_off *entry = &proto_grp->po[i];
  533. if (entry->proto_id == U8_MAX)
  534. break;
  535. if (!entry->polarity)
  536. po = rt->po + entry->offset;
  537. else
  538. po = rt->po - entry->offset;
  539. rt->protocols[entry->proto_id] = true;
  540. rt->offsets[entry->proto_id] = po;
  541. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Set Protocol %d at offset %d\n",
  542. entry->proto_id, po);
  543. }
  544. } else {
  545. rt->protocols[rt->action->proto_id] = true;
  546. rt->offsets[rt->action->proto_id] = rt->po;
  547. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Set Protocol %d at offset %d\n",
  548. rt->action->proto_id, rt->po);
  549. }
  550. }
  551. static void ice_marker_set(struct ice_parser_rt *rt, int idx)
  552. {
  553. unsigned int byte = idx / BITS_PER_BYTE;
  554. unsigned int bit = idx % BITS_PER_BYTE;
  555. rt->markers[byte] |= (u8)BIT(bit);
  556. }
  557. static void ice_marker_update(struct ice_parser_rt *rt)
  558. {
  559. struct ice_parser *psr = rt->psr;
  560. if (rt->action->is_mg) {
  561. struct ice_mk_grp_item *mk_grp =
  562. &psr->mk_grp_table[rt->action->marker_id];
  563. int i;
  564. for (i = 0; i < ICE_MARKER_ID_NUM; i++) {
  565. u8 marker = mk_grp->markers[i];
  566. if (marker == ICE_MARKER_MAX_SIZE)
  567. break;
  568. ice_marker_set(rt, marker);
  569. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Set Marker %d\n",
  570. marker);
  571. }
  572. } else {
  573. if (rt->action->marker_id != ICE_MARKER_MAX_SIZE)
  574. ice_marker_set(rt, rt->action->marker_id);
  575. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Set Marker %d\n",
  576. rt->action->marker_id);
  577. }
  578. }
  579. static u16 ice_ptype_resolve(struct ice_parser_rt *rt)
  580. {
  581. struct ice_ptype_mk_tcam_item *item;
  582. struct ice_parser *psr = rt->psr;
  583. item = ice_ptype_mk_tcam_match(psr->ptype_mk_tcam_table,
  584. rt->markers, ICE_MARKER_ID_SIZE);
  585. if (item)
  586. return item->ptype;
  587. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Could not resolve PTYPE\n");
  588. return U16_MAX;
  589. }
  590. static void ice_proto_off_resolve(struct ice_parser_rt *rt,
  591. struct ice_parser_result *rslt)
  592. {
  593. int i;
  594. for (i = 0; i < ICE_PO_PAIR_SIZE - 1; i++) {
  595. if (rt->protocols[i]) {
  596. rslt->po[rslt->po_num].proto_id = (u8)i;
  597. rslt->po[rslt->po_num].offset = rt->offsets[i];
  598. rslt->po_num++;
  599. }
  600. }
  601. }
  602. static void ice_result_resolve(struct ice_parser_rt *rt,
  603. struct ice_parser_result *rslt)
  604. {
  605. struct ice_parser *psr = rt->psr;
  606. memset(rslt, 0, sizeof(*rslt));
  607. memcpy(&rslt->flags_psr, &rt->gpr[ICE_GPR_FLG_IDX],
  608. ICE_PARSER_FLAG_PSR_SIZE);
  609. rslt->flags_pkt = ice_flg_redirect(psr->flg_rd_table, rslt->flags_psr);
  610. rslt->flags_sw = ice_xlt_kb_flag_get(psr->xlt_kb_sw, rslt->flags_pkt);
  611. rslt->flags_fd = ice_xlt_kb_flag_get(psr->xlt_kb_fd, rslt->flags_pkt);
  612. rslt->flags_rss = ice_xlt_kb_flag_get(psr->xlt_kb_rss, rslt->flags_pkt);
  613. ice_proto_off_resolve(rt, rslt);
  614. rslt->ptype = ice_ptype_resolve(rt);
  615. }
  616. /**
  617. * ice_parser_rt_execute - parser execution routine
  618. * @rt: pointer to the parser runtime
  619. * @rslt: input/output parameter to save parser result
  620. *
  621. * Return: 0 on success or errno.
  622. */
  623. int ice_parser_rt_execute(struct ice_parser_rt *rt,
  624. struct ice_parser_result *rslt)
  625. {
  626. struct ice_pg_nm_cam_item *pg_nm_cam;
  627. struct ice_parser *psr = rt->psr;
  628. struct ice_pg_cam_item *pg_cam;
  629. int status = 0;
  630. u16 node;
  631. u16 pc;
  632. node = rt->gpr[ICE_GPR_NN_IDX];
  633. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Start with Node: %u\n", node);
  634. while (true) {
  635. struct ice_bst_tcam_item *bst;
  636. struct ice_imem_item *imem;
  637. pc = rt->gpr[ICE_GPR_NP_IDX];
  638. imem = &psr->imem_table[pc];
  639. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Load imem at pc: %u\n",
  640. pc);
  641. ice_bst_key_init(rt, imem);
  642. bst = ice_bst_tcam_match(psr->bst_tcam_table, rt->bst_key);
  643. if (!bst) {
  644. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "No Boost TCAM Match\n");
  645. status = ice_imem_pgk_init(rt, imem);
  646. if (status)
  647. break;
  648. ice_imem_alu0_set(rt, imem);
  649. ice_imem_alu1_set(rt, imem);
  650. ice_imem_alu2_set(rt, imem);
  651. ice_imem_pgp_set(rt, imem);
  652. } else {
  653. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Boost TCAM Match address: %u\n",
  654. bst->addr);
  655. if (imem->b_m.pg) {
  656. status = ice_bst_pgk_init(rt, bst);
  657. if (status)
  658. break;
  659. ice_bst_pgp_set(rt, bst);
  660. } else {
  661. status = ice_imem_pgk_init(rt, imem);
  662. if (status)
  663. break;
  664. ice_imem_pgp_set(rt, imem);
  665. }
  666. if (imem->b_m.alu0)
  667. ice_bst_alu0_set(rt, bst);
  668. else
  669. ice_imem_alu0_set(rt, imem);
  670. if (imem->b_m.alu1)
  671. ice_bst_alu1_set(rt, bst);
  672. else
  673. ice_imem_alu1_set(rt, imem);
  674. if (imem->b_m.alu2)
  675. ice_bst_alu2_set(rt, bst);
  676. else
  677. ice_imem_alu2_set(rt, imem);
  678. }
  679. rt->action = NULL;
  680. pg_cam = ice_rt_pg_cam_match(rt);
  681. if (!pg_cam) {
  682. pg_nm_cam = ice_rt_pg_nm_cam_match(rt);
  683. if (pg_nm_cam) {
  684. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Match ParseGraph Nomatch CAM Address %u\n",
  685. pg_nm_cam->idx);
  686. rt->action = &pg_nm_cam->action;
  687. }
  688. } else {
  689. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Match ParseGraph CAM Address %u\n",
  690. pg_cam->idx);
  691. rt->action = &pg_cam->action;
  692. }
  693. if (!rt->action) {
  694. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Failed to match ParseGraph CAM, stop parsing.\n");
  695. status = -EINVAL;
  696. break;
  697. }
  698. ice_alu_pg_exe(rt);
  699. ice_marker_update(rt);
  700. ice_proto_off_update(rt);
  701. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Go to node %u\n",
  702. rt->action->next_node);
  703. if (rt->action->is_last_round) {
  704. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Last Round in ParseGraph Action, stop parsing.\n");
  705. break;
  706. }
  707. if (rt->gpr[ICE_GPR_HO_IDX] >= rt->pkt_len) {
  708. ice_debug(rt->psr->hw, ICE_DBG_PARSER, "Header Offset (%u) is larger than packet len (%u), stop parsing\n",
  709. rt->gpr[ICE_GPR_HO_IDX], rt->pkt_len);
  710. break;
  711. }
  712. }
  713. ice_result_resolve(rt, rslt);
  714. return status;
  715. }