forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-12-19 9370bb92b2d16684ee45cf24e879c93c509162da 
 kernel/drivers/net/usb/smsc95xx.c
....@@ -1,19 +1,7 @@
1
+// SPDX-License-Identifier: GPL-2.0-or-later
12  /***************************************************************************
23  *
34  * Copyright (C) 2007-2008 SMSC
4
- *
5
- * This program is free software; you can redistribute it and/or
6
- * modify it under the terms of the GNU General Public License
7
- * as published by the Free Software Foundation; either version 2
8
- * of the License, or (at your option) any later version.
9
- *
10
- * This program is distributed in the hope that it will be useful,
11
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
- * GNU General Public License for more details.
14
- *
15
- * You should have received a copy of the GNU General Public License
16
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
175  *
186  *****************************************************************************/
197 
....@@ -30,10 +18,12 @@
3018 #include <linux/usb/usbnet.h>
3119 #include <linux/slab.h>
3220 #include <linux/of_net.h>
21
+#include <linux/mdio.h>
22
+#include <linux/phy.h>
3323 #include "smsc95xx.h"
3424 
3525 #define SMSC_CHIPNAME			"smsc95xx"
36
-#define SMSC_DRIVER_VERSION		"1.0.6"
26
+#define SMSC_DRIVER_VERSION		"2.0.0"
3727 #define HS_USB_PKT_SIZE			(512)
3828 #define FS_USB_PKT_SIZE			(64)
3929 #define DEFAULT_HS_BURST_CAP_SIZE	(16 * 1024 + 5 * HS_USB_PKT_SIZE)
....@@ -61,10 +51,7 @@
6151 #define SUSPEND_ALLMODES		(SUSPEND_SUSPEND0 | SUSPEND_SUSPEND1 | \
6252 					 SUSPEND_SUSPEND2 | SUSPEND_SUSPEND3)
6353 
64
-#define CARRIER_CHECK_DELAY (2 * HZ)
65
-
6654 struct smsc95xx_priv {
67
-	u32 chip_id;
6855 	u32 mac_cr;
6956 	u32 hash_hi;
7057 	u32 hash_lo;
....@@ -72,10 +59,9 @@
7259 	spinlock_t mac_cr_lock;
7360 	u8 features;
7461 	u8 suspend_flags;
75
-	u8 mdix_ctrl;
76
-	bool link_ok;
77
-	struct delayed_work carrier_check;
78
-	struct usbnet *dev;
62
+	struct mii_bus *mdiobus;
63
+	struct phy_device *phydev;
64
+	struct task_struct *pm_task;
7965 };
8066 
8167 static bool turbo_mode = true;
....@@ -85,13 +71,14 @@
8571 static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
8672 					    u32 *data, int in_pm)
8773 {
74
+	struct smsc95xx_priv *pdata = dev->driver_priv;
8875 	u32 buf;
8976 	int ret;
9077 	int (*fn)(struct usbnet *, u8, u8, u16, u16, void *, u16);
9178 
9279 	BUG_ON(!dev);
9380 
94
-	if (!in_pm)
81
+	if (current != pdata->pm_task)
9582 		fn = usbnet_read_cmd;
9683 	else
9784 		fn = usbnet_read_cmd_nopm;
....@@ -99,9 +86,10 @@
9986 	ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
10087 		 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
10188 		 0, index, &buf, 4);
102
-	if (unlikely(ret < 0)) {
103
-		netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
104
-			    index, ret);
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);
10593 		return ret;
10694 	}
10795 
....@@ -114,13 +102,14 @@
114102 static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
115103 					     u32 data, int in_pm)
116104 {
105
+	struct smsc95xx_priv *pdata = dev->driver_priv;
117106 	u32 buf;
118107 	int ret;
119108 	int (*fn)(struct usbnet *, u8, u8, u16, u16, const void *, u16);
120109 
121110 	BUG_ON(!dev);
122111 
123
-	if (!in_pm)
112
+	if (current != pdata->pm_task)
124113 		fn = usbnet_write_cmd;
125114 	else
126115 		fn = usbnet_write_cmd_nopm;
....@@ -131,7 +120,7 @@
131120 	ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
132121 		 | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
133122 		 0, index, &buf, 4);
134
-	if (unlikely(ret < 0))
123
+	if (ret < 0 && ret != -ENODEV)
135124 		netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
136125 			    index, ret);
137126 
....@@ -174,6 +163,9 @@
174163 	do {
175164 		ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
176165 		if (ret < 0) {
166
+			/* Ignore -ENODEV error during disconnect() */
167
+			if (ret == -ENODEV)
168
+				return 0;
177169 			netdev_warn(dev->net, "Error reading MII_ACCESS\n");
178170 			return ret;
179171 		}
....@@ -185,10 +177,14 @@
185177 	return -EIO;
186178 }
187179 
188
-static int __smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx,
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
+
185
+static int __smsc95xx_mdio_read(struct usbnet *dev, int phy_id, int idx,
189186 				int in_pm)
190187 {
191
-	struct usbnet *dev = netdev_priv(netdev);
192188 	u32 val, addr;
193189 	int ret;
194190 
....@@ -197,17 +193,16 @@
197193 	/* confirm MII not busy */
198194 	ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
199195 	if (ret < 0) {
200
-		netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_read\n");
196
+		netdev_warn(dev->net, "%s: MII is busy\n", __func__);
201197 		goto done;
202198 	}
203199 
204200 	/* set the address, index & direction (read from PHY) */
205
-	phy_id &= dev->mii.phy_id_mask;
206
-	idx &= dev->mii.reg_num_mask;
207
-	addr = (phy_id << 11) | (idx << 6) | MII_READ_ | MII_BUSY_;
201
+	addr = mii_address_cmd(phy_id, idx, MII_READ_ | MII_BUSY_);
208202 	ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
209203 	if (ret < 0) {
210
-		netdev_warn(dev->net, "Error writing MII_ADDR\n");
204
+		if (ret != -ENODEV)
205
+			netdev_warn(dev->net, "Error writing MII_ADDR\n");
211206 		goto done;
212207 	}
213208 
....@@ -219,7 +214,8 @@
219214 
220215 	ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
221216 	if (ret < 0) {
222
-		netdev_warn(dev->net, "Error reading MII_DATA\n");
217
+		if (ret != -ENODEV)
218
+			netdev_warn(dev->net, "Error reading MII_DATA\n");
223219 		goto done;
224220 	}
225221 
....@@ -227,13 +223,16 @@
227223 
228224 done:
229225 	mutex_unlock(&dev->phy_mutex);
226
+
227
+	/* Ignore -ENODEV error during disconnect() */
228
+	if (ret == -ENODEV)
229
+		return 0;
230230 	return ret;
231231 }
232232 
233
-static void __smsc95xx_mdio_write(struct net_device *netdev, int phy_id,
233
+static void __smsc95xx_mdio_write(struct usbnet *dev, int phy_id,
234234 				  int idx, int regval, int in_pm)
235235 {
236
-	struct usbnet *dev = netdev_priv(netdev);
237236 	u32 val, addr;
238237 	int ret;
239238 
....@@ -242,24 +241,24 @@
242241 	/* confirm MII not busy */
243242 	ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
244243 	if (ret < 0) {
245
-		netdev_warn(dev->net, "MII is busy in smsc95xx_mdio_write\n");
244
+		netdev_warn(dev->net, "%s: MII is busy\n", __func__);
246245 		goto done;
247246 	}
248247 
249248 	val = regval;
250249 	ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
251250 	if (ret < 0) {
252
-		netdev_warn(dev->net, "Error writing MII_DATA\n");
251
+		if (ret != -ENODEV)
252
+			netdev_warn(dev->net, "Error writing MII_DATA\n");
253253 		goto done;
254254 	}
255255 
256256 	/* set the address, index & direction (write to PHY) */
257
-	phy_id &= dev->mii.phy_id_mask;
258
-	idx &= dev->mii.reg_num_mask;
259
-	addr = (phy_id << 11) | (idx << 6) | MII_WRITE_ | MII_BUSY_;
257
+	addr = mii_address_cmd(phy_id, idx, MII_WRITE_ | MII_BUSY_);
260258 	ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
261259 	if (ret < 0) {
262
-		netdev_warn(dev->net, "Error writing MII_ADDR\n");
260
+		if (ret != -ENODEV)
261
+			netdev_warn(dev->net, "Error writing MII_ADDR\n");
263262 		goto done;
264263 	}
265264 
....@@ -273,27 +272,34 @@
273272 	mutex_unlock(&dev->phy_mutex);
274273 }
275274 
276
-static int smsc95xx_mdio_read_nopm(struct net_device *netdev, int phy_id,
277
-				   int idx)
275
+static int smsc95xx_mdio_read_nopm(struct usbnet *dev, int idx)
278276 {
279
-	return __smsc95xx_mdio_read(netdev, phy_id, idx, 1);
277
+	struct smsc95xx_priv *pdata = dev->driver_priv;
278
+
279
+	return __smsc95xx_mdio_read(dev, pdata->phydev->mdio.addr, idx, 1);
280280 }
281281 
282
-static void smsc95xx_mdio_write_nopm(struct net_device *netdev, int phy_id,
283
-				     int idx, int regval)
282
+static void smsc95xx_mdio_write_nopm(struct usbnet *dev, int idx, int regval)
284283 {
285
-	__smsc95xx_mdio_write(netdev, phy_id, idx, regval, 1);
284
+	struct smsc95xx_priv *pdata = dev->driver_priv;
285
+
286
+	__smsc95xx_mdio_write(dev, pdata->phydev->mdio.addr, idx, regval, 1);
286287 }
287288 
288
-static int smsc95xx_mdio_read(struct net_device *netdev, int phy_id, int idx)
289
+static int smsc95xx_mdiobus_read(struct mii_bus *bus, int phy_id, int idx)
289290 {
290
-	return __smsc95xx_mdio_read(netdev, phy_id, idx, 0);
291
+	struct usbnet *dev = bus->priv;
292
+
293
+	return __smsc95xx_mdio_read(dev, phy_id, idx, 0);
291294 }
292295 
293
-static void smsc95xx_mdio_write(struct net_device *netdev, int phy_id, int idx,
294
-				int regval)
296
+static int smsc95xx_mdiobus_write(struct mii_bus *bus, int phy_id, int idx,
297
+				  u16 regval)
295298 {
296
-	__smsc95xx_mdio_write(netdev, phy_id, idx, regval, 0);
299
+	struct usbnet *dev = bus->priv;
300
+
301
+	__smsc95xx_mdio_write(dev, phy_id, idx, regval, 0);
302
+	return 0;
297303 }
298304 
299305 static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
....@@ -467,7 +473,7 @@
467473 static void smsc95xx_set_multicast(struct net_device *netdev)
468474 {
469475 	struct usbnet *dev = netdev_priv(netdev);
470
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
476
+	struct smsc95xx_priv *pdata = dev->driver_priv;
471477 	unsigned long flags;
472478 	int ret;
473479 
....@@ -523,22 +529,23 @@
523529 		netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n");
524530 }
525531 
526
-static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev, u8 duplex,
527
-					   u16 lcladv, u16 rmtadv)
532
+static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev)
528533 {
529534 	u32 flow = 0, afc_cfg;
535
+	struct smsc95xx_priv *pdata = dev->driver_priv;
536
+	bool tx_pause, rx_pause;
530537 
531538 	int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
532539 	if (ret < 0)
533540 		return ret;
534541 
535
-	if (duplex == DUPLEX_FULL) {
536
-		u8 cap = mii_resolve_flowctrl_fdx(lcladv, rmtadv);
542
+	if (pdata->phydev->duplex == DUPLEX_FULL) {
543
+		phy_get_pause(pdata->phydev, &tx_pause, &rx_pause);
537544 
538
-		if (cap & FLOW_CTRL_RX)
545
+		if (rx_pause)
539546 			flow = 0xFFFF0002;
540547 
541
-		if (cap & FLOW_CTRL_TX) {
548
+		if (tx_pause) {
542549 			afc_cfg |= 0xF;
543550 			flow |= 0xFFFF0000;
544551 		} else {
....@@ -546,8 +553,8 @@
546553 		}
547554 
548555 		netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
549
-				   cap & FLOW_CTRL_RX ? "enabled" : "disabled",
550
-				   cap & FLOW_CTRL_TX ? "enabled" : "disabled");
556
+			  rx_pause ? "enabled" : "disabled",
557
+			  tx_pause ? "enabled" : "disabled");
551558 	} else {
552559 		netif_dbg(dev, link, dev->net, "half duplex\n");
553560 		afc_cfg |= 0xF;
....@@ -560,35 +567,14 @@
560567 	return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
561568 }
562569 
563
-static int smsc95xx_link_reset(struct usbnet *dev)
570
+static void smsc95xx_mac_update_fullduplex(struct usbnet *dev)
564571 {
565
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
566
-	struct mii_if_info *mii = &dev->mii;
567
-	struct ethtool_cmd ecmd = { .cmd = ETHTOOL_GSET };
572
+	struct smsc95xx_priv *pdata = dev->driver_priv;
568573 	unsigned long flags;
569
-	u16 lcladv, rmtadv;
570574 	int ret;
571575 
572
-	/* clear interrupt status */
573
-	ret = smsc95xx_mdio_read(dev->net, mii->phy_id, PHY_INT_SRC);
574
-	if (ret < 0)
575
-		return ret;
576
-
577
-	ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
578
-	if (ret < 0)
579
-		return ret;
580
-
581
-	mii_check_media(mii, 1, 1);
582
-	mii_ethtool_gset(&dev->mii, &ecmd);
583
-	lcladv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
584
-	rmtadv = smsc95xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
585
-
586
-	netif_dbg(dev, link, dev->net,
587
-		  "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
588
-		  ethtool_cmd_speed(&ecmd), ecmd.duplex, lcladv, rmtadv);
589
-
590576 	spin_lock_irqsave(&pdata->mac_cr_lock, flags);
591
-	if (ecmd.duplex != DUPLEX_FULL) {
577
+	if (pdata->phydev->duplex != DUPLEX_FULL) {
592578 		pdata->mac_cr &= ~MAC_CR_FDPX_;
593579 		pdata->mac_cr |= MAC_CR_RCVOWN_;
594580 	} else {
....@@ -598,14 +584,16 @@
598584 	spin_unlock_irqrestore(&pdata->mac_cr_lock, flags);
599585 
600586 	ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
601
-	if (ret < 0)
602
-		return ret;
587
+	if (ret < 0) {
588
+		if (ret != -ENODEV)
589
+			netdev_warn(dev->net,
590
+				    "Error updating MAC full duplex mode\n");
591
+		return;
592
+	}
603593 
604
-	ret = smsc95xx_phy_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
594
+	ret = smsc95xx_phy_update_flowcontrol(dev);
605595 	if (ret < 0)
606596 		netdev_warn(dev->net, "Error updating PHY flow control\n");
607
-
608
-	return ret;
609597 }
610598 
611599 static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
....@@ -618,54 +606,14 @@
618606 		return;
619607 	}
620608 
621
-	memcpy(&intdata, urb->transfer_buffer, 4);
622
-	le32_to_cpus(&intdata);
623
-
609
+	intdata = get_unaligned_le32(urb->transfer_buffer);
624610 	netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
625611 
626612 	if (intdata & INT_ENP_PHY_INT_)
627
-		usbnet_defer_kevent(dev, EVENT_LINK_RESET);
613
+		;
628614 	else
629615 		netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
630616 			    intdata);
631
-}
632
-
633
-static void set_carrier(struct usbnet *dev, bool link)
634
-{
635
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
636
-
637
-	if (pdata->link_ok == link)
638
-		return;
639
-
640
-	pdata->link_ok = link;
641
-
642
-	if (link)
643
-		usbnet_link_change(dev, 1, 0);
644
-	else
645
-		usbnet_link_change(dev, 0, 0);
646
-}
647
-
648
-static void check_carrier(struct work_struct *work)
649
-{
650
-	struct smsc95xx_priv *pdata = container_of(work, struct smsc95xx_priv,
651
-						carrier_check.work);
652
-	struct usbnet *dev = pdata->dev;
653
-	int ret;
654
-
655
-	if (pdata->suspend_flags != 0)
656
-		return;
657
-
658
-	ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMSR);
659
-	if (ret < 0) {
660
-		netdev_warn(dev->net, "Failed to read MII_BMSR\n");
661
-		return;
662
-	}
663
-	if (ret & BMSR_LSTATUS)
664
-		set_carrier(dev, 1);
665
-	else
666
-		set_carrier(dev, 0);
667
-
668
-	schedule_delayed_work(&pdata->carrier_check, CARRIER_CHECK_DELAY);
669617 }
670618 
671619 /* Enable or disable Tx & Rx checksum offload engines */
....@@ -761,7 +709,7 @@
761709 				     struct ethtool_wolinfo *wolinfo)
762710 {
763711 	struct usbnet *dev = netdev_priv(net);
764
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
712
+	struct smsc95xx_priv *pdata = dev->driver_priv;
765713 
766714 	wolinfo->supported = SUPPORTED_WAKE;
767715 	wolinfo->wolopts = pdata->wolopts;
....@@ -771,7 +719,7 @@
771719 				    struct ethtool_wolinfo *wolinfo)
772720 {
773721 	struct usbnet *dev = netdev_priv(net);
774
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
722
+	struct smsc95xx_priv *pdata = dev->driver_priv;
775723 	int ret;
776724 
777725 	if (wolinfo->wolopts & ~SUPPORTED_WAKE)
....@@ -786,108 +734,15 @@
786734 	return ret;
787735 }
788736 
789
-static int get_mdix_status(struct net_device *net)
737
+static u32 smsc95xx_get_link(struct net_device *net)
790738 {
791
-	struct usbnet *dev = netdev_priv(net);
792
-	u32 val;
793
-	int buf;
794
-
795
-	buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, SPECIAL_CTRL_STS);
796
-	if (buf & SPECIAL_CTRL_STS_OVRRD_AMDIX_) {
797
-		if (buf & SPECIAL_CTRL_STS_AMDIX_ENABLE_)
798
-			return ETH_TP_MDI_AUTO;
799
-		else if (buf & SPECIAL_CTRL_STS_AMDIX_STATE_)
800
-			return ETH_TP_MDI_X;
801
-	} else {
802
-		buf = smsc95xx_read_reg(dev, STRAP_STATUS, &val);
803
-		if (val & STRAP_STATUS_AMDIX_EN_)
804
-			return ETH_TP_MDI_AUTO;
805
-	}
806
-
807
-	return ETH_TP_MDI;
808
-}
809
-
810
-static void set_mdix_status(struct net_device *net, __u8 mdix_ctrl)
811
-{
812
-	struct usbnet *dev = netdev_priv(net);
813
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
814
-	int buf;
815
-
816
-	if ((pdata->chip_id == ID_REV_CHIP_ID_9500A_) ||
817
-	    (pdata->chip_id == ID_REV_CHIP_ID_9530_) ||
818
-	    (pdata->chip_id == ID_REV_CHIP_ID_89530_) ||
819
-	    (pdata->chip_id == ID_REV_CHIP_ID_9730_)) {
820
-		/* Extend Manual AutoMDIX timer for 9500A/9500Ai */
821
-		buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id,
822
-					 PHY_EDPD_CONFIG);
823
-		buf |= PHY_EDPD_CONFIG_EXT_CROSSOVER_;
824
-		smsc95xx_mdio_write(dev->net, dev->mii.phy_id,
825
-				    PHY_EDPD_CONFIG, buf);
826
-	}
827
-
828
-	if (mdix_ctrl == ETH_TP_MDI) {
829
-		buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id,
830
-					 SPECIAL_CTRL_STS);
831
-		buf |= SPECIAL_CTRL_STS_OVRRD_AMDIX_;
832
-		buf &= ~(SPECIAL_CTRL_STS_AMDIX_ENABLE_ |
833
-			 SPECIAL_CTRL_STS_AMDIX_STATE_);
834
-		smsc95xx_mdio_write(dev->net, dev->mii.phy_id,
835
-				    SPECIAL_CTRL_STS, buf);
836
-	} else if (mdix_ctrl == ETH_TP_MDI_X) {
837
-		buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id,
838
-					 SPECIAL_CTRL_STS);
839
-		buf |= SPECIAL_CTRL_STS_OVRRD_AMDIX_;
840
-		buf &= ~(SPECIAL_CTRL_STS_AMDIX_ENABLE_ |
841
-			 SPECIAL_CTRL_STS_AMDIX_STATE_);
842
-		buf |= SPECIAL_CTRL_STS_AMDIX_STATE_;
843
-		smsc95xx_mdio_write(dev->net, dev->mii.phy_id,
844
-				    SPECIAL_CTRL_STS, buf);
845
-	} else if (mdix_ctrl == ETH_TP_MDI_AUTO) {
846
-		buf = smsc95xx_mdio_read(dev->net, dev->mii.phy_id,
847
-					 SPECIAL_CTRL_STS);
848
-		buf &= ~SPECIAL_CTRL_STS_OVRRD_AMDIX_;
849
-		buf &= ~(SPECIAL_CTRL_STS_AMDIX_ENABLE_ |
850
-			 SPECIAL_CTRL_STS_AMDIX_STATE_);
851
-		buf |= SPECIAL_CTRL_STS_AMDIX_ENABLE_;
852
-		smsc95xx_mdio_write(dev->net, dev->mii.phy_id,
853
-				    SPECIAL_CTRL_STS, buf);
854
-	}
855
-	pdata->mdix_ctrl = mdix_ctrl;
856
-}
857
-
858
-static int smsc95xx_get_link_ksettings(struct net_device *net,
859
-				       struct ethtool_link_ksettings *cmd)
860
-{
861
-	struct usbnet *dev = netdev_priv(net);
862
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
863
-	int retval;
864
-
865
-	retval = usbnet_get_link_ksettings(net, cmd);
866
-
867
-	cmd->base.eth_tp_mdix = pdata->mdix_ctrl;
868
-	cmd->base.eth_tp_mdix_ctrl = pdata->mdix_ctrl;
869
-
870
-	return retval;
871
-}
872
-
873
-static int smsc95xx_set_link_ksettings(struct net_device *net,
874
-				       const struct ethtool_link_ksettings *cmd)
875
-{
876
-	struct usbnet *dev = netdev_priv(net);
877
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
878
-	int retval;
879
-
880
-	if (pdata->mdix_ctrl != cmd->base.eth_tp_mdix_ctrl)
881
-		set_mdix_status(net, cmd->base.eth_tp_mdix_ctrl);
882
-
883
-	retval = usbnet_set_link_ksettings(net, cmd);
884
-
885
-	return retval;
739
+	phy_read_status(net->phydev);
740
+	return net->phydev->link;
886741 }
887742 
888743 static const struct ethtool_ops smsc95xx_ethtool_ops = {
889
-	.get_link	= usbnet_get_link,
890
-	.nway_reset	= usbnet_nway_reset,
744
+	.get_link	= smsc95xx_get_link,
745
+	.nway_reset	= phy_ethtool_nway_reset,
891746 	.get_drvinfo	= usbnet_get_drvinfo,
892747 	.get_msglevel	= usbnet_get_msglevel,
893748 	.set_msglevel	= usbnet_set_msglevel,
....@@ -898,30 +753,29 @@
898753 	.get_regs	= smsc95xx_ethtool_getregs,
899754 	.get_wol	= smsc95xx_ethtool_get_wol,
900755 	.set_wol	= smsc95xx_ethtool_set_wol,
901
-	.get_link_ksettings	= smsc95xx_get_link_ksettings,
902
-	.set_link_ksettings	= smsc95xx_set_link_ksettings,
756
+	.get_link_ksettings	= phy_ethtool_get_link_ksettings,
757
+	.set_link_ksettings	= phy_ethtool_set_link_ksettings,
903758 	.get_ts_info	= ethtool_op_get_ts_info,
904759 };
905760 
906761 static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
907762 {
908
-	struct usbnet *dev = netdev_priv(netdev);
909
-
910763 	if (!netif_running(netdev))
911764 		return -EINVAL;
912765 
913
-	return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
766
+	return phy_mii_ioctl(netdev->phydev, rq, cmd);
914767 }
915768 
916769 static void smsc95xx_init_mac_address(struct usbnet *dev)
917770 {
918
-	const u8 *mac_addr;
919
-
920771 	/* maybe the boot loader passed the MAC address in devicetree */
921
-	mac_addr = of_get_mac_address(dev->udev->dev.of_node);
922
-	if (mac_addr) {
923
-		memcpy(dev->net->dev_addr, mac_addr, ETH_ALEN);
924
-		return;
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
+		}
925779 	}
926780 
927781 	/* try reading mac address from EEPROM */
....@@ -956,7 +810,7 @@
956810 /* starts the TX path */
957811 static int smsc95xx_start_tx_path(struct usbnet *dev)
958812 {
959
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
813
+	struct smsc95xx_priv *pdata = dev->driver_priv;
960814 	unsigned long flags;
961815 	int ret;
962816 
....@@ -976,7 +830,7 @@
976830 /* Starts the Receive path */
977831 static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
978832 {
979
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
833
+	struct smsc95xx_priv *pdata = dev->driver_priv;
980834 	unsigned long flags;
981835 
982836 	spin_lock_irqsave(&pdata->mac_cr_lock, flags);
....@@ -986,54 +840,9 @@
986840 	return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
987841 }
988842 
989
-static int smsc95xx_phy_initialize(struct usbnet *dev)
990
-{
991
-	int bmcr, ret, timeout = 0;
992
-
993
-	/* Initialize MII structure */
994
-	dev->mii.dev = dev->net;
995
-	dev->mii.mdio_read = smsc95xx_mdio_read;
996
-	dev->mii.mdio_write = smsc95xx_mdio_write;
997
-	dev->mii.phy_id_mask = 0x1f;
998
-	dev->mii.reg_num_mask = 0x1f;
999
-	dev->mii.phy_id = SMSC95XX_INTERNAL_PHY_ID;
1000
-
1001
-	/* reset phy and wait for reset to complete */
1002
-	smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
1003
-
1004
-	do {
1005
-		msleep(10);
1006
-		bmcr = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
1007
-		timeout++;
1008
-	} while ((bmcr & BMCR_RESET) && (timeout < 100));
1009
-
1010
-	if (timeout >= 100) {
1011
-		netdev_warn(dev->net, "timeout on PHY Reset");
1012
-		return -EIO;
1013
-	}
1014
-
1015
-	smsc95xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
1016
-		ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP |
1017
-		ADVERTISE_PAUSE_ASYM);
1018
-
1019
-	/* read to clear */
1020
-	ret = smsc95xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
1021
-	if (ret < 0) {
1022
-		netdev_warn(dev->net, "Failed to read PHY_INT_SRC during init\n");
1023
-		return ret;
1024
-	}
1025
-
1026
-	smsc95xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
1027
-		PHY_INT_MASK_DEFAULT_);
1028
-	mii_nway_restart(&dev->mii);
1029
-
1030
-	netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
1031
-	return 0;
1032
-}
1033
-
1034843 static int smsc95xx_reset(struct usbnet *dev)
1035844 {
1036
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
845
+	struct smsc95xx_priv *pdata = dev->driver_priv;
1037846 	u32 read_buf, write_buf, burst_cap;
1038847 	int ret = 0, timeout;
1039848 
....@@ -1212,12 +1021,6 @@
12121021 
12131022 	smsc95xx_set_multicast(dev->net);
12141023 
1215
-	ret = smsc95xx_phy_initialize(dev);
1216
-	if (ret < 0) {
1217
-		netdev_warn(dev->net, "Failed to init PHY\n");
1218
-		return ret;
1219
-	}
1220
-
12211024 	ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
12221025 	if (ret < 0)
12231026 		return ret;
....@@ -1259,9 +1062,19 @@
12591062 	.ndo_set_features	= smsc95xx_set_features,
12601063 };
12611064 
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
+
12621074 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
12631075 {
1264
-	struct smsc95xx_priv *pdata = NULL;
1076
+	struct smsc95xx_priv *pdata;
1077
+	bool is_internal_phy;
12651078 	u32 val;
12661079 	int ret;
12671080 
....@@ -1273,12 +1086,11 @@
12731086 		return ret;
12741087 	}
12751088 
1276
-	dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc95xx_priv),
1277
-					      GFP_KERNEL);
1278
-
1279
-	pdata = (struct smsc95xx_priv *)(dev->data[0]);
1089
+	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
12801090 	if (!pdata)
12811091 		return -ENOMEM;
1092
+
1093
+	dev->driver_priv = pdata;
12821094 
12831095 	spin_lock_init(&pdata->mac_cr_lock);
12841096 
....@@ -1304,15 +1116,50 @@
13041116 	if (ret)
13051117 		goto free_pdata;
13061118 
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
+
13071157 	/* detect device revision as different features may be available */
13081158 	ret = smsc95xx_read_reg(dev, ID_REV, &val);
13091159 	if (ret < 0)
1310
-		goto free_pdata;
1160
+		goto unregister_mdio;
13111161 
13121162 	val >>= 16;
1313
-	pdata->chip_id = val;
1314
-	pdata->mdix_ctrl = get_mdix_status(dev->net);
1315
-
13161163 	if ((val == ID_REV_CHIP_ID_9500A_) || (val == ID_REV_CHIP_ID_9530_) ||
13171164 	    (val == ID_REV_CHIP_ID_89530_) || (val == ID_REV_CHIP_ID_9730_))
13181165 		pdata->features = (FEATURE_8_WAKEUP_FILTERS |
....@@ -1329,11 +1176,23 @@
13291176 	dev->net->max_mtu = ETH_DATA_LEN;
13301177 	dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
13311178 
1332
-	pdata->dev = dev;
1333
-	INIT_DELAYED_WORK(&pdata->carrier_check, check_carrier);
1334
-	schedule_delayed_work(&pdata->carrier_check, CARRIER_CHECK_DELAY);
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);
13351188 
13361189 	return 0;
1190
+
1191
+unregister_mdio:
1192
+	mdiobus_unregister(pdata->mdiobus);
1193
+
1194
+free_mdio:
1195
+	mdiobus_free(pdata->mdiobus);
13371196 
13381197 free_pdata:
13391198 	kfree(pdata);
....@@ -1342,15 +1201,28 @@
13421201 
13431202 static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)
13441203 {
1345
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1204
+	struct smsc95xx_priv *pdata = dev->driver_priv;
13461205 
1347
-	if (pdata) {
1348
-		cancel_delayed_work_sync(&pdata->carrier_check);
1349
-		netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1350
-		kfree(pdata);
1351
-		pdata = NULL;
1352
-		dev->data[0] = 0;
1353
-	}
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
+
1213
+static int smsc95xx_start_phy(struct usbnet *dev)
1214
+{
1215
+	phy_start(dev->net->phydev);
1216
+
1217
+	return 0;
1218
+}
1219
+
1220
+static int smsc95xx_stop(struct usbnet *dev)
1221
+{
1222
+	if (dev->net->phydev)
1223
+		phy_stop(dev->net->phydev);
1224
+
1225
+	return 0;
13541226 }
13551227 
13561228 static u32 smsc_crc(const u8 *buffer, size_t len, int filter)
....@@ -1361,39 +1233,37 @@
13611233 
13621234 static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
13631235 {
1364
-	struct mii_if_info *mii = &dev->mii;
13651236 	int ret;
13661237 
13671238 	netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
13681239 
13691240 	/* read to clear */
1370
-	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1241
+	ret = smsc95xx_mdio_read_nopm(dev, PHY_INT_SRC);
13711242 	if (ret < 0)
13721243 		return ret;
13731244 
13741245 	/* enable interrupt source */
1375
-	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1246
+	ret = smsc95xx_mdio_read_nopm(dev, PHY_INT_MASK);
13761247 	if (ret < 0)
13771248 		return ret;
13781249 
13791250 	ret |= mask;
13801251 
1381
-	smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1252
+	smsc95xx_mdio_write_nopm(dev, PHY_INT_MASK, ret);
13821253 
13831254 	return 0;
13841255 }
13851256 
13861257 static int smsc95xx_link_ok_nopm(struct usbnet *dev)
13871258 {
1388
-	struct mii_if_info *mii = &dev->mii;
13891259 	int ret;
13901260 
13911261 	/* first, a dummy read, needed to latch some MII phys */
1392
-	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1262
+	ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
13931263 	if (ret < 0)
13941264 		return ret;
13951265 
1396
-	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1266
+	ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
13971267 	if (ret < 0)
13981268 		return ret;
13991269 
....@@ -1402,7 +1272,7 @@
14021272 
14031273 static int smsc95xx_enter_suspend0(struct usbnet *dev)
14041274 {
1405
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1275
+	struct smsc95xx_priv *pdata = dev->driver_priv;
14061276 	u32 val;
14071277 	int ret;
14081278 
....@@ -1441,8 +1311,7 @@
14411311 
14421312 static int smsc95xx_enter_suspend1(struct usbnet *dev)
14431313 {
1444
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1445
-	struct mii_if_info *mii = &dev->mii;
1314
+	struct smsc95xx_priv *pdata = dev->driver_priv;
14461315 	u32 val;
14471316 	int ret;
14481317 
....@@ -1450,17 +1319,17 @@
14501319 	 * compatibility with non-standard link partners
14511320 	 */
14521321 	if (pdata->features & FEATURE_PHY_NLP_CROSSOVER)
1453
-		smsc95xx_mdio_write_nopm(dev->net, mii->phy_id,	PHY_EDPD_CONFIG,
1454
-			PHY_EDPD_CONFIG_DEFAULT);
1322
+		smsc95xx_mdio_write_nopm(dev, PHY_EDPD_CONFIG,
1323
+					 PHY_EDPD_CONFIG_DEFAULT);
14551324 
14561325 	/* enable energy detect power-down mode */
1457
-	ret = smsc95xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS);
1326
+	ret = smsc95xx_mdio_read_nopm(dev, PHY_MODE_CTRL_STS);
14581327 	if (ret < 0)
14591328 		return ret;
14601329 
14611330 	ret |= MODE_CTRL_STS_EDPWRDOWN_;
14621331 
1463
-	smsc95xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_MODE_CTRL_STS, ret);
1332
+	smsc95xx_mdio_write_nopm(dev, PHY_MODE_CTRL_STS, ret);
14641333 
14651334 	/* enter SUSPEND1 mode */
14661335 	ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
....@@ -1489,7 +1358,7 @@
14891358 
14901359 static int smsc95xx_enter_suspend2(struct usbnet *dev)
14911360 {
1492
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1361
+	struct smsc95xx_priv *pdata = dev->driver_priv;
14931362 	u32 val;
14941363 	int ret;
14951364 
....@@ -1511,7 +1380,7 @@
15111380 
15121381 static int smsc95xx_enter_suspend3(struct usbnet *dev)
15131382 {
1514
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1383
+	struct smsc95xx_priv *pdata = dev->driver_priv;
15151384 	u32 val;
15161385 	int ret;
15171386 
....@@ -1550,7 +1419,7 @@
15501419 
15511420 static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up)
15521421 {
1553
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1422
+	struct smsc95xx_priv *pdata = dev->driver_priv;
15541423 	int ret;
15551424 
15561425 	if (!netif_running(dev->net)) {
....@@ -1598,17 +1467,18 @@
15981467 static int smsc95xx_suspend(struct usb_interface *intf, pm_message_t message)
15991468 {
16001469 	struct usbnet *dev = usb_get_intfdata(intf);
1601
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1470
+	struct smsc95xx_priv *pdata = dev->driver_priv;
16021471 	u32 val, link_up;
16031472 	int ret;
1473
+
1474
+	pdata->pm_task = current;
16041475 
16051476 	ret = usbnet_suspend(intf, message);
16061477 	if (ret < 0) {
16071478 		netdev_warn(dev->net, "usbnet_suspend error\n");
1479
+		pdata->pm_task = NULL;
16081480 		return ret;
16091481 	}
1610
-
1611
-	cancel_delayed_work_sync(&pdata->carrier_check);
16121482 
16131483 	if (pdata->suspend_flags) {
16141484 		netdev_warn(dev->net, "error during last resume\n");
....@@ -1853,10 +1723,7 @@
18531723 	if (ret && PMSG_IS_AUTO(message))
18541724 		usbnet_resume(intf);
18551725 
1856
-	if (ret)
1857
-		schedule_delayed_work(&pdata->carrier_check,
1858
-				      CARRIER_CHECK_DELAY);
1859
-
1726
+	pdata->pm_task = NULL;
18601727 	return ret;
18611728 }
18621729 
....@@ -1869,53 +1736,61 @@
18691736 	u32 val;
18701737 
18711738 	BUG_ON(!dev);
1872
-	pdata = (struct smsc95xx_priv *)(dev->data[0]);
1739
+	pdata = dev->driver_priv;
18731740 	suspend_flags = pdata->suspend_flags;
18741741 
18751742 	netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
18761743 
18771744 	/* do this first to ensure it's cleared even in error case */
18781745 	pdata->suspend_flags = 0;
1879
-	schedule_delayed_work(&pdata->carrier_check, CARRIER_CHECK_DELAY);
1746
+
1747
+	pdata->pm_task = current;
18801748 
18811749 	if (suspend_flags & SUSPEND_ALLMODES) {
18821750 		/* clear wake-up sources */
18831751 		ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
18841752 		if (ret < 0)
1885
-			return ret;
1753
+			goto done;
18861754 
18871755 		val &= ~(WUCSR_WAKE_EN_ | WUCSR_MPEN_);
18881756 
18891757 		ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
18901758 		if (ret < 0)
1891
-			return ret;
1759
+			goto done;
18921760 
18931761 		/* clear wake-up status */
18941762 		ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
18951763 		if (ret < 0)
1896
-			return ret;
1764
+			goto done;
18971765 
18981766 		val &= ~PM_CTL_WOL_EN_;
18991767 		val |= PM_CTL_WUPS_;
19001768 
19011769 		ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
19021770 		if (ret < 0)
1903
-			return ret;
1771
+			goto done;
19041772 	}
19051773 
19061774 	ret = usbnet_resume(intf);
19071775 	if (ret < 0)
19081776 		netdev_warn(dev->net, "usbnet_resume error\n");
19091777 
1778
+	phy_init_hw(pdata->phydev);
1779
+
1780
+done:
1781
+	pdata->pm_task = NULL;
19101782 	return ret;
19111783 }
19121784 
19131785 static int smsc95xx_reset_resume(struct usb_interface *intf)
19141786 {
19151787 	struct usbnet *dev = usb_get_intfdata(intf);
1788
+	struct smsc95xx_priv *pdata = dev->driver_priv;
19161789 	int ret;
19171790 
1791
+	pdata->pm_task = current;
19181792 	ret = smsc95xx_reset(dev);
1793
+	pdata->pm_task = NULL;
19191794 	if (ret < 0)
19201795 		return ret;
19211796 
....@@ -1941,14 +1816,19 @@
19411816 		unsigned char *packet;
19421817 		u16 size;
19431818 
1944
-		memcpy(&header, skb->data, sizeof(header));
1945
-		le32_to_cpus(&header);
1819
+		header = get_unaligned_le32(skb->data);
19461820 		skb_pull(skb, 4 + NET_IP_ALIGN);
19471821 		packet = skb->data;
19481822 
19491823 		/* get the packet length */
19501824 		size = (u16)((header & RX_STS_FL_) >> 16);
19511825 		align_count = (4 - ((size + NET_IP_ALIGN) % 4)) % 4;
1826
+
1827
+		if (unlikely(size > skb->len)) {
1828
+			netif_dbg(dev, rx_err, dev->net,
1829
+				  "size err header=0x%08x\n", header);
1830
+			return 0;
1831
+		}
19521832 
19531833 		if (unlikely(header & RX_STS_ES_)) {
19541834 			netif_dbg(dev, rx_err, dev->net,
....@@ -2019,12 +1899,30 @@
20191899 	return (high_16 << 16) | low_16;
20201900 }
20211901 
1902
+/* The TX CSUM won't work if the checksum lies in the last 4 bytes of the
1903
+ * transmission. This is fairly unlikely, only seems to trigger with some
1904
+ * short TCP ACK packets sent.
1905
+ *
1906
+ * Note, this calculation should probably check for the alignment of the
1907
+ * data as well, but a straight check for csum being in the last four bytes
1908
+ * of the packet should be ok for now.
1909
+ */
1910
+static bool smsc95xx_can_tx_checksum(struct sk_buff *skb)
1911
+{
1912
+       unsigned int len = skb->len - skb_checksum_start_offset(skb);
1913
+
1914
+       if (skb->len <= 45)
1915
+	       return false;
1916
+       return skb->csum_offset < (len - (4 + 1));
1917
+}
1918
+
20221919 static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
20231920 					 struct sk_buff *skb, gfp_t flags)
20241921 {
20251922 	bool csum = skb->ip_summed == CHECKSUM_PARTIAL;
20261923 	int overhead = csum ? SMSC95XX_TX_OVERHEAD_CSUM : SMSC95XX_TX_OVERHEAD;
20271924 	u32 tx_cmd_a, tx_cmd_b;
1925
+	void *ptr;
20281926 
20291927 	/* We do not advertise SG, so skbs should be already linearized */
20301928 	BUG_ON(skb_shinfo(skb)->nr_frags);
....@@ -2038,8 +1936,11 @@
20381936 		return NULL;
20391937 	}
20401938 
1939
+	tx_cmd_b = (u32)skb->len;
1940
+	tx_cmd_a = tx_cmd_b | TX_CMD_A_FIRST_SEG_ | TX_CMD_A_LAST_SEG_;
1941
+
20411942 	if (csum) {
2042
-		if (skb->len <= 45) {
1943
+		if (!smsc95xx_can_tx_checksum(skb)) {
20431944 			/* workaround - hardware tx checksum does not work
20441945 			 * properly with extremely small packets */
20451946 			long csstart = skb_checksum_start_offset(skb);
....@@ -2051,31 +1952,25 @@
20511952 			csum = false;
20521953 		} else {
20531954 			u32 csum_preamble = smsc95xx_calc_csum_preamble(skb);
2054
-			skb_push(skb, 4);
2055
-			cpu_to_le32s(&csum_preamble);
2056
-			memcpy(skb->data, &csum_preamble, 4);
1955
+			ptr = skb_push(skb, 4);
1956
+			put_unaligned_le32(csum_preamble, ptr);
1957
+
1958
+			tx_cmd_a += 4;
1959
+			tx_cmd_b += 4;
1960
+			tx_cmd_b |= TX_CMD_B_CSUM_ENABLE;
20571961 		}
20581962 	}
20591963 
2060
-	skb_push(skb, 4);
2061
-	tx_cmd_b = (u32)(skb->len - 4);
2062
-	if (csum)
2063
-		tx_cmd_b |= TX_CMD_B_CSUM_ENABLE;
2064
-	cpu_to_le32s(&tx_cmd_b);
2065
-	memcpy(skb->data, &tx_cmd_b, 4);
2066
-
2067
-	skb_push(skb, 4);
2068
-	tx_cmd_a = (u32)(skb->len - 8) | TX_CMD_A_FIRST_SEG_ |
2069
-		TX_CMD_A_LAST_SEG_;
2070
-	cpu_to_le32s(&tx_cmd_a);
2071
-	memcpy(skb->data, &tx_cmd_a, 4);
1964
+	ptr = skb_push(skb, 8);
1965
+	put_unaligned_le32(tx_cmd_a, ptr);
1966
+	put_unaligned_le32(tx_cmd_b, ptr+4);
20721967 
20731968 	return skb;
20741969 }
20751970 
20761971 static int smsc95xx_manage_power(struct usbnet *dev, int on)
20771972 {
2078
-	struct smsc95xx_priv *pdata = (struct smsc95xx_priv *)(dev->data[0]);
1973
+	struct smsc95xx_priv *pdata = dev->driver_priv;
20791974 
20801975 	dev->intf->needs_remote_wakeup = on;
20811976 
....@@ -2097,8 +1992,9 @@
20971992 	.description	= "smsc95xx USB 2.0 Ethernet",
20981993 	.bind		= smsc95xx_bind,
20991994 	.unbind		= smsc95xx_unbind,
2100
-	.link_reset	= smsc95xx_link_reset,
21011995 	.reset		= smsc95xx_reset,
1996
+	.check_connect	= smsc95xx_start_phy,
1997
+	.stop		= smsc95xx_stop,
21021998 	.rx_fixup	= smsc95xx_rx_fixup,
21031999 	.tx_fixup	= smsc95xx_tx_fixup,
21042000 	.status		= smsc95xx_status,