Lines Matching refs:nic
537 struct nic {
542 u16 (*mdio_ctrl)(struct nic *nic, u32 addr, u32 dir, u32 reg, u16 data);
606 static inline void e100_write_flush(struct nic *nic)
610 (void)ioread8(&nic->csr->scb.status);
613 static void e100_enable_irq(struct nic *nic)
617 spin_lock_irqsave(&nic->cmd_lock, flags);
618 iowrite8(irq_mask_none, &nic->csr->scb.cmd_hi);
619 e100_write_flush(nic);
620 spin_unlock_irqrestore(&nic->cmd_lock, flags);
623 static void e100_disable_irq(struct nic *nic)
627 spin_lock_irqsave(&nic->cmd_lock, flags);
628 iowrite8(irq_mask_all, &nic->csr->scb.cmd_hi);
629 e100_write_flush(nic);
630 spin_unlock_irqrestore(&nic->cmd_lock, flags);
633 static void e100_hw_reset(struct nic *nic)
637 iowrite32(selective_reset, &nic->csr->port);
638 e100_write_flush(nic); udelay(20);
641 iowrite32(software_reset, &nic->csr->port);
642 e100_write_flush(nic); udelay(20);
645 e100_disable_irq(nic);
648 static int e100_self_test(struct nic *nic)
650 u32 dma_addr = nic->dma_addr + offsetof(struct mem, selftest);
655 nic->mem->selftest.signature = 0;
656 nic->mem->selftest.result = 0xFFFFFFFF;
658 iowrite32(selftest | dma_addr, &nic->csr->port);
659 e100_write_flush(nic);
664 e100_disable_irq(nic);
667 if (nic->mem->selftest.result != 0) {
668 netif_err(nic, hw, nic->netdev,
670 nic->mem->selftest.result);
673 if (nic->mem->selftest.signature == 0) {
674 netif_err(nic, hw, nic->netdev, "Self-test failed: timed out\n");
681 static void e100_eeprom_write(struct nic *nic, u16 addr_len, u16 addr, __le16 data)
697 iowrite8(eecs | eesk, &nic->csr->eeprom_ctrl_lo);
698 e100_write_flush(nic); udelay(4);
703 iowrite8(ctrl, &nic->csr->eeprom_ctrl_lo);
704 e100_write_flush(nic); udelay(4);
706 iowrite8(ctrl | eesk, &nic->csr->eeprom_ctrl_lo);
707 e100_write_flush(nic); udelay(4);
713 iowrite8(0, &nic->csr->eeprom_ctrl_lo);
714 e100_write_flush(nic); udelay(4);
719 static __le16 e100_eeprom_read(struct nic *nic, u16 *addr_len, u16 addr)
729 iowrite8(eecs | eesk, &nic->csr->eeprom_ctrl_lo);
730 e100_write_flush(nic); udelay(4);
735 iowrite8(ctrl, &nic->csr->eeprom_ctrl_lo);
736 e100_write_flush(nic); udelay(4);
738 iowrite8(ctrl | eesk, &nic->csr->eeprom_ctrl_lo);
739 e100_write_flush(nic); udelay(4);
743 ctrl = ioread8(&nic->csr->eeprom_ctrl_lo);
753 iowrite8(0, &nic->csr->eeprom_ctrl_lo);
754 e100_write_flush(nic); udelay(4);
760 static int e100_eeprom_load(struct nic *nic)
765 e100_eeprom_read(nic, &addr_len, 0);
766 nic->eeprom_wc = 1 << addr_len;
768 for (addr = 0; addr < nic->eeprom_wc; addr++) {
769 nic->eeprom[addr] = e100_eeprom_read(nic, &addr_len, addr);
770 if (addr < nic->eeprom_wc - 1)
771 checksum += le16_to_cpu(nic->eeprom[addr]);
776 if (cpu_to_le16(0xBABA - checksum) != nic->eeprom[nic->eeprom_wc - 1]) {
777 netif_err(nic, probe, nic->netdev, "EEPROM corrupted\n");
786 static int e100_eeprom_save(struct nic *nic, u16 start, u16 count)
791 e100_eeprom_read(nic, &addr_len, 0);
792 nic->eeprom_wc = 1 << addr_len;
794 if (start + count >= nic->eeprom_wc)
798 e100_eeprom_write(nic, addr_len, addr, nic->eeprom[addr]);
802 for (addr = 0; addr < nic->eeprom_wc - 1; addr++)
803 checksum += le16_to_cpu(nic->eeprom[addr]);
804 nic->eeprom[nic->eeprom_wc - 1] = cpu_to_le16(0xBABA - checksum);
805 e100_eeprom_write(nic, addr_len, nic->eeprom_wc - 1,
806 nic->eeprom[nic->eeprom_wc - 1]);
813 static int e100_exec_cmd(struct nic *nic, u8 cmd, dma_addr_t dma_addr)
819 spin_lock_irqsave(&nic->cmd_lock, flags);
823 if (likely(!ioread8(&nic->csr->scb.cmd_lo)))
835 iowrite32(dma_addr, &nic->csr->scb.gen_ptr);
836 iowrite8(cmd, &nic->csr->scb.cmd_lo);
839 spin_unlock_irqrestore(&nic->cmd_lock, flags);
844 static int e100_exec_cb(struct nic *nic, struct sk_buff *skb,
845 int (*cb_prepare)(struct nic *, struct cb *, struct sk_buff *))
851 spin_lock_irqsave(&nic->cb_lock, flags);
853 if (unlikely(!nic->cbs_avail)) {
858 cb = nic->cb_to_use;
859 nic->cb_to_use = cb->next;
860 nic->cbs_avail--;
863 err = cb_prepare(nic, cb, skb);
867 if (unlikely(!nic->cbs_avail))
877 while (nic->cb_to_send != nic->cb_to_use) {
878 if (unlikely(e100_exec_cmd(nic, nic->cuc_cmd,
879 nic->cb_to_send->dma_addr))) {
887 schedule_work(&nic->tx_timeout_task);
891 nic->cuc_cmd = cuc_resume;
892 nic->cb_to_send = nic->cb_to_send->next;
897 spin_unlock_irqrestore(&nic->cb_lock, flags);
904 struct nic *nic = netdev_priv(netdev);
905 return nic->mdio_ctrl(nic, addr, mdi_read, reg, 0);
910 struct nic *nic = netdev_priv(netdev);
912 nic->mdio_ctrl(nic, addr, mdi_write, reg, data);
916 static u16 mdio_ctrl_hw(struct nic *nic, u32 addr, u32 dir, u32 reg, u16 data)
929 spin_lock_irqsave(&nic->mdio_lock, flags);
931 if (ioread32(&nic->csr->mdi_ctrl) & mdi_ready)
936 netdev_err(nic->netdev, "e100.mdio_ctrl won't go Ready\n");
937 spin_unlock_irqrestore(&nic->mdio_lock, flags);
940 iowrite32((reg << 16) | (addr << 21) | dir | data, &nic->csr->mdi_ctrl);
944 if ((data_out = ioread32(&nic->csr->mdi_ctrl)) & mdi_ready)
947 spin_unlock_irqrestore(&nic->mdio_lock, flags);
948 netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
956 static u16 mdio_ctrl_phy_82552_v(struct nic *nic,
964 u16 advert = mdio_read(nic->netdev, nic->mii.phy_id,
977 return mdio_ctrl_hw(nic, addr, dir, reg, data);
986 static u16 mdio_ctrl_phy_mii_emulated(struct nic *nic,
1011 netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
1020 netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
1028 static inline int e100_phy_supports_mii(struct nic *nic)
1033 return (nic->mdio_ctrl != mdio_ctrl_phy_mii_emulated);
1036 static void e100_get_defaults(struct nic *nic)
1042 nic->mac = (nic->flags & ich) ? mac_82559_D101M : nic->pdev->revision;
1043 if (nic->mac == mac_unknown)
1044 nic->mac = mac_82557_D100_A;
1046 nic->params.rfds = rfds;
1047 nic->params.cbs = cbs;
1050 nic->tx_threshold = 0xE0;
1053 nic->tx_command = cpu_to_le16(cb_tx | cb_tx_sf |
1054 ((nic->mac >= mac_82558_D101_A4) ? cb_cid : cb_i));
1057 nic->blank_rfd.command = 0;
1058 nic->blank_rfd.rbd = cpu_to_le32(0xFFFFFFFF);
1059 nic->blank_rfd.size = cpu_to_le16(VLAN_ETH_FRAME_LEN + ETH_FCS_LEN);
1062 nic->mii.phy_id_mask = 0x1F;
1063 nic->mii.reg_num_mask = 0x1F;
1064 nic->mii.dev = nic->netdev;
1065 nic->mii.mdio_read = mdio_read;
1066 nic->mii.mdio_write = mdio_write;
1069 static int e100_configure(struct nic *nic, struct cb *cb, struct sk_buff *skb)
1073 struct net_device *netdev = nic->netdev;
1086 if (e100_phy_supports_mii(nic))
1105 config->adaptive_ifs = nic->adaptive_ifs;
1106 config->loopback = nic->loopback;
1108 if (nic->mii.force_media && nic->mii.full_duplex)
1111 if (nic->flags & promiscuous || nic->loopback) {
1120 if (nic->flags & multicast_all)
1124 if (netif_running(nic->netdev) || !(nic->flags & wol_magic))
1127 if (nic->mac >= mac_82558_D101_A4) {
1132 if (nic->mac >= mac_82559_D101M) {
1135 if (nic->mac >= mac_82551_10) {
1150 netif_printk(nic, hw, KERN_DEBUG, nic->netdev, "[00-07]=%8ph\n",
1152 netif_printk(nic, hw, KERN_DEBUG, nic->netdev, "[08-15]=%8ph\n",
1154 netif_printk(nic, hw, KERN_DEBUG, nic->netdev, "[16-23]=%8ph\n",
1219 static const struct firmware *e100_request_firmware(struct nic *nic)
1222 const struct firmware *fw = nic->fw;
1228 if (nic->flags & ich)
1244 if (nic->mac == mac_82559_D101M) {
1246 } else if (nic->mac == mac_82559_D101S) {
1248 } else if (nic->mac == mac_82551_F || nic->mac == mac_82551_10) {
1261 err = request_firmware(&fw, fw_name, &nic->pdev->dev);
1265 netif_err(nic, probe, nic->netdev,
1270 netif_info(nic, probe, nic->netdev,
1280 netif_err(nic, probe, nic->netdev,
1294 netif_err(nic, probe, nic->netdev,
1302 * to it in the nic */
1303 nic->fw = fw;
1307 static int e100_setup_ucode(struct nic *nic, struct cb *cb,
1337 static inline int e100_load_ucode_wait(struct nic *nic)
1341 struct cb *cb = nic->cb_to_clean;
1343 fw = e100_request_firmware(nic);
1348 if ((err = e100_exec_cb(nic, (void *)fw, e100_setup_ucode)))
1349 netif_err(nic, probe, nic->netdev,
1353 nic->cuc_cmd = cuc_start;
1356 e100_write_flush(nic);
1366 iowrite8(~0, &nic->csr->scb.stat_ack);
1370 netif_err(nic, probe, nic->netdev, "ucode load failed\n");
1377 static int e100_setup_iaaddr(struct nic *nic, struct cb *cb,
1381 memcpy(cb->u.iaaddr, nic->netdev->dev_addr, ETH_ALEN);
1385 static int e100_dump(struct nic *nic, struct cb *cb, struct sk_buff *skb)
1388 cb->u.dump_buffer_addr = cpu_to_le32(nic->dma_addr +
1393 static int e100_phy_check_without_mii(struct nic *nic)
1398 phy_type = (le16_to_cpu(nic->eeprom[eeprom_phy_iface]) >> 8) & 0x0f;
1410 netif_info(nic, probe, nic->netdev,
1413 nic->mdio_ctrl = mdio_ctrl_phy_mii_emulated;
1414 nic->mii.phy_id = 0; /* is this ok for an MII-less PHY? */
1417 * nic->flags |= ich;
1418 * nic->flags |= ich_10h_workaround; */
1434 static int e100_phy_init(struct nic *nic)
1436 struct net_device *netdev = nic->netdev;
1442 nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr;
1443 bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR);
1444 stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR);
1445 stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR);
1454 if (e100_phy_check_without_mii(nic))
1458 netif_err(nic, hw, nic->netdev,
1463 netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
1464 "phy_addr = %d\n", nic->mii.phy_id);
1467 id_lo = mdio_read(netdev, nic->mii.phy_id, MII_PHYSID1);
1468 id_hi = mdio_read(netdev, nic->mii.phy_id, MII_PHYSID2);
1469 nic->phy = (u32)id_hi << 16 | (u32)id_lo;
1470 netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
1471 "phy ID = 0x%08X\n", nic->phy);
1475 if (addr != nic->mii.phy_id) {
1477 } else if (nic->phy != phy_82552_v) {
1488 if (nic->phy == phy_82552_v)
1489 mdio_write(netdev, nic->mii.phy_id, MII_BMCR,
1494 if ((nic->phy & NCS_PHY_MODEL_MASK) == phy_nsc_tx) {
1496 cong = mdio_read(netdev, nic->mii.phy_id, MII_NSC_CONG);
1499 mdio_write(netdev, nic->mii.phy_id, MII_NSC_CONG, cong);
1502 if (nic->phy == phy_82552_v) {
1503 u16 advert = mdio_read(netdev, nic->mii.phy_id, MII_ADVERTISE);
1506 nic->mdio_ctrl = mdio_ctrl_phy_82552_v;
1510 mdio_write(netdev, nic->mii.phy_id, MII_ADVERTISE, advert);
1513 bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR);
1515 mdio_write(netdev, nic->mii.phy_id, MII_BMCR, bmcr);
1516 } else if ((nic->mac >= mac_82550_D102) || ((nic->flags & ich) &&
1517 (mdio_read(netdev, nic->mii.phy_id, MII_TPISTATUS) & 0x8000) &&
1518 (le16_to_cpu(nic->eeprom[eeprom_cnfg_mdix]) & eeprom_mdix_enabled))) {
1520 mdio_write(netdev, nic->mii.phy_id, MII_NCONFIG,
1521 nic->mii.force_media ? 0 : NCONFIG_AUTO_SWITCH);
1527 static int e100_hw_init(struct nic *nic)
1531 e100_hw_reset(nic);
1533 netif_err(nic, hw, nic->netdev, "e100_hw_init\n");
1534 if ((err = e100_self_test(nic)))
1537 if ((err = e100_phy_init(nic)))
1539 if ((err = e100_exec_cmd(nic, cuc_load_base, 0)))
1541 if ((err = e100_exec_cmd(nic, ruc_load_base, 0)))
1543 if ((err = e100_load_ucode_wait(nic)))
1545 if ((err = e100_exec_cb(nic, NULL, e100_configure)))
1547 if ((err = e100_exec_cb(nic, NULL, e100_setup_iaaddr)))
1549 if ((err = e100_exec_cmd(nic, cuc_dump_addr,
1550 nic->dma_addr + offsetof(struct mem, stats))))
1552 if ((err = e100_exec_cmd(nic, cuc_dump_reset, 0)))
1555 e100_disable_irq(nic);
1560 static int e100_multi(struct nic *nic, struct cb *cb, struct sk_buff *skb)
1562 struct net_device *netdev = nic->netdev;
1580 struct nic *nic = netdev_priv(netdev);
1582 netif_printk(nic, hw, KERN_DEBUG, nic->netdev,
1587 nic->flags |= promiscuous;
1589 nic->flags &= ~promiscuous;
1593 nic->flags |= multicast_all;
1595 nic->flags &= ~multicast_all;
1597 e100_exec_cb(nic, NULL, e100_configure);
1598 e100_exec_cb(nic, NULL, e100_multi);
1601 static void e100_update_stats(struct nic *nic)
1603 struct net_device *dev = nic->netdev;
1605 struct stats *s = &nic->mem->stats;
1606 __le32 *complete = (nic->mac < mac_82558_D101_A4) ? &s->fc_xmt_pause :
1607 (nic->mac < mac_82559_D101M) ? (__le32 *)&s->xmt_tco_frames :
1616 nic->tx_frames = le32_to_cpu(s->tx_good_frames);
1617 nic->tx_collisions = le32_to_cpu(s->tx_total_collisions);
1622 ns->collisions += nic->tx_collisions;
1625 nic->rx_short_frame_errors +=
1627 ns->rx_length_errors = nic->rx_short_frame_errors +
1628 nic->rx_over_length_errors;
1638 nic->tx_deferred += le32_to_cpu(s->tx_deferred);
1639 nic->tx_single_collisions +=
1641 nic->tx_multiple_collisions +=
1643 if (nic->mac >= mac_82558_D101_A4) {
1644 nic->tx_fc_pause += le32_to_cpu(s->fc_xmt_pause);
1645 nic->rx_fc_pause += le32_to_cpu(s->fc_rcv_pause);
1646 nic->rx_fc_unsupported +=
1648 if (nic->mac >= mac_82559_D101M) {
1649 nic->tx_tco_frames +=
1651 nic->rx_tco_frames +=
1658 if (e100_exec_cmd(nic, cuc_dump_reset, 0))
1659 netif_printk(nic, tx_err, KERN_DEBUG, nic->netdev,
1663 static void e100_adjust_adaptive_ifs(struct nic *nic, int speed, int duplex)
1669 u32 prev = nic->adaptive_ifs;
1672 if ((nic->tx_frames / 32 < nic->tx_collisions) &&
1673 (nic->tx_frames > min_frames)) {
1674 if (nic->adaptive_ifs < 60)
1675 nic->adaptive_ifs += 5;
1676 } else if (nic->tx_frames < min_frames) {
1677 if (nic->adaptive_ifs >= 5)
1678 nic->adaptive_ifs -= 5;
1680 if (nic->adaptive_ifs != prev)
1681 e100_exec_cb(nic, NULL, e100_configure);
1687 struct nic *nic = from_timer(nic, t, watchdog);
1691 netif_printk(nic, timer, KERN_DEBUG, nic->netdev,
1696 mii_ethtool_gset(&nic->mii, &cmd);
1699 if (mii_link_ok(&nic->mii) && !netif_carrier_ok(nic->netdev)) {
1700 netdev_info(nic->netdev, "NIC Link is Up %u Mbps %s Duplex\n",
1703 } else if (!mii_link_ok(&nic->mii) && netif_carrier_ok(nic->netdev)) {
1704 netdev_info(nic->netdev, "NIC Link is Down\n");
1707 mii_check_link(&nic->mii);
1714 spin_lock_irq(&nic->cmd_lock);
1715 iowrite8(ioread8(&nic->csr->scb.cmd_hi) | irq_sw_gen,&nic->csr->scb.cmd_hi);
1716 e100_write_flush(nic);
1717 spin_unlock_irq(&nic->cmd_lock);
1719 e100_update_stats(nic);
1720 e100_adjust_adaptive_ifs(nic, speed, cmd.duplex);
1722 if (nic->mac <= mac_82557_D100_C)
1724 e100_set_multicast_list(nic->netdev);
1726 if (nic->flags & ich && speed == SPEED_10 && cmd.duplex == DUPLEX_HALF)
1728 nic->flags |= ich_10h_workaround;
1730 nic->flags &= ~ich_10h_workaround;
1732 mod_timer(&nic->watchdog,
1736 static int e100_xmit_prepare(struct nic *nic, struct cb *cb,
1740 cb->command = nic->tx_command;
1742 dma_addr = dma_map_single(&nic->pdev->dev, skb->data, skb->len,
1745 if (dma_mapping_error(&nic->pdev->dev, dma_addr))
1758 if ((nic->cbs_avail & ~15) == nic->cbs_avail)
1762 cb->u.tcb.threshold = nic->tx_threshold;
1773 struct nic *nic = netdev_priv(netdev);
1776 if (nic->flags & ich_10h_workaround) {
1780 if (e100_exec_cmd(nic, cuc_nop, 0))
1781 netif_printk(nic, tx_err, KERN_DEBUG, nic->netdev,
1786 err = e100_exec_cb(nic, skb, e100_xmit_prepare);
1791 netif_printk(nic, tx_err, KERN_DEBUG, nic->netdev,
1797 netif_printk(nic, tx_err, KERN_DEBUG, nic->netdev,
1806 static int e100_tx_clean(struct nic *nic)
1808 struct net_device *dev = nic->netdev;
1812 spin_lock(&nic->cb_lock);
1815 for (cb = nic->cb_to_clean;
1817 cb = nic->cb_to_clean = cb->next) {
1819 netif_printk(nic, tx_done, KERN_DEBUG, nic->netdev,
1821 (int)(((void*)cb - (void*)nic->cbs)/sizeof(struct cb)),
1828 dma_unmap_single(&nic->pdev->dev,
1837 nic->cbs_avail++;
1840 spin_unlock(&nic->cb_lock);
1843 if (unlikely(tx_cleaned && netif_queue_stopped(nic->netdev)))
1844 netif_wake_queue(nic->netdev);
1849 static void e100_clean_cbs(struct nic *nic)
1851 if (nic->cbs) {
1852 while (nic->cbs_avail != nic->params.cbs.count) {
1853 struct cb *cb = nic->cb_to_clean;
1855 dma_unmap_single(&nic->pdev->dev,
1861 nic->cb_to_clean = nic->cb_to_clean->next;
1862 nic->cbs_avail++;
1864 dma_pool_free(nic->cbs_pool, nic->cbs, nic->cbs_dma_addr);
1865 nic->cbs = NULL;
1866 nic->cbs_avail = 0;
1868 nic->cuc_cmd = cuc_start;
1869 nic->cb_to_use = nic->cb_to_send = nic->cb_to_clean =
1870 nic->cbs;
1873 static int e100_alloc_cbs(struct nic *nic)
1876 unsigned int i, count = nic->params.cbs.count;
1878 nic->cuc_cmd = cuc_start;
1879 nic->cb_to_use = nic->cb_to_send = nic->cb_to_clean = NULL;
1880 nic->cbs_avail = 0;
1882 nic->cbs = dma_pool_zalloc(nic->cbs_pool, GFP_KERNEL,
1883 &nic->cbs_dma_addr);
1884 if (!nic->cbs)
1887 for (cb = nic->cbs, i = 0; i < count; cb++, i++) {
1888 cb->next = (i + 1 < count) ? cb + 1 : nic->cbs;
1889 cb->prev = (i == 0) ? nic->cbs + count - 1 : cb - 1;
1891 cb->dma_addr = nic->cbs_dma_addr + i * sizeof(struct cb);
1892 cb->link = cpu_to_le32(nic->cbs_dma_addr +
1896 nic->cb_to_use = nic->cb_to_send = nic->cb_to_clean = nic->cbs;
1897 nic->cbs_avail = count;
1902 static inline void e100_start_receiver(struct nic *nic, struct rx *rx)
1904 if (!nic->rxs) return;
1905 if (RU_SUSPENDED != nic->ru_running) return;
1908 if (!rx) rx = nic->rxs;
1912 e100_exec_cmd(nic, ruc_start, rx->dma_addr);
1913 nic->ru_running = RU_RUNNING;
1918 static int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
1920 if (!(rx->skb = netdev_alloc_skb_ip_align(nic->netdev, RFD_BUF_LEN)))
1924 skb_copy_to_linear_data(rx->skb, &nic->blank_rfd, sizeof(struct rfd));
1925 rx->dma_addr = dma_map_single(&nic->pdev->dev, rx->skb->data,
1928 if (dma_mapping_error(&nic->pdev->dev, rx->dma_addr)) {
1941 dma_sync_single_for_device(&nic->pdev->dev,
1950 static int e100_rx_indicate(struct nic *nic, struct rx *rx,
1953 struct net_device *dev = nic->netdev;
1963 dma_sync_single_for_cpu(&nic->pdev->dev, rx->dma_addr,
1967 netif_printk(nic, rx_status, KERN_DEBUG, nic->netdev,
1979 (RU_RUNNING == nic->ru_running))
1981 if (ioread8(&nic->csr->scb.status) & rus_no_res)
1982 nic->ru_running = RU_SUSPENDED;
1983 dma_sync_single_for_device(&nic->pdev->dev, rx->dma_addr,
1997 dma_unmap_single(&nic->pdev->dev, rx->dma_addr, RFD_BUF_LEN,
2007 (RU_RUNNING == nic->ru_running)) {
2009 if (ioread8(&nic->csr->scb.status) & rus_no_res)
2010 nic->ru_running = RU_SUSPENDED;
2016 skb->protocol = eth_type_trans(skb, nic->netdev);
2024 nic->rx_over_length_errors++;
2033 nic->rx_over_length_errors++;
2049 static void e100_rx_clean(struct nic *nic, unsigned int *work_done,
2058 for (rx = nic->rx_to_clean; rx->skb; rx = nic->rx_to_clean = rx->next) {
2059 err = e100_rx_indicate(nic, rx, work_done, work_to_do);
2072 if (-EAGAIN != err && RU_SUSPENDED == nic->ru_running)
2075 old_before_last_rx = nic->rx_to_use->prev->prev;
2079 for (rx = nic->rx_to_use; !rx->skb; rx = nic->rx_to_use = rx->next) {
2080 if (unlikely(e100_rx_alloc_skb(nic, rx)))
2084 new_before_last_rx = nic->rx_to_use->prev->prev;
2099 dma_sync_single_for_device(&nic->pdev->dev,
2108 dma_sync_single_for_device(&nic->pdev->dev,
2114 dma_sync_single_for_device(&nic->pdev->dev,
2122 iowrite8(stat_ack_rnr, &nic->csr->scb.stat_ack);
2123 e100_start_receiver(nic, nic->rx_to_clean);
2129 static void e100_rx_clean_list(struct nic *nic)
2132 unsigned int i, count = nic->params.rfds.count;
2134 nic->ru_running = RU_UNINITIALIZED;
2136 if (nic->rxs) {
2137 for (rx = nic->rxs, i = 0; i < count; rx++, i++) {
2139 dma_unmap_single(&nic->pdev->dev,
2145 kfree(nic->rxs);
2146 nic->rxs = NULL;
2149 nic->rx_to_use = nic->rx_to_clean = NULL;
2152 static int e100_rx_alloc_list(struct nic *nic)
2155 unsigned int i, count = nic->params.rfds.count;
2158 nic->rx_to_use = nic->rx_to_clean = NULL;
2159 nic->ru_running = RU_UNINITIALIZED;
2161 if (!(nic->rxs = kcalloc(count, sizeof(struct rx), GFP_KERNEL)))
2164 for (rx = nic->rxs, i = 0; i < count; rx++, i++) {
2165 rx->next = (i + 1 < count) ? rx + 1 : nic->rxs;
2166 rx->prev = (i == 0) ? nic->rxs + count - 1 : rx - 1;
2167 if (e100_rx_alloc_skb(nic, rx)) {
2168 e100_rx_clean_list(nic);
2179 rx = nic->rxs->prev->prev;
2183 dma_sync_single_for_device(&nic->pdev->dev, rx->dma_addr,
2186 nic->rx_to_use = nic->rx_to_clean = nic->rxs;
2187 nic->ru_running = RU_SUSPENDED;
2195 struct nic *nic = netdev_priv(netdev);
2196 u8 stat_ack = ioread8(&nic->csr->scb.stat_ack);
2198 netif_printk(nic, intr, KERN_DEBUG, nic->netdev,
2206 iowrite8(stat_ack, &nic->csr->scb.stat_ack);
2210 nic->ru_running = RU_SUSPENDED;
2212 if (likely(napi_schedule_prep(&nic->napi))) {
2213 e100_disable_irq(nic);
2214 __napi_schedule(&nic->napi);
2222 struct nic *nic = container_of(napi, struct nic, napi);
2225 e100_rx_clean(nic, &work_done, budget);
2226 e100_tx_clean(nic);
2234 e100_enable_irq(nic);
2242 struct nic *nic = netdev_priv(netdev);
2244 e100_disable_irq(nic);
2245 e100_intr(nic->pdev->irq, netdev);
2246 e100_tx_clean(nic);
2247 e100_enable_irq(nic);
2253 struct nic *nic = netdev_priv(netdev);
2260 e100_exec_cb(nic, NULL, e100_setup_iaaddr);
2265 static int e100_asf(struct nic *nic)
2268 return (nic->pdev->device >= 0x1050) && (nic->pdev->device <= 0x1057) &&
2269 (le16_to_cpu(nic->eeprom[eeprom_config_asf]) & eeprom_asf) &&
2270 !(le16_to_cpu(nic->eeprom[eeprom_config_asf]) & eeprom_gcl) &&
2271 ((le16_to_cpu(nic->eeprom[eeprom_smbus_addr]) & 0xFF) != 0xFE);
2274 static int e100_up(struct nic *nic)
2278 if ((err = e100_rx_alloc_list(nic)))
2280 if ((err = e100_alloc_cbs(nic)))
2282 if ((err = e100_hw_init(nic)))
2284 e100_set_multicast_list(nic->netdev);
2285 e100_start_receiver(nic, NULL);
2286 mod_timer(&nic->watchdog, jiffies);
2287 if ((err = request_irq(nic->pdev->irq, e100_intr, IRQF_SHARED,
2288 nic->netdev->name, nic->netdev)))
2290 netif_wake_queue(nic->netdev);
2291 napi_enable(&nic->napi);
2294 e100_enable_irq(nic);
2298 del_timer_sync(&nic->watchdog);
2300 e100_clean_cbs(nic);
2302 e100_rx_clean_list(nic);
2306 static void e100_down(struct nic *nic)
2309 napi_disable(&nic->napi);
2310 netif_stop_queue(nic->netdev);
2311 e100_hw_reset(nic);
2312 free_irq(nic->pdev->irq, nic->netdev);
2313 del_timer_sync(&nic->watchdog);
2314 netif_carrier_off(nic->netdev);
2315 e100_clean_cbs(nic);
2316 e100_rx_clean_list(nic);
2321 struct nic *nic = netdev_priv(netdev);
2325 schedule_work(&nic->tx_timeout_task);
2330 struct nic *nic = container_of(work, struct nic, tx_timeout_task);
2331 struct net_device *netdev = nic->netdev;
2333 netif_printk(nic, tx_err, KERN_DEBUG, nic->netdev,
2334 "scb.status=0x%02X\n", ioread8(&nic->csr->scb.status));
2344 static int e100_loopback_test(struct nic *nic, enum loopback loopback_mode)
2354 if ((err = e100_rx_alloc_list(nic)))
2356 if ((err = e100_alloc_cbs(nic)))
2360 if (nic->flags & ich && loopback_mode == lb_phy)
2363 nic->loopback = loopback_mode;
2364 if ((err = e100_hw_init(nic)))
2368 mdio_write(nic->netdev, nic->mii.phy_id, MII_BMCR,
2371 e100_start_receiver(nic, NULL);
2373 if (!(skb = netdev_alloc_skb(nic->netdev, ETH_DATA_LEN))) {
2379 e100_xmit_frame(skb, nic->netdev);
2383 dma_sync_single_for_cpu(&nic->pdev->dev, nic->rx_to_clean->dma_addr,
2386 if (memcmp(nic->rx_to_clean->skb->data + sizeof(struct rfd),
2391 mdio_write(nic->netdev, nic->mii.phy_id, MII_BMCR, 0);
2392 nic->loopback = lb_none;
2393 e100_clean_cbs(nic);
2394 e100_hw_reset(nic);
2396 e100_rx_clean_list(nic);
2408 struct nic *nic = netdev_priv(netdev);
2410 mii_ethtool_get_link_ksettings(&nic->mii, cmd);
2418 struct nic *nic = netdev_priv(netdev);
2421 mdio_write(netdev, nic->mii.phy_id, MII_BMCR, BMCR_RESET);
2422 err = mii_ethtool_set_link_ksettings(&nic->mii, cmd);
2423 e100_exec_cb(nic, NULL, e100_configure);
2431 struct nic *nic = netdev_priv(netdev);
2433 strlcpy(info->bus_info, pci_name(nic->pdev),
2440 struct nic *nic = netdev_priv(netdev);
2445 return (1 + E100_PHY_REGS) * sizeof(u32) + sizeof(nic->mem->dump_buf);
2451 struct nic *nic = netdev_priv(netdev);
2455 regs->version = (1 << 24) | nic->pdev->revision;
2456 buff[0] = ioread8(&nic->csr->scb.cmd_hi) << 24 |
2457 ioread8(&nic->csr->scb.cmd_lo) << 16 |
2458 ioread16(&nic->csr->scb.status);
2464 buff[1 + i] = mdio_read(netdev, nic->mii.phy_id,
2466 memset(nic->mem->dump_buf, 0, sizeof(nic->mem->dump_buf));
2467 e100_exec_cb(nic, NULL, e100_dump);
2469 memcpy(&buff[1 + E100_PHY_REGS], nic->mem->dump_buf,
2470 sizeof(nic->mem->dump_buf));
2475 struct nic *nic = netdev_priv(netdev);
2476 wol->supported = (nic->mac >= mac_82558_D101_A4) ? WAKE_MAGIC : 0;
2477 wol->wolopts = (nic->flags & wol_magic) ? WAKE_MAGIC : 0;
2482 struct nic *nic = netdev_priv(netdev);
2485 !device_can_wakeup(&nic->pdev->dev))
2489 nic->flags |= wol_magic;
2491 nic->flags &= ~wol_magic;
2493 device_set_wakeup_enable(&nic->pdev->dev, wol->wolopts);
2495 e100_exec_cb(nic, NULL, e100_configure);
2502 struct nic *nic = netdev_priv(netdev);
2503 return nic->msg_enable;
2508 struct nic *nic = netdev_priv(netdev);
2509 nic->msg_enable = value;
2514 struct nic *nic = netdev_priv(netdev);
2515 return mii_nway_restart(&nic->mii);
2520 struct nic *nic = netdev_priv(netdev);
2521 return mii_link_ok(&nic->mii);
2526 struct nic *nic = netdev_priv(netdev);
2527 return nic->eeprom_wc << 1;
2534 struct nic *nic = netdev_priv(netdev);
2537 memcpy(bytes, &((u8 *)nic->eeprom)[eeprom->offset], eeprom->len);
2545 struct nic *nic = netdev_priv(netdev);
2550 memcpy(&((u8 *)nic->eeprom)[eeprom->offset], bytes, eeprom->len);
2552 return e100_eeprom_save(nic, eeprom->offset >> 1,
2559 struct nic *nic = netdev_priv(netdev);
2560 struct param_range *rfds = &nic->params.rfds;
2561 struct param_range *cbs = &nic->params.cbs;
2572 struct nic *nic = netdev_priv(netdev);
2573 struct param_range *rfds = &nic->params.rfds;
2574 struct param_range *cbs = &nic->params.cbs;
2580 e100_down(nic);
2585 netif_info(nic, drv, nic->netdev, "Ring Param settings: rx: %d, tx %d\n",
2588 e100_up(nic);
2606 struct nic *nic = netdev_priv(netdev);
2610 data[0] = !mii_link_ok(&nic->mii);
2611 data[1] = e100_eeprom_load(nic);
2615 mii_ethtool_gset(&nic->mii, &cmd);
2618 e100_down(nic);
2619 data[2] = e100_self_test(nic);
2620 data[3] = e100_loopback_test(nic, lb_mac);
2621 data[4] = e100_loopback_test(nic, lb_phy);
2624 mii_ethtool_sset(&nic->mii, &cmd);
2627 e100_up(nic);
2638 struct nic *nic = netdev_priv(netdev);
2645 u16 led_reg = (nic->phy == phy_82552_v) ? E100_82552_LED_OVERRIDE :
2654 leds = (nic->phy == phy_82552_v) ? E100_82552_LED_ON :
2655 (nic->mac < mac_82559_D101M) ? led_on_557 : led_on_559;
2659 leds = (nic->phy == phy_82552_v) ? E100_82552_LED_OFF : led_off;
2666 mdio_write(netdev, nic->mii.phy_id, led_reg, leds);
2701 struct nic *nic = netdev_priv(netdev);
2707 data[i++] = nic->tx_deferred;
2708 data[i++] = nic->tx_single_collisions;
2709 data[i++] = nic->tx_multiple_collisions;
2710 data[i++] = nic->tx_fc_pause;
2711 data[i++] = nic->rx_fc_pause;
2712 data[i++] = nic->rx_fc_unsupported;
2713 data[i++] = nic->tx_tco_frames;
2714 data[i++] = nic->rx_tco_frames;
2715 data[i++] = nic->rx_short_frame_errors;
2716 data[i++] = nic->rx_over_length_errors;
2758 struct nic *nic = netdev_priv(netdev);
2760 return generic_mii_ioctl(&nic->mii, if_mii(ifr), cmd, NULL);
2763 static int e100_alloc(struct nic *nic)
2765 nic->mem = dma_alloc_coherent(&nic->pdev->dev, sizeof(struct mem),
2766 &nic->dma_addr, GFP_KERNEL);
2767 return nic->mem ? 0 : -ENOMEM;
2770 static void e100_free(struct nic *nic)
2772 if (nic->mem) {
2773 dma_free_coherent(&nic->pdev->dev, sizeof(struct mem),
2774 nic->mem, nic->dma_addr);
2775 nic->mem = NULL;
2781 struct nic *nic = netdev_priv(netdev);
2785 if ((err = e100_up(nic)))
2786 netif_err(nic, ifup, nic->netdev, "Cannot open interface, aborting\n");
2799 struct nic *nic = netdev_priv(netdev);
2806 e100_exec_cb(nic, NULL, e100_configure);
2828 struct nic *nic;
2831 if (!(netdev = alloc_etherdev(sizeof(struct nic))))
2843 nic = netdev_priv(netdev);
2844 netif_napi_add(netdev, &nic->napi, e100_poll, E100_NAPI_WEIGHT);
2845 nic->netdev = netdev;
2846 nic->pdev = pdev;
2847 nic->msg_enable = (1 << debug) - 1;
2848 nic->mdio_ctrl = mdio_ctrl_hw;
2852 netif_err(nic, probe, nic->netdev, "Cannot enable PCI device, aborting\n");
2857 netif_err(nic, probe, nic->netdev, "Cannot find proper PCI device base address, aborting\n");
2863 netif_err(nic, probe, nic->netdev, "Cannot obtain PCI resources, aborting\n");
2868 netif_err(nic, probe, nic->netdev, "No usable DMA configuration, aborting\n");
2875 netif_info(nic, probe, nic->netdev, "using i/o access mode\n");
2877 nic->csr = pci_iomap(pdev, (use_io ? 1 : 0), sizeof(struct csr));
2878 if (!nic->csr) {
2879 netif_err(nic, probe, nic->netdev, "Cannot map device registers, aborting\n");
2885 nic->flags |= ich;
2887 nic->flags &= ~ich;
2889 e100_get_defaults(nic);
2892 if (nic->mac < mac_82558_D101_A4)
2896 spin_lock_init(&nic->cb_lock);
2897 spin_lock_init(&nic->cmd_lock);
2898 spin_lock_init(&nic->mdio_lock);
2903 e100_hw_reset(nic);
2907 timer_setup(&nic->watchdog, e100_watchdog, 0);
2909 INIT_WORK(&nic->tx_timeout_task, e100_tx_timeout_task);
2911 if ((err = e100_alloc(nic))) {
2912 netif_err(nic, probe, nic->netdev, "Cannot alloc driver memory, aborting\n");
2916 if ((err = e100_eeprom_load(nic)))
2919 e100_phy_init(nic);
2921 memcpy(netdev->dev_addr, nic->eeprom, ETH_ALEN);
2924 netif_err(nic, probe, nic->netdev, "Invalid MAC address from EEPROM, aborting\n");
2928 netif_err(nic, probe, nic->netdev, "Invalid MAC address from EEPROM, you MUST configure one.\n");
2933 if ((nic->mac >= mac_82558_D101_A4) &&
2934 (le16_to_cpu(nic->eeprom[eeprom_id]) & eeprom_id_wol)) {
2935 nic->flags |= wol_magic;
2944 netif_err(nic, probe, nic->netdev, "Cannot register net device, aborting\n");
2947 nic->cbs_pool = dma_pool_create(netdev->name,
2948 &nic->pdev->dev,
2949 nic->params.cbs.max * sizeof(struct cb),
2952 if (!nic->cbs_pool) {
2953 netif_err(nic, probe, nic->netdev, "Cannot create DMA pool, aborting\n");
2957 netif_info(nic, probe, nic->netdev,
2967 e100_free(nic);
2969 pci_iounmap(pdev, nic->csr);
2984 struct nic *nic = netdev_priv(netdev);
2986 e100_free(nic);
2987 pci_iounmap(pdev, nic->csr);
2988 dma_pool_destroy(nic->cbs_pool);
3001 struct nic *nic = netdev_priv(netdev);
3006 e100_down(nic);
3008 if ((nic->flags & wol_magic) | e100_asf(nic)) {
3010 if (nic->phy == phy_82552_v) {
3011 u16 smartspeed = mdio_read(netdev, nic->mii.phy_id,
3014 mdio_write(netdev, nic->mii.phy_id,
3049 struct nic *nic = netdev_priv(netdev);
3060 if (nic->phy == phy_82552_v) {
3061 u16 smartspeed = mdio_read(netdev, nic->mii.phy_id,
3064 mdio_write(netdev, nic->mii.phy_id,
3070 e100_up(nic);
3094 struct nic *nic = netdev_priv(netdev);
3102 e100_down(nic);
3118 struct nic *nic = netdev_priv(netdev);
3129 e100_hw_reset(nic);
3130 e100_phy_init(nic);
3145 struct nic *nic = netdev_priv(netdev);
3153 mod_timer(&nic->watchdog, jiffies);