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