xref: /linux/drivers/net/ethernet/microchip/vcap/vcap_api.c (revision 621cde16e49b3ecf7d59a8106a20aaebfb4a59a9)
1 // SPDX-License-Identifier: GPL-2.0+
2 /* Microchip VCAP API
3  *
4  * Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
5  */
6 
7 #include <linux/types.h>
8 
9 #include "vcap_api_private.h"
10 
11 static int keyfield_size_table[] = {
12 	[VCAP_FIELD_BIT]  = sizeof(struct vcap_u1_key),
13 	[VCAP_FIELD_U32]  = sizeof(struct vcap_u32_key),
14 	[VCAP_FIELD_U48]  = sizeof(struct vcap_u48_key),
15 	[VCAP_FIELD_U56]  = sizeof(struct vcap_u56_key),
16 	[VCAP_FIELD_U64]  = sizeof(struct vcap_u64_key),
17 	[VCAP_FIELD_U72]  = sizeof(struct vcap_u72_key),
18 	[VCAP_FIELD_U112] = sizeof(struct vcap_u112_key),
19 	[VCAP_FIELD_U128] = sizeof(struct vcap_u128_key),
20 };
21 
22 static int actionfield_size_table[] = {
23 	[VCAP_FIELD_BIT]  = sizeof(struct vcap_u1_action),
24 	[VCAP_FIELD_U32]  = sizeof(struct vcap_u32_action),
25 	[VCAP_FIELD_U48]  = sizeof(struct vcap_u48_action),
26 	[VCAP_FIELD_U56]  = sizeof(struct vcap_u56_action),
27 	[VCAP_FIELD_U64]  = sizeof(struct vcap_u64_action),
28 	[VCAP_FIELD_U72]  = sizeof(struct vcap_u72_action),
29 	[VCAP_FIELD_U112] = sizeof(struct vcap_u112_action),
30 	[VCAP_FIELD_U128] = sizeof(struct vcap_u128_action),
31 };
32 
33 /* Moving a rule in the VCAP address space */
34 struct vcap_rule_move {
35 	int addr; /* address to move */
36 	int offset; /* change in address */
37 	int count; /* blocksize of addresses to move */
38 };
39 
40 /* Stores the filter cookie and chain id that enabled the port */
41 struct vcap_enabled_port {
42 	struct list_head list; /* for insertion in enabled ports list */
43 	struct net_device *ndev;  /* the enabled port */
44 	unsigned long cookie; /* filter that enabled the port */
45 	int src_cid; /* source chain id */
46 	int dst_cid; /* destination chain id */
47 };
48 
vcap_iter_set(struct vcap_stream_iter * itr,int sw_width,const struct vcap_typegroup * tg,u32 offset)49 void vcap_iter_set(struct vcap_stream_iter *itr, int sw_width,
50 		   const struct vcap_typegroup *tg, u32 offset)
51 {
52 	memset(itr, 0, sizeof(*itr));
53 	itr->offset = offset;
54 	itr->sw_width = sw_width;
55 	itr->regs_per_sw = DIV_ROUND_UP(sw_width, 32);
56 	itr->tg = tg;
57 }
58 
vcap_iter_skip_tg(struct vcap_stream_iter * itr)59 static void vcap_iter_skip_tg(struct vcap_stream_iter *itr)
60 {
61 	/* Compensate the field offset for preceding typegroups.
62 	 * A typegroup table ends with an all-zero terminator.
63 	 */
64 	while (itr->tg->width && itr->offset >= itr->tg->offset) {
65 		itr->offset += itr->tg->width;
66 		itr->tg++; /* next typegroup */
67 	}
68 }
69 
vcap_iter_update(struct vcap_stream_iter * itr)70 void vcap_iter_update(struct vcap_stream_iter *itr)
71 {
72 	int sw_idx, sw_bitpos;
73 
74 	/* Calculate the subword index and bitposition for current bit */
75 	sw_idx = itr->offset / itr->sw_width;
76 	sw_bitpos = itr->offset % itr->sw_width;
77 	/* Calculate the register index and bitposition for current bit */
78 	itr->reg_idx = (sw_idx * itr->regs_per_sw) + (sw_bitpos / 32);
79 	itr->reg_bitpos = sw_bitpos % 32;
80 }
81 
vcap_iter_init(struct vcap_stream_iter * itr,int sw_width,const struct vcap_typegroup * tg,u32 offset)82 void vcap_iter_init(struct vcap_stream_iter *itr, int sw_width,
83 		    const struct vcap_typegroup *tg, u32 offset)
84 {
85 	vcap_iter_set(itr, sw_width, tg, offset);
86 	vcap_iter_skip_tg(itr);
87 	vcap_iter_update(itr);
88 }
89 
vcap_iter_next(struct vcap_stream_iter * itr)90 void vcap_iter_next(struct vcap_stream_iter *itr)
91 {
92 	itr->offset++;
93 	vcap_iter_skip_tg(itr);
94 	vcap_iter_update(itr);
95 }
96 
vcap_set_bit(u32 * stream,struct vcap_stream_iter * itr,bool value)97 static void vcap_set_bit(u32 *stream, struct vcap_stream_iter *itr, bool value)
98 {
99 	u32 mask = BIT(itr->reg_bitpos);
100 	u32 *p = &stream[itr->reg_idx];
101 
102 	if (value)
103 		*p |= mask;
104 	else
105 		*p &= ~mask;
106 }
107 
vcap_encode_bit(u32 * stream,struct vcap_stream_iter * itr,bool val)108 static void vcap_encode_bit(u32 *stream, struct vcap_stream_iter *itr, bool val)
109 {
110 	/* When intersected by a type group field, stream the type group bits
111 	 * before continuing with the value bit
112 	 */
113 	while (itr->tg->width &&
114 	       itr->offset >= itr->tg->offset &&
115 	       itr->offset < itr->tg->offset + itr->tg->width) {
116 		int tg_bitpos = itr->tg->offset - itr->offset;
117 
118 		vcap_set_bit(stream, itr, (itr->tg->value >> tg_bitpos) & 0x1);
119 		itr->offset++;
120 		vcap_iter_update(itr);
121 	}
122 	vcap_set_bit(stream, itr, val);
123 }
124 
vcap_encode_field(u32 * stream,struct vcap_stream_iter * itr,int width,const u8 * value)125 static void vcap_encode_field(u32 *stream, struct vcap_stream_iter *itr,
126 			      int width, const u8 *value)
127 {
128 	int idx;
129 
130 	/* Loop over the field value bits and add the value bits one by one to
131 	 * the output stream.
132 	 */
133 	for (idx = 0; idx < width; idx++) {
134 		u8 bidx = idx & GENMASK(2, 0);
135 
136 		/* Encode one field value bit */
137 		vcap_encode_bit(stream, itr, (value[idx / 8] >> bidx) & 0x1);
138 		vcap_iter_next(itr);
139 	}
140 }
141 
vcap_encode_typegroups(u32 * stream,int sw_width,const struct vcap_typegroup * tg,bool mask)142 static void vcap_encode_typegroups(u32 *stream, int sw_width,
143 				   const struct vcap_typegroup *tg,
144 				   bool mask)
145 {
146 	struct vcap_stream_iter iter;
147 	int idx;
148 
149 	/* Mask bits must be set to zeros (inverted later when writing to the
150 	 * mask cache register), so that the mask typegroup bits consist of
151 	 * match-1 or match-0, or both
152 	 */
153 	vcap_iter_set(&iter, sw_width, tg, 0);
154 	while (iter.tg->width) {
155 		/* Set position to current typegroup bit */
156 		iter.offset = iter.tg->offset;
157 		vcap_iter_update(&iter);
158 		for (idx = 0; idx < iter.tg->width; idx++) {
159 			/* Iterate over current typegroup bits. Mask typegroup
160 			 * bits are always set
161 			 */
162 			if (mask)
163 				vcap_set_bit(stream, &iter, 0x1);
164 			else
165 				vcap_set_bit(stream, &iter,
166 					     (iter.tg->value >> idx) & 0x1);
167 			iter.offset++;
168 			vcap_iter_update(&iter);
169 		}
170 		iter.tg++; /* next typegroup */
171 	}
172 }
173 
vcap_bitarray_zero(int width,u8 * value)174 static bool vcap_bitarray_zero(int width, u8 *value)
175 {
176 	int bytes = DIV_ROUND_UP(width, BITS_PER_BYTE);
177 	u8 total = 0, bmask = 0xff;
178 	int rwidth = width;
179 	int idx;
180 
181 	for (idx = 0; idx < bytes; ++idx, rwidth -= BITS_PER_BYTE) {
182 		if (rwidth && rwidth < BITS_PER_BYTE)
183 			bmask = (1 << rwidth) - 1;
184 		total += value[idx] & bmask;
185 	}
186 	return total == 0;
187 }
188 
vcap_get_bit(u32 * stream,struct vcap_stream_iter * itr)189 static bool vcap_get_bit(u32 *stream, struct vcap_stream_iter *itr)
190 {
191 	u32 mask = BIT(itr->reg_bitpos);
192 	u32 *p = &stream[itr->reg_idx];
193 
194 	return !!(*p & mask);
195 }
196 
vcap_decode_field(u32 * stream,struct vcap_stream_iter * itr,int width,u8 * value)197 static void vcap_decode_field(u32 *stream, struct vcap_stream_iter *itr,
198 			      int width, u8 *value)
199 {
200 	int idx;
201 
202 	/* Loop over the field value bits and get the field bits and
203 	 * set them in the output value byte array
204 	 */
205 	for (idx = 0; idx < width; idx++) {
206 		u8 bidx = idx & 0x7;
207 
208 		/* Decode one field value bit */
209 		if (vcap_get_bit(stream, itr))
210 			*value |= 1 << bidx;
211 		vcap_iter_next(itr);
212 		if (bidx == 7)
213 			value++;
214 	}
215 }
216 
217 /* Verify that the type id in the stream matches the type id of the keyset */
vcap_verify_keystream_keyset(struct vcap_control * vctrl,enum vcap_type vt,u32 * keystream,u32 * mskstream,enum vcap_keyfield_set keyset)218 static bool vcap_verify_keystream_keyset(struct vcap_control *vctrl,
219 					 enum vcap_type vt,
220 					 u32 *keystream,
221 					 u32 *mskstream,
222 					 enum vcap_keyfield_set keyset)
223 {
224 	const struct vcap_info *vcap = &vctrl->vcaps[vt];
225 	const struct vcap_field *typefld;
226 	const struct vcap_typegroup *tgt;
227 	const struct vcap_field *fields;
228 	struct vcap_stream_iter iter;
229 	const struct vcap_set *info;
230 	u32 value = 0;
231 	u32 mask = 0;
232 
233 	if (vcap_keyfield_count(vctrl, vt, keyset) == 0)
234 		return false;
235 
236 	info = vcap_keyfieldset(vctrl, vt, keyset);
237 	/* Check that the keyset is valid */
238 	if (!info)
239 		return false;
240 
241 	/* a type_id of value -1 means that there is no type field */
242 	if (info->type_id == (u8)-1)
243 		return true;
244 
245 	/* Get a valid typegroup for the specific keyset */
246 	tgt = vcap_keyfield_typegroup(vctrl, vt, keyset);
247 	if (!tgt)
248 		return false;
249 
250 	fields = vcap_keyfields(vctrl, vt, keyset);
251 	if (!fields)
252 		return false;
253 
254 	typefld = &fields[VCAP_KF_TYPE];
255 	vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);
256 	vcap_decode_field(mskstream, &iter, typefld->width, (u8 *)&mask);
257 	/* no type info if there are no mask bits */
258 	if (vcap_bitarray_zero(typefld->width, (u8 *)&mask))
259 		return false;
260 
261 	/* Get the value of the type field in the stream and compare to the
262 	 * one define in the vcap keyset
263 	 */
264 	vcap_iter_init(&iter, vcap->sw_width, tgt, typefld->offset);
265 	vcap_decode_field(keystream, &iter, typefld->width, (u8 *)&value);
266 
267 	return (value & mask) == (info->type_id & mask);
268 }
269 
270 /* Verify that the typegroup bits have the correct values */
vcap_verify_typegroups(u32 * stream,int sw_width,const struct vcap_typegroup * tgt,bool mask,int sw_max)271 static int vcap_verify_typegroups(u32 *stream, int sw_width,
272 				  const struct vcap_typegroup *tgt, bool mask,
273 				  int sw_max)
274 {
275 	struct vcap_stream_iter iter;
276 	int sw_cnt, idx;
277 
278 	vcap_iter_set(&iter, sw_width, tgt, 0);
279 	sw_cnt = 0;
280 	while (iter.tg->width) {
281 		u32 value = 0;
282 		u32 tg_value = iter.tg->value;
283 
284 		if (mask)
285 			tg_value = (1 << iter.tg->width) - 1;
286 		/* Set position to current typegroup bit */
287 		iter.offset = iter.tg->offset;
288 		vcap_iter_update(&iter);
289 		for (idx = 0; idx < iter.tg->width; idx++) {
290 			/* Decode one typegroup bit */
291 			if (vcap_get_bit(stream, &iter))
292 				value |= 1 << idx;
293 			iter.offset++;
294 			vcap_iter_update(&iter);
295 		}
296 		if (value != tg_value)
297 			return -EINVAL;
298 		iter.tg++; /* next typegroup */
299 		sw_cnt++;
300 		/* Stop checking more typegroups */
301 		if (sw_max && sw_cnt >= sw_max)
302 			break;
303 	}
304 	return 0;
305 }
306 
307 /* Find the subword width of the key typegroup that matches the stream data */
vcap_find_keystream_typegroup_sw(struct vcap_control * vctrl,enum vcap_type vt,u32 * stream,bool mask,int sw_max)308 static int vcap_find_keystream_typegroup_sw(struct vcap_control *vctrl,
309 					    enum vcap_type vt, u32 *stream,
310 					    bool mask, int sw_max)
311 {
312 	const struct vcap_typegroup **tgt;
313 	int sw_idx, res;
314 
315 	tgt = vctrl->vcaps[vt].keyfield_set_typegroups;
316 	/* Try the longest subword match first */
317 	for (sw_idx = vctrl->vcaps[vt].sw_count; sw_idx >= 0; sw_idx--) {
318 		if (!tgt[sw_idx])
319 			continue;
320 
321 		res = vcap_verify_typegroups(stream, vctrl->vcaps[vt].sw_width,
322 					     tgt[sw_idx], mask, sw_max);
323 		if (res == 0)
324 			return sw_idx;
325 	}
326 	return -EINVAL;
327 }
328 
329 /* Verify that the typegroup information, subword count, keyset and type id
330  * are in sync and correct, return the list of matching keysets
331  */
332 int
vcap_find_keystream_keysets(struct vcap_control * vctrl,enum vcap_type vt,u32 * keystream,u32 * mskstream,bool mask,int sw_max,struct vcap_keyset_list * kslist)333 vcap_find_keystream_keysets(struct vcap_control *vctrl,
334 			    enum vcap_type vt,
335 			    u32 *keystream,
336 			    u32 *mskstream,
337 			    bool mask, int sw_max,
338 			    struct vcap_keyset_list *kslist)
339 {
340 	const struct vcap_set *keyfield_set;
341 	int sw_count, idx;
342 
343 	sw_count = vcap_find_keystream_typegroup_sw(vctrl, vt, keystream, mask,
344 						    sw_max);
345 	if (sw_count < 0)
346 		return sw_count;
347 
348 	keyfield_set = vctrl->vcaps[vt].keyfield_set;
349 	for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) {
350 		if (keyfield_set[idx].sw_per_item != sw_count)
351 			continue;
352 
353 		if (vcap_verify_keystream_keyset(vctrl, vt, keystream,
354 						 mskstream, idx))
355 			vcap_keyset_list_add(kslist, idx);
356 	}
357 	if (kslist->cnt > 0)
358 		return 0;
359 	return -EINVAL;
360 }
361 EXPORT_SYMBOL_GPL(vcap_find_keystream_keysets);
362 
363 /* Read key data from a VCAP address and discover if there are any rule keysets
364  * here
365  */
vcap_addr_keysets(struct vcap_control * vctrl,struct net_device * ndev,struct vcap_admin * admin,int addr,struct vcap_keyset_list * kslist)366 int vcap_addr_keysets(struct vcap_control *vctrl,
367 		      struct net_device *ndev,
368 		      struct vcap_admin *admin,
369 		      int addr,
370 		      struct vcap_keyset_list *kslist)
371 {
372 	enum vcap_type vt = admin->vtype;
373 	int keyset_sw_regs, idx;
374 	u32 key = 0, mask = 0;
375 
376 	/* Read the cache at the specified address */
377 	keyset_sw_regs = DIV_ROUND_UP(vctrl->vcaps[vt].sw_width, 32);
378 	vctrl->ops->update(ndev, admin, VCAP_CMD_READ, VCAP_SEL_ALL, addr);
379 	vctrl->ops->cache_read(ndev, admin, VCAP_SEL_ENTRY, 0,
380 			       keyset_sw_regs);
381 	/* Skip uninitialized key/mask entries */
382 	for (idx = 0; idx < keyset_sw_regs; ++idx) {
383 		key |= ~admin->cache.keystream[idx];
384 		mask |= admin->cache.maskstream[idx];
385 	}
386 	if (key == 0 && mask == 0)
387 		return -EINVAL;
388 	/* Decode and locate the keysets */
389 	return vcap_find_keystream_keysets(vctrl, vt, admin->cache.keystream,
390 					   admin->cache.maskstream, false, 0,
391 					   kslist);
392 }
393 EXPORT_SYMBOL_GPL(vcap_addr_keysets);
394 
395 /* Return the list of keyfields for the keyset */
vcap_keyfields(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_keyfield_set keyset)396 const struct vcap_field *vcap_keyfields(struct vcap_control *vctrl,
397 					enum vcap_type vt,
398 					enum vcap_keyfield_set keyset)
399 {
400 	/* Check that the keyset exists in the vcap keyset list */
401 	if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
402 		return NULL;
403 	return vctrl->vcaps[vt].keyfield_set_map[keyset];
404 }
405 
406 /* Return the keyset information for the keyset */
vcap_keyfieldset(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_keyfield_set keyset)407 const struct vcap_set *vcap_keyfieldset(struct vcap_control *vctrl,
408 					enum vcap_type vt,
409 					enum vcap_keyfield_set keyset)
410 {
411 	const struct vcap_set *kset;
412 
413 	/* Check that the keyset exists in the vcap keyset list */
414 	if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
415 		return NULL;
416 	kset = &vctrl->vcaps[vt].keyfield_set[keyset];
417 	if (kset->sw_per_item == 0 || kset->sw_per_item > vctrl->vcaps[vt].sw_count)
418 		return NULL;
419 	return kset;
420 }
421 EXPORT_SYMBOL_GPL(vcap_keyfieldset);
422 
423 /* Return the typegroup table for the matching keyset (using subword size) */
424 const struct vcap_typegroup *
vcap_keyfield_typegroup(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_keyfield_set keyset)425 vcap_keyfield_typegroup(struct vcap_control *vctrl,
426 			enum vcap_type vt, enum vcap_keyfield_set keyset)
427 {
428 	const struct vcap_set *kset = vcap_keyfieldset(vctrl, vt, keyset);
429 
430 	/* Check that the keyset is valid */
431 	if (!kset)
432 		return NULL;
433 	return vctrl->vcaps[vt].keyfield_set_typegroups[kset->sw_per_item];
434 }
435 
436 /* Return the number of keyfields in the keyset */
vcap_keyfield_count(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_keyfield_set keyset)437 int vcap_keyfield_count(struct vcap_control *vctrl,
438 			enum vcap_type vt, enum vcap_keyfield_set keyset)
439 {
440 	/* Check that the keyset exists in the vcap keyset list */
441 	if (keyset >= vctrl->vcaps[vt].keyfield_set_size)
442 		return 0;
443 	return vctrl->vcaps[vt].keyfield_set_map_size[keyset];
444 }
445 
vcap_encode_keyfield(struct vcap_rule_internal * ri,const struct vcap_client_keyfield * kf,const struct vcap_field * rf,const struct vcap_typegroup * tgt)446 static void vcap_encode_keyfield(struct vcap_rule_internal *ri,
447 				 const struct vcap_client_keyfield *kf,
448 				 const struct vcap_field *rf,
449 				 const struct vcap_typegroup *tgt)
450 {
451 	int sw_width = ri->vctrl->vcaps[ri->admin->vtype].sw_width;
452 	struct vcap_cache_data *cache = &ri->admin->cache;
453 	struct vcap_stream_iter iter;
454 	const u8 *value, *mask;
455 
456 	/* Encode the fields for the key and the mask in their respective
457 	 * streams, respecting the subword width.
458 	 */
459 	switch (kf->ctrl.type) {
460 	case VCAP_FIELD_BIT:
461 		value = &kf->data.u1.value;
462 		mask = &kf->data.u1.mask;
463 		break;
464 	case VCAP_FIELD_U32:
465 		value = (const u8 *)&kf->data.u32.value;
466 		mask = (const u8 *)&kf->data.u32.mask;
467 		break;
468 	case VCAP_FIELD_U48:
469 		value = kf->data.u48.value;
470 		mask = kf->data.u48.mask;
471 		break;
472 	case VCAP_FIELD_U56:
473 		value = kf->data.u56.value;
474 		mask = kf->data.u56.mask;
475 		break;
476 	case VCAP_FIELD_U64:
477 		value = kf->data.u64.value;
478 		mask = kf->data.u64.mask;
479 		break;
480 	case VCAP_FIELD_U72:
481 		value = kf->data.u72.value;
482 		mask = kf->data.u72.mask;
483 		break;
484 	case VCAP_FIELD_U112:
485 		value = kf->data.u112.value;
486 		mask = kf->data.u112.mask;
487 		break;
488 	case VCAP_FIELD_U128:
489 		value = kf->data.u128.value;
490 		mask = kf->data.u128.mask;
491 		break;
492 	}
493 	vcap_iter_init(&iter, sw_width, tgt, rf->offset);
494 	vcap_encode_field(cache->keystream, &iter, rf->width, value);
495 	vcap_iter_init(&iter, sw_width, tgt, rf->offset);
496 	vcap_encode_field(cache->maskstream, &iter, rf->width, mask);
497 }
498 
vcap_encode_keyfield_typegroups(struct vcap_control * vctrl,struct vcap_rule_internal * ri,const struct vcap_typegroup * tgt)499 static void vcap_encode_keyfield_typegroups(struct vcap_control *vctrl,
500 					    struct vcap_rule_internal *ri,
501 					    const struct vcap_typegroup *tgt)
502 {
503 	int sw_width = vctrl->vcaps[ri->admin->vtype].sw_width;
504 	struct vcap_cache_data *cache = &ri->admin->cache;
505 
506 	/* Encode the typegroup bits for the key and the mask in their streams,
507 	 * respecting the subword width.
508 	 */
509 	vcap_encode_typegroups(cache->keystream, sw_width, tgt, false);
510 	vcap_encode_typegroups(cache->maskstream, sw_width, tgt, true);
511 }
512 
513 /* Copy data from src to dst but reverse the data in chunks of 32bits.
514  * For example if src is 00:11:22:33:44:55 where 55 is LSB the dst will
515  * have the value 22:33:44:55:00:11.
516  */
vcap_copy_to_w32be(u8 * dst,const u8 * src,int size)517 static void vcap_copy_to_w32be(u8 *dst, const u8 *src, int size)
518 {
519 	for (int idx = 0; idx < size; ++idx) {
520 		int first_byte_index = 0;
521 		int nidx;
522 
523 		first_byte_index = size - (((idx >> 2) + 1) << 2);
524 		if (first_byte_index < 0)
525 			first_byte_index = 0;
526 		nidx = idx + first_byte_index - (idx & ~0x3);
527 		dst[nidx] = src[idx];
528 	}
529 }
530 
531 static void
vcap_copy_from_client_keyfield(struct vcap_rule * rule,struct vcap_client_keyfield * dst,const struct vcap_client_keyfield * src)532 vcap_copy_from_client_keyfield(struct vcap_rule *rule,
533 			       struct vcap_client_keyfield *dst,
534 			       const struct vcap_client_keyfield *src)
535 {
536 	struct vcap_rule_internal *ri = to_intrule(rule);
537 	const struct vcap_client_keyfield_data *sdata;
538 	struct vcap_client_keyfield_data *ddata;
539 	int size;
540 
541 	dst->ctrl.type = src->ctrl.type;
542 	dst->ctrl.key = src->ctrl.key;
543 	INIT_LIST_HEAD(&dst->ctrl.list);
544 	sdata = &src->data;
545 	ddata = &dst->data;
546 
547 	if (!ri->admin->w32be) {
548 		memcpy(ddata, sdata, sizeof(dst->data));
549 		return;
550 	}
551 
552 	size = keyfield_size_table[dst->ctrl.type] / 2;
553 
554 	switch (dst->ctrl.type) {
555 	case VCAP_FIELD_BIT:
556 	case VCAP_FIELD_U32:
557 		memcpy(ddata, sdata, sizeof(dst->data));
558 		break;
559 	case VCAP_FIELD_U48:
560 		vcap_copy_to_w32be(ddata->u48.value, src->data.u48.value, size);
561 		vcap_copy_to_w32be(ddata->u48.mask,  src->data.u48.mask, size);
562 		break;
563 	case VCAP_FIELD_U56:
564 		vcap_copy_to_w32be(ddata->u56.value, sdata->u56.value, size);
565 		vcap_copy_to_w32be(ddata->u56.mask,  sdata->u56.mask, size);
566 		break;
567 	case VCAP_FIELD_U64:
568 		vcap_copy_to_w32be(ddata->u64.value, sdata->u64.value, size);
569 		vcap_copy_to_w32be(ddata->u64.mask,  sdata->u64.mask, size);
570 		break;
571 	case VCAP_FIELD_U72:
572 		vcap_copy_to_w32be(ddata->u72.value, sdata->u72.value, size);
573 		vcap_copy_to_w32be(ddata->u72.mask,  sdata->u72.mask, size);
574 		break;
575 	case VCAP_FIELD_U112:
576 		vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size);
577 		vcap_copy_to_w32be(ddata->u112.mask,  sdata->u112.mask, size);
578 		break;
579 	case VCAP_FIELD_U128:
580 		vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size);
581 		vcap_copy_to_w32be(ddata->u128.mask,  sdata->u128.mask, size);
582 		break;
583 	}
584 }
585 
586 static void
vcap_copy_from_client_actionfield(struct vcap_rule * rule,struct vcap_client_actionfield * dst,const struct vcap_client_actionfield * src)587 vcap_copy_from_client_actionfield(struct vcap_rule *rule,
588 				  struct vcap_client_actionfield *dst,
589 				  const struct vcap_client_actionfield *src)
590 {
591 	struct vcap_rule_internal *ri = to_intrule(rule);
592 	const struct vcap_client_actionfield_data *sdata;
593 	struct vcap_client_actionfield_data *ddata;
594 	int size;
595 
596 	dst->ctrl.type = src->ctrl.type;
597 	dst->ctrl.action = src->ctrl.action;
598 	INIT_LIST_HEAD(&dst->ctrl.list);
599 	sdata = &src->data;
600 	ddata = &dst->data;
601 
602 	if (!ri->admin->w32be) {
603 		memcpy(ddata, sdata, sizeof(dst->data));
604 		return;
605 	}
606 
607 	size = actionfield_size_table[dst->ctrl.type];
608 
609 	switch (dst->ctrl.type) {
610 	case VCAP_FIELD_BIT:
611 	case VCAP_FIELD_U32:
612 		memcpy(ddata, sdata, sizeof(dst->data));
613 		break;
614 	case VCAP_FIELD_U48:
615 		vcap_copy_to_w32be(ddata->u48.value, sdata->u48.value, size);
616 		break;
617 	case VCAP_FIELD_U56:
618 		vcap_copy_to_w32be(ddata->u56.value, sdata->u56.value, size);
619 		break;
620 	case VCAP_FIELD_U64:
621 		vcap_copy_to_w32be(ddata->u64.value, sdata->u64.value, size);
622 		break;
623 	case VCAP_FIELD_U72:
624 		vcap_copy_to_w32be(ddata->u72.value, sdata->u72.value, size);
625 		break;
626 	case VCAP_FIELD_U112:
627 		vcap_copy_to_w32be(ddata->u112.value, sdata->u112.value, size);
628 		break;
629 	case VCAP_FIELD_U128:
630 		vcap_copy_to_w32be(ddata->u128.value, sdata->u128.value, size);
631 		break;
632 	}
633 }
634 
vcap_encode_rule_keyset(struct vcap_rule_internal * ri)635 static int vcap_encode_rule_keyset(struct vcap_rule_internal *ri)
636 {
637 	const struct vcap_client_keyfield *ckf;
638 	const struct vcap_typegroup *tg_table;
639 	struct vcap_client_keyfield tempkf;
640 	const struct vcap_field *kf_table;
641 	int keyset_size;
642 
643 	/* Get a valid set of fields for the specific keyset */
644 	kf_table = vcap_keyfields(ri->vctrl, ri->admin->vtype, ri->data.keyset);
645 	if (!kf_table) {
646 		pr_err("%s:%d: no fields available for this keyset: %d\n",
647 		       __func__, __LINE__, ri->data.keyset);
648 		return -EINVAL;
649 	}
650 	/* Get a valid typegroup for the specific keyset */
651 	tg_table = vcap_keyfield_typegroup(ri->vctrl, ri->admin->vtype,
652 					   ri->data.keyset);
653 	if (!tg_table) {
654 		pr_err("%s:%d: no typegroups available for this keyset: %d\n",
655 		       __func__, __LINE__, ri->data.keyset);
656 		return -EINVAL;
657 	}
658 	/* Get a valid size for the specific keyset */
659 	keyset_size = vcap_keyfield_count(ri->vctrl, ri->admin->vtype,
660 					  ri->data.keyset);
661 	if (keyset_size == 0) {
662 		pr_err("%s:%d: zero field count for this keyset: %d\n",
663 		       __func__, __LINE__, ri->data.keyset);
664 		return -EINVAL;
665 	}
666 	/* Iterate over the keyfields (key, mask) in the rule
667 	 * and encode these bits
668 	 */
669 	if (list_empty(&ri->data.keyfields)) {
670 		pr_err("%s:%d: no keyfields in the rule\n", __func__, __LINE__);
671 		return -EINVAL;
672 	}
673 	list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
674 		/* Check that the client entry exists in the keyset */
675 		if (ckf->ctrl.key >= keyset_size) {
676 			pr_err("%s:%d: key %d is not in vcap\n",
677 			       __func__, __LINE__, ckf->ctrl.key);
678 			return -EINVAL;
679 		}
680 		vcap_copy_from_client_keyfield(&ri->data, &tempkf, ckf);
681 		vcap_encode_keyfield(ri, &tempkf, &kf_table[ckf->ctrl.key],
682 				     tg_table);
683 	}
684 	/* Add typegroup bits to the key/mask bitstreams */
685 	vcap_encode_keyfield_typegroups(ri->vctrl, ri, tg_table);
686 	return 0;
687 }
688 
689 /* Return the list of actionfields for the actionset */
690 const struct vcap_field *
vcap_actionfields(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_actionfield_set actionset)691 vcap_actionfields(struct vcap_control *vctrl,
692 		  enum vcap_type vt, enum vcap_actionfield_set actionset)
693 {
694 	/* Check that the actionset exists in the vcap actionset list */
695 	if (actionset >= vctrl->vcaps[vt].actionfield_set_size)
696 		return NULL;
697 	return vctrl->vcaps[vt].actionfield_set_map[actionset];
698 }
699 
700 const struct vcap_set *
vcap_actionfieldset(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_actionfield_set actionset)701 vcap_actionfieldset(struct vcap_control *vctrl,
702 		    enum vcap_type vt, enum vcap_actionfield_set actionset)
703 {
704 	const struct vcap_set *aset;
705 
706 	/* Check that the actionset exists in the vcap actionset list */
707 	if (actionset >= vctrl->vcaps[vt].actionfield_set_size)
708 		return NULL;
709 	aset = &vctrl->vcaps[vt].actionfield_set[actionset];
710 	if (aset->sw_per_item == 0 || aset->sw_per_item > vctrl->vcaps[vt].sw_count)
711 		return NULL;
712 	return aset;
713 }
714 
715 /* Return the typegroup table for the matching actionset (using subword size) */
716 const struct vcap_typegroup *
vcap_actionfield_typegroup(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_actionfield_set actionset)717 vcap_actionfield_typegroup(struct vcap_control *vctrl,
718 			   enum vcap_type vt, enum vcap_actionfield_set actionset)
719 {
720 	const struct vcap_set *aset = vcap_actionfieldset(vctrl, vt, actionset);
721 
722 	/* Check that the actionset is valid */
723 	if (!aset)
724 		return NULL;
725 	return vctrl->vcaps[vt].actionfield_set_typegroups[aset->sw_per_item];
726 }
727 
728 /* Return the number of actionfields in the actionset */
vcap_actionfield_count(struct vcap_control * vctrl,enum vcap_type vt,enum vcap_actionfield_set actionset)729 int vcap_actionfield_count(struct vcap_control *vctrl,
730 			   enum vcap_type vt,
731 			   enum vcap_actionfield_set actionset)
732 {
733 	/* Check that the actionset exists in the vcap actionset list */
734 	if (actionset >= vctrl->vcaps[vt].actionfield_set_size)
735 		return 0;
736 	return vctrl->vcaps[vt].actionfield_set_map_size[actionset];
737 }
738 
vcap_encode_actionfield(struct vcap_rule_internal * ri,const struct vcap_client_actionfield * af,const struct vcap_field * rf,const struct vcap_typegroup * tgt)739 static void vcap_encode_actionfield(struct vcap_rule_internal *ri,
740 				    const struct vcap_client_actionfield *af,
741 				    const struct vcap_field *rf,
742 				    const struct vcap_typegroup *tgt)
743 {
744 	int act_width = ri->vctrl->vcaps[ri->admin->vtype].act_width;
745 
746 	struct vcap_cache_data *cache = &ri->admin->cache;
747 	struct vcap_stream_iter iter;
748 	const u8 *value;
749 
750 	/* Encode the action field in the stream, respecting the subword width */
751 	switch (af->ctrl.type) {
752 	case VCAP_FIELD_BIT:
753 		value = &af->data.u1.value;
754 		break;
755 	case VCAP_FIELD_U32:
756 		value = (const u8 *)&af->data.u32.value;
757 		break;
758 	case VCAP_FIELD_U48:
759 		value = af->data.u48.value;
760 		break;
761 	case VCAP_FIELD_U56:
762 		value = af->data.u56.value;
763 		break;
764 	case VCAP_FIELD_U64:
765 		value = af->data.u64.value;
766 		break;
767 	case VCAP_FIELD_U72:
768 		value = af->data.u72.value;
769 		break;
770 	case VCAP_FIELD_U112:
771 		value = af->data.u112.value;
772 		break;
773 	case VCAP_FIELD_U128:
774 		value = af->data.u128.value;
775 		break;
776 	}
777 	vcap_iter_init(&iter, act_width, tgt, rf->offset);
778 	vcap_encode_field(cache->actionstream, &iter, rf->width, value);
779 }
780 
vcap_encode_actionfield_typegroups(struct vcap_rule_internal * ri,const struct vcap_typegroup * tgt)781 static void vcap_encode_actionfield_typegroups(struct vcap_rule_internal *ri,
782 					       const struct vcap_typegroup *tgt)
783 {
784 	int sw_width = ri->vctrl->vcaps[ri->admin->vtype].act_width;
785 	struct vcap_cache_data *cache = &ri->admin->cache;
786 
787 	/* Encode the typegroup bits for the actionstream respecting the subword
788 	 * width.
789 	 */
790 	vcap_encode_typegroups(cache->actionstream, sw_width, tgt, false);
791 }
792 
vcap_encode_rule_actionset(struct vcap_rule_internal * ri)793 static int vcap_encode_rule_actionset(struct vcap_rule_internal *ri)
794 {
795 	const struct vcap_client_actionfield *caf;
796 	const struct vcap_typegroup *tg_table;
797 	struct vcap_client_actionfield tempaf;
798 	const struct vcap_field *af_table;
799 	int actionset_size;
800 
801 	/* Get a valid set of actionset fields for the specific actionset */
802 	af_table = vcap_actionfields(ri->vctrl, ri->admin->vtype,
803 				     ri->data.actionset);
804 	if (!af_table) {
805 		pr_err("%s:%d: no fields available for this actionset: %d\n",
806 		       __func__, __LINE__, ri->data.actionset);
807 		return -EINVAL;
808 	}
809 	/* Get a valid typegroup for the specific actionset */
810 	tg_table = vcap_actionfield_typegroup(ri->vctrl, ri->admin->vtype,
811 					      ri->data.actionset);
812 	if (!tg_table) {
813 		pr_err("%s:%d: no typegroups available for this actionset: %d\n",
814 		       __func__, __LINE__, ri->data.actionset);
815 		return -EINVAL;
816 	}
817 	/* Get a valid actionset size for the specific actionset */
818 	actionset_size = vcap_actionfield_count(ri->vctrl, ri->admin->vtype,
819 						ri->data.actionset);
820 	if (actionset_size == 0) {
821 		pr_err("%s:%d: zero field count for this actionset: %d\n",
822 		       __func__, __LINE__, ri->data.actionset);
823 		return -EINVAL;
824 	}
825 	/* Iterate over the actionfields in the rule
826 	 * and encode these bits
827 	 */
828 	if (list_empty(&ri->data.actionfields))
829 		pr_warn("%s:%d: no actionfields in the rule\n",
830 			__func__, __LINE__);
831 	list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
832 		/* Check that the client action exists in the actionset */
833 		if (caf->ctrl.action >= actionset_size) {
834 			pr_err("%s:%d: action %d is not in vcap\n",
835 			       __func__, __LINE__, caf->ctrl.action);
836 			return -EINVAL;
837 		}
838 		vcap_copy_from_client_actionfield(&ri->data, &tempaf, caf);
839 		vcap_encode_actionfield(ri, &tempaf,
840 					&af_table[caf->ctrl.action], tg_table);
841 	}
842 	/* Add typegroup bits to the entry bitstreams */
843 	vcap_encode_actionfield_typegroups(ri, tg_table);
844 	return 0;
845 }
846 
vcap_encode_rule(struct vcap_rule_internal * ri)847 static int vcap_encode_rule(struct vcap_rule_internal *ri)
848 {
849 	int err;
850 
851 	err = vcap_encode_rule_keyset(ri);
852 	if (err)
853 		return err;
854 	err = vcap_encode_rule_actionset(ri);
855 	if (err)
856 		return err;
857 	return 0;
858 }
859 
vcap_api_check(struct vcap_control * ctrl)860 int vcap_api_check(struct vcap_control *ctrl)
861 {
862 	if (!ctrl) {
863 		pr_err("%s:%d: vcap control is missing\n", __func__, __LINE__);
864 		return -EINVAL;
865 	}
866 	if (!ctrl->ops || !ctrl->ops->validate_keyset ||
867 	    !ctrl->ops->add_default_fields || !ctrl->ops->cache_erase ||
868 	    !ctrl->ops->cache_write || !ctrl->ops->cache_read ||
869 	    !ctrl->ops->init || !ctrl->ops->update || !ctrl->ops->move ||
870 	    !ctrl->ops->port_info) {
871 		pr_err("%s:%d: client operations are missing\n",
872 		       __func__, __LINE__);
873 		return -ENOENT;
874 	}
875 	return 0;
876 }
877 
vcap_erase_cache(struct vcap_rule_internal * ri)878 void vcap_erase_cache(struct vcap_rule_internal *ri)
879 {
880 	ri->vctrl->ops->cache_erase(ri->admin);
881 }
882 
883 /* Update the keyset for the rule */
vcap_set_rule_set_keyset(struct vcap_rule * rule,enum vcap_keyfield_set keyset)884 int vcap_set_rule_set_keyset(struct vcap_rule *rule,
885 			     enum vcap_keyfield_set keyset)
886 {
887 	struct vcap_rule_internal *ri = to_intrule(rule);
888 	const struct vcap_set *kset;
889 	int sw_width;
890 
891 	kset = vcap_keyfieldset(ri->vctrl, ri->admin->vtype, keyset);
892 	/* Check that the keyset is valid */
893 	if (!kset)
894 		return -EINVAL;
895 	ri->keyset_sw = kset->sw_per_item;
896 	sw_width = ri->vctrl->vcaps[ri->admin->vtype].sw_width;
897 	ri->keyset_sw_regs = DIV_ROUND_UP(sw_width, 32);
898 	ri->data.keyset = keyset;
899 	return 0;
900 }
901 EXPORT_SYMBOL_GPL(vcap_set_rule_set_keyset);
902 
903 /* Update the actionset for the rule */
vcap_set_rule_set_actionset(struct vcap_rule * rule,enum vcap_actionfield_set actionset)904 int vcap_set_rule_set_actionset(struct vcap_rule *rule,
905 				enum vcap_actionfield_set actionset)
906 {
907 	struct vcap_rule_internal *ri = to_intrule(rule);
908 	const struct vcap_set *aset;
909 	int act_width;
910 
911 	aset = vcap_actionfieldset(ri->vctrl, ri->admin->vtype, actionset);
912 	/* Check that the actionset is valid */
913 	if (!aset)
914 		return -EINVAL;
915 	ri->actionset_sw = aset->sw_per_item;
916 	act_width = ri->vctrl->vcaps[ri->admin->vtype].act_width;
917 	ri->actionset_sw_regs = DIV_ROUND_UP(act_width, 32);
918 	ri->data.actionset = actionset;
919 	return 0;
920 }
921 EXPORT_SYMBOL_GPL(vcap_set_rule_set_actionset);
922 
923 /* Check if a rule with this id exists */
vcap_rule_exists(struct vcap_control * vctrl,u32 id)924 static bool vcap_rule_exists(struct vcap_control *vctrl, u32 id)
925 {
926 	struct vcap_rule_internal *ri;
927 	struct vcap_admin *admin;
928 
929 	/* Look for the rule id in all vcaps */
930 	list_for_each_entry(admin, &vctrl->list, list)
931 		list_for_each_entry(ri, &admin->rules, list)
932 			if (ri->data.id == id)
933 				return true;
934 	return false;
935 }
936 
937 /* Find a rule with a provided rule id return a locked vcap */
938 static struct vcap_rule_internal *
vcap_get_locked_rule(struct vcap_control * vctrl,u32 id)939 vcap_get_locked_rule(struct vcap_control *vctrl, u32 id)
940 {
941 	struct vcap_rule_internal *ri;
942 	struct vcap_admin *admin;
943 
944 	/* Look for the rule id in all vcaps */
945 	list_for_each_entry(admin, &vctrl->list, list) {
946 		mutex_lock(&admin->lock);
947 		list_for_each_entry(ri, &admin->rules, list)
948 			if (ri->data.id == id)
949 				return ri;
950 		mutex_unlock(&admin->lock);
951 	}
952 	return NULL;
953 }
954 
955 /* Find a rule id with a provided cookie */
vcap_lookup_rule_by_cookie(struct vcap_control * vctrl,u64 cookie)956 int vcap_lookup_rule_by_cookie(struct vcap_control *vctrl, u64 cookie)
957 {
958 	struct vcap_rule_internal *ri;
959 	struct vcap_admin *admin;
960 	int id = 0;
961 
962 	/* Look for the rule id in all vcaps */
963 	list_for_each_entry(admin, &vctrl->list, list) {
964 		mutex_lock(&admin->lock);
965 		list_for_each_entry(ri, &admin->rules, list) {
966 			if (ri->data.cookie == cookie) {
967 				id = ri->data.id;
968 				break;
969 			}
970 		}
971 		mutex_unlock(&admin->lock);
972 		if (id)
973 			return id;
974 	}
975 	return -ENOENT;
976 }
977 EXPORT_SYMBOL_GPL(vcap_lookup_rule_by_cookie);
978 
979 /* Get number of rules in a vcap instance lookup chain id range */
vcap_admin_rule_count(struct vcap_admin * admin,int cid)980 int vcap_admin_rule_count(struct vcap_admin *admin, int cid)
981 {
982 	int max_cid = roundup(cid + 1, VCAP_CID_LOOKUP_SIZE);
983 	int min_cid = rounddown(cid, VCAP_CID_LOOKUP_SIZE);
984 	struct vcap_rule_internal *elem;
985 	int count = 0;
986 
987 	list_for_each_entry(elem, &admin->rules, list) {
988 		mutex_lock(&admin->lock);
989 		if (elem->data.vcap_chain_id >= min_cid &&
990 		    elem->data.vcap_chain_id < max_cid)
991 			++count;
992 		mutex_unlock(&admin->lock);
993 	}
994 	return count;
995 }
996 EXPORT_SYMBOL_GPL(vcap_admin_rule_count);
997 
998 /* Make a copy of the rule, shallow or full */
vcap_dup_rule(struct vcap_rule_internal * ri,bool full)999 static struct vcap_rule_internal *vcap_dup_rule(struct vcap_rule_internal *ri,
1000 						bool full)
1001 {
1002 	struct vcap_client_actionfield *caf, *newcaf;
1003 	struct vcap_client_keyfield *ckf, *newckf;
1004 	struct vcap_rule_internal *duprule;
1005 
1006 	/* Allocate the client part */
1007 	duprule = kzalloc(sizeof(*duprule), GFP_KERNEL);
1008 	if (!duprule)
1009 		return ERR_PTR(-ENOMEM);
1010 	*duprule = *ri;
1011 	/* Not inserted in the VCAP */
1012 	INIT_LIST_HEAD(&duprule->list);
1013 	/* No elements in these lists */
1014 	INIT_LIST_HEAD(&duprule->data.keyfields);
1015 	INIT_LIST_HEAD(&duprule->data.actionfields);
1016 
1017 	/* A full rule copy includes keys and actions */
1018 	if (!full)
1019 		return duprule;
1020 
1021 	list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
1022 		newckf = kmemdup(ckf, sizeof(*newckf), GFP_KERNEL);
1023 		if (!newckf)
1024 			goto err;
1025 		list_add_tail(&newckf->ctrl.list, &duprule->data.keyfields);
1026 	}
1027 
1028 	list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
1029 		newcaf = kmemdup(caf, sizeof(*newcaf), GFP_KERNEL);
1030 		if (!newcaf)
1031 			goto err;
1032 		list_add_tail(&newcaf->ctrl.list, &duprule->data.actionfields);
1033 	}
1034 
1035 	return duprule;
1036 
1037 err:
1038 	list_for_each_entry_safe(ckf, newckf, &duprule->data.keyfields, ctrl.list) {
1039 		list_del(&ckf->ctrl.list);
1040 		kfree(ckf);
1041 	}
1042 
1043 	list_for_each_entry_safe(caf, newcaf, &duprule->data.actionfields, ctrl.list) {
1044 		list_del(&caf->ctrl.list);
1045 		kfree(caf);
1046 	}
1047 
1048 	kfree(duprule);
1049 	return ERR_PTR(-ENOMEM);
1050 }
1051 
vcap_apply_width(u8 * dst,int width,int bytes)1052 static void vcap_apply_width(u8 *dst, int width, int bytes)
1053 {
1054 	u8 bmask;
1055 	int idx;
1056 
1057 	for (idx = 0; idx < bytes; idx++) {
1058 		if (width > 0)
1059 			if (width < 8)
1060 				bmask = (1 << width) - 1;
1061 			else
1062 				bmask = ~0;
1063 		else
1064 			bmask = 0;
1065 		dst[idx] &= bmask;
1066 		width -= 8;
1067 	}
1068 }
1069 
vcap_copy_from_w32be(u8 * dst,u8 * src,int size,int width)1070 static void vcap_copy_from_w32be(u8 *dst, u8 *src, int size, int width)
1071 {
1072 	int idx, ridx, wstart, nidx;
1073 	int tail_bytes = (((size + 4) >> 2) << 2) - size;
1074 
1075 	for (idx = 0, ridx = size - 1; idx < size; ++idx, --ridx) {
1076 		wstart = (idx >> 2) << 2;
1077 		nidx = wstart + 3 - (idx & 0x3);
1078 		if (nidx >= size)
1079 			nidx -= tail_bytes;
1080 		dst[nidx] = src[ridx];
1081 	}
1082 
1083 	vcap_apply_width(dst, width, size);
1084 }
1085 
vcap_copy_action_bit_field(struct vcap_u1_action * field,u8 * value)1086 static void vcap_copy_action_bit_field(struct vcap_u1_action *field, u8 *value)
1087 {
1088 	field->value = (*value) & 0x1;
1089 }
1090 
vcap_copy_limited_actionfield(u8 * dstvalue,u8 * srcvalue,int width,int bytes)1091 static void vcap_copy_limited_actionfield(u8 *dstvalue, u8 *srcvalue,
1092 					  int width, int bytes)
1093 {
1094 	memcpy(dstvalue, srcvalue, bytes);
1095 	vcap_apply_width(dstvalue, width, bytes);
1096 }
1097 
vcap_copy_to_client_actionfield(struct vcap_rule_internal * ri,struct vcap_client_actionfield * field,u8 * value,u16 width)1098 static void vcap_copy_to_client_actionfield(struct vcap_rule_internal *ri,
1099 					    struct vcap_client_actionfield *field,
1100 					    u8 *value, u16 width)
1101 {
1102 	int field_size = actionfield_size_table[field->ctrl.type];
1103 
1104 	if (ri->admin->w32be) {
1105 		switch (field->ctrl.type) {
1106 		case VCAP_FIELD_BIT:
1107 			vcap_copy_action_bit_field(&field->data.u1, value);
1108 			break;
1109 		case VCAP_FIELD_U32:
1110 			vcap_copy_limited_actionfield((u8 *)&field->data.u32.value,
1111 						      value,
1112 						      width, field_size);
1113 			break;
1114 		case VCAP_FIELD_U48:
1115 			vcap_copy_from_w32be(field->data.u48.value, value,
1116 					     field_size, width);
1117 			break;
1118 		case VCAP_FIELD_U56:
1119 			vcap_copy_from_w32be(field->data.u56.value, value,
1120 					     field_size, width);
1121 			break;
1122 		case VCAP_FIELD_U64:
1123 			vcap_copy_from_w32be(field->data.u64.value, value,
1124 					     field_size, width);
1125 			break;
1126 		case VCAP_FIELD_U72:
1127 			vcap_copy_from_w32be(field->data.u72.value, value,
1128 					     field_size, width);
1129 			break;
1130 		case VCAP_FIELD_U112:
1131 			vcap_copy_from_w32be(field->data.u112.value, value,
1132 					     field_size, width);
1133 			break;
1134 		case VCAP_FIELD_U128:
1135 			vcap_copy_from_w32be(field->data.u128.value, value,
1136 					     field_size, width);
1137 			break;
1138 		}
1139 	} else {
1140 		switch (field->ctrl.type) {
1141 		case VCAP_FIELD_BIT:
1142 			vcap_copy_action_bit_field(&field->data.u1, value);
1143 			break;
1144 		case VCAP_FIELD_U32:
1145 			vcap_copy_limited_actionfield((u8 *)&field->data.u32.value,
1146 						      value,
1147 						      width, field_size);
1148 			break;
1149 		case VCAP_FIELD_U48:
1150 			vcap_copy_limited_actionfield(field->data.u48.value,
1151 						      value,
1152 						      width, field_size);
1153 			break;
1154 		case VCAP_FIELD_U56:
1155 			vcap_copy_limited_actionfield(field->data.u56.value,
1156 						      value,
1157 						      width, field_size);
1158 			break;
1159 		case VCAP_FIELD_U64:
1160 			vcap_copy_limited_actionfield(field->data.u64.value,
1161 						      value,
1162 						      width, field_size);
1163 			break;
1164 		case VCAP_FIELD_U72:
1165 			vcap_copy_limited_actionfield(field->data.u72.value,
1166 						      value,
1167 						      width, field_size);
1168 			break;
1169 		case VCAP_FIELD_U112:
1170 			vcap_copy_limited_actionfield(field->data.u112.value,
1171 						      value,
1172 						      width, field_size);
1173 			break;
1174 		case VCAP_FIELD_U128:
1175 			vcap_copy_limited_actionfield(field->data.u128.value,
1176 						      value,
1177 						      width, field_size);
1178 			break;
1179 		}
1180 	}
1181 }
1182 
vcap_copy_key_bit_field(struct vcap_u1_key * field,u8 * value,u8 * mask)1183 static void vcap_copy_key_bit_field(struct vcap_u1_key *field,
1184 				    u8 *value, u8 *mask)
1185 {
1186 	field->value = (*value) & 0x1;
1187 	field->mask = (*mask) & 0x1;
1188 }
1189 
vcap_copy_limited_keyfield(u8 * dstvalue,u8 * dstmask,u8 * srcvalue,u8 * srcmask,int width,int bytes)1190 static void vcap_copy_limited_keyfield(u8 *dstvalue, u8 *dstmask,
1191 				       u8 *srcvalue, u8 *srcmask,
1192 				       int width, int bytes)
1193 {
1194 	memcpy(dstvalue, srcvalue, bytes);
1195 	vcap_apply_width(dstvalue, width, bytes);
1196 	memcpy(dstmask, srcmask, bytes);
1197 	vcap_apply_width(dstmask, width, bytes);
1198 }
1199 
vcap_copy_to_client_keyfield(struct vcap_rule_internal * ri,struct vcap_client_keyfield * field,u8 * value,u8 * mask,u16 width)1200 static void vcap_copy_to_client_keyfield(struct vcap_rule_internal *ri,
1201 					 struct vcap_client_keyfield *field,
1202 					 u8 *value, u8 *mask, u16 width)
1203 {
1204 	int field_size = keyfield_size_table[field->ctrl.type] / 2;
1205 
1206 	if (ri->admin->w32be) {
1207 		switch (field->ctrl.type) {
1208 		case VCAP_FIELD_BIT:
1209 			vcap_copy_key_bit_field(&field->data.u1, value, mask);
1210 			break;
1211 		case VCAP_FIELD_U32:
1212 			vcap_copy_limited_keyfield((u8 *)&field->data.u32.value,
1213 						   (u8 *)&field->data.u32.mask,
1214 						   value, mask,
1215 						   width, field_size);
1216 			break;
1217 		case VCAP_FIELD_U48:
1218 			vcap_copy_from_w32be(field->data.u48.value, value,
1219 					     field_size, width);
1220 			vcap_copy_from_w32be(field->data.u48.mask,  mask,
1221 					     field_size, width);
1222 			break;
1223 		case VCAP_FIELD_U56:
1224 			vcap_copy_from_w32be(field->data.u56.value, value,
1225 					     field_size, width);
1226 			vcap_copy_from_w32be(field->data.u56.mask,  mask,
1227 					     field_size, width);
1228 			break;
1229 		case VCAP_FIELD_U64:
1230 			vcap_copy_from_w32be(field->data.u64.value, value,
1231 					     field_size, width);
1232 			vcap_copy_from_w32be(field->data.u64.mask,  mask,
1233 					     field_size, width);
1234 			break;
1235 		case VCAP_FIELD_U72:
1236 			vcap_copy_from_w32be(field->data.u72.value, value,
1237 					     field_size, width);
1238 			vcap_copy_from_w32be(field->data.u72.mask,  mask,
1239 					     field_size, width);
1240 			break;
1241 		case VCAP_FIELD_U112:
1242 			vcap_copy_from_w32be(field->data.u112.value, value,
1243 					     field_size, width);
1244 			vcap_copy_from_w32be(field->data.u112.mask,  mask,
1245 					     field_size, width);
1246 			break;
1247 		case VCAP_FIELD_U128:
1248 			vcap_copy_from_w32be(field->data.u128.value, value,
1249 					     field_size, width);
1250 			vcap_copy_from_w32be(field->data.u128.mask,  mask,
1251 					     field_size, width);
1252 			break;
1253 		}
1254 	} else {
1255 		switch (field->ctrl.type) {
1256 		case VCAP_FIELD_BIT:
1257 			vcap_copy_key_bit_field(&field->data.u1, value, mask);
1258 			break;
1259 		case VCAP_FIELD_U32:
1260 			vcap_copy_limited_keyfield((u8 *)&field->data.u32.value,
1261 						   (u8 *)&field->data.u32.mask,
1262 						   value, mask,
1263 						   width, field_size);
1264 			break;
1265 		case VCAP_FIELD_U48:
1266 			vcap_copy_limited_keyfield(field->data.u48.value,
1267 						   field->data.u48.mask,
1268 						   value, mask,
1269 						   width, field_size);
1270 			break;
1271 		case VCAP_FIELD_U56:
1272 			vcap_copy_limited_keyfield(field->data.u56.value,
1273 						   field->data.u56.mask,
1274 						   value, mask,
1275 						   width, field_size);
1276 			break;
1277 		case VCAP_FIELD_U64:
1278 			vcap_copy_limited_keyfield(field->data.u64.value,
1279 						   field->data.u64.mask,
1280 						   value, mask,
1281 						   width, field_size);
1282 			break;
1283 		case VCAP_FIELD_U72:
1284 			vcap_copy_limited_keyfield(field->data.u72.value,
1285 						   field->data.u72.mask,
1286 						   value, mask,
1287 						   width, field_size);
1288 			break;
1289 		case VCAP_FIELD_U112:
1290 			vcap_copy_limited_keyfield(field->data.u112.value,
1291 						   field->data.u112.mask,
1292 						   value, mask,
1293 						   width, field_size);
1294 			break;
1295 		case VCAP_FIELD_U128:
1296 			vcap_copy_limited_keyfield(field->data.u128.value,
1297 						   field->data.u128.mask,
1298 						   value, mask,
1299 						   width, field_size);
1300 			break;
1301 		}
1302 	}
1303 }
1304 
vcap_rule_alloc_keyfield(struct vcap_rule_internal * ri,const struct vcap_field * keyfield,enum vcap_key_field key,u8 * value,u8 * mask)1305 static void vcap_rule_alloc_keyfield(struct vcap_rule_internal *ri,
1306 				     const struct vcap_field *keyfield,
1307 				     enum vcap_key_field key,
1308 				     u8 *value, u8 *mask)
1309 {
1310 	struct vcap_client_keyfield *field;
1311 
1312 	field = kzalloc(sizeof(*field), GFP_KERNEL);
1313 	if (!field)
1314 		return;
1315 	INIT_LIST_HEAD(&field->ctrl.list);
1316 	field->ctrl.key = key;
1317 	field->ctrl.type = keyfield->type;
1318 	vcap_copy_to_client_keyfield(ri, field, value, mask, keyfield->width);
1319 	list_add_tail(&field->ctrl.list, &ri->data.keyfields);
1320 }
1321 
1322 /* Read key data from a VCAP address and discover if there is a rule keyset
1323  * here
1324  */
1325 static bool
vcap_verify_actionstream_actionset(struct vcap_control * vctrl,enum vcap_type vt,u32 * actionstream,enum vcap_actionfield_set actionset)1326 vcap_verify_actionstream_actionset(struct vcap_control *vctrl,
1327 				   enum vcap_type vt,
1328 				   u32 *actionstream,
1329 				   enum vcap_actionfield_set actionset)
1330 {
1331 	const struct vcap_typegroup *tgt;
1332 	const struct vcap_field *fields;
1333 	const struct vcap_set *info;
1334 
1335 	if (vcap_actionfield_count(vctrl, vt, actionset) == 0)
1336 		return false;
1337 
1338 	info = vcap_actionfieldset(vctrl, vt, actionset);
1339 	/* Check that the actionset is valid */
1340 	if (!info)
1341 		return false;
1342 
1343 	/* a type_id of value -1 means that there is no type field */
1344 	if (info->type_id == (u8)-1)
1345 		return true;
1346 
1347 	/* Get a valid typegroup for the specific actionset */
1348 	tgt = vcap_actionfield_typegroup(vctrl, vt, actionset);
1349 	if (!tgt)
1350 		return false;
1351 
1352 	fields = vcap_actionfields(vctrl, vt, actionset);
1353 	if (!fields)
1354 		return false;
1355 
1356 	/* Later this will be expanded with a check of the type id */
1357 	return true;
1358 }
1359 
1360 /* Find the subword width of the action typegroup that matches the stream data
1361  */
vcap_find_actionstream_typegroup_sw(struct vcap_control * vctrl,enum vcap_type vt,u32 * stream,int sw_max)1362 static int vcap_find_actionstream_typegroup_sw(struct vcap_control *vctrl,
1363 					       enum vcap_type vt, u32 *stream,
1364 					       int sw_max)
1365 {
1366 	const struct vcap_typegroup **tgt;
1367 	int sw_idx, res;
1368 
1369 	tgt = vctrl->vcaps[vt].actionfield_set_typegroups;
1370 	/* Try the longest subword match first */
1371 	for (sw_idx = vctrl->vcaps[vt].sw_count; sw_idx >= 0; sw_idx--) {
1372 		if (!tgt[sw_idx])
1373 			continue;
1374 		res = vcap_verify_typegroups(stream, vctrl->vcaps[vt].act_width,
1375 					     tgt[sw_idx], false, sw_max);
1376 		if (res == 0)
1377 			return sw_idx;
1378 	}
1379 	return -EINVAL;
1380 }
1381 
1382 /* Verify that the typegroup information, subword count, actionset and type id
1383  * are in sync and correct, return the actionset
1384  */
1385 static enum vcap_actionfield_set
vcap_find_actionstream_actionset(struct vcap_control * vctrl,enum vcap_type vt,u32 * stream,int sw_max)1386 vcap_find_actionstream_actionset(struct vcap_control *vctrl,
1387 				 enum vcap_type vt,
1388 				 u32 *stream,
1389 				 int sw_max)
1390 {
1391 	const struct vcap_set *actionfield_set;
1392 	int sw_count, idx;
1393 	bool res;
1394 
1395 	sw_count = vcap_find_actionstream_typegroup_sw(vctrl, vt, stream,
1396 						       sw_max);
1397 	if (sw_count < 0)
1398 		return sw_count;
1399 
1400 	actionfield_set = vctrl->vcaps[vt].actionfield_set;
1401 	for (idx = 0; idx < vctrl->vcaps[vt].actionfield_set_size; ++idx) {
1402 		if (actionfield_set[idx].sw_per_item != sw_count)
1403 			continue;
1404 
1405 		res = vcap_verify_actionstream_actionset(vctrl, vt,
1406 							 stream, idx);
1407 		if (res)
1408 			return idx;
1409 	}
1410 	return -EINVAL;
1411 }
1412 
1413 /* Store action value in an element in a list for the client */
vcap_rule_alloc_actionfield(struct vcap_rule_internal * ri,const struct vcap_field * actionfield,enum vcap_action_field action,u8 * value)1414 static void vcap_rule_alloc_actionfield(struct vcap_rule_internal *ri,
1415 					const struct vcap_field *actionfield,
1416 					enum vcap_action_field action,
1417 					u8 *value)
1418 {
1419 	struct vcap_client_actionfield *field;
1420 
1421 	field = kzalloc(sizeof(*field), GFP_KERNEL);
1422 	if (!field)
1423 		return;
1424 	INIT_LIST_HEAD(&field->ctrl.list);
1425 	field->ctrl.action = action;
1426 	field->ctrl.type = actionfield->type;
1427 	vcap_copy_to_client_actionfield(ri, field, value, actionfield->width);
1428 	list_add_tail(&field->ctrl.list, &ri->data.actionfields);
1429 }
1430 
vcap_decode_actionset(struct vcap_rule_internal * ri)1431 static int vcap_decode_actionset(struct vcap_rule_internal *ri)
1432 {
1433 	struct vcap_control *vctrl = ri->vctrl;
1434 	struct vcap_admin *admin = ri->admin;
1435 	const struct vcap_field *actionfield;
1436 	enum vcap_actionfield_set actionset;
1437 	enum vcap_type vt = admin->vtype;
1438 	const struct vcap_typegroup *tgt;
1439 	struct vcap_stream_iter iter;
1440 	int idx, res, actfield_count;
1441 	u32 *actstream;
1442 	u8 value[16];
1443 
1444 	actstream = admin->cache.actionstream;
1445 	res = vcap_find_actionstream_actionset(vctrl, vt, actstream, 0);
1446 	if (res < 0) {
1447 		pr_err("%s:%d: could not find valid actionset: %d\n",
1448 		       __func__, __LINE__, res);
1449 		return -EINVAL;
1450 	}
1451 	actionset = res;
1452 	actfield_count = vcap_actionfield_count(vctrl, vt, actionset);
1453 	actionfield = vcap_actionfields(vctrl, vt, actionset);
1454 	tgt = vcap_actionfield_typegroup(vctrl, vt, actionset);
1455 	/* Start decoding the stream */
1456 	for (idx = 0; idx < actfield_count; ++idx) {
1457 		if (actionfield[idx].width <= 0)
1458 			continue;
1459 		/* Get the action */
1460 		memset(value, 0, DIV_ROUND_UP(actionfield[idx].width, 8));
1461 		vcap_iter_init(&iter, vctrl->vcaps[vt].act_width, tgt,
1462 			       actionfield[idx].offset);
1463 		vcap_decode_field(actstream, &iter, actionfield[idx].width,
1464 				  value);
1465 		/* Skip if no bits are set */
1466 		if (vcap_bitarray_zero(actionfield[idx].width, value))
1467 			continue;
1468 		vcap_rule_alloc_actionfield(ri, &actionfield[idx], idx, value);
1469 		/* Later the action id will also be checked */
1470 	}
1471 	return vcap_set_rule_set_actionset((struct vcap_rule *)ri, actionset);
1472 }
1473 
vcap_decode_keyset(struct vcap_rule_internal * ri)1474 static int vcap_decode_keyset(struct vcap_rule_internal *ri)
1475 {
1476 	struct vcap_control *vctrl = ri->vctrl;
1477 	struct vcap_stream_iter kiter, miter;
1478 	struct vcap_admin *admin = ri->admin;
1479 	enum vcap_keyfield_set keysets[10];
1480 	const struct vcap_field *keyfield;
1481 	enum vcap_type vt = admin->vtype;
1482 	const struct vcap_typegroup *tgt;
1483 	struct vcap_keyset_list matches;
1484 	enum vcap_keyfield_set keyset;
1485 	int idx, res, keyfield_count;
1486 	u32 *maskstream;
1487 	u32 *keystream;
1488 	u8 value[16];
1489 	u8 mask[16];
1490 
1491 	keystream = admin->cache.keystream;
1492 	maskstream = admin->cache.maskstream;
1493 	matches.keysets = keysets;
1494 	matches.cnt = 0;
1495 	matches.max = ARRAY_SIZE(keysets);
1496 	res = vcap_find_keystream_keysets(vctrl, vt, keystream, maskstream,
1497 					  false, 0, &matches);
1498 	if (res < 0) {
1499 		pr_err("%s:%d: could not find valid keysets: %d\n",
1500 		       __func__, __LINE__, res);
1501 		return -EINVAL;
1502 	}
1503 	keyset = matches.keysets[0];
1504 	keyfield_count = vcap_keyfield_count(vctrl, vt, keyset);
1505 	keyfield = vcap_keyfields(vctrl, vt, keyset);
1506 	tgt = vcap_keyfield_typegroup(vctrl, vt, keyset);
1507 	/* Start decoding the streams */
1508 	for (idx = 0; idx < keyfield_count; ++idx) {
1509 		if (keyfield[idx].width <= 0)
1510 			continue;
1511 		/* First get the mask */
1512 		memset(mask, 0, DIV_ROUND_UP(keyfield[idx].width, 8));
1513 		vcap_iter_init(&miter, vctrl->vcaps[vt].sw_width, tgt,
1514 			       keyfield[idx].offset);
1515 		vcap_decode_field(maskstream, &miter, keyfield[idx].width,
1516 				  mask);
1517 		/* Skip if no mask bits are set */
1518 		if (vcap_bitarray_zero(keyfield[idx].width, mask))
1519 			continue;
1520 		/* Get the key */
1521 		memset(value, 0, DIV_ROUND_UP(keyfield[idx].width, 8));
1522 		vcap_iter_init(&kiter, vctrl->vcaps[vt].sw_width, tgt,
1523 			       keyfield[idx].offset);
1524 		vcap_decode_field(keystream, &kiter, keyfield[idx].width,
1525 				  value);
1526 		vcap_rule_alloc_keyfield(ri, &keyfield[idx], idx, value, mask);
1527 	}
1528 	return vcap_set_rule_set_keyset((struct vcap_rule *)ri, keyset);
1529 }
1530 
1531 /* Read VCAP content into the VCAP cache */
vcap_read_rule(struct vcap_rule_internal * ri)1532 static int vcap_read_rule(struct vcap_rule_internal *ri)
1533 {
1534 	struct vcap_admin *admin = ri->admin;
1535 	int sw_idx, ent_idx = 0, act_idx = 0;
1536 	u32 addr = ri->addr;
1537 
1538 	if (!ri->size || !ri->keyset_sw_regs || !ri->actionset_sw_regs) {
1539 		pr_err("%s:%d: rule is empty\n", __func__, __LINE__);
1540 		return -EINVAL;
1541 	}
1542 	vcap_erase_cache(ri);
1543 	/* Use the values in the streams to read the VCAP cache */
1544 	for (sw_idx = 0; sw_idx < ri->size; sw_idx++, addr++) {
1545 		ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_READ,
1546 				       VCAP_SEL_ALL, addr);
1547 		ri->vctrl->ops->cache_read(ri->ndev, admin,
1548 					   VCAP_SEL_ENTRY, ent_idx,
1549 					   ri->keyset_sw_regs);
1550 		ri->vctrl->ops->cache_read(ri->ndev, admin,
1551 					   VCAP_SEL_ACTION, act_idx,
1552 					   ri->actionset_sw_regs);
1553 		if (sw_idx == 0)
1554 			ri->vctrl->ops->cache_read(ri->ndev, admin,
1555 						   VCAP_SEL_COUNTER,
1556 						   ri->counter_id, 0);
1557 		ent_idx += ri->keyset_sw_regs;
1558 		act_idx += ri->actionset_sw_regs;
1559 	}
1560 	return 0;
1561 }
1562 
1563 /* Write VCAP cache content to the VCAP HW instance */
vcap_write_rule(struct vcap_rule_internal * ri)1564 static int vcap_write_rule(struct vcap_rule_internal *ri)
1565 {
1566 	struct vcap_admin *admin = ri->admin;
1567 	int sw_idx, ent_idx = 0, act_idx = 0;
1568 	u32 addr = ri->addr;
1569 
1570 	if (!ri->size || !ri->keyset_sw_regs || !ri->actionset_sw_regs) {
1571 		pr_err("%s:%d: rule is empty\n", __func__, __LINE__);
1572 		return -EINVAL;
1573 	}
1574 	/* Use the values in the streams to write the VCAP cache */
1575 	for (sw_idx = 0; sw_idx < ri->size; sw_idx++, addr++) {
1576 		ri->vctrl->ops->cache_write(ri->ndev, admin,
1577 					    VCAP_SEL_ENTRY, ent_idx,
1578 					    ri->keyset_sw_regs);
1579 		ri->vctrl->ops->cache_write(ri->ndev, admin,
1580 					    VCAP_SEL_ACTION, act_idx,
1581 					    ri->actionset_sw_regs);
1582 		ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_WRITE,
1583 				       VCAP_SEL_ALL, addr);
1584 		ent_idx += ri->keyset_sw_regs;
1585 		act_idx += ri->actionset_sw_regs;
1586 	}
1587 	return 0;
1588 }
1589 
vcap_write_counter(struct vcap_rule_internal * ri,struct vcap_counter * ctr)1590 static int vcap_write_counter(struct vcap_rule_internal *ri,
1591 			      struct vcap_counter *ctr)
1592 {
1593 	struct vcap_admin *admin = ri->admin;
1594 
1595 	admin->cache.counter = ctr->value;
1596 	admin->cache.sticky = ctr->sticky;
1597 	ri->vctrl->ops->cache_write(ri->ndev, admin, VCAP_SEL_COUNTER,
1598 				    ri->counter_id, 0);
1599 	ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_WRITE,
1600 			       VCAP_SEL_COUNTER, ri->addr);
1601 	return 0;
1602 }
1603 
1604 /* Convert a chain id to a VCAP lookup index */
vcap_chain_id_to_lookup(struct vcap_admin * admin,int cur_cid)1605 int vcap_chain_id_to_lookup(struct vcap_admin *admin, int cur_cid)
1606 {
1607 	int lookup_first = admin->vinst * admin->lookups_per_instance;
1608 	int lookup_last = lookup_first + admin->lookups_per_instance;
1609 	int cid_next = admin->first_cid + VCAP_CID_LOOKUP_SIZE;
1610 	int cid = admin->first_cid;
1611 	int lookup;
1612 
1613 	for (lookup = lookup_first; lookup < lookup_last; ++lookup,
1614 	     cid += VCAP_CID_LOOKUP_SIZE, cid_next += VCAP_CID_LOOKUP_SIZE)
1615 		if (cur_cid >= cid && cur_cid < cid_next)
1616 			return lookup;
1617 	return 0;
1618 }
1619 EXPORT_SYMBOL_GPL(vcap_chain_id_to_lookup);
1620 
1621 /* Lookup a vcap instance using chain id */
vcap_find_admin(struct vcap_control * vctrl,int cid)1622 struct vcap_admin *vcap_find_admin(struct vcap_control *vctrl, int cid)
1623 {
1624 	struct vcap_admin *admin;
1625 
1626 	if (vcap_api_check(vctrl))
1627 		return NULL;
1628 
1629 	list_for_each_entry(admin, &vctrl->list, list) {
1630 		if (cid >= admin->first_cid && cid <= admin->last_cid)
1631 			return admin;
1632 	}
1633 	return NULL;
1634 }
1635 EXPORT_SYMBOL_GPL(vcap_find_admin);
1636 
1637 /* Is this the last admin instance ordered by chain id and direction */
vcap_admin_is_last(struct vcap_control * vctrl,struct vcap_admin * admin,bool ingress)1638 static bool vcap_admin_is_last(struct vcap_control *vctrl,
1639 			       struct vcap_admin *admin,
1640 			       bool ingress)
1641 {
1642 	struct vcap_admin *iter, *last = NULL;
1643 	int max_cid = 0;
1644 
1645 	list_for_each_entry(iter, &vctrl->list, list) {
1646 		if (iter->first_cid > max_cid &&
1647 		    iter->ingress == ingress) {
1648 			last = iter;
1649 			max_cid = iter->first_cid;
1650 		}
1651 	}
1652 	if (!last)
1653 		return false;
1654 
1655 	return admin == last;
1656 }
1657 
1658 /* Calculate the value used for chaining VCAP rules */
vcap_chain_offset(struct vcap_control * vctrl,int from_cid,int to_cid)1659 int vcap_chain_offset(struct vcap_control *vctrl, int from_cid, int to_cid)
1660 {
1661 	int diff = to_cid - from_cid;
1662 
1663 	if (diff < 0) /* Wrong direction */
1664 		return diff;
1665 	to_cid %= VCAP_CID_LOOKUP_SIZE;
1666 	if (to_cid == 0)  /* Destination aligned to a lookup == no chaining */
1667 		return 0;
1668 	diff %= VCAP_CID_LOOKUP_SIZE;  /* Limit to a value within a lookup */
1669 	return diff;
1670 }
1671 EXPORT_SYMBOL_GPL(vcap_chain_offset);
1672 
1673 /* Is the next chain id in one of the following lookups
1674  * For now this does not support filters linked to other filters using
1675  * keys and actions. That will be added later.
1676  */
vcap_is_next_lookup(struct vcap_control * vctrl,int src_cid,int dst_cid)1677 bool vcap_is_next_lookup(struct vcap_control *vctrl, int src_cid, int dst_cid)
1678 {
1679 	struct vcap_admin *admin;
1680 	int next_cid;
1681 
1682 	if (vcap_api_check(vctrl))
1683 		return false;
1684 
1685 	/* The offset must be at least one lookup so round up one chain */
1686 	next_cid = roundup(src_cid + 1, VCAP_CID_LOOKUP_SIZE);
1687 
1688 	if (dst_cid < next_cid)
1689 		return false;
1690 
1691 	admin = vcap_find_admin(vctrl, dst_cid);
1692 	if (!admin)
1693 		return false;
1694 
1695 	return true;
1696 }
1697 EXPORT_SYMBOL_GPL(vcap_is_next_lookup);
1698 
1699 /* Check if there is room for a new rule */
vcap_rule_space(struct vcap_admin * admin,int size)1700 static int vcap_rule_space(struct vcap_admin *admin, int size)
1701 {
1702 	if (admin->last_used_addr - size < admin->first_valid_addr) {
1703 		pr_err("%s:%d: No room for rule size: %u, %u\n",
1704 		       __func__, __LINE__, size, admin->first_valid_addr);
1705 		return -ENOSPC;
1706 	}
1707 	return 0;
1708 }
1709 
1710 /* Add the keyset typefield to the list of rule keyfields */
vcap_add_type_keyfield(struct vcap_rule * rule)1711 static int vcap_add_type_keyfield(struct vcap_rule *rule)
1712 {
1713 	struct vcap_rule_internal *ri = to_intrule(rule);
1714 	enum vcap_keyfield_set keyset = rule->keyset;
1715 	enum vcap_type vt = ri->admin->vtype;
1716 	const struct vcap_field *fields;
1717 	const struct vcap_set *kset;
1718 	int ret = -EINVAL;
1719 
1720 	kset = vcap_keyfieldset(ri->vctrl, vt, keyset);
1721 	if (!kset)
1722 		return ret;
1723 	if (kset->type_id == (u8)-1)  /* No type field is needed */
1724 		return 0;
1725 
1726 	fields = vcap_keyfields(ri->vctrl, vt, keyset);
1727 	if (!fields)
1728 		return -EINVAL;
1729 	if (fields[VCAP_KF_TYPE].width > 1) {
1730 		ret = vcap_rule_add_key_u32(rule, VCAP_KF_TYPE,
1731 					    kset->type_id, 0xff);
1732 	} else {
1733 		if (kset->type_id)
1734 			ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE,
1735 						    VCAP_BIT_1);
1736 		else
1737 			ret = vcap_rule_add_key_bit(rule, VCAP_KF_TYPE,
1738 						    VCAP_BIT_0);
1739 	}
1740 	return 0;
1741 }
1742 
1743 /* Add the actionset typefield to the list of rule actionfields */
vcap_add_type_actionfield(struct vcap_rule * rule)1744 static int vcap_add_type_actionfield(struct vcap_rule *rule)
1745 {
1746 	enum vcap_actionfield_set actionset = rule->actionset;
1747 	struct vcap_rule_internal *ri = to_intrule(rule);
1748 	enum vcap_type vt = ri->admin->vtype;
1749 	const struct vcap_field *fields;
1750 	const struct vcap_set *aset;
1751 	int ret = -EINVAL;
1752 
1753 	aset = vcap_actionfieldset(ri->vctrl, vt, actionset);
1754 	if (!aset)
1755 		return ret;
1756 	if (aset->type_id == (u8)-1)  /* No type field is needed */
1757 		return 0;
1758 
1759 	fields = vcap_actionfields(ri->vctrl, vt, actionset);
1760 	if (!fields)
1761 		return -EINVAL;
1762 	if (fields[VCAP_AF_TYPE].width > 1) {
1763 		ret = vcap_rule_add_action_u32(rule, VCAP_AF_TYPE,
1764 					       aset->type_id);
1765 	} else {
1766 		if (aset->type_id)
1767 			ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE,
1768 						       VCAP_BIT_1);
1769 		else
1770 			ret = vcap_rule_add_action_bit(rule, VCAP_AF_TYPE,
1771 						       VCAP_BIT_0);
1772 	}
1773 	return ret;
1774 }
1775 
1776 /* Add a keyset to a keyset list */
vcap_keyset_list_add(struct vcap_keyset_list * keysetlist,enum vcap_keyfield_set keyset)1777 bool vcap_keyset_list_add(struct vcap_keyset_list *keysetlist,
1778 			  enum vcap_keyfield_set keyset)
1779 {
1780 	int idx;
1781 
1782 	if (keysetlist->cnt < keysetlist->max) {
1783 		/* Avoid duplicates */
1784 		for (idx = 0; idx < keysetlist->cnt; ++idx)
1785 			if (keysetlist->keysets[idx] == keyset)
1786 				return keysetlist->cnt < keysetlist->max;
1787 		keysetlist->keysets[keysetlist->cnt++] = keyset;
1788 	}
1789 	return keysetlist->cnt < keysetlist->max;
1790 }
1791 EXPORT_SYMBOL_GPL(vcap_keyset_list_add);
1792 
1793 /* Add a actionset to a actionset list */
vcap_actionset_list_add(struct vcap_actionset_list * actionsetlist,enum vcap_actionfield_set actionset)1794 static bool vcap_actionset_list_add(struct vcap_actionset_list *actionsetlist,
1795 				    enum vcap_actionfield_set actionset)
1796 {
1797 	int idx;
1798 
1799 	if (actionsetlist->cnt < actionsetlist->max) {
1800 		/* Avoid duplicates */
1801 		for (idx = 0; idx < actionsetlist->cnt; ++idx)
1802 			if (actionsetlist->actionsets[idx] == actionset)
1803 				return actionsetlist->cnt < actionsetlist->max;
1804 		actionsetlist->actionsets[actionsetlist->cnt++] = actionset;
1805 	}
1806 	return actionsetlist->cnt < actionsetlist->max;
1807 }
1808 
1809 /* map keyset id to a string with the keyset name */
vcap_keyset_name(struct vcap_control * vctrl,enum vcap_keyfield_set keyset)1810 const char *vcap_keyset_name(struct vcap_control *vctrl,
1811 			     enum vcap_keyfield_set keyset)
1812 {
1813 	return vctrl->stats->keyfield_set_names[keyset];
1814 }
1815 EXPORT_SYMBOL_GPL(vcap_keyset_name);
1816 
1817 /* map key field id to a string with the key name */
vcap_keyfield_name(struct vcap_control * vctrl,enum vcap_key_field key)1818 const char *vcap_keyfield_name(struct vcap_control *vctrl,
1819 			       enum vcap_key_field key)
1820 {
1821 	return vctrl->stats->keyfield_names[key];
1822 }
1823 EXPORT_SYMBOL_GPL(vcap_keyfield_name);
1824 
1825 /* map actionset id to a string with the actionset name */
vcap_actionset_name(struct vcap_control * vctrl,enum vcap_actionfield_set actionset)1826 const char *vcap_actionset_name(struct vcap_control *vctrl,
1827 				enum vcap_actionfield_set actionset)
1828 {
1829 	return vctrl->stats->actionfield_set_names[actionset];
1830 }
1831 
1832 /* map action field id to a string with the action name */
vcap_actionfield_name(struct vcap_control * vctrl,enum vcap_action_field action)1833 const char *vcap_actionfield_name(struct vcap_control *vctrl,
1834 				  enum vcap_action_field action)
1835 {
1836 	return vctrl->stats->actionfield_names[action];
1837 }
1838 
1839 /* Return the keyfield that matches a key in a keyset */
1840 static const struct vcap_field *
vcap_find_keyset_keyfield(struct vcap_control * vctrl,enum vcap_type vtype,enum vcap_keyfield_set keyset,enum vcap_key_field key)1841 vcap_find_keyset_keyfield(struct vcap_control *vctrl,
1842 			  enum vcap_type vtype,
1843 			  enum vcap_keyfield_set keyset,
1844 			  enum vcap_key_field key)
1845 {
1846 	const struct vcap_field *fields;
1847 	int idx, count;
1848 
1849 	fields = vcap_keyfields(vctrl, vtype, keyset);
1850 	if (!fields)
1851 		return NULL;
1852 
1853 	/* Iterate the keyfields of the keyset */
1854 	count = vcap_keyfield_count(vctrl, vtype, keyset);
1855 	for (idx = 0; idx < count; ++idx) {
1856 		if (fields[idx].width == 0)
1857 			continue;
1858 
1859 		if (key == idx)
1860 			return &fields[idx];
1861 	}
1862 
1863 	return NULL;
1864 }
1865 
1866 /* Match a list of keys against the keysets available in a vcap type */
_vcap_rule_find_keysets(struct vcap_rule_internal * ri,struct vcap_keyset_list * matches)1867 static bool _vcap_rule_find_keysets(struct vcap_rule_internal *ri,
1868 				    struct vcap_keyset_list *matches)
1869 {
1870 	const struct vcap_client_keyfield *ckf;
1871 	int keyset, found, keycount, map_size;
1872 	const struct vcap_field **map;
1873 	enum vcap_type vtype;
1874 
1875 	vtype = ri->admin->vtype;
1876 	map = ri->vctrl->vcaps[vtype].keyfield_set_map;
1877 	map_size = ri->vctrl->vcaps[vtype].keyfield_set_size;
1878 
1879 	/* Get a count of the keyfields we want to match */
1880 	keycount = 0;
1881 	list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
1882 		++keycount;
1883 
1884 	matches->cnt = 0;
1885 	/* Iterate the keysets of the VCAP */
1886 	for (keyset = 0; keyset < map_size; ++keyset) {
1887 		if (!map[keyset])
1888 			continue;
1889 
1890 		/* Iterate the keys in the rule */
1891 		found = 0;
1892 		list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
1893 			if (vcap_find_keyset_keyfield(ri->vctrl, vtype,
1894 						      keyset, ckf->ctrl.key))
1895 				++found;
1896 
1897 		/* Save the keyset if all keyfields were found */
1898 		if (found == keycount)
1899 			if (!vcap_keyset_list_add(matches, keyset))
1900 				/* bail out when the quota is filled */
1901 				break;
1902 	}
1903 
1904 	return matches->cnt > 0;
1905 }
1906 
1907 /* Match a list of keys against the keysets available in a vcap type */
vcap_rule_find_keysets(struct vcap_rule * rule,struct vcap_keyset_list * matches)1908 bool vcap_rule_find_keysets(struct vcap_rule *rule,
1909 			    struct vcap_keyset_list *matches)
1910 {
1911 	struct vcap_rule_internal *ri = to_intrule(rule);
1912 
1913 	return _vcap_rule_find_keysets(ri, matches);
1914 }
1915 EXPORT_SYMBOL_GPL(vcap_rule_find_keysets);
1916 
1917 /* Return the actionfield that matches a action in a actionset */
1918 static const struct vcap_field *
vcap_find_actionset_actionfield(struct vcap_control * vctrl,enum vcap_type vtype,enum vcap_actionfield_set actionset,enum vcap_action_field action)1919 vcap_find_actionset_actionfield(struct vcap_control *vctrl,
1920 				enum vcap_type vtype,
1921 				enum vcap_actionfield_set actionset,
1922 				enum vcap_action_field action)
1923 {
1924 	const struct vcap_field *fields;
1925 	int idx, count;
1926 
1927 	fields = vcap_actionfields(vctrl, vtype, actionset);
1928 	if (!fields)
1929 		return NULL;
1930 
1931 	/* Iterate the actionfields of the actionset */
1932 	count = vcap_actionfield_count(vctrl, vtype, actionset);
1933 	for (idx = 0; idx < count; ++idx) {
1934 		if (fields[idx].width == 0)
1935 			continue;
1936 
1937 		if (action == idx)
1938 			return &fields[idx];
1939 	}
1940 
1941 	return NULL;
1942 }
1943 
1944 /* Match a list of actions against the actionsets available in a vcap type */
vcap_rule_find_actionsets(struct vcap_rule_internal * ri,struct vcap_actionset_list * matches)1945 static bool vcap_rule_find_actionsets(struct vcap_rule_internal *ri,
1946 				      struct vcap_actionset_list *matches)
1947 {
1948 	int actionset, found, actioncount, map_size;
1949 	const struct vcap_client_actionfield *ckf;
1950 	const struct vcap_field **map;
1951 	enum vcap_type vtype;
1952 
1953 	vtype = ri->admin->vtype;
1954 	map = ri->vctrl->vcaps[vtype].actionfield_set_map;
1955 	map_size = ri->vctrl->vcaps[vtype].actionfield_set_size;
1956 
1957 	/* Get a count of the actionfields we want to match */
1958 	actioncount = 0;
1959 	list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list)
1960 		++actioncount;
1961 
1962 	matches->cnt = 0;
1963 	/* Iterate the actionsets of the VCAP */
1964 	for (actionset = 0; actionset < map_size; ++actionset) {
1965 		if (!map[actionset])
1966 			continue;
1967 
1968 		/* Iterate the actions in the rule */
1969 		found = 0;
1970 		list_for_each_entry(ckf, &ri->data.actionfields, ctrl.list)
1971 			if (vcap_find_actionset_actionfield(ri->vctrl, vtype,
1972 							    actionset,
1973 							    ckf->ctrl.action))
1974 				++found;
1975 
1976 		/* Save the actionset if all actionfields were found */
1977 		if (found == actioncount)
1978 			if (!vcap_actionset_list_add(matches, actionset))
1979 				/* bail out when the quota is filled */
1980 				break;
1981 	}
1982 
1983 	return matches->cnt > 0;
1984 }
1985 
1986 /* Validate a rule with respect to available port keys */
vcap_val_rule(struct vcap_rule * rule,u16 l3_proto)1987 int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto)
1988 {
1989 	struct vcap_rule_internal *ri = to_intrule(rule);
1990 	struct vcap_keyset_list matches = {};
1991 	enum vcap_keyfield_set keysets[10];
1992 	int ret;
1993 
1994 	ret = vcap_api_check(ri->vctrl);
1995 	if (ret)
1996 		return ret;
1997 	if (!ri->admin) {
1998 		ri->data.exterr = VCAP_ERR_NO_ADMIN;
1999 		return -EINVAL;
2000 	}
2001 	if (!ri->ndev) {
2002 		ri->data.exterr = VCAP_ERR_NO_NETDEV;
2003 		return -EINVAL;
2004 	}
2005 
2006 	matches.keysets = keysets;
2007 	matches.max = ARRAY_SIZE(keysets);
2008 	if (ri->data.keyset == VCAP_KFS_NO_VALUE) {
2009 		/* Iterate over rule keyfields and select keysets that fits */
2010 		if (!_vcap_rule_find_keysets(ri, &matches)) {
2011 			ri->data.exterr = VCAP_ERR_NO_KEYSET_MATCH;
2012 			return -EINVAL;
2013 		}
2014 	} else {
2015 		/* prepare for keyset validation */
2016 		keysets[0] = ri->data.keyset;
2017 		matches.cnt = 1;
2018 	}
2019 
2020 	/* Pick a keyset that is supported in the port lookups */
2021 	ret = ri->vctrl->ops->validate_keyset(ri->ndev, ri->admin, rule,
2022 					      &matches, l3_proto);
2023 	if (ret < 0) {
2024 		pr_err("%s:%d: keyset validation failed: %d\n",
2025 		       __func__, __LINE__, ret);
2026 		ri->data.exterr = VCAP_ERR_NO_PORT_KEYSET_MATCH;
2027 		return ret;
2028 	}
2029 	/* use the keyset that is supported in the port lookups */
2030 	ret = vcap_set_rule_set_keyset(rule, ret);
2031 	if (ret < 0) {
2032 		pr_err("%s:%d: keyset was not updated: %d\n",
2033 		       __func__, __LINE__, ret);
2034 		return ret;
2035 	}
2036 	if (ri->data.actionset == VCAP_AFS_NO_VALUE) {
2037 		struct vcap_actionset_list matches = {};
2038 		enum vcap_actionfield_set actionsets[10];
2039 
2040 		matches.actionsets = actionsets;
2041 		matches.max = ARRAY_SIZE(actionsets);
2042 
2043 		/* Find an actionset that fits the rule actions */
2044 		if (!vcap_rule_find_actionsets(ri, &matches)) {
2045 			ri->data.exterr = VCAP_ERR_NO_ACTIONSET_MATCH;
2046 			return -EINVAL;
2047 		}
2048 		ret = vcap_set_rule_set_actionset(rule, actionsets[0]);
2049 		if (ret < 0) {
2050 			pr_err("%s:%d: actionset was not updated: %d\n",
2051 			       __func__, __LINE__, ret);
2052 			return ret;
2053 		}
2054 	}
2055 	vcap_add_type_keyfield(rule);
2056 	vcap_add_type_actionfield(rule);
2057 	/* Add default fields to this rule */
2058 	ri->vctrl->ops->add_default_fields(ri->ndev, ri->admin, rule);
2059 
2060 	/* Rule size is the maximum of the entry and action subword count */
2061 	ri->size = max(ri->keyset_sw, ri->actionset_sw);
2062 
2063 	/* Finally check if there is room for the rule in the VCAP */
2064 	return vcap_rule_space(ri->admin, ri->size);
2065 }
2066 EXPORT_SYMBOL_GPL(vcap_val_rule);
2067 
2068 /* Entries are sorted with increasing values of sort_key.
2069  * I.e. Lowest numerical sort_key is first in list.
2070  * In order to locate largest keys first in list we negate the key size with
2071  * (max_size - size).
2072  */
vcap_sort_key(u32 max_size,u32 size,u8 user,u16 prio)2073 static u32 vcap_sort_key(u32 max_size, u32 size, u8 user, u16 prio)
2074 {
2075 	return ((max_size - size) << 24) | (user << 16) | prio;
2076 }
2077 
2078 /* calculate the address of the next rule after this (lower address and prio) */
vcap_next_rule_addr(u32 addr,struct vcap_rule_internal * ri)2079 static u32 vcap_next_rule_addr(u32 addr, struct vcap_rule_internal *ri)
2080 {
2081 	return ((addr - ri->size) /  ri->size) * ri->size;
2082 }
2083 
2084 /* Assign a unique rule id and autogenerate one if id == 0 */
vcap_set_rule_id(struct vcap_rule_internal * ri)2085 static u32 vcap_set_rule_id(struct vcap_rule_internal *ri)
2086 {
2087 	if (ri->data.id != 0)
2088 		return ri->data.id;
2089 
2090 	for (u32 next_id = 1; next_id < ~0; ++next_id) {
2091 		if (!vcap_rule_exists(ri->vctrl, next_id)) {
2092 			ri->data.id = next_id;
2093 			break;
2094 		}
2095 	}
2096 	return ri->data.id;
2097 }
2098 
vcap_insert_rule(struct vcap_rule_internal * ri,struct vcap_rule_move * move)2099 static int vcap_insert_rule(struct vcap_rule_internal *ri,
2100 			    struct vcap_rule_move *move)
2101 {
2102 	int sw_count = ri->vctrl->vcaps[ri->admin->vtype].sw_count;
2103 	struct vcap_rule_internal *duprule, *iter, *elem = NULL;
2104 	struct vcap_admin *admin = ri->admin;
2105 	u32 addr;
2106 
2107 	ri->sort_key = vcap_sort_key(sw_count, ri->size, ri->data.user,
2108 				     ri->data.priority);
2109 
2110 	/* Insert the new rule in the list of rule based on the sort key
2111 	 * If the rule needs to be  inserted between existing rules then move
2112 	 * these rules to make room for the new rule and update their start
2113 	 * address.
2114 	 */
2115 	list_for_each_entry(iter, &admin->rules, list) {
2116 		if (ri->sort_key < iter->sort_key) {
2117 			elem = iter;
2118 			break;
2119 		}
2120 	}
2121 
2122 	if (!elem) {
2123 		ri->addr = vcap_next_rule_addr(admin->last_used_addr, ri);
2124 		admin->last_used_addr = ri->addr;
2125 
2126 		/* Add a copy of the rule to the VCAP list */
2127 		duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED);
2128 		if (IS_ERR(duprule))
2129 			return PTR_ERR(duprule);
2130 
2131 		list_add_tail(&duprule->list, &admin->rules);
2132 		return 0;
2133 	}
2134 
2135 	/* Reuse the space of the current rule */
2136 	addr = elem->addr + elem->size;
2137 	ri->addr = vcap_next_rule_addr(addr, ri);
2138 	addr = ri->addr;
2139 
2140 	/* Add a copy of the rule to the VCAP list */
2141 	duprule = vcap_dup_rule(ri, ri->state == VCAP_RS_DISABLED);
2142 	if (IS_ERR(duprule))
2143 		return PTR_ERR(duprule);
2144 
2145 	/* Add before the current entry */
2146 	list_add_tail(&duprule->list, &elem->list);
2147 
2148 	/* Update the current rule */
2149 	elem->addr = vcap_next_rule_addr(addr, elem);
2150 	addr = elem->addr;
2151 
2152 	/* Update the address in the remaining rules in the list */
2153 	list_for_each_entry_continue(elem, &admin->rules, list) {
2154 		elem->addr = vcap_next_rule_addr(addr, elem);
2155 		addr = elem->addr;
2156 	}
2157 
2158 	/* Update the move info */
2159 	move->addr = admin->last_used_addr;
2160 	move->count = ri->addr - addr;
2161 	move->offset = admin->last_used_addr - addr;
2162 	admin->last_used_addr = addr;
2163 	return 0;
2164 }
2165 
vcap_move_rules(struct vcap_rule_internal * ri,struct vcap_rule_move * move)2166 static void vcap_move_rules(struct vcap_rule_internal *ri,
2167 			    struct vcap_rule_move *move)
2168 {
2169 	ri->vctrl->ops->move(ri->ndev, ri->admin, move->addr,
2170 			 move->offset, move->count);
2171 }
2172 
2173 /* Check if the chain is already used to enable a VCAP lookup for this port */
vcap_is_chain_used(struct vcap_control * vctrl,struct net_device * ndev,int src_cid)2174 static bool vcap_is_chain_used(struct vcap_control *vctrl,
2175 			       struct net_device *ndev, int src_cid)
2176 {
2177 	struct vcap_enabled_port *eport;
2178 	struct vcap_admin *admin;
2179 
2180 	list_for_each_entry(admin, &vctrl->list, list)
2181 		list_for_each_entry(eport, &admin->enabled, list)
2182 			if (eport->src_cid == src_cid && eport->ndev == ndev)
2183 				return true;
2184 
2185 	return false;
2186 }
2187 
2188 /* Fetch the next chain in the enabled list for the port */
vcap_get_next_chain(struct vcap_control * vctrl,struct net_device * ndev,int dst_cid)2189 static int vcap_get_next_chain(struct vcap_control *vctrl,
2190 			       struct net_device *ndev,
2191 			       int dst_cid)
2192 {
2193 	struct vcap_enabled_port *eport;
2194 	struct vcap_admin *admin;
2195 
2196 	list_for_each_entry(admin, &vctrl->list, list) {
2197 		list_for_each_entry(eport, &admin->enabled, list) {
2198 			if (eport->ndev != ndev)
2199 				continue;
2200 			if (eport->src_cid == dst_cid)
2201 				return eport->dst_cid;
2202 		}
2203 	}
2204 
2205 	return 0;
2206 }
2207 
vcap_path_exist(struct vcap_control * vctrl,struct net_device * ndev,int dst_cid)2208 static bool vcap_path_exist(struct vcap_control *vctrl, struct net_device *ndev,
2209 			    int dst_cid)
2210 {
2211 	int cid = rounddown(dst_cid, VCAP_CID_LOOKUP_SIZE);
2212 	struct vcap_enabled_port *eport = NULL;
2213 	struct vcap_enabled_port *elem;
2214 	struct vcap_admin *admin;
2215 	int tmp;
2216 
2217 	if (cid == 0) /* Chain zero is always available */
2218 		return true;
2219 
2220 	/* Find first entry that starts from chain 0*/
2221 	list_for_each_entry(admin, &vctrl->list, list) {
2222 		list_for_each_entry(elem, &admin->enabled, list) {
2223 			if (elem->src_cid == 0 && elem->ndev == ndev) {
2224 				eport = elem;
2225 				break;
2226 			}
2227 		}
2228 		if (eport)
2229 			break;
2230 	}
2231 
2232 	if (!eport)
2233 		return false;
2234 
2235 	tmp = eport->dst_cid;
2236 	while (tmp != cid && tmp != 0)
2237 		tmp = vcap_get_next_chain(vctrl, ndev, tmp);
2238 
2239 	return !!tmp;
2240 }
2241 
2242 /* Internal clients can always store their rules in HW
2243  * External clients can store their rules if the chain is enabled all
2244  * the way from chain 0, otherwise the rule will be cached until
2245  * the chain is enabled.
2246  */
vcap_rule_set_state(struct vcap_rule_internal * ri)2247 static void vcap_rule_set_state(struct vcap_rule_internal *ri)
2248 {
2249 	if (ri->data.user <= VCAP_USER_QOS)
2250 		ri->state = VCAP_RS_PERMANENT;
2251 	else if (vcap_path_exist(ri->vctrl, ri->ndev, ri->data.vcap_chain_id))
2252 		ri->state = VCAP_RS_ENABLED;
2253 	else
2254 		ri->state = VCAP_RS_DISABLED;
2255 }
2256 
2257 /* Encode and write a validated rule to the VCAP */
vcap_add_rule(struct vcap_rule * rule)2258 int vcap_add_rule(struct vcap_rule *rule)
2259 {
2260 	struct vcap_rule_internal *ri = to_intrule(rule);
2261 	struct vcap_rule_move move = {0};
2262 	struct vcap_counter ctr = {0};
2263 	int ret;
2264 
2265 	ret = vcap_api_check(ri->vctrl);
2266 	if (ret)
2267 		return ret;
2268 	/* Insert the new rule in the list of vcap rules */
2269 	mutex_lock(&ri->admin->lock);
2270 
2271 	vcap_rule_set_state(ri);
2272 	ret = vcap_insert_rule(ri, &move);
2273 	if (ret < 0) {
2274 		pr_err("%s:%d: could not insert rule in vcap list: %d\n",
2275 		       __func__, __LINE__, ret);
2276 		goto out;
2277 	}
2278 	if (move.count > 0)
2279 		vcap_move_rules(ri, &move);
2280 
2281 	/* Set the counter to zero */
2282 	ret = vcap_write_counter(ri, &ctr);
2283 	if (ret)
2284 		goto out;
2285 
2286 	if (ri->state == VCAP_RS_DISABLED) {
2287 		/* Erase the rule area */
2288 		ri->vctrl->ops->init(ri->ndev, ri->admin, ri->addr, ri->size);
2289 		goto out;
2290 	}
2291 
2292 	vcap_erase_cache(ri);
2293 	ret = vcap_encode_rule(ri);
2294 	if (ret) {
2295 		pr_err("%s:%d: rule encoding error: %d\n", __func__, __LINE__, ret);
2296 		goto out;
2297 	}
2298 
2299 	ret = vcap_write_rule(ri);
2300 	if (ret) {
2301 		pr_err("%s:%d: rule write error: %d\n", __func__, __LINE__, ret);
2302 		goto out;
2303 	}
2304 out:
2305 	mutex_unlock(&ri->admin->lock);
2306 	return ret;
2307 }
2308 EXPORT_SYMBOL_GPL(vcap_add_rule);
2309 
2310 /* Allocate a new rule with the provided arguments */
vcap_alloc_rule(struct vcap_control * vctrl,struct net_device * ndev,int vcap_chain_id,enum vcap_user user,u16 priority,u32 id)2311 struct vcap_rule *vcap_alloc_rule(struct vcap_control *vctrl,
2312 				  struct net_device *ndev, int vcap_chain_id,
2313 				  enum vcap_user user, u16 priority,
2314 				  u32 id)
2315 {
2316 	struct vcap_rule_internal *ri;
2317 	struct vcap_admin *admin;
2318 	int err, maxsize;
2319 
2320 	err = vcap_api_check(vctrl);
2321 	if (err)
2322 		return ERR_PTR(err);
2323 	if (!ndev)
2324 		return ERR_PTR(-ENODEV);
2325 	/* Get the VCAP instance */
2326 	admin = vcap_find_admin(vctrl, vcap_chain_id);
2327 	if (!admin)
2328 		return ERR_PTR(-ENOENT);
2329 	/* Sanity check that this VCAP is supported on this platform */
2330 	if (vctrl->vcaps[admin->vtype].rows == 0)
2331 		return ERR_PTR(-EINVAL);
2332 
2333 	mutex_lock(&admin->lock);
2334 	/* Check if a rule with this id already exists */
2335 	if (vcap_rule_exists(vctrl, id)) {
2336 		err = -EINVAL;
2337 		goto out_unlock;
2338 	}
2339 
2340 	/* Check if there is room for the rule in the block(s) of the VCAP */
2341 	maxsize = vctrl->vcaps[admin->vtype].sw_count; /* worst case rule size */
2342 	if (vcap_rule_space(admin, maxsize)) {
2343 		err = -ENOSPC;
2344 		goto out_unlock;
2345 	}
2346 
2347 	/* Create a container for the rule and return it */
2348 	ri = kzalloc(sizeof(*ri), GFP_KERNEL);
2349 	if (!ri) {
2350 		err = -ENOMEM;
2351 		goto out_unlock;
2352 	}
2353 
2354 	ri->data.vcap_chain_id = vcap_chain_id;
2355 	ri->data.user = user;
2356 	ri->data.priority = priority;
2357 	ri->data.id = id;
2358 	ri->data.keyset = VCAP_KFS_NO_VALUE;
2359 	ri->data.actionset = VCAP_AFS_NO_VALUE;
2360 	INIT_LIST_HEAD(&ri->list);
2361 	INIT_LIST_HEAD(&ri->data.keyfields);
2362 	INIT_LIST_HEAD(&ri->data.actionfields);
2363 	ri->ndev = ndev;
2364 	ri->admin = admin; /* refer to the vcap instance */
2365 	ri->vctrl = vctrl; /* refer to the client */
2366 
2367 	if (vcap_set_rule_id(ri) == 0) {
2368 		err = -EINVAL;
2369 		goto out_free;
2370 	}
2371 
2372 	mutex_unlock(&admin->lock);
2373 	return (struct vcap_rule *)ri;
2374 
2375 out_free:
2376 	kfree(ri);
2377 out_unlock:
2378 	mutex_unlock(&admin->lock);
2379 	return ERR_PTR(err);
2380 
2381 }
2382 EXPORT_SYMBOL_GPL(vcap_alloc_rule);
2383 
2384 /* Free mem of a rule owned by client after the rule as been added to the VCAP */
vcap_free_rule(struct vcap_rule * rule)2385 void vcap_free_rule(struct vcap_rule *rule)
2386 {
2387 	struct vcap_rule_internal *ri = to_intrule(rule);
2388 	struct vcap_client_actionfield *caf, *next_caf;
2389 	struct vcap_client_keyfield *ckf, *next_ckf;
2390 
2391 	/* Deallocate the list of keys and actions */
2392 	list_for_each_entry_safe(ckf, next_ckf, &ri->data.keyfields, ctrl.list) {
2393 		list_del(&ckf->ctrl.list);
2394 		kfree(ckf);
2395 	}
2396 	list_for_each_entry_safe(caf, next_caf, &ri->data.actionfields, ctrl.list) {
2397 		list_del(&caf->ctrl.list);
2398 		kfree(caf);
2399 	}
2400 	/* Deallocate the rule */
2401 	kfree(rule);
2402 }
2403 EXPORT_SYMBOL_GPL(vcap_free_rule);
2404 
2405 /* Decode a rule from the VCAP cache and return a copy */
vcap_decode_rule(struct vcap_rule_internal * elem)2406 struct vcap_rule *vcap_decode_rule(struct vcap_rule_internal *elem)
2407 {
2408 	struct vcap_rule_internal *ri;
2409 	int err;
2410 
2411 	ri = vcap_dup_rule(elem, elem->state == VCAP_RS_DISABLED);
2412 	if (IS_ERR(ri))
2413 		return ERR_CAST(ri);
2414 
2415 	if (ri->state == VCAP_RS_DISABLED)
2416 		goto out;
2417 
2418 	err = vcap_read_rule(ri);
2419 	if (err)
2420 		return ERR_PTR(err);
2421 
2422 	err = vcap_decode_keyset(ri);
2423 	if (err)
2424 		return ERR_PTR(err);
2425 
2426 	err = vcap_decode_actionset(ri);
2427 	if (err)
2428 		return ERR_PTR(err);
2429 
2430 out:
2431 	return &ri->data;
2432 }
2433 
vcap_get_rule(struct vcap_control * vctrl,u32 id)2434 struct vcap_rule *vcap_get_rule(struct vcap_control *vctrl, u32 id)
2435 {
2436 	struct vcap_rule_internal *elem;
2437 	struct vcap_rule *rule;
2438 	int err;
2439 
2440 	err = vcap_api_check(vctrl);
2441 	if (err)
2442 		return ERR_PTR(err);
2443 
2444 	elem = vcap_get_locked_rule(vctrl, id);
2445 	if (!elem)
2446 		return ERR_PTR(-ENOENT);
2447 
2448 	rule = vcap_decode_rule(elem);
2449 	mutex_unlock(&elem->admin->lock);
2450 	return rule;
2451 }
2452 EXPORT_SYMBOL_GPL(vcap_get_rule);
2453 
2454 /* Update existing rule */
vcap_mod_rule(struct vcap_rule * rule)2455 int vcap_mod_rule(struct vcap_rule *rule)
2456 {
2457 	struct vcap_rule_internal *ri = to_intrule(rule);
2458 	struct vcap_counter ctr;
2459 	int err;
2460 
2461 	err = vcap_api_check(ri->vctrl);
2462 	if (err)
2463 		return err;
2464 
2465 	if (!vcap_get_locked_rule(ri->vctrl, ri->data.id))
2466 		return -ENOENT;
2467 
2468 	vcap_rule_set_state(ri);
2469 	if (ri->state == VCAP_RS_DISABLED)
2470 		goto out;
2471 
2472 	/* Encode the bitstreams to the VCAP cache */
2473 	vcap_erase_cache(ri);
2474 	err = vcap_encode_rule(ri);
2475 	if (err)
2476 		goto out;
2477 
2478 	err = vcap_write_rule(ri);
2479 	if (err)
2480 		goto out;
2481 
2482 	memset(&ctr, 0, sizeof(ctr));
2483 	err =  vcap_write_counter(ri, &ctr);
2484 
2485 out:
2486 	mutex_unlock(&ri->admin->lock);
2487 	return err;
2488 }
2489 EXPORT_SYMBOL_GPL(vcap_mod_rule);
2490 
2491 /* Return the alignment offset for a new rule address */
vcap_valid_rule_move(struct vcap_rule_internal * el,int offset)2492 static int vcap_valid_rule_move(struct vcap_rule_internal *el, int offset)
2493 {
2494 	return (el->addr + offset) % el->size;
2495 }
2496 
2497 /* Update the rule address with an offset */
vcap_adjust_rule_addr(struct vcap_rule_internal * el,int offset)2498 static void vcap_adjust_rule_addr(struct vcap_rule_internal *el, int offset)
2499 {
2500 	el->addr += offset;
2501 }
2502 
2503 /* Rules needs to be moved to fill the gap of the deleted rule */
vcap_fill_rule_gap(struct vcap_rule_internal * ri)2504 static int vcap_fill_rule_gap(struct vcap_rule_internal *ri)
2505 {
2506 	struct vcap_admin *admin = ri->admin;
2507 	struct vcap_rule_internal *elem;
2508 	struct vcap_rule_move move;
2509 	int gap = 0, offset = 0;
2510 
2511 	/* If the first rule is deleted: Move other rules to the top */
2512 	if (list_is_first(&ri->list, &admin->rules))
2513 		offset = admin->last_valid_addr + 1 - ri->addr - ri->size;
2514 
2515 	/* Locate gaps between odd size rules and adjust the move */
2516 	elem = ri;
2517 	list_for_each_entry_continue(elem, &admin->rules, list)
2518 		gap += vcap_valid_rule_move(elem, ri->size);
2519 
2520 	/* Update the address in the remaining rules in the list */
2521 	elem = ri;
2522 	list_for_each_entry_continue(elem, &admin->rules, list)
2523 		vcap_adjust_rule_addr(elem, ri->size + gap + offset);
2524 
2525 	/* Update the move info */
2526 	move.addr = admin->last_used_addr;
2527 	move.count = ri->addr - admin->last_used_addr - gap;
2528 	move.offset = -(ri->size + gap + offset);
2529 
2530 	/* Do the actual move operation */
2531 	vcap_move_rules(ri, &move);
2532 
2533 	return gap + offset;
2534 }
2535 
2536 /* Delete rule in a VCAP instance */
vcap_del_rule(struct vcap_control * vctrl,struct net_device * ndev,u32 id)2537 int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id)
2538 {
2539 	struct vcap_rule_internal *ri, *elem;
2540 	struct vcap_admin *admin;
2541 	int gap = 0, err;
2542 
2543 	/* This will later also handle rule moving */
2544 	if (!ndev)
2545 		return -ENODEV;
2546 	err = vcap_api_check(vctrl);
2547 	if (err)
2548 		return err;
2549 	/* Look for the rule id in all vcaps */
2550 	ri = vcap_get_locked_rule(vctrl, id);
2551 	if (!ri)
2552 		return -ENOENT;
2553 
2554 	admin = ri->admin;
2555 
2556 	if (ri->addr > admin->last_used_addr)
2557 		gap = vcap_fill_rule_gap(ri);
2558 
2559 	/* Delete the rule from the list of rules and the cache */
2560 	list_del(&ri->list);
2561 	vctrl->ops->init(ndev, admin, admin->last_used_addr, ri->size + gap);
2562 	vcap_free_rule(&ri->data);
2563 
2564 	/* Update the last used address, set to default when no rules */
2565 	if (list_empty(&admin->rules)) {
2566 		admin->last_used_addr = admin->last_valid_addr + 1;
2567 	} else {
2568 		elem = list_last_entry(&admin->rules, struct vcap_rule_internal,
2569 				       list);
2570 		admin->last_used_addr = elem->addr;
2571 	}
2572 
2573 	mutex_unlock(&admin->lock);
2574 	return err;
2575 }
2576 EXPORT_SYMBOL_GPL(vcap_del_rule);
2577 
2578 /* Delete all rules in the VCAP instance */
vcap_del_rules(struct vcap_control * vctrl,struct vcap_admin * admin)2579 int vcap_del_rules(struct vcap_control *vctrl, struct vcap_admin *admin)
2580 {
2581 	struct vcap_enabled_port *eport, *next_eport;
2582 	struct vcap_rule_internal *ri, *next_ri;
2583 	int ret = vcap_api_check(vctrl);
2584 
2585 	if (ret)
2586 		return ret;
2587 
2588 	mutex_lock(&admin->lock);
2589 	list_for_each_entry_safe(ri, next_ri, &admin->rules, list) {
2590 		vctrl->ops->init(ri->ndev, admin, ri->addr, ri->size);
2591 		list_del(&ri->list);
2592 		vcap_free_rule(&ri->data);
2593 	}
2594 	admin->last_used_addr = admin->last_valid_addr;
2595 
2596 	/* Remove list of enabled ports */
2597 	list_for_each_entry_safe(eport, next_eport, &admin->enabled, list) {
2598 		list_del(&eport->list);
2599 		kfree(eport);
2600 	}
2601 	mutex_unlock(&admin->lock);
2602 
2603 	return 0;
2604 }
2605 EXPORT_SYMBOL_GPL(vcap_del_rules);
2606 
2607 /* Find a client key field in a rule */
2608 static struct vcap_client_keyfield *
vcap_find_keyfield(struct vcap_rule * rule,enum vcap_key_field key)2609 vcap_find_keyfield(struct vcap_rule *rule, enum vcap_key_field key)
2610 {
2611 	struct vcap_rule_internal *ri = to_intrule(rule);
2612 	struct vcap_client_keyfield *ckf;
2613 
2614 	list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
2615 		if (ckf->ctrl.key == key)
2616 			return ckf;
2617 	return NULL;
2618 }
2619 
2620 /* Find information on a key field in a rule */
vcap_lookup_keyfield(struct vcap_rule * rule,enum vcap_key_field key)2621 const struct vcap_field *vcap_lookup_keyfield(struct vcap_rule *rule,
2622 					      enum vcap_key_field key)
2623 {
2624 	struct vcap_rule_internal *ri = to_intrule(rule);
2625 	enum vcap_keyfield_set keyset = rule->keyset;
2626 	enum vcap_type vt = ri->admin->vtype;
2627 	const struct vcap_field *fields;
2628 
2629 	if (keyset == VCAP_KFS_NO_VALUE)
2630 		return NULL;
2631 	fields = vcap_keyfields(ri->vctrl, vt, keyset);
2632 	if (!fields)
2633 		return NULL;
2634 	return &fields[key];
2635 }
2636 EXPORT_SYMBOL_GPL(vcap_lookup_keyfield);
2637 
2638 /* Check if the keyfield is already in the rule */
vcap_keyfield_unique(struct vcap_rule * rule,enum vcap_key_field key)2639 static bool vcap_keyfield_unique(struct vcap_rule *rule,
2640 				 enum vcap_key_field key)
2641 {
2642 	struct vcap_rule_internal *ri = to_intrule(rule);
2643 	const struct vcap_client_keyfield *ckf;
2644 
2645 	list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list)
2646 		if (ckf->ctrl.key == key)
2647 			return false;
2648 	return true;
2649 }
2650 
2651 /* Check if the keyfield is in the keyset */
vcap_keyfield_match_keyset(struct vcap_rule * rule,enum vcap_key_field key)2652 static bool vcap_keyfield_match_keyset(struct vcap_rule *rule,
2653 				       enum vcap_key_field key)
2654 {
2655 	struct vcap_rule_internal *ri = to_intrule(rule);
2656 	enum vcap_keyfield_set keyset = rule->keyset;
2657 	enum vcap_type vt = ri->admin->vtype;
2658 	const struct vcap_field *fields;
2659 
2660 	/* the field is accepted if the rule has no keyset yet */
2661 	if (keyset == VCAP_KFS_NO_VALUE)
2662 		return true;
2663 	fields = vcap_keyfields(ri->vctrl, vt, keyset);
2664 	if (!fields)
2665 		return false;
2666 	/* if there is a width there is a way */
2667 	return fields[key].width > 0;
2668 }
2669 
vcap_rule_add_key(struct vcap_rule * rule,enum vcap_key_field key,enum vcap_field_type ftype,struct vcap_client_keyfield_data * data)2670 static int vcap_rule_add_key(struct vcap_rule *rule,
2671 			     enum vcap_key_field key,
2672 			     enum vcap_field_type ftype,
2673 			     struct vcap_client_keyfield_data *data)
2674 {
2675 	struct vcap_rule_internal *ri = to_intrule(rule);
2676 	struct vcap_client_keyfield *field;
2677 
2678 	if (!vcap_keyfield_unique(rule, key)) {
2679 		pr_warn("%s:%d: keyfield %s is already in the rule\n",
2680 			__func__, __LINE__,
2681 			vcap_keyfield_name(ri->vctrl, key));
2682 		return -EINVAL;
2683 	}
2684 
2685 	if (!vcap_keyfield_match_keyset(rule, key)) {
2686 		pr_err("%s:%d: keyfield %s does not belong in the rule keyset\n",
2687 		       __func__, __LINE__,
2688 		       vcap_keyfield_name(ri->vctrl, key));
2689 		return -EINVAL;
2690 	}
2691 
2692 	field = kzalloc(sizeof(*field), GFP_KERNEL);
2693 	if (!field)
2694 		return -ENOMEM;
2695 	memcpy(&field->data, data, sizeof(field->data));
2696 	field->ctrl.key = key;
2697 	field->ctrl.type = ftype;
2698 	list_add_tail(&field->ctrl.list, &rule->keyfields);
2699 	return 0;
2700 }
2701 
vcap_rule_set_key_bitsize(struct vcap_u1_key * u1,enum vcap_bit val)2702 static void vcap_rule_set_key_bitsize(struct vcap_u1_key *u1, enum vcap_bit val)
2703 {
2704 	switch (val) {
2705 	case VCAP_BIT_0:
2706 		u1->value = 0;
2707 		u1->mask = 1;
2708 		break;
2709 	case VCAP_BIT_1:
2710 		u1->value = 1;
2711 		u1->mask = 1;
2712 		break;
2713 	case VCAP_BIT_ANY:
2714 		u1->value = 0;
2715 		u1->mask = 0;
2716 		break;
2717 	}
2718 }
2719 
2720 /* Add a bit key with value and mask to the rule */
vcap_rule_add_key_bit(struct vcap_rule * rule,enum vcap_key_field key,enum vcap_bit val)2721 int vcap_rule_add_key_bit(struct vcap_rule *rule, enum vcap_key_field key,
2722 			  enum vcap_bit val)
2723 {
2724 	struct vcap_client_keyfield_data data;
2725 
2726 	vcap_rule_set_key_bitsize(&data.u1, val);
2727 	return vcap_rule_add_key(rule, key, VCAP_FIELD_BIT, &data);
2728 }
2729 EXPORT_SYMBOL_GPL(vcap_rule_add_key_bit);
2730 
2731 /* Add a 32 bit key field with value and mask to the rule */
vcap_rule_add_key_u32(struct vcap_rule * rule,enum vcap_key_field key,u32 value,u32 mask)2732 int vcap_rule_add_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
2733 			  u32 value, u32 mask)
2734 {
2735 	struct vcap_client_keyfield_data data;
2736 
2737 	data.u32.value = value;
2738 	data.u32.mask = mask;
2739 	return vcap_rule_add_key(rule, key, VCAP_FIELD_U32, &data);
2740 }
2741 EXPORT_SYMBOL_GPL(vcap_rule_add_key_u32);
2742 
2743 /* Add a 48 bit key with value and mask to the rule */
vcap_rule_add_key_u48(struct vcap_rule * rule,enum vcap_key_field key,struct vcap_u48_key * fieldval)2744 int vcap_rule_add_key_u48(struct vcap_rule *rule, enum vcap_key_field key,
2745 			  struct vcap_u48_key *fieldval)
2746 {
2747 	struct vcap_client_keyfield_data data;
2748 
2749 	memcpy(&data.u48, fieldval, sizeof(data.u48));
2750 	return vcap_rule_add_key(rule, key, VCAP_FIELD_U48, &data);
2751 }
2752 EXPORT_SYMBOL_GPL(vcap_rule_add_key_u48);
2753 
2754 /* Add a 72 bit key with value and mask to the rule */
vcap_rule_add_key_u72(struct vcap_rule * rule,enum vcap_key_field key,struct vcap_u72_key * fieldval)2755 int vcap_rule_add_key_u72(struct vcap_rule *rule, enum vcap_key_field key,
2756 			  struct vcap_u72_key *fieldval)
2757 {
2758 	struct vcap_client_keyfield_data data;
2759 
2760 	memcpy(&data.u72, fieldval, sizeof(data.u72));
2761 	return vcap_rule_add_key(rule, key, VCAP_FIELD_U72, &data);
2762 }
2763 EXPORT_SYMBOL_GPL(vcap_rule_add_key_u72);
2764 
2765 /* Add a 128 bit key with value and mask to the rule */
vcap_rule_add_key_u128(struct vcap_rule * rule,enum vcap_key_field key,struct vcap_u128_key * fieldval)2766 int vcap_rule_add_key_u128(struct vcap_rule *rule, enum vcap_key_field key,
2767 			   struct vcap_u128_key *fieldval)
2768 {
2769 	struct vcap_client_keyfield_data data;
2770 
2771 	memcpy(&data.u128, fieldval, sizeof(data.u128));
2772 	return vcap_rule_add_key(rule, key, VCAP_FIELD_U128, &data);
2773 }
2774 EXPORT_SYMBOL_GPL(vcap_rule_add_key_u128);
2775 
vcap_rule_get_key_u32(struct vcap_rule * rule,enum vcap_key_field key,u32 * value,u32 * mask)2776 int vcap_rule_get_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
2777 			  u32 *value, u32 *mask)
2778 {
2779 	struct vcap_client_keyfield *ckf;
2780 
2781 	ckf = vcap_find_keyfield(rule, key);
2782 	if (!ckf)
2783 		return -ENOENT;
2784 
2785 	*value = ckf->data.u32.value;
2786 	*mask = ckf->data.u32.mask;
2787 
2788 	return 0;
2789 }
2790 EXPORT_SYMBOL_GPL(vcap_rule_get_key_u32);
2791 
2792 /* Find a client action field in a rule */
2793 struct vcap_client_actionfield *
vcap_find_actionfield(struct vcap_rule * rule,enum vcap_action_field act)2794 vcap_find_actionfield(struct vcap_rule *rule, enum vcap_action_field act)
2795 {
2796 	struct vcap_rule_internal *ri = (struct vcap_rule_internal *)rule;
2797 	struct vcap_client_actionfield *caf;
2798 
2799 	list_for_each_entry(caf, &ri->data.actionfields, ctrl.list)
2800 		if (caf->ctrl.action == act)
2801 			return caf;
2802 	return NULL;
2803 }
2804 EXPORT_SYMBOL_GPL(vcap_find_actionfield);
2805 
2806 /* Check if the actionfield is already in the rule */
vcap_actionfield_unique(struct vcap_rule * rule,enum vcap_action_field act)2807 static bool vcap_actionfield_unique(struct vcap_rule *rule,
2808 				    enum vcap_action_field act)
2809 {
2810 	struct vcap_rule_internal *ri = to_intrule(rule);
2811 	const struct vcap_client_actionfield *caf;
2812 
2813 	list_for_each_entry(caf, &ri->data.actionfields, ctrl.list)
2814 		if (caf->ctrl.action == act)
2815 			return false;
2816 	return true;
2817 }
2818 
2819 /* Check if the actionfield is in the actionset */
vcap_actionfield_match_actionset(struct vcap_rule * rule,enum vcap_action_field action)2820 static bool vcap_actionfield_match_actionset(struct vcap_rule *rule,
2821 					     enum vcap_action_field action)
2822 {
2823 	enum vcap_actionfield_set actionset = rule->actionset;
2824 	struct vcap_rule_internal *ri = to_intrule(rule);
2825 	enum vcap_type vt = ri->admin->vtype;
2826 	const struct vcap_field *fields;
2827 
2828 	/* the field is accepted if the rule has no actionset yet */
2829 	if (actionset == VCAP_AFS_NO_VALUE)
2830 		return true;
2831 	fields = vcap_actionfields(ri->vctrl, vt, actionset);
2832 	if (!fields)
2833 		return false;
2834 	/* if there is a width there is a way */
2835 	return fields[action].width > 0;
2836 }
2837 
vcap_rule_add_action(struct vcap_rule * rule,enum vcap_action_field action,enum vcap_field_type ftype,struct vcap_client_actionfield_data * data)2838 static int vcap_rule_add_action(struct vcap_rule *rule,
2839 				enum vcap_action_field action,
2840 				enum vcap_field_type ftype,
2841 				struct vcap_client_actionfield_data *data)
2842 {
2843 	struct vcap_rule_internal *ri = to_intrule(rule);
2844 	struct vcap_client_actionfield *field;
2845 
2846 	if (!vcap_actionfield_unique(rule, action)) {
2847 		pr_warn("%s:%d: actionfield %s is already in the rule\n",
2848 			__func__, __LINE__,
2849 			vcap_actionfield_name(ri->vctrl, action));
2850 		return -EINVAL;
2851 	}
2852 
2853 	if (!vcap_actionfield_match_actionset(rule, action)) {
2854 		pr_err("%s:%d: actionfield %s does not belong in the rule actionset\n",
2855 		       __func__, __LINE__,
2856 		       vcap_actionfield_name(ri->vctrl, action));
2857 		return -EINVAL;
2858 	}
2859 
2860 	field = kzalloc(sizeof(*field), GFP_KERNEL);
2861 	if (!field)
2862 		return -ENOMEM;
2863 	memcpy(&field->data, data, sizeof(field->data));
2864 	field->ctrl.action = action;
2865 	field->ctrl.type = ftype;
2866 	list_add_tail(&field->ctrl.list, &rule->actionfields);
2867 	return 0;
2868 }
2869 
vcap_rule_set_action_bitsize(struct vcap_u1_action * u1,enum vcap_bit val)2870 static void vcap_rule_set_action_bitsize(struct vcap_u1_action *u1,
2871 					 enum vcap_bit val)
2872 {
2873 	switch (val) {
2874 	case VCAP_BIT_0:
2875 		u1->value = 0;
2876 		break;
2877 	case VCAP_BIT_1:
2878 		u1->value = 1;
2879 		break;
2880 	case VCAP_BIT_ANY:
2881 		u1->value = 0;
2882 		break;
2883 	}
2884 }
2885 
2886 /* Add a bit action with value to the rule */
vcap_rule_add_action_bit(struct vcap_rule * rule,enum vcap_action_field action,enum vcap_bit val)2887 int vcap_rule_add_action_bit(struct vcap_rule *rule,
2888 			     enum vcap_action_field action,
2889 			     enum vcap_bit val)
2890 {
2891 	struct vcap_client_actionfield_data data;
2892 
2893 	vcap_rule_set_action_bitsize(&data.u1, val);
2894 	return vcap_rule_add_action(rule, action, VCAP_FIELD_BIT, &data);
2895 }
2896 EXPORT_SYMBOL_GPL(vcap_rule_add_action_bit);
2897 
2898 /* Add a 32 bit action field with value to the rule */
vcap_rule_add_action_u32(struct vcap_rule * rule,enum vcap_action_field action,u32 value)2899 int vcap_rule_add_action_u32(struct vcap_rule *rule,
2900 			     enum vcap_action_field action,
2901 			     u32 value)
2902 {
2903 	struct vcap_client_actionfield_data data;
2904 
2905 	data.u32.value = value;
2906 	return vcap_rule_add_action(rule, action, VCAP_FIELD_U32, &data);
2907 }
2908 EXPORT_SYMBOL_GPL(vcap_rule_add_action_u32);
2909 
2910 /* Add a 72 bit action field with value to the rule */
vcap_rule_add_action_u72(struct vcap_rule * rule,enum vcap_action_field action,struct vcap_u72_action * fieldval)2911 int vcap_rule_add_action_u72(struct vcap_rule *rule,
2912 			     enum vcap_action_field action,
2913 			     struct vcap_u72_action *fieldval)
2914 {
2915 	struct vcap_client_actionfield_data data;
2916 
2917 	memcpy(&data.u72, fieldval, sizeof(data.u72));
2918 	return vcap_rule_add_action(rule, action, VCAP_FIELD_U72, &data);
2919 }
2920 EXPORT_SYMBOL_GPL(vcap_rule_add_action_u72);
2921 
vcap_read_counter(struct vcap_rule_internal * ri,struct vcap_counter * ctr)2922 static int vcap_read_counter(struct vcap_rule_internal *ri,
2923 			     struct vcap_counter *ctr)
2924 {
2925 	struct vcap_admin *admin = ri->admin;
2926 
2927 	ri->vctrl->ops->update(ri->ndev, admin, VCAP_CMD_READ, VCAP_SEL_COUNTER,
2928 			       ri->addr);
2929 	ri->vctrl->ops->cache_read(ri->ndev, admin, VCAP_SEL_COUNTER,
2930 				   ri->counter_id, 0);
2931 	ctr->value = admin->cache.counter;
2932 	ctr->sticky = admin->cache.sticky;
2933 	return 0;
2934 }
2935 
2936 /* Copy to host byte order */
vcap_netbytes_copy(u8 * dst,u8 * src,int count)2937 void vcap_netbytes_copy(u8 *dst, u8 *src, int count)
2938 {
2939 	int idx;
2940 
2941 	for (idx = 0; idx < count; ++idx, ++dst)
2942 		*dst = src[count - idx - 1];
2943 }
2944 EXPORT_SYMBOL_GPL(vcap_netbytes_copy);
2945 
2946 /* Convert validation error code into tc extack error message */
vcap_set_tc_exterr(struct flow_cls_offload * fco,struct vcap_rule * vrule)2947 void vcap_set_tc_exterr(struct flow_cls_offload *fco, struct vcap_rule *vrule)
2948 {
2949 	switch (vrule->exterr) {
2950 	case VCAP_ERR_NONE:
2951 		break;
2952 	case VCAP_ERR_NO_ADMIN:
2953 		NL_SET_ERR_MSG_MOD(fco->common.extack,
2954 				   "Missing VCAP instance");
2955 		break;
2956 	case VCAP_ERR_NO_NETDEV:
2957 		NL_SET_ERR_MSG_MOD(fco->common.extack,
2958 				   "Missing network interface");
2959 		break;
2960 	case VCAP_ERR_NO_KEYSET_MATCH:
2961 		NL_SET_ERR_MSG_MOD(fco->common.extack,
2962 				   "No keyset matched the filter keys");
2963 		break;
2964 	case VCAP_ERR_NO_ACTIONSET_MATCH:
2965 		NL_SET_ERR_MSG_MOD(fco->common.extack,
2966 				   "No actionset matched the filter actions");
2967 		break;
2968 	case VCAP_ERR_NO_PORT_KEYSET_MATCH:
2969 		NL_SET_ERR_MSG_MOD(fco->common.extack,
2970 				   "No port keyset matched the filter keys");
2971 		break;
2972 	}
2973 }
2974 EXPORT_SYMBOL_GPL(vcap_set_tc_exterr);
2975 
2976 /* Write a rule to VCAP HW to enable it */
vcap_enable_rule(struct vcap_rule_internal * ri)2977 static int vcap_enable_rule(struct vcap_rule_internal *ri)
2978 {
2979 	struct vcap_client_actionfield *af, *naf;
2980 	struct vcap_client_keyfield *kf, *nkf;
2981 	int err;
2982 
2983 	vcap_erase_cache(ri);
2984 	err = vcap_encode_rule(ri);
2985 	if (err)
2986 		goto out;
2987 	err = vcap_write_rule(ri);
2988 	if (err)
2989 		goto out;
2990 
2991 	/* Deallocate the list of keys and actions */
2992 	list_for_each_entry_safe(kf, nkf, &ri->data.keyfields, ctrl.list) {
2993 		list_del(&kf->ctrl.list);
2994 		kfree(kf);
2995 	}
2996 	list_for_each_entry_safe(af, naf, &ri->data.actionfields, ctrl.list) {
2997 		list_del(&af->ctrl.list);
2998 		kfree(af);
2999 	}
3000 	ri->state = VCAP_RS_ENABLED;
3001 out:
3002 	return err;
3003 }
3004 
3005 /* Enable all disabled rules for a specific chain/port in the VCAP HW */
vcap_enable_rules(struct vcap_control * vctrl,struct net_device * ndev,int chain)3006 static int vcap_enable_rules(struct vcap_control *vctrl,
3007 			     struct net_device *ndev, int chain)
3008 {
3009 	int next_chain = chain + VCAP_CID_LOOKUP_SIZE;
3010 	struct vcap_rule_internal *ri;
3011 	struct vcap_admin *admin;
3012 	int err = 0;
3013 
3014 	list_for_each_entry(admin, &vctrl->list, list) {
3015 		if (!(chain >= admin->first_cid && chain <= admin->last_cid))
3016 			continue;
3017 
3018 		/* Found the admin, now find the offloadable rules */
3019 		mutex_lock(&admin->lock);
3020 		list_for_each_entry(ri, &admin->rules, list) {
3021 			/* Is the rule in the lookup defined by the chain */
3022 			if (!(ri->data.vcap_chain_id >= chain &&
3023 			      ri->data.vcap_chain_id < next_chain)) {
3024 				continue;
3025 			}
3026 
3027 			if (ri->ndev != ndev)
3028 				continue;
3029 
3030 			if (ri->state != VCAP_RS_DISABLED)
3031 				continue;
3032 
3033 			err = vcap_enable_rule(ri);
3034 			if (err)
3035 				break;
3036 		}
3037 		mutex_unlock(&admin->lock);
3038 		if (err)
3039 			break;
3040 	}
3041 	return err;
3042 }
3043 
3044 /* Read and erase a rule from VCAP HW to disable it */
vcap_disable_rule(struct vcap_rule_internal * ri)3045 static int vcap_disable_rule(struct vcap_rule_internal *ri)
3046 {
3047 	int err;
3048 
3049 	err = vcap_read_rule(ri);
3050 	if (err)
3051 		return err;
3052 	err = vcap_decode_keyset(ri);
3053 	if (err)
3054 		return err;
3055 	err = vcap_decode_actionset(ri);
3056 	if (err)
3057 		return err;
3058 
3059 	ri->state = VCAP_RS_DISABLED;
3060 	ri->vctrl->ops->init(ri->ndev, ri->admin, ri->addr, ri->size);
3061 	return 0;
3062 }
3063 
3064 /* Disable all enabled rules for a specific chain/port in the VCAP HW */
vcap_disable_rules(struct vcap_control * vctrl,struct net_device * ndev,int chain)3065 static int vcap_disable_rules(struct vcap_control *vctrl,
3066 			      struct net_device *ndev, int chain)
3067 {
3068 	struct vcap_rule_internal *ri;
3069 	struct vcap_admin *admin;
3070 	int err = 0;
3071 
3072 	list_for_each_entry(admin, &vctrl->list, list) {
3073 		if (!(chain >= admin->first_cid && chain <= admin->last_cid))
3074 			continue;
3075 
3076 		/* Found the admin, now find the rules on the chain */
3077 		mutex_lock(&admin->lock);
3078 		list_for_each_entry(ri, &admin->rules, list) {
3079 			if (ri->data.vcap_chain_id != chain)
3080 				continue;
3081 
3082 			if (ri->ndev != ndev)
3083 				continue;
3084 
3085 			if (ri->state != VCAP_RS_ENABLED)
3086 				continue;
3087 
3088 			err = vcap_disable_rule(ri);
3089 			if (err)
3090 				break;
3091 		}
3092 		mutex_unlock(&admin->lock);
3093 		if (err)
3094 			break;
3095 	}
3096 	return err;
3097 }
3098 
3099 /* Check if this port is already enabled for this VCAP instance */
vcap_is_enabled(struct vcap_control * vctrl,struct net_device * ndev,int dst_cid)3100 static bool vcap_is_enabled(struct vcap_control *vctrl, struct net_device *ndev,
3101 			    int dst_cid)
3102 {
3103 	struct vcap_enabled_port *eport;
3104 	struct vcap_admin *admin;
3105 
3106 	list_for_each_entry(admin, &vctrl->list, list)
3107 		list_for_each_entry(eport, &admin->enabled, list)
3108 			if (eport->dst_cid == dst_cid && eport->ndev == ndev)
3109 				return true;
3110 
3111 	return false;
3112 }
3113 
3114 /* Enable this port and chain id in a VCAP instance */
vcap_enable(struct vcap_control * vctrl,struct net_device * ndev,unsigned long cookie,int src_cid,int dst_cid)3115 static int vcap_enable(struct vcap_control *vctrl, struct net_device *ndev,
3116 		       unsigned long cookie, int src_cid, int dst_cid)
3117 {
3118 	struct vcap_enabled_port *eport;
3119 	struct vcap_admin *admin;
3120 
3121 	if (src_cid >= dst_cid)
3122 		return -EFAULT;
3123 
3124 	admin = vcap_find_admin(vctrl, dst_cid);
3125 	if (!admin)
3126 		return -ENOENT;
3127 
3128 	eport = kzalloc(sizeof(*eport), GFP_KERNEL);
3129 	if (!eport)
3130 		return -ENOMEM;
3131 
3132 	eport->ndev = ndev;
3133 	eport->cookie = cookie;
3134 	eport->src_cid = src_cid;
3135 	eport->dst_cid = dst_cid;
3136 	mutex_lock(&admin->lock);
3137 	list_add_tail(&eport->list, &admin->enabled);
3138 	mutex_unlock(&admin->lock);
3139 
3140 	if (vcap_path_exist(vctrl, ndev, src_cid)) {
3141 		/* Enable chained lookups */
3142 		while (dst_cid) {
3143 			admin = vcap_find_admin(vctrl, dst_cid);
3144 			if (!admin)
3145 				return -ENOENT;
3146 
3147 			vcap_enable_rules(vctrl, ndev, dst_cid);
3148 			dst_cid = vcap_get_next_chain(vctrl, ndev, dst_cid);
3149 		}
3150 	}
3151 	return 0;
3152 }
3153 
3154 /* Disable this port and chain id for a VCAP instance */
vcap_disable(struct vcap_control * vctrl,struct net_device * ndev,unsigned long cookie)3155 static int vcap_disable(struct vcap_control *vctrl, struct net_device *ndev,
3156 			unsigned long cookie)
3157 {
3158 	struct vcap_enabled_port *elem, *eport = NULL;
3159 	struct vcap_admin *found = NULL, *admin;
3160 	int dst_cid;
3161 
3162 	list_for_each_entry(admin, &vctrl->list, list) {
3163 		list_for_each_entry(elem, &admin->enabled, list) {
3164 			if (elem->cookie == cookie && elem->ndev == ndev) {
3165 				eport = elem;
3166 				found = admin;
3167 				break;
3168 			}
3169 		}
3170 		if (eport)
3171 			break;
3172 	}
3173 
3174 	if (!eport)
3175 		return -ENOENT;
3176 
3177 	/* Disable chained lookups */
3178 	dst_cid = eport->dst_cid;
3179 	while (dst_cid) {
3180 		admin = vcap_find_admin(vctrl, dst_cid);
3181 		if (!admin)
3182 			return -ENOENT;
3183 
3184 		vcap_disable_rules(vctrl, ndev, dst_cid);
3185 		dst_cid = vcap_get_next_chain(vctrl, ndev, dst_cid);
3186 	}
3187 
3188 	mutex_lock(&found->lock);
3189 	list_del(&eport->list);
3190 	mutex_unlock(&found->lock);
3191 	kfree(eport);
3192 	return 0;
3193 }
3194 
3195 /* Enable/Disable the VCAP instance lookups */
vcap_enable_lookups(struct vcap_control * vctrl,struct net_device * ndev,int src_cid,int dst_cid,unsigned long cookie,bool enable)3196 int vcap_enable_lookups(struct vcap_control *vctrl, struct net_device *ndev,
3197 			int src_cid, int dst_cid, unsigned long cookie,
3198 			bool enable)
3199 {
3200 	int err;
3201 
3202 	err = vcap_api_check(vctrl);
3203 	if (err)
3204 		return err;
3205 
3206 	if (!ndev)
3207 		return -ENODEV;
3208 
3209 	/* Source and destination must be the first chain in a lookup */
3210 	if (src_cid % VCAP_CID_LOOKUP_SIZE)
3211 		return -EFAULT;
3212 	if (dst_cid % VCAP_CID_LOOKUP_SIZE)
3213 		return -EFAULT;
3214 
3215 	if (enable) {
3216 		if (vcap_is_enabled(vctrl, ndev, dst_cid))
3217 			return -EADDRINUSE;
3218 		if (vcap_is_chain_used(vctrl, ndev, src_cid))
3219 			return -EADDRNOTAVAIL;
3220 		err = vcap_enable(vctrl, ndev, cookie, src_cid, dst_cid);
3221 	} else {
3222 		err = vcap_disable(vctrl, ndev, cookie);
3223 	}
3224 
3225 	return err;
3226 }
3227 EXPORT_SYMBOL_GPL(vcap_enable_lookups);
3228 
3229 /* Is this chain id the last lookup of all VCAPs */
vcap_is_last_chain(struct vcap_control * vctrl,int cid,bool ingress)3230 bool vcap_is_last_chain(struct vcap_control *vctrl, int cid, bool ingress)
3231 {
3232 	struct vcap_admin *admin;
3233 	int lookup;
3234 
3235 	if (vcap_api_check(vctrl))
3236 		return false;
3237 
3238 	admin = vcap_find_admin(vctrl, cid);
3239 	if (!admin)
3240 		return false;
3241 
3242 	if (!vcap_admin_is_last(vctrl, admin, ingress))
3243 		return false;
3244 
3245 	/* This must be the last lookup in this VCAP type */
3246 	lookup = vcap_chain_id_to_lookup(admin, cid);
3247 	return lookup == admin->lookups - 1;
3248 }
3249 EXPORT_SYMBOL_GPL(vcap_is_last_chain);
3250 
3251 /* Set a rule counter id (for certain vcaps only) */
vcap_rule_set_counter_id(struct vcap_rule * rule,u32 counter_id)3252 void vcap_rule_set_counter_id(struct vcap_rule *rule, u32 counter_id)
3253 {
3254 	struct vcap_rule_internal *ri = to_intrule(rule);
3255 
3256 	ri->counter_id = counter_id;
3257 }
3258 EXPORT_SYMBOL_GPL(vcap_rule_set_counter_id);
3259 
vcap_rule_set_counter(struct vcap_rule * rule,struct vcap_counter * ctr)3260 int vcap_rule_set_counter(struct vcap_rule *rule, struct vcap_counter *ctr)
3261 {
3262 	struct vcap_rule_internal *ri = to_intrule(rule);
3263 	int err;
3264 
3265 	err = vcap_api_check(ri->vctrl);
3266 	if (err)
3267 		return err;
3268 	if (!ctr) {
3269 		pr_err("%s:%d: counter is missing\n", __func__, __LINE__);
3270 		return -EINVAL;
3271 	}
3272 
3273 	mutex_lock(&ri->admin->lock);
3274 	err = vcap_write_counter(ri, ctr);
3275 	mutex_unlock(&ri->admin->lock);
3276 
3277 	return err;
3278 }
3279 EXPORT_SYMBOL_GPL(vcap_rule_set_counter);
3280 
vcap_rule_get_counter(struct vcap_rule * rule,struct vcap_counter * ctr)3281 int vcap_rule_get_counter(struct vcap_rule *rule, struct vcap_counter *ctr)
3282 {
3283 	struct vcap_rule_internal *ri = to_intrule(rule);
3284 	int err;
3285 
3286 	err = vcap_api_check(ri->vctrl);
3287 	if (err)
3288 		return err;
3289 	if (!ctr) {
3290 		pr_err("%s:%d: counter is missing\n", __func__, __LINE__);
3291 		return -EINVAL;
3292 	}
3293 
3294 	mutex_lock(&ri->admin->lock);
3295 	err = vcap_read_counter(ri, ctr);
3296 	mutex_unlock(&ri->admin->lock);
3297 
3298 	return err;
3299 }
3300 EXPORT_SYMBOL_GPL(vcap_rule_get_counter);
3301 
3302 /* Get a copy of a client key field */
vcap_rule_get_key(struct vcap_rule * rule,enum vcap_key_field key,struct vcap_client_keyfield * ckf)3303 static int vcap_rule_get_key(struct vcap_rule *rule,
3304 			     enum vcap_key_field key,
3305 			     struct vcap_client_keyfield *ckf)
3306 {
3307 	struct vcap_client_keyfield *field;
3308 
3309 	field = vcap_find_keyfield(rule, key);
3310 	if (!field)
3311 		return -EINVAL;
3312 	memcpy(ckf, field, sizeof(*ckf));
3313 	INIT_LIST_HEAD(&ckf->ctrl.list);
3314 	return 0;
3315 }
3316 
3317 /* Find a keyset having the same size as the provided rule, where the keyset
3318  * does not have a type id.
3319  */
vcap_rule_get_untyped_keyset(struct vcap_rule_internal * ri,struct vcap_keyset_list * matches)3320 static int vcap_rule_get_untyped_keyset(struct vcap_rule_internal *ri,
3321 					struct vcap_keyset_list *matches)
3322 {
3323 	struct vcap_control *vctrl = ri->vctrl;
3324 	enum vcap_type vt = ri->admin->vtype;
3325 	const struct vcap_set *keyfield_set;
3326 	int idx;
3327 
3328 	keyfield_set = vctrl->vcaps[vt].keyfield_set;
3329 	for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) {
3330 		if (keyfield_set[idx].sw_per_item == ri->keyset_sw &&
3331 		    keyfield_set[idx].type_id == (u8)-1) {
3332 			vcap_keyset_list_add(matches, idx);
3333 			return 0;
3334 		}
3335 	}
3336 	return -EINVAL;
3337 }
3338 
3339 /* Get the keysets that matches the rule key type/mask */
vcap_rule_get_keysets(struct vcap_rule_internal * ri,struct vcap_keyset_list * matches)3340 int vcap_rule_get_keysets(struct vcap_rule_internal *ri,
3341 			  struct vcap_keyset_list *matches)
3342 {
3343 	struct vcap_control *vctrl = ri->vctrl;
3344 	enum vcap_type vt = ri->admin->vtype;
3345 	const struct vcap_set *keyfield_set;
3346 	struct vcap_client_keyfield kf = {};
3347 	u32 value, mask;
3348 	int err, idx;
3349 
3350 	err = vcap_rule_get_key(&ri->data, VCAP_KF_TYPE, &kf);
3351 	if (err)
3352 		return vcap_rule_get_untyped_keyset(ri, matches);
3353 
3354 	if (kf.ctrl.type == VCAP_FIELD_BIT) {
3355 		value = kf.data.u1.value;
3356 		mask = kf.data.u1.mask;
3357 	} else if (kf.ctrl.type == VCAP_FIELD_U32) {
3358 		value = kf.data.u32.value;
3359 		mask = kf.data.u32.mask;
3360 	} else {
3361 		return -EINVAL;
3362 	}
3363 
3364 	keyfield_set = vctrl->vcaps[vt].keyfield_set;
3365 	for (idx = 0; idx < vctrl->vcaps[vt].keyfield_set_size; ++idx) {
3366 		if (keyfield_set[idx].sw_per_item != ri->keyset_sw)
3367 			continue;
3368 
3369 		if (keyfield_set[idx].type_id == (u8)-1) {
3370 			vcap_keyset_list_add(matches, idx);
3371 			continue;
3372 		}
3373 
3374 		if ((keyfield_set[idx].type_id & mask) == value)
3375 			vcap_keyset_list_add(matches, idx);
3376 	}
3377 	if (matches->cnt > 0)
3378 		return 0;
3379 
3380 	return -EINVAL;
3381 }
3382 
3383 /* Collect packet counts from all rules with the same cookie */
vcap_get_rule_count_by_cookie(struct vcap_control * vctrl,struct vcap_counter * ctr,u64 cookie)3384 int vcap_get_rule_count_by_cookie(struct vcap_control *vctrl,
3385 				  struct vcap_counter *ctr, u64 cookie)
3386 {
3387 	struct vcap_rule_internal *ri;
3388 	struct vcap_counter temp = {};
3389 	struct vcap_admin *admin;
3390 	int err;
3391 
3392 	err = vcap_api_check(vctrl);
3393 	if (err)
3394 		return err;
3395 
3396 	/* Iterate all rules in each VCAP instance */
3397 	list_for_each_entry(admin, &vctrl->list, list) {
3398 		mutex_lock(&admin->lock);
3399 		list_for_each_entry(ri, &admin->rules, list) {
3400 			if (ri->data.cookie != cookie)
3401 				continue;
3402 
3403 			err = vcap_read_counter(ri, &temp);
3404 			if (err)
3405 				goto unlock;
3406 			ctr->value += temp.value;
3407 
3408 			/* Reset the rule counter */
3409 			temp.value = 0;
3410 			temp.sticky = 0;
3411 			err = vcap_write_counter(ri, &temp);
3412 			if (err)
3413 				goto unlock;
3414 		}
3415 		mutex_unlock(&admin->lock);
3416 	}
3417 	return err;
3418 
3419 unlock:
3420 	mutex_unlock(&admin->lock);
3421 	return err;
3422 }
3423 EXPORT_SYMBOL_GPL(vcap_get_rule_count_by_cookie);
3424 
vcap_rule_mod_key(struct vcap_rule * rule,enum vcap_key_field key,enum vcap_field_type ftype,struct vcap_client_keyfield_data * data)3425 static int vcap_rule_mod_key(struct vcap_rule *rule,
3426 			     enum vcap_key_field key,
3427 			     enum vcap_field_type ftype,
3428 			     struct vcap_client_keyfield_data *data)
3429 {
3430 	struct vcap_client_keyfield *field;
3431 
3432 	field = vcap_find_keyfield(rule, key);
3433 	if (!field)
3434 		return vcap_rule_add_key(rule, key, ftype, data);
3435 	memcpy(&field->data, data, sizeof(field->data));
3436 	return 0;
3437 }
3438 
3439 /* Modify a 32 bit key field with value and mask in the rule */
vcap_rule_mod_key_u32(struct vcap_rule * rule,enum vcap_key_field key,u32 value,u32 mask)3440 int vcap_rule_mod_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
3441 			  u32 value, u32 mask)
3442 {
3443 	struct vcap_client_keyfield_data data;
3444 
3445 	data.u32.value = value;
3446 	data.u32.mask = mask;
3447 	return vcap_rule_mod_key(rule, key, VCAP_FIELD_U32, &data);
3448 }
3449 EXPORT_SYMBOL_GPL(vcap_rule_mod_key_u32);
3450 
3451 /* Remove a key field with value and mask in the rule */
vcap_rule_rem_key(struct vcap_rule * rule,enum vcap_key_field key)3452 int vcap_rule_rem_key(struct vcap_rule *rule, enum vcap_key_field key)
3453 {
3454 	struct vcap_rule_internal *ri = to_intrule(rule);
3455 	struct vcap_client_keyfield *field;
3456 
3457 	field = vcap_find_keyfield(rule, key);
3458 	if (!field) {
3459 		pr_err("%s:%d: key %s is not in the rule\n",
3460 		       __func__, __LINE__, vcap_keyfield_name(ri->vctrl, key));
3461 		return -EINVAL;
3462 	}
3463 	/* Deallocate the key field */
3464 	list_del(&field->ctrl.list);
3465 	kfree(field);
3466 	return 0;
3467 }
3468 EXPORT_SYMBOL_GPL(vcap_rule_rem_key);
3469 
vcap_rule_mod_action(struct vcap_rule * rule,enum vcap_action_field action,enum vcap_field_type ftype,struct vcap_client_actionfield_data * data)3470 static int vcap_rule_mod_action(struct vcap_rule *rule,
3471 				enum vcap_action_field action,
3472 				enum vcap_field_type ftype,
3473 				struct vcap_client_actionfield_data *data)
3474 {
3475 	struct vcap_client_actionfield *field;
3476 
3477 	field = vcap_find_actionfield(rule, action);
3478 	if (!field)
3479 		return vcap_rule_add_action(rule, action, ftype, data);
3480 	memcpy(&field->data, data, sizeof(field->data));
3481 	return 0;
3482 }
3483 
3484 /* Modify a 32 bit action field with value in the rule */
vcap_rule_mod_action_u32(struct vcap_rule * rule,enum vcap_action_field action,u32 value)3485 int vcap_rule_mod_action_u32(struct vcap_rule *rule,
3486 			     enum vcap_action_field action,
3487 			     u32 value)
3488 {
3489 	struct vcap_client_actionfield_data data;
3490 
3491 	data.u32.value = value;
3492 	return vcap_rule_mod_action(rule, action, VCAP_FIELD_U32, &data);
3493 }
3494 EXPORT_SYMBOL_GPL(vcap_rule_mod_action_u32);
3495 
3496 /* Drop keys in a keylist and any keys that are not supported by the keyset */
vcap_filter_rule_keys(struct vcap_rule * rule,enum vcap_key_field keylist[],int length,bool drop_unsupported)3497 int vcap_filter_rule_keys(struct vcap_rule *rule,
3498 			  enum vcap_key_field keylist[], int length,
3499 			  bool drop_unsupported)
3500 {
3501 	struct vcap_rule_internal *ri = to_intrule(rule);
3502 	struct vcap_client_keyfield *ckf, *next_ckf;
3503 	const struct vcap_field *fields;
3504 	enum vcap_key_field key;
3505 	int err = 0;
3506 	int idx;
3507 
3508 	if (length > 0) {
3509 		err = -EEXIST;
3510 		list_for_each_entry_safe(ckf, next_ckf,
3511 					 &ri->data.keyfields, ctrl.list) {
3512 			key = ckf->ctrl.key;
3513 			for (idx = 0; idx < length; ++idx)
3514 				if (key == keylist[idx]) {
3515 					list_del(&ckf->ctrl.list);
3516 					kfree(ckf);
3517 					idx++;
3518 					err = 0;
3519 				}
3520 		}
3521 	}
3522 	if (drop_unsupported) {
3523 		err = -EEXIST;
3524 		fields = vcap_keyfields(ri->vctrl, ri->admin->vtype,
3525 					rule->keyset);
3526 		if (!fields)
3527 			return err;
3528 		list_for_each_entry_safe(ckf, next_ckf,
3529 					 &ri->data.keyfields, ctrl.list) {
3530 			key = ckf->ctrl.key;
3531 			if (fields[key].width == 0) {
3532 				list_del(&ckf->ctrl.list);
3533 				kfree(ckf);
3534 				err = 0;
3535 			}
3536 		}
3537 	}
3538 	return err;
3539 }
3540 EXPORT_SYMBOL_GPL(vcap_filter_rule_keys);
3541 
3542 /* Select the keyset from the list that results in the smallest rule size */
3543 enum vcap_keyfield_set
vcap_select_min_rule_keyset(struct vcap_control * vctrl,enum vcap_type vtype,struct vcap_keyset_list * kslist)3544 vcap_select_min_rule_keyset(struct vcap_control *vctrl,
3545 			    enum vcap_type vtype,
3546 			    struct vcap_keyset_list *kslist)
3547 {
3548 	enum vcap_keyfield_set ret = VCAP_KFS_NO_VALUE;
3549 	const struct vcap_set *kset;
3550 	int max = 100, idx;
3551 
3552 	for (idx = 0; idx < kslist->cnt; ++idx) {
3553 		kset = vcap_keyfieldset(vctrl, vtype, kslist->keysets[idx]);
3554 		if (!kset)
3555 			continue;
3556 		if (kset->sw_per_item >= max)
3557 			continue;
3558 		max = kset->sw_per_item;
3559 		ret = kslist->keysets[idx];
3560 	}
3561 	return ret;
3562 }
3563 EXPORT_SYMBOL_GPL(vcap_select_min_rule_keyset);
3564 
3565 /* Make a full copy of an existing rule with a new rule id */
vcap_copy_rule(struct vcap_rule * erule)3566 struct vcap_rule *vcap_copy_rule(struct vcap_rule *erule)
3567 {
3568 	struct vcap_rule_internal *ri = to_intrule(erule);
3569 	struct vcap_client_actionfield *caf;
3570 	struct vcap_client_keyfield *ckf;
3571 	struct vcap_rule *rule;
3572 	int err;
3573 
3574 	err = vcap_api_check(ri->vctrl);
3575 	if (err)
3576 		return ERR_PTR(err);
3577 
3578 	rule = vcap_alloc_rule(ri->vctrl, ri->ndev, ri->data.vcap_chain_id,
3579 			       ri->data.user, ri->data.priority, 0);
3580 	if (IS_ERR(rule))
3581 		return rule;
3582 
3583 	list_for_each_entry(ckf, &ri->data.keyfields, ctrl.list) {
3584 		/* Add a key duplicate in the new rule */
3585 		err = vcap_rule_add_key(rule,
3586 					ckf->ctrl.key,
3587 					ckf->ctrl.type,
3588 					&ckf->data);
3589 		if (err)
3590 			goto err;
3591 	}
3592 
3593 	list_for_each_entry(caf, &ri->data.actionfields, ctrl.list) {
3594 		/* Add a action duplicate in the new rule */
3595 		err = vcap_rule_add_action(rule,
3596 					   caf->ctrl.action,
3597 					   caf->ctrl.type,
3598 					   &caf->data);
3599 		if (err)
3600 			goto err;
3601 	}
3602 	return rule;
3603 err:
3604 	vcap_free_rule(rule);
3605 	return ERR_PTR(err);
3606 }
3607 EXPORT_SYMBOL_GPL(vcap_copy_rule);
3608 
3609 #ifdef CONFIG_VCAP_KUNIT_TEST
3610 #include "vcap_api_kunit.c"
3611 #endif
3612