Commit 2a15bb1a authored by Jakub Kicinski's avatar Jakub Kicinski Committed by David S. Miller
Browse files

nfp: bpf: move software reg helpers and cmd table out of translator 



Move the software reg helpers and some static data to nfp_asm.c.
They are related to the previous patch, but move is done in a separate
commit for ease of review.

Signed-off-by: default avatarJakub Kicinski <jakub.kicinski@netronome.com>
Reviewed-by: default avatarSimon Horman <simon.horman@netronome.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent b3f868df

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ nfp-objs := \ 
	    nfpcore/nfp_resource.o \

	    nfpcore/nfp_rtsym.o \

	    nfpcore/nfp_target.o \

	    nfp_asm.o \

	    nfp_app.o \

	    nfp_app_nic.o \

	    nfp_devlink.o \

drivers/net/ethernet/netronome/nfp/bpf/jit.c

+0 −147
Original line number Diff line number Diff line
@@ -110,154 +110,7 @@ nfp_prog_offset_to_index(struct nfp_prog *nfp_prog, unsigned int offset) 
	return offset - nfp_prog->start_off;

}



/* --- SW reg --- */

struct nfp_insn_ur_regs {

	enum alu_dst_ab dst_ab;

	u16 dst;

	u16 areg, breg;

	bool swap;

	bool wr_both;

};



struct nfp_insn_re_regs {

	enum alu_dst_ab dst_ab;

	u8 dst;

	u8 areg, breg;

	bool swap;

	bool wr_both;

	bool i8;

};



static u16 nfp_swreg_to_unreg(swreg reg, bool is_dst)

{

	u16 val = swreg_value(reg);



	switch (swreg_type(reg)) {

	case NN_REG_GPR_A:

	case NN_REG_GPR_B:

	case NN_REG_GPR_BOTH:

		return val;

	case NN_REG_NNR:

		return UR_REG_NN | val;

	case NN_REG_XFER:

		return UR_REG_XFR | val;

	case NN_REG_IMM:

		if (val & ~0xff) {

			pr_err("immediate too large\n");

			return 0;

		}

		return UR_REG_IMM_encode(val);

	case NN_REG_NONE:

		return is_dst ? UR_REG_NO_DST : REG_NONE;

	}



	pr_err("unrecognized reg encoding %08x\n", reg);

	return 0;

}



static int

swreg_to_unrestricted(swreg dst, swreg lreg, swreg rreg,

		      struct nfp_insn_ur_regs *reg)

{

	memset(reg, 0, sizeof(*reg));



	/* Decode destination */

	if (swreg_type(dst) == NN_REG_IMM)

		return -EFAULT;



	if (swreg_type(dst) == NN_REG_GPR_B)

		reg->dst_ab = ALU_DST_B;

	if (swreg_type(dst) == NN_REG_GPR_BOTH)

		reg->wr_both = true;

	reg->dst = nfp_swreg_to_unreg(dst, true);



	/* Decode source operands */

	if (swreg_type(lreg) == swreg_type(rreg))

		return -EFAULT;



	if (swreg_type(lreg) == NN_REG_GPR_B ||

	    swreg_type(rreg) == NN_REG_GPR_A) {

		reg->areg = nfp_swreg_to_unreg(rreg, false);

		reg->breg = nfp_swreg_to_unreg(lreg, false);

		reg->swap = true;

	} else {

		reg->areg = nfp_swreg_to_unreg(lreg, false);

		reg->breg = nfp_swreg_to_unreg(rreg, false);

	}



	return 0;

}



static u16 nfp_swreg_to_rereg(swreg reg, bool is_dst, bool has_imm8, bool *i8)

{

	u16 val = swreg_value(reg);



	switch (swreg_type(reg)) {

	case NN_REG_GPR_A:

	case NN_REG_GPR_B:

	case NN_REG_GPR_BOTH:

		return val;

	case NN_REG_XFER:

		return RE_REG_XFR | val;

	case NN_REG_IMM:

		if (val & ~(0x7f | has_imm8 << 7)) {

			pr_err("immediate too large\n");

			return 0;

		}

		*i8 = val & 0x80;

		return RE_REG_IMM_encode(val & 0x7f);

	case NN_REG_NONE:

		return is_dst ? RE_REG_NO_DST : REG_NONE;

	case NN_REG_NNR:

		pr_err("NNRs used with restricted encoding\n");

		return 0;

	}



	pr_err("unrecognized reg encoding\n");

	return 0;

}



static int

swreg_to_restricted(swreg dst, swreg lreg, swreg rreg,

		    struct nfp_insn_re_regs *reg, bool has_imm8)

{

	memset(reg, 0, sizeof(*reg));



	/* Decode destination */

	if (swreg_type(dst) == NN_REG_IMM)

		return -EFAULT;



	if (swreg_type(dst) == NN_REG_GPR_B)

		reg->dst_ab = ALU_DST_B;

	if (swreg_type(dst) == NN_REG_GPR_BOTH)

		reg->wr_both = true;

	reg->dst = nfp_swreg_to_rereg(dst, true, false, NULL);



	/* Decode source operands */

	if (swreg_type(lreg) == swreg_type(rreg))

		return -EFAULT;



	if (swreg_type(lreg) == NN_REG_GPR_B ||

	    swreg_type(rreg) == NN_REG_GPR_A) {

		reg->areg = nfp_swreg_to_rereg(rreg, false, has_imm8, &reg->i8);

		reg->breg = nfp_swreg_to_rereg(lreg, false, has_imm8, &reg->i8);

		reg->swap = true;

	} else {

		reg->areg = nfp_swreg_to_rereg(lreg, false, has_imm8, &reg->i8);

		reg->breg = nfp_swreg_to_rereg(rreg, false, has_imm8, &reg->i8);

	}



	return 0;

}



/* --- Emitters --- */

static const struct cmd_tgt_act cmd_tgt_act[__CMD_TGT_MAP_SIZE] = {

	[CMD_TGT_WRITE8] =		{ 0x00, 0x42 },

	[CMD_TGT_READ8] =		{ 0x01, 0x43 },

	[CMD_TGT_READ_LE] =		{ 0x01, 0x40 },

	[CMD_TGT_READ_SWAP_LE] =	{ 0x03, 0x40 },

};



static void

__emit_cmd(struct nfp_prog *nfp_prog, enum cmd_tgt_map op,

	   u8 mode, u8 xfer, u8 areg, u8 breg, u8 size, bool sync)

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

0 → 100644
+167 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016-2017 Netronome Systems, Inc.

 *

 * This software is dual licensed under the GNU General License Version 2,

 * June 1991 as shown in the file COPYING in the top-level directory of this

 * source tree or the BSD 2-Clause License provided below.  You have the

 * option to license this software under the complete terms of either license.

 *

 * The BSD 2-Clause License:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      1. Redistributions of source code must retain the above

 *         copyright notice, this list of conditions and the following

 *         disclaimer.

 *

 *      2. Redistributions in binary form must reproduce the above

 *         copyright notice, this list of conditions and the following

 *         disclaimer in the documentation and/or other materials

 *         provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */



#include <linux/bitops.h>

#include <linux/errno.h>

#include <linux/kernel.h>

#include <linux/string.h>

#include <linux/types.h>



#include "nfp_asm.h"



const struct cmd_tgt_act cmd_tgt_act[__CMD_TGT_MAP_SIZE] = {

	[CMD_TGT_WRITE8] =		{ 0x00, 0x42 },

	[CMD_TGT_READ8] =		{ 0x01, 0x43 },

	[CMD_TGT_READ_LE] =		{ 0x01, 0x40 },

	[CMD_TGT_READ_SWAP_LE] =	{ 0x03, 0x40 },

};



static u16 nfp_swreg_to_unreg(swreg reg, bool is_dst)

{

	u16 val = swreg_value(reg);



	switch (swreg_type(reg)) {

	case NN_REG_GPR_A:

	case NN_REG_GPR_B:

	case NN_REG_GPR_BOTH:

		return val;

	case NN_REG_NNR:

		return UR_REG_NN | val;

	case NN_REG_XFER:

		return UR_REG_XFR | val;

	case NN_REG_IMM:

		if (val & ~0xff) {

			pr_err("immediate too large\n");

			return 0;

		}

		return UR_REG_IMM_encode(val);

	case NN_REG_NONE:

		return is_dst ? UR_REG_NO_DST : REG_NONE;

	}



	pr_err("unrecognized reg encoding %08x\n", reg);

	return 0;

}



int swreg_to_unrestricted(swreg dst, swreg lreg, swreg rreg,

			  struct nfp_insn_ur_regs *reg)

{

	memset(reg, 0, sizeof(*reg));



	/* Decode destination */

	if (swreg_type(dst) == NN_REG_IMM)

		return -EFAULT;



	if (swreg_type(dst) == NN_REG_GPR_B)

		reg->dst_ab = ALU_DST_B;

	if (swreg_type(dst) == NN_REG_GPR_BOTH)

		reg->wr_both = true;

	reg->dst = nfp_swreg_to_unreg(dst, true);



	/* Decode source operands */

	if (swreg_type(lreg) == swreg_type(rreg))

		return -EFAULT;



	if (swreg_type(lreg) == NN_REG_GPR_B ||

	    swreg_type(rreg) == NN_REG_GPR_A) {

		reg->areg = nfp_swreg_to_unreg(rreg, false);

		reg->breg = nfp_swreg_to_unreg(lreg, false);

		reg->swap = true;

	} else {

		reg->areg = nfp_swreg_to_unreg(lreg, false);

		reg->breg = nfp_swreg_to_unreg(rreg, false);

	}



	return 0;

}



static u16 nfp_swreg_to_rereg(swreg reg, bool is_dst, bool has_imm8, bool *i8)

{

	u16 val = swreg_value(reg);



	switch (swreg_type(reg)) {

	case NN_REG_GPR_A:

	case NN_REG_GPR_B:

	case NN_REG_GPR_BOTH:

		return val;

	case NN_REG_XFER:

		return RE_REG_XFR | val;

	case NN_REG_IMM:

		if (val & ~(0x7f | has_imm8 << 7)) {

			pr_err("immediate too large\n");

			return 0;

		}

		*i8 = val & 0x80;

		return RE_REG_IMM_encode(val & 0x7f);

	case NN_REG_NONE:

		return is_dst ? RE_REG_NO_DST : REG_NONE;

	case NN_REG_NNR:

		pr_err("NNRs used with restricted encoding\n");

		return 0;

	}



	pr_err("unrecognized reg encoding\n");

	return 0;

}



int swreg_to_restricted(swreg dst, swreg lreg, swreg rreg,

			struct nfp_insn_re_regs *reg, bool has_imm8)

{

	memset(reg, 0, sizeof(*reg));



	/* Decode destination */

	if (swreg_type(dst) == NN_REG_IMM)

		return -EFAULT;



	if (swreg_type(dst) == NN_REG_GPR_B)

		reg->dst_ab = ALU_DST_B;

	if (swreg_type(dst) == NN_REG_GPR_BOTH)

		reg->wr_both = true;

	reg->dst = nfp_swreg_to_rereg(dst, true, false, NULL);



	/* Decode source operands */

	if (swreg_type(lreg) == swreg_type(rreg))

		return -EFAULT;



	if (swreg_type(lreg) == NN_REG_GPR_B ||

	    swreg_type(rreg) == NN_REG_GPR_A) {

		reg->areg = nfp_swreg_to_rereg(rreg, false, has_imm8, &reg->i8);

		reg->breg = nfp_swreg_to_rereg(lreg, false, has_imm8, &reg->i8);

		reg->swap = true;

	} else {

		reg->areg = nfp_swreg_to_rereg(lreg, false, has_imm8, &reg->i8);

		reg->breg = nfp_swreg_to_rereg(rreg, false, has_imm8, &reg->i8);

	}



	return 0;

}

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

+24 −0
Original line number Diff line number Diff line
@@ -205,6 +205,8 @@ enum cmd_tgt_map { 
	__CMD_TGT_MAP_SIZE,

};



extern const struct cmd_tgt_act cmd_tgt_act[__CMD_TGT_MAP_SIZE];



enum cmd_mode {

	CMD_MODE_40b_AB	= 0,

	CMD_MODE_40b_BA	= 1,
@@ -275,4 +277,26 @@ static inline u16 swreg_value(swreg reg) 
	return FIELD_GET(NN_REG_VAL, swreg_raw(reg));

}



struct nfp_insn_ur_regs {

	enum alu_dst_ab dst_ab;

	u16 dst;

	u16 areg, breg;

	bool swap;

	bool wr_both;

};



struct nfp_insn_re_regs {

	enum alu_dst_ab dst_ab;

	u8 dst;

	u8 areg, breg;

	bool swap;

	bool wr_both;

	bool i8;

};



int swreg_to_unrestricted(swreg dst, swreg lreg, swreg rreg,

			  struct nfp_insn_ur_regs *reg);

int swreg_to_restricted(swreg dst, swreg lreg, swreg rreg,

			struct nfp_insn_re_regs *reg, bool has_imm8);



#endif