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

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxsw/spectrum_qdisc.c
   3  * Copyright (c) 2017 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2017 Nogah Frankel <nogahf@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/errno.h>
  37 #include <linux/netdevice.h>
  38 #include <net/pkt_cls.h>
  39 #include <net/red.h>
  40
  41 #include "spectrum.h"
  42 #include "reg.h"
  43
  44 static int
  45 mlxsw_sp_tclass_congestion_enable(struct mlxsw_sp_port *mlxsw_sp_port,
  46                                   int tclass_num, u32 min, u32 max,
  47                                   u32 probability, bool is_ecn)
  48 {
  49         char cwtpm_cmd[MLXSW_REG_CWTPM_LEN];
  50         char cwtp_cmd[MLXSW_REG_CWTP_LEN];
  51         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
  52         int err;
  53
  54         mlxsw_reg_cwtp_pack(cwtp_cmd, mlxsw_sp_port->local_port, tclass_num);
  55         mlxsw_reg_cwtp_profile_pack(cwtp_cmd, MLXSW_REG_CWTP_DEFAULT_PROFILE,
  56                                     roundup(min, MLXSW_REG_CWTP_MIN_VALUE),
  57                                     roundup(max, MLXSW_REG_CWTP_MIN_VALUE),
  58                                     probability);
  59
  60         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(cwtp), cwtp_cmd);
  61         if (err)
  62                 return err;
  63
  64         mlxsw_reg_cwtpm_pack(cwtpm_cmd, mlxsw_sp_port->local_port, tclass_num,
  65                              MLXSW_REG_CWTP_DEFAULT_PROFILE, true, is_ecn);
  66
  67         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(cwtpm), cwtpm_cmd);
  68 }
  69
  70 static int
  71 mlxsw_sp_tclass_congestion_disable(struct mlxsw_sp_port *mlxsw_sp_port,
  72                                    int tclass_num)
  73 {
  74         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
  75         char cwtpm_cmd[MLXSW_REG_CWTPM_LEN];
  76
  77         mlxsw_reg_cwtpm_pack(cwtpm_cmd, mlxsw_sp_port->local_port, tclass_num,
  78                              MLXSW_REG_CWTPM_RESET_PROFILE, false, false);
  79         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(cwtpm), cwtpm_cmd);
  80 }
  81
  82 static void
  83 mlxsw_sp_setup_tc_qdisc_clean_stats(struct mlxsw_sp_port *mlxsw_sp_port,
  84                                     struct mlxsw_sp_qdisc *mlxsw_sp_qdisc,
  85                                     int tclass_num)
  86 {
  87         struct red_stats *xstats_base = &mlxsw_sp_qdisc->xstats_base;
  88         struct mlxsw_sp_port_xstats *xstats;
  89         struct rtnl_link_stats64 *stats;
  90
  91         xstats = &mlxsw_sp_port->periodic_hw_stats.xstats;
  92         stats = &mlxsw_sp_port->periodic_hw_stats.stats;
  93
  94         mlxsw_sp_qdisc->tx_packets = stats->tx_packets;
  95         mlxsw_sp_qdisc->tx_bytes = stats->tx_bytes;
  96
  97         switch (mlxsw_sp_qdisc->type) {
  98         case MLXSW_SP_QDISC_RED:
  99                 xstats_base->prob_mark = xstats->ecn;
 100                 xstats_base->prob_drop = xstats->wred_drop[tclass_num];
 101                 xstats_base->pdrop = xstats->tail_drop[tclass_num];
 102
 103                 mlxsw_sp_qdisc->overlimits = xstats_base->prob_drop +
 104                                              xstats_base->prob_mark;
 105                 mlxsw_sp_qdisc->drops = xstats_base->prob_drop +
 106                                         xstats_base->pdrop;
 107                 break;
 108         default:
 109                 break;
 110         }
 111 }
 112
 113 static int
 114 mlxsw_sp_qdisc_red_destroy(struct mlxsw_sp_port *mlxsw_sp_port, u32 handle,
 115                            struct mlxsw_sp_qdisc *mlxsw_sp_qdisc,
 116                            int tclass_num)
 117 {
 118         int err;
 119
 120         if (mlxsw_sp_qdisc->handle != handle)
 121                 return 0;
 122
 123         err = mlxsw_sp_tclass_congestion_disable(mlxsw_sp_port, tclass_num);
 124         mlxsw_sp_qdisc->handle = TC_H_UNSPEC;
 125         mlxsw_sp_qdisc->type = MLXSW_SP_QDISC_NO_QDISC;
 126
 127         return err;
 128 }
 129
 130 static int
 131 mlxsw_sp_qdisc_red_replace(struct mlxsw_sp_port *mlxsw_sp_port, u32 handle,
 132                            struct mlxsw_sp_qdisc *mlxsw_sp_qdisc,
 133                            int tclass_num,
 134                            struct tc_red_qopt_offload_params *p)
 135 {
 136         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 137         u32 min, max;
 138         u64 prob;
 139         int err = 0;
 140
 141         if (p->min > p->max) {
 142                 dev_err(mlxsw_sp->bus_info->dev,
 143                         "spectrum: RED: min %u is bigger then max %u\n", p->min,
 144                         p->max);
 145                 goto err_bad_param;
 146         }
 147         if (p->max > MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_BUFFER_SIZE)) {
 148                 dev_err(mlxsw_sp->bus_info->dev,
 149                         "spectrum: RED: max value %u is too big\n", p->max);
 150                 goto err_bad_param;
 151         }
 152         if (p->min == 0 || p->max == 0) {
 153                 dev_err(mlxsw_sp->bus_info->dev,
 154                         "spectrum: RED: 0 value is illegal for min and max\n");
 155                 goto err_bad_param;
 156         }
 157
 158         /* calculate probability in percentage */
 159         prob = p->probability;
 160         prob *= 100;
 161         prob = DIV_ROUND_UP(prob, 1 << 16);
 162         prob = DIV_ROUND_UP(prob, 1 << 16);
 163         min = mlxsw_sp_bytes_cells(mlxsw_sp, p->min);
 164         max = mlxsw_sp_bytes_cells(mlxsw_sp, p->max);
 165         err = mlxsw_sp_tclass_congestion_enable(mlxsw_sp_port, tclass_num, min,
 166                                                 max, prob, p->is_ecn);
 167         if (err)
 168                 goto err_config;
 169
 170         mlxsw_sp_qdisc->type = MLXSW_SP_QDISC_RED;
 171         if (mlxsw_sp_qdisc->handle != handle)
 172                 mlxsw_sp_setup_tc_qdisc_clean_stats(mlxsw_sp_port,
 173                                                     mlxsw_sp_qdisc,
 174                                                     tclass_num);
 175
 176         mlxsw_sp_qdisc->handle = handle;
 177         return 0;
 178
 179 err_bad_param:
 180         err = -EINVAL;
 181 err_config:
 182         mlxsw_sp_qdisc_red_destroy(mlxsw_sp_port, mlxsw_sp_qdisc->handle,
 183                                    mlxsw_sp_qdisc, tclass_num);
 184         return err;
 185 }
 186
 187 static int
 188 mlxsw_sp_qdisc_get_red_xstats(struct mlxsw_sp_port *mlxsw_sp_port, u32 handle,
 189                               struct mlxsw_sp_qdisc *mlxsw_sp_qdisc,
 190                               int tclass_num, struct red_stats *res)
 191 {
 192         struct red_stats *xstats_base = &mlxsw_sp_qdisc->xstats_base;
 193         struct mlxsw_sp_port_xstats *xstats;
 194
 195         if (mlxsw_sp_qdisc->handle != handle ||
 196             mlxsw_sp_qdisc->type != MLXSW_SP_QDISC_RED)
 197                 return -EOPNOTSUPP;
 198
 199         xstats = &mlxsw_sp_port->periodic_hw_stats.xstats;
 200
 201         res->prob_drop = xstats->wred_drop[tclass_num] - xstats_base->prob_drop;
 202         res->prob_mark = xstats->ecn - xstats_base->prob_mark;
 203         res->pdrop = xstats->tail_drop[tclass_num] - xstats_base->pdrop;
 204         return 0;
 205 }
 206
 207 static int
 208 mlxsw_sp_qdisc_get_red_stats(struct mlxsw_sp_port *mlxsw_sp_port, u32 handle,
 209                              struct mlxsw_sp_qdisc *mlxsw_sp_qdisc,
 210                              int tclass_num,
 211                              struct tc_red_qopt_offload_stats *res)
 212 {
 213         u64 tx_bytes, tx_packets, overlimits, drops;
 214         struct mlxsw_sp_port_xstats *xstats;
 215         struct rtnl_link_stats64 *stats;
 216
 217         if (mlxsw_sp_qdisc->handle != handle ||
 218             mlxsw_sp_qdisc->type != MLXSW_SP_QDISC_RED)
 219                 return -EOPNOTSUPP;
 220
 221         xstats = &mlxsw_sp_port->periodic_hw_stats.xstats;
 222         stats = &mlxsw_sp_port->periodic_hw_stats.stats;
 223
 224         tx_bytes = stats->tx_bytes - mlxsw_sp_qdisc->tx_bytes;
 225         tx_packets = stats->tx_packets - mlxsw_sp_qdisc->tx_packets;
 226         overlimits = xstats->wred_drop[tclass_num] + xstats->ecn -
 227                      mlxsw_sp_qdisc->overlimits;
 228         drops = xstats->wred_drop[tclass_num] + xstats->tail_drop[tclass_num] -
 229                 mlxsw_sp_qdisc->drops;
 230
 231         _bstats_update(res->bstats, tx_bytes, tx_packets);
 232         res->qstats->overlimits += overlimits;
 233         res->qstats->drops += drops;
 234         res->qstats->backlog += mlxsw_sp_cells_bytes(mlxsw_sp_port->mlxsw_sp,
 235                                                 xstats->backlog[tclass_num]);
 236
 237         mlxsw_sp_qdisc->drops +=  drops;
 238         mlxsw_sp_qdisc->overlimits += overlimits;
 239         mlxsw_sp_qdisc->tx_bytes += tx_bytes;
 240         mlxsw_sp_qdisc->tx_packets += tx_packets;
 241         return 0;
 242 }
 243
 244 #define MLXSW_SP_PORT_DEFAULT_TCLASS 0
 245
 246 int mlxsw_sp_setup_tc_red(struct mlxsw_sp_port *mlxsw_sp_port,
 247                           struct tc_red_qopt_offload *p)
 248 {
 249         struct mlxsw_sp_qdisc *mlxsw_sp_qdisc;
 250         int tclass_num;
 251
 252         if (p->parent != TC_H_ROOT)
 253                 return -EOPNOTSUPP;
 254
 255         mlxsw_sp_qdisc = &mlxsw_sp_port->root_qdisc;
 256         tclass_num = MLXSW_SP_PORT_DEFAULT_TCLASS;
 257
 258         switch (p->command) {
 259         case TC_RED_REPLACE:
 260                 return mlxsw_sp_qdisc_red_replace(mlxsw_sp_port, p->handle,
 261                                                   mlxsw_sp_qdisc, tclass_num,
 262                                                   &p->set);
 263         case TC_RED_DESTROY:
 264                 return mlxsw_sp_qdisc_red_destroy(mlxsw_sp_port, p->handle,
 265                                                   mlxsw_sp_qdisc, tclass_num);
 266         case TC_RED_XSTATS:
 267                 return mlxsw_sp_qdisc_get_red_xstats(mlxsw_sp_port, p->handle,
 268                                                      mlxsw_sp_qdisc, tclass_num,
 269                                                      p->xstats);
 270         case TC_RED_STATS:
 271                 return mlxsw_sp_qdisc_get_red_stats(mlxsw_sp_port, p->handle,
 272                                                     mlxsw_sp_qdisc, tclass_num,
 273                                                     &p->stats);
 274         default:
 275                 return -EOPNOTSUPP;
 276         }
 277 }