drivers/net/bnxt/tf_core/tf_tbl.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019-2021 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 /* Truflow Table APIs and supporting code */
   7
   8 #include <rte_common.h>
   9
  10 #include "tf_tbl.h"
  11 #include "tf_common.h"
  12 #include "tf_rm.h"
  13 #include "tf_util.h"
  14 #include "tf_msg.h"
  15 #include "tfp.h"
  16 #include "tf_session.h"
  17 #include "tf_device.h"
  18
  19 #define TF_TBL_RM_TO_PTR(new_idx, idx, base, shift) {           \
  20                 *(new_idx) = (((idx) + (base)) << (shift));     \
  21 }
  22
  23 #define TF_TBL_PTR_TO_RM(new_idx, idx, base, shift) {           \
  24                 *(new_idx) = (((idx) >> (shift)) - (base));     \
  25 }
  26
  27 struct tf;
  28
  29 /**
  30  * Table Shadow DBs
  31  */
  32 static void *shadow_tbl_db[TF_DIR_MAX];
  33
  34 /**
  35  * Shadow init flag, set on bind and cleared on unbind
  36  */
  37 static uint8_t shadow_init;
  38
  39 int
  40 tf_tbl_bind(struct tf *tfp,
  41             struct tf_tbl_cfg_parms *parms)
  42 {
  43         int rc, d, i;
  44         int db_rc[TF_DIR_MAX] = { 0 };
  45         struct tf_rm_create_db_parms db_cfg = { 0 };
  46         struct tbl_rm_db *tbl_db;
  47         struct tfp_calloc_parms cparms;
  48         struct tf_session *tfs;
  49
  50         TF_CHECK_PARMS2(tfp, parms);
  51
  52         /* Retrieve the session information */
  53         rc = tf_session_get_session_internal(tfp, &tfs);
  54         if (rc)
  55                 return rc;
  56
  57         memset(&db_cfg, 0, sizeof(db_cfg));
  58         cparms.nitems = 1;
  59         cparms.size = sizeof(struct tbl_rm_db);
  60         cparms.alignment = 0;
  61         if (tfp_calloc(&cparms) != 0) {
  62                 TFP_DRV_LOG(ERR, "tbl_rm_db alloc error %s\n",
  63                             strerror(ENOMEM));
  64                 return -ENOMEM;
  65         }
  66
  67         tbl_db = cparms.mem_va;
  68         for (i = 0; i < TF_DIR_MAX; i++)
  69                 tbl_db->tbl_db[i] = NULL;
  70         tf_session_set_db(tfp, TF_MODULE_TYPE_TABLE, tbl_db);
  71
  72         db_cfg.num_elements = parms->num_elements;
  73         db_cfg.module = TF_MODULE_TYPE_TABLE;
  74         db_cfg.num_elements = parms->num_elements;
  75         db_cfg.cfg = parms->cfg;
  76
  77         for (d = 0; d < TF_DIR_MAX; d++) {
  78                 db_cfg.dir = d;
  79                 db_cfg.alloc_cnt = parms->resources->tbl_cnt[d].cnt;
  80                 db_cfg.rm_db = (void *)&tbl_db->tbl_db[d];
  81                 if (tf_session_is_shared_session(tfs) &&
  82                         (!tf_session_is_shared_session_creator(tfs)))
  83                         db_rc[d] = tf_rm_create_db_no_reservation(tfp, &db_cfg);
  84                 else
  85                         db_rc[d] = tf_rm_create_db(tfp, &db_cfg);
  86         }
  87
  88         /* No db created */
  89         if (db_rc[TF_DIR_RX] && db_rc[TF_DIR_TX]) {
  90                 TFP_DRV_LOG(ERR,
  91                             "%s: No Table DB created\n",
  92                             tf_dir_2_str(d));
  93                 return db_rc[TF_DIR_RX];
  94         }
  95
  96         TFP_DRV_LOG(INFO,
  97                     "Table Type - initialized\n");
  98
  99         return 0;
 100 }
 101
 102 int
 103 tf_tbl_unbind(struct tf *tfp)
 104 {
 105         int rc;
 106         int i;
 107         struct tf_rm_free_db_parms fparms = { 0 };
 108         struct tbl_rm_db *tbl_db;
 109         void *tbl_db_ptr = NULL;
 110         TF_CHECK_PARMS1(tfp);
 111
 112         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 113         if (rc)
 114                 return 0;
 115         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 116
 117         for (i = 0; i < TF_DIR_MAX; i++) {
 118                 if (tbl_db->tbl_db[i] == NULL)
 119                         continue;
 120                 fparms.dir = i;
 121                 fparms.rm_db = tbl_db->tbl_db[i];
 122                 rc = tf_rm_free_db(tfp, &fparms);
 123                 if (rc)
 124                         return rc;
 125
 126                 tbl_db->tbl_db[i] = NULL;
 127         }
 128
 129         shadow_init = 0;
 130
 131         return 0;
 132 }
 133
 134 int
 135 tf_tbl_alloc(struct tf *tfp __rte_unused,
 136              struct tf_tbl_alloc_parms *parms)
 137 {
 138         int rc;
 139         uint32_t idx;
 140         struct tf_rm_allocate_parms aparms = { 0 };
 141         struct tf_session *tfs;
 142         struct tf_dev_info *dev;
 143         uint16_t base = 0, shift = 0;
 144         struct tbl_rm_db *tbl_db;
 145         void *tbl_db_ptr = NULL;
 146
 147         TF_CHECK_PARMS2(tfp, parms);
 148
 149         /* Retrieve the session information */
 150         rc = tf_session_get_session_internal(tfp, &tfs);
 151         if (rc)
 152                 return rc;
 153
 154         /* Retrieve the device information */
 155         rc = tf_session_get_device(tfs, &dev);
 156         if (rc)
 157                 return rc;
 158
 159         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 160         if (rc) {
 161                 TFP_DRV_LOG(ERR,
 162                             "Failed to get em_ext_db from session, rc:%s\n",
 163                             strerror(-rc));
 164                 return rc;
 165         }
 166         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 167
 168         /* Only get table info if required for the device */
 169         if (dev->ops->tf_dev_get_tbl_info) {
 170                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 171                                                    tbl_db->tbl_db[parms->dir],
 172                                                    parms->type,
 173                                                    &base,
 174                                                    &shift);
 175                 if (rc) {
 176                         TFP_DRV_LOG(ERR,
 177                                     "%s: Failed to get table info:%d\n",
 178                                     tf_dir_2_str(parms->dir),
 179                                     parms->type);
 180                         return rc;
 181                 }
 182         }
 183
 184         /* Allocate requested element */
 185         aparms.rm_db = tbl_db->tbl_db[parms->dir];
 186         aparms.subtype = parms->type;
 187         aparms.index = &idx;
 188         rc = tf_rm_allocate(&aparms);
 189         if (rc) {
 190                 TFP_DRV_LOG(ERR,
 191                             "%s: Failed allocate, type:%d\n",
 192                             tf_dir_2_str(parms->dir),
 193                             parms->type);
 194                 return rc;
 195         }
 196
 197         TF_TBL_RM_TO_PTR(&idx, idx, base, shift);
 198         *parms->idx = idx;
 199
 200         return 0;
 201 }
 202
 203 int
 204 tf_tbl_free(struct tf *tfp __rte_unused,
 205             struct tf_tbl_free_parms *parms)
 206 {
 207         int rc;
 208         struct tf_rm_is_allocated_parms aparms = { 0 };
 209         struct tf_rm_free_parms fparms = { 0 };
 210         int allocated = 0;
 211         struct tf_session *tfs;
 212         struct tf_dev_info *dev;
 213         uint16_t base = 0, shift = 0;
 214         struct tbl_rm_db *tbl_db;
 215         void *tbl_db_ptr = NULL;
 216
 217         TF_CHECK_PARMS2(tfp, parms);
 218
 219         /* Retrieve the session information */
 220         rc = tf_session_get_session_internal(tfp, &tfs);
 221         if (rc)
 222                 return rc;
 223
 224         /* Retrieve the device information */
 225         rc = tf_session_get_device(tfs, &dev);
 226         if (rc)
 227                 return rc;
 228
 229         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 230         if (rc) {
 231                 TFP_DRV_LOG(ERR,
 232                             "Failed to get em_ext_db from session, rc:%s\n",
 233                             strerror(-rc));
 234                 return rc;
 235         }
 236         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 237
 238         /* Only get table info if required for the device */
 239         if (dev->ops->tf_dev_get_tbl_info) {
 240                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 241                                                    tbl_db->tbl_db[parms->dir],
 242                                                    parms->type,
 243                                                    &base,
 244                                                    &shift);
 245                 if (rc) {
 246                         TFP_DRV_LOG(ERR,
 247                                     "%s: Failed to get table info:%d\n",
 248                                     tf_dir_2_str(parms->dir),
 249                                     parms->type);
 250                         return rc;
 251                 }
 252         }
 253
 254         /* Check if element is in use */
 255         aparms.rm_db = tbl_db->tbl_db[parms->dir];
 256         aparms.subtype = parms->type;
 257
 258         TF_TBL_PTR_TO_RM(&aparms.index, parms->idx, base, shift);
 259
 260         aparms.allocated = &allocated;
 261         rc = tf_rm_is_allocated(&aparms);
 262         if (rc)
 263                 return rc;
 264
 265         if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
 266                 TFP_DRV_LOG(ERR,
 267                             "%s: Entry already free, type:%d, index:%d\n",
 268                             tf_dir_2_str(parms->dir),
 269                             parms->type,
 270                             parms->idx);
 271                 return -EINVAL;
 272         }
 273
 274         /* If this is counter table, clear the entry on free */
 275         if (parms->type == TF_TBL_TYPE_ACT_STATS_64) {
 276                 uint8_t data[8] = { 0 };
 277                 uint16_t hcapi_type = 0;
 278                 struct tf_rm_get_hcapi_parms hparms = { 0 };
 279
 280                 /* Get the hcapi type */
 281                 hparms.rm_db = tbl_db->tbl_db[parms->dir];
 282                 hparms.subtype = parms->type;
 283                 hparms.hcapi_type = &hcapi_type;
 284                 rc = tf_rm_get_hcapi_type(&hparms);
 285                 if (rc) {
 286                         TFP_DRV_LOG(ERR,
 287                                     "%s, Failed type lookup, type:%d, rc:%s\n",
 288                                     tf_dir_2_str(parms->dir),
 289                                     parms->type,
 290                                     strerror(-rc));
 291                         return rc;
 292                 }
 293                 /* Clear the counter
 294                  */
 295                 rc = tf_msg_set_tbl_entry(tfp,
 296                                           parms->dir,
 297                                           hcapi_type,
 298                                           sizeof(data),
 299                                           data,
 300                                           parms->idx);
 301                 if (rc) {
 302                         TFP_DRV_LOG(ERR,
 303                                     "%s, Set failed, type:%d, rc:%s\n",
 304                                     tf_dir_2_str(parms->dir),
 305                                     parms->type,
 306                                     strerror(-rc));
 307                         return rc;
 308                 }
 309         }
 310
 311         /* Free requested element */
 312         fparms.rm_db = tbl_db->tbl_db[parms->dir];
 313         fparms.subtype = parms->type;
 314
 315         TF_TBL_PTR_TO_RM(&fparms.index, parms->idx, base, shift);
 316
 317         rc = tf_rm_free(&fparms);
 318         if (rc) {
 319                 TFP_DRV_LOG(ERR,
 320                             "%s: Free failed, type:%d, index:%d\n",
 321                             tf_dir_2_str(parms->dir),
 322                             parms->type,
 323                             parms->idx);
 324                 return rc;
 325         }
 326
 327         return 0;
 328 }
 329
 330 int
 331 tf_tbl_alloc_search(struct tf *tfp,
 332                     struct tf_tbl_alloc_search_parms *parms)
 333 {
 334         int rc = 0;
 335         TF_CHECK_PARMS2(tfp, parms);
 336
 337         if (!shadow_init || !shadow_tbl_db[parms->dir]) {
 338                 TFP_DRV_LOG(ERR, "%s: Shadow TBL not initialized.\n",
 339                             tf_dir_2_str(parms->dir));
 340                 return -EINVAL;
 341         }
 342
 343         return rc;
 344 }
 345
 346 int
 347 tf_tbl_set(struct tf *tfp,
 348            struct tf_tbl_set_parms *parms)
 349 {
 350         int rc;
 351         int allocated = 0;
 352         uint16_t hcapi_type;
 353         struct tf_rm_is_allocated_parms aparms = { 0 };
 354         struct tf_rm_get_hcapi_parms hparms = { 0 };
 355         struct tf_session *tfs;
 356         struct tf_dev_info *dev;
 357         uint16_t base = 0, shift = 0;
 358         struct tbl_rm_db *tbl_db;
 359         void *tbl_db_ptr = NULL;
 360
 361         TF_CHECK_PARMS3(tfp, parms, parms->data);
 362
 363         /* Retrieve the session information */
 364         rc = tf_session_get_session_internal(tfp, &tfs);
 365         if (rc)
 366                 return rc;
 367
 368         /* Retrieve the device information */
 369         rc = tf_session_get_device(tfs, &dev);
 370         if (rc)
 371                 return rc;
 372
 373         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 374         if (rc) {
 375                 TFP_DRV_LOG(ERR,
 376                             "Failed to get em_ext_db from session, rc:%s\n",
 377                             strerror(-rc));
 378                 return rc;
 379         }
 380         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 381
 382         /* Only get table info if required for the device */
 383         if (dev->ops->tf_dev_get_tbl_info) {
 384                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 385                                                    tbl_db->tbl_db[parms->dir],
 386                                                    parms->type,
 387                                                    &base,
 388                                                    &shift);
 389                 if (rc) {
 390                         TFP_DRV_LOG(ERR,
 391                                     "%s: Failed to get table info:%d\n",
 392                                     tf_dir_2_str(parms->dir),
 393                                     parms->type);
 394                         return rc;
 395                 }
 396         }
 397
 398         /* Verify that the entry has been previously allocated */
 399         aparms.rm_db = tbl_db->tbl_db[parms->dir];
 400         aparms.subtype = parms->type;
 401         TF_TBL_PTR_TO_RM(&aparms.index, parms->idx, base, shift);
 402
 403         aparms.allocated = &allocated;
 404         rc = tf_rm_is_allocated(&aparms);
 405         if (rc)
 406                 return rc;
 407
 408         if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
 409                 TFP_DRV_LOG(ERR,
 410                    "%s, Invalid or not allocated index, type:%d, idx:%d\n",
 411                    tf_dir_2_str(parms->dir),
 412                    parms->type,
 413                    parms->idx);
 414                 return -EINVAL;
 415         }
 416
 417         /* Set the entry */
 418         hparms.rm_db = tbl_db->tbl_db[parms->dir];
 419         hparms.subtype = parms->type;
 420         hparms.hcapi_type = &hcapi_type;
 421         rc = tf_rm_get_hcapi_type(&hparms);
 422         if (rc) {
 423                 TFP_DRV_LOG(ERR,
 424                             "%s, Failed type lookup, type:%d, rc:%s\n",
 425                             tf_dir_2_str(parms->dir),
 426                             parms->type,
 427                             strerror(-rc));
 428                 return rc;
 429         }
 430
 431         rc = tf_msg_set_tbl_entry(tfp,
 432                                   parms->dir,
 433                                   hcapi_type,
 434                                   parms->data_sz_in_bytes,
 435                                   parms->data,
 436                                   parms->idx);
 437         if (rc) {
 438                 TFP_DRV_LOG(ERR,
 439                             "%s, Set failed, type:%d, rc:%s\n",
 440                             tf_dir_2_str(parms->dir),
 441                             parms->type,
 442                             strerror(-rc));
 443                 return rc;
 444         }
 445
 446         return 0;
 447 }
 448
 449 int
 450 tf_tbl_get(struct tf *tfp,
 451            struct tf_tbl_get_parms *parms)
 452 {
 453         int rc;
 454         uint16_t hcapi_type;
 455         int allocated = 0;
 456         struct tf_rm_is_allocated_parms aparms = { 0 };
 457         struct tf_rm_get_hcapi_parms hparms = { 0 };
 458         struct tf_session *tfs;
 459         struct tf_dev_info *dev;
 460         uint16_t base = 0, shift = 0;
 461         struct tbl_rm_db *tbl_db;
 462         void *tbl_db_ptr = NULL;
 463
 464         TF_CHECK_PARMS3(tfp, parms, parms->data);
 465
 466         /* Retrieve the session information */
 467         rc = tf_session_get_session_internal(tfp, &tfs);
 468         if (rc)
 469                 return rc;
 470
 471         /* Retrieve the device information */
 472         rc = tf_session_get_device(tfs, &dev);
 473         if (rc)
 474                 return rc;
 475
 476         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 477         if (rc) {
 478                 TFP_DRV_LOG(ERR,
 479                             "Failed to get em_ext_db from session, rc:%s\n",
 480                             strerror(-rc));
 481                 return rc;
 482         }
 483         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 484
 485         /* Only get table info if required for the device */
 486         if (dev->ops->tf_dev_get_tbl_info) {
 487                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 488                                                    tbl_db->tbl_db[parms->dir],
 489                                                    parms->type,
 490                                                    &base,
 491                                                    &shift);
 492                 if (rc) {
 493                         TFP_DRV_LOG(ERR,
 494                                     "%s: Failed to get table info:%d\n",
 495                                     tf_dir_2_str(parms->dir),
 496                                     parms->type);
 497                         return rc;
 498                 }
 499         }
 500
 501         /* Verify that the entry has been previously allocated */
 502         aparms.rm_db = tbl_db->tbl_db[parms->dir];
 503         aparms.subtype = parms->type;
 504         TF_TBL_PTR_TO_RM(&aparms.index, parms->idx, base, shift);
 505
 506         aparms.allocated = &allocated;
 507         rc = tf_rm_is_allocated(&aparms);
 508         if (rc)
 509                 return rc;
 510
 511         if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
 512                 TFP_DRV_LOG(ERR,
 513                    "%s, Invalid or not allocated index, type:%d, idx:%d\n",
 514                    tf_dir_2_str(parms->dir),
 515                    parms->type,
 516                    parms->idx);
 517                 return -EINVAL;
 518         }
 519
 520         /* Set the entry */
 521         hparms.rm_db = tbl_db->tbl_db[parms->dir];
 522         hparms.subtype = parms->type;
 523         hparms.hcapi_type = &hcapi_type;
 524         rc = tf_rm_get_hcapi_type(&hparms);
 525         if (rc) {
 526                 TFP_DRV_LOG(ERR,
 527                             "%s, Failed type lookup, type:%d, rc:%s\n",
 528                             tf_dir_2_str(parms->dir),
 529                             parms->type,
 530                             strerror(-rc));
 531                 return rc;
 532         }
 533
 534         /* Get the entry */
 535         rc = tf_msg_get_tbl_entry(tfp,
 536                                   parms->dir,
 537                                   hcapi_type,
 538                                   parms->data_sz_in_bytes,
 539                                   parms->data,
 540                                   parms->idx);
 541         if (rc) {
 542                 TFP_DRV_LOG(ERR,
 543                             "%s, Get failed, type:%d, rc:%s\n",
 544                             tf_dir_2_str(parms->dir),
 545                             parms->type,
 546                             strerror(-rc));
 547                 return rc;
 548         }
 549
 550         return 0;
 551 }
 552
 553 int
 554 tf_tbl_bulk_get(struct tf *tfp,
 555                 struct tf_tbl_get_bulk_parms *parms)
 556 {
 557         int rc;
 558         uint16_t hcapi_type;
 559         struct tf_rm_get_hcapi_parms hparms = { 0 };
 560         struct tf_rm_check_indexes_in_range_parms cparms = { 0 };
 561         struct tf_session *tfs;
 562         struct tf_dev_info *dev;
 563         uint16_t base = 0, shift = 0;
 564         struct tbl_rm_db *tbl_db;
 565         void *tbl_db_ptr = NULL;
 566
 567         TF_CHECK_PARMS2(tfp, parms);
 568
 569         /* Retrieve the session information */
 570         rc = tf_session_get_session_internal(tfp, &tfs);
 571         if (rc)
 572                 return rc;
 573
 574         /* Retrieve the device information */
 575         rc = tf_session_get_device(tfs, &dev);
 576         if (rc)
 577                 return rc;
 578
 579         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 580         if (rc) {
 581                 TFP_DRV_LOG(ERR,
 582                             "Failed to get em_ext_db from session, rc:%s\n",
 583                             strerror(-rc));
 584                 return rc;
 585         }
 586         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 587
 588         /* Only get table info if required for the device */
 589         if (dev->ops->tf_dev_get_tbl_info) {
 590                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 591                                                    tbl_db->tbl_db[parms->dir],
 592                                                    parms->type,
 593                                                    &base,
 594                                                    &shift);
 595                 if (rc) {
 596                         TFP_DRV_LOG(ERR,
 597                                     "%s: Failed to get table info:%d\n",
 598                                     tf_dir_2_str(parms->dir),
 599                                     parms->type);
 600                         return rc;
 601                 }
 602         }
 603
 604         /* Verify that the entries are in the range of reserved resources. */
 605         cparms.rm_db = tbl_db->tbl_db[parms->dir];
 606         cparms.subtype = parms->type;
 607
 608         TF_TBL_PTR_TO_RM(&cparms.starting_index, parms->starting_idx,
 609                          base, shift);
 610
 611         cparms.num_entries = parms->num_entries;
 612
 613         rc = tf_rm_check_indexes_in_range(&cparms);
 614         if (rc) {
 615                 TFP_DRV_LOG(ERR,
 616                             "%s, Invalid or %d index starting from %d"
 617                             " not in range, type:%d",
 618                             tf_dir_2_str(parms->dir),
 619                             parms->starting_idx,
 620                             parms->num_entries,
 621                             parms->type);
 622                 return rc;
 623         }
 624
 625         hparms.rm_db = tbl_db->tbl_db[parms->dir];
 626         hparms.subtype = parms->type;
 627         hparms.hcapi_type = &hcapi_type;
 628         rc = tf_rm_get_hcapi_type(&hparms);
 629         if (rc) {
 630                 TFP_DRV_LOG(ERR,
 631                             "%s, Failed type lookup, type:%d, rc:%s\n",
 632                             tf_dir_2_str(parms->dir),
 633                             parms->type,
 634                             strerror(-rc));
 635                 return rc;
 636         }
 637
 638         /* Get the entries */
 639         rc = tf_msg_bulk_get_tbl_entry(tfp,
 640                                        parms->dir,
 641                                        hcapi_type,
 642                                        parms->starting_idx,
 643                                        parms->num_entries,
 644                                        parms->entry_sz_in_bytes,
 645                                        parms->physical_mem_addr);
 646         if (rc) {
 647                 TFP_DRV_LOG(ERR,
 648                             "%s, Bulk get failed, type:%d, rc:%s\n",
 649                             tf_dir_2_str(parms->dir),
 650                             parms->type,
 651                             strerror(-rc));
 652         }
 653
 654         return rc;
 655 }
 656
 657 int
 658 tf_tbl_get_resc_info(struct tf *tfp,
 659                      struct tf_tbl_resource_info *tbl)
 660 {
 661         int rc;
 662         int d, i;
 663         struct tf_resource_info *dinfo;
 664         struct tf_rm_get_alloc_info_parms ainfo;
 665         void *tbl_db_ptr = NULL;
 666         struct tbl_rm_db *tbl_db;
 667         uint16_t base = 0, shift = 0;
 668         struct tf_dev_info *dev;
 669         struct tf_session *tfs;
 670
 671         TF_CHECK_PARMS2(tfp, tbl);
 672
 673         /* Retrieve the session information */
 674         rc = tf_session_get_session_internal(tfp, &tfs);
 675         if (rc)
 676                 return rc;
 677
 678         /* Retrieve the device information */
 679         rc = tf_session_get_device(tfs, &dev);
 680         if (rc)
 681                 return rc;
 682
 683         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 684         if (rc == -ENOMEM)
 685                 return 0; /* db doesn't exist */
 686         else if (rc)
 687                 return rc; /* error getting db */
 688
 689         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 690
 691         /* check if reserved resource for WC is multiple of num_slices */
 692         for (d = 0; d < TF_DIR_MAX; d++) {
 693                 ainfo.rm_db = tbl_db->tbl_db[d];
 694                 dinfo = tbl[d].info;
 695
 696                 if (!ainfo.rm_db)
 697                         continue;
 698
 699                 ainfo.info = (struct tf_rm_alloc_info *)dinfo;
 700                 ainfo.subtype = 0;
 701                 rc = tf_rm_get_all_info(&ainfo, TF_TBL_TYPE_MAX);
 702                 if (rc)
 703                         return rc;
 704
 705                 if (dev->ops->tf_dev_get_tbl_info) {
 706                         /* Adjust all */
 707                         for (i = 0; i < TF_TBL_TYPE_MAX; i++) {
 708                                 /* Only get table info if required for the device */
 709                                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 710                                                                    tbl_db->tbl_db[d],
 711                                                                    i,
 712                                                                    &base,
 713                                                                    &shift);
 714                                 if (rc) {
 715                                         TFP_DRV_LOG(ERR,
 716                                                     "%s: Failed to get table info:%d\n",
 717                                                     tf_dir_2_str(d),
 718                                                     i);
 719                                         return rc;
 720                                 }
 721                                 if (dinfo[i].stride)
 722                                         TF_TBL_RM_TO_PTR(&dinfo[i].start,
 723                                                          dinfo[i].start,
 724                                                          base,
 725                                                          shift);
 726                         }
 727                 }
 728         }
 729
 730         return 0;
 731 }