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