target/linux/mediatek/files-5.4/drivers/net/phy/rtk/rtl8367s_dbg.c

   1 #include <linux/uaccess.h>
   2 #include <linux/trace_seq.h>
   3 #include <linux/seq_file.h>
   4 #include <linux/proc_fs.h>
   5 #include <linux/u64_stats_sync.h>
   6
   7 #include  "./rtl8367c/include/rtk_switch.h"
   8 #include  "./rtl8367c/include/port.h"
   9 #include  "./rtl8367c/include/vlan.h"
  10 #include  "./rtl8367c/include/rtl8367c_asicdrv_port.h"
  11 #include  "./rtl8367c/include/stat.h"
  12 #include  "./rtl8367c/include/l2.h"
  13 #include  "./rtl8367c/include/smi.h"
  14 #include  "./rtl8367c/include/mirror.h"
  15 #include  "./rtl8367c/include/igmp.h"
  16 #include  "./rtl8367c/include/leaky.h"
  17
  18 static struct proc_dir_entry *proc_reg_dir;
  19 static struct proc_dir_entry *proc_esw_cnt;
  20 static struct proc_dir_entry *proc_vlan_cnt;
  21 static struct proc_dir_entry *proc_mac_tbl;
  22 static struct proc_dir_entry *proc_reg;
  23 static struct proc_dir_entry *proc_phyreg;
  24 static struct proc_dir_entry *proc_mirror;
  25 static struct proc_dir_entry *proc_igmp;
  26
  27 #define PROCREG_ESW_CNT         "esw_cnt"
  28 #define PROCREG_VLAN            "vlan"
  29 #define PROCREG_MAC_TBL            "mac_tbl"
  30 #define PROCREG_REG            "reg"
  31 #define PROCREG_PHYREG            "phyreg"
  32 #define PROCREG_MIRROR            "mirror"
  33 #define PROCREG_IGMP            "igmp"
  34 #define PROCREG_DIR             "rtk_gsw"
  35
  36 #define RTK_SW_VID_RANGE        16
  37
  38 static void rtk_dump_mib_type(rtk_stat_port_type_t cntr_idx)
  39 {
  40         rtk_port_t port;
  41         rtk_stat_counter_t Cntr;
  42
  43         for (port = UTP_PORT0; port < (UTP_PORT0 + 5); port++) {
  44                 rtk_stat_port_get(port, cntr_idx, &Cntr);
  45                 printk("%8llu", Cntr);
  46         }
  47
  48         for (port = EXT_PORT0; port < (EXT_PORT0 + 2); port++) {
  49                 rtk_stat_port_get(port, cntr_idx, &Cntr);
  50                 printk("%8llu", Cntr);
  51         }
  52
  53         printk("\n");
  54 }
  55 static void rtk_hal_dump_mib(void)
  56 {
  57
  58         printk("==================%8s%8s%8s%8s%8s%8s%8s\n", "Port0", "Port1",
  59                "Port2", "Port3", "Port4", "Port16", "Port17");
  60         /* Get TX Unicast Pkts */
  61         printk("TX Unicast Pkts  :");
  62         rtk_dump_mib_type(STAT_IfOutUcastPkts);
  63         /* Get TX Multicast Pkts */
  64         printk("TX Multicast Pkts:");
  65         rtk_dump_mib_type(STAT_IfOutMulticastPkts);
  66         /* Get TX BroadCast Pkts */
  67         printk("TX BroadCast Pkts:");
  68         rtk_dump_mib_type(STAT_IfOutBroadcastPkts);
  69         /* Get TX Collisions */
  70         /* Get TX Puase Frames */
  71         printk("TX Pause Frames  :");
  72         rtk_dump_mib_type(STAT_Dot3OutPauseFrames);
  73         /* Get TX Drop Events */
  74         /* Get RX Unicast Pkts */
  75         printk("RX Unicast Pkts  :");
  76         rtk_dump_mib_type(STAT_IfInUcastPkts);
  77         /* Get RX Multicast Pkts */
  78         printk("RX Multicast Pkts:");
  79         rtk_dump_mib_type(STAT_IfInMulticastPkts);
  80         /* Get RX Broadcast Pkts */
  81         printk("RX Broadcast Pkts:");
  82         rtk_dump_mib_type(STAT_IfInBroadcastPkts);
  83         /* Get RX FCS Erros */
  84         printk("RX FCS Errors    :");
  85         rtk_dump_mib_type(STAT_Dot3StatsFCSErrors);
  86         /* Get RX Undersize Pkts */
  87         printk("RX Undersize Pkts:");
  88         rtk_dump_mib_type(STAT_EtherStatsUnderSizePkts);
  89         /* Get RX Discard Pkts */
  90         printk("RX Discard Pkts  :");
  91         rtk_dump_mib_type(STAT_Dot1dTpPortInDiscards);
  92         /* Get RX Fragments */
  93         printk("RX Fragments     :");
  94         rtk_dump_mib_type(STAT_EtherStatsFragments);
  95         /* Get RX Oversize Pkts */
  96         printk("RX Oversize Pkts :");
  97         rtk_dump_mib_type(STAT_EtherOversizeStats);
  98         /* Get RX Jabbers */
  99         printk("RX Jabbers       :");
 100         rtk_dump_mib_type(STAT_EtherStatsJabbers);
 101         /* Get RX Pause Frames */
 102         printk("RX Pause Frames  :");
 103         rtk_dump_mib_type(STAT_Dot3InPauseFrames);
 104         /* clear MIB */
 105         rtk_stat_global_reset();
 106
 107 }
 108
 109 static int rtk_hal_dump_vlan(void)
 110 {
 111         rtk_vlan_cfg_t vlan;
 112         int i;
 113
 114         printk("vid    portmap\n");
 115         for (i = 0; i < RTK_SW_VID_RANGE; i++) {
 116                 rtk_vlan_get(i, &vlan);
 117                 printk("%3d    ", i);
 118                 printk("%c",
 119                        RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 120                                         UTP_PORT0) ? '1' : '-');
 121                 printk("%c",
 122                 RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 123                                         UTP_PORT1) ? '1' : '-');
 124                 printk("%c",
 125                        RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 126                                         UTP_PORT2) ? '1' : '-');
 127                 printk("%c",
 128                        RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 129                                         UTP_PORT3) ? '1' : '-');
 130                 printk("%c",
 131                 RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 132                                         UTP_PORT4) ? '1' : '-');
 133                 printk("%c",
 134                        RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 135                                         EXT_PORT0) ? '1' : '-');
 136                 printk("%c",
 137                        RTK_PORTMASK_IS_PORT_SET(vlan.mbr,
 138                                         EXT_PORT1) ? '1' : '-');
 139                 printk("\n");
 140         }
 141
 142         return 0;
 143 }
 144
 145 static void rtk_hal_dump_table(void)
 146 {
 147         rtk_uint32 i;
 148         rtk_uint32 address = 0;
 149         rtk_l2_ucastAddr_t l2_data;
 150         rtk_l2_ipMcastAddr_t ipMcastAddr;
 151         rtk_l2_age_time_t age_timout;
 152
 153         rtk_l2_aging_get(&age_timout);
 154         printk("Mac table age timeout =%d\n",(unsigned int)age_timout);
 155
 156         printk("hash  port(0:17)   fid   vid  mac-address\n");
 157         while (1) {
 158                 if (rtk_l2_addr_next_get(READMETHOD_NEXT_L2UC, UTP_PORT0, &address, &l2_data) != RT_ERR_OK) {
 159                         break;
 160                 } else {
 161                         printk("%03x   ", l2_data.address);
 162                         for (i = 0; i < 5; i++)
 163                                 if ( l2_data.port == i)
 164                                         printk("1");
 165                                 else
 166                                         printk("-");
 167                         for (i = 16; i < 18; i++)
 168                                 if ( l2_data.port == i)
 169                                         printk("1");
 170                                 else
 171                                         printk("-");
 172
 173                         printk("      %2d", l2_data.fid);
 174                         printk("  %4d", l2_data.cvid);
 175                         printk("  %02x%02x%02x%02x%02x%02x\n", l2_data.mac.octet[0],
 176                         l2_data.mac.octet[1], l2_data.mac.octet[2], l2_data.mac.octet[3],
 177                         l2_data.mac.octet[4], l2_data.mac.octet[5]);
 178                         address ++;
 179                         }
 180         }
 181
 182         address = 0;
 183         while (1) {
 184         if (rtk_l2_ipMcastAddr_next_get(&address, &ipMcastAddr) != RT_ERR_OK) {
 185             break;
 186         } else {
 187             printk("%03x   ", ipMcastAddr.address);
 188             for (i = 0; i < 5; i++)
 189                 printk("%c", RTK_PORTMASK_IS_PORT_SET(ipMcastAddr.portmask, i) ? '1' : '-');
 190             for (i = 16; i < 18; i++)
 191                 printk("%c", RTK_PORTMASK_IS_PORT_SET(ipMcastAddr.portmask, i) ? '1' : '-');
 192                         printk("                ");
 193                         printk("01005E%06x\n", (ipMcastAddr.dip & 0xefffff));
 194             address ++;
 195             }
 196     }
 197 }
 198
 199 static void rtk_hal_clear_table(void)
 200 {
 201         rtk_api_ret_t ret;
 202
 203         ret = rtk_l2_table_clear();
 204         if (ret != RT_ERR_OK)
 205                 printk("rtk_l2_table_clear failed\n");
 206 }
 207
 208 static void rtk_hal_read_reg(unsigned int reg_addr)
 209 {
 210         ret_t retVal;
 211          unsigned int reg_val;
 212
 213         retVal = smi_read(reg_addr, &reg_val);
 214
 215         if(retVal != RT_ERR_OK)
 216                 printk("switch reg read failed\n");
 217         else
 218                 printk("reg0x%x = 0x%x\n", reg_addr, reg_val);
 219 }
 220
 221 static void rtk_hal_write_reg(unsigned int reg_addr , unsigned int reg_val)
 222 {
 223         ret_t retVal;
 224
 225     retVal = smi_write(reg_addr, reg_val);
 226
 227     if(retVal != RT_ERR_OK)
 228         printk("switch reg write failed\n");
 229     else
 230         printk("write switch reg0x%x 0x%x success\n", reg_addr, reg_val);
 231 }
 232
 233 static void rtk_hal_get_phy_reg(unsigned int port ,unsigned int reg_addr )
 234 {
 235         ret_t retVal;
 236         rtk_port_phy_data_t Data;
 237
 238         retVal = rtk_port_phyReg_get(port, reg_addr, &Data);
 239         if (retVal == RT_ERR_OK)
 240                 printk("Get: phy[%d].reg[%d] = 0x%04x\n", port, reg_addr, Data);
 241         else
 242                 printk("read phy reg failed\n");
 243 }
 244
 245 static void rtk_hal_set_phy_reg(unsigned int port ,unsigned int reg_addr,unsigned int reg_val)
 246 {
 247         ret_t retVal;
 248
 249         retVal = rtk_port_phyReg_set(port, reg_addr, reg_val);
 250         if (retVal == RT_ERR_OK)
 251                 printk("Set: phy[%d].reg[%d] = 0x%04x\n", port, reg_addr, reg_val);
 252         else
 253                 printk("write phy reg failed\n");
 254 }
 255
 256 static void rtk_hal_set_port_mirror(unsigned int port ,unsigned int rx_port_map,unsigned int tx_port_map)
 257 {
 258         rtk_portmask_t rx_portmask;
 259         rtk_portmask_t tx_portmask;
 260         rtk_api_ret_t ret;
 261         int i;
 262
 263         rtk_mirror_portIso_set(ENABLED);
 264         RTK_PORTMASK_CLEAR(rx_portmask);
 265         RTK_PORTMASK_CLEAR(tx_portmask);
 266
 267         for (i = 0; i < 5; i++)
 268                 if (rx_port_map & (1 << i))
 269                         RTK_PORTMASK_PORT_SET(rx_portmask, i);
 270
 271         for (i = 0; i < 2; i++)
 272                 if (rx_port_map & (1 << (i + 5)))
 273                         RTK_PORTMASK_PORT_SET(rx_portmask, (i + EXT_PORT0));
 274
 275         RTK_PORTMASK_CLEAR(tx_portmask);
 276
 277         for (i = 0; i < 5; i++)
 278                 if (tx_port_map & (1 << i))
 279                            RTK_PORTMASK_PORT_SET(tx_portmask, i);
 280
 281         for (i = 0; i < 2; i++)
 282                 if (tx_port_map & (1 << (i + 5)))
 283                         RTK_PORTMASK_PORT_SET(tx_portmask, (i + EXT_PORT0));
 284
 285         ret = rtk_mirror_portBased_set(port, &rx_portmask, &tx_portmask);
 286
 287         if (!ret)
 288                 printk("rtk_mirror_portBased_set success\n");
 289
 290 }
 291
 292 static void rtk_hal_enable_igmpsnoop(int hw_on)
 293 {
 294         rtk_api_ret_t ret;
 295         rtk_portmask_t pmask;
 296
 297         ret = rtk_igmp_init();
 298         if (hw_on == 1) {
 299                 RTK_PORTMASK_CLEAR(pmask);
 300                 RTK_PORTMASK_PORT_SET(pmask, EXT_PORT0);
 301                 ret |= rtk_igmp_static_router_port_set(&pmask);
 302                 ret |= rtk_igmp_protocol_set(UTP_PORT4, PROTOCOL_IGMPv1, IGMP_ACTION_FORWARD);
 303                 ret |= rtk_igmp_protocol_set(UTP_PORT4, PROTOCOL_IGMPv2, IGMP_ACTION_FORWARD);
 304                 ret |= rtk_igmp_protocol_set(UTP_PORT4, PROTOCOL_MLDv1, IGMP_ACTION_FORWARD);
 305                 ret |= rtk_igmp_protocol_set(EXT_PORT1, PROTOCOL_IGMPv1, IGMP_ACTION_FORWARD);
 306                 ret |= rtk_igmp_protocol_set(EXT_PORT1, PROTOCOL_IGMPv2, IGMP_ACTION_FORWARD);
 307                 ret |= rtk_igmp_protocol_set(EXT_PORT1, PROTOCOL_MLDv1, IGMP_ACTION_FORWARD);
 308                 ret |= rtk_igmp_protocol_set(UTP_PORT0, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 309                 ret |= rtk_igmp_protocol_set(UTP_PORT1, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 310                 ret |= rtk_igmp_protocol_set(UTP_PORT2, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 311                 ret |= rtk_igmp_protocol_set(UTP_PORT3, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 312                 ret |= rtk_igmp_protocol_set(EXT_PORT0, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 313
 314                 ret |= rtk_leaky_vlan_set(LEAKY_IPMULTICAST, ENABLED);
 315                 ret |= rtk_l2_ipMcastForwardRouterPort_set(DISABLED);
 316                 /* drop unknown multicast packets*/
 317                 /* ret |= rtk_trap_unknownMcastPktAction_set(UTP_PORT4, MCAST_IPV4, MCAST_ACTION_DROP);*/
 318         } else {
 319                 RTK_PORTMASK_CLEAR(pmask);
 320                 RTK_PORTMASK_PORT_SET(pmask, EXT_PORT0);
 321                 RTK_PORTMASK_PORT_SET(pmask, EXT_PORT1);
 322                 ret |= rtk_igmp_protocol_set(UTP_PORT0, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 323                 ret |= rtk_igmp_protocol_set(UTP_PORT1, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 324                 ret |= rtk_igmp_protocol_set(UTP_PORT2, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 325                 ret |= rtk_igmp_protocol_set(UTP_PORT3, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 326                 ret |= rtk_igmp_protocol_set(EXT_PORT0, PROTOCOL_IGMPv3, IGMP_ACTION_ASIC);
 327
 328                 ret |= rtk_igmp_static_router_port_set(&pmask);
 329         }
 330
 331         if(ret != RT_ERR_OK)
 332                 printk("enable switch igmpsnoop failed\n");
 333
 334 }
 335
 336 static void rtk_hal_disable_igmpsnoop(void)
 337 {
 338         if (rtk_igmp_state_set(DISABLED) != RT_ERR_OK)
 339                 printk("Disable IGMP SNOOPING failed\n");
 340 }
 341
 342 static ssize_t mac_tbl_write(struct file *file,
 343                             const char __user *buffer, size_t count,
 344                             loff_t *data)
 345 {
 346         rtk_hal_clear_table();
 347
 348         return count;
 349 }
 350
 351
 352 static ssize_t phyreg_ops(struct file *file,
 353                             const char __user *buffer, size_t count,
 354                             loff_t *data)
 355 {
 356         char buf[64];
 357          unsigned int port;
 358         unsigned int offset;
 359         unsigned int val;
 360
 361         memset(buf, 0, 64);
 362
 363         if (copy_from_user(buf, buffer, count))
 364                 return -EFAULT;
 365
 366
 367         if(buf[0] == 'w') {
 368
 369                 if(sscanf(buf, "w %d %x %x", &port,&offset,&val) == -1)
 370                         return -EFAULT;
 371                 else
 372                         rtk_hal_set_phy_reg(port,offset,val);
 373
 374         } else {
 375
 376                 if(sscanf(buf, "r %d %x",&port, &offset) == -1)
 377                         return -EFAULT;
 378                 else
 379                         rtk_hal_get_phy_reg(port,offset);
 380         }
 381
 382         return count;
 383 }
 384
 385 static ssize_t reg_ops(struct file *file,
 386                             const char __user *buffer, size_t count,
 387                             loff_t *data)
 388 {
 389         char buf[64];
 390         unsigned int offset;
 391         unsigned int val;
 392
 393         memset(buf, 0, 64);
 394
 395         if (copy_from_user(buf, buffer, count))
 396                 return -EFAULT;
 397
 398
 399         if(buf[0] == 'w') {
 400
 401                 if(sscanf(buf, "w %x %x", &offset,&val) == -1)
 402                         return -EFAULT;
 403                 else
 404                         rtk_hal_write_reg(offset,val);
 405
 406         } else {
 407
 408                 if(sscanf(buf, "r %x", &offset) == -1)
 409                         return -EFAULT;
 410                 else
 411                         rtk_hal_read_reg(offset);
 412         }
 413
 414         return count;
 415 }
 416
 417 static ssize_t mirror_ops(struct file *file,
 418                             const char __user *buffer, size_t count,
 419                             loff_t *data)
 420 {
 421         char buf[64];
 422          unsigned int port;
 423         unsigned int tx_map,rx_map;
 424
 425         memset(buf, 0, 64);
 426
 427         if (copy_from_user(buf, buffer, count))
 428                 return -EFAULT;
 429
 430         if(sscanf(buf, "%d %x %x", &port,&rx_map,&tx_map) == -1)
 431                 return -EFAULT;
 432         else
 433                 rtk_hal_set_port_mirror(port,rx_map,tx_map);
 434
 435         return count;
 436 }
 437
 438
 439 static ssize_t igmp_ops(struct file *file,
 440                             const char __user *buffer, size_t count,
 441                             loff_t *data)
 442 {
 443         char buf[8];
 444         unsigned int ops;
 445
 446         if (copy_from_user(buf, buffer, count))
 447                 return -EFAULT;
 448
 449         if(sscanf(buf, "%d", &ops) == -1)
 450                 return -EFAULT;
 451
 452         if(ops == 0)
 453                 rtk_hal_disable_igmpsnoop();
 454         else if (ops == 1)
 455                 rtk_hal_enable_igmpsnoop(0);
 456         else //hw igmp
 457                 rtk_hal_enable_igmpsnoop(1);
 458
 459         return count;
 460 }
 461
 462
 463 static int esw_cnt_read(struct seq_file *seq, void *v)
 464 {
 465         rtk_hal_dump_mib();
 466         return 0;
 467 }
 468
 469 static int vlan_read(struct seq_file *seq, void *v)
 470 {
 471         rtk_hal_dump_vlan();
 472         return 0;
 473 }
 474
 475 static int mac_tbl_read(struct seq_file *seq, void *v)
 476 {
 477         rtk_hal_dump_table();
 478         return 0;
 479 }
 480
 481 static int reg_show(struct seq_file *seq, void *v)
 482 {
 483         return 0;
 484 }
 485
 486 static int phyreg_show(struct seq_file *seq, void *v)
 487 {
 488         return 0;
 489 }
 490
 491 static int mirror_show(struct seq_file *seq, void *v)
 492 {
 493         return 0;
 494 }
 495
 496 static int igmp_show(struct seq_file *seq, void *v)
 497 {
 498         return 0;
 499 }
 500
 501 static int switch_count_open(struct inode *inode, struct file *file)
 502 {
 503         return single_open(file, esw_cnt_read, 0);
 504 }
 505
 506 static int switch_vlan_open(struct inode *inode, struct file *file)
 507 {
 508         return single_open(file, vlan_read, 0);
 509 }
 510
 511 static int mac_tbl_open(struct inode *inode, struct file *file)
 512 {
 513         return single_open(file, mac_tbl_read, 0);
 514 }
 515
 516 static int reg_open(struct inode *inode, struct file *file)
 517 {
 518         return single_open(file, reg_show, 0);
 519 }
 520
 521 static int phyreg_open(struct inode *inode, struct file *file)
 522 {
 523         return single_open(file, phyreg_show, 0);
 524 }
 525
 526 static int mirror_open(struct inode *inode, struct file *file)
 527 {
 528         return single_open(file, mirror_show, 0);
 529 }
 530
 531 static int igmp_open(struct inode *inode, struct file *file)
 532 {
 533         return single_open(file, igmp_show, 0);
 534 }
 535
 536
 537 static const struct file_operations switch_count_fops = {
 538         .owner = THIS_MODULE,
 539         .open = switch_count_open,
 540         .read = seq_read,
 541         .llseek = seq_lseek,
 542         .release = single_release
 543 };
 544
 545 static const struct file_operations switch_vlan_fops = {
 546         .owner = THIS_MODULE,
 547         .open = switch_vlan_open,
 548         .read = seq_read,
 549         .llseek = seq_lseek,
 550         .release = single_release
 551 };
 552
 553 static const struct file_operations mac_tbl_fops = {
 554         .owner = THIS_MODULE,
 555         .open = mac_tbl_open,
 556         .read = seq_read,
 557         .llseek = seq_lseek,
 558         .write = mac_tbl_write,
 559         .release = single_release
 560 };
 561
 562 static const struct file_operations reg_fops = {
 563         .owner = THIS_MODULE,
 564         .open = reg_open,
 565         .read = seq_read,
 566         .llseek = seq_lseek,
 567         .write = reg_ops,
 568         .release = single_release
 569 };
 570
 571 static const struct file_operations phyreg_fops = {
 572         .owner = THIS_MODULE,
 573         .open = phyreg_open,
 574         .read = seq_read,
 575         .llseek = seq_lseek,
 576         .write = phyreg_ops,
 577         .release = single_release
 578 };
 579
 580 static const struct file_operations mirror_fops = {
 581         .owner = THIS_MODULE,
 582         .open = mirror_open,
 583         .read = seq_read,
 584         .llseek = seq_lseek,
 585         .write = mirror_ops,
 586         .release = single_release
 587 };
 588
 589 static const struct file_operations igmp_fops = {
 590         .owner = THIS_MODULE,
 591         .open = igmp_open,
 592         .read = seq_read,
 593         .llseek = seq_lseek,
 594         .write = igmp_ops,
 595         .release = single_release
 596 };
 597
 598 int gsw_debug_proc_init(void)
 599 {
 600
 601         if (!proc_reg_dir)
 602                 proc_reg_dir = proc_mkdir(PROCREG_DIR, NULL);
 603
 604         proc_esw_cnt =
 605         proc_create(PROCREG_ESW_CNT, 0, proc_reg_dir, &switch_count_fops);
 606
 607         if (!proc_esw_cnt)
 608                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_ESW_CNT);
 609
 610         proc_vlan_cnt =
 611         proc_create(PROCREG_VLAN, 0, proc_reg_dir, &switch_vlan_fops);
 612
 613         if (!proc_vlan_cnt)
 614                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_VLAN);
 615
 616         proc_mac_tbl =
 617         proc_create(PROCREG_MAC_TBL, 0, proc_reg_dir, &mac_tbl_fops);
 618
 619         if (!proc_mac_tbl)
 620                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_MAC_TBL);
 621
 622         proc_reg =
 623         proc_create(PROCREG_REG, 0, proc_reg_dir, &reg_fops);
 624
 625         if (!proc_reg)
 626                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_REG);
 627
 628         proc_phyreg =
 629         proc_create(PROCREG_PHYREG, 0, proc_reg_dir, &phyreg_fops);
 630
 631         if (!proc_phyreg)
 632                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_PHYREG);
 633
 634         proc_mirror =
 635         proc_create(PROCREG_MIRROR, 0, proc_reg_dir, &mirror_fops);
 636
 637         if (!proc_mirror)
 638                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_MIRROR);
 639
 640         proc_igmp =
 641         proc_create(PROCREG_IGMP, 0, proc_reg_dir, &igmp_fops);
 642
 643         if (!proc_igmp)
 644                 pr_err("!! FAIL to create %s PROC !!\n", PROCREG_IGMP);
 645
 646         return 0;
 647 }
 648
 649 void gsw_debug_proc_exit(void)
 650 {
 651         if (proc_esw_cnt)
 652                 remove_proc_entry(PROCREG_ESW_CNT, proc_reg_dir);
 653 }
 654
 655