[ceph.git] / ceph / src / seastar / dpdk / drivers / crypto / dpaa2_sec / hw / rta / math_cmd.h

/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
 *
 * Copyright 2008-2016 Freescale Semiconductor Inc.
 * Copyright 2016 NXP
 *
 */

#ifndef __RTA_MATH_CMD_H__
#define __RTA_MATH_CMD_H__

extern enum rta_sec_era rta_sec_era;

static const uint32_t math_op1[][2] = {
/*1*/	{ MATH0,     MATH_SRC0_REG0 },
	{ MATH1,     MATH_SRC0_REG1 },
	{ MATH2,     MATH_SRC0_REG2 },
	{ MATH3,     MATH_SRC0_REG3 },
	{ SEQINSZ,   MATH_SRC0_SEQINLEN },
	{ SEQOUTSZ,  MATH_SRC0_SEQOUTLEN },
	{ VSEQINSZ,  MATH_SRC0_VARSEQINLEN },
	{ VSEQOUTSZ, MATH_SRC0_VARSEQOUTLEN },
	{ ZERO,      MATH_SRC0_ZERO },
/*10*/	{ NONE,      0 }, /* dummy value */
	{ DPOVRD,    MATH_SRC0_DPOVRD },
	{ ONE,       MATH_SRC0_ONE }
};

/*
 * Allowed MATH op1 sources for each SEC Era.
 * Values represent the number of entries from math_op1[] that are supported.
 */
static const unsigned int math_op1_sz[] = {10, 10, 12, 12, 12, 12, 12, 12};

static const uint32_t math_op2[][2] = {
/*1*/	{ MATH0,     MATH_SRC1_REG0 },
	{ MATH1,     MATH_SRC1_REG1 },
	{ MATH2,     MATH_SRC1_REG2 },
	{ MATH3,     MATH_SRC1_REG3 },
	{ ABD,       MATH_SRC1_INFIFO },
	{ OFIFO,     MATH_SRC1_OUTFIFO },
	{ ONE,       MATH_SRC1_ONE },
/*8*/	{ NONE,      0 }, /* dummy value */
	{ JOBSRC,    MATH_SRC1_JOBSOURCE },
	{ DPOVRD,    MATH_SRC1_DPOVRD },
	{ VSEQINSZ,  MATH_SRC1_VARSEQINLEN },
	{ VSEQOUTSZ, MATH_SRC1_VARSEQOUTLEN },
/*13*/	{ ZERO,      MATH_SRC1_ZERO }
};

/*
 * Allowed MATH op2 sources for each SEC Era.
 * Values represent the number of entries from math_op2[] that are supported.
 */
static const unsigned int math_op2_sz[] = {8, 9, 13, 13, 13, 13, 13, 13};

static const uint32_t math_result[][2] = {
/*1*/	{ MATH0,     MATH_DEST_REG0 },
	{ MATH1,     MATH_DEST_REG1 },
	{ MATH2,     MATH_DEST_REG2 },
	{ MATH3,     MATH_DEST_REG3 },
	{ SEQINSZ,   MATH_DEST_SEQINLEN },
	{ SEQOUTSZ,  MATH_DEST_SEQOUTLEN },
	{ VSEQINSZ,  MATH_DEST_VARSEQINLEN },
	{ VSEQOUTSZ, MATH_DEST_VARSEQOUTLEN },
/*9*/	{ NONE,      MATH_DEST_NONE },
	{ DPOVRD,    MATH_DEST_DPOVRD }
};

/*
 * Allowed MATH result destinations for each SEC Era.
 * Values represent the number of entries from math_result[] that are
 * supported.
 */
static const unsigned int math_result_sz[] = {9, 9, 10, 10, 10, 10, 10, 10};

static inline int
rta_math(struct program *program, uint64_t operand1,
	 uint32_t op, uint64_t operand2, uint32_t result,
	 int length, uint32_t options)
{
	uint32_t opcode = CMD_MATH;
	uint32_t val = 0;
	int ret = -EINVAL;
	unsigned int start_pc = program->current_pc;

	if (((op == MATH_FUN_BSWAP) && (rta_sec_era < RTA_SEC_ERA_4)) ||
	    ((op == MATH_FUN_ZBYT) && (rta_sec_era < RTA_SEC_ERA_2))) {
		pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
		       USER_SEC_ERA(rta_sec_era), program->current_pc,
		       program->current_instruction);
		goto err;
	}

	if (options & SWP) {
		if (rta_sec_era < RTA_SEC_ERA_7) {
			pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
			       USER_SEC_ERA(rta_sec_era), program->current_pc,
			       program->current_instruction);
			goto err;
		}

		if ((options & IFB) ||
		    (!(options & IMMED) && !(options & IMMED2)) ||
		    ((options & IMMED) && (options & IMMED2))) {
			pr_err("MATH: SWP - invalid configuration. SEC PC: %d; Instr: %d\n",
			       program->current_pc,
			       program->current_instruction);
			goto err;
		}
	}

	/*
	 * SHLD operation is different from others and we
	 * assume that we can have _NONE as first operand
	 * or _SEQINSZ as second operand
	 */
	if ((op != MATH_FUN_SHLD) && ((operand1 == NONE) ||
				      (operand2 == SEQINSZ))) {
		pr_err("MATH: Invalid operand. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		goto err;
	}

	/*
	 * We first check if it is unary operation. In that
	 * case second operand must be _NONE
	 */
	if (((op == MATH_FUN_ZBYT) || (op == MATH_FUN_BSWAP)) &&
	    (operand2 != NONE)) {
		pr_err("MATH: Invalid operand2. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		goto err;
	}

	/* Write first operand field */
	if (options & IMMED) {
		opcode |= MATH_SRC0_IMM;
	} else {
		ret = __rta_map_opcode((uint32_t)operand1, math_op1,
				       math_op1_sz[rta_sec_era], &val);
		if (ret < 0) {
			pr_err("MATH: operand1 not supported. SEC PC: %d; Instr: %d\n",
			       program->current_pc,
			       program->current_instruction);
			goto err;
		}
		opcode |= val;
	}

	/* Write second operand field */
	if (options & IMMED2) {
		opcode |= MATH_SRC1_IMM;
	} else {
		ret = __rta_map_opcode((uint32_t)operand2, math_op2,
				       math_op2_sz[rta_sec_era], &val);
		if (ret < 0) {
			pr_err("MATH: operand2 not supported. SEC PC: %d; Instr: %d\n",
			       program->current_pc,
			       program->current_instruction);
			goto err;
		}
		opcode |= val;
	}

	/* Write result field */
	ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
			       &val);
	if (ret < 0) {
		pr_err("MATH: result not supported. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		goto err;
	}
	opcode |= val;

	/*
	 * as we encode operations with their "real" values, we do not
	 * to translate but we do need to validate the value
	 */
	switch (op) {
	/*Binary operators */
	case (MATH_FUN_ADD):
	case (MATH_FUN_ADDC):
	case (MATH_FUN_SUB):
	case (MATH_FUN_SUBB):
	case (MATH_FUN_OR):
	case (MATH_FUN_AND):
	case (MATH_FUN_XOR):
	case (MATH_FUN_LSHIFT):
	case (MATH_FUN_RSHIFT):
	case (MATH_FUN_SHLD):
	/* Unary operators */
	case (MATH_FUN_ZBYT):
	case (MATH_FUN_BSWAP):
		opcode |= op;
		break;
	default:
		pr_err("MATH: operator is not supported. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		ret = -EINVAL;
		goto err;
	}

	opcode |= (options & ~(IMMED | IMMED2));

	/* Verify length */
	switch (length) {
	case (1):
		opcode |= MATH_LEN_1BYTE;
		break;
	case (2):
		opcode |= MATH_LEN_2BYTE;
		break;
	case (4):
		opcode |= MATH_LEN_4BYTE;
		break;
	case (8):
		opcode |= MATH_LEN_8BYTE;
		break;
	default:
		pr_err("MATH: length is not supported. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		ret = -EINVAL;
		goto err;
	}

	__rta_out32(program, opcode);
	program->current_instruction++;

	/* Write immediate value */
	if ((options & IMMED) && !(options & IMMED2)) {
		__rta_out64(program, (length > 4) && !(options & IFB),
			    operand1);
	} else if ((options & IMMED2) && !(options & IMMED)) {
		__rta_out64(program, (length > 4) && !(options & IFB),
			    operand2);
	} else if ((options & IMMED) && (options & IMMED2)) {
		__rta_out32(program, lower_32_bits(operand1));
		__rta_out32(program, lower_32_bits(operand2));
	}

	return (int)start_pc;

 err:
	program->first_error_pc = start_pc;
	program->current_instruction++;
	return ret;
}

static inline int
rta_mathi(struct program *program, uint64_t operand,
	  uint32_t op, uint8_t imm, uint32_t result,
	  int length, uint32_t options)
{
	uint32_t opcode = CMD_MATHI;
	uint32_t val = 0;
	int ret = -EINVAL;
	unsigned int start_pc = program->current_pc;

	if (rta_sec_era < RTA_SEC_ERA_6) {
		pr_err("MATHI: Command not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
		       USER_SEC_ERA(rta_sec_era), program->current_pc,
		       program->current_instruction);
		goto err;
	}

	if (((op == MATH_FUN_FBYT) && (options & SSEL))) {
		pr_err("MATHI: Illegal combination - FBYT and SSEL. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		goto err;
	}

	if ((options & SWP) && (rta_sec_era < RTA_SEC_ERA_7)) {
		pr_err("MATHI: SWP not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
		       USER_SEC_ERA(rta_sec_era), program->current_pc,
		       program->current_instruction);
		goto err;
	}

	/* Write first operand field */
	if (!(options & SSEL))
		ret = __rta_map_opcode((uint32_t)operand, math_op1,
				       math_op1_sz[rta_sec_era], &val);
	else
		ret = __rta_map_opcode((uint32_t)operand, math_op2,
				       math_op2_sz[rta_sec_era], &val);
	if (ret < 0) {
		pr_err("MATHI: operand not supported. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		goto err;
	}

	if (!(options & SSEL))
		opcode |= val;
	else
		opcode |= (val << (MATHI_SRC1_SHIFT - MATH_SRC1_SHIFT));

	/* Write second operand field */
	opcode |= (imm << MATHI_IMM_SHIFT);

	/* Write result field */
	ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
			       &val);
	if (ret < 0) {
		pr_err("MATHI: result not supported. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		goto err;
	}
	opcode |= (val << (MATHI_DEST_SHIFT - MATH_DEST_SHIFT));

	/*
	 * as we encode operations with their "real" values, we do not have to
	 * translate but we do need to validate the value
	 */
	switch (op) {
	case (MATH_FUN_ADD):
	case (MATH_FUN_ADDC):
	case (MATH_FUN_SUB):
	case (MATH_FUN_SUBB):
	case (MATH_FUN_OR):
	case (MATH_FUN_AND):
	case (MATH_FUN_XOR):
	case (MATH_FUN_LSHIFT):
	case (MATH_FUN_RSHIFT):
	case (MATH_FUN_FBYT):
		opcode |= op;
		break;
	default:
		pr_err("MATHI: operator not supported. SEC PC: %d; Instr: %d\n",
		       program->current_pc, program->current_instruction);
		ret = -EINVAL;
		goto err;
	}

	opcode |= options;

	/* Verify length */
	switch (length) {
	case (1):
		opcode |= MATH_LEN_1BYTE;
		break;
	case (2):
		opcode |= MATH_LEN_2BYTE;
		break;
	case (4):
		opcode |= MATH_LEN_4BYTE;
		break;
	case (8):
		opcode |= MATH_LEN_8BYTE;
		break;
	default:
		pr_err("MATHI: length %d not supported. SEC PC: %d; Instr: %d\n",
		       length, program->current_pc,
		       program->current_instruction);
		ret = -EINVAL;
		goto err;
	}

	__rta_out32(program, opcode);
	program->current_instruction++;

	return (int)start_pc;

 err:
	program->first_error_pc = start_pc;
	program->current_instruction++;
	return ret;
}

#endif /* __RTA_MATH_CMD_H__ */
Commit	Line	Data
9f95a23c	1	/* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
11fdf7f2 TL	2	*
11fdf7f2 TL	3	* Copyright 2008-2016 Freescale Semiconductor Inc.
9f95a23c	4	* Copyright 2016 NXP
11fdf7f2	5	*
11fdf7f2 TL	6	*/
	7
	8	#ifndef __RTA_MATH_CMD_H__
	9	#define __RTA_MATH_CMD_H__
	10
	11	extern enum rta_sec_era rta_sec_era;
	12
	13	static const uint32_t math_op1[][2] = {
	14	/1/ { MATH0, MATH_SRC0_REG0 },
	15	{ MATH1, MATH_SRC0_REG1 },
	16	{ MATH2, MATH_SRC0_REG2 },
	17	{ MATH3, MATH_SRC0_REG3 },
	18	{ SEQINSZ, MATH_SRC0_SEQINLEN },
	19	{ SEQOUTSZ, MATH_SRC0_SEQOUTLEN },
	20	{ VSEQINSZ, MATH_SRC0_VARSEQINLEN },
	21	{ VSEQOUTSZ, MATH_SRC0_VARSEQOUTLEN },
	22	{ ZERO, MATH_SRC0_ZERO },
	23	/10/ { NONE, 0 }, /* dummy value */
	24	{ DPOVRD, MATH_SRC0_DPOVRD },
	25	{ ONE, MATH_SRC0_ONE }
	26	};
	27
	28	/*
	29	* Allowed MATH op1 sources for each SEC Era.
	30	* Values represent the number of entries from math_op1[] that are supported.
	31	*/
	32	static const unsigned int math_op1_sz[] = {10, 10, 12, 12, 12, 12, 12, 12};
	33
	34	static const uint32_t math_op2[][2] = {
	35	/1/ { MATH0, MATH_SRC1_REG0 },
	36	{ MATH1, MATH_SRC1_REG1 },
	37	{ MATH2, MATH_SRC1_REG2 },
	38	{ MATH3, MATH_SRC1_REG3 },
	39	{ ABD, MATH_SRC1_INFIFO },
	40	{ OFIFO, MATH_SRC1_OUTFIFO },
	41	{ ONE, MATH_SRC1_ONE },
	42	/8/ { NONE, 0 }, /* dummy value */
	43	{ JOBSRC, MATH_SRC1_JOBSOURCE },
	44	{ DPOVRD, MATH_SRC1_DPOVRD },
	45	{ VSEQINSZ, MATH_SRC1_VARSEQINLEN },
	46	{ VSEQOUTSZ, MATH_SRC1_VARSEQOUTLEN },
	47	/13/ { ZERO, MATH_SRC1_ZERO }
	48	};
	49
	50	/*
	51	* Allowed MATH op2 sources for each SEC Era.
	52	* Values represent the number of entries from math_op2[] that are supported.
	53	*/
	54	static const unsigned int math_op2_sz[] = {8, 9, 13, 13, 13, 13, 13, 13};
	55
	56	static const uint32_t math_result[][2] = {
	57	/1/ { MATH0, MATH_DEST_REG0 },
	58	{ MATH1, MATH_DEST_REG1 },
	59	{ MATH2, MATH_DEST_REG2 },
	60	{ MATH3, MATH_DEST_REG3 },
	61	{ SEQINSZ, MATH_DEST_SEQINLEN },
	62	{ SEQOUTSZ, MATH_DEST_SEQOUTLEN },
	63	{ VSEQINSZ, MATH_DEST_VARSEQINLEN },
	64	{ VSEQOUTSZ, MATH_DEST_VARSEQOUTLEN },
	65	/9/ { NONE, MATH_DEST_NONE },
	66	{ DPOVRD, MATH_DEST_DPOVRD }
	67	};
	68
	69	/*
70	* Allowed MATH result destinations for each SEC Era.
71	* Values represent the number of entries from math_result[] that are
72	* supported.
73	*/
74	static const unsigned int math_result_sz[] = {9, 9, 10, 10, 10, 10, 10, 10};
75
76	static inline int
77	rta_math(struct program *program, uint64_t operand1,
78	uint32_t op, uint64_t operand2, uint32_t result,
79	int length, uint32_t options)
80	{
81	uint32_t opcode = CMD_MATH;
82	uint32_t val = 0;
83	int ret = -EINVAL;
84	unsigned int start_pc = program->current_pc;
85
86	if (((op == MATH_FUN_BSWAP) && (rta_sec_era < RTA_SEC_ERA_4)) \|\|
87	((op == MATH_FUN_ZBYT) && (rta_sec_era < RTA_SEC_ERA_2))) {
88	pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
89	USER_SEC_ERA(rta_sec_era), program->current_pc,
90	program->current_instruction);
91	goto err;
92	}
93
94	if (options & SWP) {
95	if (rta_sec_era < RTA_SEC_ERA_7) {
96	pr_err("MATH: operation not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
97	USER_SEC_ERA(rta_sec_era), program->current_pc,
98	program->current_instruction);
99	goto err;
100	}
101
102	if ((options & IFB) \|\|
103	(!(options & IMMED) && !(options & IMMED2)) \|\|
104	((options & IMMED) && (options & IMMED2))) {
105	pr_err("MATH: SWP - invalid configuration. SEC PC: %d; Instr: %d\n",
106	program->current_pc,
107	program->current_instruction);
108	goto err;
109	}
110	}
111
112	/*
113	* SHLD operation is different from others and we
114	* assume that we can have _NONE as first operand
115	* or _SEQINSZ as second operand
116	*/
117	if ((op != MATH_FUN_SHLD) && ((operand1 == NONE) \|\|
118	(operand2 == SEQINSZ))) {
119	pr_err("MATH: Invalid operand. SEC PC: %d; Instr: %d\n",
120	program->current_pc, program->current_instruction);
121	goto err;
122	}
123
124	/*
125	* We first check if it is unary operation. In that
126	* case second operand must be _NONE
127	*/
128	if (((op == MATH_FUN_ZBYT) \|\| (op == MATH_FUN_BSWAP)) &&
129	(operand2 != NONE)) {
130	pr_err("MATH: Invalid operand2. SEC PC: %d; Instr: %d\n",
131	program->current_pc, program->current_instruction);
132	goto err;
133	}
134
135	/* Write first operand field */
136	if (options & IMMED) {
137	opcode \|= MATH_SRC0_IMM;
138	} else {
139	ret = __rta_map_opcode((uint32_t)operand1, math_op1,
140	math_op1_sz[rta_sec_era], &val);
141	if (ret < 0) {
142	pr_err("MATH: operand1 not supported. SEC PC: %d; Instr: %d\n",
143	program->current_pc,
144	program->current_instruction);
145	goto err;
146	}
147	opcode \|= val;
148	}
149
150	/* Write second operand field */
151	if (options & IMMED2) {
152	opcode \|= MATH_SRC1_IMM;
153	} else {
154	ret = __rta_map_opcode((uint32_t)operand2, math_op2,
155	math_op2_sz[rta_sec_era], &val);
156	if (ret < 0) {
157	pr_err("MATH: operand2 not supported. SEC PC: %d; Instr: %d\n",
158	program->current_pc,
159	program->current_instruction);
160	goto err;
161	}
162	opcode \|= val;
163	}
164
165	/* Write result field */
166	ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
167	&val);
168	if (ret < 0) {
169	pr_err("MATH: result not supported. SEC PC: %d; Instr: %d\n",
170	program->current_pc, program->current_instruction);
171	goto err;
172	}
173	opcode \|= val;
174
175	/*
176	* as we encode operations with their "real" values, we do not
177	* to translate but we do need to validate the value
178	*/
179	switch (op) {
180	/Binary operators /
181	case (MATH_FUN_ADD):
182	case (MATH_FUN_ADDC):
183	case (MATH_FUN_SUB):
184	case (MATH_FUN_SUBB):
185	case (MATH_FUN_OR):
186	case (MATH_FUN_AND):
187	case (MATH_FUN_XOR):
188	case (MATH_FUN_LSHIFT):
189	case (MATH_FUN_RSHIFT):
190	case (MATH_FUN_SHLD):
191	/* Unary operators */
192	case (MATH_FUN_ZBYT):
193	case (MATH_FUN_BSWAP):
194	opcode \|= op;
195	break;
196	default:
197	pr_err("MATH: operator is not supported. SEC PC: %d; Instr: %d\n",
198	program->current_pc, program->current_instruction);
199	ret = -EINVAL;
200	goto err;
201	}
202
203	opcode \|= (options & ~(IMMED \| IMMED2));
204
205	/* Verify length */
206	switch (length) {
207	case (1):
208	opcode \|= MATH_LEN_1BYTE;
209	break;
210	case (2):
211	opcode \|= MATH_LEN_2BYTE;
212	break;
213	case (4):
214	opcode \|= MATH_LEN_4BYTE;
215	break;
216	case (8):
217	opcode \|= MATH_LEN_8BYTE;
218	break;
219	default:
220	pr_err("MATH: length is not supported. SEC PC: %d; Instr: %d\n",
221	program->current_pc, program->current_instruction);
222	ret = -EINVAL;
223	goto err;
224	}
225
226	__rta_out32(program, opcode);
227	program->current_instruction++;
228
229	/* Write immediate value */
230	if ((options & IMMED) && !(options & IMMED2)) {
231	__rta_out64(program, (length > 4) && !(options & IFB),
232	operand1);
233	} else if ((options & IMMED2) && !(options & IMMED)) {
234	__rta_out64(program, (length > 4) && !(options & IFB),
235	operand2);
236	} else if ((options & IMMED) && (options & IMMED2)) {
237	__rta_out32(program, lower_32_bits(operand1));
238	__rta_out32(program, lower_32_bits(operand2));
239	}
240
241	return (int)start_pc;
242
243	err:
244	program->first_error_pc = start_pc;
245	program->current_instruction++;
246	return ret;
247	}
248
249	static inline int
250	rta_mathi(struct program *program, uint64_t operand,
251	uint32_t op, uint8_t imm, uint32_t result,
252	int length, uint32_t options)
253	{
254	uint32_t opcode = CMD_MATHI;
255	uint32_t val = 0;
256	int ret = -EINVAL;
257	unsigned int start_pc = program->current_pc;
258
259	if (rta_sec_era < RTA_SEC_ERA_6) {
260	pr_err("MATHI: Command not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
261	USER_SEC_ERA(rta_sec_era), program->current_pc,
262	program->current_instruction);
263	goto err;
264	}
265
266	if (((op == MATH_FUN_FBYT) && (options & SSEL))) {
267	pr_err("MATHI: Illegal combination - FBYT and SSEL. SEC PC: %d; Instr: %d\n",
268	program->current_pc, program->current_instruction);
269	goto err;
270	}
271
272	if ((options & SWP) && (rta_sec_era < RTA_SEC_ERA_7)) {
273	pr_err("MATHI: SWP not supported by SEC Era %d. SEC PC: %d; Instr: %d\n",
274	USER_SEC_ERA(rta_sec_era), program->current_pc,
275	program->current_instruction);
276	goto err;
277	}
278
279	/* Write first operand field */
280	if (!(options & SSEL))
281	ret = __rta_map_opcode((uint32_t)operand, math_op1,
282	math_op1_sz[rta_sec_era], &val);
283	else
284	ret = __rta_map_opcode((uint32_t)operand, math_op2,
285	math_op2_sz[rta_sec_era], &val);
286	if (ret < 0) {
287	pr_err("MATHI: operand not supported. SEC PC: %d; Instr: %d\n",
288	program->current_pc, program->current_instruction);
289	goto err;
290	}
291
292	if (!(options & SSEL))
293	opcode \|= val;
294	else
295	opcode \|= (val << (MATHI_SRC1_SHIFT - MATH_SRC1_SHIFT));
296
297	/* Write second operand field */
298	opcode \|= (imm << MATHI_IMM_SHIFT);
299
300	/* Write result field */
301	ret = __rta_map_opcode(result, math_result, math_result_sz[rta_sec_era],
302	&val);
303	if (ret < 0) {
304	pr_err("MATHI: result not supported. SEC PC: %d; Instr: %d\n",
305	program->current_pc, program->current_instruction);
306	goto err;
307	}
308	opcode \|= (val << (MATHI_DEST_SHIFT - MATH_DEST_SHIFT));
309
310	/*
311	* as we encode operations with their "real" values, we do not have to
312	* translate but we do need to validate the value
313	*/
314	switch (op) {
315	case (MATH_FUN_ADD):
316	case (MATH_FUN_ADDC):
317	case (MATH_FUN_SUB):
318	case (MATH_FUN_SUBB):
319	case (MATH_FUN_OR):
320	case (MATH_FUN_AND):
321	case (MATH_FUN_XOR):
322	case (MATH_FUN_LSHIFT):
323	case (MATH_FUN_RSHIFT):
324	case (MATH_FUN_FBYT):
325	opcode \|= op;
326	break;
327	default:
328	pr_err("MATHI: operator not supported. SEC PC: %d; Instr: %d\n",
329	program->current_pc, program->current_instruction);
330	ret = -EINVAL;
331	goto err;
332	}
333
334	opcode \|= options;
335
336	/* Verify length */
337	switch (length) {
338	case (1):
339	opcode \|= MATH_LEN_1BYTE;
340	break;
341	case (2):
342	opcode \|= MATH_LEN_2BYTE;
343	break;
344	case (4):
345	opcode \|= MATH_LEN_4BYTE;
346	break;
347	case (8):
348	opcode \|= MATH_LEN_8BYTE;
349	break;
350	default:
351	pr_err("MATHI: length %d not supported. SEC PC: %d; Instr: %d\n",
352	length, program->current_pc,
353	program->current_instruction);
354	ret = -EINVAL;
355	goto err;
356	}
357
358	__rta_out32(program, opcode);
359	program->current_instruction++;
360
361	return (int)start_pc;
362
363	err:
364	program->first_error_pc = start_pc;
365	program->current_instruction++;
366	return ret;
367	}
368
369	#endif /* __RTA_MATH_CMD_H__ */