Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

[cascardo/linux.git] / drivers / staging / silicom / bpctl_mod.c

diff --git a/drivers/staging/silicom/bpctl_mod.c b/drivers/staging/silicom/bpctl_mod.c
index c8ddb99..48b9fb1 100644 (file)
--- a/drivers/staging/silicom/bpctl_mod.c
+++ b/drivers/staging/silicom/bpctl_mod.c
@@ -35,7 +35,7 @@
 #define BP_MOD_DESCR "Silicom Bypass-SD Control driver"
 #define BP_SYNC_FLAG 1
 
-static int major_num = 0;
+static int major_num;
 
 MODULE_AUTHOR("Anna Lukin, annal@silicom.co.il");
 MODULE_LICENSE("GPL");
@@ -43,21 +43,16 @@ MODULE_DESCRIPTION(BP_MOD_DESCR);
 MODULE_VERSION(BP_MOD_VER);
 spinlock_t bpvm_lock;
 
-#define lock_bpctl()                                   \
-if (down_interruptible(&bpctl_sema)) {                 \
-       return -ERESTARTSYS;                            \
-}                                                      \
-
-#define unlock_bpctl()                                         \
+#define unlock_bpctl()                                 \
        up(&bpctl_sema);
 
 /* Media Types */
-typedef enum {
-       bp_copper = 0,
-       bp_fiber,
-       bp_cx4,
-       bp_none,
-} bp_media_type;
+enum bp_media_type {
+       BP_COPPER = 0,
+       BP_FIBER,
+       BP_CX4,
+       BP_NONE,
+};
 
 struct bypass_pfs_sd {
        char dir_name[32];
@@ -89,7 +84,7 @@ typedef struct _bpctl_dev {
        uint32_t reset_time;
        uint8_t bp_status_un;
        atomic_t wdt_busy;
-       bp_media_type media_type;
+       enum bp_media_type media_type;
        int bp_tpl_flag;
        struct timer_list bp_tpl_timer;
        spinlock_t bypass_wr_lock;
@@ -112,7 +107,7 @@ typedef struct _bpctl_dev {
 static bpctl_dev_t *bpctl_dev_arr;
 
 static struct semaphore bpctl_sema;
-static int device_num = 0;
+static int device_num;
 
 static int get_dev_idx(int ifindex);
 static bpctl_dev_t *get_master_port_fn(bpctl_dev_t *pbpctl_dev);
@@ -134,7 +129,7 @@ static int bp_device_event(struct notifier_block *unused,
                           unsigned long event, void *ptr)
 {
        struct net_device *dev = netdev_notifier_info_to_dev(ptr);
-       static bpctl_dev_t *pbpctl_dev = NULL, *pbpctl_dev_m = NULL;
+       static bpctl_dev_t *pbpctl_dev, *pbpctl_dev_m;
        int dev_num = 0, ret = 0, ret_d = 0, time_left = 0;
        /* printk("BP_PROC_SUPPORT event =%d %s %d\n", event,dev->name, dev->ifindex ); */
        /* return NOTIFY_DONE; */
@@ -165,7 +160,8 @@ static int bp_device_event(struct notifier_block *unused,
                        memcpy(&cbuf, drvinfo.bus_info, 32);
                        buf = &cbuf[0];
 
-                       while (*buf++ != ':') ;
+                       while (*buf++ != ':')
+                               ;
                        for (i = 0; i < 10; i++, buf++) {
                                if (*buf == ':')
                                        break;
@@ -306,7 +302,8 @@ static void write_pulse(bpctl_dev_t *pbpctl_dev,
                ctrl = BP10G_READ_REG(pbpctl_dev, ESDP);
 
        if (pbpctl_dev->bp_10g9) {
-               if (!(pbpctl_dev_c = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_c = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_c)
                        return;
                ctrl = BP10G_READ_REG(pbpctl_dev_c, ESDP);
        }
@@ -606,7 +603,8 @@ static int read_pulse(bpctl_dev_t *pbpctl_dev, unsigned int ctrl_ext,
        if (pbpctl_dev->bp_540)
                ctrl = BP10G_READ_REG(pbpctl_dev, ESDP);
        if (pbpctl_dev->bp_10g9) {
-               if (!(pbpctl_dev_c = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_c = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_c)
                        return -1;
                ctrl = BP10G_READ_REG(pbpctl_dev_c, ESDP);
        }
@@ -720,16 +718,15 @@ static int read_pulse(bpctl_dev_t *pbpctl_dev, unsigned int ctrl_ext,
                                         BP10G_MDIO_DATA_OUT));
 
                }
-               if (pbpctl_dev->bp_10g9) {
-                       ctrl_ext = BP10G_READ_REG(pbpctl_dev, I2CCTL);
 
-               } else if ((pbpctl_dev->bp_fiber5) || (pbpctl_dev->bp_i80)) {
+               if (pbpctl_dev->bp_10g9)
+                       ctrl_ext = BP10G_READ_REG(pbpctl_dev, I2CCTL);
+               else if ((pbpctl_dev->bp_fiber5) || (pbpctl_dev->bp_i80))
                        ctrl_ext = BPCTL_READ_REG(pbpctl_dev, CTRL);
-               } else if (pbpctl_dev->bp_540) {
+               else if (pbpctl_dev->bp_540)
                        ctrl_ext = BP10G_READ_REG(pbpctl_dev, ESDP);
-               } else if (pbpctl_dev->bp_10gb)
+               else if (pbpctl_dev->bp_10gb)
                        ctrl_ext = BP10GB_READ_REG(pbpctl_dev, MISC_REG_SPIO);
-
                else if (!pbpctl_dev->bp_10g)
                        ctrl_ext = BPCTL_READ_REG(pbpctl_dev, CTRL_EXT);
                else
@@ -775,7 +772,8 @@ static void write_reg(bpctl_dev_t *pbpctl_dev, unsigned char value,
        bpctl_dev_t *pbpctl_dev_c = NULL;
        unsigned long flags;
        if (pbpctl_dev->bp_10g9) {
-               if (!(pbpctl_dev_c = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_c = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_c)
                        return;
        }
        if ((pbpctl_dev->wdt_status == WDT_STATUS_EN) &&
@@ -953,7 +951,8 @@ static int read_reg(bpctl_dev_t *pbpctl_dev, unsigned char addr)
        atomic_set(&pbpctl_dev->wdt_busy, 1);
 #endif
        if (pbpctl_dev->bp_10g9) {
-               if (!(pbpctl_dev_c = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_c = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_c)
                        return -1;
        }
 
@@ -1224,7 +1223,8 @@ static int wdt_pulse(bpctl_dev_t *pbpctl_dev)
                return -1;
 #endif
        if (pbpctl_dev->bp_10g9) {
-               if (!(pbpctl_dev_c = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_c = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_c)
                        return -1;
        }
 
@@ -1414,8 +1414,8 @@ static int wdt_pulse(bpctl_dev_t *pbpctl_dev)
                                (ctrl_ext &
                                 ~(BP10G_MCLK_DATA_OUT | BP10G_MDIO_DATA_OUT)));
        }
-       if ((pbpctl_dev->wdt_status == WDT_STATUS_EN)   /*&&
-                                                          (pbpctl_dev->bp_ext_ver<PXG4BPFI_VER) */ )
+       if ((pbpctl_dev->wdt_status == WDT_STATUS_EN))
+               /*&& (pbpctl_dev->bp_ext_ver<PXG4BPFI_VER) */
                pbpctl_dev->bypass_wdt_on_time = jiffies;
 #ifdef BP_SYNC_FLAG
        spin_unlock_irqrestore(&pbpctl_dev->bypass_wr_lock, flags);
@@ -1744,7 +1744,8 @@ static int write_data_int(bpctl_dev_t *pbpctl_dev, unsigned char value)
 {
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+       pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+       if (!pbpctl_dev_b)
                return -1;
        atomic_set(&pbpctl_dev->wdt_busy, 1);
        write_data_port_int(pbpctl_dev, value & 0x3);
@@ -1920,13 +1921,10 @@ int disc_port_on(bpctl_dev_t *pbpctl_dev)
                return BP_NOT_CAP;
 
        if (pbpctl_dev_m->bp_caps_ex & DISC_PORT_CAP_EX) {
-               if (is_bypass_fn(pbpctl_dev) == 1) {
-
+               if (is_bypass_fn(pbpctl_dev) == 1)
                        write_data(pbpctl_dev_m, TX_DISA);
-               } else {
-
+               else
                        write_data(pbpctl_dev_m, TX_DISB);
-               }
 
                msec_delay_bp(LATCH_DELAY);
 
@@ -1965,7 +1963,8 @@ int tpl_hw_on(bpctl_dev_t *pbpctl_dev)
        int ret = 0, ctrl = 0;
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+       pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+       if (!pbpctl_dev_b)
                return BP_NOT_CAP;
 
        if (pbpctl_dev->bp_caps_ex & TPL2_CAP_EX) {
@@ -1992,7 +1991,8 @@ int tpl_hw_off(bpctl_dev_t *pbpctl_dev)
        int ret = 0, ctrl = 0;
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+       pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+       if (!pbpctl_dev_b)
                return BP_NOT_CAP;
        if (pbpctl_dev->bp_caps_ex & TPL2_CAP_EX) {
                cmnd_on(pbpctl_dev);
@@ -2017,9 +2017,9 @@ int wdt_off(bpctl_dev_t *pbpctl_dev)
        int ret = BP_NOT_CAP;
 
        if (pbpctl_dev->bp_caps & WD_CTL_CAP) {
-               if (INTEL_IF_SERIES(pbpctl_dev->subdevice)) {
+               if (INTEL_IF_SERIES(pbpctl_dev->subdevice))
                        bypass_off(pbpctl_dev);
-               } else if (pbpctl_dev->bp_ext_ver >= PXG2BPI_VER)
+               else if (pbpctl_dev->bp_ext_ver >= PXG2BPI_VER)
                        write_data(pbpctl_dev, WDT_OFF);
                else
                        data_pulse(pbpctl_dev, WDT_OFF);
@@ -2150,12 +2150,14 @@ static void bp75_release_phy(bpctl_dev_t *pbpctl_dev)
 {
        u16 mask = BPCTLI_SWFW_PHY0_SM;
        u32 swfw_sync;
+       s32 ret_val;
 
        if ((pbpctl_dev->func == 1) || (pbpctl_dev->func == 3))
                mask = BPCTLI_SWFW_PHY1_SM;
 
-       while (bp75_get_hw_semaphore_generic(pbpctl_dev) != 0) ;
-       /* Empty */
+       do
+               ret_val = bp75_get_hw_semaphore_generic(pbpctl_dev);
+       while (ret_val != 0);
 
        swfw_sync = BPCTL_READ_REG(pbpctl_dev, SW_FW_SYNC);
        swfw_sync &= ~mask;
@@ -2404,12 +2406,10 @@ static int set_tx(bpctl_dev_t *pbpctl_dev, int tx_state)
                        }
 
                }
-               if (pbpctl_dev->bp_fiber5) {
+               if (pbpctl_dev->bp_fiber5)
                        ctrl = BPCTL_READ_REG(pbpctl_dev, CTRL_EXT);
-
-               } else if (pbpctl_dev->bp_10gb)
+               else if (pbpctl_dev->bp_10gb)
                        ctrl = BP10GB_READ_REG(pbpctl_dev, MISC_REG_GPIO);
-
                else if (!pbpctl_dev->bp_10g)
                        ctrl = BPCTL_READ_REG(pbpctl_dev, CTRL);
                else
@@ -3237,8 +3237,10 @@ int bypass_from_last_read(bpctl_dev_t *pbpctl_dev)
        uint32_t ctrl_ext = 0;
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if ((pbpctl_dev->bp_caps & SW_CTL_CAP)
-           && (pbpctl_dev_b = get_status_port_fn(pbpctl_dev))) {
+       if (pbpctl_dev->bp_caps & SW_CTL_CAP) {
+               pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_b)
+                       return BP_NOT_CAP;
                ctrl_ext = BPCTL_READ_REG(pbpctl_dev_b, CTRL_EXT);
                BPCTL_BP_WRITE_REG(pbpctl_dev_b, CTRL_EXT,
                                   (ctrl_ext & ~BPCTLI_CTRL_EXT_SDP7_DIR));
@@ -3254,9 +3256,10 @@ int bypass_status_clear(bpctl_dev_t *pbpctl_dev)
 {
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if ((pbpctl_dev->bp_caps & SW_CTL_CAP)
-           && (pbpctl_dev_b = get_status_port_fn(pbpctl_dev))) {
-
+       if (pbpctl_dev->bp_caps & SW_CTL_CAP) {
+               pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_b)
+                       return BP_NOT_CAP;
                send_bypass_clear_pulse(pbpctl_dev_b, 1);
                return 0;
        } else
@@ -3329,7 +3332,8 @@ static int bypass_status(bpctl_dev_t *pbpctl_dev)
 
                bpctl_dev_t *pbpctl_dev_b = NULL;
 
-               if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_b)
                        return BP_NOT_CAP;
 
                if (INTEL_IF_SERIES(pbpctl_dev->subdevice)) {
@@ -3391,7 +3395,7 @@ static int bypass_status(bpctl_dev_t *pbpctl_dev)
                                         BP10G_SDP7_DATA_IN) != 0 ? 0 : 1);
                        }
 
-               } else if (pbpctl_dev->media_type == bp_copper) {
+               } else if (pbpctl_dev->media_type == BP_COPPER) {
 
                        return (((BPCTL_READ_REG(pbpctl_dev_b, CTRL)) &
                                 BPCTLI_CTRL_SWDPIN1) != 0 ? 1 : 0);
@@ -3617,7 +3621,8 @@ int tap_status(bpctl_dev_t *pbpctl_dev)
        if (pbpctl_dev->bp_caps & TAP_CAP) {
                bpctl_dev_t *pbpctl_dev_b = NULL;
 
-               if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_b)
                        return BP_NOT_CAP;
 
                if (pbpctl_dev->bp_ext_ver >= 0x8) {
@@ -3636,7 +3641,7 @@ int tap_status(bpctl_dev_t *pbpctl_dev)
                                         BP10G_SDP6_DATA_IN) != 0 ? 0 : 1);
                        }
 
-               } else if (pbpctl_dev->media_type == bp_copper)
+               } else if (pbpctl_dev->media_type == BP_COPPER)
                        return (((BPCTL_READ_REG(pbpctl_dev, CTRL)) &
                                 BPCTLI_CTRL_SWDPIN0) != 0 ? 1 : 0);
                else {
@@ -3713,7 +3718,8 @@ int disc_off_status(bpctl_dev_t *pbpctl_dev)
        u32 ctrl_ext = 0;
 
        if (pbpctl_dev->bp_caps & DISC_CAP) {
-               if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+               pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+               if (!pbpctl_dev_b)
                        return BP_NOT_CAP;
                if (DISCF_IF_SERIES(pbpctl_dev->subdevice))
                        return ((((read_reg(pbpctl_dev, STATUS_DISC_REG_ADDR)) &
@@ -3730,7 +3736,7 @@ int disc_off_status(bpctl_dev_t *pbpctl_dev)
                                 BP10G_SDP2_DATA) != 0 ? 1 : 0);
 
                }
-               if (pbpctl_dev->media_type == bp_copper) {
+               if (pbpctl_dev->media_type == BP_COPPER) {
 
 #if 0
                        return ((((read_reg(pbpctl_dev, STATUS_DISC_REG_ADDR)) &
@@ -3794,11 +3800,10 @@ static int disc_status(bpctl_dev_t *pbpctl_dev)
 {
        int ctrl = 0;
        if (pbpctl_dev->bp_caps & DISC_CAP) {
-
-               if ((ctrl = disc_off_status(pbpctl_dev)) < 0)
+               ctrl = disc_off_status(pbpctl_dev);
+               if (ctrl < 0)
                        return ctrl;
                return ((ctrl == 0) ? 1 : 0);
-
        }
        return BP_NOT_CAP;
 }
@@ -3911,7 +3916,8 @@ int tpl_hw_status(bpctl_dev_t *pbpctl_dev)
 {
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+       pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+       if (!pbpctl_dev_b)
                return BP_NOT_CAP;
 
        if (TPL_IF_SERIES(pbpctl_dev->subdevice))
@@ -4021,42 +4027,41 @@ void bypass_caps_init(bpctl_dev_t *pbpctl_dev)
        }
 #endif
        if ((pbpctl_dev->bp_fiber5) || (pbpctl_dev->bp_10g9)) {
-               pbpctl_dev->media_type = bp_fiber;
+               pbpctl_dev->media_type = BP_FIBER;
        } else if (pbpctl_dev->bp_10gb) {
                if (BP10GB_CX4_SERIES(pbpctl_dev->subdevice))
-                       pbpctl_dev->media_type = bp_cx4;
+                       pbpctl_dev->media_type = BP_CX4;
                else
-                       pbpctl_dev->media_type = bp_fiber;
+                       pbpctl_dev->media_type = BP_FIBER;
 
        }
 
        else if (pbpctl_dev->bp_540)
-               pbpctl_dev->media_type = bp_none;
+               pbpctl_dev->media_type = BP_NONE;
        else if (!pbpctl_dev->bp_10g) {
 
                ctrl_ext = BPCTL_READ_REG(pbpctl_dev, CTRL_EXT);
                if ((ctrl_ext & BPCTLI_CTRL_EXT_LINK_MODE_MASK) == 0x0)
-                       pbpctl_dev->media_type = bp_copper;
+                       pbpctl_dev->media_type = BP_COPPER;
                else
-                       pbpctl_dev->media_type = bp_fiber;
+                       pbpctl_dev->media_type = BP_FIBER;
 
        } else {
                if (BP10G_CX4_SERIES(pbpctl_dev->subdevice))
-                       pbpctl_dev->media_type = bp_cx4;
+                       pbpctl_dev->media_type = BP_CX4;
                else
-                       pbpctl_dev->media_type = bp_fiber;
+                       pbpctl_dev->media_type = BP_FIBER;
        }
 
        if (is_bypass_fn(pbpctl_dev)) {
 
                pbpctl_dev->bp_caps |= BP_PWOFF_ON_CAP;
-               if (pbpctl_dev->media_type == bp_fiber)
+               if (pbpctl_dev->media_type == BP_FIBER)
                        pbpctl_dev->bp_caps |=
                            (TX_CTL_CAP | TX_STATUS_CAP | TPL_CAP);
 
-               if (TPL_IF_SERIES(pbpctl_dev->subdevice)) {
+               if (TPL_IF_SERIES(pbpctl_dev->subdevice))
                        pbpctl_dev->bp_caps |= TPL_CAP;
-               }
 
                if (INTEL_IF_SERIES(pbpctl_dev->subdevice)) {
                        pbpctl_dev->bp_caps |=
@@ -4196,9 +4201,9 @@ void bypass_caps_init(bpctl_dev_t *pbpctl_dev)
        if (PEG5_IF_SERIES(pbpctl_dev->subdevice))
                pbpctl_dev->bp_caps |= (TX_CTL_CAP | TX_STATUS_CAP);
 
-       if (BP10GB_IF_SERIES(pbpctl_dev->subdevice)) {
+       if (BP10GB_IF_SERIES(pbpctl_dev->subdevice))
                pbpctl_dev->bp_caps &= ~(TX_CTL_CAP | TX_STATUS_CAP);
-       }
+
        pbpctl_dev_m = get_master_port_fn(pbpctl_dev);
        if (pbpctl_dev_m != NULL) {
                int cap_reg = 0;
@@ -4215,9 +4220,8 @@ void bypass_caps_init(bpctl_dev_t *pbpctl_dev)
 
 int bypass_off_init(bpctl_dev_t *pbpctl_dev)
 {
-       int ret = 0;
-
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       int ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (INTEL_IF_SERIES(pbpctl_dev->subdevice))
                return dis_bypass_cap(pbpctl_dev);
@@ -4327,14 +4331,13 @@ int set_bypass_wd_auto(bpctl_dev_t *pbpctl_dev, unsigned int param)
 
 int get_bypass_wd_auto(bpctl_dev_t *pbpctl_dev)
 {
-
-       if (pbpctl_dev->bp_caps & WD_CTL_CAP) {
+       if (pbpctl_dev->bp_caps & WD_CTL_CAP)
                return pbpctl_dev->reset_time;
-       }
+
        return BP_NOT_CAP;
 }
 
-#ifdef  BP_SELF_TEST
+#ifdef BP_SELF_TEST
 
 int set_bp_self_test(bpctl_dev_t *pbpctl_dev, unsigned int param)
 {
@@ -4403,7 +4406,8 @@ int set_bypass_fn(bpctl_dev_t *pbpctl_dev, int bypass_mode)
 
        if (!(pbpctl_dev->bp_caps & BP_CAP))
                return BP_NOT_CAP;
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (!bypass_mode)
                ret = bypass_off(pbpctl_dev);
@@ -4435,7 +4439,8 @@ int set_dis_bypass_fn(bpctl_dev_t *pbpctl_dev, int dis_param)
 
        if (!(pbpctl_dev->bp_caps & BP_DIS_CAP))
                return BP_NOT_CAP;
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (dis_param)
                ret = dis_bypass_cap(pbpctl_dev);
@@ -4461,7 +4466,8 @@ int set_bypass_pwoff_fn(bpctl_dev_t *pbpctl_dev, int bypass_mode)
 
        if (!(pbpctl_dev->bp_caps & BP_PWOFF_CTL_CAP))
                return BP_NOT_CAP;
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (bypass_mode)
                ret = bypass_state_pwroff(pbpctl_dev);
@@ -4487,7 +4493,8 @@ int set_bypass_pwup_fn(bpctl_dev_t *pbpctl_dev, int bypass_mode)
 
        if (!(pbpctl_dev->bp_caps & BP_PWUP_CTL_CAP))
                return BP_NOT_CAP;
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (bypass_mode)
                ret = bypass_state_pwron(pbpctl_dev);
@@ -4514,7 +4521,8 @@ int set_bypass_wd_fn(bpctl_dev_t *pbpctl_dev, int timeout)
        if (!(pbpctl_dev->bp_caps & WD_CTL_CAP))
                return BP_NOT_CAP;
 
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (!timeout)
                ret = wdt_off(pbpctl_dev);
@@ -4583,7 +4591,8 @@ int set_std_nic_fn(bpctl_dev_t *pbpctl_dev, int nic_mode)
        if (!(pbpctl_dev->bp_caps & STD_NIC_CAP))
                return BP_NOT_CAP;
 
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        if (nic_mode)
                ret = std_nic_on(pbpctl_dev);
@@ -4649,7 +4658,8 @@ int get_tap_pwup_fn(bpctl_dev_t *pbpctl_dev)
        if (!pbpctl_dev)
                return -1;
 
-       if ((ret = default_pwron_tap_status(pbpctl_dev)) < 0)
+       ret = default_pwron_tap_status(pbpctl_dev);
+       if (ret < 0)
                return ret;
        return ((ret == 0) ? 1 : 0);
 }
@@ -4824,7 +4834,8 @@ int get_disc_port_pwup_fn(bpctl_dev_t *pbpctl_dev)
        if (!pbpctl_dev)
                return -1;
 
-       if ((ret = default_pwron_disc_port_status(pbpctl_dev)) < 0)
+       ret = default_pwron_disc_port_status(pbpctl_dev);
+       if (ret < 0)
                return ret;
        return ((ret == 0) ? 1 : 0);
 }
@@ -4851,7 +4862,8 @@ int reset_cont_fn(bpctl_dev_t *pbpctl_dev)
        if (!pbpctl_dev)
                return -1;
 
-       if ((ret = cmnd_on(pbpctl_dev)) < 0)
+       ret = cmnd_on(pbpctl_dev);
+       if (ret < 0)
                return ret;
        return reset_cont(pbpctl_dev);
 }
@@ -4867,8 +4879,10 @@ int set_tx_fn(bpctl_dev_t *pbpctl_dev, int tx_state)
            (pbpctl_dev->bp_caps & SW_CTL_CAP)) {
                if ((pbpctl_dev->bp_tpl_flag))
                        return BP_NOT_CAP;
-       } else if ((pbpctl_dev_b = get_master_port_fn(pbpctl_dev))) {
-               if ((pbpctl_dev_b->bp_caps & TPL_CAP) &&
+       } else {
+               pbpctl_dev_b = get_master_port_fn(pbpctl_dev);
+               if (pbpctl_dev_b &&
+                   (pbpctl_dev_b->bp_caps & TPL_CAP) &&
                    (pbpctl_dev_b->bp_tpl_flag))
                        return BP_NOT_CAP;
        }
@@ -4984,8 +4998,10 @@ int get_tx_fn(bpctl_dev_t *pbpctl_dev)
            (pbpctl_dev->bp_caps & SW_CTL_CAP)) {
                if ((pbpctl_dev->bp_tpl_flag))
                        return BP_NOT_CAP;
-       } else if ((pbpctl_dev_b = get_master_port_fn(pbpctl_dev))) {
-               if ((pbpctl_dev_b->bp_caps & TPL_CAP) &&
+       } else {
+               pbpctl_dev_b = get_master_port_fn(pbpctl_dev);
+               if (pbpctl_dev_b &&
+                   (pbpctl_dev_b->bp_caps & TPL_CAP) &&
                    (pbpctl_dev_b->bp_tpl_flag))
                        return BP_NOT_CAP;
        }
@@ -5009,7 +5025,7 @@ static int get_bypass_link_status(bpctl_dev_t *pbpctl_dev)
        if (!pbpctl_dev)
                return -1;
 
-       if (pbpctl_dev->media_type == bp_fiber)
+       if (pbpctl_dev->media_type == BP_FIBER)
                return ((BPCTL_READ_REG(pbpctl_dev, CTRL) &
                         BPCTLI_CTRL_SWDPIN1));
        else
@@ -5024,7 +5040,8 @@ static void bp_tpl_timer_fn(unsigned long param)
        uint32_t link1, link2;
        bpctl_dev_t *pbpctl_dev_b = NULL;
 
-       if (!(pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+       pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+       if (!pbpctl_dev_b)
                return;
 
        if (!pbpctl_dev->bp_tpl_flag) {
@@ -5036,23 +5053,19 @@ static void bp_tpl_timer_fn(unsigned long param)
 
        link2 = get_bypass_link_status(pbpctl_dev_b);
        if ((link1) && (tx_status(pbpctl_dev))) {
-               if ((!link2) && (tx_status(pbpctl_dev_b))) {
+               if ((!link2) && (tx_status(pbpctl_dev_b)))
                        set_tx(pbpctl_dev, 0);
-               } else if (!tx_status(pbpctl_dev_b)) {
+               else if (!tx_status(pbpctl_dev_b))
                        set_tx(pbpctl_dev_b, 1);
-               }
        } else if ((!link1) && (tx_status(pbpctl_dev))) {
-               if ((link2) && (tx_status(pbpctl_dev_b))) {
+               if ((link2) && (tx_status(pbpctl_dev_b)))
                        set_tx(pbpctl_dev_b, 0);
-               }
        } else if ((link1) && (!tx_status(pbpctl_dev))) {
-               if ((link2) && (tx_status(pbpctl_dev_b))) {
+               if ((link2) && (tx_status(pbpctl_dev_b)))
                        set_tx(pbpctl_dev, 1);
-               }
        } else if ((!link1) && (!tx_status(pbpctl_dev))) {
-               if ((link2) && (tx_status(pbpctl_dev_b))) {
+               if ((link2) && (tx_status(pbpctl_dev_b)))
                        set_tx(pbpctl_dev, 1);
-               }
        }
 
        mod_timer(&pbpctl_dev->bp_tpl_timer, jiffies + BP_LINK_MON_DELAY * HZ);
@@ -5111,9 +5124,9 @@ int get_bypass_tpl_auto(bpctl_dev_t *pbpctl_dev)
 {
        if (!pbpctl_dev)
                return -1;
-       if (pbpctl_dev->bp_caps & TPL_CAP) {
+       if (pbpctl_dev->bp_caps & TPL_CAP)
                return pbpctl_dev->bp_tpl_flag;
-       }
+
        return BP_NOT_CAP;
 }
 
@@ -5128,7 +5141,8 @@ int set_tpl_fn(bpctl_dev_t *pbpctl_dev, int tpl_mode)
 
        if (pbpctl_dev->bp_caps & TPL_CAP) {
                if (tpl_mode) {
-                       if ((pbpctl_dev_b = get_status_port_fn(pbpctl_dev)))
+                       pbpctl_dev_b = get_status_port_fn(pbpctl_dev);
+                       if (pbpctl_dev_b)
                                set_tx(pbpctl_dev_b, 1);
                        set_tx(pbpctl_dev, 1);
                }
@@ -5345,7 +5359,8 @@ static void if_scan_init(void)
                memcpy(&cbuf, drvinfo.bus_info, 32);
                buf = &cbuf[0];
 
-               while (*buf++ != ':') ;
+               while (*buf++ != ':')
+                       ;
                for (i = 0; i < 10; i++, buf++) {
                        if (*buf == ':')
                                break;
@@ -5394,7 +5409,8 @@ static long device_ioctl(struct file *file,       /* see include/linux/fs.h */
        static bpctl_dev_t *pbpctl_dev;
 
        /* lock_kernel(); */
-       lock_bpctl();
+       if (down_interruptible(&bpctl_sema))
+               return -ERESTARTSYS;
        /* local_irq_save(flags); */
        /* if(!spin_trylock_irqsave(&bpvm_lock)){
           local_irq_restore(flags);
@@ -5438,9 +5454,9 @@ static long device_ioctl(struct file *file,       /* see include/linux/fs.h */
                return -1;
        }
 
-/*     preempt_disable();
+/*     preempt_disable();
        rcu_read_lock();
-       spin_lock_irqsave(&bpvm_lock, flags);
+       spin_lock_irqsave(&bpvm_lock, flags);
 */
        if ((bpctl_cmd.in_param[5]) ||
            (bpctl_cmd.in_param[6]) || (bpctl_cmd.in_param[7]))
@@ -5787,7 +5803,7 @@ static const struct file_operations Fops = {
 };
 
 #ifndef PCI_DEVICE
-#define PCI_DEVICE(vend,dev) \
+#define PCI_DEVICE(vend, dev) \
        .vendor = (vend), .device = (dev), \
        .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
 #endif
@@ -5795,7 +5811,7 @@ static const struct file_operations Fops = {
 #define SILICOM_E1000BP_ETHERNET_DEVICE(device_id) {\
        PCI_DEVICE(SILICOM_VID, device_id)}
 
-typedef enum {
+enum board_type {
        PXG2BPFI,
        PXG2BPFIL,
        PXG2BPFILX,
@@ -5953,7 +5969,7 @@ typedef enum {
        PE310G4BPi9SR,
        PE310G4BPi9LR,
        PE210G2BPi40,
-} board_t;
+};
 
 typedef struct _bpmod_info_t {
        unsigned int vendor;
@@ -6629,7 +6645,7 @@ static void find_fw(bpctl_dev_t *dev)
                            ioremap(mmio_start, mmio_len);
 
                        dev->bp_fw_ver = bypass_fw_ver(dev);
-                       if (dev-> bp_fw_ver == 0xa8)
+                       if (dev->bp_fw_ver == 0xa8)
                                break;
                }
        }
@@ -6708,7 +6724,8 @@ static int init_one(bpctl_dev_t *dev, bpmod_info_t *info, struct pci_dev *pdev1)
                        reset_cont(dev);
        }
 #ifdef BP_SELF_TEST
-       if ((dev->bp_tx_data = kzalloc(BPTEST_DATA_LEN, GFP_KERNEL))) {
+       dev->bp_tx_data = kzalloc(BPTEST_DATA_LEN, GFP_KERNEL);
+       if (dev->bp_tx_data) {
                memset(dev->bp_tx_data, 0xff, 6);
                memset(dev->bp_tx_data + 6, 0x0, 1);
                memset(dev->bp_tx_data + 7, 0xaa, 5);
@@ -6878,59 +6895,69 @@ int is_bypass_sd(int ifindex)
 {
        return is_bypass(get_dev_idx_p(ifindex));
 }
+EXPORT_SYMBOL(is_bypass_sd);
 
 int set_bypass_sd(int ifindex, int bypass_mode)
 {
 
        return set_bypass_fn(get_dev_idx_p(ifindex), bypass_mode);
 }
+EXPORT_SYMBOL(set_bypass_sd);
 
 int get_bypass_sd(int ifindex)
 {
 
        return get_bypass_fn(get_dev_idx_p(ifindex));
 }
+EXPORT_SYMBOL(get_bypass_sd);
 
 int get_bypass_change_sd(int ifindex)
 {
 
        return get_bypass_change_fn(get_dev_idx_p(ifindex));
 }
+EXPORT_SYMBOL(get_bypass_change_sd);
 
 int set_dis_bypass_sd(int ifindex, int dis_param)
 {
        return set_dis_bypass_fn(get_dev_idx_p(ifindex), dis_param);
 }
+EXPORT_SYMBOL(set_dis_bypass_sd);
 
 int get_dis_bypass_sd(int ifindex)
 {
 
        return get_dis_bypass_fn(get_dev_idx_p(ifindex));
 }
+EXPORT_SYMBOL(get_dis_bypass_sd);
 
 int set_bypass_pwoff_sd(int ifindex, int bypass_mode)
 {
        return set_bypass_pwoff_fn(get_dev_idx_p(ifindex), bypass_mode);
 
 }
+EXPORT_SYMBOL(set_bypass_pwoff_sd);
 
 int get_bypass_pwoff_sd(int ifindex)
 {
        return get_bypass_pwoff_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bypass_pwoff_sd);
 
 int set_bypass_pwup_sd(int ifindex, int bypass_mode)
 {
        return set_bypass_pwup_fn(get_dev_idx_p(ifindex), bypass_mode);
 
 }
+EXPORT_SYMBOL(set_bypass_pwup_sd);
 
 int get_bypass_pwup_sd(int ifindex)
 {
        return get_bypass_pwup_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bypass_pwup_sd);
 
 int set_bypass_wd_sd(int if_index, int ms_timeout, int *ms_timeout_set)
 {
@@ -6939,136 +6966,159 @@ int set_bypass_wd_sd(int if_index, int ms_timeout, int *ms_timeout_set)
        *ms_timeout_set = set_bypass_wd_fn(get_dev_idx_p(if_index), ms_timeout);
        return 0;
 }
+EXPORT_SYMBOL(set_bypass_wd_sd);
 
 int get_bypass_wd_sd(int ifindex, int *timeout)
 {
        return get_bypass_wd_fn(get_dev_idx_p(ifindex), timeout);
 
 }
+EXPORT_SYMBOL(get_bypass_wd_sd);
 
 int get_wd_expire_time_sd(int ifindex, int *time_left)
 {
        return get_wd_expire_time_fn(get_dev_idx_p(ifindex), time_left);
 }
+EXPORT_SYMBOL(get_wd_expire_time_sd);
 
 int reset_bypass_wd_timer_sd(int ifindex)
 {
        return reset_bypass_wd_timer_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(reset_bypass_wd_timer_sd);
 
 int get_wd_set_caps_sd(int ifindex)
 {
        return get_wd_set_caps_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_wd_set_caps_sd);
 
 int set_std_nic_sd(int ifindex, int nic_mode)
 {
        return set_std_nic_fn(get_dev_idx_p(ifindex), nic_mode);
 
 }
+EXPORT_SYMBOL(set_std_nic_sd);
 
 int get_std_nic_sd(int ifindex)
 {
        return get_std_nic_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_std_nic_sd);
 
 int set_tap_sd(int ifindex, int tap_mode)
 {
        return set_tap_fn(get_dev_idx_p(ifindex), tap_mode);
 
 }
+EXPORT_SYMBOL(set_tap_sd);
 
 int get_tap_sd(int ifindex)
 {
        return get_tap_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_tap_sd);
 
 int set_tap_pwup_sd(int ifindex, int tap_mode)
 {
        return set_tap_pwup_fn(get_dev_idx_p(ifindex), tap_mode);
 
 }
+EXPORT_SYMBOL(set_tap_pwup_sd);
 
 int get_tap_pwup_sd(int ifindex)
 {
        return get_tap_pwup_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_tap_pwup_sd);
 
 int get_tap_change_sd(int ifindex)
 {
        return get_tap_change_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_tap_change_sd);
 
 int set_dis_tap_sd(int ifindex, int dis_param)
 {
        return set_dis_tap_fn(get_dev_idx_p(ifindex), dis_param);
 
 }
+EXPORT_SYMBOL(set_dis_tap_sd);
 
 int get_dis_tap_sd(int ifindex)
 {
        return get_dis_tap_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_dis_tap_sd);
 
 int set_bp_disc_sd(int ifindex, int disc_mode)
 {
        return set_disc_fn(get_dev_idx_p(ifindex), disc_mode);
 
 }
+EXPORT_SYMBOL(set_bp_disc_sd);
 
 int get_bp_disc_sd(int ifindex)
 {
        return get_disc_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bp_disc_sd);
 
 int set_bp_disc_pwup_sd(int ifindex, int disc_mode)
 {
        return set_disc_pwup_fn(get_dev_idx_p(ifindex), disc_mode);
 
 }
+EXPORT_SYMBOL(set_bp_disc_pwup_sd);
 
 int get_bp_disc_pwup_sd(int ifindex)
 {
        return get_disc_pwup_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bp_disc_pwup_sd);
 
 int get_bp_disc_change_sd(int ifindex)
 {
        return get_disc_change_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bp_disc_change_sd);
 
 int set_bp_dis_disc_sd(int ifindex, int dis_param)
 {
        return set_dis_disc_fn(get_dev_idx_p(ifindex), dis_param);
 
 }
+EXPORT_SYMBOL(set_bp_dis_disc_sd);
 
 int get_bp_dis_disc_sd(int ifindex)
 {
        return get_dis_disc_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bp_dis_disc_sd);
 
 int get_wd_exp_mode_sd(int ifindex)
 {
        return get_wd_exp_mode_fn(get_dev_idx_p(ifindex));
 }
+EXPORT_SYMBOL(get_wd_exp_mode_sd);
 
 int set_wd_exp_mode_sd(int ifindex, int param)
 {
        return set_wd_exp_mode_fn(get_dev_idx_p(ifindex), param);
 
 }
+EXPORT_SYMBOL(set_wd_exp_mode_sd);
 
 int reset_cont_sd(int ifindex)
 {
@@ -7081,35 +7131,41 @@ int set_tx_sd(int ifindex, int tx_state)
        return set_tx_fn(get_dev_idx_p(ifindex), tx_state);
 
 }
+EXPORT_SYMBOL(set_tx_sd);
 
 int set_tpl_sd(int ifindex, int tpl_state)
 {
        return set_tpl_fn(get_dev_idx_p(ifindex), tpl_state);
 
 }
+EXPORT_SYMBOL(set_tpl_sd);
 
 int set_bp_hw_reset_sd(int ifindex, int status)
 {
        return set_bp_hw_reset_fn(get_dev_idx_p(ifindex), status);
 
 }
+EXPORT_SYMBOL(set_bp_hw_reset_sd);
 
 int set_wd_autoreset_sd(int ifindex, int param)
 {
        return set_wd_autoreset_fn(get_dev_idx_p(ifindex), param);
 
 }
+EXPORT_SYMBOL(set_wd_autoreset_sd);
 
 int get_wd_autoreset_sd(int ifindex)
 {
        return get_wd_autoreset_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_wd_autoreset_sd);
 
 int get_bypass_caps_sd(int ifindex)
 {
        return get_bypass_caps_fn(get_dev_idx_p(ifindex));
 }
+EXPORT_SYMBOL(get_bypass_caps_sd);
 
 int get_bypass_slave_sd(int ifindex)
 {
@@ -7120,81 +7176,41 @@ int get_bypass_slave_sd(int ifindex)
        return -1;
 
 }
+EXPORT_SYMBOL(get_bypass_slave_sd);
 
 int get_tx_sd(int ifindex)
 {
        return get_tx_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_tx_sd);
 
 int get_tpl_sd(int ifindex)
 {
        return get_tpl_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_tpl_sd);
 
 int get_bp_hw_reset_sd(int ifindex)
 {
        return get_bp_hw_reset_fn(get_dev_idx_p(ifindex));
 
 }
+EXPORT_SYMBOL(get_bp_hw_reset_sd);
 
 int get_bypass_info_sd(int ifindex, struct bp_info *bp_info)
 {
        return get_bypass_info_fn(get_dev_idx_p(ifindex), bp_info->prod_name, &bp_info->fw_ver);
 }
+EXPORT_SYMBOL(get_bypass_info_sd);
 
 int bp_if_scan_sd(void)
 {
        if_scan_init();
        return 0;
 }
-
-EXPORT_SYMBOL_NOVERS(is_bypass_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_slave_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_caps_sd);
-EXPORT_SYMBOL_NOVERS(get_wd_set_caps_sd);
-EXPORT_SYMBOL_NOVERS(set_bypass_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_change_sd);
-EXPORT_SYMBOL_NOVERS(set_dis_bypass_sd);
-EXPORT_SYMBOL_NOVERS(get_dis_bypass_sd);
-EXPORT_SYMBOL_NOVERS(set_bypass_pwoff_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_pwoff_sd);
-EXPORT_SYMBOL_NOVERS(set_bypass_pwup_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_pwup_sd);
-EXPORT_SYMBOL_NOVERS(set_bypass_wd_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_wd_sd);
-EXPORT_SYMBOL_NOVERS(get_wd_expire_time_sd);
-EXPORT_SYMBOL_NOVERS(reset_bypass_wd_timer_sd);
-EXPORT_SYMBOL_NOVERS(set_std_nic_sd);
-EXPORT_SYMBOL_NOVERS(get_std_nic_sd);
-EXPORT_SYMBOL_NOVERS(set_tx_sd);
-EXPORT_SYMBOL_NOVERS(get_tx_sd);
-EXPORT_SYMBOL_NOVERS(set_tpl_sd);
-EXPORT_SYMBOL_NOVERS(get_tpl_sd);
-EXPORT_SYMBOL_NOVERS(set_bp_hw_reset_sd);
-EXPORT_SYMBOL_NOVERS(get_bp_hw_reset_sd);
-EXPORT_SYMBOL_NOVERS(set_tap_sd);
-EXPORT_SYMBOL_NOVERS(get_tap_sd);
-EXPORT_SYMBOL_NOVERS(get_tap_change_sd);
-EXPORT_SYMBOL_NOVERS(set_dis_tap_sd);
-EXPORT_SYMBOL_NOVERS(get_dis_tap_sd);
-EXPORT_SYMBOL_NOVERS(set_tap_pwup_sd);
-EXPORT_SYMBOL_NOVERS(get_tap_pwup_sd);
-EXPORT_SYMBOL_NOVERS(set_wd_exp_mode_sd);
-EXPORT_SYMBOL_NOVERS(get_wd_exp_mode_sd);
-EXPORT_SYMBOL_NOVERS(set_wd_autoreset_sd);
-EXPORT_SYMBOL_NOVERS(get_wd_autoreset_sd);
-EXPORT_SYMBOL_NOVERS(set_bp_disc_sd);
-EXPORT_SYMBOL_NOVERS(get_bp_disc_sd);
-EXPORT_SYMBOL_NOVERS(get_bp_disc_change_sd);
-EXPORT_SYMBOL_NOVERS(set_bp_dis_disc_sd);
-EXPORT_SYMBOL_NOVERS(get_bp_dis_disc_sd);
-EXPORT_SYMBOL_NOVERS(set_bp_disc_pwup_sd);
-EXPORT_SYMBOL_NOVERS(get_bp_disc_pwup_sd);
-EXPORT_SYMBOL_NOVERS(get_bypass_info_sd);
-EXPORT_SYMBOL_NOVERS(bp_if_scan_sd);
+EXPORT_SYMBOL(bp_if_scan_sd);
 
 #define BP_PROC_DIR "bypass"
 
@@ -7263,7 +7279,7 @@ static int show_bypass_slave(struct seq_file *m, void *v)
        if (!slave)
                slave = dev;
        if (!slave)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (slave->ndev)
                seq_printf(m, "%s\n", slave->ndev->name);
        return 0;
@@ -7275,7 +7291,7 @@ static int show_bypass_caps(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bypass_caps_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "-1\n");
+               seq_puts(m, "-1\n");
        else
                seq_printf(m, "0x%x\n", ret);
        return 0;
@@ -7287,7 +7303,7 @@ static int show_wd_set_caps(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_wd_set_caps_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "-1\n");
+               seq_puts(m, "-1\n");
        else
                seq_printf(m, "0x%x\n", ret);
        return 0;
@@ -7333,11 +7349,11 @@ static int show_bypass(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bypass_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        return 0;
 }
 RW_FOPS(bypass)
@@ -7357,11 +7373,11 @@ static int show_tap(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_tap_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        return 0;
 }
 RW_FOPS(tap)
@@ -7381,11 +7397,11 @@ static int show_disc(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_disc_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        return 0;
 }
 RW_FOPS(disc)
@@ -7395,11 +7411,11 @@ static int show_bypass_change(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bypass_change_fn(dev);
        if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        return 0;
 }
 RO_FOPS(bypass_change)
@@ -7409,11 +7425,11 @@ static int show_tap_change(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_tap_change_fn(dev);
        if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        return 0;
 }
 RO_FOPS(tap_change)
@@ -7423,11 +7439,11 @@ static int show_disc_change(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_disc_change_fn(dev);
        if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        return 0;
 }
 RO_FOPS(disc_change)
@@ -7450,11 +7466,11 @@ static int show_bypass_wd(struct seq_file *m, void *v)
 
        ret = get_bypass_wd_fn(dev, &timeout);
        if (ret == BP_NOT_CAP)
-               seq_printf(m,  "fail\n");
+               seq_puts(m,  "fail\n");
        else if (timeout == -1)
-               seq_printf(m,  "unknown\n");
+               seq_puts(m,  "unknown\n");
        else if (timeout == 0)
-               seq_printf(m,  "disable\n");
+               seq_puts(m,  "disable\n");
        else
                seq_printf(m, "%d\n", timeout);
        return 0;
@@ -7467,11 +7483,11 @@ static int show_wd_expire_time(struct seq_file *m, void *v)
        int ret = 0, timeout = 0;
        ret = get_wd_expire_time_fn(dev, &timeout);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (timeout == -1)
-               seq_printf(m, "expire\n");
+               seq_puts(m, "expire\n");
        else if (timeout == 0)
-               seq_printf(m, "disable\n");
+               seq_puts(m, "disable\n");
        else
                seq_printf(m, "%d\n", timeout);
        return 0;
@@ -7494,11 +7510,11 @@ static int show_tpl(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_tpl_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        return 0;
 }
 RW_FOPS(tpl)
@@ -7520,11 +7536,11 @@ static int show_wait_at_pwup(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bp_wait_at_pwup_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        return 0;
 }
 RW_FOPS(wait_at_pwup)
@@ -7545,11 +7561,11 @@ static int show_hw_reset(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bp_hw_reset_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 1)
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        return 0;
 }
 RW_FOPS(hw_reset)
@@ -7561,11 +7577,11 @@ static int show_reset_bypass_wd(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = reset_bypass_wd_timer_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "disable\n");
+               seq_puts(m, "disable\n");
        else if (ret == 1)
-               seq_printf(m, "success\n");
+               seq_puts(m, "success\n");
        return 0;
 }
 RO_FOPS(reset_bypass_wd)
@@ -7585,11 +7601,11 @@ static int show_dis_bypass(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_dis_bypass_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(dis_bypass)
@@ -7609,11 +7625,11 @@ static int show_dis_tap(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_dis_tap_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(dis_tap)
@@ -7633,11 +7649,11 @@ static int show_dis_disc(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_dis_disc_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(dis_disc)
@@ -7657,11 +7673,11 @@ static int show_bypass_pwup(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bypass_pwup_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(bypass_pwup)
@@ -7681,11 +7697,11 @@ static int show_bypass_pwoff(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_bypass_pwoff_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(bypass_pwoff)
@@ -7705,11 +7721,11 @@ static int show_tap_pwup(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_tap_pwup_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(tap_pwup)
@@ -7729,11 +7745,11 @@ static int show_disc_pwup(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_disc_pwup_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(disc_pwup)
@@ -7753,11 +7769,11 @@ static int show_std_nic(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_std_nic_fn(dev);
        if (ret == BP_NOT_CAP)
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        else if (ret == 0)
-               seq_printf(m, "off\n");
+               seq_puts(m, "off\n");
        else
-               seq_printf(m, "on\n");
+               seq_puts(m, "on\n");
        return 0;
 }
 RW_FOPS(std_nic)
@@ -7795,13 +7811,13 @@ static int show_wd_exp_mode(struct seq_file *m, void *v)
        bpctl_dev_t *dev = m->private;
        int ret = get_wd_exp_mode_fn(dev);
        if (ret == 1)
-               seq_printf(m, "tap\n");
+               seq_puts(m, "tap\n");
        else if (ret == 0)
-               seq_printf(m, "bypass\n");
+               seq_puts(m, "bypass\n");
        else if (ret == 2)
-               seq_printf(m, "disc\n");
+               seq_puts(m, "disc\n");
        else
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        return 0;
 }
 RW_FOPS(wd_exp_mode)
@@ -7823,7 +7839,7 @@ static int show_wd_autoreset(struct seq_file *m, void *v)
        if (ret >= 0)
                seq_printf(m, "%d\n", ret);
        else
-               seq_printf(m, "fail\n");
+               seq_puts(m, "fail\n");
        return 0;
 }
 RW_FOPS(wd_autoreset)
@@ -7831,7 +7847,7 @@ RW_FOPS(wd_autoreset)
 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;
+       static struct proc_dir_entry *procfs_dir;
        int ret = 0;
 
        if (!pbp_device_block->ndev)
@@ -7851,7 +7867,8 @@ int bypass_proc_create_dev_sd(bpctl_dev_t *pbp_device_block)
        }
        current_pfs->bypass_entry = procfs_dir;
 
-#define ENTRY(x) ret |= procfs_add(#x, &x##_ops, pbp_device_block)
+#define ENTRY(x) (ret |= procfs_add(#x, &x##_ops, pbp_device_block))
+
        ENTRY(bypass_info);
        if (pbp_device_block->bp_caps & SW_CTL_CAP) {
                /* Create set param proc's */