OSCL-LXR linux-6.0.1/​drivers/​net/​ethernet/​mscc/​ocelot_devlink.c	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
 /* Copyright 2020-2021 NXP
  */
 #include <net/devlink.h>
 #include "ocelot.h"
 
 /* The queue system tracks four resource consumptions:
  * Resource 0: Memory tracked per source port
  * Resource 1: Frame references tracked per source port
  * Resource 2: Memory tracked per destination port
  * Resource 3: Frame references tracked per destination port
  */
 #define OCELOT_RESOURCE_SZ      256
 #define OCELOT_NUM_RESOURCES        4
 
 #define BUF_xxxx_I          (0 * OCELOT_RESOURCE_SZ)
 #define REF_xxxx_I          (1 * OCELOT_RESOURCE_SZ)
 #define BUF_xxxx_E          (2 * OCELOT_RESOURCE_SZ)
 #define REF_xxxx_E          (3 * OCELOT_RESOURCE_SZ)
 
 /* For each resource type there are 4 types of watermarks:
  * Q_RSRV: reservation per QoS class per port
  * PRIO_SHR: sharing watermark per QoS class across all ports
  * P_RSRV: reservation per port
  * COL_SHR: sharing watermark per color (drop precedence) across all ports
  */
 #define xxx_Q_RSRV_x            0
 #define xxx_PRIO_SHR_x          216
 #define xxx_P_RSRV_x            224
 #define xxx_COL_SHR_x           254
 
 /* Reservation Watermarks
  * ----------------------
  *
  * For setting up the reserved areas, egress watermarks exist per port and per
  * QoS class for both ingress and egress.
  */
 
 /*  Amount of packet buffer
  *  |  per QoS class
  *  |  |  reserved
  *  |  |  |   per egress port
  *  |  |  |   |
  *  V  V  v   v
  * BUF_Q_RSRV_E
  */
 #define BUF_Q_RSRV_E(port, prio) \
     (BUF_xxxx_E + xxx_Q_RSRV_x + OCELOT_NUM_TC * (port) + (prio))
 
 /*  Amount of packet buffer
  *  |  for all port's traffic classes
  *  |  |  reserved
  *  |  |  |   per egress port
  *  |  |  |   |
  *  V  V  v   v
  * BUF_P_RSRV_E
  */
 #define BUF_P_RSRV_E(port) \
     (BUF_xxxx_E + xxx_P_RSRV_x + (port))
 
 /*  Amount of packet buffer
  *  |  per QoS class
  *  |  |  reserved
  *  |  |  |   per ingress port
  *  |  |  |   |
  *  V  V  v   v
  * BUF_Q_RSRV_I
  */
 #define BUF_Q_RSRV_I(port, prio) \
     (BUF_xxxx_I + xxx_Q_RSRV_x + OCELOT_NUM_TC * (port) + (prio))
 
 /*  Amount of packet buffer
  *  |  for all port's traffic classes
  *  |  |  reserved
  *  |  |  |   per ingress port
  *  |  |  |   |
  *  V  V  v   v
  * BUF_P_RSRV_I
  */
 #define BUF_P_RSRV_I(port) \
     (BUF_xxxx_I + xxx_P_RSRV_x + (port))
 
 /*  Amount of frame references
  *  |  per QoS class
  *  |  |  reserved
  *  |  |  |   per egress port
  *  |  |  |   |
  *  V  V  v   v
  * REF_Q_RSRV_E
  */
 #define REF_Q_RSRV_E(port, prio) \
     (REF_xxxx_E + xxx_Q_RSRV_x + OCELOT_NUM_TC * (port) + (prio))
 
 /*  Amount of frame references
  *  |  for all port's traffic classes
  *  |  |  reserved
  *  |  |  |   per egress port
  *  |  |  |   |
  *  V  V  v   v
  * REF_P_RSRV_E
  */
 #define REF_P_RSRV_E(port) \
     (REF_xxxx_E + xxx_P_RSRV_x + (port))
 
 /*  Amount of frame references
  *  |  per QoS class
  *  |  |  reserved
  *  |  |  |   per ingress port
  *  |  |  |   |
  *  V  V  v   v
  * REF_Q_RSRV_I
  */
 #define REF_Q_RSRV_I(port, prio) \
     (REF_xxxx_I + xxx_Q_RSRV_x + OCELOT_NUM_TC * (port) + (prio))
 
 /*  Amount of frame references
  *  |  for all port's traffic classes
  *  |  |  reserved
  *  |  |  |   per ingress port
  *  |  |  |   |
  *  V  V  v   v
  * REF_P_RSRV_I
  */
 #define REF_P_RSRV_I(port) \
     (REF_xxxx_I + xxx_P_RSRV_x + (port))
 
 /* Sharing Watermarks
  * ------------------
  *
  * The shared memory area is shared between all ports.
  */
 
 /* Amount of buffer
  *  |   per QoS class
  *  |   |    from the shared memory area
  *  |   |    |  for egress traffic
  *  |   |    |  |
  *  V   V    v  v
  * BUF_PRIO_SHR_E
  */
 #define BUF_PRIO_SHR_E(prio) \
     (BUF_xxxx_E + xxx_PRIO_SHR_x + (prio))
 
 /* Amount of buffer
  *  |   per color (drop precedence level)
  *  |   |   from the shared memory area
  *  |   |   |  for egress traffic
  *  |   |   |  |
  *  V   V   v  v
  * BUF_COL_SHR_E
  */
 #define BUF_COL_SHR_E(dp) \
     (BUF_xxxx_E + xxx_COL_SHR_x + (1 - (dp)))
 
 /* Amount of buffer
  *  |   per QoS class
  *  |   |    from the shared memory area
  *  |   |    |  for ingress traffic
  *  |   |    |  |
  *  V   V    v  v
  * BUF_PRIO_SHR_I
  */
 #define BUF_PRIO_SHR_I(prio) \
     (BUF_xxxx_I + xxx_PRIO_SHR_x + (prio))
 
 /* Amount of buffer
  *  |   per color (drop precedence level)
  *  |   |   from the shared memory area
  *  |   |   |  for ingress traffic
  *  |   |   |  |
  *  V   V   v  v
  * BUF_COL_SHR_I
  */
 #define BUF_COL_SHR_I(dp) \
     (BUF_xxxx_I + xxx_COL_SHR_x + (1 - (dp)))
 
 /* Amount of frame references
  *  |   per QoS class
  *  |   |    from the shared area
  *  |   |    |  for egress traffic
  *  |   |    |  |
  *  V   V    v  v
  * REF_PRIO_SHR_E
  */
 #define REF_PRIO_SHR_E(prio) \
     (REF_xxxx_E + xxx_PRIO_SHR_x + (prio))
 
 /* Amount of frame references
  *  |   per color (drop precedence level)
  *  |   |   from the shared area
  *  |   |   |  for egress traffic
  *  |   |   |  |
  *  V   V   v  v
  * REF_COL_SHR_E
  */
 #define REF_COL_SHR_E(dp) \
     (REF_xxxx_E + xxx_COL_SHR_x + (1 - (dp)))
 
 /* Amount of frame references
  *  |   per QoS class
  *  |   |    from the shared area
  *  |   |    |  for ingress traffic
  *  |   |    |  |
  *  V   V    v  v
  * REF_PRIO_SHR_I
  */
 #define REF_PRIO_SHR_I(prio) \
     (REF_xxxx_I + xxx_PRIO_SHR_x + (prio))
 
 /* Amount of frame references
  *  |   per color (drop precedence level)
  *  |   |   from the shared area
  *  |   |   |  for ingress traffic
  *  |   |   |  |
  *  V   V   v  v
  * REF_COL_SHR_I
  */
 #define REF_COL_SHR_I(dp) \
     (REF_xxxx_I + xxx_COL_SHR_x + (1 - (dp)))
 
 static u32 ocelot_wm_read(struct ocelot *ocelot, int index)
 {
     int wm = ocelot_read_gix(ocelot, QSYS_RES_CFG, index);
 
     return ocelot->ops->wm_dec(wm);
 }
 
 static void ocelot_wm_write(struct ocelot *ocelot, int index, u32 val)
 {
     u32 wm = ocelot->ops->wm_enc(val);
 
     ocelot_write_gix(ocelot, wm, QSYS_RES_CFG, index);
 }
 
 static void ocelot_wm_status(struct ocelot *ocelot, int index, u32 *inuse,
                  u32 *maxuse)
 {
     int res_stat = ocelot_read_gix(ocelot, QSYS_RES_STAT, index);
 
     return ocelot->ops->wm_stat(res_stat, inuse, maxuse);
 }
 
 /* The hardware comes out of reset with strange defaults: the sum of all
  * reservations for frame memory is larger than the total buffer size.
  * One has to wonder how can the reservation watermarks still guarantee
  * anything under congestion.
  * Bring some sense into the hardware by changing the defaults to disable all
  * reservations and rely only on the sharing watermark for frames with drop
  * precedence 0. The user can still explicitly request reservations per port
  * and per port-tc through devlink-sb.
  */
 static void ocelot_disable_reservation_watermarks(struct ocelot *ocelot,
                           int port)
 {
     int prio;
 
     for (prio = 0; prio < OCELOT_NUM_TC; prio++) {
         ocelot_wm_write(ocelot, BUF_Q_RSRV_I(port, prio), 0);
         ocelot_wm_write(ocelot, BUF_Q_RSRV_E(port, prio), 0);
         ocelot_wm_write(ocelot, REF_Q_RSRV_I(port, prio), 0);
         ocelot_wm_write(ocelot, REF_Q_RSRV_E(port, prio), 0);
     }
 
     ocelot_wm_write(ocelot, BUF_P_RSRV_I(port), 0);
     ocelot_wm_write(ocelot, BUF_P_RSRV_E(port), 0);
     ocelot_wm_write(ocelot, REF_P_RSRV_I(port), 0);
     ocelot_wm_write(ocelot, REF_P_RSRV_E(port), 0);
 }
 
 /* We want the sharing watermarks to consume all nonreserved resources, for
  * efficient resource utilization (a single traffic flow should be able to use
  * up the entire buffer space and frame resources as long as there's no
  * interference).
  * The switch has 10 sharing watermarks per lookup: 8 per traffic class and 2
  * per color (drop precedence).
  * The trouble with configuring these sharing watermarks is that:
  * (1) There's a risk that we overcommit the resources if we configure
  *     (a) all 8 per-TC sharing watermarks to the max
  *     (b) all 2 per-color sharing watermarks to the max
  * (2) There's a risk that we undercommit the resources if we configure
  *     (a) all 8 per-TC sharing watermarks to "max / 8"
  *     (b) all 2 per-color sharing watermarks to "max / 2"
  * So for Linux, let's just disable the sharing watermarks per traffic class
  * (setting them to 0 will make them always exceeded), and rely only on the
  * sharing watermark for drop priority 0. So frames with drop priority set to 1
  * by QoS classification or policing will still be allowed, but only as long as
  * the port and port-TC reservations are not exceeded.
  */
 static void ocelot_disable_tc_sharing_watermarks(struct ocelot *ocelot)
 {
     int prio;
 
     for (prio = 0; prio < OCELOT_NUM_TC; prio++) {
         ocelot_wm_write(ocelot, BUF_PRIO_SHR_I(prio), 0);
         ocelot_wm_write(ocelot, BUF_PRIO_SHR_E(prio), 0);
         ocelot_wm_write(ocelot, REF_PRIO_SHR_I(prio), 0);
         ocelot_wm_write(ocelot, REF_PRIO_SHR_E(prio), 0);
     }
 }
 
 static void ocelot_get_buf_rsrv(struct ocelot *ocelot, u32 *buf_rsrv_i,
                 u32 *buf_rsrv_e)
 {
     int port, prio;
 
     *buf_rsrv_i = 0;
     *buf_rsrv_e = 0;
 
     for (port = 0; port <= ocelot->num_phys_ports; port++) {
         for (prio = 0; prio < OCELOT_NUM_TC; prio++) {
             *buf_rsrv_i += ocelot_wm_read(ocelot,
                               BUF_Q_RSRV_I(port, prio));
             *buf_rsrv_e += ocelot_wm_read(ocelot,
                               BUF_Q_RSRV_E(port, prio));
         }
 
         *buf_rsrv_i += ocelot_wm_read(ocelot, BUF_P_RSRV_I(port));
         *buf_rsrv_e += ocelot_wm_read(ocelot, BUF_P_RSRV_E(port));
     }
 
     *buf_rsrv_i *= OCELOT_BUFFER_CELL_SZ;
     *buf_rsrv_e *= OCELOT_BUFFER_CELL_SZ;
 }
 
 static void ocelot_get_ref_rsrv(struct ocelot *ocelot, u32 *ref_rsrv_i,
                 u32 *ref_rsrv_e)
 {
     int port, prio;
 
     *ref_rsrv_i = 0;
     *ref_rsrv_e = 0;
 
     for (port = 0; port <= ocelot->num_phys_ports; port++) {
         for (prio = 0; prio < OCELOT_NUM_TC; prio++) {
             *ref_rsrv_i += ocelot_wm_read(ocelot,
                               REF_Q_RSRV_I(port, prio));
             *ref_rsrv_e += ocelot_wm_read(ocelot,
                               REF_Q_RSRV_E(port, prio));
         }
 
         *ref_rsrv_i += ocelot_wm_read(ocelot, REF_P_RSRV_I(port));
         *ref_rsrv_e += ocelot_wm_read(ocelot, REF_P_RSRV_E(port));
     }
 }
 
 /* Calculate all reservations, then set up the sharing watermark for DP=0 to
  * consume the remaining resources up to the pool's configured size.
  */
 static void ocelot_setup_sharing_watermarks(struct ocelot *ocelot)
 {
     u32 buf_rsrv_i, buf_rsrv_e;
     u32 ref_rsrv_i, ref_rsrv_e;
     u32 buf_shr_i, buf_shr_e;
     u32 ref_shr_i, ref_shr_e;
 
     ocelot_get_buf_rsrv(ocelot, &buf_rsrv_i, &buf_rsrv_e);
     ocelot_get_ref_rsrv(ocelot, &ref_rsrv_i, &ref_rsrv_e);
 
     buf_shr_i = ocelot->pool_size[OCELOT_SB_BUF][OCELOT_SB_POOL_ING] -
             buf_rsrv_i;
     buf_shr_e = ocelot->pool_size[OCELOT_SB_BUF][OCELOT_SB_POOL_EGR] -
             buf_rsrv_e;
     ref_shr_i = ocelot->pool_size[OCELOT_SB_REF][OCELOT_SB_POOL_ING] -
             ref_rsrv_i;
     ref_shr_e = ocelot->pool_size[OCELOT_SB_REF][OCELOT_SB_POOL_EGR] -
             ref_rsrv_e;
 
     buf_shr_i /= OCELOT_BUFFER_CELL_SZ;
     buf_shr_e /= OCELOT_BUFFER_CELL_SZ;
 
     ocelot_wm_write(ocelot, BUF_COL_SHR_I(0), buf_shr_i);
     ocelot_wm_write(ocelot, BUF_COL_SHR_E(0), buf_shr_e);
     ocelot_wm_write(ocelot, REF_COL_SHR_E(0), ref_shr_e);
     ocelot_wm_write(ocelot, REF_COL_SHR_I(0), ref_shr_i);
     ocelot_wm_write(ocelot, BUF_COL_SHR_I(1), 0);
     ocelot_wm_write(ocelot, BUF_COL_SHR_E(1), 0);
     ocelot_wm_write(ocelot, REF_COL_SHR_E(1), 0);
     ocelot_wm_write(ocelot, REF_COL_SHR_I(1), 0);
 }
 
 /* Ensure that all reservations can be enforced */
 static int ocelot_watermark_validate(struct ocelot *ocelot,
                      struct netlink_ext_ack *extack)
 {
     u32 buf_rsrv_i, buf_rsrv_e;
     u32 ref_rsrv_i, ref_rsrv_e;
 
     ocelot_get_buf_rsrv(ocelot, &buf_rsrv_i, &buf_rsrv_e);
     ocelot_get_ref_rsrv(ocelot, &ref_rsrv_i, &ref_rsrv_e);
 
     if (buf_rsrv_i > ocelot->pool_size[OCELOT_SB_BUF][OCELOT_SB_POOL_ING]) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Ingress frame reservations exceed pool size");
         return -ERANGE;
     }
     if (buf_rsrv_e > ocelot->pool_size[OCELOT_SB_BUF][OCELOT_SB_POOL_EGR]) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Egress frame reservations exceed pool size");
         return -ERANGE;
     }
     if (ref_rsrv_i > ocelot->pool_size[OCELOT_SB_REF][OCELOT_SB_POOL_ING]) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Ingress reference reservations exceed pool size");
         return -ERANGE;
     }
     if (ref_rsrv_e > ocelot->pool_size[OCELOT_SB_REF][OCELOT_SB_POOL_EGR]) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Egress reference reservations exceed pool size");
         return -ERANGE;
     }
 
     return 0;
 }
 
 /* The hardware works like this:
  *
  *                         Frame forwarding decision taken
  *                                       |
  *                                       v
  *       +--------------------+--------------------+--------------------+
  *       |                    |                    |                    |
  *       v                    v                    v                    v
  * Ingress memory       Egress memory        Ingress frame        Egress frame
  *     check                check           reference check      reference check
  *       |                    |                    |                    |
  *       v                    v                    v                    v
  *  BUF_Q_RSRV_I   ok    BUF_Q_RSRV_E   ok    REF_Q_RSRV_I   ok     REF_Q_RSRV_E   ok
  *(src port, prio) -+  (dst port, prio) -+  (src port, prio) -+   (dst port, prio) -+
  *       |          |         |          |         |          |         |           |
  *       |exceeded  |         |exceeded  |         |exceeded  |         |exceeded   |
  *       v          |         v          |         v          |         v           |
  *  BUF_P_RSRV_I  ok|    BUF_P_RSRV_E  ok|    REF_P_RSRV_I  ok|    REF_P_RSRV_E   ok|
  *   (src port) ----+     (dst port) ----+     (src port) ----+     (dst port) -----+
  *       |          |         |          |         |          |         |           |
  *       |exceeded  |         |exceeded  |         |exceeded  |         |exceeded   |
  *       v          |         v          |         v          |         v           |
  * BUF_PRIO_SHR_I ok|   BUF_PRIO_SHR_E ok|   REF_PRIO_SHR_I ok|   REF_PRIO_SHR_E  ok|
  *     (prio) ------+       (prio) ------+       (prio) ------+       (prio) -------+
  *       |          |         |          |         |          |         |           |
  *       |exceeded  |         |exceeded  |         |exceeded  |         |exceeded   |
  *       v          |         v          |         v          |         v           |
  * BUF_COL_SHR_I  ok|   BUF_COL_SHR_E  ok|   REF_COL_SHR_I  ok|   REF_COL_SHR_E   ok|
  *      (dp) -------+        (dp) -------+        (dp) -------+        (dp) --------+
  *       |          |         |          |         |          |         |           |
  *       |exceeded  |         |exceeded  |         |exceeded  |         |exceeded   |
  *       v          v         v          v         v          v         v           v
  *      fail     success     fail     success     fail     success     fail      success
  *       |          |         |          |         |          |         |           |
  *       v          v         v          v         v          v         v           v
  *       +-----+----+         +-----+----+         +-----+----+         +-----+-----+
  *             |                    |                    |                    |
  *             +-------> OR <-------+                    +-------> OR <-------+
  *                        |                                        |
  *                        v                                        v
  *                        +----------------> AND <-----------------+
  *                                            |
  *                                            v
  *                                    FIFO drop / accept
  *
  * We are modeling each of the 4 parallel lookups as a devlink-sb pool.
  * At least one (ingress or egress) memory pool and one (ingress or egress)
  * frame reference pool need to have resources for frame acceptance to succeed.
  *
  * The following watermarks are controlled explicitly through devlink-sb:
  * BUF_Q_RSRV_I, BUF_Q_RSRV_E, REF_Q_RSRV_I, REF_Q_RSRV_E
  * BUF_P_RSRV_I, BUF_P_RSRV_E, REF_P_RSRV_I, REF_P_RSRV_E
  * The following watermarks are controlled implicitly through devlink-sb:
  * BUF_COL_SHR_I, BUF_COL_SHR_E, REF_COL_SHR_I, REF_COL_SHR_E
  * The following watermarks are unused and disabled:
  * BUF_PRIO_SHR_I, BUF_PRIO_SHR_E, REF_PRIO_SHR_I, REF_PRIO_SHR_E
  *
  * This function overrides the hardware defaults with more sane ones (no
  * reservations by default, let sharing use all resources) and disables the
  * unused watermarks.
  */
 static void ocelot_watermark_init(struct ocelot *ocelot)
 {
     int all_tcs = GENMASK(OCELOT_NUM_TC - 1, 0);
     int port;
 
     ocelot_write(ocelot, all_tcs, QSYS_RES_QOS_MODE);
 
     for (port = 0; port <= ocelot->num_phys_ports; port++)
         ocelot_disable_reservation_watermarks(ocelot, port);
 
     ocelot_disable_tc_sharing_watermarks(ocelot);
     ocelot_setup_sharing_watermarks(ocelot);
 }
 
 /* Pool size and type are fixed up at runtime. Keeping this structure to
  * look up the cell size multipliers.
  */
 static const struct devlink_sb_pool_info ocelot_sb_pool[] = {
     [OCELOT_SB_BUF] = {
         .cell_size = OCELOT_BUFFER_CELL_SZ,
         .threshold_type = DEVLINK_SB_THRESHOLD_TYPE_STATIC,
     },
     [OCELOT_SB_REF] = {
         .cell_size = 1,
         .threshold_type = DEVLINK_SB_THRESHOLD_TYPE_STATIC,
     },
 };
 
 /* Returns the pool size configured through ocelot_sb_pool_set */
 int ocelot_sb_pool_get(struct ocelot *ocelot, unsigned int sb_index,
                u16 pool_index,
                struct devlink_sb_pool_info *pool_info)
 {
     if (sb_index >= OCELOT_SB_NUM)
         return -ENODEV;
     if (pool_index >= OCELOT_SB_POOL_NUM)
         return -ENODEV;
 
     *pool_info = ocelot_sb_pool[sb_index];
     pool_info->size = ocelot->pool_size[sb_index][pool_index];
     if (pool_index)
         pool_info->pool_type = DEVLINK_SB_POOL_TYPE_INGRESS;
     else
         pool_info->pool_type = DEVLINK_SB_POOL_TYPE_EGRESS;
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_pool_get);
 
 /* The pool size received here configures the total amount of resources used on
  * ingress (or on egress, depending upon the pool index). The pool size, minus
  * the values for the port and port-tc reservations, is written into the
  * COL_SHR(dp=0) sharing watermark.
  */
 int ocelot_sb_pool_set(struct ocelot *ocelot, unsigned int sb_index,
                u16 pool_index, u32 size,
                enum devlink_sb_threshold_type threshold_type,
                struct netlink_ext_ack *extack)
 {
     u32 old_pool_size;
     int err;
 
     if (sb_index >= OCELOT_SB_NUM) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Invalid sb, use 0 for buffers and 1 for frame references");
         return -ENODEV;
     }
     if (pool_index >= OCELOT_SB_POOL_NUM) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Invalid pool, use 0 for ingress and 1 for egress");
         return -ENODEV;
     }
     if (threshold_type != DEVLINK_SB_THRESHOLD_TYPE_STATIC) {
         NL_SET_ERR_MSG_MOD(extack,
                    "Only static threshold supported");
         return -EOPNOTSUPP;
     }
 
     old_pool_size = ocelot->pool_size[sb_index][pool_index];
     ocelot->pool_size[sb_index][pool_index] = size;
 
     err = ocelot_watermark_validate(ocelot, extack);
     if (err) {
         ocelot->pool_size[sb_index][pool_index] = old_pool_size;
         return err;
     }
 
     ocelot_setup_sharing_watermarks(ocelot);
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_pool_set);
 
 /* This retrieves the configuration made with ocelot_sb_port_pool_set */
 int ocelot_sb_port_pool_get(struct ocelot *ocelot, int port,
                 unsigned int sb_index, u16 pool_index,
                 u32 *p_threshold)
 {
     int wm_index;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         if (pool_index == OCELOT_SB_POOL_ING)
             wm_index = BUF_P_RSRV_I(port);
         else
             wm_index = BUF_P_RSRV_E(port);
         break;
     case OCELOT_SB_REF:
         if (pool_index == OCELOT_SB_POOL_ING)
             wm_index = REF_P_RSRV_I(port);
         else
             wm_index = REF_P_RSRV_E(port);
         break;
     default:
         return -ENODEV;
     }
 
     *p_threshold = ocelot_wm_read(ocelot, wm_index);
     *p_threshold *= ocelot_sb_pool[sb_index].cell_size;
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_port_pool_get);
 
 /* This configures the P_RSRV per-port reserved resource watermark */
 int ocelot_sb_port_pool_set(struct ocelot *ocelot, int port,
                 unsigned int sb_index, u16 pool_index,
                 u32 threshold, struct netlink_ext_ack *extack)
 {
     int wm_index, err;
     u32 old_thr;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         if (pool_index == OCELOT_SB_POOL_ING)
             wm_index = BUF_P_RSRV_I(port);
         else
             wm_index = BUF_P_RSRV_E(port);
         break;
     case OCELOT_SB_REF:
         if (pool_index == OCELOT_SB_POOL_ING)
             wm_index = REF_P_RSRV_I(port);
         else
             wm_index = REF_P_RSRV_E(port);
         break;
     default:
         NL_SET_ERR_MSG_MOD(extack, "Invalid shared buffer");
         return -ENODEV;
     }
 
     threshold /= ocelot_sb_pool[sb_index].cell_size;
 
     old_thr = ocelot_wm_read(ocelot, wm_index);
     ocelot_wm_write(ocelot, wm_index, threshold);
 
     err = ocelot_watermark_validate(ocelot, extack);
     if (err) {
         ocelot_wm_write(ocelot, wm_index, old_thr);
         return err;
     }
 
     ocelot_setup_sharing_watermarks(ocelot);
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_port_pool_set);
 
 /* This retrieves the configuration done by ocelot_sb_tc_pool_bind_set */
 int ocelot_sb_tc_pool_bind_get(struct ocelot *ocelot, int port,
                    unsigned int sb_index, u16 tc_index,
                    enum devlink_sb_pool_type pool_type,
                    u16 *p_pool_index, u32 *p_threshold)
 {
     int wm_index;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
             wm_index = BUF_Q_RSRV_I(port, tc_index);
         else
             wm_index = BUF_Q_RSRV_E(port, tc_index);
         break;
     case OCELOT_SB_REF:
         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
             wm_index = REF_Q_RSRV_I(port, tc_index);
         else
             wm_index = REF_Q_RSRV_E(port, tc_index);
         break;
     default:
         return -ENODEV;
     }
 
     *p_threshold = ocelot_wm_read(ocelot, wm_index);
     *p_threshold *= ocelot_sb_pool[sb_index].cell_size;
 
     if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
         *p_pool_index = 0;
     else
         *p_pool_index = 1;
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_tc_pool_bind_get);
 
 /* This configures the Q_RSRV per-port-tc reserved resource watermark */
 int ocelot_sb_tc_pool_bind_set(struct ocelot *ocelot, int port,
                    unsigned int sb_index, u16 tc_index,
                    enum devlink_sb_pool_type pool_type,
                    u16 pool_index, u32 threshold,
                    struct netlink_ext_ack *extack)
 {
     int wm_index, err;
     u32 old_thr;
 
     /* Paranoid check? */
     if (pool_index == OCELOT_SB_POOL_ING &&
         pool_type != DEVLINK_SB_POOL_TYPE_INGRESS)
         return -EINVAL;
     if (pool_index == OCELOT_SB_POOL_EGR &&
         pool_type != DEVLINK_SB_POOL_TYPE_EGRESS)
         return -EINVAL;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
             wm_index = BUF_Q_RSRV_I(port, tc_index);
         else
             wm_index = BUF_Q_RSRV_E(port, tc_index);
         break;
     case OCELOT_SB_REF:
         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
             wm_index = REF_Q_RSRV_I(port, tc_index);
         else
             wm_index = REF_Q_RSRV_E(port, tc_index);
         break;
     default:
         NL_SET_ERR_MSG_MOD(extack, "Invalid shared buffer");
         return -ENODEV;
     }
 
     threshold /= ocelot_sb_pool[sb_index].cell_size;
 
     old_thr = ocelot_wm_read(ocelot, wm_index);
     ocelot_wm_write(ocelot, wm_index, threshold);
     err = ocelot_watermark_validate(ocelot, extack);
     if (err) {
         ocelot_wm_write(ocelot, wm_index, old_thr);
         return err;
     }
 
     ocelot_setup_sharing_watermarks(ocelot);
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_tc_pool_bind_set);
 
 /* The hardware does not support atomic snapshots, we'll read out the
  * occupancy registers individually and have this as just a stub.
  */
 int ocelot_sb_occ_snapshot(struct ocelot *ocelot, unsigned int sb_index)
 {
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_occ_snapshot);
 
 /* The watermark occupancy registers are cleared upon read,
  * so let's read them.
  */
 int ocelot_sb_occ_max_clear(struct ocelot *ocelot, unsigned int sb_index)
 {
     u32 inuse, maxuse;
     int port, prio;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         for (port = 0; port <= ocelot->num_phys_ports; port++) {
             for (prio = 0; prio < OCELOT_NUM_TC; prio++) {
                 ocelot_wm_status(ocelot, BUF_Q_RSRV_I(port, prio),
                          &inuse, &maxuse);
                 ocelot_wm_status(ocelot, BUF_Q_RSRV_E(port, prio),
                          &inuse, &maxuse);
             }
             ocelot_wm_status(ocelot, BUF_P_RSRV_I(port),
                      &inuse, &maxuse);
             ocelot_wm_status(ocelot, BUF_P_RSRV_E(port),
                      &inuse, &maxuse);
         }
         break;
     case OCELOT_SB_REF:
         for (port = 0; port <= ocelot->num_phys_ports; port++) {
             for (prio = 0; prio < OCELOT_NUM_TC; prio++) {
                 ocelot_wm_status(ocelot, REF_Q_RSRV_I(port, prio),
                          &inuse, &maxuse);
                 ocelot_wm_status(ocelot, REF_Q_RSRV_E(port, prio),
                          &inuse, &maxuse);
             }
             ocelot_wm_status(ocelot, REF_P_RSRV_I(port),
                      &inuse, &maxuse);
             ocelot_wm_status(ocelot, REF_P_RSRV_E(port),
                      &inuse, &maxuse);
         }
         break;
     default:
         return -ENODEV;
     }
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_occ_max_clear);
 
 /* This retrieves the watermark occupancy for per-port P_RSRV watermarks */
 int ocelot_sb_occ_port_pool_get(struct ocelot *ocelot, int port,
                 unsigned int sb_index, u16 pool_index,
                 u32 *p_cur, u32 *p_max)
 {
     int wm_index;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         if (pool_index == OCELOT_SB_POOL_ING)
             wm_index = BUF_P_RSRV_I(port);
         else
             wm_index = BUF_P_RSRV_E(port);
         break;
     case OCELOT_SB_REF:
         if (pool_index == OCELOT_SB_POOL_ING)
             wm_index = REF_P_RSRV_I(port);
         else
             wm_index = REF_P_RSRV_E(port);
         break;
     default:
         return -ENODEV;
     }
 
     ocelot_wm_status(ocelot, wm_index, p_cur, p_max);
     *p_cur *= ocelot_sb_pool[sb_index].cell_size;
     *p_max *= ocelot_sb_pool[sb_index].cell_size;
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_occ_port_pool_get);
 
 /* This retrieves the watermark occupancy for per-port-tc Q_RSRV watermarks */
 int ocelot_sb_occ_tc_port_bind_get(struct ocelot *ocelot, int port,
                    unsigned int sb_index, u16 tc_index,
                    enum devlink_sb_pool_type pool_type,
                    u32 *p_cur, u32 *p_max)
 {
     int wm_index;
 
     switch (sb_index) {
     case OCELOT_SB_BUF:
         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
             wm_index = BUF_Q_RSRV_I(port, tc_index);
         else
             wm_index = BUF_Q_RSRV_E(port, tc_index);
         break;
     case OCELOT_SB_REF:
         if (pool_type == DEVLINK_SB_POOL_TYPE_INGRESS)
             wm_index = REF_Q_RSRV_I(port, tc_index);
         else
             wm_index = REF_Q_RSRV_E(port, tc_index);
         break;
     default:
         return -ENODEV;
     }
 
     ocelot_wm_status(ocelot, wm_index, p_cur, p_max);
     *p_cur *= ocelot_sb_pool[sb_index].cell_size;
     *p_max *= ocelot_sb_pool[sb_index].cell_size;
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_sb_occ_tc_port_bind_get);
 
 int ocelot_devlink_sb_register(struct ocelot *ocelot)
 {
     int err;
 
     err = devlink_sb_register(ocelot->devlink, OCELOT_SB_BUF,
                   ocelot->packet_buffer_size, 1, 1,
                   OCELOT_NUM_TC, OCELOT_NUM_TC);
     if (err)
         return err;
 
     err = devlink_sb_register(ocelot->devlink, OCELOT_SB_REF,
                   ocelot->num_frame_refs, 1, 1,
                   OCELOT_NUM_TC, OCELOT_NUM_TC);
     if (err) {
         devlink_sb_unregister(ocelot->devlink, OCELOT_SB_BUF);
         return err;
     }
 
     ocelot->pool_size[OCELOT_SB_BUF][OCELOT_SB_POOL_ING] = ocelot->packet_buffer_size;
     ocelot->pool_size[OCELOT_SB_BUF][OCELOT_SB_POOL_EGR] = ocelot->packet_buffer_size;
     ocelot->pool_size[OCELOT_SB_REF][OCELOT_SB_POOL_ING] = ocelot->num_frame_refs;
     ocelot->pool_size[OCELOT_SB_REF][OCELOT_SB_POOL_EGR] = ocelot->num_frame_refs;
 
     ocelot_watermark_init(ocelot);
 
     return 0;
 }
 EXPORT_SYMBOL(ocelot_devlink_sb_register);
 
 void ocelot_devlink_sb_unregister(struct ocelot *ocelot)
 {
     devlink_sb_unregister(ocelot->devlink, OCELOT_SB_BUF);
     devlink_sb_unregister(ocelot->devlink, OCELOT_SB_REF);
 }
 EXPORT_SYMBOL(ocelot_devlink_sb_unregister);

This page was automatically generated by the 2.1.0 LXR engine. The LXR team