Lines Matching refs:dev
54 struct usbnet *dev;
66 struct usbnet *dev;
73 static int smsc75xx_link_ok_nopm(struct usbnet *dev);
74 static int smsc75xx_phy_gig_workaround(struct usbnet *dev);
76 static int __must_check __smsc75xx_read_reg(struct usbnet *dev, u32 index,
83 BUG_ON(!dev);
90 ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
96 netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
107 static int __must_check __smsc75xx_write_reg(struct usbnet *dev, u32 index,
114 BUG_ON(!dev);
124 ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
128 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
134 static int __must_check smsc75xx_read_reg_nopm(struct usbnet *dev, u32 index,
137 return __smsc75xx_read_reg(dev, index, data, 1);
140 static int __must_check smsc75xx_write_reg_nopm(struct usbnet *dev, u32 index,
143 return __smsc75xx_write_reg(dev, index, data, 1);
146 static int __must_check smsc75xx_read_reg(struct usbnet *dev, u32 index,
149 return __smsc75xx_read_reg(dev, index, data, 0);
152 static int __must_check smsc75xx_write_reg(struct usbnet *dev, u32 index,
155 return __smsc75xx_write_reg(dev, index, data, 0);
160 static __must_check int __smsc75xx_phy_wait_not_busy(struct usbnet *dev,
168 ret = __smsc75xx_read_reg(dev, MII_ACCESS, &val, in_pm);
170 netdev_warn(dev->net, "Error reading MII_ACCESS\n");
184 struct usbnet *dev = netdev_priv(netdev);
188 mutex_lock(&dev->phy_mutex);
191 ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
193 netdev_warn(dev->net, "MII is busy in smsc75xx_mdio_read\n");
198 phy_id &= dev->mii.phy_id_mask;
199 idx &= dev->mii.reg_num_mask;
203 ret = __smsc75xx_write_reg(dev, MII_ACCESS, addr, in_pm);
205 netdev_warn(dev->net, "Error writing MII_ACCESS\n");
209 ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
211 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
215 ret = __smsc75xx_read_reg(dev, MII_DATA, &val, in_pm);
217 netdev_warn(dev->net, "Error reading MII_DATA\n");
224 mutex_unlock(&dev->phy_mutex);
231 struct usbnet *dev = netdev_priv(netdev);
235 mutex_lock(&dev->phy_mutex);
238 ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
240 netdev_warn(dev->net, "MII is busy in smsc75xx_mdio_write\n");
245 ret = __smsc75xx_write_reg(dev, MII_DATA, val, in_pm);
247 netdev_warn(dev->net, "Error writing MII_DATA\n");
252 phy_id &= dev->mii.phy_id_mask;
253 idx &= dev->mii.reg_num_mask;
257 ret = __smsc75xx_write_reg(dev, MII_ACCESS, addr, in_pm);
259 netdev_warn(dev->net, "Error writing MII_ACCESS\n");
263 ret = __smsc75xx_phy_wait_not_busy(dev, in_pm);
265 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
270 mutex_unlock(&dev->phy_mutex);
296 static int smsc75xx_wait_eeprom(struct usbnet *dev)
303 ret = smsc75xx_read_reg(dev, E2P_CMD, &val);
305 netdev_warn(dev->net, "Error reading E2P_CMD\n");
315 netdev_warn(dev->net, "EEPROM read operation timeout\n");
322 static int smsc75xx_eeprom_confirm_not_busy(struct usbnet *dev)
329 ret = smsc75xx_read_reg(dev, E2P_CMD, &val);
331 netdev_warn(dev->net, "Error reading E2P_CMD\n");
341 netdev_warn(dev->net, "EEPROM is busy\n");
345 static int smsc75xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
351 BUG_ON(!dev);
354 ret = smsc75xx_eeprom_confirm_not_busy(dev);
360 ret = smsc75xx_write_reg(dev, E2P_CMD, val);
362 netdev_warn(dev->net, "Error writing E2P_CMD\n");
366 ret = smsc75xx_wait_eeprom(dev);
370 ret = smsc75xx_read_reg(dev, E2P_DATA, &val);
372 netdev_warn(dev->net, "Error reading E2P_DATA\n");
383 static int smsc75xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
389 BUG_ON(!dev);
392 ret = smsc75xx_eeprom_confirm_not_busy(dev);
398 ret = smsc75xx_write_reg(dev, E2P_CMD, val);
400 netdev_warn(dev->net, "Error writing E2P_CMD\n");
404 ret = smsc75xx_wait_eeprom(dev);
412 ret = smsc75xx_write_reg(dev, E2P_DATA, val);
414 netdev_warn(dev->net, "Error writing E2P_DATA\n");
420 ret = smsc75xx_write_reg(dev, E2P_CMD, val);
422 netdev_warn(dev->net, "Error writing E2P_CMD\n");
426 ret = smsc75xx_wait_eeprom(dev);
436 static int smsc75xx_dataport_wait_not_busy(struct usbnet *dev)
442 ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
444 netdev_warn(dev->net, "Error reading DP_SEL\n");
454 netdev_warn(dev->net, "smsc75xx_dataport_wait_not_busy timed out\n");
459 static int smsc75xx_dataport_write(struct usbnet *dev, u32 ram_select, u32 addr,
462 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
468 ret = smsc75xx_dataport_wait_not_busy(dev);
470 netdev_warn(dev->net, "smsc75xx_dataport_write busy on entry\n");
474 ret = smsc75xx_read_reg(dev, DP_SEL, &dp_sel);
476 netdev_warn(dev->net, "Error reading DP_SEL\n");
482 ret = smsc75xx_write_reg(dev, DP_SEL, dp_sel);
484 netdev_warn(dev->net, "Error writing DP_SEL\n");
489 ret = smsc75xx_write_reg(dev, DP_ADDR, addr + i);
491 netdev_warn(dev->net, "Error writing DP_ADDR\n");
495 ret = smsc75xx_write_reg(dev, DP_DATA, buf[i]);
497 netdev_warn(dev->net, "Error writing DP_DATA\n");
501 ret = smsc75xx_write_reg(dev, DP_CMD, DP_CMD_WRITE);
503 netdev_warn(dev->net, "Error writing DP_CMD\n");
507 ret = smsc75xx_dataport_wait_not_busy(dev);
509 netdev_warn(dev->net, "smsc75xx_dataport_write timeout\n");
529 struct usbnet *dev = pdata->dev;
532 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
535 smsc75xx_dataport_write(dev, DP_SEL_VHF, DP_SEL_VHF_VLAN_LEN,
538 ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
540 netdev_warn(dev->net, "Error writing RFE_CRL\n");
545 struct usbnet *dev = netdev_priv(netdev);
546 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
559 if (dev->net->flags & IFF_PROMISC) {
560 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
562 } else if (dev->net->flags & IFF_ALLMULTI) {
563 netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
565 } else if (!netdev_mc_empty(dev->net)) {
568 netif_dbg(dev, drv, dev->net, "receive multicast hash filter\n");
578 netif_dbg(dev, drv, dev->net, "receive own packets only\n");
588 static int smsc75xx_update_flowcontrol(struct usbnet *dev, u8 duplex,
606 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
610 netif_dbg(dev, link, dev->net, "half duplex\n");
613 ret = smsc75xx_write_reg(dev, FLOW, flow);
615 netdev_warn(dev->net, "Error writing FLOW\n");
619 ret = smsc75xx_write_reg(dev, FCT_FLOW, fct_flow);
621 netdev_warn(dev->net, "Error writing FCT_FLOW\n");
628 static int smsc75xx_link_reset(struct usbnet *dev)
630 struct mii_if_info *mii = &dev->mii;
636 smsc75xx_mdio_write(dev->net, mii->phy_id, PHY_INT_SRC,
639 ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
641 netdev_warn(dev->net, "Error writing INT_STS\n");
646 mii_ethtool_gset(&dev->mii, &ecmd);
647 lcladv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_ADVERTISE);
648 rmtadv = smsc75xx_mdio_read(dev->net, mii->phy_id, MII_LPA);
650 netif_dbg(dev, link, dev->net, "speed: %u duplex: %d lcladv: %04x rmtadv: %04x\n",
653 return smsc75xx_update_flowcontrol(dev, ecmd.duplex, lcladv, rmtadv);
656 static void smsc75xx_status(struct usbnet *dev, struct urb *urb)
661 netdev_warn(dev->net, "unexpected urb length %d\n",
668 netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
671 usbnet_defer_kevent(dev, EVENT_LINK_RESET);
673 netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
685 struct usbnet *dev = netdev_priv(netdev);
689 return smsc75xx_read_eeprom(dev, ee->offset, ee->len, data);
695 struct usbnet *dev = netdev_priv(netdev);
698 netdev_warn(dev->net, "EEPROM: magic value mismatch: 0x%x\n",
703 return smsc75xx_write_eeprom(dev, ee->offset, ee->len, data);
709 struct usbnet *dev = netdev_priv(net);
710 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
719 struct usbnet *dev = netdev_priv(net);
720 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
728 ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
730 netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
752 struct usbnet *dev = netdev_priv(netdev);
757 return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
760 static void smsc75xx_init_mac_address(struct usbnet *dev)
765 if (!platform_get_ethdev_address(&dev->udev->dev, dev->net)) {
766 if (is_valid_ether_addr(dev->net->dev_addr)) {
768 netif_dbg(dev, ifup, dev->net, "MAC address read from the device tree\n");
774 if (smsc75xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN, addr) == 0) {
775 eth_hw_addr_set(dev->net, addr);
776 if (is_valid_ether_addr(dev->net->dev_addr)) {
778 netif_dbg(dev, ifup, dev->net,
785 eth_hw_addr_random(dev->net);
786 netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
789 static int smsc75xx_set_mac_address(struct usbnet *dev)
791 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
792 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
793 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
795 int ret = smsc75xx_write_reg(dev, RX_ADDRH, addr_hi);
797 netdev_warn(dev->net, "Failed to write RX_ADDRH: %d\n", ret);
801 ret = smsc75xx_write_reg(dev, RX_ADDRL, addr_lo);
803 netdev_warn(dev->net, "Failed to write RX_ADDRL: %d\n", ret);
808 ret = smsc75xx_write_reg(dev, ADDR_FILTX, addr_hi);
810 netdev_warn(dev->net, "Failed to write ADDR_FILTX: %d\n", ret);
814 ret = smsc75xx_write_reg(dev, ADDR_FILTX + 4, addr_lo);
816 netdev_warn(dev->net, "Failed to write ADDR_FILTX+4: %d\n", ret);
821 static int smsc75xx_phy_initialize(struct usbnet *dev)
826 dev->mii.dev = dev->net;
827 dev->mii.mdio_read = smsc75xx_mdio_read;
828 dev->mii.mdio_write = smsc75xx_mdio_write;
829 dev->mii.phy_id_mask = 0x1f;
830 dev->mii.reg_num_mask = 0x1f;
831 dev->mii.supports_gmii = 1;
832 dev->mii.phy_id = SMSC75XX_INTERNAL_PHY_ID;
835 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
839 bmcr = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
841 netdev_warn(dev->net, "Error reading MII_BMCR\n");
848 netdev_warn(dev->net, "timeout on PHY Reset\n");
853 smsc75xx_phy_gig_workaround(dev);
855 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
858 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_CTRL1000,
862 ret = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
864 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
868 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_SRC, 0xffff);
870 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
872 mii_nway_restart(&dev->mii);
874 netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
878 static int smsc75xx_set_rx_max_frame_length(struct usbnet *dev, int size)
884 ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
886 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
894 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
896 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
905 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
907 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
913 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
915 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
925 struct usbnet *dev = netdev_priv(netdev);
928 ret = smsc75xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
930 netdev_warn(dev->net, "Failed to set mac rx frame length\n");
941 struct usbnet *dev = netdev_priv(netdev);
942 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
956 ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
958 netdev_warn(dev->net, "Error writing RFE_CTL\n");
964 static int smsc75xx_wait_ready(struct usbnet *dev, int in_pm)
972 ret = __smsc75xx_read_reg(dev, PMT_CTL, &buf, in_pm);
975 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
986 netdev_warn(dev->net, "timeout waiting for device ready\n");
990 static int smsc75xx_phy_gig_workaround(struct usbnet *dev)
992 struct mii_if_info *mii = &dev->mii;
997 smsc75xx_mdio_write(dev->net, mii->phy_id, MII_BMCR, 0x4040);
1001 link_up = smsc75xx_link_ok_nopm(dev);
1007 netdev_warn(dev->net, "Timeout waiting for PHY link up\n");
1012 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1014 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1020 ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
1022 netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
1029 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1031 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n",
1039 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
1046 static int smsc75xx_reset(struct usbnet *dev)
1048 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1052 netif_dbg(dev, ifup, dev->net, "entering smsc75xx_reset\n");
1054 ret = smsc75xx_wait_ready(dev, 0);
1056 netdev_warn(dev->net, "device not ready in smsc75xx_reset\n");
1060 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1062 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1068 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1070 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1077 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1079 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1086 netdev_warn(dev->net, "timeout on completion of Lite Reset\n");
1090 netif_dbg(dev, ifup, dev->net, "Lite reset complete, resetting PHY\n");
1092 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1094 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1100 ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
1102 netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
1109 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1111 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1118 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
1122 netif_dbg(dev, ifup, dev->net, "PHY reset complete\n");
1124 ret = smsc75xx_set_mac_address(dev);
1126 netdev_warn(dev->net, "Failed to set mac address\n");
1130 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
1131 dev->net->dev_addr);
1133 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1135 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1139 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
1144 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1146 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1150 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1152 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1156 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG after writing HW_CFG_BIR: 0x%08x\n",
1161 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
1162 } else if (dev->udev->speed == USB_SPEED_HIGH) {
1164 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
1167 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
1170 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
1171 (ulong)dev->rx_urb_size);
1173 ret = smsc75xx_write_reg(dev, BURST_CAP, buf);
1175 netdev_warn(dev->net, "Failed to write BURST_CAP: %d\n", ret);
1179 ret = smsc75xx_read_reg(dev, BURST_CAP, &buf);
1181 netdev_warn(dev->net, "Failed to read BURST_CAP: %d\n", ret);
1185 netif_dbg(dev, ifup, dev->net,
1188 ret = smsc75xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1190 netdev_warn(dev->net, "Failed to write BULK_IN_DLY: %d\n", ret);
1194 ret = smsc75xx_read_reg(dev, BULK_IN_DLY, &buf);
1196 netdev_warn(dev->net, "Failed to read BULK_IN_DLY: %d\n", ret);
1200 netif_dbg(dev, ifup, dev->net,
1204 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1206 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1210 netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
1214 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1216 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1220 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1222 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1226 netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
1231 ret = smsc75xx_write_reg(dev, FCT_RX_FIFO_END, buf);
1233 netdev_warn(dev->net, "Failed to write FCT_RX_FIFO_END: %d\n", ret);
1237 netif_dbg(dev, ifup, dev->net, "FCT_RX_FIFO_END set to 0x%08x\n", buf);
1240 ret = smsc75xx_write_reg(dev, FCT_TX_FIFO_END, buf);
1242 netdev_warn(dev->net, "Failed to write FCT_TX_FIFO_END: %d\n", ret);
1246 netif_dbg(dev, ifup, dev->net, "FCT_TX_FIFO_END set to 0x%08x\n", buf);
1248 ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
1250 netdev_warn(dev->net, "Failed to write INT_STS: %d\n", ret);
1254 ret = smsc75xx_read_reg(dev, ID_REV, &buf);
1256 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1260 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", buf);
1262 ret = smsc75xx_read_reg(dev, E2P_CMD, &buf);
1264 netdev_warn(dev->net, "Failed to read E2P_CMD: %d\n", ret);
1270 ret = smsc75xx_read_reg(dev, LED_GPIO_CFG, &buf);
1272 netdev_warn(dev->net, "Failed to read LED_GPIO_CFG: %d\n", ret);
1279 ret = smsc75xx_write_reg(dev, LED_GPIO_CFG, buf);
1281 netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n", ret);
1286 ret = smsc75xx_write_reg(dev, FLOW, 0);
1288 netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
1292 ret = smsc75xx_write_reg(dev, FCT_FLOW, 0);
1294 netdev_warn(dev->net, "Failed to write FCT_FLOW: %d\n", ret);
1299 ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1301 netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
1307 ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1309 netdev_warn(dev->net, "Failed to write RFE_CTL: %d\n", ret);
1313 ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1315 netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
1319 netif_dbg(dev, ifup, dev->net, "RFE_CTL set to 0x%08x\n",
1323 smsc75xx_set_features(dev->net, dev->net->features);
1325 smsc75xx_set_multicast(dev->net);
1327 ret = smsc75xx_phy_initialize(dev);
1329 netdev_warn(dev->net, "Failed to initialize PHY: %d\n", ret);
1333 ret = smsc75xx_read_reg(dev, INT_EP_CTL, &buf);
1335 netdev_warn(dev->net, "Failed to read INT_EP_CTL: %d\n", ret);
1342 ret = smsc75xx_write_reg(dev, INT_EP_CTL, buf);
1344 netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
1349 ret = smsc75xx_read_reg(dev, MAC_CR, &buf);
1351 netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret);
1356 ret = smsc75xx_write_reg(dev, MAC_CR, buf);
1358 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
1362 ret = smsc75xx_read_reg(dev, MAC_TX, &buf);
1364 netdev_warn(dev->net, "Failed to read MAC_TX: %d\n", ret);
1370 ret = smsc75xx_write_reg(dev, MAC_TX, buf);
1372 netdev_warn(dev->net, "Failed to write MAC_TX: %d\n", ret);
1376 netif_dbg(dev, ifup, dev->net, "MAC_TX set to 0x%08x\n", buf);
1378 ret = smsc75xx_read_reg(dev, FCT_TX_CTL, &buf);
1380 netdev_warn(dev->net, "Failed to read FCT_TX_CTL: %d\n", ret);
1386 ret = smsc75xx_write_reg(dev, FCT_TX_CTL, buf);
1388 netdev_warn(dev->net, "Failed to write FCT_TX_CTL: %d\n", ret);
1392 netif_dbg(dev, ifup, dev->net, "FCT_TX_CTL set to 0x%08x\n", buf);
1394 ret = smsc75xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
1396 netdev_warn(dev->net, "Failed to set max rx frame length\n");
1400 ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
1402 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
1408 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
1410 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
1414 netif_dbg(dev, ifup, dev->net, "MAC_RX set to 0x%08x\n", buf);
1416 ret = smsc75xx_read_reg(dev, FCT_RX_CTL, &buf);
1418 netdev_warn(dev->net, "Failed to read FCT_RX_CTL: %d\n", ret);
1424 ret = smsc75xx_write_reg(dev, FCT_RX_CTL, buf);
1426 netdev_warn(dev->net, "Failed to write FCT_RX_CTL: %d\n", ret);
1430 netif_dbg(dev, ifup, dev->net, "FCT_RX_CTL set to 0x%08x\n", buf);
1432 netif_dbg(dev, ifup, dev->net, "smsc75xx_reset, return 0\n");
1450 static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf)
1457 ret = usbnet_get_endpoints(dev, intf);
1459 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1463 dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc75xx_priv),
1466 pdata = (struct smsc75xx_priv *)(dev->data[0]);
1470 pdata->dev = dev;
1478 dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
1481 dev->net->features |= NETIF_F_RXCSUM;
1483 dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
1486 ret = smsc75xx_wait_ready(dev, 0);
1488 netdev_warn(dev->net, "device not ready in smsc75xx_bind\n");
1492 smsc75xx_init_mac_address(dev);
1495 ret = smsc75xx_reset(dev);
1497 netdev_warn(dev->net, "smsc75xx_reset error %d\n", ret);
1501 dev->net->netdev_ops = &smsc75xx_netdev_ops;
1502 dev->net->ethtool_ops = &smsc75xx_ethtool_ops;
1503 dev->net->flags |= IFF_MULTICAST;
1504 dev->net->hard_header_len += SMSC75XX_TX_OVERHEAD;
1505 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1506 dev->net->max_mtu = MAX_SINGLE_PACKET_SIZE;
1513 dev->data[0] = 0;
1517 static void smsc75xx_unbind(struct usbnet *dev, struct usb_interface *intf)
1519 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1522 netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1524 dev->data[0] = 0;
1533 static int smsc75xx_write_wuff(struct usbnet *dev, int filter, u32 wuf_cfg,
1540 ret = smsc75xx_write_reg(dev, cfg_base, wuf_cfg);
1542 netdev_warn(dev->net, "Error writing WUF_CFGX\n");
1546 ret = smsc75xx_write_reg(dev, mask_base, wuf_mask1);
1548 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1552 ret = smsc75xx_write_reg(dev, mask_base + 4, 0);
1554 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1558 ret = smsc75xx_write_reg(dev, mask_base + 8, 0);
1560 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1564 ret = smsc75xx_write_reg(dev, mask_base + 12, 0);
1566 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1573 static int smsc75xx_enter_suspend0(struct usbnet *dev)
1575 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1579 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1581 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1588 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1590 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1599 static int smsc75xx_enter_suspend1(struct usbnet *dev)
1601 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1605 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1607 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1614 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1616 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1624 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1626 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1635 static int smsc75xx_enter_suspend2(struct usbnet *dev)
1637 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1641 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1643 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1650 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1652 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1661 static int smsc75xx_enter_suspend3(struct usbnet *dev)
1663 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1667 ret = smsc75xx_read_reg_nopm(dev, FCT_RX_CTL, &val);
1669 netdev_warn(dev->net, "Error reading FCT_RX_CTL\n");
1674 netdev_dbg(dev->net, "rx fifo not empty in autosuspend\n");
1678 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1680 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1687 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1689 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1697 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1699 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1708 static int smsc75xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
1710 struct mii_if_info *mii = &dev->mii;
1713 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1716 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1718 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
1723 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1725 netdev_warn(dev->net, "Error reading PHY_INT_MASK\n");
1731 smsc75xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1736 static int smsc75xx_link_ok_nopm(struct usbnet *dev)
1738 struct mii_if_info *mii = &dev->mii;
1742 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1744 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1748 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1750 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1757 static int smsc75xx_autosuspend(struct usbnet *dev, u32 link_up)
1761 if (!netif_running(dev->net)) {
1763 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
1764 return smsc75xx_enter_suspend2(dev);
1769 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
1772 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1775 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1779 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1780 return smsc75xx_enter_suspend1(dev);
1784 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1787 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1791 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
1792 return smsc75xx_enter_suspend3(dev);
1797 struct usbnet *dev = usb_get_intfdata(intf);
1798 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1804 netdev_warn(dev->net, "usbnet_suspend error\n");
1809 netdev_warn(dev->net, "error during last resume\n");
1814 link_up = smsc75xx_link_ok_nopm(dev);
1817 ret = smsc75xx_autosuspend(dev, link_up);
1827 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1830 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1832 netdev_warn(dev->net, "Error reading WUCSR\n");
1838 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1840 netdev_warn(dev->net, "Error writing WUCSR\n");
1844 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1846 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1852 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1854 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1858 ret = smsc75xx_enter_suspend2(dev);
1863 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1866 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1874 struct mii_if_info *mii = &dev->mii;
1875 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1878 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id,
1881 netdev_warn(dev->net, "Error reading PHY_MODE_CTRL_STS\n");
1887 smsc75xx_mdio_write_nopm(dev->net, mii->phy_id,
1891 ret = smsc75xx_enter_suspend1(dev);
1901 ret = smsc75xx_write_reg_nopm(dev, WUF_CFGX + i * 4, 0);
1903 netdev_warn(dev->net, "Error writing WUF_CFGX\n");
1910 netdev_info(dev->net, "enabling multicast detection\n");
1914 ret = smsc75xx_write_wuff(dev, filter++, val, 0x0007);
1916 netdev_warn(dev->net, "Error writing wakeup filter\n");
1923 netdev_info(dev->net, "enabling ARP detection\n");
1927 ret = smsc75xx_write_wuff(dev, filter++, val, 0x0003);
1929 netdev_warn(dev->net, "Error writing wakeup filter\n");
1935 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1937 netdev_warn(dev->net, "Error reading WUCSR\n");
1943 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1945 netdev_warn(dev->net, "Error writing WUCSR\n");
1949 netdev_info(dev->net, "enabling packet match detection\n");
1950 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1952 netdev_warn(dev->net, "Error reading WUCSR\n");
1958 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1960 netdev_warn(dev->net, "Error writing WUCSR\n");
1964 netdev_info(dev->net, "disabling packet match detection\n");
1965 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1967 netdev_warn(dev->net, "Error reading WUCSR\n");
1973 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1975 netdev_warn(dev->net, "Error writing WUCSR\n");
1981 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1983 netdev_warn(dev->net, "Error reading WUCSR\n");
1989 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1991 netdev_warn(dev->net, "Error writing WUCSR\n");
1996 netdev_info(dev->net, "enabling PHY wakeup\n");
1998 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2000 netdev_warn(dev->net, "Error reading PMT_CTL\n");
2008 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2010 netdev_warn(dev->net, "Error writing PMT_CTL\n");
2016 netdev_info(dev->net, "enabling magic packet wakeup\n");
2017 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2019 netdev_warn(dev->net, "Error reading WUCSR\n");
2026 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2028 netdev_warn(dev->net, "Error writing WUCSR\n");
2034 netdev_info(dev->net, "enabling broadcast detection\n");
2035 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2037 netdev_warn(dev->net, "Error reading WUCSR\n");
2043 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2045 netdev_warn(dev->net, "Error writing WUCSR\n");
2051 netdev_info(dev->net, "enabling unicast detection\n");
2052 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2054 netdev_warn(dev->net, "Error reading WUCSR\n");
2060 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2062 netdev_warn(dev->net, "Error writing WUCSR\n");
2068 ret = smsc75xx_read_reg_nopm(dev, MAC_RX, &val);
2070 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
2076 ret = smsc75xx_write_reg_nopm(dev, MAC_RX, val);
2078 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
2083 netdev_info(dev->net, "entering SUSPEND0 mode\n");
2084 ret = smsc75xx_enter_suspend0(dev);
2098 struct usbnet *dev = usb_get_intfdata(intf);
2099 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
2104 netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
2111 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2113 netdev_warn(dev->net, "Error reading WUCSR\n");
2120 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2122 netdev_warn(dev->net, "Error writing WUCSR\n");
2127 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2129 netdev_warn(dev->net, "Error reading PMT_CTL\n");
2136 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2138 netdev_warn(dev->net, "Error writing PMT_CTL\n");
2144 netdev_info(dev->net, "resuming from SUSPEND2\n");
2146 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2148 netdev_warn(dev->net, "Error reading PMT_CTL\n");
2154 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2156 netdev_warn(dev->net, "Error writing PMT_CTL\n");
2161 ret = smsc75xx_wait_ready(dev, 1);
2163 netdev_warn(dev->net, "device not ready in smsc75xx_resume\n");
2170 static void smsc75xx_rx_csum_offload(struct usbnet *dev, struct sk_buff *skb,
2173 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2182 static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
2185 if (skb->len < dev->net->hard_header_len)
2206 netif_dbg(dev, rx_err, dev->net,
2213 netif_dbg(dev, rx_err, dev->net,
2215 dev->net->stats.rx_errors++;
2216 dev->net->stats.rx_dropped++;
2219 dev->net->stats.rx_crc_errors++;
2221 dev->net->stats.rx_frame_errors++;
2225 netif_dbg(dev, rx_err, dev->net,
2233 smsc75xx_rx_csum_offload(dev, skb, rx_cmd_a,
2244 netdev_warn(dev->net, "Error allocating skb\n");
2252 smsc75xx_rx_csum_offload(dev, ax_skb, rx_cmd_a,
2258 usbnet_skb_return(dev, ax_skb);
2271 static struct sk_buff *smsc75xx_tx_fixup(struct usbnet *dev,
2303 static int smsc75xx_manage_power(struct usbnet *dev, int on)
2305 dev->intf->needs_remote_wakeup = on;