diff options
author | DanielC <puff65537@bansheeslibrary.com> | 2012-09-07 02:59:06 (GMT) |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@linuxfoundation.org> | 2012-09-08 05:12:43 (GMT) |
commit | 7040e556c90aefd7b0e1341f7490de20a33340d7 (patch) | |
tree | 5b3c3dd35a6e53112d16bcb231414e36b9a224ba /drivers/staging/silicom/bp_proc.c | |
parent | 960cf81187833ed3f19850551d46377323043876 (diff) | |
download | linux-fsl-qoriq-7040e556c90aefd7b0e1341f7490de20a33340d7.tar.xz |
staging: add Silicom Bypass driver
The Silicom Bypass Network Interface Cards (NICs) are network cards with
paired ports (2 or 4). The pairs either act as a "wire" allowing the
network packets to pass or insert the device in between the two ports.
When paired with the on-board hardware watchdog or other failsafe, they
provide high availability for the network in the face of software
outages or maintenance.
Signed-off-by: Daniel Cotey <puff65537@bansheeslibrary.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Diffstat (limited to 'drivers/staging/silicom/bp_proc.c')
-rw-r--r-- | drivers/staging/silicom/bp_proc.c | 1351 |
1 files changed, 1351 insertions, 0 deletions
diff --git a/drivers/staging/silicom/bp_proc.c b/drivers/staging/silicom/bp_proc.c new file mode 100644 index 0000000..4fe862d --- /dev/null +++ b/drivers/staging/silicom/bp_proc.c @@ -0,0 +1,1351 @@ +/******************************************************************************/ +/* */ +/* 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_IWGRP | S_IROTH | + S_IWOTH, 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 */ |