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>
9 #include <linux/kmod.h>
10 #include <linux/netdevice.h>
11 #include <linux/etherdevice.h>
12 #include <linux/ethtool.h>
13 #include <linux/mii.h>
14 #include <linux/usb.h>
15 #include <linux/bitrev.h>
16 #include <linux/crc16.h>
17 #include <linux/crc32.h>
18 #include <linux/usb/usbnet.h>
19 #include <linux/slab.h>
20 #include <linux/of_net.h>
21 #include <linux/mdio.h>
22 #include <linux/phy.h>
23 #include "smsc95xx.h"
24
25 #define SMSC_CHIPNAME "smsc95xx"
26 #define SMSC_DRIVER_VERSION "2.0.0"
27 #define HS_USB_PKT_SIZE (512)
28 #define FS_USB_PKT_SIZE (64)
29 #define DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * HS_USB_PKT_SIZE)
30 #define DEFAULT_FS_BURST_CAP_SIZE (6 * 1024 + 33 * FS_USB_PKT_SIZE)
31 #define DEFAULT_BULK_IN_DELAY (0x00002000)
32 #define MAX_SINGLE_PACKET_SIZE (2048)
33 #define LAN95XX_EEPROM_MAGIC (0x9500)
34 #define EEPROM_MAC_OFFSET (0x01)
35 #define DEFAULT_TX_CSUM_ENABLE (true)
36 #define DEFAULT_RX_CSUM_ENABLE (true)
37 #define SMSC95XX_INTERNAL_PHY_ID (1)
38 #define SMSC95XX_TX_OVERHEAD (8)
39 #define SMSC95XX_TX_OVERHEAD_CSUM (12)
40 #define SUPPORTED_WAKE (WAKE_PHY | WAKE_UCAST | WAKE_BCAST | \
41 WAKE_MCAST | WAKE_ARP | WAKE_MAGIC)
42
43 #define FEATURE_8_WAKEUP_FILTERS (0x01)
44 #define FEATURE_PHY_NLP_CROSSOVER (0x02)
45 #define FEATURE_REMOTE_WAKEUP (0x04)
46
47 #define SUSPEND_SUSPEND0 (0x01)
48 #define SUSPEND_SUSPEND1 (0x02)
49 #define SUSPEND_SUSPEND2 (0x04)
50 #define SUSPEND_SUSPEND3 (0x08)
51 #define SUSPEND_ALLMODES (SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
52 SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
53
54 struct smsc95xx_priv {
55 u32 mac_cr;
56 u32 hash_hi;
57 u32 hash_lo;
58 u32 wolopts;
59 spinlock_t mac_cr_lock;
60 u8 features;
61 u8 suspend_flags;
62 struct mii_bus *mdiobus;
63 struct phy_device *phydev;
64 struct task_struct *pm_task;
65 };
66
67 static bool turbo_mode = true;
68 module_param(turbo_mode, bool, 0644);
69 MODULE_PARM_DESC(turbo_mode, "Enable multiple frames per Rx transaction");
70
__smsc95xx_read_reg(struct usbnet * dev,u32 index,u32 * data,int in_pm)71 static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
72 u32 *data, int in_pm)
73 {
74 struct smsc95xx_priv *pdata = dev->driver_priv;
75 u32 buf;
76 int ret;
77 int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
78
79 BUG_ON(!dev);
80
81 if (current != pdata->pm_task)
82 fn = usbnet_read_cmd;
83 else
84 fn = usbnet_read_cmd_nopm;
85
86 ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
87 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
88 0, index, &buf, 4);
89 if (ret < 0) {
90 if (ret != -ENODEV)
91 netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
92 index, ret);
93 return ret;
94 }
95
96 le32_to_cpus(&buf);
97 *data = buf;
98
99 return ret;
100 }
101
__smsc95xx_write_reg(struct usbnet * dev,u32 index,u32 data,int in_pm)102 static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
103 u32 data, int in_pm)
104 {
105 struct smsc95xx_priv *pdata = dev->driver_priv;
106 u32 buf;
107 int ret;
108 int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
109
110 BUG_ON(!dev);
111
112 if (current != pdata->pm_task)
113 fn = usbnet_write_cmd;
114 else
115 fn = usbnet_write_cmd_nopm;
116
117 buf = data;
118 cpu_to_le32s(&buf);
119
120 ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
121 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
122 0, index, &buf, 4);
123 if (ret < 0 && ret != -ENODEV)
124 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
125 index, ret);
126
127 return ret;
128 }
129
smsc95xx_read_reg_nopm(struct usbnet * dev,u32 index,u32 * data)130 static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index,
131 u32 *data)
132 {
133 return __smsc95xx_read_reg(dev, index, data, 1);
134 }
135
smsc95xx_write_reg_nopm(struct usbnet * dev,u32 index,u32 data)136 static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index,
137 u32 data)
138 {
139 return __smsc95xx_write_reg(dev, index, data, 1);
140 }
141
smsc95xx_read_reg(struct usbnet * dev,u32 index,u32 * data)142 static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
143 u32 *data)
144 {
145 return __smsc95xx_read_reg(dev, index, data, 0);
146 }
147
smsc95xx_write_reg(struct usbnet * dev,u32 index,u32 data)148 static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
149 u32 data)
150 {
151 return __smsc95xx_write_reg(dev, index, data, 0);
152 }
153
154 /* Loop until the read is completed with timeout
155 * called with phy_mutex held */
__smsc95xx_phy_wait_not_busy(struct usbnet * dev,int in_pm)156 static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev,
157 int in_pm)
158 {
159 unsigned long start_time = jiffies;
160 u32 val;
161 int ret;
162
163 do {
164 ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
165 if (ret < 0) {
166 /* Ignore -ENODEV error during disconnect() */
167 if (ret == -ENODEV)
168 return 0;
169 netdev_warn(dev->net, "Error reading MII_ACCESS\n");
170 return ret;
171 }
172
173 if (!(val & MII_BUSY_))
174 return 0;
175 } while (!time_after(jiffies, start_time + HZ));
176
177 return -EIO;
178 }
179
mii_address_cmd(int phy_id,int idx,u16 op)180 static u32 mii_address_cmd(int phy_id, int idx, u16 op)
181 {
182 return (phy_id & 0x1f) << 11 | (idx & 0x1f) << 6 | op;
183 }
184
__smsc95xx_mdio_read(struct usbnet * dev,int phy_id,int idx,int in_pm)185 static int __smsc95xx_mdio_read(struct usbnet *dev, int phy_id, int idx,
186 int in_pm)
187 {
188 u32 val, addr;
189 int ret;
190
191 mutex_lock(&dev->phy_mutex);
192
193 /* confirm MII not busy */
194 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
195 if (ret < 0) {
196 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
197 goto done;
198 }
199
200 /* set the address, index & direction (read from PHY) */
201 addr = mii_address_cmd(phy_id, idx, MII_READ_ | MII_BUSY_);
202 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
203 if (ret < 0) {
204 if (ret != -ENODEV)
205 netdev_warn(dev->net, "Error writing MII_ADDR\n");
206 goto done;
207 }
208
209 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
210 if (ret < 0) {
211 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
212 goto done;
213 }
214
215 ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
216 if (ret < 0) {
217 if (ret != -ENODEV)
218 netdev_warn(dev->net, "Error reading MII_DATA\n");
219 goto done;
220 }
221
222 ret = (u16)(val & 0xFFFF);
223
224 done:
225 mutex_unlock(&dev->phy_mutex);
226
227 /* Ignore -ENODEV error during disconnect() */
228 if (ret == -ENODEV)
229 return 0;
230 return ret;
231 }
232
__smsc95xx_mdio_write(struct usbnet * dev,int phy_id,int idx,int regval,int in_pm)233 static void __smsc95xx_mdio_write(struct usbnet *dev, int phy_id,
234 int idx, int regval, int in_pm)
235 {
236 u32 val, addr;
237 int ret;
238
239 mutex_lock(&dev->phy_mutex);
240
241 /* confirm MII not busy */
242 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
243 if (ret < 0) {
244 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
245 goto done;
246 }
247
248 val = regval;
249 ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
250 if (ret < 0) {
251 if (ret != -ENODEV)
252 netdev_warn(dev->net, "Error writing MII_DATA\n");
253 goto done;
254 }
255
256 /* set the address, index & direction (write to PHY) */
257 addr = mii_address_cmd(phy_id, idx, MII_WRITE_ | MII_BUSY_);
258 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
259 if (ret < 0) {
260 if (ret != -ENODEV)
261 netdev_warn(dev->net, "Error writing MII_ADDR\n");
262 goto done;
263 }
264
265 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
266 if (ret < 0) {
267 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
268 goto done;
269 }
270
271 done:
272 mutex_unlock(&dev->phy_mutex);
273 }
274
smsc95xx_mdio_read_nopm(struct usbnet * dev,int idx)275 static int smsc95xx_mdio_read_nopm(struct usbnet *dev, int idx)
276 {
277 struct smsc95xx_priv *pdata = dev->driver_priv;
278
279 return __smsc95xx_mdio_read(dev, pdata->phydev->mdio.addr, idx, 1);
280 }
281
smsc95xx_mdio_write_nopm(struct usbnet * dev,int idx,int regval)282 static void smsc95xx_mdio_write_nopm(struct usbnet *dev, int idx, int regval)
283 {
284 struct smsc95xx_priv *pdata = dev->driver_priv;
285
286 __smsc95xx_mdio_write(dev, pdata->phydev->mdio.addr, idx, regval, 1);
287 }
288
smsc95xx_mdiobus_read(struct mii_bus * bus,int phy_id,int idx)289 static int smsc95xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
290 {
291 struct usbnet *dev = bus->priv;
292
293 return __smsc95xx_mdio_read(dev, phy_id, idx, 0);
294 }
295
smsc95xx_mdiobus_write(struct mii_bus * bus,int phy_id,int idx,u16 regval)296 static int smsc95xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
297 u16 regval)
298 {
299 struct usbnet *dev = bus->priv;
300
301 __smsc95xx_mdio_write(dev, phy_id, idx, regval, 0);
302 return 0;
303 }
304
smsc95xx_wait_eeprom(struct usbnet * dev)305 static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
306 {
307 unsigned long start_time = jiffies;
308 u32 val;
309 int ret;
310
311 do {
312 ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
313 if (ret < 0) {
314 netdev_warn(dev->net, "Error reading E2P_CMD\n");
315 return ret;
316 }
317
318 if (!(val & E2P_CMD_BUSY_) || (val & E2P_CMD_TIMEOUT_))
319 break;
320 udelay(40);
321 } while (!time_after(jiffies, start_time + HZ));
322
323 if (val & (E2P_CMD_TIMEOUT_ | E2P_CMD_BUSY_)) {
324 netdev_warn(dev->net, "EEPROM read operation timeout\n");
325 return -EIO;
326 }
327
328 return 0;
329 }
330
smsc95xx_eeprom_confirm_not_busy(struct usbnet * dev)331 static int __must_check smsc95xx_eeprom_confirm_not_busy(struct usbnet *dev)
332 {
333 unsigned long start_time = jiffies;
334 u32 val;
335 int ret;
336
337 do {
338 ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
339 if (ret < 0) {
340 netdev_warn(dev->net, "Error reading E2P_CMD\n");
341 return ret;
342 }
343
344 if (!(val & E2P_CMD_BUSY_))
345 return 0;
346
347 udelay(40);
348 } while (!time_after(jiffies, start_time + HZ));
349
350 netdev_warn(dev->net, "EEPROM is busy\n");
351 return -EIO;
352 }
353
smsc95xx_read_eeprom(struct usbnet * dev,u32 offset,u32 length,u8 * data)354 static int smsc95xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
355 u8 *data)
356 {
357 u32 val;
358 int i, ret;
359
360 BUG_ON(!dev);
361 BUG_ON(!data);
362
363 ret = smsc95xx_eeprom_confirm_not_busy(dev);
364 if (ret)
365 return ret;
366
367 for (i = 0; i < length; i++) {
368 val = E2P_CMD_BUSY_ | E2P_CMD_READ_ | (offset & E2P_CMD_ADDR_);
369 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
370 if (ret < 0) {
371 netdev_warn(dev->net, "Error writing E2P_CMD\n");
372 return ret;
373 }
374
375 ret = smsc95xx_wait_eeprom(dev);
376 if (ret < 0)
377 return ret;
378
379 ret = smsc95xx_read_reg(dev, E2P_DATA, &val);
380 if (ret < 0) {
381 netdev_warn(dev->net, "Error reading E2P_DATA\n");
382 return ret;
383 }
384
385 data[i] = val & 0xFF;
386 offset++;
387 }
388
389 return 0;
390 }
391
smsc95xx_write_eeprom(struct usbnet * dev,u32 offset,u32 length,u8 * data)392 static int smsc95xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
393 u8 *data)
394 {
395 u32 val;
396 int i, ret;
397
398 BUG_ON(!dev);
399 BUG_ON(!data);
400
401 ret = smsc95xx_eeprom_confirm_not_busy(dev);
402 if (ret)
403 return ret;
404
405 /* Issue write/erase enable command */
406 val = E2P_CMD_BUSY_ | E2P_CMD_EWEN_;
407 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
408 if (ret < 0) {
409 netdev_warn(dev->net, "Error writing E2P_DATA\n");
410 return ret;
411 }
412
413 ret = smsc95xx_wait_eeprom(dev);
414 if (ret < 0)
415 return ret;
416
417 for (i = 0; i < length; i++) {
418
419 /* Fill data register */
420 val = data[i];
421 ret = smsc95xx_write_reg(dev, E2P_DATA, val);
422 if (ret < 0) {
423 netdev_warn(dev->net, "Error writing E2P_DATA\n");
424 return ret;
425 }
426
427 /* Send "write" command */
428 val = E2P_CMD_BUSY_ | E2P_CMD_WRITE_ | (offset & E2P_CMD_ADDR_);
429 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
430 if (ret < 0) {
431 netdev_warn(dev->net, "Error writing E2P_CMD\n");
432 return ret;
433 }
434
435 ret = smsc95xx_wait_eeprom(dev);
436 if (ret < 0)
437 return ret;
438
439 offset++;
440 }
441
442 return 0;
443 }
444
smsc95xx_write_reg_async(struct usbnet * dev,u16 index,u32 data)445 static int __must_check smsc95xx_write_reg_async(struct usbnet *dev, u16 index,
446 u32 data)
447 {
448 const u16 size = 4;
449 u32 buf;
450 int ret;
451
452 buf = data;
453 cpu_to_le32s(&buf);
454
455 ret = usbnet_write_cmd_async(dev, USB_VENDOR_REQUEST_WRITE_REGISTER,
456 USB_DIR_OUT | USB_TYPE_VENDOR |
457 USB_RECIP_DEVICE,
458 0, index, &buf, size);
459 if (ret < 0)
460 netdev_warn(dev->net, "Error write async cmd, sts=%d\n",
461 ret);
462 return ret;
463 }
464
465 /* returns hash bit number for given MAC address
466 * example:
467 * 01 00 5E 00 00 01 -> returns bit number 31 */
smsc95xx_hash(char addr[ETH_ALEN])468 static unsigned int smsc95xx_hash(char addr[ETH_ALEN])
469 {
470 return (ether_crc(ETH_ALEN, addr) >> 26) & 0x3f;
471 }
472
smsc95xx_set_multicast(struct net_device * netdev)473 static void smsc95xx_set_multicast(struct net_device *netdev)
474 {
475 struct usbnet *dev = netdev_priv(netdev);
476 struct smsc95xx_priv *pdata = dev->driver_priv;
477 unsigned long flags;
478 int ret;
479
480 pdata->hash_hi = 0;
481 pdata->hash_lo = 0;
482
483 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
484
485 if (dev->net->flags & IFF_PROMISC) {
486 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
487 pdata->mac_cr |= MAC_CR_PRMS_;
488 pdata->mac_cr &= ~(MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
489 } else if (dev->net->flags & IFF_ALLMULTI) {
490 netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
491 pdata->mac_cr |= MAC_CR_MCPAS_;
492 pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_HPFILT_);
493 } else if (!netdev_mc_empty(dev->net)) {
494 struct netdev_hw_addr *ha;
495
496 pdata->mac_cr |= MAC_CR_HPFILT_;
497 pdata->mac_cr &= ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_);
498
499 netdev_for_each_mc_addr(ha, netdev) {
500 u32 bitnum = smsc95xx_hash(ha->addr);
501 u32 mask = 0x01 << (bitnum & 0x1F);
502 if (bitnum & 0x20)
503 pdata->hash_hi |= mask;
504 else
505 pdata->hash_lo |= mask;
506 }
507
508 netif_dbg(dev, drv, dev->net, "HASHH=0x%08X, HASHL=0x%08X\n",
509 pdata->hash_hi, pdata->hash_lo);
510 } else {
511 netif_dbg(dev, drv, dev->net, "receive own packets only\n");
512 pdata->mac_cr &=
513 ~(MAC_CR_PRMS_ | MAC_CR_MCPAS_ | MAC_CR_HPFILT_);
514 }
515
516 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
517
518 /* Initiate async writes, as we can't wait for completion here */
519 ret = smsc95xx_write_reg_async(dev, HASHH, pdata->hash_hi);
520 if (ret < 0)
521 netdev_warn(dev->net, "failed to initiate async write to HASHH\n");
522
523 ret = smsc95xx_write_reg_async(dev, HASHL, pdata->hash_lo);
524 if (ret < 0)
525 netdev_warn(dev->net, "failed to initiate async write to HASHL\n");
526
527 ret = smsc95xx_write_reg_async(dev, MAC_CR, pdata->mac_cr);
528 if (ret < 0)
529 netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n");
530 }
531
smsc95xx_phy_update_flowcontrol(struct usbnet * dev)532 static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev)
533 {
534 u32 flow = 0, afc_cfg;
535 struct smsc95xx_priv *pdata = dev->driver_priv;
536 bool tx_pause, rx_pause;
537
538 int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
539 if (ret < 0)
540 return ret;
541
542 if (pdata->phydev->duplex == DUPLEX_FULL) {
543 phy_get_pause(pdata->phydev, &tx_pause, &rx_pause);
544
545 if (rx_pause)
546 flow = 0xFFFF0002;
547
548 if (tx_pause) {
549 afc_cfg |= 0xF;
550 flow |= 0xFFFF0000;
551 } else {
552 afc_cfg &= ~0xF;
553 }
554
555 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
556 rx_pause ? "enabled" : "disabled",
557 tx_pause ? "enabled" : "disabled");
558 } else {
559 netif_dbg(dev, link, dev->net, "half duplex\n");
560 afc_cfg |= 0xF;
561 }
562
563 ret = smsc95xx_write_reg(dev, FLOW, flow);
564 if (ret < 0)
565 return ret;
566
567 return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
568 }
569
smsc95xx_mac_update_fullduplex(struct usbnet * dev)570 static void smsc95xx_mac_update_fullduplex(struct usbnet *dev)
571 {
572 struct smsc95xx_priv *pdata = dev->driver_priv;
573 unsigned long flags;
574 int ret;
575
576 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
577 if (pdata->phydev->duplex != DUPLEX_FULL) {
578 pdata->mac_cr &= ~MAC_CR_FDPX_;
579 pdata->mac_cr |= MAC_CR_RCVOWN_;
580 } else {
581 pdata->mac_cr &= ~MAC_CR_RCVOWN_;
582 pdata->mac_cr |= MAC_CR_FDPX_;
583 }
584 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
585
586 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
587 if (ret < 0) {
588 if (ret != -ENODEV)
589 netdev_warn(dev->net,
590 "Error updating MAC full duplex mode\n");
591 return;
592 }
593
594 ret = smsc95xx_phy_update_flowcontrol(dev);
595 if (ret < 0)
596 netdev_warn(dev->net, "Error updating PHY flow control\n");
597 }
598
smsc95xx_status(struct usbnet * dev,struct urb * urb)599 static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
600 {
601 u32 intdata;
602
603 if (urb->actual_length != 4) {
604 netdev_warn(dev->net, "unexpected urb length %d\n",
605 urb->actual_length);
606 return;
607 }
608
609 intdata = get_unaligned_le32(urb->transfer_buffer);
610 netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
611
612 if (intdata & INT_ENP_PHY_INT_)
613 ;
614 else
615 netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
616 intdata);
617 }
618
619 /* Enable or disable Tx & Rx checksum offload engines */
smsc95xx_set_features(struct net_device * netdev,netdev_features_t features)620 static int smsc95xx_set_features(struct net_device *netdev,
621 netdev_features_t features)
622 {
623 struct usbnet *dev = netdev_priv(netdev);
624 u32 read_buf;
625 int ret;
626
627 ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
628 if (ret < 0)
629 return ret;
630
631 if (features & NETIF_F_IP_CSUM)
632 read_buf |= Tx_COE_EN_;
633 else
634 read_buf &= ~Tx_COE_EN_;
635
636 if (features & NETIF_F_RXCSUM)
637 read_buf |= Rx_COE_EN_;
638 else
639 read_buf &= ~Rx_COE_EN_;
640
641 ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
642 if (ret < 0)
643 return ret;
644
645 netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
646 return 0;
647 }
648
smsc95xx_ethtool_get_eeprom_len(struct net_device * net)649 static int smsc95xx_ethtool_get_eeprom_len(struct net_device *net)
650 {
651 return MAX_EEPROM_SIZE;
652 }
653
smsc95xx_ethtool_get_eeprom(struct net_device * netdev,struct ethtool_eeprom * ee,u8 * data)654 static int smsc95xx_ethtool_get_eeprom(struct net_device *netdev,
655 struct ethtool_eeprom *ee, u8 *data)
656 {
657 struct usbnet *dev = netdev_priv(netdev);
658
659 ee->magic = LAN95XX_EEPROM_MAGIC;
660
661 return smsc95xx_read_eeprom(dev, ee->offset, ee->len, data);
662 }
663
smsc95xx_ethtool_set_eeprom(struct net_device * netdev,struct ethtool_eeprom * ee,u8 * data)664 static int smsc95xx_ethtool_set_eeprom(struct net_device *netdev,
665 struct ethtool_eeprom *ee, u8 *data)
666 {
667 struct usbnet *dev = netdev_priv(netdev);
668
669 if (ee->magic != LAN95XX_EEPROM_MAGIC) {
670 netdev_warn(dev->net, "EEPROM: magic value mismatch, magic = 0x%x\n",
671 ee->magic);
672 return -EINVAL;
673 }
674
675 return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data);
676 }
677
smsc95xx_ethtool_getregslen(struct net_device * netdev)678 static int smsc95xx_ethtool_getregslen(struct net_device *netdev)
679 {
680 /* all smsc95xx registers */
681 return COE_CR - ID_REV + sizeof(u32);
682 }
683
684 static void
smsc95xx_ethtool_getregs(struct net_device * netdev,struct ethtool_regs * regs,void * buf)685 smsc95xx_ethtool_getregs(struct net_device *netdev, struct ethtool_regs *regs,
686 void *buf)
687 {
688 struct usbnet *dev = netdev_priv(netdev);
689 unsigned int i, j;
690 int retval;
691 u32 *data = buf;
692
693 retval = smsc95xx_read_reg(dev, ID_REV, ®s->version);
694 if (retval < 0) {
695 netdev_warn(netdev, "REGS: cannot read ID_REV\n");
696 return;
697 }
698
699 for (i = ID_REV, j = 0; i <= COE_CR; i += (sizeof(u32)), j++) {
700 retval = smsc95xx_read_reg(dev, i, &data[j]);
701 if (retval < 0) {
702 netdev_warn(netdev, "REGS: cannot read reg[%x]\n", i);
703 return;
704 }
705 }
706 }
707
smsc95xx_ethtool_get_wol(struct net_device * net,struct ethtool_wolinfo * wolinfo)708 static void smsc95xx_ethtool_get_wol(struct net_device *net,
709 struct ethtool_wolinfo *wolinfo)
710 {
711 struct usbnet *dev = netdev_priv(net);
712 struct smsc95xx_priv *pdata = dev->driver_priv;
713
714 wolinfo->supported = SUPPORTED_WAKE;
715 wolinfo->wolopts = pdata->wolopts;
716 }
717
smsc95xx_ethtool_set_wol(struct net_device * net,struct ethtool_wolinfo * wolinfo)718 static int smsc95xx_ethtool_set_wol(struct net_device *net,
719 struct ethtool_wolinfo *wolinfo)
720 {
721 struct usbnet *dev = netdev_priv(net);
722 struct smsc95xx_priv *pdata = dev->driver_priv;
723 int ret;
724
725 if (wolinfo->wolopts & ~SUPPORTED_WAKE)
726 return -EINVAL;
727
728 pdata->wolopts = wolinfo->wolopts & SUPPORTED_WAKE;
729
730 ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
731 if (ret < 0)
732 netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
733
734 return ret;
735 }
736
smsc95xx_get_link(struct net_device * net)737 static u32 smsc95xx_get_link(struct net_device *net)
738 {
739 phy_read_status(net->phydev);
740 return net->phydev->link;
741 }
742
743 static const struct ethtool_ops smsc95xx_ethtool_ops = {
744 .get_link = smsc95xx_get_link,
745 .nway_reset = phy_ethtool_nway_reset,
746 .get_drvinfo = usbnet_get_drvinfo,
747 .get_msglevel = usbnet_get_msglevel,
748 .set_msglevel = usbnet_set_msglevel,
749 .get_eeprom_len = smsc95xx_ethtool_get_eeprom_len,
750 .get_eeprom = smsc95xx_ethtool_get_eeprom,
751 .set_eeprom = smsc95xx_ethtool_set_eeprom,
752 .get_regs_len = smsc95xx_ethtool_getregslen,
753 .get_regs = smsc95xx_ethtool_getregs,
754 .get_wol = smsc95xx_ethtool_get_wol,
755 .set_wol = smsc95xx_ethtool_set_wol,
756 .get_link_ksettings = phy_ethtool_get_link_ksettings,
757 .set_link_ksettings = phy_ethtool_set_link_ksettings,
758 .get_ts_info = ethtool_op_get_ts_info,
759 };
760
smsc95xx_ioctl(struct net_device * netdev,struct ifreq * rq,int cmd)761 static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
762 {
763 if (!netif_running(netdev))
764 return -EINVAL;
765
766 return phy_mii_ioctl(netdev->phydev, rq, cmd);
767 }
768
smsc95xx_init_mac_address(struct usbnet * dev)769 static void smsc95xx_init_mac_address(struct usbnet *dev)
770 {
771 /* maybe the boot loader passed the MAC address in devicetree */
772 if (!eth_platform_get_mac_address(&dev->udev->dev,
773 dev->net->dev_addr)) {
774 if (is_valid_ether_addr(dev->net->dev_addr)) {
775 /* device tree values are valid so use them */
776 netif_dbg(dev, ifup, dev->net, "MAC address read from the device tree\n");
777 return;
778 }
779 }
780
781 /* try reading mac address from EEPROM */
782 if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
783 dev->net->dev_addr) == 0) {
784 if (is_valid_ether_addr(dev->net->dev_addr)) {
785 /* eeprom values are valid so use them */
786 netif_dbg(dev, ifup, dev->net, "MAC address read from EEPROM\n");
787 return;
788 }
789 }
790
791 /* no useful static MAC address found. generate a random one */
792 eth_hw_addr_random(dev->net);
793 netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
794 }
795
smsc95xx_set_mac_address(struct usbnet * dev)796 static int smsc95xx_set_mac_address(struct usbnet *dev)
797 {
798 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
799 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
800 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
801 int ret;
802
803 ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
804 if (ret < 0)
805 return ret;
806
807 return smsc95xx_write_reg(dev, ADDRH, addr_hi);
808 }
809
810 /* starts the TX path */
smsc95xx_start_tx_path(struct usbnet * dev)811 static int smsc95xx_start_tx_path(struct usbnet *dev)
812 {
813 struct smsc95xx_priv *pdata = dev->driver_priv;
814 unsigned long flags;
815 int ret;
816
817 /* Enable Tx at MAC */
818 spin_lock_irqsave(&pdata->mac_cr_lock, flags);
819 pdata->mac_cr |= MAC_CR_TXEN_;
820 spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
821
822 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
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 */
smsc95xx_start_rx_path(struct usbnet * dev,int in_pm)831 static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
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
840 return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
841 }
842
smsc95xx_reset(struct usbnet * dev)843 static 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
849 netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
850
851 ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
852 if (ret < 0)
853 return ret;
854
855 timeout = 0;
856 do {
857 msleep(10);
858 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
859 if (ret < 0)
860 return ret;
861 timeout++;
862 } while ((read_buf & HW_CFG_LRST_) && (timeout < 100));
863
864 if (timeout >= 100) {
865 netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
866 return ret;
867 }
868
869 ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
870 if (ret < 0)
871 return ret;
872
873 timeout = 0;
874 do {
875 msleep(10);
876 ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
877 if (ret < 0)
878 return ret;
879 timeout++;
880 } while ((read_buf & PM_CTL_PHY_RST_) && (timeout < 100));
881
882 if (timeout >= 100) {
883 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
884 return ret;
885 }
886
887 ret = smsc95xx_set_mac_address(dev);
888 if (ret < 0)
889 return ret;
890
891 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
892 dev->net->dev_addr);
893
894 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
895 if (ret < 0)
896 return ret;
897
898 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
899 read_buf);
900
901 read_buf |= HW_CFG_BIR_;
902
903 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
904 if (ret < 0)
905 return ret;
906
907 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
908 if (ret < 0)
909 return ret;
910
911 netif_dbg(dev, ifup, dev->net,
912 "Read Value from HW_CFG after writing HW_CFG_BIR_: 0x%08x\n",
913 read_buf);
914
915 if (!turbo_mode) {
916 burst_cap = 0;
917 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
918 } else if (dev->udev->speed == USB_SPEED_HIGH) {
919 burst_cap = DEFAULT_HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
920 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
921 } else {
922 burst_cap = DEFAULT_FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
923 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
924 }
925
926 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
927 (ulong)dev->rx_urb_size);
928
929 ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
930 if (ret < 0)
931 return ret;
932
933 ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
934 if (ret < 0)
935 return ret;
936
937 netif_dbg(dev, ifup, dev->net,
938 "Read Value from BURST_CAP after writing: 0x%08x\n",
939 read_buf);
940
941 ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
942 if (ret < 0)
943 return ret;
944
945 ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
946 if (ret < 0)
947 return ret;
948
949 netif_dbg(dev, ifup, dev->net,
950 "Read Value from BULK_IN_DLY after writing: 0x%08x\n",
951 read_buf);
952
953 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
954 if (ret < 0)
955 return ret;
956
957 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
958 read_buf);
959
960 if (turbo_mode)
961 read_buf |= (HW_CFG_MEF_ | HW_CFG_BCE_);
962
963 read_buf &= ~HW_CFG_RXDOFF_;
964
965 /* set Rx data offset=2, Make IP header aligns on word boundary. */
966 read_buf |= NET_IP_ALIGN << 9;
967
968 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
969 if (ret < 0)
970 return ret;
971
972 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
973 if (ret < 0)
974 return ret;
975
976 netif_dbg(dev, ifup, dev->net,
977 "Read Value from HW_CFG after writing: 0x%08x\n", read_buf);
978
979 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
980 if (ret < 0)
981 return ret;
982
983 ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
984 if (ret < 0)
985 return ret;
986 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
987
988 /* Configure GPIO pins as LED outputs */
989 write_buf = LED_GPIO_CFG_SPD_LED | LED_GPIO_CFG_LNK_LED |
990 LED_GPIO_CFG_FDX_LED;
991 ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
992 if (ret < 0)
993 return ret;
994
995 /* Init Tx */
996 ret = smsc95xx_write_reg(dev, FLOW, 0);
997 if (ret < 0)
998 return ret;
999
1000 ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
1001 if (ret < 0)
1002 return ret;
1003
1004 /* Don't need mac_cr_lock during initialisation */
1005 ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
1006 if (ret < 0)
1007 return ret;
1008
1009 /* Init Rx */
1010 /* Set Vlan */
1011 ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
1012 if (ret < 0)
1013 return ret;
1014
1015 /* Enable or disable checksum offload engines */
1016 ret = smsc95xx_set_features(dev->net, dev->net->features);
1017 if (ret < 0) {
1018 netdev_warn(dev->net, "Failed to set checksum offload features\n");
1019 return ret;
1020 }
1021
1022 smsc95xx_set_multicast(dev->net);
1023
1024 ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
1025 if (ret < 0)
1026 return ret;
1027
1028 /* enable PHY interrupts */
1029 read_buf |= INT_EP_CTL_PHY_INT_;
1030
1031 ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
1032 if (ret < 0)
1033 return ret;
1034
1035 ret = smsc95xx_start_tx_path(dev);
1036 if (ret < 0) {
1037 netdev_warn(dev->net, "Failed to start TX path\n");
1038 return ret;
1039 }
1040
1041 ret = smsc95xx_start_rx_path(dev, 0);
1042 if (ret < 0) {
1043 netdev_warn(dev->net, "Failed to start RX path\n");
1044 return ret;
1045 }
1046
1047 netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
1048 return 0;
1049 }
1050
1051 static const struct net_device_ops smsc95xx_netdev_ops = {
1052 .ndo_open = usbnet_open,
1053 .ndo_stop = usbnet_stop,
1054 .ndo_start_xmit = usbnet_start_xmit,
1055 .ndo_tx_timeout = usbnet_tx_timeout,
1056 .ndo_change_mtu = usbnet_change_mtu,
1057 .ndo_get_stats64 = usbnet_get_stats64,
1058 .ndo_set_mac_address = eth_mac_addr,
1059 .ndo_validate_addr = eth_validate_addr,
1060 .ndo_do_ioctl = smsc95xx_ioctl,
1061 .ndo_set_rx_mode = smsc95xx_set_multicast,
1062 .ndo_set_features = smsc95xx_set_features,
1063 };
1064
smsc95xx_handle_link_change(struct net_device * net)1065 static void smsc95xx_handle_link_change(struct net_device *net)
1066 {
1067 struct usbnet *dev = netdev_priv(net);
1068
1069 phy_print_status(net->phydev);
1070 smsc95xx_mac_update_fullduplex(dev);
1071 usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
1072 }
1073
smsc95xx_bind(struct usbnet * dev,struct usb_interface * intf)1074 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
1075 {
1076 struct smsc95xx_priv *pdata;
1077 bool is_internal_phy;
1078 u32 val;
1079 int ret;
1080
1081 printk(KERN_INFO SMSC_CHIPNAME " v" SMSC_DRIVER_VERSION "\n");
1082
1083 ret = usbnet_get_endpoints(dev, intf);
1084 if (ret < 0) {
1085 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1086 return ret;
1087 }
1088
1089 pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
1090 if (!pdata)
1091 return -ENOMEM;
1092
1093 dev->driver_priv = pdata;
1094
1095 spin_lock_init(&pdata->mac_cr_lock);
1096
1097 /* LAN95xx devices do not alter the computed checksum of 0 to 0xffff.
1098 * RFC 2460, ipv6 UDP calculated checksum yields a result of zero must
1099 * be changed to 0xffff. RFC 768, ipv4 UDP computed checksum is zero,
1100 * it is transmitted as all ones. The zero transmitted checksum means
1101 * transmitter generated no checksum. Hence, enable csum offload only
1102 * for ipv4 packets.
1103 */
1104 if (DEFAULT_TX_CSUM_ENABLE)
1105 dev->net->features |= NETIF_F_IP_CSUM;
1106 if (DEFAULT_RX_CSUM_ENABLE)
1107 dev->net->features |= NETIF_F_RXCSUM;
1108
1109 dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
1110 set_bit(EVENT_NO_IP_ALIGN, &dev->flags);
1111
1112 smsc95xx_init_mac_address(dev);
1113
1114 /* Init all registers */
1115 ret = smsc95xx_reset(dev);
1116 if (ret)
1117 goto free_pdata;
1118
1119 pdata->mdiobus = mdiobus_alloc();
1120 if (!pdata->mdiobus) {
1121 ret = -ENOMEM;
1122 goto free_pdata;
1123 }
1124
1125 ret = smsc95xx_read_reg(dev, HW_CFG, &val);
1126 if (ret < 0)
1127 goto free_mdio;
1128
1129 is_internal_phy = !(val & HW_CFG_PSEL_);
1130 if (is_internal_phy)
1131 pdata->mdiobus->phy_mask = ~(1u << SMSC95XX_INTERNAL_PHY_ID);
1132
1133 pdata->mdiobus->priv = dev;
1134 pdata->mdiobus->read = smsc95xx_mdiobus_read;
1135 pdata->mdiobus->write = smsc95xx_mdiobus_write;
1136 pdata->mdiobus->name = "smsc95xx-mdiobus";
1137 pdata->mdiobus->parent = &dev->udev->dev;
1138
1139 snprintf(pdata->mdiobus->id, ARRAY_SIZE(pdata->mdiobus->id),
1140 "usb-%03d:%03d", dev->udev->bus->busnum, dev->udev->devnum);
1141
1142 ret = mdiobus_register(pdata->mdiobus);
1143 if (ret) {
1144 netdev_err(dev->net, "Could not register MDIO bus\n");
1145 goto free_mdio;
1146 }
1147
1148 pdata->phydev = phy_find_first(pdata->mdiobus);
1149 if (!pdata->phydev) {
1150 netdev_err(dev->net, "no PHY found\n");
1151 ret = -ENODEV;
1152 goto unregister_mdio;
1153 }
1154
1155 pdata->phydev->is_internal = is_internal_phy;
1156
1157 /* detect device revision as different features may be available */
1158 ret = smsc95xx_read_reg(dev, ID_REV, &val);
1159 if (ret < 0)
1160 goto unregister_mdio;
1161
1162 val >>= 16;
1163 if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) ||
1164 (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_))
1165 pdata->features = (FEATURE_8_WAKEUP_FILTERS |
1166 FEATURE_PHY_NLP_CROSSOVER |
1167 FEATURE_REMOTE_WAKEUP);
1168 else if (val == ID_REV_CHIP_ID_9512_)
1169 pdata->features = FEATURE_8_WAKEUP_FILTERS;
1170
1171 dev->net->netdev_ops = &smsc95xx_netdev_ops;
1172 dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
1173 dev->net->flags |= IFF_MULTICAST;
1174 dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
1175 dev->net->min_mtu = ETH_MIN_MTU;
1176 dev->net->max_mtu = ETH_DATA_LEN;
1177 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1178
1179 ret = phy_connect_direct(dev->net, pdata->phydev,
1180 &smsc95xx_handle_link_change,
1181 PHY_INTERFACE_MODE_MII);
1182 if (ret) {
1183 netdev_err(dev->net, "can't attach PHY to %s\n", pdata->mdiobus->id);
1184 goto unregister_mdio;
1185 }
1186
1187 phy_attached_info(dev->net->phydev);
1188
1189 return 0;
1190
1191 unregister_mdio:
1192 mdiobus_unregister(pdata->mdiobus);
1193
1194 free_mdio:
1195 mdiobus_free(pdata->mdiobus);
1196
1197 free_pdata:
1198 kfree(pdata);
1199 return ret;
1200 }
1201
smsc95xx_unbind(struct usbnet * dev,struct usb_interface * intf)1202 static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)
1203 {
1204 struct smsc95xx_priv *pdata = dev->driver_priv;
1205
1206 phy_disconnect(dev->net->phydev);
1207 mdiobus_unregister(pdata->mdiobus);
1208 mdiobus_free(pdata->mdiobus);
1209 netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1210 kfree(pdata);
1211 }
1212
smsc95xx_start_phy(struct usbnet * dev)1213 static int smsc95xx_start_phy(struct usbnet *dev)
1214 {
1215 phy_start(dev->net->phydev);
1216
1217 return 0;
1218 }
1219
smsc95xx_stop(struct usbnet * dev)1220 static int smsc95xx_stop(struct usbnet *dev)
1221 {
1222 if (dev->net->phydev)
1223 phy_stop(dev->net->phydev);
1224
1225 return 0;
1226 }
1227
smsc_crc(const u8 * buffer,size_t len,int filter)1228 static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
1229 {
1230 u32 crc = bitrev16(crc16(0xFFFF, buffer, len));
1231 return crc << ((filter % 2) * 16);
1232 }
1233
smsc95xx_enable_phy_wakeup_interrupts(struct usbnet * dev,u16 mask)1234 static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
1235 {
1236 int ret;
1237
1238 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1239
1240 /* read to clear */
1241 ret = smsc95xx_mdio_read_nopm(dev, PHY_INT_SRC);
1242 if (ret < 0)
1243 return ret;
1244
1245 /* enable interrupt source */
1246 ret = smsc95xx_mdio_read_nopm(dev, PHY_INT_MASK);
1247 if (ret < 0)
1248 return ret;
1249
1250 ret |= mask;
1251
1252 smsc95xx_mdio_write_nopm(dev, PHY_INT_MASK, ret);
1253
1254 return 0;
1255 }
1256
smsc95xx_link_ok_nopm(struct usbnet * dev)1257 static int smsc95xx_link_ok_nopm(struct usbnet *dev)
1258 {
1259 int ret;
1260
1261 /* first, a dummy read, needed to latch some MII phys */
1262 ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
1263 if (ret < 0)
1264 return ret;
1265
1266 ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
1267 if (ret < 0)
1268 return ret;
1269
1270 return !!(ret & BMSR_LSTATUS);
1271 }
1272
smsc95xx_enter_suspend0(struct usbnet * dev)1273 static int smsc95xx_enter_suspend0(struct usbnet *dev)
1274 {
1275 struct smsc95xx_priv *pdata = dev->driver_priv;
1276 u32 val;
1277 int ret;
1278
1279 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1280 if (ret < 0)
1281 return ret;
1282
1283 val &= (~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_));
1284 val |= PM_CTL_SUS_MODE_0;
1285
1286 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1287 if (ret < 0)
1288 return ret;
1289
1290 /* clear wol status */
1291 val &= ~PM_CTL_WUPS_;
1292 val |= PM_CTL_WUPS_WOL_;
1293
1294 /* enable energy detection */
1295 if (pdata->wolopts & WAKE_PHY)
1296 val |= PM_CTL_WUPS_ED_;
1297
1298 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1299 if (ret < 0)
1300 return ret;
1301
1302 /* read back PM_CTRL */
1303 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1304 if (ret < 0)
1305 return ret;
1306
1307 pdata->suspend_flags |= SUSPEND_SUSPEND0;
1308
1309 return 0;
1310 }
1311
smsc95xx_enter_suspend1(struct usbnet * dev)1312 static int smsc95xx_enter_suspend1(struct usbnet *dev)
1313 {
1314 struct smsc95xx_priv *pdata = dev->driver_priv;
1315 u32 val;
1316 int ret;
1317
1318 /* reconfigure link pulse detection timing for
1319 * compatibility with non-standard link partners
1320 */
1321 if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
1322 smsc95xx_mdio_write_nopm(dev, PHY_EDPD_CONFIG,
1323 PHY_EDPD_CONFIG_DEFAULT);
1324
1325 /* enable energy detect power-down mode */
1326 ret = smsc95xx_mdio_read_nopm(dev, PHY_MODE_CTRL_STS);
1327 if (ret < 0)
1328 return ret;
1329
1330 ret |= MODE_CTRL_STS_EDPWRDOWN_;
1331
1332 smsc95xx_mdio_write_nopm(dev, PHY_MODE_CTRL_STS, ret);
1333
1334 /* enter SUSPEND1 mode */
1335 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1336 if (ret < 0)
1337 return ret;
1338
1339 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1340 val |= PM_CTL_SUS_MODE_1;
1341
1342 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1343 if (ret < 0)
1344 return ret;
1345
1346 /* clear wol status, enable energy detection */
1347 val &= ~PM_CTL_WUPS_;
1348 val |= (PM_CTL_WUPS_ED_ | PM_CTL_ED_EN_);
1349
1350 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1351 if (ret < 0)
1352 return ret;
1353
1354 pdata->suspend_flags |= SUSPEND_SUSPEND1;
1355
1356 return 0;
1357 }
1358
smsc95xx_enter_suspend2(struct usbnet * dev)1359 static int smsc95xx_enter_suspend2(struct usbnet *dev)
1360 {
1361 struct smsc95xx_priv *pdata = dev->driver_priv;
1362 u32 val;
1363 int ret;
1364
1365 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1366 if (ret < 0)
1367 return ret;
1368
1369 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1370 val |= PM_CTL_SUS_MODE_2;
1371
1372 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1373 if (ret < 0)
1374 return ret;
1375
1376 pdata->suspend_flags |= SUSPEND_SUSPEND2;
1377
1378 return 0;
1379 }
1380
smsc95xx_enter_suspend3(struct usbnet * dev)1381 static int smsc95xx_enter_suspend3(struct usbnet *dev)
1382 {
1383 struct smsc95xx_priv *pdata = dev->driver_priv;
1384 u32 val;
1385 int ret;
1386
1387 ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val);
1388 if (ret < 0)
1389 return ret;
1390
1391 if (val & RX_FIFO_INF_USED_) {
1392 netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
1393 return -EBUSY;
1394 }
1395
1396 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1397 if (ret < 0)
1398 return ret;
1399
1400 val &= ~(PM_CTL_SUS_MODE_ | PM_CTL_WUPS_ | PM_CTL_PHY_RST_);
1401 val |= PM_CTL_SUS_MODE_3 | PM_CTL_RES_CLR_WKP_STS;
1402
1403 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1404 if (ret < 0)
1405 return ret;
1406
1407 /* clear wol status */
1408 val &= ~PM_CTL_WUPS_;
1409 val |= PM_CTL_WUPS_WOL_;
1410
1411 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1412 if (ret < 0)
1413 return ret;
1414
1415 pdata->suspend_flags |= SUSPEND_SUSPEND3;
1416
1417 return 0;
1418 }
1419
smsc95xx_autosuspend(struct usbnet * dev,u32 link_up)1420 static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up)
1421 {
1422 struct smsc95xx_priv *pdata = dev->driver_priv;
1423 int ret;
1424
1425 if (!netif_running(dev->net)) {
1426 /* interface is ifconfig down so fully power down hw */
1427 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
1428 return smsc95xx_enter_suspend2(dev);
1429 }
1430
1431 if (!link_up) {
1432 /* link is down so enter EDPD mode, but only if device can
1433 * reliably resume from it. This check should be redundant
1434 * as current FEATURE_REMOTE_WAKEUP parts also support
1435 * FEATURE_PHY_NLP_CROSSOVER but it's included for clarity */
1436 if (!(pdata->features & FEATURE_PHY_NLP_CROSSOVER)) {
1437 netdev_warn(dev->net, "EDPD not supported\n");
1438 return -EBUSY;
1439 }
1440
1441 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
1442
1443 /* enable PHY wakeup events for if cable is attached */
1444 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1445 PHY_INT_MASK_ANEG_COMP_);
1446 if (ret < 0) {
1447 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1448 return ret;
1449 }
1450
1451 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1452 return smsc95xx_enter_suspend1(dev);
1453 }
1454
1455 /* enable PHY wakeup events so we remote wakeup if cable is pulled */
1456 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1457 PHY_INT_MASK_LINK_DOWN_);
1458 if (ret < 0) {
1459 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1460 return ret;
1461 }
1462
1463 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
1464 return smsc95xx_enter_suspend3(dev);
1465 }
1466
smsc95xx_suspend(struct usb_interface * intf,pm_message_t message)1467 static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
1468 {
1469 struct usbnet *dev = usb_get_intfdata(intf);
1470 struct smsc95xx_priv *pdata = dev->driver_priv;
1471 u32 val, link_up;
1472 int ret;
1473
1474 pdata->pm_task = current;
1475
1476 ret = usbnet_suspend(intf, message);
1477 if (ret < 0) {
1478 netdev_warn(dev->net, "usbnet_suspend error\n");
1479 pdata->pm_task = NULL;
1480 return ret;
1481 }
1482
1483 if (pdata->suspend_flags) {
1484 netdev_warn(dev->net, "error during last resume\n");
1485 pdata->suspend_flags = 0;
1486 }
1487
1488 /* determine if link is up using only _nopm functions */
1489 link_up = smsc95xx_link_ok_nopm(dev);
1490
1491 if (message.event == PM_EVENT_AUTO_SUSPEND &&
1492 (pdata->features & FEATURE_REMOTE_WAKEUP)) {
1493 ret = smsc95xx_autosuspend(dev, link_up);
1494 goto done;
1495 }
1496
1497 /* if we get this far we're not autosuspending */
1498 /* if no wol options set, or if link is down and we're not waking on
1499 * PHY activity, enter lowest power SUSPEND2 mode
1500 */
1501 if (!(pdata->wolopts & SUPPORTED_WAKE) ||
1502 !(link_up || (pdata->wolopts & WAKE_PHY))) {
1503 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1504
1505 /* disable energy detect (link up) & wake up events */
1506 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1507 if (ret < 0)
1508 goto done;
1509
1510 val &= ~(WUCSR_MPEN_ | WUCSR_WAKE_EN_);
1511
1512 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1513 if (ret < 0)
1514 goto done;
1515
1516 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1517 if (ret < 0)
1518 goto done;
1519
1520 val &= ~(PM_CTL_ED_EN_ | PM_CTL_WOL_EN_);
1521
1522 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1523 if (ret < 0)
1524 goto done;
1525
1526 ret = smsc95xx_enter_suspend2(dev);
1527 goto done;
1528 }
1529
1530 if (pdata->wolopts & WAKE_PHY) {
1531 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1532 (PHY_INT_MASK_ANEG_COMP_ | PHY_INT_MASK_LINK_DOWN_));
1533 if (ret < 0) {
1534 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1535 goto done;
1536 }
1537
1538 /* if link is down then configure EDPD and enter SUSPEND1,
1539 * otherwise enter SUSPEND0 below
1540 */
1541 if (!link_up) {
1542 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1543 ret = smsc95xx_enter_suspend1(dev);
1544 goto done;
1545 }
1546 }
1547
1548 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1549 u32 *filter_mask = kcalloc(32, sizeof(u32), GFP_KERNEL);
1550 u32 command[2];
1551 u32 offset[2];
1552 u32 crc[4];
1553 int wuff_filter_count =
1554 (pdata->features & FEATURE_8_WAKEUP_FILTERS) ?
1555 LAN9500A_WUFF_NUM : LAN9500_WUFF_NUM;
1556 int i, filter = 0;
1557
1558 if (!filter_mask) {
1559 netdev_warn(dev->net, "Unable to allocate filter_mask\n");
1560 ret = -ENOMEM;
1561 goto done;
1562 }
1563
1564 memset(command, 0, sizeof(command));
1565 memset(offset, 0, sizeof(offset));
1566 memset(crc, 0, sizeof(crc));
1567
1568 if (pdata->wolopts & WAKE_BCAST) {
1569 const u8 bcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
1570 netdev_info(dev->net, "enabling broadcast detection\n");
1571 filter_mask[filter * 4] = 0x003F;
1572 filter_mask[filter * 4 + 1] = 0x00;
1573 filter_mask[filter * 4 + 2] = 0x00;
1574 filter_mask[filter * 4 + 3] = 0x00;
1575 command[filter/4] |= 0x05UL << ((filter % 4) * 8);
1576 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1577 crc[filter/2] |= smsc_crc(bcast, 6, filter);
1578 filter++;
1579 }
1580
1581 if (pdata->wolopts & WAKE_MCAST) {
1582 const u8 mcast[] = {0x01, 0x00, 0x5E};
1583 netdev_info(dev->net, "enabling multicast detection\n");
1584 filter_mask[filter * 4] = 0x0007;
1585 filter_mask[filter * 4 + 1] = 0x00;
1586 filter_mask[filter * 4 + 2] = 0x00;
1587 filter_mask[filter * 4 + 3] = 0x00;
1588 command[filter/4] |= 0x09UL << ((filter % 4) * 8);
1589 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1590 crc[filter/2] |= smsc_crc(mcast, 3, filter);
1591 filter++;
1592 }
1593
1594 if (pdata->wolopts & WAKE_ARP) {
1595 const u8 arp[] = {0x08, 0x06};
1596 netdev_info(dev->net, "enabling ARP detection\n");
1597 filter_mask[filter * 4] = 0x0003;
1598 filter_mask[filter * 4 + 1] = 0x00;
1599 filter_mask[filter * 4 + 2] = 0x00;
1600 filter_mask[filter * 4 + 3] = 0x00;
1601 command[filter/4] |= 0x05UL << ((filter % 4) * 8);
1602 offset[filter/4] |= 0x0C << ((filter % 4) * 8);
1603 crc[filter/2] |= smsc_crc(arp, 2, filter);
1604 filter++;
1605 }
1606
1607 if (pdata->wolopts & WAKE_UCAST) {
1608 netdev_info(dev->net, "enabling unicast detection\n");
1609 filter_mask[filter * 4] = 0x003F;
1610 filter_mask[filter * 4 + 1] = 0x00;
1611 filter_mask[filter * 4 + 2] = 0x00;
1612 filter_mask[filter * 4 + 3] = 0x00;
1613 command[filter/4] |= 0x01UL << ((filter % 4) * 8);
1614 offset[filter/4] |= 0x00 << ((filter % 4) * 8);
1615 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1616 filter++;
1617 }
1618
1619 for (i = 0; i < (wuff_filter_count * 4); i++) {
1620 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
1621 if (ret < 0) {
1622 kfree(filter_mask);
1623 goto done;
1624 }
1625 }
1626 kfree(filter_mask);
1627
1628 for (i = 0; i < (wuff_filter_count / 4); i++) {
1629 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1630 if (ret < 0)
1631 goto done;
1632 }
1633
1634 for (i = 0; i < (wuff_filter_count / 4); i++) {
1635 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1636 if (ret < 0)
1637 goto done;
1638 }
1639
1640 for (i = 0; i < (wuff_filter_count / 2); i++) {
1641 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1642 if (ret < 0)
1643 goto done;
1644 }
1645
1646 /* clear any pending pattern match packet status */
1647 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1648 if (ret < 0)
1649 goto done;
1650
1651 val |= WUCSR_WUFR_;
1652
1653 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1654 if (ret < 0)
1655 goto done;
1656 }
1657
1658 if (pdata->wolopts & WAKE_MAGIC) {
1659 /* clear any pending magic packet status */
1660 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1661 if (ret < 0)
1662 goto done;
1663
1664 val |= WUCSR_MPR_;
1665
1666 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1667 if (ret < 0)
1668 goto done;
1669 }
1670
1671 /* enable/disable wakeup sources */
1672 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1673 if (ret < 0)
1674 goto done;
1675
1676 if (pdata->wolopts & (WAKE_BCAST | WAKE_MCAST | WAKE_ARP | WAKE_UCAST)) {
1677 netdev_info(dev->net, "enabling pattern match wakeup\n");
1678 val |= WUCSR_WAKE_EN_;
1679 } else {
1680 netdev_info(dev->net, "disabling pattern match wakeup\n");
1681 val &= ~WUCSR_WAKE_EN_;
1682 }
1683
1684 if (pdata->wolopts & WAKE_MAGIC) {
1685 netdev_info(dev->net, "enabling magic packet wakeup\n");
1686 val |= WUCSR_MPEN_;
1687 } else {
1688 netdev_info(dev->net, "disabling magic packet wakeup\n");
1689 val &= ~WUCSR_MPEN_;
1690 }
1691
1692 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1693 if (ret < 0)
1694 goto done;
1695
1696 /* enable wol wakeup source */
1697 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1698 if (ret < 0)
1699 goto done;
1700
1701 val |= PM_CTL_WOL_EN_;
1702
1703 /* phy energy detect wakeup source */
1704 if (pdata->wolopts & WAKE_PHY)
1705 val |= PM_CTL_ED_EN_;
1706
1707 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1708 if (ret < 0)
1709 goto done;
1710
1711 /* enable receiver to enable frame reception */
1712 smsc95xx_start_rx_path(dev, 1);
1713
1714 /* some wol options are enabled, so enter SUSPEND0 */
1715 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1716 ret = smsc95xx_enter_suspend0(dev);
1717
1718 done:
1719 /*
1720 * TODO: resume() might need to handle the suspend failure
1721 * in system sleep
1722 */
1723 if (ret && PMSG_IS_AUTO(message))
1724 usbnet_resume(intf);
1725
1726 pdata->pm_task = NULL;
1727 return ret;
1728 }
1729
smsc95xx_resume(struct usb_interface * intf)1730 static int smsc95xx_resume(struct usb_interface *intf)
1731 {
1732 struct usbnet *dev = usb_get_intfdata(intf);
1733 struct smsc95xx_priv *pdata;
1734 u8 suspend_flags;
1735 int ret;
1736 u32 val;
1737
1738 BUG_ON(!dev);
1739 pdata = dev->driver_priv;
1740 suspend_flags = pdata->suspend_flags;
1741
1742 netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
1743
1744 /* do this first to ensure it's cleared even in error case */
1745 pdata->suspend_flags = 0;
1746
1747 pdata->pm_task = current;
1748
1749 if (suspend_flags & SUSPEND_ALLMODES) {
1750 /* clear wake-up sources */
1751 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1752 if (ret < 0)
1753 goto done;
1754
1755 val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
1756
1757 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1758 if (ret < 0)
1759 goto done;
1760
1761 /* clear wake-up status */
1762 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1763 if (ret < 0)
1764 goto done;
1765
1766 val &= ~PM_CTL_WOL_EN_;
1767 val |= PM_CTL_WUPS_;
1768
1769 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1770 if (ret < 0)
1771 goto done;
1772 }
1773
1774 ret = usbnet_resume(intf);
1775 if (ret < 0)
1776 netdev_warn(dev->net, "usbnet_resume error\n");
1777
1778 phy_init_hw(pdata->phydev);
1779
1780 done:
1781 pdata->pm_task = NULL;
1782 return ret;
1783 }
1784
smsc95xx_reset_resume(struct usb_interface * intf)1785 static int smsc95xx_reset_resume(struct usb_interface *intf)
1786 {
1787 struct usbnet *dev = usb_get_intfdata(intf);
1788 struct smsc95xx_priv *pdata = dev->driver_priv;
1789 int ret;
1790
1791 pdata->pm_task = current;
1792 ret = smsc95xx_reset(dev);
1793 pdata->pm_task = NULL;
1794 if (ret < 0)
1795 return ret;
1796
1797 return smsc95xx_resume(intf);
1798 }
1799
smsc95xx_rx_csum_offload(struct sk_buff * skb)1800 static void smsc95xx_rx_csum_offload(struct sk_buff *skb)
1801 {
1802 skb->csum = *(u16 *)(skb_tail_pointer(skb) - 2);
1803 skb->ip_summed = CHECKSUM_COMPLETE;
1804 skb_trim(skb, skb->len - 2);
1805 }
1806
smsc95xx_rx_fixup(struct usbnet * dev,struct sk_buff * skb)1807 static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
1808 {
1809 /* This check is no longer done by usbnet */
1810 if (skb->len < dev->net->hard_header_len)
1811 return 0;
1812
1813 while (skb->len > 0) {
1814 u32 header, align_count;
1815 struct sk_buff *ax_skb;
1816 unsigned char *packet;
1817 u16 size;
1818
1819 header = get_unaligned_le32(skb->data);
1820 skb_pull(skb, 4 + NET_IP_ALIGN);
1821 packet = skb->data;
1822
1823 /* get the packet length */
1824 size = (u16)((header & RX_STS_FL_) >> 16);
1825 align_count = (4 - ((size + NET_IP_ALIGN) % 4)) % 4;
1826
1827 if (unlikely(header & RX_STS_ES_)) {
1828 netif_dbg(dev, rx_err, dev->net,
1829 "Error header=0x%08x\n", header);
1830 dev->net->stats.rx_errors++;
1831 dev->net->stats.rx_dropped++;
1832
1833 if (header & RX_STS_CRC_) {
1834 dev->net->stats.rx_crc_errors++;
1835 } else {
1836 if (header & (RX_STS_TL_ | RX_STS_RF_))
1837 dev->net->stats.rx_frame_errors++;
1838
1839 if ((header & RX_STS_LE_) &&
1840 (!(header & RX_STS_FT_)))
1841 dev->net->stats.rx_length_errors++;
1842 }
1843 } else {
1844 /* ETH_FRAME_LEN + 4(CRC) + 2(COE) + 4(Vlan) */
1845 if (unlikely(size > (ETH_FRAME_LEN + 12))) {
1846 netif_dbg(dev, rx_err, dev->net,
1847 "size err header=0x%08x\n", header);
1848 return 0;
1849 }
1850
1851 /* last frame in this batch */
1852 if (skb->len == size) {
1853 if (dev->net->features & NETIF_F_RXCSUM)
1854 smsc95xx_rx_csum_offload(skb);
1855 skb_trim(skb, skb->len - 4); /* remove fcs */
1856 skb->truesize = size + sizeof(struct sk_buff);
1857
1858 return 1;
1859 }
1860
1861 ax_skb = skb_clone(skb, GFP_ATOMIC);
1862 if (unlikely(!ax_skb)) {
1863 netdev_warn(dev->net, "Error allocating skb\n");
1864 return 0;
1865 }
1866
1867 ax_skb->len = size;
1868 ax_skb->data = packet;
1869 skb_set_tail_pointer(ax_skb, size);
1870
1871 if (dev->net->features & NETIF_F_RXCSUM)
1872 smsc95xx_rx_csum_offload(ax_skb);
1873 skb_trim(ax_skb, ax_skb->len - 4); /* remove fcs */
1874 ax_skb->truesize = size + sizeof(struct sk_buff);
1875
1876 usbnet_skb_return(dev, ax_skb);
1877 }
1878
1879 skb_pull(skb, size);
1880
1881 /* padding bytes before the next frame starts */
1882 if (skb->len)
1883 skb_pull(skb, align_count);
1884 }
1885
1886 return 1;
1887 }
1888
smsc95xx_calc_csum_preamble(struct sk_buff * skb)1889 static u32 smsc95xx_calc_csum_preamble(struct sk_buff *skb)
1890 {
1891 u16 low_16 = (u16)skb_checksum_start_offset(skb);
1892 u16 high_16 = low_16 + skb->csum_offset;
1893 return (high_16 << 16) | low_16;
1894 }
1895
1896 /* The TX CSUM won't work if the checksum lies in the last 4 bytes of the
1897 * transmission. This is fairly unlikely, only seems to trigger with some
1898 * short TCP ACK packets sent.
1899 *
1900 * Note, this calculation should probably check for the alignment of the
1901 * data as well, but a straight check for csum being in the last four bytes
1902 * of the packet should be ok for now.
1903 */
smsc95xx_can_tx_checksum(struct sk_buff * skb)1904 static bool smsc95xx_can_tx_checksum(struct sk_buff *skb)
1905 {
1906 unsigned int len = skb->len - skb_checksum_start_offset(skb);
1907
1908 if (skb->len <= 45)
1909 return false;
1910 return skb->csum_offset < (len - (4 + 1));
1911 }
1912
smsc95xx_tx_fixup(struct usbnet * dev,struct sk_buff * skb,gfp_t flags)1913 static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
1914 struct sk_buff *skb, gfp_t flags)
1915 {
1916 bool csum = skb->ip_summed == CHECKSUM_PARTIAL;
1917 int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD;
1918 u32 tx_cmd_a, tx_cmd_b;
1919 void *ptr;
1920
1921 /* We do not advertise SG, so skbs should be already linearized */
1922 BUG_ON(skb_shinfo(skb)->nr_frags);
1923
1924 /* Make writable and expand header space by overhead if required */
1925 if (skb_cow_head(skb, overhead)) {
1926 /* Must deallocate here as returning NULL to indicate error
1927 * means the skb won't be deallocated in the caller.
1928 */
1929 dev_kfree_skb_any(skb);
1930 return NULL;
1931 }
1932
1933 tx_cmd_b = (u32)skb->len;
1934 tx_cmd_a = tx_cmd_b | TX_CMD_A_FIRST_SEG_ | TX_CMD_A_LAST_SEG_;
1935
1936 if (csum) {
1937 if (!smsc95xx_can_tx_checksum(skb)) {
1938 /* workaround - hardware tx checksum does not work
1939 * properly with extremely small packets */
1940 long csstart = skb_checksum_start_offset(skb);
1941 __wsum calc = csum_partial(skb->data + csstart,
1942 skb->len - csstart, 0);
1943 *((__sum16 *)(skb->data + csstart
1944 + skb->csum_offset)) = csum_fold(calc);
1945
1946 csum = false;
1947 } else {
1948 u32 csum_preamble = smsc95xx_calc_csum_preamble(skb);
1949 ptr = skb_push(skb, 4);
1950 put_unaligned_le32(csum_preamble, ptr);
1951
1952 tx_cmd_a += 4;
1953 tx_cmd_b += 4;
1954 tx_cmd_b |= TX_CMD_B_CSUM_ENABLE;
1955 }
1956 }
1957
1958 ptr = skb_push(skb, 8);
1959 put_unaligned_le32(tx_cmd_a, ptr);
1960 put_unaligned_le32(tx_cmd_b, ptr+4);
1961
1962 return skb;
1963 }
1964
smsc95xx_manage_power(struct usbnet * dev,int on)1965 static int smsc95xx_manage_power(struct usbnet *dev, int on)
1966 {
1967 struct smsc95xx_priv *pdata = dev->driver_priv;
1968
1969 dev->intf->needs_remote_wakeup = on;
1970
1971 if (pdata->features & FEATURE_REMOTE_WAKEUP)
1972 return 0;
1973
1974 /* this chip revision isn't capable of remote wakeup */
1975 netdev_info(dev->net, "hardware isn't capable of remote wakeup\n");
1976
1977 if (on)
1978 usb_autopm_get_interface_no_resume(dev->intf);
1979 else
1980 usb_autopm_put_interface(dev->intf);
1981
1982 return 0;
1983 }
1984
1985 static const struct driver_info smsc95xx_info = {
1986 .description = "smsc95xx USB 2.0 Ethernet",
1987 .bind = smsc95xx_bind,
1988 .unbind = smsc95xx_unbind,
1989 .reset = smsc95xx_reset,
1990 .check_connect = smsc95xx_start_phy,
1991 .stop = smsc95xx_stop,
1992 .rx_fixup = smsc95xx_rx_fixup,
1993 .tx_fixup = smsc95xx_tx_fixup,
1994 .status = smsc95xx_status,
1995 .manage_power = smsc95xx_manage_power,
1996 .flags = FLAG_ETHER | FLAG_SEND_ZLP | FLAG_LINK_INTR,
1997 };
1998
1999 static const struct usb_device_id products[] = {
2000 {
2001 /* SMSC9500 USB Ethernet Device */
2002 USB_DEVICE(0x0424, 0x9500),
2003 .driver_info = (unsigned long) &smsc95xx_info,
2004 },
2005 {
2006 /* SMSC9505 USB Ethernet Device */
2007 USB_DEVICE(0x0424, 0x9505),
2008 .driver_info = (unsigned long) &smsc95xx_info,
2009 },
2010 {
2011 /* SMSC9500A USB Ethernet Device */
2012 USB_DEVICE(0x0424, 0x9E00),
2013 .driver_info = (unsigned long) &smsc95xx_info,
2014 },
2015 {
2016 /* SMSC9505A USB Ethernet Device */
2017 USB_DEVICE(0x0424, 0x9E01),
2018 .driver_info = (unsigned long) &smsc95xx_info,
2019 },
2020 {
2021 /* SMSC9512/9514 USB Hub & Ethernet Device */
2022 USB_DEVICE(0x0424, 0xec00),
2023 .driver_info = (unsigned long) &smsc95xx_info,
2024 },
2025 {
2026 /* SMSC9500 USB Ethernet Device (SAL10) */
2027 USB_DEVICE(0x0424, 0x9900),
2028 .driver_info = (unsigned long) &smsc95xx_info,
2029 },
2030 {
2031 /* SMSC9505 USB Ethernet Device (SAL10) */
2032 USB_DEVICE(0x0424, 0x9901),
2033 .driver_info = (unsigned long) &smsc95xx_info,
2034 },
2035 {
2036 /* SMSC9500A USB Ethernet Device (SAL10) */
2037 USB_DEVICE(0x0424, 0x9902),
2038 .driver_info = (unsigned long) &smsc95xx_info,
2039 },
2040 {
2041 /* SMSC9505A USB Ethernet Device (SAL10) */
2042 USB_DEVICE(0x0424, 0x9903),
2043 .driver_info = (unsigned long) &smsc95xx_info,
2044 },
2045 {
2046 /* SMSC9512/9514 USB Hub & Ethernet Device (SAL10) */
2047 USB_DEVICE(0x0424, 0x9904),
2048 .driver_info = (unsigned long) &smsc95xx_info,
2049 },
2050 {
2051 /* SMSC9500A USB Ethernet Device (HAL) */
2052 USB_DEVICE(0x0424, 0x9905),
2053 .driver_info = (unsigned long) &smsc95xx_info,
2054 },
2055 {
2056 /* SMSC9505A USB Ethernet Device (HAL) */
2057 USB_DEVICE(0x0424, 0x9906),
2058 .driver_info = (unsigned long) &smsc95xx_info,
2059 },
2060 {
2061 /* SMSC9500 USB Ethernet Device (Alternate ID) */
2062 USB_DEVICE(0x0424, 0x9907),
2063 .driver_info = (unsigned long) &smsc95xx_info,
2064 },
2065 {
2066 /* SMSC9500A USB Ethernet Device (Alternate ID) */
2067 USB_DEVICE(0x0424, 0x9908),
2068 .driver_info = (unsigned long) &smsc95xx_info,
2069 },
2070 {
2071 /* SMSC9512/9514 USB Hub & Ethernet Device (Alternate ID) */
2072 USB_DEVICE(0x0424, 0x9909),
2073 .driver_info = (unsigned long) &smsc95xx_info,
2074 },
2075 {
2076 /* SMSC LAN9530 USB Ethernet Device */
2077 USB_DEVICE(0x0424, 0x9530),
2078 .driver_info = (unsigned long) &smsc95xx_info,
2079 },
2080 {
2081 /* SMSC LAN9730 USB Ethernet Device */
2082 USB_DEVICE(0x0424, 0x9730),
2083 .driver_info = (unsigned long) &smsc95xx_info,
2084 },
2085 {
2086 /* SMSC LAN89530 USB Ethernet Device */
2087 USB_DEVICE(0x0424, 0x9E08),
2088 .driver_info = (unsigned long) &smsc95xx_info,
2089 },
2090 { }, /* END */
2091 };
2092 MODULE_DEVICE_TABLE(usb, products);
2093
2094 static struct usb_driver smsc95xx_driver = {
2095 .name = "smsc95xx",
2096 .id_table = products,
2097 .probe = usbnet_probe,
2098 .suspend = smsc95xx_suspend,
2099 .resume = smsc95xx_resume,
2100 .reset_resume = smsc95xx_reset_resume,
2101 .disconnect = usbnet_disconnect,
2102 .disable_hub_initiated_lpm = 1,
2103 .supports_autosuspend = 1,
2104 };
2105
2106 module_usb_driver(smsc95xx_driver);
2107
2108 MODULE_AUTHOR("Nancy Lin");
2109 MODULE_AUTHOR("Steve Glendinning <steve.glendinning@shawell.net>");
2110 MODULE_DESCRIPTION("SMSC95XX USB 2.0 Ethernet Devices");
2111 MODULE_LICENSE("GPL");
2112