/******************************************************************************/
/*                                                                            */
/* Copyright (c) 2004-2006 Silicom, Ltd                                       */
/* All rights reserved.                                                       */
/*                                                                            */
/* This program is free software; you can redistribute it and/or modify       */
/* it under the terms of the GNU General Public License as published by       */
/* the Free Software Foundation, located in the file LICENSE.                 */
/*                                                                            */
/*                                                                            */
/******************************************************************************/

#include <linux/version.h>
#if defined(CONFIG_SMP) && ! defined(__SMP__)
#define __SMP__
#endif

#include <linux/proc_fs.h>
#include <linux/netdevice.h>
#include <asm/uaccess.h>
//#include <linux/smp_lock.h>
#include "bp_mod.h"

#define BP_PROC_DIR "bypass"
//#define BYPASS_SUPPORT "bypass"

#ifdef  BYPASS_SUPPORT

#define GPIO6_SET_ENTRY_SD           "gpio6_set"
#define GPIO6_CLEAR_ENTRY_SD         "gpio6_clear"

#define GPIO7_SET_ENTRY_SD           "gpio7_set"
#define GPIO7_CLEAR_ENTRY_SD         "gpio7_clear"

#define PULSE_SET_ENTRY_SD            "pulse_set"
#define ZERO_SET_ENTRY_SD            "zero_set"
#define PULSE_GET1_ENTRY_SD            "pulse_get1"
#define PULSE_GET2_ENTRY_SD            "pulse_get2"

#define CMND_ON_ENTRY_SD              "cmnd_on"
#define CMND_OFF_ENTRY_SD             "cmnd_off"
#define RESET_CONT_ENTRY_SD           "reset_cont"

 /*COMMANDS*/
#define BYPASS_INFO_ENTRY_SD     "bypass_info"
#define BYPASS_SLAVE_ENTRY_SD    "bypass_slave"
#define BYPASS_CAPS_ENTRY_SD     "bypass_caps"
#define WD_SET_CAPS_ENTRY_SD     "wd_set_caps"
#define BYPASS_ENTRY_SD          "bypass"
#define BYPASS_CHANGE_ENTRY_SD   "bypass_change"
#define BYPASS_WD_ENTRY_SD       "bypass_wd"
#define WD_EXPIRE_TIME_ENTRY_SD  "wd_expire_time"
#define RESET_BYPASS_WD_ENTRY_SD "reset_bypass_wd"
#define DIS_BYPASS_ENTRY_SD      "dis_bypass"
#define BYPASS_PWUP_ENTRY_SD     "bypass_pwup"
#define BYPASS_PWOFF_ENTRY_SD     "bypass_pwoff"
#define STD_NIC_ENTRY_SD         "std_nic"
#define STD_NIC_ENTRY_SD         "std_nic"
#define TAP_ENTRY_SD             "tap"
#define TAP_CHANGE_ENTRY_SD      "tap_change"
#define DIS_TAP_ENTRY_SD         "dis_tap"
#define TAP_PWUP_ENTRY_SD        "tap_pwup"
#define TWO_PORT_LINK_ENTRY_SD   "two_port_link"
#define WD_EXP_MODE_ENTRY_SD     "wd_exp_mode"
#define WD_AUTORESET_ENTRY_SD    "wd_autoreset"
#define TPL_ENTRY_SD             "tpl"
#define WAIT_AT_PWUP_ENTRY_SD    "wait_at_pwup"
#define HW_RESET_ENTRY_SD        "hw_reset"
#define DISC_ENTRY_SD             "disc"
#define DISC_CHANGE_ENTRY_SD      "disc_change"
#define DIS_DISC_ENTRY_SD         "dis_disc"
#define DISC_PWUP_ENTRY_SD        "disc_pwup"
#endif				//bypass_support
static struct proc_dir_entry *bp_procfs_dir;

static struct proc_dir_entry *proc_getdir(char *name,
					  struct proc_dir_entry *proc_dir)
{
	struct proc_dir_entry *pde = proc_dir;
	for (pde = pde->subdir; pde; pde = pde->next) {
		if (pde->namelen && (strcmp(name, pde->name) == 0)) {
			/* directory exists */
			break;
		}
	}
	if (pde == (struct proc_dir_entry *)0) {
		/* create the directory */
		pde = create_proc_entry(name, S_IFDIR, proc_dir);
		if (pde == (struct proc_dir_entry *)0) {
			return (pde);
		}
	}
	return (pde);
}

#ifdef BYPASS_SUPPORT

int
bypass_proc_create_entry_sd(struct pfs_unit *pfs_unit_curr,
			    char *proc_name,
			    write_proc_t * write_proc,
			    read_proc_t * read_proc,
			    struct proc_dir_entry *parent_pfs, void *data)
{
	strcpy(pfs_unit_curr->proc_name, proc_name);
	pfs_unit_curr->proc_entry = create_proc_entry(pfs_unit_curr->proc_name,
						      S_IFREG | S_IRUSR |
						      S_IWUSR | S_IRGRP |
						      S_IROTH, parent_pfs);
	if (pfs_unit_curr->proc_entry == 0) {

		return -1;
	}

	pfs_unit_curr->proc_entry->read_proc = read_proc;
	pfs_unit_curr->proc_entry->write_proc = write_proc;
	pfs_unit_curr->proc_entry->data = data;

	return 0;

}

int
get_bypass_info_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
	int len = 0;

	len += sprintf(page, "Name\t\t\t%s\n", pbp_device_block->bp_name);
	len +=
	    sprintf(page + len, "Firmware version\t0x%x\n",
		    pbp_device_block->bp_fw_ver);

	*eof = 1;
	return len;
}

int
get_bypass_slave_pfs(char *page, char **start, off_t off, int count,
		     int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	struct pci_dev *pci_slave_dev = pbp_device_block->bp_slave;
	struct net_device *net_slave_dev;
	int len = 0;

	if (is_bypass_fn(pbp_device_block)) {
		net_slave_dev = pci_get_drvdata(pci_slave_dev);
		if (net_slave_dev)
			len = sprintf(page, "%s\n", net_slave_dev->name);
		else
			len = sprintf(page, "fail\n");
	} else
		len = sprintf(page, "fail\n");

	*eof = 1;
	return len;
}

int
get_bypass_caps_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bypass_caps_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "-1\n");
	else
		len = sprintf(page, "0x%x\n", ret);
	*eof = 1;
	return len;

}

int
get_wd_set_caps_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_wd_set_caps_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "-1\n");
	else
		len = sprintf(page, "0x%x\n", ret);
	*eof = 1;
	return len;
}

int
set_bypass_pfs(struct file *file, const char *buffer,
	       unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int bypass_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		bypass_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		bypass_param = 0;

	set_bypass_fn(pbp_device_block, bypass_param);

	return count;
}

int
set_tap_pfs(struct file *file, const char *buffer,
	    unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tap_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tap_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tap_param = 0;

	set_tap_fn(pbp_device_block, tap_param);

	return count;
}

int
set_disc_pfs(struct file *file, const char *buffer,
	     unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tap_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tap_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tap_param = 0;

	set_disc_fn(pbp_device_block, tap_param);

	return count;
}

int
get_bypass_pfs(char *page, char **start, off_t off, int count,
	       int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bypass_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");

	*eof = 1;
	return len;
}

int
get_tap_pfs(char *page, char **start, off_t off, int count,
	    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_tap_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");

	*eof = 1;
	return len;
}

int
get_disc_pfs(char *page, char **start, off_t off, int count,
	     int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_disc_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");

	*eof = 1;
	return len;
}

int
get_bypass_change_pfs(char *page, char **start, off_t off, int count,
		      int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bypass_change_fn(pbp_device_block);
	if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "fail\n");

	*eof = 1;
	return len;
}

int
get_tap_change_pfs(char *page, char **start, off_t off, int count,
		   int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_tap_change_fn(pbp_device_block);
	if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "fail\n");

	*eof = 1;
	return len;
}

int
get_disc_change_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_disc_change_fn(pbp_device_block);
	if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "fail\n");

	*eof = 1;
	return len;
}

int
set_bypass_wd_pfs(struct file *file, const char *buffer,
		  unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	unsigned int timeout = 0;
	char *timeout_ptr = kbuf;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	timeout_ptr = kbuf;
	timeout = atoi(&timeout_ptr);

	set_bypass_wd_fn(pbp_device_block, timeout);

	return count;
}

int
get_bypass_wd_pfs(char *page, char **start, off_t off, int count,
		  int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0, timeout = 0;

	ret = get_bypass_wd_fn(pbp_device_block, &timeout);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (timeout == -1)
		len = sprintf(page, "unknown\n");
	else if (timeout == 0)
		len = sprintf(page, "disable\n");
	else
		len = sprintf(page, "%d\n", timeout);

	*eof = 1;
	return len;
}

int
get_wd_expire_time_pfs(char *page, char **start, off_t off, int count,
		       int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0, timeout = 0;

	ret = get_wd_expire_time_fn(pbp_device_block, &timeout);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (timeout == -1)
		len = sprintf(page, "expire\n");
	else if (timeout == 0)
		len = sprintf(page, "disable\n");

	else
		len = sprintf(page, "%d\n", timeout);
	*eof = 1;
	return len;
}

int
get_tpl_pfs(char *page, char **start, off_t off, int count,
	    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_tpl_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");

	*eof = 1;
	return len;
}

#ifdef PMC_FIX_FLAG
int
get_wait_at_pwup_pfs(char *page, char **start, off_t off, int count,
		     int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bp_wait_at_pwup_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");

	*eof = 1;
	return len;
}

int
get_hw_reset_pfs(char *page, char **start, off_t off, int count,
		 int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bp_hw_reset_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 1)
		len = sprintf(page, "on\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");

	*eof = 1;
	return len;
}

#endif				/*PMC_WAIT_FLAG */

int
reset_bypass_wd_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = reset_bypass_wd_timer_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "disable\n");
	else if (ret == 1)
		len = sprintf(page, "success\n");

	*eof = 1;
	return len;
}

int
set_dis_bypass_pfs(struct file *file, const char *buffer,
		   unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int bypass_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		bypass_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		bypass_param = 0;

	set_dis_bypass_fn(pbp_device_block, bypass_param);

	return count;
}

int
set_dis_tap_pfs(struct file *file, const char *buffer,
		unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tap_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tap_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tap_param = 0;

	set_dis_tap_fn(pbp_device_block, tap_param);

	return count;
}

int
set_dis_disc_pfs(struct file *file, const char *buffer,
		 unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tap_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tap_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tap_param = 0;

	set_dis_disc_fn(pbp_device_block, tap_param);

	return count;
}

int
get_dis_bypass_pfs(char *page, char **start, off_t off, int count,
		   int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_dis_bypass_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
get_dis_tap_pfs(char *page, char **start, off_t off, int count,
		int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_dis_tap_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
get_dis_disc_pfs(char *page, char **start, off_t off, int count,
		 int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_dis_disc_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
set_bypass_pwup_pfs(struct file *file, const char *buffer,
		    unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int bypass_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		bypass_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		bypass_param = 0;

	set_bypass_pwup_fn(pbp_device_block, bypass_param);

	return count;
}

int
set_bypass_pwoff_pfs(struct file *file, const char *buffer,
		     unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int bypass_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		bypass_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		bypass_param = 0;

	set_bypass_pwoff_fn(pbp_device_block, bypass_param);

	return count;
}

int
set_tap_pwup_pfs(struct file *file, const char *buffer,
		 unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tap_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tap_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tap_param = 0;

	set_tap_pwup_fn(pbp_device_block, tap_param);

	return count;
}

int
set_disc_pwup_pfs(struct file *file, const char *buffer,
		  unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tap_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tap_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tap_param = 0;

	set_disc_pwup_fn(pbp_device_block, tap_param);

	return count;
}

int
get_bypass_pwup_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bypass_pwup_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
get_bypass_pwoff_pfs(char *page, char **start, off_t off, int count,
		     int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_bypass_pwoff_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
get_tap_pwup_pfs(char *page, char **start, off_t off, int count,
		 int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_tap_pwup_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
get_disc_pwup_pfs(char *page, char **start, off_t off, int count,
		  int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_disc_pwup_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
set_std_nic_pfs(struct file *file, const char *buffer,
		unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int bypass_param = 0, length = 0;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		bypass_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		bypass_param = 0;

	set_std_nic_fn(pbp_device_block, bypass_param);

	return count;
}

int
get_std_nic_pfs(char *page, char **start, off_t off, int count,
		int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_std_nic_fn(pbp_device_block);
	if (ret == BP_NOT_CAP)
		len = sprintf(page, "fail\n");
	else if (ret == 0)
		len = sprintf(page, "off\n");
	else
		len = sprintf(page, "on\n");

	*eof = 1;
	return len;
}

int
get_wd_exp_mode_pfs(char *page, char **start, off_t off, int count,
		    int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_wd_exp_mode_fn(pbp_device_block);
	if (ret == 1)
		len = sprintf(page, "tap\n");
	else if (ret == 0)
		len = sprintf(page, "bypass\n");
	else if (ret == 2)
		len = sprintf(page, "disc\n");

	else
		len = sprintf(page, "fail\n");

	*eof = 1;
	return len;
}

int
set_wd_exp_mode_pfs(struct file *file, const char *buffer,
		    unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int bypass_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "tap") == 0)
		bypass_param = 1;
	else if (strcmp(kbuf, "bypass") == 0)
		bypass_param = 0;
	else if (strcmp(kbuf, "disc") == 0)
		bypass_param = 2;

	set_wd_exp_mode_fn(pbp_device_block, bypass_param);

	return count;
}

int
get_wd_autoreset_pfs(char *page, char **start, off_t off, int count,
		     int *eof, void *data)
{
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int len = 0, ret = 0;

	ret = get_wd_autoreset_fn(pbp_device_block);
	if (ret >= 0)
		len = sprintf(page, "%d\n", ret);
	else
		len = sprintf(page, "fail\n");

	*eof = 1;
	return len;
}

int
set_wd_autoreset_pfs(struct file *file, const char *buffer,
		     unsigned long count, void *data)
{
	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
	u32 timeout = 0;
	char *timeout_ptr = kbuf;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	timeout_ptr = kbuf;
	timeout = atoi(&timeout_ptr);

	set_wd_autoreset_fn(pbp_device_block, timeout);

	return count;
}

int
set_tpl_pfs(struct file *file, const char *buffer,
	    unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tpl_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tpl_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tpl_param = 0;

	set_tpl_fn(pbp_device_block, tpl_param);

	return count;
}

#ifdef PMC_FIX_FLAG
int
set_wait_at_pwup_pfs(struct file *file, const char *buffer,
		     unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tpl_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tpl_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tpl_param = 0;

	set_bp_wait_at_pwup_fn(pbp_device_block, tpl_param);

	return count;
}

int
set_hw_reset_pfs(struct file *file, const char *buffer,
		 unsigned long count, void *data)
{

	char kbuf[256];
	bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;

	int tpl_param = 0, length = 0;

	if (count > (sizeof(kbuf) - 1))
		return -1;

	if (copy_from_user(&kbuf, buffer, count)) {
		return -1;
	}

	kbuf[count] = '\0';
	length = strlen(kbuf);
	if (kbuf[length - 1] == '\n')
		kbuf[--length] = '\0';

	if (strcmp(kbuf, "on") == 0)
		tpl_param = 1;
	else if (strcmp(kbuf, "off") == 0)
		tpl_param = 0;

	set_bp_hw_reset_fn(pbp_device_block, tpl_param);

	return count;
}

#endif				/*PMC_FIX_FLAG */

int bypass_proc_create_dev_sd(bpctl_dev_t * pbp_device_block)
{
	struct bypass_pfs_sd *current_pfs = &(pbp_device_block->bypass_pfs_set);
	static struct proc_dir_entry *procfs_dir = NULL;
	int ret = 0;

	sprintf(current_pfs->dir_name, "bypass_%s", dev->name);

	if (!bp_procfs_dir)
		return -1;

	/* create device proc dir */
	procfs_dir = proc_getdir(current_pfs->dir_name, bp_procfs_dir);
	if (procfs_dir == 0) {
		printk(KERN_DEBUG "Could not create procfs directory %s\n",
		       current_pfs->dir_name);
		return -1;
	}
	current_pfs->bypass_entry = procfs_dir;

	if (bypass_proc_create_entry(&(current_pfs->bypass_info), BYPASS_INFO_ENTRY_SD, NULL,	/* write */
				     get_bypass_info_pfs,	/* read  */
				     procfs_dir, pbp_device_block))
		ret = -1;

	if (pbp_device_block->bp_caps & SW_CTL_CAP) {

		/* Create set param proc's */
		if (bypass_proc_create_entry_sd(&(current_pfs->bypass_slave), BYPASS_SLAVE_ENTRY_SD, NULL,	/* write */
						get_bypass_slave_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (bypass_proc_create_entry_sd(&(current_pfs->bypass_caps), BYPASS_CAPS_ENTRY_SD, NULL,	/* write */
						get_bypass_caps_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (bypass_proc_create_entry_sd(&(current_pfs->wd_set_caps), WD_SET_CAPS_ENTRY_SD, NULL,	/* write */
						get_wd_set_caps_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;
		if (bypass_proc_create_entry_sd(&(current_pfs->bypass_wd), BYPASS_WD_ENTRY_SD, set_bypass_wd_pfs,	/* write */
						get_bypass_wd_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (bypass_proc_create_entry_sd(&(current_pfs->wd_expire_time), WD_EXPIRE_TIME_ENTRY_SD, NULL,	/* write */
						get_wd_expire_time_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (bypass_proc_create_entry_sd(&(current_pfs->reset_bypass_wd), RESET_BYPASS_WD_ENTRY_SD, NULL,	/* write */
						reset_bypass_wd_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (bypass_proc_create_entry_sd(&(current_pfs->std_nic), STD_NIC_ENTRY_SD, set_std_nic_pfs,	/* write */
						get_std_nic_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (pbp_device_block->bp_caps & BP_CAP) {
			if (bypass_proc_create_entry_sd(&(current_pfs->bypass), BYPASS_ENTRY_SD, set_bypass_pfs,	/* write */
							get_bypass_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->dis_bypass), DIS_BYPASS_ENTRY_SD, set_dis_bypass_pfs,	/* write */
							get_dis_bypass_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->bypass_pwup), BYPASS_PWUP_ENTRY_SD, set_bypass_pwup_pfs,	/* write */
							get_bypass_pwup_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;
			if (bypass_proc_create_entry_sd(&(current_pfs->bypass_pwoff), BYPASS_PWOFF_ENTRY_SD, set_bypass_pwoff_pfs,	/* write */
							get_bypass_pwoff_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->bypass_change), BYPASS_CHANGE_ENTRY_SD, NULL,	/* write */
							get_bypass_change_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;
		}

		if (pbp_device_block->bp_caps & TAP_CAP) {

			if (bypass_proc_create_entry_sd(&(current_pfs->tap), TAP_ENTRY_SD, set_tap_pfs,	/* write */
							get_tap_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->dis_tap), DIS_TAP_ENTRY_SD, set_dis_tap_pfs,	/* write */
							get_dis_tap_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->tap_pwup), TAP_PWUP_ENTRY_SD, set_tap_pwup_pfs,	/* write */
							get_tap_pwup_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->tap_change), TAP_CHANGE_ENTRY_SD, NULL,	/* write */
							get_tap_change_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;
		}
		if (pbp_device_block->bp_caps & DISC_CAP) {

			if (bypass_proc_create_entry_sd(&(current_pfs->tap), DISC_ENTRY_SD, set_disc_pfs,	/* write */
							get_disc_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;
#if 1

			if (bypass_proc_create_entry_sd(&(current_pfs->dis_tap), DIS_DISC_ENTRY_SD, set_dis_disc_pfs,	/* write */
							get_dis_disc_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;
#endif

			if (bypass_proc_create_entry_sd(&(current_pfs->tap_pwup), DISC_PWUP_ENTRY_SD, set_disc_pwup_pfs,	/* write */
							get_disc_pwup_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;

			if (bypass_proc_create_entry_sd(&(current_pfs->tap_change), DISC_CHANGE_ENTRY_SD, NULL,	/* write */
							get_disc_change_pfs,	/* read  */
							procfs_dir,
							pbp_device_block))
				ret = -1;
		}

		if (bypass_proc_create_entry_sd(&(current_pfs->wd_exp_mode), WD_EXP_MODE_ENTRY_SD, set_wd_exp_mode_pfs,	/* write */
						get_wd_exp_mode_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

		if (bypass_proc_create_entry_sd(&(current_pfs->wd_autoreset), WD_AUTORESET_ENTRY_SD, set_wd_autoreset_pfs,	/* write */
						get_wd_autoreset_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;
		if (bypass_proc_create_entry_sd(&(current_pfs->tpl), TPL_ENTRY_SD, set_tpl_pfs,	/* write */
						get_tpl_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;
#ifdef PMC_FIX_FLAG
		if (bypass_proc_create_entry_sd(&(current_pfs->tpl), WAIT_AT_PWUP_ENTRY_SD, set_wait_at_pwup_pfs,	/* write */
						get_wait_at_pwup_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;
		if (bypass_proc_create_entry_sd(&(current_pfs->tpl), HW_RESET_ENTRY_SD, set_hw_reset_pfs,	/* write */
						get_hw_reset_pfs,	/* read  */
						procfs_dir, pbp_device_block))
			ret = -1;

#endif

	}
	if (ret < 0)
		printk(KERN_DEBUG "Create proc entry failed\n");

	return ret;
}

int bypass_proc_remove_dev_sd(bpctl_dev_t * pbp_device_block)
{

	struct bypass_pfs_sd *current_pfs = &pbp_device_block->bypass_pfs_set;
	struct proc_dir_entry *pde = current_pfs->bypass_entry, *pde_curr =
	    NULL;
	char name[256];

	for (pde = pde->subdir; pde;) {
		strcpy(name, pde->name);
		pde_curr = pde;
		pde = pde->next;
		remove_proc_entry(name, current_pfs->bypass_entry);
	}
	if (!pde)
		remove_proc_entry(current_pfs->dir_name, bp_procfs_dir);

	return 0;
}

#endif				/* BYPASS_SUPPORT */