drivers/net/ethernet/netronome/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 "main.h"
  43 #include "../nfp_asm.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 -EOPNOTSUPP;
 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 -EOPNOTSUPP;
 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 -EOPNOTSUPP;
 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_skb(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 -EOPNOTSUPP;
1131
1132         return 0;
1133 }
1134
1135 static int mem_ldx4_xdp(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1136 {
1137         u32 dst = reg_both(meta->insn.dst_reg * 2);
1138
1139         if (meta->insn.off != offsetof(struct xdp_md, data) &&
1140             meta->insn.off != offsetof(struct xdp_md, data_end))
1141                 return -EOPNOTSUPP;
1142
1143         emit_alu(nfp_prog, dst, reg_none(), ALU_OP_NONE, NFP_BPF_ABI_PKT);
1144
1145         if (meta->insn.off == offsetof(struct xdp_md, data))
1146                 return 0;
1147
1148         emit_alu(nfp_prog, dst, dst, ALU_OP_ADD, NFP_BPF_ABI_LEN);
1149
1150         return 0;
1151 }
1152
1153 static int mem_ldx4(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1154 {
1155         int ret;
1156
1157         if (nfp_prog->act == NN_ACT_XDP)
1158                 ret = mem_ldx4_xdp(nfp_prog, meta);
1159         else
1160                 ret = mem_ldx4_skb(nfp_prog, meta);
1161
1162         wrp_immed(nfp_prog, reg_both(meta->insn.dst_reg * 2 + 1), 0);
1163
1164         return ret;
1165 }
1166
1167 static int mem_stx4_skb(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1168 {
1169         if (meta->insn.off == offsetof(struct sk_buff, mark))
1170                 return wrp_set_mark(nfp_prog, meta->insn.src_reg * 2);
1171
1172         return -EOPNOTSUPP;
1173 }
1174
1175 static int mem_stx4_xdp(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1176 {
1177         return -EOPNOTSUPP;
1178 }
1179
1180 static int mem_stx4(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1181 {
1182         if (nfp_prog->act == NN_ACT_XDP)
1183                 return mem_stx4_xdp(nfp_prog, meta);
1184         return mem_stx4_skb(nfp_prog, meta);
1185 }
1186
1187 static int jump(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1188 {
1189         if (meta->insn.off < 0) /* TODO */
1190                 return -EOPNOTSUPP;
1191         emit_br(nfp_prog, BR_UNC, meta->insn.off, 0);
1192
1193         return 0;
1194 }
1195
1196 static int jeq_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1197 {
1198         const struct bpf_insn *insn = &meta->insn;
1199         u64 imm = insn->imm; /* sign extend */
1200         u32 or1 = reg_a(insn->dst_reg * 2), or2 = reg_b(insn->dst_reg * 2 + 1);
1201         u32 tmp_reg;
1202
1203         if (insn->off < 0) /* TODO */
1204                 return -EOPNOTSUPP;
1205
1206         if (imm & ~0U) {
1207                 tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
1208                 emit_alu(nfp_prog, imm_a(nfp_prog),
1209                          reg_a(insn->dst_reg * 2), ALU_OP_XOR, tmp_reg);
1210                 or1 = imm_a(nfp_prog);
1211         }
1212
1213         if (imm >> 32) {
1214                 tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
1215                 emit_alu(nfp_prog, imm_b(nfp_prog),
1216                          reg_a(insn->dst_reg * 2 + 1), ALU_OP_XOR, tmp_reg);
1217                 or2 = imm_b(nfp_prog);
1218         }
1219
1220         emit_alu(nfp_prog, reg_none(), or1, ALU_OP_OR, or2);
1221         emit_br(nfp_prog, BR_BEQ, insn->off, 0);
1222
1223         return 0;
1224 }
1225
1226 static int jgt_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1227 {
1228         return wrp_cmp_imm(nfp_prog, meta, BR_BLO, false);
1229 }
1230
1231 static int jge_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1232 {
1233         return wrp_cmp_imm(nfp_prog, meta, BR_BHS, true);
1234 }
1235
1236 static int jlt_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1237 {
1238         return wrp_cmp_imm(nfp_prog, meta, BR_BHS, false);
1239 }
1240
1241 static int jle_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1242 {
1243         return wrp_cmp_imm(nfp_prog, meta, BR_BLO, true);
1244 }
1245
1246 static int jset_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1247 {
1248         const struct bpf_insn *insn = &meta->insn;
1249         u64 imm = insn->imm; /* sign extend */
1250         u32 tmp_reg;
1251
1252         if (insn->off < 0) /* TODO */
1253                 return -EOPNOTSUPP;
1254
1255         if (!imm) {
1256                 meta->skip = true;
1257                 return 0;
1258         }
1259
1260         if (imm & ~0U) {
1261                 tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
1262                 emit_alu(nfp_prog, reg_none(),
1263                          reg_a(insn->dst_reg * 2), ALU_OP_AND, tmp_reg);
1264                 emit_br(nfp_prog, BR_BNE, insn->off, 0);
1265         }
1266
1267         if (imm >> 32) {
1268                 tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
1269                 emit_alu(nfp_prog, reg_none(),
1270                          reg_a(insn->dst_reg * 2 + 1), ALU_OP_AND, tmp_reg);
1271                 emit_br(nfp_prog, BR_BNE, insn->off, 0);
1272         }
1273
1274         return 0;
1275 }
1276
1277 static int jne_imm(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1278 {
1279         const struct bpf_insn *insn = &meta->insn;
1280         u64 imm = insn->imm; /* sign extend */
1281         u32 tmp_reg;
1282
1283         if (insn->off < 0) /* TODO */
1284                 return -EOPNOTSUPP;
1285
1286         if (!imm) {
1287                 emit_alu(nfp_prog, reg_none(), reg_a(insn->dst_reg * 2),
1288                          ALU_OP_OR, reg_b(insn->dst_reg * 2 + 1));
1289                 emit_br(nfp_prog, BR_BNE, insn->off, 0);
1290         }
1291
1292         tmp_reg = ur_load_imm_any(nfp_prog, imm & ~0U, imm_b(nfp_prog));
1293         emit_alu(nfp_prog, reg_none(),
1294                  reg_a(insn->dst_reg * 2), ALU_OP_XOR, tmp_reg);
1295         emit_br(nfp_prog, BR_BNE, insn->off, 0);
1296
1297         tmp_reg = ur_load_imm_any(nfp_prog, imm >> 32, imm_b(nfp_prog));
1298         emit_alu(nfp_prog, reg_none(),
1299                  reg_a(insn->dst_reg * 2 + 1), ALU_OP_XOR, tmp_reg);
1300         emit_br(nfp_prog, BR_BNE, insn->off, 0);
1301
1302         return 0;
1303 }
1304
1305 static int jeq_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1306 {
1307         const struct bpf_insn *insn = &meta->insn;
1308
1309         if (insn->off < 0) /* TODO */
1310                 return -EOPNOTSUPP;
1311
1312         emit_alu(nfp_prog, imm_a(nfp_prog), reg_a(insn->dst_reg * 2),
1313                  ALU_OP_XOR, reg_b(insn->src_reg * 2));
1314         emit_alu(nfp_prog, imm_b(nfp_prog), reg_a(insn->dst_reg * 2 + 1),
1315                  ALU_OP_XOR, reg_b(insn->src_reg * 2 + 1));
1316         emit_alu(nfp_prog, reg_none(),
1317                  imm_a(nfp_prog), ALU_OP_OR, imm_b(nfp_prog));
1318         emit_br(nfp_prog, BR_BEQ, insn->off, 0);
1319
1320         return 0;
1321 }
1322
1323 static int jgt_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1324 {
1325         return wrp_cmp_reg(nfp_prog, meta, BR_BLO, false);
1326 }
1327
1328 static int jge_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1329 {
1330         return wrp_cmp_reg(nfp_prog, meta, BR_BHS, true);
1331 }
1332
1333 static int jlt_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1334 {
1335         return wrp_cmp_reg(nfp_prog, meta, BR_BHS, false);
1336 }
1337
1338 static int jle_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1339 {
1340         return wrp_cmp_reg(nfp_prog, meta, BR_BLO, true);
1341 }
1342
1343 static int jset_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1344 {
1345         return wrp_test_reg(nfp_prog, meta, ALU_OP_AND, BR_BNE);
1346 }
1347
1348 static int jne_reg(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1349 {
1350         return wrp_test_reg(nfp_prog, meta, ALU_OP_XOR, BR_BNE);
1351 }
1352
1353 static int goto_out(struct nfp_prog *nfp_prog, struct nfp_insn_meta *meta)
1354 {
1355         wrp_br_special(nfp_prog, BR_UNC, OP_BR_GO_OUT);
1356
1357         return 0;
1358 }
1359
1360 static const instr_cb_t instr_cb[256] = {
1361         [BPF_ALU64 | BPF_MOV | BPF_X] = mov_reg64,
1362         [BPF_ALU64 | BPF_MOV | BPF_K] = mov_imm64,
1363         [BPF_ALU64 | BPF_XOR | BPF_X] = xor_reg64,
1364         [BPF_ALU64 | BPF_XOR | BPF_K] = xor_imm64,
1365         [BPF_ALU64 | BPF_AND | BPF_X] = and_reg64,
1366         [BPF_ALU64 | BPF_AND | BPF_K] = and_imm64,
1367         [BPF_ALU64 | BPF_OR | BPF_X] =  or_reg64,
1368         [BPF_ALU64 | BPF_OR | BPF_K] =  or_imm64,
1369         [BPF_ALU64 | BPF_ADD | BPF_X] = add_reg64,
1370         [BPF_ALU64 | BPF_ADD | BPF_K] = add_imm64,
1371         [BPF_ALU64 | BPF_SUB | BPF_X] = sub_reg64,
1372         [BPF_ALU64 | BPF_SUB | BPF_K] = sub_imm64,
1373         [BPF_ALU64 | BPF_LSH | BPF_K] = shl_imm64,
1374         [BPF_ALU64 | BPF_RSH | BPF_K] = shr_imm64,
1375         [BPF_ALU | BPF_MOV | BPF_X] =   mov_reg,
1376         [BPF_ALU | BPF_MOV | BPF_K] =   mov_imm,
1377         [BPF_ALU | BPF_XOR | BPF_X] =   xor_reg,
1378         [BPF_ALU | BPF_XOR | BPF_K] =   xor_imm,
1379         [BPF_ALU | BPF_AND | BPF_X] =   and_reg,
1380         [BPF_ALU | BPF_AND | BPF_K] =   and_imm,
1381         [BPF_ALU | BPF_OR | BPF_X] =    or_reg,
1382         [BPF_ALU | BPF_OR | BPF_K] =    or_imm,
1383         [BPF_ALU | BPF_ADD | BPF_X] =   add_reg,
1384         [BPF_ALU | BPF_ADD | BPF_K] =   add_imm,
1385         [BPF_ALU | BPF_SUB | BPF_X] =   sub_reg,
1386         [BPF_ALU | BPF_SUB | BPF_K] =   sub_imm,
1387         [BPF_ALU | BPF_LSH | BPF_K] =   shl_imm,
1388         [BPF_LD | BPF_IMM | BPF_DW] =   imm_ld8,
1389         [BPF_LD | BPF_ABS | BPF_B] =    data_ld1,
1390         [BPF_LD | BPF_ABS | BPF_H] =    data_ld2,
1391         [BPF_LD | BPF_ABS | BPF_W] =    data_ld4,
1392         [BPF_LD | BPF_IND | BPF_B] =    data_ind_ld1,
1393         [BPF_LD | BPF_IND | BPF_H] =    data_ind_ld2,
1394         [BPF_LD | BPF_IND | BPF_W] =    data_ind_ld4,
1395         [BPF_LDX | BPF_MEM | BPF_W] =   mem_ldx4,
1396         [BPF_STX | BPF_MEM | BPF_W] =   mem_stx4,
1397         [BPF_JMP | BPF_JA | BPF_K] =    jump,
1398         [BPF_JMP | BPF_JEQ | BPF_K] =   jeq_imm,
1399         [BPF_JMP | BPF_JGT | BPF_K] =   jgt_imm,
1400         [BPF_JMP | BPF_JGE | BPF_K] =   jge_imm,
1401         [BPF_JMP | BPF_JLT | BPF_K] =   jlt_imm,
1402         [BPF_JMP | BPF_JLE | BPF_K] =   jle_imm,
1403         [BPF_JMP | BPF_JSET | BPF_K] =  jset_imm,
1404         [BPF_JMP | BPF_JNE | BPF_K] =   jne_imm,
1405         [BPF_JMP | BPF_JEQ | BPF_X] =   jeq_reg,
1406         [BPF_JMP | BPF_JGT | BPF_X] =   jgt_reg,
1407         [BPF_JMP | BPF_JGE | BPF_X] =   jge_reg,
1408         [BPF_JMP | BPF_JLT | BPF_X] =   jlt_reg,
1409         [BPF_JMP | BPF_JLE | BPF_X] =   jle_reg,
1410         [BPF_JMP | BPF_JSET | BPF_X] =  jset_reg,
1411         [BPF_JMP | BPF_JNE | BPF_X] =   jne_reg,
1412         [BPF_JMP | BPF_EXIT] =          goto_out,
1413 };
1414
1415 /* --- Misc code --- */
1416 static void br_set_offset(u64 *instr, u16 offset)
1417 {
1418         u16 addr_lo, addr_hi;
1419
1420         addr_lo = offset & (OP_BR_ADDR_LO >> __bf_shf(OP_BR_ADDR_LO));
1421         addr_hi = offset != addr_lo;
1422         *instr &= ~(OP_BR_ADDR_HI | OP_BR_ADDR_LO);
1423         *instr |= FIELD_PREP(OP_BR_ADDR_HI, addr_hi);
1424         *instr |= FIELD_PREP(OP_BR_ADDR_LO, addr_lo);
1425 }
1426
1427 /* --- Assembler logic --- */
1428 static int nfp_fixup_branches(struct nfp_prog *nfp_prog)
1429 {
1430         struct nfp_insn_meta *meta, *next;
1431         u32 off, br_idx;
1432         u32 idx;
1433
1434         nfp_for_each_insn_walk2(nfp_prog, meta, next) {
1435                 if (meta->skip)
1436                         continue;
1437                 if (BPF_CLASS(meta->insn.code) != BPF_JMP)
1438                         continue;
1439
1440                 br_idx = nfp_prog_offset_to_index(nfp_prog, next->off) - 1;
1441                 if (!nfp_is_br(nfp_prog->prog[br_idx])) {
1442                         pr_err("Fixup found block not ending in branch %d %02x %016llx!!\n",
1443                                br_idx, meta->insn.code, nfp_prog->prog[br_idx]);
1444                         return -ELOOP;
1445                 }
1446                 /* Leave special branches for later */
1447                 if (FIELD_GET(OP_BR_SPECIAL, nfp_prog->prog[br_idx]))
1448                         continue;
1449
1450                 /* Find the target offset in assembler realm */
1451                 off = meta->insn.off;
1452                 if (!off) {
1453                         pr_err("Fixup found zero offset!!\n");
1454                         return -ELOOP;
1455                 }
1456
1457                 while (off && nfp_meta_has_next(nfp_prog, next)) {
1458                         next = nfp_meta_next(next);
1459                         off--;
1460                 }
1461                 if (off) {
1462                         pr_err("Fixup found too large jump!! %d\n", off);
1463                         return -ELOOP;
1464                 }
1465
1466                 if (next->skip) {
1467                         pr_err("Branch landing on removed instruction!!\n");
1468                         return -ELOOP;
1469                 }
1470
1471                 for (idx = nfp_prog_offset_to_index(nfp_prog, meta->off);
1472                      idx <= br_idx; idx++) {
1473                         if (!nfp_is_br(nfp_prog->prog[idx]))
1474                                 continue;
1475                         br_set_offset(&nfp_prog->prog[idx], next->off);
1476                 }
1477         }
1478
1479         /* Fixup 'goto out's separately, they can be scattered around */
1480         for (br_idx = 0; br_idx < nfp_prog->prog_len; br_idx++) {
1481                 enum br_special special;
1482
1483                 if ((nfp_prog->prog[br_idx] & OP_BR_BASE_MASK) != OP_BR_BASE)
1484                         continue;
1485
1486                 special = FIELD_GET(OP_BR_SPECIAL, nfp_prog->prog[br_idx]);
1487                 switch (special) {
1488                 case OP_BR_NORMAL:
1489                         break;
1490                 case OP_BR_GO_OUT:
1491                         br_set_offset(&nfp_prog->prog[br_idx],
1492                                       nfp_prog->tgt_out);
1493                         break;
1494                 case OP_BR_GO_ABORT:
1495                         br_set_offset(&nfp_prog->prog[br_idx],
1496                                       nfp_prog->tgt_abort);
1497                         break;
1498                 }
1499
1500                 nfp_prog->prog[br_idx] &= ~OP_BR_SPECIAL;
1501         }
1502
1503         return 0;
1504 }
1505
1506 static void nfp_intro(struct nfp_prog *nfp_prog)
1507 {
1508         emit_alu(nfp_prog, pkt_reg(nfp_prog),
1509                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_PKT);
1510 }
1511
1512 static void nfp_outro_tc_legacy(struct nfp_prog *nfp_prog)
1513 {
1514         const u8 act2code[] = {
1515                 [NN_ACT_TC_DROP]  = 0x22,
1516                 [NN_ACT_TC_REDIR] = 0x24
1517         };
1518         /* Target for aborts */
1519         nfp_prog->tgt_abort = nfp_prog_current_offset(nfp_prog);
1520         wrp_immed(nfp_prog, reg_both(0), 0);
1521
1522         /* Target for normal exits */
1523         nfp_prog->tgt_out = nfp_prog_current_offset(nfp_prog);
1524         /* Legacy TC mode:
1525          *   0        0x11 -> pass,  count as stat0
1526          *  -1  drop  0x22 -> drop,  count as stat1
1527          *     redir  0x24 -> redir, count as stat1
1528          *  ife mark  0x21 -> pass,  count as stat1
1529          *  ife + tx  0x24 -> redir, count as stat1
1530          */
1531         emit_br_byte_neq(nfp_prog, reg_b(0), 0xff, 0, nfp_prog->tgt_done, 2);
1532         emit_alu(nfp_prog, reg_a(0),
1533                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1534         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(0x11), SHF_SC_L_SHF, 16);
1535
1536         emit_br(nfp_prog, BR_UNC, nfp_prog->tgt_done, 1);
1537         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(act2code[nfp_prog->act]),
1538                       SHF_SC_L_SHF, 16);
1539 }
1540
1541 static void nfp_outro_tc_da(struct nfp_prog *nfp_prog)
1542 {
1543         /* TC direct-action mode:
1544          *   0,1   ok        NOT SUPPORTED[1]
1545          *   2   drop  0x22 -> drop,  count as stat1
1546          *   4,5 nuke  0x02 -> drop
1547          *   7  redir  0x44 -> redir, count as stat2
1548          *   * unspec  0x11 -> pass,  count as stat0
1549          *
1550          * [1] We can't support OK and RECLASSIFY because we can't tell TC
1551          *     the exact decision made.  We are forced to support UNSPEC
1552          *     to handle aborts so that's the only one we handle for passing
1553          *     packets up the stack.
1554          */
1555         /* Target for aborts */
1556         nfp_prog->tgt_abort = nfp_prog_current_offset(nfp_prog);
1557
1558         emit_br_def(nfp_prog, nfp_prog->tgt_done, 2);
1559
1560         emit_alu(nfp_prog, reg_a(0),
1561                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1562         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(0x11), SHF_SC_L_SHF, 16);
1563
1564         /* Target for normal exits */
1565         nfp_prog->tgt_out = nfp_prog_current_offset(nfp_prog);
1566
1567         /* if R0 > 7 jump to abort */
1568         emit_alu(nfp_prog, reg_none(), reg_imm(7), ALU_OP_SUB, reg_b(0));
1569         emit_br(nfp_prog, BR_BLO, nfp_prog->tgt_abort, 0);
1570         emit_alu(nfp_prog, reg_a(0),
1571                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1572
1573         wrp_immed(nfp_prog, reg_b(2), 0x41221211);
1574         wrp_immed(nfp_prog, reg_b(3), 0x41001211);
1575
1576         emit_shf(nfp_prog, reg_a(1),
1577                  reg_none(), SHF_OP_NONE, reg_b(0), SHF_SC_L_SHF, 2);
1578
1579         emit_alu(nfp_prog, reg_none(), reg_a(1), ALU_OP_OR, reg_imm(0));
1580         emit_shf(nfp_prog, reg_a(2),
1581                  reg_imm(0xf), SHF_OP_AND, reg_b(2), SHF_SC_R_SHF, 0);
1582
1583         emit_alu(nfp_prog, reg_none(), reg_a(1), ALU_OP_OR, reg_imm(0));
1584         emit_shf(nfp_prog, reg_b(2),
1585                  reg_imm(0xf), SHF_OP_AND, reg_b(3), SHF_SC_R_SHF, 0);
1586
1587         emit_br_def(nfp_prog, nfp_prog->tgt_done, 2);
1588
1589         emit_shf(nfp_prog, reg_b(2),
1590                  reg_a(2), SHF_OP_OR, reg_b(2), SHF_SC_L_SHF, 4);
1591         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_b(2), SHF_SC_L_SHF, 16);
1592 }
1593
1594 static void nfp_outro_xdp(struct nfp_prog *nfp_prog)
1595 {
1596         /* XDP return codes:
1597          *   0 aborted  0x82 -> drop,  count as stat3
1598          *   1    drop  0x22 -> drop,  count as stat1
1599          *   2    pass  0x11 -> pass,  count as stat0
1600          *   3      tx  0x44 -> redir, count as stat2
1601          *   * unknown  0x82 -> drop,  count as stat3
1602          */
1603         /* Target for aborts */
1604         nfp_prog->tgt_abort = nfp_prog_current_offset(nfp_prog);
1605
1606         emit_br_def(nfp_prog, nfp_prog->tgt_done, 2);
1607
1608         emit_alu(nfp_prog, reg_a(0),
1609                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1610         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_imm(0x82), SHF_SC_L_SHF, 16);
1611
1612         /* Target for normal exits */
1613         nfp_prog->tgt_out = nfp_prog_current_offset(nfp_prog);
1614
1615         /* if R0 > 3 jump to abort */
1616         emit_alu(nfp_prog, reg_none(), reg_imm(3), ALU_OP_SUB, reg_b(0));
1617         emit_br(nfp_prog, BR_BLO, nfp_prog->tgt_abort, 0);
1618
1619         wrp_immed(nfp_prog, reg_b(2), 0x44112282);
1620
1621         emit_shf(nfp_prog, reg_a(1),
1622                  reg_none(), SHF_OP_NONE, reg_b(0), SHF_SC_L_SHF, 3);
1623
1624         emit_alu(nfp_prog, reg_none(), reg_a(1), ALU_OP_OR, reg_imm(0));
1625         emit_shf(nfp_prog, reg_b(2),
1626                  reg_imm(0xff), SHF_OP_AND, reg_b(2), SHF_SC_R_SHF, 0);
1627
1628         emit_br_def(nfp_prog, nfp_prog->tgt_done, 2);
1629
1630         emit_alu(nfp_prog, reg_a(0),
1631                  reg_none(), ALU_OP_NONE, NFP_BPF_ABI_FLAGS);
1632         emit_ld_field(nfp_prog, reg_a(0), 0xc, reg_b(2), SHF_SC_L_SHF, 16);
1633 }
1634
1635 static void nfp_outro(struct nfp_prog *nfp_prog)
1636 {
1637         switch (nfp_prog->act) {
1638         case NN_ACT_DIRECT:
1639                 nfp_outro_tc_da(nfp_prog);
1640                 break;
1641         case NN_ACT_TC_DROP:
1642         case NN_ACT_TC_REDIR:
1643                 nfp_outro_tc_legacy(nfp_prog);
1644                 break;
1645         case NN_ACT_XDP:
1646                 nfp_outro_xdp(nfp_prog);
1647                 break;
1648         }
1649 }
1650
1651 static int nfp_translate(struct nfp_prog *nfp_prog)
1652 {
1653         struct nfp_insn_meta *meta;
1654         int err;
1655
1656         nfp_intro(nfp_prog);
1657         if (nfp_prog->error)
1658                 return nfp_prog->error;
1659
1660         list_for_each_entry(meta, &nfp_prog->insns, l) {
1661                 instr_cb_t cb = instr_cb[meta->insn.code];
1662
1663                 meta->off = nfp_prog_current_offset(nfp_prog);
1664
1665                 if (meta->skip) {
1666                         nfp_prog->n_translated++;
1667                         continue;
1668                 }
1669
1670                 if (nfp_meta_has_prev(nfp_prog, meta) &&
1671                     nfp_meta_prev(meta)->double_cb)
1672                         cb = nfp_meta_prev(meta)->double_cb;
1673                 if (!cb)
1674                         return -ENOENT;
1675                 err = cb(nfp_prog, meta);
1676                 if (err)
1677                         return err;
1678
1679                 nfp_prog->n_translated++;
1680         }
1681
1682         nfp_outro(nfp_prog);
1683         if (nfp_prog->error)
1684                 return nfp_prog->error;
1685
1686         return nfp_fixup_branches(nfp_prog);
1687 }
1688
1689 static int
1690 nfp_prog_prepare(struct nfp_prog *nfp_prog, const struct bpf_insn *prog,
1691                  unsigned int cnt)
1692 {
1693         unsigned int i;
1694
1695         for (i = 0; i < cnt; i++) {
1696                 struct nfp_insn_meta *meta;
1697
1698                 meta = kzalloc(sizeof(*meta), GFP_KERNEL);
1699                 if (!meta)
1700                         return -ENOMEM;
1701
1702                 meta->insn = prog[i];
1703                 meta->n = i;
1704
1705                 list_add_tail(&meta->l, &nfp_prog->insns);
1706         }
1707
1708         return 0;
1709 }
1710
1711 /* --- Optimizations --- */
1712 static void nfp_bpf_opt_reg_init(struct nfp_prog *nfp_prog)
1713 {
1714         struct nfp_insn_meta *meta;
1715
1716         list_for_each_entry(meta, &nfp_prog->insns, l) {
1717                 struct bpf_insn insn = meta->insn;
1718
1719                 /* Programs converted from cBPF start with register xoring */
1720                 if (insn.code == (BPF_ALU64 | BPF_XOR | BPF_X) &&
1721                     insn.src_reg == insn.dst_reg)
1722                         continue;
1723
1724                 /* Programs start with R6 = R1 but we ignore the skb pointer */
1725                 if (insn.code == (BPF_ALU64 | BPF_MOV | BPF_X) &&
1726                     insn.src_reg == 1 && insn.dst_reg == 6)
1727                         meta->skip = true;
1728
1729                 /* Return as soon as something doesn't match */
1730                 if (!meta->skip)
1731                         return;
1732         }
1733 }
1734
1735 /* Try to rename registers so that program uses only low ones */
1736 static int nfp_bpf_opt_reg_rename(struct nfp_prog *nfp_prog)
1737 {
1738         bool reg_used[MAX_BPF_REG] = {};
1739         u8 tgt_reg[MAX_BPF_REG] = {};
1740         struct nfp_insn_meta *meta;
1741         unsigned int i, j;
1742
1743         list_for_each_entry(meta, &nfp_prog->insns, l) {
1744                 if (meta->skip)
1745                         continue;
1746
1747                 reg_used[meta->insn.src_reg] = true;
1748                 reg_used[meta->insn.dst_reg] = true;
1749         }
1750
1751         for (i = 0, j = 0; i < ARRAY_SIZE(tgt_reg); i++) {
1752                 if (!reg_used[i])
1753                         continue;
1754
1755                 tgt_reg[i] = j++;
1756         }
1757         nfp_prog->num_regs = j;
1758
1759         list_for_each_entry(meta, &nfp_prog->insns, l) {
1760                 meta->insn.src_reg = tgt_reg[meta->insn.src_reg];
1761                 meta->insn.dst_reg = tgt_reg[meta->insn.dst_reg];
1762         }
1763
1764         return 0;
1765 }
1766
1767 /* Remove masking after load since our load guarantees this is not needed */
1768 static void nfp_bpf_opt_ld_mask(struct nfp_prog *nfp_prog)
1769 {
1770         struct nfp_insn_meta *meta1, *meta2;
1771         const s32 exp_mask[] = {
1772                 [BPF_B] = 0x000000ffU,
1773                 [BPF_H] = 0x0000ffffU,
1774                 [BPF_W] = 0xffffffffU,
1775         };
1776
1777         nfp_for_each_insn_walk2(nfp_prog, meta1, meta2) {
1778                 struct bpf_insn insn, next;
1779
1780                 insn = meta1->insn;
1781                 next = meta2->insn;
1782
1783                 if (BPF_CLASS(insn.code) != BPF_LD)
1784                         continue;
1785                 if (BPF_MODE(insn.code) != BPF_ABS &&
1786                     BPF_MODE(insn.code) != BPF_IND)
1787                         continue;
1788
1789                 if (next.code != (BPF_ALU64 | BPF_AND | BPF_K))
1790                         continue;
1791
1792                 if (!exp_mask[BPF_SIZE(insn.code)])
1793                         continue;
1794                 if (exp_mask[BPF_SIZE(insn.code)] != next.imm)
1795                         continue;
1796
1797                 if (next.src_reg || next.dst_reg)
1798                         continue;
1799
1800                 meta2->skip = true;
1801         }
1802 }
1803
1804 static void nfp_bpf_opt_ld_shift(struct nfp_prog *nfp_prog)
1805 {
1806         struct nfp_insn_meta *meta1, *meta2, *meta3;
1807
1808         nfp_for_each_insn_walk3(nfp_prog, meta1, meta2, meta3) {
1809                 struct bpf_insn insn, next1, next2;
1810
1811                 insn = meta1->insn;
1812                 next1 = meta2->insn;
1813                 next2 = meta3->insn;
1814
1815                 if (BPF_CLASS(insn.code) != BPF_LD)
1816                         continue;
1817                 if (BPF_MODE(insn.code) != BPF_ABS &&
1818                     BPF_MODE(insn.code) != BPF_IND)
1819                         continue;
1820                 if (BPF_SIZE(insn.code) != BPF_W)
1821                         continue;
1822
1823                 if (!(next1.code == (BPF_LSH | BPF_K | BPF_ALU64) &&
1824                       next2.code == (BPF_RSH | BPF_K | BPF_ALU64)) &&
1825                     !(next1.code == (BPF_RSH | BPF_K | BPF_ALU64) &&
1826                       next2.code == (BPF_LSH | BPF_K | BPF_ALU64)))
1827                         continue;
1828
1829                 if (next1.src_reg || next1.dst_reg ||
1830                     next2.src_reg || next2.dst_reg)
1831                         continue;
1832
1833                 if (next1.imm != 0x20 || next2.imm != 0x20)
1834                         continue;
1835
1836                 meta2->skip = true;
1837                 meta3->skip = true;
1838         }
1839 }
1840
1841 static int nfp_bpf_optimize(struct nfp_prog *nfp_prog)
1842 {
1843         int ret;
1844
1845         nfp_bpf_opt_reg_init(nfp_prog);
1846
1847         ret = nfp_bpf_opt_reg_rename(nfp_prog);
1848         if (ret)
1849                 return ret;
1850
1851         nfp_bpf_opt_ld_mask(nfp_prog);
1852         nfp_bpf_opt_ld_shift(nfp_prog);
1853
1854         return 0;
1855 }
1856
1857 /**
1858  * nfp_bpf_jit() - translate BPF code into NFP assembly
1859  * @filter:     kernel BPF filter struct
1860  * @prog_mem:   memory to store assembler instructions
1861  * @act:        action attached to this eBPF program
1862  * @prog_start: offset of the first instruction when loaded
1863  * @prog_done:  where to jump on exit
1864  * @prog_sz:    size of @prog_mem in instructions
1865  * @res:        achieved parameters of translation results
1866  */
1867 int
1868 nfp_bpf_jit(struct bpf_prog *filter, void *prog_mem,
1869             enum nfp_bpf_action_type act,
1870             unsigned int prog_start, unsigned int prog_done,
1871             unsigned int prog_sz, struct nfp_bpf_result *res)
1872 {
1873         struct nfp_prog *nfp_prog;
1874         int ret;
1875
1876         nfp_prog = kzalloc(sizeof(*nfp_prog), GFP_KERNEL);
1877         if (!nfp_prog)
1878                 return -ENOMEM;
1879
1880         INIT_LIST_HEAD(&nfp_prog->insns);
1881         nfp_prog->act = act;
1882         nfp_prog->start_off = prog_start;
1883         nfp_prog->tgt_done = prog_done;
1884
1885         ret = nfp_prog_prepare(nfp_prog, filter->insnsi, filter->len);
1886         if (ret)
1887                 goto out;
1888
1889         ret = nfp_prog_verify(nfp_prog, filter);
1890         if (ret)
1891                 goto out;
1892
1893         ret = nfp_bpf_optimize(nfp_prog);
1894         if (ret)
1895                 goto out;
1896
1897         if (nfp_prog->num_regs <= 7)
1898                 nfp_prog->regs_per_thread = 16;
1899         else
1900                 nfp_prog->regs_per_thread = 32;
1901
1902         nfp_prog->prog = prog_mem;
1903         nfp_prog->__prog_alloc_len = prog_sz;
1904
1905         ret = nfp_translate(nfp_prog);
1906         if (ret) {
1907                 pr_err("Translation failed with error %d (translated: %u)\n",
1908                        ret, nfp_prog->n_translated);
1909                 ret = -EINVAL;
1910         }
1911
1912         res->n_instr = nfp_prog->prog_len;
1913         res->dense_mode = nfp_prog->num_regs <= 7;
1914 out:
1915         nfp_prog_free(nfp_prog);
1916
1917         return ret;
1918 }