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)
763 if (!eth_platform_get_mac_address(&dev->udev->dev,
764 dev->net->dev_addr)) {
765 if (is_valid_ether_addr(dev->net->dev_addr)) {
767 netif_dbg(dev, ifup, dev->net, "MAC address read from the device tree\n");
773 if (smsc75xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
774 dev->net->dev_addr) == 0) {
775 if (is_valid_ether_addr(dev->net->dev_addr)) {
777 netif_dbg(dev, ifup, dev->net,
784 eth_hw_addr_random(dev->net);
785 netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
788 static int smsc75xx_set_mac_address(struct usbnet *dev)
790 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
791 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
792 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
794 int ret = smsc75xx_write_reg(dev, RX_ADDRH, addr_hi);
796 netdev_warn(dev->net, "Failed to write RX_ADDRH: %d\n", ret);
800 ret = smsc75xx_write_reg(dev, RX_ADDRL, addr_lo);
802 netdev_warn(dev->net, "Failed to write RX_ADDRL: %d\n", ret);
807 ret = smsc75xx_write_reg(dev, ADDR_FILTX, addr_hi);
809 netdev_warn(dev->net, "Failed to write ADDR_FILTX: %d\n", ret);
813 ret = smsc75xx_write_reg(dev, ADDR_FILTX + 4, addr_lo);
815 netdev_warn(dev->net, "Failed to write ADDR_FILTX+4: %d\n", ret);
820 static int smsc75xx_phy_initialize(struct usbnet *dev)
825 dev->mii.dev = dev->net;
826 dev->mii.mdio_read = smsc75xx_mdio_read;
827 dev->mii.mdio_write = smsc75xx_mdio_write;
828 dev->mii.phy_id_mask = 0x1f;
829 dev->mii.reg_num_mask = 0x1f;
830 dev->mii.supports_gmii = 1;
831 dev->mii.phy_id = SMSC75XX_INTERNAL_PHY_ID;
834 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
838 bmcr = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, MII_BMCR);
840 netdev_warn(dev->net, "Error reading MII_BMCR\n");
847 netdev_warn(dev->net, "timeout on PHY Reset\n");
852 smsc75xx_phy_gig_workaround(dev);
854 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
857 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, MII_CTRL1000,
861 ret = smsc75xx_mdio_read(dev->net, dev->mii.phy_id, PHY_INT_SRC);
863 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
867 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_SRC, 0xffff);
869 smsc75xx_mdio_write(dev->net, dev->mii.phy_id, PHY_INT_MASK,
871 mii_nway_restart(&dev->mii);
873 netif_dbg(dev, ifup, dev->net, "phy initialised successfully\n");
877 static int smsc75xx_set_rx_max_frame_length(struct usbnet *dev, int size)
883 ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
885 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
893 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
895 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
904 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
906 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
912 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
914 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
924 struct usbnet *dev = netdev_priv(netdev);
927 ret = smsc75xx_set_rx_max_frame_length(dev, new_mtu + ETH_HLEN);
929 netdev_warn(dev->net, "Failed to set mac rx frame length\n");
940 struct usbnet *dev = netdev_priv(netdev);
941 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
955 ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
957 netdev_warn(dev->net, "Error writing RFE_CTL\n");
963 static int smsc75xx_wait_ready(struct usbnet *dev, int in_pm)
971 ret = __smsc75xx_read_reg(dev, PMT_CTL, &buf, in_pm);
974 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
985 netdev_warn(dev->net, "timeout waiting for device ready\n");
989 static int smsc75xx_phy_gig_workaround(struct usbnet *dev)
991 struct mii_if_info *mii = &dev->mii;
996 smsc75xx_mdio_write(dev->net, mii->phy_id, MII_BMCR, 0x4040);
1000 link_up = smsc75xx_link_ok_nopm(dev);
1006 netdev_warn(dev->net, "Timeout waiting for PHY link up\n");
1011 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1013 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1019 ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
1021 netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
1028 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1030 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n",
1038 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
1045 static int smsc75xx_reset(struct usbnet *dev)
1047 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1051 netif_dbg(dev, ifup, dev->net, "entering smsc75xx_reset\n");
1053 ret = smsc75xx_wait_ready(dev, 0);
1055 netdev_warn(dev->net, "device not ready in smsc75xx_reset\n");
1059 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1061 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1067 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1069 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1076 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1078 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1085 netdev_warn(dev->net, "timeout on completion of Lite Reset\n");
1089 netif_dbg(dev, ifup, dev->net, "Lite reset complete, resetting PHY\n");
1091 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1093 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1099 ret = smsc75xx_write_reg(dev, PMT_CTL, buf);
1101 netdev_warn(dev->net, "Failed to write PMT_CTL: %d\n", ret);
1108 ret = smsc75xx_read_reg(dev, PMT_CTL, &buf);
1110 netdev_warn(dev->net, "Failed to read PMT_CTL: %d\n", ret);
1117 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
1121 netif_dbg(dev, ifup, dev->net, "PHY reset complete\n");
1123 ret = smsc75xx_set_mac_address(dev);
1125 netdev_warn(dev->net, "Failed to set mac address\n");
1129 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
1130 dev->net->dev_addr);
1132 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1134 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1138 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
1143 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1145 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1149 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1151 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1155 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG after writing HW_CFG_BIR: 0x%08x\n",
1160 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
1161 } else if (dev->udev->speed == USB_SPEED_HIGH) {
1163 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
1166 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
1169 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
1170 (ulong)dev->rx_urb_size);
1172 ret = smsc75xx_write_reg(dev, BURST_CAP, buf);
1174 netdev_warn(dev->net, "Failed to write BURST_CAP: %d\n", ret);
1178 ret = smsc75xx_read_reg(dev, BURST_CAP, &buf);
1180 netdev_warn(dev->net, "Failed to read BURST_CAP: %d\n", ret);
1184 netif_dbg(dev, ifup, dev->net,
1187 ret = smsc75xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
1189 netdev_warn(dev->net, "Failed to write BULK_IN_DLY: %d\n", ret);
1193 ret = smsc75xx_read_reg(dev, BULK_IN_DLY, &buf);
1195 netdev_warn(dev->net, "Failed to read BULK_IN_DLY: %d\n", ret);
1199 netif_dbg(dev, ifup, dev->net,
1203 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1205 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1209 netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
1213 ret = smsc75xx_write_reg(dev, HW_CFG, buf);
1215 netdev_warn(dev->net, "Failed to write HW_CFG: %d\n", ret);
1219 ret = smsc75xx_read_reg(dev, HW_CFG, &buf);
1221 netdev_warn(dev->net, "Failed to read HW_CFG: %d\n", ret);
1225 netif_dbg(dev, ifup, dev->net, "HW_CFG: 0x%08x\n", buf);
1230 ret = smsc75xx_write_reg(dev, FCT_RX_FIFO_END, buf);
1232 netdev_warn(dev->net, "Failed to write FCT_RX_FIFO_END: %d\n", ret);
1236 netif_dbg(dev, ifup, dev->net, "FCT_RX_FIFO_END set to 0x%08x\n", buf);
1239 ret = smsc75xx_write_reg(dev, FCT_TX_FIFO_END, buf);
1241 netdev_warn(dev->net, "Failed to write FCT_TX_FIFO_END: %d\n", ret);
1245 netif_dbg(dev, ifup, dev->net, "FCT_TX_FIFO_END set to 0x%08x\n", buf);
1247 ret = smsc75xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL);
1249 netdev_warn(dev->net, "Failed to write INT_STS: %d\n", ret);
1253 ret = smsc75xx_read_reg(dev, ID_REV, &buf);
1255 netdev_warn(dev->net, "Failed to read ID_REV: %d\n", ret);
1259 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", buf);
1261 ret = smsc75xx_read_reg(dev, E2P_CMD, &buf);
1263 netdev_warn(dev->net, "Failed to read E2P_CMD: %d\n", ret);
1269 ret = smsc75xx_read_reg(dev, LED_GPIO_CFG, &buf);
1271 netdev_warn(dev->net, "Failed to read LED_GPIO_CFG: %d\n", ret);
1278 ret = smsc75xx_write_reg(dev, LED_GPIO_CFG, buf);
1280 netdev_warn(dev->net, "Failed to write LED_GPIO_CFG: %d\n", ret);
1285 ret = smsc75xx_write_reg(dev, FLOW, 0);
1287 netdev_warn(dev->net, "Failed to write FLOW: %d\n", ret);
1291 ret = smsc75xx_write_reg(dev, FCT_FLOW, 0);
1293 netdev_warn(dev->net, "Failed to write FCT_FLOW: %d\n", ret);
1298 ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1300 netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
1306 ret = smsc75xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1308 netdev_warn(dev->net, "Failed to write RFE_CTL: %d\n", ret);
1312 ret = smsc75xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
1314 netdev_warn(dev->net, "Failed to read RFE_CTL: %d\n", ret);
1318 netif_dbg(dev, ifup, dev->net, "RFE_CTL set to 0x%08x\n",
1322 smsc75xx_set_features(dev->net, dev->net->features);
1324 smsc75xx_set_multicast(dev->net);
1326 ret = smsc75xx_phy_initialize(dev);
1328 netdev_warn(dev->net, "Failed to initialize PHY: %d\n", ret);
1332 ret = smsc75xx_read_reg(dev, INT_EP_CTL, &buf);
1334 netdev_warn(dev->net, "Failed to read INT_EP_CTL: %d\n", ret);
1341 ret = smsc75xx_write_reg(dev, INT_EP_CTL, buf);
1343 netdev_warn(dev->net, "Failed to write INT_EP_CTL: %d\n", ret);
1348 ret = smsc75xx_read_reg(dev, MAC_CR, &buf);
1350 netdev_warn(dev->net, "Failed to read MAC_CR: %d\n", ret);
1355 ret = smsc75xx_write_reg(dev, MAC_CR, buf);
1357 netdev_warn(dev->net, "Failed to write MAC_CR: %d\n", ret);
1361 ret = smsc75xx_read_reg(dev, MAC_TX, &buf);
1363 netdev_warn(dev->net, "Failed to read MAC_TX: %d\n", ret);
1369 ret = smsc75xx_write_reg(dev, MAC_TX, buf);
1371 netdev_warn(dev->net, "Failed to write MAC_TX: %d\n", ret);
1375 netif_dbg(dev, ifup, dev->net, "MAC_TX set to 0x%08x\n", buf);
1377 ret = smsc75xx_read_reg(dev, FCT_TX_CTL, &buf);
1379 netdev_warn(dev->net, "Failed to read FCT_TX_CTL: %d\n", ret);
1385 ret = smsc75xx_write_reg(dev, FCT_TX_CTL, buf);
1387 netdev_warn(dev->net, "Failed to write FCT_TX_CTL: %d\n", ret);
1391 netif_dbg(dev, ifup, dev->net, "FCT_TX_CTL set to 0x%08x\n", buf);
1393 ret = smsc75xx_set_rx_max_frame_length(dev, dev->net->mtu + ETH_HLEN);
1395 netdev_warn(dev->net, "Failed to set max rx frame length\n");
1399 ret = smsc75xx_read_reg(dev, MAC_RX, &buf);
1401 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
1407 ret = smsc75xx_write_reg(dev, MAC_RX, buf);
1409 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
1413 netif_dbg(dev, ifup, dev->net, "MAC_RX set to 0x%08x\n", buf);
1415 ret = smsc75xx_read_reg(dev, FCT_RX_CTL, &buf);
1417 netdev_warn(dev->net, "Failed to read FCT_RX_CTL: %d\n", ret);
1423 ret = smsc75xx_write_reg(dev, FCT_RX_CTL, buf);
1425 netdev_warn(dev->net, "Failed to write FCT_RX_CTL: %d\n", ret);
1429 netif_dbg(dev, ifup, dev->net, "FCT_RX_CTL set to 0x%08x\n", buf);
1431 netif_dbg(dev, ifup, dev->net, "smsc75xx_reset, return 0\n");
1449 static int smsc75xx_bind(struct usbnet *dev, struct usb_interface *intf)
1456 ret = usbnet_get_endpoints(dev, intf);
1458 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1462 dev->data[0] = (unsigned long)kzalloc(sizeof(struct smsc75xx_priv),
1465 pdata = (struct smsc75xx_priv *)(dev->data[0]);
1469 pdata->dev = dev;
1477 dev->net->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
1480 dev->net->features |= NETIF_F_RXCSUM;
1482 dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
1485 ret = smsc75xx_wait_ready(dev, 0);
1487 netdev_warn(dev->net, "device not ready in smsc75xx_bind\n");
1491 smsc75xx_init_mac_address(dev);
1494 ret = smsc75xx_reset(dev);
1496 netdev_warn(dev->net, "smsc75xx_reset error %d\n", ret);
1500 dev->net->netdev_ops = &smsc75xx_netdev_ops;
1501 dev->net->ethtool_ops = &smsc75xx_ethtool_ops;
1502 dev->net->flags |= IFF_MULTICAST;
1503 dev->net->hard_header_len += SMSC75XX_TX_OVERHEAD;
1504 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1505 dev->net->max_mtu = MAX_SINGLE_PACKET_SIZE;
1512 dev->data[0] = 0;
1516 static void smsc75xx_unbind(struct usbnet *dev, struct usb_interface *intf)
1518 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1521 netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1523 dev->data[0] = 0;
1532 static int smsc75xx_write_wuff(struct usbnet *dev, int filter, u32 wuf_cfg,
1539 ret = smsc75xx_write_reg(dev, cfg_base, wuf_cfg);
1541 netdev_warn(dev->net, "Error writing WUF_CFGX\n");
1545 ret = smsc75xx_write_reg(dev, mask_base, wuf_mask1);
1547 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1551 ret = smsc75xx_write_reg(dev, mask_base + 4, 0);
1553 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1557 ret = smsc75xx_write_reg(dev, mask_base + 8, 0);
1559 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1563 ret = smsc75xx_write_reg(dev, mask_base + 12, 0);
1565 netdev_warn(dev->net, "Error writing WUF_MASKX\n");
1572 static int smsc75xx_enter_suspend0(struct usbnet *dev)
1574 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1578 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1580 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1587 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1589 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1598 static int smsc75xx_enter_suspend1(struct usbnet *dev)
1600 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1604 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1606 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1613 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1615 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1623 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1625 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1634 static int smsc75xx_enter_suspend2(struct usbnet *dev)
1636 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1640 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1642 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1649 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1651 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1660 static int smsc75xx_enter_suspend3(struct usbnet *dev)
1662 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1666 ret = smsc75xx_read_reg_nopm(dev, FCT_RX_CTL, &val);
1668 netdev_warn(dev->net, "Error reading FCT_RX_CTL\n");
1673 netdev_dbg(dev->net, "rx fifo not empty in autosuspend\n");
1677 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1679 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1686 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1688 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1696 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1698 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1707 static int smsc75xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
1709 struct mii_if_info *mii = &dev->mii;
1712 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1715 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_SRC);
1717 netdev_warn(dev->net, "Error reading PHY_INT_SRC\n");
1722 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, PHY_INT_MASK);
1724 netdev_warn(dev->net, "Error reading PHY_INT_MASK\n");
1730 smsc75xx_mdio_write_nopm(dev->net, mii->phy_id, PHY_INT_MASK, ret);
1735 static int smsc75xx_link_ok_nopm(struct usbnet *dev)
1737 struct mii_if_info *mii = &dev->mii;
1741 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1743 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1747 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id, MII_BMSR);
1749 netdev_warn(dev->net, "Error reading MII_BMSR\n");
1756 static int smsc75xx_autosuspend(struct usbnet *dev, u32 link_up)
1760 if (!netif_running(dev->net)) {
1762 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
1763 return smsc75xx_enter_suspend2(dev);
1768 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
1771 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1774 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1778 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1779 return smsc75xx_enter_suspend1(dev);
1783 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1786 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1790 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
1791 return smsc75xx_enter_suspend3(dev);
1796 struct usbnet *dev = usb_get_intfdata(intf);
1797 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
1803 netdev_warn(dev->net, "usbnet_suspend error\n");
1808 netdev_warn(dev->net, "error during last resume\n");
1813 link_up = smsc75xx_link_ok_nopm(dev);
1816 ret = smsc75xx_autosuspend(dev, link_up);
1826 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1829 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1831 netdev_warn(dev->net, "Error reading WUCSR\n");
1837 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1839 netdev_warn(dev->net, "Error writing WUCSR\n");
1843 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1845 netdev_warn(dev->net, "Error reading PMT_CTL\n");
1851 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
1853 netdev_warn(dev->net, "Error writing PMT_CTL\n");
1857 ret = smsc75xx_enter_suspend2(dev);
1862 ret = smsc75xx_enable_phy_wakeup_interrupts(dev,
1865 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1873 struct mii_if_info *mii = &dev->mii;
1874 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1877 ret = smsc75xx_mdio_read_nopm(dev->net, mii->phy_id,
1880 netdev_warn(dev->net, "Error reading PHY_MODE_CTRL_STS\n");
1886 smsc75xx_mdio_write_nopm(dev->net, mii->phy_id,
1890 ret = smsc75xx_enter_suspend1(dev);
1900 ret = smsc75xx_write_reg_nopm(dev, WUF_CFGX + i * 4, 0);
1902 netdev_warn(dev->net, "Error writing WUF_CFGX\n");
1909 netdev_info(dev->net, "enabling multicast detection\n");
1913 ret = smsc75xx_write_wuff(dev, filter++, val, 0x0007);
1915 netdev_warn(dev->net, "Error writing wakeup filter\n");
1922 netdev_info(dev->net, "enabling ARP detection\n");
1926 ret = smsc75xx_write_wuff(dev, filter++, val, 0x0003);
1928 netdev_warn(dev->net, "Error writing wakeup filter\n");
1934 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1936 netdev_warn(dev->net, "Error reading WUCSR\n");
1942 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1944 netdev_warn(dev->net, "Error writing WUCSR\n");
1948 netdev_info(dev->net, "enabling packet match detection\n");
1949 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1951 netdev_warn(dev->net, "Error reading WUCSR\n");
1957 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1959 netdev_warn(dev->net, "Error writing WUCSR\n");
1963 netdev_info(dev->net, "disabling packet match detection\n");
1964 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1966 netdev_warn(dev->net, "Error reading WUCSR\n");
1972 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1974 netdev_warn(dev->net, "Error writing WUCSR\n");
1980 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
1982 netdev_warn(dev->net, "Error reading WUCSR\n");
1988 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
1990 netdev_warn(dev->net, "Error writing WUCSR\n");
1995 netdev_info(dev->net, "enabling PHY wakeup\n");
1997 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
1999 netdev_warn(dev->net, "Error reading PMT_CTL\n");
2007 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2009 netdev_warn(dev->net, "Error writing PMT_CTL\n");
2015 netdev_info(dev->net, "enabling magic packet wakeup\n");
2016 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2018 netdev_warn(dev->net, "Error reading WUCSR\n");
2025 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2027 netdev_warn(dev->net, "Error writing WUCSR\n");
2033 netdev_info(dev->net, "enabling broadcast detection\n");
2034 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2036 netdev_warn(dev->net, "Error reading WUCSR\n");
2042 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2044 netdev_warn(dev->net, "Error writing WUCSR\n");
2050 netdev_info(dev->net, "enabling unicast detection\n");
2051 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2053 netdev_warn(dev->net, "Error reading WUCSR\n");
2059 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2061 netdev_warn(dev->net, "Error writing WUCSR\n");
2067 ret = smsc75xx_read_reg_nopm(dev, MAC_RX, &val);
2069 netdev_warn(dev->net, "Failed to read MAC_RX: %d\n", ret);
2075 ret = smsc75xx_write_reg_nopm(dev, MAC_RX, val);
2077 netdev_warn(dev->net, "Failed to write MAC_RX: %d\n", ret);
2082 netdev_info(dev->net, "entering SUSPEND0 mode\n");
2083 ret = smsc75xx_enter_suspend0(dev);
2097 struct usbnet *dev = usb_get_intfdata(intf);
2098 struct smsc75xx_priv *pdata = (struct smsc75xx_priv *)(dev->data[0]);
2103 netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
2110 ret = smsc75xx_read_reg_nopm(dev, WUCSR, &val);
2112 netdev_warn(dev->net, "Error reading WUCSR\n");
2119 ret = smsc75xx_write_reg_nopm(dev, WUCSR, val);
2121 netdev_warn(dev->net, "Error writing WUCSR\n");
2126 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2128 netdev_warn(dev->net, "Error reading PMT_CTL\n");
2135 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2137 netdev_warn(dev->net, "Error writing PMT_CTL\n");
2143 netdev_info(dev->net, "resuming from SUSPEND2\n");
2145 ret = smsc75xx_read_reg_nopm(dev, PMT_CTL, &val);
2147 netdev_warn(dev->net, "Error reading PMT_CTL\n");
2153 ret = smsc75xx_write_reg_nopm(dev, PMT_CTL, val);
2155 netdev_warn(dev->net, "Error writing PMT_CTL\n");
2160 ret = smsc75xx_wait_ready(dev, 1);
2162 netdev_warn(dev->net, "device not ready in smsc75xx_resume\n");
2169 static void smsc75xx_rx_csum_offload(struct usbnet *dev, struct sk_buff *skb,
2172 if (!(dev->net->features & NETIF_F_RXCSUM) ||
2181 static int smsc75xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
2184 if (skb->len < dev->net->hard_header_len)
2205 netif_dbg(dev, rx_err, dev->net,
2212 netif_dbg(dev, rx_err, dev->net,
2214 dev->net->stats.rx_errors++;
2215 dev->net->stats.rx_dropped++;
2218 dev->net->stats.rx_crc_errors++;
2220 dev->net->stats.rx_frame_errors++;
2224 netif_dbg(dev, rx_err, dev->net,
2232 smsc75xx_rx_csum_offload(dev, skb, rx_cmd_a,
2243 netdev_warn(dev->net, "Error allocating skb\n");
2251 smsc75xx_rx_csum_offload(dev, ax_skb, rx_cmd_a,
2257 usbnet_skb_return(dev, ax_skb);
2270 static struct sk_buff *smsc75xx_tx_fixup(struct usbnet *dev,
2302 static int smsc75xx_manage_power(struct usbnet *dev, int on)
2304 dev->intf->needs_remote_wakeup = on;