struct ocelot *ocelot = ds->priv;
        struct ocelot_policer pol = {
                .rate = div_u64(policer->rate_bytes_per_sec, 1000) * 8,
-               .burst = div_u64(policer->rate_bytes_per_sec *
-                                PSCHED_NS2TICKS(policer->burst),
-                                PSCHED_TICKS_PER_SEC),
+               .burst = policer->burst,
        };
 
        return ocelot_port_policer_add(ocelot, port, &pol);
 
                                       struct netlink_ext_ack *extack,
                                       unsigned long cookie, int port,
                                       u64 rate_bytes_per_sec,
-                                      s64 burst)
+                                      u32 burst)
 {
        struct sja1105_rule *rule = sja1105_rule_find(priv, cookie);
        struct sja1105_l2_policing_entry *policing;
 
        policing[rule->bcast_pol.sharindx].rate = div_u64(rate_bytes_per_sec *
                                                          512, 1000000);
-       policing[rule->bcast_pol.sharindx].smax = div_u64(rate_bytes_per_sec *
-                                                         PSCHED_NS2TICKS(burst),
-                                                         PSCHED_TICKS_PER_SEC);
+       policing[rule->bcast_pol.sharindx].smax = burst;
+
        /* TODO: support per-flow MTU */
        policing[rule->bcast_pol.sharindx].maxlen = VLAN_ETH_FRAME_LEN +
                                                    ETH_FCS_LEN;
                                    struct netlink_ext_ack *extack,
                                    unsigned long cookie, int port, int tc,
                                    u64 rate_bytes_per_sec,
-                                   s64 burst)
+                                   u32 burst)
 {
        struct sja1105_rule *rule = sja1105_rule_find(priv, cookie);
        struct sja1105_l2_policing_entry *policing;
 
        policing[rule->tc_pol.sharindx].rate = div_u64(rate_bytes_per_sec *
                                                       512, 1000000);
-       policing[rule->tc_pol.sharindx].smax = div_u64(rate_bytes_per_sec *
-                                                      PSCHED_NS2TICKS(burst),
-                                                      PSCHED_TICKS_PER_SEC);
+       policing[rule->tc_pol.sharindx].smax = burst;
+
        /* TODO: support per-flow MTU */
        policing[rule->tc_pol.sharindx].maxlen = VLAN_ETH_FRAME_LEN +
                                                 ETH_FCS_LEN;
                                  unsigned long cookie,
                                  struct sja1105_key *key,
                                  u64 rate_bytes_per_sec,
-                                 s64 burst)
+                                 u32 burst)
 {
        switch (key->type) {
        case SJA1105_KEY_BCAST:
 
         */
        policing[port].rate = div_u64(512 * policer->rate_bytes_per_sec,
                                      1000000);
-       policing[port].smax = div_u64(policer->rate_bytes_per_sec *
-                                     PSCHED_NS2TICKS(policer->burst),
-                                     PSCHED_TICKS_PER_SEC);
+       policing[port].smax = policer->burst;
 
        return sja1105_static_config_reload(priv, SJA1105_BEST_EFFORT_POLICING);
 }
 
        /* Flow meter and max frame size */
        if (entryp) {
                if (entryp->police.burst) {
-                       u64 temp;
-
                        fmi = kzalloc(sizeof(*fmi), GFP_KERNEL);
                        if (!fmi) {
                                err = -ENOMEM;
                        }
                        refcount_set(&fmi->refcount, 1);
                        fmi->cir = entryp->police.rate_bytes_ps;
-                       /* Convert to original burst value */
-                       temp = entryp->police.burst * fmi->cir;
-                       temp = div_u64(temp, 1000000000ULL);
-
-                       fmi->cbs = temp;
+                       fmi->cbs = entryp->police.burst;
                        fmi->index = entryp->police.index;
                        filter->flags |= ENETC_PSFP_FLAGS_FMI;
                        filter->fmi_index = fmi->index;
 
                                      struct ocelot_vcap_filter *filter)
 {
        const struct flow_action_entry *a;
-       s64 burst;
        u64 rate;
        int i;
 
                        filter->action = OCELOT_VCAP_ACTION_POLICE;
                        rate = a->police.rate_bytes_ps;
                        filter->pol.rate = div_u64(rate, 1000) * 8;
-                       burst = rate * PSCHED_NS2TICKS(a->police.burst);
-                       filter->pol.burst = div_u64(burst, PSCHED_TICKS_PER_SEC);
+                       filter->pol.burst = a->police.burst;
                        break;
                default:
                        return -EOPNOTSUPP;
 
                }
 
                pol.rate = (u32)div_u64(action->police.rate_bytes_ps, 1000) * 8;
-               pol.burst = (u32)div_u64(action->police.rate_bytes_ps *
-                                        PSCHED_NS2TICKS(action->police.burst),
-                                        PSCHED_TICKS_PER_SEC);
+               pol.burst = action->police.burst;
 
                err = ocelot_port_policer_add(ocelot, port, &pol);
                if (err) {
 
        struct nfp_repr *repr;
        struct sk_buff *skb;
        u32 netdev_port_id;
-       u64 burst, rate;
+       u32 burst;
+       u64 rate;
 
        if (!nfp_netdev_is_nfp_repr(netdev)) {
                NL_SET_ERR_MSG_MOD(extack, "unsupported offload: qos rate limit offload not supported on higher level port");
        }
 
        rate = action->police.rate_bytes_ps;
-       burst = div_u64(rate * PSCHED_NS2TICKS(action->police.burst),
-                       PSCHED_TICKS_PER_SEC);
+       burst = action->police.burst;
        netdev_port_id = nfp_repr_get_port_id(netdev);
 
        skb = nfp_flower_cmsg_alloc(repr->app, sizeof(struct nfp_police_config),
 
 
 /* TC port policer entry */
 struct dsa_mall_policer_tc_entry {
-       s64 burst;
+       u32 burst;
        u64 rate_bytes_per_sec;
 };
 
 
                } sample;
                struct {                                /* FLOW_ACTION_POLICE */
                        u32                     index;
-                       s64                     burst;
+                       u32                     burst;
                        u64                     rate_bytes_ps;
                        u32                     mtu;
                } police;
 
        return params->rate.rate_bytes_ps;
 }
 
-static inline s64 tcf_police_tcfp_burst(const struct tc_action *act)
+static inline u32 tcf_police_burst(const struct tc_action *act)
 {
        struct tcf_police *police = to_police(act);
        struct tcf_police_params *params;
+       u32 burst;
 
        params = rcu_dereference_protected(police->params,
                                           lockdep_is_held(&police->tcf_lock));
-       return params->tcfp_burst;
+
+       /*
+        *  "rate" bytes   "burst" nanoseconds
+        *  ------------ * -------------------
+        *    1 second          2^6 ticks
+        *
+        * ------------------------------------
+        *        NSEC_PER_SEC nanoseconds
+        *        ------------------------
+        *              2^6 ticks
+        *
+        *    "rate" bytes   "burst" nanoseconds            2^6 ticks
+        *  = ------------ * ------------------- * ------------------------
+        *      1 second          2^6 ticks        NSEC_PER_SEC nanoseconds
+        *
+        *   "rate" * "burst"
+        * = ---------------- bytes/nanosecond
+        *    NSEC_PER_SEC^2
+        *
+        *
+        *   "rate" * "burst"
+        * = ---------------- bytes/second
+        *     NSEC_PER_SEC
+        */
+       burst = div_u64(params->tcfp_burst * params->rate.rate_bytes_ps,
+                       NSEC_PER_SEC);
+
+       return burst;
 }
 
 static inline u32 tcf_police_tcfp_mtu(const struct tc_action *act)
 
                        tcf_sample_get_group(entry, act);
                } else if (is_tcf_police(act)) {
                        entry->id = FLOW_ACTION_POLICE;
-                       entry->police.burst = tcf_police_tcfp_burst(act);
+                       entry->police.burst = tcf_police_burst(act);
                        entry->police.rate_bytes_ps =
                                tcf_police_rate_bytes_ps(act);
                        entry->police.mtu = tcf_police_tcfp_mtu(act);