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         /* Verify that the entry has been previously allocated */
 378         aparms.rm_db = tbl_db->tbl_db[parms->dir];
 379         aparms.subtype = parms->type;
 380         TF_TBL_PTR_TO_RM(&aparms.index, parms->idx, base, shift);
 381
 382         aparms.allocated = &allocated;
 383         rc = tf_rm_is_allocated(&aparms);
 384         if (rc)
 385                 return rc;
 386
 387         if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
 388                 TFP_DRV_LOG(ERR,
 389                    "%s, Invalid or not allocated index, type:%d, idx:%d\n",
 390                    tf_dir_2_str(parms->dir),
 391                    parms->type,
 392                    parms->idx);
 393                 return -EINVAL;
 394         }
 395
 396         /* Set the entry */
 397         hparms.rm_db = tbl_db->tbl_db[parms->dir];
 398         hparms.subtype = parms->type;
 399         hparms.hcapi_type = &hcapi_type;
 400         rc = tf_rm_get_hcapi_type(&hparms);
 401         if (rc) {
 402                 TFP_DRV_LOG(ERR,
 403                             "%s, Failed type lookup, type:%d, rc:%s\n",
 404                             tf_dir_2_str(parms->dir),
 405                             parms->type,
 406                             strerror(-rc));
 407                 return rc;
 408         }
 409
 410         rc = tf_msg_set_tbl_entry(tfp,
 411                                   parms->dir,
 412                                   hcapi_type,
 413                                   parms->data_sz_in_bytes,
 414                                   parms->data,
 415                                   parms->idx);
 416         if (rc) {
 417                 TFP_DRV_LOG(ERR,
 418                             "%s, Set failed, type:%d, rc:%s\n",
 419                             tf_dir_2_str(parms->dir),
 420                             parms->type,
 421                             strerror(-rc));
 422                 return rc;
 423         }
 424
 425         return 0;
 426 }
 427
 428 int
 429 tf_tbl_get(struct tf *tfp,
 430            struct tf_tbl_get_parms *parms)
 431 {
 432         int rc;
 433         uint16_t hcapi_type;
 434         int allocated = 0;
 435         struct tf_rm_is_allocated_parms aparms = { 0 };
 436         struct tf_rm_get_hcapi_parms hparms = { 0 };
 437         struct tf_session *tfs;
 438         struct tf_dev_info *dev;
 439         uint16_t base = 0, shift = 0;
 440         struct tbl_rm_db *tbl_db;
 441         void *tbl_db_ptr = NULL;
 442
 443         TF_CHECK_PARMS3(tfp, parms, parms->data);
 444
 445         /* Retrieve the session information */
 446         rc = tf_session_get_session_internal(tfp, &tfs);
 447         if (rc)
 448                 return rc;
 449
 450         /* Retrieve the device information */
 451         rc = tf_session_get_device(tfs, &dev);
 452         if (rc)
 453                 return rc;
 454
 455         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 456         if (rc) {
 457                 TFP_DRV_LOG(ERR,
 458                             "Failed to get em_ext_db from session, rc:%s\n",
 459                             strerror(-rc));
 460                 return rc;
 461         }
 462         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 463
 464         /* Only get table info if required for the device */
 465         if (dev->ops->tf_dev_get_tbl_info) {
 466                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 467                                                    tbl_db->tbl_db[parms->dir],
 468                                                    parms->type,
 469                                                    &base,
 470                                                    &shift);
 471                 if (rc) {
 472                         TFP_DRV_LOG(ERR,
 473                                     "%s: Failed to get table info:%d\n",
 474                                     tf_dir_2_str(parms->dir),
 475                                     parms->type);
 476                         return rc;
 477                 }
 478         }
 479
 480         /* Verify that the entry has been previously allocated */
 481         aparms.rm_db = tbl_db->tbl_db[parms->dir];
 482         aparms.subtype = parms->type;
 483         TF_TBL_PTR_TO_RM(&aparms.index, parms->idx, base, shift);
 484
 485         aparms.allocated = &allocated;
 486         rc = tf_rm_is_allocated(&aparms);
 487         if (rc)
 488                 return rc;
 489
 490         if (allocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
 491                 TFP_DRV_LOG(ERR,
 492                    "%s, Invalid or not allocated index, type:%d, idx:%d\n",
 493                    tf_dir_2_str(parms->dir),
 494                    parms->type,
 495                    parms->idx);
 496                 return -EINVAL;
 497         }
 498
 499         /* Set the entry */
 500         hparms.rm_db = tbl_db->tbl_db[parms->dir];
 501         hparms.subtype = parms->type;
 502         hparms.hcapi_type = &hcapi_type;
 503         rc = tf_rm_get_hcapi_type(&hparms);
 504         if (rc) {
 505                 TFP_DRV_LOG(ERR,
 506                             "%s, Failed type lookup, type:%d, rc:%s\n",
 507                             tf_dir_2_str(parms->dir),
 508                             parms->type,
 509                             strerror(-rc));
 510                 return rc;
 511         }
 512
 513         /* Get the entry */
 514         rc = tf_msg_get_tbl_entry(tfp,
 515                                   parms->dir,
 516                                   hcapi_type,
 517                                   parms->data_sz_in_bytes,
 518                                   parms->data,
 519                                   parms->idx);
 520         if (rc) {
 521                 TFP_DRV_LOG(ERR,
 522                             "%s, Get failed, type:%d, rc:%s\n",
 523                             tf_dir_2_str(parms->dir),
 524                             parms->type,
 525                             strerror(-rc));
 526                 return rc;
 527         }
 528
 529         return 0;
 530 }
 531
 532 int
 533 tf_tbl_bulk_get(struct tf *tfp,
 534                 struct tf_tbl_get_bulk_parms *parms)
 535 {
 536         int rc;
 537         uint16_t hcapi_type;
 538         struct tf_rm_get_hcapi_parms hparms = { 0 };
 539         struct tf_rm_check_indexes_in_range_parms cparms = { 0 };
 540         struct tf_session *tfs;
 541         struct tf_dev_info *dev;
 542         uint16_t base = 0, shift = 0;
 543         struct tbl_rm_db *tbl_db;
 544         void *tbl_db_ptr = NULL;
 545
 546         TF_CHECK_PARMS2(tfp, parms);
 547
 548         /* Retrieve the session information */
 549         rc = tf_session_get_session_internal(tfp, &tfs);
 550         if (rc)
 551                 return rc;
 552
 553         /* Retrieve the device information */
 554         rc = tf_session_get_device(tfs, &dev);
 555         if (rc)
 556                 return rc;
 557
 558         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 559         if (rc) {
 560                 TFP_DRV_LOG(ERR,
 561                             "Failed to get em_ext_db from session, rc:%s\n",
 562                             strerror(-rc));
 563                 return rc;
 564         }
 565         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 566
 567         /* Only get table info if required for the device */
 568         if (dev->ops->tf_dev_get_tbl_info) {
 569                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 570                                                    tbl_db->tbl_db[parms->dir],
 571                                                    parms->type,
 572                                                    &base,
 573                                                    &shift);
 574                 if (rc) {
 575                         TFP_DRV_LOG(ERR,
 576                                     "%s: Failed to get table info:%d\n",
 577                                     tf_dir_2_str(parms->dir),
 578                                     parms->type);
 579                         return rc;
 580                 }
 581         }
 582
 583         /* Verify that the entries are in the range of reserved resources. */
 584         cparms.rm_db = tbl_db->tbl_db[parms->dir];
 585         cparms.subtype = parms->type;
 586
 587         TF_TBL_PTR_TO_RM(&cparms.starting_index, parms->starting_idx,
 588                          base, shift);
 589
 590         cparms.num_entries = parms->num_entries;
 591
 592         rc = tf_rm_check_indexes_in_range(&cparms);
 593         if (rc) {
 594                 TFP_DRV_LOG(ERR,
 595                             "%s, Invalid or %d index starting from %d"
 596                             " not in range, type:%d",
 597                             tf_dir_2_str(parms->dir),
 598                             parms->starting_idx,
 599                             parms->num_entries,
 600                             parms->type);
 601                 return rc;
 602         }
 603
 604         hparms.rm_db = tbl_db->tbl_db[parms->dir];
 605         hparms.subtype = parms->type;
 606         hparms.hcapi_type = &hcapi_type;
 607         rc = tf_rm_get_hcapi_type(&hparms);
 608         if (rc) {
 609                 TFP_DRV_LOG(ERR,
 610                             "%s, Failed type lookup, type:%d, rc:%s\n",
 611                             tf_dir_2_str(parms->dir),
 612                             parms->type,
 613                             strerror(-rc));
 614                 return rc;
 615         }
 616
 617         /* Get the entries */
 618         rc = tf_msg_bulk_get_tbl_entry(tfp,
 619                                        parms->dir,
 620                                        hcapi_type,
 621                                        parms->starting_idx,
 622                                        parms->num_entries,
 623                                        parms->entry_sz_in_bytes,
 624                                        parms->physical_mem_addr);
 625         if (rc) {
 626                 TFP_DRV_LOG(ERR,
 627                             "%s, Bulk get failed, type:%d, rc:%s\n",
 628                             tf_dir_2_str(parms->dir),
 629                             parms->type,
 630                             strerror(-rc));
 631         }
 632
 633         return rc;
 634 }
 635
 636 int
 637 tf_tbl_get_resc_info(struct tf *tfp,
 638                      struct tf_tbl_resource_info *tbl)
 639 {
 640         int rc;
 641         int d, i;
 642         struct tf_resource_info *dinfo;
 643         struct tf_rm_get_alloc_info_parms ainfo;
 644         void *tbl_db_ptr = NULL;
 645         struct tbl_rm_db *tbl_db;
 646         uint16_t base = 0, shift = 0;
 647         struct tf_dev_info *dev;
 648         struct tf_session *tfs;
 649
 650         TF_CHECK_PARMS2(tfp, tbl);
 651
 652         /* Retrieve the session information */
 653         rc = tf_session_get_session_internal(tfp, &tfs);
 654         if (rc)
 655                 return rc;
 656
 657         /* Retrieve the device information */
 658         rc = tf_session_get_device(tfs, &dev);
 659         if (rc)
 660                 return rc;
 661
 662         rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
 663         if (rc == -ENOMEM)
 664                 return 0; /* db doesn't exist */
 665         else if (rc)
 666                 return rc; /* error getting db */
 667
 668         tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
 669
 670         /* check if reserved resource for WC is multiple of num_slices */
 671         for (d = 0; d < TF_DIR_MAX; d++) {
 672                 ainfo.rm_db = tbl_db->tbl_db[d];
 673                 dinfo = tbl[d].info;
 674
 675                 if (!ainfo.rm_db)
 676                         continue;
 677
 678                 ainfo.info = (struct tf_rm_alloc_info *)dinfo;
 679                 ainfo.subtype = 0;
 680                 rc = tf_rm_get_all_info(&ainfo, TF_TBL_TYPE_MAX);
 681                 if (rc)
 682                         return rc;
 683
 684                 if (dev->ops->tf_dev_get_tbl_info) {
 685                         /* Adjust all */
 686                         for (i = 0; i < TF_TBL_TYPE_MAX; i++) {
 687                                 /* Only get table info if required for the device */
 688                                 rc = dev->ops->tf_dev_get_tbl_info(tfp,
 689                                                                    tbl_db->tbl_db[d],
 690                                                                    i,
 691                                                                    &base,
 692                                                                    &shift);
 693                                 if (rc) {
 694                                         TFP_DRV_LOG(ERR,
 695                                                     "%s: Failed to get table info:%d\n",
 696                                                     tf_dir_2_str(d),
 697                                                     i);
 698                                         return rc;
 699                                 }
 700                                 if (dinfo[i].stride)
 701                                         TF_TBL_RM_TO_PTR(&dinfo[i].start,
 702                                                          dinfo[i].start,
 703                                                          base,
 704                                                          shift);
 705                         }
 706                 }
 707         }
 708
 709         return 0;
 710 }