drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c

   1 // SPDX-License-Identifier: BSD-3-Clause
   2 /* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
   3  * Microchip VCAP API kunit test suite
   4  */
   5
   6 #include <kunit/test.h>
   7 #include "vcap_api.h"
   8 #include "vcap_api_client.h"
   9 #include "vcap_model_kunit.h"
  10
  11 /* First we have the test infrastructure that emulates the platform
  12  * implementation
  13  */
  14 #define TEST_BUF_CNT 100
  15 #define TEST_BUF_SZ  350
  16 #define STREAMWSIZE 64
  17
  18 static u32 test_updateaddr[STREAMWSIZE] = {};
  19 static int test_updateaddridx;
  20 static int test_cache_erase_count;
  21 static u32 test_init_start;
  22 static u32 test_init_count;
  23 static u32 test_hw_counter_id;
  24 static struct vcap_cache_data test_hw_cache;
  25 static struct net_device test_netdev = {};
  26 static int test_move_addr;
  27 static int test_move_offset;
  28 static int test_move_count;
  29
  30 /* Callback used by the VCAP API */
  31 static enum vcap_keyfield_set test_val_keyset(struct net_device *ndev,
  32                                               struct vcap_admin *admin,
  33                                               struct vcap_rule *rule,
  34                                               struct vcap_keyset_list *kslist,
  35                                               u16 l3_proto)
  36 {
  37         int idx;
  38
  39         if (kslist->cnt > 0) {
  40                 switch (admin->vtype) {
  41                 case VCAP_TYPE_IS0:
  42                         for (idx = 0; idx < kslist->cnt; idx++) {
  43                                 if (kslist->keysets[idx] == VCAP_KFS_ETAG)
  44                                         return kslist->keysets[idx];
  45                                 if (kslist->keysets[idx] == VCAP_KFS_PURE_5TUPLE_IP4)
  46                                         return kslist->keysets[idx];
  47                                 if (kslist->keysets[idx] == VCAP_KFS_NORMAL_5TUPLE_IP4)
  48                                         return kslist->keysets[idx];
  49                                 if (kslist->keysets[idx] == VCAP_KFS_NORMAL_7TUPLE)
  50                                         return kslist->keysets[idx];
  51                         }
  52                         break;
  53                 case VCAP_TYPE_IS2:
  54                         for (idx = 0; idx < kslist->cnt; idx++) {
  55                                 if (kslist->keysets[idx] == VCAP_KFS_MAC_ETYPE)
  56                                         return kslist->keysets[idx];
  57                                 if (kslist->keysets[idx] == VCAP_KFS_ARP)
  58                                         return kslist->keysets[idx];
  59                                 if (kslist->keysets[idx] == VCAP_KFS_IP_7TUPLE)
  60                                         return kslist->keysets[idx];
  61                         }
  62                         break;
  63                 default:
  64                         pr_info("%s:%d: no validation for VCAP %d\n",
  65                                 __func__, __LINE__, admin->vtype);
  66                         break;
  67                 }
  68         }
  69         return -EINVAL;
  70 }
  71
  72 /* Callback used by the VCAP API */
  73 static void test_add_def_fields(struct net_device *ndev,
  74                                 struct vcap_admin *admin,
  75                                 struct vcap_rule *rule)
  76 {
  77         if (admin->vinst == 0 || admin->vinst == 2)
  78                 vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1);
  79         else
  80                 vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0);
  81 }
  82
  83 /* Callback used by the VCAP API */
  84 static void test_cache_erase(struct vcap_admin *admin)
  85 {
  86         if (test_cache_erase_count) {
  87                 memset(admin->cache.keystream, 0, test_cache_erase_count);
  88                 memset(admin->cache.maskstream, 0, test_cache_erase_count);
  89                 memset(admin->cache.actionstream, 0, test_cache_erase_count);
  90                 test_cache_erase_count = 0;
  91         }
  92 }
  93
  94 /* Callback used by the VCAP API */
  95 static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin,
  96                             u32 start, u32 count)
  97 {
  98         test_init_start = start;
  99         test_init_count = count;
 100 }
 101
 102 /* Callback used by the VCAP API */
 103 static void test_cache_read(struct net_device *ndev, struct vcap_admin *admin,
 104                             enum vcap_selection sel, u32 start, u32 count)
 105 {
 106         u32 *keystr, *mskstr, *actstr;
 107         int idx;
 108
 109         pr_debug("%s:%d: %d %d\n", __func__, __LINE__, start, count);
 110         switch (sel) {
 111         case VCAP_SEL_ENTRY:
 112                 keystr = &admin->cache.keystream[start];
 113                 mskstr = &admin->cache.maskstream[start];
 114                 for (idx = 0; idx < count; ++idx) {
 115                         pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
 116                                  __LINE__, start + idx, keystr[idx]);
 117                 }
 118                 for (idx = 0; idx < count; ++idx) {
 119                         /* Invert the mask before decoding starts */
 120                         mskstr[idx] = ~mskstr[idx];
 121                         pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
 122                                  __LINE__, start + idx, mskstr[idx]);
 123                 }
 124                 break;
 125         case VCAP_SEL_ACTION:
 126                 actstr = &admin->cache.actionstream[start];
 127                 for (idx = 0; idx < count; ++idx) {
 128                         pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
 129                                  __LINE__, start + idx, actstr[idx]);
 130                 }
 131                 break;
 132         case VCAP_SEL_COUNTER:
 133                 pr_debug("%s:%d\n", __func__, __LINE__);
 134                 test_hw_counter_id = start;
 135                 admin->cache.counter = test_hw_cache.counter;
 136                 admin->cache.sticky = test_hw_cache.sticky;
 137                 break;
 138         case VCAP_SEL_ALL:
 139                 pr_debug("%s:%d\n", __func__, __LINE__);
 140                 break;
 141         }
 142 }
 143
 144 /* Callback used by the VCAP API */
 145 static void test_cache_write(struct net_device *ndev, struct vcap_admin *admin,
 146                              enum vcap_selection sel, u32 start, u32 count)
 147 {
 148         u32 *keystr, *mskstr, *actstr;
 149         int idx;
 150
 151         switch (sel) {
 152         case VCAP_SEL_ENTRY:
 153                 keystr = &admin->cache.keystream[start];
 154                 mskstr = &admin->cache.maskstream[start];
 155                 for (idx = 0; idx < count; ++idx) {
 156                         pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
 157                                  __LINE__, start + idx, keystr[idx]);
 158                 }
 159                 for (idx = 0; idx < count; ++idx) {
 160                         /* Invert the mask before encoding starts */
 161                         mskstr[idx] = ~mskstr[idx];
 162                         pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
 163                                  __LINE__, start + idx, mskstr[idx]);
 164                 }
 165                 break;
 166         case VCAP_SEL_ACTION:
 167                 actstr = &admin->cache.actionstream[start];
 168                 for (idx = 0; idx < count; ++idx) {
 169                         pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
 170                                  __LINE__, start + idx, actstr[idx]);
 171                 }
 172                 break;
 173         case VCAP_SEL_COUNTER:
 174                 pr_debug("%s:%d\n", __func__, __LINE__);
 175                 test_hw_counter_id = start;
 176                 test_hw_cache.counter = admin->cache.counter;
 177                 test_hw_cache.sticky = admin->cache.sticky;
 178                 break;
 179         case VCAP_SEL_ALL:
 180                 pr_err("%s:%d: cannot write all streams at once\n",
 181                        __func__, __LINE__);
 182                 break;
 183         }
 184 }
 185
 186 /* Callback used by the VCAP API */
 187 static void test_cache_update(struct net_device *ndev, struct vcap_admin *admin,
 188                               enum vcap_command cmd,
 189                               enum vcap_selection sel, u32 addr)
 190 {
 191         if (test_updateaddridx < ARRAY_SIZE(test_updateaddr))
 192                 test_updateaddr[test_updateaddridx] = addr;
 193         else
 194                 pr_err("%s:%d: overflow: %d\n", __func__, __LINE__, test_updateaddridx);
 195         test_updateaddridx++;
 196 }
 197
 198 static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin,
 199                             u32 addr, int offset, int count)
 200 {
 201         test_move_addr = addr;
 202         test_move_offset = offset;
 203         test_move_count = count;
 204 }
 205
 206 /* Provide port information via a callback interface */
 207 static int vcap_test_port_info(struct net_device *ndev,
 208                                struct vcap_admin *admin,
 209                                struct vcap_output_print *out)
 210 {
 211         return 0;
 212 }
 213
 214 static struct vcap_operations test_callbacks = {
 215         .validate_keyset = test_val_keyset,
 216         .add_default_fields = test_add_def_fields,
 217         .cache_erase = test_cache_erase,
 218         .cache_write = test_cache_write,
 219         .cache_read = test_cache_read,
 220         .init = test_cache_init,
 221         .update = test_cache_update,
 222         .move = test_cache_move,
 223         .port_info = vcap_test_port_info,
 224 };
 225
 226 static struct vcap_control test_vctrl = {
 227         .vcaps = kunit_test_vcaps,
 228         .stats = &kunit_test_vcap_stats,
 229         .ops = &test_callbacks,
 230 };
 231
 232 static void vcap_test_api_init(struct vcap_admin *admin)
 233 {
 234         /* Initialize the shared objects */
 235         INIT_LIST_HEAD(&test_vctrl.list);
 236         INIT_LIST_HEAD(&admin->list);
 237         INIT_LIST_HEAD(&admin->rules);
 238         INIT_LIST_HEAD(&admin->enabled);
 239         mutex_init(&admin->lock);
 240         list_add_tail(&admin->list, &test_vctrl.list);
 241         memset(test_updateaddr, 0, sizeof(test_updateaddr));
 242         test_updateaddridx = 0;
 243 }
 244
 245 /* Helper function to create a rule of a specific size */
 246 static void test_vcap_xn_rule_creator(struct kunit *test, int cid,
 247                                       enum vcap_user user, u16 priority,
 248                                       int id, int size, int expected_addr)
 249 {
 250         struct vcap_rule *rule;
 251         struct vcap_rule_internal *ri;
 252         enum vcap_keyfield_set keyset = VCAP_KFS_NO_VALUE;
 253         enum vcap_actionfield_set actionset = VCAP_AFS_NO_VALUE;
 254         int ret;
 255
 256         /* init before testing */
 257         memset(test_updateaddr, 0, sizeof(test_updateaddr));
 258         test_updateaddridx = 0;
 259         test_move_addr = 0;
 260         test_move_offset = 0;
 261         test_move_count = 0;
 262
 263         switch (size) {
 264         case 2:
 265                 keyset = VCAP_KFS_ETAG;
 266                 actionset = VCAP_AFS_CLASS_REDUCED;
 267                 break;
 268         case 3:
 269                 keyset = VCAP_KFS_PURE_5TUPLE_IP4;
 270                 actionset = VCAP_AFS_CLASSIFICATION;
 271                 break;
 272         case 6:
 273                 keyset = VCAP_KFS_NORMAL_5TUPLE_IP4;
 274                 actionset = VCAP_AFS_CLASSIFICATION;
 275                 break;
 276         case 12:
 277                 keyset = VCAP_KFS_NORMAL_7TUPLE;
 278                 actionset = VCAP_AFS_FULL;
 279                 break;
 280         default:
 281                 break;
 282         }
 283
 284         /* Check that a valid size was used */
 285         KUNIT_ASSERT_NE(test, VCAP_KFS_NO_VALUE, keyset);
 286
 287         /* Allocate the rule */
 288         rule = vcap_alloc_rule(&test_vctrl, &test_netdev, cid, user, priority,
 289                                id);
 290         KUNIT_EXPECT_PTR_NE(test, NULL, rule);
 291
 292         ri = (struct vcap_rule_internal *)rule;
 293
 294         /* Override rule keyset */
 295         ret = vcap_set_rule_set_keyset(rule, keyset);
 296
 297         /* Add rule actions : there must be at least one action */
 298         ret = vcap_rule_add_action_u32(rule, VCAP_AF_ISDX_VAL, 0);
 299
 300         /* Override rule actionset */
 301         ret = vcap_set_rule_set_actionset(rule, actionset);
 302
 303         ret = vcap_val_rule(rule, ETH_P_ALL);
 304         KUNIT_EXPECT_EQ(test, 0, ret);
 305         KUNIT_EXPECT_EQ(test, keyset, rule->keyset);
 306         KUNIT_EXPECT_EQ(test, actionset, rule->actionset);
 307         KUNIT_EXPECT_EQ(test, size, ri->size);
 308
 309         /* Add rule with write callback */
 310         ret = vcap_add_rule(rule);
 311         KUNIT_EXPECT_EQ(test, 0, ret);
 312         KUNIT_EXPECT_EQ(test, expected_addr, ri->addr);
 313         vcap_free_rule(rule);
 314 }
 315
 316 /* Prepare testing rule deletion */
 317 static void test_init_rule_deletion(void)
 318 {
 319         test_move_addr = 0;
 320         test_move_offset = 0;
 321         test_move_count = 0;
 322         test_init_start = 0;
 323         test_init_count = 0;
 324 }
 325
 326 /* Define the test cases. */
 327
 328 static void vcap_api_set_bit_1_test(struct kunit *test)
 329 {
 330         struct vcap_stream_iter iter = {
 331                 .offset = 35,
 332                 .sw_width = 52,
 333                 .reg_idx = 1,
 334                 .reg_bitpos = 20,
 335                 .tg = NULL,
 336         };
 337         u32 stream[2] = {0};
 338
 339         vcap_set_bit(stream, &iter, 1);
 340
 341         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
 342         KUNIT_EXPECT_EQ(test, (u32)BIT(20), stream[1]);
 343 }
 344
 345 static void vcap_api_set_bit_0_test(struct kunit *test)
 346 {
 347         struct vcap_stream_iter iter = {
 348                 .offset = 35,
 349                 .sw_width = 52,
 350                 .reg_idx = 2,
 351                 .reg_bitpos = 11,
 352                 .tg = NULL,
 353         };
 354         u32 stream[3] = {~0, ~0, ~0};
 355
 356         vcap_set_bit(stream, &iter, 0);
 357
 358         KUNIT_EXPECT_EQ(test, (u32)~0, stream[0]);
 359         KUNIT_EXPECT_EQ(test, (u32)~0, stream[1]);
 360         KUNIT_EXPECT_EQ(test, (u32)~BIT(11), stream[2]);
 361 }
 362
 363 static void vcap_api_iterator_init_test(struct kunit *test)
 364 {
 365         struct vcap_stream_iter iter;
 366         struct vcap_typegroup typegroups[] = {
 367                 { .offset = 0, .width = 2, .value = 2, },
 368                 { .offset = 156, .width = 1, .value = 0, },
 369                 { .offset = 0, .width = 0, .value = 0, },
 370         };
 371         struct vcap_typegroup typegroups2[] = {
 372                 { .offset = 0, .width = 3, .value = 4, },
 373                 { .offset = 49, .width = 2, .value = 0, },
 374                 { .offset = 98, .width = 2, .value = 0, },
 375         };
 376
 377         vcap_iter_init(&iter, 52, typegroups, 86);
 378
 379         KUNIT_EXPECT_EQ(test, 52, iter.sw_width);
 380         KUNIT_EXPECT_EQ(test, 86 + 2, iter.offset);
 381         KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
 382         KUNIT_EXPECT_EQ(test, 4, iter.reg_bitpos);
 383
 384         vcap_iter_init(&iter, 49, typegroups2, 134);
 385
 386         KUNIT_EXPECT_EQ(test, 49, iter.sw_width);
 387         KUNIT_EXPECT_EQ(test, 134 + 7, iter.offset);
 388         KUNIT_EXPECT_EQ(test, 5, iter.reg_idx);
 389         KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);
 390 }
 391
 392 static void vcap_api_iterator_next_test(struct kunit *test)
 393 {
 394         struct vcap_stream_iter iter;
 395         struct vcap_typegroup typegroups[] = {
 396                 { .offset = 0, .width = 4, .value = 8, },
 397                 { .offset = 49, .width = 1, .value = 0, },
 398                 { .offset = 98, .width = 2, .value = 0, },
 399                 { .offset = 147, .width = 3, .value = 0, },
 400                 { .offset = 196, .width = 2, .value = 0, },
 401                 { .offset = 245, .width = 1, .value = 0, },
 402         };
 403         int idx;
 404
 405         vcap_iter_init(&iter, 49, typegroups, 86);
 406
 407         KUNIT_EXPECT_EQ(test, 49, iter.sw_width);
 408         KUNIT_EXPECT_EQ(test, 86 + 5, iter.offset);
 409         KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
 410         KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);
 411
 412         vcap_iter_next(&iter);
 413
 414         KUNIT_EXPECT_EQ(test, 91 + 1, iter.offset);
 415         KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
 416         KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);
 417
 418         for (idx = 0; idx < 6; idx++)
 419                 vcap_iter_next(&iter);
 420
 421         KUNIT_EXPECT_EQ(test, 92 + 6 + 2, iter.offset);
 422         KUNIT_EXPECT_EQ(test, 4, iter.reg_idx);
 423         KUNIT_EXPECT_EQ(test, 2, iter.reg_bitpos);
 424 }
 425
 426 static void vcap_api_encode_typegroups_test(struct kunit *test)
 427 {
 428         u32 stream[12] = {0};
 429         struct vcap_typegroup typegroups[] = {
 430                 { .offset = 0, .width = 4, .value = 8, },
 431                 { .offset = 49, .width = 1, .value = 1, },
 432                 { .offset = 98, .width = 2, .value = 3, },
 433                 { .offset = 147, .width = 3, .value = 5, },
 434                 { .offset = 196, .width = 2, .value = 2, },
 435                 { .offset = 245, .width = 5, .value = 27, },
 436                 { .offset = 0, .width = 0, .value = 0, },
 437         };
 438
 439         vcap_encode_typegroups(stream, 49, typegroups, false);
 440
 441         KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]);
 442         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
 443         KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]);
 444         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]);
 445         KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]);
 446         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
 447         KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]);
 448         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]);
 449         KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]);
 450         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]);
 451         KUNIT_EXPECT_EQ(test, (u32)27, stream[10]);
 452         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]);
 453 }
 454
 455 static void vcap_api_encode_bit_test(struct kunit *test)
 456 {
 457         struct vcap_stream_iter iter;
 458         u32 stream[4] = {0};
 459         struct vcap_typegroup typegroups[] = {
 460                 { .offset = 0, .width = 4, .value = 8, },
 461                 { .offset = 49, .width = 1, .value = 1, },
 462                 { .offset = 98, .width = 2, .value = 3, },
 463                 { .offset = 147, .width = 3, .value = 5, },
 464                 { .offset = 196, .width = 2, .value = 2, },
 465                 { .offset = 245, .width = 1, .value = 0, },
 466         };
 467
 468         vcap_iter_init(&iter, 49, typegroups, 44);
 469
 470         KUNIT_EXPECT_EQ(test, 48, iter.offset);
 471         KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);
 472         KUNIT_EXPECT_EQ(test, 16, iter.reg_bitpos);
 473
 474         vcap_encode_bit(stream, &iter, 1);
 475
 476         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
 477         KUNIT_EXPECT_EQ(test, (u32)BIT(16), stream[1]);
 478         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
 479 }
 480
 481 static void vcap_api_encode_field_test(struct kunit *test)
 482 {
 483         struct vcap_stream_iter iter;
 484         u32 stream[16] = {0};
 485         struct vcap_typegroup typegroups[] = {
 486                 { .offset = 0, .width = 4, .value = 8, },
 487                 { .offset = 49, .width = 1, .value = 1, },
 488                 { .offset = 98, .width = 2, .value = 3, },
 489                 { .offset = 147, .width = 3, .value = 5, },
 490                 { .offset = 196, .width = 2, .value = 2, },
 491                 { .offset = 245, .width = 5, .value = 27, },
 492                 { .offset = 0, .width = 0, .value = 0, },
 493         };
 494         struct vcap_field rf = {
 495                 .type = VCAP_FIELD_U32,
 496                 .offset = 86,
 497                 .width = 4,
 498         };
 499         u8 value[] = {0x5};
 500
 501         vcap_iter_init(&iter, 49, typegroups, rf.offset);
 502
 503         KUNIT_EXPECT_EQ(test, 91, iter.offset);
 504         KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
 505         KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);
 506
 507         vcap_encode_field(stream, &iter, rf.width, value);
 508
 509         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
 510         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
 511         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
 512         KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]);
 513         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]);
 514
 515         vcap_encode_typegroups(stream, 49, typegroups, false);
 516
 517         KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]);
 518         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
 519         KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]);
 520         KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]);
 521         KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]);
 522         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
 523         KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]);
 524         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]);
 525         KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]);
 526         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]);
 527         KUNIT_EXPECT_EQ(test, (u32)27, stream[10]);
 528         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]);
 529 }
 530
 531 /* In this testcase the subword is smaller than a register */
 532 static void vcap_api_encode_short_field_test(struct kunit *test)
 533 {
 534         struct vcap_stream_iter iter;
 535         int sw_width = 21;
 536         u32 stream[6] = {0};
 537         struct vcap_typegroup tgt[] = {
 538                 { .offset = 0, .width = 3, .value = 7, },
 539                 { .offset = 21, .width = 2, .value = 3, },
 540                 { .offset = 42, .width = 1, .value = 1, },
 541                 { .offset = 0, .width = 0, .value = 0, },
 542         };
 543         struct vcap_field rf = {
 544                 .type = VCAP_FIELD_U32,
 545                 .offset = 25,
 546                 .width = 4,
 547         };
 548         u8 value[] = {0x5};
 549
 550         vcap_iter_init(&iter, sw_width, tgt, rf.offset);
 551
 552         KUNIT_EXPECT_EQ(test, 1, iter.regs_per_sw);
 553         KUNIT_EXPECT_EQ(test, 21, iter.sw_width);
 554         KUNIT_EXPECT_EQ(test, 25 + 3 + 2, iter.offset);
 555         KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);
 556         KUNIT_EXPECT_EQ(test, 25 + 3 + 2 - sw_width, iter.reg_bitpos);
 557
 558         vcap_encode_field(stream, &iter, rf.width, value);
 559
 560         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
 561         KUNIT_EXPECT_EQ(test, (u32)(0x5 << (25 + 3 + 2 - sw_width)), stream[1]);
 562         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
 563         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]);
 564         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]);
 565         KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
 566
 567         vcap_encode_typegroups(stream, sw_width, tgt, false);
 568
 569         KUNIT_EXPECT_EQ(test, (u32)7, stream[0]);
 570         KUNIT_EXPECT_EQ(test, (u32)((0x5 << (25 + 3 + 2 - sw_width)) + 3), stream[1]);
 571         KUNIT_EXPECT_EQ(test, (u32)1, stream[2]);
 572         KUNIT_EXPECT_EQ(test, (u32)0, stream[3]);
 573         KUNIT_EXPECT_EQ(test, (u32)0, stream[4]);
 574         KUNIT_EXPECT_EQ(test, (u32)0, stream[5]);
 575 }
 576
 577 static void vcap_api_encode_keyfield_test(struct kunit *test)
 578 {
 579         u32 keywords[16] = {0};
 580         u32 maskwords[16] = {0};
 581         struct vcap_admin admin = {
 582                 .vtype = VCAP_TYPE_IS2,
 583                 .cache = {
 584                         .keystream = keywords,
 585                         .maskstream = maskwords,
 586                         .actionstream = keywords,
 587                 },
 588         };
 589         struct vcap_rule_internal rule = {
 590                 .admin = &admin,
 591                 .data = {
 592                         .keyset = VCAP_KFS_MAC_ETYPE,
 593                 },
 594                 .vctrl = &test_vctrl,
 595         };
 596         struct vcap_client_keyfield ckf = {
 597                 .ctrl.list = {},
 598                 .ctrl.key = VCAP_KF_ISDX_CLS,
 599                 .ctrl.type = VCAP_FIELD_U32,
 600                 .data.u32.value = 0xeef014a1,
 601                 .data.u32.mask = 0xfff,
 602         };
 603         struct vcap_field rf = {
 604                 .type = VCAP_FIELD_U32,
 605                 .offset = 56,
 606                 .width = 12,
 607         };
 608         struct vcap_typegroup tgt[] = {
 609                 { .offset = 0, .width = 2, .value = 2, },
 610                 { .offset = 156, .width = 1, .value = 1, },
 611                 { .offset = 0, .width = 0, .value = 0, },
 612         };
 613
 614         vcap_test_api_init(&admin);
 615         vcap_encode_keyfield(&rule, &ckf, &rf, tgt);
 616
 617         /* Key */
 618         KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[0]);
 619         KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[1]);
 620         KUNIT_EXPECT_EQ(test, (u32)(0x04a1 << 6), keywords[2]);
 621         KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[3]);
 622         KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[4]);
 623         KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[5]);
 624         KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[6]);
 625
 626         /* Mask */
 627         KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[0]);
 628         KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[1]);
 629         KUNIT_EXPECT_EQ(test, (u32)(0x0fff << 6), maskwords[2]);
 630         KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[3]);
 631         KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[4]);
 632         KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[5]);
 633         KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[6]);
 634 }
 635
 636 static void vcap_api_encode_max_keyfield_test(struct kunit *test)
 637 {
 638         int idx;
 639         u32 keywords[6] = {0};
 640         u32 maskwords[6] = {0};
 641         struct vcap_admin admin = {
 642                 .vtype = VCAP_TYPE_IS2,
 643                 /* IS2 sw_width = 52 bit */
 644                 .cache = {
 645                         .keystream = keywords,
 646                         .maskstream = maskwords,
 647                         .actionstream = keywords,
 648                 },
 649         };
 650         struct vcap_rule_internal rule = {
 651                 .admin = &admin,
 652                 .data = {
 653                         .keyset = VCAP_KFS_IP_7TUPLE,
 654                 },
 655                 .vctrl = &test_vctrl,
 656         };
 657         struct vcap_client_keyfield ckf = {
 658                 .ctrl.list = {},
 659                 .ctrl.key = VCAP_KF_L3_IP6_DIP,
 660                 .ctrl.type = VCAP_FIELD_U128,
 661                 .data.u128.value = { 0xa1, 0xa2, 0xa3, 0xa4, 0, 0, 0x43, 0,
 662                         0, 0, 0, 0, 0, 0, 0x78, 0x8e, },
 663                 .data.u128.mask =  { 0xff, 0xff, 0xff, 0xff, 0, 0, 0xff, 0,
 664                         0, 0, 0, 0, 0, 0, 0xff, 0xff },
 665         };
 666         struct vcap_field rf = {
 667                 .type = VCAP_FIELD_U128,
 668                 .offset = 0,
 669                 .width = 128,
 670         };
 671         struct vcap_typegroup tgt[] = {
 672                 { .offset = 0, .width = 2, .value = 2, },
 673                 { .offset = 156, .width = 1, .value = 1, },
 674                 { .offset = 0, .width = 0, .value = 0, },
 675         };
 676         u32 keyres[] = {
 677                 0x928e8a84,
 678                 0x000c0002,
 679                 0x00000010,
 680                 0x00000000,
 681                 0x0239e000,
 682                 0x00000000,
 683         };
 684         u32 mskres[] = {
 685                 0xfffffffc,
 686                 0x000c0003,
 687                 0x0000003f,
 688                 0x00000000,
 689                 0x03fffc00,
 690                 0x00000000,
 691         };
 692
 693         vcap_encode_keyfield(&rule, &ckf, &rf, tgt);
 694
 695         /* Key */
 696         for (idx = 0; idx < ARRAY_SIZE(keyres); ++idx)
 697                 KUNIT_EXPECT_EQ(test, keyres[idx], keywords[idx]);
 698         /* Mask */
 699         for (idx = 0; idx < ARRAY_SIZE(mskres); ++idx)
 700                 KUNIT_EXPECT_EQ(test, mskres[idx], maskwords[idx]);
 701 }
 702
 703 static void vcap_api_encode_actionfield_test(struct kunit *test)
 704 {
 705         u32 actwords[16] = {0};
 706         int sw_width = 21;
 707         struct vcap_admin admin = {
 708                 .vtype = VCAP_TYPE_ES2, /* act_width = 21 */
 709                 .cache = {
 710                         .actionstream = actwords,
 711                 },
 712         };
 713         struct vcap_rule_internal rule = {
 714                 .admin = &admin,
 715                 .data = {
 716                         .actionset = VCAP_AFS_BASE_TYPE,
 717                 },
 718                 .vctrl = &test_vctrl,
 719         };
 720         struct vcap_client_actionfield caf = {
 721                 .ctrl.list = {},
 722                 .ctrl.action = VCAP_AF_POLICE_IDX,
 723                 .ctrl.type = VCAP_FIELD_U32,
 724                 .data.u32.value = 0x67908032,
 725         };
 726         struct vcap_field rf = {
 727                 .type = VCAP_FIELD_U32,
 728                 .offset = 35,
 729                 .width = 6,
 730         };
 731         struct vcap_typegroup tgt[] = {
 732                 { .offset = 0, .width = 2, .value = 2, },
 733                 { .offset = 21, .width = 1, .value = 1, },
 734                 { .offset = 42, .width = 1, .value = 0, },
 735                 { .offset = 0, .width = 0, .value = 0, },
 736         };
 737
 738         vcap_encode_actionfield(&rule, &caf, &rf, tgt);
 739
 740         /* Action */
 741         KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[0]);
 742         KUNIT_EXPECT_EQ(test, (u32)((0x32 << (35 + 2 + 1 - sw_width)) & 0x1fffff), actwords[1]);
 743         KUNIT_EXPECT_EQ(test, (u32)((0x32 >> ((2 * sw_width) - 38 - 1))), actwords[2]);
 744         KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[3]);
 745         KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[4]);
 746         KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[5]);
 747         KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[6]);
 748 }
 749
 750 static void vcap_api_keyfield_typegroup_test(struct kunit *test)
 751 {
 752         const struct vcap_typegroup *tg;
 753
 754         tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE);
 755         KUNIT_EXPECT_PTR_NE(test, NULL, tg);
 756         KUNIT_EXPECT_EQ(test, 0, tg[0].offset);
 757         KUNIT_EXPECT_EQ(test, 2, tg[0].width);
 758         KUNIT_EXPECT_EQ(test, 2, tg[0].value);
 759         KUNIT_EXPECT_EQ(test, 156, tg[1].offset);
 760         KUNIT_EXPECT_EQ(test, 1, tg[1].width);
 761         KUNIT_EXPECT_EQ(test, 0, tg[1].value);
 762         KUNIT_EXPECT_EQ(test, 0, tg[2].offset);
 763         KUNIT_EXPECT_EQ(test, 0, tg[2].width);
 764         KUNIT_EXPECT_EQ(test, 0, tg[2].value);
 765
 766         tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL);
 767         KUNIT_EXPECT_PTR_EQ(test, NULL, tg);
 768 }
 769
 770 static void vcap_api_actionfield_typegroup_test(struct kunit *test)
 771 {
 772         const struct vcap_typegroup *tg;
 773
 774         tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL);
 775         KUNIT_EXPECT_PTR_NE(test, NULL, tg);
 776         KUNIT_EXPECT_EQ(test, 0, tg[0].offset);
 777         KUNIT_EXPECT_EQ(test, 3, tg[0].width);
 778         KUNIT_EXPECT_EQ(test, 4, tg[0].value);
 779         KUNIT_EXPECT_EQ(test, 110, tg[1].offset);
 780         KUNIT_EXPECT_EQ(test, 2, tg[1].width);
 781         KUNIT_EXPECT_EQ(test, 0, tg[1].value);
 782         KUNIT_EXPECT_EQ(test, 220, tg[2].offset);
 783         KUNIT_EXPECT_EQ(test, 2, tg[2].width);
 784         KUNIT_EXPECT_EQ(test, 0, tg[2].value);
 785         KUNIT_EXPECT_EQ(test, 0, tg[3].offset);
 786         KUNIT_EXPECT_EQ(test, 0, tg[3].width);
 787         KUNIT_EXPECT_EQ(test, 0, tg[3].value);
 788
 789         tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION);
 790         KUNIT_EXPECT_PTR_EQ(test, NULL, tg);
 791 }
 792
 793 static void vcap_api_vcap_keyfields_test(struct kunit *test)
 794 {
 795         const struct vcap_field *ft;
 796
 797         ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE);
 798         KUNIT_EXPECT_PTR_NE(test, NULL, ft);
 799
 800         /* Keyset that is not available and within the maximum keyset enum value */
 801         ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_PURE_5TUPLE_IP4);
 802         KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
 803
 804         /* Keyset that is not available and beyond the maximum keyset enum value */
 805         ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL);
 806         KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
 807 }
 808
 809 static void vcap_api_vcap_actionfields_test(struct kunit *test)
 810 {
 811         const struct vcap_field *ft;
 812
 813         ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL);
 814         KUNIT_EXPECT_PTR_NE(test, NULL, ft);
 815
 816         ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_FULL);
 817         KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
 818
 819         ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION);
 820         KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
 821 }
 822
 823 static void vcap_api_encode_rule_keyset_test(struct kunit *test)
 824 {
 825         u32 keywords[16] = {0};
 826         u32 maskwords[16] = {0};
 827         struct vcap_admin admin = {
 828                 .vtype = VCAP_TYPE_IS2,
 829                 .cache = {
 830                         .keystream = keywords,
 831                         .maskstream = maskwords,
 832                 },
 833         };
 834         struct vcap_rule_internal rule = {
 835                 .admin = &admin,
 836                 .data = {
 837                         .keyset = VCAP_KFS_MAC_ETYPE,
 838                 },
 839                 .vctrl = &test_vctrl,
 840         };
 841         struct vcap_client_keyfield ckf[] = {
 842                 {
 843                         .ctrl.key = VCAP_KF_TYPE,
 844                         .ctrl.type = VCAP_FIELD_U32,
 845                         .data.u32.value = 0x00,
 846                         .data.u32.mask = 0x0f,
 847                 },
 848                 {
 849                         .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
 850                         .ctrl.type = VCAP_FIELD_BIT,
 851                         .data.u1.value = 0x01,
 852                         .data.u1.mask = 0x01,
 853                 },
 854                 {
 855                         .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_L3,
 856                         .ctrl.type = VCAP_FIELD_BIT,
 857                         .data.u1.value = 0x00,
 858                         .data.u1.mask = 0x01,
 859                 },
 860                 {
 861                         .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_RNG,
 862                         .ctrl.type = VCAP_FIELD_U32,
 863                         .data.u32.value = 0x00,
 864                         .data.u32.mask = 0x0f,
 865                 },
 866                 {
 867                         .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK,
 868                         .ctrl.type = VCAP_FIELD_U72,
 869                         .data.u72.value = {0x0, 0x00, 0x00, 0x00},
 870                         .data.u72.mask = {0xfd, 0xff, 0xff, 0xff},
 871                 },
 872                 {
 873                         .ctrl.key = VCAP_KF_L2_DMAC,
 874                         .ctrl.type = VCAP_FIELD_U48,
 875                         /* Opposite endianness */
 876                         .data.u48.value = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06},
 877                         .data.u48.mask = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 878                 },
 879                 {
 880                         .ctrl.key = VCAP_KF_ETYPE_LEN_IS,
 881                         .ctrl.type = VCAP_FIELD_BIT,
 882                         .data.u1.value = 0x01,
 883                         .data.u1.mask = 0x01,
 884                 },
 885                 {
 886                         .ctrl.key = VCAP_KF_ETYPE,
 887                         .ctrl.type = VCAP_FIELD_U32,
 888                         .data.u32.value = 0xaabb,
 889                         .data.u32.mask = 0xffff,
 890                 },
 891         };
 892         int idx;
 893         int ret;
 894
 895         /* Empty entry list */
 896         INIT_LIST_HEAD(&rule.data.keyfields);
 897         ret = vcap_encode_rule_keyset(&rule);
 898         KUNIT_EXPECT_EQ(test, -EINVAL, ret);
 899
 900         for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
 901                 list_add_tail(&ckf[idx].ctrl.list, &rule.data.keyfields);
 902         ret = vcap_encode_rule_keyset(&rule);
 903         KUNIT_EXPECT_EQ(test, 0, ret);
 904
 905         /* The key and mask values below are from an actual Sparx5 rule config */
 906         /* Key */
 907         KUNIT_EXPECT_EQ(test, (u32)0x00000042, keywords[0]);
 908         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[1]);
 909         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[2]);
 910         KUNIT_EXPECT_EQ(test, (u32)0x00020100, keywords[3]);
 911         KUNIT_EXPECT_EQ(test, (u32)0x60504030, keywords[4]);
 912         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[5]);
 913         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[6]);
 914         KUNIT_EXPECT_EQ(test, (u32)0x0002aaee, keywords[7]);
 915         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[8]);
 916         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[9]);
 917         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[10]);
 918         KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[11]);
 919
 920         /* Mask: they will be inverted when applied to the register */
 921         KUNIT_EXPECT_EQ(test, (u32)~0x00b07f80, maskwords[0]);
 922         KUNIT_EXPECT_EQ(test, (u32)~0xfff00000, maskwords[1]);
 923         KUNIT_EXPECT_EQ(test, (u32)~0xfffffffc, maskwords[2]);
 924         KUNIT_EXPECT_EQ(test, (u32)~0xfff000ff, maskwords[3]);
 925         KUNIT_EXPECT_EQ(test, (u32)~0x00000000, maskwords[4]);
 926         KUNIT_EXPECT_EQ(test, (u32)~0xfffffff0, maskwords[5]);
 927         KUNIT_EXPECT_EQ(test, (u32)~0xfffffffe, maskwords[6]);
 928         KUNIT_EXPECT_EQ(test, (u32)~0xfffc0001, maskwords[7]);
 929         KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[8]);
 930         KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[9]);
 931         KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[10]);
 932         KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[11]);
 933 }
 934
 935 static void vcap_api_encode_rule_actionset_test(struct kunit *test)
 936 {
 937         u32 actwords[16] = {0};
 938         struct vcap_admin admin = {
 939                 .vtype = VCAP_TYPE_IS2,
 940                 .cache = {
 941                         .actionstream = actwords,
 942                 },
 943         };
 944         struct vcap_rule_internal rule = {
 945                 .admin = &admin,
 946                 .data = {
 947                         .actionset = VCAP_AFS_BASE_TYPE,
 948                 },
 949                 .vctrl = &test_vctrl,
 950         };
 951         struct vcap_client_actionfield caf[] = {
 952                 {
 953                         .ctrl.action = VCAP_AF_MATCH_ID,
 954                         .ctrl.type = VCAP_FIELD_U32,
 955                         .data.u32.value = 0x01,
 956                 },
 957                 {
 958                         .ctrl.action = VCAP_AF_MATCH_ID_MASK,
 959                         .ctrl.type = VCAP_FIELD_U32,
 960                         .data.u32.value = 0x01,
 961                 },
 962                 {
 963                         .ctrl.action = VCAP_AF_CNT_ID,
 964                         .ctrl.type = VCAP_FIELD_U32,
 965                         .data.u32.value = 0x64,
 966                 },
 967         };
 968         int idx;
 969         int ret;
 970
 971         /* Empty entry list */
 972         INIT_LIST_HEAD(&rule.data.actionfields);
 973         ret = vcap_encode_rule_actionset(&rule);
 974         /* We allow rules with no actions */
 975         KUNIT_EXPECT_EQ(test, 0, ret);
 976
 977         for (idx = 0; idx < ARRAY_SIZE(caf); idx++)
 978                 list_add_tail(&caf[idx].ctrl.list, &rule.data.actionfields);
 979         ret = vcap_encode_rule_actionset(&rule);
 980         KUNIT_EXPECT_EQ(test, 0, ret);
 981
 982         /* The action values below are from an actual Sparx5 rule config */
 983         KUNIT_EXPECT_EQ(test, (u32)0x00000002, actwords[0]);
 984         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[1]);
 985         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[2]);
 986         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[3]);
 987         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[4]);
 988         KUNIT_EXPECT_EQ(test, (u32)0x00100000, actwords[5]);
 989         KUNIT_EXPECT_EQ(test, (u32)0x06400010, actwords[6]);
 990         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[7]);
 991         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[8]);
 992         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[9]);
 993         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[10]);
 994         KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[11]);
 995 }
 996
 997 static void vcap_free_ckf(struct vcap_rule *rule)
 998 {
 999         struct vcap_client_keyfield *ckf, *next_ckf;
1000
1001         list_for_each_entry_safe(ckf, next_ckf, &rule->keyfields, ctrl.list) {
1002                 list_del(&ckf->ctrl.list);
1003                 kfree(ckf);
1004         }
1005 }
1006
1007 static void vcap_api_rule_add_keyvalue_test(struct kunit *test)
1008 {
1009         struct vcap_admin admin = {
1010                 .vtype = VCAP_TYPE_IS2,
1011         };
1012         struct vcap_rule_internal ri = {
1013                 .admin = &admin,
1014                 .data = {
1015                         .keyset = VCAP_KFS_NO_VALUE,
1016                 },
1017                 .vctrl = &test_vctrl,
1018         };
1019         struct vcap_rule *rule = (struct vcap_rule *)&ri;
1020         struct vcap_client_keyfield *kf;
1021         int ret;
1022         struct vcap_u128_key dip = {
1023                 .value = {0x17, 0x26, 0x35, 0x44, 0x63, 0x62, 0x71},
1024                 .mask = {0xf1, 0xf2, 0xf3, 0xf4, 0x4f, 0x3f, 0x2f, 0x1f},
1025         };
1026         int idx;
1027
1028         INIT_LIST_HEAD(&rule->keyfields);
1029         ret = vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0);
1030         KUNIT_EXPECT_EQ(test, 0, ret);
1031         ret = list_empty(&rule->keyfields);
1032         KUNIT_EXPECT_EQ(test, false, ret);
1033         kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1034                               ctrl.list);
1035         KUNIT_EXPECT_EQ(test, VCAP_KF_LOOKUP_FIRST_IS, kf->ctrl.key);
1036         KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, kf->ctrl.type);
1037         KUNIT_EXPECT_EQ(test, 0x0, kf->data.u1.value);
1038         KUNIT_EXPECT_EQ(test, 0x1, kf->data.u1.mask);
1039         vcap_free_ckf(rule);
1040
1041         INIT_LIST_HEAD(&rule->keyfields);
1042         ret = vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1);
1043         KUNIT_EXPECT_EQ(test, 0, ret);
1044         ret = list_empty(&rule->keyfields);
1045         KUNIT_EXPECT_EQ(test, false, ret);
1046         kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1047                               ctrl.list);
1048         KUNIT_EXPECT_EQ(test, VCAP_KF_LOOKUP_FIRST_IS, kf->ctrl.key);
1049         KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, kf->ctrl.type);
1050         KUNIT_EXPECT_EQ(test, 0x1, kf->data.u1.value);
1051         KUNIT_EXPECT_EQ(test, 0x1, kf->data.u1.mask);
1052         vcap_free_ckf(rule);
1053
1054         INIT_LIST_HEAD(&rule->keyfields);
1055         ret = vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS,
1056                                     VCAP_BIT_ANY);
1057         KUNIT_EXPECT_EQ(test, 0, ret);
1058         ret = list_empty(&rule->keyfields);
1059         KUNIT_EXPECT_EQ(test, false, ret);
1060         kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1061                               ctrl.list);
1062         KUNIT_EXPECT_EQ(test, VCAP_KF_LOOKUP_FIRST_IS, kf->ctrl.key);
1063         KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, kf->ctrl.type);
1064         KUNIT_EXPECT_EQ(test, 0x0, kf->data.u1.value);
1065         KUNIT_EXPECT_EQ(test, 0x0, kf->data.u1.mask);
1066         vcap_free_ckf(rule);
1067
1068         INIT_LIST_HEAD(&rule->keyfields);
1069         ret = vcap_rule_add_key_u32(rule, VCAP_KF_TYPE, 0x98765432, 0xff00ffab);
1070         KUNIT_EXPECT_EQ(test, 0, ret);
1071         ret = list_empty(&rule->keyfields);
1072         KUNIT_EXPECT_EQ(test, false, ret);
1073         kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1074                               ctrl.list);
1075         KUNIT_EXPECT_EQ(test, VCAP_KF_TYPE, kf->ctrl.key);
1076         KUNIT_EXPECT_EQ(test, VCAP_FIELD_U32, kf->ctrl.type);
1077         KUNIT_EXPECT_EQ(test, 0x98765432, kf->data.u32.value);
1078         KUNIT_EXPECT_EQ(test, 0xff00ffab, kf->data.u32.mask);
1079         vcap_free_ckf(rule);
1080
1081         INIT_LIST_HEAD(&rule->keyfields);
1082         ret = vcap_rule_add_key_u128(rule, VCAP_KF_L3_IP6_SIP, &dip);
1083         KUNIT_EXPECT_EQ(test, 0, ret);
1084         ret = list_empty(&rule->keyfields);
1085         KUNIT_EXPECT_EQ(test, false, ret);
1086         kf = list_first_entry(&rule->keyfields, struct vcap_client_keyfield,
1087                               ctrl.list);
1088         KUNIT_EXPECT_EQ(test, VCAP_KF_L3_IP6_SIP, kf->ctrl.key);
1089         KUNIT_EXPECT_EQ(test, VCAP_FIELD_U128, kf->ctrl.type);
1090         for (idx = 0; idx < ARRAY_SIZE(dip.value); ++idx)
1091                 KUNIT_EXPECT_EQ(test, dip.value[idx], kf->data.u128.value[idx]);
1092         for (idx = 0; idx < ARRAY_SIZE(dip.mask); ++idx)
1093                 KUNIT_EXPECT_EQ(test, dip.mask[idx], kf->data.u128.mask[idx]);
1094         vcap_free_ckf(rule);
1095 }
1096
1097 static void vcap_free_caf(struct vcap_rule *rule)
1098 {
1099         struct vcap_client_actionfield *caf, *next_caf;
1100
1101         list_for_each_entry_safe(caf, next_caf,
1102                                  &rule->actionfields, ctrl.list) {
1103                 list_del(&caf->ctrl.list);
1104                 kfree(caf);
1105         }
1106 }
1107
1108 static void vcap_api_rule_add_actionvalue_test(struct kunit *test)
1109 {
1110         struct vcap_admin admin = {
1111                 .vtype = VCAP_TYPE_IS2,
1112         };
1113         struct vcap_rule_internal ri = {
1114                 .admin = &admin,
1115                 .data = {
1116                         .actionset = VCAP_AFS_NO_VALUE,
1117                 },
1118         };
1119         struct vcap_rule *rule = (struct vcap_rule *)&ri;
1120         struct vcap_client_actionfield *af;
1121         int ret;
1122
1123         INIT_LIST_HEAD(&rule->actionfields);
1124         ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_0);
1125         KUNIT_EXPECT_EQ(test, 0, ret);
1126         ret = list_empty(&rule->actionfields);
1127         KUNIT_EXPECT_EQ(test, false, ret);
1128         af = list_first_entry(&rule->actionfields,
1129                               struct vcap_client_actionfield, ctrl.list);
1130         KUNIT_EXPECT_EQ(test, VCAP_AF_POLICE_ENA, af->ctrl.action);
1131         KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, af->ctrl.type);
1132         KUNIT_EXPECT_EQ(test, 0x0, af->data.u1.value);
1133         vcap_free_caf(rule);
1134
1135         INIT_LIST_HEAD(&rule->actionfields);
1136         ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_1);
1137         KUNIT_EXPECT_EQ(test, 0, ret);
1138         ret = list_empty(&rule->actionfields);
1139         KUNIT_EXPECT_EQ(test, false, ret);
1140         af = list_first_entry(&rule->actionfields,
1141                               struct vcap_client_actionfield, ctrl.list);
1142         KUNIT_EXPECT_EQ(test, VCAP_AF_POLICE_ENA, af->ctrl.action);
1143         KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, af->ctrl.type);
1144         KUNIT_EXPECT_EQ(test, 0x1, af->data.u1.value);
1145         vcap_free_caf(rule);
1146
1147         INIT_LIST_HEAD(&rule->actionfields);
1148         ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_ANY);
1149         KUNIT_EXPECT_EQ(test, 0, ret);
1150         ret = list_empty(&rule->actionfields);
1151         KUNIT_EXPECT_EQ(test, false, ret);
1152         af = list_first_entry(&rule->actionfields,
1153                               struct vcap_client_actionfield, ctrl.list);
1154         KUNIT_EXPECT_EQ(test, VCAP_AF_POLICE_ENA, af->ctrl.action);
1155         KUNIT_EXPECT_EQ(test, VCAP_FIELD_BIT, af->ctrl.type);
1156         KUNIT_EXPECT_EQ(test, 0x0, af->data.u1.value);
1157         vcap_free_caf(rule);
1158
1159         INIT_LIST_HEAD(&rule->actionfields);
1160         ret = vcap_rule_add_action_u32(rule, VCAP_AF_TYPE, 0x98765432);
1161         KUNIT_EXPECT_EQ(test, 0, ret);
1162         ret = list_empty(&rule->actionfields);
1163         KUNIT_EXPECT_EQ(test, false, ret);
1164         af = list_first_entry(&rule->actionfields,
1165                               struct vcap_client_actionfield, ctrl.list);
1166         KUNIT_EXPECT_EQ(test, VCAP_AF_TYPE, af->ctrl.action);
1167         KUNIT_EXPECT_EQ(test, VCAP_FIELD_U32, af->ctrl.type);
1168         KUNIT_EXPECT_EQ(test, 0x98765432, af->data.u32.value);
1169         vcap_free_caf(rule);
1170
1171         INIT_LIST_HEAD(&rule->actionfields);
1172         ret = vcap_rule_add_action_u32(rule, VCAP_AF_MASK_MODE, 0xaabbccdd);
1173         KUNIT_EXPECT_EQ(test, 0, ret);
1174         ret = list_empty(&rule->actionfields);
1175         KUNIT_EXPECT_EQ(test, false, ret);
1176         af = list_first_entry(&rule->actionfields,
1177                               struct vcap_client_actionfield, ctrl.list);
1178         KUNIT_EXPECT_EQ(test, VCAP_AF_MASK_MODE, af->ctrl.action);
1179         KUNIT_EXPECT_EQ(test, VCAP_FIELD_U32, af->ctrl.type);
1180         KUNIT_EXPECT_EQ(test, 0xaabbccdd, af->data.u32.value);
1181         vcap_free_caf(rule);
1182 }
1183
1184 static void vcap_api_rule_find_keyset_basic_test(struct kunit *test)
1185 {
1186         struct vcap_keyset_list matches = {};
1187         struct vcap_admin admin = {
1188                 .vtype = VCAP_TYPE_IS2,
1189         };
1190         struct vcap_rule_internal ri = {
1191                 .admin = &admin,
1192                 .vctrl = &test_vctrl,
1193         };
1194         struct vcap_client_keyfield ckf[] = {
1195                 {
1196                         .ctrl.key = VCAP_KF_TYPE,
1197                 }, {
1198                         .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
1199                 }, {
1200                         .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_L3,
1201                 }, {
1202                         .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_RNG,
1203                 }, {
1204                         .ctrl.key = VCAP_KF_IF_IGR_PORT_MASK,
1205                 }, {
1206                         .ctrl.key = VCAP_KF_L2_DMAC,
1207                 }, {
1208                         .ctrl.key = VCAP_KF_ETYPE_LEN_IS,
1209                 }, {
1210                         .ctrl.key = VCAP_KF_ETYPE,
1211                 },
1212         };
1213         int idx;
1214         bool ret;
1215         enum vcap_keyfield_set keysets[10] = {};
1216
1217         matches.keysets = keysets;
1218         matches.max = ARRAY_SIZE(keysets);
1219
1220         INIT_LIST_HEAD(&ri.data.keyfields);
1221         for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
1222                 list_add_tail(&ckf[idx].ctrl.list, &ri.data.keyfields);
1223
1224         ret = vcap_rule_find_keysets(&ri.data, &matches);
1225
1226         KUNIT_EXPECT_EQ(test, true, ret);
1227         KUNIT_EXPECT_EQ(test, 1, matches.cnt);
1228         KUNIT_EXPECT_EQ(test, VCAP_KFS_MAC_ETYPE, matches.keysets[0]);
1229 }
1230
1231 static void vcap_api_rule_find_keyset_failed_test(struct kunit *test)
1232 {
1233         struct vcap_keyset_list matches = {};
1234         struct vcap_admin admin = {
1235                 .vtype = VCAP_TYPE_IS2,
1236         };
1237         struct vcap_rule_internal ri = {
1238                 .admin = &admin,
1239                 .vctrl = &test_vctrl,
1240         };
1241         struct vcap_client_keyfield ckf[] = {
1242                 {
1243                         .ctrl.key = VCAP_KF_TYPE,
1244                 }, {
1245                         .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
1246                 }, {
1247                         .ctrl.key = VCAP_KF_ARP_OPCODE,
1248                 }, {
1249                         .ctrl.key = VCAP_KF_L3_IP4_SIP,
1250                 }, {
1251                         .ctrl.key = VCAP_KF_L3_IP4_DIP,
1252                 }, {
1253                         .ctrl.key = VCAP_KF_8021Q_PCP_CLS,
1254                 }, {
1255                         .ctrl.key = VCAP_KF_ETYPE_LEN_IS, /* Not with ARP */
1256                 }, {
1257                         .ctrl.key = VCAP_KF_ETYPE, /* Not with ARP */
1258                 },
1259         };
1260         int idx;
1261         bool ret;
1262         enum vcap_keyfield_set keysets[10] = {};
1263
1264         matches.keysets = keysets;
1265         matches.max = ARRAY_SIZE(keysets);
1266
1267         INIT_LIST_HEAD(&ri.data.keyfields);
1268         for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
1269                 list_add_tail(&ckf[idx].ctrl.list, &ri.data.keyfields);
1270
1271         ret = vcap_rule_find_keysets(&ri.data, &matches);
1272
1273         KUNIT_EXPECT_EQ(test, false, ret);
1274         KUNIT_EXPECT_EQ(test, 0, matches.cnt);
1275         KUNIT_EXPECT_EQ(test, VCAP_KFS_NO_VALUE, matches.keysets[0]);
1276 }
1277
1278 static void vcap_api_rule_find_keyset_many_test(struct kunit *test)
1279 {
1280         struct vcap_keyset_list matches = {};
1281         struct vcap_admin admin = {
1282                 .vtype = VCAP_TYPE_IS2,
1283         };
1284         struct vcap_rule_internal ri = {
1285                 .admin = &admin,
1286                 .vctrl = &test_vctrl,
1287         };
1288         struct vcap_client_keyfield ckf[] = {
1289                 {
1290                         .ctrl.key = VCAP_KF_TYPE,
1291                 }, {
1292                         .ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
1293                 }, {
1294                         .ctrl.key = VCAP_KF_8021Q_DEI_CLS,
1295                 }, {
1296                         .ctrl.key = VCAP_KF_8021Q_PCP_CLS,
1297                 }, {
1298                         .ctrl.key = VCAP_KF_8021Q_VID_CLS,
1299                 }, {
1300                         .ctrl.key = VCAP_KF_ISDX_CLS,
1301                 }, {
1302                         .ctrl.key = VCAP_KF_L2_MC_IS,
1303                 }, {
1304                         .ctrl.key = VCAP_KF_L2_BC_IS,
1305                 },
1306         };
1307         int idx;
1308         bool ret;
1309         enum vcap_keyfield_set keysets[10] = {};
1310
1311         matches.keysets = keysets;
1312         matches.max = ARRAY_SIZE(keysets);
1313
1314         INIT_LIST_HEAD(&ri.data.keyfields);
1315         for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
1316                 list_add_tail(&ckf[idx].ctrl.list, &ri.data.keyfields);
1317
1318         ret = vcap_rule_find_keysets(&ri.data, &matches);
1319
1320         KUNIT_EXPECT_EQ(test, true, ret);
1321         KUNIT_EXPECT_EQ(test, 6, matches.cnt);
1322         KUNIT_EXPECT_EQ(test, VCAP_KFS_ARP, matches.keysets[0]);
1323         KUNIT_EXPECT_EQ(test, VCAP_KFS_IP4_OTHER, matches.keysets[1]);
1324         KUNIT_EXPECT_EQ(test, VCAP_KFS_IP4_TCP_UDP, matches.keysets[2]);
1325         KUNIT_EXPECT_EQ(test, VCAP_KFS_IP6_STD, matches.keysets[3]);
1326         KUNIT_EXPECT_EQ(test, VCAP_KFS_IP_7TUPLE, matches.keysets[4]);
1327         KUNIT_EXPECT_EQ(test, VCAP_KFS_MAC_ETYPE, matches.keysets[5]);
1328 }
1329
1330 static void vcap_api_encode_rule_test(struct kunit *test)
1331 {
1332         /* Data used by VCAP Library callback */
1333         static u32 keydata[32] = {};
1334         static u32 mskdata[32] = {};
1335         static u32 actdata[32] = {};
1336
1337         struct vcap_admin is2_admin = {
1338                 .vtype = VCAP_TYPE_IS2,
1339                 .first_cid = 8000000,
1340                 .last_cid = 8099999,
1341                 .lookups = 4,
1342                 .last_valid_addr = 3071,
1343                 .first_valid_addr = 0,
1344                 .last_used_addr = 800,
1345                 .cache = {
1346                         .keystream = keydata,
1347                         .maskstream = mskdata,
1348                         .actionstream = actdata,
1349                 },
1350         };
1351         struct vcap_rule *rule;
1352         struct vcap_rule_internal *ri;
1353         int vcap_chain_id = 8000000;
1354         enum vcap_user user = VCAP_USER_VCAP_UTIL;
1355         u16 priority = 10;
1356         int id = 100;
1357         int ret;
1358         struct vcap_u48_key smac = {
1359                 .value = { 0x88, 0x75, 0x32, 0x34, 0x9e, 0xb1 },
1360                 .mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
1361         };
1362         struct vcap_u48_key dmac = {
1363                 .value = { 0x06, 0x05, 0x04, 0x03, 0x02, 0x01 },
1364                 .mask = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
1365         };
1366         u32 port_mask_rng_value = 0x05;
1367         u32 port_mask_rng_mask = 0x0f;
1368         u32 igr_port_mask_value = 0xffabcd01;
1369         u32 igr_port_mask_mask = ~0;
1370         /* counter is written as the first operation */
1371         u32 expwriteaddr[] = {792, 792, 793, 794, 795, 796, 797};
1372         int idx;
1373
1374         vcap_test_api_init(&is2_admin);
1375
1376         /* Allocate the rule */
1377         rule = vcap_alloc_rule(&test_vctrl, &test_netdev, vcap_chain_id, user,
1378                                priority, id);
1379         KUNIT_EXPECT_PTR_NE(test, NULL, rule);
1380         ri = (struct vcap_rule_internal *)rule;
1381
1382         /* Add rule keys */
1383         ret = vcap_rule_add_key_u48(rule, VCAP_KF_L2_DMAC, &dmac);
1384         KUNIT_EXPECT_EQ(test, 0, ret);
1385         ret = vcap_rule_add_key_u48(rule, VCAP_KF_L2_SMAC, &smac);
1386         KUNIT_EXPECT_EQ(test, 0, ret);
1387         ret = vcap_rule_add_key_bit(rule, VCAP_KF_ETYPE_LEN_IS, VCAP_BIT_1);
1388         KUNIT_EXPECT_EQ(test, 0, ret);
1389         /* Cannot add the same field twice */
1390         ret = vcap_rule_add_key_bit(rule, VCAP_KF_ETYPE_LEN_IS, VCAP_BIT_1);
1391         KUNIT_EXPECT_EQ(test, -EINVAL, ret);
1392         ret = vcap_rule_add_key_bit(rule, VCAP_KF_IF_IGR_PORT_MASK_L3,
1393                                     VCAP_BIT_ANY);
1394         KUNIT_EXPECT_EQ(test, 0, ret);
1395         ret = vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK_RNG,
1396                                     port_mask_rng_value, port_mask_rng_mask);
1397         KUNIT_EXPECT_EQ(test, 0, ret);
1398         ret = vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK,
1399                                     igr_port_mask_value, igr_port_mask_mask);
1400         KUNIT_EXPECT_EQ(test, 0, ret);
1401
1402         /* Add rule actions */
1403         ret = vcap_rule_add_action_bit(rule, VCAP_AF_POLICE_ENA, VCAP_BIT_1);
1404         KUNIT_EXPECT_EQ(test, 0, ret);
1405         ret = vcap_rule_add_action_u32(rule, VCAP_AF_CNT_ID, id);
1406         KUNIT_EXPECT_EQ(test, 0, ret);
1407         ret = vcap_rule_add_action_u32(rule, VCAP_AF_MATCH_ID, 1);
1408         KUNIT_EXPECT_EQ(test, 0, ret);
1409         ret = vcap_rule_add_action_u32(rule, VCAP_AF_MATCH_ID_MASK, 1);
1410         KUNIT_EXPECT_EQ(test, 0, ret);
1411
1412         /* For now the actionset is hardcoded */
1413         ret = vcap_set_rule_set_actionset(rule, VCAP_AFS_BASE_TYPE);
1414         KUNIT_EXPECT_EQ(test, 0, ret);
1415
1416         /* Validation with validate keyset callback */
1417         ret = vcap_val_rule(rule, ETH_P_ALL);
1418         KUNIT_EXPECT_EQ(test, 0, ret);
1419         KUNIT_EXPECT_EQ(test, VCAP_KFS_MAC_ETYPE, rule->keyset);
1420         KUNIT_EXPECT_EQ(test, VCAP_AFS_BASE_TYPE, rule->actionset);
1421         KUNIT_EXPECT_EQ(test, 6, ri->size);
1422         KUNIT_EXPECT_EQ(test, 2, ri->keyset_sw_regs);
1423         KUNIT_EXPECT_EQ(test, 4, ri->actionset_sw_regs);
1424
1425         /* Enable lookup, so the rule will be written */
1426         ret = vcap_enable_lookups(&test_vctrl, &test_netdev, 0,
1427                                   rule->vcap_chain_id, rule->cookie, true);
1428         KUNIT_EXPECT_EQ(test, 0, ret);
1429
1430         /* Add rule with write callback */
1431         ret = vcap_add_rule(rule);
1432         KUNIT_EXPECT_EQ(test, 0, ret);
1433         KUNIT_EXPECT_EQ(test, 792, is2_admin.last_used_addr);
1434         for (idx = 0; idx < ARRAY_SIZE(expwriteaddr); ++idx)
1435                 KUNIT_EXPECT_EQ(test, expwriteaddr[idx], test_updateaddr[idx]);
1436
1437         /* Check that the rule has been added */
1438         ret = list_empty(&is2_admin.rules);
1439         KUNIT_EXPECT_EQ(test, false, ret);
1440         KUNIT_EXPECT_EQ(test, 0, ret);
1441
1442         vcap_enable_lookups(&test_vctrl, &test_netdev, 0, 0,
1443                             rule->cookie, false);
1444
1445         vcap_free_rule(rule);
1446
1447         /* Check that the rule has been freed: tricky to access since this
1448          * memory should not be accessible anymore
1449          */
1450         KUNIT_EXPECT_PTR_NE(test, NULL, rule);
1451         ret = list_empty(&rule->keyfields);
1452         KUNIT_EXPECT_EQ(test, true, ret);
1453         ret = list_empty(&rule->actionfields);
1454         KUNIT_EXPECT_EQ(test, true, ret);
1455
1456         vcap_del_rule(&test_vctrl, &test_netdev, id);
1457 }
1458
1459 static void vcap_api_set_rule_counter_test(struct kunit *test)
1460 {
1461         struct vcap_admin is2_admin = {
1462                 .cache = {
1463                         .counter = 100,
1464                         .sticky = true,
1465                 },
1466         };
1467         struct vcap_rule_internal ri = {
1468                 .data = {
1469                         .id = 1001,
1470                 },
1471                 .addr = 600,
1472                 .admin = &is2_admin,
1473                 .counter_id = 1002,
1474                 .vctrl = &test_vctrl,
1475         };
1476         struct vcap_rule_internal ri2 = {
1477                 .data = {
1478                         .id = 2001,
1479                 },
1480                 .addr = 700,
1481                 .admin = &is2_admin,
1482                 .counter_id = 2002,
1483                 .vctrl = &test_vctrl,
1484         };
1485         struct vcap_counter ctr = { .value = 0, .sticky = false};
1486         struct vcap_counter ctr2 = { .value = 101, .sticky = true};
1487         int ret;
1488
1489         vcap_test_api_init(&is2_admin);
1490         list_add_tail(&ri.list, &is2_admin.rules);
1491         list_add_tail(&ri2.list, &is2_admin.rules);
1492
1493         pr_info("%s:%d\n", __func__, __LINE__);
1494         ret = vcap_rule_set_counter(&ri.data, &ctr);
1495         pr_info("%s:%d\n", __func__, __LINE__);
1496         KUNIT_EXPECT_EQ(test, 0, ret);
1497
1498         KUNIT_EXPECT_EQ(test, 1002, test_hw_counter_id);
1499         KUNIT_EXPECT_EQ(test, 0, test_hw_cache.counter);
1500         KUNIT_EXPECT_EQ(test, false, test_hw_cache.sticky);
1501         KUNIT_EXPECT_EQ(test, 600, test_updateaddr[0]);
1502
1503         ret = vcap_rule_set_counter(&ri2.data, &ctr2);
1504         KUNIT_EXPECT_EQ(test, 0, ret);
1505
1506         KUNIT_EXPECT_EQ(test, 2002, test_hw_counter_id);
1507         KUNIT_EXPECT_EQ(test, 101, test_hw_cache.counter);
1508         KUNIT_EXPECT_EQ(test, true, test_hw_cache.sticky);
1509         KUNIT_EXPECT_EQ(test, 700, test_updateaddr[1]);
1510 }
1511
1512 static void vcap_api_get_rule_counter_test(struct kunit *test)
1513 {
1514         struct vcap_admin is2_admin = {
1515                 .cache = {
1516                         .counter = 100,
1517                         .sticky = true,
1518                 },
1519         };
1520         struct vcap_rule_internal ri = {
1521                 .data = {
1522                         .id = 1010,
1523                 },
1524                 .addr = 400,
1525                 .admin = &is2_admin,
1526                 .counter_id = 1011,
1527                 .vctrl = &test_vctrl,
1528         };
1529         struct vcap_rule_internal ri2 = {
1530                 .data = {
1531                         .id = 2011,
1532                 },
1533                 .addr = 300,
1534                 .admin = &is2_admin,
1535                 .counter_id = 2012,
1536                 .vctrl = &test_vctrl,
1537         };
1538         struct vcap_counter ctr = {};
1539         struct vcap_counter ctr2 = {};
1540         int ret;
1541
1542         vcap_test_api_init(&is2_admin);
1543         test_hw_cache.counter = 55;
1544         test_hw_cache.sticky = true;
1545
1546         list_add_tail(&ri.list, &is2_admin.rules);
1547         list_add_tail(&ri2.list, &is2_admin.rules);
1548
1549         ret = vcap_rule_get_counter(&ri.data, &ctr);
1550         KUNIT_EXPECT_EQ(test, 0, ret);
1551
1552         KUNIT_EXPECT_EQ(test, 1011, test_hw_counter_id);
1553         KUNIT_EXPECT_EQ(test, 55, ctr.value);
1554         KUNIT_EXPECT_EQ(test, true, ctr.sticky);
1555         KUNIT_EXPECT_EQ(test, 400, test_updateaddr[0]);
1556
1557         test_hw_cache.counter = 22;
1558         test_hw_cache.sticky = false;
1559
1560         ret = vcap_rule_get_counter(&ri2.data, &ctr2);
1561         KUNIT_EXPECT_EQ(test, 0, ret);
1562
1563         KUNIT_EXPECT_EQ(test, 2012, test_hw_counter_id);
1564         KUNIT_EXPECT_EQ(test, 22, ctr2.value);
1565         KUNIT_EXPECT_EQ(test, false, ctr2.sticky);
1566         KUNIT_EXPECT_EQ(test, 300, test_updateaddr[1]);
1567 }
1568
1569 static void vcap_api_rule_insert_in_order_test(struct kunit *test)
1570 {
1571         /* Data used by VCAP Library callback */
1572         static u32 keydata[32] = {};
1573         static u32 mskdata[32] = {};
1574         static u32 actdata[32] = {};
1575
1576         struct vcap_admin admin = {
1577                 .vtype = VCAP_TYPE_IS0,
1578                 .first_cid = 10000,
1579                 .last_cid = 19999,
1580                 .lookups = 4,
1581                 .last_valid_addr = 3071,
1582                 .first_valid_addr = 0,
1583                 .last_used_addr = 800,
1584                 .cache = {
1585                         .keystream = keydata,
1586                         .maskstream = mskdata,
1587                         .actionstream = actdata,
1588                 },
1589         };
1590
1591         vcap_test_api_init(&admin);
1592
1593         /* Create rules with different sizes and check that they are placed
1594          * at the correct address in the VCAP according to size
1595          */
1596         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1597         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 774);
1598         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 771);
1599         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 768);
1600
1601         vcap_del_rule(&test_vctrl, &test_netdev, 200);
1602         vcap_del_rule(&test_vctrl, &test_netdev, 300);
1603         vcap_del_rule(&test_vctrl, &test_netdev, 400);
1604         vcap_del_rule(&test_vctrl, &test_netdev, 500);
1605 }
1606
1607 static void vcap_api_rule_insert_reverse_order_test(struct kunit *test)
1608 {
1609         /* Data used by VCAP Library callback */
1610         static u32 keydata[32] = {};
1611         static u32 mskdata[32] = {};
1612         static u32 actdata[32] = {};
1613
1614         struct vcap_admin admin = {
1615                 .vtype = VCAP_TYPE_IS0,
1616                 .first_cid = 10000,
1617                 .last_cid = 19999,
1618                 .lookups = 4,
1619                 .last_valid_addr = 3071,
1620                 .first_valid_addr = 0,
1621                 .last_used_addr = 800,
1622                 .cache = {
1623                         .keystream = keydata,
1624                         .maskstream = mskdata,
1625                         .actionstream = actdata,
1626                 },
1627         };
1628         struct vcap_rule_internal *elem;
1629         u32 exp_addr[] = {780, 774, 771, 768, 767};
1630         int idx;
1631
1632         vcap_test_api_init(&admin);
1633
1634         /* Create rules with different sizes and check that they are placed
1635          * at the correct address in the VCAP according to size
1636          */
1637         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 200, 2, 798);
1638         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1639         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1640         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1641
1642         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 795);
1643         KUNIT_EXPECT_EQ(test, 6, test_move_offset);
1644         KUNIT_EXPECT_EQ(test, 3, test_move_count);
1645         KUNIT_EXPECT_EQ(test, 798, test_move_addr);
1646
1647         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 400, 6, 792);
1648         KUNIT_EXPECT_EQ(test, 6, test_move_offset);
1649         KUNIT_EXPECT_EQ(test, 6, test_move_count);
1650         KUNIT_EXPECT_EQ(test, 792, test_move_addr);
1651
1652         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 50, 500, 12, 780);
1653         KUNIT_EXPECT_EQ(test, 18, test_move_offset);
1654         KUNIT_EXPECT_EQ(test, 12, test_move_count);
1655         KUNIT_EXPECT_EQ(test, 786, test_move_addr);
1656
1657         idx = 0;
1658         list_for_each_entry(elem, &admin.rules, list) {
1659                 KUNIT_EXPECT_EQ(test, exp_addr[idx], elem->addr);
1660                 ++idx;
1661         }
1662         KUNIT_EXPECT_EQ(test, 768, admin.last_used_addr);
1663
1664         vcap_del_rule(&test_vctrl, &test_netdev, 500);
1665         vcap_del_rule(&test_vctrl, &test_netdev, 400);
1666         vcap_del_rule(&test_vctrl, &test_netdev, 300);
1667         vcap_del_rule(&test_vctrl, &test_netdev, 200);
1668 }
1669
1670 static void vcap_api_rule_remove_at_end_test(struct kunit *test)
1671 {
1672         /* Data used by VCAP Library callback */
1673         static u32 keydata[32] = {};
1674         static u32 mskdata[32] = {};
1675         static u32 actdata[32] = {};
1676
1677         struct vcap_admin admin = {
1678                 .vtype = VCAP_TYPE_IS0,
1679                 .first_cid = 10000,
1680                 .last_cid = 19999,
1681                 .lookups = 4,
1682                 .last_valid_addr = 3071,
1683                 .first_valid_addr = 0,
1684                 .last_used_addr = 800,
1685                 .cache = {
1686                         .keystream = keydata,
1687                         .maskstream = mskdata,
1688                         .actionstream = actdata,
1689                 },
1690         };
1691         int ret;
1692
1693         vcap_test_api_init(&admin);
1694         test_init_rule_deletion();
1695
1696         /* Create rules with different sizes and check that they are placed
1697          * at the correct address in the VCAP according to size
1698          */
1699         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1700         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 774);
1701         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 771);
1702         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 768);
1703
1704         /* Remove rules again from the end */
1705         ret = vcap_del_rule(&test_vctrl, &test_netdev, 200);
1706         KUNIT_EXPECT_EQ(test, 0, ret);
1707         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1708         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1709         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1710         KUNIT_EXPECT_EQ(test, 768, test_init_start);
1711         KUNIT_EXPECT_EQ(test, 2, test_init_count);
1712         KUNIT_EXPECT_EQ(test, 771, admin.last_used_addr);
1713
1714         ret = vcap_del_rule(&test_vctrl, &test_netdev, 300);
1715         KUNIT_EXPECT_EQ(test, ret, 0);
1716         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1717         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1718         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1719         KUNIT_EXPECT_EQ(test, 771, test_init_start);
1720         KUNIT_EXPECT_EQ(test, 3, test_init_count);
1721         KUNIT_EXPECT_EQ(test, 774, admin.last_used_addr);
1722
1723         ret = vcap_del_rule(&test_vctrl, &test_netdev, 400);
1724         KUNIT_EXPECT_EQ(test, ret, 0);
1725         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1726         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1727         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1728         KUNIT_EXPECT_EQ(test, 774, test_init_start);
1729         KUNIT_EXPECT_EQ(test, 6, test_init_count);
1730         KUNIT_EXPECT_EQ(test, 780, admin.last_used_addr);
1731
1732         ret = vcap_del_rule(&test_vctrl, &test_netdev, 500);
1733         KUNIT_EXPECT_EQ(test, ret, 0);
1734         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1735         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1736         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1737         KUNIT_EXPECT_EQ(test, 780, test_init_start);
1738         KUNIT_EXPECT_EQ(test, 12, test_init_count);
1739         KUNIT_EXPECT_EQ(test, 3072, admin.last_used_addr);
1740 }
1741
1742 static void vcap_api_rule_remove_in_middle_test(struct kunit *test)
1743 {
1744         /* Data used by VCAP Library callback */
1745         static u32 keydata[32] = {};
1746         static u32 mskdata[32] = {};
1747         static u32 actdata[32] = {};
1748
1749         struct vcap_admin admin = {
1750                 .vtype = VCAP_TYPE_IS0,
1751                 .first_cid = 10000,
1752                 .last_cid = 19999,
1753                 .lookups = 4,
1754                 .first_valid_addr = 0,
1755                 .last_used_addr = 800,
1756                 .last_valid_addr = 800 - 1,
1757                 .cache = {
1758                         .keystream = keydata,
1759                         .maskstream = mskdata,
1760                         .actionstream = actdata,
1761                 },
1762         };
1763         int ret;
1764
1765         vcap_test_api_init(&admin);
1766
1767         /* Create rules with different sizes and check that they are placed
1768          * at the correct address in the VCAP according to size
1769          */
1770         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1771         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 774);
1772         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 771);
1773         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 768);
1774
1775         /* Remove rules in the middle */
1776         test_init_rule_deletion();
1777         ret = vcap_del_rule(&test_vctrl, &test_netdev, 400);
1778         KUNIT_EXPECT_EQ(test, 0, ret);
1779         KUNIT_EXPECT_EQ(test, 768, test_move_addr);
1780         KUNIT_EXPECT_EQ(test, -6, test_move_offset);
1781         KUNIT_EXPECT_EQ(test, 6, test_move_count);
1782         KUNIT_EXPECT_EQ(test, 768, test_init_start);
1783         KUNIT_EXPECT_EQ(test, 6, test_init_count);
1784         KUNIT_EXPECT_EQ(test, 774, admin.last_used_addr);
1785
1786         test_init_rule_deletion();
1787         ret = vcap_del_rule(&test_vctrl, &test_netdev, 300);
1788         KUNIT_EXPECT_EQ(test, 0, ret);
1789         KUNIT_EXPECT_EQ(test, 774, test_move_addr);
1790         KUNIT_EXPECT_EQ(test, -4, test_move_offset);
1791         KUNIT_EXPECT_EQ(test, 2, test_move_count);
1792         KUNIT_EXPECT_EQ(test, 774, test_init_start);
1793         KUNIT_EXPECT_EQ(test, 4, test_init_count);
1794         KUNIT_EXPECT_EQ(test, 778, admin.last_used_addr);
1795
1796         test_init_rule_deletion();
1797         ret = vcap_del_rule(&test_vctrl, &test_netdev, 500);
1798         KUNIT_EXPECT_EQ(test, 0, ret);
1799         KUNIT_EXPECT_EQ(test, 778, test_move_addr);
1800         KUNIT_EXPECT_EQ(test, -20, test_move_offset);
1801         KUNIT_EXPECT_EQ(test, 2, test_move_count);
1802         KUNIT_EXPECT_EQ(test, 778, test_init_start);
1803         KUNIT_EXPECT_EQ(test, 20, test_init_count);
1804         KUNIT_EXPECT_EQ(test, 798, admin.last_used_addr);
1805
1806         test_init_rule_deletion();
1807         ret = vcap_del_rule(&test_vctrl, &test_netdev, 200);
1808         KUNIT_EXPECT_EQ(test, 0, ret);
1809         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1810         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1811         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1812         KUNIT_EXPECT_EQ(test, 798, test_init_start);
1813         KUNIT_EXPECT_EQ(test, 2, test_init_count);
1814         KUNIT_EXPECT_EQ(test, 800, admin.last_used_addr);
1815 }
1816
1817 static void vcap_api_rule_remove_in_front_test(struct kunit *test)
1818 {
1819         /* Data used by VCAP Library callback */
1820         static u32 keydata[32] = {};
1821         static u32 mskdata[32] = {};
1822         static u32 actdata[32] = {};
1823
1824         struct vcap_admin admin = {
1825                 .vtype = VCAP_TYPE_IS0,
1826                 .first_cid = 10000,
1827                 .last_cid = 19999,
1828                 .lookups = 4,
1829                 .first_valid_addr = 0,
1830                 .last_used_addr = 800,
1831                 .last_valid_addr = 800 - 1,
1832                 .cache = {
1833                         .keystream = keydata,
1834                         .maskstream = mskdata,
1835                         .actionstream = actdata,
1836                 },
1837         };
1838         int ret;
1839
1840         vcap_test_api_init(&admin);
1841
1842         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 10, 500, 12, 780);
1843         KUNIT_EXPECT_EQ(test, 780, admin.last_used_addr);
1844
1845         test_init_rule_deletion();
1846         ret = vcap_del_rule(&test_vctrl, &test_netdev, 500);
1847         KUNIT_EXPECT_EQ(test, 0, ret);
1848         KUNIT_EXPECT_EQ(test, 0, test_move_addr);
1849         KUNIT_EXPECT_EQ(test, 0, test_move_offset);
1850         KUNIT_EXPECT_EQ(test, 0, test_move_count);
1851         KUNIT_EXPECT_EQ(test, 780, test_init_start);
1852         KUNIT_EXPECT_EQ(test, 12, test_init_count);
1853         KUNIT_EXPECT_EQ(test, 800, admin.last_used_addr);
1854
1855         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 20, 400, 6, 792);
1856         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 30, 300, 3, 789);
1857         test_vcap_xn_rule_creator(test, 10000, VCAP_USER_QOS, 40, 200, 2, 786);
1858
1859         test_init_rule_deletion();
1860         ret = vcap_del_rule(&test_vctrl, &test_netdev, 400);
1861         KUNIT_EXPECT_EQ(test, 0, ret);
1862         KUNIT_EXPECT_EQ(test, 786, test_move_addr);
1863         KUNIT_EXPECT_EQ(test, -8, test_move_offset);
1864         KUNIT_EXPECT_EQ(test, 6, test_move_count);
1865         KUNIT_EXPECT_EQ(test, 786, test_init_start);
1866         KUNIT_EXPECT_EQ(test, 8, test_init_count);
1867         KUNIT_EXPECT_EQ(test, 794, admin.last_used_addr);
1868
1869         vcap_del_rule(&test_vctrl, &test_netdev, 200);
1870         vcap_del_rule(&test_vctrl, &test_netdev, 300);
1871 }
1872
1873 static struct kunit_case vcap_api_rule_remove_test_cases[] = {
1874         KUNIT_CASE(vcap_api_rule_remove_at_end_test),
1875         KUNIT_CASE(vcap_api_rule_remove_in_middle_test),
1876         KUNIT_CASE(vcap_api_rule_remove_in_front_test),
1877         {}
1878 };
1879
1880 static void vcap_api_next_lookup_basic_test(struct kunit *test)
1881 {
1882         struct vcap_admin admin1 = {
1883                 .vtype = VCAP_TYPE_IS2,
1884                 .vinst = 0,
1885                 .first_cid = 8000000,
1886                 .last_cid = 8199999,
1887                 .lookups = 4,
1888                 .lookups_per_instance = 2,
1889         };
1890         struct vcap_admin admin2 = {
1891                 .vtype = VCAP_TYPE_IS2,
1892                 .vinst = 1,
1893                 .first_cid = 8200000,
1894                 .last_cid = 8399999,
1895                 .lookups = 4,
1896                 .lookups_per_instance = 2,
1897         };
1898         bool ret;
1899
1900         vcap_test_api_init(&admin1);
1901         list_add_tail(&admin2.list, &test_vctrl.list);
1902
1903         ret = vcap_is_next_lookup(&test_vctrl, 8000000, 1001000);
1904         KUNIT_EXPECT_EQ(test, false, ret);
1905         ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8001000);
1906         KUNIT_EXPECT_EQ(test, false, ret);
1907         ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8101000);
1908         KUNIT_EXPECT_EQ(test, true, ret);
1909
1910         ret = vcap_is_next_lookup(&test_vctrl, 8100000, 8101000);
1911         KUNIT_EXPECT_EQ(test, false, ret);
1912         ret = vcap_is_next_lookup(&test_vctrl, 8100000, 8201000);
1913         KUNIT_EXPECT_EQ(test, true, ret);
1914
1915         ret = vcap_is_next_lookup(&test_vctrl, 8200000, 8201000);
1916         KUNIT_EXPECT_EQ(test, false, ret);
1917         ret = vcap_is_next_lookup(&test_vctrl, 8200000, 8301000);
1918         KUNIT_EXPECT_EQ(test, true, ret);
1919
1920         ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8301000);
1921         KUNIT_EXPECT_EQ(test, false, ret);
1922         ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8401000);
1923         KUNIT_EXPECT_EQ(test, false, ret);
1924 }
1925
1926 static void vcap_api_next_lookup_advanced_test(struct kunit *test)
1927 {
1928         struct vcap_admin admin[] = {
1929         {
1930                 .vtype = VCAP_TYPE_IS0,
1931                 .vinst = 0,
1932                 .first_cid = 1000000,
1933                 .last_cid =  1199999,
1934                 .lookups = 6,
1935                 .lookups_per_instance = 2,
1936         }, {
1937                 .vtype = VCAP_TYPE_IS0,
1938                 .vinst = 1,
1939                 .first_cid = 1200000,
1940                 .last_cid =  1399999,
1941                 .lookups = 6,
1942                 .lookups_per_instance = 2,
1943         }, {
1944                 .vtype = VCAP_TYPE_IS0,
1945                 .vinst = 2,
1946                 .first_cid = 1400000,
1947                 .last_cid =  1599999,
1948                 .lookups = 6,
1949                 .lookups_per_instance = 2,
1950         }, {
1951                 .vtype = VCAP_TYPE_IS2,
1952                 .vinst = 0,
1953                 .first_cid = 8000000,
1954                 .last_cid = 8199999,
1955                 .lookups = 4,
1956                 .lookups_per_instance = 2,
1957         }, {
1958                 .vtype = VCAP_TYPE_IS2,
1959                 .vinst = 1,
1960                 .first_cid = 8200000,
1961                 .last_cid = 8399999,
1962                 .lookups = 4,
1963                 .lookups_per_instance = 2,
1964         }
1965         };
1966         bool ret;
1967
1968         vcap_test_api_init(&admin[0]);
1969         list_add_tail(&admin[1].list, &test_vctrl.list);
1970         list_add_tail(&admin[2].list, &test_vctrl.list);
1971         list_add_tail(&admin[3].list, &test_vctrl.list);
1972         list_add_tail(&admin[4].list, &test_vctrl.list);
1973
1974         ret = vcap_is_next_lookup(&test_vctrl, 1000000, 1001000);
1975         KUNIT_EXPECT_EQ(test, false, ret);
1976         ret = vcap_is_next_lookup(&test_vctrl, 1000000, 1101000);
1977         KUNIT_EXPECT_EQ(test, true, ret);
1978
1979         ret = vcap_is_next_lookup(&test_vctrl, 1100000, 1201000);
1980         KUNIT_EXPECT_EQ(test, true, ret);
1981         ret = vcap_is_next_lookup(&test_vctrl, 1100000, 1301000);
1982         KUNIT_EXPECT_EQ(test, true, ret);
1983         ret = vcap_is_next_lookup(&test_vctrl, 1100000, 8101000);
1984         KUNIT_EXPECT_EQ(test, true, ret);
1985         ret = vcap_is_next_lookup(&test_vctrl, 1300000, 1401000);
1986         KUNIT_EXPECT_EQ(test, true, ret);
1987         ret = vcap_is_next_lookup(&test_vctrl, 1400000, 1501000);
1988         KUNIT_EXPECT_EQ(test, true, ret);
1989         ret = vcap_is_next_lookup(&test_vctrl, 1500000, 8001000);
1990         KUNIT_EXPECT_EQ(test, true, ret);
1991
1992         ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8001000);
1993         KUNIT_EXPECT_EQ(test, false, ret);
1994         ret = vcap_is_next_lookup(&test_vctrl, 8000000, 8101000);
1995         KUNIT_EXPECT_EQ(test, true, ret);
1996
1997         ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8301000);
1998         KUNIT_EXPECT_EQ(test, false, ret);
1999         ret = vcap_is_next_lookup(&test_vctrl, 8300000, 8401000);
2000         KUNIT_EXPECT_EQ(test, false, ret);
2001 }
2002
2003 static void vcap_api_filter_unsupported_keys_test(struct kunit *test)
2004 {
2005         struct vcap_admin admin = {
2006                 .vtype = VCAP_TYPE_IS2,
2007         };
2008         struct vcap_rule_internal ri = {
2009                 .admin = &admin,
2010                 .vctrl = &test_vctrl,
2011                 .data.keyset = VCAP_KFS_MAC_ETYPE,
2012         };
2013         enum vcap_key_field keylist[] = {
2014                 VCAP_KF_TYPE,
2015                 VCAP_KF_LOOKUP_FIRST_IS,
2016                 VCAP_KF_ARP_ADDR_SPACE_OK_IS,  /* arp keys are not in keyset */
2017                 VCAP_KF_ARP_PROTO_SPACE_OK_IS,
2018                 VCAP_KF_ARP_LEN_OK_IS,
2019                 VCAP_KF_ARP_TGT_MATCH_IS,
2020                 VCAP_KF_ARP_SENDER_MATCH_IS,
2021                 VCAP_KF_ARP_OPCODE_UNKNOWN_IS,
2022                 VCAP_KF_ARP_OPCODE,
2023                 VCAP_KF_8021Q_DEI_CLS,
2024                 VCAP_KF_8021Q_PCP_CLS,
2025                 VCAP_KF_8021Q_VID_CLS,
2026                 VCAP_KF_L2_MC_IS,
2027                 VCAP_KF_L2_BC_IS,
2028         };
2029         enum vcap_key_field expected[] = {
2030                 VCAP_KF_TYPE,
2031                 VCAP_KF_LOOKUP_FIRST_IS,
2032                 VCAP_KF_8021Q_DEI_CLS,
2033                 VCAP_KF_8021Q_PCP_CLS,
2034                 VCAP_KF_8021Q_VID_CLS,
2035                 VCAP_KF_L2_MC_IS,
2036                 VCAP_KF_L2_BC_IS,
2037         };
2038         struct vcap_client_keyfield *ckf, *next;
2039         bool ret;
2040         int idx;
2041
2042         /* Add all keys to the rule */
2043         INIT_LIST_HEAD(&ri.data.keyfields);
2044         for (idx = 0; idx < ARRAY_SIZE(keylist); idx++) {
2045                 ckf = kzalloc(sizeof(*ckf), GFP_KERNEL);
2046                 if (ckf) {
2047                         ckf->ctrl.key = keylist[idx];
2048                         list_add_tail(&ckf->ctrl.list, &ri.data.keyfields);
2049                 }
2050         }
2051
2052         KUNIT_EXPECT_EQ(test, 14, ARRAY_SIZE(keylist));
2053
2054         /* Drop unsupported keys from the rule */
2055         ret = vcap_filter_rule_keys(&ri.data, NULL, 0, true);
2056
2057         KUNIT_EXPECT_EQ(test, 0, ret);
2058
2059         /* Check remaining keys in the rule */
2060         idx = 0;
2061         list_for_each_entry_safe(ckf, next, &ri.data.keyfields, ctrl.list) {
2062                 KUNIT_EXPECT_EQ(test, expected[idx], ckf->ctrl.key);
2063                 list_del(&ckf->ctrl.list);
2064                 kfree(ckf);
2065                 ++idx;
2066         }
2067         KUNIT_EXPECT_EQ(test, 7, idx);
2068 }
2069
2070 static void vcap_api_filter_keylist_test(struct kunit *test)
2071 {
2072         struct vcap_admin admin = {
2073                 .vtype = VCAP_TYPE_IS0,
2074         };
2075         struct vcap_rule_internal ri = {
2076                 .admin = &admin,
2077                 .vctrl = &test_vctrl,
2078                 .data.keyset = VCAP_KFS_NORMAL_7TUPLE,
2079         };
2080         enum vcap_key_field keylist[] = {
2081                 VCAP_KF_TYPE,
2082                 VCAP_KF_LOOKUP_FIRST_IS,
2083                 VCAP_KF_LOOKUP_GEN_IDX_SEL,
2084                 VCAP_KF_LOOKUP_GEN_IDX,
2085                 VCAP_KF_IF_IGR_PORT_MASK_SEL,
2086                 VCAP_KF_IF_IGR_PORT_MASK,
2087                 VCAP_KF_L2_MC_IS,
2088                 VCAP_KF_L2_BC_IS,
2089                 VCAP_KF_8021Q_VLAN_TAGS,
2090                 VCAP_KF_8021Q_TPID0,
2091                 VCAP_KF_8021Q_PCP0,
2092                 VCAP_KF_8021Q_DEI0,
2093                 VCAP_KF_8021Q_VID0,
2094                 VCAP_KF_8021Q_TPID1,
2095                 VCAP_KF_8021Q_PCP1,
2096                 VCAP_KF_8021Q_DEI1,
2097                 VCAP_KF_8021Q_VID1,
2098                 VCAP_KF_8021Q_TPID2,
2099                 VCAP_KF_8021Q_PCP2,
2100                 VCAP_KF_8021Q_DEI2,
2101                 VCAP_KF_8021Q_VID2,
2102                 VCAP_KF_L2_DMAC,
2103                 VCAP_KF_L2_SMAC,
2104                 VCAP_KF_IP_MC_IS,
2105                 VCAP_KF_ETYPE_LEN_IS,
2106                 VCAP_KF_ETYPE,
2107                 VCAP_KF_IP_SNAP_IS,
2108                 VCAP_KF_IP4_IS,
2109                 VCAP_KF_L3_FRAGMENT_TYPE,
2110                 VCAP_KF_L3_FRAG_INVLD_L4_LEN,
2111                 VCAP_KF_L3_OPTIONS_IS,
2112                 VCAP_KF_L3_DSCP,
2113                 VCAP_KF_L3_IP6_DIP,
2114                 VCAP_KF_L3_IP6_SIP,
2115                 VCAP_KF_TCP_UDP_IS,
2116                 VCAP_KF_TCP_IS,
2117                 VCAP_KF_L4_SPORT,
2118                 VCAP_KF_L4_RNG,
2119         };
2120         enum vcap_key_field droplist[] = {
2121                 VCAP_KF_8021Q_TPID1,
2122                 VCAP_KF_8021Q_PCP1,
2123                 VCAP_KF_8021Q_DEI1,
2124                 VCAP_KF_8021Q_VID1,
2125                 VCAP_KF_8021Q_TPID2,
2126                 VCAP_KF_8021Q_PCP2,
2127                 VCAP_KF_8021Q_DEI2,
2128                 VCAP_KF_8021Q_VID2,
2129                 VCAP_KF_L3_IP6_DIP,
2130                 VCAP_KF_L3_IP6_SIP,
2131                 VCAP_KF_L4_SPORT,
2132                 VCAP_KF_L4_RNG,
2133         };
2134         enum vcap_key_field expected[] = {
2135                 VCAP_KF_TYPE,
2136                 VCAP_KF_LOOKUP_FIRST_IS,
2137                 VCAP_KF_LOOKUP_GEN_IDX_SEL,
2138                 VCAP_KF_LOOKUP_GEN_IDX,
2139                 VCAP_KF_IF_IGR_PORT_MASK_SEL,
2140                 VCAP_KF_IF_IGR_PORT_MASK,
2141                 VCAP_KF_L2_MC_IS,
2142                 VCAP_KF_L2_BC_IS,
2143                 VCAP_KF_8021Q_VLAN_TAGS,
2144                 VCAP_KF_8021Q_TPID0,
2145                 VCAP_KF_8021Q_PCP0,
2146                 VCAP_KF_8021Q_DEI0,
2147                 VCAP_KF_8021Q_VID0,
2148                 VCAP_KF_L2_DMAC,
2149                 VCAP_KF_L2_SMAC,
2150                 VCAP_KF_IP_MC_IS,
2151                 VCAP_KF_ETYPE_LEN_IS,
2152                 VCAP_KF_ETYPE,
2153                 VCAP_KF_IP_SNAP_IS,
2154                 VCAP_KF_IP4_IS,
2155                 VCAP_KF_L3_FRAGMENT_TYPE,
2156                 VCAP_KF_L3_FRAG_INVLD_L4_LEN,
2157                 VCAP_KF_L3_OPTIONS_IS,
2158                 VCAP_KF_L3_DSCP,
2159                 VCAP_KF_TCP_UDP_IS,
2160                 VCAP_KF_TCP_IS,
2161         };
2162         struct vcap_client_keyfield *ckf, *next;
2163         bool ret;
2164         int idx;
2165
2166         /* Add all keys to the rule */
2167         INIT_LIST_HEAD(&ri.data.keyfields);
2168         for (idx = 0; idx < ARRAY_SIZE(keylist); idx++) {
2169                 ckf = kzalloc(sizeof(*ckf), GFP_KERNEL);
2170                 if (ckf) {
2171                         ckf->ctrl.key = keylist[idx];
2172                         list_add_tail(&ckf->ctrl.list, &ri.data.keyfields);
2173                 }
2174         }
2175
2176         KUNIT_EXPECT_EQ(test, 38, ARRAY_SIZE(keylist));
2177
2178         /* Drop listed keys from the rule */
2179         ret = vcap_filter_rule_keys(&ri.data, droplist, ARRAY_SIZE(droplist),
2180                                     false);
2181
2182         KUNIT_EXPECT_EQ(test, 0, ret);
2183
2184         /* Check remaining keys in the rule */
2185         idx = 0;
2186         list_for_each_entry_safe(ckf, next, &ri.data.keyfields, ctrl.list) {
2187                 KUNIT_EXPECT_EQ(test, expected[idx], ckf->ctrl.key);
2188                 list_del(&ckf->ctrl.list);
2189                 kfree(ckf);
2190                 ++idx;
2191         }
2192         KUNIT_EXPECT_EQ(test, 26, idx);
2193 }
2194
2195 static void vcap_api_rule_chain_path_test(struct kunit *test)
2196 {
2197         struct vcap_admin admin1 = {
2198                 .vtype = VCAP_TYPE_IS0,
2199                 .vinst = 0,
2200                 .first_cid = 1000000,
2201                 .last_cid =  1199999,
2202                 .lookups = 6,
2203                 .lookups_per_instance = 2,
2204         };
2205         struct vcap_enabled_port eport3 = {
2206                 .ndev = &test_netdev,
2207                 .cookie = 0x100,
2208                 .src_cid = 0,
2209                 .dst_cid = 1000000,
2210         };
2211         struct vcap_enabled_port eport2 = {
2212                 .ndev = &test_netdev,
2213                 .cookie = 0x200,
2214                 .src_cid = 1000000,
2215                 .dst_cid = 1100000,
2216         };
2217         struct vcap_enabled_port eport1 = {
2218                 .ndev = &test_netdev,
2219                 .cookie = 0x300,
2220                 .src_cid = 1100000,
2221                 .dst_cid = 8000000,
2222         };
2223         bool ret;
2224         int chain;
2225
2226         vcap_test_api_init(&admin1);
2227         list_add_tail(&eport1.list, &admin1.enabled);
2228         list_add_tail(&eport2.list, &admin1.enabled);
2229         list_add_tail(&eport3.list, &admin1.enabled);
2230
2231         ret = vcap_path_exist(&test_vctrl, &test_netdev, 1000000);
2232         KUNIT_EXPECT_EQ(test, true, ret);
2233
2234         ret = vcap_path_exist(&test_vctrl, &test_netdev, 1100000);
2235         KUNIT_EXPECT_EQ(test, true, ret);
2236
2237         ret = vcap_path_exist(&test_vctrl, &test_netdev, 1200000);
2238         KUNIT_EXPECT_EQ(test, false, ret);
2239
2240         chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 0);
2241         KUNIT_EXPECT_EQ(test, 1000000, chain);
2242
2243         chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 1000000);
2244         KUNIT_EXPECT_EQ(test, 1100000, chain);
2245
2246         chain = vcap_get_next_chain(&test_vctrl, &test_netdev, 1100000);
2247         KUNIT_EXPECT_EQ(test, 8000000, chain);
2248 }
2249
2250 static struct kunit_case vcap_api_rule_enable_test_cases[] = {
2251         KUNIT_CASE(vcap_api_rule_chain_path_test),
2252         {}
2253 };
2254
2255 static struct kunit_suite vcap_api_rule_enable_test_suite = {
2256         .name = "VCAP_API_Rule_Enable_Testsuite",
2257         .test_cases = vcap_api_rule_enable_test_cases,
2258 };
2259
2260 static struct kunit_suite vcap_api_rule_remove_test_suite = {
2261         .name = "VCAP_API_Rule_Remove_Testsuite",
2262         .test_cases = vcap_api_rule_remove_test_cases,
2263 };
2264
2265 static struct kunit_case vcap_api_rule_insert_test_cases[] = {
2266         KUNIT_CASE(vcap_api_rule_insert_in_order_test),
2267         KUNIT_CASE(vcap_api_rule_insert_reverse_order_test),
2268         {}
2269 };
2270
2271 static struct kunit_suite vcap_api_rule_insert_test_suite = {
2272         .name = "VCAP_API_Rule_Insert_Testsuite",
2273         .test_cases = vcap_api_rule_insert_test_cases,
2274 };
2275
2276 static struct kunit_case vcap_api_rule_counter_test_cases[] = {
2277         KUNIT_CASE(vcap_api_set_rule_counter_test),
2278         KUNIT_CASE(vcap_api_get_rule_counter_test),
2279         {}
2280 };
2281
2282 static struct kunit_suite vcap_api_rule_counter_test_suite = {
2283         .name = "VCAP_API_Rule_Counter_Testsuite",
2284         .test_cases = vcap_api_rule_counter_test_cases,
2285 };
2286
2287 static struct kunit_case vcap_api_support_test_cases[] = {
2288         KUNIT_CASE(vcap_api_next_lookup_basic_test),
2289         KUNIT_CASE(vcap_api_next_lookup_advanced_test),
2290         KUNIT_CASE(vcap_api_filter_unsupported_keys_test),
2291         KUNIT_CASE(vcap_api_filter_keylist_test),
2292         {}
2293 };
2294
2295 static struct kunit_suite vcap_api_support_test_suite = {
2296         .name = "VCAP_API_Support_Testsuite",
2297         .test_cases = vcap_api_support_test_cases,
2298 };
2299
2300 static struct kunit_case vcap_api_full_rule_test_cases[] = {
2301         KUNIT_CASE(vcap_api_rule_find_keyset_basic_test),
2302         KUNIT_CASE(vcap_api_rule_find_keyset_failed_test),
2303         KUNIT_CASE(vcap_api_rule_find_keyset_many_test),
2304         KUNIT_CASE(vcap_api_encode_rule_test),
2305         {}
2306 };
2307
2308 static struct kunit_suite vcap_api_full_rule_test_suite = {
2309         .name = "VCAP_API_Full_Rule_Testsuite",
2310         .test_cases = vcap_api_full_rule_test_cases,
2311 };
2312
2313 static struct kunit_case vcap_api_rule_value_test_cases[] = {
2314         KUNIT_CASE(vcap_api_rule_add_keyvalue_test),
2315         KUNIT_CASE(vcap_api_rule_add_actionvalue_test),
2316         {}
2317 };
2318
2319 static struct kunit_suite vcap_api_rule_value_test_suite = {
2320         .name = "VCAP_API_Rule_Value_Testsuite",
2321         .test_cases = vcap_api_rule_value_test_cases,
2322 };
2323
2324 static struct kunit_case vcap_api_encoding_test_cases[] = {
2325         KUNIT_CASE(vcap_api_set_bit_1_test),
2326         KUNIT_CASE(vcap_api_set_bit_0_test),
2327         KUNIT_CASE(vcap_api_iterator_init_test),
2328         KUNIT_CASE(vcap_api_iterator_next_test),
2329         KUNIT_CASE(vcap_api_encode_typegroups_test),
2330         KUNIT_CASE(vcap_api_encode_bit_test),
2331         KUNIT_CASE(vcap_api_encode_field_test),
2332         KUNIT_CASE(vcap_api_encode_short_field_test),
2333         KUNIT_CASE(vcap_api_encode_keyfield_test),
2334         KUNIT_CASE(vcap_api_encode_max_keyfield_test),
2335         KUNIT_CASE(vcap_api_encode_actionfield_test),
2336         KUNIT_CASE(vcap_api_keyfield_typegroup_test),
2337         KUNIT_CASE(vcap_api_actionfield_typegroup_test),
2338         KUNIT_CASE(vcap_api_vcap_keyfields_test),
2339         KUNIT_CASE(vcap_api_vcap_actionfields_test),
2340         KUNIT_CASE(vcap_api_encode_rule_keyset_test),
2341         KUNIT_CASE(vcap_api_encode_rule_actionset_test),
2342         {}
2343 };
2344
2345 static struct kunit_suite vcap_api_encoding_test_suite = {
2346         .name = "VCAP_API_Encoding_Testsuite",
2347         .test_cases = vcap_api_encoding_test_cases,
2348 };
2349
2350 kunit_test_suite(vcap_api_rule_enable_test_suite);
2351 kunit_test_suite(vcap_api_rule_remove_test_suite);
2352 kunit_test_suite(vcap_api_rule_insert_test_suite);
2353 kunit_test_suite(vcap_api_rule_counter_test_suite);
2354 kunit_test_suite(vcap_api_support_test_suite);
2355 kunit_test_suite(vcap_api_full_rule_test_suite);
2356 kunit_test_suite(vcap_api_rule_value_test_suite);
2357 kunit_test_suite(vcap_api_encoding_test_suite);