devices/e1000e/netdev-3.4-ethercat.c
branchstable-1.5
changeset 2492 d7b1a62709af
parent 2491 5e9221a78855
child 2497 505cf41488a4
equal deleted inserted replaced
2491:5e9221a78855 2492:d7b1a62709af
  1168 		eop_desc = E1000_TX_DESC(*tx_ring, eop);
  1168 		eop_desc = E1000_TX_DESC(*tx_ring, eop);
  1169 	}
  1169 	}
  1170 
  1170 
  1171 	tx_ring->next_to_clean = i;
  1171 	tx_ring->next_to_clean = i;
  1172 
  1172 
  1173 	netdev_completed_queue(netdev, pkts_compl, bytes_compl);
  1173 	if (!adapter->ecdev) {
       
  1174 		netdev_completed_queue(netdev, pkts_compl, bytes_compl);
       
  1175 	}
  1174 
  1176 
  1175 #define TX_WAKE_THRESHOLD 32
  1177 #define TX_WAKE_THRESHOLD 32
  1176 	if (!adapter->ecdev && count && netif_carrier_ok(netdev) &&
  1178 	if (!adapter->ecdev && count && netif_carrier_ok(netdev) &&
  1177 	    e1000_desc_unused(tx_ring) >= TX_WAKE_THRESHOLD) {
  1179 	    e1000_desc_unused(tx_ring) >= TX_WAKE_THRESHOLD) {
  1178 		/* Make sure that anybody stopping the queue after this
  1180 		/* Make sure that anybody stopping the queue after this
  1700 	}
  1702 	}
  1701 	/*
  1703 	/*
  1702 	 * read ICR disables interrupts using IAM
  1704 	 * read ICR disables interrupts using IAM
  1703 	 */
  1705 	 */
  1704 
  1706 
  1705 	if (!adapter->ecdev && icr & E1000_ICR_LSC) {
  1707 	if (icr & E1000_ICR_LSC) {
  1706 		hw->mac.get_link_status = true;
  1708 		hw->mac.get_link_status = true;
  1707 		/*
  1709 		/*
  1708 		 * ICH8 workaround-- Call gig speed drop workaround on cable
  1710 		 * ICH8 workaround-- Call gig speed drop workaround on cable
  1709 		 * disconnect (LSC) before accessing any PHY registers
  1711 		 * disconnect (LSC) before accessing any PHY registers
  1710 		 */
  1712 		 */
  1750 	struct net_device *netdev = data;
  1752 	struct net_device *netdev = data;
  1751 	struct e1000_adapter *adapter = netdev_priv(netdev);
  1753 	struct e1000_adapter *adapter = netdev_priv(netdev);
  1752 	struct e1000_hw *hw = &adapter->hw;
  1754 	struct e1000_hw *hw = &adapter->hw;
  1753 	u32 rctl, icr = er32(ICR);
  1755 	u32 rctl, icr = er32(ICR);
  1754 
  1756 
       
  1757 	if (adapter->ecdev) {
       
  1758 		int ec_work_done = 0;
       
  1759 		adapter->clean_rx(adapter->rx_ring, &ec_work_done, 100);
       
  1760 		e1000_clean_tx_irq(adapter->tx_ring);
       
  1761 		return IRQ_HANDLED;
       
  1762 	}
       
  1763 
  1755 	if (!icr || test_bit(__E1000_DOWN, &adapter->state))
  1764 	if (!icr || test_bit(__E1000_DOWN, &adapter->state))
  1756 		return IRQ_NONE;  /* Not our interrupt */
  1765 		return IRQ_NONE;  /* Not our interrupt */
  1757 
  1766 
  1758 	/*
  1767 	/*
  1759 	 * IMS will not auto-mask if INT_ASSERTED is not set, and if it is
  1768 	 * IMS will not auto-mask if INT_ASSERTED is not set, and if it is
  1760 	 * not set, then the adapter didn't send an interrupt
  1769 	 * not set, then the adapter didn't send an interrupt
  1761 	 */
  1770 	 */
  1762 	if (!adapter->ecdev && !(icr & E1000_ICR_INT_ASSERTED))
  1771 	if (!(icr & E1000_ICR_INT_ASSERTED))
  1763 		return IRQ_NONE;
  1772 		return IRQ_NONE;
  1764 
  1773 
  1765 	/*
  1774 	/*
  1766 	 * Interrupt Auto-Mask...upon reading ICR,
  1775 	 * Interrupt Auto-Mask...upon reading ICR,
  1767 	 * interrupts are masked.  No need for the
  1776 	 * interrupts are masked.  No need for the
  1792 			adapter->flags |= FLAG_RX_RESTART_NOW;
  1801 			adapter->flags |= FLAG_RX_RESTART_NOW;
  1793 		}
  1802 		}
  1794 		/* guard against interrupt when we're going down */
  1803 		/* guard against interrupt when we're going down */
  1795 		if (!test_bit(__E1000_DOWN, &adapter->state))
  1804 		if (!test_bit(__E1000_DOWN, &adapter->state))
  1796 			mod_timer(&adapter->watchdog_timer, jiffies + 1);
  1805 			mod_timer(&adapter->watchdog_timer, jiffies + 1);
  1797 	}
       
  1798 
       
  1799 	if (adapter->ecdev) {
       
  1800 		int ec_work_done = 0;
       
  1801 		adapter->clean_rx(adapter->rx_ring, &ec_work_done, 100);
       
  1802 		e1000_clean_tx_irq(adapter->tx_ring);
       
  1803 		return IRQ_HANDLED;
       
  1804 	}
  1806 	}
  1805 
  1807 
  1806 	if (napi_schedule_prep(&adapter->napi)) {
  1808 	if (napi_schedule_prep(&adapter->napi)) {
  1807 		adapter->total_tx_bytes = 0;
  1809 		adapter->total_tx_bytes = 0;
  1808 		adapter->total_tx_packets = 0;
  1810 		adapter->total_tx_packets = 0;
  2124 
  2126 
  2125 static void e1000_free_irq(struct e1000_adapter *adapter)
  2127 static void e1000_free_irq(struct e1000_adapter *adapter)
  2126 {
  2128 {
  2127 	struct net_device *netdev = adapter->netdev;
  2129 	struct net_device *netdev = adapter->netdev;
  2128 
  2130 
  2129 	if (adapter->ecdev)
  2131 	if (adapter->ecdev) {
  2130 		return;
  2132 		return;
       
  2133 	}
  2131 
  2134 
  2132 	if (adapter->msix_entries) {
  2135 	if (adapter->msix_entries) {
  2133 		int vector = 0;
  2136 		int vector = 0;
  2134 
  2137 
  2135 		free_irq(adapter->msix_entries[vector].vector, netdev);
  2138 		free_irq(adapter->msix_entries[vector].vector, netdev);
  4059 
  4062 
  4060 	WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
  4063 	WARN_ON(test_bit(__E1000_RESETTING, &adapter->state));
  4061 
  4064 
  4062 	pm_runtime_get_sync(&pdev->dev);
  4065 	pm_runtime_get_sync(&pdev->dev);
  4063 
  4066 
  4064 	napi_disable(&adapter->napi);
  4067 	if (!adapter->ecdev) {
       
  4068 		napi_disable(&adapter->napi);
       
  4069 	}
  4065 
  4070 
  4066 	if (!test_bit(__E1000_DOWN, &adapter->state)) {
  4071 	if (!test_bit(__E1000_DOWN, &adapter->state)) {
  4067 		e1000e_down(adapter);
  4072 		e1000e_down(adapter);
  4068 		e1000_free_irq(adapter);
  4073 		e1000_free_irq(adapter);
  4069 	}
  4074 	}
  6199 		e1000_watchdog((unsigned long) adapter);
  6204 		e1000_watchdog((unsigned long) adapter);
  6200 		adapter->ec_watchdog_jiffies = jiffies;
  6205 		adapter->ec_watchdog_jiffies = jiffies;
  6201 	}
  6206 	}
  6202 
  6207 
  6203 #ifdef CONFIG_PCI_MSI
  6208 #ifdef CONFIG_PCI_MSI
  6204 	e1000_intr_msi(0,netdev);
  6209 	e1000_intr_msi(0, netdev);
  6205 #else
  6210 #else
  6206 	e1000_intr(0,netdev);
  6211 	e1000_intr(0, netdev);
  6207 #endif
  6212 #endif
  6208 }
  6213 }
  6209 
  6214 
  6210 /**
  6215 /**
  6211  * e1000_probe - Device Initialization Routine
  6216  * e1000_probe - Device Initialization Routine
  6569 {
  6574 {
  6570 	struct net_device *netdev = pci_get_drvdata(pdev);
  6575 	struct net_device *netdev = pci_get_drvdata(pdev);
  6571 	struct e1000_adapter *adapter = netdev_priv(netdev);
  6576 	struct e1000_adapter *adapter = netdev_priv(netdev);
  6572 	bool down = test_bit(__E1000_DOWN, &adapter->state);
  6577 	bool down = test_bit(__E1000_DOWN, &adapter->state);
  6573 
  6578 
       
  6579 	if (adapter->ecdev) {
       
  6580 		ecdev_close(adapter->ecdev);
       
  6581 		ecdev_withdraw(adapter->ecdev);
       
  6582 	}
       
  6583 
  6574 	/*
  6584 	/*
  6575 	 * The timers may be rescheduled, so explicitly disable them
  6585 	 * The timers may be rescheduled, so explicitly disable them
  6576 	 * from being rescheduled.
  6586 	 * from being rescheduled.
  6577 	 */
  6587 	 */
  6578 	if (!down)
  6588 	if (!down)
  6591 
  6601 
  6592 	/* Don't lie to e1000_close() down the road. */
  6602 	/* Don't lie to e1000_close() down the road. */
  6593 	if (!down)
  6603 	if (!down)
  6594 		clear_bit(__E1000_DOWN, &adapter->state);
  6604 		clear_bit(__E1000_DOWN, &adapter->state);
  6595 
  6605 
  6596 	if (adapter->ecdev) {
  6606 	if (!adapter->ecdev) {
  6597 		ecdev_close(adapter->ecdev);
       
  6598 		ecdev_withdraw(adapter->ecdev);
       
  6599 	} else {
       
  6600 		unregister_netdev(netdev);
  6607 		unregister_netdev(netdev);
  6601 	}
  6608 	}
  6602 
  6609 
  6603 	if (pci_dev_run_wake(pdev))
  6610 	if (pci_dev_run_wake(pdev))
  6604 		pm_runtime_get_noresume(&pdev->dev);
  6611 		pm_runtime_get_noresume(&pdev->dev);