drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxsw/spectrum_buffers.c
   3  * Copyright (c) 2015 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2015 Jiri Pirko <jiri@mellanox.com>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the names of the copyright holders nor the names of its
  15  *    contributors may be used to endorse or promote products derived from
  16  *    this software without specific prior written permission.
  17  *
  18  * Alternatively, this software may be distributed under the terms of the
  19  * GNU General Public License ("GPL") version 2 as published by the Free
  20  * Software Foundation.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  26  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  32  * POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/types.h>
  37 #include <linux/dcbnl.h>
  38 #include <linux/if_ether.h>
  39 #include <linux/list.h>
  40
  41 #include "spectrum.h"
  42 #include "core.h"
  43 #include "port.h"
  44 #include "reg.h"
  45
  46 static struct mlxsw_sp_sb_pr *mlxsw_sp_sb_pr_get(struct mlxsw_sp *mlxsw_sp,
  47                                                  u8 pool,
  48                                                  enum mlxsw_reg_sbxx_dir dir)
  49 {
  50         return &mlxsw_sp->sb.prs[dir][pool];
  51 }
  52
  53 static struct mlxsw_sp_sb_cm *mlxsw_sp_sb_cm_get(struct mlxsw_sp *mlxsw_sp,
  54                                                  u8 local_port, u8 pg_buff,
  55                                                  enum mlxsw_reg_sbxx_dir dir)
  56 {
  57         return &mlxsw_sp->sb.ports[local_port].cms[dir][pg_buff];
  58 }
  59
  60 static struct mlxsw_sp_sb_pm *mlxsw_sp_sb_pm_get(struct mlxsw_sp *mlxsw_sp,
  61                                                  u8 local_port, u8 pool,
  62                                                  enum mlxsw_reg_sbxx_dir dir)
  63 {
  64         return &mlxsw_sp->sb.ports[local_port].pms[dir][pool];
  65 }
  66
  67 static int mlxsw_sp_sb_pr_write(struct mlxsw_sp *mlxsw_sp, u8 pool,
  68                                 enum mlxsw_reg_sbxx_dir dir,
  69                                 enum mlxsw_reg_sbpr_mode mode, u32 size)
  70 {
  71         char sbpr_pl[MLXSW_REG_SBPR_LEN];
  72         struct mlxsw_sp_sb_pr *pr;
  73         int err;
  74
  75         mlxsw_reg_sbpr_pack(sbpr_pl, pool, dir, mode, size);
  76         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbpr), sbpr_pl);
  77         if (err)
  78                 return err;
  79
  80         pr = mlxsw_sp_sb_pr_get(mlxsw_sp, pool, dir);
  81         pr->mode = mode;
  82         pr->size = size;
  83         return 0;
  84 }
  85
  86 static int mlxsw_sp_sb_cm_write(struct mlxsw_sp *mlxsw_sp, u8 local_port,
  87                                 u8 pg_buff, enum mlxsw_reg_sbxx_dir dir,
  88                                 u32 min_buff, u32 max_buff, u8 pool)
  89 {
  90         char sbcm_pl[MLXSW_REG_SBCM_LEN];
  91         int err;
  92
  93         mlxsw_reg_sbcm_pack(sbcm_pl, local_port, pg_buff, dir,
  94                             min_buff, max_buff, pool);
  95         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbcm), sbcm_pl);
  96         if (err)
  97                 return err;
  98         if (pg_buff < MLXSW_SP_SB_TC_COUNT) {
  99                 struct mlxsw_sp_sb_cm *cm;
 100
 101                 cm = mlxsw_sp_sb_cm_get(mlxsw_sp, local_port, pg_buff, dir);
 102                 cm->min_buff = min_buff;
 103                 cm->max_buff = max_buff;
 104                 cm->pool = pool;
 105         }
 106         return 0;
 107 }
 108
 109 static int mlxsw_sp_sb_pm_write(struct mlxsw_sp *mlxsw_sp, u8 local_port,
 110                                 u8 pool, enum mlxsw_reg_sbxx_dir dir,
 111                                 u32 min_buff, u32 max_buff)
 112 {
 113         char sbpm_pl[MLXSW_REG_SBPM_LEN];
 114         struct mlxsw_sp_sb_pm *pm;
 115         int err;
 116
 117         mlxsw_reg_sbpm_pack(sbpm_pl, local_port, pool, dir, false,
 118                             min_buff, max_buff);
 119         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbpm), sbpm_pl);
 120         if (err)
 121                 return err;
 122
 123         pm = mlxsw_sp_sb_pm_get(mlxsw_sp, local_port, pool, dir);
 124         pm->min_buff = min_buff;
 125         pm->max_buff = max_buff;
 126         return 0;
 127 }
 128
 129 static int mlxsw_sp_sb_pm_occ_clear(struct mlxsw_sp *mlxsw_sp, u8 local_port,
 130                                     u8 pool, enum mlxsw_reg_sbxx_dir dir,
 131                                     struct list_head *bulk_list)
 132 {
 133         char sbpm_pl[MLXSW_REG_SBPM_LEN];
 134
 135         mlxsw_reg_sbpm_pack(sbpm_pl, local_port, pool, dir, true, 0, 0);
 136         return mlxsw_reg_trans_query(mlxsw_sp->core, MLXSW_REG(sbpm), sbpm_pl,
 137                                      bulk_list, NULL, 0);
 138 }
 139
 140 static void mlxsw_sp_sb_pm_occ_query_cb(struct mlxsw_core *mlxsw_core,
 141                                         char *sbpm_pl, size_t sbpm_pl_len,
 142                                         unsigned long cb_priv)
 143 {
 144         struct mlxsw_sp_sb_pm *pm = (struct mlxsw_sp_sb_pm *) cb_priv;
 145
 146         mlxsw_reg_sbpm_unpack(sbpm_pl, &pm->occ.cur, &pm->occ.max);
 147 }
 148
 149 static int mlxsw_sp_sb_pm_occ_query(struct mlxsw_sp *mlxsw_sp, u8 local_port,
 150                                     u8 pool, enum mlxsw_reg_sbxx_dir dir,
 151                                     struct list_head *bulk_list)
 152 {
 153         char sbpm_pl[MLXSW_REG_SBPM_LEN];
 154         struct mlxsw_sp_sb_pm *pm;
 155
 156         pm = mlxsw_sp_sb_pm_get(mlxsw_sp, local_port, pool, dir);
 157         mlxsw_reg_sbpm_pack(sbpm_pl, local_port, pool, dir, false, 0, 0);
 158         return mlxsw_reg_trans_query(mlxsw_sp->core, MLXSW_REG(sbpm), sbpm_pl,
 159                                      bulk_list,
 160                                      mlxsw_sp_sb_pm_occ_query_cb,
 161                                      (unsigned long) pm);
 162 }
 163
 164 static const u16 mlxsw_sp_pbs[] = {
 165         [0] = 2 * MLXSW_SP_BYTES_TO_CELLS(ETH_FRAME_LEN),
 166         [9] = 2 * MLXSW_SP_BYTES_TO_CELLS(MLXSW_PORT_MAX_MTU),
 167 };
 168
 169 #define MLXSW_SP_PBS_LEN ARRAY_SIZE(mlxsw_sp_pbs)
 170 #define MLXSW_SP_PB_UNUSED 8
 171
 172 static int mlxsw_sp_port_pb_init(struct mlxsw_sp_port *mlxsw_sp_port)
 173 {
 174         char pbmc_pl[MLXSW_REG_PBMC_LEN];
 175         int i;
 176
 177         mlxsw_reg_pbmc_pack(pbmc_pl, mlxsw_sp_port->local_port,
 178                             0xffff, 0xffff / 2);
 179         for (i = 0; i < MLXSW_SP_PBS_LEN; i++) {
 180                 if (i == MLXSW_SP_PB_UNUSED)
 181                         continue;
 182                 mlxsw_reg_pbmc_lossy_buffer_pack(pbmc_pl, i, mlxsw_sp_pbs[i]);
 183         }
 184         mlxsw_reg_pbmc_lossy_buffer_pack(pbmc_pl,
 185                                          MLXSW_REG_PBMC_PORT_SHARED_BUF_IDX, 0);
 186         return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core,
 187                                MLXSW_REG(pbmc), pbmc_pl);
 188 }
 189
 190 static int mlxsw_sp_port_pb_prio_init(struct mlxsw_sp_port *mlxsw_sp_port)
 191 {
 192         char pptb_pl[MLXSW_REG_PPTB_LEN];
 193         int i;
 194
 195         mlxsw_reg_pptb_pack(pptb_pl, mlxsw_sp_port->local_port);
 196         for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++)
 197                 mlxsw_reg_pptb_prio_to_buff_pack(pptb_pl, i, 0);
 198         return mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core, MLXSW_REG(pptb),
 199                                pptb_pl);
 200 }
 201
 202 static int mlxsw_sp_port_headroom_init(struct mlxsw_sp_port *mlxsw_sp_port)
 203 {
 204         int err;
 205
 206         err = mlxsw_sp_port_pb_init(mlxsw_sp_port);
 207         if (err)
 208                 return err;
 209         return mlxsw_sp_port_pb_prio_init(mlxsw_sp_port);
 210 }
 211
 212 #define MLXSW_SP_SB_PR_INGRESS_SIZE                             \
 213         (15000000 - (2 * 20000 * MLXSW_PORT_MAX_PORTS))
 214 #define MLXSW_SP_SB_PR_INGRESS_MNG_SIZE (200 * 1000)
 215 #define MLXSW_SP_SB_PR_EGRESS_SIZE                              \
 216         (14000000 - (8 * 1500 * MLXSW_PORT_MAX_PORTS))
 217
 218 #define MLXSW_SP_SB_PR(_mode, _size)    \
 219         {                               \
 220                 .mode = _mode,          \
 221                 .size = _size,          \
 222         }
 223
 224 static const struct mlxsw_sp_sb_pr mlxsw_sp_sb_prs_ingress[] = {
 225         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC,
 226                        MLXSW_SP_BYTES_TO_CELLS(MLXSW_SP_SB_PR_INGRESS_SIZE)),
 227         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC, 0),
 228         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC, 0),
 229         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC,
 230                        MLXSW_SP_BYTES_TO_CELLS(MLXSW_SP_SB_PR_INGRESS_MNG_SIZE)),
 231 };
 232
 233 #define MLXSW_SP_SB_PRS_INGRESS_LEN ARRAY_SIZE(mlxsw_sp_sb_prs_ingress)
 234
 235 static const struct mlxsw_sp_sb_pr mlxsw_sp_sb_prs_egress[] = {
 236         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC,
 237                        MLXSW_SP_BYTES_TO_CELLS(MLXSW_SP_SB_PR_EGRESS_SIZE)),
 238         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC, 0),
 239         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC, 0),
 240         MLXSW_SP_SB_PR(MLXSW_REG_SBPR_MODE_DYNAMIC, 0),
 241 };
 242
 243 #define MLXSW_SP_SB_PRS_EGRESS_LEN ARRAY_SIZE(mlxsw_sp_sb_prs_egress)
 244
 245 static int __mlxsw_sp_sb_prs_init(struct mlxsw_sp *mlxsw_sp,
 246                                   enum mlxsw_reg_sbxx_dir dir,
 247                                   const struct mlxsw_sp_sb_pr *prs,
 248                                   size_t prs_len)
 249 {
 250         int i;
 251         int err;
 252
 253         for (i = 0; i < prs_len; i++) {
 254                 const struct mlxsw_sp_sb_pr *pr;
 255
 256                 pr = &prs[i];
 257                 err = mlxsw_sp_sb_pr_write(mlxsw_sp, i, dir,
 258                                            pr->mode, pr->size);
 259                 if (err)
 260                         return err;
 261         }
 262         return 0;
 263 }
 264
 265 static int mlxsw_sp_sb_prs_init(struct mlxsw_sp *mlxsw_sp)
 266 {
 267         int err;
 268
 269         err = __mlxsw_sp_sb_prs_init(mlxsw_sp, MLXSW_REG_SBXX_DIR_INGRESS,
 270                                      mlxsw_sp_sb_prs_ingress,
 271                                      MLXSW_SP_SB_PRS_INGRESS_LEN);
 272         if (err)
 273                 return err;
 274         return __mlxsw_sp_sb_prs_init(mlxsw_sp, MLXSW_REG_SBXX_DIR_EGRESS,
 275                                       mlxsw_sp_sb_prs_egress,
 276                                       MLXSW_SP_SB_PRS_EGRESS_LEN);
 277 }
 278
 279 #define MLXSW_SP_SB_CM(_min_buff, _max_buff, _pool)     \
 280         {                                               \
 281                 .min_buff = _min_buff,                  \
 282                 .max_buff = _max_buff,                  \
 283                 .pool = _pool,                          \
 284         }
 285
 286 static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms_ingress[] = {
 287         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(10000), 8, 0),
 288         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 289         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 290         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 291         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 292         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 293         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 294         MLXSW_SP_SB_CM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN, 0),
 295         MLXSW_SP_SB_CM(0, 0, 0), /* dummy, this PG does not exist */
 296         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(20000), 1, 3),
 297 };
 298
 299 #define MLXSW_SP_SB_CMS_INGRESS_LEN ARRAY_SIZE(mlxsw_sp_sb_cms_ingress)
 300
 301 static const struct mlxsw_sp_sb_cm mlxsw_sp_sb_cms_egress[] = {
 302         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 303         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 304         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 305         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 306         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 307         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 308         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 309         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(1500), 9, 0),
 310         MLXSW_SP_SB_CM(0, 0, 0),
 311         MLXSW_SP_SB_CM(0, 0, 0),
 312         MLXSW_SP_SB_CM(0, 0, 0),
 313         MLXSW_SP_SB_CM(0, 0, 0),
 314         MLXSW_SP_SB_CM(0, 0, 0),
 315         MLXSW_SP_SB_CM(0, 0, 0),
 316         MLXSW_SP_SB_CM(0, 0, 0),
 317         MLXSW_SP_SB_CM(0, 0, 0),
 318         MLXSW_SP_SB_CM(1, 0xff, 0),
 319 };
 320
 321 #define MLXSW_SP_SB_CMS_EGRESS_LEN ARRAY_SIZE(mlxsw_sp_sb_cms_egress)
 322
 323 #define MLXSW_SP_CPU_PORT_SB_CM MLXSW_SP_SB_CM(0, 0, 0)
 324
 325 static const struct mlxsw_sp_sb_cm mlxsw_sp_cpu_port_sb_cms[] = {
 326         MLXSW_SP_CPU_PORT_SB_CM,
 327         MLXSW_SP_CPU_PORT_SB_CM,
 328         MLXSW_SP_CPU_PORT_SB_CM,
 329         MLXSW_SP_CPU_PORT_SB_CM,
 330         MLXSW_SP_CPU_PORT_SB_CM,
 331         MLXSW_SP_CPU_PORT_SB_CM,
 332         MLXSW_SP_CPU_PORT_SB_CM,
 333         MLXSW_SP_SB_CM(MLXSW_SP_BYTES_TO_CELLS(10000), 0, 0),
 334         MLXSW_SP_CPU_PORT_SB_CM,
 335         MLXSW_SP_CPU_PORT_SB_CM,
 336         MLXSW_SP_CPU_PORT_SB_CM,
 337         MLXSW_SP_CPU_PORT_SB_CM,
 338         MLXSW_SP_CPU_PORT_SB_CM,
 339         MLXSW_SP_CPU_PORT_SB_CM,
 340         MLXSW_SP_CPU_PORT_SB_CM,
 341         MLXSW_SP_CPU_PORT_SB_CM,
 342         MLXSW_SP_CPU_PORT_SB_CM,
 343         MLXSW_SP_CPU_PORT_SB_CM,
 344         MLXSW_SP_CPU_PORT_SB_CM,
 345         MLXSW_SP_CPU_PORT_SB_CM,
 346         MLXSW_SP_CPU_PORT_SB_CM,
 347         MLXSW_SP_CPU_PORT_SB_CM,
 348         MLXSW_SP_CPU_PORT_SB_CM,
 349         MLXSW_SP_CPU_PORT_SB_CM,
 350         MLXSW_SP_CPU_PORT_SB_CM,
 351         MLXSW_SP_CPU_PORT_SB_CM,
 352         MLXSW_SP_CPU_PORT_SB_CM,
 353         MLXSW_SP_CPU_PORT_SB_CM,
 354         MLXSW_SP_CPU_PORT_SB_CM,
 355         MLXSW_SP_CPU_PORT_SB_CM,
 356         MLXSW_SP_CPU_PORT_SB_CM,
 357         MLXSW_SP_CPU_PORT_SB_CM,
 358 };
 359
 360 #define MLXSW_SP_CPU_PORT_SB_MCS_LEN \
 361         ARRAY_SIZE(mlxsw_sp_cpu_port_sb_cms)
 362
 363 static int __mlxsw_sp_sb_cms_init(struct mlxsw_sp *mlxsw_sp, u8 local_port,
 364                                   enum mlxsw_reg_sbxx_dir dir,
 365                                   const struct mlxsw_sp_sb_cm *cms,
 366                                   size_t cms_len)
 367 {
 368         int i;
 369         int err;
 370
 371         for (i = 0; i < cms_len; i++) {
 372                 const struct mlxsw_sp_sb_cm *cm;
 373
 374                 if (i == 8 && dir == MLXSW_REG_SBXX_DIR_INGRESS)
 375                         continue; /* PG number 8 does not exist, skip it */
 376                 cm = &cms[i];
 377                 err = mlxsw_sp_sb_cm_write(mlxsw_sp, local_port, i, dir,
 378                                            cm->min_buff, cm->max_buff,
 379                                            cm->pool);
 380                 if (err)
 381                         return err;
 382         }
 383         return 0;
 384 }
 385
 386 static int mlxsw_sp_port_sb_cms_init(struct mlxsw_sp_port *mlxsw_sp_port)
 387 {
 388         int err;
 389
 390         err = __mlxsw_sp_sb_cms_init(mlxsw_sp_port->mlxsw_sp,
 391                                      mlxsw_sp_port->local_port,
 392                                      MLXSW_REG_SBXX_DIR_INGRESS,
 393                                      mlxsw_sp_sb_cms_ingress,
 394                                      MLXSW_SP_SB_CMS_INGRESS_LEN);
 395         if (err)
 396                 return err;
 397         return __mlxsw_sp_sb_cms_init(mlxsw_sp_port->mlxsw_sp,
 398                                       mlxsw_sp_port->local_port,
 399                                       MLXSW_REG_SBXX_DIR_EGRESS,
 400                                       mlxsw_sp_sb_cms_egress,
 401                                       MLXSW_SP_SB_CMS_EGRESS_LEN);
 402 }
 403
 404 static int mlxsw_sp_cpu_port_sb_cms_init(struct mlxsw_sp *mlxsw_sp)
 405 {
 406         return __mlxsw_sp_sb_cms_init(mlxsw_sp, 0, MLXSW_REG_SBXX_DIR_EGRESS,
 407                                       mlxsw_sp_cpu_port_sb_cms,
 408                                       MLXSW_SP_CPU_PORT_SB_MCS_LEN);
 409 }
 410
 411 #define MLXSW_SP_SB_PM(_min_buff, _max_buff)    \
 412         {                                       \
 413                 .min_buff = _min_buff,          \
 414                 .max_buff = _max_buff,          \
 415         }
 416
 417 static const struct mlxsw_sp_sb_pm mlxsw_sp_sb_pms_ingress[] = {
 418         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MAX),
 419         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN),
 420         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN),
 421         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MAX),
 422 };
 423
 424 #define MLXSW_SP_SB_PMS_INGRESS_LEN ARRAY_SIZE(mlxsw_sp_sb_pms_ingress)
 425
 426 static const struct mlxsw_sp_sb_pm mlxsw_sp_sb_pms_egress[] = {
 427         MLXSW_SP_SB_PM(0, 7),
 428         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN),
 429         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN),
 430         MLXSW_SP_SB_PM(0, MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN),
 431 };
 432
 433 #define MLXSW_SP_SB_PMS_EGRESS_LEN ARRAY_SIZE(mlxsw_sp_sb_pms_egress)
 434
 435 static int __mlxsw_sp_port_sb_pms_init(struct mlxsw_sp *mlxsw_sp, u8 local_port,
 436                                        enum mlxsw_reg_sbxx_dir dir,
 437                                        const struct mlxsw_sp_sb_pm *pms,
 438                                        size_t pms_len)
 439 {
 440         int i;
 441         int err;
 442
 443         for (i = 0; i < pms_len; i++) {
 444                 const struct mlxsw_sp_sb_pm *pm;
 445
 446                 pm = &pms[i];
 447                 err = mlxsw_sp_sb_pm_write(mlxsw_sp, local_port, i, dir,
 448                                            pm->min_buff, pm->max_buff);
 449                 if (err)
 450                         return err;
 451         }
 452         return 0;
 453 }
 454
 455 static int mlxsw_sp_port_sb_pms_init(struct mlxsw_sp_port *mlxsw_sp_port)
 456 {
 457         int err;
 458
 459         err = __mlxsw_sp_port_sb_pms_init(mlxsw_sp_port->mlxsw_sp,
 460                                           mlxsw_sp_port->local_port,
 461                                           MLXSW_REG_SBXX_DIR_INGRESS,
 462                                           mlxsw_sp_sb_pms_ingress,
 463                                           MLXSW_SP_SB_PMS_INGRESS_LEN);
 464         if (err)
 465                 return err;
 466         return __mlxsw_sp_port_sb_pms_init(mlxsw_sp_port->mlxsw_sp,
 467                                            mlxsw_sp_port->local_port,
 468                                            MLXSW_REG_SBXX_DIR_EGRESS,
 469                                            mlxsw_sp_sb_pms_egress,
 470                                            MLXSW_SP_SB_PMS_EGRESS_LEN);
 471 }
 472
 473 struct mlxsw_sp_sb_mm {
 474         u32 min_buff;
 475         u32 max_buff;
 476         u8 pool;
 477 };
 478
 479 #define MLXSW_SP_SB_MM(_min_buff, _max_buff, _pool)     \
 480         {                                               \
 481                 .min_buff = _min_buff,                  \
 482                 .max_buff = _max_buff,                  \
 483                 .pool = _pool,                          \
 484         }
 485
 486 static const struct mlxsw_sp_sb_mm mlxsw_sp_sb_mms[] = {
 487         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 488         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 489         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 490         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 491         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 492         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 493         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 494         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 495         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 496         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 497         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 498         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 499         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 500         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 501         MLXSW_SP_SB_MM(MLXSW_SP_BYTES_TO_CELLS(20000), 0xff, 0),
 502 };
 503
 504 #define MLXSW_SP_SB_MMS_LEN ARRAY_SIZE(mlxsw_sp_sb_mms)
 505
 506 static int mlxsw_sp_sb_mms_init(struct mlxsw_sp *mlxsw_sp)
 507 {
 508         char sbmm_pl[MLXSW_REG_SBMM_LEN];
 509         int i;
 510         int err;
 511
 512         for (i = 0; i < MLXSW_SP_SB_MMS_LEN; i++) {
 513                 const struct mlxsw_sp_sb_mm *mc;
 514
 515                 mc = &mlxsw_sp_sb_mms[i];
 516                 mlxsw_reg_sbmm_pack(sbmm_pl, i, mc->min_buff,
 517                                     mc->max_buff, mc->pool);
 518                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbmm), sbmm_pl);
 519                 if (err)
 520                         return err;
 521         }
 522         return 0;
 523 }
 524
 525 #define MLXSW_SP_SB_SIZE (16 * 1024 * 1024)
 526
 527 int mlxsw_sp_buffers_init(struct mlxsw_sp *mlxsw_sp)
 528 {
 529         int err;
 530
 531         err = mlxsw_sp_sb_prs_init(mlxsw_sp);
 532         if (err)
 533                 return err;
 534         err = mlxsw_sp_cpu_port_sb_cms_init(mlxsw_sp);
 535         if (err)
 536                 return err;
 537         err = mlxsw_sp_sb_mms_init(mlxsw_sp);
 538         if (err)
 539                 return err;
 540         return devlink_sb_register(priv_to_devlink(mlxsw_sp->core), 0,
 541                                    MLXSW_SP_SB_SIZE,
 542                                    MLXSW_SP_SB_POOL_COUNT,
 543                                    MLXSW_SP_SB_POOL_COUNT,
 544                                    MLXSW_SP_SB_TC_COUNT,
 545                                    MLXSW_SP_SB_TC_COUNT);
 546 }
 547
 548 void mlxsw_sp_buffers_fini(struct mlxsw_sp *mlxsw_sp)
 549 {
 550         devlink_sb_unregister(priv_to_devlink(mlxsw_sp->core), 0);
 551 }
 552
 553 int mlxsw_sp_port_buffers_init(struct mlxsw_sp_port *mlxsw_sp_port)
 554 {
 555         int err;
 556
 557         err = mlxsw_sp_port_headroom_init(mlxsw_sp_port);
 558         if (err)
 559                 return err;
 560         err = mlxsw_sp_port_sb_cms_init(mlxsw_sp_port);
 561         if (err)
 562                 return err;
 563         err = mlxsw_sp_port_sb_pms_init(mlxsw_sp_port);
 564
 565         return err;
 566 }
 567
 568 static u8 pool_get(u16 pool_index)
 569 {
 570         return pool_index % MLXSW_SP_SB_POOL_COUNT;
 571 }
 572
 573 static u16 pool_index_get(u8 pool, enum mlxsw_reg_sbxx_dir dir)
 574 {
 575         u16 pool_index;
 576
 577         pool_index = pool;
 578         if (dir == MLXSW_REG_SBXX_DIR_EGRESS)
 579                 pool_index += MLXSW_SP_SB_POOL_COUNT;
 580         return pool_index;
 581 }
 582
 583 static enum mlxsw_reg_sbxx_dir dir_get(u16 pool_index)
 584 {
 585         return pool_index < MLXSW_SP_SB_POOL_COUNT ?
 586                MLXSW_REG_SBXX_DIR_INGRESS : MLXSW_REG_SBXX_DIR_EGRESS;
 587 }
 588
 589 int mlxsw_sp_sb_pool_get(struct mlxsw_core *mlxsw_core,
 590                          unsigned int sb_index, u16 pool_index,
 591                          struct devlink_sb_pool_info *pool_info)
 592 {
 593         struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 594         u8 pool = pool_get(pool_index);
 595         enum mlxsw_reg_sbxx_dir dir = dir_get(pool_index);
 596         struct mlxsw_sp_sb_pr *pr = mlxsw_sp_sb_pr_get(mlxsw_sp, pool, dir);
 597
 598         pool_info->pool_type = (enum devlink_sb_pool_type) dir;
 599         pool_info->size = MLXSW_SP_CELLS_TO_BYTES(pr->size);
 600         pool_info->threshold_type = (enum devlink_sb_threshold_type) pr->mode;
 601         return 0;
 602 }
 603
 604 int mlxsw_sp_sb_pool_set(struct mlxsw_core *mlxsw_core,
 605                          unsigned int sb_index, u16 pool_index, u32 size,
 606                          enum devlink_sb_threshold_type threshold_type)
 607 {
 608         struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 609         u8 pool = pool_get(pool_index);
 610         enum mlxsw_reg_sbxx_dir dir = dir_get(pool_index);
 611         u32 pool_size = MLXSW_SP_BYTES_TO_CELLS(size);
 612         enum mlxsw_reg_sbpr_mode mode;
 613
 614         mode = (enum mlxsw_reg_sbpr_mode) threshold_type;
 615         return mlxsw_sp_sb_pr_write(mlxsw_sp, pool, dir, mode, pool_size);
 616 }
 617
 618 #define MLXSW_SP_SB_THRESHOLD_TO_ALPHA_OFFSET (-2) /* 3->1, 16->14 */
 619
 620 static u32 mlxsw_sp_sb_threshold_out(struct mlxsw_sp *mlxsw_sp, u8 pool,
 621                                      enum mlxsw_reg_sbxx_dir dir, u32 max_buff)
 622 {
 623         struct mlxsw_sp_sb_pr *pr = mlxsw_sp_sb_pr_get(mlxsw_sp, pool, dir);
 624
 625         if (pr->mode == MLXSW_REG_SBPR_MODE_DYNAMIC)
 626                 return max_buff - MLXSW_SP_SB_THRESHOLD_TO_ALPHA_OFFSET;
 627         return MLXSW_SP_CELLS_TO_BYTES(max_buff);
 628 }
 629
 630 static int mlxsw_sp_sb_threshold_in(struct mlxsw_sp *mlxsw_sp, u8 pool,
 631                                     enum mlxsw_reg_sbxx_dir dir, u32 threshold,
 632                                     u32 *p_max_buff)
 633 {
 634         struct mlxsw_sp_sb_pr *pr = mlxsw_sp_sb_pr_get(mlxsw_sp, pool, dir);
 635
 636         if (pr->mode == MLXSW_REG_SBPR_MODE_DYNAMIC) {
 637                 int val;
 638
 639                 val = threshold + MLXSW_SP_SB_THRESHOLD_TO_ALPHA_OFFSET;
 640                 if (val < MLXSW_REG_SBXX_DYN_MAX_BUFF_MIN ||
 641                     val > MLXSW_REG_SBXX_DYN_MAX_BUFF_MAX)
 642                         return -EINVAL;
 643                 *p_max_buff = val;
 644         } else {
 645                 *p_max_buff = MLXSW_SP_BYTES_TO_CELLS(threshold);
 646         }
 647         return 0;
 648 }
 649
 650 int mlxsw_sp_sb_port_pool_get(struct mlxsw_core_port *mlxsw_core_port,
 651                               unsigned int sb_index, u16 pool_index,
 652                               u32 *p_threshold)
 653 {
 654         struct mlxsw_sp_port *mlxsw_sp_port =
 655                         mlxsw_core_port_driver_priv(mlxsw_core_port);
 656         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 657         u8 local_port = mlxsw_sp_port->local_port;
 658         u8 pool = pool_get(pool_index);
 659         enum mlxsw_reg_sbxx_dir dir = dir_get(pool_index);
 660         struct mlxsw_sp_sb_pm *pm = mlxsw_sp_sb_pm_get(mlxsw_sp, local_port,
 661                                                        pool, dir);
 662
 663         *p_threshold = mlxsw_sp_sb_threshold_out(mlxsw_sp, pool, dir,
 664                                                  pm->max_buff);
 665         return 0;
 666 }
 667
 668 int mlxsw_sp_sb_port_pool_set(struct mlxsw_core_port *mlxsw_core_port,
 669                               unsigned int sb_index, u16 pool_index,
 670                               u32 threshold)
 671 {
 672         struct mlxsw_sp_port *mlxsw_sp_port =
 673                         mlxsw_core_port_driver_priv(mlxsw_core_port);
 674         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 675         u8 local_port = mlxsw_sp_port->local_port;
 676         u8 pool = pool_get(pool_index);
 677         enum mlxsw_reg_sbxx_dir dir = dir_get(pool_index);
 678         u32 max_buff;
 679         int err;
 680
 681         err = mlxsw_sp_sb_threshold_in(mlxsw_sp, pool, dir,
 682                                        threshold, &max_buff);
 683         if (err)
 684                 return err;
 685
 686         return mlxsw_sp_sb_pm_write(mlxsw_sp, local_port, pool, dir,
 687                                     0, max_buff);
 688 }
 689
 690 int mlxsw_sp_sb_tc_pool_bind_get(struct mlxsw_core_port *mlxsw_core_port,
 691                                  unsigned int sb_index, u16 tc_index,
 692                                  enum devlink_sb_pool_type pool_type,
 693                                  u16 *p_pool_index, u32 *p_threshold)
 694 {
 695         struct mlxsw_sp_port *mlxsw_sp_port =
 696                         mlxsw_core_port_driver_priv(mlxsw_core_port);
 697         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 698         u8 local_port = mlxsw_sp_port->local_port;
 699         u8 pg_buff = tc_index;
 700         enum mlxsw_reg_sbxx_dir dir = (enum mlxsw_reg_sbxx_dir) pool_type;
 701         struct mlxsw_sp_sb_cm *cm = mlxsw_sp_sb_cm_get(mlxsw_sp, local_port,
 702                                                        pg_buff, dir);
 703
 704         *p_threshold = mlxsw_sp_sb_threshold_out(mlxsw_sp, cm->pool, dir,
 705                                                  cm->max_buff);
 706         *p_pool_index = pool_index_get(cm->pool, dir);
 707         return 0;
 708 }
 709
 710 int mlxsw_sp_sb_tc_pool_bind_set(struct mlxsw_core_port *mlxsw_core_port,
 711                                  unsigned int sb_index, u16 tc_index,
 712                                  enum devlink_sb_pool_type pool_type,
 713                                  u16 pool_index, u32 threshold)
 714 {
 715         struct mlxsw_sp_port *mlxsw_sp_port =
 716                         mlxsw_core_port_driver_priv(mlxsw_core_port);
 717         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 718         u8 local_port = mlxsw_sp_port->local_port;
 719         u8 pg_buff = tc_index;
 720         enum mlxsw_reg_sbxx_dir dir = (enum mlxsw_reg_sbxx_dir) pool_type;
 721         u8 pool = pool_get(pool_index);
 722         u32 max_buff;
 723         int err;
 724
 725         if (dir != dir_get(pool_index))
 726                 return -EINVAL;
 727
 728         err = mlxsw_sp_sb_threshold_in(mlxsw_sp, pool, dir,
 729                                        threshold, &max_buff);
 730         if (err)
 731                 return err;
 732
 733         return mlxsw_sp_sb_cm_write(mlxsw_sp, local_port, pg_buff, dir,
 734                                     0, max_buff, pool);
 735 }
 736
 737 #define MASKED_COUNT_MAX \
 738         (MLXSW_REG_SBSR_REC_MAX_COUNT / (MLXSW_SP_SB_TC_COUNT * 2))
 739
 740 struct mlxsw_sp_sb_sr_occ_query_cb_ctx {
 741         u8 masked_count;
 742         u8 local_port_1;
 743 };
 744
 745 static void mlxsw_sp_sb_sr_occ_query_cb(struct mlxsw_core *mlxsw_core,
 746                                         char *sbsr_pl, size_t sbsr_pl_len,
 747                                         unsigned long cb_priv)
 748 {
 749         struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 750         struct mlxsw_sp_sb_sr_occ_query_cb_ctx cb_ctx;
 751         u8 masked_count;
 752         u8 local_port;
 753         int rec_index = 0;
 754         struct mlxsw_sp_sb_cm *cm;
 755         int i;
 756
 757         memcpy(&cb_ctx, &cb_priv, sizeof(cb_ctx));
 758
 759         masked_count = 0;
 760         for (local_port = cb_ctx.local_port_1;
 761              local_port < MLXSW_PORT_MAX_PORTS; local_port++) {
 762                 if (!mlxsw_sp->ports[local_port])
 763                         continue;
 764                 for (i = 0; i < MLXSW_SP_SB_TC_COUNT; i++) {
 765                         cm = mlxsw_sp_sb_cm_get(mlxsw_sp, local_port, i,
 766                                                 MLXSW_REG_SBXX_DIR_INGRESS);
 767                         mlxsw_reg_sbsr_rec_unpack(sbsr_pl, rec_index++,
 768                                                   &cm->occ.cur, &cm->occ.max);
 769                 }
 770                 if (++masked_count == cb_ctx.masked_count)
 771                         break;
 772         }
 773         masked_count = 0;
 774         for (local_port = cb_ctx.local_port_1;
 775              local_port < MLXSW_PORT_MAX_PORTS; local_port++) {
 776                 if (!mlxsw_sp->ports[local_port])
 777                         continue;
 778                 for (i = 0; i < MLXSW_SP_SB_TC_COUNT; i++) {
 779                         cm = mlxsw_sp_sb_cm_get(mlxsw_sp, local_port, i,
 780                                                 MLXSW_REG_SBXX_DIR_EGRESS);
 781                         mlxsw_reg_sbsr_rec_unpack(sbsr_pl, rec_index++,
 782                                                   &cm->occ.cur, &cm->occ.max);
 783                 }
 784                 if (++masked_count == cb_ctx.masked_count)
 785                         break;
 786         }
 787 }
 788
 789 int mlxsw_sp_sb_occ_snapshot(struct mlxsw_core *mlxsw_core,
 790                              unsigned int sb_index)
 791 {
 792         struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 793         struct mlxsw_sp_sb_sr_occ_query_cb_ctx cb_ctx;
 794         unsigned long cb_priv;
 795         LIST_HEAD(bulk_list);
 796         char *sbsr_pl;
 797         u8 masked_count;
 798         u8 local_port_1;
 799         u8 local_port = 0;
 800         int i;
 801         int err;
 802         int err2;
 803
 804         sbsr_pl = kmalloc(MLXSW_REG_SBSR_LEN, GFP_KERNEL);
 805         if (!sbsr_pl)
 806                 return -ENOMEM;
 807
 808 next_batch:
 809         local_port++;
 810         local_port_1 = local_port;
 811         masked_count = 0;
 812         mlxsw_reg_sbsr_pack(sbsr_pl, false);
 813         for (i = 0; i < MLXSW_SP_SB_TC_COUNT; i++) {
 814                 mlxsw_reg_sbsr_pg_buff_mask_set(sbsr_pl, i, 1);
 815                 mlxsw_reg_sbsr_tclass_mask_set(sbsr_pl, i, 1);
 816         }
 817         for (; local_port < MLXSW_PORT_MAX_PORTS; local_port++) {
 818                 if (!mlxsw_sp->ports[local_port])
 819                         continue;
 820                 mlxsw_reg_sbsr_ingress_port_mask_set(sbsr_pl, local_port, 1);
 821                 mlxsw_reg_sbsr_egress_port_mask_set(sbsr_pl, local_port, 1);
 822                 for (i = 0; i < MLXSW_SP_SB_POOL_COUNT; i++) {
 823                         err = mlxsw_sp_sb_pm_occ_query(mlxsw_sp, local_port, i,
 824                                                        MLXSW_REG_SBXX_DIR_INGRESS,
 825                                                        &bulk_list);
 826                         if (err)
 827                                 goto out;
 828                         err = mlxsw_sp_sb_pm_occ_query(mlxsw_sp, local_port, i,
 829                                                        MLXSW_REG_SBXX_DIR_EGRESS,
 830                                                        &bulk_list);
 831                         if (err)
 832                                 goto out;
 833                 }
 834                 if (++masked_count == MASKED_COUNT_MAX)
 835                         goto do_query;
 836         }
 837
 838 do_query:
 839         cb_ctx.masked_count = masked_count;
 840         cb_ctx.local_port_1 = local_port_1;
 841         memcpy(&cb_priv, &cb_ctx, sizeof(cb_ctx));
 842         err = mlxsw_reg_trans_query(mlxsw_core, MLXSW_REG(sbsr), sbsr_pl,
 843                                     &bulk_list, mlxsw_sp_sb_sr_occ_query_cb,
 844                                     cb_priv);
 845         if (err)
 846                 goto out;
 847         if (local_port < MLXSW_PORT_MAX_PORTS)
 848                 goto next_batch;
 849
 850 out:
 851         err2 = mlxsw_reg_trans_bulk_wait(&bulk_list);
 852         if (!err)
 853                 err = err2;
 854         kfree(sbsr_pl);
 855         return err;
 856 }
 857
 858 int mlxsw_sp_sb_occ_max_clear(struct mlxsw_core *mlxsw_core,
 859                               unsigned int sb_index)
 860 {
 861         struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);
 862         LIST_HEAD(bulk_list);
 863         char *sbsr_pl;
 864         unsigned int masked_count;
 865         u8 local_port = 0;
 866         int i;
 867         int err;
 868         int err2;
 869
 870         sbsr_pl = kmalloc(MLXSW_REG_SBSR_LEN, GFP_KERNEL);
 871         if (!sbsr_pl)
 872                 return -ENOMEM;
 873
 874 next_batch:
 875         local_port++;
 876         masked_count = 0;
 877         mlxsw_reg_sbsr_pack(sbsr_pl, true);
 878         for (i = 0; i < MLXSW_SP_SB_TC_COUNT; i++) {
 879                 mlxsw_reg_sbsr_pg_buff_mask_set(sbsr_pl, i, 1);
 880                 mlxsw_reg_sbsr_tclass_mask_set(sbsr_pl, i, 1);
 881         }
 882         for (; local_port < MLXSW_PORT_MAX_PORTS; local_port++) {
 883                 if (!mlxsw_sp->ports[local_port])
 884                         continue;
 885                 mlxsw_reg_sbsr_ingress_port_mask_set(sbsr_pl, local_port, 1);
 886                 mlxsw_reg_sbsr_egress_port_mask_set(sbsr_pl, local_port, 1);
 887                 for (i = 0; i < MLXSW_SP_SB_POOL_COUNT; i++) {
 888                         err = mlxsw_sp_sb_pm_occ_clear(mlxsw_sp, local_port, i,
 889                                                        MLXSW_REG_SBXX_DIR_INGRESS,
 890                                                        &bulk_list);
 891                         if (err)
 892                                 goto out;
 893                         err = mlxsw_sp_sb_pm_occ_clear(mlxsw_sp, local_port, i,
 894                                                        MLXSW_REG_SBXX_DIR_EGRESS,
 895                                                        &bulk_list);
 896                         if (err)
 897                                 goto out;
 898                 }
 899                 if (++masked_count == MASKED_COUNT_MAX)
 900                         goto do_query;
 901         }
 902
 903 do_query:
 904         err = mlxsw_reg_trans_query(mlxsw_core, MLXSW_REG(sbsr), sbsr_pl,
 905                                     &bulk_list, NULL, 0);
 906         if (err)
 907                 goto out;
 908         if (local_port < MLXSW_PORT_MAX_PORTS)
 909                 goto next_batch;
 910
 911 out:
 912         err2 = mlxsw_reg_trans_bulk_wait(&bulk_list);
 913         if (!err)
 914                 err = err2;
 915         kfree(sbsr_pl);
 916         return err;
 917 }
 918
 919 int mlxsw_sp_sb_occ_port_pool_get(struct mlxsw_core_port *mlxsw_core_port,
 920                                   unsigned int sb_index, u16 pool_index,
 921                                   u32 *p_cur, u32 *p_max)
 922 {
 923         struct mlxsw_sp_port *mlxsw_sp_port =
 924                         mlxsw_core_port_driver_priv(mlxsw_core_port);
 925         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 926         u8 local_port = mlxsw_sp_port->local_port;
 927         u8 pool = pool_get(pool_index);
 928         enum mlxsw_reg_sbxx_dir dir = dir_get(pool_index);
 929         struct mlxsw_sp_sb_pm *pm = mlxsw_sp_sb_pm_get(mlxsw_sp, local_port,
 930                                                        pool, dir);
 931
 932         *p_cur = MLXSW_SP_CELLS_TO_BYTES(pm->occ.cur);
 933         *p_max = MLXSW_SP_CELLS_TO_BYTES(pm->occ.max);
 934         return 0;
 935 }
 936
 937 int mlxsw_sp_sb_occ_tc_port_bind_get(struct mlxsw_core_port *mlxsw_core_port,
 938                                      unsigned int sb_index, u16 tc_index,
 939                                      enum devlink_sb_pool_type pool_type,
 940                                      u32 *p_cur, u32 *p_max)
 941 {
 942         struct mlxsw_sp_port *mlxsw_sp_port =
 943                         mlxsw_core_port_driver_priv(mlxsw_core_port);
 944         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 945         u8 local_port = mlxsw_sp_port->local_port;
 946         u8 pg_buff = tc_index;
 947         enum mlxsw_reg_sbxx_dir dir = (enum mlxsw_reg_sbxx_dir) pool_type;
 948         struct mlxsw_sp_sb_cm *cm = mlxsw_sp_sb_cm_get(mlxsw_sp, local_port,
 949                                                        pg_buff, dir);
 950
 951         *p_cur = MLXSW_SP_CELLS_TO_BYTES(cm->occ.cur);
 952         *p_max = MLXSW_SP_CELLS_TO_BYTES(cm->occ.max);
 953         return 0;
 954 }