Quelle  ocelot_police.c   Sprache: C

// SPDX-License-Identifier: (GPL-2.0 OR MIT)
/* Microsemi Ocelot Switch driver
 *
 * Copyright (c) 2019 Microsemi Corporation
 */

#include <soc/mscc/ocelot.h>
#include "ocelot_police.h"

/* Types for ANA:POL[0-192]:POL_MODE_CFG.FRM_MODE */
#define POL_MODE_LINERATE   0 /* Incl IPG. Unit: 33 1/3 kbps, 4096 bytes */
#define POL_MODE_DATARATE   1 /* Excl IPG. Unit: 33 1/3 kbps, 4096 bytes  */
#define POL_MODE_FRMRATE_HI 2 /* Unit: 33 1/3 fps, 32.8 frames */
#define POL_MODE_FRMRATE_LO 3 /* Unit: 1/3 fps, 0.3 frames */

/* Policer indexes */
#define POL_IX_PORT    0    /* 0-11    : Port policers */
#define POL_IX_QUEUE   32   /* 32-127  : Queue policers  */

/* Default policer order */
#define POL_ORDER 0x1d3 /* Ocelot policer order: Serial (QoS -> Port -> VCAP) */

int qos_policer_conf_set(struct ocelot *ocelot, u32 pol_ix,
    struct qos_policer_conf *conf)
{
 u32 cf = 0, cir_ena = 0, frm_mode = POL_MODE_LINERATE;
 u32 cir = 0, cbs = 0, pir = 0, pbs = 0;
 bool cir_discard = 0, pir_discard = 0;
 u32 pbs_max = 0, cbs_max = 0;
 u8 ipg = 20;
 u32 value;

 pir = conf->pir;
 pbs = conf->pbs;

 switch (conf->mode) {
 case MSCC_QOS_RATE_MODE_LINE:
 case MSCC_QOS_RATE_MODE_DATA:
  if (conf->mode == MSCC_QOS_RATE_MODE_LINE) {
   frm_mode = POL_MODE_LINERATE;
   ipg = min_t(u8, GENMASK(4, 0), conf->ipg);
  } else {
   frm_mode = POL_MODE_DATARATE;
  }
  if (conf->dlb) {
   cir_ena = 1;
   cir = conf->cir;
   cbs = conf->cbs;
   if (cir == 0 && cbs == 0) {
    /* Discard cir frames */
    cir_discard = 1;
   } else {
    cir = DIV_ROUND_UP(cir, 100);
    cir *= 3; /* 33 1/3 kbps */
    cbs = DIV_ROUND_UP(cbs, 4096);
    cbs = (cbs ? cbs : 1); /* No zero burst size */
    cbs_max = 60; /* Limit burst size */
    cf = conf->cf;
    if (cf)
     pir += conf->cir;
   }
  }
  if (pir == 0 && pbs == 0) {
   /* Discard PIR frames */
   pir_discard = 1;
  } else {
   pir = DIV_ROUND_UP(pir, 100);
   pir *= 3;  /* 33 1/3 kbps */
   pbs = DIV_ROUND_UP(pbs, 4096);
   pbs = (pbs ? pbs : 1); /* No zero burst size */
   pbs_max = 60; /* Limit burst size */
  }
  break;
 case MSCC_QOS_RATE_MODE_FRAME:
  if (pir >= 100) {
   frm_mode = POL_MODE_FRMRATE_HI;
   pir = DIV_ROUND_UP(pir, 100);
   pir *= 3;  /* 33 1/3 fps */
   pbs = (pbs * 10) / 328; /* 32.8 frames */
   pbs = (pbs ? pbs : 1); /* No zero burst size */
   pbs_max = GENMASK(6, 0); /* Limit burst size */
  } else {
   frm_mode = POL_MODE_FRMRATE_LO;
   if (pir == 0 && pbs == 0) {
    /* Discard all frames */
    pir_discard = 1;
    cir_discard = 1;
   } else {
    pir *= 3; /* 1/3 fps */
    pbs = (pbs * 10) / 3; /* 0.3 frames */
    pbs = (pbs ? pbs : 1); /* No zero burst size */
    pbs_max = 61; /* Limit burst size */
   }
  }
  break;
 default: /* MSCC_QOS_RATE_MODE_DISABLED */
  /* Disable policer using maximum rate and zero burst */
  pir = GENMASK(15, 0);
  pbs = 0;
  break;
 }

 /* Check limits */
 if (pir > GENMASK(15, 0)) {
  dev_err(ocelot->dev,
   "Invalid pir for policer %u: %u (max %lu)\n",
   pol_ix, pir, GENMASK(15, 0));
  return -EINVAL;
 }

 if (cir > GENMASK(15, 0)) {
  dev_err(ocelot->dev,
   "Invalid cir for policer %u: %u (max %lu)\n",
   pol_ix, cir, GENMASK(15, 0));
  return -EINVAL;
 }

 if (pbs > pbs_max) {
  dev_err(ocelot->dev,
   "Invalid pbs for policer %u: %u (max %u)\n",
   pol_ix, pbs, pbs_max);
  return -EINVAL;
 }

 if (cbs > cbs_max) {
  dev_err(ocelot->dev,
   "Invalid cbs for policer %u: %u (max %u)\n",
   pol_ix, cbs, cbs_max);
  return -EINVAL;
 }

 value = (ANA_POL_MODE_CFG_IPG_SIZE(ipg) |
   ANA_POL_MODE_CFG_FRM_MODE(frm_mode) |
   (cf ? ANA_POL_MODE_CFG_DLB_COUPLED : 0) |
   (cir_ena ? ANA_POL_MODE_CFG_CIR_ENA : 0) |
   ANA_POL_MODE_CFG_OVERSHOOT_ENA);

 ocelot_write_gix(ocelot, value, ANA_POL_MODE_CFG, pol_ix);

 ocelot_write_gix(ocelot,
    ANA_POL_PIR_CFG_PIR_RATE(pir) |
    ANA_POL_PIR_CFG_PIR_BURST(pbs),
    ANA_POL_PIR_CFG, pol_ix);

 ocelot_write_gix(ocelot,
    (pir_discard ? GENMASK(22, 0) : 0),
    ANA_POL_PIR_STATE, pol_ix);

 ocelot_write_gix(ocelot,
    ANA_POL_CIR_CFG_CIR_RATE(cir) |
    ANA_POL_CIR_CFG_CIR_BURST(cbs),
    ANA_POL_CIR_CFG, pol_ix);

 ocelot_write_gix(ocelot,
    (cir_discard ? GENMASK(22, 0) : 0),
    ANA_POL_CIR_STATE, pol_ix);

 return 0;
}

int ocelot_policer_validate(const struct flow_action *action,
       const struct flow_action_entry *a,
       struct netlink_ext_ack *extack)
{
 if (a->police.exceed.act_id != FLOW_ACTION_DROP) {
  NL_SET_ERR_MSG_MOD(extack,
       "Offload not supported when exceed action is not drop");
  return -EOPNOTSUPP;
 }

 if (a->police.notexceed.act_id != FLOW_ACTION_PIPE &&
     a->police.notexceed.act_id != FLOW_ACTION_ACCEPT) {
  NL_SET_ERR_MSG_MOD(extack,
       "Offload not supported when conform action is not pipe or ok");
  return -EOPNOTSUPP;
 }

 if (a->police.notexceed.act_id == FLOW_ACTION_ACCEPT &&
     !flow_action_is_last_entry(action, a)) {
  NL_SET_ERR_MSG_MOD(extack,
       "Offload not supported when conform action is ok, but police action is not last");
  return -EOPNOTSUPP;
 }

 if (a->police.peakrate_bytes_ps ||
     a->police.avrate || a->police.overhead) {
  NL_SET_ERR_MSG_MOD(extack,
       "Offload not supported when peakrate/avrate/overhead is configured");
  return -EOPNOTSUPP;
 }

 if (a->police.rate_pkt_ps) {
  NL_SET_ERR_MSG_MOD(extack,
       "Offload does not support packets per second");
  return -EOPNOTSUPP;
 }

 return 0;
}
EXPORT_SYMBOL(ocelot_policer_validate);

int ocelot_port_policer_add(struct ocelot *ocelot, int port,
       struct ocelot_policer *pol)
{
 struct qos_policer_conf pp = { 0 };
 int err;

 if (!pol)
  return -EINVAL;

 pp.mode = MSCC_QOS_RATE_MODE_DATA;
 pp.pir = pol->rate;
 pp.pbs = pol->burst;

 dev_dbg(ocelot->dev, "%s: port %u pir %u kbps, pbs %u bytes\n",
  __func__, port, pp.pir, pp.pbs);

 err = qos_policer_conf_set(ocelot, POL_IX_PORT + port, &pp);
 if (err)
  return err;

 ocelot_rmw_gix(ocelot,
         ANA_PORT_POL_CFG_PORT_POL_ENA |
         ANA_PORT_POL_CFG_POL_ORDER(POL_ORDER),
         ANA_PORT_POL_CFG_PORT_POL_ENA |
         ANA_PORT_POL_CFG_POL_ORDER_M,
         ANA_PORT_POL_CFG, port);

 return 0;
}
EXPORT_SYMBOL(ocelot_port_policer_add);

int ocelot_port_policer_del(struct ocelot *ocelot, int port)
{
 struct qos_policer_conf pp = { 0 };
 int err;

 dev_dbg(ocelot->dev, "%s: port %u\n", __func__, port);

 pp.mode = MSCC_QOS_RATE_MODE_DISABLED;

 err = qos_policer_conf_set(ocelot, POL_IX_PORT + port, &pp);
 if (err)
  return err;

 ocelot_rmw_gix(ocelot,
         ANA_PORT_POL_CFG_POL_ORDER(POL_ORDER),
         ANA_PORT_POL_CFG_PORT_POL_ENA |
         ANA_PORT_POL_CFG_POL_ORDER_M,
         ANA_PORT_POL_CFG, port);

 return 0;
}
EXPORT_SYMBOL(ocelot_port_policer_del);