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