net: airoha: Introduce PPE debugfs support

Similar to PPE support for Mediatek devices, introduce PPE debugfs
in order to dump binded and unbinded flows.

Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

diff --git a/drivers/net/ethernet/airoha/Makefile b/drivers/net/ethernet/airoha/Makefile
index 6deff2f16229a7638be0737caa06282ba63183a4..94468053e34bef8fd155760e13745a8663592f4a 100644 (file)
--- a/drivers/net/ethernet/airoha/Makefile
+++ b/drivers/net/ethernet/airoha/Makefile
@@ -5,4 +5,5 @@
 
 obj-$(CONFIG_NET_AIROHA) += airoha-eth.o
 airoha-eth-y := airoha_eth.o airoha_ppe.o
+airoha-eth-$(CONFIG_DEBUG_FS) += airoha_ppe_debugfs.o
 obj-$(CONFIG_NET_AIROHA_NPU) += airoha_npu.o

diff --git a/drivers/net/ethernet/airoha/airoha_eth.h b/drivers/net/ethernet/airoha/airoha_eth.h
index a59ff6e41890a6b4d1b31b4b0b8e9dbca1e5cf51..b7a3bd7a76b7be3125a2f244582e5bceab48bd47 100644 (file)
--- a/drivers/net/ethernet/airoha/airoha_eth.h
+++ b/drivers/net/ethernet/airoha/airoha_eth.h
@@ -7,6 +7,7 @@
 #ifndef AIROHA_ETH_H
 #define AIROHA_ETH_H
 
+#include <linux/debugfs.h>
 #include <linux/etherdevice.h>
 #include <linux/iopoll.h>
 #include <linux/kernel.h>
@@ -480,6 +481,8 @@ struct airoha_ppe {
 
        struct hlist_head *foe_flow;
        u16 foe_check_time[PPE_NUM_ENTRIES];
+
+       struct dentry *debugfs_dir;
 };
 
 struct airoha_eth {
@@ -533,5 +536,16 @@ int airoha_ppe_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
                                 void *cb_priv);
 int airoha_ppe_init(struct airoha_eth *eth);
 void airoha_ppe_deinit(struct airoha_eth *eth);
+struct airoha_foe_entry *airoha_ppe_foe_get_entry(struct airoha_ppe *ppe,
+                                                 u32 hash);
+
+#if CONFIG_DEBUG_FS
+int airoha_ppe_debugfs_init(struct airoha_ppe *ppe);
+#else
+static inline int airoha_ppe_debugfs_init(struct airoha_ppe *ppe)
+{
+       return 0;
+}
+#endif
 
 #endif /* AIROHA_ETH_H */

diff --git a/drivers/net/ethernet/airoha/airoha_ppe.c b/drivers/net/ethernet/airoha/airoha_ppe.c
index de291f44cf14b5951828065cec820b58a3cc5e98..8b55e871352d359fa692c253d3f3315c619472b3 100644 (file)
--- a/drivers/net/ethernet/airoha/airoha_ppe.c
+++ b/drivers/net/ethernet/airoha/airoha_ppe.c
@@ -390,8 +390,8 @@ static u32 airoha_ppe_foe_get_entry_hash(struct airoha_foe_entry *hwe)
        return hash;
 }
 
-static struct airoha_foe_entry *
-airoha_ppe_foe_get_entry(struct airoha_ppe *ppe, u32 hash)
+struct airoha_foe_entry *airoha_ppe_foe_get_entry(struct airoha_ppe *ppe,
+                                                 u32 hash)
 {
        if (hash < PPE_SRAM_NUM_ENTRIES) {
                u32 *hwe = ppe->foe + hash * sizeof(struct airoha_foe_entry);
@@ -861,7 +861,7 @@ void airoha_ppe_check_skb(struct airoha_ppe *ppe, u16 hash)
 int airoha_ppe_init(struct airoha_eth *eth)
 {
        struct airoha_ppe *ppe;
-       int foe_size;
+       int foe_size, err;
 
        ppe = devm_kzalloc(eth->dev, sizeof(*ppe), GFP_KERNEL);
        if (!ppe)
@@ -882,7 +882,15 @@ int airoha_ppe_init(struct airoha_eth *eth)
        if (!ppe->foe_flow)
                return -ENOMEM;
 
-       return rhashtable_init(&eth->flow_table, &airoha_flow_table_params);
+       err = rhashtable_init(&eth->flow_table, &airoha_flow_table_params);
+       if (err)
+               return err;
+
+       err = airoha_ppe_debugfs_init(ppe);
+       if (err)
+               rhashtable_destroy(&eth->flow_table);
+
+       return err;
 }
 
 void airoha_ppe_deinit(struct airoha_eth *eth)
@@ -898,4 +906,5 @@ void airoha_ppe_deinit(struct airoha_eth *eth)
        rcu_read_unlock();
 
        rhashtable_destroy(&eth->flow_table);
+       debugfs_remove(eth->ppe->debugfs_dir);
 }

diff --git a/drivers/net/ethernet/airoha/airoha_ppe_debugfs.c b/drivers/net/ethernet/airoha/airoha_ppe_debugfs.c
new file mode 100644 (file)
index 0000000..3cdc6fd
--- /dev/null
+++ b/drivers/net/ethernet/airoha/airoha_ppe_debugfs.c
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2025 AIROHA Inc
+ * Author: Lorenzo Bianconi <lorenzo@kernel.org>
+ */
+
+#include "airoha_eth.h"
+
+static void airoha_debugfs_ppe_print_tuple(struct seq_file *m,
+                                          void *src_addr, void *dest_addr,
+                                          u16 *src_port, u16 *dest_port,
+                                          bool ipv6)
+{
+       __be32 n_addr[IPV6_ADDR_WORDS];
+
+       if (ipv6) {
+               ipv6_addr_cpu_to_be32(n_addr, src_addr);
+               seq_printf(m, "%pI6", n_addr);
+       } else {
+               seq_printf(m, "%pI4h", src_addr);
+       }
+       if (src_port)
+               seq_printf(m, ":%d", *src_port);
+
+       seq_puts(m, "->");
+
+       if (ipv6) {
+               ipv6_addr_cpu_to_be32(n_addr, dest_addr);
+               seq_printf(m, "%pI6", n_addr);
+       } else {
+               seq_printf(m, "%pI4h", dest_addr);
+       }
+       if (dest_port)
+               seq_printf(m, ":%d", *dest_port);
+}
+
+static int airoha_ppe_debugfs_foe_show(struct seq_file *m, void *private,
+                                      bool bind)
+{
+       static const char *const ppe_type_str[] = {
+               [PPE_PKT_TYPE_IPV4_HNAPT] = "IPv4 5T",
+               [PPE_PKT_TYPE_IPV4_ROUTE] = "IPv4 3T",
+               [PPE_PKT_TYPE_BRIDGE] = "L2B",
+               [PPE_PKT_TYPE_IPV4_DSLITE] = "DS-LITE",
+               [PPE_PKT_TYPE_IPV6_ROUTE_3T] = "IPv6 3T",
+               [PPE_PKT_TYPE_IPV6_ROUTE_5T] = "IPv6 5T",
+               [PPE_PKT_TYPE_IPV6_6RD] = "6RD",
+       };
+       static const char *const ppe_state_str[] = {
+               [AIROHA_FOE_STATE_INVALID] = "INV",
+               [AIROHA_FOE_STATE_UNBIND] = "UNB",
+               [AIROHA_FOE_STATE_BIND] = "BND",
+               [AIROHA_FOE_STATE_FIN] = "FIN",
+       };
+       struct airoha_ppe *ppe = m->private;
+       int i;
+
+       for (i = 0; i < PPE_NUM_ENTRIES; i++) {
+               const char *state_str, *type_str = "UNKNOWN";
+               void *src_addr = NULL, *dest_addr = NULL;
+               u16 *src_port = NULL, *dest_port = NULL;
+               struct airoha_foe_mac_info_common *l2;
+               unsigned char h_source[ETH_ALEN] = {};
+               unsigned char h_dest[ETH_ALEN];
+               struct airoha_foe_entry *hwe;
+               u32 type, state, ib2, data;
+               bool ipv6 = false;
+
+               hwe = airoha_ppe_foe_get_entry(ppe, i);
+               if (!hwe)
+                       continue;
+
+               state = FIELD_GET(AIROHA_FOE_IB1_BIND_STATE, hwe->ib1);
+               if (!state)
+                       continue;
+
+               if (bind && state != AIROHA_FOE_STATE_BIND)
+                       continue;
+
+               state_str = ppe_state_str[state % ARRAY_SIZE(ppe_state_str)];
+               type = FIELD_GET(AIROHA_FOE_IB1_BIND_PACKET_TYPE, hwe->ib1);
+               if (type < ARRAY_SIZE(ppe_type_str) && ppe_type_str[type])
+                       type_str = ppe_type_str[type];
+
+               seq_printf(m, "%05x %s %7s", i, state_str, type_str);
+
+               switch (type) {
+               case PPE_PKT_TYPE_IPV4_HNAPT:
+               case PPE_PKT_TYPE_IPV4_DSLITE:
+                       src_port = &hwe->ipv4.orig_tuple.src_port;
+                       dest_port = &hwe->ipv4.orig_tuple.dest_port;
+                       fallthrough;
+               case PPE_PKT_TYPE_IPV4_ROUTE:
+                       src_addr = &hwe->ipv4.orig_tuple.src_ip;
+                       dest_addr = &hwe->ipv4.orig_tuple.dest_ip;
+                       break;
+               case PPE_PKT_TYPE_IPV6_ROUTE_5T:
+                       src_port = &hwe->ipv6.src_port;
+                       dest_port = &hwe->ipv6.dest_port;
+                       fallthrough;
+               case PPE_PKT_TYPE_IPV6_ROUTE_3T:
+               case PPE_PKT_TYPE_IPV6_6RD:
+                       src_addr = &hwe->ipv6.src_ip;
+                       dest_addr = &hwe->ipv6.dest_ip;
+                       ipv6 = true;
+                       break;
+               default:
+                       break;
+               }
+
+               if (src_addr && dest_addr) {
+                       seq_puts(m, " orig=");
+                       airoha_debugfs_ppe_print_tuple(m, src_addr, dest_addr,
+                                                      src_port, dest_port, ipv6);
+               }
+
+               switch (type) {
+               case PPE_PKT_TYPE_IPV4_HNAPT:
+               case PPE_PKT_TYPE_IPV4_DSLITE:
+                       src_port = &hwe->ipv4.new_tuple.src_port;
+                       dest_port = &hwe->ipv4.new_tuple.dest_port;
+                       fallthrough;
+               case PPE_PKT_TYPE_IPV4_ROUTE:
+                       src_addr = &hwe->ipv4.new_tuple.src_ip;
+                       dest_addr = &hwe->ipv4.new_tuple.dest_ip;
+                       seq_puts(m, " new=");
+                       airoha_debugfs_ppe_print_tuple(m, src_addr, dest_addr,
+                                                      src_port, dest_port,
+                                                      ipv6);
+                       break;
+               default:
+                       break;
+               }
+
+               if (type >= PPE_PKT_TYPE_IPV6_ROUTE_3T) {
+                       data = hwe->ipv6.data;
+                       ib2 = hwe->ipv6.ib2;
+                       l2 = &hwe->ipv6.l2;
+               } else {
+                       data = hwe->ipv4.data;
+                       ib2 = hwe->ipv4.ib2;
+                       l2 = &hwe->ipv4.l2.common;
+                       *((__be16 *)&h_source[4]) =
+                               cpu_to_be16(hwe->ipv4.l2.src_mac_lo);
+               }
+
+               *((__be32 *)h_dest) = cpu_to_be32(l2->dest_mac_hi);
+               *((__be16 *)&h_dest[4]) = cpu_to_be16(l2->dest_mac_lo);
+               *((__be32 *)h_source) = cpu_to_be32(l2->src_mac_hi);
+
+               seq_printf(m, " eth=%pM->%pM etype=%04x data=%08x"
+                             " vlan=%d,%d ib1=%08x ib2=%08x\n",
+                          h_source, h_dest, l2->etype, data,
+                          l2->vlan1, l2->vlan2, hwe->ib1, ib2);
+       }
+
+       return 0;
+}
+
+static int airoha_ppe_debugfs_foe_all_show(struct seq_file *m, void *private)
+{
+       return airoha_ppe_debugfs_foe_show(m, private, false);
+}
+DEFINE_SHOW_ATTRIBUTE(airoha_ppe_debugfs_foe_all);
+
+static int airoha_ppe_debugfs_foe_bind_show(struct seq_file *m, void *private)
+{
+       return airoha_ppe_debugfs_foe_show(m, private, true);
+}
+DEFINE_SHOW_ATTRIBUTE(airoha_ppe_debugfs_foe_bind);
+
+int airoha_ppe_debugfs_init(struct airoha_ppe *ppe)
+{
+       ppe->debugfs_dir = debugfs_create_dir("ppe", NULL);
+       debugfs_create_file("entries", 0444, ppe->debugfs_dir, ppe,
+                           &airoha_ppe_debugfs_foe_all_fops);
+       debugfs_create_file("bind", 0444, ppe->debugfs_dir, ppe,
+                           &airoha_ppe_debugfs_foe_bind_fops);
+
+       return 0;
+}