drivers/net/mvpp2/mrvl_qos.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Marvell International Ltd.
   3  * Copyright(c) 2017 Semihalf.
   4  * All rights reserved.
   5  */
   6
   7 #include <stdint.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10
  11 #include <rte_common.h>
  12 #include <rte_cfgfile.h>
  13 #include <rte_log.h>
  14 #include <rte_lcore.h>
  15 #include <rte_malloc.h>
  16 #include <rte_string_fns.h>
  17
  18 #include "mrvl_qos.h"
  19
  20 /* Parsing tokens. Defined conveniently, so that any correction is easy. */
  21 #define MRVL_TOK_DEFAULT "default"
  22 #define MRVL_TOK_DSA_MODE "dsa_mode"
  23 #define MRVL_TOK_START_HDR "start_hdr"
  24 #define MRVL_TOK_START_HDR_NONE "none"
  25 #define MRVL_TOK_START_HDR_DSA "dsa"
  26 #define MRVL_TOK_START_HDR_CUSTOM "custom"
  27 #define MRVL_TOK_START_HDR_EXT_DSA "ext_dsa"
  28 #define MRVL_TOK_DEFAULT_TC "default_tc"
  29 #define MRVL_TOK_DSCP "dscp"
  30 #define MRVL_TOK_MAPPING_PRIORITY "mapping_priority"
  31 #define MRVL_TOK_IP "ip"
  32 #define MRVL_TOK_IP_VLAN "ip/vlan"
  33 #define MRVL_TOK_PCP "pcp"
  34 #define MRVL_TOK_PORT "port"
  35 #define MRVL_TOK_RXQ "rxq"
  36 #define MRVL_TOK_TC "tc"
  37 #define MRVL_TOK_TXQ "txq"
  38 #define MRVL_TOK_VLAN "vlan"
  39 #define MRVL_TOK_VLAN_IP "vlan/ip"
  40 #define MRVL_TOK_PARSER_UDF "parser udf"
  41
  42 /* egress specific configuration tokens */
  43 #define MRVL_TOK_BURST_SIZE "burst_size"
  44 #define MRVL_TOK_RATE_LIMIT "rate_limit"
  45 #define MRVL_TOK_RATE_LIMIT_ENABLE "rate_limit_enable"
  46 #define MRVL_TOK_SCHED_MODE "sched_mode"
  47 #define MRVL_TOK_SCHED_MODE_SP "sp"
  48 #define MRVL_TOK_SCHED_MODE_WRR "wrr"
  49 #define MRVL_TOK_WRR_WEIGHT "wrr_weight"
  50
  51 /* policer specific configuration tokens */
  52 #define MRVL_TOK_PLCR "policer"
  53 #define MRVL_TOK_PLCR_DEFAULT "default_policer"
  54 #define MRVL_TOK_PLCR_UNIT "token_unit"
  55 #define MRVL_TOK_PLCR_UNIT_BYTES "bytes"
  56 #define MRVL_TOK_PLCR_UNIT_PACKETS "packets"
  57 #define MRVL_TOK_PLCR_COLOR "color_mode"
  58 #define MRVL_TOK_PLCR_COLOR_BLIND "blind"
  59 #define MRVL_TOK_PLCR_COLOR_AWARE "aware"
  60 #define MRVL_TOK_PLCR_CIR "cir"
  61 #define MRVL_TOK_PLCR_CBS "cbs"
  62 #define MRVL_TOK_PLCR_EBS "ebs"
  63 #define MRVL_TOK_PLCR_DEFAULT_COLOR "default_color"
  64 #define MRVL_TOK_PLCR_DEFAULT_COLOR_GREEN "green"
  65 #define MRVL_TOK_PLCR_DEFAULT_COLOR_YELLOW "yellow"
  66 #define MRVL_TOK_PLCR_DEFAULT_COLOR_RED "red"
  67
  68 /* parser udf specific configuration tokens */
  69 #define MRVL_TOK_PARSER_UDF_PROTO "proto"
  70 #define MRVL_TOK_PARSER_UDF_FIELD "field"
  71 #define MRVL_TOK_PARSER_UDF_KEY "key"
  72 #define MRVL_TOK_PARSER_UDF_MASK "mask"
  73 #define MRVL_TOK_PARSER_UDF_OFFSET "offset"
  74 #define MRVL_TOK_PARSER_UDF_PROTO_ETH "eth"
  75 #define MRVL_TOK_PARSER_UDF_FIELD_ETH_TYPE "type"
  76 #define MRVL_TOK_PARSER_UDF_PROTO_UDP "udp"
  77 #define MRVL_TOK_PARSER_UDF_FIELD_UDP_DPORT "dport"
  78
  79 /* parser forward bad frames tokens */
  80 #define MRVL_TOK_FWD_BAD_FRAMES "forward_bad_frames"
  81
  82 /** Number of tokens in range a-b = 2. */
  83 #define MAX_RNG_TOKENS 2
  84
  85 /** Maximum possible value of PCP. */
  86 #define MAX_PCP 7
  87
  88 /** Maximum possible value of DSCP. */
  89 #define MAX_DSCP 63
  90
  91 /** Global configuration. */
  92 struct mrvl_cfg *mrvl_cfg;
  93
  94 /**
  95  * Read out-queue configuration from file.
  96  *
  97  * @param file Path to the configuration file.
  98  * @param port Port number.
  99  * @param outq Out queue number.
 100  * @param cfg Pointer to the Marvell configuration structure.
 101  * @returns 0 in case of success, negative value otherwise.
 102  */
 103 static int
 104 get_outq_cfg(struct rte_cfgfile *file, int port, int outq,
 105                 struct mrvl_cfg *cfg)
 106 {
 107         char sec_name[32];
 108         const char *entry;
 109         uint32_t val;
 110
 111         snprintf(sec_name, sizeof(sec_name), "%s %d %s %d",
 112                 MRVL_TOK_PORT, port, MRVL_TOK_TXQ, outq);
 113
 114         /* Skip non-existing */
 115         if (rte_cfgfile_num_sections(file, sec_name, strlen(sec_name)) <= 0)
 116                 return 0;
 117
 118         /* Read scheduling mode */
 119         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_SCHED_MODE);
 120         if (entry) {
 121                 if (!strncmp(entry, MRVL_TOK_SCHED_MODE_SP,
 122                                         strlen(MRVL_TOK_SCHED_MODE_SP))) {
 123                         cfg->port[port].outq[outq].sched_mode =
 124                                 PP2_PPIO_SCHED_M_SP;
 125                 } else if (!strncmp(entry, MRVL_TOK_SCHED_MODE_WRR,
 126                                         strlen(MRVL_TOK_SCHED_MODE_WRR))) {
 127                         cfg->port[port].outq[outq].sched_mode =
 128                                 PP2_PPIO_SCHED_M_WRR;
 129                 } else {
 130                         MRVL_LOG(ERR, "Unknown token: %s", entry);
 131                         return -1;
 132                 }
 133         }
 134
 135         /* Read wrr weight */
 136         if (cfg->port[port].outq[outq].sched_mode == PP2_PPIO_SCHED_M_WRR) {
 137                 entry = rte_cfgfile_get_entry(file, sec_name,
 138                                 MRVL_TOK_WRR_WEIGHT);
 139                 if (entry) {
 140                         if (get_val_securely(entry, &val) < 0)
 141                                 return -1;
 142                         cfg->port[port].outq[outq].weight = val;
 143                 }
 144         }
 145
 146         /*
 147          * There's no point in setting rate limiting for specific outq as
 148          * global port rate limiting has priority.
 149          */
 150         if (cfg->port[port].rate_limit_enable) {
 151                 MRVL_LOG(WARNING, "Port %d rate limiting already enabled",
 152                         port);
 153                 return 0;
 154         }
 155
 156         entry = rte_cfgfile_get_entry(file, sec_name,
 157                         MRVL_TOK_RATE_LIMIT_ENABLE);
 158         if (entry) {
 159                 if (get_val_securely(entry, &val) < 0)
 160                         return -1;
 161                 cfg->port[port].outq[outq].rate_limit_enable = val;
 162         }
 163
 164         if (!cfg->port[port].outq[outq].rate_limit_enable)
 165                 return 0;
 166
 167         /* Read CBS (in kB) */
 168         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_BURST_SIZE);
 169         if (entry) {
 170                 if (get_val_securely(entry, &val) < 0)
 171                         return -1;
 172                 cfg->port[port].outq[outq].rate_limit_params.cbs = val;
 173         }
 174
 175         /* Read CIR (in kbps) */
 176         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_RATE_LIMIT);
 177         if (entry) {
 178                 if (get_val_securely(entry, &val) < 0)
 179                         return -1;
 180                 cfg->port[port].outq[outq].rate_limit_params.cir = val;
 181         }
 182
 183         return 0;
 184 }
 185
 186 /**
 187  * Gets multiple-entry values and places them in table.
 188  *
 189  * Entry can be anything, e.g. "1 2-3 5 6 7-9". This needs to be converted to
 190  * table entries, respectively: {1, 2, 3, 5, 6, 7, 8, 9}.
 191  * As all result table's elements are always 1-byte long, we
 192  * won't overcomplicate the function, but we'll keep API generic,
 193  * check if someone hasn't changed element size and make it simple
 194  * to extend to other sizes.
 195  *
 196  * This function is purely utilitary, it does not print any error, only returns
 197  * different error numbers.
 198  *
 199  * @param entry[in] Values string to parse.
 200  * @param tab[out] Results table.
 201  * @param elem_sz[in] Element size (in bytes).
 202  * @param max_elems[in] Number of results table elements available.
 203  * @param max val[in] Maximum value allowed.
 204  * @returns Number of correctly parsed elements in case of success.
 205  * @retval -1 Wrong element size.
 206  * @retval -2 More tokens than result table allows.
 207  * @retval -3 Wrong range syntax.
 208  * @retval -4 Wrong range values.
 209  * @retval -5 Maximum value exceeded.
 210  */
 211 static int
 212 get_entry_values(const char *entry, uint8_t *tab,
 213         size_t elem_sz, uint8_t max_elems, uint8_t max_val)
 214 {
 215         /* There should not be more tokens than max elements.
 216          * Add 1 for error trap.
 217          */
 218         char *tokens[max_elems + 1];
 219
 220         /* Begin, End + error trap = 3. */
 221         char *rng_tokens[MAX_RNG_TOKENS + 1];
 222         long beg, end;
 223         uint32_t token_val;
 224         int nb_tokens, nb_rng_tokens;
 225         int i;
 226         int values = 0;
 227         char val;
 228         char entry_cpy[CFG_VALUE_LEN];
 229
 230         if (elem_sz != 1)
 231                 return -1;
 232
 233         /* Copy the entry to safely use rte_strsplit(). */
 234         strlcpy(entry_cpy, entry, RTE_DIM(entry_cpy));
 235
 236         /*
 237          * If there are more tokens than array size, rte_strsplit will
 238          * not return error, just array size.
 239          */
 240         nb_tokens = rte_strsplit(entry_cpy, strlen(entry_cpy),
 241                 tokens, max_elems + 1, ' ');
 242
 243         /* Quick check, will be refined later. */
 244         if (nb_tokens > max_elems)
 245                 return -2;
 246
 247         for (i = 0; i < nb_tokens; ++i) {
 248                 if (strchr(tokens[i], '-') != NULL) {
 249                         /*
 250                          * Split to begin and end tokens.
 251                          * We want to catch error cases too, thus we leave
 252                          * option for number of tokens to be more than 2.
 253                          */
 254                         nb_rng_tokens = rte_strsplit(tokens[i],
 255                                         strlen(tokens[i]), rng_tokens,
 256                                         RTE_DIM(rng_tokens), '-');
 257                         if (nb_rng_tokens != 2)
 258                                 return -3;
 259
 260                         /* Range and sanity checks. */
 261                         if (get_val_securely(rng_tokens[0], &token_val) < 0)
 262                                 return -4;
 263                         beg = (char)token_val;
 264                         if (get_val_securely(rng_tokens[1], &token_val) < 0)
 265                                 return -4;
 266                         end = (char)token_val;
 267                         if (beg < 0 || beg > UCHAR_MAX ||
 268                                 end < 0 || end > UCHAR_MAX || end < beg)
 269                                 return -4;
 270
 271                         for (val = beg; val <= end; ++val) {
 272                                 if (val > max_val)
 273                                         return -5;
 274
 275                                 *tab = val;
 276                                 tab = RTE_PTR_ADD(tab, elem_sz);
 277                                 ++values;
 278                                 if (values >= max_elems)
 279                                         return -2;
 280                         }
 281                 } else {
 282                         /* Single values. */
 283                         if (get_val_securely(tokens[i], &token_val) < 0)
 284                                 return -5;
 285                         val = (char)token_val;
 286                         if (val > max_val)
 287                                 return -5;
 288
 289                         *tab = val;
 290                         tab = RTE_PTR_ADD(tab, elem_sz);
 291                         ++values;
 292                         if (values >= max_elems)
 293                                 return -2;
 294                 }
 295         }
 296
 297         return values;
 298 }
 299
 300 /**
 301  * Parse Traffic Class'es mapping configuration.
 302  *
 303  * @param file Config file handle.
 304  * @param port Which port to look for.
 305  * @param tc Which Traffic Class to look for.
 306  * @param cfg[out] Parsing results.
 307  * @returns 0 in case of success, negative value otherwise.
 308  */
 309 static int
 310 parse_tc_cfg(struct rte_cfgfile *file, int port, int tc,
 311                 struct mrvl_cfg *cfg)
 312 {
 313         char sec_name[32];
 314         const char *entry;
 315         int n;
 316
 317         snprintf(sec_name, sizeof(sec_name), "%s %d %s %d",
 318                 MRVL_TOK_PORT, port, MRVL_TOK_TC, tc);
 319
 320         /* Skip non-existing */
 321         if (rte_cfgfile_num_sections(file, sec_name, strlen(sec_name)) <= 0)
 322                 return 0;
 323
 324         cfg->port[port].use_global_defaults = 0;
 325         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_RXQ);
 326         if (entry) {
 327                 n = get_entry_values(entry,
 328                         cfg->port[port].tc[tc].inq,
 329                         sizeof(cfg->port[port].tc[tc].inq[0]),
 330                         RTE_DIM(cfg->port[port].tc[tc].inq),
 331                         MRVL_PP2_RXQ_MAX);
 332                 if (n < 0) {
 333                         MRVL_LOG(ERR, "Error %d while parsing: %s",
 334                                 n, entry);
 335                         return n;
 336                 }
 337                 cfg->port[port].tc[tc].inqs = n;
 338         }
 339
 340         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PCP);
 341         if (entry) {
 342                 n = get_entry_values(entry,
 343                         cfg->port[port].tc[tc].pcp,
 344                         sizeof(cfg->port[port].tc[tc].pcp[0]),
 345                         RTE_DIM(cfg->port[port].tc[tc].pcp),
 346                         MAX_PCP);
 347                 if (n < 0) {
 348                         MRVL_LOG(ERR, "Error %d while parsing: %s",
 349                                 n, entry);
 350                         return n;
 351                 }
 352                 cfg->port[port].tc[tc].pcps = n;
 353         }
 354
 355         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_DSCP);
 356         if (entry) {
 357                 n = get_entry_values(entry,
 358                         cfg->port[port].tc[tc].dscp,
 359                         sizeof(cfg->port[port].tc[tc].dscp[0]),
 360                         RTE_DIM(cfg->port[port].tc[tc].dscp),
 361                         MAX_DSCP);
 362                 if (n < 0) {
 363                         MRVL_LOG(ERR, "Error %d while parsing: %s",
 364                                 n, entry);
 365                         return n;
 366                 }
 367                 cfg->port[port].tc[tc].dscps = n;
 368         }
 369
 370         if (!cfg->port[port].setup_policer)
 371                 return 0;
 372
 373         entry = rte_cfgfile_get_entry(file, sec_name,
 374                         MRVL_TOK_PLCR_DEFAULT_COLOR);
 375         if (entry) {
 376                 if (!strncmp(entry, MRVL_TOK_PLCR_DEFAULT_COLOR_GREEN,
 377                                 sizeof(MRVL_TOK_PLCR_DEFAULT_COLOR_GREEN))) {
 378                         cfg->port[port].tc[tc].color = PP2_PPIO_COLOR_GREEN;
 379                 } else if (!strncmp(entry, MRVL_TOK_PLCR_DEFAULT_COLOR_YELLOW,
 380                                 sizeof(MRVL_TOK_PLCR_DEFAULT_COLOR_YELLOW))) {
 381                         cfg->port[port].tc[tc].color = PP2_PPIO_COLOR_YELLOW;
 382                 } else if (!strncmp(entry, MRVL_TOK_PLCR_DEFAULT_COLOR_RED,
 383                                 sizeof(MRVL_TOK_PLCR_DEFAULT_COLOR_RED))) {
 384                         cfg->port[port].tc[tc].color = PP2_PPIO_COLOR_RED;
 385                 } else {
 386                         MRVL_LOG(ERR, "Error while parsing: %s", entry);
 387                         return -1;
 388                 }
 389         }
 390
 391         return 0;
 392 }
 393
 394 /**
 395  * Parse default port policer.
 396  *
 397  * @param file Config file handle.
 398  * @param sec_name Section name with policer configuration
 399  * @param port Port number.
 400  * @param cfg[out] Parsing results.
 401  * @returns 0 in case of success, negative value otherwise.
 402  */
 403 static int
 404 parse_policer(struct rte_cfgfile *file, int port, const char *sec_name,
 405                 struct mrvl_cfg *cfg)
 406 {
 407         const char *entry;
 408         uint32_t val;
 409
 410         /* Read policer token unit */
 411         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PLCR_UNIT);
 412         if (entry) {
 413                 if (!strncmp(entry, MRVL_TOK_PLCR_UNIT_BYTES,
 414                                         sizeof(MRVL_TOK_PLCR_UNIT_BYTES))) {
 415                         cfg->port[port].policer_params.token_unit =
 416                                 PP2_CLS_PLCR_BYTES_TOKEN_UNIT;
 417                 } else if (!strncmp(entry, MRVL_TOK_PLCR_UNIT_PACKETS,
 418                                         sizeof(MRVL_TOK_PLCR_UNIT_PACKETS))) {
 419                         cfg->port[port].policer_params.token_unit =
 420                                 PP2_CLS_PLCR_PACKETS_TOKEN_UNIT;
 421                 } else {
 422                         MRVL_LOG(ERR, "Unknown token: %s", entry);
 423                         return -1;
 424                 }
 425         }
 426
 427         /* Read policer color mode */
 428         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PLCR_COLOR);
 429         if (entry) {
 430                 if (!strncmp(entry, MRVL_TOK_PLCR_COLOR_BLIND,
 431                                         sizeof(MRVL_TOK_PLCR_COLOR_BLIND))) {
 432                         cfg->port[port].policer_params.color_mode =
 433                                 PP2_CLS_PLCR_COLOR_BLIND_MODE;
 434                 } else if (!strncmp(entry, MRVL_TOK_PLCR_COLOR_AWARE,
 435                                         sizeof(MRVL_TOK_PLCR_COLOR_AWARE))) {
 436                         cfg->port[port].policer_params.color_mode =
 437                                 PP2_CLS_PLCR_COLOR_AWARE_MODE;
 438                 } else {
 439                         MRVL_LOG(ERR, "Error in parsing: %s", entry);
 440                         return -1;
 441                 }
 442         }
 443
 444         /* Read policer cir */
 445         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PLCR_CIR);
 446         if (entry) {
 447                 if (get_val_securely(entry, &val) < 0)
 448                         return -1;
 449                 cfg->port[port].policer_params.cir = val;
 450         }
 451
 452         /* Read policer cbs */
 453         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PLCR_CBS);
 454         if (entry) {
 455                 if (get_val_securely(entry, &val) < 0)
 456                         return -1;
 457                 cfg->port[port].policer_params.cbs = val;
 458         }
 459
 460         /* Read policer ebs */
 461         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PLCR_EBS);
 462         if (entry) {
 463                 if (get_val_securely(entry, &val) < 0)
 464                         return -1;
 465                 cfg->port[port].policer_params.ebs = val;
 466         }
 467
 468         cfg->port[port].setup_policer = 1;
 469
 470         return 0;
 471 }
 472
 473 /**
 474  * Parse parser udf.
 475  *
 476  * @param file Config file handle.
 477  * @param sec_name section name
 478  * @param udf udf index
 479  * @param cfg[out] Parsing results.
 480  * @returns 0 in case of success, negative value otherwise.
 481  */
 482 static int
 483 parse_udf(struct rte_cfgfile *file, const char *sec_name, int udf,
 484           struct mrvl_cfg *cfg)
 485 {
 486         struct pp2_parse_udf_params *udf_params;
 487         const char *entry, *entry_field;
 488         uint32_t val, i;
 489         uint8_t field_size;
 490         char malloc_name[32], tmp_arr[3];
 491         /* field len in chars equal to '0x' + rest of data */
 492 #define FIELD_LEN_IN_CHARS(field_size)  (uint32_t)(2 + (field_size) * 2)
 493
 494         udf_params = &cfg->pp2_cfg.prs_udfs.udfs[udf];
 495
 496         /* Read 'proto' field */
 497         entry = rte_cfgfile_get_entry(file, sec_name,
 498                                       MRVL_TOK_PARSER_UDF_PROTO);
 499         if (!entry) {
 500                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must be set\n", udf,
 501                          MRVL_TOK_PARSER_UDF_PROTO);
 502                 return -1;
 503         }
 504
 505         /* Read 'field' field */
 506         entry_field = rte_cfgfile_get_entry(file, sec_name,
 507                                        MRVL_TOK_PARSER_UDF_FIELD);
 508         if (!entry_field) {
 509                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must be set\n", udf,
 510                          MRVL_TOK_PARSER_UDF_FIELD);
 511                 return -1;
 512         }
 513
 514         if (!strncmp(entry, MRVL_TOK_PARSER_UDF_PROTO_ETH,
 515                                 sizeof(MRVL_TOK_PARSER_UDF_PROTO_ETH))) {
 516                 udf_params->match_proto = MV_NET_PROTO_ETH;
 517                 if (!strncmp(entry_field, MRVL_TOK_PARSER_UDF_FIELD_ETH_TYPE,
 518                              sizeof(MRVL_TOK_PARSER_UDF_FIELD_ETH_TYPE))) {
 519                         udf_params->match_field.eth = MV_NET_ETH_F_TYPE;
 520                         field_size = 2;
 521                 } else {
 522                         MRVL_LOG(ERR, "UDF[%d]: mismatch between '%s' proto "
 523                                  "and '%s' field\n", udf,
 524                                  MRVL_TOK_PARSER_UDF_PROTO_ETH,
 525                                  entry_field);
 526                         return -1;
 527                 }
 528         } else if (!strncmp(entry, MRVL_TOK_PARSER_UDF_PROTO_UDP,
 529                                 sizeof(MRVL_TOK_PARSER_UDF_PROTO_UDP))) {
 530                 udf_params->match_proto = MV_NET_PROTO_UDP;
 531                 if (!strncmp(entry_field, MRVL_TOK_PARSER_UDF_FIELD_UDP_DPORT,
 532                              sizeof(MRVL_TOK_PARSER_UDF_FIELD_UDP_DPORT))) {
 533                         udf_params->match_field.udp = MV_NET_UDP_F_DP;
 534                         field_size = 2;
 535                 } else {
 536                         MRVL_LOG(ERR, "UDF[%d]: mismatch between '%s' proto "
 537                                  "and '%s' field\n", udf,
 538                                  MRVL_TOK_PARSER_UDF_PROTO_UDP,
 539                                  entry_field);
 540                         return -1;
 541                 }
 542         } else {
 543                 MRVL_LOG(ERR, "UDF[%d]: Unsupported '%s' proto\n", udf, entry);
 544                 return -1;
 545         }
 546
 547         snprintf(malloc_name, sizeof(malloc_name), "mrvl_udf_%d_key", udf);
 548         udf_params->match_key = rte_zmalloc(malloc_name, field_size, 0);
 549         if (udf_params->match_key == NULL) {
 550                 MRVL_LOG(ERR, "Cannot allocate udf %d key\n", udf);
 551                 return -1;
 552         }
 553         snprintf(malloc_name, sizeof(malloc_name), "mrvl_udf_%d_mask", udf);
 554         udf_params->match_mask = rte_zmalloc(malloc_name, field_size, 0);
 555         if (udf_params->match_mask == NULL) {
 556                 MRVL_LOG(ERR, "Cannot allocate udf %d mask\n", udf);
 557                 return -1;
 558         }
 559
 560         /* Read 'key' field */
 561         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PARSER_UDF_KEY);
 562         if (!entry) {
 563                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must be set\n", udf,
 564                          MRVL_TOK_PARSER_UDF_KEY);
 565                 return -1;
 566         }
 567
 568         if (strncmp(entry, "0x", 2) != 0)  {
 569                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must start with '0x'\n",
 570                          udf, MRVL_TOK_PARSER_UDF_KEY);
 571                 return -EINVAL;
 572         }
 573
 574         if (strlen(entry) != FIELD_LEN_IN_CHARS(field_size)) {
 575                 MRVL_LOG(ERR, "UDF[%d]: '%s' field's len must be %d\n", udf,
 576                          MRVL_TOK_PARSER_UDF_KEY,
 577                          FIELD_LEN_IN_CHARS(field_size));
 578                 return -EINVAL;
 579         }
 580
 581         entry += 2; /* skip the '0x' */
 582         for (i = 0; i < field_size; i++) {
 583                 strncpy(tmp_arr, entry, 2);
 584                 tmp_arr[2] = '\0';
 585                 if (get_val_securely8(tmp_arr, 16,
 586                                       &udf_params->match_key[i]) < 0) {
 587                         MRVL_LOG(ERR, "UDF[%d]: '%s' field's value is not in "
 588                                 "hex format\n", udf, MRVL_TOK_PARSER_UDF_KEY);
 589                         return -EINVAL;
 590                 }
 591                 entry += 2;
 592         }
 593
 594         /* Read 'mask' field */
 595         entry = rte_cfgfile_get_entry(file, sec_name, MRVL_TOK_PARSER_UDF_MASK);
 596         if (!entry) {
 597                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must be set\n", udf,
 598                          MRVL_TOK_PARSER_UDF_MASK);
 599                 return -1;
 600         }
 601         if (strncmp(entry, "0x", 2) != 0) {
 602                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must start with '0x'\n",
 603                          udf, MRVL_TOK_PARSER_UDF_MASK);
 604                 return -EINVAL;
 605         }
 606
 607         if (strlen(entry) != FIELD_LEN_IN_CHARS(field_size)) {
 608                 MRVL_LOG(ERR, "UDF[%d]: '%s' field's len must be %d\n", udf,
 609                          MRVL_TOK_PARSER_UDF_MASK,
 610                          FIELD_LEN_IN_CHARS(field_size));
 611                 return -EINVAL;
 612         }
 613
 614         entry += 2; /* skip the '0x' */
 615         for (i = 0; i < field_size; i++) {
 616                 strncpy(tmp_arr, entry, 2);
 617                 tmp_arr[2] = '\0';
 618                 if (get_val_securely8(tmp_arr, 16,
 619                                       &udf_params->match_mask[i]) < 0) {
 620                         MRVL_LOG(ERR, "UDF[%d]: '%s' field's value is not in "
 621                                 "hex format\n", udf, MRVL_TOK_PARSER_UDF_MASK);
 622                         return -EINVAL;
 623                 }
 624                 entry += 2;
 625         }
 626
 627         /* Read offset */
 628         entry = rte_cfgfile_get_entry(file, sec_name,
 629                                       MRVL_TOK_PARSER_UDF_OFFSET);
 630         if (!entry) {
 631                 MRVL_LOG(ERR, "UDF[%d]: '%s' field must be set\n", udf,
 632                          MRVL_TOK_PARSER_UDF_OFFSET);
 633                 return -1;
 634         }
 635         if (get_val_securely(entry, &val) < 0)
 636                 return -1;
 637         udf_params->offset = val;
 638
 639         return 0;
 640 }
 641
 642 /**
 643  * Parse configuration - rte_kvargs_process handler.
 644  *
 645  * Opens configuration file and parses its content.
 646  *
 647  * @param key Unused.
 648  * @param path Path to config file.
 649  * @param extra_args Pointer to configuration structure.
 650  * @returns 0 in case of success, exits otherwise.
 651  */
 652 int
 653 mrvl_get_cfg(const char *key __rte_unused, const char *path, void *extra_args)
 654 {
 655         struct mrvl_cfg **cfg = extra_args;
 656         struct rte_cfgfile *file = rte_cfgfile_load(path, 0);
 657         uint32_t val;
 658         int n, i, ret;
 659         const char *entry;
 660         char sec_name[32];
 661
 662         if (file == NULL) {
 663                 MRVL_LOG(ERR, "Cannot load configuration %s\n", path);
 664                 return -1;
 665         }
 666
 667         /* Create configuration. This is never accessed on the fast path,
 668          * so we can ignore socket.
 669          */
 670         *cfg = rte_zmalloc("mrvl_cfg", sizeof(struct mrvl_cfg), 0);
 671         if (*cfg == NULL) {
 672                 MRVL_LOG(ERR, "Cannot allocate configuration %s\n", path);
 673                 return -1;
 674         }
 675
 676         /* PP2 configuration */
 677         n = rte_cfgfile_num_sections(file, MRVL_TOK_PARSER_UDF,
 678                 sizeof(MRVL_TOK_PARSER_UDF) - 1);
 679
 680         if (n && n > PP2_MAX_UDFS_SUPPORTED) {
 681                 MRVL_LOG(ERR, "found %d udf sections, but only %d are supported\n",
 682                          n, PP2_MAX_UDFS_SUPPORTED);
 683                 return -1;
 684         }
 685         (*cfg)->pp2_cfg.prs_udfs.num_udfs = n;
 686         for (i = 0; i < n; i++) {
 687                 snprintf(sec_name, sizeof(sec_name), "%s %d",
 688                                 MRVL_TOK_PARSER_UDF, i);
 689
 690                 /* udf sections must be sequential. */
 691                 if (rte_cfgfile_num_sections(file, sec_name,
 692                                 strlen(sec_name)) <= 0) {
 693                         MRVL_LOG(ERR, "udf sections must be sequential (0 - %d)\n",
 694                                  PP2_MAX_UDFS_SUPPORTED - 1);
 695                         return -1;
 696                 }
 697
 698                 ret = parse_udf(file, sec_name, i, *cfg);
 699                 if (ret) {
 700                         MRVL_LOG(ERR, "Error in parsing %s!\n", sec_name);
 701                         return -1;
 702                 }
 703         }
 704
 705         /* PP2 Ports configuration */
 706         n = rte_cfgfile_num_sections(file, MRVL_TOK_PORT,
 707                 sizeof(MRVL_TOK_PORT) - 1);
 708
 709         if (n == 0) {
 710                 /* This is weird, but not bad. */
 711                 MRVL_LOG(WARNING, "Empty configuration file?");
 712                 return 0;
 713         }
 714
 715         /* Use the number of ports given as vdev parameters. */
 716         for (n = 0; n < (PP2_NUM_ETH_PPIO * PP2_NUM_PKT_PROC); ++n) {
 717                 snprintf(sec_name, sizeof(sec_name), "%s %d %s",
 718                         MRVL_TOK_PORT, n, MRVL_TOK_DEFAULT);
 719
 720                 /* Use global defaults, unless an override occurs */
 721                 (*cfg)->port[n].use_global_defaults = 1;
 722
 723                 /* Skip ports non-existing in configuration. */
 724                 if (rte_cfgfile_num_sections(file, sec_name,
 725                                 strlen(sec_name)) <= 0) {
 726                         continue;
 727                 }
 728
 729                 /* MRVL_TOK_START_HDR replaces MRVL_TOK_DSA_MODE parameter.
 730                  * MRVL_TOK_DSA_MODE will be supported for backward
 731                  * compatibillity.
 732                  */
 733                 entry = rte_cfgfile_get_entry(file, sec_name,
 734                                 MRVL_TOK_START_HDR);
 735                 /* if start_hsr is missing, check if dsa_mode exist instead */
 736                 if (entry == NULL)
 737                         entry = rte_cfgfile_get_entry(file, sec_name,
 738                                 MRVL_TOK_DSA_MODE);
 739                 if (entry) {
 740                         if (!strncmp(entry, MRVL_TOK_START_HDR_NONE,
 741                                 sizeof(MRVL_TOK_START_HDR_NONE)))
 742                                 (*cfg)->port[n].eth_start_hdr =
 743                                 PP2_PPIO_HDR_ETH;
 744                         else if (!strncmp(entry, MRVL_TOK_START_HDR_DSA,
 745                                 sizeof(MRVL_TOK_START_HDR_DSA)))
 746                                 (*cfg)->port[n].eth_start_hdr =
 747                                 PP2_PPIO_HDR_ETH_DSA;
 748                         else if (!strncmp(entry, MRVL_TOK_START_HDR_CUSTOM,
 749                                 sizeof(MRVL_TOK_START_HDR_CUSTOM)))
 750                                 (*cfg)->port[n].eth_start_hdr =
 751                                 PP2_PPIO_HDR_ETH_CUSTOM;
 752                         else if (!strncmp(entry, MRVL_TOK_START_HDR_EXT_DSA,
 753                                 sizeof(MRVL_TOK_START_HDR_EXT_DSA))) {
 754                                 (*cfg)->port[n].eth_start_hdr =
 755                                 PP2_PPIO_HDR_ETH_EXT_DSA;
 756                         } else {
 757                                 MRVL_LOG(ERR,
 758                                         "Error in parsing %s value (%s)!\n",
 759                                         MRVL_TOK_START_HDR, entry);
 760                                 return -1;
 761                         }
 762                 } else {
 763                         (*cfg)->port[n].eth_start_hdr = PP2_PPIO_HDR_ETH;
 764                 }
 765
 766                 /*
 767                  * Read per-port rate limiting. Setting that will
 768                  * disable per-queue rate limiting.
 769                  */
 770                 entry = rte_cfgfile_get_entry(file, sec_name,
 771                                 MRVL_TOK_RATE_LIMIT_ENABLE);
 772                 if (entry) {
 773                         if (get_val_securely(entry, &val) < 0)
 774                                 return -1;
 775                         (*cfg)->port[n].rate_limit_enable = val;
 776                 }
 777
 778                 if ((*cfg)->port[n].rate_limit_enable) {
 779                         entry = rte_cfgfile_get_entry(file, sec_name,
 780                                         MRVL_TOK_BURST_SIZE);
 781                         if (entry) {
 782                                 if (get_val_securely(entry, &val) < 0)
 783                                         return -1;
 784                                 (*cfg)->port[n].rate_limit_params.cbs = val;
 785                         }
 786
 787                         entry = rte_cfgfile_get_entry(file, sec_name,
 788                                         MRVL_TOK_RATE_LIMIT);
 789                         if (entry) {
 790                                 if (get_val_securely(entry, &val) < 0)
 791                                         return -1;
 792                                 (*cfg)->port[n].rate_limit_params.cir = val;
 793                         }
 794                 }
 795
 796                 entry = rte_cfgfile_get_entry(file, sec_name,
 797                                 MRVL_TOK_MAPPING_PRIORITY);
 798                 if (entry) {
 799                         (*cfg)->port[n].use_global_defaults = 0;
 800                         if (!strncmp(entry, MRVL_TOK_VLAN_IP,
 801                                 sizeof(MRVL_TOK_VLAN_IP)))
 802                                 (*cfg)->port[n].mapping_priority =
 803                                         PP2_CLS_QOS_TBL_VLAN_IP_PRI;
 804                         else if (!strncmp(entry, MRVL_TOK_IP_VLAN,
 805                                 sizeof(MRVL_TOK_IP_VLAN)))
 806                                 (*cfg)->port[n].mapping_priority =
 807                                         PP2_CLS_QOS_TBL_IP_VLAN_PRI;
 808                         else if (!strncmp(entry, MRVL_TOK_IP,
 809                                 sizeof(MRVL_TOK_IP)))
 810                                 (*cfg)->port[n].mapping_priority =
 811                                         PP2_CLS_QOS_TBL_IP_PRI;
 812                         else if (!strncmp(entry, MRVL_TOK_VLAN,
 813                                 sizeof(MRVL_TOK_VLAN))) {
 814                                 (*cfg)->port[n].mapping_priority =
 815                                         PP2_CLS_QOS_TBL_VLAN_PRI;
 816                         } else {
 817                                 MRVL_LOG(ERR,
 818                                         "Error in parsing %s value (%s)!\n",
 819                                         MRVL_TOK_MAPPING_PRIORITY, entry);
 820                                 return -1;
 821                         }
 822                 } else {
 823                         (*cfg)->port[n].mapping_priority =
 824                                 PP2_CLS_QOS_TBL_NONE;
 825                 }
 826
 827                 /* Parse policer configuration (if any) */
 828                 entry = rte_cfgfile_get_entry(file, sec_name,
 829                                 MRVL_TOK_PLCR_DEFAULT);
 830                 if (entry) {
 831                         (*cfg)->port[n].use_global_defaults = 0;
 832                         if (get_val_securely(entry, &val) < 0)
 833                                 return -1;
 834
 835                         snprintf(sec_name, sizeof(sec_name), "%s %d",
 836                                         MRVL_TOK_PLCR, val);
 837                         ret = parse_policer(file, n, sec_name, *cfg);
 838                         if (ret)
 839                                 return -1;
 840                 }
 841
 842                 for (i = 0; i < MRVL_PP2_RXQ_MAX; ++i) {
 843                         ret = get_outq_cfg(file, n, i, *cfg);
 844                         if (ret < 0) {
 845                                 MRVL_LOG(ERR,
 846                                         "Error %d parsing port %d outq %d!\n",
 847                                         ret, n, i);
 848                                 return -1;
 849                         }
 850                 }
 851
 852                 for (i = 0; i < MRVL_PP2_TC_MAX; ++i) {
 853                         ret = parse_tc_cfg(file, n, i, *cfg);
 854                         if (ret < 0) {
 855                                 MRVL_LOG(ERR,
 856                                         "Error %d parsing port %d tc %d!\n",
 857                                         ret, n, i);
 858                                 return -1;
 859                         }
 860                 }
 861
 862                 entry = rte_cfgfile_get_entry(file, sec_name,
 863                                               MRVL_TOK_DEFAULT_TC);
 864                 if (entry) {
 865                         if (get_val_securely(entry, &val) < 0 ||
 866                             val > USHRT_MAX)
 867                                 return -1;
 868                         (*cfg)->port[n].default_tc = (uint8_t)val;
 869                 } else {
 870                         if ((*cfg)->port[n].use_global_defaults == 0) {
 871                                 MRVL_LOG(ERR,
 872                                          "Default Traffic Class required in "
 873                                          "custom configuration!");
 874                                 return -1;
 875                         }
 876                 }
 877
 878                 /* Parse forward bad frames option */
 879                 entry = rte_cfgfile_get_entry(file, sec_name,
 880                                 MRVL_TOK_FWD_BAD_FRAMES);
 881                 if (entry) {
 882                         if (get_val_securely(entry, &val) < 0) {
 883                                 MRVL_LOG(ERR,
 884                                         "Error in parsing %s value (%s)!\n",
 885                                         MRVL_TOK_FWD_BAD_FRAMES, entry);
 886                                 return -1;
 887                         }
 888                         (*cfg)->port[n].forward_bad_frames = (uint8_t)val;
 889                 } else {
 890                         (*cfg)->port[n].forward_bad_frames = 0;
 891                 }
 892         }
 893
 894         return 0;
 895 }
 896
 897 /**
 898  * Setup Traffic Class.
 899  *
 900  * Fill in TC parameters in single MUSDK TC config entry.
 901  * @param param TC parameters entry.
 902  * @param inqs Number of MUSDK in-queues in this TC.
 903  * @param bpool Bpool for this TC.
 904  * @param color Default color for this TC.
 905  * @returns 0 in case of success, exits otherwise.
 906  */
 907 static int
 908 setup_tc(struct pp2_ppio_tc_params *param, uint8_t inqs,
 909         struct pp2_bpool *bpool, enum pp2_ppio_color color)
 910 {
 911         struct pp2_ppio_inq_params *inq_params;
 912
 913         param->pkt_offset = MRVL_PKT_OFFS;
 914         param->pools[0][0] = bpool;
 915         param->pools[0][1] = dummy_pool[bpool->pp2_id];
 916         param->default_color = color;
 917
 918         inq_params = rte_zmalloc_socket("inq_params",
 919                 inqs * sizeof(*inq_params),
 920                 0, rte_socket_id());
 921         if (!inq_params)
 922                 return -ENOMEM;
 923
 924         param->num_in_qs = inqs;
 925
 926         /* Release old config if necessary. */
 927         if (param->inqs_params)
 928                 rte_free(param->inqs_params);
 929
 930         param->inqs_params = inq_params;
 931
 932         return 0;
 933 }
 934
 935 /**
 936  * Setup ingress policer.
 937  *
 938  * @param priv Port's private data.
 939  * @param params Pointer to the policer's configuration.
 940  * @param plcr_id Policer id.
 941  * @returns 0 in case of success, negative values otherwise.
 942  */
 943 static int
 944 setup_policer(struct mrvl_priv *priv, struct pp2_cls_plcr_params *params)
 945 {
 946         char match[16];
 947         int ret;
 948
 949         /*
 950          * At this point no other policers are used which means
 951          * any policer can be picked up and used as a default one.
 952          *
 953          * Lets use 0th then.
 954          */
 955         sprintf(match, "policer-%d:%d\n", priv->pp_id, 0);
 956         params->match = match;
 957
 958         ret = pp2_cls_plcr_init(params, &priv->default_policer);
 959         if (ret) {
 960                 MRVL_LOG(ERR, "Failed to setup %s", match);
 961                 return -1;
 962         }
 963
 964         priv->ppio_params.inqs_params.plcr = priv->default_policer;
 965         priv->used_plcrs = BIT(0);
 966
 967         return 0;
 968 }
 969
 970 /**
 971  * Configure RX Queues in a given port.
 972  *
 973  * Sets up RX queues, their Traffic Classes and DPDK rxq->(TC,inq) mapping.
 974  *
 975  * @param priv Port's private data
 976  * @param portid DPDK port ID
 977  * @param max_queues Maximum number of queues to configure.
 978  * @returns 0 in case of success, negative value otherwise.
 979  */
 980 int
 981 mrvl_configure_rxqs(struct mrvl_priv *priv, uint16_t portid,
 982         uint16_t max_queues)
 983 {
 984         size_t i, tc;
 985
 986         if (mrvl_cfg == NULL ||
 987                 mrvl_cfg->port[portid].use_global_defaults) {
 988                 /*
 989                  * No port configuration, use default: 1 TC, no QoS,
 990                  * TC color set to green.
 991                  */
 992                 priv->ppio_params.inqs_params.num_tcs = 1;
 993                 setup_tc(&priv->ppio_params.inqs_params.tcs_params[0],
 994                         max_queues, priv->bpool, PP2_PPIO_COLOR_GREEN);
 995
 996                 /* Direct mapping of queues i.e. 0->0, 1->1 etc. */
 997                 for (i = 0; i < max_queues; ++i) {
 998                         priv->rxq_map[i].tc = 0;
 999                         priv->rxq_map[i].inq = i;
1000                 }
1001                 return 0;
1002         }
1003
1004         /* We need only a subset of configuration. */
1005         struct port_cfg *port_cfg = &mrvl_cfg->port[portid];
1006
1007         priv->qos_tbl_params.type = port_cfg->mapping_priority;
1008
1009         /*
1010          * We need to reverse mapping, from tc->pcp (better from usability
1011          * point of view) to pcp->tc (configurable in MUSDK).
1012          * First, set all map elements to "default".
1013          */
1014         for (i = 0; i < RTE_DIM(priv->qos_tbl_params.pcp_cos_map); ++i)
1015                 priv->qos_tbl_params.pcp_cos_map[i].tc = port_cfg->default_tc;
1016
1017         /* Then, fill in all known values. */
1018         for (tc = 0; tc < RTE_DIM(port_cfg->tc); ++tc) {
1019                 if (port_cfg->tc[tc].pcps > RTE_DIM(port_cfg->tc[0].pcp)) {
1020                         /* Better safe than sorry. */
1021                         MRVL_LOG(ERR,
1022                                 "Too many PCPs configured in TC %zu!", tc);
1023                         return -1;
1024                 }
1025                 for (i = 0; i < port_cfg->tc[tc].pcps; ++i) {
1026                         priv->qos_tbl_params.pcp_cos_map[
1027                           port_cfg->tc[tc].pcp[i]].tc = tc;
1028                 }
1029         }
1030
1031         /*
1032          * The same logic goes with DSCP.
1033          * First, set all map elements to "default".
1034          */
1035         for (i = 0; i < RTE_DIM(priv->qos_tbl_params.dscp_cos_map); ++i)
1036                 priv->qos_tbl_params.dscp_cos_map[i].tc =
1037                         port_cfg->default_tc;
1038
1039         /* Fill in all known values. */
1040         for (tc = 0; tc < RTE_DIM(port_cfg->tc); ++tc) {
1041                 if (port_cfg->tc[tc].dscps > RTE_DIM(port_cfg->tc[0].dscp)) {
1042                         /* Better safe than sorry. */
1043                         MRVL_LOG(ERR,
1044                                 "Too many DSCPs configured in TC %zu!", tc);
1045                         return -1;
1046                 }
1047                 for (i = 0; i < port_cfg->tc[tc].dscps; ++i) {
1048                         priv->qos_tbl_params.dscp_cos_map[
1049                           port_cfg->tc[tc].dscp[i]].tc = tc;
1050                 }
1051         }
1052
1053         /*
1054          * Surprisingly, similar logic goes with queue mapping.
1055          * We need only to store qid->tc mapping,
1056          * to know TC when queue is read.
1057          */
1058         for (i = 0; i < RTE_DIM(priv->rxq_map); ++i)
1059                 priv->rxq_map[i].tc = MRVL_UNKNOWN_TC;
1060
1061         /* Set up DPDKq->(TC,inq) mapping. */
1062         for (tc = 0; tc < RTE_DIM(port_cfg->tc); ++tc) {
1063                 if (port_cfg->tc[tc].inqs > RTE_DIM(port_cfg->tc[0].inq)) {
1064                         /* Overflow. */
1065                         MRVL_LOG(ERR,
1066                                 "Too many RX queues configured per TC %zu!",
1067                                 tc);
1068                         return -1;
1069                 }
1070                 for (i = 0; i < port_cfg->tc[tc].inqs; ++i) {
1071                         uint8_t idx = port_cfg->tc[tc].inq[i];
1072
1073                         if (idx > RTE_DIM(priv->rxq_map)) {
1074                                 MRVL_LOG(ERR, "Bad queue index %d!", idx);
1075                                 return -1;
1076                         }
1077
1078                         priv->rxq_map[idx].tc = tc;
1079                         priv->rxq_map[idx].inq = i;
1080                 }
1081         }
1082
1083         /*
1084          * Set up TC configuration. TCs need to be sequenced: 0, 1, 2
1085          * with no gaps. Empty TC means end of processing.
1086          */
1087         for (i = 0; i < MRVL_PP2_TC_MAX; ++i) {
1088                 if (port_cfg->tc[i].inqs == 0)
1089                         break;
1090                 setup_tc(&priv->ppio_params.inqs_params.tcs_params[i],
1091                                 port_cfg->tc[i].inqs,
1092                                 priv->bpool, port_cfg->tc[i].color);
1093         }
1094
1095         priv->ppio_params.inqs_params.num_tcs = i;
1096
1097         if (port_cfg->setup_policer)
1098                 return setup_policer(priv, &port_cfg->policer_params);
1099
1100         return 0;
1101 }
1102
1103 /**
1104  * Configure TX Queues in a given port.
1105  *
1106  * Sets up TX queues egress scheduler and limiter.
1107  *
1108  * @param priv Port's private data
1109  * @param portid DPDK port ID
1110  * @param max_queues Maximum number of queues to configure.
1111  * @returns 0 in case of success, negative value otherwise.
1112  */
1113 int
1114 mrvl_configure_txqs(struct mrvl_priv *priv, uint16_t portid,
1115                 uint16_t max_queues)
1116 {
1117         /* We need only a subset of configuration. */
1118         struct port_cfg *port_cfg = &mrvl_cfg->port[portid];
1119         int i;
1120
1121         if (mrvl_cfg == NULL)
1122                 return 0;
1123
1124         priv->ppio_params.rate_limit_enable = port_cfg->rate_limit_enable;
1125         if (port_cfg->rate_limit_enable)
1126                 priv->ppio_params.rate_limit_params =
1127                         port_cfg->rate_limit_params;
1128
1129         for (i = 0; i < max_queues; i++) {
1130                 struct pp2_ppio_outq_params *params =
1131                         &priv->ppio_params.outqs_params.outqs_params[i];
1132
1133                 params->sched_mode = port_cfg->outq[i].sched_mode;
1134                 params->weight = port_cfg->outq[i].weight;
1135                 params->rate_limit_enable = port_cfg->outq[i].rate_limit_enable;
1136                 params->rate_limit_params = port_cfg->outq[i].rate_limit_params;
1137         }
1138
1139         return 0;
1140 }
1141
1142 /**
1143  * Start QoS mapping.
1144  *
1145  * Finalize QoS table configuration and initialize it in SDK. It can be done
1146  * only after port is started, so we have a valid ppio reference.
1147  *
1148  * @param priv Port's private (configuration) data.
1149  * @returns 0 in case of success, exits otherwise.
1150  */
1151 int
1152 mrvl_start_qos_mapping(struct mrvl_priv *priv)
1153 {
1154         size_t i;
1155
1156         if (priv->qos_tbl_params.type == PP2_CLS_QOS_TBL_NONE)
1157                 return 0;
1158
1159         if (priv->ppio == NULL) {
1160                 MRVL_LOG(ERR, "ppio must not be NULL here!");
1161                 return -1;
1162         }
1163
1164         for (i = 0; i < RTE_DIM(priv->qos_tbl_params.pcp_cos_map); ++i)
1165                 priv->qos_tbl_params.pcp_cos_map[i].ppio = priv->ppio;
1166
1167         for (i = 0; i < RTE_DIM(priv->qos_tbl_params.dscp_cos_map); ++i)
1168                 priv->qos_tbl_params.dscp_cos_map[i].ppio = priv->ppio;
1169
1170         /* Initialize Classifier QoS table. */
1171
1172         return pp2_cls_qos_tbl_init(&priv->qos_tbl_params, &priv->qos_tbl);
1173 }