drivers/net/ethernet/mscc/ocelot_police.c

   1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
   2 /* Microsemi Ocelot Switch driver
   3  *
   4  * Copyright (c) 2019 Microsemi Corporation
   5  */
   6
   7 #include <soc/mscc/ocelot.h>
   8 #include "ocelot_police.h"
   9
  10 /* Types for ANA:POL[0-192]:POL_MODE_CFG.FRM_MODE */
  11 #define POL_MODE_LINERATE   0 /* Incl IPG. Unit: 33 1/3 kbps, 4096 bytes */
  12 #define POL_MODE_DATARATE   1 /* Excl IPG. Unit: 33 1/3 kbps, 4096 bytes  */
  13 #define POL_MODE_FRMRATE_HI 2 /* Unit: 33 1/3 fps, 32.8 frames */
  14 #define POL_MODE_FRMRATE_LO 3 /* Unit: 1/3 fps, 0.3 frames */
  15
  16 /* Policer indexes */
  17 #define POL_IX_PORT    0    /* 0-11    : Port policers */
  18 #define POL_IX_QUEUE   32   /* 32-127  : Queue policers  */
  19
  20 /* Default policer order */
  21 #define POL_ORDER 0x1d3 /* Ocelot policer order: Serial (QoS -> Port -> VCAP) */
  22
  23 int qos_policer_conf_set(struct ocelot *ocelot, u32 pol_ix,
  24                          struct qos_policer_conf *conf)
  25 {
  26         u32 cf = 0, cir_ena = 0, frm_mode = POL_MODE_LINERATE;
  27         u32 cir = 0, cbs = 0, pir = 0, pbs = 0;
  28         bool cir_discard = 0, pir_discard = 0;
  29         u32 pbs_max = 0, cbs_max = 0;
  30         u8 ipg = 20;
  31         u32 value;
  32
  33         pir = conf->pir;
  34         pbs = conf->pbs;
  35
  36         switch (conf->mode) {
  37         case MSCC_QOS_RATE_MODE_LINE:
  38         case MSCC_QOS_RATE_MODE_DATA:
  39                 if (conf->mode == MSCC_QOS_RATE_MODE_LINE) {
  40                         frm_mode = POL_MODE_LINERATE;
  41                         ipg = min_t(u8, GENMASK(4, 0), conf->ipg);
  42                 } else {
  43                         frm_mode = POL_MODE_DATARATE;
  44                 }
  45                 if (conf->dlb) {
  46                         cir_ena = 1;
  47                         cir = conf->cir;
  48                         cbs = conf->cbs;
  49                         if (cir == 0 && cbs == 0) {
  50                                 /* Discard cir frames */
  51                                 cir_discard = 1;
  52                         } else {
  53                                 cir = DIV_ROUND_UP(cir, 100);
  54                                 cir *= 3; /* 33 1/3 kbps */
  55                                 cbs = DIV_ROUND_UP(cbs, 4096);
  56                                 cbs = (cbs ? cbs : 1); /* No zero burst size */
  57                                 cbs_max = 60; /* Limit burst size */
  58                                 cf = conf->cf;
  59                                 if (cf)
  60                                         pir += conf->cir;
  61                         }
  62                 }
  63                 if (pir == 0 && pbs == 0) {
  64                         /* Discard PIR frames */
  65                         pir_discard = 1;
  66                 } else {
  67                         pir = DIV_ROUND_UP(pir, 100);
  68                         pir *= 3;  /* 33 1/3 kbps */
  69                         pbs = DIV_ROUND_UP(pbs, 4096);
  70                         pbs = (pbs ? pbs : 1); /* No zero burst size */
  71                         pbs_max = 60; /* Limit burst size */
  72                 }
  73                 break;
  74         case MSCC_QOS_RATE_MODE_FRAME:
  75                 if (pir >= 100) {
  76                         frm_mode = POL_MODE_FRMRATE_HI;
  77                         pir = DIV_ROUND_UP(pir, 100);
  78                         pir *= 3;  /* 33 1/3 fps */
  79                         pbs = (pbs * 10) / 328; /* 32.8 frames */
  80                         pbs = (pbs ? pbs : 1); /* No zero burst size */
  81                         pbs_max = GENMASK(6, 0); /* Limit burst size */
  82                 } else {
  83                         frm_mode = POL_MODE_FRMRATE_LO;
  84                         if (pir == 0 && pbs == 0) {
  85                                 /* Discard all frames */
  86                                 pir_discard = 1;
  87                                 cir_discard = 1;
  88                         } else {
  89                                 pir *= 3; /* 1/3 fps */
  90                                 pbs = (pbs * 10) / 3; /* 0.3 frames */
  91                                 pbs = (pbs ? pbs : 1); /* No zero burst size */
  92                                 pbs_max = 61; /* Limit burst size */
  93                         }
  94                 }
  95                 break;
  96         default: /* MSCC_QOS_RATE_MODE_DISABLED */
  97                 /* Disable policer using maximum rate and zero burst */
  98                 pir = GENMASK(15, 0);
  99                 pbs = 0;
 100                 break;
 101         }
 102
 103         /* Check limits */
 104         if (pir > GENMASK(15, 0)) {
 105                 dev_err(ocelot->dev,
 106                         "Invalid pir for policer %u: %u (max %lu)\n",
 107                         pol_ix, pir, GENMASK(15, 0));
 108                 return -EINVAL;
 109         }
 110
 111         if (cir > GENMASK(15, 0)) {
 112                 dev_err(ocelot->dev,
 113                         "Invalid cir for policer %u: %u (max %lu)\n",
 114                         pol_ix, cir, GENMASK(15, 0));
 115                 return -EINVAL;
 116         }
 117
 118         if (pbs > pbs_max) {
 119                 dev_err(ocelot->dev,
 120                         "Invalid pbs for policer %u: %u (max %u)\n",
 121                         pol_ix, pbs, pbs_max);
 122                 return -EINVAL;
 123         }
 124
 125         if (cbs > cbs_max) {
 126                 dev_err(ocelot->dev,
 127                         "Invalid cbs for policer %u: %u (max %u)\n",
 128                         pol_ix, cbs, cbs_max);
 129                 return -EINVAL;
 130         }
 131
 132         value = (ANA_POL_MODE_CFG_IPG_SIZE(ipg) |
 133                  ANA_POL_MODE_CFG_FRM_MODE(frm_mode) |
 134                  (cf ? ANA_POL_MODE_CFG_DLB_COUPLED : 0) |
 135                  (cir_ena ? ANA_POL_MODE_CFG_CIR_ENA : 0) |
 136                  ANA_POL_MODE_CFG_OVERSHOOT_ENA);
 137
 138         ocelot_write_gix(ocelot, value, ANA_POL_MODE_CFG, pol_ix);
 139
 140         ocelot_write_gix(ocelot,
 141                          ANA_POL_PIR_CFG_PIR_RATE(pir) |
 142                          ANA_POL_PIR_CFG_PIR_BURST(pbs),
 143                          ANA_POL_PIR_CFG, pol_ix);
 144
 145         ocelot_write_gix(ocelot,
 146                          (pir_discard ? GENMASK(22, 0) : 0),
 147                          ANA_POL_PIR_STATE, pol_ix);
 148
 149         ocelot_write_gix(ocelot,
 150                          ANA_POL_CIR_CFG_CIR_RATE(cir) |
 151                          ANA_POL_CIR_CFG_CIR_BURST(cbs),
 152                          ANA_POL_CIR_CFG, pol_ix);
 153
 154         ocelot_write_gix(ocelot,
 155                          (cir_discard ? GENMASK(22, 0) : 0),
 156                          ANA_POL_CIR_STATE, pol_ix);
 157
 158         return 0;
 159 }
 160
 161 int ocelot_policer_validate(const struct flow_action *action,
 162                             const struct flow_action_entry *a,
 163                             struct netlink_ext_ack *extack)
 164 {
 165         if (a->police.exceed.act_id != FLOW_ACTION_DROP) {
 166                 NL_SET_ERR_MSG_MOD(extack,
 167                                    "Offload not supported when exceed action is not drop");
 168                 return -EOPNOTSUPP;
 169         }
 170
 171         if (a->police.notexceed.act_id != FLOW_ACTION_PIPE &&
 172             a->police.notexceed.act_id != FLOW_ACTION_ACCEPT) {
 173                 NL_SET_ERR_MSG_MOD(extack,
 174                                    "Offload not supported when conform action is not pipe or ok");
 175                 return -EOPNOTSUPP;
 176         }
 177
 178         if (a->police.notexceed.act_id == FLOW_ACTION_ACCEPT &&
 179             !flow_action_is_last_entry(action, a)) {
 180                 NL_SET_ERR_MSG_MOD(extack,
 181                                    "Offload not supported when conform action is ok, but police action is not last");
 182                 return -EOPNOTSUPP;
 183         }
 184
 185         if (a->police.peakrate_bytes_ps ||
 186             a->police.avrate || a->police.overhead) {
 187                 NL_SET_ERR_MSG_MOD(extack,
 188                                    "Offload not supported when peakrate/avrate/overhead is configured");
 189                 return -EOPNOTSUPP;
 190         }
 191
 192         if (a->police.rate_pkt_ps) {
 193                 NL_SET_ERR_MSG_MOD(extack,
 194                                    "Offload does not support packets per second");
 195                 return -EOPNOTSUPP;
 196         }
 197
 198         return 0;
 199 }
 200 EXPORT_SYMBOL(ocelot_policer_validate);
 201
 202 int ocelot_port_policer_add(struct ocelot *ocelot, int port,
 203                             struct ocelot_policer *pol)
 204 {
 205         struct qos_policer_conf pp = { 0 };
 206         int err;
 207
 208         if (!pol)
 209                 return -EINVAL;
 210
 211         pp.mode = MSCC_QOS_RATE_MODE_DATA;
 212         pp.pir = pol->rate;
 213         pp.pbs = pol->burst;
 214
 215         dev_dbg(ocelot->dev, "%s: port %u pir %u kbps, pbs %u bytes\n",
 216                 __func__, port, pp.pir, pp.pbs);
 217
 218         err = qos_policer_conf_set(ocelot, POL_IX_PORT + port, &pp);
 219         if (err)
 220                 return err;
 221
 222         ocelot_rmw_gix(ocelot,
 223                        ANA_PORT_POL_CFG_PORT_POL_ENA |
 224                        ANA_PORT_POL_CFG_POL_ORDER(POL_ORDER),
 225                        ANA_PORT_POL_CFG_PORT_POL_ENA |
 226                        ANA_PORT_POL_CFG_POL_ORDER_M,
 227                        ANA_PORT_POL_CFG, port);
 228
 229         return 0;
 230 }
 231 EXPORT_SYMBOL(ocelot_port_policer_add);
 232
 233 int ocelot_port_policer_del(struct ocelot *ocelot, int port)
 234 {
 235         struct qos_policer_conf pp = { 0 };
 236         int err;
 237
 238         dev_dbg(ocelot->dev, "%s: port %u\n", __func__, port);
 239
 240         pp.mode = MSCC_QOS_RATE_MODE_DISABLED;
 241
 242         err = qos_policer_conf_set(ocelot, POL_IX_PORT + port, &pp);
 243         if (err)
 244                 return err;
 245
 246         ocelot_rmw_gix(ocelot,
 247                        ANA_PORT_POL_CFG_POL_ORDER(POL_ORDER),
 248                        ANA_PORT_POL_CFG_PORT_POL_ENA |
 249                        ANA_PORT_POL_CFG_POL_ORDER_M,
 250                        ANA_PORT_POL_CFG, port);
 251
 252         return 0;
 253 }
 254 EXPORT_SYMBOL(ocelot_port_policer_del);