drivers/net/ethernet/netronome/nfp/nfp_bpf_jit.c

   1 /*
   2  * Copyright (C) 2016 Netronome Systems, Inc.
   3  *
   4  * This software is dual licensed under the GNU General License Version 2,
   5  * June 1991 as shown in the file COPYING in the top-level directory of this
   6  * source tree or the BSD 2-Clause License provided below.  You have the
   7  * option to license this software under the complete terms of either license.
   8  *
   9  * The BSD 2-Clause License:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      1. Redistributions of source code must retain the above
  16  *         copyright notice, this list of conditions and the following
  17  *         disclaimer.
  18  *
  19  *      2. Redistributions in binary form must reproduce the above
  20  *         copyright notice, this list of conditions and the following
  21  *         disclaimer in the documentation and/or other materials
  22  *         provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #define pr_fmt(fmt)     "NFP net bpf: " fmt
  35
  36 #include <linux/kernel.h>
  37 #include <linux/bpf.h>
  38 #include <linux/filter.h>
  39 #include <linux/pkt_cls.h>
  40 #include <linux/unistd.h>
  41
  42 #include "nfp_asm.h"
  43 #include "nfp_bpf.h"
  44
  45 /* --- NFP prog --- */
  46 /* Foreach "multiple" entries macros provide pos and next<n> pointers.
  47  * It's safe to modify the next pointers (but not pos).
  48  */
  49 #define nfp_for_each_insn_walk2(nfp_prog, pos, next)                    \
  50         for (pos = list_first_entry(&(nfp_prog)->insns, typeof(*pos), l), \
  51              next = list_next_entry(pos, l);                    \
  52              &(nfp_prog)->insns != &pos->l &&                   \
  53              &(nfp_prog)->insns != &next->l;                    \
  54              pos = nfp_meta_next(pos),                          \
  55              next = nfp_meta_next(pos))
  56
  57 #define nfp_for_each_insn_walk3(nfp_prog, pos, next, next2)             \
  58         for (pos = list_first_entry(&(nfp_prog)->insns, typeof(*pos), l), \
  59              next = list_next_entry(pos, l),                    \
  60              next2 = list_next_entry(next, l);                  \
  61              &(nfp_prog)->insns != &pos->l &&                   \
  62              &(nfp_prog)->insns != &next->l &&                  \
  63              &(nfp_prog)->insns != &next2->l;                   \
  64              pos = nfp_meta_next(pos),                          \
  65              next = nfp_meta_next(pos),                         \
  66              next2 = nfp_meta_next(next))
  67
  68 static bool
  69 nfp_meta_has_next(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
  70 {
  71         return meta->l.next != &nfp_prog->insns;
  72 }
  73
  74 static bool
  75 nfp_meta_has_prev(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
  76 {
  77         return meta->l.prev != &nfp_prog->insns;
  78 }
  79
  80 static void nfp_prog_free(struct nfp_prog *nfp_prog)
  81 {
  82         struct nfp_insn_meta *meta, *tmp;
  83
  84         list_for_each_entry_safe(meta, tmp, &nfp_prog->insns, l) {
  85                 list_del(&meta->l);
  86                 kfree(meta);
  87         }
  88         kfree(nfp_prog);
  89 }
  90
  91 static void nfp_prog_push(struct nfp_prog *nfp_prog, u64 insn)
  92 {
  93         if (nfp_prog->__prog_alloc_len == nfp_prog->prog_len) {
  94                 nfp_prog->error = -ENOSPC;
  95                 return;
  96         }
  97
  98         nfp_prog->prog[nfp_prog->prog_len] = insn;
  99         nfp_prog->prog_len++;
 100 }
 101
 102 static unsigned int nfp_prog_current_offset(struct nfp_prog *nfp_prog)
 103 {
 104         return nfp_prog->start_off + nfp_prog->prog_len;
 105 }
 106
 107 static unsigned int
 108 nfp_prog_offset_to_index(struct nfp_prog *nfp_prog, unsigned int offset)
 109 {
 110         return offset - nfp_prog->start_off;
 111 }
 112
 113 /* --- SW reg --- */
 114 struct nfp_insn_ur_regs {
 115         enum alu_dst_ab dst_ab;
 116         u16 dst;
 117         u16 areg, breg;
 118         bool swap;
 119         bool wr_both;
 120 };
 121
 122 struct nfp_insn_re_regs {
 123         enum alu_dst_ab dst_ab;
 124         u8 dst;
 125         u8 areg, breg;
 126         bool swap;
 127         bool wr_both;
 128         bool i8;
 129 };
 130
 131 static u16 nfp_swreg_to_unreg(u32 swreg, bool is_dst)
 132 {
 133         u16 val = FIELD_GET(NN_REG_VAL, swreg);
 134
 135         switch (FIELD_GET(NN_REG_TYPE, swreg)) {
 136         case NN_REG_GPR_A:
 137         case NN_REG_GPR_B:
 138         case NN_REG_GPR_BOTH:
 139                 return val;
 140         case NN_REG_NNR:
 141                 return UR_REG_NN | val;
 142         case NN_REG_XFER:
 143                 return UR_REG_XFR | val;
 144         case NN_REG_IMM:
 145                 if (val & ~0xff) {
 146                         pr_err("immediate too large\n");
 147                         return 0;
 148                 }
 149                 return UR_REG_IMM_encode(val);
 150         case NN_REG_NONE:
 151                 return is_dst ? UR_REG_NO_DST : REG_NONE;
 152         default:
 153                 pr_err("unrecognized reg encoding %08x\n", swreg);
 154                 return 0;
 155         }
 156 }
 157
 158 static int
 159 swreg_to_unrestricted(u32 dst, u32 lreg, u32 rreg, struct nfp_insn_ur_regs *reg)
 160 {
 161         memset(reg, 0, sizeof(*reg));
 162
 163         /* Decode destination */
 164         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_IMM)
 165                 return -EFAULT;
 166
 167         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_GPR_B)
 168                 reg->dst_ab = ALU_DST_B;
 169         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_GPR_BOTH)
 170                 reg->wr_both = true;
 171         reg->dst = nfp_swreg_to_unreg(dst, true);
 172
 173         /* Decode source operands */
 174         if (FIELD_GET(NN_REG_TYPE, lreg) == FIELD_GET(NN_REG_TYPE, rreg))
 175                 return -EFAULT;
 176
 177         if (FIELD_GET(NN_REG_TYPE, lreg) == NN_REG_GPR_B ||
 178             FIELD_GET(NN_REG_TYPE, rreg) == NN_REG_GPR_A) {
 179                 reg->areg = nfp_swreg_to_unreg(rreg, false);
 180                 reg->breg = nfp_swreg_to_unreg(lreg, false);
 181                 reg->swap = true;
 182         } else {
 183                 reg->areg = nfp_swreg_to_unreg(lreg, false);
 184                 reg->breg = nfp_swreg_to_unreg(rreg, false);
 185         }
 186
 187         return 0;
 188 }
 189
 190 static u16 nfp_swreg_to_rereg(u32 swreg, bool is_dst, bool has_imm8, bool *i8)
 191 {
 192         u16 val = FIELD_GET(NN_REG_VAL, swreg);
 193
 194         switch (FIELD_GET(NN_REG_TYPE, swreg)) {
 195         case NN_REG_GPR_A:
 196         case NN_REG_GPR_B:
 197         case NN_REG_GPR_BOTH:
 198                 return val;
 199         case NN_REG_XFER:
 200                 return RE_REG_XFR | val;
 201         case NN_REG_IMM:
 202                 if (val & ~(0x7f | has_imm8 << 7)) {
 203                         pr_err("immediate too large\n");
 204                         return 0;
 205                 }
 206                 *i8 = val & 0x80;
 207                 return RE_REG_IMM_encode(val & 0x7f);
 208         case NN_REG_NONE:
 209                 return is_dst ? RE_REG_NO_DST : REG_NONE;
 210         default:
 211                 pr_err("unrecognized reg encoding\n");
 212                 return 0;
 213         }
 214 }
 215
 216 static int
 217 swreg_to_restricted(u32 dst, u32 lreg, u32 rreg, struct nfp_insn_re_regs *reg,
 218                     bool has_imm8)
 219 {
 220         memset(reg, 0, sizeof(*reg));
 221
 222         /* Decode destination */
 223         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_IMM)
 224                 return -EFAULT;
 225
 226         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_GPR_B)
 227                 reg->dst_ab = ALU_DST_B;
 228         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_GPR_BOTH)
 229                 reg->wr_both = true;
 230         reg->dst = nfp_swreg_to_rereg(dst, true, false, NULL);
 231
 232         /* Decode source operands */
 233         if (FIELD_GET(NN_REG_TYPE, lreg) == FIELD_GET(NN_REG_TYPE, rreg))
 234                 return -EFAULT;
 235
 236         if (FIELD_GET(NN_REG_TYPE, lreg) == NN_REG_GPR_B ||
 237             FIELD_GET(NN_REG_TYPE, rreg) == NN_REG_GPR_A) {
 238                 reg->areg = nfp_swreg_to_rereg(rreg, false, has_imm8, &reg->i8);
 239                 reg->breg = nfp_swreg_to_rereg(lreg, false, has_imm8, &reg->i8);
 240                 reg->swap = true;
 241         } else {
 242                 reg->areg = nfp_swreg_to_rereg(lreg, false, has_imm8, &reg->i8);
 243                 reg->breg = nfp_swreg_to_rereg(rreg, false, has_imm8, &reg->i8);
 244         }
 245
 246         return 0;
 247 }
 248
 249 /* --- Emitters --- */
 250 static const struct cmd_tgt_act cmd_tgt_act[__CMD_TGT_MAP_SIZE] = {
 251         [CMD_TGT_WRITE8] =              { 0x00, 0x42 },
 252         [CMD_TGT_READ8] =               { 0x01, 0x43 },
 253         [CMD_TGT_READ_LE] =             { 0x01, 0x40 },
 254         [CMD_TGT_READ_SWAP_LE] =        { 0x03, 0x40 },
 255 };
 256
 257 static void
 258 __emit_cmd(struct nfp_prog *nfp_prog, enum cmd_tgt_map op,
 259            u8 mode, u8 xfer, u8 areg, u8 breg, u8 size, bool sync)
 260 {
 261         enum cmd_ctx_swap ctx;
 262         u64 insn;
 263
 264         if (sync)
 265                 ctx = CMD_CTX_SWAP;
 266         else
 267                 ctx = CMD_CTX_NO_SWAP;
 268
 269         insn =  FIELD_PREP(OP_CMD_A_SRC, areg) |
 270                 FIELD_PREP(OP_CMD_CTX, ctx) |
 271                 FIELD_PREP(OP_CMD_B_SRC, breg) |
 272                 FIELD_PREP(OP_CMD_TOKEN, cmd_tgt_act[op].token) |
 273                 FIELD_PREP(OP_CMD_XFER, xfer) |
 274                 FIELD_PREP(OP_CMD_CNT, size) |
 275                 FIELD_PREP(OP_CMD_SIG, sync) |
 276                 FIELD_PREP(OP_CMD_TGT_CMD, cmd_tgt_act[op].tgt_cmd) |
 277                 FIELD_PREP(OP_CMD_MODE, mode);
 278
 279         nfp_prog_push(nfp_prog, insn);
 280 }
 281
 282 static void
 283 emit_cmd(struct nfp_prog *nfp_prog, enum cmd_tgt_map op,
 284          u8 mode, u8 xfer, u32 lreg, u32 rreg, u8 size, bool sync)
 285 {
 286         struct nfp_insn_re_regs reg;
 287         int err;
 288
 289         err = swreg_to_restricted(reg_none(), lreg, rreg, &reg, false);
 290         if (err) {
 291                 nfp_prog->error = err;
 292                 return;
 293         }
 294         if (reg.swap) {
 295                 pr_err("cmd can't swap arguments\n");
 296                 nfp_prog->error = -EFAULT;
 297                 return;
 298         }
 299
 300         __emit_cmd(nfp_prog, op, mode, xfer, reg.areg, reg.breg, size, sync);
 301 }
 302
 303 static void
 304 __emit_br(struct nfp_prog *nfp_prog, enum br_mask mask, enum br_ev_pip ev_pip,
 305           enum br_ctx_signal_state css, u16 addr, u8 defer)
 306 {
 307         u16 addr_lo, addr_hi;
 308         u64 insn;
 309
 310         addr_lo = addr & (OP_BR_ADDR_LO >> __bf_shf(OP_BR_ADDR_LO));
 311         addr_hi = addr != addr_lo;
 312
 313         insn = OP_BR_BASE |
 314                 FIELD_PREP(OP_BR_MASK, mask) |
 315                 FIELD_PREP(OP_BR_EV_PIP, ev_pip) |
 316                 FIELD_PREP(OP_BR_CSS, css) |
 317                 FIELD_PREP(OP_BR_DEFBR, defer) |
 318                 FIELD_PREP(OP_BR_ADDR_LO, addr_lo) |
 319                 FIELD_PREP(OP_BR_ADDR_HI, addr_hi);
 320
 321         nfp_prog_push(nfp_prog, insn);
 322 }
 323
 324 static void emit_br_def(struct nfp_prog *nfp_prog, u16 addr, u8 defer)
 325 {
 326         if (defer > 2) {
 327                 pr_err("BUG: branch defer out of bounds %d\n", defer);
 328                 nfp_prog->error = -EFAULT;
 329                 return;
 330         }
 331         __emit_br(nfp_prog, BR_UNC, BR_EV_PIP_UNCOND, BR_CSS_NONE, addr, defer);
 332 }
 333
 334 static void
 335 emit_br(struct nfp_prog *nfp_prog, enum br_mask mask, u16 addr, u8 defer)
 336 {
 337         __emit_br(nfp_prog, mask,
 338                   mask != BR_UNC ? BR_EV_PIP_COND : BR_EV_PIP_UNCOND,
 339                   BR_CSS_NONE, addr, defer);
 340 }
 341
 342 static void
 343 __emit_br_byte(struct nfp_prog *nfp_prog, u8 areg, u8 breg, bool imm8,
 344                u8 byte, bool equal, u16 addr, u8 defer)
 345 {
 346         u16 addr_lo, addr_hi;
 347         u64 insn;
 348
 349         addr_lo = addr & (OP_BB_ADDR_LO >> __bf_shf(OP_BB_ADDR_LO));
 350         addr_hi = addr != addr_lo;
 351
 352         insn = OP_BBYTE_BASE |
 353                 FIELD_PREP(OP_BB_A_SRC, areg) |
 354                 FIELD_PREP(OP_BB_BYTE, byte) |
 355                 FIELD_PREP(OP_BB_B_SRC, breg) |
 356                 FIELD_PREP(OP_BB_I8, imm8) |
 357                 FIELD_PREP(OP_BB_EQ, equal) |
 358                 FIELD_PREP(OP_BB_DEFBR, defer) |
 359                 FIELD_PREP(OP_BB_ADDR_LO, addr_lo) |
 360                 FIELD_PREP(OP_BB_ADDR_HI, addr_hi);
 361
 362         nfp_prog_push(nfp_prog, insn);
 363 }
 364
 365 static void
 366 emit_br_byte_neq(struct nfp_prog *nfp_prog,
 367                  u32 dst, u8 imm, u8 byte, u16 addr, u8 defer)
 368 {
 369         struct nfp_insn_re_regs reg;
 370         int err;
 371
 372         err = swreg_to_restricted(reg_none(), dst, reg_imm(imm), &reg, true);
 373         if (err) {
 374                 nfp_prog->error = err;
 375                 return;
 376         }
 377
 378         __emit_br_byte(nfp_prog, reg.areg, reg.breg, reg.i8, byte, false, addr,
 379                        defer);
 380 }
 381
 382 static void
 383 __emit_immed(struct nfp_prog *nfp_prog, u16 areg, u16 breg, u16 imm_hi,
 384              enum immed_width width, bool invert,
 385              enum immed_shift shift, bool wr_both)
 386 {
 387         u64 insn;
 388
 389         insn = OP_IMMED_BASE |
 390                 FIELD_PREP(OP_IMMED_A_SRC, areg) |
 391                 FIELD_PREP(OP_IMMED_B_SRC, breg) |
 392                 FIELD_PREP(OP_IMMED_IMM, imm_hi) |
 393                 FIELD_PREP(OP_IMMED_WIDTH, width) |
 394                 FIELD_PREP(OP_IMMED_INV, invert) |
 395                 FIELD_PREP(OP_IMMED_SHIFT, shift) |
 396                 FIELD_PREP(OP_IMMED_WR_AB, wr_both);
 397
 398         nfp_prog_push(nfp_prog, insn);
 399 }
 400
 401 static void
 402 emit_immed(struct nfp_prog *nfp_prog, u32 dst, u16 imm,
 403            enum immed_width width, bool invert, enum immed_shift shift)
 404 {
 405         struct nfp_insn_ur_regs reg;
 406         int err;
 407
 408         if (FIELD_GET(NN_REG_TYPE, dst) == NN_REG_IMM) {
 409                 nfp_prog->error = -EFAULT;
 410                 return;
 411         }
 412
 413         err = swreg_to_unrestricted(dst, dst, reg_imm(imm & 0xff), &reg);
 414         if (err) {
 415                 nfp_prog->error = err;
 416                 return;
 417         }
 418
 419         __emit_immed(nfp_prog, reg.areg, reg.breg, imm >> 8, width,
 420                      invert, shift, reg.wr_both);
 421 }
 422
 423 static void
 424 __emit_shf(struct nfp_prog *nfp_prog, u16 dst, enum alu_dst_ab dst_ab,
 425            enum shf_sc sc, u8 shift,
 426            u16 areg, enum shf_op op, u16 breg, bool i8, bool sw, bool wr_both)
 427 {
 428         u64 insn;
 429
 430         if (!FIELD_FIT(OP_SHF_SHIFT, shift)) {
 431                 nfp_prog->error = -EFAULT;
 432                 return;
 433         }
 434
 435         if (sc == SHF_SC_L_SHF)
 436                 shift = 32 - shift;
 437
 438         insn = OP_SHF_BASE |
 439                 FIELD_PREP(OP_SHF_A_SRC, areg) |
 440                 FIELD_PREP(OP_SHF_SC, sc) |
 441                 FIELD_PREP(OP_SHF_B_SRC, breg) |
 442                 FIELD_PREP(OP_SHF_I8, i8) |
 443                 FIELD_PREP(OP_SHF_SW, sw) |
 444                 FIELD_PREP(OP_SHF_DST, dst) |
 445                 FIELD_PREP(OP_SHF_SHIFT, shift) |
 446                 FIELD_PREP(OP_SHF_OP, op) |
 447                 FIELD_PREP(OP_SHF_DST_AB, dst_ab) |
 448                 FIELD_PREP(OP_SHF_WR_AB, wr_both);
 449
 450         nfp_prog_push(nfp_prog, insn);
 451 }
 452
 453 static void
 454 emit_shf(struct nfp_prog *nfp_prog, u32 dst, u32 lreg, enum shf_op op, u32 rreg,
 455          enum shf_sc sc, u8 shift)
 456 {
 457         struct nfp_insn_re_regs reg;
 458         int err;
 459
 460         err = swreg_to_restricted(dst, lreg, rreg, &reg, true);
 461         if (err) {
 462                 nfp_prog->error = err;
 463                 return;
 464         }
 465
 466         __emit_shf(nfp_prog, reg.dst, reg.dst_ab, sc, shift,
 467                    reg.areg, op, reg.breg, reg.i8, reg.swap, reg.wr_both);
 468 }
 469
 470 static void
 471 __emit_alu(struct nfp_prog *nfp_prog, u16 dst, enum alu_dst_ab dst_ab,
 472            u16 areg, enum alu_op op, u16 breg, bool swap, bool wr_both)
 473 {
 474         u64 insn;
 475
 476         insn = OP_ALU_BASE |
 477                 FIELD_PREP(OP_ALU_A_SRC, areg) |
 478                 FIELD_PREP(OP_ALU_B_SRC, breg) |
 479                 FIELD_PREP(OP_ALU_DST, dst) |
 480                 FIELD_PREP(OP_ALU_SW, swap) |
 481                 FIELD_PREP(OP_ALU_OP, op) |
 482                 FIELD_PREP(OP_ALU_DST_AB, dst_ab) |
 483                 FIELD_PREP(OP_ALU_WR_AB, wr_both);
 484
 485         nfp_prog_push(nfp_prog, insn);
 486 }
 487
 488 static void
 489 emit_alu(struct nfp_prog *nfp_prog, u32 dst, u32 lreg, enum alu_op op, u32 rreg)
 490 {
 491         struct nfp_insn_ur_regs reg;
 492         int err;
 493
 494         err = swreg_to_unrestricted(dst, lreg, rreg, &reg);
 495         if (err) {
 496                 nfp_prog->error = err;
 497                 return;
 498         }
 499
 500         __emit_alu(nfp_prog, reg.dst, reg.dst_ab,
 501                    reg.areg, op, reg.breg, reg.swap, reg.wr_both);
 502 }
 503
 504 static void
 505 __emit_ld_field(struct nfp_prog *nfp_prog, enum shf_sc sc,
 506                 u8 areg, u8 bmask, u8 breg, u8 shift, bool imm8,
 507                 bool zero, bool swap, bool wr_both)
 508 {
 509         u64 insn;
 510
 511         insn = OP_LDF_BASE |
 512                 FIELD_PREP(OP_LDF_A_SRC, areg) |
 513                 FIELD_PREP(OP_LDF_SC, sc) |
 514                 FIELD_PREP(OP_LDF_B_SRC, breg) |
 515                 FIELD_PREP(OP_LDF_I8, imm8) |
 516                 FIELD_PREP(OP_LDF_SW, swap) |
 517                 FIELD_PREP(OP_LDF_ZF, zero) |
 518                 FIELD_PREP(OP_LDF_BMASK, bmask) |
 519                 FIELD_PREP(OP_LDF_SHF, shift) |
 520                 FIELD_PREP(OP_LDF_WR_AB, wr_both);
 521
 522         nfp_prog_push(nfp_prog, insn);
 523 }
 524
 525 static void
 526 emit_ld_field_any(struct nfp_prog *nfp_prog, enum shf_sc sc, u8 shift,
 527                   u32 dst, u8 bmask, u32 src, bool zero)
 528 {
 529         struct nfp_insn_re_regs reg;
 530         int err;
 531
 532         err = swreg_to_restricted(reg_none(), dst, src, &reg, true);
 533         if (err) {
 534                 nfp_prog->error = err;
 535                 return;
 536         }
 537
 538         __emit_ld_field(nfp_prog, sc, reg.areg, bmask, reg.breg, shift,
 539                         reg.i8, zero, reg.swap, reg.wr_both);
 540 }
 541
 542 static void
 543 emit_ld_field(struct nfp_prog *nfp_prog, u32 dst, u8 bmask, u32 src,
 544               enum shf_sc sc, u8 shift)
 545 {
 546         emit_ld_field_any(nfp_prog, sc, shift, dst, bmask, src, false);
 547 }
 548
 549 /* --- Wrappers --- */
 550 static bool pack_immed(u32 imm, u16 *val, enum immed_shift *shift)
 551 {
 552         if (!(imm & 0xffff0000)) {
 553                 *val = imm;
 554                 *shift = IMMED_SHIFT_0B;
 555         } else if (!(imm & 0xff0000ff)) {
 556                 *val = imm >> 8;
 557                 *shift = IMMED_SHIFT_1B;
 558         } else if (!(imm & 0x0000ffff)) {
 559                 *val = imm >> 16;
 560                 *shift = IMMED_SHIFT_2B;
 561         } else {
 562                 return false;
 563         }
 564
 565         return true;
 566 }
 567
 568 static void wrp_immed(struct nfp_prog *nfp_prog, u32 dst, u32 imm)
 569 {
 570         enum immed_shift shift;
 571         u16 val;
 572
 573         if (pack_immed(imm, &val, &shift)) {
 574                 emit_immed(nfp_prog, dst, val, IMMED_WIDTH_ALL, false, shift);
 575         } else if (pack_immed(~imm, &val, &shift)) {
 576                 emit_immed(nfp_prog, dst, val, IMMED_WIDTH_ALL, true, shift);
 577         } else {
 578                 emit_immed(nfp_prog, dst, imm & 0xffff, IMMED_WIDTH_ALL,
 579                            false, IMMED_SHIFT_0B);
 580                 emit_immed(nfp_prog, dst, imm >> 16, IMMED_WIDTH_WORD,
 581                            false, IMMED_SHIFT_2B);
 582         }
 583 }
 584
 585 /* ur_load_imm_any() - encode immediate or use tmp register (unrestricted)
 586  * If the @imm is small enough encode it directly in operand and return
 587  * otherwise load @imm to a spare register and return its encoding.
 588  */
 589 static u32 ur_load_imm_any(struct nfp_prog *nfp_prog, u32 imm, u32 tmp_reg)
 590 {
 591         if (FIELD_FIT(UR_REG_IMM_MAX, imm))
 592                 return reg_imm(imm);
 593
 594         wrp_immed(nfp_prog, tmp_reg, imm);
 595         return tmp_reg;
 596 }
 597
 598 /* re_load_imm_any() - encode immediate or use tmp register (restricted)
 599  * If the @imm is small enough encode it directly in operand and return
 600  * otherwise load @imm to a spare register and return its encoding.
 601  */
 602 static u32 re_load_imm_any(struct nfp_prog *nfp_prog, u32 imm, u32 tmp_reg)
 603 {
 604         if (FIELD_FIT(RE_REG_IMM_MAX, imm))
 605                 return reg_imm(imm);
 606
 607         wrp_immed(nfp_prog, tmp_reg, imm);
 608         return tmp_reg;
 609 }
 610
 611 static void
 612 wrp_br_special(struct nfp_prog *nfp_prog, enum br_mask mask,
 613                enum br_special special)
 614 {
 615         emit_br(nfp_prog, mask, 0, 0);
 616
 617         nfp_prog->prog[nfp_prog->prog_len - 1] |=
 618                 FIELD_PREP(OP_BR_SPECIAL, special);
 619 }
 620
 621 static void wrp_reg_mov(struct nfp_prog *nfp_prog, u16 dst, u16 src)
 622 {
 623         emit_alu(nfp_prog, reg_both(dst), reg_none(), ALU_OP_NONE, reg_b(src));
 624 }
 625
 626 static int
 627 construct_data_ind_ld(struct nfp_prog *nfp_prog, u16 offset,
 628                       u16 src, bool src_valid, u8 size)
 629 {
 630         unsigned int i;
 631         u16 shift, sz;
 632         u32 tmp_reg;
 633
 634         /* We load the value from the address indicated in @offset and then
 635          * shift out the data we don't need.  Note: this is big endian!
 636          */
 637         sz = size < 4 ? 4 : size;
 638         shift = size < 4 ? 4 - size : 0;
 639
 640         if (src_valid) {
 641                 /* Calculate the true offset (src_reg + imm) */
 642                 tmp_reg = ur_load_imm_any(nfp_prog, offset, imm_b(nfp_prog));
 643                 emit_alu(nfp_prog, imm_both(nfp_prog),
 644                          reg_a(src), ALU_OP_ADD, tmp_reg);
 645                 /* Check packet length (size guaranteed to fit b/c it's u8) */
 646                 emit_alu(nfp_prog, imm_a(nfp_prog),
 647                          imm_a(nfp_prog), ALU_OP_ADD, reg_imm(size));
 648                 emit_alu(nfp_prog, reg_none(),
 649                          NFP_BPF_ABI_LEN, ALU_OP_SUB, imm_a(nfp_prog));
 650                 wrp_br_special(nfp_prog, BR_BLO, OP_BR_GO_ABORT);
 651                 /* Load data */
 652                 emit_cmd(nfp_prog, CMD_TGT_READ8, CMD_MODE_32b, 0,
 653                          pkt_reg(nfp_prog), imm_b(nfp_prog), sz - 1, true);
 654         } else {
 655                 /* Check packet length */
 656                 tmp_reg = ur_load_imm_any(nfp_prog, offset + size,
 657                                           imm_a(nfp_prog));
 658                 emit_alu(nfp_prog, reg_none(),
 659                          NFP_BPF_ABI_LEN, ALU_OP_SUB, tmp_reg);
 660                 wrp_br_special(nfp_prog, BR_BLO, OP_BR_GO_ABORT);
 661                 /* Load data */
 662                 tmp_reg = re_load_imm_any(nfp_prog, offset, imm_b(nfp_prog));
 663                 emit_cmd(nfp_prog, CMD_TGT_READ8, CMD_MODE_32b, 0,
 664                          pkt_reg(nfp_prog), tmp_reg, sz - 1, true);
 665         }
 666
 667         i = 0;
 668         if (shift)
 669                 emit_shf(nfp_prog, reg_both(0), reg_none(), SHF_OP_NONE,
 670                          reg_xfer(0), SHF_SC_R_SHF, shift * 8);
 671         else
 672                 for (; i * 4 < size; i++)
 673                         emit_alu(nfp_prog, reg_both(i),
 674                                  reg_none(), ALU_OP_NONE, reg_xfer(i));
 675
 676         if (i < 2)
 677                 wrp_immed(nfp_prog, reg_both(1), 0);
 678
 679         return 0;
 680 }
 681
 682 static int construct_data_ld(struct nfp_prog *nfp_prog, u16 offset, u8 size)
 683 {
 684         return construct_data_ind_ld(nfp_prog, offset, 0, false, size);
 685 }
 686
 687 static int wrp_set_mark(struct nfp_prog *nfp_prog, u8 src)
 688 {
 689         emit_alu(nfp_prog, NFP_BPF_ABI_MARK,
 690                  reg_none(), ALU_OP_NONE, reg_b(src));
 691         emit_alu(nfp_prog, NFP_BPF_ABI_FLAGS,
 692                  NFP_BPF_ABI_FLAGS, ALU_OP_OR, reg_imm(NFP_BPF_ABI_FLAG_MARK));
 693
 694         return 0;
 695 }
 696
 697 static void
 698 wrp_alu_imm(struct nfp_prog *nfp_prog, u8 dst, enum alu_op alu_op, u32 imm)
 699 {
 700         u32 tmp_reg;
 701
 702         if (alu_op == ALU_OP_AND) {
 703                 if (!imm)
 704                         wrp_immed(nfp_prog, reg_both(dst), 0);
 705                 if (!imm || !~imm)
 706                         return;
 707         }
 708         if (alu_op == ALU_OP_OR) {
 709                 if (!~imm)
 710                         wrp_immed(nfp_prog, reg_both(dst), ~0U);
 711                 if (!imm || !~imm)
 712                         return;
 713         }
 714         if (alu_op == ALU_OP_XOR) {
 715                 if (!~imm)
 716                         emit_alu(nfp_prog, reg_both(dst), reg_none(),
 717                                  ALU_OP_NEG, reg_b(dst));
 718                 if (!imm || !~imm)
 719                         return;
 720         }
 721
 722         tmp_reg = ur_load_imm_any(nfp_prog, imm, imm_b(nfp_prog));
 723         emit_alu(nfp_prog, reg_both(dst), reg_a(dst), alu_op, tmp_reg);
 724 }
 725
 726 static int
 727 wrp_alu64_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 728               enum alu_op alu_op, bool skip)
 729 {
 730         const struct bpf_insn *insn = &meta->insn;
 731         u64 imm = insn->imm; /* sign extend */
 732
 733         if (skip) {
 734                 meta->skip = true;
 735                 return 0;
 736         }
 737
 738         wrp_alu_imm(nfp_prog, insn->dst_reg * 2, alu_op, imm & ~0U);
 739         wrp_alu_imm(nfp_prog, insn->dst_reg * 2 + 1, alu_op, imm >> 32);
 740
 741         return 0;
 742 }
 743
 744 static int
 745 wrp_alu64_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 746               enum alu_op alu_op)
 747 {
 748         u8 dst = meta->insn.dst_reg * 2, src = meta->insn.src_reg * 2;
 749
 750         emit_alu(nfp_prog, reg_both(dst), reg_a(dst), alu_op, reg_b(src));
 751         emit_alu(nfp_prog, reg_both(dst + 1),
 752                  reg_a(dst + 1), alu_op, reg_b(src + 1));
 753
 754         return 0;
 755 }
 756
 757 static int
 758 wrp_alu32_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 759               enum alu_op alu_op)
 760 {
 761         const struct bpf_insn *insn = &meta->insn;
 762
 763         wrp_alu_imm(nfp_prog, insn->dst_reg * 2, alu_op, insn->imm);
 764         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
 765
 766         return 0;
 767 }
 768
 769 static int
 770 wrp_alu32_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 771               enum alu_op alu_op)
 772 {
 773         u8 dst = meta->insn.dst_reg * 2, src = meta->insn.src_reg * 2;
 774
 775         emit_alu(nfp_prog, reg_both(dst), reg_a(dst), alu_op, reg_b(src));
 776         wrp_immed(nfp_prog, reg_both(meta->insn.dst_reg * 2 + 1), 0);
 777
 778         return 0;
 779 }
 780
 781 static void
 782 wrp_test_reg_one(struct nfp_prog *nfp_prog, u8 dst, enum alu_op alu_op, u8 src,
 783                  enum br_mask br_mask, u16 off)
 784 {
 785         emit_alu(nfp_prog, reg_none(), reg_a(dst), alu_op, reg_b(src));
 786         emit_br(nfp_prog, br_mask, off, 0);
 787 }
 788
 789 static int
 790 wrp_test_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 791              enum alu_op alu_op, enum br_mask br_mask)
 792 {
 793         const struct bpf_insn *insn = &meta->insn;
 794
 795         if (insn->off < 0) /* TODO */
 796                 return -ENOTSUPP;
 797
 798         wrp_test_reg_one(nfp_prog, insn->dst_reg * 2, alu_op,
 799                          insn->src_reg * 2, br_mask, insn->off);
 800         wrp_test_reg_one(nfp_prog, insn->dst_reg * 2 + 1, alu_op,
 801                          insn->src_reg * 2 + 1, br_mask, insn->off);
 802
 803         return 0;
 804 }
 805
 806 static int
 807 wrp_cmp_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 808             enum br_mask br_mask, bool swap)
 809 {
 810         const struct bpf_insn *insn = &meta->insn;
 811         u64 imm = insn->imm; /* sign extend */
 812         u8 reg = insn->dst_reg * 2;
 813         u32 tmp_reg;
 814
 815         if (insn->off < 0) /* TODO */
 816                 return -ENOTSUPP;
 817
 818         tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
 819         if (!swap)
 820                 emit_alu(nfp_prog, reg_none(), reg_a(reg), ALU_OP_SUB, tmp_reg);
 821         else
 822                 emit_alu(nfp_prog, reg_none(), tmp_reg, ALU_OP_SUB, reg_a(reg));
 823
 824         tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
 825         if (!swap)
 826                 emit_alu(nfp_prog, reg_none(),
 827                          reg_a(reg + 1), ALU_OP_SUB_C, tmp_reg);
 828         else
 829                 emit_alu(nfp_prog, reg_none(),
 830                          tmp_reg, ALU_OP_SUB_C, reg_a(reg + 1));
 831
 832         emit_br(nfp_prog, br_mask, insn->off, 0);
 833
 834         return 0;
 835 }
 836
 837 static int
 838 wrp_cmp_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta,
 839             enum br_mask br_mask, bool swap)
 840 {
 841         const struct bpf_insn *insn = &meta->insn;
 842         u8 areg = insn->src_reg * 2, breg = insn->dst_reg * 2;
 843
 844         if (insn->off < 0) /* TODO */
 845                 return -ENOTSUPP;
 846
 847         if (swap) {
 848                 areg ^= breg;
 849                 breg ^= areg;
 850                 areg ^= breg;
 851         }
 852
 853         emit_alu(nfp_prog, reg_none(), reg_a(areg), ALU_OP_SUB, reg_b(breg));
 854         emit_alu(nfp_prog, reg_none(),
 855                  reg_a(areg + 1), ALU_OP_SUB_C, reg_b(breg + 1));
 856         emit_br(nfp_prog, br_mask, insn->off, 0);
 857
 858         return 0;
 859 }
 860
 861 /* --- Callbacks --- */
 862 static int mov_reg64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 863 {
 864         const struct bpf_insn *insn = &meta->insn;
 865
 866         wrp_reg_mov(nfp_prog, insn->dst_reg * 2, insn->src_reg * 2);
 867         wrp_reg_mov(nfp_prog, insn->dst_reg * 2 + 1, insn->src_reg * 2 + 1);
 868
 869         return 0;
 870 }
 871
 872 static int mov_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 873 {
 874         u64 imm = meta->insn.imm; /* sign extend */
 875
 876         wrp_immed(nfp_prog, reg_both(meta->insn.dst_reg * 2), imm & ~0U);
 877         wrp_immed(nfp_prog, reg_both(meta->insn.dst_reg * 2 + 1), imm >> 32);
 878
 879         return 0;
 880 }
 881
 882 static int xor_reg64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 883 {
 884         return wrp_alu64_reg(nfp_prog, meta, ALU_OP_XOR);
 885 }
 886
 887 static int xor_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 888 {
 889         return wrp_alu64_imm(nfp_prog, meta, ALU_OP_XOR, !meta->insn.imm);
 890 }
 891
 892 static int and_reg64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 893 {
 894         return wrp_alu64_reg(nfp_prog, meta, ALU_OP_AND);
 895 }
 896
 897 static int and_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 898 {
 899         return wrp_alu64_imm(nfp_prog, meta, ALU_OP_AND, !~meta->insn.imm);
 900 }
 901
 902 static int or_reg64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 903 {
 904         return wrp_alu64_reg(nfp_prog, meta, ALU_OP_OR);
 905 }
 906
 907 static int or_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 908 {
 909         return wrp_alu64_imm(nfp_prog, meta, ALU_OP_OR, !meta->insn.imm);
 910 }
 911
 912 static int add_reg64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 913 {
 914         const struct bpf_insn *insn = &meta->insn;
 915
 916         emit_alu(nfp_prog, reg_both(insn->dst_reg * 2),
 917                  reg_a(insn->dst_reg * 2), ALU_OP_ADD,
 918                  reg_b(insn->src_reg * 2));
 919         emit_alu(nfp_prog, reg_both(insn->dst_reg * 2 + 1),
 920                  reg_a(insn->dst_reg * 2 + 1), ALU_OP_ADD_C,
 921                  reg_b(insn->src_reg * 2 + 1));
 922
 923         return 0;
 924 }
 925
 926 static int add_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 927 {
 928         const struct bpf_insn *insn = &meta->insn;
 929         u64 imm = insn->imm; /* sign extend */
 930
 931         wrp_alu_imm(nfp_prog, insn->dst_reg * 2, ALU_OP_ADD, imm & ~0U);
 932         wrp_alu_imm(nfp_prog, insn->dst_reg * 2 + 1, ALU_OP_ADD_C, imm >> 32);
 933
 934         return 0;
 935 }
 936
 937 static int sub_reg64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 938 {
 939         const struct bpf_insn *insn = &meta->insn;
 940
 941         emit_alu(nfp_prog, reg_both(insn->dst_reg * 2),
 942                  reg_a(insn->dst_reg * 2), ALU_OP_SUB,
 943                  reg_b(insn->src_reg * 2));
 944         emit_alu(nfp_prog, reg_both(insn->dst_reg * 2 + 1),
 945                  reg_a(insn->dst_reg * 2 + 1), ALU_OP_SUB_C,
 946                  reg_b(insn->src_reg * 2 + 1));
 947
 948         return 0;
 949 }
 950
 951 static int sub_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 952 {
 953         const struct bpf_insn *insn = &meta->insn;
 954         u64 imm = insn->imm; /* sign extend */
 955
 956         wrp_alu_imm(nfp_prog, insn->dst_reg * 2, ALU_OP_SUB, imm & ~0U);
 957         wrp_alu_imm(nfp_prog, insn->dst_reg * 2 + 1, ALU_OP_SUB_C, imm >> 32);
 958
 959         return 0;
 960 }
 961
 962 static int shl_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 963 {
 964         const struct bpf_insn *insn = &meta->insn;
 965
 966         if (insn->imm != 32)
 967                 return 1; /* TODO */
 968
 969         wrp_reg_mov(nfp_prog, insn->dst_reg * 2 + 1, insn->dst_reg * 2);
 970         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2), 0);
 971
 972         return 0;
 973 }
 974
 975 static int shr_imm64(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 976 {
 977         const struct bpf_insn *insn = &meta->insn;
 978
 979         if (insn->imm != 32)
 980                 return 1; /* TODO */
 981
 982         wrp_reg_mov(nfp_prog, insn->dst_reg * 2, insn->dst_reg * 2 + 1);
 983         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
 984
 985         return 0;
 986 }
 987
 988 static int mov_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 989 {
 990         const struct bpf_insn *insn = &meta->insn;
 991
 992         wrp_reg_mov(nfp_prog, insn->dst_reg * 2,  insn->src_reg * 2);
 993         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
 994
 995         return 0;
 996 }
 997
 998 static int mov_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
 999 {
1000         const struct bpf_insn *insn = &meta->insn;
1001
1002         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2), insn->imm);
1003         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
1004
1005         return 0;
1006 }
1007
1008 static int xor_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1009 {
1010         return wrp_alu32_reg(nfp_prog, meta, ALU_OP_XOR);
1011 }
1012
1013 static int xor_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1014 {
1015         return wrp_alu32_imm(nfp_prog, meta, ALU_OP_XOR);
1016 }
1017
1018 static int and_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1019 {
1020         return wrp_alu32_reg(nfp_prog, meta, ALU_OP_AND);
1021 }
1022
1023 static int and_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1024 {
1025         return wrp_alu32_imm(nfp_prog, meta, ALU_OP_AND);
1026 }
1027
1028 static int or_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1029 {
1030         return wrp_alu32_reg(nfp_prog, meta, ALU_OP_OR);
1031 }
1032
1033 static int or_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1034 {
1035         return wrp_alu32_imm(nfp_prog, meta, ALU_OP_OR);
1036 }
1037
1038 static int add_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1039 {
1040         return wrp_alu32_reg(nfp_prog, meta, ALU_OP_ADD);
1041 }
1042
1043 static int add_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1044 {
1045         return wrp_alu32_imm(nfp_prog, meta, ALU_OP_ADD);
1046 }
1047
1048 static int sub_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1049 {
1050         return wrp_alu32_reg(nfp_prog, meta, ALU_OP_SUB);
1051 }
1052
1053 static int sub_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1054 {
1055         return wrp_alu32_imm(nfp_prog, meta, ALU_OP_SUB);
1056 }
1057
1058 static int shl_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1059 {
1060         const struct bpf_insn *insn = &meta->insn;
1061
1062         if (!insn->imm)
1063                 return 1; /* TODO: zero shift means indirect */
1064
1065         emit_shf(nfp_prog, reg_both(insn->dst_reg * 2),
1066                  reg_none(), SHF_OP_NONE, reg_b(insn->dst_reg * 2),
1067                  SHF_SC_L_SHF, insn->imm);
1068         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2 + 1), 0);
1069
1070         return 0;
1071 }
1072
1073 static int imm_ld8_part2(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1074 {
1075         wrp_immed(nfp_prog, reg_both(nfp_meta_prev(meta)->insn.dst_reg * 2 + 1),
1076                   meta->insn.imm);
1077
1078         return 0;
1079 }
1080
1081 static int imm_ld8(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1082 {
1083         const struct bpf_insn *insn = &meta->insn;
1084
1085         meta->double_cb = imm_ld8_part2;
1086         wrp_immed(nfp_prog, reg_both(insn->dst_reg * 2), insn->imm);
1087
1088         return 0;
1089 }
1090
1091 static int data_ld1(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1092 {
1093         return construct_data_ld(nfp_prog, meta->insn.imm, 1);
1094 }
1095
1096 static int data_ld2(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1097 {
1098         return construct_data_ld(nfp_prog, meta->insn.imm, 2);
1099 }
1100
1101 static int data_ld4(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1102 {
1103         return construct_data_ld(nfp_prog, meta->insn.imm, 4);
1104 }
1105
1106 static int data_ind_ld1(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1107 {
1108         return construct_data_ind_ld(nfp_prog, meta->insn.imm,
1109                                      meta->insn.src_reg * 2, true, 1);
1110 }
1111
1112 static int data_ind_ld2(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1113 {
1114         return construct_data_ind_ld(nfp_prog, meta->insn.imm,
1115                                      meta->insn.src_reg * 2, true, 2);
1116 }
1117
1118 static int data_ind_ld4(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1119 {
1120         return construct_data_ind_ld(nfp_prog, meta->insn.imm,
1121                                      meta->insn.src_reg * 2, true, 4);
1122 }
1123
1124 static int mem_ldx4(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1125 {
1126         if (meta->insn.off == offsetof(struct sk_buff, len))
1127                 emit_alu(nfp_prog, reg_both(meta->insn.dst_reg * 2),
1128                          reg_none(), ALU_OP_NONE, NFP_BPF_ABI_LEN);
1129         else
1130                 return -ENOTSUPP;
1131
1132         wrp_immed(nfp_prog, reg_both(meta->insn.dst_reg * 2 + 1), 0);
1133
1134         return 0;
1135 }
1136
1137 static int mem_stx4(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1138 {
1139         if (meta->insn.off == offsetof(struct sk_buff, mark))
1140                 return wrp_set_mark(nfp_prog, meta->insn.src_reg * 2);
1141
1142         return -ENOTSUPP;
1143 }
1144
1145 static int jump(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1146 {
1147         if (meta->insn.off < 0) /* TODO */
1148                 return -ENOTSUPP;
1149         emit_br(nfp_prog, BR_UNC, meta->insn.off, 0);
1150
1151         return 0;
1152 }
1153
1154 static int jeq_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1155 {
1156         const struct bpf_insn *insn = &meta->insn;
1157         u64 imm = insn->imm; /* sign extend */
1158         u32 or1 = reg_a(insn->dst_reg * 2), or2 = reg_b(insn->dst_reg * 2 + 1);
1159         u32 tmp_reg;
1160
1161         if (insn->off < 0) /* TODO */
1162                 return -ENOTSUPP;
1163
1164         if (imm & ~0U) {
1165                 tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
1166                 emit_alu(nfp_prog, imm_a(nfp_prog),
1167                          reg_a(insn->dst_reg * 2), ALU_OP_XOR, tmp_reg);
1168                 or1 = imm_a(nfp_prog);
1169         }
1170
1171         if (imm >> 32) {
1172                 tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
1173                 emit_alu(nfp_prog, imm_b(nfp_prog),
1174                          reg_a(insn->dst_reg * 2 + 1), ALU_OP_XOR, tmp_reg);
1175                 or2 = imm_b(nfp_prog);
1176         }
1177
1178         emit_alu(nfp_prog, reg_none(), or1, ALU_OP_OR, or2);
1179         emit_br(nfp_prog, BR_BEQ, insn->off, 0);
1180
1181         return 0;
1182 }
1183
1184 static int jgt_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1185 {
1186         return wrp_cmp_imm(nfp_prog, meta, BR_BLO, false);
1187 }
1188
1189 static int jge_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1190 {
1191         return wrp_cmp_imm(nfp_prog, meta, BR_BHS, true);
1192 }
1193
1194 static int jset_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1195 {
1196         const struct bpf_insn *insn = &meta->insn;
1197         u64 imm = insn->imm; /* sign extend */
1198         u32 tmp_reg;
1199
1200         if (insn->off < 0) /* TODO */
1201                 return -ENOTSUPP;
1202
1203         if (!imm) {
1204                 meta->skip = true;
1205                 return 0;
1206         }
1207
1208         if (imm & ~0U) {
1209                 tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
1210                 emit_alu(nfp_prog, reg_none(),
1211                          reg_a(insn->dst_reg * 2), ALU_OP_AND, tmp_reg);
1212                 emit_br(nfp_prog, BR_BNE, insn->off, 0);
1213         }
1214
1215         if (imm >> 32) {
1216                 tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
1217                 emit_alu(nfp_prog, reg_none(),
1218                          reg_a(insn->dst_reg * 2 + 1), ALU_OP_AND, tmp_reg);
1219                 emit_br(nfp_prog, BR_BNE, insn->off, 0);
1220         }
1221
1222         return 0;
1223 }
1224
1225 static int jne_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1226 {
1227         const struct bpf_insn *insn = &meta->insn;
1228         u64 imm = insn->imm; /* sign extend */
1229         u32 tmp_reg;
1230
1231         if (insn->off < 0) /* TODO */
1232                 return -ENOTSUPP;
1233
1234         if (!imm) {
1235                 emit_alu(nfp_prog, reg_none(), reg_a(insn->dst_reg * 2),
1236                          ALU_OP_OR, reg_b(insn->dst_reg * 2 + 1));
1237                 emit_br(nfp_prog, BR_BNE, insn->off, 0);
1238         }
1239
1240         tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
1241         emit_alu(nfp_prog, reg_none(),
1242                  reg_a(insn->dst_reg * 2), ALU_OP_XOR, tmp_reg);
1243         emit_br(nfp_prog, BR_BNE, insn->off, 0);
1244
1245         tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
1246         emit_alu(nfp_prog, reg_none(),
1247                  reg_a(insn->dst_reg * 2 + 1), ALU_OP_XOR, tmp_reg);
1248         emit_br(nfp_prog, BR_BNE, insn->off, 0);
1249
1250         return 0;
1251 }
1252
1253 static int jeq_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1254 {
1255         const struct bpf_insn *insn = &meta->insn;
1256
1257         if (insn->off < 0) /* TODO */
1258                 return -ENOTSUPP;
1259
1260         emit_alu(nfp_prog, imm_a(nfp_prog), reg_a(insn->dst_reg * 2),
1261                  ALU_OP_XOR, reg_b(insn->src_reg * 2));
1262         emit_alu(nfp_prog, imm_b(nfp_prog), reg_a(insn->dst_reg * 2 + 1),
1263                  ALU_OP_XOR, reg_b(insn->src_reg * 2 + 1));
1264         emit_alu(nfp_prog, reg_none(),
1265                  imm_a(nfp_prog), ALU_OP_OR, imm_b(nfp_prog));
1266         emit_br(nfp_prog, BR_BEQ, insn->off, 0);
1267
1268         return 0;
1269 }
1270
1271 static int jgt_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1272 {
1273         return wrp_cmp_reg(nfp_prog, meta, BR_BLO, false);
1274 }
1275
1276 static int jge_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1277 {
1278         return wrp_cmp_reg(nfp_prog, meta, BR_BHS, true);
1279 }
1280
1281 static int jset_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1282 {
1283         return wrp_test_reg(nfp_prog, meta, ALU_OP_AND, BR_BNE);
1284 }
1285
1286 static int jne_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1287 {
1288         return wrp_test_reg(nfp_prog, meta, ALU_OP_XOR, BR_BNE);
1289 }
1290
1291 static int goto_out(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1292 {
1293         wrp_br_special(nfp_prog, BR_UNC, OP_BR_GO_OUT);
1294
1295         return 0;
1296 }
1297
1298 static const instr_cb_t instr_cb[256] = {
1299         [BPF_ALU64 | BPF_MOV | BPF_X] = mov_reg64,
1300         [BPF_ALU64 | BPF_MOV | BPF_K] = mov_imm64,
1301         [BPF_ALU64 | BPF_XOR | BPF_X] = xor_reg64,
1302         [BPF_ALU64 | BPF_XOR | BPF_K] = xor_imm64,
1303         [BPF_ALU64 | BPF_AND | BPF_X] = and_reg64,
1304         [BPF_ALU64 | BPF_AND | BPF_K] = and_imm64,
1305         [BPF_ALU64 | BPF_OR | BPF_X] =  or_reg64,
1306         [BPF_ALU64 | BPF_OR | BPF_K] =  or_imm64,
1307         [BPF_ALU64 | BPF_ADD | BPF_X] = add_reg64,
1308         [BPF_ALU64 | BPF_ADD | BPF_K] = add_imm64,
1309         [BPF_ALU64 | BPF_SUB | BPF_X] = sub_reg64,
1310         [BPF_ALU64 | BPF_SUB | BPF_K] = sub_imm64,
1311         [BPF_ALU64 | BPF_LSH | BPF_K] = shl_imm64,
1312         [BPF_ALU64 | BPF_RSH | BPF_K] = shr_imm64,
1313         [BPF_ALU | BPF_MOV | BPF_X] =   mov_reg,
1314         [BPF_ALU | BPF_MOV | BPF_K] =   mov_imm,
1315         [BPF_ALU | BPF_XOR | BPF_X] =   xor_reg,
1316         [BPF_ALU | BPF_XOR | BPF_K] =   xor_imm,
1317         [BPF_ALU | BPF_AND | BPF_X] =   and_reg,
1318         [BPF_ALU | BPF_AND | BPF_K] =   and_imm,
1319         [BPF_ALU | BPF_OR | BPF_X] =    or_reg,
1320         [BPF_ALU | BPF_OR | BPF_K] =    or_imm,
1321         [BPF_ALU | BPF_ADD | BPF_X] =   add_reg,
1322         [BPF_ALU | BPF_ADD | BPF_K] =   add_imm,
1323         [BPF_ALU | BPF_SUB | BPF_X] =   sub_reg,
1324         [BPF_ALU | BPF_SUB | BPF_K] =   sub_imm,
1325         [BPF_ALU | BPF_LSH | BPF_K] =   shl_imm,
1326         [BPF_LD | BPF_IMM | BPF_DW] =   imm_ld8,
1327         [BPF_LD | BPF_ABS | BPF_B] =    data_ld1,
1328         [BPF_LD | BPF_ABS | BPF_H] =    data_ld2,
1329         [BPF_LD | BPF_ABS | BPF_W] =    data_ld4,
1330         [BPF_LD | BPF_IND | BPF_B] =    data_ind_ld1,
1331         [BPF_LD | BPF_IND | BPF_H] =    data_ind_ld2,
1332         [BPF_LD | BPF_IND | BPF_W] =    data_ind_ld4,
1333         [BPF_LDX | BPF_MEM | BPF_W] =   mem_ldx4,
1334         [BPF_STX | BPF_MEM | BPF_W] =   mem_stx4,
1335         [BPF_JMP | BPF_JA | BPF_K] =    jump,
1336         [BPF_JMP | BPF_JEQ | BPF_K] =   jeq_imm,
1337         [BPF_JMP | BPF_JGT | BPF_K] =   jgt_imm,
1338         [BPF_JMP | BPF_JGE | BPF_K] =   jge_imm,
1339         [BPF_JMP | BPF_JSET | BPF_K] =  jset_imm,
1340         [BPF_JMP | BPF_JNE | BPF_K] =   jne_imm,
1341         [BPF_JMP | BPF_JEQ | BPF_X] =   jeq_reg,
1342         [BPF_JMP | BPF_JGT | BPF_X] =   jgt_reg,
1343         [BPF_JMP | BPF_JGE | BPF_X] =   jge_reg,
1344         [BPF_JMP | BPF_JSET | BPF_X] =  jset_reg,
1345         [BPF_JMP | BPF_JNE | BPF_X] =   jne_reg,
1346         [BPF_JMP | BPF_EXIT] =          goto_out,
1347 };
1348
1349 /* --- Misc code --- */
1350 static void br_set_offset(u64 *instr, u16 offset)
1351 {
1352         u16 addr_lo, addr_hi;
1353
1354         addr_lo = offset & (OP_BR_ADDR_LO >> __bf_shf(OP_BR_ADDR_LO));
1355         addr_hi = offset != addr_lo;
1356         *instr &= ~(OP_BR_ADDR_HI | OP_BR_ADDR_LO);
1357         *instr |= FIELD_PREP(OP_BR_ADDR_HI, addr_hi);
1358         *instr |= FIELD_PREP(OP_BR_ADDR_LO, addr_lo);
1359 }
1360
1361 /* --- Assembler logic --- */
1362 static int nfp_fixup_branches(struct nfp_prog *nfp_prog)
1363 {
1364         struct nfp_insn_meta *meta, *next;
1365         u32 off, br_idx;
1366         u32 idx;
1367
1368         nfp_for_each_insn_walk2(nfp_prog, meta, next) {
1369                 if (meta->skip)
1370                         continue;
1371                 if (BPF_CLASS(meta->insn.code) != BPF_JMP)
1372                         continue;
1373
1374                 br_idx = nfp_prog_offset_to_index(nfp_prog, next->off) - 1;
1375                 if (!nfp_is_br(nfp_prog->prog[br_idx])) {
1376                         pr_err("Fixup found block not ending in branch %d %02x %016llx!!\n",
1377                                br_idx, meta->insn.code, nfp_prog->prog[br_idx]);
1378                         return -ELOOP;
1379                 }
1380                 /* Leave special branches for later */
1381                 if (FIELD_GET(OP_BR_SPECIAL, nfp_prog->prog[br_idx]))
1382                         continue;
1383
1384                 /* Find the target offset in assembler realm */
1385                 off = meta->insn.off;
1386                 if (!off) {
1387                         pr_err("Fixup found zero offset!!\n");
1388                         return -ELOOP;
1389                 }
1390
1391                 while (off && nfp_meta_has_next(nfp_prog, next)) {
1392                         next = nfp_meta_next(next);
1393                         off--;
1394                 }
1395                 if (off) {
1396                         pr_err("Fixup found too large jump!! %d\n", off);
1397                         return -ELOOP;
1398                 }
1399
1400                 if (next->skip) {
1401                         pr_err("Branch landing on removed instruction!!\n");
1402                         return -ELOOP;
1403                 }
1404
1405                 for (idx = nfp_prog_offset_to_index(nfp_prog, meta->off);
1406                      idx <= br_idx; idx++) {
1407                         if (!nfp_is_br(nfp_prog->prog[idx]))
1408                                 continue;
1409                         br_set_offset(&nfp_prog->prog[idx], next->off);
1410                 }
1411         }
1412
1413         /* Fixup 'goto out's separately, they can be scattered around */
1414         for (br_idx = 0; br_idx < nfp_prog->prog_len; br_idx++) {
1415                 enum br_special special;
1416
1417                 if ((nfp_prog->prog[br_idx] & OP_BR_BASE_MASK) != OP_BR_BASE)
1418                         continue;
1419
1420                 special = FIELD_GET(OP_BR_SPECIAL, nfp_prog->prog[br_idx]);
1421                 switch (special) {
1422                 case OP_BR_NORMAL:
1423                         break;
1424                 case OP_BR_GO_OUT:
1425                         br_set_offset(&nfp_prog->prog[br_idx],
1426                                       nfp_prog->tgt_out);
1427                         break;
1428                 case OP_BR_GO_ABORT:
1429                         br_set_offset(&nfp_prog->prog[br_idx],
1430                                       nfp_prog->tgt_abort);
1431                         break;
1432                 }
1433
1434                 nfp_prog->prog[br_idx] &= ~OP_BR_SPECIAL;
1435         }
1436
1437         return 0;
1438 }
1439
1440 static void nfp_intro(struct nfp_prog *nfp_prog)
1441 {
1442         emit_alu(nfp_prog, pkt_reg(nfp_prog),
1443                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_PKT);
1444 }
1445
1446 static void nfp_outro_tc_legacy(struct nfp_prog *nfp_prog)
1447 {
1448         const u8 act2code[] = {
1449                 [NN_ACT_TC_DROP]  = 0x22,
1450                 [NN_ACT_TC_REDIR] = 0x24
1451         };
1452         /* Target for aborts */
1453         nfp_prog->tgt_abort = nfp_prog_current_offset(nfp_prog);
1454         wrp_immed(nfp_prog, reg_both(0), 0);
1455
1456         /* Target for normal exits */
1457         nfp_prog->tgt_out = nfp_prog_current_offset(nfp_prog);
1458         /* Legacy TC mode:
1459          *   0        0x11 -> pass,  count as stat0
1460          *  -1  drop  0x22 -> drop,  count as stat1
1461          *     redir  0x24 -> redir, count as stat1
1462          *  ife mark  0x21 -> pass,  count as stat1
1463          *  ife + tx  0x24 -> redir, count as stat1
1464          */
1465         emit_br_byte_neq(nfp_prog, reg_b(0), 0xff, 0, nfp_prog->tgt_done, 2);
1466         emit_alu(nfp_prog, reg_a(0),
1467                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1468         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(0x11), SHF_SC_L_SHF, 16);
1469
1470         emit_br(nfp_prog, BR_UNC, nfp_prog->tgt_done, 1);
1471         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(act2code[nfp_prog->act]),
1472                       SHF_SC_L_SHF, 16);
1473 }
1474
1475 static void nfp_outro_tc_da(struct nfp_prog *nfp_prog)
1476 {
1477         /* TC direct-action mode:
1478          *   0,1   ok        NOT SUPPORTED[1]
1479          *   2   drop  0x22 -> drop,  count as stat1
1480          *   4,5 nuke  0x02 -> drop
1481          *   7  redir  0x44 -> redir, count as stat2
1482          *   * unspec  0x11 -> pass,  count as stat0
1483          *
1484          * [1] We can't support OK and RECLASSIFY because we can't tell TC
1485          *     the exact decision made.  We are forced to support UNSPEC
1486          *     to handle aborts so that's the only one we handle for passing
1487          *     packets up the stack.
1488          */
1489         /* Target for aborts */
1490         nfp_prog->tgt_abort = nfp_prog_current_offset(nfp_prog);
1491
1492         emit_br_def(nfp_prog, nfp_prog->tgt_done, 2);
1493
1494         emit_alu(nfp_prog, reg_a(0),
1495                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1496         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(0x11), SHF_SC_L_SHF, 16);
1497
1498         /* Target for normal exits */
1499         nfp_prog->tgt_out = nfp_prog_current_offset(nfp_prog);
1500
1501         /* if R0 > 7 jump to abort */
1502         emit_alu(nfp_prog, reg_none(), reg_imm(7), ALU_OP_SUB, reg_b(0));
1503         emit_br(nfp_prog, BR_BLO, nfp_prog->tgt_abort, 0);
1504         emit_alu(nfp_prog, reg_a(0),
1505                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1506
1507         wrp_immed(nfp_prog, reg_b(2), 0x41221211);
1508         wrp_immed(nfp_prog, reg_b(3), 0x41001211);
1509
1510         emit_shf(nfp_prog, reg_a(1),
1511                  reg_none(), SHF_OP_NONE, reg_b(0), SHF_SC_L_SHF, 2);
1512
1513         emit_alu(nfp_prog, reg_none(), reg_a(1), ALU_OP_OR, reg_imm(0));
1514         emit_shf(nfp_prog, reg_a(2),
1515                  reg_imm(0xf), SHF_OP_AND, reg_b(2), SHF_SC_R_SHF, 0);
1516
1517         emit_alu(nfp_prog, reg_none(), reg_a(1), ALU_OP_OR, reg_imm(0));
1518         emit_shf(nfp_prog, reg_b(2),
1519                  reg_imm(0xf), SHF_OP_AND, reg_b(3), SHF_SC_R_SHF, 0);
1520
1521         emit_br_def(nfp_prog, nfp_prog->tgt_done, 2);
1522
1523         emit_shf(nfp_prog, reg_b(2),
1524                  reg_a(2), SHF_OP_OR, reg_b(2), SHF_SC_L_SHF, 4);
1525         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_b(2), SHF_SC_L_SHF, 16);
1526 }
1527
1528 static void nfp_outro(struct nfp_prog *nfp_prog)
1529 {
1530         switch (nfp_prog->act) {
1531         case NN_ACT_DIRECT:
1532                 nfp_outro_tc_da(nfp_prog);
1533                 break;
1534         case NN_ACT_TC_DROP:
1535         case NN_ACT_TC_REDIR:
1536                 nfp_outro_tc_legacy(nfp_prog);
1537                 break;
1538         }
1539 }
1540
1541 static int nfp_translate(struct nfp_prog *nfp_prog)
1542 {
1543         struct nfp_insn_meta *meta;
1544         int err;
1545
1546         nfp_intro(nfp_prog);
1547         if (nfp_prog->error)
1548                 return nfp_prog->error;
1549
1550         list_for_each_entry(meta, &nfp_prog->insns, l) {
1551                 instr_cb_t cb = instr_cb[meta->insn.code];
1552
1553                 meta->off = nfp_prog_current_offset(nfp_prog);
1554
1555                 if (meta->skip) {
1556                         nfp_prog->n_translated++;
1557                         continue;
1558                 }
1559
1560                 if (nfp_meta_has_prev(nfp_prog, meta) &&
1561                     nfp_meta_prev(meta)->double_cb)
1562                         cb = nfp_meta_prev(meta)->double_cb;
1563                 if (!cb)
1564                         return -ENOENT;
1565                 err = cb(nfp_prog, meta);
1566                 if (err)
1567                         return err;
1568
1569                 nfp_prog->n_translated++;
1570         }
1571
1572         nfp_outro(nfp_prog);
1573         if (nfp_prog->error)
1574                 return nfp_prog->error;
1575
1576         return nfp_fixup_branches(nfp_prog);
1577 }
1578
1579 static int
1580 nfp_prog_prepare(struct nfp_prog *nfp_prog, const struct bpf_insn *prog,
1581                  unsigned int cnt)
1582 {
1583         unsigned int i;
1584
1585         for (i = 0; i < cnt; i++) {
1586                 struct nfp_insn_meta *meta;
1587
1588                 meta = kzalloc(sizeof(*meta), GFP_KERNEL);
1589                 if (!meta)
1590                         return -ENOMEM;
1591
1592                 meta->insn = prog[i];
1593                 meta->n = i;
1594
1595                 list_add_tail(&meta->l, &nfp_prog->insns);
1596         }
1597
1598         return 0;
1599 }
1600
1601 /* --- Optimizations --- */
1602 static void nfp_bpf_opt_reg_init(struct nfp_prog *nfp_prog)
1603 {
1604         struct nfp_insn_meta *meta;
1605
1606         list_for_each_entry(meta, &nfp_prog->insns, l) {
1607                 struct bpf_insn insn = meta->insn;
1608
1609                 /* Programs converted from cBPF start with register xoring */
1610                 if (insn.code == (BPF_ALU64 | BPF_XOR | BPF_X) &&
1611                     insn.src_reg == insn.dst_reg)
1612                         continue;
1613
1614                 /* Programs start with R6 = R1 but we ignore the skb pointer */
1615                 if (insn.code == (BPF_ALU64 | BPF_MOV | BPF_X) &&
1616                     insn.src_reg == 1 && insn.dst_reg == 6)
1617                         meta->skip = true;
1618
1619                 /* Return as soon as something doesn't match */
1620                 if (!meta->skip)
1621                         return;
1622         }
1623 }
1624
1625 /* Try to rename registers so that program uses only low ones */
1626 static int nfp_bpf_opt_reg_rename(struct nfp_prog *nfp_prog)
1627 {
1628         bool reg_used[MAX_BPF_REG] = {};
1629         u8 tgt_reg[MAX_BPF_REG] = {};
1630         struct nfp_insn_meta *meta;
1631         unsigned int i, j;
1632
1633         list_for_each_entry(meta, &nfp_prog->insns, l) {
1634                 if (meta->skip)
1635                         continue;
1636
1637                 reg_used[meta->insn.src_reg] = true;
1638                 reg_used[meta->insn.dst_reg] = true;
1639         }
1640
1641         for (i = 0, j = 0; i < ARRAY_SIZE(tgt_reg); i++) {
1642                 if (!reg_used[i])
1643                         continue;
1644
1645                 tgt_reg[i] = j++;
1646         }
1647         nfp_prog->num_regs = j;
1648
1649         list_for_each_entry(meta, &nfp_prog->insns, l) {
1650                 meta->insn.src_reg = tgt_reg[meta->insn.src_reg];
1651                 meta->insn.dst_reg = tgt_reg[meta->insn.dst_reg];
1652         }
1653
1654         return 0;
1655 }
1656
1657 /* Remove masking after load since our load guarantees this is not needed */
1658 static void nfp_bpf_opt_ld_mask(struct nfp_prog *nfp_prog)
1659 {
1660         struct nfp_insn_meta *meta1, *meta2;
1661         const s32 exp_mask[] = {
1662                 [BPF_B] = 0x000000ffU,
1663                 [BPF_H] = 0x0000ffffU,
1664                 [BPF_W] = 0xffffffffU,
1665         };
1666
1667         nfp_for_each_insn_walk2(nfp_prog, meta1, meta2) {
1668                 struct bpf_insn insn, next;
1669
1670                 insn = meta1->insn;
1671                 next = meta2->insn;
1672
1673                 if (BPF_CLASS(insn.code) != BPF_LD)
1674                         continue;
1675                 if (BPF_MODE(insn.code) != BPF_ABS &&
1676                     BPF_MODE(insn.code) != BPF_IND)
1677                         continue;
1678
1679                 if (next.code != (BPF_ALU64 | BPF_AND | BPF_K))
1680                         continue;
1681
1682                 if (!exp_mask[BPF_SIZE(insn.code)])
1683                         continue;
1684                 if (exp_mask[BPF_SIZE(insn.code)] != next.imm)
1685                         continue;
1686
1687                 if (next.src_reg || next.dst_reg)
1688                         continue;
1689
1690                 meta2->skip = true;
1691         }
1692 }
1693
1694 static void nfp_bpf_opt_ld_shift(struct nfp_prog *nfp_prog)
1695 {
1696         struct nfp_insn_meta *meta1, *meta2, *meta3;
1697
1698         nfp_for_each_insn_walk3(nfp_prog, meta1, meta2, meta3) {
1699                 struct bpf_insn insn, next1, next2;
1700
1701                 insn = meta1->insn;
1702                 next1 = meta2->insn;
1703                 next2 = meta3->insn;
1704
1705                 if (BPF_CLASS(insn.code) != BPF_LD)
1706                         continue;
1707                 if (BPF_MODE(insn.code) != BPF_ABS &&
1708                     BPF_MODE(insn.code) != BPF_IND)
1709                         continue;
1710                 if (BPF_SIZE(insn.code) != BPF_W)
1711                         continue;
1712
1713                 if (!(next1.code == (BPF_LSH | BPF_K | BPF_ALU64) &&
1714                       next2.code == (BPF_RSH | BPF_K | BPF_ALU64)) &&
1715                     !(next1.code == (BPF_RSH | BPF_K | BPF_ALU64) &&
1716                       next2.code == (BPF_LSH | BPF_K | BPF_ALU64)))
1717                         continue;
1718
1719                 if (next1.src_reg || next1.dst_reg ||
1720                     next2.src_reg || next2.dst_reg)
1721                         continue;
1722
1723                 if (next1.imm != 0x20 || next2.imm != 0x20)
1724                         continue;
1725
1726                 meta2->skip = true;
1727                 meta3->skip = true;
1728         }
1729 }
1730
1731 static int nfp_bpf_optimize(struct nfp_prog *nfp_prog)
1732 {
1733         int ret;
1734
1735         nfp_bpf_opt_reg_init(nfp_prog);
1736
1737         ret = nfp_bpf_opt_reg_rename(nfp_prog);
1738         if (ret)
1739                 return ret;
1740
1741         nfp_bpf_opt_ld_mask(nfp_prog);
1742         nfp_bpf_opt_ld_shift(nfp_prog);
1743
1744         return 0;
1745 }
1746
1747 /**
1748  * nfp_bpf_jit() - translate BPF code into NFP assembly
1749  * @filter:     kernel BPF filter struct
1750  * @prog_mem:   memory to store assembler instructions
1751  * @act:        action attached to this eBPF program
1752  * @prog_start: offset of the first instruction when loaded
1753  * @prog_done:  where to jump on exit
1754  * @prog_sz:    size of @prog_mem in instructions
1755  * @res:        achieved parameters of translation results
1756  */
1757 int
1758 nfp_bpf_jit(struct bpf_prog *filter, void *prog_mem,
1759             enum nfp_bpf_action_type act,
1760             unsigned int prog_start, unsigned int prog_done,
1761             unsigned int prog_sz, struct nfp_bpf_result *res)
1762 {
1763         struct nfp_prog *nfp_prog;
1764         int ret;
1765
1766         nfp_prog = kzalloc(sizeof(*nfp_prog), GFP_KERNEL);
1767         if (!nfp_prog)
1768                 return -ENOMEM;
1769
1770         INIT_LIST_HEAD(&nfp_prog->insns);
1771         nfp_prog->act = act;
1772         nfp_prog->start_off = prog_start;
1773         nfp_prog->tgt_done = prog_done;
1774
1775         ret = nfp_prog_prepare(nfp_prog, filter->insnsi, filter->len);
1776         if (ret)
1777                 goto out;
1778
1779         ret = nfp_prog_verify(nfp_prog, filter);
1780         if (ret)
1781                 goto out;
1782
1783         ret = nfp_bpf_optimize(nfp_prog);
1784         if (ret)
1785                 goto out;
1786
1787         if (nfp_prog->num_regs <= 7)
1788                 nfp_prog->regs_per_thread = 16;
1789         else
1790                 nfp_prog->regs_per_thread = 32;
1791
1792         nfp_prog->prog = prog_mem;
1793         nfp_prog->__prog_alloc_len = prog_sz;
1794
1795         ret = nfp_translate(nfp_prog);
1796         if (ret) {
1797                 pr_err("Translation failed with error %d (translated: %u)\n",
1798                        ret, nfp_prog->n_translated);
1799                 ret = -EINVAL;
1800         }
1801
1802         res->n_instr = nfp_prog->prog_len;
1803         res->dense_mode = nfp_prog->num_regs <= 7;
1804 out:
1805         nfp_prog_free(nfp_prog);
1806
1807         return ret;
1808 }