Lines Matching refs:dev
71 static int __must_check __smsc95xx_read_reg(struct usbnet *dev, u32 index,
74 struct smsc95xx_priv *pdata = dev->driver_priv;
79 BUG_ON(!dev);
86 ret = fn(dev, USB_VENDOR_REQUEST_READ_REGISTER, USB_DIR_IN
93 netdev_warn(dev->net, "Failed to read reg index 0x%08x: %d\n",
104 static int __must_check __smsc95xx_write_reg(struct usbnet *dev, u32 index,
107 struct smsc95xx_priv *pdata = dev->driver_priv;
112 BUG_ON(!dev);
122 ret = fn(dev, USB_VENDOR_REQUEST_WRITE_REGISTER, USB_DIR_OUT
126 netdev_warn(dev->net, "Failed to write reg index 0x%08x: %d\n",
132 static int __must_check smsc95xx_read_reg_nopm(struct usbnet *dev, u32 index,
135 return __smsc95xx_read_reg(dev, index, data, 1);
138 static int __must_check smsc95xx_write_reg_nopm(struct usbnet *dev, u32 index,
141 return __smsc95xx_write_reg(dev, index, data, 1);
144 static int __must_check smsc95xx_read_reg(struct usbnet *dev, u32 index,
147 return __smsc95xx_read_reg(dev, index, data, 0);
150 static int __must_check smsc95xx_write_reg(struct usbnet *dev, u32 index,
153 return __smsc95xx_write_reg(dev, index, data, 0);
158 static int __must_check __smsc95xx_phy_wait_not_busy(struct usbnet *dev,
166 ret = __smsc95xx_read_reg(dev, MII_ADDR, &val, in_pm);
171 netdev_warn(dev->net, "Error reading MII_ACCESS\n");
187 static int __smsc95xx_mdio_read(struct usbnet *dev, int phy_id, int idx,
193 mutex_lock(&dev->phy_mutex);
196 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
198 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
204 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
207 netdev_warn(dev->net, "Error writing MII_ADDR\n");
211 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
213 netdev_warn(dev->net, "Timed out reading MII reg %02X\n", idx);
217 ret = __smsc95xx_read_reg(dev, MII_DATA, &val, in_pm);
220 netdev_warn(dev->net, "Error reading MII_DATA\n");
227 mutex_unlock(&dev->phy_mutex);
235 static void __smsc95xx_mdio_write(struct usbnet *dev, int phy_id,
241 mutex_lock(&dev->phy_mutex);
244 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
246 netdev_warn(dev->net, "%s: MII is busy\n", __func__);
251 ret = __smsc95xx_write_reg(dev, MII_DATA, val, in_pm);
254 netdev_warn(dev->net, "Error writing MII_DATA\n");
260 ret = __smsc95xx_write_reg(dev, MII_ADDR, addr, in_pm);
263 netdev_warn(dev->net, "Error writing MII_ADDR\n");
267 ret = __smsc95xx_phy_wait_not_busy(dev, in_pm);
269 netdev_warn(dev->net, "Timed out writing MII reg %02X\n", idx);
274 mutex_unlock(&dev->phy_mutex);
277 static int smsc95xx_mdio_read_nopm(struct usbnet *dev, int idx)
279 struct smsc95xx_priv *pdata = dev->driver_priv;
281 return __smsc95xx_mdio_read(dev, pdata->phydev->mdio.addr, idx, 1);
284 static void smsc95xx_mdio_write_nopm(struct usbnet *dev, int idx, int regval)
286 struct smsc95xx_priv *pdata = dev->driver_priv;
288 __smsc95xx_mdio_write(dev, pdata->phydev->mdio.addr, idx, regval, 1);
293 struct usbnet *dev = bus->priv;
295 return __smsc95xx_mdio_read(dev, phy_id, idx, 0);
301 struct usbnet *dev = bus->priv;
303 __smsc95xx_mdio_write(dev, phy_id, idx, regval, 0);
307 static int __must_check smsc95xx_wait_eeprom(struct usbnet *dev)
314 ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
316 netdev_warn(dev->net, "Error reading E2P_CMD\n");
326 netdev_warn(dev->net, "EEPROM read operation timeout\n");
333 static int __must_check smsc95xx_eeprom_confirm_not_busy(struct usbnet *dev)
340 ret = smsc95xx_read_reg(dev, E2P_CMD, &val);
342 netdev_warn(dev->net, "Error reading E2P_CMD\n");
352 netdev_warn(dev->net, "EEPROM is busy\n");
356 static int smsc95xx_read_eeprom(struct usbnet *dev, u32 offset, u32 length,
362 BUG_ON(!dev);
365 ret = smsc95xx_eeprom_confirm_not_busy(dev);
371 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
373 netdev_warn(dev->net, "Error writing E2P_CMD\n");
377 ret = smsc95xx_wait_eeprom(dev);
381 ret = smsc95xx_read_reg(dev, E2P_DATA, &val);
383 netdev_warn(dev->net, "Error reading E2P_DATA\n");
394 static int smsc95xx_write_eeprom(struct usbnet *dev, u32 offset, u32 length,
400 BUG_ON(!dev);
403 ret = smsc95xx_eeprom_confirm_not_busy(dev);
409 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
411 netdev_warn(dev->net, "Error writing E2P_DATA\n");
415 ret = smsc95xx_wait_eeprom(dev);
423 ret = smsc95xx_write_reg(dev, E2P_DATA, val);
425 netdev_warn(dev->net, "Error writing E2P_DATA\n");
431 ret = smsc95xx_write_reg(dev, E2P_CMD, val);
433 netdev_warn(dev->net, "Error writing E2P_CMD\n");
437 ret = smsc95xx_wait_eeprom(dev);
447 static int __must_check smsc95xx_write_reg_async(struct usbnet *dev, u16 index,
457 ret = usbnet_write_cmd_async(dev, USB_VENDOR_REQUEST_WRITE_REGISTER,
462 netdev_warn(dev->net, "Error write async cmd, sts=%d\n",
477 struct usbnet *dev = netdev_priv(netdev);
478 struct smsc95xx_priv *pdata = dev->driver_priv;
487 if (dev->net->flags & IFF_PROMISC) {
488 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled\n");
491 } else if (dev->net->flags & IFF_ALLMULTI) {
492 netif_dbg(dev, drv, dev->net, "receive all multicast enabled\n");
495 } else if (!netdev_mc_empty(dev->net)) {
510 netif_dbg(dev, drv, dev->net, "HASHH=0x%08X, HASHL=0x%08X\n",
513 netif_dbg(dev, drv, dev->net, "receive own packets only\n");
521 ret = smsc95xx_write_reg_async(dev, HASHH, pdata->hash_hi);
523 netdev_warn(dev->net, "failed to initiate async write to HASHH\n");
525 ret = smsc95xx_write_reg_async(dev, HASHL, pdata->hash_lo);
527 netdev_warn(dev->net, "failed to initiate async write to HASHL\n");
529 ret = smsc95xx_write_reg_async(dev, MAC_CR, pdata->mac_cr);
531 netdev_warn(dev->net, "failed to initiate async write to MAC_CR\n");
534 static int smsc95xx_phy_update_flowcontrol(struct usbnet *dev)
537 struct smsc95xx_priv *pdata = dev->driver_priv;
540 int ret = smsc95xx_read_reg(dev, AFC_CFG, &afc_cfg);
557 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s\n",
561 netif_dbg(dev, link, dev->net, "half duplex\n");
565 ret = smsc95xx_write_reg(dev, FLOW, flow);
569 return smsc95xx_write_reg(dev, AFC_CFG, afc_cfg);
572 static void smsc95xx_mac_update_fullduplex(struct usbnet *dev)
574 struct smsc95xx_priv *pdata = dev->driver_priv;
588 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
591 netdev_warn(dev->net,
596 ret = smsc95xx_phy_update_flowcontrol(dev);
598 netdev_warn(dev->net, "Error updating PHY flow control\n");
601 static void smsc95xx_status(struct usbnet *dev, struct urb *urb)
606 netdev_warn(dev->net, "unexpected urb length %d\n",
612 netif_dbg(dev, link, dev->net, "intdata: 0x%08X\n", intdata);
617 netdev_warn(dev->net, "unexpected interrupt, intdata=0x%08X\n",
625 struct usbnet *dev = netdev_priv(netdev);
629 ret = smsc95xx_read_reg(dev, COE_CR, &read_buf);
643 ret = smsc95xx_write_reg(dev, COE_CR, read_buf);
647 netif_dbg(dev, hw, dev->net, "COE_CR = 0x%08x\n", read_buf);
659 struct usbnet *dev = netdev_priv(netdev);
663 return smsc95xx_read_eeprom(dev, ee->offset, ee->len, data);
669 struct usbnet *dev = netdev_priv(netdev);
672 netdev_warn(dev->net, "EEPROM: magic value mismatch, magic = 0x%x\n",
677 return smsc95xx_write_eeprom(dev, ee->offset, ee->len, data);
690 struct usbnet *dev = netdev_priv(netdev);
695 retval = smsc95xx_read_reg(dev, ID_REV, ®s->version);
702 retval = smsc95xx_read_reg(dev, i, &data[j]);
713 struct usbnet *dev = netdev_priv(net);
714 struct smsc95xx_priv *pdata = dev->driver_priv;
723 struct usbnet *dev = netdev_priv(net);
724 struct smsc95xx_priv *pdata = dev->driver_priv;
732 ret = device_set_wakeup_enable(&dev->udev->dev, pdata->wolopts);
734 netdev_warn(dev->net, "device_set_wakeup_enable error %d\n", ret);
771 static void smsc95xx_init_mac_address(struct usbnet *dev)
774 if (!eth_platform_get_mac_address(&dev->udev->dev,
775 dev->net->dev_addr)) {
776 if (is_valid_ether_addr(dev->net->dev_addr)) {
778 netif_dbg(dev, ifup, dev->net, "MAC address read from the device tree\n");
784 if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
785 dev->net->dev_addr) == 0) {
786 if (is_valid_ether_addr(dev->net->dev_addr)) {
788 netif_dbg(dev, ifup, dev->net, "MAC address read from EEPROM\n");
794 eth_hw_addr_random(dev->net);
795 netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
798 static int smsc95xx_set_mac_address(struct usbnet *dev)
800 u32 addr_lo = dev->net->dev_addr[0] | dev->net->dev_addr[1] << 8 |
801 dev->net->dev_addr[2] << 16 | dev->net->dev_addr[3] << 24;
802 u32 addr_hi = dev->net->dev_addr[4] | dev->net->dev_addr[5] << 8;
805 ret = smsc95xx_write_reg(dev, ADDRL, addr_lo);
809 return smsc95xx_write_reg(dev, ADDRH, addr_hi);
813 static int smsc95xx_start_tx_path(struct usbnet *dev)
815 struct smsc95xx_priv *pdata = dev->driver_priv;
824 ret = smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr);
829 return smsc95xx_write_reg(dev, TX_CFG, TX_CFG_ON_);
833 static int smsc95xx_start_rx_path(struct usbnet *dev, int in_pm)
835 struct smsc95xx_priv *pdata = dev->driver_priv;
842 return __smsc95xx_write_reg(dev, MAC_CR, pdata->mac_cr, in_pm);
845 static int smsc95xx_reset(struct usbnet *dev)
847 struct smsc95xx_priv *pdata = dev->driver_priv;
851 netif_dbg(dev, ifup, dev->net, "entering smsc95xx_reset\n");
853 ret = smsc95xx_write_reg(dev, HW_CFG, HW_CFG_LRST_);
860 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
867 netdev_warn(dev->net, "timeout waiting for completion of Lite Reset\n");
871 ret = smsc95xx_write_reg(dev, PM_CTRL, PM_CTL_PHY_RST_);
878 ret = smsc95xx_read_reg(dev, PM_CTRL, &read_buf);
885 netdev_warn(dev->net, "timeout waiting for PHY Reset\n");
889 ret = smsc95xx_set_mac_address(dev);
893 netif_dbg(dev, ifup, dev->net, "MAC Address: %pM\n",
894 dev->net->dev_addr);
896 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
900 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG : 0x%08x\n",
905 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
909 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
913 netif_dbg(dev, ifup, dev->net,
919 dev->rx_urb_size = MAX_SINGLE_PACKET_SIZE;
920 } else if (dev->udev->speed == USB_SPEED_HIGH) {
922 dev->rx_urb_size = DEFAULT_HS_BURST_CAP_SIZE;
925 dev->rx_urb_size = DEFAULT_FS_BURST_CAP_SIZE;
928 netif_dbg(dev, ifup, dev->net, "rx_urb_size=%ld\n",
929 (ulong)dev->rx_urb_size);
931 ret = smsc95xx_write_reg(dev, BURST_CAP, burst_cap);
935 ret = smsc95xx_read_reg(dev, BURST_CAP, &read_buf);
939 netif_dbg(dev, ifup, dev->net,
943 ret = smsc95xx_write_reg(dev, BULK_IN_DLY, DEFAULT_BULK_IN_DELAY);
947 ret = smsc95xx_read_reg(dev, BULK_IN_DLY, &read_buf);
951 netif_dbg(dev, ifup, dev->net,
955 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
959 netif_dbg(dev, ifup, dev->net, "Read Value from HW_CFG: 0x%08x\n",
970 ret = smsc95xx_write_reg(dev, HW_CFG, read_buf);
974 ret = smsc95xx_read_reg(dev, HW_CFG, &read_buf);
978 netif_dbg(dev, ifup, dev->net,
981 ret = smsc95xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
985 ret = smsc95xx_read_reg(dev, ID_REV, &read_buf);
988 netif_dbg(dev, ifup, dev->net, "ID_REV = 0x%08x\n", read_buf);
993 ret = smsc95xx_write_reg(dev, LED_GPIO_CFG, write_buf);
998 ret = smsc95xx_write_reg(dev, FLOW, 0);
1002 ret = smsc95xx_write_reg(dev, AFC_CFG, AFC_CFG_DEFAULT);
1007 ret = smsc95xx_read_reg(dev, MAC_CR, &pdata->mac_cr);
1013 ret = smsc95xx_write_reg(dev, VLAN1, (u32)ETH_P_8021Q);
1018 ret = smsc95xx_set_features(dev->net, dev->net->features);
1020 netdev_warn(dev->net, "Failed to set checksum offload features\n");
1024 smsc95xx_set_multicast(dev->net);
1026 ret = smsc95xx_read_reg(dev, INT_EP_CTL, &read_buf);
1033 ret = smsc95xx_write_reg(dev, INT_EP_CTL, read_buf);
1037 ret = smsc95xx_start_tx_path(dev);
1039 netdev_warn(dev->net, "Failed to start TX path\n");
1043 ret = smsc95xx_start_rx_path(dev, 0);
1045 netdev_warn(dev->net, "Failed to start RX path\n");
1049 netif_dbg(dev, ifup, dev->net, "smsc95xx_reset, return 0\n");
1069 struct usbnet *dev = netdev_priv(net);
1072 smsc95xx_mac_update_fullduplex(dev);
1073 usbnet_defer_kevent(dev, EVENT_LINK_CHANGE);
1076 static int smsc95xx_bind(struct usbnet *dev, struct usb_interface *intf)
1085 ret = usbnet_get_endpoints(dev, intf);
1087 netdev_warn(dev->net, "usbnet_get_endpoints failed: %d\n", ret);
1095 dev->driver_priv = pdata;
1107 dev->net->features |= NETIF_F_IP_CSUM;
1109 dev->net->features |= NETIF_F_RXCSUM;
1111 dev->net->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
1112 set_bit(EVENT_NO_IP_ALIGN, &dev->flags);
1114 smsc95xx_init_mac_address(dev);
1117 ret = smsc95xx_reset(dev);
1127 ret = smsc95xx_read_reg(dev, HW_CFG, &val);
1135 pdata->mdiobus->priv = dev;
1139 pdata->mdiobus->parent = &dev->udev->dev;
1142 "usb-%03d:%03d", dev->udev->bus->busnum, dev->udev->devnum);
1146 netdev_err(dev->net, "Could not register MDIO bus\n");
1152 netdev_err(dev->net, "no PHY found\n");
1160 ret = smsc95xx_read_reg(dev, ID_REV, &val);
1173 dev->net->netdev_ops = &smsc95xx_netdev_ops;
1174 dev->net->ethtool_ops = &smsc95xx_ethtool_ops;
1175 dev->net->flags |= IFF_MULTICAST;
1176 dev->net->hard_header_len += SMSC95XX_TX_OVERHEAD_CSUM;
1177 dev->net->min_mtu = ETH_MIN_MTU;
1178 dev->net->max_mtu = ETH_DATA_LEN;
1179 dev->hard_mtu = dev->net->mtu + dev->net->hard_header_len;
1181 ret = phy_connect_direct(dev->net, pdata->phydev,
1185 netdev_err(dev->net, "can't attach PHY to %s\n", pdata->mdiobus->id);
1189 phy_attached_info(dev->net->phydev);
1204 static void smsc95xx_unbind(struct usbnet *dev, struct usb_interface *intf)
1206 struct smsc95xx_priv *pdata = dev->driver_priv;
1208 phy_disconnect(dev->net->phydev);
1211 netif_dbg(dev, ifdown, dev->net, "free pdata\n");
1215 static int smsc95xx_start_phy(struct usbnet *dev)
1217 phy_start(dev->net->phydev);
1222 static int smsc95xx_stop(struct usbnet *dev)
1224 if (dev->net->phydev)
1225 phy_stop(dev->net->phydev);
1236 static int smsc95xx_enable_phy_wakeup_interrupts(struct usbnet *dev, u16 mask)
1240 netdev_dbg(dev->net, "enabling PHY wakeup interrupts\n");
1243 ret = smsc95xx_mdio_read_nopm(dev, PHY_INT_SRC);
1248 ret = smsc95xx_mdio_read_nopm(dev, PHY_INT_MASK);
1254 smsc95xx_mdio_write_nopm(dev, PHY_INT_MASK, ret);
1259 static int smsc95xx_link_ok_nopm(struct usbnet *dev)
1264 ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
1268 ret = smsc95xx_mdio_read_nopm(dev, MII_BMSR);
1275 static int smsc95xx_enter_suspend0(struct usbnet *dev)
1277 struct smsc95xx_priv *pdata = dev->driver_priv;
1281 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1288 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1300 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1305 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1314 static int smsc95xx_enter_suspend1(struct usbnet *dev)
1316 struct smsc95xx_priv *pdata = dev->driver_priv;
1324 smsc95xx_mdio_write_nopm(dev, PHY_EDPD_CONFIG,
1328 ret = smsc95xx_mdio_read_nopm(dev, PHY_MODE_CTRL_STS);
1334 smsc95xx_mdio_write_nopm(dev, PHY_MODE_CTRL_STS, ret);
1337 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1344 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1352 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1361 static int smsc95xx_enter_suspend2(struct usbnet *dev)
1363 struct smsc95xx_priv *pdata = dev->driver_priv;
1367 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1374 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1383 static int smsc95xx_enter_suspend3(struct usbnet *dev)
1385 struct smsc95xx_priv *pdata = dev->driver_priv;
1389 ret = smsc95xx_read_reg_nopm(dev, RX_FIFO_INF, &val);
1394 netdev_info(dev->net, "rx fifo not empty in autosuspend\n");
1398 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1405 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1413 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1422 static int smsc95xx_autosuspend(struct usbnet *dev, u32 link_up)
1424 struct smsc95xx_priv *pdata = dev->driver_priv;
1427 if (!netif_running(dev->net)) {
1429 netdev_dbg(dev->net, "autosuspend entering SUSPEND2\n");
1430 return smsc95xx_enter_suspend2(dev);
1439 netdev_warn(dev->net, "EDPD not supported\n");
1443 netdev_dbg(dev->net, "autosuspend entering SUSPEND1\n");
1446 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1449 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1453 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1454 return smsc95xx_enter_suspend1(dev);
1458 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1461 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1465 netdev_dbg(dev->net, "autosuspend entering SUSPEND3\n");
1466 return smsc95xx_enter_suspend3(dev);
1471 struct usbnet *dev = usb_get_intfdata(intf);
1472 struct smsc95xx_priv *pdata = dev->driver_priv;
1480 netdev_warn(dev->net, "usbnet_suspend error\n");
1486 netdev_warn(dev->net, "error during last resume\n");
1491 link_up = smsc95xx_link_ok_nopm(dev);
1495 ret = smsc95xx_autosuspend(dev, link_up);
1505 netdev_info(dev->net, "entering SUSPEND2 mode\n");
1508 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1514 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1518 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1524 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1528 ret = smsc95xx_enter_suspend2(dev);
1533 ret = smsc95xx_enable_phy_wakeup_interrupts(dev,
1536 netdev_warn(dev->net, "error enabling PHY wakeup ints\n");
1544 netdev_info(dev->net, "entering SUSPEND1 mode\n");
1545 ret = smsc95xx_enter_suspend1(dev);
1561 netdev_warn(dev->net, "Unable to allocate filter_mask\n");
1572 netdev_info(dev->net, "enabling broadcast detection\n");
1585 netdev_info(dev->net, "enabling multicast detection\n");
1598 netdev_info(dev->net, "enabling ARP detection\n");
1610 netdev_info(dev->net, "enabling unicast detection\n");
1617 crc[filter/2] |= smsc_crc(dev->net->dev_addr, ETH_ALEN, filter);
1622 ret = smsc95xx_write_reg_nopm(dev, WUFF, filter_mask[i]);
1631 ret = smsc95xx_write_reg_nopm(dev, WUFF, command[i]);
1637 ret = smsc95xx_write_reg_nopm(dev, WUFF, offset[i]);
1643 ret = smsc95xx_write_reg_nopm(dev, WUFF, crc[i]);
1649 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1655 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1662 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1668 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1674 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1679 netdev_info(dev->net, "enabling pattern match wakeup\n");
1682 netdev_info(dev->net, "disabling pattern match wakeup\n");
1687 netdev_info(dev->net, "enabling magic packet wakeup\n");
1690 netdev_info(dev->net, "disabling magic packet wakeup\n");
1694 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1699 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1709 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1714 smsc95xx_start_rx_path(dev, 1);
1717 netdev_info(dev->net, "entering SUSPEND0 mode\n");
1718 ret = smsc95xx_enter_suspend0(dev);
1734 struct usbnet *dev = usb_get_intfdata(intf);
1740 BUG_ON(!dev);
1741 pdata = dev->driver_priv;
1744 netdev_dbg(dev->net, "resume suspend_flags=0x%02x\n", suspend_flags);
1753 ret = smsc95xx_read_reg_nopm(dev, WUCSR, &val);
1759 ret = smsc95xx_write_reg_nopm(dev, WUCSR, val);
1764 ret = smsc95xx_read_reg_nopm(dev, PM_CTRL, &val);
1771 ret = smsc95xx_write_reg_nopm(dev, PM_CTRL, val);
1778 netdev_warn(dev->net, "usbnet_resume error\n");
1789 struct usbnet *dev = usb_get_intfdata(intf);
1790 struct smsc95xx_priv *pdata = dev->driver_priv;
1794 ret = smsc95xx_reset(dev);
1809 static int smsc95xx_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
1812 if (skb->len < dev->net->hard_header_len)
1830 netif_dbg(dev, rx_err, dev->net,
1836 netif_dbg(dev, rx_err, dev->net,
1838 dev->net->stats.rx_errors++;
1839 dev->net->stats.rx_dropped++;
1842 dev->net->stats.rx_crc_errors++;
1845 dev->net->stats.rx_frame_errors++;
1849 dev->net->stats.rx_length_errors++;
1854 netif_dbg(dev, rx_err, dev->net,
1861 if (dev->net->features & NETIF_F_RXCSUM)
1871 netdev_warn(dev->net, "Error allocating skb\n");
1879 if (dev->net->features & NETIF_F_RXCSUM)
1884 usbnet_skb_return(dev, ax_skb);
1921 static struct sk_buff *smsc95xx_tx_fixup(struct usbnet *dev,
1973 static int smsc95xx_manage_power(struct usbnet *dev, int on)
1975 struct smsc95xx_priv *pdata = dev->driver_priv;
1977 dev->intf->needs_remote_wakeup = on;
1983 netdev_info(dev->net, "hardware isn't capable of remote wakeup\n");
1986 usb_autopm_get_interface_no_resume(dev->intf);
1988 usb_autopm_put_interface(dev->intf);