smsc95xx.c (7b960c967f2aa01ab8f45c5a0bd78e754cffdeee) smsc95xx.c (3147242980c5f849978b424cf79dda4fef20716f)
1// SPDX-License-Identifier: GPL-2.0-or-later
2 /***************************************************************************
3 *
4 * Copyright (C) 2007-2008 SMSC
5 *
6 *****************************************************************************/
7
8#include <linux/module.h>

--- 64 unchanged lines hidden (view full) ---

73 struct phy_device *phydev;
74 struct task_struct *pm_task;
75};
76
77static bool turbo_mode = true;
78module_param(turbo_mode, bool, 0644);
79MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
80
1// SPDX-License-Identifier: GPL-2.0-or-later
2 /***************************************************************************
3 *
4 * Copyright (C) 2007-2008 SMSC
5 *
6 *****************************************************************************/
7
8#include <linux/module.h>

--- 64 unchanged lines hidden (view full) ---

73 struct phy_device *phydev;
74 struct task_struct *pm_task;
75};
76
77static bool turbo_mode = true;
78module_param(turbo_mode, bool, 0644);
79MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
80
81static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
82 u32 *data, int in_pm)
81static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
82 u32 *data)
83{
84 struct smsc95xx_priv *pdata = dev->driver_priv;
85 u32 buf;
86 int ret;
87 int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
88
89 BUG_ON(!dev);
90

--- 13 unchanged lines hidden (view full) ---

104 }
105
106 le32_to_cpus(&buf);
107 *data = buf;
108
109 return ret;
110}
111
83{
84 struct smsc95xx_priv *pdata = dev->driver_priv;
85 u32 buf;
86 int ret;
87 int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
88
89 BUG_ON(!dev);
90

--- 13 unchanged lines hidden (view full) ---

104 }
105
106 le32_to_cpus(&buf);
107 *data = buf;
108
109 return ret;
110}
111
112static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
113 u32 data, int in_pm)
112static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
113 u32 data)
114{
115 struct smsc95xx_priv *pdata = dev->driver_priv;
116 u32 buf;
117 int ret;
118 int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
119
120 BUG_ON(!dev);
121

--- 10 unchanged lines hidden (view full) ---

132 0, index, &buf, 4);
133 if (ret < 0 && ret != -ENODEV)
134 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
135 index, ret);
136
137 return ret;
138}
139
114{
115 struct smsc95xx_priv *pdata = dev->driver_priv;
116 u32 buf;
117 int ret;
118 int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
119
120 BUG_ON(!dev);
121

--- 10 unchanged lines hidden (view full) ---

132 0, index, &buf, 4);
133 if (ret < 0 && ret != -ENODEV)
134 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
135 index, ret);
136
137 return ret;
138}
139
140static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index,
141 u32 *data)
142{
143 return __smsc95xx_read_reg(dev, index, data, 1);
144}
145
146static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index,
147 u32 data)
148{
149 return __smsc95xx_write_reg(dev, index, data, 1);
150}
151
152static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
153 u32 *data)
154{
155 return __smsc95xx_read_reg(dev, index, data, 0);
156}
157
158static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
159 u32 data)
160{
161 return __smsc95xx_write_reg(dev, index, data, 0);
162}
163
164/* Loop until the read is completed with timeout
165 * called with phy_mutex held */
140/* Loop until the read is completed with timeout
141 * called with phy_mutex held */
166static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev,
167 int in_pm)
142static int __must_check smsc95xx_phy_wait_not_busy(struct usbnet *dev)
168{
169 unsigned long start_time = jiffies;
170 u32 val;
171 int ret;
172
173 do {
143{
144 unsigned long start_time = jiffies;
145 u32 val;
146 int ret;
147
148 do {
174 ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
149 ret = smsc95xx_read_reg(dev, MII_ADDR, &val);
175 if (ret < 0) {
176 /* Ignore -ENODEV error during disconnect() */
177 if (ret == -ENODEV)
178 return 0;
179 netdev_warn(dev->net, "Error reading MII_ACCESS\n");
180 return ret;
181 }
182

--- 4 unchanged lines hidden (view full) ---

187 return -EIO;
188}
189
190static u32 mii_address_cmd(int phy_id, int idx, u16 op)
191{
192 return (phy_id & 0x1f) << 11 | (idx & 0x1f) << 6 | op;
193}
194
150 if (ret < 0) {
151 /* Ignore -ENODEV error during disconnect() */
152 if (ret == -ENODEV)
153 return 0;
154 netdev_warn(dev->net, "Error reading MII_ACCESS\n");
155 return ret;
156 }
157

--- 4 unchanged lines hidden (view full) ---

162 return -EIO;
163}
164
165static u32 mii_address_cmd(int phy_id, int idx, u16 op)
166{
167 return (phy_id & 0x1f) << 11 | (idx & 0x1f) << 6 | op;
168}
169
195static int __smsc95xx_mdio_read(struct usbnet *dev, int phy_id, int idx,
196 int in_pm)
170static int smsc95xx_mdio_read(struct usbnet *dev, int phy_id, int idx)
197{
198 u32 val, addr;
199 int ret;
200
201 mutex_lock(&dev->phy_mutex);
202
203 /* confirm MII not busy */
171{
172 u32 val, addr;
173 int ret;
174
175 mutex_lock(&dev->phy_mutex);
176
177 /* confirm MII not busy */
204 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
178 ret = smsc95xx_phy_wait_not_busy(dev);
205 if (ret < 0) {
206 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
207 goto done;
208 }
209
210 /* set the address, index & direction (read from PHY) */
211 addr = mii_address_cmd(phy_id, idx, MII_READ_ | MII_BUSY_);
179 if (ret < 0) {
180 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
181 goto done;
182 }
183
184 /* set the address, index & direction (read from PHY) */
185 addr = mii_address_cmd(phy_id, idx, MII_READ_ | MII_BUSY_);
212 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
186 ret = smsc95xx_write_reg(dev, MII_ADDR, addr);
213 if (ret < 0) {
214 if (ret != -ENODEV)
215 netdev_warn(dev->net, "Error writing MII_ADDR\n");
216 goto done;
217 }
218
187 if (ret < 0) {
188 if (ret != -ENODEV)
189 netdev_warn(dev->net, "Error writing MII_ADDR\n");
190 goto done;
191 }
192
219 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
193 ret = smsc95xx_phy_wait_not_busy(dev);
220 if (ret < 0) {
221 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
222 goto done;
223 }
224
194 if (ret < 0) {
195 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
196 goto done;
197 }
198
225 ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
199 ret = smsc95xx_read_reg(dev, MII_DATA, &val);
226 if (ret < 0) {
227 if (ret != -ENODEV)
228 netdev_warn(dev->net, "Error reading MII_DATA\n");
229 goto done;
230 }
231
232 ret = (u16)(val & 0xFFFF);
233
234done:
235 mutex_unlock(&dev->phy_mutex);
236
237 /* Ignore -ENODEV error during disconnect() */
238 if (ret == -ENODEV)
239 return 0;
240 return ret;
241}
242
200 if (ret < 0) {
201 if (ret != -ENODEV)
202 netdev_warn(dev->net, "Error reading MII_DATA\n");
203 goto done;
204 }
205
206 ret = (u16)(val & 0xFFFF);
207
208done:
209 mutex_unlock(&dev->phy_mutex);
210
211 /* Ignore -ENODEV error during disconnect() */
212 if (ret == -ENODEV)
213 return 0;
214 return ret;
215}
216
243static void __smsc95xx_mdio_write(struct usbnet *dev, int phy_id,
244 int idx, int regval, int in_pm)
217static void smsc95xx_mdio_write(struct usbnet *dev, int phy_id, int idx,
218 int regval)
245{
246 u32 val, addr;
247 int ret;
248
249 mutex_lock(&dev->phy_mutex);
250
251 /* confirm MII not busy */
219{
220 u32 val, addr;
221 int ret;
222
223 mutex_lock(&dev->phy_mutex);
224
225 /* confirm MII not busy */
252 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
226 ret = smsc95xx_phy_wait_not_busy(dev);
253 if (ret < 0) {
254 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
255 goto done;
256 }
257
258 val = regval;
227 if (ret < 0) {
228 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
229 goto done;
230 }
231
232 val = regval;
259 ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
233 ret = smsc95xx_write_reg(dev, MII_DATA, val);
260 if (ret < 0) {
261 if (ret != -ENODEV)
262 netdev_warn(dev->net, "Error writing MII_DATA\n");
263 goto done;
264 }
265
266 /* set the address, index & direction (write to PHY) */
267 addr = mii_address_cmd(phy_id, idx, MII_WRITE_ | MII_BUSY_);
234 if (ret < 0) {
235 if (ret != -ENODEV)
236 netdev_warn(dev->net, "Error writing MII_DATA\n");
237 goto done;
238 }
239
240 /* set the address, index & direction (write to PHY) */
241 addr = mii_address_cmd(phy_id, idx, MII_WRITE_ | MII_BUSY_);
268 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
242 ret = smsc95xx_write_reg(dev, MII_ADDR, addr);
269 if (ret < 0) {
270 if (ret != -ENODEV)
271 netdev_warn(dev->net, "Error writing MII_ADDR\n");
272 goto done;
273 }
274
243 if (ret < 0) {
244 if (ret != -ENODEV)
245 netdev_warn(dev->net, "Error writing MII_ADDR\n");
246 goto done;
247 }
248
275 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
249 ret = smsc95xx_phy_wait_not_busy(dev);
276 if (ret < 0) {
277 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
278 goto done;
279 }
280
281done:
282 mutex_unlock(&dev->phy_mutex);
283}
284
250 if (ret < 0) {
251 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
252 goto done;
253 }
254
255done:
256 mutex_unlock(&dev->phy_mutex);
257}
258
285static int smsc95xx_mdio_read_nopm(struct usbnet *dev, int idx)
286{
287 struct smsc95xx_priv *pdata = dev->driver_priv;
288
289 return __smsc95xx_mdio_read(dev, pdata->phydev->mdio.addr, idx, 1);
290}
291
292static void smsc95xx_mdio_write_nopm(struct usbnet *dev, int idx, int regval)
293{
294 struct smsc95xx_priv *pdata = dev->driver_priv;
295
296 __smsc95xx_mdio_write(dev, pdata->phydev->mdio.addr, idx, regval, 1);
297}
298
299static int smsc95xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
300{
301 struct usbnet *dev = bus->priv;
302
259static int smsc95xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
260{
261 struct usbnet *dev = bus->priv;
262
303 return __smsc95xx_mdio_read(dev, phy_id, idx, 0);
263 return smsc95xx_mdio_read(dev, phy_id, idx);
304}
305
306static int smsc95xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
307 u16 regval)
308{
309 struct usbnet *dev = bus->priv;
310
264}
265
266static int smsc95xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
267 u16 regval)
268{
269 struct usbnet *dev = bus->priv;
270
311 __smsc95xx_mdio_write(dev, phy_id, idx, regval, 0);
271 smsc95xx_mdio_write(dev, phy_id, idx, regval);
312 return 0;
313}
314
315static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
316{
317 unsigned long start_time = jiffies;
318 u32 val;
319 int ret;

--- 543 unchanged lines hidden (view full) ---

863 if (ret < 0)
864 return ret;
865
866 /* Enable Tx at SCSRs */
867 return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
868}
869
870/* Starts the Receive path */
272 return 0;
273}
274
275static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
276{
277 unsigned long start_time = jiffies;
278 u32 val;
279 int ret;

--- 543 unchanged lines hidden (view full) ---

823 if (ret < 0)
824 return ret;
825
826 /* Enable Tx at SCSRs */
827 return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
828}
829
830/* Starts the Receive path */
871static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
831static int smsc95xx_start_rx_path(struct usbnet *dev)
872{
873 struct smsc95xx_priv *pdata = dev->driver_priv;
874 unsigned long flags;
875
876 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
877 pdata->mac_cr |= MAC_CR_RXEN_;
878 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
879
832{
833 struct smsc95xx_priv *pdata = dev->driver_priv;
834 unsigned long flags;
835
836 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
837 pdata->mac_cr |= MAC_CR_RXEN_;
838 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
839
880 return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
840 return smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
881}
882
883static int smsc95xx_reset(struct usbnet *dev)
884{
885 struct smsc95xx_priv *pdata = dev->driver_priv;
886 u32 read_buf, write_buf, burst_cap;
887 int ret = 0, timeout;
888

--- 166 unchanged lines hidden (view full) ---

1055 return ret;
1056
1057 ret = smsc95xx_start_tx_path(dev);
1058 if (ret < 0) {
1059 netdev_warn(dev->net, "Failed to start TX path\n");
1060 return ret;
1061 }
1062
841}
842
843static int smsc95xx_reset(struct usbnet *dev)
844{
845 struct smsc95xx_priv *pdata = dev->driver_priv;
846 u32 read_buf, write_buf, burst_cap;
847 int ret = 0, timeout;
848

--- 166 unchanged lines hidden (view full) ---

1015 return ret;
1016
1017 ret = smsc95xx_start_tx_path(dev);
1018 if (ret < 0) {
1019 netdev_warn(dev->net, "Failed to start TX path\n");
1020 return ret;
1021 }
1022
1063 ret = smsc95xx_start_rx_path(dev, 0);
1023 ret = smsc95xx_start_rx_path(dev);
1064 if (ret < 0) {
1065 netdev_warn(dev->net, "Failed to start RX path\n");
1066 return ret;
1067 }
1068
1069 netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
1070 return 0;
1071}

--- 217 unchanged lines hidden (view full) ---

1289}
1290
1291static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
1292{
1293 u32 crc = bitrev16(crc16(0xFFFF, buffer, len));
1294 return crc << ((filter % 2) * 16);
1295}
1296
1024 if (ret < 0) {
1025 netdev_warn(dev->net, "Failed to start RX path\n");
1026 return ret;
1027 }
1028
1029 netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
1030 return 0;
1031}

--- 217 unchanged lines hidden (view full) ---

1249}
1250
1251static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
1252{
1253 u32 crc = bitrev16(crc16(0xFFFF, buffer, len));
1254 return crc << ((filter % 2) * 16);
1255}
1256
1297static int smsc95xx_link_ok_nopm(struct usbnet *dev)
1257static int smsc95xx_link_ok(struct usbnet *dev)
1298{
1258{
1259 struct smsc95xx_priv *pdata = dev->driver_priv;
1299 int ret;
1300
1301 /* first, a dummy read, needed to latch some MII phys */
1260 int ret;
1261
1262 /* first, a dummy read, needed to latch some MII phys */
1302 ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
1263 ret = smsc95xx_mdio_read(dev, pdata->phydev->mdio.addr, MII_BMSR);
1303 if (ret < 0)
1304 return ret;
1305
1264 if (ret < 0)
1265 return ret;
1266
1306 ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
1267 ret = smsc95xx_mdio_read(dev, pdata->phydev->mdio.addr, MII_BMSR);
1307 if (ret < 0)
1308 return ret;
1309
1310 return !!(ret & BMSR_LSTATUS);
1311}
1312
1313static int smsc95xx_enter_suspend0(struct usbnet *dev)
1314{
1315 struct smsc95xx_priv *pdata = dev->driver_priv;
1316 u32 val;
1317 int ret;
1318
1268 if (ret < 0)
1269 return ret;
1270
1271 return !!(ret & BMSR_LSTATUS);
1272}
1273
1274static int smsc95xx_enter_suspend0(struct usbnet *dev)
1275{
1276 struct smsc95xx_priv *pdata = dev->driver_priv;
1277 u32 val;
1278 int ret;
1279
1319 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1280 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1320 if (ret < 0)
1321 return ret;
1322
1323 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
1324 val |= PM_CTL_SUS_MODE_0;
1325
1281 if (ret < 0)
1282 return ret;
1283
1284 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
1285 val |= PM_CTL_SUS_MODE_0;
1286
1326 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1287 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1327 if (ret < 0)
1328 return ret;
1329
1330 /* clear wol status */
1331 val &= ~PM_CTL_WUPS_;
1332 val |= PM_CTL_WUPS_WOL_;
1333
1334 /* enable energy detection */
1335 if (pdata->wolopts & WAKE_PHY)
1336 val |= PM_CTL_WUPS_ED_;
1337
1288 if (ret < 0)
1289 return ret;
1290
1291 /* clear wol status */
1292 val &= ~PM_CTL_WUPS_;
1293 val |= PM_CTL_WUPS_WOL_;
1294
1295 /* enable energy detection */
1296 if (pdata->wolopts & WAKE_PHY)
1297 val |= PM_CTL_WUPS_ED_;
1298
1338 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1299 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1339 if (ret < 0)
1340 return ret;
1341
1342 /* read back PM_CTRL */
1300 if (ret < 0)
1301 return ret;
1302
1303 /* read back PM_CTRL */
1343 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1304 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1344 if (ret < 0)
1345 return ret;
1346
1347 pdata->suspend_flags |= SUSPEND_SUSPEND0;
1348
1349 return 0;
1350}
1351
1352static int smsc95xx_enter_suspend1(struct usbnet *dev)
1353{
1354 struct smsc95xx_priv *pdata = dev->driver_priv;
1305 if (ret < 0)
1306 return ret;
1307
1308 pdata->suspend_flags |= SUSPEND_SUSPEND0;
1309
1310 return 0;
1311}
1312
1313static int smsc95xx_enter_suspend1(struct usbnet *dev)
1314{
1315 struct smsc95xx_priv *pdata = dev->driver_priv;
1316 int ret, phy_id = pdata->phydev->mdio.addr;
1355 u32 val;
1317 u32 val;
1356 int ret;
1357
1358 /* reconfigure link pulse detection timing for
1359 * compatibility with non-standard link partners
1360 */
1361 if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
1318
1319 /* reconfigure link pulse detection timing for
1320 * compatibility with non-standard link partners
1321 */
1322 if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
1362 smsc95xx_mdio_write_nopm(dev, PHY_EDPD_CONFIG,
1363 PHY_EDPD_CONFIG_DEFAULT);
1323 smsc95xx_mdio_write(dev, phy_id, PHY_EDPD_CONFIG,
1324 PHY_EDPD_CONFIG_DEFAULT);
1364
1365 /* enable energy detect power-down mode */
1325
1326 /* enable energy detect power-down mode */
1366 ret = smsc95xx_mdio_read_nopm(dev, PHY_MODE_CTRL_STS);
1327 ret = smsc95xx_mdio_read(dev, phy_id, PHY_MODE_CTRL_STS);
1367 if (ret < 0)
1368 return ret;
1369
1370 ret |= MODE_CTRL_STS_EDPWRDOWN_;
1371
1328 if (ret < 0)
1329 return ret;
1330
1331 ret |= MODE_CTRL_STS_EDPWRDOWN_;
1332
1372 smsc95xx_mdio_write_nopm(dev, PHY_MODE_CTRL_STS, ret);
1333 smsc95xx_mdio_write(dev, phy_id, PHY_MODE_CTRL_STS, ret);
1373
1374 /* enter SUSPEND1 mode */
1334
1335 /* enter SUSPEND1 mode */
1375 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1336 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1376 if (ret < 0)
1377 return ret;
1378
1379 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1380 val |= PM_CTL_SUS_MODE_1;
1381
1337 if (ret < 0)
1338 return ret;
1339
1340 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1341 val |= PM_CTL_SUS_MODE_1;
1342
1382 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1343 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1383 if (ret < 0)
1384 return ret;
1385
1386 /* clear wol status, enable energy detection */
1387 val &= ~PM_CTL_WUPS_;
1388 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
1389
1344 if (ret < 0)
1345 return ret;
1346
1347 /* clear wol status, enable energy detection */
1348 val &= ~PM_CTL_WUPS_;
1349 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
1350
1390 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1351 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1391 if (ret < 0)
1392 return ret;
1393
1394 pdata->suspend_flags |= SUSPEND_SUSPEND1;
1395
1396 return 0;
1397}
1398
1399static int smsc95xx_enter_suspend2(struct usbnet *dev)
1400{
1401 struct smsc95xx_priv *pdata = dev->driver_priv;
1402 u32 val;
1403 int ret;
1404
1352 if (ret < 0)
1353 return ret;
1354
1355 pdata->suspend_flags |= SUSPEND_SUSPEND1;
1356
1357 return 0;
1358}
1359
1360static int smsc95xx_enter_suspend2(struct usbnet *dev)
1361{
1362 struct smsc95xx_priv *pdata = dev->driver_priv;
1363 u32 val;
1364 int ret;
1365
1405 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1366 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1406 if (ret < 0)
1407 return ret;
1408
1409 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1410 val |= PM_CTL_SUS_MODE_2;
1411
1367 if (ret < 0)
1368 return ret;
1369
1370 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1371 val |= PM_CTL_SUS_MODE_2;
1372
1412 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1373 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1413 if (ret < 0)
1414 return ret;
1415
1416 pdata->suspend_flags |= SUSPEND_SUSPEND2;
1417
1418 return 0;
1419}
1420
1421static int smsc95xx_enter_suspend3(struct usbnet *dev)
1422{
1423 struct smsc95xx_priv *pdata = dev->driver_priv;
1424 u32 val;
1425 int ret;
1426
1374 if (ret < 0)
1375 return ret;
1376
1377 pdata->suspend_flags |= SUSPEND_SUSPEND2;
1378
1379 return 0;
1380}
1381
1382static int smsc95xx_enter_suspend3(struct usbnet *dev)
1383{
1384 struct smsc95xx_priv *pdata = dev->driver_priv;
1385 u32 val;
1386 int ret;
1387
1427 ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val);
1388 ret = smsc95xx_read_reg(dev, RX_FIFO_INF, &val);
1428 if (ret < 0)
1429 return ret;
1430
1431 if (val & RX_FIFO_INF_USED_) {
1432 netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
1433 return -EBUSY;
1434 }
1435
1389 if (ret < 0)
1390 return ret;
1391
1392 if (val & RX_FIFO_INF_USED_) {
1393 netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
1394 return -EBUSY;
1395 }
1396
1436 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1397 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1437 if (ret < 0)
1438 return ret;
1439
1440 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1441 val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS;
1442
1398 if (ret < 0)
1399 return ret;
1400
1401 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1402 val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS;
1403
1443 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1404 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1444 if (ret < 0)
1445 return ret;
1446
1447 /* clear wol status */
1448 val &= ~PM_CTL_WUPS_;
1449 val |= PM_CTL_WUPS_WOL_;
1450
1405 if (ret < 0)
1406 return ret;
1407
1408 /* clear wol status */
1409 val &= ~PM_CTL_WUPS_;
1410 val |= PM_CTL_WUPS_WOL_;
1411
1451 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1412 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1452 if (ret < 0)
1453 return ret;
1454
1455 pdata->suspend_flags |= SUSPEND_SUSPEND3;
1456
1457 return 0;
1458}
1459

--- 42 unchanged lines hidden (view full) ---

1502 return ret;
1503 }
1504
1505 if (pdata->suspend_flags) {
1506 netdev_warn(dev->net, "error during last resume\n");
1507 pdata->suspend_flags = 0;
1508 }
1509
1413 if (ret < 0)
1414 return ret;
1415
1416 pdata->suspend_flags |= SUSPEND_SUSPEND3;
1417
1418 return 0;
1419}
1420

--- 42 unchanged lines hidden (view full) ---

1463 return ret;
1464 }
1465
1466 if (pdata->suspend_flags) {
1467 netdev_warn(dev->net, "error during last resume\n");
1468 pdata->suspend_flags = 0;
1469 }
1470
1510 /* determine if link is up using only _nopm functions */
1511 link_up = smsc95xx_link_ok_nopm(dev);
1471 link_up = smsc95xx_link_ok(dev);
1512
1513 if (message.event == PM_EVENT_AUTO_SUSPEND &&
1514 (pdata->features & FEATURE_REMOTE_WAKEUP)) {
1515 ret = smsc95xx_autosuspend(dev, link_up);
1516 goto done;
1517 }
1518
1519 /* if we get this far we're not autosuspending */
1520 /* if no wol options set, or if link is down and we're not waking on
1521 * PHY activity, enter lowest power SUSPEND2 mode
1522 */
1523 if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1524 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1525 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1526
1527 /* disable energy detect (link up) & wake up events */
1472
1473 if (message.event == PM_EVENT_AUTO_SUSPEND &&
1474 (pdata->features & FEATURE_REMOTE_WAKEUP)) {
1475 ret = smsc95xx_autosuspend(dev, link_up);
1476 goto done;
1477 }
1478
1479 /* if we get this far we're not autosuspending */
1480 /* if no wol options set, or if link is down and we're not waking on
1481 * PHY activity, enter lowest power SUSPEND2 mode
1482 */
1483 if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1484 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1485 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1486
1487 /* disable energy detect (link up) & wake up events */
1528 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1488 ret = smsc95xx_read_reg(dev, WUCSR, &val);
1529 if (ret < 0)
1530 goto done;
1531
1532 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
1533
1489 if (ret < 0)
1490 goto done;
1491
1492 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
1493
1534 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1494 ret = smsc95xx_write_reg(dev, WUCSR, val);
1535 if (ret < 0)
1536 goto done;
1537
1495 if (ret < 0)
1496 goto done;
1497
1538 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1498 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1539 if (ret < 0)
1540 goto done;
1541
1542 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
1543
1499 if (ret < 0)
1500 goto done;
1501
1502 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
1503
1544 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1504 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1545 if (ret < 0)
1546 goto done;
1547
1548 ret = smsc95xx_enter_suspend2(dev);
1549 goto done;
1550 }
1551
1552 if (pdata->wolopts & WAKE_PHY) {

--- 74 unchanged lines hidden (view full) ---

1627 filter_mask[filter * 4 + 3] = 0x00;
1628 command[filter/4] |= 0x01UL << ((filter % 4) * 8);
1629 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1630 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1631 filter++;
1632 }
1633
1634 for (i = 0; i < (wuff_filter_count * 4); i++) {
1505 if (ret < 0)
1506 goto done;
1507
1508 ret = smsc95xx_enter_suspend2(dev);
1509 goto done;
1510 }
1511
1512 if (pdata->wolopts & WAKE_PHY) {

--- 74 unchanged lines hidden (view full) ---

1587 filter_mask[filter * 4 + 3] = 0x00;
1588 command[filter/4] |= 0x01UL << ((filter % 4) * 8);
1589 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1590 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1591 filter++;
1592 }
1593
1594 for (i = 0; i < (wuff_filter_count * 4); i++) {
1635 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
1595 ret = smsc95xx_write_reg(dev, WUFF, filter_mask[i]);
1636 if (ret < 0) {
1637 kfree(filter_mask);
1638 goto done;
1639 }
1640 }
1641 kfree(filter_mask);
1642
1643 for (i = 0; i < (wuff_filter_count / 4); i++) {
1596 if (ret < 0) {
1597 kfree(filter_mask);
1598 goto done;
1599 }
1600 }
1601 kfree(filter_mask);
1602
1603 for (i = 0; i < (wuff_filter_count / 4); i++) {
1644 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1604 ret = smsc95xx_write_reg(dev, WUFF, command[i]);
1645 if (ret < 0)
1646 goto done;
1647 }
1648
1649 for (i = 0; i < (wuff_filter_count / 4); i++) {
1605 if (ret < 0)
1606 goto done;
1607 }
1608
1609 for (i = 0; i < (wuff_filter_count / 4); i++) {
1650 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1610 ret = smsc95xx_write_reg(dev, WUFF, offset[i]);
1651 if (ret < 0)
1652 goto done;
1653 }
1654
1655 for (i = 0; i < (wuff_filter_count / 2); i++) {
1611 if (ret < 0)
1612 goto done;
1613 }
1614
1615 for (i = 0; i < (wuff_filter_count / 2); i++) {
1656 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1616 ret = smsc95xx_write_reg(dev, WUFF, crc[i]);
1657 if (ret < 0)
1658 goto done;
1659 }
1660
1661 /* clear any pending pattern match packet status */
1617 if (ret < 0)
1618 goto done;
1619 }
1620
1621 /* clear any pending pattern match packet status */
1662 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1622 ret = smsc95xx_read_reg(dev, WUCSR, &val);
1663 if (ret < 0)
1664 goto done;
1665
1666 val |= WUCSR_WUFR_;
1667
1623 if (ret < 0)
1624 goto done;
1625
1626 val |= WUCSR_WUFR_;
1627
1668 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1628 ret = smsc95xx_write_reg(dev, WUCSR, val);
1669 if (ret < 0)
1670 goto done;
1671 }
1672
1673 if (pdata->wolopts & WAKE_MAGIC) {
1674 /* clear any pending magic packet status */
1629 if (ret < 0)
1630 goto done;
1631 }
1632
1633 if (pdata->wolopts & WAKE_MAGIC) {
1634 /* clear any pending magic packet status */
1675 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1635 ret = smsc95xx_read_reg(dev, WUCSR, &val);
1676 if (ret < 0)
1677 goto done;
1678
1679 val |= WUCSR_MPR_;
1680
1636 if (ret < 0)
1637 goto done;
1638
1639 val |= WUCSR_MPR_;
1640
1681 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1641 ret = smsc95xx_write_reg(dev, WUCSR, val);
1682 if (ret < 0)
1683 goto done;
1684 }
1685
1686 /* enable/disable wakeup sources */
1642 if (ret < 0)
1643 goto done;
1644 }
1645
1646 /* enable/disable wakeup sources */
1687 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1647 ret = smsc95xx_read_reg(dev, WUCSR, &val);
1688 if (ret < 0)
1689 goto done;
1690
1691 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1692 netdev_info(dev->net, "enabling pattern match wakeup\n");
1693 val |= WUCSR_WAKE_EN_;
1694 } else {
1695 netdev_info(dev->net, "disabling pattern match wakeup\n");
1696 val &= ~WUCSR_WAKE_EN_;
1697 }
1698
1699 if (pdata->wolopts & WAKE_MAGIC) {
1700 netdev_info(dev->net, "enabling magic packet wakeup\n");
1701 val |= WUCSR_MPEN_;
1702 } else {
1703 netdev_info(dev->net, "disabling magic packet wakeup\n");
1704 val &= ~WUCSR_MPEN_;
1705 }
1706
1648 if (ret < 0)
1649 goto done;
1650
1651 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1652 netdev_info(dev->net, "enabling pattern match wakeup\n");
1653 val |= WUCSR_WAKE_EN_;
1654 } else {
1655 netdev_info(dev->net, "disabling pattern match wakeup\n");
1656 val &= ~WUCSR_WAKE_EN_;
1657 }
1658
1659 if (pdata->wolopts & WAKE_MAGIC) {
1660 netdev_info(dev->net, "enabling magic packet wakeup\n");
1661 val |= WUCSR_MPEN_;
1662 } else {
1663 netdev_info(dev->net, "disabling magic packet wakeup\n");
1664 val &= ~WUCSR_MPEN_;
1665 }
1666
1707 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1667 ret = smsc95xx_write_reg(dev, WUCSR, val);
1708 if (ret < 0)
1709 goto done;
1710
1711 /* enable wol wakeup source */
1668 if (ret < 0)
1669 goto done;
1670
1671 /* enable wol wakeup source */
1712 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1672 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1713 if (ret < 0)
1714 goto done;
1715
1716 val |= PM_CTL_WOL_EN_;
1717
1718 /* phy energy detect wakeup source */
1719 if (pdata->wolopts & WAKE_PHY)
1720 val |= PM_CTL_ED_EN_;
1721
1673 if (ret < 0)
1674 goto done;
1675
1676 val |= PM_CTL_WOL_EN_;
1677
1678 /* phy energy detect wakeup source */
1679 if (pdata->wolopts & WAKE_PHY)
1680 val |= PM_CTL_ED_EN_;
1681
1722 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1682 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1723 if (ret < 0)
1724 goto done;
1725
1726 /* enable receiver to enable frame reception */
1683 if (ret < 0)
1684 goto done;
1685
1686 /* enable receiver to enable frame reception */
1727 smsc95xx_start_rx_path(dev, 1);
1687 smsc95xx_start_rx_path(dev);
1728
1729 /* some wol options are enabled, so enter SUSPEND0 */
1730 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1731 ret = smsc95xx_enter_suspend0(dev);
1732
1733done:
1734 /*
1735 * TODO: resume() might need to handle the suspend failure

--- 22 unchanged lines hidden (view full) ---

1758
1759 /* do this first to ensure it's cleared even in error case */
1760 pdata->suspend_flags = 0;
1761
1762 pdata->pm_task = current;
1763
1764 if (suspend_flags & SUSPEND_ALLMODES) {
1765 /* clear wake-up sources */
1688
1689 /* some wol options are enabled, so enter SUSPEND0 */
1690 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1691 ret = smsc95xx_enter_suspend0(dev);
1692
1693done:
1694 /*
1695 * TODO: resume() might need to handle the suspend failure

--- 22 unchanged lines hidden (view full) ---

1718
1719 /* do this first to ensure it's cleared even in error case */
1720 pdata->suspend_flags = 0;
1721
1722 pdata->pm_task = current;
1723
1724 if (suspend_flags & SUSPEND_ALLMODES) {
1725 /* clear wake-up sources */
1766 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1726 ret = smsc95xx_read_reg(dev, WUCSR, &val);
1767 if (ret < 0)
1768 goto done;
1769
1770 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1771
1727 if (ret < 0)
1728 goto done;
1729
1730 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1731
1772 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1732 ret = smsc95xx_write_reg(dev, WUCSR, val);
1773 if (ret < 0)
1774 goto done;
1775
1776 /* clear wake-up status */
1733 if (ret < 0)
1734 goto done;
1735
1736 /* clear wake-up status */
1777 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1737 ret = smsc95xx_read_reg(dev, PM_CTRL, &val);
1778 if (ret < 0)
1779 goto done;
1780
1781 val &= ~PM_CTL_WOL_EN_;
1782 val |= PM_CTL_WUPS_;
1783
1738 if (ret < 0)
1739 goto done;
1740
1741 val &= ~PM_CTL_WOL_EN_;
1742 val |= PM_CTL_WUPS_;
1743
1784 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1744 ret = smsc95xx_write_reg(dev, PM_CTRL, val);
1785 if (ret < 0)
1786 goto done;
1787 }
1788
1789 phy_init_hw(pdata->phydev);
1790
1791 ret = usbnet_resume(intf);
1792 if (ret < 0)

--- 339 unchanged lines hidden --- 		1745 if (ret < 0)
1746 goto done;
1747 }
1748
1749 phy_init_hw(pdata->phydev);
1750
1751 ret = usbnet_resume(intf);
1752 if (ret < 0)

--- 339 unchanged lines hidden ---