drivers/net/ethernet/marvell/mvpp2/mvpp2_debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Driver for Marvell PPv2 network controller for Armada 375 SoC.
   4  *
   5  * Copyright (C) 2018 Marvell
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/slab.h>
  10 #include <linux/debugfs.h>
  11
  12 #include "mvpp2.h"
  13 #include "mvpp2_prs.h"
  14 #include "mvpp2_cls.h"
  15
  16 struct mvpp2_dbgfs_prs_entry {
  17         int tid;
  18         struct mvpp2 *priv;
  19 };
  20
  21 struct mvpp2_dbgfs_c2_entry {
  22         int id;
  23         struct mvpp2 *priv;
  24 };
  25
  26 struct mvpp2_dbgfs_flow_entry {
  27         int flow;
  28         struct mvpp2 *priv;
  29 };
  30
  31 struct mvpp2_dbgfs_flow_tbl_entry {
  32         int id;
  33         struct mvpp2 *priv;
  34 };
  35
  36 struct mvpp2_dbgfs_port_flow_entry {
  37         struct mvpp2_port *port;
  38         struct mvpp2_dbgfs_flow_entry *dbg_fe;
  39 };
  40
  41 struct mvpp2_dbgfs_entries {
  42         /* Entries for Header Parser debug info */
  43         struct mvpp2_dbgfs_prs_entry prs_entries[MVPP2_PRS_TCAM_SRAM_SIZE];
  44
  45         /* Entries for Classifier C2 engine debug info */
  46         struct mvpp2_dbgfs_c2_entry c2_entries[MVPP22_CLS_C2_N_ENTRIES];
  47
  48         /* Entries for Classifier Flow Table debug info */
  49         struct mvpp2_dbgfs_flow_tbl_entry flt_entries[MVPP2_CLS_FLOWS_TBL_SIZE];
  50
  51         /* Entries for Classifier flows debug info */
  52         struct mvpp2_dbgfs_flow_entry flow_entries[MVPP2_N_PRS_FLOWS];
  53
  54         /* Entries for per-port flows debug info */
  55         struct mvpp2_dbgfs_port_flow_entry port_flow_entries[MVPP2_MAX_PORTS];
  56 };
  57
  58 static int mvpp2_dbgfs_flow_flt_hits_show(struct seq_file *s, void *unused)
  59 {
  60         struct mvpp2_dbgfs_flow_tbl_entry *entry = s->private;
  61
  62         u32 hits = mvpp2_cls_flow_hits(entry->priv, entry->id);
  63
  64         seq_printf(s, "%u\n", hits);
  65
  66         return 0;
  67 }
  68
  69 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_flt_hits);
  70
  71 static int mvpp2_dbgfs_flow_dec_hits_show(struct seq_file *s, void *unused)
  72 {
  73         struct mvpp2_dbgfs_flow_entry *entry = s->private;
  74
  75         u32 hits = mvpp2_cls_lookup_hits(entry->priv, entry->flow);
  76
  77         seq_printf(s, "%u\n", hits);
  78
  79         return 0;
  80 }
  81
  82 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_dec_hits);
  83
  84 static int mvpp2_dbgfs_flow_type_show(struct seq_file *s, void *unused)
  85 {
  86         struct mvpp2_dbgfs_flow_entry *entry = s->private;
  87         const struct mvpp2_cls_flow *f;
  88         const char *flow_name;
  89
  90         f = mvpp2_cls_flow_get(entry->flow);
  91         if (!f)
  92                 return -EINVAL;
  93
  94         switch (f->flow_type) {
  95         case IPV4_FLOW:
  96                 flow_name = "ipv4";
  97                 break;
  98         case IPV6_FLOW:
  99                 flow_name = "ipv6";
 100                 break;
 101         case TCP_V4_FLOW:
 102                 flow_name = "tcp4";
 103                 break;
 104         case TCP_V6_FLOW:
 105                 flow_name = "tcp6";
 106                 break;
 107         case UDP_V4_FLOW:
 108                 flow_name = "udp4";
 109                 break;
 110         case UDP_V6_FLOW:
 111                 flow_name = "udp6";
 112                 break;
 113         default:
 114                 flow_name = "other";
 115         }
 116
 117         seq_printf(s, "%s\n", flow_name);
 118
 119         return 0;
 120 }
 121
 122 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_type);
 123
 124 static int mvpp2_dbgfs_flow_id_show(struct seq_file *s, void *unused)
 125 {
 126         const struct mvpp2_dbgfs_flow_entry *entry = s->private;
 127         const struct mvpp2_cls_flow *f;
 128
 129         f = mvpp2_cls_flow_get(entry->flow);
 130         if (!f)
 131                 return -EINVAL;
 132
 133         seq_printf(s, "%d\n", f->flow_id);
 134
 135         return 0;
 136 }
 137
 138 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_id);
 139
 140 static int mvpp2_dbgfs_port_flow_hash_opt_show(struct seq_file *s, void *unused)
 141 {
 142         struct mvpp2_dbgfs_port_flow_entry *entry = s->private;
 143         struct mvpp2_port *port = entry->port;
 144         struct mvpp2_cls_flow_entry fe;
 145         const struct mvpp2_cls_flow *f;
 146         int flow_index;
 147         u16 hash_opts;
 148
 149         f = mvpp2_cls_flow_get(entry->dbg_fe->flow);
 150         if (!f)
 151                 return -EINVAL;
 152
 153         flow_index = MVPP2_CLS_FLT_HASH_ENTRY(entry->port->id, f->flow_id);
 154
 155         mvpp2_cls_flow_read(port->priv, flow_index, &fe);
 156
 157         hash_opts = mvpp2_flow_get_hek_fields(&fe);
 158
 159         seq_printf(s, "0x%04x\n", hash_opts);
 160
 161         return 0;
 162 }
 163
 164 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_flow_hash_opt);
 165
 166 static int mvpp2_dbgfs_port_flow_engine_show(struct seq_file *s, void *unused)
 167 {
 168         struct mvpp2_dbgfs_port_flow_entry *entry = s->private;
 169         struct mvpp2_port *port = entry->port;
 170         struct mvpp2_cls_flow_entry fe;
 171         const struct mvpp2_cls_flow *f;
 172         int flow_index, engine;
 173
 174         f = mvpp2_cls_flow_get(entry->dbg_fe->flow);
 175         if (!f)
 176                 return -EINVAL;
 177
 178         flow_index = MVPP2_CLS_FLT_HASH_ENTRY(entry->port->id, f->flow_id);
 179
 180         mvpp2_cls_flow_read(port->priv, flow_index, &fe);
 181
 182         engine = mvpp2_cls_flow_eng_get(&fe);
 183
 184         seq_printf(s, "%d\n", engine);
 185
 186         return 0;
 187 }
 188
 189 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_flow_engine);
 190
 191 static int mvpp2_dbgfs_flow_c2_hits_show(struct seq_file *s, void *unused)
 192 {
 193         struct mvpp2_dbgfs_c2_entry *entry = s->private;
 194         u32 hits;
 195
 196         hits = mvpp2_cls_c2_hit_count(entry->priv, entry->id);
 197
 198         seq_printf(s, "%u\n", hits);
 199
 200         return 0;
 201 }
 202
 203 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_hits);
 204
 205 static int mvpp2_dbgfs_flow_c2_rxq_show(struct seq_file *s, void *unused)
 206 {
 207         struct mvpp2_dbgfs_c2_entry *entry = s->private;
 208         struct mvpp2_cls_c2_entry c2;
 209         u8 qh, ql;
 210
 211         mvpp2_cls_c2_read(entry->priv, entry->id, &c2);
 212
 213         qh = (c2.attr[0] >> MVPP22_CLS_C2_ATTR0_QHIGH_OFFS) &
 214              MVPP22_CLS_C2_ATTR0_QHIGH_MASK;
 215
 216         ql = (c2.attr[0] >> MVPP22_CLS_C2_ATTR0_QLOW_OFFS) &
 217              MVPP22_CLS_C2_ATTR0_QLOW_MASK;
 218
 219         seq_printf(s, "%d\n", (qh << 3 | ql));
 220
 221         return 0;
 222 }
 223
 224 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_rxq);
 225
 226 static int mvpp2_dbgfs_flow_c2_enable_show(struct seq_file *s, void *unused)
 227 {
 228         struct mvpp2_dbgfs_c2_entry *entry = s->private;
 229         struct mvpp2_cls_c2_entry c2;
 230         int enabled;
 231
 232         mvpp2_cls_c2_read(entry->priv, entry->id, &c2);
 233
 234         enabled = !!(c2.attr[2] & MVPP22_CLS_C2_ATTR2_RSS_EN);
 235
 236         seq_printf(s, "%d\n", enabled);
 237
 238         return 0;
 239 }
 240
 241 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_flow_c2_enable);
 242
 243 static int mvpp2_dbgfs_port_vid_show(struct seq_file *s, void *unused)
 244 {
 245         struct mvpp2_port *port = s->private;
 246         unsigned char byte[2], enable[2];
 247         struct mvpp2 *priv = port->priv;
 248         struct mvpp2_prs_entry pe;
 249         unsigned long pmap;
 250         u16 rvid;
 251         int tid;
 252
 253         for (tid = MVPP2_PRS_VID_PORT_FIRST(port->id);
 254              tid <= MVPP2_PRS_VID_PORT_LAST(port->id); tid++) {
 255                 mvpp2_prs_init_from_hw(priv, &pe, tid);
 256
 257                 pmap = mvpp2_prs_tcam_port_map_get(&pe);
 258
 259                 if (!priv->prs_shadow[tid].valid)
 260                         continue;
 261
 262                 if (!test_bit(port->id, &pmap))
 263                         continue;
 264
 265                 mvpp2_prs_tcam_data_byte_get(&pe, 2, &byte[0], &enable[0]);
 266                 mvpp2_prs_tcam_data_byte_get(&pe, 3, &byte[1], &enable[1]);
 267
 268                 rvid = ((byte[0] & 0xf) << 8) + byte[1];
 269
 270                 seq_printf(s, "%u\n", rvid);
 271         }
 272
 273         return 0;
 274 }
 275
 276 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_vid);
 277
 278 static int mvpp2_dbgfs_port_parser_show(struct seq_file *s, void *unused)
 279 {
 280         struct mvpp2_port *port = s->private;
 281         struct mvpp2 *priv = port->priv;
 282         struct mvpp2_prs_entry pe;
 283         unsigned long pmap;
 284         int i;
 285
 286         for (i = 0; i < MVPP2_PRS_TCAM_SRAM_SIZE; i++) {
 287                 mvpp2_prs_init_from_hw(port->priv, &pe, i);
 288
 289                 pmap = mvpp2_prs_tcam_port_map_get(&pe);
 290                 if (priv->prs_shadow[i].valid && test_bit(port->id, &pmap))
 291                         seq_printf(s, "%03d\n", i);
 292         }
 293
 294         return 0;
 295 }
 296
 297 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_port_parser);
 298
 299 static int mvpp2_dbgfs_filter_show(struct seq_file *s, void *unused)
 300 {
 301         struct mvpp2_port *port = s->private;
 302         struct mvpp2 *priv = port->priv;
 303         struct mvpp2_prs_entry pe;
 304         unsigned long pmap;
 305         int index, tid;
 306
 307         for (tid = MVPP2_PE_MAC_RANGE_START;
 308              tid <= MVPP2_PE_MAC_RANGE_END; tid++) {
 309                 unsigned char da[ETH_ALEN], da_mask[ETH_ALEN];
 310
 311                 if (!priv->prs_shadow[tid].valid ||
 312                     priv->prs_shadow[tid].lu != MVPP2_PRS_LU_MAC ||
 313                     priv->prs_shadow[tid].udf != MVPP2_PRS_UDF_MAC_DEF)
 314                         continue;
 315
 316                 mvpp2_prs_init_from_hw(priv, &pe, tid);
 317
 318                 pmap = mvpp2_prs_tcam_port_map_get(&pe);
 319
 320                 /* We only want entries active on this port */
 321                 if (!test_bit(port->id, &pmap))
 322                         continue;
 323
 324                 /* Read mac addr from entry */
 325                 for (index = 0; index < ETH_ALEN; index++)
 326                         mvpp2_prs_tcam_data_byte_get(&pe, index, &da[index],
 327                                                      &da_mask[index]);
 328
 329                 seq_printf(s, "%pM\n", da);
 330         }
 331
 332         return 0;
 333 }
 334
 335 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_filter);
 336
 337 static int mvpp2_dbgfs_prs_lu_show(struct seq_file *s, void *unused)
 338 {
 339         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 340         struct mvpp2 *priv = entry->priv;
 341
 342         seq_printf(s, "%x\n", priv->prs_shadow[entry->tid].lu);
 343
 344         return 0;
 345 }
 346
 347 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_lu);
 348
 349 static int mvpp2_dbgfs_prs_pmap_show(struct seq_file *s, void *unused)
 350 {
 351         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 352         struct mvpp2_prs_entry pe;
 353         unsigned int pmap;
 354
 355         mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);
 356
 357         pmap = mvpp2_prs_tcam_port_map_get(&pe);
 358         pmap &= MVPP2_PRS_PORT_MASK;
 359
 360         seq_printf(s, "%02x\n", pmap);
 361
 362         return 0;
 363 }
 364
 365 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_pmap);
 366
 367 static int mvpp2_dbgfs_prs_ai_show(struct seq_file *s, void *unused)
 368 {
 369         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 370         struct mvpp2_prs_entry pe;
 371         unsigned char ai, ai_mask;
 372
 373         mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);
 374
 375         ai = pe.tcam[MVPP2_PRS_TCAM_AI_WORD] & MVPP2_PRS_AI_MASK;
 376         ai_mask = (pe.tcam[MVPP2_PRS_TCAM_AI_WORD] >> 16) & MVPP2_PRS_AI_MASK;
 377
 378         seq_printf(s, "%02x %02x\n", ai, ai_mask);
 379
 380         return 0;
 381 }
 382
 383 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_ai);
 384
 385 static int mvpp2_dbgfs_prs_hdata_show(struct seq_file *s, void *unused)
 386 {
 387         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 388         struct mvpp2_prs_entry pe;
 389         unsigned char data[8], mask[8];
 390         int i;
 391
 392         mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);
 393
 394         for (i = 0; i < 8; i++)
 395                 mvpp2_prs_tcam_data_byte_get(&pe, i, &data[i], &mask[i]);
 396
 397         seq_printf(s, "%*phN %*phN\n", 8, data, 8, mask);
 398
 399         return 0;
 400 }
 401
 402 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_hdata);
 403
 404 static int mvpp2_dbgfs_prs_sram_show(struct seq_file *s, void *unused)
 405 {
 406         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 407         struct mvpp2_prs_entry pe;
 408
 409         mvpp2_prs_init_from_hw(entry->priv, &pe, entry->tid);
 410
 411         seq_printf(s, "%*phN\n", 14, pe.sram);
 412
 413         return 0;
 414 }
 415
 416 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_sram);
 417
 418 static int mvpp2_dbgfs_prs_hits_show(struct seq_file *s, void *unused)
 419 {
 420         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 421         int val;
 422
 423         val = mvpp2_prs_hits(entry->priv, entry->tid);
 424         if (val < 0)
 425                 return val;
 426
 427         seq_printf(s, "%d\n", val);
 428
 429         return 0;
 430 }
 431
 432 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_hits);
 433
 434 static int mvpp2_dbgfs_prs_valid_show(struct seq_file *s, void *unused)
 435 {
 436         struct mvpp2_dbgfs_prs_entry *entry = s->private;
 437         struct mvpp2 *priv = entry->priv;
 438         int tid = entry->tid;
 439
 440         seq_printf(s, "%d\n", priv->prs_shadow[tid].valid ? 1 : 0);
 441
 442         return 0;
 443 }
 444
 445 DEFINE_SHOW_ATTRIBUTE(mvpp2_dbgfs_prs_valid);
 446
 447 static int mvpp2_dbgfs_flow_port_init(struct dentry *parent,
 448                                       struct mvpp2_port *port,
 449                                       struct mvpp2_dbgfs_flow_entry *entry)
 450 {
 451         struct mvpp2_dbgfs_port_flow_entry *port_entry;
 452         struct dentry *port_dir;
 453
 454         port_dir = debugfs_create_dir(port->dev->name, parent);
 455         if (IS_ERR(port_dir))
 456                 return PTR_ERR(port_dir);
 457
 458         port_entry = &port->priv->dbgfs_entries->port_flow_entries[port->id];
 459
 460         port_entry->port = port;
 461         port_entry->dbg_fe = entry;
 462
 463         debugfs_create_file("hash_opts", 0444, port_dir, port_entry,
 464                             &mvpp2_dbgfs_port_flow_hash_opt_fops);
 465
 466         debugfs_create_file("engine", 0444, port_dir, port_entry,
 467                             &mvpp2_dbgfs_port_flow_engine_fops);
 468
 469         return 0;
 470 }
 471
 472 static int mvpp2_dbgfs_flow_entry_init(struct dentry *parent,
 473                                        struct mvpp2 *priv, int flow)
 474 {
 475         struct mvpp2_dbgfs_flow_entry *entry;
 476         struct dentry *flow_entry_dir;
 477         char flow_entry_name[10];
 478         int i, ret;
 479
 480         sprintf(flow_entry_name, "%02d", flow);
 481
 482         flow_entry_dir = debugfs_create_dir(flow_entry_name, parent);
 483         if (!flow_entry_dir)
 484                 return -ENOMEM;
 485
 486         entry = &priv->dbgfs_entries->flow_entries[flow];
 487
 488         entry->flow = flow;
 489         entry->priv = priv;
 490
 491         debugfs_create_file("dec_hits", 0444, flow_entry_dir, entry,
 492                             &mvpp2_dbgfs_flow_dec_hits_fops);
 493
 494         debugfs_create_file("type", 0444, flow_entry_dir, entry,
 495                             &mvpp2_dbgfs_flow_type_fops);
 496
 497         debugfs_create_file("id", 0444, flow_entry_dir, entry,
 498                             &mvpp2_dbgfs_flow_id_fops);
 499
 500         /* Create entry for each port */
 501         for (i = 0; i < priv->port_count; i++) {
 502                 ret = mvpp2_dbgfs_flow_port_init(flow_entry_dir,
 503                                                  priv->port_list[i], entry);
 504                 if (ret)
 505                         return ret;
 506         }
 507
 508         return 0;
 509 }
 510
 511 static int mvpp2_dbgfs_flow_init(struct dentry *parent, struct mvpp2 *priv)
 512 {
 513         struct dentry *flow_dir;
 514         int i, ret;
 515
 516         flow_dir = debugfs_create_dir("flows", parent);
 517         if (!flow_dir)
 518                 return -ENOMEM;
 519
 520         for (i = 0; i < MVPP2_N_PRS_FLOWS; i++) {
 521                 ret = mvpp2_dbgfs_flow_entry_init(flow_dir, priv, i);
 522                 if (ret)
 523                         return ret;
 524         }
 525
 526         return 0;
 527 }
 528
 529 static int mvpp2_dbgfs_prs_entry_init(struct dentry *parent,
 530                                       struct mvpp2 *priv, int tid)
 531 {
 532         struct mvpp2_dbgfs_prs_entry *entry;
 533         struct dentry *prs_entry_dir;
 534         char prs_entry_name[10];
 535
 536         if (tid >= MVPP2_PRS_TCAM_SRAM_SIZE)
 537                 return -EINVAL;
 538
 539         sprintf(prs_entry_name, "%03d", tid);
 540
 541         prs_entry_dir = debugfs_create_dir(prs_entry_name, parent);
 542         if (!prs_entry_dir)
 543                 return -ENOMEM;
 544
 545         entry = &priv->dbgfs_entries->prs_entries[tid];
 546
 547         entry->tid = tid;
 548         entry->priv = priv;
 549
 550         /* Create each attr */
 551         debugfs_create_file("sram", 0444, prs_entry_dir, entry,
 552                             &mvpp2_dbgfs_prs_sram_fops);
 553
 554         debugfs_create_file("valid", 0644, prs_entry_dir, entry,
 555                             &mvpp2_dbgfs_prs_valid_fops);
 556
 557         debugfs_create_file("lookup_id", 0644, prs_entry_dir, entry,
 558                             &mvpp2_dbgfs_prs_lu_fops);
 559
 560         debugfs_create_file("ai", 0644, prs_entry_dir, entry,
 561                             &mvpp2_dbgfs_prs_ai_fops);
 562
 563         debugfs_create_file("header_data", 0644, prs_entry_dir, entry,
 564                             &mvpp2_dbgfs_prs_hdata_fops);
 565
 566         debugfs_create_file("hits", 0444, prs_entry_dir, entry,
 567                             &mvpp2_dbgfs_prs_hits_fops);
 568
 569         debugfs_create_file("pmap", 0444, prs_entry_dir, entry,
 570                              &mvpp2_dbgfs_prs_pmap_fops);
 571
 572         return 0;
 573 }
 574
 575 static int mvpp2_dbgfs_prs_init(struct dentry *parent, struct mvpp2 *priv)
 576 {
 577         struct dentry *prs_dir;
 578         int i, ret;
 579
 580         prs_dir = debugfs_create_dir("parser", parent);
 581         if (!prs_dir)
 582                 return -ENOMEM;
 583
 584         for (i = 0; i < MVPP2_PRS_TCAM_SRAM_SIZE; i++) {
 585                 ret = mvpp2_dbgfs_prs_entry_init(prs_dir, priv, i);
 586                 if (ret)
 587                         return ret;
 588         }
 589
 590         return 0;
 591 }
 592
 593 static int mvpp2_dbgfs_c2_entry_init(struct dentry *parent,
 594                                      struct mvpp2 *priv, int id)
 595 {
 596         struct mvpp2_dbgfs_c2_entry *entry;
 597         struct dentry *c2_entry_dir;
 598         char c2_entry_name[10];
 599
 600         if (id >= MVPP22_CLS_C2_N_ENTRIES)
 601                 return -EINVAL;
 602
 603         sprintf(c2_entry_name, "%03d", id);
 604
 605         c2_entry_dir = debugfs_create_dir(c2_entry_name, parent);
 606         if (!c2_entry_dir)
 607                 return -ENOMEM;
 608
 609         entry = &priv->dbgfs_entries->c2_entries[id];
 610
 611         entry->id = id;
 612         entry->priv = priv;
 613
 614         debugfs_create_file("hits", 0444, c2_entry_dir, entry,
 615                             &mvpp2_dbgfs_flow_c2_hits_fops);
 616
 617         debugfs_create_file("default_rxq", 0444, c2_entry_dir, entry,
 618                             &mvpp2_dbgfs_flow_c2_rxq_fops);
 619
 620         debugfs_create_file("rss_enable", 0444, c2_entry_dir, entry,
 621                             &mvpp2_dbgfs_flow_c2_enable_fops);
 622
 623         return 0;
 624 }
 625
 626 static int mvpp2_dbgfs_flow_tbl_entry_init(struct dentry *parent,
 627                                            struct mvpp2 *priv, int id)
 628 {
 629         struct mvpp2_dbgfs_flow_tbl_entry *entry;
 630         struct dentry *flow_tbl_entry_dir;
 631         char flow_tbl_entry_name[10];
 632
 633         if (id >= MVPP2_CLS_FLOWS_TBL_SIZE)
 634                 return -EINVAL;
 635
 636         sprintf(flow_tbl_entry_name, "%03d", id);
 637
 638         flow_tbl_entry_dir = debugfs_create_dir(flow_tbl_entry_name, parent);
 639         if (!flow_tbl_entry_dir)
 640                 return -ENOMEM;
 641
 642         entry = &priv->dbgfs_entries->flt_entries[id];
 643
 644         entry->id = id;
 645         entry->priv = priv;
 646
 647         debugfs_create_file("hits", 0444, flow_tbl_entry_dir, entry,
 648                             &mvpp2_dbgfs_flow_flt_hits_fops);
 649
 650         return 0;
 651 }
 652
 653 static int mvpp2_dbgfs_cls_init(struct dentry *parent, struct mvpp2 *priv)
 654 {
 655         struct dentry *cls_dir, *c2_dir, *flow_tbl_dir;
 656         int i, ret;
 657
 658         cls_dir = debugfs_create_dir("classifier", parent);
 659         if (!cls_dir)
 660                 return -ENOMEM;
 661
 662         c2_dir = debugfs_create_dir("c2", cls_dir);
 663         if (!c2_dir)
 664                 return -ENOMEM;
 665
 666         for (i = 0; i < MVPP22_CLS_C2_N_ENTRIES; i++) {
 667                 ret = mvpp2_dbgfs_c2_entry_init(c2_dir, priv, i);
 668                 if (ret)
 669                         return ret;
 670         }
 671
 672         flow_tbl_dir = debugfs_create_dir("flow_table", cls_dir);
 673         if (!flow_tbl_dir)
 674                 return -ENOMEM;
 675
 676         for (i = 0; i < MVPP2_CLS_FLOWS_TBL_SIZE; i++) {
 677                 ret = mvpp2_dbgfs_flow_tbl_entry_init(flow_tbl_dir, priv, i);
 678                 if (ret)
 679                         return ret;
 680         }
 681
 682         return 0;
 683 }
 684
 685 static int mvpp2_dbgfs_port_init(struct dentry *parent,
 686                                  struct mvpp2_port *port)
 687 {
 688         struct dentry *port_dir;
 689
 690         port_dir = debugfs_create_dir(port->dev->name, parent);
 691         if (IS_ERR(port_dir))
 692                 return PTR_ERR(port_dir);
 693
 694         debugfs_create_file("parser_entries", 0444, port_dir, port,
 695                             &mvpp2_dbgfs_port_parser_fops);
 696
 697         debugfs_create_file("mac_filter", 0444, port_dir, port,
 698                             &mvpp2_dbgfs_filter_fops);
 699
 700         debugfs_create_file("vid_filter", 0444, port_dir, port,
 701                             &mvpp2_dbgfs_port_vid_fops);
 702
 703         return 0;
 704 }
 705
 706 void mvpp2_dbgfs_cleanup(struct mvpp2 *priv)
 707 {
 708         debugfs_remove_recursive(priv->dbgfs_dir);
 709
 710         kfree(priv->dbgfs_entries);
 711 }
 712
 713 void mvpp2_dbgfs_init(struct mvpp2 *priv, const char *name)
 714 {
 715         struct dentry *mvpp2_dir, *mvpp2_root;
 716         int ret, i;
 717
 718         mvpp2_root = debugfs_lookup(MVPP2_DRIVER_NAME, NULL);
 719         if (!mvpp2_root) {
 720                 mvpp2_root = debugfs_create_dir(MVPP2_DRIVER_NAME, NULL);
 721                 if (IS_ERR(mvpp2_root))
 722                         return;
 723         }
 724
 725         mvpp2_dir = debugfs_create_dir(name, mvpp2_root);
 726         if (IS_ERR(mvpp2_dir))
 727                 return;
 728
 729         priv->dbgfs_dir = mvpp2_dir;
 730         priv->dbgfs_entries = kzalloc(sizeof(*priv->dbgfs_entries), GFP_KERNEL);
 731         if (!priv->dbgfs_entries)
 732                 goto err;
 733
 734         ret = mvpp2_dbgfs_prs_init(mvpp2_dir, priv);
 735         if (ret)
 736                 goto err;
 737
 738         ret = mvpp2_dbgfs_cls_init(mvpp2_dir, priv);
 739         if (ret)
 740                 goto err;
 741
 742         for (i = 0; i < priv->port_count; i++) {
 743                 ret = mvpp2_dbgfs_port_init(mvpp2_dir, priv->port_list[i]);
 744                 if (ret)
 745                         goto err;
 746         }
 747
 748         ret = mvpp2_dbgfs_flow_init(mvpp2_dir, priv);
 749         if (ret)
 750                 goto err;
 751
 752         return;
 753 err:
 754         mvpp2_dbgfs_cleanup(priv);
 755 }