1415 int retval; |
1413 int retval; |
1416 void __iomem *ioaddr = tp->mmio_addr; |
1414 void __iomem *ioaddr = tp->mmio_addr; |
1417 |
1415 |
1418 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1416 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1419 |
1417 |
1420 #ifdef EC_DEBUG |
1418 if (dev != rtl_ec_net_dev) { |
1421 printk(KERN_DEBUG "%s: open\n", dev->name); |
1419 retval = request_irq(dev->irq, rtl8139_interrupt, |
1422 #endif |
1420 SA_SHIRQ, dev->name, dev); |
1423 |
1421 if (retval) |
1424 if (dev != rtl_ec_net_dev) { |
1422 return retval; |
1425 retval = request_irq(dev->irq, rtl8139_interrupt, |
1423 } |
1426 SA_SHIRQ, dev->name, dev); |
|
1427 if (retval) |
|
1428 return retval; |
|
1429 } |
|
1430 |
1424 |
1431 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1425 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1432 |
1426 |
1433 tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN, |
1427 tp->tx_bufs = pci_alloc_consistent(tp->pci_dev, TX_BUF_TOT_LEN, |
1434 &tp->tx_bufs_dma); |
1428 &tp->tx_bufs_dma); |
1435 tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN, |
1429 tp->rx_ring = pci_alloc_consistent(tp->pci_dev, RX_BUF_TOT_LEN, |
1436 &tp->rx_ring_dma); |
1430 &tp->rx_ring_dma); |
1437 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) |
1431 if (tp->tx_bufs == NULL || tp->rx_ring == NULL) { |
1438 { |
1432 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1439 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1433 |
1440 |
1434 if (dev != rtl_ec_net_dev) { |
1441 if (dev != rtl_ec_net_dev) { |
1435 free_irq(dev->irq, dev); |
1442 free_irq(dev->irq, dev); |
1436 } |
1443 } |
1437 |
1444 |
1438 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1445 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1439 |
1446 |
1440 if (tp->tx_bufs) |
1447 if (tp->tx_bufs) |
1441 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN, |
1448 pci_free_consistent(tp->pci_dev, TX_BUF_TOT_LEN, |
1442 tp->tx_bufs, tp->tx_bufs_dma); |
1449 tp->tx_bufs, tp->tx_bufs_dma); |
1443 if (tp->rx_ring) |
1450 if (tp->rx_ring) |
1444 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN, |
1451 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN, |
1445 tp->rx_ring, tp->rx_ring_dma); |
1452 tp->rx_ring, tp->rx_ring_dma); |
1446 |
1453 |
1447 return -ENOMEM; |
1454 return -ENOMEM; |
1448 |
1455 } |
1449 } |
1456 |
1450 |
1457 tp->mii.full_duplex = tp->mii.force_media; |
1451 tp->mii.full_duplex = tp->mii.force_media; |
1458 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000; |
1452 tp->tx_flag = (TX_FIFO_THRESH << 11) & 0x003f0000; |
1459 |
1453 |
1460 rtl8139_init_ring (dev); |
1454 rtl8139_init_ring (dev); |
1461 rtl8139_hw_start (dev); |
1455 rtl8139_hw_start (dev); |
1462 |
1456 |
1463 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1457 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1464 |
1458 |
1465 if (dev != rtl_ec_net_dev) { |
1459 if (dev != rtl_ec_net_dev) { |
1466 netif_start_queue (dev); |
1460 netif_start_queue (dev); |
1467 |
1461 |
1468 if (netif_msg_ifup(tp)) { |
1462 if (netif_msg_ifup(tp)) |
1469 printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#lx IRQ %d" |
1463 printk(KERN_DEBUG "%s: rtl8139_open() ioaddr %#lx IRQ %d" |
1470 " GP Pins %2.2x %s-duplex.\n", |
1464 " GP Pins %2.2x %s-duplex.\n", |
1471 dev->name, pci_resource_start (tp->pci_dev, 1), |
1465 dev->name, pci_resource_start (tp->pci_dev, 1), |
1472 dev->irq, RTL_R8 (MediaStatus), |
1466 dev->irq, RTL_R8 (MediaStatus), |
1473 tp->mii.full_duplex ? "full" : "half"); |
1467 tp->mii.full_duplex ? "full" : "half"); |
1474 } |
1468 |
1475 |
1469 rtl8139_start_thread(dev); |
1476 rtl8139_start_thread(dev); |
1470 } |
|
1471 |
|
1472 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
|
1473 |
|
1474 return 0; |
|
1475 } |
|
1476 |
|
1477 |
|
1478 static void rtl_check_media (struct net_device *dev, unsigned int init_media) |
|
1479 { |
|
1480 struct rtl8139_private *tp = netdev_priv(dev); |
|
1481 |
|
1482 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
|
1483 |
|
1484 if (dev != rtl_ec_net_dev) { |
|
1485 if (tp->phys[0] >= 0) { |
|
1486 mii_check_media(&tp->mii, netif_msg_link(tp), init_media); |
1477 } |
1487 } |
|
1488 } else { |
|
1489 void __iomem *ioaddr = tp->mmio_addr; |
|
1490 uint16_t state = RTL_R16(BasicModeStatus) & BMSR_LSTATUS; |
|
1491 ecdev_link_state(rtl_ec_dev, state ? 1 : 0); |
|
1492 } |
1478 |
1493 |
1479 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1494 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1480 |
1495 |
1481 return 0; |
|
1482 } |
|
1483 |
|
1484 |
|
1485 static void rtl_check_media (struct net_device *dev, unsigned int init_media) |
|
1486 { |
|
1487 struct rtl8139_private *tp = netdev_priv(dev); |
|
1488 |
|
1489 if (dev == rtl_ec_net_dev) { |
|
1490 void __iomem *ioaddr = tp->mmio_addr; |
|
1491 uint16_t state = RTL_R16(BasicModeStatus) & BMSR_LSTATUS; |
|
1492 ecdev_link_state(rtl_ec_dev, state ? 1 : 0); |
|
1493 } |
|
1494 else if (tp->phys[0] >= 0) { |
|
1495 mii_check_media(&tp->mii, netif_msg_link(tp), init_media); |
|
1496 } |
|
1497 } |
1496 } |
1498 |
1497 |
1499 /* Start the hardware at open or resume. */ |
1498 /* Start the hardware at open or resume. */ |
1500 static void rtl8139_hw_start (struct net_device *dev) |
1499 static void rtl8139_hw_start (struct net_device *dev) |
1501 { |
1500 { |
1816 dev->name, i, RTL_R32 (TxStatus0 + (i * 4)), |
1815 dev->name, i, RTL_R32 (TxStatus0 + (i * 4)), |
1817 i == tp->dirty_tx % NUM_TX_DESC ? |
1816 i == tp->dirty_tx % NUM_TX_DESC ? |
1818 " (queue head)" : ""); |
1817 " (queue head)" : ""); |
1819 |
1818 |
1820 tp->xstats.tx_timeouts++; |
1819 tp->xstats.tx_timeouts++; |
1821 printk(KERN_DEBUG "%s: tx_timeout\n", dev->name); |
|
1822 |
1820 |
1823 /* disable Tx ASAP, if not already */ |
1821 /* disable Tx ASAP, if not already */ |
1824 tmp8 = RTL_R8 (ChipCmd); |
1822 tmp8 = RTL_R8 (ChipCmd); |
1825 if (tmp8 & CmdTxEnb) |
1823 if (tmp8 & CmdTxEnb) |
1826 RTL_W8 (ChipCmd, CmdRxEnb); |
1824 RTL_W8 (ChipCmd, CmdRxEnb); |
1827 |
1825 |
1828 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1826 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1829 |
1827 |
1830 |
1828 if (dev != rtl_ec_net_dev) { |
1831 if (dev != rtl_ec_net_dev) { |
1829 spin_lock(&tp->rx_lock); |
1832 spin_lock(&tp->rx_lock); |
1830 /* Disable interrupts by clearing the interrupt mask. */ |
1833 |
1831 RTL_W16 (IntrMask, 0x0000); |
1834 /* Disable interrupts by clearing the interrupt mask. */ |
1832 |
1835 RTL_W16 (IntrMask, 0x0000); |
1833 /* Stop a shared interrupt from scavenging while we are. */ |
1836 |
1834 spin_lock_irqsave (&tp->lock, flags); |
1837 /* Stop a shared interrupt from scavenging while we are. */ |
1835 rtl8139_tx_clear (tp); |
1838 spin_lock_irqsave (&tp->lock, flags); |
1836 spin_unlock_irqrestore (&tp->lock, flags); |
1839 rtl8139_tx_clear (tp); |
1837 |
1840 spin_unlock_irqrestore (&tp->lock, flags); |
1838 /* ...and finally, reset everything */ |
1841 |
1839 if (netif_running(dev)) { |
1842 /* ...and finally, reset everything */ |
1840 rtl8139_hw_start (dev); |
1843 |
1841 netif_wake_queue (dev); |
1844 if (netif_running(dev)) { |
|
1845 rtl8139_hw_start (dev); |
|
1846 netif_wake_queue (dev); |
|
1847 } |
|
1848 |
|
1849 spin_unlock(&tp->rx_lock); |
|
1850 } |
1842 } |
1851 else { |
1843 spin_unlock(&tp->rx_lock); |
1852 rtl8139_tx_clear (tp); |
1844 } else { |
1853 rtl8139_hw_start(dev); |
1845 rtl8139_tx_clear (tp); |
1854 } |
1846 rtl8139_hw_start(dev); |
|
1847 } |
1855 |
1848 |
1856 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1849 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1857 } |
1850 } |
|
1851 |
1858 |
1852 |
1859 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev) |
1853 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev) |
1860 { |
1854 { |
1861 struct rtl8139_private *tp = netdev_priv(dev); |
1855 struct rtl8139_private *tp = netdev_priv(dev); |
1862 void __iomem *ioaddr = tp->mmio_addr; |
1856 void __iomem *ioaddr = tp->mmio_addr; |
1864 unsigned int len = skb->len; |
1858 unsigned int len = skb->len; |
1865 |
1859 |
1866 /* Calculate the next Tx descriptor entry. */ |
1860 /* Calculate the next Tx descriptor entry. */ |
1867 entry = tp->cur_tx % NUM_TX_DESC; |
1861 entry = tp->cur_tx % NUM_TX_DESC; |
1868 |
1862 |
1869 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1863 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1870 |
1864 |
1871 /* Note: the chip doesn't have auto-pad! */ |
1865 /* Note: the chip doesn't have auto-pad! */ |
1872 if (likely(len < TX_BUF_SIZE)) |
1866 if (likely(len < TX_BUF_SIZE)) { |
1873 { |
1867 if (len < ETH_ZLEN) |
1874 if (len < ETH_ZLEN) |
1868 memset(tp->tx_buf[entry], 0, ETH_ZLEN); |
1875 memset(tp->tx_buf[entry], 0, ETH_ZLEN); |
1869 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]); |
1876 |
1870 if (dev != rtl_ec_net_dev) { |
1877 skb_copy_and_csum_dev(skb, tp->tx_buf[entry]); |
1871 dev_kfree_skb(skb); |
1878 if (dev != rtl_ec_net_dev) dev_kfree_skb(skb); |
1872 } |
1879 } |
1873 } else { |
1880 else |
1874 if (dev != rtl_ec_net_dev) { |
1881 { |
1875 dev_kfree_skb(skb); |
1882 if (dev != rtl_ec_net_dev) dev_kfree_skb(skb); |
1876 } |
1883 tp->stats.tx_dropped++; |
1877 tp->stats.tx_dropped++; |
1884 return 0; |
1878 return 0; |
1885 } |
1879 } |
1886 |
1880 |
1887 if (dev != rtl_ec_net_dev) { |
1881 if (dev != rtl_ec_net_dev) { |
1888 spin_lock_irq(&tp->lock); |
1882 spin_lock_irq(&tp->lock); |
1889 } |
1883 } |
1890 |
1884 |
1891 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1885 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1892 |
1886 |
1893 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)), |
1887 RTL_W32_F (TxStatus0 + (entry * sizeof (u32)), |
1894 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN)); |
1888 tp->tx_flag | max(len, (unsigned int)ETH_ZLEN)); |
1969 |
1961 |
1970 dirty_tx++; |
1962 dirty_tx++; |
1971 tx_left--; |
1963 tx_left--; |
1972 } |
1964 } |
1973 |
1965 |
1974 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1966 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1975 |
1967 |
1976 #ifndef RTL8139_NDEBUG |
1968 #ifndef RTL8139_NDEBUG |
1977 if (dev != rtl_ec_net_dev && tp->cur_tx - dirty_tx > NUM_TX_DESC) { |
1969 if (dev != rtl_ec_net_dev && tp->cur_tx - dirty_tx > NUM_TX_DESC) { |
1978 printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n", |
1970 printk (KERN_ERR "%s: Out-of-sync dirty pointer, %ld vs. %ld.\n", |
1979 dev->name, dirty_tx, tp->cur_tx); |
1971 dev->name, dirty_tx, tp->cur_tx); |
1980 dirty_tx += NUM_TX_DESC; |
1972 dirty_tx += NUM_TX_DESC; |
1981 } |
1973 } |
1982 #endif /* RTL8139_NDEBUG */ |
1974 #endif /* RTL8139_NDEBUG */ |
1983 |
1975 |
1984 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1976 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1985 |
1977 |
1986 /* only wake the queue if we did work, and the queue is stopped */ |
1978 /* only wake the queue if we did work, and the queue is stopped */ |
1987 if (tp->dirty_tx != dirty_tx) { |
1979 if (tp->dirty_tx != dirty_tx) { |
1988 tp->dirty_tx = dirty_tx; |
1980 tp->dirty_tx = dirty_tx; |
1989 mb(); |
1981 mb(); |
1990 |
1982 |
1991 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1983 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
1992 |
1984 |
1993 if (dev != rtl_ec_net_dev) { |
1985 if (dev != rtl_ec_net_dev) { |
1994 netif_wake_queue (dev); |
1986 netif_wake_queue (dev); |
1995 } |
1987 } |
1996 |
1988 |
1997 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1989 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
1998 } |
1990 } |
1999 } |
1991 } |
2000 |
1992 |
2001 |
1993 |
2002 /* TODO: clean this up! Rx reset need not be this intensive */ |
1994 /* TODO: clean this up! Rx reset need not be this intensive */ |
2126 DPRINTK ("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x," |
2118 DPRINTK ("%s: In rtl8139_rx(), current %4.4x BufAddr %4.4x," |
2127 " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx, |
2119 " free to %4.4x, Cmd %2.2x.\n", dev->name, (u16)cur_rx, |
2128 RTL_R16 (RxBufAddr), |
2120 RTL_R16 (RxBufAddr), |
2129 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd)); |
2121 RTL_R16 (RxBufPtr), RTL_R8 (ChipCmd)); |
2130 |
2122 |
|
2123 |
|
2124 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
|
2125 |
2131 while ((dev == rtl_ec_net_dev || netif_running(dev)) |
2126 while ((dev == rtl_ec_net_dev || netif_running(dev)) |
2132 && received < budget |
2127 && received < budget |
2133 && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) { |
2128 && (RTL_R8 (ChipCmd) & RxBufEmpty) == 0) { |
|
2129 |
|
2130 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
|
2131 |
2134 u32 ring_offset = cur_rx % RX_BUF_LEN; |
2132 u32 ring_offset = cur_rx % RX_BUF_LEN; |
2135 u32 rx_status; |
2133 u32 rx_status; |
2136 unsigned int pkt_size; |
2134 unsigned int pkt_size; |
2137 struct sk_buff *skb; |
2135 struct sk_buff *skb; |
2138 |
2136 |
2141 /* read size+status of next frame from DMA ring buffer */ |
2139 /* read size+status of next frame from DMA ring buffer */ |
2142 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset)); |
2140 rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset)); |
2143 rx_size = rx_status >> 16; |
2141 rx_size = rx_status >> 16; |
2144 pkt_size = rx_size - 4; |
2142 pkt_size = rx_size - 4; |
2145 |
2143 |
2146 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2144 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2147 |
2145 |
2148 if (dev != rtl_ec_net_dev && netif_msg_rx_status(tp)) |
2146 if (dev != rtl_ec_net_dev) { |
2149 printk(KERN_DEBUG "%s: rtl8139_rx() status %4.4x, size %4.4x," |
2147 if (netif_msg_rx_status(tp)) |
2150 " cur %4.4x.\n", dev->name, rx_status, |
2148 printk(KERN_DEBUG "%s: rtl8139_rx() status %4.4x, size %4.4x," |
2151 rx_size, cur_rx); |
2149 " cur %4.4x.\n", dev->name, rx_status, |
2152 |
2150 rx_size, cur_rx); |
2153 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2151 } |
|
2152 |
|
2153 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2154 |
2154 |
2155 #if RTL8139_DEBUG > 2 |
2155 #if RTL8139_DEBUG > 2 |
2156 { |
2156 { |
2157 int i; |
2157 int i; |
2158 DPRINTK ("%s: Frame contents ", dev->name); |
2158 DPRINTK ("%s: Frame contents ", dev->name); |
2197 rtl8139_rx_err (rx_status, dev, tp, ioaddr); |
2197 rtl8139_rx_err (rx_status, dev, tp, ioaddr); |
2198 received = -1; |
2198 received = -1; |
2199 goto out; |
2199 goto out; |
2200 } |
2200 } |
2201 |
2201 |
2202 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2202 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2203 |
2203 |
2204 if (dev != rtl_ec_net_dev) { |
2204 if (dev != rtl_ec_net_dev) { |
2205 /* Malloc up new buffer, compatible with net-2e. */ |
2205 /* Malloc up new buffer, compatible with net-2e. */ |
2206 /* Omit the four octet CRC from the length. */ |
2206 /* Omit the four octet CRC from the length. */ |
2207 skb = dev_alloc_skb(pkt_size + 2); |
2207 |
2208 |
2208 skb = dev_alloc_skb (pkt_size + 2); |
2209 if (likely(skb)) { |
2209 if (likely(skb)) { |
2210 skb->dev = dev; |
2210 skb->dev = dev; |
2211 skb_reserve (skb, 2); /* 16 byte align the IP fields. */ |
2211 skb_reserve (skb, 2); /* 16 byte align the IP fields. */ |
2212 #if RX_BUF_IDX == 3 |
2212 #if RX_BUF_IDX == 3 |
2213 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size); |
2213 wrap_copy(skb, rx_ring, ring_offset+4, pkt_size); |
2214 #else |
2214 #else |
2215 eth_copy_and_sum (skb, &rx_ring[ring_offset + 4], pkt_size, 0); |
2215 eth_copy_and_sum (skb, &rx_ring[ring_offset + 4], pkt_size, 0); |
2216 #endif |
2216 #endif |
2217 skb_put (skb, pkt_size); |
2217 skb_put (skb, pkt_size); |
2218 |
2218 |
2219 skb->protocol = eth_type_trans (skb, dev); |
2219 skb->protocol = eth_type_trans (skb, dev); |
2220 |
2220 |
2221 dev->last_rx = jiffies; |
2221 dev->last_rx = jiffies; |
2222 tp->stats.rx_bytes += pkt_size; |
2222 tp->stats.rx_bytes += pkt_size; |
2223 tp->stats.rx_packets++; |
2223 tp->stats.rx_packets++; |
2224 |
2224 |
2225 netif_receive_skb (skb); |
2225 netif_receive_skb (skb); |
2226 } else { |
2226 } else { |
2227 if (net_ratelimit()) |
2227 if (net_ratelimit()) |
2228 printk (KERN_WARNING |
2228 printk (KERN_WARNING |
2229 "%s: Memory squeeze, dropping packet.\n", |
2229 "%s: Memory squeeze, dropping packet.\n", |
2230 dev->name); |
2230 dev->name); |
2231 tp->stats.rx_dropped++; |
2231 tp->stats.rx_dropped++; |
2232 } |
2232 } |
2233 } |
2233 } else { |
2234 else |
2234 ecdev_receive(rtl_ec_dev, |
2235 { |
2235 &rx_ring[ring_offset + 4], pkt_size); |
2236 ecdev_receive(rtl_ec_dev, |
2236 dev->last_rx = jiffies; |
2237 &rx_ring[ring_offset + 4], pkt_size); |
2237 tp->stats.rx_bytes += pkt_size; |
2238 dev->last_rx = jiffies; |
2238 tp->stats.rx_packets++; |
2239 tp->stats.rx_bytes += pkt_size; |
2239 } |
2240 tp->stats.rx_packets++; |
2240 |
2241 } |
2241 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2242 |
|
2243 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
|
2244 |
2242 |
2245 received++; |
2243 received++; |
2246 |
2244 |
2247 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3; |
2245 cur_rx = (cur_rx + rx_size + 4 + 3) & ~3; |
2248 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16)); |
2246 RTL_W16 (RxBufPtr, (u16) (cur_rx - 16)); |
2358 void __iomem *ioaddr = tp->mmio_addr; |
2355 void __iomem *ioaddr = tp->mmio_addr; |
2359 u16 status, ackstat; |
2356 u16 status, ackstat; |
2360 int link_changed = 0; /* avoid bogus "uninit" warning */ |
2357 int link_changed = 0; /* avoid bogus "uninit" warning */ |
2361 int handled = 0; |
2358 int handled = 0; |
2362 |
2359 |
2363 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2360 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2364 |
2361 |
2365 if (dev == rtl_ec_net_dev) { |
2362 if (dev != rtl_ec_net_dev) { |
2366 status = RTL_R16 (IntrStatus); |
2363 spin_lock (&tp->lock); |
2367 } |
2364 status = RTL_R16 (IntrStatus); |
2368 else { |
2365 |
2369 spin_lock(&tp->lock); |
2366 /* shared irq? */ |
2370 |
2367 if (unlikely((status & rtl8139_intr_mask) == 0)) |
2371 status = RTL_R16 (IntrStatus); |
2368 goto out; |
2372 |
2369 } else { |
2373 if (unlikely((status & rtl8139_intr_mask) == 0)) |
2370 status = RTL_R16 (IntrStatus); |
2374 goto out; |
2371 } |
2375 } |
2372 |
2376 |
2373 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2377 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
|
2378 |
2374 |
2379 handled = 1; |
2375 handled = 1; |
2380 |
2376 |
2381 /* h/w no longer present (hotplug?) or major error, bail */ |
2377 /* h/w no longer present (hotplug?) or major error, bail */ |
2382 if (unlikely(status == 0xFFFF)) |
2378 if (unlikely(status == 0xFFFF)) |
2383 goto out; |
2379 goto out; |
2384 |
2380 |
2385 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2381 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2386 |
2382 |
2387 if (dev != rtl_ec_net_dev) { |
2383 if (dev != rtl_ec_net_dev) { |
2388 /* close possible race's with dev_close */ |
2384 /* close possible race's with dev_close */ |
2389 if (unlikely(!netif_running(dev))) { |
2385 if (unlikely(!netif_running(dev))) { |
2390 RTL_W16 (IntrMask, 0); |
2386 RTL_W16 (IntrMask, 0); |
2391 goto out; |
2387 goto out; |
2392 } |
2388 } |
2393 } |
2389 } |
2394 |
2390 |
2395 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2391 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2396 |
2392 |
2397 /* Acknowledge all of the current interrupt sources ASAP, but |
2393 /* Acknowledge all of the current interrupt sources ASAP, but |
2398 an first get an additional status bit from CSCR. */ |
2394 an first get an additional status bit from CSCR. */ |
2399 if (unlikely(status & RxUnderrun)) |
2395 if (unlikely(status & RxUnderrun)) |
2400 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit; |
2396 link_changed = RTL_R16 (CSCR) & CSCR_LinkChangeBit; |
2401 |
2397 |
2402 ackstat = status & ~(RxAckBits | TxErr); |
2398 ackstat = status & ~(RxAckBits | TxErr); |
2403 if (ackstat) { |
2399 if (ackstat) |
2404 RTL_W16 (IntrStatus, ackstat); |
2400 RTL_W16 (IntrStatus, ackstat); |
2405 } |
|
2406 |
2401 |
2407 /* Receive packets are processed by poll routine. |
2402 /* Receive packets are processed by poll routine. |
2408 If not running start it now. */ |
2403 If not running start it now. */ |
2409 |
2404 |
2410 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2405 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2411 |
2406 |
2412 if (status & RxAckBits) |
2407 if (status & RxAckBits){ |
2413 { |
2408 if (dev != rtl_ec_net_dev) { |
2414 if (dev != rtl_ec_net_dev) { |
2409 /* Mark for polling */ |
2415 /* Mark for polling */ |
2410 if (netif_rx_schedule_prep(dev)) { |
2416 if (netif_rx_schedule_prep(dev)) { |
2411 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask); |
2417 RTL_W16_F (IntrMask, rtl8139_norx_intr_mask); |
2412 __netif_rx_schedule (dev); |
2418 __netif_rx_schedule (dev); |
|
2419 } |
|
2420 } |
2413 } |
2421 else { |
2414 } else { |
2422 /* EtherCAT device: Just receive all frames */ |
2415 /* EtherCAT device: Just receive all frames */ |
2423 rtl8139_rx(dev, tp, 100); // FIXME |
2416 rtl8139_rx(dev, tp, 100); // FIXME |
2424 } |
2417 } |
2425 } |
2418 } |
2426 |
2419 |
2427 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2420 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2428 |
2421 |
2429 /* Check uncommon events with one test. */ |
2422 /* Check uncommon events with one test. */ |
2430 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr))) |
2423 if (unlikely(status & (PCIErr | PCSTimeout | RxUnderrun | RxErr))) |
2431 rtl8139_weird_interrupt (dev, tp, ioaddr, |
2424 rtl8139_weird_interrupt (dev, tp, ioaddr, |
2432 status, link_changed); |
2425 status, link_changed); |
2435 rtl8139_tx_interrupt (dev, tp, ioaddr); |
2428 rtl8139_tx_interrupt (dev, tp, ioaddr); |
2436 if (status & TxErr) |
2429 if (status & TxErr) |
2437 RTL_W16 (IntrStatus, TxErr); |
2430 RTL_W16 (IntrStatus, TxErr); |
2438 } |
2431 } |
2439 out: |
2432 out: |
2440 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2433 |
|
2434 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2441 |
2435 |
2442 if (dev != rtl_ec_net_dev) { |
2436 if (dev != rtl_ec_net_dev) { |
2443 spin_unlock (&tp->lock); |
2437 spin_unlock (&tp->lock); |
2444 } |
2438 } |
2445 |
2439 |
2446 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2440 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2447 |
2441 |
2448 DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n", |
2442 DPRINTK ("%s: exiting interrupt, intr_status=%#4.4x.\n", |
2449 dev->name, RTL_R16 (IntrStatus)); |
2443 dev->name, RTL_R16 (IntrStatus)); |
2450 return IRQ_RETVAL(handled); |
2444 return IRQ_RETVAL(handled); |
2451 } |
2445 } |
2468 struct rtl8139_private *tp = netdev_priv(dev); |
2462 struct rtl8139_private *tp = netdev_priv(dev); |
2469 void __iomem *ioaddr = tp->mmio_addr; |
2463 void __iomem *ioaddr = tp->mmio_addr; |
2470 int ret = 0; |
2464 int ret = 0; |
2471 unsigned long flags; |
2465 unsigned long flags; |
2472 |
2466 |
2473 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2467 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2474 |
2468 |
2475 if (dev != rtl_ec_net_dev) { |
2469 if (dev != rtl_ec_net_dev) { |
2476 netif_stop_queue(dev); |
2470 netif_stop_queue (dev); |
2477 if (tp->thr_pid >= 0) { |
2471 |
2478 tp->time_to_die = 1; |
2472 if (tp->thr_pid >= 0) { |
2479 wmb(); |
2473 tp->time_to_die = 1; |
2480 ret = kill_proc (tp->thr_pid, SIGTERM, 1); |
2474 wmb(); |
2481 if (ret) { |
2475 ret = kill_proc (tp->thr_pid, SIGTERM, 1); |
2482 printk (KERN_ERR "%s: unable to signal thread\n", dev->name); |
2476 if (ret) { |
2483 return ret; |
2477 printk (KERN_ERR "%s: unable to signal thread\n", dev->name); |
2484 } |
2478 return ret; |
2485 wait_for_completion (&tp->thr_exited); |
|
2486 } |
2479 } |
2487 |
2480 wait_for_completion (&tp->thr_exited); |
2488 if (netif_msg_ifdown(tp)) |
|
2489 printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n", |
|
2490 dev->name, RTL_R16 (IntrStatus)); |
|
2491 |
|
2492 spin_lock_irqsave (&tp->lock, flags); |
|
2493 |
|
2494 /* Stop the chip's Tx and Rx DMA processes. */ |
|
2495 RTL_W8 (ChipCmd, 0); |
|
2496 |
|
2497 /* Disable interrupts by clearing the interrupt mask. */ |
|
2498 RTL_W16 (IntrMask, 0); |
|
2499 |
|
2500 /* Update the error counts. */ |
|
2501 tp->stats.rx_missed_errors += RTL_R32 (RxMissed); |
|
2502 RTL_W32 (RxMissed, 0); |
|
2503 |
|
2504 spin_unlock_irqrestore (&tp->lock, flags); |
|
2505 |
|
2506 synchronize_irq (dev->irq); /* racy, but that's ok here */ |
|
2507 free_irq (dev->irq, dev); |
|
2508 } |
2481 } |
2509 else { |
2482 |
2510 /* Stop the chip's Tx and Rx DMA processes. */ |
2483 if (netif_msg_ifdown(tp)) |
2511 RTL_W8 (ChipCmd, 0); |
2484 printk(KERN_DEBUG "%s: Shutting down ethercard, status was 0x%4.4x.\n", |
2512 |
2485 dev->name, RTL_R16 (IntrStatus)); |
2513 /* Disable interrupts by clearing the interrupt mask. */ |
2486 |
2514 RTL_W16 (IntrMask, 0); |
2487 spin_lock_irqsave (&tp->lock, flags); |
2515 |
2488 |
2516 /* Update the error counts. */ |
2489 /* Stop the chip's Tx and Rx DMA processes. */ |
2517 tp->stats.rx_missed_errors += RTL_R32 (RxMissed); |
2490 RTL_W8 (ChipCmd, 0); |
2518 RTL_W32 (RxMissed, 0); |
2491 |
2519 } |
2492 /* Disable interrupts by clearing the interrupt mask. */ |
2520 |
2493 RTL_W16 (IntrMask, 0); |
2521 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2494 |
|
2495 /* Update the error counts. */ |
|
2496 tp->stats.rx_missed_errors += RTL_R32 (RxMissed); |
|
2497 RTL_W32 (RxMissed, 0); |
|
2498 |
|
2499 spin_unlock_irqrestore (&tp->lock, flags); |
|
2500 |
|
2501 synchronize_irq (dev->irq); /* racy, but that's ok here */ |
|
2502 free_irq (dev->irq, dev); |
|
2503 } else { |
|
2504 /* Stop the chip's Tx and Rx DMA processes. */ |
|
2505 RTL_W8 (ChipCmd, 0); |
|
2506 |
|
2507 /* Disable interrupts by clearing the interrupt mask. */ |
|
2508 RTL_W16 (IntrMask, 0); |
|
2509 |
|
2510 /* Update the error counts. */ |
|
2511 tp->stats.rx_missed_errors += RTL_R32 (RxMissed); |
|
2512 RTL_W32 (RxMissed, 0); |
|
2513 } |
|
2514 |
|
2515 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2522 |
2516 |
2523 rtl8139_tx_clear (tp); |
2517 rtl8139_tx_clear (tp); |
2524 |
2518 |
2525 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN, |
2519 pci_free_consistent(tp->pci_dev, RX_BUF_TOT_LEN, |
2526 tp->rx_ring, tp->rx_ring_dma); |
2520 tp->rx_ring, tp->rx_ring_dma); |
2752 { |
2746 { |
2753 struct rtl8139_private *tp = netdev_priv(dev); |
2747 struct rtl8139_private *tp = netdev_priv(dev); |
2754 void __iomem *ioaddr = tp->mmio_addr; |
2748 void __iomem *ioaddr = tp->mmio_addr; |
2755 unsigned long flags; |
2749 unsigned long flags; |
2756 |
2750 |
2757 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2751 /* EtherCAT >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>*/ |
2758 |
2752 |
2759 if (dev == rtl_ec_net_dev || netif_running(dev)) { |
2753 if (dev == rtl_ec_net_dev || netif_running(dev)) { |
2760 spin_lock_irqsave (&tp->lock, flags); |
2754 spin_lock_irqsave (&tp->lock, flags); |
2761 tp->stats.rx_missed_errors += RTL_R32 (RxMissed); |
2755 tp->stats.rx_missed_errors += RTL_R32 (RxMissed); |
2762 RTL_W32 (RxMissed, 0); |
2756 RTL_W32 (RxMissed, 0); |
2763 spin_unlock_irqrestore (&tp->lock, flags); |
2757 spin_unlock_irqrestore (&tp->lock, flags); |
2764 } |
2758 } |
2765 |
2759 |
2766 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2760 /* EtherCAT <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/ |
2767 |
2761 |
2768 return &tp->stats; |
2762 return &tp->stats; |
2769 } |
2763 } |
2770 |
2764 |
2771 /* Set or clear the multicast filter for this adaptor. |
2765 /* Set or clear the multicast filter for this adaptor. |