Lines Matching refs:dev
122 #define LAN78XX_TSO_SIZE(dev) ((dev)->tx_urb_size - TX_SKB_MIN_LEN)
353 struct lan78xx_net *dev;
377 struct lan78xx_net *dev;
385 struct lan78xx_net *dev;
526 struct lan78xx_net *dev)
553 entry->dev = dev;
568 static struct sk_buff *lan78xx_get_rx_buf(struct lan78xx_net *dev)
570 return lan78xx_get_buf(&dev->rxq_free);
573 static void lan78xx_release_rx_buf(struct lan78xx_net *dev,
576 lan78xx_release_buf(&dev->rxq_free, rx_buf);
579 static void lan78xx_free_rx_resources(struct lan78xx_net *dev)
581 lan78xx_free_buf_pool(&dev->rxq_free);
584 static int lan78xx_alloc_rx_resources(struct lan78xx_net *dev)
586 return lan78xx_alloc_buf_pool(&dev->rxq_free,
587 dev->n_rx_urbs, dev->rx_urb_size, dev);
590 static struct sk_buff *lan78xx_get_tx_buf(struct lan78xx_net *dev)
592 return lan78xx_get_buf(&dev->txq_free);
595 static void lan78xx_release_tx_buf(struct lan78xx_net *dev,
598 lan78xx_release_buf(&dev->txq_free, tx_buf);
601 static void lan78xx_free_tx_resources(struct lan78xx_net *dev)
603 lan78xx_free_buf_pool(&dev->txq_free);
606 static int lan78xx_alloc_tx_resources(struct lan78xx_net *dev)
608 return lan78xx_alloc_buf_pool(&dev->txq_free,
609 dev->n_tx_urbs, dev->tx_urb_size, dev);
612 static int lan78xx_read_reg(struct lan78xx_net *dev, u32 index, u32 *data)
617 if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
624 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
632 netdev_warn(dev->net,
642 static int lan78xx_write_reg(struct lan78xx_net *dev, u32 index, u32 data)
647 if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
657 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
663 netdev_warn(dev->net,
673 static int lan78xx_update_reg(struct lan78xx_net *dev, u32 reg, u32 mask,
679 ret = lan78xx_read_reg(dev, reg, &buf);
686 ret = lan78xx_write_reg(dev, reg, buf);
693 static int lan78xx_read_stats(struct lan78xx_net *dev,
706 ret = usb_control_msg(dev->udev,
707 usb_rcvctrlpipe(dev->udev, 0),
723 netdev_warn(dev->net,
738 static void lan78xx_check_stat_rollover(struct lan78xx_net *dev,
741 check_counter_rollover(stats, dev->stats, rx_fcs_errors);
742 check_counter_rollover(stats, dev->stats, rx_alignment_errors);
743 check_counter_rollover(stats, dev->stats, rx_fragment_errors);
744 check_counter_rollover(stats, dev->stats, rx_jabber_errors);
745 check_counter_rollover(stats, dev->stats, rx_undersize_frame_errors);
746 check_counter_rollover(stats, dev->stats, rx_oversize_frame_errors);
747 check_counter_rollover(stats, dev->stats, rx_dropped_frames);
748 check_counter_rollover(stats, dev->stats, rx_unicast_byte_count);
749 check_counter_rollover(stats, dev->stats, rx_broadcast_byte_count);
750 check_counter_rollover(stats, dev->stats, rx_multicast_byte_count);
751 check_counter_rollover(stats, dev->stats, rx_unicast_frames);
752 check_counter_rollover(stats, dev->stats, rx_broadcast_frames);
753 check_counter_rollover(stats, dev->stats, rx_multicast_frames);
754 check_counter_rollover(stats, dev->stats, rx_pause_frames);
755 check_counter_rollover(stats, dev->stats, rx_64_byte_frames);
756 check_counter_rollover(stats, dev->stats, rx_65_127_byte_frames);
757 check_counter_rollover(stats, dev->stats, rx_128_255_byte_frames);
758 check_counter_rollover(stats, dev->stats, rx_256_511_bytes_frames);
759 check_counter_rollover(stats, dev->stats, rx_512_1023_byte_frames);
760 check_counter_rollover(stats, dev->stats, rx_1024_1518_byte_frames);
761 check_counter_rollover(stats, dev->stats, rx_greater_1518_byte_frames);
762 check_counter_rollover(stats, dev->stats, eee_rx_lpi_transitions);
763 check_counter_rollover(stats, dev->stats, eee_rx_lpi_time);
764 check_counter_rollover(stats, dev->stats, tx_fcs_errors);
765 check_counter_rollover(stats, dev->stats, tx_excess_deferral_errors);
766 check_counter_rollover(stats, dev->stats, tx_carrier_errors);
767 check_counter_rollover(stats, dev->stats, tx_bad_byte_count);
768 check_counter_rollover(stats, dev->stats, tx_single_collisions);
769 check_counter_rollover(stats, dev->stats, tx_multiple_collisions);
770 check_counter_rollover(stats, dev->stats, tx_excessive_collision);
771 check_counter_rollover(stats, dev->stats, tx_late_collisions);
772 check_counter_rollover(stats, dev->stats, tx_unicast_byte_count);
773 check_counter_rollover(stats, dev->stats, tx_broadcast_byte_count);
774 check_counter_rollover(stats, dev->stats, tx_multicast_byte_count);
775 check_counter_rollover(stats, dev->stats, tx_unicast_frames);
776 check_counter_rollover(stats, dev->stats, tx_broadcast_frames);
777 check_counter_rollover(stats, dev->stats, tx_multicast_frames);
778 check_counter_rollover(stats, dev->stats, tx_pause_frames);
779 check_counter_rollover(stats, dev->stats, tx_64_byte_frames);
780 check_counter_rollover(stats, dev->stats, tx_65_127_byte_frames);
781 check_counter_rollover(stats, dev->stats, tx_128_255_byte_frames);
782 check_counter_rollover(stats, dev->stats, tx_256_511_bytes_frames);
783 check_counter_rollover(stats, dev->stats, tx_512_1023_byte_frames);
784 check_counter_rollover(stats, dev->stats, tx_1024_1518_byte_frames);
785 check_counter_rollover(stats, dev->stats, tx_greater_1518_byte_frames);
786 check_counter_rollover(stats, dev->stats, eee_tx_lpi_transitions);
787 check_counter_rollover(stats, dev->stats, eee_tx_lpi_time);
789 memcpy(&dev->stats.saved, stats, sizeof(struct lan78xx_statstage));
792 static void lan78xx_update_stats(struct lan78xx_net *dev)
799 if (usb_autopm_get_interface(dev->intf) < 0)
803 count = (u32 *)&dev->stats.rollover_count;
804 max = (u32 *)&dev->stats.rollover_max;
805 data = (u64 *)&dev->stats.curr_stat;
807 mutex_lock(&dev->stats.access_lock);
809 if (lan78xx_read_stats(dev, &lan78xx_stats) > 0)
810 lan78xx_check_stat_rollover(dev, &lan78xx_stats);
815 mutex_unlock(&dev->stats.access_lock);
817 usb_autopm_put_interface(dev->intf);
821 static int lan78xx_phy_wait_not_busy(struct lan78xx_net *dev)
828 ret = lan78xx_read_reg(dev, MII_ACC, &val);
854 static int lan78xx_wait_eeprom(struct lan78xx_net *dev)
861 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
872 netdev_warn(dev->net, "EEPROM read operation timeout");
879 static int lan78xx_eeprom_confirm_not_busy(struct lan78xx_net *dev)
886 ret = lan78xx_read_reg(dev, E2P_CMD, &val);
896 netdev_warn(dev->net, "EEPROM is busy");
900 static int lan78xx_read_raw_eeprom(struct lan78xx_net *dev, u32 offset,
911 ret = lan78xx_read_reg(dev, HW_CFG, &val);
913 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
915 ret = lan78xx_write_reg(dev, HW_CFG, val);
918 retval = lan78xx_eeprom_confirm_not_busy(dev);
925 ret = lan78xx_write_reg(dev, E2P_CMD, val);
931 retval = lan78xx_wait_eeprom(dev);
935 ret = lan78xx_read_reg(dev, E2P_DATA, &val);
947 if (dev->chipid == ID_REV_CHIP_ID_7800_)
948 ret = lan78xx_write_reg(dev, HW_CFG, saved);
953 static int lan78xx_read_eeprom(struct lan78xx_net *dev, u32 offset,
959 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
961 ret = lan78xx_read_raw_eeprom(dev, offset, length, data);
968 static int lan78xx_write_raw_eeprom(struct lan78xx_net *dev, u32 offset,
979 ret = lan78xx_read_reg(dev, HW_CFG, &val);
981 if (dev->chipid == ID_REV_CHIP_ID_7800_) {
983 ret = lan78xx_write_reg(dev, HW_CFG, val);
986 retval = lan78xx_eeprom_confirm_not_busy(dev);
992 ret = lan78xx_write_reg(dev, E2P_CMD, val);
998 retval = lan78xx_wait_eeprom(dev);
1005 ret = lan78xx_write_reg(dev, E2P_DATA, val);
1014 ret = lan78xx_write_reg(dev, E2P_CMD, val);
1020 retval = lan78xx_wait_eeprom(dev);
1029 if (dev->chipid == ID_REV_CHIP_ID_7800_)
1030 ret = lan78xx_write_reg(dev, HW_CFG, saved);
1035 static int lan78xx_read_raw_otp(struct lan78xx_net *dev, u32 offset,
1042 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1046 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1051 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1053 netdev_warn(dev->net,
1061 lan78xx_write_reg(dev, OTP_ADDR1,
1063 lan78xx_write_reg(dev, OTP_ADDR2,
1066 lan78xx_write_reg(dev, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
1067 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1072 lan78xx_read_reg(dev, OTP_STATUS, &buf);
1074 netdev_warn(dev->net,
1080 lan78xx_read_reg(dev, OTP_RD_DATA, &buf);
1088 static int lan78xx_write_raw_otp(struct lan78xx_net *dev, u32 offset,
1095 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1099 lan78xx_write_reg(dev, OTP_PWR_DN, 0);
1104 lan78xx_read_reg(dev, OTP_PWR_DN, &buf);
1106 netdev_warn(dev->net,
1114 lan78xx_write_reg(dev, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
1117 lan78xx_write_reg(dev, OTP_ADDR1,
1119 lan78xx_write_reg(dev, OTP_ADDR2,
1121 lan78xx_write_reg(dev, OTP_PRGM_DATA, data[i]);
1122 lan78xx_write_reg(dev, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
1123 lan78xx_write_reg(dev, OTP_CMD_GO, OTP_CMD_GO_GO_);
1128 lan78xx_read_reg(dev, OTP_STATUS, &buf);
1130 netdev_warn(dev->net,
1140 static int lan78xx_read_otp(struct lan78xx_net *dev, u32 offset,
1146 ret = lan78xx_read_raw_otp(dev, 0, 1, &sig);
1154 ret = lan78xx_read_raw_otp(dev, offset, length, data);
1160 static int lan78xx_dataport_wait_not_busy(struct lan78xx_net *dev)
1167 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1177 netdev_warn(dev->net, "%s timed out", __func__);
1182 static int lan78xx_dataport_write(struct lan78xx_net *dev, u32 ram_select,
1185 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1189 if (usb_autopm_get_interface(dev->intf) < 0)
1194 ret = lan78xx_dataport_wait_not_busy(dev);
1198 ret = lan78xx_read_reg(dev, DP_SEL, &dp_sel);
1202 ret = lan78xx_write_reg(dev, DP_SEL, dp_sel);
1205 ret = lan78xx_write_reg(dev, DP_ADDR, addr + i);
1207 ret = lan78xx_write_reg(dev, DP_DATA, buf[i]);
1209 ret = lan78xx_write_reg(dev, DP_CMD, DP_CMD_WRITE_);
1211 ret = lan78xx_dataport_wait_not_busy(dev);
1218 usb_autopm_put_interface(dev->intf);
1251 struct lan78xx_net *dev = pdata->dev;
1254 netif_dbg(dev, drv, dev->net, "deferred multicast write 0x%08x\n",
1257 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, DP_SEL_VHF_VLAN_LEN,
1261 lan78xx_write_reg(dev, MAF_HI(i), 0);
1262 lan78xx_write_reg(dev, MAF_LO(i),
1264 lan78xx_write_reg(dev, MAF_HI(i),
1268 lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
1273 struct lan78xx_net *dev = netdev_priv(netdev);
1274 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1294 if (dev->net->flags & IFF_PROMISC) {
1295 netif_dbg(dev, drv, dev->net, "promiscuous mode enabled");
1298 if (dev->net->flags & IFF_ALLMULTI) {
1299 netif_dbg(dev, drv, dev->net,
1305 if (netdev_mc_count(dev->net)) {
1309 netif_dbg(dev, drv, dev->net, "receive multicast hash filter");
1335 static int lan78xx_update_flowcontrol(struct lan78xx_net *dev, u8 duplex,
1341 if (dev->fc_autoneg)
1344 cap = dev->fc_request_control;
1352 if (dev->udev->speed == USB_SPEED_SUPER)
1354 else if (dev->udev->speed == USB_SPEED_HIGH)
1357 netif_dbg(dev, link, dev->net, "rx pause %s, tx pause %s",
1361 lan78xx_write_reg(dev, FCT_FLOW, fct_flow);
1364 lan78xx_write_reg(dev, FLOW, flow);
1369 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev);
1371 static int lan78xx_mac_reset(struct lan78xx_net *dev)
1377 mutex_lock(&dev->phy_mutex);
1383 ret = lan78xx_phy_wait_not_busy(dev);
1387 ret = lan78xx_read_reg(dev, MAC_CR, &val);
1392 ret = lan78xx_write_reg(dev, MAC_CR, val);
1400 ret = lan78xx_read_reg(dev, MAC_CR, &val);
1412 mutex_unlock(&dev->phy_mutex);
1417 static int lan78xx_link_reset(struct lan78xx_net *dev)
1419 struct phy_device *phydev = dev->net->phydev;
1425 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_PHY_INT_);
1434 if (!link && dev->link_on) {
1435 dev->link_on = false;
1438 ret = lan78xx_mac_reset(dev);
1442 del_timer(&dev->stat_monitor);
1443 } else if (link && !dev->link_on) {
1444 dev->link_on = true;
1448 if (dev->udev->speed == USB_SPEED_SUPER) {
1451 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1455 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1459 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1463 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1468 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
1473 ret = lan78xx_write_reg(dev, USB_CFG1, buf);
1487 netif_dbg(dev, link, dev->net,
1491 ret = lan78xx_update_flowcontrol(dev, ecmd.base.duplex, ladv,
1496 if (!timer_pending(&dev->stat_monitor)) {
1497 dev->delta = 1;
1498 mod_timer(&dev->stat_monitor,
1502 lan78xx_rx_urb_submit_all(dev);
1505 napi_schedule(&dev->napi);
1517 static void lan78xx_defer_kevent(struct lan78xx_net *dev, int work)
1519 set_bit(work, &dev->flags);
1520 if (!schedule_delayed_work(&dev->wq, 0))
1521 netdev_err(dev->net, "kevent %d may have been dropped\n", work);
1524 static void lan78xx_status(struct lan78xx_net *dev, struct urb *urb)
1529 netdev_warn(dev->net,
1537 netif_dbg(dev, link, dev->net, "PHY INTR: 0x%08x\n", intdata);
1538 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
1540 if (dev->domain_data.phyirq > 0)
1541 generic_handle_irq_safe(dev->domain_data.phyirq);
1543 netdev_warn(dev->net,
1556 struct lan78xx_net *dev = netdev_priv(netdev);
1559 ret = usb_autopm_get_interface(dev->intf);
1565 ret = lan78xx_read_raw_eeprom(dev, ee->offset, ee->len, data);
1567 usb_autopm_put_interface(dev->intf);
1575 struct lan78xx_net *dev = netdev_priv(netdev);
1578 ret = usb_autopm_get_interface(dev->intf);
1586 ret = lan78xx_write_raw_eeprom(dev, ee->offset, ee->len, data);
1591 ret = lan78xx_write_raw_otp(dev, ee->offset, ee->len, data);
1593 usb_autopm_put_interface(dev->intf);
1616 struct lan78xx_net *dev = netdev_priv(netdev);
1618 lan78xx_update_stats(dev);
1620 mutex_lock(&dev->stats.access_lock);
1621 memcpy(data, &dev->stats.curr_stat, sizeof(dev->stats.curr_stat));
1622 mutex_unlock(&dev->stats.access_lock);
1628 struct lan78xx_net *dev = netdev_priv(netdev);
1631 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1633 if (usb_autopm_get_interface(dev->intf) < 0)
1636 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
1650 usb_autopm_put_interface(dev->intf);
1656 struct lan78xx_net *dev = netdev_priv(netdev);
1657 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
1660 ret = usb_autopm_get_interface(dev->intf);
1669 device_set_wakeup_enable(&dev->udev->dev, (bool)wol->wolopts);
1673 usb_autopm_put_interface(dev->intf);
1680 struct lan78xx_net *dev = netdev_priv(net);
1685 ret = usb_autopm_get_interface(dev->intf);
1693 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1700 ret = lan78xx_read_reg(dev, EEE_TX_LPI_REQ_DLY, &buf);
1711 usb_autopm_put_interface(dev->intf);
1718 struct lan78xx_net *dev = netdev_priv(net);
1722 ret = usb_autopm_get_interface(dev->intf);
1727 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1729 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1734 ret = lan78xx_write_reg(dev, EEE_TX_LPI_REQ_DLY, buf);
1736 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
1738 ret = lan78xx_write_reg(dev, MAC_CR, buf);
1741 usb_autopm_put_interface(dev->intf);
1761 struct lan78xx_net *dev = netdev_priv(net);
1764 usb_make_path(dev->udev, info->bus_info, sizeof(info->bus_info));
1769 struct lan78xx_net *dev = netdev_priv(net);
1771 return dev->msg_enable;
1776 struct lan78xx_net *dev = netdev_priv(net);
1778 dev->msg_enable = level;
1784 struct lan78xx_net *dev = netdev_priv(net);
1788 ret = usb_autopm_get_interface(dev->intf);
1794 usb_autopm_put_interface(dev->intf);
1802 struct lan78xx_net *dev = netdev_priv(net);
1807 ret = usb_autopm_get_interface(dev->intf);
1822 usb_autopm_put_interface(dev->intf);
1830 struct lan78xx_net *dev = netdev_priv(net);
1836 pause->autoneg = dev->fc_autoneg;
1838 if (dev->fc_request_control & FLOW_CTRL_TX)
1841 if (dev->fc_request_control & FLOW_CTRL_RX)
1848 struct lan78xx_net *dev = netdev_priv(net);
1860 dev->fc_request_control = 0;
1862 dev->fc_request_control |= FLOW_CTRL_RX;
1865 dev->fc_request_control |= FLOW_CTRL_TX;
1875 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
1883 dev->fc_autoneg = pause->autoneg;
1904 struct lan78xx_net *dev = netdev_priv(netdev);
1908 lan78xx_read_reg(dev, lan78xx_regs[i], &data[i]);
1943 static void lan78xx_init_mac_address(struct lan78xx_net *dev)
1948 lan78xx_read_reg(dev, RX_ADDRL, &addr_lo);
1949 lan78xx_read_reg(dev, RX_ADDRH, &addr_hi);
1959 if (!eth_platform_get_mac_address(&dev->udev->dev, addr)) {
1961 netif_dbg(dev, ifup, dev->net,
1963 } else if (((lan78xx_read_eeprom(dev, EEPROM_MAC_OFFSET,
1965 (lan78xx_read_otp(dev, EEPROM_MAC_OFFSET,
1969 netif_dbg(dev, ifup, dev->net,
1974 netif_dbg(dev, ifup, dev->net,
1982 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
1983 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
1986 lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
1987 lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
1989 eth_hw_addr_set(dev->net, addr);
1995 struct lan78xx_net *dev = bus->priv;
1999 ret = usb_autopm_get_interface(dev->intf);
2003 mutex_lock(&dev->phy_mutex);
2006 ret = lan78xx_phy_wait_not_busy(dev);
2012 ret = lan78xx_write_reg(dev, MII_ACC, addr);
2014 ret = lan78xx_phy_wait_not_busy(dev);
2018 ret = lan78xx_read_reg(dev, MII_DATA, &val);
2023 mutex_unlock(&dev->phy_mutex);
2024 usb_autopm_put_interface(dev->intf);
2032 struct lan78xx_net *dev = bus->priv;
2036 ret = usb_autopm_get_interface(dev->intf);
2040 mutex_lock(&dev->phy_mutex);
2043 ret = lan78xx_phy_wait_not_busy(dev);
2048 ret = lan78xx_write_reg(dev, MII_DATA, val);
2052 ret = lan78xx_write_reg(dev, MII_ACC, addr);
2054 ret = lan78xx_phy_wait_not_busy(dev);
2059 mutex_unlock(&dev->phy_mutex);
2060 usb_autopm_put_interface(dev->intf);
2064 static int lan78xx_mdio_init(struct lan78xx_net *dev)
2069 dev->mdiobus = mdiobus_alloc();
2070 if (!dev->mdiobus) {
2071 netdev_err(dev->net, "can't allocate MDIO bus\n");
2075 dev->mdiobus->priv = (void *)dev;
2076 dev->mdiobus->read = lan78xx_mdiobus_read;
2077 dev->mdiobus->write = lan78xx_mdiobus_write;
2078 dev->mdiobus->name = "lan78xx-mdiobus";
2079 dev->mdiobus->parent = &dev->udev->dev;
2081 snprintf(dev->mdiobus->id, MII_BUS_ID_SIZE, "usb-%03d:%03d",
2082 dev->udev->bus->busnum, dev->udev->devnum);
2084 switch (dev->chipid) {
2088 dev->mdiobus->phy_mask = ~(1 << 1);
2092 dev->mdiobus->phy_mask = ~(0xFF);
2096 node = of_get_child_by_name(dev->udev->dev.of_node, "mdio");
2097 ret = of_mdiobus_register(dev->mdiobus, node);
2100 netdev_err(dev->net, "can't register MDIO bus\n");
2104 netdev_dbg(dev->net, "registered mdiobus bus %s\n", dev->mdiobus->id);
2107 mdiobus_free(dev->mdiobus);
2111 static void lan78xx_remove_mdio(struct lan78xx_net *dev)
2113 mdiobus_unregister(dev->mdiobus);
2114 mdiobus_free(dev->mdiobus);
2171 struct lan78xx_net *dev =
2178 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2180 lan78xx_write_reg(dev, INT_EP_CTL, data->irqenable);
2193 static int lan78xx_setup_irq_domain(struct lan78xx_net *dev)
2201 of_node = dev->udev->dev.parent->of_node;
2203 mutex_init(&dev->domain_data.irq_lock);
2205 lan78xx_read_reg(dev, INT_EP_CTL, &buf);
2206 dev->domain_data.irqenable = buf;
2208 dev->domain_data.irqchip = &lan78xx_irqchip;
2209 dev->domain_data.irq_handler = handle_simple_irq;
2212 &chip_domain_ops, &dev->domain_data);
2226 dev->domain_data.irqdomain = irqdomain;
2227 dev->domain_data.phyirq = irqmap;
2232 static void lan78xx_remove_irq_domain(struct lan78xx_net *dev)
2234 if (dev->domain_data.phyirq > 0) {
2235 irq_dispose_mapping(dev->domain_data.phyirq);
2237 if (dev->domain_data.irqdomain)
2238 irq_domain_remove(dev->domain_data.irqdomain);
2240 dev->domain_data.phyirq = 0;
2241 dev->domain_data.irqdomain = NULL;
2247 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2256 lan78xx_write_reg(dev, MAC_RGMII_ID,
2260 lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2262 dev->interface = PHY_INTERFACE_MODE_RGMII_TXID;
2269 struct lan78xx_net *dev = netdev_priv(phydev->attached_dev);
2279 dev->interface = PHY_INTERFACE_MODE_RGMII_RXID;
2284 static struct phy_device *lan7801_phy_init(struct lan78xx_net *dev)
2295 phydev = phy_find_first(dev->mdiobus);
2297 netdev_dbg(dev->net, "PHY Not Found!! Registering Fixed PHY\n");
2300 netdev_err(dev->net, "No PHY/fixed_PHY found\n");
2303 netdev_dbg(dev->net, "Registered FIXED PHY\n");
2304 dev->interface = PHY_INTERFACE_MODE_RGMII;
2305 ret = lan78xx_write_reg(dev, MAC_RGMII_ID,
2307 ret = lan78xx_write_reg(dev, RGMII_TX_BYP_DLL, 0x3D00);
2308 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2311 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2314 netdev_err(dev->net, "no PHY driver found\n");
2317 dev->interface = PHY_INTERFACE_MODE_RGMII;
2322 netdev_err(dev->net, "Failed to register fixup for PHY_KSZ9031RNX\n");
2329 netdev_err(dev->net, "Failed to register fixup for PHY_LAN8835\n");
2339 static int lan78xx_phy_init(struct lan78xx_net *dev)
2346 switch (dev->chipid) {
2348 phydev = lan7801_phy_init(dev);
2350 netdev_err(dev->net, "lan7801: PHY Init Failed");
2357 phydev = phy_find_first(dev->mdiobus);
2359 netdev_err(dev->net, "no PHY found\n");
2363 dev->interface = PHY_INTERFACE_MODE_GMII;
2367 netdev_err(dev->net, "Unknown CHIP ID found\n");
2372 if (dev->domain_data.phyirq > 0)
2373 phydev->irq = dev->domain_data.phyirq;
2376 netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2381 ret = phy_connect_direct(dev->net, phydev,
2383 dev->interface);
2385 netdev_err(dev->net, "can't attach PHY to %s\n",
2386 dev->mdiobus->id);
2387 if (dev->chipid == ID_REV_CHIP_ID_7801_) {
2404 dev->fc_request_control = (FLOW_CTRL_RX | FLOW_CTRL_TX);
2409 mii_adv = (u32)mii_advertise_flowctrl(dev->fc_request_control);
2413 if (phydev->mdio.dev.of_node) {
2417 len = of_property_count_elems_of_size(phydev->mdio.dev.of_node,
2422 lan78xx_read_reg(dev, HW_CFG, ®);
2431 lan78xx_write_reg(dev, HW_CFG, reg);
2437 dev->fc_autoneg = phydev->autoneg;
2442 static int lan78xx_set_rx_max_frame_length(struct lan78xx_net *dev, int size)
2447 lan78xx_read_reg(dev, MAC_RX, &buf);
2453 lan78xx_write_reg(dev, MAC_RX, buf);
2460 lan78xx_write_reg(dev, MAC_RX, buf);
2464 lan78xx_write_reg(dev, MAC_RX, buf);
2470 static int unlink_urbs(struct lan78xx_net *dev, struct sk_buff_head *q)
2505 netdev_dbg(dev->net, "unlink urb err, %d\n", ret);
2517 struct lan78xx_net *dev = netdev_priv(netdev);
2522 if ((max_frame_len % dev->maxpacket) == 0)
2525 ret = usb_autopm_get_interface(dev->intf);
2529 ret = lan78xx_set_rx_max_frame_length(dev, max_frame_len);
2533 usb_autopm_put_interface(dev->intf);
2540 struct lan78xx_net *dev = netdev_priv(netdev);
2559 lan78xx_write_reg(dev, RX_ADDRL, addr_lo);
2560 lan78xx_write_reg(dev, RX_ADDRH, addr_hi);
2563 lan78xx_write_reg(dev, MAF_LO(0), addr_lo);
2564 lan78xx_write_reg(dev, MAF_HI(0), addr_hi | MAF_HI_VALID_);
2573 struct lan78xx_net *dev = netdev_priv(netdev);
2574 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2599 lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
2608 struct lan78xx_net *dev = pdata->dev;
2610 lan78xx_dataport_write(dev, DP_SEL_RSEL_VLAN_DA_, 0,
2617 struct lan78xx_net *dev = netdev_priv(netdev);
2618 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2636 struct lan78xx_net *dev = netdev_priv(netdev);
2637 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2652 static void lan78xx_init_ltm(struct lan78xx_net *dev)
2658 ret = lan78xx_read_reg(dev, USB_CFG1, &buf);
2662 if (lan78xx_read_eeprom(dev, 0x3F, 2, temp) == 0) {
2664 ret = lan78xx_read_raw_eeprom(dev,
2671 } else if (lan78xx_read_otp(dev, 0x3F, 2, temp) == 0) {
2673 ret = lan78xx_read_raw_otp(dev,
2683 lan78xx_write_reg(dev, LTM_BELT_IDLE0, regs[0]);
2684 lan78xx_write_reg(dev, LTM_BELT_IDLE1, regs[1]);
2685 lan78xx_write_reg(dev, LTM_BELT_ACT0, regs[2]);
2686 lan78xx_write_reg(dev, LTM_BELT_ACT1, regs[3]);
2687 lan78xx_write_reg(dev, LTM_INACTIVE0, regs[4]);
2688 lan78xx_write_reg(dev, LTM_INACTIVE1, regs[5]);
2691 static int lan78xx_urb_config_init(struct lan78xx_net *dev)
2695 switch (dev->udev->speed) {
2697 dev->rx_urb_size = RX_SS_URB_SIZE;
2698 dev->tx_urb_size = TX_SS_URB_SIZE;
2699 dev->n_rx_urbs = RX_SS_URB_NUM;
2700 dev->n_tx_urbs = TX_SS_URB_NUM;
2701 dev->bulk_in_delay = SS_BULK_IN_DELAY;
2702 dev->burst_cap = SS_BURST_CAP_SIZE / SS_USB_PKT_SIZE;
2705 dev->rx_urb_size = RX_HS_URB_SIZE;
2706 dev->tx_urb_size = TX_HS_URB_SIZE;
2707 dev->n_rx_urbs = RX_HS_URB_NUM;
2708 dev->n_tx_urbs = TX_HS_URB_NUM;
2709 dev->bulk_in_delay = HS_BULK_IN_DELAY;
2710 dev->burst_cap = HS_BURST_CAP_SIZE / HS_USB_PKT_SIZE;
2713 dev->rx_urb_size = RX_FS_URB_SIZE;
2714 dev->tx_urb_size = TX_FS_URB_SIZE;
2715 dev->n_rx_urbs = RX_FS_URB_NUM;
2716 dev->n_tx_urbs = TX_FS_URB_NUM;
2717 dev->bulk_in_delay = FS_BULK_IN_DELAY;
2718 dev->burst_cap = FS_BURST_CAP_SIZE / FS_USB_PKT_SIZE;
2721 netdev_warn(dev->net, "USB bus speed not supported\n");
2729 static int lan78xx_start_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enable)
2731 return lan78xx_update_reg(dev, reg, hw_enable, hw_enable);
2734 static int lan78xx_stop_hw(struct lan78xx_net *dev, u32 reg, u32 hw_enabled,
2744 ret = lan78xx_read_reg(dev, reg, &buf);
2751 ret = lan78xx_write_reg(dev, reg, buf);
2758 ret = lan78xx_read_reg(dev, reg, &buf);
2774 static int lan78xx_flush_fifo(struct lan78xx_net *dev, u32 reg, u32 fifo_flush)
2776 return lan78xx_update_reg(dev, reg, fifo_flush, fifo_flush);
2779 static int lan78xx_start_tx_path(struct lan78xx_net *dev)
2783 netif_dbg(dev, drv, dev->net, "start tx path");
2787 ret = lan78xx_start_hw(dev, MAC_TX, MAC_TX_TXEN_);
2793 ret = lan78xx_start_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_);
2800 static int lan78xx_stop_tx_path(struct lan78xx_net *dev)
2804 netif_dbg(dev, drv, dev->net, "stop tx path");
2808 ret = lan78xx_stop_hw(dev, FCT_TX_CTL, FCT_TX_CTL_EN_, FCT_TX_CTL_DIS_);
2814 ret = lan78xx_stop_hw(dev, MAC_TX, MAC_TX_TXEN_, MAC_TX_TXD_);
2824 static int lan78xx_flush_tx_fifo(struct lan78xx_net *dev)
2826 return lan78xx_flush_fifo(dev, FCT_TX_CTL, FCT_TX_CTL_RST_);
2829 static int lan78xx_start_rx_path(struct lan78xx_net *dev)
2833 netif_dbg(dev, drv, dev->net, "start rx path");
2837 ret = lan78xx_start_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_);
2843 ret = lan78xx_start_hw(dev, MAC_RX, MAC_RX_RXEN_);
2850 static int lan78xx_stop_rx_path(struct lan78xx_net *dev)
2854 netif_dbg(dev, drv, dev->net, "stop rx path");
2858 ret = lan78xx_stop_hw(dev, MAC_RX, MAC_RX_RXEN_, MAC_RX_RXD_);
2864 ret = lan78xx_stop_hw(dev, FCT_RX_CTL, FCT_RX_CTL_EN_, FCT_RX_CTL_DIS_);
2874 static int lan78xx_flush_rx_fifo(struct lan78xx_net *dev)
2876 return lan78xx_flush_fifo(dev, FCT_RX_CTL, FCT_RX_CTL_RST_);
2879 static int lan78xx_reset(struct lan78xx_net *dev)
2881 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
2887 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2893 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2900 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2905 netdev_warn(dev->net,
2912 lan78xx_init_mac_address(dev);
2915 ret = lan78xx_read_reg(dev, ID_REV, &buf);
2919 dev->chipid = (buf & ID_REV_CHIP_ID_MASK_) >> 16;
2920 dev->chiprev = buf & ID_REV_CHIP_REV_MASK_;
2923 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2929 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2934 lan78xx_init_ltm(dev);
2936 ret = lan78xx_write_reg(dev, BURST_CAP, dev->burst_cap);
2940 ret = lan78xx_write_reg(dev, BULK_IN_DLY, dev->bulk_in_delay);
2944 ret = lan78xx_read_reg(dev, HW_CFG, &buf);
2950 ret = lan78xx_write_reg(dev, HW_CFG, buf);
2954 ret = lan78xx_read_reg(dev, USB_CFG0, &buf);
2960 ret = lan78xx_write_reg(dev, USB_CFG0, buf);
2967 ret = lan78xx_write_reg(dev, FCT_RX_FIFO_END, buf);
2973 ret = lan78xx_write_reg(dev, FCT_TX_FIFO_END, buf);
2977 ret = lan78xx_write_reg(dev, INT_STS, INT_STS_CLEAR_ALL_);
2981 ret = lan78xx_write_reg(dev, FLOW, 0);
2985 ret = lan78xx_write_reg(dev, FCT_FLOW, 0);
2990 ret = lan78xx_read_reg(dev, RFE_CTL, &pdata->rfe_ctl);
2996 ret = lan78xx_write_reg(dev, RFE_CTL, pdata->rfe_ctl);
3001 ret = lan78xx_set_features(dev->net, dev->net->features);
3005 lan78xx_set_multicast(dev->net);
3008 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3014 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
3021 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
3026 netdev_warn(dev->net, "timeout waiting for PHY Reset");
3032 ret = lan78xx_read_reg(dev, MAC_CR, &buf);
3037 if (dev->chipid == ID_REV_CHIP_ID_7801_)
3040 if (dev->chipid == ID_REV_CHIP_ID_7800_ ||
3041 dev->chipid == ID_REV_CHIP_ID_7850_) {
3042 ret = lan78xx_read_raw_eeprom(dev, 0, 1, &sig);
3045 netdev_info(dev->net, "No External EEPROM. Setting MAC Speed\n");
3049 ret = lan78xx_write_reg(dev, MAC_CR, buf);
3053 ret = lan78xx_set_rx_max_frame_length(dev,
3054 RX_MAX_FRAME_LEN(dev->net->mtu));
3059 static void lan78xx_init_stats(struct lan78xx_net *dev)
3067 p = (u32 *)&dev->stats.rollover_max;
3068 for (i = 0; i < (sizeof(dev->stats.rollover_max) / (sizeof(u32))); i++)
3071 dev->stats.rollover_max.rx_unicast_byte_count = 0xFFFFFFFF;
3072 dev->stats.rollover_max.rx_broadcast_byte_count = 0xFFFFFFFF;
3073 dev->stats.rollover_max.rx_multicast_byte_count = 0xFFFFFFFF;
3074 dev->stats.rollover_max.eee_rx_lpi_transitions = 0xFFFFFFFF;
3075 dev->stats.rollover_max.eee_rx_lpi_time = 0xFFFFFFFF;
3076 dev->stats.rollover_max.tx_unicast_byte_count = 0xFFFFFFFF;
3077 dev->stats.rollover_max.tx_broadcast_byte_count = 0xFFFFFFFF;
3078 dev->stats.rollover_max.tx_multicast_byte_count = 0xFFFFFFFF;
3079 dev->stats.rollover_max.eee_tx_lpi_transitions = 0xFFFFFFFF;
3080 dev->stats.rollover_max.eee_tx_lpi_time = 0xFFFFFFFF;
3082 set_bit(EVENT_STAT_UPDATE, &dev->flags);
3087 struct lan78xx_net *dev = netdev_priv(net);
3090 netif_dbg(dev, ifup, dev->net, "open device");
3092 ret = usb_autopm_get_interface(dev->intf);
3096 mutex_lock(&dev->dev_mutex);
3100 netif_dbg(dev, ifup, dev->net, "phy initialised successfully");
3103 if (dev->urb_intr) {
3104 ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
3106 netif_err(dev, ifup, dev->net,
3112 ret = lan78xx_flush_rx_fifo(dev);
3115 ret = lan78xx_flush_tx_fifo(dev);
3119 ret = lan78xx_start_tx_path(dev);
3122 ret = lan78xx_start_rx_path(dev);
3126 lan78xx_init_stats(dev);
3128 set_bit(EVENT_DEV_OPEN, &dev->flags);
3132 dev->link_on = false;
3134 napi_enable(&dev->napi);
3136 lan78xx_defer_kevent(dev, EVENT_LINK_RESET);
3138 mutex_unlock(&dev->dev_mutex);
3141 usb_autopm_put_interface(dev->intf);
3146 static void lan78xx_terminate_urbs(struct lan78xx_net *dev)
3155 dev->wait = &unlink_wakeup;
3156 temp = unlink_urbs(dev, &dev->txq) + unlink_urbs(dev, &dev->rxq);
3159 while (!skb_queue_empty(&dev->rxq) ||
3160 !skb_queue_empty(&dev->txq)) {
3163 netif_dbg(dev, ifdown, dev->net,
3167 dev->wait = NULL;
3172 while (!skb_queue_empty(&dev->rxq_done)) {
3173 struct sk_buff *skb = skb_dequeue(&dev->rxq_done);
3175 lan78xx_release_rx_buf(dev, skb);
3178 skb_queue_purge(&dev->rxq_overflow);
3179 skb_queue_purge(&dev->txq_pend);
3184 struct lan78xx_net *dev = netdev_priv(net);
3186 netif_dbg(dev, ifup, dev->net, "stop device");
3188 mutex_lock(&dev->dev_mutex);
3190 if (timer_pending(&dev->stat_monitor))
3191 del_timer_sync(&dev->stat_monitor);
3193 clear_bit(EVENT_DEV_OPEN, &dev->flags);
3195 napi_disable(&dev->napi);
3197 lan78xx_terminate_urbs(dev);
3199 netif_info(dev, ifdown, dev->net,
3205 lan78xx_stop_tx_path(dev);
3206 lan78xx_stop_rx_path(dev);
3211 usb_kill_urb(dev->urb_intr);
3217 clear_bit(EVENT_TX_HALT, &dev->flags);
3218 clear_bit(EVENT_RX_HALT, &dev->flags);
3219 clear_bit(EVENT_LINK_RESET, &dev->flags);
3220 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
3222 cancel_delayed_work_sync(&dev->wq);
3224 usb_autopm_put_interface(dev->intf);
3226 mutex_unlock(&dev->dev_mutex);
3231 static enum skb_state defer_bh(struct lan78xx_net *dev, struct sk_buff *skb,
3244 spin_lock(&dev->rxq_done.lock);
3246 __skb_queue_tail(&dev->rxq_done, skb);
3247 if (skb_queue_len(&dev->rxq_done) == 1)
3248 napi_schedule(&dev->napi);
3250 spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
3259 struct lan78xx_net *dev = entry->dev;
3262 dev->net->stats.tx_packets += entry->num_of_packet;
3263 dev->net->stats.tx_bytes += entry->length;
3265 dev->net->stats.tx_errors += entry->num_of_packet;
3269 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3275 netif_dbg(dev, tx_err, dev->net,
3283 netif_stop_queue(dev->net);
3284 netif_dbg(dev, tx_err, dev->net,
3289 netif_dbg(dev, tx_err, dev->net,
3296 usb_autopm_put_interface_async(dev->intf);
3298 skb_unlink(skb, &dev->txq);
3300 lan78xx_release_tx_buf(dev, skb);
3304 if (skb_queue_empty(&dev->txq) &&
3305 !skb_queue_empty(&dev->txq_pend))
3306 napi_schedule(&dev->napi);
3318 static unsigned int lan78xx_tx_urb_space(struct lan78xx_net *dev)
3320 return skb_queue_len(&dev->txq_free) * dev->tx_urb_size;
3323 static unsigned int lan78xx_tx_pend_data_len(struct lan78xx_net *dev)
3325 return dev->tx_pend_data_len;
3328 static void lan78xx_tx_pend_skb_add(struct lan78xx_net *dev,
3334 spin_lock_irqsave(&dev->txq_pend.lock, flags);
3336 __skb_queue_tail(&dev->txq_pend, skb);
3338 dev->tx_pend_data_len += skb->len;
3339 *tx_pend_data_len = dev->tx_pend_data_len;
3341 spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3344 static void lan78xx_tx_pend_skb_head_add(struct lan78xx_net *dev,
3350 spin_lock_irqsave(&dev->txq_pend.lock, flags);
3352 __skb_queue_head(&dev->txq_pend, skb);
3354 dev->tx_pend_data_len += skb->len;
3355 *tx_pend_data_len = dev->tx_pend_data_len;
3357 spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3360 static void lan78xx_tx_pend_skb_get(struct lan78xx_net *dev,
3366 spin_lock_irqsave(&dev->txq_pend.lock, flags);
3368 *skb = __skb_dequeue(&dev->txq_pend);
3370 dev->tx_pend_data_len -= (*skb)->len;
3371 *tx_pend_data_len = dev->tx_pend_data_len;
3373 spin_unlock_irqrestore(&dev->txq_pend.lock, flags);
3379 struct lan78xx_net *dev = netdev_priv(net);
3382 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags))
3383 schedule_delayed_work(&dev->wq, 0);
3387 lan78xx_tx_pend_skb_add(dev, skb, &tx_pend_data_len);
3391 if (skb_queue_empty(&dev->txq))
3392 napi_schedule(&dev->napi);
3397 if (tx_pend_data_len > lan78xx_tx_urb_space(dev)) {
3400 netif_dbg(dev, hw, dev->net, "tx data len: %u, urb space %u",
3401 tx_pend_data_len, lan78xx_tx_urb_space(dev));
3405 if (!skb_queue_empty(&dev->txq_free))
3406 napi_schedule(&dev->napi);
3412 static int lan78xx_bind(struct lan78xx_net *dev, struct usb_interface *intf)
3418 dev->data[0] = (unsigned long)kzalloc(sizeof(*pdata), GFP_KERNEL);
3420 pdata = (struct lan78xx_priv *)(dev->data[0]);
3422 netdev_warn(dev->net, "Unable to allocate lan78xx_priv");
3426 pdata->dev = dev;
3438 dev->net->features = 0;
3441 dev->net->features |= NETIF_F_HW_CSUM;
3444 dev->net->features |= NETIF_F_RXCSUM;
3447 dev->net->features |= NETIF_F_TSO | NETIF_F_TSO6 | NETIF_F_SG;
3450 dev->net->features |= NETIF_F_HW_VLAN_CTAG_RX;
3453 dev->net->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
3455 dev->net->hw_features = dev->net->features;
3457 ret = lan78xx_setup_irq_domain(dev);
3459 netdev_warn(dev->net,
3465 ret = lan78xx_reset(dev);
3467 netdev_warn(dev->net, "Registers INIT FAILED....");
3471 ret = lan78xx_mdio_init(dev);
3473 netdev_warn(dev->net, "MDIO INIT FAILED.....");
3477 dev->net->flags |= IFF_MULTICAST;
3484 lan78xx_remove_irq_domain(dev);
3487 netdev_warn(dev->net, "Bind routine FAILED");
3494 static void lan78xx_unbind(struct lan78xx_net *dev, struct usb_interface *intf)
3496 struct lan78xx_priv *pdata = (struct lan78xx_priv *)(dev->data[0]);
3498 lan78xx_remove_irq_domain(dev);
3500 lan78xx_remove_mdio(dev);
3505 netif_dbg(dev, ifdown, dev->net, "free pdata");
3508 dev->data[0] = 0;
3512 static void lan78xx_rx_csum_offload(struct lan78xx_net *dev,
3519 if (!(dev->net->features & NETIF_F_RXCSUM) ||
3522 !(dev->net->features & NETIF_F_HW_VLAN_CTAG_RX))) {
3530 static void lan78xx_rx_vlan_offload(struct lan78xx_net *dev,
3534 if ((dev->net->features & NETIF_F_HW_VLAN_CTAG_RX) &&
3540 static void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
3542 dev->net->stats.rx_packets++;
3543 dev->net->stats.rx_bytes += skb->len;
3545 skb->protocol = eth_type_trans(skb, dev->net);
3547 netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
3554 napi_gro_receive(&dev->napi, skb);
3557 static int lan78xx_rx(struct lan78xx_net *dev, struct sk_buff *skb,
3587 netif_dbg(dev, rx_err, dev->net,
3594 netif_dbg(dev, rx_err, dev->net,
3601 netif_dbg(dev, rx_err, dev->net,
3609 skb2 = napi_alloc_skb(&dev->napi, frame_len);
3617 lan78xx_rx_csum_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3618 lan78xx_rx_vlan_offload(dev, skb2, rx_cmd_a, rx_cmd_b);
3626 lan78xx_skb_return(dev, skb2);
3629 skb_queue_tail(&dev->rxq_overflow, skb2);
3643 static inline void rx_process(struct lan78xx_net *dev, struct sk_buff *skb,
3646 if (!lan78xx_rx(dev, skb, budget, work_done)) {
3647 netif_dbg(dev, rx_err, dev->net, "drop\n");
3648 dev->net->stats.rx_errors++;
3656 struct lan78xx_net *dev = entry->dev;
3660 netif_dbg(dev, rx_status, dev->net,
3667 netif_warn(dev, rx_err, dev->net, "URB pointer mismatch");
3673 dev->net->stats.rx_errors++;
3674 dev->net->stats.rx_length_errors++;
3675 netif_dbg(dev, rx_err, dev->net,
3678 usb_mark_last_busy(dev->udev);
3681 dev->net->stats.rx_errors++;
3682 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3686 netif_dbg(dev, ifdown, dev->net,
3693 dev->net->stats.rx_errors++;
3699 dev->net->stats.rx_over_errors++;
3704 dev->net->stats.rx_errors++;
3705 netif_dbg(dev, rx_err, dev->net, "rx status %d\n", urb_status);
3709 state = defer_bh(dev, skb, &dev->rxq, state);
3712 static int rx_submit(struct lan78xx_net *dev, struct sk_buff *skb, gfp_t flags)
3715 size_t size = dev->rx_urb_size;
3720 usb_fill_bulk_urb(urb, dev->udev, dev->pipe_in,
3723 spin_lock_irqsave(&dev->rxq.lock, lockflags);
3725 if (netif_device_present(dev->net) &&
3726 netif_running(dev->net) &&
3727 !test_bit(EVENT_RX_HALT, &dev->flags) &&
3728 !test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3732 lan78xx_queue_skb(&dev->rxq, skb, rx_start);
3735 lan78xx_defer_kevent(dev, EVENT_RX_HALT);
3739 netif_dbg(dev, ifdown, dev->net, "device gone\n");
3740 netif_device_detach(dev->net);
3744 napi_schedule(&dev->napi);
3747 netif_dbg(dev, rx_err, dev->net,
3749 napi_schedule(&dev->napi);
3753 netif_dbg(dev, ifdown, dev->net, "rx: stopped\n");
3756 spin_unlock_irqrestore(&dev->rxq.lock, lockflags);
3759 lan78xx_release_rx_buf(dev, skb);
3764 static void lan78xx_rx_urb_submit_all(struct lan78xx_net *dev)
3770 while ((rx_buf = lan78xx_get_rx_buf(dev)) != NULL) {
3771 if (rx_submit(dev, rx_buf, GFP_ATOMIC) != 0)
3776 static void lan78xx_rx_urb_resubmit(struct lan78xx_net *dev,
3786 rx_submit(dev, rx_buf, GFP_ATOMIC);
3817 static struct skb_data *lan78xx_tx_buf_fill(struct lan78xx_net *dev,
3821 int remain = dev->tx_urb_size;
3839 lan78xx_tx_pend_skb_get(dev, &skb, &pending_bytes);
3848 lan78xx_tx_pend_skb_head_add(dev, skb, &pending_bytes);
3859 struct net_device_stats *stats = &dev->net->stats;
3875 remain = dev->tx_urb_size - urb_len;
3883 static void lan78xx_tx_bh(struct lan78xx_net *dev)
3889 netif_tx_lock(dev->net);
3890 if (netif_queue_stopped(dev->net)) {
3891 if (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev))
3892 netif_wake_queue(dev->net);
3894 netif_tx_unlock(dev->net);
3905 if (skb_queue_empty(&dev->txq_pend))
3908 tx_buf = lan78xx_get_tx_buf(dev);
3912 entry = lan78xx_tx_buf_fill(dev, tx_buf);
3914 spin_lock_irqsave(&dev->txq.lock, flags);
3915 ret = usb_autopm_get_interface_async(dev->intf);
3917 spin_unlock_irqrestore(&dev->txq.lock, flags);
3921 usb_fill_bulk_urb(entry->urb, dev->udev, dev->pipe_out,
3925 if (tx_buf->len % dev->maxpacket == 0) {
3932 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
3933 usb_anchor_urb(entry->urb, &dev->deferred);
3934 netif_stop_queue(dev->net);
3935 spin_unlock_irqrestore(&dev->txq.lock, flags);
3936 netdev_dbg(dev->net,
3944 netif_trans_update(dev->net);
3945 lan78xx_queue_skb(&dev->txq, tx_buf, tx_start);
3948 netif_stop_queue(dev->net);
3949 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
3950 usb_autopm_put_interface_async(dev->intf);
3954 netif_dbg(dev, tx_err, dev->net,
3956 netif_device_detach(dev->net);
3959 usb_autopm_put_interface_async(dev->intf);
3960 netif_dbg(dev, tx_err, dev->net,
3965 spin_unlock_irqrestore(&dev->txq.lock, flags);
3968 netdev_warn(dev->net, "failed to tx urb %d\n", ret);
3970 dev->net->stats.tx_dropped += entry->num_of_packet;
3971 lan78xx_release_tx_buf(dev, tx_buf);
3976 static int lan78xx_bh(struct lan78xx_net *dev, int budget)
3987 while (!skb_queue_empty(&dev->rxq_overflow)) {
3988 lan78xx_skb_return(dev, skb_dequeue(&dev->rxq_overflow));
3998 spin_lock_irqsave(&dev->rxq_done.lock, flags);
3999 skb_queue_splice_init(&dev->rxq_done, &done);
4000 spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4010 rx_process(dev, rx_buf, budget, &work_done);
4015 netdev_dbg(dev->net, "rx buf state %d\n",
4020 lan78xx_rx_urb_resubmit(dev, rx_buf);
4027 spin_lock_irqsave(&dev->rxq_done.lock, flags);
4028 skb_queue_splice(&done, &dev->rxq_done);
4029 spin_unlock_irqrestore(&dev->rxq_done.lock, flags);
4031 if (netif_device_present(dev->net) && netif_running(dev->net)) {
4033 if (timer_pending(&dev->stat_monitor) && (dev->delta != 1)) {
4034 dev->delta = 1;
4035 mod_timer(&dev->stat_monitor,
4041 if (!test_bit(EVENT_RX_HALT, &dev->flags))
4042 lan78xx_rx_urb_submit_all(dev);
4046 lan78xx_tx_bh(dev);
4054 struct lan78xx_net *dev = container_of(napi, struct lan78xx_net, napi);
4060 if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {
4067 work_done = lan78xx_bh(dev, budget);
4075 if (!skb_queue_empty(&dev->rxq_done)) {
4077 } else if (netif_carrier_ok(dev->net)) {
4078 if (skb_queue_empty(&dev->txq) &&
4079 !skb_queue_empty(&dev->txq_pend)) {
4082 netif_tx_lock(dev->net);
4083 if (netif_queue_stopped(dev->net)) {
4084 netif_wake_queue(dev->net);
4087 netif_tx_unlock(dev->net);
4099 struct lan78xx_net *dev;
4101 dev = container_of(work, struct lan78xx_net, wq.work);
4103 if (test_bit(EVENT_DEV_DISCONNECT, &dev->flags))
4106 if (usb_autopm_get_interface(dev->intf) < 0)
4109 if (test_bit(EVENT_TX_HALT, &dev->flags)) {
4110 unlink_urbs(dev, &dev->txq);
4112 status = usb_clear_halt(dev->udev, dev->pipe_out);
4116 if (netif_msg_tx_err(dev))
4117 netdev_err(dev->net,
4121 clear_bit(EVENT_TX_HALT, &dev->flags);
4123 netif_wake_queue(dev->net);
4127 if (test_bit(EVENT_RX_HALT, &dev->flags)) {
4128 unlink_urbs(dev, &dev->rxq);
4129 status = usb_clear_halt(dev->udev, dev->pipe_in);
4133 if (netif_msg_rx_err(dev))
4134 netdev_err(dev->net,
4138 clear_bit(EVENT_RX_HALT, &dev->flags);
4139 napi_schedule(&dev->napi);
4143 if (test_bit(EVENT_LINK_RESET, &dev->flags)) {
4146 clear_bit(EVENT_LINK_RESET, &dev->flags);
4147 if (lan78xx_link_reset(dev) < 0) {
4148 netdev_info(dev->net, "link reset failed (%d)\n",
4153 if (test_bit(EVENT_STAT_UPDATE, &dev->flags)) {
4154 lan78xx_update_stats(dev);
4156 clear_bit(EVENT_STAT_UPDATE, &dev->flags);
4158 mod_timer(&dev->stat_monitor,
4159 jiffies + (STAT_UPDATE_TIMER * dev->delta));
4161 dev->delta = min((dev->delta * 2), 50);
4164 usb_autopm_put_interface(dev->intf);
4169 struct lan78xx_net *dev = urb->context;
4175 lan78xx_status(dev, urb);
4182 netif_dbg(dev, ifdown, dev->net,
4190 netdev_dbg(dev->net, "intr status %d\n", status);
4194 if (!netif_device_present(dev->net) ||
4195 !netif_running(dev->net)) {
4196 netdev_warn(dev->net, "not submitting new status URB");
4208 netif_dbg(dev, timer, dev->net,
4210 netif_device_detach(dev->net);
4213 netif_err(dev, timer, dev->net,
4221 struct lan78xx_net *dev;
4226 dev = usb_get_intfdata(intf);
4228 if (!dev)
4231 netif_napi_del(&dev->napi);
4234 net = dev->net;
4238 timer_shutdown_sync(&dev->stat_monitor);
4239 set_bit(EVENT_DEV_DISCONNECT, &dev->flags);
4240 cancel_delayed_work_sync(&dev->wq);
4252 usb_scuttle_anchored_urbs(&dev->deferred);
4254 lan78xx_unbind(dev, intf);
4256 lan78xx_free_tx_resources(dev);
4257 lan78xx_free_rx_resources(dev);
4259 usb_kill_urb(dev->urb_intr);
4260 usb_free_urb(dev->urb_intr);
4268 struct lan78xx_net *dev = netdev_priv(net);
4270 unlink_urbs(dev, &dev->txq);
4271 napi_schedule(&dev->napi);
4278 struct lan78xx_net *dev = netdev_priv(netdev);
4280 if (skb->len > LAN78XX_TSO_SIZE(dev))
4307 struct lan78xx_net *dev = from_timer(dev, t, stat_monitor);
4309 lan78xx_defer_kevent(dev, EVENT_STAT_UPDATE);
4316 struct lan78xx_net *dev;
4329 dev_err(&intf->dev, "Error: OOM\n");
4335 SET_NETDEV_DEV(netdev, &intf->dev);
4337 dev = netdev_priv(netdev);
4338 dev->udev = udev;
4339 dev->intf = intf;
4340 dev->net = netdev;
4341 dev->msg_enable = netif_msg_init(msg_level, NETIF_MSG_DRV
4344 skb_queue_head_init(&dev->rxq);
4345 skb_queue_head_init(&dev->txq);
4346 skb_queue_head_init(&dev->rxq_done);
4347 skb_queue_head_init(&dev->txq_pend);
4348 skb_queue_head_init(&dev->rxq_overflow);
4349 mutex_init(&dev->phy_mutex);
4350 mutex_init(&dev->dev_mutex);
4352 ret = lan78xx_urb_config_init(dev);
4356 ret = lan78xx_alloc_tx_resources(dev);
4360 ret = lan78xx_alloc_rx_resources(dev);
4367 netif_set_tso_max_size(netdev, LAN78XX_TSO_SIZE(dev));
4369 netif_napi_add(netdev, &dev->napi, lan78xx_poll);
4371 INIT_DELAYED_WORK(&dev->wq, lan78xx_delayedwork);
4372 init_usb_anchor(&dev->deferred);
4378 dev->delta = 1;
4379 timer_setup(&dev->stat_monitor, lan78xx_stat_monitor, 0);
4381 mutex_init(&dev->stats.access_lock);
4388 dev->pipe_in = usb_rcvbulkpipe(udev, BULK_IN_PIPE);
4389 ep_blkin = usb_pipe_endpoint(udev, dev->pipe_in);
4395 dev->pipe_out = usb_sndbulkpipe(udev, BULK_OUT_PIPE);
4396 ep_blkout = usb_pipe_endpoint(udev, dev->pipe_out);
4408 dev->pipe_intr = usb_rcvintpipe(dev->udev,
4411 ret = lan78xx_bind(dev, intf);
4416 maxp = usb_maxpacket(dev->udev, dev->pipe_intr);
4423 dev->urb_intr = usb_alloc_urb(0, GFP_KERNEL);
4424 if (!dev->urb_intr) {
4428 usb_fill_int_urb(dev->urb_intr, dev->udev,
4429 dev->pipe_intr, buf, maxp,
4430 intr_complete, dev, period);
4431 dev->urb_intr->transfer_flags |= URB_FREE_BUFFER;
4434 dev->maxpacket = usb_maxpacket(dev->udev, dev->pipe_out);
4437 if (dev->maxpacket == 0) {
4445 ret = lan78xx_phy_init(dev);
4451 netif_err(dev, probe, netdev, "couldn't register the device\n");
4455 usb_set_intfdata(intf, dev);
4457 ret = device_set_wakeup_enable(&udev->dev, true);
4462 pm_runtime_set_autosuspend_delay(&udev->dev,
4470 usb_free_urb(dev->urb_intr);
4474 lan78xx_unbind(dev, intf);
4476 netif_napi_del(&dev->napi);
4477 lan78xx_free_rx_resources(dev);
4479 lan78xx_free_tx_resources(dev);
4513 static int lan78xx_set_auto_suspend(struct lan78xx_net *dev)
4518 ret = lan78xx_stop_tx_path(dev);
4522 ret = lan78xx_stop_rx_path(dev);
4528 ret = lan78xx_write_reg(dev, WUCSR, 0);
4531 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4534 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4540 ret = lan78xx_read_reg(dev, WUCSR, &buf);
4547 ret = lan78xx_write_reg(dev, WUCSR, buf);
4551 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4562 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4566 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4572 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4576 ret = lan78xx_start_rx_path(dev);
4581 static int lan78xx_set_suspend(struct lan78xx_net *dev, u32 wol)
4593 ret = lan78xx_stop_tx_path(dev);
4596 ret = lan78xx_stop_rx_path(dev);
4600 ret = lan78xx_write_reg(dev, WUCSR, 0);
4603 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4606 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4614 ret = lan78xx_read_reg(dev, PMT_CTL, &temp_pmt_ctl);
4622 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index), 0);
4654 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4662 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 7);
4665 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4668 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4671 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4679 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4687 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 3);
4690 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4693 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4696 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4720 ret = lan78xx_write_reg(dev, WUF_CFG(mask_index),
4728 ret = lan78xx_write_reg(dev, WUF_MASK0(mask_index), 0x3000);
4731 ret = lan78xx_write_reg(dev, WUF_MASK1(mask_index), 0);
4734 ret = lan78xx_write_reg(dev, WUF_MASK2(mask_index), 0);
4737 ret = lan78xx_write_reg(dev, WUF_MASK3(mask_index), 0);
4748 ret = lan78xx_write_reg(dev, WUCSR, temp_wucsr);
4758 ret = lan78xx_write_reg(dev, PMT_CTL, temp_pmt_ctl);
4763 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4769 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4773 ret = lan78xx_start_rx_path(dev);
4780 struct lan78xx_net *dev = usb_get_intfdata(intf);
4784 mutex_lock(&dev->dev_mutex);
4786 netif_dbg(dev, ifdown, dev->net,
4789 dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4792 spin_lock_irq(&dev->txq.lock);
4794 if ((skb_queue_len(&dev->txq) ||
4795 skb_queue_len(&dev->txq_pend)) &&
4797 spin_unlock_irq(&dev->txq.lock);
4801 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4802 spin_unlock_irq(&dev->txq.lock);
4806 ret = lan78xx_stop_rx_path(dev);
4810 ret = lan78xx_flush_rx_fifo(dev);
4815 ret = lan78xx_stop_tx_path(dev);
4820 netif_device_detach(dev->net);
4821 lan78xx_terminate_urbs(dev);
4822 usb_kill_urb(dev->urb_intr);
4825 netif_device_attach(dev->net);
4827 del_timer(&dev->stat_monitor);
4830 ret = lan78xx_set_auto_suspend(dev);
4836 pdata = (struct lan78xx_priv *)(dev->data[0]);
4837 netif_carrier_off(dev->net);
4838 ret = lan78xx_set_suspend(dev, pdata->wol);
4848 set_bit(EVENT_DEV_ASLEEP, &dev->flags);
4850 ret = lan78xx_write_reg(dev, WUCSR, 0);
4853 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4857 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4866 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4870 ret = lan78xx_read_reg(dev, PMT_CTL, &buf);
4876 ret = lan78xx_write_reg(dev, PMT_CTL, buf);
4883 mutex_unlock(&dev->dev_mutex);
4888 static bool lan78xx_submit_deferred_urbs(struct lan78xx_net *dev)
4893 while ((urb = usb_get_from_anchor(&dev->deferred))) {
4897 if (!netif_device_present(dev->net) ||
4898 !netif_carrier_ok(dev->net) ||
4900 lan78xx_release_tx_buf(dev, skb);
4907 netif_trans_update(dev->net);
4908 lan78xx_queue_skb(&dev->txq, skb, tx_start);
4911 netif_stop_queue(dev->net);
4914 netif_device_detach(dev->net);
4917 lan78xx_release_tx_buf(dev, skb);
4926 struct lan78xx_net *dev = usb_get_intfdata(intf);
4930 mutex_lock(&dev->dev_mutex);
4932 netif_dbg(dev, ifup, dev->net, "resuming device");
4934 dev_open = test_bit(EVENT_DEV_OPEN, &dev->flags);
4939 ret = lan78xx_flush_tx_fifo(dev);
4943 if (dev->urb_intr) {
4944 int ret = usb_submit_urb(dev->urb_intr, GFP_KERNEL);
4948 netif_device_detach(dev->net);
4949 netdev_warn(dev->net, "Failed to submit intr URB");
4953 spin_lock_irq(&dev->txq.lock);
4955 if (netif_device_present(dev->net)) {
4956 pipe_halted = lan78xx_submit_deferred_urbs(dev);
4959 lan78xx_defer_kevent(dev, EVENT_TX_HALT);
4962 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4964 spin_unlock_irq(&dev->txq.lock);
4967 netif_device_present(dev->net) &&
4968 (lan78xx_tx_pend_data_len(dev) < lan78xx_tx_urb_space(dev)))
4969 netif_start_queue(dev->net);
4971 ret = lan78xx_start_tx_path(dev);
4975 napi_schedule(&dev->napi);
4977 if (!timer_pending(&dev->stat_monitor)) {
4978 dev->delta = 1;
4979 mod_timer(&dev->stat_monitor,
4984 clear_bit(EVENT_DEV_ASLEEP, &dev->flags);
4987 ret = lan78xx_write_reg(dev, WUCSR2, 0);
4990 ret = lan78xx_write_reg(dev, WUCSR, 0);
4993 ret = lan78xx_write_reg(dev, WK_SRC, 0xFFF1FF1FUL);
4997 ret = lan78xx_write_reg(dev, WUCSR2, WUCSR2_NS_RCD_ |
5004 ret = lan78xx_write_reg(dev, WUCSR, WUCSR_EEE_TX_WAKE_ |
5016 mutex_unlock(&dev->dev_mutex);
5023 struct lan78xx_net *dev = usb_get_intfdata(intf);
5026 netif_dbg(dev, ifup, dev->net, "(reset) resuming device");
5028 ret = lan78xx_reset(dev);
5032 phy_start(dev->net->phydev);