| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Driver for Marvell PPv2 network controller for Armada 375 SoC. | |
| * | |
| * Copyright (C) 2018 Marvell | |
| */ | |
| #include <linux/kernel.h> | |
| #include <linux/slab.h> | |
| #include <linux/debugfs.h> | |
| #include "mvpp2.h" | |
| #include "mvpp2_prs.h" | |
| #include "mvpp2_cls.h" | |
| struct mvpp2_dbgfs_prs_entry { | |
| int tid; | |
| struct mvpp2 *priv; | |
| }; | |
| struct mvpp2_dbgfs_c2_entry { | |
| int id; | |
| struct mvpp2 *priv; | |
| }; | |
| struct mvpp2_dbgfs_flow_entry { | |
| int flow; | |
| struct mvpp2 *priv; | |
| }; | |
| struct mvpp2_dbgfs_flow_tbl_entry { | |
| int id; | |
| struct mvpp2 *priv; | |
| }; | |
| struct mvpp2_dbgfs_port_flow_entry { | |
| struct mvpp2_port *port; | |
| struct mvpp2_dbgfs_flow_entry *dbg_fe; | |
| }; | |
| struct mvpp2_dbgfs_entries { | |
| /* Entries for Header Parser debug info */ | |
| struct mvpp2_dbgfs_prs_entry prs_entries[MVPP2_PRS_TCAM_SRAM_SIZE]; | |
| /* Entries for Classifier C2 engine debug info */ | |
| struct mvpp2_dbgfs_c2_entry c2_entries[MVPP22_CLS_C2_N_ENTRIES]; | |
| /* Entries for Classifier Flow Table debug info */ | |
| struct mvpp2_dbgfs_flow_tbl_entry flt_entries[MVPP2_CLS_FLOWS_TBL_SIZE]; | |
| /* Entries for Classifier flows debug info */ | |
| struct mvpp2_dbgfs_flow_entry flow_entries[MVPP2_N_PRS_FLOWS]; | |
| /* Entries for per-port flows debug info */ | |
| struct mvpp2_dbgfs_port_flow_entry port_flow_entries[MVPP2_MAX_PORTS]; | |
| }; | |
| static int mvpp2_dbgfs_flow_flt_hits_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_flow_tbl_entry *entry = s->private; | |
| u32 hits = mvpp2_cls_flow_hits(entry->priv, entry->id); | |
| seq_printf(s, "%u\n", hits); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_flt_hits); | |
| static int mvpp2_dbgfs_flow_dec_hits_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_flow_entry *entry = s->private; | |
| u32 hits = mvpp2_cls_lookup_hits(entry->priv, entry->flow); | |
| seq_printf(s, "%u\n", hits); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_dec_hits); | |
| static int mvpp2_dbgfs_flow_type_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_flow_entry *entry = s->private; | |
| const struct mvpp2_cls_flow *f; | |
| const char *flow_name; | |
| f = mvpp2_cls_flow_get(entry->flow); | |
| if (!f) | |
| return -EINVAL; | |
| switch (f->flow_type) { | |
| case IPV4_FLOW: | |
| flow_name = "ipv4"; | |
| break; | |
| case IPV6_FLOW: | |
| flow_name = "ipv6"; | |
| break; | |
| case TCP_V4_FLOW: | |
| flow_name = "tcp4"; | |
| break; | |
| case TCP_V6_FLOW: | |
| flow_name = "tcp6"; | |
| break; | |
| case UDP_V4_FLOW: | |
| flow_name = "udp4"; | |
| break; | |
| case UDP_V6_FLOW: | |
| flow_name = "udp6"; | |
| break; | |
| default: | |
| flow_name = "other"; | |
| } | |
| seq_printf(s, "%s\n", flow_name); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_type); | |
| static int mvpp2_dbgfs_flow_id_show(struct seq_file *s, void *unused) | |
| { | |
| const struct mvpp2_dbgfs_flow_entry *entry = s->private; | |
| const struct mvpp2_cls_flow *f; | |
| f = mvpp2_cls_flow_get(entry->flow); | |
| if (!f) | |
| return -EINVAL; | |
| seq_printf(s, "%d\n", f->flow_id); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_id); | |
| static int mvpp2_dbgfs_port_flow_hash_opt_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_port_flow_entry *entry = s->private; | |
| struct mvpp2_port *port = entry->port; | |
| struct mvpp2_cls_flow_entry fe; | |
| const struct mvpp2_cls_flow *f; | |
| int flow_index; | |
| u16 hash_opts; | |
| f = mvpp2_cls_flow_get(entry->dbg_fe->flow); | |
| if (!f) | |
| return -EINVAL; | |
| flow_index = MVPP2_CLS_FLT_HASH_ENTRY(entry->port->id, f->flow_id); | |
| mvpp2_cls_flow_read(port->priv, flow_index, &fe); | |
| hash_opts = mvpp2_flow_get_hek_fields(&fe); | |
| seq_printf(s, "0x%04x\n", hash_opts); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_flow_hash_opt); | |
| static int mvpp2_dbgfs_port_flow_engine_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_port_flow_entry *entry = s->private; | |
| struct mvpp2_port *port = entry->port; | |
| struct mvpp2_cls_flow_entry fe; | |
| const struct mvpp2_cls_flow *f; | |
| int flow_index, engine; | |
| f = mvpp2_cls_flow_get(entry->dbg_fe->flow); | |
| if (!f) | |
| return -EINVAL; | |
| flow_index = MVPP2_CLS_FLT_HASH_ENTRY(entry->port->id, f->flow_id); | |
| mvpp2_cls_flow_read(port->priv, flow_index, &fe); | |
| engine = mvpp2_cls_flow_eng_get(&fe); | |
| seq_printf(s, "%d\n", engine); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_flow_engine); | |
| static int mvpp2_dbgfs_flow_c2_hits_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_c2_entry *entry = s->private; | |
| u32 hits; | |
| hits = mvpp2_cls_c2_hit_count(entry->priv, entry->id); | |
| seq_printf(s, "%u\n", hits); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_hits); | |
| static int mvpp2_dbgfs_flow_c2_rxq_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_c2_entry *entry = s->private; | |
| struct mvpp2_cls_c2_entry c2; | |
| u8 qh, ql; | |
| mvpp2_cls_c2_read(entry->priv, entry->id, &c2); | |
| qh = (c2.attr[0] >> MVPP22_CLS_C2_ATTR0_QHIGH_OFFS) & | |
| MVPP22_CLS_C2_ATTR0_QHIGH_MASK; | |
| ql = (c2.attr[0] >> MVPP22_CLS_C2_ATTR0_QLOW_OFFS) & | |
| MVPP22_CLS_C2_ATTR0_QLOW_MASK; | |
| seq_printf(s, "%d\n", (qh << 3 | ql)); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_rxq); | |
| static int mvpp2_dbgfs_flow_c2_enable_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_c2_entry *entry = s->private; | |
| struct mvpp2_cls_c2_entry c2; | |
| int enabled; | |
| mvpp2_cls_c2_read(entry->priv, entry->id, &c2); | |
| enabled = !!(c2.attr[2] & MVPP22_CLS_C2_ATTR2_RSS_EN); | |
| seq_printf(s, "%d\n", enabled); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_enable); | |
| static int mvpp2_dbgfs_port_vid_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_port *port = s->private; | |
| unsigned char byte[2], enable[2]; | |
| struct mvpp2 *priv = port->priv; | |
| struct mvpp2_prs_entry pe; | |
| unsigned long pmap; | |
| u16 rvid; | |
| int tid; | |
| for (tid = MVPP2_PRS_VID_PORT_FIRST(port->id); | |
| tid <= MVPP2_PRS_VID_PORT_LAST(port->id); tid++) { | |
| mvpp2_prs_init_from_hw(priv, &pe, tid); | |
| pmap = mvpp2_prs_tcam_port_map_get(&pe); | |
| if (!priv->prs_shadow[tid].valid) | |
| continue; | |
| if (!test_bit(port->id, &pmap)) | |
| continue; | |
| mvpp2_prs_tcam_data_byte_get(&pe, 2, &byte[0], &enable[0]); | |
| mvpp2_prs_tcam_data_byte_get(&pe, 3, &byte[1], &enable[1]); | |
| rvid = ((byte[0] & 0xf) << 8) + byte[1]; | |
| seq_printf(s, "%u\n", rvid); | |
| } | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_vid); | |
| static int mvpp2_dbgfs_port_parser_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_port *port = s->private; | |
| struct mvpp2 *priv = port->priv; | |
| struct mvpp2_prs_entry pe; | |
| unsigned long pmap; | |
| int i; | |
| for (i = 0; i < MVPP2_PRS_TCAM_SRAM_SIZE; i++) { | |
| mvpp2_prs_init_from_hw(port->priv, &pe, i); | |
| pmap = mvpp2_prs_tcam_port_map_get(&pe); | |
| if (priv->prs_shadow[i].valid && test_bit(port->id, &pmap)) | |
| seq_printf(s, "%03d\n", i); | |
| } | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_parser); | |
| static int mvpp2_dbgfs_filter_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_port *port = s->private; | |
| struct mvpp2 *priv = port->priv; | |
| struct mvpp2_prs_entry pe; | |
| unsigned long pmap; | |
| int index, tid; | |
| for (tid = MVPP2_PE_MAC_RANGE_START; | |
| tid <= MVPP2_PE_MAC_RANGE_END; tid++) { | |
| unsigned char da[ETH_ALEN], da_mask[ETH_ALEN]; | |
| if (!priv->prs_shadow[tid].valid || | |
| priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC || | |
| priv->prs_shadow[tid].udf != MVPP2_PRS_UDF_MAC_DEF) | |
| continue; | |
| mvpp2_prs_init_from_hw(priv, &pe, tid); | |
| pmap = mvpp2_prs_tcam_port_map_get(&pe); | |
| /* We only want entries active on this port */ | |
| if (!test_bit(port->id, &pmap)) | |
| continue; | |
| /* Read mac addr from entry */ | |
| for (index = 0; index < ETH_ALEN; index++) | |
| mvpp2_prs_tcam_data_byte_get(&pe, index, &da[index], | |
| &da_mask[index]); | |
| seq_printf(s, "%pM\n", da); | |
| } | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_filter); | |
| static int mvpp2_dbgfs_prs_lu_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| struct mvpp2 *priv = entry->priv; | |
| seq_printf(s, "%x\n", priv->prs_shadow[entry->tid].lu); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_lu); | |
| static int mvpp2_dbgfs_prs_pmap_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| struct mvpp2_prs_entry pe; | |
| unsigned int pmap; | |
| mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid); | |
| pmap = mvpp2_prs_tcam_port_map_get(&pe); | |
| pmap &= MVPP2_PRS_PORT_MASK; | |
| seq_printf(s, "%02x\n", pmap); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_pmap); | |
| static int mvpp2_dbgfs_prs_ai_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| struct mvpp2_prs_entry pe; | |
| unsigned char ai, ai_mask; | |
| mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid); | |
| ai = pe.tcam[MVPP2_PRS_TCAM_AI_WORD] & MVPP2_PRS_AI_MASK; | |
| ai_mask = (pe.tcam[MVPP2_PRS_TCAM_AI_WORD] >> 16) & MVPP2_PRS_AI_MASK; | |
| seq_printf(s, "%02x %02x\n", ai, ai_mask); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_ai); | |
| static int mvpp2_dbgfs_prs_hdata_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| struct mvpp2_prs_entry pe; | |
| unsigned char data[8], mask[8]; | |
| int i; | |
| mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid); | |
| for (i = 0; i < 8; i++) | |
| mvpp2_prs_tcam_data_byte_get(&pe, i, &data[i], &mask[i]); | |
| seq_printf(s, "%*phN %*phN\n", 8, data, 8, mask); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_hdata); | |
| static int mvpp2_dbgfs_prs_sram_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| struct mvpp2_prs_entry pe; | |
| mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid); | |
| seq_printf(s, "%*phN\n", 14, pe.sram); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_sram); | |
| static int mvpp2_dbgfs_prs_hits_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| int val; | |
| val = mvpp2_prs_hits(entry->priv, entry->tid); | |
| if (val < 0) | |
| return val; | |
| seq_printf(s, "%d\n", val); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_hits); | |
| static int mvpp2_dbgfs_prs_valid_show(struct seq_file *s, void *unused) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry = s->private; | |
| struct mvpp2 *priv = entry->priv; | |
| int tid = entry->tid; | |
| seq_printf(s, "%d\n", priv->prs_shadow[tid].valid ? 1 : 0); | |
| return 0; | |
| } | |
| DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_valid); | |
| static int mvpp2_dbgfs_flow_port_init(struct dentry *parent, | |
| struct mvpp2_port *port, | |
| struct mvpp2_dbgfs_flow_entry *entry) | |
| { | |
| struct mvpp2_dbgfs_port_flow_entry *port_entry; | |
| struct dentry *port_dir; | |
| port_dir = debugfs_create_dir(port->dev->name, parent); | |
| port_entry = &port->priv->dbgfs_entries->port_flow_entries[port->id]; | |
| port_entry->port = port; | |
| port_entry->dbg_fe = entry; | |
| debugfs_create_file("hash_opts", 0444, port_dir, port_entry, | |
| &mvpp2_dbgfs_port_flow_hash_opt_fops); | |
| debugfs_create_file("engine", 0444, port_dir, port_entry, | |
| &mvpp2_dbgfs_port_flow_engine_fops); | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_flow_entry_init(struct dentry *parent, | |
| struct mvpp2 *priv, int flow) | |
| { | |
| struct mvpp2_dbgfs_flow_entry *entry; | |
| struct dentry *flow_entry_dir; | |
| char flow_entry_name[10]; | |
| int i, ret; | |
| sprintf(flow_entry_name, "%02d", flow); | |
| flow_entry_dir = debugfs_create_dir(flow_entry_name, parent); | |
| entry = &priv->dbgfs_entries->flow_entries[flow]; | |
| entry->flow = flow; | |
| entry->priv = priv; | |
| debugfs_create_file("dec_hits", 0444, flow_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_dec_hits_fops); | |
| debugfs_create_file("type", 0444, flow_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_type_fops); | |
| debugfs_create_file("id", 0444, flow_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_id_fops); | |
| /* Create entry for each port */ | |
| for (i = 0; i < priv->port_count; i++) { | |
| ret = mvpp2_dbgfs_flow_port_init(flow_entry_dir, | |
| priv->port_list[i], entry); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_flow_init(struct dentry *parent, struct mvpp2 *priv) | |
| { | |
| struct dentry *flow_dir; | |
| int i, ret; | |
| flow_dir = debugfs_create_dir("flows", parent); | |
| for (i = 0; i < MVPP2_N_PRS_FLOWS; i++) { | |
| ret = mvpp2_dbgfs_flow_entry_init(flow_dir, priv, i); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_prs_entry_init(struct dentry *parent, | |
| struct mvpp2 *priv, int tid) | |
| { | |
| struct mvpp2_dbgfs_prs_entry *entry; | |
| struct dentry *prs_entry_dir; | |
| char prs_entry_name[10]; | |
| if (tid >= MVPP2_PRS_TCAM_SRAM_SIZE) | |
| return -EINVAL; | |
| sprintf(prs_entry_name, "%03d", tid); | |
| prs_entry_dir = debugfs_create_dir(prs_entry_name, parent); | |
| entry = &priv->dbgfs_entries->prs_entries[tid]; | |
| entry->tid = tid; | |
| entry->priv = priv; | |
| /* Create each attr */ | |
| debugfs_create_file("sram", 0444, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_sram_fops); | |
| debugfs_create_file("valid", 0644, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_valid_fops); | |
| debugfs_create_file("lookup_id", 0644, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_lu_fops); | |
| debugfs_create_file("ai", 0644, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_ai_fops); | |
| debugfs_create_file("header_data", 0644, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_hdata_fops); | |
| debugfs_create_file("hits", 0444, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_hits_fops); | |
| debugfs_create_file("pmap", 0444, prs_entry_dir, entry, | |
| &mvpp2_dbgfs_prs_pmap_fops); | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_prs_init(struct dentry *parent, struct mvpp2 *priv) | |
| { | |
| struct dentry *prs_dir; | |
| int i, ret; | |
| prs_dir = debugfs_create_dir("parser", parent); | |
| for (i = 0; i < MVPP2_PRS_TCAM_SRAM_SIZE; i++) { | |
| ret = mvpp2_dbgfs_prs_entry_init(prs_dir, priv, i); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_c2_entry_init(struct dentry *parent, | |
| struct mvpp2 *priv, int id) | |
| { | |
| struct mvpp2_dbgfs_c2_entry *entry; | |
| struct dentry *c2_entry_dir; | |
| char c2_entry_name[10]; | |
| if (id >= MVPP22_CLS_C2_N_ENTRIES) | |
| return -EINVAL; | |
| sprintf(c2_entry_name, "%03d", id); | |
| c2_entry_dir = debugfs_create_dir(c2_entry_name, parent); | |
| entry = &priv->dbgfs_entries->c2_entries[id]; | |
| entry->id = id; | |
| entry->priv = priv; | |
| debugfs_create_file("hits", 0444, c2_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_c2_hits_fops); | |
| debugfs_create_file("default_rxq", 0444, c2_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_c2_rxq_fops); | |
| debugfs_create_file("rss_enable", 0444, c2_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_c2_enable_fops); | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_flow_tbl_entry_init(struct dentry *parent, | |
| struct mvpp2 *priv, int id) | |
| { | |
| struct mvpp2_dbgfs_flow_tbl_entry *entry; | |
| struct dentry *flow_tbl_entry_dir; | |
| char flow_tbl_entry_name[10]; | |
| if (id >= MVPP2_CLS_FLOWS_TBL_SIZE) | |
| return -EINVAL; | |
| sprintf(flow_tbl_entry_name, "%03d", id); | |
| flow_tbl_entry_dir = debugfs_create_dir(flow_tbl_entry_name, parent); | |
| entry = &priv->dbgfs_entries->flt_entries[id]; | |
| entry->id = id; | |
| entry->priv = priv; | |
| debugfs_create_file("hits", 0444, flow_tbl_entry_dir, entry, | |
| &mvpp2_dbgfs_flow_flt_hits_fops); | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_cls_init(struct dentry *parent, struct mvpp2 *priv) | |
| { | |
| struct dentry *cls_dir, *c2_dir, *flow_tbl_dir; | |
| int i, ret; | |
| cls_dir = debugfs_create_dir("classifier", parent); | |
| c2_dir = debugfs_create_dir("c2", cls_dir); | |
| for (i = 0; i < MVPP22_CLS_C2_N_ENTRIES; i++) { | |
| ret = mvpp2_dbgfs_c2_entry_init(c2_dir, priv, i); | |
| if (ret) | |
| return ret; | |
| } | |
| flow_tbl_dir = debugfs_create_dir("flow_table", cls_dir); | |
| for (i = 0; i < MVPP2_CLS_FLOWS_TBL_SIZE; i++) { | |
| ret = mvpp2_dbgfs_flow_tbl_entry_init(flow_tbl_dir, priv, i); | |
| if (ret) | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| static int mvpp2_dbgfs_port_init(struct dentry *parent, | |
| struct mvpp2_port *port) | |
| { | |
| struct dentry *port_dir; | |
| port_dir = debugfs_create_dir(port->dev->name, parent); | |
| debugfs_create_file("parser_entries", 0444, port_dir, port, | |
| &mvpp2_dbgfs_port_parser_fops); | |
| debugfs_create_file("mac_filter", 0444, port_dir, port, | |
| &mvpp2_dbgfs_filter_fops); | |
| debugfs_create_file("vid_filter", 0444, port_dir, port, | |
| &mvpp2_dbgfs_port_vid_fops); | |
| return 0; | |
| } | |
| static struct dentry *mvpp2_root; | |
| void mvpp2_dbgfs_exit(void) | |
| { | |
| debugfs_remove(mvpp2_root); | |
| } | |
| void mvpp2_dbgfs_cleanup(struct mvpp2 *priv) | |
| { | |
| debugfs_remove_recursive(priv->dbgfs_dir); | |
| kfree(priv->dbgfs_entries); | |
| } | |
| void mvpp2_dbgfs_init(struct mvpp2 *priv, const char *name) | |
| { | |
| struct dentry *mvpp2_dir; | |
| int ret, i; | |
| if (!mvpp2_root) | |
| mvpp2_root = debugfs_create_dir(MVPP2_DRIVER_NAME, NULL); | |
| mvpp2_dir = debugfs_create_dir(name, mvpp2_root); | |
| priv->dbgfs_dir = mvpp2_dir; | |
| priv->dbgfs_entries = kzalloc_obj(*priv->dbgfs_entries); | |
| if (!priv->dbgfs_entries) | |
| goto err; | |
| ret = mvpp2_dbgfs_prs_init(mvpp2_dir, priv); | |
| if (ret) | |
| goto err; | |
| ret = mvpp2_dbgfs_cls_init(mvpp2_dir, priv); | |
| if (ret) | |
| goto err; | |
| for (i = 0; i < priv->port_count; i++) { | |
| ret = mvpp2_dbgfs_port_init(mvpp2_dir, priv->port_list[i]); | |
| if (ret) | |
| goto err; | |
| } | |
| ret = mvpp2_dbgfs_flow_init(mvpp2_dir, priv); | |
| if (ret) | |
| goto err; | |
| return; | |
| err: | |
| mvpp2_dbgfs_cleanup(priv); | |
| } |