| /******************************************************************************/ |
| /* */ |
| /* bypass library, Copyright (c) 2004-2007 Silicom, Ltd */ |
| /* */ |
| /* 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. */ |
| /* */ |
| /* */ |
| /* bypass.c */ |
| /* */ |
| /******************************************************************************/ |
| |
| #if defined(CONFIG_SMP) && !defined(__SMP__) |
| #define __SMP__ |
| #endif |
| |
| #include <linux/module.h> |
| #include <linux/kernel.h> |
| #include <asm/unistd.h> |
| |
| #include <linux/sched.h> |
| #include <linux/wait.h> |
| |
| #include <linux/netdevice.h> /* struct device, and other headers */ |
| #include <linux/kernel_stat.h> |
| #include <linux/pci.h> |
| #include <linux/rtnetlink.h> |
| #include <linux/ethtool.h> |
| |
| #include <net/net_namespace.h> |
| |
| #include "bplibk.h" |
| |
| #define MOD_NAME "bypass" |
| |
| #define VERSION "\n"MOD_NAME" version 9.0.4\n" |
| |
| MODULE_AUTHOR("www.silicom.co.il"); |
| |
| MODULE_LICENSE("GPL"); |
| |
| static int do_cmd(struct net_device *dev, struct ifreq *ifr, int cmd, int *data) |
| { |
| int ret = -1; |
| struct if_bypass *bypass_cb; |
| |
| bypass_cb = (struct if_bypass *)ifr; |
| bypass_cb->cmd = cmd; |
| bypass_cb->data = *data; |
| |
| if (dev->netdev_ops && dev->netdev_ops->ndo_do_ioctl) { |
| ret = dev->netdev_ops->ndo_do_ioctl(dev, ifr, SIOCGIFBYPASS); |
| *data = bypass_cb->data; |
| } |
| |
| return ret; |
| } |
| |
| static int doit(int cmd, int if_index, int *data) |
| { |
| struct ifreq ifr; |
| int ret = -1; |
| struct net_device *dev; |
| struct net_device *n; |
| |
| for_each_netdev_safe(&init_net, dev, n) { |
| if (dev->ifindex == if_index) { |
| ret = do_cmd(dev, &ifr, cmd, data); |
| if (ret < 0) |
| ret = -1; |
| } |
| } |
| |
| return ret; |
| } |
| |
| #define bp_symbol_get(fn_name) symbol_get(fn_name) |
| #define bp_symbol_put(fn_name) symbol_put(fn_name) |
| |
| #define SET_BPLIB_INT_FN(fn_name, arg_type, arg, ret) \ |
| ({ int (*fn_ex)(arg_type) = NULL; \ |
| fn_ex = bp_symbol_get(fn_name##_sd); \ |
| if (fn_ex) { \ |
| ret = fn_ex(arg); \ |
| bp_symbol_put(fn_name##_sd); \ |
| } else { \ |
| ret = -1; \ |
| } \ |
| }) |
| |
| #define SET_BPLIB_INT_FN2(fn_name, arg_type, arg, arg_type1, arg1, ret)\ |
| ({ int (*fn_ex)(arg_type, arg_type1) = NULL; \ |
| fn_ex = bp_symbol_get(fn_name##_sd); \ |
| if (fn_ex) { \ |
| ret = fn_ex(arg, arg1); \ |
| bp_symbol_put(fn_name##_sd); \ |
| } else { \ |
| ret = -1; \ |
| } \ |
| }) |
| |
| #define SET_BPLIB_INT_FN3(fn_name, arg_type, arg, arg_type1, arg1, \ |
| arg_type2, arg2, ret) \ |
| ({ int (*fn_ex)(arg_type, arg_type1, arg_type2) = NULL; \ |
| fn_ex = bp_symbol_get(fn_name##_sd); \ |
| if (fn_ex) { \ |
| ret = fn_ex(arg, arg1, arg2); \ |
| bp_symbol_put(fn_name##_sd); \ |
| } else { \ |
| ret = -1; \ |
| } \ |
| }) |
| |
| #define DO_BPLIB_GET_ARG_FN(fn_name, ioctl_val, if_index) \ |
| ({ int data, ret = 0; \ |
| if (is_dev_sd(if_index)) { \ |
| SET_BPLIB_INT_FN(fn_name, int, if_index, ret); \ |
| return ret; \ |
| } \ |
| return doit(ioctl_val, if_index, &data); \ |
| }) |
| |
| #define DO_BPLIB_SET_ARG_FN(fn_name, ioctl_val, if_index, arg) \ |
| ({ int data, ret = 0; \ |
| if (is_dev_sd(if_index)) { \ |
| SET_BPLIB_INT_FN2(fn_name, int, if_index, int, \ |
| arg, ret); \ |
| return ret; \ |
| } \ |
| data = arg; \ |
| return doit(ioctl_val, if_index, &data); \ |
| }) |
| |
| static int is_dev_sd(int if_index) |
| { |
| int ret = 0; |
| |
| SET_BPLIB_INT_FN(is_bypass, int, if_index, ret); |
| return ret >= 0 ? 1 : 0; |
| } |
| |
| static int is_bypass_dev(int if_index) |
| { |
| struct pci_dev *pdev = NULL; |
| struct net_device *dev = NULL; |
| struct ifreq ifr; |
| int ret = 0; |
| int data = 0; |
| |
| while ((pdev = pci_get_class(PCI_CLASS_NETWORK_ETHERNET << 8, pdev))) { |
| dev = pci_get_drvdata(pdev); |
| if ((dev != NULL) && (dev->ifindex == if_index)) { |
| if ((pdev->vendor == SILICOM_VID) && |
| (pdev->device >= SILICOM_BP_PID_MIN) && |
| (pdev->device <= SILICOM_BP_PID_MAX)) { |
| goto send_cmd; |
| } |
| #if defined(BP_VENDOR_SUPPORT) && defined(ETHTOOL_GDRVINFO) |
| else { |
| struct ethtool_drvinfo info; |
| const struct ethtool_ops *ops = |
| dev->ethtool_ops; |
| int k = 0; |
| |
| if (ops->get_drvinfo) { |
| memset(&info, 0, sizeof(info)); |
| info.cmd = ETHTOOL_GDRVINFO; |
| ops->get_drvinfo(dev, &info); |
| for (; bp_desc_array[k]; k++) |
| if (!(strcmp(bp_desc_array[k], |
| info.driver))) |
| goto send_cmd; |
| |
| } |
| |
| } |
| #endif |
| return -1; |
| } |
| } |
| send_cmd: |
| ret = do_cmd(dev, &ifr, IS_BYPASS, &data); |
| return ret < 0 ? -1 : ret; |
| } |
| |
| static int is_bypass(int if_index) |
| { |
| int ret = 0; |
| |
| SET_BPLIB_INT_FN(is_bypass, int, if_index, ret); |
| |
| if (ret < 0) |
| return is_bypass_dev(if_index); |
| return ret; |
| } |
| EXPORT_SYMBOL(is_bypass); |
| |
| static int get_bypass_slave(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bypass_slave, GET_BYPASS_SLAVE, if_index); |
| } |
| EXPORT_SYMBOL(get_bypass_slave); |
| |
| static int get_bypass_caps(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bypass_caps, GET_BYPASS_CAPS, if_index); |
| } |
| EXPORT_SYMBOL(get_bypass_caps); |
| |
| static int get_wd_set_caps(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_wd_set_caps, GET_WD_SET_CAPS, if_index); |
| } |
| EXPORT_SYMBOL(get_wd_set_caps); |
| |
| static int set_bypass(int if_index, int bypass_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_bypass, SET_BYPASS, if_index, bypass_mode); |
| } |
| EXPORT_SYMBOL(set_bypass); |
| |
| static int get_bypass(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bypass, GET_BYPASS, if_index); |
| } |
| EXPORT_SYMBOL(get_bypass); |
| |
| static int get_bypass_change(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bypass_change, GET_BYPASS_CHANGE, if_index); |
| } |
| EXPORT_SYMBOL(get_bypass_change); |
| |
| static int set_dis_bypass(int if_index, int dis_bypass) |
| { |
| DO_BPLIB_SET_ARG_FN(set_dis_bypass, SET_DIS_BYPASS, if_index, |
| dis_bypass); |
| } |
| EXPORT_SYMBOL(set_dis_bypass); |
| |
| static int get_dis_bypass(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_dis_bypass, GET_DIS_BYPASS, if_index); |
| } |
| EXPORT_SYMBOL(get_dis_bypass); |
| |
| static int set_bypass_pwoff(int if_index, int bypass_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_bypass_pwoff, SET_BYPASS_PWOFF, if_index, |
| bypass_mode); |
| } |
| EXPORT_SYMBOL(set_bypass_pwoff); |
| |
| static int get_bypass_pwoff(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bypass_pwoff, GET_BYPASS_PWOFF, if_index); |
| } |
| EXPORT_SYMBOL(get_bypass_pwoff); |
| |
| static int set_bypass_pwup(int if_index, int bypass_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_bypass_pwup, SET_BYPASS_PWUP, if_index, |
| bypass_mode); |
| } |
| EXPORT_SYMBOL(set_bypass_pwup); |
| |
| static int get_bypass_pwup(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bypass_pwup, GET_BYPASS_PWUP, if_index); |
| } |
| EXPORT_SYMBOL(get_bypass_pwup); |
| |
| static int set_bypass_wd(int if_index, int ms_timeout, int *ms_timeout_set) |
| { |
| int data = ms_timeout; |
| int ret = 0; |
| |
| if (is_dev_sd(if_index)) { |
| SET_BPLIB_INT_FN3(set_bypass_wd, int, if_index, int, ms_timeout, |
| int *, ms_timeout_set, ret); |
| } else { |
| ret = doit(SET_BYPASS_WD, if_index, &data); |
| if (ret > 0) { |
| *ms_timeout_set = ret; |
| ret = 0; |
| } |
| } |
| return ret; |
| } |
| EXPORT_SYMBOL(set_bypass_wd); |
| |
| static int get_bypass_wd(int if_index, int *ms_timeout_set) |
| { |
| int *data = ms_timeout_set; |
| int ret = 0; |
| |
| if (is_dev_sd(if_index)) |
| SET_BPLIB_INT_FN2(get_bypass_wd, int, if_index, int *, |
| ms_timeout_set, ret); |
| else |
| ret = doit(GET_BYPASS_WD, if_index, data); |
| return ret; |
| } |
| EXPORT_SYMBOL(get_bypass_wd); |
| |
| static int get_wd_expire_time(int if_index, int *ms_time_left) |
| { |
| int *data = ms_time_left, ret = 0; |
| |
| if (is_dev_sd(if_index)) { |
| SET_BPLIB_INT_FN2(get_wd_expire_time, int, if_index, int *, |
| ms_time_left, ret); |
| } else { |
| ret = doit(GET_WD_EXPIRE_TIME, if_index, data); |
| if ((ret == 0) && (*data != 0)) |
| ret = 1; |
| } |
| return ret; |
| } |
| EXPORT_SYMBOL(get_wd_expire_time); |
| |
| static int reset_bypass_wd_timer(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(reset_bypass_wd_timer, RESET_BYPASS_WD_TIMER, |
| if_index); |
| } |
| EXPORT_SYMBOL(reset_bypass_wd_timer); |
| |
| static int set_std_nic(int if_index, int bypass_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_std_nic, SET_STD_NIC, if_index, bypass_mode); |
| } |
| EXPORT_SYMBOL(set_std_nic); |
| |
| static int get_std_nic(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_std_nic, GET_STD_NIC, if_index); |
| } |
| EXPORT_SYMBOL(get_std_nic); |
| |
| static int set_tx(int if_index, int tx_state) |
| { |
| DO_BPLIB_SET_ARG_FN(set_tx, SET_TX, if_index, tx_state); |
| } |
| EXPORT_SYMBOL(set_tx); |
| |
| static int get_tx(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_tx, GET_TX, if_index); |
| } |
| EXPORT_SYMBOL(get_tx); |
| |
| static int set_tap(int if_index, int tap_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_tap, SET_TAP, if_index, tap_mode); |
| } |
| EXPORT_SYMBOL(set_tap); |
| |
| static int get_tap(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_tap, GET_TAP, if_index); |
| } |
| EXPORT_SYMBOL(get_tap); |
| |
| static int get_tap_change(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_tap_change, GET_TAP_CHANGE, if_index); |
| } |
| EXPORT_SYMBOL(get_tap_change); |
| |
| static int set_dis_tap(int if_index, int dis_tap) |
| { |
| DO_BPLIB_SET_ARG_FN(set_dis_tap, SET_DIS_TAP, if_index, dis_tap); |
| } |
| EXPORT_SYMBOL(set_dis_tap); |
| |
| static int get_dis_tap(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_dis_tap, GET_DIS_TAP, if_index); |
| } |
| EXPORT_SYMBOL(get_dis_tap); |
| |
| static int set_tap_pwup(int if_index, int tap_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_tap_pwup, SET_TAP_PWUP, if_index, tap_mode); |
| } |
| EXPORT_SYMBOL(set_tap_pwup); |
| |
| static int get_tap_pwup(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_tap_pwup, GET_TAP_PWUP, if_index); |
| } |
| EXPORT_SYMBOL(get_tap_pwup); |
| |
| static int set_bp_disc(int if_index, int disc_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_bp_disc, SET_DISC, if_index, disc_mode); |
| } |
| EXPORT_SYMBOL(set_bp_disc); |
| |
| static int get_bp_disc(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bp_disc, GET_DISC, if_index); |
| } |
| EXPORT_SYMBOL(get_bp_disc); |
| |
| static int get_bp_disc_change(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bp_disc_change, GET_DISC_CHANGE, if_index); |
| } |
| EXPORT_SYMBOL(get_bp_disc_change); |
| |
| static int set_bp_dis_disc(int if_index, int dis_disc) |
| { |
| DO_BPLIB_SET_ARG_FN(set_bp_dis_disc, SET_DIS_DISC, if_index, dis_disc); |
| } |
| EXPORT_SYMBOL(set_bp_dis_disc); |
| |
| static int get_bp_dis_disc(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bp_dis_disc, GET_DIS_DISC, if_index); |
| } |
| EXPORT_SYMBOL(get_bp_dis_disc); |
| |
| static int set_bp_disc_pwup(int if_index, int disc_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_bp_disc_pwup, SET_DISC_PWUP, if_index, |
| disc_mode); |
| } |
| EXPORT_SYMBOL(set_bp_disc_pwup); |
| |
| static int get_bp_disc_pwup(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_bp_disc_pwup, GET_DISC_PWUP, if_index); |
| } |
| EXPORT_SYMBOL(get_bp_disc_pwup); |
| |
| static int set_wd_exp_mode(int if_index, int mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_wd_exp_mode, SET_WD_EXP_MODE, if_index, mode); |
| } |
| EXPORT_SYMBOL(set_wd_exp_mode); |
| |
| static int get_wd_exp_mode(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_wd_exp_mode, GET_WD_EXP_MODE, if_index); |
| } |
| EXPORT_SYMBOL(get_wd_exp_mode); |
| |
| static int set_wd_autoreset(int if_index, int time) |
| { |
| DO_BPLIB_SET_ARG_FN(set_wd_autoreset, SET_WD_AUTORESET, if_index, time); |
| } |
| EXPORT_SYMBOL(set_wd_autoreset); |
| |
| static int get_wd_autoreset(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_wd_autoreset, GET_WD_AUTORESET, if_index); |
| } |
| EXPORT_SYMBOL(get_wd_autoreset); |
| |
| static int set_tpl(int if_index, int tpl_mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_tpl, SET_TPL, if_index, tpl_mode); |
| } |
| EXPORT_SYMBOL(set_tpl); |
| |
| static int get_tpl(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_tpl, GET_TPL, if_index); |
| } |
| EXPORT_SYMBOL(get_tpl); |
| |
| static int set_bp_hw_reset(int if_index, int mode) |
| { |
| DO_BPLIB_SET_ARG_FN(set_tpl, SET_BP_HW_RESET, if_index, mode); |
| } |
| EXPORT_SYMBOL(set_bp_hw_reset); |
| |
| static int get_bp_hw_reset(int if_index) |
| { |
| DO_BPLIB_GET_ARG_FN(get_tpl, GET_BP_HW_RESET, if_index); |
| } |
| EXPORT_SYMBOL(get_bp_hw_reset); |
| |
| static int get_bypass_info(int if_index, struct bp_info *bp_info) |
| { |
| int ret = 0; |
| |
| if (is_dev_sd(if_index)) { |
| SET_BPLIB_INT_FN2(get_bypass_info, int, if_index, |
| struct bp_info *, bp_info, ret); |
| } else { |
| struct net_device *dev; |
| struct net_device *n; |
| |
| for_each_netdev_safe(&init_net, dev, n) { |
| if (dev->ifindex == if_index) { |
| struct if_bypass_info *bypass_cb; |
| struct ifreq ifr; |
| |
| memset(&ifr, 0, sizeof(ifr)); |
| bypass_cb = (struct if_bypass_info *)𝔦 |
| bypass_cb->cmd = GET_BYPASS_INFO; |
| |
| if (dev->netdev_ops && |
| dev->netdev_ops->ndo_do_ioctl) |
| ret = dev->netdev_ops->ndo_do_ioctl(dev, |
| &ifr, SIOCGIFBYPASS); |
| else |
| ret = -1; |
| if (ret == 0) |
| memcpy(bp_info, &bypass_cb->bp_info, |
| sizeof(struct bp_info)); |
| ret = ret < 0 ? -1 : 0; |
| break; |
| } |
| } |
| } |
| return ret; |
| } |
| EXPORT_SYMBOL(get_bypass_info); |
| |
| static int __init init_lib_module(void) |
| { |
| printk(VERSION); |
| return 0; |
| } |
| |
| static void __exit cleanup_lib_module(void) |
| { |
| } |
| |
| module_init(init_lib_module); |
| module_exit(cleanup_lib_module); |