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