tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

net: usb: lan78xx: Remove lots of set but unused 'ret' variables

Fixes the following W=1 kernel build warning(s):

drivers/net/usb/lan78xx.c: In function ‘lan78xx_read_raw_otp’:
drivers/net/usb/lan78xx.c:825:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_write_raw_otp’:
drivers/net/usb/lan78xx.c:879:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_deferred_multicast_write’:
drivers/net/usb/lan78xx.c:1041:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_update_flowcontrol’:
drivers/net/usb/lan78xx.c:1127:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_init_mac_address’:
drivers/net/usb/lan78xx.c:1666:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_link_status_change’:
drivers/net/usb/lan78xx.c:1841:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_irq_bus_sync_unlock’:
drivers/net/usb/lan78xx.c:1920:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan8835_fixup’:
drivers/net/usb/lan78xx.c:1994:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_set_rx_max_frame_length’:
drivers/net/usb/lan78xx.c:2192:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_change_mtu’:
drivers/net/usb/lan78xx.c:2270:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_set_mac_addr’:
drivers/net/usb/lan78xx.c:2299:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_set_features’:
drivers/net/usb/lan78xx.c:2333:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]
drivers/net/usb/lan78xx.c: In function ‘lan78xx_set_suspend’:
drivers/net/usb/lan78xx.c:3807:6: warning: variable ‘ret’ set but not used [-Wunused-but-set-variable]

Signed-off-by: Lee Jones <lee.jones@linaro.org>
Link: https://lore.kernel.org/r/20201102114512.1062724-25-lee.jones@linaro.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

authored by

Lee Jones and committed by
Jakub Kicinski 06cd7c46 800a328b

+78 -90
+78 -90
drivers/net/usb/lan78xx.c
··· 822 822 u32 length, u8 *data) 823 823 { 824 824 int i; 825 - int ret; 826 825 u32 buf; 827 826 unsigned long timeout; 828 827 829 - ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 828 + lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 830 829 831 830 if (buf & OTP_PWR_DN_PWRDN_N_) { 832 831 /* clear it and wait to be cleared */ 833 - ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0); 832 + lan78xx_write_reg(dev, OTP_PWR_DN, 0); 834 833 835 834 timeout = jiffies + HZ; 836 835 do { 837 836 usleep_range(1, 10); 838 - ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 837 + lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 839 838 if (time_after(jiffies, timeout)) { 840 839 netdev_warn(dev->net, 841 840 "timeout on OTP_PWR_DN"); ··· 844 845 } 845 846 846 847 for (i = 0; i < length; i++) { 847 - ret = lan78xx_write_reg(dev, OTP_ADDR1, 848 + lan78xx_write_reg(dev, OTP_ADDR1, 848 849 ((offset + i) >> 8) & OTP_ADDR1_15_11); 849 - ret = lan78xx_write_reg(dev, OTP_ADDR2, 850 + lan78xx_write_reg(dev, OTP_ADDR2, 850 851 ((offset + i) & OTP_ADDR2_10_3)); 851 852 852 - ret = lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_); 853 - ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_); 853 + lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_); 854 + lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_); 854 855 855 856 timeout = jiffies + HZ; 856 857 do { 857 858 udelay(1); 858 - ret = lan78xx_read_reg(dev, OTP_STATUS, &buf); 859 + lan78xx_read_reg(dev, OTP_STATUS, &buf); 859 860 if (time_after(jiffies, timeout)) { 860 861 netdev_warn(dev->net, 861 862 "timeout on OTP_STATUS"); ··· 863 864 } 864 865 } while (buf & OTP_STATUS_BUSY_); 865 866 866 - ret = lan78xx_read_reg(dev, OTP_RD_DATA, &buf); 867 + lan78xx_read_reg(dev, OTP_RD_DATA, &buf); 867 868 868 869 data[i] = (u8)(buf & 0xFF); 869 870 } ··· 875 876 u32 length, u8 *data) 876 877 { 877 878 int i; 878 - int ret; 879 879 u32 buf; 880 880 unsigned long timeout; 881 881 882 - ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 882 + lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 883 883 884 884 if (buf & OTP_PWR_DN_PWRDN_N_) { 885 885 /* clear it and wait to be cleared */ 886 - ret = lan78xx_write_reg(dev, OTP_PWR_DN, 0); 886 + lan78xx_write_reg(dev, OTP_PWR_DN, 0); 887 887 888 888 timeout = jiffies + HZ; 889 889 do { 890 890 udelay(1); 891 - ret = lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 891 + lan78xx_read_reg(dev, OTP_PWR_DN, &buf); 892 892 if (time_after(jiffies, timeout)) { 893 893 netdev_warn(dev->net, 894 894 "timeout on OTP_PWR_DN completion"); ··· 897 899 } 898 900 899 901 /* set to BYTE program mode */ 900 - ret = lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_); 902 + lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_); 901 903 902 904 for (i = 0; i < length; i++) { 903 - ret = lan78xx_write_reg(dev, OTP_ADDR1, 905 + lan78xx_write_reg(dev, OTP_ADDR1, 904 906 ((offset + i) >> 8) & OTP_ADDR1_15_11); 905 - ret = lan78xx_write_reg(dev, OTP_ADDR2, 907 + lan78xx_write_reg(dev, OTP_ADDR2, 906 908 ((offset + i) & OTP_ADDR2_10_3)); 907 - ret = lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]); 908 - ret = lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_); 909 - ret = lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_); 909 + lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]); 910 + lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_); 911 + lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_); 910 912 911 913 timeout = jiffies + HZ; 912 914 do { 913 915 udelay(1); 914 - ret = lan78xx_read_reg(dev, OTP_STATUS, &buf); 916 + lan78xx_read_reg(dev, OTP_STATUS, &buf); 915 917 if (time_after(jiffies, timeout)) { 916 918 netdev_warn(dev->net, 917 919 "Timeout on OTP_STATUS completion"); ··· 1036 1038 container_of(param, struct lan78xx_priv, set_multicast); 1037 1039 struct lan78xx_net *dev = pdata->dev; 1038 1040 int i; 1039 - int ret; 1040 1041 1041 1042 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n", 1042 1043 pdata->rfe_ctl); ··· 1044 1047 DP_SEL_VHF_HASH_LEN, pdata->mchash_table); 1045 1048 1046 1049 for (i = 1; i < NUM_OF_MAF; i++) { 1047 - ret = lan78xx_write_reg(dev, MAF_HI(i), 0); 1048 - ret = lan78xx_write_reg(dev, MAF_LO(i), 1050 + lan78xx_write_reg(dev, MAF_HI(i), 0); 1051 + lan78xx_write_reg(dev, MAF_LO(i), 1049 1052 pdata->pfilter_table[i][1]); 1050 - ret = lan78xx_write_reg(dev, MAF_HI(i), 1053 + lan78xx_write_reg(dev, MAF_HI(i), 1051 1054 pdata->pfilter_table[i][0]); 1052 1055 } 1053 1056 1054 - ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl); 1057 + lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl); 1055 1058 } 1056 1059 1057 1060 static void lan78xx_set_multicast(struct net_device *netdev) ··· 1121 1124 u16 lcladv, u16 rmtadv) 1122 1125 { 1123 1126 u32 flow = 0, fct_flow = 0; 1124 - int ret; 1125 1127 u8 cap; 1126 1128 1127 1129 if (dev->fc_autoneg) ··· 1143 1147 (cap & FLOW_CTRL_RX ? "enabled" : "disabled"), 1144 1148 (cap & FLOW_CTRL_TX ? "enabled" : "disabled")); 1145 1149 1146 - ret = lan78xx_write_reg(dev, FCT_FLOW, fct_flow); 1150 + lan78xx_write_reg(dev, FCT_FLOW, fct_flow); 1147 1151 1148 1152 /* threshold value should be set before enabling flow */ 1149 - ret = lan78xx_write_reg(dev, FLOW, flow); 1153 + lan78xx_write_reg(dev, FLOW, flow); 1150 1154 1151 1155 return 0; 1152 1156 } ··· 1659 1663 static void lan78xx_init_mac_address(struct lan78xx_net *dev) 1660 1664 { 1661 1665 u32 addr_lo, addr_hi; 1662 - int ret; 1663 1666 u8 addr[6]; 1664 1667 1665 - ret = lan78xx_read_reg(dev, RX_ADDRL, &addr_lo); 1666 - ret = lan78xx_read_reg(dev, RX_ADDRH, &addr_hi); 1668 + lan78xx_read_reg(dev, RX_ADDRL, &addr_lo); 1669 + lan78xx_read_reg(dev, RX_ADDRH, &addr_hi); 1667 1670 1668 1671 addr[0] = addr_lo & 0xFF; 1669 1672 addr[1] = (addr_lo >> 8) & 0xFF; ··· 1695 1700 (addr[2] << 16) | (addr[3] << 24); 1696 1701 addr_hi = addr[4] | (addr[5] << 8); 1697 1702 1698 - ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo); 1699 - ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi); 1703 + lan78xx_write_reg(dev, RX_ADDRL, addr_lo); 1704 + lan78xx_write_reg(dev, RX_ADDRH, addr_hi); 1700 1705 } 1701 1706 1702 - ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo); 1703 - ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_); 1707 + lan78xx_write_reg(dev, MAF_LO(0), addr_lo); 1708 + lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_); 1704 1709 1705 1710 ether_addr_copy(dev->net->dev_addr, addr); 1706 1711 } ··· 1833 1838 static void lan78xx_link_status_change(struct net_device *net) 1834 1839 { 1835 1840 struct phy_device *phydev = net->phydev; 1836 - int ret, temp; 1841 + int temp; 1837 1842 1838 1843 /* At forced 100 F/H mode, chip may fail to set mode correctly 1839 1844 * when cable is switched between long(~50+m) and short one. ··· 1844 1849 /* disable phy interrupt */ 1845 1850 temp = phy_read(phydev, LAN88XX_INT_MASK); 1846 1851 temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_; 1847 - ret = phy_write(phydev, LAN88XX_INT_MASK, temp); 1852 + phy_write(phydev, LAN88XX_INT_MASK, temp); 1848 1853 1849 1854 temp = phy_read(phydev, MII_BMCR); 1850 1855 temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000); ··· 1858 1863 /* enable phy interrupt back */ 1859 1864 temp = phy_read(phydev, LAN88XX_INT_MASK); 1860 1865 temp |= LAN88XX_INT_MASK_MDINTPIN_EN_; 1861 - ret = phy_write(phydev, LAN88XX_INT_MASK, temp); 1866 + phy_write(phydev, LAN88XX_INT_MASK, temp); 1862 1867 } 1863 1868 } 1864 1869 ··· 1912 1917 struct lan78xx_net *dev = 1913 1918 container_of(data, struct lan78xx_net, domain_data); 1914 1919 u32 buf; 1915 - int ret; 1916 1920 1917 1921 /* call register access here because irq_bus_lock & irq_bus_sync_unlock 1918 1922 * are only two callbacks executed in non-atomic contex. 1919 1923 */ 1920 - ret = lan78xx_read_reg(dev, INT_EP_CTL, &buf); 1924 + lan78xx_read_reg(dev, INT_EP_CTL, &buf); 1921 1925 if (buf != data->irqenable) 1922 - ret = lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable); 1926 + lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable); 1923 1927 1924 1928 mutex_unlock(&data->irq_lock); 1925 1929 } ··· 1985 1991 static int lan8835_fixup(struct phy_device *phydev) 1986 1992 { 1987 1993 int buf; 1988 - int ret; 1989 1994 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev); 1990 1995 1991 1996 /* LED2/PME_N/IRQ_N/RGMII_ID pin to IRQ_N mode */ ··· 1994 2001 phy_write_mmd(phydev, MDIO_MMD_PCS, 0x8010, buf); 1995 2002 1996 2003 /* RGMII MAC TXC Delay Enable */ 1997 - ret = lan78xx_write_reg(dev, MAC_RGMII_ID, 2004 + lan78xx_write_reg(dev, MAC_RGMII_ID, 1998 2005 MAC_RGMII_ID_TXC_DELAY_EN_); 1999 2006 2000 2007 /* RGMII TX DLL Tune Adjust */ 2001 - ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00); 2008 + lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00); 2002 2009 2003 2010 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID; 2004 2011 ··· 2182 2189 2183 2190 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size) 2184 2191 { 2185 - int ret = 0; 2186 2192 u32 buf; 2187 2193 bool rxenabled; 2188 2194 2189 - ret = lan78xx_read_reg(dev, MAC_RX, &buf); 2195 + lan78xx_read_reg(dev, MAC_RX, &buf); 2190 2196 2191 2197 rxenabled = ((buf & MAC_RX_RXEN_) != 0); 2192 2198 2193 2199 if (rxenabled) { 2194 2200 buf &= ~MAC_RX_RXEN_; 2195 - ret = lan78xx_write_reg(dev, MAC_RX, buf); 2201 + lan78xx_write_reg(dev, MAC_RX, buf); 2196 2202 } 2197 2203 2198 2204 /* add 4 to size for FCS */ 2199 2205 buf &= ~MAC_RX_MAX_SIZE_MASK_; 2200 2206 buf |= (((size + 4) << MAC_RX_MAX_SIZE_SHIFT_) & MAC_RX_MAX_SIZE_MASK_); 2201 2207 2202 - ret = lan78xx_write_reg(dev, MAC_RX, buf); 2208 + lan78xx_write_reg(dev, MAC_RX, buf); 2203 2209 2204 2210 if (rxenabled) { 2205 2211 buf |= MAC_RX_RXEN_; 2206 - ret = lan78xx_write_reg(dev, MAC_RX, buf); 2212 + lan78xx_write_reg(dev, MAC_RX, buf); 2207 2213 } 2208 2214 2209 2215 return 0; ··· 2259 2267 int ll_mtu = new_mtu + netdev->hard_header_len; 2260 2268 int old_hard_mtu = dev->hard_mtu; 2261 2269 int old_rx_urb_size = dev->rx_urb_size; 2262 - int ret; 2263 2270 2264 2271 /* no second zero-length packet read wanted after mtu-sized packets */ 2265 2272 if ((ll_mtu % dev->maxpacket) == 0) 2266 2273 return -EDOM; 2267 2274 2268 - ret = lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN); 2275 + lan78xx_set_rx_max_frame_length(dev, new_mtu + VLAN_ETH_HLEN); 2269 2276 2270 2277 netdev->mtu = new_mtu; 2271 2278 ··· 2287 2296 struct lan78xx_net *dev = netdev_priv(netdev); 2288 2297 struct sockaddr *addr = p; 2289 2298 u32 addr_lo, addr_hi; 2290 - int ret; 2291 2299 2292 2300 if (netif_running(netdev)) 2293 2301 return -EBUSY; ··· 2303 2313 addr_hi = netdev->dev_addr[4] | 2304 2314 netdev->dev_addr[5] << 8; 2305 2315 2306 - ret = lan78xx_write_reg(dev, RX_ADDRL, addr_lo); 2307 - ret = lan78xx_write_reg(dev, RX_ADDRH, addr_hi); 2316 + lan78xx_write_reg(dev, RX_ADDRL, addr_lo); 2317 + lan78xx_write_reg(dev, RX_ADDRH, addr_hi); 2308 2318 2309 2319 /* Added to support MAC address changes */ 2310 - ret = lan78xx_write_reg(dev, MAF_LO(0), addr_lo); 2311 - ret = lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_); 2320 + lan78xx_write_reg(dev, MAF_LO(0), addr_lo); 2321 + lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_); 2312 2322 2313 2323 return 0; 2314 2324 } ··· 2320 2330 struct lan78xx_net *dev = netdev_priv(netdev); 2321 2331 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]); 2322 2332 unsigned long flags; 2323 - int ret; 2324 2333 2325 2334 spin_lock_irqsave(&pdata->rfe_ctl_lock, flags); 2326 2335 ··· 2343 2354 2344 2355 spin_unlock_irqrestore(&pdata->rfe_ctl_lock, flags); 2345 2356 2346 - ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl); 2357 + lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl); 2347 2358 2348 2359 return 0; 2349 2360 } ··· 3793 3804 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol) 3794 3805 { 3795 3806 u32 buf; 3796 - int ret; 3797 3807 int mask_index; 3798 3808 u16 crc; 3799 3809 u32 temp_wucsr; ··· 3801 3813 const u8 ipv6_multicast[3] = { 0x33, 0x33 }; 3802 3814 const u8 arp_type[2] = { 0x08, 0x06 }; 3803 3815 3804 - ret = lan78xx_read_reg(dev, MAC_TX, &buf); 3816 + lan78xx_read_reg(dev, MAC_TX, &buf); 3805 3817 buf &= ~MAC_TX_TXEN_; 3806 - ret = lan78xx_write_reg(dev, MAC_TX, buf); 3807 - ret = lan78xx_read_reg(dev, MAC_RX, &buf); 3818 + lan78xx_write_reg(dev, MAC_TX, buf); 3819 + lan78xx_read_reg(dev, MAC_RX, &buf); 3808 3820 buf &= ~MAC_RX_RXEN_; 3809 - ret = lan78xx_write_reg(dev, MAC_RX, buf); 3821 + lan78xx_write_reg(dev, MAC_RX, buf); 3810 3822 3811 - ret = lan78xx_write_reg(dev, WUCSR, 0); 3812 - ret = lan78xx_write_reg(dev, WUCSR2, 0); 3813 - ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL); 3823 + lan78xx_write_reg(dev, WUCSR, 0); 3824 + lan78xx_write_reg(dev, WUCSR2, 0); 3825 + lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL); 3814 3826 3815 3827 temp_wucsr = 0; 3816 3828 3817 3829 temp_pmt_ctl = 0; 3818 - ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl); 3830 + lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl); 3819 3831 temp_pmt_ctl &= ~PMT_CTL_RES_CLR_WKP_EN_; 3820 3832 temp_pmt_ctl |= PMT_CTL_RES_CLR_WKP_STS_; 3821 3833 3822 3834 for (mask_index = 0; mask_index < NUM_OF_WUF_CFG; mask_index++) 3823 - ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0); 3835 + lan78xx_write_reg(dev, WUF_CFG(mask_index), 0); 3824 3836 3825 3837 mask_index = 0; 3826 3838 if (wol & WAKE_PHY) { ··· 3849 3861 3850 3862 /* set WUF_CFG & WUF_MASK for IPv4 Multicast */ 3851 3863 crc = lan78xx_wakeframe_crc16(ipv4_multicast, 3); 3852 - ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 3864 + lan78xx_write_reg(dev, WUF_CFG(mask_index), 3853 3865 WUF_CFGX_EN_ | 3854 3866 WUF_CFGX_TYPE_MCAST_ | 3855 3867 (0 << WUF_CFGX_OFFSET_SHIFT_) | 3856 3868 (crc & WUF_CFGX_CRC16_MASK_)); 3857 3869 3858 - ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7); 3859 - ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0); 3860 - ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0); 3861 - ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0); 3870 + lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7); 3871 + lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0); 3872 + lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0); 3873 + lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0); 3862 3874 mask_index++; 3863 3875 3864 3876 /* for IPv6 Multicast */ 3865 3877 crc = lan78xx_wakeframe_crc16(ipv6_multicast, 2); 3866 - ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 3878 + lan78xx_write_reg(dev, WUF_CFG(mask_index), 3867 3879 WUF_CFGX_EN_ | 3868 3880 WUF_CFGX_TYPE_MCAST_ | 3869 3881 (0 << WUF_CFGX_OFFSET_SHIFT_) | 3870 3882 (crc & WUF_CFGX_CRC16_MASK_)); 3871 3883 3872 - ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3); 3873 - ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0); 3874 - ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0); 3875 - ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0); 3884 + lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3); 3885 + lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0); 3886 + lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0); 3887 + lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0); 3876 3888 mask_index++; 3877 3889 3878 3890 temp_pmt_ctl |= PMT_CTL_WOL_EN_; ··· 3893 3905 * for packettype (offset 12,13) = ARP (0x0806) 3894 3906 */ 3895 3907 crc = lan78xx_wakeframe_crc16(arp_type, 2); 3896 - ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 3908 + lan78xx_write_reg(dev, WUF_CFG(mask_index), 3897 3909 WUF_CFGX_EN_ | 3898 3910 WUF_CFGX_TYPE_ALL_ | 3899 3911 (0 << WUF_CFGX_OFFSET_SHIFT_) | 3900 3912 (crc & WUF_CFGX_CRC16_MASK_)); 3901 3913 3902 - ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000); 3903 - ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0); 3904 - ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0); 3905 - ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0); 3914 + lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000); 3915 + lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0); 3916 + lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0); 3917 + lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0); 3906 3918 mask_index++; 3907 3919 3908 3920 temp_pmt_ctl |= PMT_CTL_WOL_EN_; ··· 3910 3922 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_; 3911 3923 } 3912 3924 3913 - ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr); 3925 + lan78xx_write_reg(dev, WUCSR, temp_wucsr); 3914 3926 3915 3927 /* when multiple WOL bits are set */ 3916 3928 if (hweight_long((unsigned long)wol) > 1) { ··· 3918 3930 temp_pmt_ctl &= ~PMT_CTL_SUS_MODE_MASK_; 3919 3931 temp_pmt_ctl |= PMT_CTL_SUS_MODE_0_; 3920 3932 } 3921 - ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl); 3933 + lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl); 3922 3934 3923 3935 /* clear WUPS */ 3924 - ret = lan78xx_read_reg(dev, PMT_CTL, &buf); 3936 + lan78xx_read_reg(dev, PMT_CTL, &buf); 3925 3937 buf |= PMT_CTL_WUPS_MASK_; 3926 - ret = lan78xx_write_reg(dev, PMT_CTL, buf); 3938 + lan78xx_write_reg(dev, PMT_CTL, buf); 3927 3939 3928 - ret = lan78xx_read_reg(dev, MAC_RX, &buf); 3940 + lan78xx_read_reg(dev, MAC_RX, &buf); 3929 3941 buf |= MAC_RX_RXEN_; 3930 - ret = lan78xx_write_reg(dev, MAC_RX, buf); 3942 + lan78xx_write_reg(dev, MAC_RX, buf); 3931 3943 3932 3944 return 0; 3933 3945 }