drivers/net/ethernet/netronome/nfp/nic/dcb.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2023 Corigine, Inc. */
   3
   4 #include <linux/device.h>
   5 #include <linux/netdevice.h>
   6 #include <net/dcbnl.h>
   7
   8 #include "../nfp_app.h"
   9 #include "../nfp_net.h"
  10 #include "../nfp_main.h"
  11 #include "../nfpcore/nfp_cpp.h"
  12 #include "../nfpcore/nfp_nffw.h"
  13 #include "../nfp_net_sriov.h"
  14
  15 #include "main.h"
  16
  17 #define NFP_DCB_TRUST_PCP       1
  18 #define NFP_DCB_TRUST_DSCP      2
  19 #define NFP_DCB_TRUST_INVALID   0xff
  20
  21 #define NFP_DCB_TSA_VENDOR      1
  22 #define NFP_DCB_TSA_STRICT      2
  23 #define NFP_DCB_TSA_ETS         3
  24
  25 #define NFP_DCB_GBL_ENABLE      BIT(0)
  26 #define NFP_DCB_QOS_ENABLE      BIT(1)
  27 #define NFP_DCB_DISABLE         0
  28 #define NFP_DCB_ALL_QOS_ENABLE  (NFP_DCB_GBL_ENABLE | NFP_DCB_QOS_ENABLE)
  29
  30 #define NFP_DCB_UPDATE_MSK_SZ   4
  31 #define NFP_DCB_TC_RATE_MAX     0xffff
  32
  33 #define NFP_DCB_DATA_OFF_DSCP2IDX       0
  34 #define NFP_DCB_DATA_OFF_PCP2IDX        64
  35 #define NFP_DCB_DATA_OFF_TSA            80
  36 #define NFP_DCB_DATA_OFF_IDX_BW_PCT     88
  37 #define NFP_DCB_DATA_OFF_RATE           96
  38 #define NFP_DCB_DATA_OFF_CAP            112
  39 #define NFP_DCB_DATA_OFF_ENABLE         116
  40 #define NFP_DCB_DATA_OFF_TRUST          120
  41
  42 #define NFP_DCB_MSG_MSK_ENABLE  BIT(31)
  43 #define NFP_DCB_MSG_MSK_TRUST   BIT(30)
  44 #define NFP_DCB_MSG_MSK_TSA     BIT(29)
  45 #define NFP_DCB_MSG_MSK_DSCP    BIT(28)
  46 #define NFP_DCB_MSG_MSK_PCP     BIT(27)
  47 #define NFP_DCB_MSG_MSK_RATE    BIT(26)
  48 #define NFP_DCB_MSG_MSK_PCT     BIT(25)
  49
  50 static struct nfp_dcb *get_dcb_priv(struct nfp_net *nn)
  51 {
  52         struct nfp_dcb *dcb = &((struct nfp_app_nic_private *)nn->app_priv)->dcb;
  53
  54         return dcb;
  55 }
  56
  57 static u8 nfp_tsa_ieee2nfp(u8 tsa)
  58 {
  59         switch (tsa) {
  60         case IEEE_8021QAZ_TSA_STRICT:
  61                 return NFP_DCB_TSA_STRICT;
  62         case IEEE_8021QAZ_TSA_ETS:
  63                 return NFP_DCB_TSA_ETS;
  64         default:
  65                 return NFP_DCB_TSA_VENDOR;
  66         }
  67 }
  68
  69 static int nfp_nic_dcbnl_ieee_getets(struct net_device *dev,
  70                                      struct ieee_ets *ets)
  71 {
  72         struct nfp_net *nn = netdev_priv(dev);
  73         struct nfp_dcb *dcb;
  74
  75         dcb = get_dcb_priv(nn);
  76
  77         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
  78                 ets->prio_tc[i] = dcb->prio2tc[i];
  79                 ets->tc_tx_bw[i] = dcb->tc_tx_pct[i];
  80                 ets->tc_tsa[i] = dcb->tc_tsa[i];
  81         }
  82
  83         return 0;
  84 }
  85
  86 static bool nfp_refresh_tc2idx(struct nfp_net *nn)
  87 {
  88         u8 tc2idx[IEEE_8021QAZ_MAX_TCS];
  89         bool change = false;
  90         struct nfp_dcb *dcb;
  91         int maxstrict = 0;
  92
  93         dcb = get_dcb_priv(nn);
  94
  95         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
  96                 tc2idx[i] = i;
  97                 if (dcb->tc_tsa[i] == IEEE_8021QAZ_TSA_STRICT)
  98                         maxstrict = i;
  99         }
 100
 101         if (maxstrict > 0 && dcb->tc_tsa[0] != IEEE_8021QAZ_TSA_STRICT) {
 102                 tc2idx[0] = maxstrict;
 103                 tc2idx[maxstrict] = 0;
 104         }
 105
 106         for (unsigned int j = 0; j < IEEE_8021QAZ_MAX_TCS; j++) {
 107                 if (dcb->tc2idx[j] != tc2idx[j]) {
 108                         change = true;
 109                         dcb->tc2idx[j] = tc2idx[j];
 110                 }
 111         }
 112
 113         return change;
 114 }
 115
 116 static int nfp_fill_maxrate(struct nfp_net *nn, u64 *max_rate_array)
 117 {
 118         struct nfp_app *app  = nn->app;
 119         struct nfp_dcb *dcb;
 120         u32 ratembps;
 121
 122         dcb = get_dcb_priv(nn);
 123
 124         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 125                 /* Convert bandwidth from kbps to mbps. */
 126                 ratembps = max_rate_array[i] / 1024;
 127
 128                 /* Reject input values >= NFP_DCB_TC_RATE_MAX */
 129                 if (ratembps >= NFP_DCB_TC_RATE_MAX) {
 130                         nfp_warn(app->cpp, "ratembps(%d) must less than %d.",
 131                                  ratembps, NFP_DCB_TC_RATE_MAX);
 132                         return -EINVAL;
 133                 }
 134                 /* Input value 0 mapped to NFP_DCB_TC_RATE_MAX for firmware. */
 135                 if (ratembps == 0)
 136                         ratembps = NFP_DCB_TC_RATE_MAX;
 137
 138                 writew((u16)ratembps, dcb->dcbcfg_tbl +
 139                        dcb->cfg_offset + NFP_DCB_DATA_OFF_RATE + dcb->tc2idx[i] * 2);
 140                 /* for rate value from user space, need to sync to dcb structure */
 141                 if (dcb->tc_maxrate != max_rate_array)
 142                         dcb->tc_maxrate[i] = max_rate_array[i];
 143         }
 144
 145         return 0;
 146 }
 147
 148 static int update_dscp_maxrate(struct net_device *dev, u32 *update)
 149 {
 150         struct nfp_net *nn = netdev_priv(dev);
 151         struct nfp_dcb *dcb;
 152         int err;
 153
 154         dcb = get_dcb_priv(nn);
 155
 156         err = nfp_fill_maxrate(nn, dcb->tc_maxrate);
 157         if (err)
 158                 return err;
 159
 160         *update |= NFP_DCB_MSG_MSK_RATE;
 161
 162         /* We only refresh dscp in dscp trust mode. */
 163         if (dcb->dscp_cnt > 0) {
 164                 for (unsigned int i = 0; i < NFP_NET_MAX_DSCP; i++) {
 165                         writeb(dcb->tc2idx[dcb->prio2tc[dcb->dscp2prio[i]]],
 166                                dcb->dcbcfg_tbl + dcb->cfg_offset +
 167                                NFP_DCB_DATA_OFF_DSCP2IDX + i);
 168                 }
 169                 *update |= NFP_DCB_MSG_MSK_DSCP;
 170         }
 171
 172         return 0;
 173 }
 174
 175 static void nfp_nic_set_trust(struct nfp_net *nn, u32 *update)
 176 {
 177         struct nfp_dcb *dcb;
 178         u8 trust;
 179
 180         dcb = get_dcb_priv(nn);
 181
 182         if (dcb->trust_status != NFP_DCB_TRUST_INVALID)
 183                 return;
 184
 185         trust = dcb->dscp_cnt > 0 ? NFP_DCB_TRUST_DSCP : NFP_DCB_TRUST_PCP;
 186         writeb(trust, dcb->dcbcfg_tbl + dcb->cfg_offset +
 187                NFP_DCB_DATA_OFF_TRUST);
 188
 189         dcb->trust_status = trust;
 190         *update |= NFP_DCB_MSG_MSK_TRUST;
 191 }
 192
 193 static void nfp_nic_set_enable(struct nfp_net *nn, u32 enable, u32 *update)
 194 {
 195         struct nfp_dcb *dcb;
 196         u32 value = 0;
 197
 198         dcb = get_dcb_priv(nn);
 199
 200         value = readl(dcb->dcbcfg_tbl + dcb->cfg_offset +
 201                       NFP_DCB_DATA_OFF_ENABLE);
 202         if (value != enable) {
 203                 writel(enable, dcb->dcbcfg_tbl + dcb->cfg_offset +
 204                        NFP_DCB_DATA_OFF_ENABLE);
 205                 *update |= NFP_DCB_MSG_MSK_ENABLE;
 206         }
 207 }
 208
 209 static int dcb_ets_check(struct net_device *dev, struct ieee_ets *ets)
 210 {
 211         struct nfp_net *nn = netdev_priv(dev);
 212         struct nfp_app *app = nn->app;
 213         bool ets_exists = false;
 214         int sum = 0;
 215
 216         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 217                 /* For ets mode, check bw percentage sum. */
 218                 if (ets->tc_tsa[i] == IEEE_8021QAZ_TSA_ETS) {
 219                         ets_exists = true;
 220                         sum += ets->tc_tx_bw[i];
 221                 } else if (ets->tc_tx_bw[i]) {
 222                         nfp_warn(app->cpp, "ETS BW for strict/vendor TC must be 0.");
 223                         return -EINVAL;
 224                 }
 225         }
 226
 227         if (ets_exists && sum != 100) {
 228                 nfp_warn(app->cpp, "Failed to validate ETS BW: sum must be 100.");
 229                 return -EINVAL;
 230         }
 231
 232         return 0;
 233 }
 234
 235 static void nfp_nic_fill_ets(struct nfp_net *nn)
 236 {
 237         struct nfp_dcb *dcb;
 238
 239         dcb = get_dcb_priv(nn);
 240
 241         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 242                 writeb(dcb->tc2idx[dcb->prio2tc[i]],
 243                        dcb->dcbcfg_tbl + dcb->cfg_offset + NFP_DCB_DATA_OFF_PCP2IDX + i);
 244                 writeb(dcb->tc_tx_pct[i], dcb->dcbcfg_tbl +
 245                        dcb->cfg_offset + NFP_DCB_DATA_OFF_IDX_BW_PCT + dcb->tc2idx[i]);
 246                 writeb(nfp_tsa_ieee2nfp(dcb->tc_tsa[i]), dcb->dcbcfg_tbl +
 247                        dcb->cfg_offset + NFP_DCB_DATA_OFF_TSA + dcb->tc2idx[i]);
 248         }
 249 }
 250
 251 static void nfp_nic_ets_init(struct nfp_net *nn, u32 *update)
 252 {
 253         struct nfp_dcb *dcb = get_dcb_priv(nn);
 254
 255         if (dcb->ets_init)
 256                 return;
 257
 258         nfp_nic_fill_ets(nn);
 259         dcb->ets_init = true;
 260         *update |= NFP_DCB_MSG_MSK_TSA | NFP_DCB_MSG_MSK_PCT | NFP_DCB_MSG_MSK_PCP;
 261 }
 262
 263 static int nfp_nic_dcbnl_ieee_setets(struct net_device *dev,
 264                                      struct ieee_ets *ets)
 265 {
 266         const u32 cmd = NFP_NET_CFG_MBOX_CMD_DCB_UPDATE;
 267         struct nfp_net *nn = netdev_priv(dev);
 268         struct nfp_app *app = nn->app;
 269         struct nfp_dcb *dcb;
 270         u32 update = 0;
 271         bool change;
 272         int err;
 273
 274         err = dcb_ets_check(dev, ets);
 275         if (err)
 276                 return err;
 277
 278         dcb = get_dcb_priv(nn);
 279
 280         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 281                 dcb->prio2tc[i] = ets->prio_tc[i];
 282                 dcb->tc_tx_pct[i] = ets->tc_tx_bw[i];
 283                 dcb->tc_tsa[i] = ets->tc_tsa[i];
 284         }
 285
 286         change = nfp_refresh_tc2idx(nn);
 287         nfp_nic_fill_ets(nn);
 288         dcb->ets_init = true;
 289         if (change || !dcb->rate_init) {
 290                 err = update_dscp_maxrate(dev, &update);
 291                 if (err) {
 292                         nfp_warn(app->cpp,
 293                                  "nfp dcbnl ieee setets ERROR:%d.",
 294                                  err);
 295                         return err;
 296                 }
 297
 298                 dcb->rate_init = true;
 299         }
 300         nfp_nic_set_enable(nn, NFP_DCB_ALL_QOS_ENABLE, &update);
 301         nfp_nic_set_trust(nn, &update);
 302         err = nfp_net_mbox_lock(nn, NFP_DCB_UPDATE_MSK_SZ);
 303         if (err)
 304                 return err;
 305
 306         nn_writel(nn, nn->tlv_caps.mbox_off + NFP_NET_CFG_MBOX_SIMPLE_VAL,
 307                   update | NFP_DCB_MSG_MSK_TSA | NFP_DCB_MSG_MSK_PCT |
 308                   NFP_DCB_MSG_MSK_PCP);
 309
 310         return nfp_net_mbox_reconfig_and_unlock(nn, cmd);
 311 }
 312
 313 static int nfp_nic_dcbnl_ieee_getmaxrate(struct net_device *dev,
 314                                          struct ieee_maxrate *maxrate)
 315 {
 316         struct nfp_net *nn = netdev_priv(dev);
 317         struct nfp_dcb *dcb;
 318
 319         dcb = get_dcb_priv(nn);
 320
 321         for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
 322                 maxrate->tc_maxrate[i] = dcb->tc_maxrate[i];
 323
 324         return 0;
 325 }
 326
 327 static int nfp_nic_dcbnl_ieee_setmaxrate(struct net_device *dev,
 328                                          struct ieee_maxrate *maxrate)
 329 {
 330         const u32 cmd = NFP_NET_CFG_MBOX_CMD_DCB_UPDATE;
 331         struct nfp_net *nn = netdev_priv(dev);
 332         struct nfp_app *app = nn->app;
 333         struct nfp_dcb *dcb;
 334         u32 update = 0;
 335         int err;
 336
 337         err = nfp_fill_maxrate(nn, maxrate->tc_maxrate);
 338         if (err) {
 339                 nfp_warn(app->cpp,
 340                          "nfp dcbnl ieee setmaxrate ERROR:%d.",
 341                          err);
 342                 return err;
 343         }
 344
 345         dcb = get_dcb_priv(nn);
 346
 347         dcb->rate_init = true;
 348         nfp_nic_set_enable(nn, NFP_DCB_ALL_QOS_ENABLE, &update);
 349         nfp_nic_set_trust(nn, &update);
 350         nfp_nic_ets_init(nn, &update);
 351
 352         err = nfp_net_mbox_lock(nn, NFP_DCB_UPDATE_MSK_SZ);
 353         if (err)
 354                 return err;
 355
 356         nn_writel(nn, nn->tlv_caps.mbox_off + NFP_NET_CFG_MBOX_SIMPLE_VAL,
 357                   update | NFP_DCB_MSG_MSK_RATE);
 358
 359         return nfp_net_mbox_reconfig_and_unlock(nn, cmd);
 360 }
 361
 362 static int nfp_nic_set_trust_status(struct nfp_net *nn, u8 status)
 363 {
 364         const u32 cmd = NFP_NET_CFG_MBOX_CMD_DCB_UPDATE;
 365         struct nfp_dcb *dcb;
 366         u32 update = 0;
 367         int err;
 368
 369         dcb = get_dcb_priv(nn);
 370         if (!dcb->rate_init) {
 371                 err = nfp_fill_maxrate(nn, dcb->tc_maxrate);
 372                 if (err)
 373                         return err;
 374
 375                 update |= NFP_DCB_MSG_MSK_RATE;
 376                 dcb->rate_init = true;
 377         }
 378
 379         err = nfp_net_mbox_lock(nn, NFP_DCB_UPDATE_MSK_SZ);
 380         if (err)
 381                 return err;
 382
 383         nfp_nic_ets_init(nn, &update);
 384         writeb(status, dcb->dcbcfg_tbl + dcb->cfg_offset +
 385                NFP_DCB_DATA_OFF_TRUST);
 386         nfp_nic_set_enable(nn, NFP_DCB_ALL_QOS_ENABLE, &update);
 387         nn_writel(nn, nn->tlv_caps.mbox_off + NFP_NET_CFG_MBOX_SIMPLE_VAL,
 388                   update | NFP_DCB_MSG_MSK_TRUST);
 389
 390         err = nfp_net_mbox_reconfig_and_unlock(nn, cmd);
 391         if (err)
 392                 return err;
 393
 394         dcb->trust_status = status;
 395
 396         return 0;
 397 }
 398
 399 static int nfp_nic_set_dscp2prio(struct nfp_net *nn, u8 dscp, u8 prio)
 400 {
 401         const u32 cmd = NFP_NET_CFG_MBOX_CMD_DCB_UPDATE;
 402         struct nfp_dcb *dcb;
 403         u8 idx, tc;
 404         int err;
 405
 406         err = nfp_net_mbox_lock(nn, NFP_DCB_UPDATE_MSK_SZ);
 407         if (err)
 408                 return err;
 409
 410         dcb = get_dcb_priv(nn);
 411
 412         tc = dcb->prio2tc[prio];
 413         idx = dcb->tc2idx[tc];
 414
 415         writeb(idx, dcb->dcbcfg_tbl + dcb->cfg_offset +
 416                NFP_DCB_DATA_OFF_DSCP2IDX + dscp);
 417
 418         nn_writel(nn, nn->tlv_caps.mbox_off +
 419                   NFP_NET_CFG_MBOX_SIMPLE_VAL, NFP_DCB_MSG_MSK_DSCP);
 420
 421         err = nfp_net_mbox_reconfig_and_unlock(nn, cmd);
 422         if (err)
 423                 return err;
 424
 425         dcb->dscp2prio[dscp] = prio;
 426
 427         return 0;
 428 }
 429
 430 static int nfp_nic_dcbnl_ieee_setapp(struct net_device *dev,
 431                                      struct dcb_app *app)
 432 {
 433         struct nfp_net *nn = netdev_priv(dev);
 434         struct dcb_app old_app;
 435         struct nfp_dcb *dcb;
 436         bool is_new;
 437         int err;
 438
 439         if (app->selector != IEEE_8021QAZ_APP_SEL_DSCP)
 440                 return -EINVAL;
 441
 442         dcb = get_dcb_priv(nn);
 443
 444         /* Save the old entry info */
 445         old_app.selector = IEEE_8021QAZ_APP_SEL_DSCP;
 446         old_app.protocol = app->protocol;
 447         old_app.priority = dcb->dscp2prio[app->protocol];
 448
 449         /* Check trust status */
 450         if (!dcb->dscp_cnt) {
 451                 err = nfp_nic_set_trust_status(nn, NFP_DCB_TRUST_DSCP);
 452                 if (err)
 453                         return err;
 454         }
 455
 456         /* Check if the new mapping is same as old or in init stage */
 457         if (app->priority != old_app.priority || app->priority == 0) {
 458                 err = nfp_nic_set_dscp2prio(nn, app->protocol, app->priority);
 459                 if (err)
 460                         return err;
 461         }
 462
 463         /* Delete the old entry if exists */
 464         is_new = !!dcb_ieee_delapp(dev, &old_app);
 465
 466         /* Add new entry and update counter */
 467         err = dcb_ieee_setapp(dev, app);
 468         if (err)
 469                 return err;
 470
 471         if (is_new)
 472                 dcb->dscp_cnt++;
 473
 474         return 0;
 475 }
 476
 477 static int nfp_nic_dcbnl_ieee_delapp(struct net_device *dev,
 478                                      struct dcb_app *app)
 479 {
 480         struct nfp_net *nn = netdev_priv(dev);
 481         struct nfp_dcb *dcb;
 482         int err;
 483
 484         if (app->selector != IEEE_8021QAZ_APP_SEL_DSCP)
 485                 return -EINVAL;
 486
 487         dcb = get_dcb_priv(nn);
 488
 489         /* Check if the dcb_app param match fw */
 490         if (app->priority != dcb->dscp2prio[app->protocol])
 491                 return -ENOENT;
 492
 493         /* Set fw dscp mapping to 0 */
 494         err = nfp_nic_set_dscp2prio(nn, app->protocol, 0);
 495         if (err)
 496                 return err;
 497
 498         /* Delete app from dcb list */
 499         err = dcb_ieee_delapp(dev, app);
 500         if (err)
 501                 return err;
 502
 503         /* Decrease dscp counter */
 504         dcb->dscp_cnt--;
 505
 506         /* If no dscp mapping is configured, trust pcp */
 507         if (dcb->dscp_cnt == 0)
 508                 return nfp_nic_set_trust_status(nn, NFP_DCB_TRUST_PCP);
 509
 510         return 0;
 511 }
 512
 513 static const struct dcbnl_rtnl_ops nfp_nic_dcbnl_ops = {
 514         /* ieee 802.1Qaz std */
 515         .ieee_getets    = nfp_nic_dcbnl_ieee_getets,
 516         .ieee_setets    = nfp_nic_dcbnl_ieee_setets,
 517         .ieee_getmaxrate = nfp_nic_dcbnl_ieee_getmaxrate,
 518         .ieee_setmaxrate = nfp_nic_dcbnl_ieee_setmaxrate,
 519         .ieee_setapp    = nfp_nic_dcbnl_ieee_setapp,
 520         .ieee_delapp    = nfp_nic_dcbnl_ieee_delapp,
 521 };
 522
 523 int nfp_nic_dcb_init(struct nfp_net *nn)
 524 {
 525         struct nfp_app *app = nn->app;
 526         struct nfp_dcb *dcb;
 527         int err;
 528
 529         dcb = get_dcb_priv(nn);
 530         dcb->cfg_offset = NFP_DCB_CFG_STRIDE * nn->id;
 531         dcb->dcbcfg_tbl = nfp_pf_map_rtsym(app->pf, "net.dcbcfg_tbl",
 532                                            "_abi_dcb_cfg",
 533                                            dcb->cfg_offset, &dcb->dcbcfg_tbl_area);
 534         if (IS_ERR(dcb->dcbcfg_tbl)) {
 535                 if (PTR_ERR(dcb->dcbcfg_tbl) != -ENOENT) {
 536                         err = PTR_ERR(dcb->dcbcfg_tbl);
 537                         dcb->dcbcfg_tbl = NULL;
 538                         nfp_err(app->cpp,
 539                                 "Failed to map dcbcfg_tbl area, min_size %u.\n",
 540                                 dcb->cfg_offset);
 541                         return err;
 542                 }
 543                 dcb->dcbcfg_tbl = NULL;
 544         }
 545
 546         if (dcb->dcbcfg_tbl) {
 547                 for (unsigned int i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 548                         dcb->prio2tc[i] = i;
 549                         dcb->tc2idx[i] = i;
 550                         dcb->tc_tx_pct[i] = 0;
 551                         dcb->tc_maxrate[i] = 0;
 552                         dcb->tc_tsa[i] = IEEE_8021QAZ_TSA_VENDOR;
 553                 }
 554                 dcb->trust_status = NFP_DCB_TRUST_INVALID;
 555                 dcb->rate_init = false;
 556                 dcb->ets_init = false;
 557
 558                 nn->dp.netdev->dcbnl_ops = &nfp_nic_dcbnl_ops;
 559         }
 560
 561         return 0;
 562 }
 563
 564 void nfp_nic_dcb_clean(struct nfp_net *nn)
 565 {
 566         struct nfp_dcb *dcb;
 567
 568         dcb = get_dcb_priv(nn);
 569         if (dcb->dcbcfg_tbl_area)
 570                 nfp_cpp_area_release_free(dcb->dcbcfg_tbl_area);
 571 }