devices/e1000e/netdev-2.6.34-ethercat.c
changeset 2589 2b9c78543663
parent 2076 1baafcd263cc
equal deleted inserted replaced
2415:af21f0bdc7c9 2589:2b9c78543663
    21 
    21 
    22   Contact Information:
    22   Contact Information:
    23   Linux NICS <linux.nics@intel.com>
    23   Linux NICS <linux.nics@intel.com>
    24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
    24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
    25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
    25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
       
    26 
       
    27   vim: noexpandtab
    26 
    28 
    27 *******************************************************************************/
    29 *******************************************************************************/
    28 
    30 
    29 #include <linux/module.h>
    31 #include <linux/module.h>
    30 #include <linux/types.h>
    32 #include <linux/types.h>
  1185 	struct net_device *netdev = data;
  1187 	struct net_device *netdev = data;
  1186 	struct e1000_adapter *adapter = netdev_priv(netdev);
  1188 	struct e1000_adapter *adapter = netdev_priv(netdev);
  1187 	struct e1000_hw *hw = &adapter->hw;
  1189 	struct e1000_hw *hw = &adapter->hw;
  1188 	u32 icr = er32(ICR);
  1190 	u32 icr = er32(ICR);
  1189 
  1191 
  1190  	if (adapter->ecdev) {
  1192 	if (adapter->ecdev) {
  1191  		int ec_work_done = 0;
  1193 		int ec_work_done = 0;
  1192  		adapter->clean_rx(adapter, &ec_work_done, 100);
  1194 		adapter->clean_rx(adapter, &ec_work_done, 100);
  1193  		e1000_clean_tx_irq(adapter);
  1195 		e1000_clean_tx_irq(adapter);
  1194 		return IRQ_HANDLED;
  1196 		return IRQ_HANDLED;
  1195 	}
  1197 	}
  1196 	/*
  1198 	/*
  1197 	 * read ICR disables interrupts using IAM
  1199 	 * read ICR disables interrupts using IAM
  1198 	 */
  1200 	 */
  1289 		/* guard against interrupt when we're going down */
  1291 		/* guard against interrupt when we're going down */
  1290 		if (!test_bit(__E1000_DOWN, &adapter->state))
  1292 		if (!test_bit(__E1000_DOWN, &adapter->state))
  1291 			mod_timer(&adapter->watchdog_timer, jiffies + 1);
  1293 			mod_timer(&adapter->watchdog_timer, jiffies + 1);
  1292 	}
  1294 	}
  1293 
  1295 
  1294  	if (adapter->ecdev) {
  1296 	if (adapter->ecdev) {
  1295  		int ec_work_done = 0;
  1297 		int ec_work_done = 0;
  1296  		adapter->clean_rx(adapter, &ec_work_done, 100);
  1298 		adapter->clean_rx(adapter, &ec_work_done, 100);
  1297  		e1000_clean_tx_irq(adapter);
  1299 		e1000_clean_tx_irq(adapter);
  1298 		return IRQ_HANDLED;
  1300 		return IRQ_HANDLED;
  1299 	}
  1301 	}
  1300 
  1302 
  1301 	if (napi_schedule_prep(&adapter->napi)) {
  1303 	if (napi_schedule_prep(&adapter->napi)) {
  1302 		adapter->total_tx_bytes = 0;
  1304 		adapter->total_tx_bytes = 0;
  1372 		writel(1000000000 / (adapter->rx_ring->itr_val * 256),
  1374 		writel(1000000000 / (adapter->rx_ring->itr_val * 256),
  1373 		       adapter->hw.hw_addr + adapter->rx_ring->itr_register);
  1375 		       adapter->hw.hw_addr + adapter->rx_ring->itr_register);
  1374 		adapter->rx_ring->set_itr = 0;
  1376 		adapter->rx_ring->set_itr = 0;
  1375 	}
  1377 	}
  1376 
  1378 
  1377  	if (adapter->ecdev) {
  1379 	if (adapter->ecdev) {
  1378  		int ec_work_done = 0;
  1380 		int ec_work_done = 0;
  1379  		adapter->clean_rx(adapter, &ec_work_done, 100);
  1381 		adapter->clean_rx(adapter, &ec_work_done, 100);
  1380 	} else {
  1382 	} else {
  1381 		if (napi_schedule_prep(&adapter->napi)) {
  1383 		if (napi_schedule_prep(&adapter->napi)) {
  1382 			adapter->total_rx_bytes = 0;
  1384 			adapter->total_rx_bytes = 0;
  1383 			adapter->total_rx_packets = 0;
  1385 			adapter->total_rx_packets = 0;
  1384 			__napi_schedule(&adapter->napi);
  1386 			__napi_schedule(&adapter->napi);
  2890 	/* hardware has been reset, we need to reload some things */
  2892 	/* hardware has been reset, we need to reload some things */
  2891 	e1000_configure(adapter);
  2893 	e1000_configure(adapter);
  2892 
  2894 
  2893 	clear_bit(__E1000_DOWN, &adapter->state);
  2895 	clear_bit(__E1000_DOWN, &adapter->state);
  2894 
  2896 
  2895 	if (!adapter->ecdev) 
  2897 	if (!adapter->ecdev)
  2896 		napi_enable(&adapter->napi);
  2898 		napi_enable(&adapter->napi);
  2897 
  2899 
  2898 	if (adapter->msix_entries)
  2900 	if (adapter->msix_entries)
  2899 		e1000_configure_msix(adapter);
  2901 		e1000_configure_msix(adapter);
  2900 
  2902 
  2924 	/* disable receives in the hardware */
  2926 	/* disable receives in the hardware */
  2925 	rctl = er32(RCTL);
  2927 	rctl = er32(RCTL);
  2926 	ew32(RCTL, rctl & ~E1000_RCTL_EN);
  2928 	ew32(RCTL, rctl & ~E1000_RCTL_EN);
  2927 	/* flush and sleep below */
  2929 	/* flush and sleep below */
  2928 
  2930 
  2929 	if (!adapter->ecdev) 
  2931 	if (!adapter->ecdev)
  2930 		netif_stop_queue(netdev);
  2932 		netif_stop_queue(netdev);
  2931 
  2933 
  2932 	/* disable transmits in the hardware */
  2934 	/* disable transmits in the hardware */
  2933 	tctl = er32(TCTL);
  2935 	tctl = er32(TCTL);
  2934 	tctl &= ~E1000_TCTL_EN;
  2936 	tctl &= ~E1000_TCTL_EN;
  3215 	}
  3217 	}
  3216 
  3218 
  3217 	/* From here on the code is the same as e1000e_up() */
  3219 	/* From here on the code is the same as e1000e_up() */
  3218 	clear_bit(__E1000_DOWN, &adapter->state);
  3220 	clear_bit(__E1000_DOWN, &adapter->state);
  3219 
  3221 
  3220 	napi_enable(&adapter->napi);
  3222 	if (!adapter->ecdev) {
  3221 
  3223 		napi_enable(&adapter->napi);
  3222 	e1000_irq_enable(adapter);
  3224 
  3223 
  3225 		e1000_irq_enable(adapter);
  3224 	netif_start_queue(netdev);
  3226 
       
  3227 		netif_start_queue(netdev);
       
  3228 	}
  3225 
  3229 
  3226 	/* fire a link status change interrupt to start the watchdog */
  3230 	/* fire a link status change interrupt to start the watchdog */
  3227 	ew32(ICS, E1000_ICS_LSC);
  3231 	ew32(ICS, E1000_ICS_LSC);
  3228 
  3232 
  3229 	return 0;
  3233 	return 0;
  3632 	if ((e1000e_enable_tx_pkt_filtering(hw)) &&
  3636 	if ((e1000e_enable_tx_pkt_filtering(hw)) &&
  3633 	    (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id))
  3637 	    (adapter->mng_vlan_id != adapter->hw.mng_cookie.vlan_id))
  3634 		e1000_update_mng_vlan(adapter);
  3638 		e1000_update_mng_vlan(adapter);
  3635 
  3639 
  3636 	if (link) {
  3640 	if (link) {
  3637 		if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev)) 
  3641 		if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev))
  3638 				|| (!adapter->ecdev && !netif_carrier_ok(netdev))) {
  3642 				|| (!adapter->ecdev && !netif_carrier_ok(netdev))) {
  3639 			bool txb2b = 1;
  3643 			bool txb2b = 1;
  3640 			/* update snapshot of PHY registers on LSC */
  3644 			/* update snapshot of PHY registers on LSC */
  3641 			e1000_phy_read_status(adapter);
  3645 			e1000_phy_read_status(adapter);
  3642 			mac->ops.get_link_up_info(&adapter->hw,
  3646 			mac->ops.get_link_up_info(&adapter->hw,
  3726 			if (phy->ops.cfg_on_link_up)
  3730 			if (phy->ops.cfg_on_link_up)
  3727 				phy->ops.cfg_on_link_up(hw);
  3731 				phy->ops.cfg_on_link_up(hw);
  3728 
  3732 
  3729 			if (adapter->ecdev)
  3733 			if (adapter->ecdev)
  3730 				ecdev_set_link(adapter->ecdev, 1);
  3734 				ecdev_set_link(adapter->ecdev, 1);
  3731 			else 
  3735 			else
  3732 				netif_carrier_on(netdev);
  3736 				netif_carrier_on(netdev);
  3733 
  3737 
  3734 			if (!adapter->ecdev && !test_bit(__E1000_DOWN, &adapter->state))
  3738 			if (!adapter->ecdev && !test_bit(__E1000_DOWN, &adapter->state))
  3735 				mod_timer(&adapter->phy_info_timer,
  3739 				mod_timer(&adapter->phy_info_timer,
  3736 					  round_jiffies(jiffies + 2 * HZ));
  3740 					  round_jiffies(jiffies + 2 * HZ));
  3737 		}
  3741 		}
  3738 	} else {
  3742 	} else {
  3739 		if ((adapter->ecdev && ecdev_get_link(adapter->ecdev)) 
  3743 		if ((adapter->ecdev && ecdev_get_link(adapter->ecdev))
  3740 				|| (!adapter->ecdev && netif_carrier_ok(netdev))) {
  3744 				|| (!adapter->ecdev && netif_carrier_ok(netdev))) {
  3741 			adapter->link_speed = 0;
  3745 			adapter->link_speed = 0;
  3742 			adapter->link_duplex = 0;
  3746 			adapter->link_duplex = 0;
  3743 			/* Link status message must follow this format */
  3747 			/* Link status message must follow this format */
  3744 			printk(KERN_INFO "e1000e: %s NIC Link is Down\n",
  3748 			printk(KERN_INFO "e1000e: %s NIC Link is Down\n",
  3769 	adapter->gotc = adapter->stats.gotc - adapter->gotc_old;
  3773 	adapter->gotc = adapter->stats.gotc - adapter->gotc_old;
  3770 	adapter->gotc_old = adapter->stats.gotc;
  3774 	adapter->gotc_old = adapter->stats.gotc;
  3771 
  3775 
  3772 	e1000e_update_adaptive(&adapter->hw);
  3776 	e1000e_update_adaptive(&adapter->hw);
  3773 
  3777 
  3774 	if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev)) 
  3778 	if (!adapter->ecdev && !netif_carrier_ok(netdev)) {
  3775 			|| (!adapter->ecdev && !netif_carrier_ok(netdev))) {
       
  3776 		tx_pending = (e1000_desc_unused(tx_ring) + 1 <
  3779 		tx_pending = (e1000_desc_unused(tx_ring) + 1 <
  3777 			       tx_ring->count);
  3780 			       tx_ring->count);
  3778 		if (tx_pending) {
  3781 		if (tx_pending) {
  3779 			/*
  3782 			/*
  3780 			 * We've lost link, so the controller stops DMA,
  3783 			 * We've lost link, so the controller stops DMA,
  4146 }
  4149 }
  4147 
  4150 
  4148 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
  4151 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
  4149 {
  4152 {
  4150 	struct e1000_adapter *adapter = netdev_priv(netdev);
  4153 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  4154 
       
  4155 	if (adapter->ecdev) {
       
  4156 		return -EBUSY;
       
  4157 	}
  4151 
  4158 
  4152 	netif_stop_queue(netdev);
  4159 	netif_stop_queue(netdev);
  4153 	/*
  4160 	/*
  4154 	 * Herbert's original patch had:
  4161 	 * Herbert's original patch had:
  4155 	 *  smp_mb__after_netif_stop_queue();
  4162 	 *  smp_mb__after_netif_stop_queue();
  4853 static void e1000_shutdown(struct pci_dev *pdev)
  4860 static void e1000_shutdown(struct pci_dev *pdev)
  4854 {
  4861 {
  4855 	bool wake = false;
  4862 	bool wake = false;
  4856 	struct net_device *netdev = pci_get_drvdata(pdev);
  4863 	struct net_device *netdev = pci_get_drvdata(pdev);
  4857 	struct e1000_adapter *adapter = netdev_priv(netdev);
  4864 	struct e1000_adapter *adapter = netdev_priv(netdev);
  4858 	
  4865 
  4859 	if (adapter->ecdev)
  4866 	if (adapter->ecdev)
  4860 		return;
  4867 		return;
  4861 
  4868 
  4862 	__e1000_shutdown(pdev, &wake);
  4869 	__e1000_shutdown(pdev, &wake);
  4863 
  4870 
  5348 	if (!(adapter->flags & FLAG_HAS_AMT))
  5355 	if (!(adapter->flags & FLAG_HAS_AMT))
  5349 		e1000_get_hw_control(adapter);
  5356 		e1000_get_hw_control(adapter);
  5350 
  5357 
  5351 	adapter->ecdev = ecdev_offer(netdev,ec_poll,THIS_MODULE);
  5358 	adapter->ecdev = ecdev_offer(netdev,ec_poll,THIS_MODULE);
  5352 	if (adapter->ecdev) {
  5359 	if (adapter->ecdev) {
  5353 		if (ecdev_open(adapter->ecdev)) {
  5360 		err = ecdev_open(adapter->ecdev);
       
  5361 		if (err) {
  5354 			ecdev_withdraw(adapter->ecdev);
  5362 			ecdev_withdraw(adapter->ecdev);
  5355 			goto err_register;
  5363 			goto err_register;
  5356 		}
  5364 		}
  5357 	} else {
  5365 	} else {
  5358 		strcpy(netdev->name, "eth%d");
  5366 		strcpy(netdev->name, "eth%d");