drivers/net/ethernet/netronome/nfp/nfp_asm.h

   1 /*
   2  * Copyright (C) 2016-2017 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 #ifndef __NFP_ASM_H__
  35 #define __NFP_ASM_H__ 1
  36
  37 #include <linux/bitfield.h>
  38 #include <linux/bug.h>
  39 #include <linux/types.h>
  40
  41 #define REG_NONE        0
  42 #define REG_WIDTH       4
  43
  44 #define RE_REG_NO_DST   0x020
  45 #define RE_REG_IMM      0x020
  46 #define RE_REG_IMM_encode(x)                                    \
  47         (RE_REG_IMM | ((x) & 0x1f) | (((x) & 0x60) << 1))
  48 #define RE_REG_IMM_MAX   0x07fULL
  49 #define RE_REG_LM       0x050
  50 #define RE_REG_LM_IDX   0x008
  51 #define RE_REG_LM_IDX_MAX       0x7
  52 #define RE_REG_XFR      0x080
  53
  54 #define UR_REG_XFR      0x180
  55 #define UR_REG_LM       0x200
  56 #define UR_REG_LM_IDX   0x020
  57 #define UR_REG_LM_POST_MOD      0x010
  58 #define UR_REG_LM_POST_MOD_DEC  0x001
  59 #define UR_REG_LM_IDX_MAX       0xf
  60 #define UR_REG_NN       0x280
  61 #define UR_REG_NO_DST   0x300
  62 #define UR_REG_IMM      UR_REG_NO_DST
  63 #define UR_REG_IMM_encode(x) (UR_REG_IMM | (x))
  64 #define UR_REG_IMM_MAX   0x0ffULL
  65
  66 #define OP_BR_BASE              0x0d800000020ULL
  67 #define OP_BR_BASE_MASK         0x0f8000c3ce0ULL
  68 #define OP_BR_MASK              0x0000000001fULL
  69 #define OP_BR_EV_PIP            0x00000000300ULL
  70 #define OP_BR_CSS               0x0000003c000ULL
  71 #define OP_BR_DEFBR             0x00000300000ULL
  72 #define OP_BR_ADDR_LO           0x007ffc00000ULL
  73 #define OP_BR_ADDR_HI           0x10000000000ULL
  74
  75 #define OP_BR_BIT_BASE          0x0d000000000ULL
  76 #define OP_BR_BIT_BASE_MASK     0x0f800080300ULL
  77 #define OP_BR_BIT_A_SRC         0x000000000ffULL
  78 #define OP_BR_BIT_B_SRC         0x0000003fc00ULL
  79 #define OP_BR_BIT_BV            0x00000040000ULL
  80 #define OP_BR_BIT_SRC_LMEXTN    0x40000000000ULL
  81 #define OP_BR_BIT_DEFBR         OP_BR_DEFBR
  82 #define OP_BR_BIT_ADDR_LO       OP_BR_ADDR_LO
  83 #define OP_BR_BIT_ADDR_HI       OP_BR_ADDR_HI
  84
  85 static inline bool nfp_is_br(u64 insn)
  86 {
  87         return (insn & OP_BR_BASE_MASK) == OP_BR_BASE ||
  88                (insn & OP_BR_BIT_BASE_MASK) == OP_BR_BIT_BASE;
  89 }
  90
  91 enum br_mask {
  92         BR_BEQ = 0x00,
  93         BR_BNE = 0x01,
  94         BR_BMI = 0x02,
  95         BR_BHS = 0x04,
  96         BR_BCC = 0x05,
  97         BR_BLO = 0x05,
  98         BR_BGE = 0x08,
  99         BR_BLT = 0x09,
 100         BR_UNC = 0x18,
 101 };
 102
 103 enum br_ev_pip {
 104         BR_EV_PIP_UNCOND = 0,
 105         BR_EV_PIP_COND = 1,
 106 };
 107
 108 enum br_ctx_signal_state {
 109         BR_CSS_NONE = 2,
 110 };
 111
 112 u16 br_get_offset(u64 instr);
 113 void br_set_offset(u64 *instr, u16 offset);
 114 void br_add_offset(u64 *instr, u16 offset);
 115
 116 #define OP_BBYTE_BASE           0x0c800000000ULL
 117 #define OP_BB_A_SRC             0x000000000ffULL
 118 #define OP_BB_BYTE              0x00000000300ULL
 119 #define OP_BB_B_SRC             0x0000003fc00ULL
 120 #define OP_BB_I8                0x00000040000ULL
 121 #define OP_BB_EQ                0x00000080000ULL
 122 #define OP_BB_DEFBR             0x00000300000ULL
 123 #define OP_BB_ADDR_LO           0x007ffc00000ULL
 124 #define OP_BB_ADDR_HI           0x10000000000ULL
 125 #define OP_BB_SRC_LMEXTN        0x40000000000ULL
 126
 127 #define OP_BALU_BASE            0x0e800000000ULL
 128 #define OP_BA_A_SRC             0x000000003ffULL
 129 #define OP_BA_B_SRC             0x000000ffc00ULL
 130 #define OP_BA_DEFBR             0x00000300000ULL
 131 #define OP_BA_ADDR_HI           0x0007fc00000ULL
 132
 133 #define OP_IMMED_A_SRC          0x000000003ffULL
 134 #define OP_IMMED_B_SRC          0x000000ffc00ULL
 135 #define OP_IMMED_IMM            0x0000ff00000ULL
 136 #define OP_IMMED_WIDTH          0x00060000000ULL
 137 #define OP_IMMED_INV            0x00080000000ULL
 138 #define OP_IMMED_SHIFT          0x00600000000ULL
 139 #define OP_IMMED_BASE           0x0f000000000ULL
 140 #define OP_IMMED_WR_AB          0x20000000000ULL
 141 #define OP_IMMED_SRC_LMEXTN     0x40000000000ULL
 142 #define OP_IMMED_DST_LMEXTN     0x80000000000ULL
 143
 144 enum immed_width {
 145         IMMED_WIDTH_ALL = 0,
 146         IMMED_WIDTH_BYTE = 1,
 147         IMMED_WIDTH_WORD = 2,
 148 };
 149
 150 enum immed_shift {
 151         IMMED_SHIFT_0B = 0,
 152         IMMED_SHIFT_1B = 1,
 153         IMMED_SHIFT_2B = 2,
 154 };
 155
 156 u16 immed_get_value(u64 instr);
 157 void immed_set_value(u64 *instr, u16 immed);
 158 void immed_add_value(u64 *instr, u16 offset);
 159
 160 #define OP_SHF_BASE             0x08000000000ULL
 161 #define OP_SHF_A_SRC            0x000000000ffULL
 162 #define OP_SHF_SC               0x00000000300ULL
 163 #define OP_SHF_B_SRC            0x0000003fc00ULL
 164 #define OP_SHF_I8               0x00000040000ULL
 165 #define OP_SHF_SW               0x00000080000ULL
 166 #define OP_SHF_DST              0x0000ff00000ULL
 167 #define OP_SHF_SHIFT            0x001f0000000ULL
 168 #define OP_SHF_OP               0x00e00000000ULL
 169 #define OP_SHF_DST_AB           0x01000000000ULL
 170 #define OP_SHF_WR_AB            0x20000000000ULL
 171 #define OP_SHF_SRC_LMEXTN       0x40000000000ULL
 172 #define OP_SHF_DST_LMEXTN       0x80000000000ULL
 173
 174 enum shf_op {
 175         SHF_OP_NONE = 0,
 176         SHF_OP_AND = 2,
 177         SHF_OP_OR = 5,
 178         SHF_OP_ASHR = 6,
 179 };
 180
 181 enum shf_sc {
 182         SHF_SC_R_ROT = 0,
 183         SHF_SC_NONE = SHF_SC_R_ROT,
 184         SHF_SC_R_SHF = 1,
 185         SHF_SC_L_SHF = 2,
 186         SHF_SC_R_DSHF = 3,
 187 };
 188
 189 #define OP_ALU_A_SRC            0x000000003ffULL
 190 #define OP_ALU_B_SRC            0x000000ffc00ULL
 191 #define OP_ALU_DST              0x0003ff00000ULL
 192 #define OP_ALU_SW               0x00040000000ULL
 193 #define OP_ALU_OP               0x00f80000000ULL
 194 #define OP_ALU_DST_AB           0x01000000000ULL
 195 #define OP_ALU_BASE             0x0a000000000ULL
 196 #define OP_ALU_WR_AB            0x20000000000ULL
 197 #define OP_ALU_SRC_LMEXTN       0x40000000000ULL
 198 #define OP_ALU_DST_LMEXTN       0x80000000000ULL
 199
 200 enum alu_op {
 201         ALU_OP_NONE             = 0x00,
 202         ALU_OP_ADD              = 0x01,
 203         ALU_OP_NOT              = 0x04,
 204         ALU_OP_ADD_2B           = 0x05,
 205         ALU_OP_AND              = 0x08,
 206         ALU_OP_AND_NOT_A        = 0x0c,
 207         ALU_OP_SUB_C            = 0x0d,
 208         ALU_OP_AND_NOT_B        = 0x10,
 209         ALU_OP_ADD_C            = 0x11,
 210         ALU_OP_OR               = 0x14,
 211         ALU_OP_SUB              = 0x15,
 212         ALU_OP_XOR              = 0x18,
 213 };
 214
 215 enum alu_dst_ab {
 216         ALU_DST_A = 0,
 217         ALU_DST_B = 1,
 218 };
 219
 220 #define OP_LDF_BASE             0x0c000000000ULL
 221 #define OP_LDF_A_SRC            0x000000000ffULL
 222 #define OP_LDF_SC               0x00000000300ULL
 223 #define OP_LDF_B_SRC            0x0000003fc00ULL
 224 #define OP_LDF_I8               0x00000040000ULL
 225 #define OP_LDF_SW               0x00000080000ULL
 226 #define OP_LDF_ZF               0x00000100000ULL
 227 #define OP_LDF_BMASK            0x0000f000000ULL
 228 #define OP_LDF_SHF              0x001f0000000ULL
 229 #define OP_LDF_WR_AB            0x20000000000ULL
 230 #define OP_LDF_SRC_LMEXTN       0x40000000000ULL
 231 #define OP_LDF_DST_LMEXTN       0x80000000000ULL
 232
 233 #define OP_CMD_A_SRC            0x000000000ffULL
 234 #define OP_CMD_CTX              0x00000000300ULL
 235 #define OP_CMD_B_SRC            0x0000003fc00ULL
 236 #define OP_CMD_TOKEN            0x000000c0000ULL
 237 #define OP_CMD_XFER             0x00001f00000ULL
 238 #define OP_CMD_CNT              0x0000e000000ULL
 239 #define OP_CMD_SIG              0x000f0000000ULL
 240 #define OP_CMD_TGT_CMD          0x07f00000000ULL
 241 #define OP_CMD_INDIR            0x20000000000ULL
 242 #define OP_CMD_MODE            0x1c0000000000ULL
 243
 244 struct cmd_tgt_act {
 245         u8 token;
 246         u8 tgt_cmd;
 247 };
 248
 249 enum cmd_tgt_map {
 250         CMD_TGT_READ8,
 251         CMD_TGT_WRITE8_SWAP,
 252         CMD_TGT_WRITE32_SWAP,
 253         CMD_TGT_READ32,
 254         CMD_TGT_READ32_LE,
 255         CMD_TGT_READ32_SWAP,
 256         CMD_TGT_READ_LE,
 257         CMD_TGT_READ_SWAP_LE,
 258         CMD_TGT_ADD,
 259         CMD_TGT_ADD_IMM,
 260         __CMD_TGT_MAP_SIZE,
 261 };
 262
 263 extern const struct cmd_tgt_act cmd_tgt_act[__CMD_TGT_MAP_SIZE];
 264
 265 enum cmd_mode {
 266         CMD_MODE_40b_AB = 0,
 267         CMD_MODE_40b_BA = 1,
 268         CMD_MODE_32b    = 4,
 269 };
 270
 271 enum cmd_ctx_swap {
 272         CMD_CTX_SWAP = 0,
 273         CMD_CTX_SWAP_DEFER1 = 1,
 274         CMD_CTX_SWAP_DEFER2 = 2,
 275         CMD_CTX_NO_SWAP = 3,
 276 };
 277
 278 #define CMD_OVE_DATA    GENMASK(5, 3)
 279 #define CMD_OVE_LEN     BIT(7)
 280 #define CMD_OV_LEN      GENMASK(12, 8)
 281
 282 #define OP_LCSR_BASE            0x0fc00000000ULL
 283 #define OP_LCSR_A_SRC           0x000000003ffULL
 284 #define OP_LCSR_B_SRC           0x000000ffc00ULL
 285 #define OP_LCSR_WRITE           0x00000200000ULL
 286 #define OP_LCSR_ADDR            0x001ffc00000ULL
 287 #define OP_LCSR_SRC_LMEXTN      0x40000000000ULL
 288 #define OP_LCSR_DST_LMEXTN      0x80000000000ULL
 289
 290 enum lcsr_wr_src {
 291         LCSR_WR_AREG,
 292         LCSR_WR_BREG,
 293         LCSR_WR_IMM,
 294 };
 295
 296 #define OP_CARB_BASE            0x0e000000000ULL
 297 #define OP_CARB_OR              0x00000010000ULL
 298
 299 #define NFP_CSR_CTX_PTR         0x20
 300 #define NFP_CSR_ACT_LM_ADDR0    0x64
 301 #define NFP_CSR_ACT_LM_ADDR1    0x6c
 302 #define NFP_CSR_ACT_LM_ADDR2    0x94
 303 #define NFP_CSR_ACT_LM_ADDR3    0x9c
 304 #define NFP_CSR_PSEUDO_RND_NUM  0x148
 305
 306 /* Software register representation, independent of operand type */
 307 #define NN_REG_TYPE     GENMASK(31, 24)
 308 #define NN_REG_LM_IDX   GENMASK(23, 22)
 309 #define NN_REG_LM_IDX_HI        BIT(23)
 310 #define NN_REG_LM_IDX_LO        BIT(22)
 311 #define NN_REG_LM_MOD   GENMASK(21, 20)
 312 #define NN_REG_VAL      GENMASK(7, 0)
 313
 314 enum nfp_bpf_reg_type {
 315         NN_REG_GPR_A =  BIT(0),
 316         NN_REG_GPR_B =  BIT(1),
 317         NN_REG_GPR_BOTH = NN_REG_GPR_A | NN_REG_GPR_B,
 318         NN_REG_NNR =    BIT(2),
 319         NN_REG_XFER =   BIT(3),
 320         NN_REG_IMM =    BIT(4),
 321         NN_REG_NONE =   BIT(5),
 322         NN_REG_LMEM =   BIT(6),
 323 };
 324
 325 enum nfp_bpf_lm_mode {
 326         NN_LM_MOD_NONE = 0,
 327         NN_LM_MOD_INC,
 328         NN_LM_MOD_DEC,
 329 };
 330
 331 #define reg_both(x)     __enc_swreg((x), NN_REG_GPR_BOTH)
 332 #define reg_a(x)        __enc_swreg((x), NN_REG_GPR_A)
 333 #define reg_b(x)        __enc_swreg((x), NN_REG_GPR_B)
 334 #define reg_nnr(x)      __enc_swreg((x), NN_REG_NNR)
 335 #define reg_xfer(x)     __enc_swreg((x), NN_REG_XFER)
 336 #define reg_imm(x)      __enc_swreg((x), NN_REG_IMM)
 337 #define reg_none()      __enc_swreg(0, NN_REG_NONE)
 338 #define reg_lm(x, off)  __enc_swreg_lm((x), NN_LM_MOD_NONE, (off))
 339 #define reg_lm_inc(x)   __enc_swreg_lm((x), NN_LM_MOD_INC, 0)
 340 #define reg_lm_dec(x)   __enc_swreg_lm((x), NN_LM_MOD_DEC, 0)
 341 #define __reg_lm(x, mod, off)   __enc_swreg_lm((x), (mod), (off))
 342
 343 typedef __u32 __bitwise swreg;
 344
 345 static inline swreg __enc_swreg(u16 id, u8 type)
 346 {
 347         return (__force swreg)(id | FIELD_PREP(NN_REG_TYPE, type));
 348 }
 349
 350 static inline swreg __enc_swreg_lm(u8 id, enum nfp_bpf_lm_mode mode, u8 off)
 351 {
 352         WARN_ON(id > 3 || (off && mode != NN_LM_MOD_NONE));
 353
 354         return (__force swreg)(FIELD_PREP(NN_REG_TYPE, NN_REG_LMEM) |
 355                                FIELD_PREP(NN_REG_LM_IDX, id) |
 356                                FIELD_PREP(NN_REG_LM_MOD, mode) |
 357                                off);
 358 }
 359
 360 static inline u32 swreg_raw(swreg reg)
 361 {
 362         return (__force u32)reg;
 363 }
 364
 365 static inline enum nfp_bpf_reg_type swreg_type(swreg reg)
 366 {
 367         return FIELD_GET(NN_REG_TYPE, swreg_raw(reg));
 368 }
 369
 370 static inline u16 swreg_value(swreg reg)
 371 {
 372         return FIELD_GET(NN_REG_VAL, swreg_raw(reg));
 373 }
 374
 375 static inline bool swreg_lm_idx(swreg reg)
 376 {
 377         return FIELD_GET(NN_REG_LM_IDX_LO, swreg_raw(reg));
 378 }
 379
 380 static inline bool swreg_lmextn(swreg reg)
 381 {
 382         return FIELD_GET(NN_REG_LM_IDX_HI, swreg_raw(reg));
 383 }
 384
 385 static inline enum nfp_bpf_lm_mode swreg_lm_mode(swreg reg)
 386 {
 387         return FIELD_GET(NN_REG_LM_MOD, swreg_raw(reg));
 388 }
 389
 390 struct nfp_insn_ur_regs {
 391         enum alu_dst_ab dst_ab;
 392         u16 dst;
 393         u16 areg, breg;
 394         bool swap;
 395         bool wr_both;
 396         bool dst_lmextn;
 397         bool src_lmextn;
 398 };
 399
 400 struct nfp_insn_re_regs {
 401         enum alu_dst_ab dst_ab;
 402         u8 dst;
 403         u8 areg, breg;
 404         bool swap;
 405         bool wr_both;
 406         bool i8;
 407         bool dst_lmextn;
 408         bool src_lmextn;
 409 };
 410
 411 int swreg_to_unrestricted(swreg dst, swreg lreg, swreg rreg,
 412                           struct nfp_insn_ur_regs *reg);
 413 int swreg_to_restricted(swreg dst, swreg lreg, swreg rreg,
 414                         struct nfp_insn_re_regs *reg, bool has_imm8);
 415
 416 #define NFP_USTORE_PREFETCH_WINDOW      8
 417
 418 int nfp_ustore_check_valid_no_ecc(u64 insn);
 419 u64 nfp_ustore_calc_ecc_insn(u64 insn);
 420
 421 #define NFP_IND_ME_REFL_WR_SIG_INIT     3
 422 #define NFP_IND_ME_CTX_PTR_BASE_MASK    GENMASK(9, 0)
 423 #define NFP_IND_NUM_CONTEXTS            8
 424
 425 static inline u32 nfp_get_ind_csr_ctx_ptr_offs(u32 read_offset)
 426 {
 427         return (read_offset & ~NFP_IND_ME_CTX_PTR_BASE_MASK) | NFP_CSR_CTX_PTR;
 428 }
 429
 430 enum mul_type {
 431         MUL_TYPE_START          = 0x00,
 432         MUL_TYPE_STEP_24x8      = 0x01,
 433         MUL_TYPE_STEP_16x16     = 0x02,
 434         MUL_TYPE_STEP_32x32     = 0x03,
 435 };
 436
 437 enum mul_step {
 438         MUL_STEP_1              = 0x00,
 439         MUL_STEP_NONE           = MUL_STEP_1,
 440         MUL_STEP_2              = 0x01,
 441         MUL_STEP_3              = 0x02,
 442         MUL_STEP_4              = 0x03,
 443         MUL_LAST                = 0x04,
 444         MUL_LAST_2              = 0x05,
 445 };
 446
 447 #define OP_MUL_BASE             0x0f800000000ULL
 448 #define OP_MUL_A_SRC            0x000000003ffULL
 449 #define OP_MUL_B_SRC            0x000000ffc00ULL
 450 #define OP_MUL_STEP             0x00000700000ULL
 451 #define OP_MUL_DST_AB           0x00000800000ULL
 452 #define OP_MUL_SW               0x00040000000ULL
 453 #define OP_MUL_TYPE             0x00180000000ULL
 454 #define OP_MUL_WR_AB            0x20000000000ULL
 455 #define OP_MUL_SRC_LMEXTN       0x40000000000ULL
 456 #define OP_MUL_DST_LMEXTN       0x80000000000ULL
 457
 458 #endif