devices/e1000/e1000_main-3.8-ethercat.c
branchstable-1.5
changeset 2584 0e3d989ff233
child 2598 19ff84bbbcb3
equal deleted inserted replaced
2583:fe5687a0a322 2584:0e3d989ff233
       
     1 /*******************************************************************************
       
     2 
       
     3   Intel PRO/1000 Linux driver
       
     4   Copyright(c) 1999 - 2006 Intel Corporation.
       
     5 
       
     6   This program is free software; you can redistribute it and/or modify it
       
     7   under the terms and conditions of the GNU General Public License,
       
     8   version 2, as published by the Free Software Foundation.
       
     9 
       
    10   This program is distributed in the hope it will be useful, but WITHOUT
       
    11   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
       
    12   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
       
    13   more details.
       
    14 
       
    15   You should have received a copy of the GNU General Public License along with
       
    16   this program; if not, write to the Free Software Foundation, Inc.,
       
    17   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
       
    18 
       
    19   The full GNU General Public License is included in this distribution in
       
    20   the file called "COPYING".
       
    21 
       
    22   Contact Information:
       
    23   Linux NICS <linux.nics@intel.com>
       
    24   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
       
    25   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
       
    26 
       
    27   vim: noexpandtab
       
    28 
       
    29 *******************************************************************************/
       
    30 
       
    31 #include "e1000-3.8-ethercat.h"
       
    32 #include <net/ip6_checksum.h>
       
    33 #include <linux/io.h>
       
    34 #include <linux/prefetch.h>
       
    35 #include <linux/bitops.h>
       
    36 #include <linux/if_vlan.h>
       
    37 
       
    38 char e1000_driver_name[] = "ec_e1000";
       
    39 static char e1000_driver_string[] = "Intel(R) PRO/1000 Network Driver";
       
    40 #define DRV_VERSION "7.3.21-k8-NAPI"
       
    41 const char e1000_driver_version[] = DRV_VERSION;
       
    42 static const char e1000_copyright[] = "Copyright (c) 1999-2006 Intel Corporation.";
       
    43 
       
    44 /* e1000_pci_tbl - PCI Device ID Table
       
    45  *
       
    46  * Last entry must be all 0s
       
    47  *
       
    48  * Macro expands to...
       
    49  *   {PCI_DEVICE(PCI_VENDOR_ID_INTEL, device_id)}
       
    50  */
       
    51 static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
       
    52 	INTEL_E1000_ETHERNET_DEVICE(0x1000),
       
    53 	INTEL_E1000_ETHERNET_DEVICE(0x1001),
       
    54 	INTEL_E1000_ETHERNET_DEVICE(0x1004),
       
    55 	INTEL_E1000_ETHERNET_DEVICE(0x1008),
       
    56 	INTEL_E1000_ETHERNET_DEVICE(0x1009),
       
    57 	INTEL_E1000_ETHERNET_DEVICE(0x100C),
       
    58 	INTEL_E1000_ETHERNET_DEVICE(0x100D),
       
    59 	INTEL_E1000_ETHERNET_DEVICE(0x100E),
       
    60 	INTEL_E1000_ETHERNET_DEVICE(0x100F),
       
    61 	INTEL_E1000_ETHERNET_DEVICE(0x1010),
       
    62 	INTEL_E1000_ETHERNET_DEVICE(0x1011),
       
    63 	INTEL_E1000_ETHERNET_DEVICE(0x1012),
       
    64 	INTEL_E1000_ETHERNET_DEVICE(0x1013),
       
    65 	INTEL_E1000_ETHERNET_DEVICE(0x1014),
       
    66 	INTEL_E1000_ETHERNET_DEVICE(0x1015),
       
    67 	INTEL_E1000_ETHERNET_DEVICE(0x1016),
       
    68 	INTEL_E1000_ETHERNET_DEVICE(0x1017),
       
    69 	INTEL_E1000_ETHERNET_DEVICE(0x1018),
       
    70 	INTEL_E1000_ETHERNET_DEVICE(0x1019),
       
    71 	INTEL_E1000_ETHERNET_DEVICE(0x101A),
       
    72 	INTEL_E1000_ETHERNET_DEVICE(0x101D),
       
    73 	INTEL_E1000_ETHERNET_DEVICE(0x101E),
       
    74 	INTEL_E1000_ETHERNET_DEVICE(0x1026),
       
    75 	INTEL_E1000_ETHERNET_DEVICE(0x1027),
       
    76 	INTEL_E1000_ETHERNET_DEVICE(0x1028),
       
    77 	INTEL_E1000_ETHERNET_DEVICE(0x1075),
       
    78 	INTEL_E1000_ETHERNET_DEVICE(0x1076),
       
    79 	INTEL_E1000_ETHERNET_DEVICE(0x1077),
       
    80 	INTEL_E1000_ETHERNET_DEVICE(0x1078),
       
    81 	INTEL_E1000_ETHERNET_DEVICE(0x1079),
       
    82 	INTEL_E1000_ETHERNET_DEVICE(0x107A),
       
    83 	INTEL_E1000_ETHERNET_DEVICE(0x107B),
       
    84 	INTEL_E1000_ETHERNET_DEVICE(0x107C),
       
    85 	INTEL_E1000_ETHERNET_DEVICE(0x108A),
       
    86 	INTEL_E1000_ETHERNET_DEVICE(0x1099),
       
    87 	INTEL_E1000_ETHERNET_DEVICE(0x10B5),
       
    88 	INTEL_E1000_ETHERNET_DEVICE(0x2E6E),
       
    89 	/* required last entry */
       
    90 	{0,}
       
    91 };
       
    92 
       
    93 // do not auto-load driver
       
    94 // MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
       
    95 
       
    96 int e1000_up(struct e1000_adapter *adapter);
       
    97 void e1000_down(struct e1000_adapter *adapter);
       
    98 void e1000_reinit_locked(struct e1000_adapter *adapter);
       
    99 void e1000_reset(struct e1000_adapter *adapter);
       
   100 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter);
       
   101 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter);
       
   102 void e1000_free_all_tx_resources(struct e1000_adapter *adapter);
       
   103 void e1000_free_all_rx_resources(struct e1000_adapter *adapter);
       
   104 static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
       
   105                              struct e1000_tx_ring *txdr);
       
   106 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
       
   107                              struct e1000_rx_ring *rxdr);
       
   108 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
       
   109                              struct e1000_tx_ring *tx_ring);
       
   110 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
       
   111                              struct e1000_rx_ring *rx_ring);
       
   112 void e1000_update_stats(struct e1000_adapter *adapter);
       
   113 
       
   114 static int e1000_init_module(void);
       
   115 static void e1000_exit_module(void);
       
   116 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent);
       
   117 static void e1000_remove(struct pci_dev *pdev);
       
   118 static int e1000_alloc_queues(struct e1000_adapter *adapter);
       
   119 static int e1000_sw_init(struct e1000_adapter *adapter);
       
   120 static int e1000_open(struct net_device *netdev);
       
   121 static int e1000_close(struct net_device *netdev);
       
   122 static void e1000_configure_tx(struct e1000_adapter *adapter);
       
   123 static void e1000_configure_rx(struct e1000_adapter *adapter);
       
   124 static void e1000_setup_rctl(struct e1000_adapter *adapter);
       
   125 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter);
       
   126 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter);
       
   127 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
       
   128                                 struct e1000_tx_ring *tx_ring);
       
   129 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
       
   130                                 struct e1000_rx_ring *rx_ring);
       
   131 static void e1000_set_rx_mode(struct net_device *netdev);
       
   132 static void e1000_update_phy_info_task(struct work_struct *work);
       
   133 static void e1000_watchdog(struct work_struct *work);
       
   134 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work);
       
   135 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
       
   136 				    struct net_device *netdev);
       
   137 static struct net_device_stats * e1000_get_stats(struct net_device *netdev);
       
   138 static int e1000_change_mtu(struct net_device *netdev, int new_mtu);
       
   139 static int e1000_set_mac(struct net_device *netdev, void *p);
       
   140 void ec_poll(struct net_device *);
       
   141 static irqreturn_t e1000_intr(int irq, void *data);
       
   142 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
       
   143 			       struct e1000_tx_ring *tx_ring);
       
   144 static int e1000_clean(struct napi_struct *napi, int budget);
       
   145 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
       
   146 			       struct e1000_rx_ring *rx_ring,
       
   147 			       int *work_done, int work_to_do);
       
   148 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
       
   149 				     struct e1000_rx_ring *rx_ring,
       
   150 				     int *work_done, int work_to_do);
       
   151 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
       
   152 				   struct e1000_rx_ring *rx_ring,
       
   153 				   int cleaned_count);
       
   154 static void e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
       
   155 					 struct e1000_rx_ring *rx_ring,
       
   156 					 int cleaned_count);
       
   157 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd);
       
   158 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
       
   159 			   int cmd);
       
   160 static void e1000_enter_82542_rst(struct e1000_adapter *adapter);
       
   161 static void e1000_leave_82542_rst(struct e1000_adapter *adapter);
       
   162 static void e1000_tx_timeout(struct net_device *dev);
       
   163 static void e1000_reset_task(struct work_struct *work);
       
   164 static void e1000_smartspeed(struct e1000_adapter *adapter);
       
   165 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
       
   166                                        struct sk_buff *skb);
       
   167 
       
   168 static bool e1000_vlan_used(struct e1000_adapter *adapter);
       
   169 static void e1000_vlan_mode(struct net_device *netdev,
       
   170 			    netdev_features_t features);
       
   171 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
       
   172 				     bool filter_on);
       
   173 static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
       
   174 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
       
   175 static void e1000_restore_vlan(struct e1000_adapter *adapter);
       
   176 
       
   177 #ifdef CONFIG_PM
       
   178 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state);
       
   179 static int e1000_resume(struct pci_dev *pdev);
       
   180 #endif
       
   181 static void e1000_shutdown(struct pci_dev *pdev);
       
   182 
       
   183 #ifdef CONFIG_NET_POLL_CONTROLLER
       
   184 /* for netdump / net console */
       
   185 static void e1000_netpoll (struct net_device *netdev);
       
   186 #endif
       
   187 
       
   188 #define COPYBREAK_DEFAULT 256
       
   189 static unsigned int copybreak __read_mostly = COPYBREAK_DEFAULT;
       
   190 module_param(copybreak, uint, 0644);
       
   191 MODULE_PARM_DESC(copybreak,
       
   192 	"Maximum size of packet that is copied to a new buffer on receive");
       
   193 
       
   194 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
       
   195                      pci_channel_state_t state);
       
   196 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev);
       
   197 static void e1000_io_resume(struct pci_dev *pdev);
       
   198 
       
   199 static const struct pci_error_handlers e1000_err_handler = {
       
   200 	.error_detected = e1000_io_error_detected,
       
   201 	.slot_reset = e1000_io_slot_reset,
       
   202 	.resume = e1000_io_resume,
       
   203 };
       
   204 
       
   205 static struct pci_driver e1000_driver = {
       
   206 	.name     = e1000_driver_name,
       
   207 	.id_table = e1000_pci_tbl,
       
   208 	.probe    = e1000_probe,
       
   209 	.remove   = e1000_remove,
       
   210 #ifdef CONFIG_PM
       
   211 	/* Power Management Hooks */
       
   212 	.suspend  = e1000_suspend,
       
   213 	.resume   = e1000_resume,
       
   214 #endif
       
   215 	.shutdown = e1000_shutdown,
       
   216 	.err_handler = &e1000_err_handler
       
   217 };
       
   218 
       
   219 MODULE_AUTHOR("Florian Pose <fp@igh-essen.com>");
       
   220 MODULE_DESCRIPTION("EtherCAT-capable Intel(R) PRO/1000 Network Driver");
       
   221 MODULE_LICENSE("GPL");
       
   222 MODULE_VERSION(DRV_VERSION);
       
   223 
       
   224 #define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV|NETIF_MSG_PROBE|NETIF_MSG_LINK)
       
   225 static int debug = -1;
       
   226 module_param(debug, int, 0);
       
   227 MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
       
   228 
       
   229 /**
       
   230  * e1000_get_hw_dev - return device
       
   231  * used by hardware layer to print debugging information
       
   232  *
       
   233  **/
       
   234 struct net_device *e1000_get_hw_dev(struct e1000_hw *hw)
       
   235 {
       
   236 	struct e1000_adapter *adapter = hw->back;
       
   237 	return adapter->netdev;
       
   238 }
       
   239 
       
   240 /**
       
   241  * e1000_init_module - Driver Registration Routine
       
   242  *
       
   243  * e1000_init_module is the first routine called when the driver is
       
   244  * loaded. All it does is register with the PCI subsystem.
       
   245  **/
       
   246 
       
   247 static int __init e1000_init_module(void)
       
   248 {
       
   249 	int ret;
       
   250 	pr_info("%s - version %s\n", e1000_driver_string, e1000_driver_version);
       
   251 
       
   252 	pr_info("%s\n", e1000_copyright);
       
   253 
       
   254 	ret = pci_register_driver(&e1000_driver);
       
   255 	if (copybreak != COPYBREAK_DEFAULT) {
       
   256 		if (copybreak == 0)
       
   257 			pr_info("copybreak disabled\n");
       
   258 		else
       
   259 			pr_info("copybreak enabled for "
       
   260 				   "packets <= %u bytes\n", copybreak);
       
   261 	}
       
   262 	return ret;
       
   263 }
       
   264 
       
   265 module_init(e1000_init_module);
       
   266 
       
   267 /**
       
   268  * e1000_exit_module - Driver Exit Cleanup Routine
       
   269  *
       
   270  * e1000_exit_module is called just before the driver is removed
       
   271  * from memory.
       
   272  **/
       
   273 
       
   274 static void __exit e1000_exit_module(void)
       
   275 {
       
   276 	pci_unregister_driver(&e1000_driver);
       
   277 }
       
   278 
       
   279 module_exit(e1000_exit_module);
       
   280 
       
   281 static int e1000_request_irq(struct e1000_adapter *adapter)
       
   282 {
       
   283 	struct net_device *netdev = adapter->netdev;
       
   284 	irq_handler_t handler = e1000_intr;
       
   285 	int irq_flags = IRQF_SHARED;
       
   286 	int err;
       
   287 
       
   288 	if (adapter->ecdev) {
       
   289 		return 0;
       
   290 	}
       
   291 
       
   292 	err = request_irq(adapter->pdev->irq, handler, irq_flags, netdev->name,
       
   293 	                  netdev);
       
   294 	if (err) {
       
   295 		e_err(probe, "Unable to allocate interrupt Error: %d\n", err);
       
   296 	}
       
   297 
       
   298 	return err;
       
   299 }
       
   300 
       
   301 static void e1000_free_irq(struct e1000_adapter *adapter)
       
   302 {
       
   303 	struct net_device *netdev = adapter->netdev;
       
   304 
       
   305 	if (adapter->ecdev) {
       
   306 		return;
       
   307 	}
       
   308 
       
   309 	free_irq(adapter->pdev->irq, netdev);
       
   310 }
       
   311 
       
   312 /**
       
   313  * e1000_irq_disable - Mask off interrupt generation on the NIC
       
   314  * @adapter: board private structure
       
   315  **/
       
   316 
       
   317 static void e1000_irq_disable(struct e1000_adapter *adapter)
       
   318 {
       
   319 	struct e1000_hw *hw = &adapter->hw;
       
   320 
       
   321 	if (adapter->ecdev) {
       
   322 		return;
       
   323 	}
       
   324 
       
   325 	ew32(IMC, ~0);
       
   326 	E1000_WRITE_FLUSH();
       
   327 	synchronize_irq(adapter->pdev->irq);
       
   328 }
       
   329 
       
   330 /**
       
   331  * e1000_irq_enable - Enable default interrupt generation settings
       
   332  * @adapter: board private structure
       
   333  **/
       
   334 
       
   335 static void e1000_irq_enable(struct e1000_adapter *adapter)
       
   336 {
       
   337 	struct e1000_hw *hw = &adapter->hw;
       
   338 
       
   339 	if (adapter->ecdev) {
       
   340 		return;
       
   341 	}
       
   342 
       
   343 	ew32(IMS, IMS_ENABLE_MASK);
       
   344 	E1000_WRITE_FLUSH();
       
   345 }
       
   346 
       
   347 static void e1000_update_mng_vlan(struct e1000_adapter *adapter)
       
   348 {
       
   349 	struct e1000_hw *hw = &adapter->hw;
       
   350 	struct net_device *netdev = adapter->netdev;
       
   351 	u16 vid = hw->mng_cookie.vlan_id;
       
   352 	u16 old_vid = adapter->mng_vlan_id;
       
   353 
       
   354 	if (!e1000_vlan_used(adapter))
       
   355 		return;
       
   356 
       
   357 	if (!test_bit(vid, adapter->active_vlans)) {
       
   358 		if (hw->mng_cookie.status &
       
   359 		    E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) {
       
   360 			e1000_vlan_rx_add_vid(netdev, vid);
       
   361 			adapter->mng_vlan_id = vid;
       
   362 		} else {
       
   363 			adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
       
   364 		}
       
   365 		if ((old_vid != (u16)E1000_MNG_VLAN_NONE) &&
       
   366 		    (vid != old_vid) &&
       
   367 		    !test_bit(old_vid, adapter->active_vlans))
       
   368 			e1000_vlan_rx_kill_vid(netdev, old_vid);
       
   369 	} else {
       
   370 		adapter->mng_vlan_id = vid;
       
   371 	}
       
   372 }
       
   373 
       
   374 static void e1000_init_manageability(struct e1000_adapter *adapter)
       
   375 {
       
   376 	struct e1000_hw *hw = &adapter->hw;
       
   377 
       
   378 	if (adapter->en_mng_pt) {
       
   379 		u32 manc = er32(MANC);
       
   380 
       
   381 		/* disable hardware interception of ARP */
       
   382 		manc &= ~(E1000_MANC_ARP_EN);
       
   383 
       
   384 		ew32(MANC, manc);
       
   385 	}
       
   386 }
       
   387 
       
   388 static void e1000_release_manageability(struct e1000_adapter *adapter)
       
   389 {
       
   390 	struct e1000_hw *hw = &adapter->hw;
       
   391 
       
   392 	if (adapter->en_mng_pt) {
       
   393 		u32 manc = er32(MANC);
       
   394 
       
   395 		/* re-enable hardware interception of ARP */
       
   396 		manc |= E1000_MANC_ARP_EN;
       
   397 
       
   398 		ew32(MANC, manc);
       
   399 	}
       
   400 }
       
   401 
       
   402 /**
       
   403  * e1000_configure - configure the hardware for RX and TX
       
   404  * @adapter = private board structure
       
   405  **/
       
   406 static void e1000_configure(struct e1000_adapter *adapter)
       
   407 {
       
   408 	struct net_device *netdev = adapter->netdev;
       
   409 	int i;
       
   410 
       
   411 	e1000_set_rx_mode(netdev);
       
   412 
       
   413 	e1000_restore_vlan(adapter);
       
   414 	e1000_init_manageability(adapter);
       
   415 
       
   416 	e1000_configure_tx(adapter);
       
   417 	e1000_setup_rctl(adapter);
       
   418 	e1000_configure_rx(adapter);
       
   419 	/* call E1000_DESC_UNUSED which always leaves
       
   420 	 * at least 1 descriptor unused to make sure
       
   421 	 * next_to_use != next_to_clean */
       
   422 	for (i = 0; i < adapter->num_rx_queues; i++) {
       
   423 		struct e1000_rx_ring *ring = &adapter->rx_ring[i];
       
   424 		if (adapter->ecdev) {
       
   425 			/* fill rx ring completely! */
       
   426 			adapter->alloc_rx_buf(adapter, ring, ring->count);
       
   427 		} else {
       
   428 			/* this one leaves the last ring element unallocated! */
       
   429 			adapter->alloc_rx_buf(adapter, ring,
       
   430 					E1000_DESC_UNUSED(ring));
       
   431 		}
       
   432 	}
       
   433 }
       
   434 
       
   435 int e1000_up(struct e1000_adapter *adapter)
       
   436 {
       
   437 	struct e1000_hw *hw = &adapter->hw;
       
   438 
       
   439 	/* hardware has been reset, we need to reload some things */
       
   440 	e1000_configure(adapter);
       
   441 
       
   442 	clear_bit(__E1000_DOWN, &adapter->flags);
       
   443 
       
   444 	if (!adapter->ecdev) {
       
   445 		napi_enable(&adapter->napi);
       
   446 
       
   447 		e1000_irq_enable(adapter);
       
   448 
       
   449 		netif_wake_queue(adapter->netdev);
       
   450 
       
   451 		/* fire a link change interrupt to start the watchdog */
       
   452 		ew32(ICS, E1000_ICS_LSC);
       
   453 	}
       
   454 	return 0;
       
   455 }
       
   456 
       
   457 /**
       
   458  * e1000_power_up_phy - restore link in case the phy was powered down
       
   459  * @adapter: address of board private structure
       
   460  *
       
   461  * The phy may be powered down to save power and turn off link when the
       
   462  * driver is unloaded and wake on lan is not enabled (among others)
       
   463  * *** this routine MUST be followed by a call to e1000_reset ***
       
   464  *
       
   465  **/
       
   466 
       
   467 void e1000_power_up_phy(struct e1000_adapter *adapter)
       
   468 {
       
   469 	struct e1000_hw *hw = &adapter->hw;
       
   470 	u16 mii_reg = 0;
       
   471 
       
   472 	/* Just clear the power down bit to wake the phy back up */
       
   473 	if (hw->media_type == e1000_media_type_copper) {
       
   474 		/* according to the manual, the phy will retain its
       
   475 		 * settings across a power-down/up cycle */
       
   476 		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
       
   477 		mii_reg &= ~MII_CR_POWER_DOWN;
       
   478 		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
       
   479 	}
       
   480 }
       
   481 
       
   482 static void e1000_power_down_phy(struct e1000_adapter *adapter)
       
   483 {
       
   484 	struct e1000_hw *hw = &adapter->hw;
       
   485 
       
   486 	/* Power down the PHY so no link is implied when interface is down *
       
   487 	 * The PHY cannot be powered down if any of the following is true *
       
   488 	 * (a) WoL is enabled
       
   489 	 * (b) AMT is active
       
   490 	 * (c) SoL/IDER session is active */
       
   491 	if (!adapter->wol && hw->mac_type >= e1000_82540 &&
       
   492 	   hw->media_type == e1000_media_type_copper) {
       
   493 		u16 mii_reg = 0;
       
   494 
       
   495 		switch (hw->mac_type) {
       
   496 		case e1000_82540:
       
   497 		case e1000_82545:
       
   498 		case e1000_82545_rev_3:
       
   499 		case e1000_82546:
       
   500 		case e1000_ce4100:
       
   501 		case e1000_82546_rev_3:
       
   502 		case e1000_82541:
       
   503 		case e1000_82541_rev_2:
       
   504 		case e1000_82547:
       
   505 		case e1000_82547_rev_2:
       
   506 			if (er32(MANC) & E1000_MANC_SMBUS_EN)
       
   507 				goto out;
       
   508 			break;
       
   509 		default:
       
   510 			goto out;
       
   511 		}
       
   512 		e1000_read_phy_reg(hw, PHY_CTRL, &mii_reg);
       
   513 		mii_reg |= MII_CR_POWER_DOWN;
       
   514 		e1000_write_phy_reg(hw, PHY_CTRL, mii_reg);
       
   515 		msleep(1);
       
   516 	}
       
   517 out:
       
   518 	return;
       
   519 }
       
   520 
       
   521 static void e1000_down_and_stop(struct e1000_adapter *adapter)
       
   522 {
       
   523 	set_bit(__E1000_DOWN, &adapter->flags);
       
   524 
       
   525 	/* Only kill reset task if adapter is not resetting */
       
   526 	if (!test_bit(__E1000_RESETTING, &adapter->flags))
       
   527 		cancel_work_sync(&adapter->reset_task);
       
   528 
       
   529 	if (!adapter->ecdev) {
       
   530 		cancel_delayed_work_sync(&adapter->watchdog_task);
       
   531 		cancel_delayed_work_sync(&adapter->phy_info_task);
       
   532 		cancel_delayed_work_sync(&adapter->fifo_stall_task);
       
   533 	}
       
   534 }
       
   535 
       
   536 void e1000_down(struct e1000_adapter *adapter)
       
   537 {
       
   538 	struct e1000_hw *hw = &adapter->hw;
       
   539 	struct net_device *netdev = adapter->netdev;
       
   540 	u32 rctl, tctl;
       
   541 
       
   542 
       
   543 	/* disable receives in the hardware */	
       
   544 	rctl = er32(RCTL);
       
   545 	ew32(RCTL, rctl & ~E1000_RCTL_EN);
       
   546 
       
   547 	if (!adapter->ecdev) {
       
   548 		/* flush and sleep below */
       
   549 		netif_tx_disable(netdev);
       
   550 	}
       
   551 
       
   552 	/* disable transmits in the hardware */
       
   553 	tctl = er32(TCTL);
       
   554 	tctl &= ~E1000_TCTL_EN;
       
   555 	ew32(TCTL, tctl);
       
   556 	/* flush both disables and wait for them to finish */
       
   557 	E1000_WRITE_FLUSH();
       
   558 	msleep(10);
       
   559 
       
   560 	if (!adapter->ecdev) {
       
   561 		napi_disable(&adapter->napi);
       
   562 
       
   563 		e1000_irq_disable(adapter);
       
   564 	}
       
   565 
       
   566 	/*
       
   567 	 * Setting DOWN must be after irq_disable to prevent
       
   568 	 * a screaming interrupt.  Setting DOWN also prevents
       
   569 	 * tasks from rescheduling.
       
   570 	 */
       
   571 	e1000_down_and_stop(adapter);
       
   572 
       
   573 	adapter->link_speed = 0;
       
   574 	adapter->link_duplex = 0;
       
   575 
       
   576 	if (!adapter->ecdev) {
       
   577 		netif_carrier_off(netdev);
       
   578 	}
       
   579 
       
   580 	e1000_reset(adapter);
       
   581 	e1000_clean_all_tx_rings(adapter);
       
   582 	e1000_clean_all_rx_rings(adapter);
       
   583 }
       
   584 
       
   585 static void e1000_reinit_safe(struct e1000_adapter *adapter)
       
   586 {
       
   587 	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
       
   588 		msleep(1);
       
   589 	mutex_lock(&adapter->mutex);
       
   590 	e1000_down(adapter);
       
   591 	e1000_up(adapter);
       
   592 	mutex_unlock(&adapter->mutex);
       
   593 	clear_bit(__E1000_RESETTING, &adapter->flags);
       
   594 }
       
   595 
       
   596 void e1000_reinit_locked(struct e1000_adapter *adapter)
       
   597 {
       
   598 	/* if rtnl_lock is not held the call path is bogus */
       
   599 	ASSERT_RTNL();
       
   600 	WARN_ON(in_interrupt());
       
   601 	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
       
   602 		msleep(1);
       
   603 	e1000_down(adapter);
       
   604 	e1000_up(adapter);
       
   605 	clear_bit(__E1000_RESETTING, &adapter->flags);
       
   606 }
       
   607 
       
   608 void e1000_reset(struct e1000_adapter *adapter)
       
   609 {
       
   610 	struct e1000_hw *hw = &adapter->hw;
       
   611 	u32 pba = 0, tx_space, min_tx_space, min_rx_space;
       
   612 	bool legacy_pba_adjust = false;
       
   613 	u16 hwm;
       
   614 
       
   615 	/* Repartition Pba for greater than 9k mtu
       
   616 	 * To take effect CTRL.RST is required.
       
   617 	 */
       
   618 
       
   619 	switch (hw->mac_type) {
       
   620 	case e1000_82542_rev2_0:
       
   621 	case e1000_82542_rev2_1:
       
   622 	case e1000_82543:
       
   623 	case e1000_82544:
       
   624 	case e1000_82540:
       
   625 	case e1000_82541:
       
   626 	case e1000_82541_rev_2:
       
   627 		legacy_pba_adjust = true;
       
   628 		pba = E1000_PBA_48K;
       
   629 		break;
       
   630 	case e1000_82545:
       
   631 	case e1000_82545_rev_3:
       
   632 	case e1000_82546:
       
   633 	case e1000_ce4100:
       
   634 	case e1000_82546_rev_3:
       
   635 		pba = E1000_PBA_48K;
       
   636 		break;
       
   637 	case e1000_82547:
       
   638 	case e1000_82547_rev_2:
       
   639 		legacy_pba_adjust = true;
       
   640 		pba = E1000_PBA_30K;
       
   641 		break;
       
   642 	case e1000_undefined:
       
   643 	case e1000_num_macs:
       
   644 		break;
       
   645 	}
       
   646 
       
   647 	if (legacy_pba_adjust) {
       
   648 		if (hw->max_frame_size > E1000_RXBUFFER_8192)
       
   649 			pba -= 8; /* allocate more FIFO for Tx */
       
   650 
       
   651 		if (hw->mac_type == e1000_82547) {
       
   652 			adapter->tx_fifo_head = 0;
       
   653 			adapter->tx_head_addr = pba << E1000_TX_HEAD_ADDR_SHIFT;
       
   654 			adapter->tx_fifo_size =
       
   655 				(E1000_PBA_40K - pba) << E1000_PBA_BYTES_SHIFT;
       
   656 			atomic_set(&adapter->tx_fifo_stall, 0);
       
   657 		}
       
   658 	} else if (hw->max_frame_size >  ETH_FRAME_LEN + ETH_FCS_LEN) {
       
   659 		/* adjust PBA for jumbo frames */
       
   660 		ew32(PBA, pba);
       
   661 
       
   662 		/* To maintain wire speed transmits, the Tx FIFO should be
       
   663 		 * large enough to accommodate two full transmit packets,
       
   664 		 * rounded up to the next 1KB and expressed in KB.  Likewise,
       
   665 		 * the Rx FIFO should be large enough to accommodate at least
       
   666 		 * one full receive packet and is similarly rounded up and
       
   667 		 * expressed in KB. */
       
   668 		pba = er32(PBA);
       
   669 		/* upper 16 bits has Tx packet buffer allocation size in KB */
       
   670 		tx_space = pba >> 16;
       
   671 		/* lower 16 bits has Rx packet buffer allocation size in KB */
       
   672 		pba &= 0xffff;
       
   673 		/*
       
   674 		 * the tx fifo also stores 16 bytes of information about the tx
       
   675 		 * but don't include ethernet FCS because hardware appends it
       
   676 		 */
       
   677 		min_tx_space = (hw->max_frame_size +
       
   678 		                sizeof(struct e1000_tx_desc) -
       
   679 		                ETH_FCS_LEN) * 2;
       
   680 		min_tx_space = ALIGN(min_tx_space, 1024);
       
   681 		min_tx_space >>= 10;
       
   682 		/* software strips receive CRC, so leave room for it */
       
   683 		min_rx_space = hw->max_frame_size;
       
   684 		min_rx_space = ALIGN(min_rx_space, 1024);
       
   685 		min_rx_space >>= 10;
       
   686 
       
   687 		/* If current Tx allocation is less than the min Tx FIFO size,
       
   688 		 * and the min Tx FIFO size is less than the current Rx FIFO
       
   689 		 * allocation, take space away from current Rx allocation */
       
   690 		if (tx_space < min_tx_space &&
       
   691 		    ((min_tx_space - tx_space) < pba)) {
       
   692 			pba = pba - (min_tx_space - tx_space);
       
   693 
       
   694 			/* PCI/PCIx hardware has PBA alignment constraints */
       
   695 			switch (hw->mac_type) {
       
   696 			case e1000_82545 ... e1000_82546_rev_3:
       
   697 				pba &= ~(E1000_PBA_8K - 1);
       
   698 				break;
       
   699 			default:
       
   700 				break;
       
   701 			}
       
   702 
       
   703 			/* if short on rx space, rx wins and must trump tx
       
   704 			 * adjustment or use Early Receive if available */
       
   705 			if (pba < min_rx_space)
       
   706 				pba = min_rx_space;
       
   707 		}
       
   708 	}
       
   709 
       
   710 	ew32(PBA, pba);
       
   711 
       
   712 	/*
       
   713 	 * flow control settings:
       
   714 	 * The high water mark must be low enough to fit one full frame
       
   715 	 * (or the size used for early receive) above it in the Rx FIFO.
       
   716 	 * Set it to the lower of:
       
   717 	 * - 90% of the Rx FIFO size, and
       
   718 	 * - the full Rx FIFO size minus the early receive size (for parts
       
   719 	 *   with ERT support assuming ERT set to E1000_ERT_2048), or
       
   720 	 * - the full Rx FIFO size minus one full frame
       
   721 	 */
       
   722 	hwm = min(((pba << 10) * 9 / 10),
       
   723 		  ((pba << 10) - hw->max_frame_size));
       
   724 
       
   725 	hw->fc_high_water = hwm & 0xFFF8;	/* 8-byte granularity */
       
   726 	hw->fc_low_water = hw->fc_high_water - 8;
       
   727 	hw->fc_pause_time = E1000_FC_PAUSE_TIME;
       
   728 	hw->fc_send_xon = 1;
       
   729 	hw->fc = hw->original_fc;
       
   730 
       
   731 	/* Allow time for pending master requests to run */
       
   732 	e1000_reset_hw(hw);
       
   733 	if (hw->mac_type >= e1000_82544)
       
   734 		ew32(WUC, 0);
       
   735 
       
   736 	if (e1000_init_hw(hw))
       
   737 		e_dev_err("Hardware Error\n");
       
   738 	e1000_update_mng_vlan(adapter);
       
   739 
       
   740 	/* if (adapter->hwflags & HWFLAGS_PHY_PWR_BIT) { */
       
   741 	if (hw->mac_type >= e1000_82544 &&
       
   742 	    hw->autoneg == 1 &&
       
   743 	    hw->autoneg_advertised == ADVERTISE_1000_FULL) {
       
   744 		u32 ctrl = er32(CTRL);
       
   745 		/* clear phy power management bit if we are in gig only mode,
       
   746 		 * which if enabled will attempt negotiation to 100Mb, which
       
   747 		 * can cause a loss of link at power off or driver unload */
       
   748 		ctrl &= ~E1000_CTRL_SWDPIN3;
       
   749 		ew32(CTRL, ctrl);
       
   750 	}
       
   751 
       
   752 	/* Enable h/w to recognize an 802.1Q VLAN Ethernet packet */
       
   753 	ew32(VET, ETHERNET_IEEE_VLAN_TYPE);
       
   754 
       
   755 	e1000_reset_adaptive(hw);
       
   756 	e1000_phy_get_info(hw, &adapter->phy_info);
       
   757 
       
   758 	e1000_release_manageability(adapter);
       
   759 }
       
   760 
       
   761 /* Dump the eeprom for users having checksum issues */
       
   762 static void e1000_dump_eeprom(struct e1000_adapter *adapter)
       
   763 {
       
   764 	struct net_device *netdev = adapter->netdev;
       
   765 	struct ethtool_eeprom eeprom;
       
   766 	const struct ethtool_ops *ops = netdev->ethtool_ops;
       
   767 	u8 *data;
       
   768 	int i;
       
   769 	u16 csum_old, csum_new = 0;
       
   770 
       
   771 	eeprom.len = ops->get_eeprom_len(netdev);
       
   772 	eeprom.offset = 0;
       
   773 
       
   774 	data = kmalloc(eeprom.len, GFP_KERNEL);
       
   775 	if (!data)
       
   776 		return;
       
   777 
       
   778 	ops->get_eeprom(netdev, &eeprom, data);
       
   779 
       
   780 	csum_old = (data[EEPROM_CHECKSUM_REG * 2]) +
       
   781 		   (data[EEPROM_CHECKSUM_REG * 2 + 1] << 8);
       
   782 	for (i = 0; i < EEPROM_CHECKSUM_REG * 2; i += 2)
       
   783 		csum_new += data[i] + (data[i + 1] << 8);
       
   784 	csum_new = EEPROM_SUM - csum_new;
       
   785 
       
   786 	pr_err("/*********************/\n");
       
   787 	pr_err("Current EEPROM Checksum : 0x%04x\n", csum_old);
       
   788 	pr_err("Calculated              : 0x%04x\n", csum_new);
       
   789 
       
   790 	pr_err("Offset    Values\n");
       
   791 	pr_err("========  ======\n");
       
   792 	print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1, data, 128, 0);
       
   793 
       
   794 	pr_err("Include this output when contacting your support provider.\n");
       
   795 	pr_err("This is not a software error! Something bad happened to\n");
       
   796 	pr_err("your hardware or EEPROM image. Ignoring this problem could\n");
       
   797 	pr_err("result in further problems, possibly loss of data,\n");
       
   798 	pr_err("corruption or system hangs!\n");
       
   799 	pr_err("The MAC Address will be reset to 00:00:00:00:00:00,\n");
       
   800 	pr_err("which is invalid and requires you to set the proper MAC\n");
       
   801 	pr_err("address manually before continuing to enable this network\n");
       
   802 	pr_err("device. Please inspect the EEPROM dump and report the\n");
       
   803 	pr_err("issue to your hardware vendor or Intel Customer Support.\n");
       
   804 	pr_err("/*********************/\n");
       
   805 
       
   806 	kfree(data);
       
   807 }
       
   808 
       
   809 /**
       
   810  * e1000_is_need_ioport - determine if an adapter needs ioport resources or not
       
   811  * @pdev: PCI device information struct
       
   812  *
       
   813  * Return true if an adapter needs ioport resources
       
   814  **/
       
   815 static int e1000_is_need_ioport(struct pci_dev *pdev)
       
   816 {
       
   817 	switch (pdev->device) {
       
   818 	case E1000_DEV_ID_82540EM:
       
   819 	case E1000_DEV_ID_82540EM_LOM:
       
   820 	case E1000_DEV_ID_82540EP:
       
   821 	case E1000_DEV_ID_82540EP_LOM:
       
   822 	case E1000_DEV_ID_82540EP_LP:
       
   823 	case E1000_DEV_ID_82541EI:
       
   824 	case E1000_DEV_ID_82541EI_MOBILE:
       
   825 	case E1000_DEV_ID_82541ER:
       
   826 	case E1000_DEV_ID_82541ER_LOM:
       
   827 	case E1000_DEV_ID_82541GI:
       
   828 	case E1000_DEV_ID_82541GI_LF:
       
   829 	case E1000_DEV_ID_82541GI_MOBILE:
       
   830 	case E1000_DEV_ID_82544EI_COPPER:
       
   831 	case E1000_DEV_ID_82544EI_FIBER:
       
   832 	case E1000_DEV_ID_82544GC_COPPER:
       
   833 	case E1000_DEV_ID_82544GC_LOM:
       
   834 	case E1000_DEV_ID_82545EM_COPPER:
       
   835 	case E1000_DEV_ID_82545EM_FIBER:
       
   836 	case E1000_DEV_ID_82546EB_COPPER:
       
   837 	case E1000_DEV_ID_82546EB_FIBER:
       
   838 	case E1000_DEV_ID_82546EB_QUAD_COPPER:
       
   839 		return true;
       
   840 	default:
       
   841 		return false;
       
   842 	}
       
   843 }
       
   844 
       
   845 static netdev_features_t e1000_fix_features(struct net_device *netdev,
       
   846 	netdev_features_t features)
       
   847 {
       
   848 	/*
       
   849 	 * Since there is no support for separate rx/tx vlan accel
       
   850 	 * enable/disable make sure tx flag is always in same state as rx.
       
   851 	 */
       
   852 	if (features & NETIF_F_HW_VLAN_RX)
       
   853 		features |= NETIF_F_HW_VLAN_TX;
       
   854 	else
       
   855 		features &= ~NETIF_F_HW_VLAN_TX;
       
   856 
       
   857 	return features;
       
   858 }
       
   859 
       
   860 static int e1000_set_features(struct net_device *netdev,
       
   861 	netdev_features_t features)
       
   862 {
       
   863 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
   864 	netdev_features_t changed = features ^ netdev->features;
       
   865 
       
   866 	if (changed & NETIF_F_HW_VLAN_RX)
       
   867 		e1000_vlan_mode(netdev, features);
       
   868 
       
   869 	if (!(changed & (NETIF_F_RXCSUM | NETIF_F_RXALL)))
       
   870 		return 0;
       
   871 
       
   872 	netdev->features = features;
       
   873 	adapter->rx_csum = !!(features & NETIF_F_RXCSUM);
       
   874 
       
   875 	if (netif_running(netdev))
       
   876 		e1000_reinit_locked(adapter);
       
   877 	else
       
   878 		e1000_reset(adapter);
       
   879 
       
   880 	return 0;
       
   881 }
       
   882 
       
   883 static const struct net_device_ops e1000_netdev_ops = {
       
   884 	.ndo_open		= e1000_open,
       
   885 	.ndo_stop		= e1000_close,
       
   886 	.ndo_start_xmit		= e1000_xmit_frame,
       
   887 	.ndo_get_stats		= e1000_get_stats,
       
   888 	.ndo_set_rx_mode	= e1000_set_rx_mode,
       
   889 	.ndo_set_mac_address	= e1000_set_mac,
       
   890 	.ndo_tx_timeout		= e1000_tx_timeout,
       
   891 	.ndo_change_mtu		= e1000_change_mtu,
       
   892 	.ndo_do_ioctl		= e1000_ioctl,
       
   893 	.ndo_validate_addr	= eth_validate_addr,
       
   894 	.ndo_vlan_rx_add_vid	= e1000_vlan_rx_add_vid,
       
   895 	.ndo_vlan_rx_kill_vid	= e1000_vlan_rx_kill_vid,
       
   896 #ifdef CONFIG_NET_POLL_CONTROLLER
       
   897 	.ndo_poll_controller	= e1000_netpoll,
       
   898 #endif
       
   899 	.ndo_fix_features	= e1000_fix_features,
       
   900 	.ndo_set_features	= e1000_set_features,
       
   901 };
       
   902 
       
   903 /**
       
   904  * e1000_init_hw_struct - initialize members of hw struct
       
   905  * @adapter: board private struct
       
   906  * @hw: structure used by e1000_hw.c
       
   907  *
       
   908  * Factors out initialization of the e1000_hw struct to its own function
       
   909  * that can be called very early at init (just after struct allocation).
       
   910  * Fields are initialized based on PCI device information and
       
   911  * OS network device settings (MTU size).
       
   912  * Returns negative error codes if MAC type setup fails.
       
   913  */
       
   914 static int e1000_init_hw_struct(struct e1000_adapter *adapter,
       
   915 				struct e1000_hw *hw)
       
   916 {
       
   917 	struct pci_dev *pdev = adapter->pdev;
       
   918 
       
   919 	/* PCI config space info */
       
   920 	hw->vendor_id = pdev->vendor;
       
   921 	hw->device_id = pdev->device;
       
   922 	hw->subsystem_vendor_id = pdev->subsystem_vendor;
       
   923 	hw->subsystem_id = pdev->subsystem_device;
       
   924 	hw->revision_id = pdev->revision;
       
   925 
       
   926 	pci_read_config_word(pdev, PCI_COMMAND, &hw->pci_cmd_word);
       
   927 
       
   928 	hw->max_frame_size = adapter->netdev->mtu +
       
   929 			     ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
       
   930 	hw->min_frame_size = MINIMUM_ETHERNET_FRAME_SIZE;
       
   931 
       
   932 	/* identify the MAC */
       
   933 	if (e1000_set_mac_type(hw)) {
       
   934 		e_err(probe, "Unknown MAC Type\n");
       
   935 		return -EIO;
       
   936 	}
       
   937 
       
   938 	switch (hw->mac_type) {
       
   939 	default:
       
   940 		break;
       
   941 	case e1000_82541:
       
   942 	case e1000_82547:
       
   943 	case e1000_82541_rev_2:
       
   944 	case e1000_82547_rev_2:
       
   945 		hw->phy_init_script = 1;
       
   946 		break;
       
   947 	}
       
   948 
       
   949 	e1000_set_media_type(hw);
       
   950 	e1000_get_bus_info(hw);
       
   951 
       
   952 	hw->wait_autoneg_complete = false;
       
   953 	hw->tbi_compatibility_en = true;
       
   954 	hw->adaptive_ifs = true;
       
   955 
       
   956 	/* Copper options */
       
   957 
       
   958 	if (hw->media_type == e1000_media_type_copper) {
       
   959 		hw->mdix = AUTO_ALL_MODES;
       
   960 		hw->disable_polarity_correction = false;
       
   961 		hw->master_slave = E1000_MASTER_SLAVE;
       
   962 	}
       
   963 
       
   964 	return 0;
       
   965 }
       
   966 
       
   967 /**
       
   968  * e1000_probe - Device Initialization Routine
       
   969  * @pdev: PCI device information struct
       
   970  * @ent: entry in e1000_pci_tbl
       
   971  *
       
   972  * Returns 0 on success, negative on failure
       
   973  *
       
   974  * e1000_probe initializes an adapter identified by a pci_dev structure.
       
   975  * The OS initialization, configuring of the adapter private structure,
       
   976  * and a hardware reset occur.
       
   977  **/
       
   978 static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
       
   979 {
       
   980 	struct net_device *netdev;
       
   981 	struct e1000_adapter *adapter;
       
   982 	struct e1000_hw *hw;
       
   983 
       
   984 	static int cards_found = 0;
       
   985 	static int global_quad_port_a = 0; /* global ksp3 port a indication */
       
   986 	int i, err, pci_using_dac;
       
   987 	u16 eeprom_data = 0;
       
   988 	u16 tmp = 0;
       
   989 	u16 eeprom_apme_mask = E1000_EEPROM_APME;
       
   990 	int bars, need_ioport;
       
   991 
       
   992 	/* do not allocate ioport bars when not needed */
       
   993 	need_ioport = e1000_is_need_ioport(pdev);
       
   994 	if (need_ioport) {
       
   995 		bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
       
   996 		err = pci_enable_device(pdev);
       
   997 	} else {
       
   998 		bars = pci_select_bars(pdev, IORESOURCE_MEM);
       
   999 		err = pci_enable_device_mem(pdev);
       
  1000 	}
       
  1001 	if (err)
       
  1002 		return err;
       
  1003 
       
  1004 	err = pci_request_selected_regions(pdev, bars, e1000_driver_name);
       
  1005 	if (err)
       
  1006 		goto err_pci_reg;
       
  1007 
       
  1008 	pci_set_master(pdev);
       
  1009 	err = pci_save_state(pdev);
       
  1010 	if (err)
       
  1011 		goto err_alloc_etherdev;
       
  1012 
       
  1013 	err = -ENOMEM;
       
  1014 	netdev = alloc_etherdev(sizeof(struct e1000_adapter));
       
  1015 	if (!netdev)
       
  1016 		goto err_alloc_etherdev;
       
  1017 
       
  1018 	SET_NETDEV_DEV(netdev, &pdev->dev);
       
  1019 
       
  1020 	pci_set_drvdata(pdev, netdev);
       
  1021 	adapter = netdev_priv(netdev);
       
  1022 	adapter->netdev = netdev;
       
  1023 	adapter->pdev = pdev;
       
  1024 	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
       
  1025 	adapter->bars = bars;
       
  1026 	adapter->need_ioport = need_ioport;
       
  1027 
       
  1028 	hw = &adapter->hw;
       
  1029 	hw->back = adapter;
       
  1030 
       
  1031 	err = -EIO;
       
  1032 	hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);
       
  1033 	if (!hw->hw_addr)
       
  1034 		goto err_ioremap;
       
  1035 
       
  1036 	if (adapter->need_ioport) {
       
  1037 		for (i = BAR_1; i <= BAR_5; i++) {
       
  1038 			if (pci_resource_len(pdev, i) == 0)
       
  1039 				continue;
       
  1040 			if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
       
  1041 				hw->io_base = pci_resource_start(pdev, i);
       
  1042 				break;
       
  1043 			}
       
  1044 		}
       
  1045 	}
       
  1046 
       
  1047 	/* make ready for any if (hw->...) below */
       
  1048 	err = e1000_init_hw_struct(adapter, hw);
       
  1049 	if (err)
       
  1050 		goto err_sw_init;
       
  1051 
       
  1052 	/*
       
  1053 	 * there is a workaround being applied below that limits
       
  1054 	 * 64-bit DMA addresses to 64-bit hardware.  There are some
       
  1055 	 * 32-bit adapters that Tx hang when given 64-bit DMA addresses
       
  1056 	 */
       
  1057 	pci_using_dac = 0;
       
  1058 	if ((hw->bus_type == e1000_bus_type_pcix) &&
       
  1059 	    !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
       
  1060 		/*
       
  1061 		 * according to DMA-API-HOWTO, coherent calls will always
       
  1062 		 * succeed if the set call did
       
  1063 		 */
       
  1064 		dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
       
  1065 		pci_using_dac = 1;
       
  1066 	} else {
       
  1067 		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
       
  1068 		if (err) {
       
  1069 			pr_err("No usable DMA config, aborting\n");
       
  1070 			goto err_dma;
       
  1071 		}
       
  1072 		dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
       
  1073 	}
       
  1074 
       
  1075 	netdev->netdev_ops = &e1000_netdev_ops;
       
  1076 	e1000_set_ethtool_ops(netdev);
       
  1077 	netdev->watchdog_timeo = 5 * HZ;
       
  1078 	netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);
       
  1079 
       
  1080 	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);
       
  1081 
       
  1082 	adapter->bd_number = cards_found;
       
  1083 
       
  1084 	/* setup the private structure */
       
  1085 
       
  1086 	err = e1000_sw_init(adapter);
       
  1087 	if (err)
       
  1088 		goto err_sw_init;
       
  1089 
       
  1090 	err = -EIO;
       
  1091 	if (hw->mac_type == e1000_ce4100) {
       
  1092 		hw->ce4100_gbe_mdio_base_virt =
       
  1093 					ioremap(pci_resource_start(pdev, BAR_1),
       
  1094 		                                pci_resource_len(pdev, BAR_1));
       
  1095 
       
  1096 		if (!hw->ce4100_gbe_mdio_base_virt)
       
  1097 			goto err_mdio_ioremap;
       
  1098 	}
       
  1099 
       
  1100 	if (hw->mac_type >= e1000_82543) {
       
  1101 		netdev->hw_features = NETIF_F_SG |
       
  1102 				   NETIF_F_HW_CSUM |
       
  1103 				   NETIF_F_HW_VLAN_RX;
       
  1104 		netdev->features = NETIF_F_HW_VLAN_TX |
       
  1105 				   NETIF_F_HW_VLAN_FILTER;
       
  1106 	}
       
  1107 
       
  1108 	if ((hw->mac_type >= e1000_82544) &&
       
  1109 	   (hw->mac_type != e1000_82547))
       
  1110 		netdev->hw_features |= NETIF_F_TSO;
       
  1111 
       
  1112 	netdev->priv_flags |= IFF_SUPP_NOFCS;
       
  1113 
       
  1114 	netdev->features |= netdev->hw_features;
       
  1115 	netdev->hw_features |= (NETIF_F_RXCSUM |
       
  1116 				NETIF_F_RXALL |
       
  1117 				NETIF_F_RXFCS);
       
  1118 
       
  1119 	if (pci_using_dac) {
       
  1120 		netdev->features |= NETIF_F_HIGHDMA;
       
  1121 		netdev->vlan_features |= NETIF_F_HIGHDMA;
       
  1122 	}
       
  1123 
       
  1124 	netdev->vlan_features |= (NETIF_F_TSO |
       
  1125 				  NETIF_F_HW_CSUM |
       
  1126 				  NETIF_F_SG);
       
  1127 
       
  1128 	netdev->priv_flags |= IFF_UNICAST_FLT;
       
  1129 
       
  1130 	adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw);
       
  1131 
       
  1132 	/* initialize eeprom parameters */
       
  1133 	if (e1000_init_eeprom_params(hw)) {
       
  1134 		e_err(probe, "EEPROM initialization failed\n");
       
  1135 		goto err_eeprom;
       
  1136 	}
       
  1137 
       
  1138 	/* before reading the EEPROM, reset the controller to
       
  1139 	 * put the device in a known good starting state */
       
  1140 
       
  1141 	e1000_reset_hw(hw);
       
  1142 
       
  1143 	/* make sure the EEPROM is good */
       
  1144 	if (e1000_validate_eeprom_checksum(hw) < 0) {
       
  1145 		e_err(probe, "The EEPROM Checksum Is Not Valid\n");
       
  1146 		e1000_dump_eeprom(adapter);
       
  1147 		/*
       
  1148 		 * set MAC address to all zeroes to invalidate and temporary
       
  1149 		 * disable this device for the user. This blocks regular
       
  1150 		 * traffic while still permitting ethtool ioctls from reaching
       
  1151 		 * the hardware as well as allowing the user to run the
       
  1152 		 * interface after manually setting a hw addr using
       
  1153 		 * `ip set address`
       
  1154 		 */
       
  1155 		memset(hw->mac_addr, 0, netdev->addr_len);
       
  1156 	} else {
       
  1157 		/* copy the MAC address out of the EEPROM */
       
  1158 		if (e1000_read_mac_addr(hw))
       
  1159 			e_err(probe, "EEPROM Read Error\n");
       
  1160 	}
       
  1161 	/* don't block initalization here due to bad MAC address */
       
  1162 	memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);
       
  1163 	memcpy(netdev->perm_addr, hw->mac_addr, netdev->addr_len);
       
  1164 
       
  1165 	if (!is_valid_ether_addr(netdev->perm_addr))
       
  1166 		e_err(probe, "Invalid MAC Address\n");
       
  1167 
       
  1168 
       
  1169 	INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog);
       
  1170 	INIT_DELAYED_WORK(&adapter->fifo_stall_task,
       
  1171 			  e1000_82547_tx_fifo_stall_task);
       
  1172 	INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);
       
  1173 	INIT_WORK(&adapter->reset_task, e1000_reset_task);
       
  1174 
       
  1175 	e1000_check_options(adapter);
       
  1176 
       
  1177 	/* Initial Wake on LAN setting
       
  1178 	 * If APM wake is enabled in the EEPROM,
       
  1179 	 * enable the ACPI Magic Packet filter
       
  1180 	 */
       
  1181 
       
  1182 	switch (hw->mac_type) {
       
  1183 	case e1000_82542_rev2_0:
       
  1184 	case e1000_82542_rev2_1:
       
  1185 	case e1000_82543:
       
  1186 		break;
       
  1187 	case e1000_82544:
       
  1188 		e1000_read_eeprom(hw,
       
  1189 			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);
       
  1190 		eeprom_apme_mask = E1000_EEPROM_82544_APM;
       
  1191 		break;
       
  1192 	case e1000_82546:
       
  1193 	case e1000_82546_rev_3:
       
  1194 		if (er32(STATUS) & E1000_STATUS_FUNC_1){
       
  1195 			e1000_read_eeprom(hw,
       
  1196 				EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);
       
  1197 			break;
       
  1198 		}
       
  1199 		/* Fall Through */
       
  1200 	default:
       
  1201 		e1000_read_eeprom(hw,
       
  1202 			EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);
       
  1203 		break;
       
  1204 	}
       
  1205 	if (eeprom_data & eeprom_apme_mask)
       
  1206 		adapter->eeprom_wol |= E1000_WUFC_MAG;
       
  1207 
       
  1208 	/* now that we have the eeprom settings, apply the special cases
       
  1209 	 * where the eeprom may be wrong or the board simply won't support
       
  1210 	 * wake on lan on a particular port */
       
  1211 	switch (pdev->device) {
       
  1212 	case E1000_DEV_ID_82546GB_PCIE:
       
  1213 		adapter->eeprom_wol = 0;
       
  1214 		break;
       
  1215 	case E1000_DEV_ID_82546EB_FIBER:
       
  1216 	case E1000_DEV_ID_82546GB_FIBER:
       
  1217 		/* Wake events only supported on port A for dual fiber
       
  1218 		 * regardless of eeprom setting */
       
  1219 		if (er32(STATUS) & E1000_STATUS_FUNC_1)
       
  1220 			adapter->eeprom_wol = 0;
       
  1221 		break;
       
  1222 	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:
       
  1223 		/* if quad port adapter, disable WoL on all but port A */
       
  1224 		if (global_quad_port_a != 0)
       
  1225 			adapter->eeprom_wol = 0;
       
  1226 		else
       
  1227 			adapter->quad_port_a = true;
       
  1228 		/* Reset for multiple quad port adapters */
       
  1229 		if (++global_quad_port_a == 4)
       
  1230 			global_quad_port_a = 0;
       
  1231 		break;
       
  1232 	}
       
  1233 
       
  1234 	/* initialize the wol settings based on the eeprom settings */
       
  1235 	adapter->wol = adapter->eeprom_wol;
       
  1236 	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
       
  1237 
       
  1238 	/* Auto detect PHY address */
       
  1239 	if (hw->mac_type == e1000_ce4100) {
       
  1240 		for (i = 0; i < 32; i++) {
       
  1241 			hw->phy_addr = i;
       
  1242 			e1000_read_phy_reg(hw, PHY_ID2, &tmp);
       
  1243 			if (tmp == 0 || tmp == 0xFF) {
       
  1244 				if (i == 31)
       
  1245 					goto err_eeprom;
       
  1246 				continue;
       
  1247 			} else
       
  1248 				break;
       
  1249 		}
       
  1250 	}
       
  1251 
       
  1252 	/* reset the hardware with the new settings */
       
  1253 	e1000_reset(adapter);
       
  1254 
       
  1255  	// offer device to EtherCAT master module
       
  1256 	adapter->ecdev = ecdev_offer(netdev, ec_poll, THIS_MODULE);
       
  1257 	if (adapter->ecdev) {
       
  1258 		err = ecdev_open(adapter->ecdev);
       
  1259 		if (err) {
       
  1260 			ecdev_withdraw(adapter->ecdev);
       
  1261 			goto err_register;
       
  1262 		}
       
  1263 	} else {
       
  1264 		strcpy(netdev->name, "eth%d");
       
  1265 		err = register_netdev(netdev);
       
  1266 		if (err)
       
  1267 			goto err_register;
       
  1268 	}
       
  1269 
       
  1270 	e1000_vlan_filter_on_off(adapter, false);
       
  1271 
       
  1272 	/* print bus type/speed/width info */
       
  1273 	e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",
       
  1274 	       ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),
       
  1275 	       ((hw->bus_speed == e1000_bus_speed_133) ? 133 :
       
  1276 		(hw->bus_speed == e1000_bus_speed_120) ? 120 :
       
  1277 		(hw->bus_speed == e1000_bus_speed_100) ? 100 :
       
  1278 		(hw->bus_speed == e1000_bus_speed_66) ? 66 : 33),
       
  1279 	       ((hw->bus_width == e1000_bus_width_64) ? 64 : 32),
       
  1280 	       netdev->dev_addr);
       
  1281 
       
  1282 	if (!adapter->ecdev) {
       
  1283 		/* carrier off reporting is important to ethtool even BEFORE open */
       
  1284 		netif_carrier_off(netdev);
       
  1285 	}
       
  1286 
       
  1287 	e_info(probe, "Intel(R) PRO/1000 Network Connection\n");
       
  1288 
       
  1289 	cards_found++;
       
  1290 	return 0;
       
  1291 
       
  1292 err_register:
       
  1293 err_eeprom:
       
  1294 	e1000_phy_hw_reset(hw);
       
  1295 
       
  1296 	if (hw->flash_address)
       
  1297 		iounmap(hw->flash_address);
       
  1298 	kfree(adapter->tx_ring);
       
  1299 	kfree(adapter->rx_ring);
       
  1300 err_dma:
       
  1301 err_sw_init:
       
  1302 err_mdio_ioremap:
       
  1303 	iounmap(hw->ce4100_gbe_mdio_base_virt);
       
  1304 	iounmap(hw->hw_addr);
       
  1305 err_ioremap:
       
  1306 	free_netdev(netdev);
       
  1307 err_alloc_etherdev:
       
  1308 	pci_release_selected_regions(pdev, bars);
       
  1309 err_pci_reg:
       
  1310 	pci_disable_device(pdev);
       
  1311 	return err;
       
  1312 }
       
  1313 
       
  1314 /**
       
  1315  * e1000_remove - Device Removal Routine
       
  1316  * @pdev: PCI device information struct
       
  1317  *
       
  1318  * e1000_remove is called by the PCI subsystem to alert the driver
       
  1319  * that it should release a PCI device.  The could be caused by a
       
  1320  * Hot-Plug event, or because the driver is going to be removed from
       
  1321  * memory.
       
  1322  **/
       
  1323 
       
  1324 static void e1000_remove(struct pci_dev *pdev)
       
  1325 {
       
  1326 	struct net_device *netdev = pci_get_drvdata(pdev);
       
  1327 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  1328 	struct e1000_hw *hw = &adapter->hw;
       
  1329 
       
  1330 	e1000_down_and_stop(adapter);
       
  1331 	e1000_release_manageability(adapter);
       
  1332 
       
  1333 	if (adapter->ecdev) {
       
  1334 		ecdev_close(adapter->ecdev);
       
  1335 		ecdev_withdraw(adapter->ecdev);
       
  1336 	} else {
       
  1337 		unregister_netdev(netdev);
       
  1338 	}
       
  1339 
       
  1340 	e1000_phy_hw_reset(hw);
       
  1341 
       
  1342 	kfree(adapter->tx_ring);
       
  1343 	kfree(adapter->rx_ring);
       
  1344 
       
  1345 	if (hw->mac_type == e1000_ce4100)
       
  1346 		iounmap(hw->ce4100_gbe_mdio_base_virt);
       
  1347 	iounmap(hw->hw_addr);
       
  1348 	if (hw->flash_address)
       
  1349 		iounmap(hw->flash_address);
       
  1350 	pci_release_selected_regions(pdev, adapter->bars);
       
  1351 
       
  1352 	free_netdev(netdev);
       
  1353 
       
  1354 	pci_disable_device(pdev);
       
  1355 }
       
  1356 
       
  1357 /**
       
  1358  * e1000_sw_init - Initialize general software structures (struct e1000_adapter)
       
  1359  * @adapter: board private structure to initialize
       
  1360  *
       
  1361  * e1000_sw_init initializes the Adapter private data structure.
       
  1362  * e1000_init_hw_struct MUST be called before this function
       
  1363  **/
       
  1364 
       
  1365 static int e1000_sw_init(struct e1000_adapter *adapter)
       
  1366 {
       
  1367 	adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
       
  1368 
       
  1369 	adapter->num_tx_queues = 1;
       
  1370 	adapter->num_rx_queues = 1;
       
  1371 
       
  1372 	if (e1000_alloc_queues(adapter)) {
       
  1373 		e_err(probe, "Unable to allocate memory for queues\n");
       
  1374 		return -ENOMEM;
       
  1375 	}
       
  1376 
       
  1377 	/* Explicitly disable IRQ since the NIC can be in any state. */
       
  1378 	e1000_irq_disable(adapter);
       
  1379 
       
  1380 	spin_lock_init(&adapter->stats_lock);
       
  1381 	mutex_init(&adapter->mutex);
       
  1382 
       
  1383 	set_bit(__E1000_DOWN, &adapter->flags);
       
  1384 
       
  1385 	return 0;
       
  1386 }
       
  1387 
       
  1388 /**
       
  1389  * e1000_alloc_queues - Allocate memory for all rings
       
  1390  * @adapter: board private structure to initialize
       
  1391  *
       
  1392  * We allocate one ring per queue at run-time since we don't know the
       
  1393  * number of queues at compile-time.
       
  1394  **/
       
  1395 
       
  1396 static int e1000_alloc_queues(struct e1000_adapter *adapter)
       
  1397 {
       
  1398 	adapter->tx_ring = kcalloc(adapter->num_tx_queues,
       
  1399 	                           sizeof(struct e1000_tx_ring), GFP_KERNEL);
       
  1400 	if (!adapter->tx_ring)
       
  1401 		return -ENOMEM;
       
  1402 
       
  1403 	adapter->rx_ring = kcalloc(adapter->num_rx_queues,
       
  1404 	                           sizeof(struct e1000_rx_ring), GFP_KERNEL);
       
  1405 	if (!adapter->rx_ring) {
       
  1406 		kfree(adapter->tx_ring);
       
  1407 		return -ENOMEM;
       
  1408 	}
       
  1409 
       
  1410 	return E1000_SUCCESS;
       
  1411 }
       
  1412 
       
  1413 /**
       
  1414  * e1000_open - Called when a network interface is made active
       
  1415  * @netdev: network interface device structure
       
  1416  *
       
  1417  * Returns 0 on success, negative value on failure
       
  1418  *
       
  1419  * The open entry point is called when a network interface is made
       
  1420  * active by the system (IFF_UP).  At this point all resources needed
       
  1421  * for transmit and receive operations are allocated, the interrupt
       
  1422  * handler is registered with the OS, the watchdog task is started,
       
  1423  * and the stack is notified that the interface is ready.
       
  1424  **/
       
  1425 
       
  1426 static int e1000_open(struct net_device *netdev)
       
  1427 {
       
  1428 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  1429 	struct e1000_hw *hw = &adapter->hw;
       
  1430 	int err;
       
  1431 
       
  1432 	/* disallow open during test */
       
  1433 	if (test_bit(__E1000_TESTING, &adapter->flags))
       
  1434 		return -EBUSY;
       
  1435 
       
  1436 	netif_carrier_off(netdev);
       
  1437 
       
  1438 	/* allocate transmit descriptors */
       
  1439 	err = e1000_setup_all_tx_resources(adapter);
       
  1440 	if (err)
       
  1441 		goto err_setup_tx;
       
  1442 
       
  1443 	/* allocate receive descriptors */
       
  1444 	err = e1000_setup_all_rx_resources(adapter);
       
  1445 	if (err)
       
  1446 		goto err_setup_rx;
       
  1447 
       
  1448 	e1000_power_up_phy(adapter);
       
  1449 
       
  1450 	adapter->mng_vlan_id = E1000_MNG_VLAN_NONE;
       
  1451 	if ((hw->mng_cookie.status &
       
  1452 			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT)) {
       
  1453 		e1000_update_mng_vlan(adapter);
       
  1454 	}
       
  1455 
       
  1456 	/* before we allocate an interrupt, we must be ready to handle it.
       
  1457 	 * Setting DEBUG_SHIRQ in the kernel makes it fire an interrupt
       
  1458 	 * as soon as we call pci_request_irq, so we have to setup our
       
  1459 	 * clean_rx handler before we do so.  */
       
  1460 	e1000_configure(adapter);
       
  1461 
       
  1462 	err = e1000_request_irq(adapter);
       
  1463 	if (err)
       
  1464 		goto err_req_irq;
       
  1465 
       
  1466 	/* From here on the code is the same as e1000_up() */
       
  1467 	clear_bit(__E1000_DOWN, &adapter->flags);
       
  1468 
       
  1469 	if (!adapter->ecdev) {
       
  1470 		napi_enable(&adapter->napi);
       
  1471 
       
  1472 		e1000_irq_enable(adapter);
       
  1473 
       
  1474 		netif_start_queue(netdev);
       
  1475 	}
       
  1476 
       
  1477 	/* fire a link status change interrupt to start the watchdog */
       
  1478 	ew32(ICS, E1000_ICS_LSC);
       
  1479 
       
  1480 	return E1000_SUCCESS;
       
  1481 
       
  1482 err_req_irq:
       
  1483 	e1000_power_down_phy(adapter);
       
  1484 	e1000_free_all_rx_resources(adapter);
       
  1485 err_setup_rx:
       
  1486 	e1000_free_all_tx_resources(adapter);
       
  1487 err_setup_tx:
       
  1488 	e1000_reset(adapter);
       
  1489 
       
  1490 	return err;
       
  1491 }
       
  1492 
       
  1493 /**
       
  1494  * e1000_close - Disables a network interface
       
  1495  * @netdev: network interface device structure
       
  1496  *
       
  1497  * Returns 0, this is not allowed to fail
       
  1498  *
       
  1499  * The close entry point is called when an interface is de-activated
       
  1500  * by the OS.  The hardware is still under the drivers control, but
       
  1501  * needs to be disabled.  A global MAC reset is issued to stop the
       
  1502  * hardware, and all transmit and receive resources are freed.
       
  1503  **/
       
  1504 
       
  1505 static int e1000_close(struct net_device *netdev)
       
  1506 {
       
  1507 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  1508 	struct e1000_hw *hw = &adapter->hw;
       
  1509 
       
  1510 	WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
       
  1511 	e1000_down(adapter);
       
  1512 	e1000_power_down_phy(adapter);
       
  1513 	e1000_free_irq(adapter);
       
  1514 
       
  1515 	e1000_free_all_tx_resources(adapter);
       
  1516 	e1000_free_all_rx_resources(adapter);
       
  1517 
       
  1518 	/* kill manageability vlan ID if supported, but not if a vlan with
       
  1519 	 * the same ID is registered on the host OS (let 8021q kill it) */
       
  1520 	if ((hw->mng_cookie.status &
       
  1521 			  E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
       
  1522 	     !test_bit(adapter->mng_vlan_id, adapter->active_vlans)) {
       
  1523 		e1000_vlan_rx_kill_vid(netdev, adapter->mng_vlan_id);
       
  1524 	}
       
  1525 
       
  1526 	return 0;
       
  1527 }
       
  1528 
       
  1529 /**
       
  1530  * e1000_check_64k_bound - check that memory doesn't cross 64kB boundary
       
  1531  * @adapter: address of board private structure
       
  1532  * @start: address of beginning of memory
       
  1533  * @len: length of memory
       
  1534  **/
       
  1535 static bool e1000_check_64k_bound(struct e1000_adapter *adapter, void *start,
       
  1536 				  unsigned long len)
       
  1537 {
       
  1538 	struct e1000_hw *hw = &adapter->hw;
       
  1539 	unsigned long begin = (unsigned long)start;
       
  1540 	unsigned long end = begin + len;
       
  1541 
       
  1542 	/* First rev 82545 and 82546 need to not allow any memory
       
  1543 	 * write location to cross 64k boundary due to errata 23 */
       
  1544 	if (hw->mac_type == e1000_82545 ||
       
  1545 	    hw->mac_type == e1000_ce4100 ||
       
  1546 	    hw->mac_type == e1000_82546) {
       
  1547 		return ((begin ^ (end - 1)) >> 16) != 0 ? false : true;
       
  1548 	}
       
  1549 
       
  1550 	return true;
       
  1551 }
       
  1552 
       
  1553 /**
       
  1554  * e1000_setup_tx_resources - allocate Tx resources (Descriptors)
       
  1555  * @adapter: board private structure
       
  1556  * @txdr:    tx descriptor ring (for a specific queue) to setup
       
  1557  *
       
  1558  * Return 0 on success, negative on failure
       
  1559  **/
       
  1560 
       
  1561 static int e1000_setup_tx_resources(struct e1000_adapter *adapter,
       
  1562 				    struct e1000_tx_ring *txdr)
       
  1563 {
       
  1564 	struct pci_dev *pdev = adapter->pdev;
       
  1565 	int size;
       
  1566 
       
  1567 	size = sizeof(struct e1000_buffer) * txdr->count;
       
  1568 	txdr->buffer_info = vzalloc(size);
       
  1569 	if (!txdr->buffer_info) {
       
  1570 		e_err(probe, "Unable to allocate memory for the Tx descriptor "
       
  1571 		      "ring\n");
       
  1572 		return -ENOMEM;
       
  1573 	}
       
  1574 
       
  1575 	/* round up to nearest 4K */
       
  1576 
       
  1577 	txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
       
  1578 	txdr->size = ALIGN(txdr->size, 4096);
       
  1579 
       
  1580 	txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
       
  1581 					GFP_KERNEL);
       
  1582 	if (!txdr->desc) {
       
  1583 setup_tx_desc_die:
       
  1584 		vfree(txdr->buffer_info);
       
  1585 		e_err(probe, "Unable to allocate memory for the Tx descriptor "
       
  1586 		      "ring\n");
       
  1587 		return -ENOMEM;
       
  1588 	}
       
  1589 
       
  1590 	/* Fix for errata 23, can't cross 64kB boundary */
       
  1591 	if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
       
  1592 		void *olddesc = txdr->desc;
       
  1593 		dma_addr_t olddma = txdr->dma;
       
  1594 		e_err(tx_err, "txdr align check failed: %u bytes at %p\n",
       
  1595 		      txdr->size, txdr->desc);
       
  1596 		/* Try again, without freeing the previous */
       
  1597 		txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size,
       
  1598 						&txdr->dma, GFP_KERNEL);
       
  1599 		/* Failed allocation, critical failure */
       
  1600 		if (!txdr->desc) {
       
  1601 			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
       
  1602 					  olddma);
       
  1603 			goto setup_tx_desc_die;
       
  1604 		}
       
  1605 
       
  1606 		if (!e1000_check_64k_bound(adapter, txdr->desc, txdr->size)) {
       
  1607 			/* give up */
       
  1608 			dma_free_coherent(&pdev->dev, txdr->size, txdr->desc,
       
  1609 					  txdr->dma);
       
  1610 			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
       
  1611 					  olddma);
       
  1612 			e_err(probe, "Unable to allocate aligned memory "
       
  1613 			      "for the transmit descriptor ring\n");
       
  1614 			vfree(txdr->buffer_info);
       
  1615 			return -ENOMEM;
       
  1616 		} else {
       
  1617 			/* Free old allocation, new allocation was successful */
       
  1618 			dma_free_coherent(&pdev->dev, txdr->size, olddesc,
       
  1619 					  olddma);
       
  1620 		}
       
  1621 	}
       
  1622 	memset(txdr->desc, 0, txdr->size);
       
  1623 
       
  1624 	txdr->next_to_use = 0;
       
  1625 	txdr->next_to_clean = 0;
       
  1626 
       
  1627 	return 0;
       
  1628 }
       
  1629 
       
  1630 /**
       
  1631  * e1000_setup_all_tx_resources - wrapper to allocate Tx resources
       
  1632  * 				  (Descriptors) for all queues
       
  1633  * @adapter: board private structure
       
  1634  *
       
  1635  * Return 0 on success, negative on failure
       
  1636  **/
       
  1637 
       
  1638 int e1000_setup_all_tx_resources(struct e1000_adapter *adapter)
       
  1639 {
       
  1640 	int i, err = 0;
       
  1641 
       
  1642 	for (i = 0; i < adapter->num_tx_queues; i++) {
       
  1643 		err = e1000_setup_tx_resources(adapter, &adapter->tx_ring[i]);
       
  1644 		if (err) {
       
  1645 			e_err(probe, "Allocation for Tx Queue %u failed\n", i);
       
  1646 			for (i-- ; i >= 0; i--)
       
  1647 				e1000_free_tx_resources(adapter,
       
  1648 							&adapter->tx_ring[i]);
       
  1649 			break;
       
  1650 		}
       
  1651 	}
       
  1652 
       
  1653 	return err;
       
  1654 }
       
  1655 
       
  1656 /**
       
  1657  * e1000_configure_tx - Configure 8254x Transmit Unit after Reset
       
  1658  * @adapter: board private structure
       
  1659  *
       
  1660  * Configure the Tx unit of the MAC after a reset.
       
  1661  **/
       
  1662 
       
  1663 static void e1000_configure_tx(struct e1000_adapter *adapter)
       
  1664 {
       
  1665 	u64 tdba;
       
  1666 	struct e1000_hw *hw = &adapter->hw;
       
  1667 	u32 tdlen, tctl, tipg;
       
  1668 	u32 ipgr1, ipgr2;
       
  1669 
       
  1670 	/* Setup the HW Tx Head and Tail descriptor pointers */
       
  1671 
       
  1672 	switch (adapter->num_tx_queues) {
       
  1673 	case 1:
       
  1674 	default:
       
  1675 		tdba = adapter->tx_ring[0].dma;
       
  1676 		tdlen = adapter->tx_ring[0].count *
       
  1677 			sizeof(struct e1000_tx_desc);
       
  1678 		ew32(TDLEN, tdlen);
       
  1679 		ew32(TDBAH, (tdba >> 32));
       
  1680 		ew32(TDBAL, (tdba & 0x00000000ffffffffULL));
       
  1681 		ew32(TDT, 0);
       
  1682 		ew32(TDH, 0);
       
  1683 		adapter->tx_ring[0].tdh = ((hw->mac_type >= e1000_82543) ? E1000_TDH : E1000_82542_TDH);
       
  1684 		adapter->tx_ring[0].tdt = ((hw->mac_type >= e1000_82543) ? E1000_TDT : E1000_82542_TDT);
       
  1685 		break;
       
  1686 	}
       
  1687 
       
  1688 	/* Set the default values for the Tx Inter Packet Gap timer */
       
  1689 	if ((hw->media_type == e1000_media_type_fiber ||
       
  1690 	     hw->media_type == e1000_media_type_internal_serdes))
       
  1691 		tipg = DEFAULT_82543_TIPG_IPGT_FIBER;
       
  1692 	else
       
  1693 		tipg = DEFAULT_82543_TIPG_IPGT_COPPER;
       
  1694 
       
  1695 	switch (hw->mac_type) {
       
  1696 	case e1000_82542_rev2_0:
       
  1697 	case e1000_82542_rev2_1:
       
  1698 		tipg = DEFAULT_82542_TIPG_IPGT;
       
  1699 		ipgr1 = DEFAULT_82542_TIPG_IPGR1;
       
  1700 		ipgr2 = DEFAULT_82542_TIPG_IPGR2;
       
  1701 		break;
       
  1702 	default:
       
  1703 		ipgr1 = DEFAULT_82543_TIPG_IPGR1;
       
  1704 		ipgr2 = DEFAULT_82543_TIPG_IPGR2;
       
  1705 		break;
       
  1706 	}
       
  1707 	tipg |= ipgr1 << E1000_TIPG_IPGR1_SHIFT;
       
  1708 	tipg |= ipgr2 << E1000_TIPG_IPGR2_SHIFT;
       
  1709 	ew32(TIPG, tipg);
       
  1710 
       
  1711 	/* Set the Tx Interrupt Delay register */
       
  1712 
       
  1713 	ew32(TIDV, adapter->tx_int_delay);
       
  1714 	if (hw->mac_type >= e1000_82540)
       
  1715 		ew32(TADV, adapter->tx_abs_int_delay);
       
  1716 
       
  1717 	/* Program the Transmit Control Register */
       
  1718 
       
  1719 	tctl = er32(TCTL);
       
  1720 	tctl &= ~E1000_TCTL_CT;
       
  1721 	tctl |= E1000_TCTL_PSP | E1000_TCTL_RTLC |
       
  1722 		(E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT);
       
  1723 
       
  1724 	e1000_config_collision_dist(hw);
       
  1725 
       
  1726 	/* Setup Transmit Descriptor Settings for eop descriptor */
       
  1727 	adapter->txd_cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_IFCS;
       
  1728 
       
  1729 	/* only set IDE if we are delaying interrupts using the timers */
       
  1730 	if (adapter->tx_int_delay)
       
  1731 		adapter->txd_cmd |= E1000_TXD_CMD_IDE;
       
  1732 
       
  1733 	if (hw->mac_type < e1000_82543)
       
  1734 		adapter->txd_cmd |= E1000_TXD_CMD_RPS;
       
  1735 	else
       
  1736 		adapter->txd_cmd |= E1000_TXD_CMD_RS;
       
  1737 
       
  1738 	/* Cache if we're 82544 running in PCI-X because we'll
       
  1739 	 * need this to apply a workaround later in the send path. */
       
  1740 	if (hw->mac_type == e1000_82544 &&
       
  1741 	    hw->bus_type == e1000_bus_type_pcix)
       
  1742 		adapter->pcix_82544 = true;
       
  1743 
       
  1744 	ew32(TCTL, tctl);
       
  1745 
       
  1746 }
       
  1747 
       
  1748 /**
       
  1749  * e1000_setup_rx_resources - allocate Rx resources (Descriptors)
       
  1750  * @adapter: board private structure
       
  1751  * @rxdr:    rx descriptor ring (for a specific queue) to setup
       
  1752  *
       
  1753  * Returns 0 on success, negative on failure
       
  1754  **/
       
  1755 
       
  1756 static int e1000_setup_rx_resources(struct e1000_adapter *adapter,
       
  1757 				    struct e1000_rx_ring *rxdr)
       
  1758 {
       
  1759 	struct pci_dev *pdev = adapter->pdev;
       
  1760 	int size, desc_len;
       
  1761 
       
  1762 	size = sizeof(struct e1000_buffer) * rxdr->count;
       
  1763 	rxdr->buffer_info = vzalloc(size);
       
  1764 	if (!rxdr->buffer_info) {
       
  1765 		e_err(probe, "Unable to allocate memory for the Rx descriptor "
       
  1766 		      "ring\n");
       
  1767 		return -ENOMEM;
       
  1768 	}
       
  1769 
       
  1770 	desc_len = sizeof(struct e1000_rx_desc);
       
  1771 
       
  1772 	/* Round up to nearest 4K */
       
  1773 
       
  1774 	rxdr->size = rxdr->count * desc_len;
       
  1775 	rxdr->size = ALIGN(rxdr->size, 4096);
       
  1776 
       
  1777 	rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
       
  1778 					GFP_KERNEL);
       
  1779 
       
  1780 	if (!rxdr->desc) {
       
  1781 		e_err(probe, "Unable to allocate memory for the Rx descriptor "
       
  1782 		      "ring\n");
       
  1783 setup_rx_desc_die:
       
  1784 		vfree(rxdr->buffer_info);
       
  1785 		return -ENOMEM;
       
  1786 	}
       
  1787 
       
  1788 	/* Fix for errata 23, can't cross 64kB boundary */
       
  1789 	if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
       
  1790 		void *olddesc = rxdr->desc;
       
  1791 		dma_addr_t olddma = rxdr->dma;
       
  1792 		e_err(rx_err, "rxdr align check failed: %u bytes at %p\n",
       
  1793 		      rxdr->size, rxdr->desc);
       
  1794 		/* Try again, without freeing the previous */
       
  1795 		rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size,
       
  1796 						&rxdr->dma, GFP_KERNEL);
       
  1797 		/* Failed allocation, critical failure */
       
  1798 		if (!rxdr->desc) {
       
  1799 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
       
  1800 					  olddma);
       
  1801 			e_err(probe, "Unable to allocate memory for the Rx "
       
  1802 			      "descriptor ring\n");
       
  1803 			goto setup_rx_desc_die;
       
  1804 		}
       
  1805 
       
  1806 		if (!e1000_check_64k_bound(adapter, rxdr->desc, rxdr->size)) {
       
  1807 			/* give up */
       
  1808 			dma_free_coherent(&pdev->dev, rxdr->size, rxdr->desc,
       
  1809 					  rxdr->dma);
       
  1810 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
       
  1811 					  olddma);
       
  1812 			e_err(probe, "Unable to allocate aligned memory for "
       
  1813 			      "the Rx descriptor ring\n");
       
  1814 			goto setup_rx_desc_die;
       
  1815 		} else {
       
  1816 			/* Free old allocation, new allocation was successful */
       
  1817 			dma_free_coherent(&pdev->dev, rxdr->size, olddesc,
       
  1818 					  olddma);
       
  1819 		}
       
  1820 	}
       
  1821 	memset(rxdr->desc, 0, rxdr->size);
       
  1822 
       
  1823 	rxdr->next_to_clean = 0;
       
  1824 	rxdr->next_to_use = 0;
       
  1825 	rxdr->rx_skb_top = NULL;
       
  1826 
       
  1827 	return 0;
       
  1828 }
       
  1829 
       
  1830 /**
       
  1831  * e1000_setup_all_rx_resources - wrapper to allocate Rx resources
       
  1832  * 				  (Descriptors) for all queues
       
  1833  * @adapter: board private structure
       
  1834  *
       
  1835  * Return 0 on success, negative on failure
       
  1836  **/
       
  1837 
       
  1838 int e1000_setup_all_rx_resources(struct e1000_adapter *adapter)
       
  1839 {
       
  1840 	int i, err = 0;
       
  1841 
       
  1842 	for (i = 0; i < adapter->num_rx_queues; i++) {
       
  1843 		err = e1000_setup_rx_resources(adapter, &adapter->rx_ring[i]);
       
  1844 		if (err) {
       
  1845 			e_err(probe, "Allocation for Rx Queue %u failed\n", i);
       
  1846 			for (i-- ; i >= 0; i--)
       
  1847 				e1000_free_rx_resources(adapter,
       
  1848 							&adapter->rx_ring[i]);
       
  1849 			break;
       
  1850 		}
       
  1851 	}
       
  1852 
       
  1853 	return err;
       
  1854 }
       
  1855 
       
  1856 /**
       
  1857  * e1000_setup_rctl - configure the receive control registers
       
  1858  * @adapter: Board private structure
       
  1859  **/
       
  1860 static void e1000_setup_rctl(struct e1000_adapter *adapter)
       
  1861 {
       
  1862 	struct e1000_hw *hw = &adapter->hw;
       
  1863 	u32 rctl;
       
  1864 
       
  1865 	rctl = er32(RCTL);
       
  1866 
       
  1867 	rctl &= ~(3 << E1000_RCTL_MO_SHIFT);
       
  1868 
       
  1869 	rctl |= E1000_RCTL_BAM | E1000_RCTL_LBM_NO |
       
  1870 		E1000_RCTL_RDMTS_HALF |
       
  1871 		(hw->mc_filter_type << E1000_RCTL_MO_SHIFT);
       
  1872 
       
  1873 	if (hw->tbi_compatibility_on == 1)
       
  1874 		rctl |= E1000_RCTL_SBP;
       
  1875 	else
       
  1876 		rctl &= ~E1000_RCTL_SBP;
       
  1877 
       
  1878 	if (adapter->netdev->mtu <= ETH_DATA_LEN)
       
  1879 		rctl &= ~E1000_RCTL_LPE;
       
  1880 	else
       
  1881 		rctl |= E1000_RCTL_LPE;
       
  1882 
       
  1883 	/* Setup buffer sizes */
       
  1884 	rctl &= ~E1000_RCTL_SZ_4096;
       
  1885 	rctl |= E1000_RCTL_BSEX;
       
  1886 	switch (adapter->rx_buffer_len) {
       
  1887 		case E1000_RXBUFFER_2048:
       
  1888 		default:
       
  1889 			rctl |= E1000_RCTL_SZ_2048;
       
  1890 			rctl &= ~E1000_RCTL_BSEX;
       
  1891 			break;
       
  1892 		case E1000_RXBUFFER_4096:
       
  1893 			rctl |= E1000_RCTL_SZ_4096;
       
  1894 			break;
       
  1895 		case E1000_RXBUFFER_8192:
       
  1896 			rctl |= E1000_RCTL_SZ_8192;
       
  1897 			break;
       
  1898 		case E1000_RXBUFFER_16384:
       
  1899 			rctl |= E1000_RCTL_SZ_16384;
       
  1900 			break;
       
  1901 	}
       
  1902 
       
  1903 	/* This is useful for sniffing bad packets. */
       
  1904 	if (adapter->netdev->features & NETIF_F_RXALL) {
       
  1905 		/* UPE and MPE will be handled by normal PROMISC logic
       
  1906 		 * in e1000e_set_rx_mode */
       
  1907 		rctl |= (E1000_RCTL_SBP | /* Receive bad packets */
       
  1908 			 E1000_RCTL_BAM | /* RX All Bcast Pkts */
       
  1909 			 E1000_RCTL_PMCF); /* RX All MAC Ctrl Pkts */
       
  1910 
       
  1911 		rctl &= ~(E1000_RCTL_VFE | /* Disable VLAN filter */
       
  1912 			  E1000_RCTL_DPF | /* Allow filtered pause */
       
  1913 			  E1000_RCTL_CFIEN); /* Dis VLAN CFIEN Filter */
       
  1914 		/* Do not mess with E1000_CTRL_VME, it affects transmit as well,
       
  1915 		 * and that breaks VLANs.
       
  1916 		 */
       
  1917 	}
       
  1918 
       
  1919 	ew32(RCTL, rctl);
       
  1920 }
       
  1921 
       
  1922 /**
       
  1923  * e1000_configure_rx - Configure 8254x Receive Unit after Reset
       
  1924  * @adapter: board private structure
       
  1925  *
       
  1926  * Configure the Rx unit of the MAC after a reset.
       
  1927  **/
       
  1928 
       
  1929 static void e1000_configure_rx(struct e1000_adapter *adapter)
       
  1930 {
       
  1931 	u64 rdba;
       
  1932 	struct e1000_hw *hw = &adapter->hw;
       
  1933 	u32 rdlen, rctl, rxcsum;
       
  1934 
       
  1935 	if (adapter->netdev->mtu > ETH_DATA_LEN) {
       
  1936 		rdlen = adapter->rx_ring[0].count *
       
  1937 		        sizeof(struct e1000_rx_desc);
       
  1938 		adapter->clean_rx = e1000_clean_jumbo_rx_irq;
       
  1939 		adapter->alloc_rx_buf = e1000_alloc_jumbo_rx_buffers;
       
  1940 	} else {
       
  1941 		rdlen = adapter->rx_ring[0].count *
       
  1942 		        sizeof(struct e1000_rx_desc);
       
  1943 		adapter->clean_rx = e1000_clean_rx_irq;
       
  1944 		adapter->alloc_rx_buf = e1000_alloc_rx_buffers;
       
  1945 	}
       
  1946 
       
  1947 	/* disable receives while setting up the descriptors */
       
  1948 	rctl = er32(RCTL);
       
  1949 	ew32(RCTL, rctl & ~E1000_RCTL_EN);
       
  1950 
       
  1951 	/* set the Receive Delay Timer Register */
       
  1952 	ew32(RDTR, adapter->rx_int_delay);
       
  1953 
       
  1954 	if (hw->mac_type >= e1000_82540) {
       
  1955 		ew32(RADV, adapter->rx_abs_int_delay);
       
  1956 		if (adapter->itr_setting != 0)
       
  1957 			ew32(ITR, 1000000000 / (adapter->itr * 256));
       
  1958 	}
       
  1959 
       
  1960 	/* Setup the HW Rx Head and Tail Descriptor Pointers and
       
  1961 	 * the Base and Length of the Rx Descriptor Ring */
       
  1962 	switch (adapter->num_rx_queues) {
       
  1963 	case 1:
       
  1964 	default:
       
  1965 		rdba = adapter->rx_ring[0].dma;
       
  1966 		ew32(RDLEN, rdlen);
       
  1967 		ew32(RDBAH, (rdba >> 32));
       
  1968 		ew32(RDBAL, (rdba & 0x00000000ffffffffULL));
       
  1969 		ew32(RDT, 0);
       
  1970 		ew32(RDH, 0);
       
  1971 		adapter->rx_ring[0].rdh = ((hw->mac_type >= e1000_82543) ? E1000_RDH : E1000_82542_RDH);
       
  1972 		adapter->rx_ring[0].rdt = ((hw->mac_type >= e1000_82543) ? E1000_RDT : E1000_82542_RDT);
       
  1973 		break;
       
  1974 	}
       
  1975 
       
  1976 	/* Enable 82543 Receive Checksum Offload for TCP and UDP */
       
  1977 	if (hw->mac_type >= e1000_82543) {
       
  1978 		rxcsum = er32(RXCSUM);
       
  1979 		if (adapter->rx_csum)
       
  1980 			rxcsum |= E1000_RXCSUM_TUOFL;
       
  1981 		else
       
  1982 			/* don't need to clear IPPCSE as it defaults to 0 */
       
  1983 			rxcsum &= ~E1000_RXCSUM_TUOFL;
       
  1984 		ew32(RXCSUM, rxcsum);
       
  1985 	}
       
  1986 
       
  1987 	/* Enable Receives */
       
  1988 	ew32(RCTL, rctl | E1000_RCTL_EN);
       
  1989 }
       
  1990 
       
  1991 /**
       
  1992  * e1000_free_tx_resources - Free Tx Resources per Queue
       
  1993  * @adapter: board private structure
       
  1994  * @tx_ring: Tx descriptor ring for a specific queue
       
  1995  *
       
  1996  * Free all transmit software resources
       
  1997  **/
       
  1998 
       
  1999 static void e1000_free_tx_resources(struct e1000_adapter *adapter,
       
  2000 				    struct e1000_tx_ring *tx_ring)
       
  2001 {
       
  2002 	struct pci_dev *pdev = adapter->pdev;
       
  2003 
       
  2004 	e1000_clean_tx_ring(adapter, tx_ring);
       
  2005 
       
  2006 	vfree(tx_ring->buffer_info);
       
  2007 	tx_ring->buffer_info = NULL;
       
  2008 
       
  2009 	dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,
       
  2010 			  tx_ring->dma);
       
  2011 
       
  2012 	tx_ring->desc = NULL;
       
  2013 }
       
  2014 
       
  2015 /**
       
  2016  * e1000_free_all_tx_resources - Free Tx Resources for All Queues
       
  2017  * @adapter: board private structure
       
  2018  *
       
  2019  * Free all transmit software resources
       
  2020  **/
       
  2021 
       
  2022 void e1000_free_all_tx_resources(struct e1000_adapter *adapter)
       
  2023 {
       
  2024 	int i;
       
  2025 
       
  2026 	for (i = 0; i < adapter->num_tx_queues; i++)
       
  2027 		e1000_free_tx_resources(adapter, &adapter->tx_ring[i]);
       
  2028 }
       
  2029 
       
  2030 static void e1000_unmap_and_free_tx_resource(struct e1000_adapter *adapter,
       
  2031 					     struct e1000_buffer *buffer_info)
       
  2032 {
       
  2033 	if (adapter->ecdev) {
       
  2034 		return;
       
  2035 	}
       
  2036 
       
  2037 	if (buffer_info->dma) {
       
  2038 		if (buffer_info->mapped_as_page)
       
  2039 			dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
       
  2040 				       buffer_info->length, DMA_TO_DEVICE);
       
  2041 		else
       
  2042 			dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
       
  2043 					 buffer_info->length,
       
  2044 					 DMA_TO_DEVICE);
       
  2045 		buffer_info->dma = 0;
       
  2046 	}
       
  2047 	if (buffer_info->skb) {
       
  2048 		dev_kfree_skb_any(buffer_info->skb);
       
  2049 		buffer_info->skb = NULL;
       
  2050 	}
       
  2051 	buffer_info->time_stamp = 0;
       
  2052 	/* buffer_info must be completely set up in the transmit path */
       
  2053 }
       
  2054 
       
  2055 /**
       
  2056  * e1000_clean_tx_ring - Free Tx Buffers
       
  2057  * @adapter: board private structure
       
  2058  * @tx_ring: ring to be cleaned
       
  2059  **/
       
  2060 
       
  2061 static void e1000_clean_tx_ring(struct e1000_adapter *adapter,
       
  2062 				struct e1000_tx_ring *tx_ring)
       
  2063 {
       
  2064 	struct e1000_hw *hw = &adapter->hw;
       
  2065 	struct e1000_buffer *buffer_info;
       
  2066 	unsigned long size;
       
  2067 	unsigned int i;
       
  2068 
       
  2069 	/* Free all the Tx ring sk_buffs */
       
  2070 
       
  2071 	for (i = 0; i < tx_ring->count; i++) {
       
  2072 		buffer_info = &tx_ring->buffer_info[i];
       
  2073 		e1000_unmap_and_free_tx_resource(adapter, buffer_info);
       
  2074 	}
       
  2075 
       
  2076 	netdev_reset_queue(adapter->netdev);
       
  2077 	size = sizeof(struct e1000_buffer) * tx_ring->count;
       
  2078 	memset(tx_ring->buffer_info, 0, size);
       
  2079 
       
  2080 	/* Zero out the descriptor ring */
       
  2081 
       
  2082 	memset(tx_ring->desc, 0, tx_ring->size);
       
  2083 
       
  2084 	tx_ring->next_to_use = 0;
       
  2085 	tx_ring->next_to_clean = 0;
       
  2086 	tx_ring->last_tx_tso = false;
       
  2087 
       
  2088 	writel(0, hw->hw_addr + tx_ring->tdh);
       
  2089 	writel(0, hw->hw_addr + tx_ring->tdt);
       
  2090 }
       
  2091 
       
  2092 /**
       
  2093  * e1000_clean_all_tx_rings - Free Tx Buffers for all queues
       
  2094  * @adapter: board private structure
       
  2095  **/
       
  2096 
       
  2097 static void e1000_clean_all_tx_rings(struct e1000_adapter *adapter)
       
  2098 {
       
  2099 	int i;
       
  2100 
       
  2101 	for (i = 0; i < adapter->num_tx_queues; i++)
       
  2102 		e1000_clean_tx_ring(adapter, &adapter->tx_ring[i]);
       
  2103 }
       
  2104 
       
  2105 /**
       
  2106  * e1000_free_rx_resources - Free Rx Resources
       
  2107  * @adapter: board private structure
       
  2108  * @rx_ring: ring to clean the resources from
       
  2109  *
       
  2110  * Free all receive software resources
       
  2111  **/
       
  2112 
       
  2113 static void e1000_free_rx_resources(struct e1000_adapter *adapter,
       
  2114 				    struct e1000_rx_ring *rx_ring)
       
  2115 {
       
  2116 	struct pci_dev *pdev = adapter->pdev;
       
  2117 
       
  2118 	e1000_clean_rx_ring(adapter, rx_ring);
       
  2119 
       
  2120 	vfree(rx_ring->buffer_info);
       
  2121 	rx_ring->buffer_info = NULL;
       
  2122 
       
  2123 	dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
       
  2124 			  rx_ring->dma);
       
  2125 
       
  2126 	rx_ring->desc = NULL;
       
  2127 }
       
  2128 
       
  2129 /**
       
  2130  * e1000_free_all_rx_resources - Free Rx Resources for All Queues
       
  2131  * @adapter: board private structure
       
  2132  *
       
  2133  * Free all receive software resources
       
  2134  **/
       
  2135 
       
  2136 void e1000_free_all_rx_resources(struct e1000_adapter *adapter)
       
  2137 {
       
  2138 	int i;
       
  2139 
       
  2140 	for (i = 0; i < adapter->num_rx_queues; i++)
       
  2141 		e1000_free_rx_resources(adapter, &adapter->rx_ring[i]);
       
  2142 }
       
  2143 
       
  2144 /**
       
  2145  * e1000_clean_rx_ring - Free Rx Buffers per Queue
       
  2146  * @adapter: board private structure
       
  2147  * @rx_ring: ring to free buffers from
       
  2148  **/
       
  2149 
       
  2150 static void e1000_clean_rx_ring(struct e1000_adapter *adapter,
       
  2151 				struct e1000_rx_ring *rx_ring)
       
  2152 {
       
  2153 	struct e1000_hw *hw = &adapter->hw;
       
  2154 	struct e1000_buffer *buffer_info;
       
  2155 	struct pci_dev *pdev = adapter->pdev;
       
  2156 	unsigned long size;
       
  2157 	unsigned int i;
       
  2158 
       
  2159 	/* Free all the Rx ring sk_buffs */
       
  2160 	for (i = 0; i < rx_ring->count; i++) {
       
  2161 		buffer_info = &rx_ring->buffer_info[i];
       
  2162 		if (buffer_info->dma &&
       
  2163 		    adapter->clean_rx == e1000_clean_rx_irq) {
       
  2164 			dma_unmap_single(&pdev->dev, buffer_info->dma,
       
  2165 			                 buffer_info->length,
       
  2166 					 DMA_FROM_DEVICE);
       
  2167 		} else if (buffer_info->dma &&
       
  2168 		           adapter->clean_rx == e1000_clean_jumbo_rx_irq) {
       
  2169 			dma_unmap_page(&pdev->dev, buffer_info->dma,
       
  2170 				       buffer_info->length,
       
  2171 				       DMA_FROM_DEVICE);
       
  2172 		}
       
  2173 
       
  2174 		buffer_info->dma = 0;
       
  2175 		if (buffer_info->page) {
       
  2176 			put_page(buffer_info->page);
       
  2177 			buffer_info->page = NULL;
       
  2178 		}
       
  2179 		if (buffer_info->skb) {
       
  2180 			dev_kfree_skb(buffer_info->skb);
       
  2181 			buffer_info->skb = NULL;
       
  2182 		}
       
  2183 	}
       
  2184 
       
  2185 	/* there also may be some cached data from a chained receive */
       
  2186 	if (rx_ring->rx_skb_top) {
       
  2187 		dev_kfree_skb(rx_ring->rx_skb_top);
       
  2188 		rx_ring->rx_skb_top = NULL;
       
  2189 	}
       
  2190 
       
  2191 	size = sizeof(struct e1000_buffer) * rx_ring->count;
       
  2192 	memset(rx_ring->buffer_info, 0, size);
       
  2193 
       
  2194 	/* Zero out the descriptor ring */
       
  2195 	memset(rx_ring->desc, 0, rx_ring->size);
       
  2196 
       
  2197 	rx_ring->next_to_clean = 0;
       
  2198 	rx_ring->next_to_use = 0;
       
  2199 
       
  2200 	writel(0, hw->hw_addr + rx_ring->rdh);
       
  2201 	writel(0, hw->hw_addr + rx_ring->rdt);
       
  2202 }
       
  2203 
       
  2204 /**
       
  2205  * e1000_clean_all_rx_rings - Free Rx Buffers for all queues
       
  2206  * @adapter: board private structure
       
  2207  **/
       
  2208 
       
  2209 static void e1000_clean_all_rx_rings(struct e1000_adapter *adapter)
       
  2210 {
       
  2211 	int i;
       
  2212 
       
  2213 	for (i = 0; i < adapter->num_rx_queues; i++)
       
  2214 		e1000_clean_rx_ring(adapter, &adapter->rx_ring[i]);
       
  2215 }
       
  2216 
       
  2217 /* The 82542 2.0 (revision 2) needs to have the receive unit in reset
       
  2218  * and memory write and invalidate disabled for certain operations
       
  2219  */
       
  2220 static void e1000_enter_82542_rst(struct e1000_adapter *adapter)
       
  2221 {
       
  2222 	struct e1000_hw *hw = &adapter->hw;
       
  2223 	struct net_device *netdev = adapter->netdev;
       
  2224 	u32 rctl;
       
  2225 
       
  2226 	e1000_pci_clear_mwi(hw);
       
  2227 
       
  2228 	rctl = er32(RCTL);
       
  2229 	rctl |= E1000_RCTL_RST;
       
  2230 	ew32(RCTL, rctl);
       
  2231 	E1000_WRITE_FLUSH();
       
  2232 	mdelay(5);
       
  2233 
       
  2234 	if (!adapter->ecdev && netif_running(netdev))
       
  2235 		e1000_clean_all_rx_rings(adapter);
       
  2236 }
       
  2237 
       
  2238 static void e1000_leave_82542_rst(struct e1000_adapter *adapter)
       
  2239 {
       
  2240 	struct e1000_hw *hw = &adapter->hw;
       
  2241 	struct net_device *netdev = adapter->netdev;
       
  2242 	u32 rctl;
       
  2243 
       
  2244 	rctl = er32(RCTL);
       
  2245 	rctl &= ~E1000_RCTL_RST;
       
  2246 	ew32(RCTL, rctl);
       
  2247 	E1000_WRITE_FLUSH();
       
  2248 	mdelay(5);
       
  2249 
       
  2250 	if (hw->pci_cmd_word & PCI_COMMAND_INVALIDATE)
       
  2251 		e1000_pci_set_mwi(hw);
       
  2252 
       
  2253 	if (!adapter->netdev && netif_running(netdev)) {
       
  2254 		/* No need to loop, because 82542 supports only 1 queue */
       
  2255 		struct e1000_rx_ring *ring = &adapter->rx_ring[0];
       
  2256 		e1000_configure_rx(adapter);
       
  2257 		if (adapter->ecdev) {
       
  2258 			/* fill rx ring completely! */
       
  2259 			adapter->alloc_rx_buf(adapter, ring, ring->count);
       
  2260 		} else {
       
  2261 			/* this one leaves the last ring element unallocated! */
       
  2262 			adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring));
       
  2263 		}
       
  2264 
       
  2265 	}
       
  2266 }
       
  2267 
       
  2268 /**
       
  2269  * e1000_set_mac - Change the Ethernet Address of the NIC
       
  2270  * @netdev: network interface device structure
       
  2271  * @p: pointer to an address structure
       
  2272  *
       
  2273  * Returns 0 on success, negative on failure
       
  2274  **/
       
  2275 
       
  2276 static int e1000_set_mac(struct net_device *netdev, void *p)
       
  2277 {
       
  2278 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  2279 	struct e1000_hw *hw = &adapter->hw;
       
  2280 	struct sockaddr *addr = p;
       
  2281 
       
  2282 	if (!is_valid_ether_addr(addr->sa_data))
       
  2283 		return -EADDRNOTAVAIL;
       
  2284 
       
  2285 	/* 82542 2.0 needs to be in reset to write receive address registers */
       
  2286 
       
  2287 	if (hw->mac_type == e1000_82542_rev2_0)
       
  2288 		e1000_enter_82542_rst(adapter);
       
  2289 
       
  2290 	memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
       
  2291 	memcpy(hw->mac_addr, addr->sa_data, netdev->addr_len);
       
  2292 
       
  2293 	e1000_rar_set(hw, hw->mac_addr, 0);
       
  2294 
       
  2295 	if (hw->mac_type == e1000_82542_rev2_0)
       
  2296 		e1000_leave_82542_rst(adapter);
       
  2297 
       
  2298 	return 0;
       
  2299 }
       
  2300 
       
  2301 /**
       
  2302  * e1000_set_rx_mode - Secondary Unicast, Multicast and Promiscuous mode set
       
  2303  * @netdev: network interface device structure
       
  2304  *
       
  2305  * The set_rx_mode entry point is called whenever the unicast or multicast
       
  2306  * address lists or the network interface flags are updated. This routine is
       
  2307  * responsible for configuring the hardware for proper unicast, multicast,
       
  2308  * promiscuous mode, and all-multi behavior.
       
  2309  **/
       
  2310 
       
  2311 static void e1000_set_rx_mode(struct net_device *netdev)
       
  2312 {
       
  2313 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  2314 	struct e1000_hw *hw = &adapter->hw;
       
  2315 	struct netdev_hw_addr *ha;
       
  2316 	bool use_uc = false;
       
  2317 	u32 rctl;
       
  2318 	u32 hash_value;
       
  2319 	int i, rar_entries = E1000_RAR_ENTRIES;
       
  2320 	int mta_reg_count = E1000_NUM_MTA_REGISTERS;
       
  2321 	u32 *mcarray = kcalloc(mta_reg_count, sizeof(u32), GFP_ATOMIC);
       
  2322 
       
  2323 	if (!mcarray) {
       
  2324 		e_err(probe, "memory allocation failed\n");
       
  2325 		return;
       
  2326 	}
       
  2327 
       
  2328 	/* Check for Promiscuous and All Multicast modes */
       
  2329 
       
  2330 	rctl = er32(RCTL);
       
  2331 
       
  2332 	if (netdev->flags & IFF_PROMISC) {
       
  2333 		rctl |= (E1000_RCTL_UPE | E1000_RCTL_MPE);
       
  2334 		rctl &= ~E1000_RCTL_VFE;
       
  2335 	} else {
       
  2336 		if (netdev->flags & IFF_ALLMULTI)
       
  2337 			rctl |= E1000_RCTL_MPE;
       
  2338 		else
       
  2339 			rctl &= ~E1000_RCTL_MPE;
       
  2340 		/* Enable VLAN filter if there is a VLAN */
       
  2341 		if (e1000_vlan_used(adapter))
       
  2342 			rctl |= E1000_RCTL_VFE;
       
  2343 	}
       
  2344 
       
  2345 	if (netdev_uc_count(netdev) > rar_entries - 1) {
       
  2346 		rctl |= E1000_RCTL_UPE;
       
  2347 	} else if (!(netdev->flags & IFF_PROMISC)) {
       
  2348 		rctl &= ~E1000_RCTL_UPE;
       
  2349 		use_uc = true;
       
  2350 	}
       
  2351 
       
  2352 	ew32(RCTL, rctl);
       
  2353 
       
  2354 	/* 82542 2.0 needs to be in reset to write receive address registers */
       
  2355 
       
  2356 	if (hw->mac_type == e1000_82542_rev2_0)
       
  2357 		e1000_enter_82542_rst(adapter);
       
  2358 
       
  2359 	/* load the first 14 addresses into the exact filters 1-14. Unicast
       
  2360 	 * addresses take precedence to avoid disabling unicast filtering
       
  2361 	 * when possible.
       
  2362 	 *
       
  2363 	 * RAR 0 is used for the station MAC address
       
  2364 	 * if there are not 14 addresses, go ahead and clear the filters
       
  2365 	 */
       
  2366 	i = 1;
       
  2367 	if (use_uc)
       
  2368 		netdev_for_each_uc_addr(ha, netdev) {
       
  2369 			if (i == rar_entries)
       
  2370 				break;
       
  2371 			e1000_rar_set(hw, ha->addr, i++);
       
  2372 		}
       
  2373 
       
  2374 	netdev_for_each_mc_addr(ha, netdev) {
       
  2375 		if (i == rar_entries) {
       
  2376 			/* load any remaining addresses into the hash table */
       
  2377 			u32 hash_reg, hash_bit, mta;
       
  2378 			hash_value = e1000_hash_mc_addr(hw, ha->addr);
       
  2379 			hash_reg = (hash_value >> 5) & 0x7F;
       
  2380 			hash_bit = hash_value & 0x1F;
       
  2381 			mta = (1 << hash_bit);
       
  2382 			mcarray[hash_reg] |= mta;
       
  2383 		} else {
       
  2384 			e1000_rar_set(hw, ha->addr, i++);
       
  2385 		}
       
  2386 	}
       
  2387 
       
  2388 	for (; i < rar_entries; i++) {
       
  2389 		E1000_WRITE_REG_ARRAY(hw, RA, i << 1, 0);
       
  2390 		E1000_WRITE_FLUSH();
       
  2391 		E1000_WRITE_REG_ARRAY(hw, RA, (i << 1) + 1, 0);
       
  2392 		E1000_WRITE_FLUSH();
       
  2393 	}
       
  2394 
       
  2395 	/* write the hash table completely, write from bottom to avoid
       
  2396 	 * both stupid write combining chipsets, and flushing each write */
       
  2397 	for (i = mta_reg_count - 1; i >= 0 ; i--) {
       
  2398 		/*
       
  2399 		 * If we are on an 82544 has an errata where writing odd
       
  2400 		 * offsets overwrites the previous even offset, but writing
       
  2401 		 * backwards over the range solves the issue by always
       
  2402 		 * writing the odd offset first
       
  2403 		 */
       
  2404 		E1000_WRITE_REG_ARRAY(hw, MTA, i, mcarray[i]);
       
  2405 	}
       
  2406 	E1000_WRITE_FLUSH();
       
  2407 
       
  2408 	if (hw->mac_type == e1000_82542_rev2_0)
       
  2409 		e1000_leave_82542_rst(adapter);
       
  2410 
       
  2411 	kfree(mcarray);
       
  2412 }
       
  2413 
       
  2414 /**
       
  2415  * e1000_update_phy_info_task - get phy info
       
  2416  * @work: work struct contained inside adapter struct
       
  2417  *
       
  2418  * Need to wait a few seconds after link up to get diagnostic information from
       
  2419  * the phy
       
  2420  */
       
  2421 static void e1000_update_phy_info_task(struct work_struct *work)
       
  2422 {
       
  2423 	struct e1000_adapter *adapter = container_of(work,
       
  2424 						     struct e1000_adapter,
       
  2425 						     phy_info_task.work);
       
  2426 	if (test_bit(__E1000_DOWN, &adapter->flags))
       
  2427 		return;
       
  2428 	mutex_lock(&adapter->mutex);
       
  2429 	e1000_phy_get_info(&adapter->hw, &adapter->phy_info);
       
  2430 	mutex_unlock(&adapter->mutex);
       
  2431 }
       
  2432 
       
  2433 /**
       
  2434  * e1000_82547_tx_fifo_stall_task - task to complete work
       
  2435  * @work: work struct contained inside adapter struct
       
  2436  **/
       
  2437 static void e1000_82547_tx_fifo_stall_task(struct work_struct *work)
       
  2438 {
       
  2439 	struct e1000_adapter *adapter = container_of(work,
       
  2440 						     struct e1000_adapter,
       
  2441 						     fifo_stall_task.work);
       
  2442 	struct e1000_hw *hw = &adapter->hw;
       
  2443 	struct net_device *netdev = adapter->netdev;
       
  2444 	u32 tctl;
       
  2445 
       
  2446 	if (test_bit(__E1000_DOWN, &adapter->flags))
       
  2447 		return;
       
  2448 	mutex_lock(&adapter->mutex);
       
  2449 	if (atomic_read(&adapter->tx_fifo_stall)) {
       
  2450 		if ((er32(TDT) == er32(TDH)) &&
       
  2451 		   (er32(TDFT) == er32(TDFH)) &&
       
  2452 		   (er32(TDFTS) == er32(TDFHS))) {
       
  2453 			tctl = er32(TCTL);
       
  2454 			ew32(TCTL, tctl & ~E1000_TCTL_EN);
       
  2455 			ew32(TDFT, adapter->tx_head_addr);
       
  2456 			ew32(TDFH, adapter->tx_head_addr);
       
  2457 			ew32(TDFTS, adapter->tx_head_addr);
       
  2458 			ew32(TDFHS, adapter->tx_head_addr);
       
  2459 			ew32(TCTL, tctl);
       
  2460 			E1000_WRITE_FLUSH();
       
  2461 
       
  2462 			adapter->tx_fifo_head = 0;
       
  2463 			atomic_set(&adapter->tx_fifo_stall, 0);
       
  2464 			netif_wake_queue(netdev);
       
  2465 		} else if (!test_bit(__E1000_DOWN, &adapter->flags)) {
       
  2466 			schedule_delayed_work(&adapter->fifo_stall_task, 1);
       
  2467 		}
       
  2468 	}
       
  2469 	mutex_unlock(&adapter->mutex);
       
  2470 }
       
  2471 
       
  2472 bool e1000_has_link(struct e1000_adapter *adapter)
       
  2473 {
       
  2474 	struct e1000_hw *hw = &adapter->hw;
       
  2475 	bool link_active = false;
       
  2476 
       
  2477 	/* get_link_status is set on LSC (link status) interrupt or rx
       
  2478 	 * sequence error interrupt (except on intel ce4100).
       
  2479 	 * get_link_status will stay false until the
       
  2480 	 * e1000_check_for_link establishes link for copper adapters
       
  2481 	 * ONLY
       
  2482 	 */
       
  2483 	switch (hw->media_type) {
       
  2484 	case e1000_media_type_copper:
       
  2485 		if (hw->mac_type == e1000_ce4100)
       
  2486 			hw->get_link_status = 1;
       
  2487 		if (hw->get_link_status) {
       
  2488 			e1000_check_for_link(hw);
       
  2489 			link_active = !hw->get_link_status;
       
  2490 		} else {
       
  2491 			link_active = true;
       
  2492 		}
       
  2493 		break;
       
  2494 	case e1000_media_type_fiber:
       
  2495 		e1000_check_for_link(hw);
       
  2496 		link_active = !!(er32(STATUS) & E1000_STATUS_LU);
       
  2497 		break;
       
  2498 	case e1000_media_type_internal_serdes:
       
  2499 		e1000_check_for_link(hw);
       
  2500 		link_active = hw->serdes_has_link;
       
  2501 		break;
       
  2502 	default:
       
  2503 		break;
       
  2504 	}
       
  2505 
       
  2506 	return link_active;
       
  2507 }
       
  2508 
       
  2509 /**
       
  2510  * e1000_watchdog - work function
       
  2511  * @work: work struct contained inside adapter struct
       
  2512  **/
       
  2513 static void e1000_watchdog(struct work_struct *work)
       
  2514 {
       
  2515 	struct e1000_adapter *adapter = container_of(work,
       
  2516 						     struct e1000_adapter,
       
  2517 						     watchdog_task.work);
       
  2518 	struct e1000_hw *hw = &adapter->hw;
       
  2519 	struct net_device *netdev = adapter->netdev;
       
  2520 	struct e1000_tx_ring *txdr = adapter->tx_ring;
       
  2521 	u32 link, tctl;
       
  2522 
       
  2523 	if (test_bit(__E1000_DOWN, &adapter->flags))
       
  2524 		return;
       
  2525 
       
  2526 	mutex_lock(&adapter->mutex);
       
  2527 	link = e1000_has_link(adapter);
       
  2528 	if (!adapter->ecdev && (netif_carrier_ok(netdev)) && link)
       
  2529 		goto link_up;
       
  2530 
       
  2531 	if (link) {
       
  2532 		if ((adapter->ecdev && !ecdev_get_link(adapter->ecdev))
       
  2533 				|| (!adapter->ecdev && !netif_carrier_ok(netdev))) {
       
  2534 			u32 ctrl;
       
  2535 			bool txb2b __attribute__ ((unused)) = true;
       
  2536 			/* update snapshot of PHY registers on LSC */
       
  2537 			e1000_get_speed_and_duplex(hw,
       
  2538 			                           &adapter->link_speed,
       
  2539 			                           &adapter->link_duplex);
       
  2540 
       
  2541 			ctrl = er32(CTRL);
       
  2542 			pr_info("%s NIC Link is Up %d Mbps %s, "
       
  2543 				"Flow Control: %s\n",
       
  2544 				netdev->name,
       
  2545 				adapter->link_speed,
       
  2546 				adapter->link_duplex == FULL_DUPLEX ?
       
  2547 				"Full Duplex" : "Half Duplex",
       
  2548 				((ctrl & E1000_CTRL_TFCE) && (ctrl &
       
  2549 				E1000_CTRL_RFCE)) ? "RX/TX" : ((ctrl &
       
  2550 				E1000_CTRL_RFCE) ? "RX" : ((ctrl &
       
  2551 				E1000_CTRL_TFCE) ? "TX" : "None")));
       
  2552 
       
  2553 			/* adjust timeout factor according to speed/duplex */
       
  2554 			adapter->tx_timeout_factor = 1;
       
  2555 			switch (adapter->link_speed) {
       
  2556 			case SPEED_10:
       
  2557 				txb2b = false;
       
  2558 				adapter->tx_timeout_factor = 16;
       
  2559 				break;
       
  2560 			case SPEED_100:
       
  2561 				txb2b = false;
       
  2562 				/* maybe add some timeout factor ? */
       
  2563 				break;
       
  2564 			}
       
  2565 
       
  2566 			/* enable transmits in the hardware */
       
  2567 			tctl = er32(TCTL);
       
  2568 			tctl |= E1000_TCTL_EN;
       
  2569 			ew32(TCTL, tctl);
       
  2570 
       
  2571 			if (adapter->ecdev) {
       
  2572 				ecdev_set_link(adapter->ecdev, 1);
       
  2573 			}
       
  2574 			else {
       
  2575 				netif_carrier_on(netdev);
       
  2576 				if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  2577 					schedule_delayed_work(&adapter->phy_info_task,
       
  2578 							2 * HZ);
       
  2579 			}
       
  2580 			adapter->smartspeed = 0;
       
  2581 		}
       
  2582 	} else {
       
  2583 		if ((adapter->ecdev && ecdev_get_link(adapter->ecdev))
       
  2584 				|| (!adapter->ecdev && netif_carrier_ok(netdev))) {
       
  2585 			adapter->link_speed = 0;
       
  2586 			adapter->link_duplex = 0;
       
  2587 			pr_info("%s NIC Link is Down\n",
       
  2588 				netdev->name);
       
  2589 
       
  2590 			if (adapter->ecdev) {
       
  2591 				ecdev_set_link(adapter->ecdev, 0);
       
  2592 			} else {
       
  2593 				netif_carrier_off(netdev);
       
  2594 
       
  2595 				if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  2596 					schedule_delayed_work(&adapter->phy_info_task,
       
  2597 							2 * HZ);
       
  2598 			}
       
  2599 		}
       
  2600 
       
  2601 		e1000_smartspeed(adapter);
       
  2602 	}
       
  2603 
       
  2604 link_up:
       
  2605 	e1000_update_stats(adapter);
       
  2606 
       
  2607 	hw->tx_packet_delta = adapter->stats.tpt - adapter->tpt_old;
       
  2608 	adapter->tpt_old = adapter->stats.tpt;
       
  2609 	hw->collision_delta = adapter->stats.colc - adapter->colc_old;
       
  2610 	adapter->colc_old = adapter->stats.colc;
       
  2611 
       
  2612 	adapter->gorcl = adapter->stats.gorcl - adapter->gorcl_old;
       
  2613 	adapter->gorcl_old = adapter->stats.gorcl;
       
  2614 	adapter->gotcl = adapter->stats.gotcl - adapter->gotcl_old;
       
  2615 	adapter->gotcl_old = adapter->stats.gotcl;
       
  2616 
       
  2617 	e1000_update_adaptive(hw);
       
  2618 
       
  2619 	if (!adapter->ecdev && !netif_carrier_ok(netdev)) {
       
  2620 		if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) {
       
  2621 			/* We've lost link, so the controller stops DMA,
       
  2622 			 * but we've got queued Tx work that's never going
       
  2623 			 * to get done, so reset controller to flush Tx.
       
  2624 			 * (Do the reset outside of interrupt context). */
       
  2625 			adapter->tx_timeout_count++;
       
  2626 			schedule_work(&adapter->reset_task);
       
  2627 			/* exit immediately since reset is imminent */
       
  2628 			goto unlock;
       
  2629 		}
       
  2630 	}
       
  2631 
       
  2632 	/* Simple mode for Interrupt Throttle Rate (ITR) */
       
  2633 	if (hw->mac_type >= e1000_82540 && adapter->itr_setting == 4) {
       
  2634 		/*
       
  2635 		 * Symmetric Tx/Rx gets a reduced ITR=2000;
       
  2636 		 * Total asymmetrical Tx or Rx gets ITR=8000;
       
  2637 		 * everyone else is between 2000-8000.
       
  2638 		 */
       
  2639 		u32 goc = (adapter->gotcl + adapter->gorcl) / 10000;
       
  2640 		u32 dif = (adapter->gotcl > adapter->gorcl ?
       
  2641 			    adapter->gotcl - adapter->gorcl :
       
  2642 			    adapter->gorcl - adapter->gotcl) / 10000;
       
  2643 		u32 itr = goc > 0 ? (dif * 6000 / goc + 2000) : 8000;
       
  2644 
       
  2645 		ew32(ITR, 1000000000 / (itr * 256));
       
  2646 	}
       
  2647 
       
  2648 	/* Cause software interrupt to ensure rx ring is cleaned */
       
  2649 	ew32(ICS, E1000_ICS_RXDMT0);
       
  2650 
       
  2651 	/* Force detection of hung controller every watchdog period */
       
  2652 	adapter->detect_tx_hung = true;
       
  2653 
       
  2654 	/* Reschedule the task */
       
  2655 	if (!adapter->ecdev && !test_bit(__E1000_DOWN, &adapter->flags))
       
  2656 		schedule_delayed_work(&adapter->watchdog_task, 2 * HZ);
       
  2657 
       
  2658 unlock:
       
  2659 	mutex_unlock(&adapter->mutex);
       
  2660 }
       
  2661 
       
  2662 enum latency_range {
       
  2663 	lowest_latency = 0,
       
  2664 	low_latency = 1,
       
  2665 	bulk_latency = 2,
       
  2666 	latency_invalid = 255
       
  2667 };
       
  2668 
       
  2669 /**
       
  2670  * e1000_update_itr - update the dynamic ITR value based on statistics
       
  2671  * @adapter: pointer to adapter
       
  2672  * @itr_setting: current adapter->itr
       
  2673  * @packets: the number of packets during this measurement interval
       
  2674  * @bytes: the number of bytes during this measurement interval
       
  2675  *
       
  2676  *      Stores a new ITR value based on packets and byte
       
  2677  *      counts during the last interrupt.  The advantage of per interrupt
       
  2678  *      computation is faster updates and more accurate ITR for the current
       
  2679  *      traffic pattern.  Constants in this function were computed
       
  2680  *      based on theoretical maximum wire speed and thresholds were set based
       
  2681  *      on testing data as well as attempting to minimize response time
       
  2682  *      while increasing bulk throughput.
       
  2683  *      this functionality is controlled by the InterruptThrottleRate module
       
  2684  *      parameter (see e1000_param.c)
       
  2685  **/
       
  2686 static unsigned int e1000_update_itr(struct e1000_adapter *adapter,
       
  2687 				     u16 itr_setting, int packets, int bytes)
       
  2688 {
       
  2689 	unsigned int retval = itr_setting;
       
  2690 	struct e1000_hw *hw = &adapter->hw;
       
  2691 
       
  2692 	if (unlikely(hw->mac_type < e1000_82540))
       
  2693 		goto update_itr_done;
       
  2694 
       
  2695 	if (packets == 0)
       
  2696 		goto update_itr_done;
       
  2697 
       
  2698 	switch (itr_setting) {
       
  2699 	case lowest_latency:
       
  2700 		/* jumbo frames get bulk treatment*/
       
  2701 		if (bytes/packets > 8000)
       
  2702 			retval = bulk_latency;
       
  2703 		else if ((packets < 5) && (bytes > 512))
       
  2704 			retval = low_latency;
       
  2705 		break;
       
  2706 	case low_latency:  /* 50 usec aka 20000 ints/s */
       
  2707 		if (bytes > 10000) {
       
  2708 			/* jumbo frames need bulk latency setting */
       
  2709 			if (bytes/packets > 8000)
       
  2710 				retval = bulk_latency;
       
  2711 			else if ((packets < 10) || ((bytes/packets) > 1200))
       
  2712 				retval = bulk_latency;
       
  2713 			else if ((packets > 35))
       
  2714 				retval = lowest_latency;
       
  2715 		} else if (bytes/packets > 2000)
       
  2716 			retval = bulk_latency;
       
  2717 		else if (packets <= 2 && bytes < 512)
       
  2718 			retval = lowest_latency;
       
  2719 		break;
       
  2720 	case bulk_latency: /* 250 usec aka 4000 ints/s */
       
  2721 		if (bytes > 25000) {
       
  2722 			if (packets > 35)
       
  2723 				retval = low_latency;
       
  2724 		} else if (bytes < 6000) {
       
  2725 			retval = low_latency;
       
  2726 		}
       
  2727 		break;
       
  2728 	}
       
  2729 
       
  2730 update_itr_done:
       
  2731 	return retval;
       
  2732 }
       
  2733 
       
  2734 static void e1000_set_itr(struct e1000_adapter *adapter)
       
  2735 {
       
  2736 	struct e1000_hw *hw = &adapter->hw;
       
  2737 	u16 current_itr;
       
  2738 	u32 new_itr = adapter->itr;
       
  2739 
       
  2740 	if (unlikely(hw->mac_type < e1000_82540))
       
  2741 		return;
       
  2742 
       
  2743 	/* for non-gigabit speeds, just fix the interrupt rate at 4000 */
       
  2744 	if (unlikely(adapter->link_speed != SPEED_1000)) {
       
  2745 		current_itr = 0;
       
  2746 		new_itr = 4000;
       
  2747 		goto set_itr_now;
       
  2748 	}
       
  2749 
       
  2750 	adapter->tx_itr = e1000_update_itr(adapter,
       
  2751 	                            adapter->tx_itr,
       
  2752 	                            adapter->total_tx_packets,
       
  2753 	                            adapter->total_tx_bytes);
       
  2754 	/* conservative mode (itr 3) eliminates the lowest_latency setting */
       
  2755 	if (adapter->itr_setting == 3 && adapter->tx_itr == lowest_latency)
       
  2756 		adapter->tx_itr = low_latency;
       
  2757 
       
  2758 	adapter->rx_itr = e1000_update_itr(adapter,
       
  2759 	                            adapter->rx_itr,
       
  2760 	                            adapter->total_rx_packets,
       
  2761 	                            adapter->total_rx_bytes);
       
  2762 	/* conservative mode (itr 3) eliminates the lowest_latency setting */
       
  2763 	if (adapter->itr_setting == 3 && adapter->rx_itr == lowest_latency)
       
  2764 		adapter->rx_itr = low_latency;
       
  2765 
       
  2766 	current_itr = max(adapter->rx_itr, adapter->tx_itr);
       
  2767 
       
  2768 	switch (current_itr) {
       
  2769 	/* counts and packets in update_itr are dependent on these numbers */
       
  2770 	case lowest_latency:
       
  2771 		new_itr = 70000;
       
  2772 		break;
       
  2773 	case low_latency:
       
  2774 		new_itr = 20000; /* aka hwitr = ~200 */
       
  2775 		break;
       
  2776 	case bulk_latency:
       
  2777 		new_itr = 4000;
       
  2778 		break;
       
  2779 	default:
       
  2780 		break;
       
  2781 	}
       
  2782 
       
  2783 set_itr_now:
       
  2784 	if (new_itr != adapter->itr) {
       
  2785 		/* this attempts to bias the interrupt rate towards Bulk
       
  2786 		 * by adding intermediate steps when interrupt rate is
       
  2787 		 * increasing */
       
  2788 		new_itr = new_itr > adapter->itr ?
       
  2789 		             min(adapter->itr + (new_itr >> 2), new_itr) :
       
  2790 		             new_itr;
       
  2791 		adapter->itr = new_itr;
       
  2792 		ew32(ITR, 1000000000 / (new_itr * 256));
       
  2793 	}
       
  2794 }
       
  2795 
       
  2796 #define E1000_TX_FLAGS_CSUM		0x00000001
       
  2797 #define E1000_TX_FLAGS_VLAN		0x00000002
       
  2798 #define E1000_TX_FLAGS_TSO		0x00000004
       
  2799 #define E1000_TX_FLAGS_IPV4		0x00000008
       
  2800 #define E1000_TX_FLAGS_NO_FCS		0x00000010
       
  2801 #define E1000_TX_FLAGS_VLAN_MASK	0xffff0000
       
  2802 #define E1000_TX_FLAGS_VLAN_SHIFT	16
       
  2803 
       
  2804 static int e1000_tso(struct e1000_adapter *adapter,
       
  2805 		     struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
       
  2806 {
       
  2807 	struct e1000_context_desc *context_desc;
       
  2808 	struct e1000_buffer *buffer_info;
       
  2809 	unsigned int i;
       
  2810 	u32 cmd_length = 0;
       
  2811 	u16 ipcse = 0, tucse, mss;
       
  2812 	u8 ipcss, ipcso, tucss, tucso, hdr_len;
       
  2813 	int err;
       
  2814 
       
  2815 	if (skb_is_gso(skb)) {
       
  2816 		if (skb_header_cloned(skb)) {
       
  2817 			err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC);
       
  2818 			if (err)
       
  2819 				return err;
       
  2820 		}
       
  2821 
       
  2822 		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
       
  2823 		mss = skb_shinfo(skb)->gso_size;
       
  2824 		if (skb->protocol == htons(ETH_P_IP)) {
       
  2825 			struct iphdr *iph = ip_hdr(skb);
       
  2826 			iph->tot_len = 0;
       
  2827 			iph->check = 0;
       
  2828 			tcp_hdr(skb)->check = ~csum_tcpudp_magic(iph->saddr,
       
  2829 								 iph->daddr, 0,
       
  2830 								 IPPROTO_TCP,
       
  2831 								 0);
       
  2832 			cmd_length = E1000_TXD_CMD_IP;
       
  2833 			ipcse = skb_transport_offset(skb) - 1;
       
  2834 		} else if (skb->protocol == htons(ETH_P_IPV6)) {
       
  2835 			ipv6_hdr(skb)->payload_len = 0;
       
  2836 			tcp_hdr(skb)->check =
       
  2837 				~csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
       
  2838 						 &ipv6_hdr(skb)->daddr,
       
  2839 						 0, IPPROTO_TCP, 0);
       
  2840 			ipcse = 0;
       
  2841 		}
       
  2842 		ipcss = skb_network_offset(skb);
       
  2843 		ipcso = (void *)&(ip_hdr(skb)->check) - (void *)skb->data;
       
  2844 		tucss = skb_transport_offset(skb);
       
  2845 		tucso = (void *)&(tcp_hdr(skb)->check) - (void *)skb->data;
       
  2846 		tucse = 0;
       
  2847 
       
  2848 		cmd_length |= (E1000_TXD_CMD_DEXT | E1000_TXD_CMD_TSE |
       
  2849 			       E1000_TXD_CMD_TCP | (skb->len - (hdr_len)));
       
  2850 
       
  2851 		i = tx_ring->next_to_use;
       
  2852 		context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
       
  2853 		buffer_info = &tx_ring->buffer_info[i];
       
  2854 
       
  2855 		context_desc->lower_setup.ip_fields.ipcss  = ipcss;
       
  2856 		context_desc->lower_setup.ip_fields.ipcso  = ipcso;
       
  2857 		context_desc->lower_setup.ip_fields.ipcse  = cpu_to_le16(ipcse);
       
  2858 		context_desc->upper_setup.tcp_fields.tucss = tucss;
       
  2859 		context_desc->upper_setup.tcp_fields.tucso = tucso;
       
  2860 		context_desc->upper_setup.tcp_fields.tucse = cpu_to_le16(tucse);
       
  2861 		context_desc->tcp_seg_setup.fields.mss     = cpu_to_le16(mss);
       
  2862 		context_desc->tcp_seg_setup.fields.hdr_len = hdr_len;
       
  2863 		context_desc->cmd_and_length = cpu_to_le32(cmd_length);
       
  2864 
       
  2865 		buffer_info->time_stamp = jiffies;
       
  2866 		buffer_info->next_to_watch = i;
       
  2867 
       
  2868 		if (++i == tx_ring->count) i = 0;
       
  2869 		tx_ring->next_to_use = i;
       
  2870 
       
  2871 		return true;
       
  2872 	}
       
  2873 	return false;
       
  2874 }
       
  2875 
       
  2876 static bool e1000_tx_csum(struct e1000_adapter *adapter,
       
  2877 			  struct e1000_tx_ring *tx_ring, struct sk_buff *skb)
       
  2878 {
       
  2879 	struct e1000_context_desc *context_desc;
       
  2880 	struct e1000_buffer *buffer_info;
       
  2881 	unsigned int i;
       
  2882 	u8 css;
       
  2883 	u32 cmd_len = E1000_TXD_CMD_DEXT;
       
  2884 
       
  2885 	if (skb->ip_summed != CHECKSUM_PARTIAL)
       
  2886 		return false;
       
  2887 
       
  2888 	switch (skb->protocol) {
       
  2889 	case cpu_to_be16(ETH_P_IP):
       
  2890 		if (ip_hdr(skb)->protocol == IPPROTO_TCP)
       
  2891 			cmd_len |= E1000_TXD_CMD_TCP;
       
  2892 		break;
       
  2893 	case cpu_to_be16(ETH_P_IPV6):
       
  2894 		/* XXX not handling all IPV6 headers */
       
  2895 		if (ipv6_hdr(skb)->nexthdr == IPPROTO_TCP)
       
  2896 			cmd_len |= E1000_TXD_CMD_TCP;
       
  2897 		break;
       
  2898 	default:
       
  2899 		if (unlikely(net_ratelimit()))
       
  2900 			e_warn(drv, "checksum_partial proto=%x!\n",
       
  2901 			       skb->protocol);
       
  2902 		break;
       
  2903 	}
       
  2904 
       
  2905 	css = skb_checksum_start_offset(skb);
       
  2906 
       
  2907 	i = tx_ring->next_to_use;
       
  2908 	buffer_info = &tx_ring->buffer_info[i];
       
  2909 	context_desc = E1000_CONTEXT_DESC(*tx_ring, i);
       
  2910 
       
  2911 	context_desc->lower_setup.ip_config = 0;
       
  2912 	context_desc->upper_setup.tcp_fields.tucss = css;
       
  2913 	context_desc->upper_setup.tcp_fields.tucso =
       
  2914 		css + skb->csum_offset;
       
  2915 	context_desc->upper_setup.tcp_fields.tucse = 0;
       
  2916 	context_desc->tcp_seg_setup.data = 0;
       
  2917 	context_desc->cmd_and_length = cpu_to_le32(cmd_len);
       
  2918 
       
  2919 	buffer_info->time_stamp = jiffies;
       
  2920 	buffer_info->next_to_watch = i;
       
  2921 
       
  2922 	if (unlikely(++i == tx_ring->count)) i = 0;
       
  2923 	tx_ring->next_to_use = i;
       
  2924 
       
  2925 	return true;
       
  2926 }
       
  2927 
       
  2928 #define E1000_MAX_TXD_PWR	12
       
  2929 #define E1000_MAX_DATA_PER_TXD	(1<<E1000_MAX_TXD_PWR)
       
  2930 
       
  2931 static int e1000_tx_map(struct e1000_adapter *adapter,
       
  2932 			struct e1000_tx_ring *tx_ring,
       
  2933 			struct sk_buff *skb, unsigned int first,
       
  2934 			unsigned int max_per_txd, unsigned int nr_frags,
       
  2935 			unsigned int mss)
       
  2936 {
       
  2937 	struct e1000_hw *hw = &adapter->hw;
       
  2938 	struct pci_dev *pdev = adapter->pdev;
       
  2939 	struct e1000_buffer *buffer_info;
       
  2940 	unsigned int len = skb_headlen(skb);
       
  2941 	unsigned int offset = 0, size, count = 0, i;
       
  2942 	unsigned int f, bytecount, segs;
       
  2943 
       
  2944 	i = tx_ring->next_to_use;
       
  2945 
       
  2946 	while (len) {
       
  2947 		buffer_info = &tx_ring->buffer_info[i];
       
  2948 		size = min(len, max_per_txd);
       
  2949 		/* Workaround for Controller erratum --
       
  2950 		 * descriptor for non-tso packet in a linear SKB that follows a
       
  2951 		 * tso gets written back prematurely before the data is fully
       
  2952 		 * DMA'd to the controller */
       
  2953 		if (!skb->data_len && tx_ring->last_tx_tso &&
       
  2954 		    !skb_is_gso(skb)) {
       
  2955 			tx_ring->last_tx_tso = false;
       
  2956 			size -= 4;
       
  2957 		}
       
  2958 
       
  2959 		/* Workaround for premature desc write-backs
       
  2960 		 * in TSO mode.  Append 4-byte sentinel desc */
       
  2961 		if (unlikely(mss && !nr_frags && size == len && size > 8))
       
  2962 			size -= 4;
       
  2963 		/* work-around for errata 10 and it applies
       
  2964 		 * to all controllers in PCI-X mode
       
  2965 		 * The fix is to make sure that the first descriptor of a
       
  2966 		 * packet is smaller than 2048 - 16 - 16 (or 2016) bytes
       
  2967 		 */
       
  2968 		if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
       
  2969 		                (size > 2015) && count == 0))
       
  2970 		        size = 2015;
       
  2971 
       
  2972 		/* Workaround for potential 82544 hang in PCI-X.  Avoid
       
  2973 		 * terminating buffers within evenly-aligned dwords. */
       
  2974 		if (unlikely(adapter->pcix_82544 &&
       
  2975 		   !((unsigned long)(skb->data + offset + size - 1) & 4) &&
       
  2976 		   size > 4))
       
  2977 			size -= 4;
       
  2978 
       
  2979 		buffer_info->length = size;
       
  2980 		/* set time_stamp *before* dma to help avoid a possible race */
       
  2981 		buffer_info->time_stamp = jiffies;
       
  2982 		buffer_info->mapped_as_page = false;
       
  2983 		buffer_info->dma = dma_map_single(&pdev->dev,
       
  2984 						  skb->data + offset,
       
  2985 						  size,	DMA_TO_DEVICE);
       
  2986 		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
       
  2987 			goto dma_error;
       
  2988 		buffer_info->next_to_watch = i;
       
  2989 
       
  2990 		len -= size;
       
  2991 		offset += size;
       
  2992 		count++;
       
  2993 		if (len) {
       
  2994 			i++;
       
  2995 			if (unlikely(i == tx_ring->count))
       
  2996 				i = 0;
       
  2997 		}
       
  2998 	}
       
  2999 
       
  3000 	for (f = 0; f < nr_frags; f++) {
       
  3001 		const struct skb_frag_struct *frag;
       
  3002 
       
  3003 		frag = &skb_shinfo(skb)->frags[f];
       
  3004 		len = skb_frag_size(frag);
       
  3005 		offset = 0;
       
  3006 
       
  3007 		while (len) {
       
  3008 			unsigned long bufend;
       
  3009 			i++;
       
  3010 			if (unlikely(i == tx_ring->count))
       
  3011 				i = 0;
       
  3012 
       
  3013 			buffer_info = &tx_ring->buffer_info[i];
       
  3014 			size = min(len, max_per_txd);
       
  3015 			/* Workaround for premature desc write-backs
       
  3016 			 * in TSO mode.  Append 4-byte sentinel desc */
       
  3017 			if (unlikely(mss && f == (nr_frags-1) && size == len && size > 8))
       
  3018 				size -= 4;
       
  3019 			/* Workaround for potential 82544 hang in PCI-X.
       
  3020 			 * Avoid terminating buffers within evenly-aligned
       
  3021 			 * dwords. */
       
  3022 			bufend = (unsigned long)
       
  3023 				page_to_phys(skb_frag_page(frag));
       
  3024 			bufend += offset + size - 1;
       
  3025 			if (unlikely(adapter->pcix_82544 &&
       
  3026 				     !(bufend & 4) &&
       
  3027 				     size > 4))
       
  3028 				size -= 4;
       
  3029 
       
  3030 			buffer_info->length = size;
       
  3031 			buffer_info->time_stamp = jiffies;
       
  3032 			buffer_info->mapped_as_page = true;
       
  3033 			buffer_info->dma = skb_frag_dma_map(&pdev->dev, frag,
       
  3034 						offset, size, DMA_TO_DEVICE);
       
  3035 			if (dma_mapping_error(&pdev->dev, buffer_info->dma))
       
  3036 				goto dma_error;
       
  3037 			buffer_info->next_to_watch = i;
       
  3038 
       
  3039 			len -= size;
       
  3040 			offset += size;
       
  3041 			count++;
       
  3042 		}
       
  3043 	}
       
  3044 
       
  3045 	segs = skb_shinfo(skb)->gso_segs ?: 1;
       
  3046 	/* multiply data chunks by size of headers */
       
  3047 	bytecount = ((segs - 1) * skb_headlen(skb)) + skb->len;
       
  3048 
       
  3049 	tx_ring->buffer_info[i].skb = skb;
       
  3050 	tx_ring->buffer_info[i].segs = segs;
       
  3051 	tx_ring->buffer_info[i].bytecount = bytecount;
       
  3052 	tx_ring->buffer_info[first].next_to_watch = i;
       
  3053 
       
  3054 	return count;
       
  3055 
       
  3056 dma_error:
       
  3057 	dev_err(&pdev->dev, "TX DMA map failed\n");
       
  3058 	buffer_info->dma = 0;
       
  3059 	if (count)
       
  3060 		count--;
       
  3061 
       
  3062 	while (count--) {
       
  3063 		if (i==0)
       
  3064 			i += tx_ring->count;
       
  3065 		i--;
       
  3066 		buffer_info = &tx_ring->buffer_info[i];
       
  3067 		e1000_unmap_and_free_tx_resource(adapter, buffer_info);
       
  3068 	}
       
  3069 
       
  3070 	return 0;
       
  3071 }
       
  3072 
       
  3073 static void e1000_tx_queue(struct e1000_adapter *adapter,
       
  3074 			   struct e1000_tx_ring *tx_ring, int tx_flags,
       
  3075 			   int count)
       
  3076 {
       
  3077 	struct e1000_hw *hw = &adapter->hw;
       
  3078 	struct e1000_tx_desc *tx_desc = NULL;
       
  3079 	struct e1000_buffer *buffer_info;
       
  3080 	u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS;
       
  3081 	unsigned int i;
       
  3082 
       
  3083 	if (likely(tx_flags & E1000_TX_FLAGS_TSO)) {
       
  3084 		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D |
       
  3085 		             E1000_TXD_CMD_TSE;
       
  3086 		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
       
  3087 
       
  3088 		if (likely(tx_flags & E1000_TX_FLAGS_IPV4))
       
  3089 			txd_upper |= E1000_TXD_POPTS_IXSM << 8;
       
  3090 	}
       
  3091 
       
  3092 	if (likely(tx_flags & E1000_TX_FLAGS_CSUM)) {
       
  3093 		txd_lower |= E1000_TXD_CMD_DEXT | E1000_TXD_DTYP_D;
       
  3094 		txd_upper |= E1000_TXD_POPTS_TXSM << 8;
       
  3095 	}
       
  3096 
       
  3097 	if (unlikely(tx_flags & E1000_TX_FLAGS_VLAN)) {
       
  3098 		txd_lower |= E1000_TXD_CMD_VLE;
       
  3099 		txd_upper |= (tx_flags & E1000_TX_FLAGS_VLAN_MASK);
       
  3100 	}
       
  3101 
       
  3102 	if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
       
  3103 		txd_lower &= ~(E1000_TXD_CMD_IFCS);
       
  3104 
       
  3105 	i = tx_ring->next_to_use;
       
  3106 
       
  3107 	while (count--) {
       
  3108 		buffer_info = &tx_ring->buffer_info[i];
       
  3109 		tx_desc = E1000_TX_DESC(*tx_ring, i);
       
  3110 		tx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
       
  3111 		tx_desc->lower.data =
       
  3112 			cpu_to_le32(txd_lower | buffer_info->length);
       
  3113 		tx_desc->upper.data = cpu_to_le32(txd_upper);
       
  3114 		if (unlikely(++i == tx_ring->count)) i = 0;
       
  3115 	}
       
  3116 
       
  3117 	tx_desc->lower.data |= cpu_to_le32(adapter->txd_cmd);
       
  3118 
       
  3119 	/* txd_cmd re-enables FCS, so we'll re-disable it here as desired. */
       
  3120 	if (unlikely(tx_flags & E1000_TX_FLAGS_NO_FCS))
       
  3121 		tx_desc->lower.data &= ~(cpu_to_le32(E1000_TXD_CMD_IFCS));
       
  3122 
       
  3123 	/* Force memory writes to complete before letting h/w
       
  3124 	 * know there are new descriptors to fetch.  (Only
       
  3125 	 * applicable for weak-ordered memory model archs,
       
  3126 	 * such as IA-64). */
       
  3127 	wmb();
       
  3128 
       
  3129 	tx_ring->next_to_use = i;
       
  3130 	writel(i, hw->hw_addr + tx_ring->tdt);
       
  3131 	/* we need this if more than one processor can write to our tail
       
  3132 	 * at a time, it syncronizes IO on IA64/Altix systems */
       
  3133 	mmiowb();
       
  3134 }
       
  3135 
       
  3136 /* 82547 workaround to avoid controller hang in half-duplex environment.
       
  3137  * The workaround is to avoid queuing a large packet that would span
       
  3138  * the internal Tx FIFO ring boundary by notifying the stack to resend
       
  3139  * the packet at a later time.  This gives the Tx FIFO an opportunity to
       
  3140  * flush all packets.  When that occurs, we reset the Tx FIFO pointers
       
  3141  * to the beginning of the Tx FIFO.
       
  3142  */
       
  3143 
       
  3144 #define E1000_FIFO_HDR			0x10
       
  3145 #define E1000_82547_PAD_LEN		0x3E0
       
  3146 
       
  3147 static int e1000_82547_fifo_workaround(struct e1000_adapter *adapter,
       
  3148 				       struct sk_buff *skb)
       
  3149 {
       
  3150 	u32 fifo_space = adapter->tx_fifo_size - adapter->tx_fifo_head;
       
  3151 	u32 skb_fifo_len = skb->len + E1000_FIFO_HDR;
       
  3152 
       
  3153 	skb_fifo_len = ALIGN(skb_fifo_len, E1000_FIFO_HDR);
       
  3154 
       
  3155 	if (adapter->link_duplex != HALF_DUPLEX)
       
  3156 		goto no_fifo_stall_required;
       
  3157 
       
  3158 	if (atomic_read(&adapter->tx_fifo_stall))
       
  3159 		return 1;
       
  3160 
       
  3161 	if (skb_fifo_len >= (E1000_82547_PAD_LEN + fifo_space)) {
       
  3162 		atomic_set(&adapter->tx_fifo_stall, 1);
       
  3163 		return 1;
       
  3164 	}
       
  3165 
       
  3166 no_fifo_stall_required:
       
  3167 	adapter->tx_fifo_head += skb_fifo_len;
       
  3168 	if (adapter->tx_fifo_head >= adapter->tx_fifo_size)
       
  3169 		adapter->tx_fifo_head -= adapter->tx_fifo_size;
       
  3170 	return 0;
       
  3171 }
       
  3172 
       
  3173 static int __e1000_maybe_stop_tx(struct net_device *netdev, int size)
       
  3174 {
       
  3175 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  3176 	struct e1000_tx_ring *tx_ring = adapter->tx_ring;
       
  3177 
       
  3178 	if (adapter->ecdev) {
       
  3179 		return -EBUSY;
       
  3180 	}
       
  3181 
       
  3182 	netif_stop_queue(netdev);
       
  3183 	/* Herbert's original patch had:
       
  3184 	 *  smp_mb__after_netif_stop_queue();
       
  3185 	 * but since that doesn't exist yet, just open code it. */
       
  3186 	smp_mb();
       
  3187 
       
  3188 	/* We need to check again in a case another CPU has just
       
  3189 	 * made room available. */
       
  3190 	if (likely(E1000_DESC_UNUSED(tx_ring) < size))
       
  3191 		return -EBUSY;
       
  3192 
       
  3193 	/* A reprieve! */
       
  3194 	netif_start_queue(netdev);
       
  3195 	++adapter->restart_queue;
       
  3196 	return 0;
       
  3197 }
       
  3198 
       
  3199 static int e1000_maybe_stop_tx(struct net_device *netdev,
       
  3200                                struct e1000_tx_ring *tx_ring, int size)
       
  3201 {
       
  3202 	if (likely(E1000_DESC_UNUSED(tx_ring) >= size))
       
  3203 		return 0;
       
  3204 	return __e1000_maybe_stop_tx(netdev, size);
       
  3205 }
       
  3206 
       
  3207 #define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1 )
       
  3208 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
       
  3209 				    struct net_device *netdev)
       
  3210 {
       
  3211 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  3212 	struct e1000_hw *hw = &adapter->hw;
       
  3213 	struct e1000_tx_ring *tx_ring;
       
  3214 	unsigned int first, max_per_txd = E1000_MAX_DATA_PER_TXD;
       
  3215 	unsigned int max_txd_pwr = E1000_MAX_TXD_PWR;
       
  3216 	unsigned int tx_flags = 0;
       
  3217 	unsigned int len = skb_headlen(skb);
       
  3218 	unsigned int nr_frags;
       
  3219 	unsigned int mss;
       
  3220 	int count = 0;
       
  3221 	int tso;
       
  3222 	unsigned int f;
       
  3223 
       
  3224 	/* This goes back to the question of how to logically map a tx queue
       
  3225 	 * to a flow.  Right now, performance is impacted slightly negatively
       
  3226 	 * if using multiple tx queues.  If the stack breaks away from a
       
  3227 	 * single qdisc implementation, we can look at this again. */
       
  3228 	tx_ring = adapter->tx_ring;
       
  3229 
       
  3230 	if (unlikely(skb->len <= 0)) {
       
  3231 		if (!adapter->ecdev) {
       
  3232 			dev_kfree_skb_any(skb);
       
  3233 		}
       
  3234 		return NETDEV_TX_OK;
       
  3235 	}
       
  3236 
       
  3237 	/* On PCI/PCI-X HW, if packet size is less than ETH_ZLEN,
       
  3238 	 * packets may get corrupted during padding by HW.
       
  3239 	 * To WA this issue, pad all small packets manually.
       
  3240 	 */
       
  3241 	if (skb->len < ETH_ZLEN) {
       
  3242 		if (skb_pad(skb, ETH_ZLEN - skb->len))
       
  3243 			return NETDEV_TX_OK;
       
  3244 		skb->len = ETH_ZLEN;
       
  3245 		skb_set_tail_pointer(skb, ETH_ZLEN);
       
  3246 	}
       
  3247 
       
  3248 	mss = skb_shinfo(skb)->gso_size;
       
  3249 	/* The controller does a simple calculation to
       
  3250 	 * make sure there is enough room in the FIFO before
       
  3251 	 * initiating the DMA for each buffer.  The calc is:
       
  3252 	 * 4 = ceil(buffer len/mss).  To make sure we don't
       
  3253 	 * overrun the FIFO, adjust the max buffer len if mss
       
  3254 	 * drops. */
       
  3255 	if (mss) {
       
  3256 		u8 hdr_len;
       
  3257 		max_per_txd = min(mss << 2, max_per_txd);
       
  3258 		max_txd_pwr = fls(max_per_txd) - 1;
       
  3259 
       
  3260 		hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
       
  3261 		if (skb->data_len && hdr_len == len) {
       
  3262 			switch (hw->mac_type) {
       
  3263 				unsigned int pull_size;
       
  3264 			case e1000_82544:
       
  3265 				/* Make sure we have room to chop off 4 bytes,
       
  3266 				 * and that the end alignment will work out to
       
  3267 				 * this hardware's requirements
       
  3268 				 * NOTE: this is a TSO only workaround
       
  3269 				 * if end byte alignment not correct move us
       
  3270 				 * into the next dword */
       
  3271 				if ((unsigned long)(skb_tail_pointer(skb) - 1) & 4)
       
  3272 					break;
       
  3273 				/* fall through */
       
  3274 				pull_size = min((unsigned int)4, skb->data_len);
       
  3275 				if (!__pskb_pull_tail(skb, pull_size)) {
       
  3276 					e_err(drv, "__pskb_pull_tail "
       
  3277 					      "failed.\n");
       
  3278 					if (!adapter->ecdev) {
       
  3279 						dev_kfree_skb_any(skb);
       
  3280 					}
       
  3281 					return NETDEV_TX_OK;
       
  3282 				}
       
  3283 				len = skb_headlen(skb);
       
  3284 				break;
       
  3285 			default:
       
  3286 				/* do nothing */
       
  3287 				break;
       
  3288 			}
       
  3289 		}
       
  3290 	}
       
  3291 
       
  3292 	/* reserve a descriptor for the offload context */
       
  3293 	if ((mss) || (skb->ip_summed == CHECKSUM_PARTIAL))
       
  3294 		count++;
       
  3295 	count++;
       
  3296 
       
  3297 	/* Controller Erratum workaround */
       
  3298 	if (!skb->data_len && tx_ring->last_tx_tso && !skb_is_gso(skb))
       
  3299 		count++;
       
  3300 
       
  3301 	count += TXD_USE_COUNT(len, max_txd_pwr);
       
  3302 
       
  3303 	if (adapter->pcix_82544)
       
  3304 		count++;
       
  3305 
       
  3306 	/* work-around for errata 10 and it applies to all controllers
       
  3307 	 * in PCI-X mode, so add one more descriptor to the count
       
  3308 	 */
       
  3309 	if (unlikely((hw->bus_type == e1000_bus_type_pcix) &&
       
  3310 			(len > 2015)))
       
  3311 		count++;
       
  3312 
       
  3313 	nr_frags = skb_shinfo(skb)->nr_frags;
       
  3314 	for (f = 0; f < nr_frags; f++)
       
  3315 		count += TXD_USE_COUNT(skb_frag_size(&skb_shinfo(skb)->frags[f]),
       
  3316 				       max_txd_pwr);
       
  3317 	if (adapter->pcix_82544)
       
  3318 		count += nr_frags;
       
  3319 
       
  3320 	/* need: count + 2 desc gap to keep tail from touching
       
  3321 	 * head, otherwise try next time */
       
  3322 	if (unlikely(e1000_maybe_stop_tx(netdev, tx_ring, count + 2)))
       
  3323 		return NETDEV_TX_BUSY;
       
  3324 
       
  3325 	if (unlikely((hw->mac_type == e1000_82547) &&
       
  3326 		     (e1000_82547_fifo_workaround(adapter, skb)))) {
       
  3327 		if (!adapter->ecdev) {
       
  3328 			netif_stop_queue(netdev);
       
  3329 			if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  3330 				schedule_delayed_work(&adapter->fifo_stall_task, 1);
       
  3331 		}
       
  3332 		return NETDEV_TX_BUSY;
       
  3333 	}
       
  3334 
       
  3335 	if (vlan_tx_tag_present(skb)) {
       
  3336 		tx_flags |= E1000_TX_FLAGS_VLAN;
       
  3337 		tx_flags |= (vlan_tx_tag_get(skb) << E1000_TX_FLAGS_VLAN_SHIFT);
       
  3338 	}
       
  3339 
       
  3340 	first = tx_ring->next_to_use;
       
  3341 
       
  3342 	tso = e1000_tso(adapter, tx_ring, skb);
       
  3343 	if (tso < 0) {
       
  3344 		if (!adapter->ecdev) {
       
  3345 			dev_kfree_skb_any(skb);
       
  3346 		}
       
  3347 		return NETDEV_TX_OK;
       
  3348 	}
       
  3349 
       
  3350 	if (likely(tso)) {
       
  3351 		if (likely(hw->mac_type != e1000_82544))
       
  3352 			tx_ring->last_tx_tso = true;
       
  3353 		tx_flags |= E1000_TX_FLAGS_TSO;
       
  3354 	} else if (likely(e1000_tx_csum(adapter, tx_ring, skb)))
       
  3355 		tx_flags |= E1000_TX_FLAGS_CSUM;
       
  3356 
       
  3357 	if (likely(skb->protocol == htons(ETH_P_IP)))
       
  3358 		tx_flags |= E1000_TX_FLAGS_IPV4;
       
  3359 
       
  3360 	if (unlikely(skb->no_fcs))
       
  3361 		tx_flags |= E1000_TX_FLAGS_NO_FCS;
       
  3362 
       
  3363 	count = e1000_tx_map(adapter, tx_ring, skb, first, max_per_txd,
       
  3364 	                     nr_frags, mss);
       
  3365 
       
  3366 	if (count) {
       
  3367 		netdev_sent_queue(netdev, skb->len);
       
  3368 		skb_tx_timestamp(skb);
       
  3369 
       
  3370 		e1000_tx_queue(adapter, tx_ring, tx_flags, count);
       
  3371 		if (!adapter->ecdev) {
       
  3372 			/* Make sure there is space in the ring for the next send. */
       
  3373 			e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
       
  3374 		}
       
  3375 
       
  3376 	} else {
       
  3377 		if (!adapter->ecdev) {
       
  3378 			dev_kfree_skb_any(skb);
       
  3379 		}
       
  3380 		tx_ring->buffer_info[first].time_stamp = 0;
       
  3381 		tx_ring->next_to_use = first;
       
  3382 	}
       
  3383 
       
  3384 	return NETDEV_TX_OK;
       
  3385 }
       
  3386 
       
  3387 #define NUM_REGS 38 /* 1 based count */
       
  3388 static void e1000_regdump(struct e1000_adapter *adapter)
       
  3389 {
       
  3390 	struct e1000_hw *hw = &adapter->hw;
       
  3391 	u32 regs[NUM_REGS];
       
  3392 	u32 *regs_buff = regs;
       
  3393 	int i = 0;
       
  3394 
       
  3395 	static const char * const reg_name[] = {
       
  3396 		"CTRL",  "STATUS",
       
  3397 		"RCTL", "RDLEN", "RDH", "RDT", "RDTR",
       
  3398 		"TCTL", "TDBAL", "TDBAH", "TDLEN", "TDH", "TDT",
       
  3399 		"TIDV", "TXDCTL", "TADV", "TARC0",
       
  3400 		"TDBAL1", "TDBAH1", "TDLEN1", "TDH1", "TDT1",
       
  3401 		"TXDCTL1", "TARC1",
       
  3402 		"CTRL_EXT", "ERT", "RDBAL", "RDBAH",
       
  3403 		"TDFH", "TDFT", "TDFHS", "TDFTS", "TDFPC",
       
  3404 		"RDFH", "RDFT", "RDFHS", "RDFTS", "RDFPC"
       
  3405 	};
       
  3406 
       
  3407 	regs_buff[0]  = er32(CTRL);
       
  3408 	regs_buff[1]  = er32(STATUS);
       
  3409 
       
  3410 	regs_buff[2]  = er32(RCTL);
       
  3411 	regs_buff[3]  = er32(RDLEN);
       
  3412 	regs_buff[4]  = er32(RDH);
       
  3413 	regs_buff[5]  = er32(RDT);
       
  3414 	regs_buff[6]  = er32(RDTR);
       
  3415 
       
  3416 	regs_buff[7]  = er32(TCTL);
       
  3417 	regs_buff[8]  = er32(TDBAL);
       
  3418 	regs_buff[9]  = er32(TDBAH);
       
  3419 	regs_buff[10] = er32(TDLEN);
       
  3420 	regs_buff[11] = er32(TDH);
       
  3421 	regs_buff[12] = er32(TDT);
       
  3422 	regs_buff[13] = er32(TIDV);
       
  3423 	regs_buff[14] = er32(TXDCTL);
       
  3424 	regs_buff[15] = er32(TADV);
       
  3425 	regs_buff[16] = er32(TARC0);
       
  3426 
       
  3427 	regs_buff[17] = er32(TDBAL1);
       
  3428 	regs_buff[18] = er32(TDBAH1);
       
  3429 	regs_buff[19] = er32(TDLEN1);
       
  3430 	regs_buff[20] = er32(TDH1);
       
  3431 	regs_buff[21] = er32(TDT1);
       
  3432 	regs_buff[22] = er32(TXDCTL1);
       
  3433 	regs_buff[23] = er32(TARC1);
       
  3434 	regs_buff[24] = er32(CTRL_EXT);
       
  3435 	regs_buff[25] = er32(ERT);
       
  3436 	regs_buff[26] = er32(RDBAL0);
       
  3437 	regs_buff[27] = er32(RDBAH0);
       
  3438 	regs_buff[28] = er32(TDFH);
       
  3439 	regs_buff[29] = er32(TDFT);
       
  3440 	regs_buff[30] = er32(TDFHS);
       
  3441 	regs_buff[31] = er32(TDFTS);
       
  3442 	regs_buff[32] = er32(TDFPC);
       
  3443 	regs_buff[33] = er32(RDFH);
       
  3444 	regs_buff[34] = er32(RDFT);
       
  3445 	regs_buff[35] = er32(RDFHS);
       
  3446 	regs_buff[36] = er32(RDFTS);
       
  3447 	regs_buff[37] = er32(RDFPC);
       
  3448 
       
  3449 	pr_info("Register dump\n");
       
  3450 	for (i = 0; i < NUM_REGS; i++)
       
  3451 		pr_info("%-15s  %08x\n", reg_name[i], regs_buff[i]);
       
  3452 }
       
  3453 
       
  3454 /*
       
  3455  * e1000_dump: Print registers, tx ring and rx ring
       
  3456  */
       
  3457 static void e1000_dump(struct e1000_adapter *adapter)
       
  3458 {
       
  3459 	/* this code doesn't handle multiple rings */
       
  3460 	struct e1000_tx_ring *tx_ring = adapter->tx_ring;
       
  3461 	struct e1000_rx_ring *rx_ring = adapter->rx_ring;
       
  3462 	int i;
       
  3463 
       
  3464 	if (!netif_msg_hw(adapter))
       
  3465 		return;
       
  3466 
       
  3467 	/* Print Registers */
       
  3468 	e1000_regdump(adapter);
       
  3469 
       
  3470 	/*
       
  3471 	 * transmit dump
       
  3472 	 */
       
  3473 	pr_info("TX Desc ring0 dump\n");
       
  3474 
       
  3475 	/* Transmit Descriptor Formats - DEXT[29] is 0 (Legacy) or 1 (Extended)
       
  3476 	 *
       
  3477 	 * Legacy Transmit Descriptor
       
  3478 	 *   +--------------------------------------------------------------+
       
  3479 	 * 0 |         Buffer Address [63:0] (Reserved on Write Back)       |
       
  3480 	 *   +--------------------------------------------------------------+
       
  3481 	 * 8 | Special  |    CSS     | Status |  CMD    |  CSO   |  Length  |
       
  3482 	 *   +--------------------------------------------------------------+
       
  3483 	 *   63       48 47        36 35    32 31     24 23    16 15        0
       
  3484 	 *
       
  3485 	 * Extended Context Descriptor (DTYP=0x0) for TSO or checksum offload
       
  3486 	 *   63      48 47    40 39       32 31             16 15    8 7      0
       
  3487 	 *   +----------------------------------------------------------------+
       
  3488 	 * 0 |  TUCSE  | TUCS0  |   TUCSS   |     IPCSE       | IPCS0 | IPCSS |
       
  3489 	 *   +----------------------------------------------------------------+
       
  3490 	 * 8 |   MSS   | HDRLEN | RSV | STA | TUCMD | DTYP |      PAYLEN      |
       
  3491 	 *   +----------------------------------------------------------------+
       
  3492 	 *   63      48 47    40 39 36 35 32 31   24 23  20 19                0
       
  3493 	 *
       
  3494 	 * Extended Data Descriptor (DTYP=0x1)
       
  3495 	 *   +----------------------------------------------------------------+
       
  3496 	 * 0 |                     Buffer Address [63:0]                      |
       
  3497 	 *   +----------------------------------------------------------------+
       
  3498 	 * 8 | VLAN tag |  POPTS  | Rsvd | Status | Command | DTYP |  DTALEN  |
       
  3499 	 *   +----------------------------------------------------------------+
       
  3500 	 *   63       48 47     40 39  36 35    32 31     24 23  20 19        0
       
  3501 	 */
       
  3502 	pr_info("Tc[desc]     [Ce CoCsIpceCoS] [MssHlRSCm0Plen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
       
  3503 	pr_info("Td[desc]     [address 63:0  ] [VlaPoRSCm1Dlen] [bi->dma       ] leng  ntw timestmp         bi->skb\n");
       
  3504 
       
  3505 	if (!netif_msg_tx_done(adapter))
       
  3506 		goto rx_ring_summary;
       
  3507 
       
  3508 	for (i = 0; tx_ring->desc && (i < tx_ring->count); i++) {
       
  3509 		struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);
       
  3510 		struct e1000_buffer *buffer_info = &tx_ring->buffer_info[i];
       
  3511 		struct my_u { __le64 a; __le64 b; };
       
  3512 		struct my_u *u = (struct my_u *)tx_desc;
       
  3513 		const char *type;
       
  3514 
       
  3515 		if (i == tx_ring->next_to_use && i == tx_ring->next_to_clean)
       
  3516 			type = "NTC/U";
       
  3517 		else if (i == tx_ring->next_to_use)
       
  3518 			type = "NTU";
       
  3519 		else if (i == tx_ring->next_to_clean)
       
  3520 			type = "NTC";
       
  3521 		else
       
  3522 			type = "";
       
  3523 
       
  3524 		pr_info("T%c[0x%03X]    %016llX %016llX %016llX %04X  %3X %016llX %p %s\n",
       
  3525 			((le64_to_cpu(u->b) & (1<<20)) ? 'd' : 'c'), i,
       
  3526 			le64_to_cpu(u->a), le64_to_cpu(u->b),
       
  3527 			(u64)buffer_info->dma, buffer_info->length,
       
  3528 			buffer_info->next_to_watch,
       
  3529 			(u64)buffer_info->time_stamp, buffer_info->skb, type);
       
  3530 	}
       
  3531 
       
  3532 rx_ring_summary:
       
  3533 	/*
       
  3534 	 * receive dump
       
  3535 	 */
       
  3536 	pr_info("\nRX Desc ring dump\n");
       
  3537 
       
  3538 	/* Legacy Receive Descriptor Format
       
  3539 	 *
       
  3540 	 * +-----------------------------------------------------+
       
  3541 	 * |                Buffer Address [63:0]                |
       
  3542 	 * +-----------------------------------------------------+
       
  3543 	 * | VLAN Tag | Errors | Status 0 | Packet csum | Length |
       
  3544 	 * +-----------------------------------------------------+
       
  3545 	 * 63       48 47    40 39      32 31         16 15      0
       
  3546 	 */
       
  3547 	pr_info("R[desc]      [address 63:0  ] [vl er S cks ln] [bi->dma       ] [bi->skb]\n");
       
  3548 
       
  3549 	if (!netif_msg_rx_status(adapter))
       
  3550 		goto exit;
       
  3551 
       
  3552 	for (i = 0; rx_ring->desc && (i < rx_ring->count); i++) {
       
  3553 		struct e1000_rx_desc *rx_desc = E1000_RX_DESC(*rx_ring, i);
       
  3554 		struct e1000_buffer *buffer_info = &rx_ring->buffer_info[i];
       
  3555 		struct my_u { __le64 a; __le64 b; };
       
  3556 		struct my_u *u = (struct my_u *)rx_desc;
       
  3557 		const char *type;
       
  3558 
       
  3559 		if (i == rx_ring->next_to_use)
       
  3560 			type = "NTU";
       
  3561 		else if (i == rx_ring->next_to_clean)
       
  3562 			type = "NTC";
       
  3563 		else
       
  3564 			type = "";
       
  3565 
       
  3566 		pr_info("R[0x%03X]     %016llX %016llX %016llX %p %s\n",
       
  3567 			i, le64_to_cpu(u->a), le64_to_cpu(u->b),
       
  3568 			(u64)buffer_info->dma, buffer_info->skb, type);
       
  3569 	} /* for */
       
  3570 
       
  3571 	/* dump the descriptor caches */
       
  3572 	/* rx */
       
  3573 	pr_info("Rx descriptor cache in 64bit format\n");
       
  3574 	for (i = 0x6000; i <= 0x63FF ; i += 0x10) {
       
  3575 		pr_info("R%04X: %08X|%08X %08X|%08X\n",
       
  3576 			i,
       
  3577 			readl(adapter->hw.hw_addr + i+4),
       
  3578 			readl(adapter->hw.hw_addr + i),
       
  3579 			readl(adapter->hw.hw_addr + i+12),
       
  3580 			readl(adapter->hw.hw_addr + i+8));
       
  3581 	}
       
  3582 	/* tx */
       
  3583 	pr_info("Tx descriptor cache in 64bit format\n");
       
  3584 	for (i = 0x7000; i <= 0x73FF ; i += 0x10) {
       
  3585 		pr_info("T%04X: %08X|%08X %08X|%08X\n",
       
  3586 			i,
       
  3587 			readl(adapter->hw.hw_addr + i+4),
       
  3588 			readl(adapter->hw.hw_addr + i),
       
  3589 			readl(adapter->hw.hw_addr + i+12),
       
  3590 			readl(adapter->hw.hw_addr + i+8));
       
  3591 	}
       
  3592 exit:
       
  3593 	return;
       
  3594 }
       
  3595 
       
  3596 /**
       
  3597  * e1000_tx_timeout - Respond to a Tx Hang
       
  3598  * @netdev: network interface device structure
       
  3599  **/
       
  3600 
       
  3601 static void e1000_tx_timeout(struct net_device *netdev)
       
  3602 {
       
  3603 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  3604 
       
  3605 	/* Do the reset outside of interrupt context */
       
  3606 	adapter->tx_timeout_count++;
       
  3607 	schedule_work(&adapter->reset_task);
       
  3608 }
       
  3609 
       
  3610 static void e1000_reset_task(struct work_struct *work)
       
  3611 {
       
  3612 	struct e1000_adapter *adapter =
       
  3613 		container_of(work, struct e1000_adapter, reset_task);
       
  3614 
       
  3615 	if (test_bit(__E1000_DOWN, &adapter->flags))
       
  3616 		return;
       
  3617 	e_err(drv, "Reset adapter\n");
       
  3618 	e1000_reinit_safe(adapter);
       
  3619 }
       
  3620 
       
  3621 /**
       
  3622  * e1000_get_stats - Get System Network Statistics
       
  3623  * @netdev: network interface device structure
       
  3624  *
       
  3625  * Returns the address of the device statistics structure.
       
  3626  * The statistics are actually updated from the watchdog.
       
  3627  **/
       
  3628 
       
  3629 static struct net_device_stats *e1000_get_stats(struct net_device *netdev)
       
  3630 {
       
  3631 	/* only return the current stats */
       
  3632 	return &netdev->stats;
       
  3633 }
       
  3634 
       
  3635 /**
       
  3636  * e1000_change_mtu - Change the Maximum Transfer Unit
       
  3637  * @netdev: network interface device structure
       
  3638  * @new_mtu: new value for maximum frame size
       
  3639  *
       
  3640  * Returns 0 on success, negative on failure
       
  3641  **/
       
  3642 
       
  3643 static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
       
  3644 {
       
  3645 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  3646 	struct e1000_hw *hw = &adapter->hw;
       
  3647 	int max_frame = new_mtu + ENET_HEADER_SIZE + ETHERNET_FCS_SIZE;
       
  3648 
       
  3649 	if (adapter->ecdev) {
       
  3650 		return -EBUSY;
       
  3651 	}
       
  3652 
       
  3653 	if ((max_frame < MINIMUM_ETHERNET_FRAME_SIZE) ||
       
  3654 	    (max_frame > MAX_JUMBO_FRAME_SIZE)) {
       
  3655 		e_err(probe, "Invalid MTU setting\n");
       
  3656 		return -EINVAL;
       
  3657 	}
       
  3658 
       
  3659 	/* Adapter-specific max frame size limits. */
       
  3660 	switch (hw->mac_type) {
       
  3661 	case e1000_undefined ... e1000_82542_rev2_1:
       
  3662 		if (max_frame > (ETH_FRAME_LEN + ETH_FCS_LEN)) {
       
  3663 			e_err(probe, "Jumbo Frames not supported.\n");
       
  3664 			return -EINVAL;
       
  3665 		}
       
  3666 		break;
       
  3667 	default:
       
  3668 		/* Capable of supporting up to MAX_JUMBO_FRAME_SIZE limit. */
       
  3669 		break;
       
  3670 	}
       
  3671 
       
  3672 	while (test_and_set_bit(__E1000_RESETTING, &adapter->flags))
       
  3673 		msleep(1);
       
  3674 	/* e1000_down has a dependency on max_frame_size */
       
  3675 	hw->max_frame_size = max_frame;
       
  3676 	if (netif_running(netdev))
       
  3677 		e1000_down(adapter);
       
  3678 
       
  3679 	/* NOTE: netdev_alloc_skb reserves 16 bytes, and typically NET_IP_ALIGN
       
  3680 	 * means we reserve 2 more, this pushes us to allocate from the next
       
  3681 	 * larger slab size.
       
  3682 	 * i.e. RXBUFFER_2048 --> size-4096 slab
       
  3683 	 *  however with the new *_jumbo_rx* routines, jumbo receives will use
       
  3684 	 *  fragmented skbs */
       
  3685 
       
  3686 	if (max_frame <= E1000_RXBUFFER_2048)
       
  3687 		adapter->rx_buffer_len = E1000_RXBUFFER_2048;
       
  3688 	else
       
  3689 #if (PAGE_SIZE >= E1000_RXBUFFER_16384)
       
  3690 		adapter->rx_buffer_len = E1000_RXBUFFER_16384;
       
  3691 #elif (PAGE_SIZE >= E1000_RXBUFFER_4096)
       
  3692 		adapter->rx_buffer_len = PAGE_SIZE;
       
  3693 #endif
       
  3694 
       
  3695 	/* adjust allocation if LPE protects us, and we aren't using SBP */
       
  3696 	if (!hw->tbi_compatibility_on &&
       
  3697 	    ((max_frame == (ETH_FRAME_LEN + ETH_FCS_LEN)) ||
       
  3698 	     (max_frame == MAXIMUM_ETHERNET_VLAN_SIZE)))
       
  3699 		adapter->rx_buffer_len = MAXIMUM_ETHERNET_VLAN_SIZE;
       
  3700 
       
  3701 	pr_info("%s changing MTU from %d to %d\n",
       
  3702 		netdev->name, netdev->mtu, new_mtu);
       
  3703 	netdev->mtu = new_mtu;
       
  3704 
       
  3705 	if (netif_running(netdev))
       
  3706 		e1000_up(adapter);
       
  3707 	else
       
  3708 		e1000_reset(adapter);
       
  3709 
       
  3710 	clear_bit(__E1000_RESETTING, &adapter->flags);
       
  3711 
       
  3712 	return 0;
       
  3713 }
       
  3714 
       
  3715 /**
       
  3716  * e1000_update_stats - Update the board statistics counters
       
  3717  * @adapter: board private structure
       
  3718  **/
       
  3719 
       
  3720 void e1000_update_stats(struct e1000_adapter *adapter)
       
  3721 {
       
  3722 	struct net_device *netdev = adapter->netdev;
       
  3723 	struct e1000_hw *hw = &adapter->hw;
       
  3724 	struct pci_dev *pdev = adapter->pdev;
       
  3725 	unsigned long flags = 0;
       
  3726 	u16 phy_tmp;
       
  3727 
       
  3728 #define PHY_IDLE_ERROR_COUNT_MASK 0x00FF
       
  3729 
       
  3730 	/*
       
  3731 	 * Prevent stats update while adapter is being reset, or if the pci
       
  3732 	 * connection is down.
       
  3733 	 */
       
  3734 	if (adapter->link_speed == 0)
       
  3735 		return;
       
  3736 	if (pci_channel_offline(pdev))
       
  3737 		return;
       
  3738 
       
  3739 	if (!adapter->ecdev) {
       
  3740 		spin_lock_irqsave(&adapter->stats_lock, flags);
       
  3741 	}
       
  3742 
       
  3743 	/* these counters are modified from e1000_tbi_adjust_stats,
       
  3744 	 * called from the interrupt context, so they must only
       
  3745 	 * be written while holding adapter->stats_lock
       
  3746 	 */
       
  3747 
       
  3748 	adapter->stats.crcerrs += er32(CRCERRS);
       
  3749 	adapter->stats.gprc += er32(GPRC);
       
  3750 	adapter->stats.gorcl += er32(GORCL);
       
  3751 	adapter->stats.gorch += er32(GORCH);
       
  3752 	adapter->stats.bprc += er32(BPRC);
       
  3753 	adapter->stats.mprc += er32(MPRC);
       
  3754 	adapter->stats.roc += er32(ROC);
       
  3755 
       
  3756 	adapter->stats.prc64 += er32(PRC64);
       
  3757 	adapter->stats.prc127 += er32(PRC127);
       
  3758 	adapter->stats.prc255 += er32(PRC255);
       
  3759 	adapter->stats.prc511 += er32(PRC511);
       
  3760 	adapter->stats.prc1023 += er32(PRC1023);
       
  3761 	adapter->stats.prc1522 += er32(PRC1522);
       
  3762 
       
  3763 	adapter->stats.symerrs += er32(SYMERRS);
       
  3764 	adapter->stats.mpc += er32(MPC);
       
  3765 	adapter->stats.scc += er32(SCC);
       
  3766 	adapter->stats.ecol += er32(ECOL);
       
  3767 	adapter->stats.mcc += er32(MCC);
       
  3768 	adapter->stats.latecol += er32(LATECOL);
       
  3769 	adapter->stats.dc += er32(DC);
       
  3770 	adapter->stats.sec += er32(SEC);
       
  3771 	adapter->stats.rlec += er32(RLEC);
       
  3772 	adapter->stats.xonrxc += er32(XONRXC);
       
  3773 	adapter->stats.xontxc += er32(XONTXC);
       
  3774 	adapter->stats.xoffrxc += er32(XOFFRXC);
       
  3775 	adapter->stats.xofftxc += er32(XOFFTXC);
       
  3776 	adapter->stats.fcruc += er32(FCRUC);
       
  3777 	adapter->stats.gptc += er32(GPTC);
       
  3778 	adapter->stats.gotcl += er32(GOTCL);
       
  3779 	adapter->stats.gotch += er32(GOTCH);
       
  3780 	adapter->stats.rnbc += er32(RNBC);
       
  3781 	adapter->stats.ruc += er32(RUC);
       
  3782 	adapter->stats.rfc += er32(RFC);
       
  3783 	adapter->stats.rjc += er32(RJC);
       
  3784 	adapter->stats.torl += er32(TORL);
       
  3785 	adapter->stats.torh += er32(TORH);
       
  3786 	adapter->stats.totl += er32(TOTL);
       
  3787 	adapter->stats.toth += er32(TOTH);
       
  3788 	adapter->stats.tpr += er32(TPR);
       
  3789 
       
  3790 	adapter->stats.ptc64 += er32(PTC64);
       
  3791 	adapter->stats.ptc127 += er32(PTC127);
       
  3792 	adapter->stats.ptc255 += er32(PTC255);
       
  3793 	adapter->stats.ptc511 += er32(PTC511);
       
  3794 	adapter->stats.ptc1023 += er32(PTC1023);
       
  3795 	adapter->stats.ptc1522 += er32(PTC1522);
       
  3796 
       
  3797 	adapter->stats.mptc += er32(MPTC);
       
  3798 	adapter->stats.bptc += er32(BPTC);
       
  3799 
       
  3800 	/* used for adaptive IFS */
       
  3801 
       
  3802 	hw->tx_packet_delta = er32(TPT);
       
  3803 	adapter->stats.tpt += hw->tx_packet_delta;
       
  3804 	hw->collision_delta = er32(COLC);
       
  3805 	adapter->stats.colc += hw->collision_delta;
       
  3806 
       
  3807 	if (hw->mac_type >= e1000_82543) {
       
  3808 		adapter->stats.algnerrc += er32(ALGNERRC);
       
  3809 		adapter->stats.rxerrc += er32(RXERRC);
       
  3810 		adapter->stats.tncrs += er32(TNCRS);
       
  3811 		adapter->stats.cexterr += er32(CEXTERR);
       
  3812 		adapter->stats.tsctc += er32(TSCTC);
       
  3813 		adapter->stats.tsctfc += er32(TSCTFC);
       
  3814 	}
       
  3815 
       
  3816 	/* Fill out the OS statistics structure */
       
  3817 	netdev->stats.multicast = adapter->stats.mprc;
       
  3818 	netdev->stats.collisions = adapter->stats.colc;
       
  3819 
       
  3820 	/* Rx Errors */
       
  3821 
       
  3822 	/* RLEC on some newer hardware can be incorrect so build
       
  3823 	* our own version based on RUC and ROC */
       
  3824 	netdev->stats.rx_errors = adapter->stats.rxerrc +
       
  3825 		adapter->stats.crcerrs + adapter->stats.algnerrc +
       
  3826 		adapter->stats.ruc + adapter->stats.roc +
       
  3827 		adapter->stats.cexterr;
       
  3828 	adapter->stats.rlerrc = adapter->stats.ruc + adapter->stats.roc;
       
  3829 	netdev->stats.rx_length_errors = adapter->stats.rlerrc;
       
  3830 	netdev->stats.rx_crc_errors = adapter->stats.crcerrs;
       
  3831 	netdev->stats.rx_frame_errors = adapter->stats.algnerrc;
       
  3832 	netdev->stats.rx_missed_errors = adapter->stats.mpc;
       
  3833 
       
  3834 	/* Tx Errors */
       
  3835 	adapter->stats.txerrc = adapter->stats.ecol + adapter->stats.latecol;
       
  3836 	netdev->stats.tx_errors = adapter->stats.txerrc;
       
  3837 	netdev->stats.tx_aborted_errors = adapter->stats.ecol;
       
  3838 	netdev->stats.tx_window_errors = adapter->stats.latecol;
       
  3839 	netdev->stats.tx_carrier_errors = adapter->stats.tncrs;
       
  3840 	if (hw->bad_tx_carr_stats_fd &&
       
  3841 	    adapter->link_duplex == FULL_DUPLEX) {
       
  3842 		netdev->stats.tx_carrier_errors = 0;
       
  3843 		adapter->stats.tncrs = 0;
       
  3844 	}
       
  3845 
       
  3846 	/* Tx Dropped needs to be maintained elsewhere */
       
  3847 
       
  3848 	/* Phy Stats */
       
  3849 	if (hw->media_type == e1000_media_type_copper) {
       
  3850 		if ((adapter->link_speed == SPEED_1000) &&
       
  3851 		   (!e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_tmp))) {
       
  3852 			phy_tmp &= PHY_IDLE_ERROR_COUNT_MASK;
       
  3853 			adapter->phy_stats.idle_errors += phy_tmp;
       
  3854 		}
       
  3855 
       
  3856 		if ((hw->mac_type <= e1000_82546) &&
       
  3857 		   (hw->phy_type == e1000_phy_m88) &&
       
  3858 		   !e1000_read_phy_reg(hw, M88E1000_RX_ERR_CNTR, &phy_tmp))
       
  3859 			adapter->phy_stats.receive_errors += phy_tmp;
       
  3860 	}
       
  3861 
       
  3862 	/* Management Stats */
       
  3863 	if (hw->has_smbus) {
       
  3864 		adapter->stats.mgptc += er32(MGTPTC);
       
  3865 		adapter->stats.mgprc += er32(MGTPRC);
       
  3866 		adapter->stats.mgpdc += er32(MGTPDC);
       
  3867 	}
       
  3868 
       
  3869 	if (!adapter->ecdev) {
       
  3870 		spin_unlock_irqrestore(&adapter->stats_lock, flags);
       
  3871 	}
       
  3872 }
       
  3873 
       
  3874 void ec_poll(struct net_device *netdev)
       
  3875 {
       
  3876 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  3877 	if (jiffies - adapter->ec_watchdog_jiffies >= 2 * HZ) {
       
  3878 		e1000_watchdog(&adapter->watchdog_task.work);
       
  3879 		adapter->ec_watchdog_jiffies = jiffies;
       
  3880 	}
       
  3881 
       
  3882 	e1000_intr(0, netdev);
       
  3883 }
       
  3884 
       
  3885 /**
       
  3886  * e1000_intr - Interrupt Handler
       
  3887  * @irq: interrupt number
       
  3888  * @data: pointer to a network interface device structure
       
  3889  **/
       
  3890 
       
  3891 static irqreturn_t e1000_intr(int irq, void *data)
       
  3892 {
       
  3893 	struct net_device *netdev = data;
       
  3894 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  3895 	struct e1000_hw *hw = &adapter->hw;
       
  3896 	u32 icr = er32(ICR);
       
  3897 
       
  3898 	if (unlikely((!icr)))
       
  3899 		return IRQ_NONE;  /* Not our interrupt */
       
  3900 
       
  3901 	/*
       
  3902 	 * we might have caused the interrupt, but the above
       
  3903 	 * read cleared it, and just in case the driver is
       
  3904 	 * down there is nothing to do so return handled
       
  3905 	 */
       
  3906 	if (unlikely(test_bit(__E1000_DOWN, &adapter->flags)))
       
  3907 		return IRQ_HANDLED;
       
  3908 
       
  3909 	if (unlikely(icr & (E1000_ICR_RXSEQ | E1000_ICR_LSC))) {
       
  3910 		hw->get_link_status = 1;
       
  3911 		/* guard against interrupt when we're going down */
       
  3912 		if (!adapter->ecdev && !test_bit(__E1000_DOWN, &adapter->flags))
       
  3913 			schedule_delayed_work(&adapter->watchdog_task, 1);
       
  3914 	}
       
  3915 
       
  3916 	if (adapter->ecdev) {
       
  3917 		int i, ec_work_done = 0;
       
  3918 		for (i = 0; i < E1000_MAX_INTR; i++) {
       
  3919 			if (unlikely(!adapter->clean_rx(adapter, adapter->rx_ring,
       
  3920 							&ec_work_done, 100) &&
       
  3921 						!e1000_clean_tx_irq(adapter, adapter->tx_ring))) {
       
  3922 				break;
       
  3923 			}
       
  3924 		}
       
  3925  	} else {
       
  3926 		/* disable interrupts, without the synchronize_irq bit */
       
  3927 		ew32(IMC, ~0);
       
  3928 		E1000_WRITE_FLUSH();
       
  3929 
       
  3930 		if (likely(napi_schedule_prep(&adapter->napi))) {
       
  3931 			adapter->total_tx_bytes = 0;
       
  3932 			adapter->total_tx_packets = 0;
       
  3933 			adapter->total_rx_bytes = 0;
       
  3934 			adapter->total_rx_packets = 0;
       
  3935 			__napi_schedule(&adapter->napi);
       
  3936 		} else {
       
  3937 			/* this really should not happen! if it does it is basically a
       
  3938 			 * bug, but not a hard error, so enable ints and continue */
       
  3939 			if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  3940 				e1000_irq_enable(adapter);
       
  3941 		}
       
  3942 	}
       
  3943 
       
  3944 	return IRQ_HANDLED;
       
  3945 }
       
  3946 
       
  3947 /**
       
  3948  * e1000_clean - NAPI Rx polling callback
       
  3949  * @adapter: board private structure
       
  3950  * EtherCAT: never called
       
  3951  **/
       
  3952 static int e1000_clean(struct napi_struct *napi, int budget)
       
  3953 {
       
  3954 	struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, napi);
       
  3955 	int tx_clean_complete = 0, work_done = 0;
       
  3956 
       
  3957 	tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]);
       
  3958 
       
  3959 	adapter->clean_rx(adapter, &adapter->rx_ring[0], &work_done, budget);
       
  3960 
       
  3961 	if (!tx_clean_complete)
       
  3962 		work_done = budget;
       
  3963 
       
  3964 	/* If budget not fully consumed, exit the polling mode */
       
  3965 	if (work_done < budget) {
       
  3966 		if (likely(adapter->itr_setting & 3))
       
  3967 			e1000_set_itr(adapter);
       
  3968 		napi_complete(napi);
       
  3969 		if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  3970 			e1000_irq_enable(adapter);
       
  3971 	}
       
  3972 
       
  3973 	return work_done;
       
  3974 }
       
  3975 
       
  3976 /**
       
  3977  * e1000_clean_tx_irq - Reclaim resources after transmit completes
       
  3978  * @adapter: board private structure
       
  3979  **/
       
  3980 static bool e1000_clean_tx_irq(struct e1000_adapter *adapter,
       
  3981 			       struct e1000_tx_ring *tx_ring)
       
  3982 {
       
  3983 	struct e1000_hw *hw = &adapter->hw;
       
  3984 	struct net_device *netdev = adapter->netdev;
       
  3985 	struct e1000_tx_desc *tx_desc, *eop_desc;
       
  3986 	struct e1000_buffer *buffer_info;
       
  3987 	unsigned int i, eop;
       
  3988 	unsigned int count = 0;
       
  3989 	unsigned int total_tx_bytes=0, total_tx_packets=0;
       
  3990 	unsigned int bytes_compl = 0, pkts_compl = 0;
       
  3991 
       
  3992 	i = tx_ring->next_to_clean;
       
  3993 	eop = tx_ring->buffer_info[i].next_to_watch;
       
  3994 	eop_desc = E1000_TX_DESC(*tx_ring, eop);
       
  3995 
       
  3996 	while ((eop_desc->upper.data & cpu_to_le32(E1000_TXD_STAT_DD)) &&
       
  3997 	       (count < tx_ring->count)) {
       
  3998 		bool cleaned = false;
       
  3999 		rmb();	/* read buffer_info after eop_desc */
       
  4000 		for ( ; !cleaned; count++) {
       
  4001 			tx_desc = E1000_TX_DESC(*tx_ring, i);
       
  4002 			buffer_info = &tx_ring->buffer_info[i];
       
  4003 			cleaned = (i == eop);
       
  4004 
       
  4005 			if (cleaned) {
       
  4006 				total_tx_packets += buffer_info->segs;
       
  4007 				total_tx_bytes += buffer_info->bytecount;
       
  4008 				if (buffer_info->skb) {
       
  4009 					bytes_compl += buffer_info->skb->len;
       
  4010 					pkts_compl++;
       
  4011 				}
       
  4012 
       
  4013 			}
       
  4014 			e1000_unmap_and_free_tx_resource(adapter, buffer_info);
       
  4015 			tx_desc->upper.data = 0;
       
  4016 
       
  4017 			if (unlikely(++i == tx_ring->count)) i = 0;
       
  4018 		}
       
  4019 
       
  4020 		eop = tx_ring->buffer_info[i].next_to_watch;
       
  4021 		eop_desc = E1000_TX_DESC(*tx_ring, eop);
       
  4022 	}
       
  4023 
       
  4024 	tx_ring->next_to_clean = i;
       
  4025 
       
  4026 	netdev_completed_queue(netdev, pkts_compl, bytes_compl);
       
  4027 
       
  4028 #define TX_WAKE_THRESHOLD 32
       
  4029 	if (!adapter->ecdev && unlikely(count && netif_carrier_ok(netdev) &&
       
  4030 		     E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) {
       
  4031 		/* Make sure that anybody stopping the queue after this
       
  4032 		 * sees the new next_to_clean.
       
  4033 		 */
       
  4034 		smp_mb();
       
  4035 
       
  4036 		if (netif_queue_stopped(netdev) &&
       
  4037 		    !(test_bit(__E1000_DOWN, &adapter->flags))) {
       
  4038 			netif_wake_queue(netdev);
       
  4039 			++adapter->restart_queue;
       
  4040 		}
       
  4041 	}
       
  4042 
       
  4043 	if (!adapter->ecdev && adapter->detect_tx_hung) {
       
  4044 		/* Detect a transmit hang in hardware, this serializes the
       
  4045 		 * check with the clearing of time_stamp and movement of i */
       
  4046 		adapter->detect_tx_hung = false;
       
  4047 		if (tx_ring->buffer_info[eop].time_stamp &&
       
  4048 		    time_after(jiffies, tx_ring->buffer_info[eop].time_stamp +
       
  4049 		               (adapter->tx_timeout_factor * HZ)) &&
       
  4050 		    !(er32(STATUS) & E1000_STATUS_TXOFF)) {
       
  4051 
       
  4052 			/* detected Tx unit hang */
       
  4053 			e_err(drv, "Detected Tx Unit Hang\n"
       
  4054 			      "  Tx Queue             <%lu>\n"
       
  4055 			      "  TDH                  <%x>\n"
       
  4056 			      "  TDT                  <%x>\n"
       
  4057 			      "  next_to_use          <%x>\n"
       
  4058 			      "  next_to_clean        <%x>\n"
       
  4059 			      "buffer_info[next_to_clean]\n"
       
  4060 			      "  time_stamp           <%lx>\n"
       
  4061 			      "  next_to_watch        <%x>\n"
       
  4062 			      "  jiffies              <%lx>\n"
       
  4063 			      "  next_to_watch.status <%x>\n",
       
  4064 				(unsigned long)((tx_ring - adapter->tx_ring) /
       
  4065 					sizeof(struct e1000_tx_ring)),
       
  4066 				readl(hw->hw_addr + tx_ring->tdh),
       
  4067 				readl(hw->hw_addr + tx_ring->tdt),
       
  4068 				tx_ring->next_to_use,
       
  4069 				tx_ring->next_to_clean,
       
  4070 				tx_ring->buffer_info[eop].time_stamp,
       
  4071 				eop,
       
  4072 				jiffies,
       
  4073 				eop_desc->upper.fields.status);
       
  4074 			e1000_dump(adapter);
       
  4075 			netif_stop_queue(netdev);
       
  4076 		}
       
  4077 	}
       
  4078 	adapter->total_tx_bytes += total_tx_bytes;
       
  4079 	adapter->total_tx_packets += total_tx_packets;
       
  4080 	netdev->stats.tx_bytes += total_tx_bytes;
       
  4081 	netdev->stats.tx_packets += total_tx_packets;
       
  4082 	return count < tx_ring->count;
       
  4083 }
       
  4084 
       
  4085 /**
       
  4086  * e1000_rx_checksum - Receive Checksum Offload for 82543
       
  4087  * @adapter:     board private structure
       
  4088  * @status_err:  receive descriptor status and error fields
       
  4089  * @csum:        receive descriptor csum field
       
  4090  * @sk_buff:     socket buffer with received data
       
  4091  **/
       
  4092 
       
  4093 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
       
  4094 			      u32 csum, struct sk_buff *skb)
       
  4095 {
       
  4096 	struct e1000_hw *hw = &adapter->hw;
       
  4097 	u16 status = (u16)status_err;
       
  4098 	u8 errors = (u8)(status_err >> 24);
       
  4099 
       
  4100 	skb_checksum_none_assert(skb);
       
  4101 
       
  4102 	/* 82543 or newer only */
       
  4103 	if (unlikely(hw->mac_type < e1000_82543)) return;
       
  4104 	/* Ignore Checksum bit is set */
       
  4105 	if (unlikely(status & E1000_RXD_STAT_IXSM)) return;
       
  4106 	/* TCP/UDP checksum error bit is set */
       
  4107 	if (unlikely(errors & E1000_RXD_ERR_TCPE)) {
       
  4108 		/* let the stack verify checksum errors */
       
  4109 		adapter->hw_csum_err++;
       
  4110 		return;
       
  4111 	}
       
  4112 	/* TCP/UDP Checksum has not been calculated */
       
  4113 	if (!(status & E1000_RXD_STAT_TCPCS))
       
  4114 		return;
       
  4115 
       
  4116 	/* It must be a TCP or UDP packet with a valid checksum */
       
  4117 	if (likely(status & E1000_RXD_STAT_TCPCS)) {
       
  4118 		/* TCP checksum is good */
       
  4119 		skb->ip_summed = CHECKSUM_UNNECESSARY;
       
  4120 	}
       
  4121 	adapter->hw_csum_good++;
       
  4122 }
       
  4123 
       
  4124 /**
       
  4125  * e1000_consume_page - helper function
       
  4126  **/
       
  4127 static void e1000_consume_page(struct e1000_buffer *bi, struct sk_buff *skb,
       
  4128                                u16 length)
       
  4129 {
       
  4130 	bi->page = NULL;
       
  4131 	skb->len += length;
       
  4132 	skb->data_len += length;
       
  4133 	skb->truesize += PAGE_SIZE;
       
  4134 }
       
  4135 
       
  4136 /**
       
  4137  * e1000_receive_skb - helper function to handle rx indications
       
  4138  * @adapter: board private structure
       
  4139  * @status: descriptor status field as written by hardware
       
  4140  * @vlan: descriptor vlan field as written by hardware (no le/be conversion)
       
  4141  * @skb: pointer to sk_buff to be indicated to stack
       
  4142  */
       
  4143 static void e1000_receive_skb(struct e1000_adapter *adapter, u8 status,
       
  4144 			      __le16 vlan, struct sk_buff *skb)
       
  4145 {
       
  4146 	skb->protocol = eth_type_trans(skb, adapter->netdev);
       
  4147 
       
  4148 	if (status & E1000_RXD_STAT_VP) {
       
  4149 		u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
       
  4150 
       
  4151 		__vlan_hwaccel_put_tag(skb, vid);
       
  4152 	}
       
  4153 	napi_gro_receive(&adapter->napi, skb);
       
  4154 }
       
  4155 
       
  4156 /**
       
  4157  * e1000_clean_jumbo_rx_irq - Send received data up the network stack; legacy
       
  4158  * @adapter: board private structure
       
  4159  * @rx_ring: ring to clean
       
  4160  * @work_done: amount of napi work completed this call
       
  4161  * @work_to_do: max amount of work allowed for this call to do
       
  4162  *
       
  4163  * the return value indicates whether actual cleaning was done, there
       
  4164  * is no guarantee that everything was cleaned
       
  4165  */
       
  4166 static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,
       
  4167 				     struct e1000_rx_ring *rx_ring,
       
  4168 				     int *work_done, int work_to_do)
       
  4169 {
       
  4170 	struct e1000_hw *hw = &adapter->hw;
       
  4171 	struct net_device *netdev = adapter->netdev;
       
  4172 	struct pci_dev *pdev = adapter->pdev;
       
  4173 	struct e1000_rx_desc *rx_desc, *next_rxd;
       
  4174 	struct e1000_buffer *buffer_info, *next_buffer;
       
  4175 	unsigned long irq_flags;
       
  4176 	u32 length;
       
  4177 	unsigned int i;
       
  4178 	int cleaned_count = 0;
       
  4179 	bool cleaned = false;
       
  4180 	unsigned int total_rx_bytes=0, total_rx_packets=0;
       
  4181 
       
  4182 	i = rx_ring->next_to_clean;
       
  4183 	rx_desc = E1000_RX_DESC(*rx_ring, i);
       
  4184 	buffer_info = &rx_ring->buffer_info[i];
       
  4185 
       
  4186 	while (rx_desc->status & E1000_RXD_STAT_DD) {
       
  4187 		struct sk_buff *skb;
       
  4188 		u8 status;
       
  4189 
       
  4190 		if (*work_done >= work_to_do)
       
  4191 			break;
       
  4192 		(*work_done)++;
       
  4193 		rmb(); /* read descriptor and rx_buffer_info after status DD */
       
  4194 
       
  4195 		status = rx_desc->status;
       
  4196 		skb = buffer_info->skb;
       
  4197 		if (!adapter->ecdev) {
       
  4198 			buffer_info->skb = NULL;
       
  4199 		}
       
  4200 
       
  4201 		if (++i == rx_ring->count) i = 0;
       
  4202 		next_rxd = E1000_RX_DESC(*rx_ring, i);
       
  4203 		prefetch(next_rxd);
       
  4204 
       
  4205 		next_buffer = &rx_ring->buffer_info[i];
       
  4206 
       
  4207 		cleaned = true;
       
  4208 		cleaned_count++;
       
  4209 		dma_unmap_page(&pdev->dev, buffer_info->dma,
       
  4210 			       buffer_info->length, DMA_FROM_DEVICE);
       
  4211 		buffer_info->dma = 0;
       
  4212 
       
  4213 		length = le16_to_cpu(rx_desc->length);
       
  4214 
       
  4215 		/* errors is only valid for DD + EOP descriptors */
       
  4216 		if (!adapter->ecdev &&
       
  4217 		    unlikely((status & E1000_RXD_STAT_EOP) &&
       
  4218 		    (rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK))) {
       
  4219 			u8 *mapped;
       
  4220 			u8 last_byte;
       
  4221 
       
  4222 			mapped = page_address(buffer_info->page);
       
  4223 			last_byte = *(mapped + length - 1);
       
  4224 			if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
       
  4225 				       last_byte)) {
       
  4226 				spin_lock_irqsave(&adapter->stats_lock,
       
  4227 				                  irq_flags);
       
  4228 				e1000_tbi_adjust_stats(hw, &adapter->stats,
       
  4229 						       length, mapped);
       
  4230 				spin_unlock_irqrestore(&adapter->stats_lock,
       
  4231 				                       irq_flags);
       
  4232 				length--;
       
  4233 			} else {
       
  4234 				if (netdev->features & NETIF_F_RXALL)
       
  4235 					goto process_skb;
       
  4236 				/* recycle both page and skb */
       
  4237 				buffer_info->skb = skb;
       
  4238 				/* an error means any chain goes out the window
       
  4239 				 * too */
       
  4240 				if (rx_ring->rx_skb_top)
       
  4241 					dev_kfree_skb(rx_ring->rx_skb_top);
       
  4242 				rx_ring->rx_skb_top = NULL;
       
  4243 				goto next_desc;
       
  4244 			}
       
  4245 		}
       
  4246 
       
  4247 #define rxtop rx_ring->rx_skb_top
       
  4248 process_skb:
       
  4249 		if (!(status & E1000_RXD_STAT_EOP)) {
       
  4250 			/* this descriptor is only the beginning (or middle) */
       
  4251 			if (!rxtop) {
       
  4252 				/* this is the beginning of a chain */
       
  4253 				rxtop = skb;
       
  4254 				skb_fill_page_desc(rxtop, 0, buffer_info->page,
       
  4255 				                   0, length);
       
  4256 			} else {
       
  4257 				/* this is the middle of a chain */
       
  4258 				skb_fill_page_desc(rxtop,
       
  4259 				    skb_shinfo(rxtop)->nr_frags,
       
  4260 				    buffer_info->page, 0, length);
       
  4261 				/* re-use the skb, only consumed the page */
       
  4262 				buffer_info->skb = skb;
       
  4263 			}
       
  4264 			e1000_consume_page(buffer_info, rxtop, length);
       
  4265 			goto next_desc;
       
  4266 		} else {
       
  4267 			if (rxtop) {
       
  4268 				/* end of the chain */
       
  4269 				skb_fill_page_desc(rxtop,
       
  4270 				    skb_shinfo(rxtop)->nr_frags,
       
  4271 				    buffer_info->page, 0, length);
       
  4272 				/* re-use the current skb, we only consumed the
       
  4273 				 * page */
       
  4274 				buffer_info->skb = skb;
       
  4275 				skb = rxtop;
       
  4276 				rxtop = NULL;
       
  4277 				e1000_consume_page(buffer_info, skb, length);
       
  4278 			} else {
       
  4279 				/* no chain, got EOP, this buf is the packet
       
  4280 				 * copybreak to save the put_page/alloc_page */
       
  4281 				if (length <= copybreak &&
       
  4282 				    skb_tailroom(skb) >= length) {
       
  4283 					u8 *vaddr;
       
  4284 					vaddr = kmap_atomic(buffer_info->page);
       
  4285 					memcpy(skb_tail_pointer(skb), vaddr, length);
       
  4286 					kunmap_atomic(vaddr);
       
  4287 					/* re-use the page, so don't erase
       
  4288 					 * buffer_info->page */
       
  4289 					skb_put(skb, length);
       
  4290 				} else {
       
  4291 					skb_fill_page_desc(skb, 0,
       
  4292 					                   buffer_info->page, 0,
       
  4293 				                           length);
       
  4294 					e1000_consume_page(buffer_info, skb,
       
  4295 					                   length);
       
  4296 				}
       
  4297 			}
       
  4298 		}
       
  4299 
       
  4300 		/* Receive Checksum Offload XXX recompute due to CRC strip? */
       
  4301 		e1000_rx_checksum(adapter,
       
  4302 		                  (u32)(status) |
       
  4303 		                  ((u32)(rx_desc->errors) << 24),
       
  4304 		                  le16_to_cpu(rx_desc->csum), skb);
       
  4305 
       
  4306 		total_rx_bytes += (skb->len - 4); /* don't count FCS */
       
  4307 		if (likely(!(netdev->features & NETIF_F_RXFCS)))
       
  4308 			pskb_trim(skb, skb->len - 4);
       
  4309 		total_rx_packets++;
       
  4310 
       
  4311 		/* eth type trans needs skb->data to point to something */
       
  4312 		if (!pskb_may_pull(skb, ETH_HLEN)) {
       
  4313 			e_err(drv, "pskb_may_pull failed.\n");
       
  4314 			if (!adapter->ecdev) {
       
  4315 				dev_kfree_skb(skb);
       
  4316 			}
       
  4317 			goto next_desc;
       
  4318 		}
       
  4319 
       
  4320 		if (adapter->ecdev) {
       
  4321 			ecdev_receive(adapter->ecdev, skb->data, length);
       
  4322 
       
  4323 			// No need to detect link status as
       
  4324 			// long as frames are received: Reset watchdog.
       
  4325 			adapter->ec_watchdog_jiffies = jiffies;
       
  4326 		} else {
       
  4327 			e1000_receive_skb(adapter, status, rx_desc->special, skb);
       
  4328 		}
       
  4329 
       
  4330 next_desc:
       
  4331 		rx_desc->status = 0;
       
  4332 
       
  4333 		/* return some buffers to hardware, one at a time is too slow */
       
  4334 		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
       
  4335 			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
       
  4336 			cleaned_count = 0;
       
  4337 		}
       
  4338 
       
  4339 		/* use prefetched values */
       
  4340 		rx_desc = next_rxd;
       
  4341 		buffer_info = next_buffer;
       
  4342 	}
       
  4343 	rx_ring->next_to_clean = i;
       
  4344 
       
  4345 	cleaned_count = E1000_DESC_UNUSED(rx_ring);
       
  4346 	if (cleaned_count)
       
  4347 		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
       
  4348 
       
  4349 	adapter->total_rx_packets += total_rx_packets;
       
  4350 	adapter->total_rx_bytes += total_rx_bytes;
       
  4351 	netdev->stats.rx_bytes += total_rx_bytes;
       
  4352 	netdev->stats.rx_packets += total_rx_packets;
       
  4353 	return cleaned;
       
  4354 }
       
  4355 
       
  4356 /*
       
  4357  * this should improve performance for small packets with large amounts
       
  4358  * of reassembly being done in the stack
       
  4359  */
       
  4360 static void e1000_check_copybreak(struct net_device *netdev,
       
  4361 				 struct e1000_buffer *buffer_info,
       
  4362 				 u32 length, struct sk_buff **skb)
       
  4363 {
       
  4364 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  4365 	struct sk_buff *new_skb;
       
  4366 
       
  4367 	if (adapter->ecdev || length > copybreak)
       
  4368 		return;
       
  4369 
       
  4370 	new_skb = netdev_alloc_skb_ip_align(netdev, length);
       
  4371 	if (!new_skb)
       
  4372 		return;
       
  4373 
       
  4374 	skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
       
  4375 				       (*skb)->data - NET_IP_ALIGN,
       
  4376 				       length + NET_IP_ALIGN);
       
  4377 	/* save the skb in buffer_info as good */
       
  4378 	buffer_info->skb = *skb;
       
  4379 	*skb = new_skb;
       
  4380 }
       
  4381 
       
  4382 /**
       
  4383  * e1000_clean_rx_irq - Send received data up the network stack; legacy
       
  4384  * @adapter: board private structure
       
  4385  * @rx_ring: ring to clean
       
  4386  * @work_done: amount of napi work completed this call
       
  4387  * @work_to_do: max amount of work allowed for this call to do
       
  4388  */
       
  4389 static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,
       
  4390 			       struct e1000_rx_ring *rx_ring,
       
  4391 			       int *work_done, int work_to_do)
       
  4392 {
       
  4393 	struct e1000_hw *hw = &adapter->hw;
       
  4394 	struct net_device *netdev = adapter->netdev;
       
  4395 	struct pci_dev *pdev = adapter->pdev;
       
  4396 	struct e1000_rx_desc *rx_desc, *next_rxd;
       
  4397 	struct e1000_buffer *buffer_info, *next_buffer;
       
  4398 	unsigned long flags;
       
  4399 	u32 length;
       
  4400 	unsigned int i;
       
  4401 	int cleaned_count = 0;
       
  4402 	bool cleaned = false;
       
  4403 	unsigned int total_rx_bytes=0, total_rx_packets=0;
       
  4404 
       
  4405 	i = rx_ring->next_to_clean;
       
  4406 	rx_desc = E1000_RX_DESC(*rx_ring, i);
       
  4407 	buffer_info = &rx_ring->buffer_info[i];
       
  4408 
       
  4409 	while (rx_desc->status & E1000_RXD_STAT_DD) {
       
  4410 		struct sk_buff *skb;
       
  4411 		u8 status;
       
  4412 
       
  4413 		if (*work_done >= work_to_do)
       
  4414 			break;
       
  4415 		(*work_done)++;
       
  4416 		rmb(); /* read descriptor and rx_buffer_info after status DD */
       
  4417 
       
  4418 		status = rx_desc->status;
       
  4419 		skb = buffer_info->skb;
       
  4420 		if (!adapter->ecdev) {
       
  4421 			buffer_info->skb = NULL;
       
  4422 		}
       
  4423 
       
  4424 		prefetch(skb->data - NET_IP_ALIGN);
       
  4425 
       
  4426 		if (++i == rx_ring->count) i = 0;
       
  4427 		next_rxd = E1000_RX_DESC(*rx_ring, i);
       
  4428 		prefetch(next_rxd);
       
  4429 
       
  4430 		next_buffer = &rx_ring->buffer_info[i];
       
  4431 
       
  4432 		cleaned = true;
       
  4433 		cleaned_count++;
       
  4434 		dma_unmap_single(&pdev->dev, buffer_info->dma,
       
  4435 				 buffer_info->length, DMA_FROM_DEVICE);
       
  4436 		buffer_info->dma = 0;
       
  4437 
       
  4438 		length = le16_to_cpu(rx_desc->length);
       
  4439 		/* !EOP means multiple descriptors were used to store a single
       
  4440 		 * packet, if thats the case we need to toss it.  In fact, we
       
  4441 		 * to toss every packet with the EOP bit clear and the next
       
  4442 		 * frame that _does_ have the EOP bit set, as it is by
       
  4443 		 * definition only a frame fragment
       
  4444 		 */
       
  4445 		if (unlikely(!(status & E1000_RXD_STAT_EOP)))
       
  4446 			adapter->discarding = true;
       
  4447 
       
  4448 		if (adapter->discarding) {
       
  4449 			/* All receives must fit into a single buffer */
       
  4450 			e_dbg("Receive packet consumed multiple buffers\n");
       
  4451 			/* recycle */
       
  4452 			buffer_info->skb = skb;
       
  4453 			if (status & E1000_RXD_STAT_EOP)
       
  4454 				adapter->discarding = false;
       
  4455 			goto next_desc;
       
  4456 		}
       
  4457 
       
  4458 		if (!adapter->ecdev &&
       
  4459 		    unlikely(rx_desc->errors & E1000_RXD_ERR_FRAME_ERR_MASK)) {
       
  4460 			u8 last_byte = *(skb->data + length - 1);
       
  4461 			if (TBI_ACCEPT(hw, status, rx_desc->errors, length,
       
  4462 				       last_byte)) {
       
  4463 				spin_lock_irqsave(&adapter->stats_lock, flags);
       
  4464 				e1000_tbi_adjust_stats(hw, &adapter->stats,
       
  4465 				                       length, skb->data);
       
  4466 				spin_unlock_irqrestore(&adapter->stats_lock,
       
  4467 				                       flags);
       
  4468 				length--;
       
  4469 			} else {
       
  4470 				if (netdev->features & NETIF_F_RXALL)
       
  4471 					goto process_skb;
       
  4472 				/* recycle */
       
  4473 				buffer_info->skb = skb;
       
  4474 				goto next_desc;
       
  4475 			}
       
  4476 		}
       
  4477 
       
  4478 process_skb:
       
  4479 		total_rx_bytes += (length - 4); /* don't count FCS */
       
  4480 		total_rx_packets++;
       
  4481 
       
  4482 		if (likely(!(netdev->features & NETIF_F_RXFCS)))
       
  4483 			/* adjust length to remove Ethernet CRC, this must be
       
  4484 			 * done after the TBI_ACCEPT workaround above
       
  4485 			 */
       
  4486 			length -= 4;
       
  4487 
       
  4488 		e1000_check_copybreak(netdev, buffer_info, length, &skb);
       
  4489 
       
  4490 		skb_put(skb, length);
       
  4491 
       
  4492 		/* Receive Checksum Offload */
       
  4493 		e1000_rx_checksum(adapter,
       
  4494 				  (u32)(status) |
       
  4495 				  ((u32)(rx_desc->errors) << 24),
       
  4496 				  le16_to_cpu(rx_desc->csum), skb);
       
  4497 
       
  4498 		if (adapter->ecdev) {
       
  4499 			ecdev_receive(adapter->ecdev, skb->data, length);
       
  4500 
       
  4501 			// No need to detect link status as
       
  4502 			// long as frames are received: Reset watchdog.
       
  4503 			adapter->ec_watchdog_jiffies = jiffies;
       
  4504 		} else {
       
  4505 			e1000_receive_skb(adapter, status, rx_desc->special, skb);
       
  4506 		}
       
  4507 
       
  4508 next_desc:
       
  4509 		rx_desc->status = 0;
       
  4510 
       
  4511 		/* return some buffers to hardware, one at a time is too slow */
       
  4512 		if (unlikely(cleaned_count >= E1000_RX_BUFFER_WRITE)) {
       
  4513 			adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
       
  4514 			cleaned_count = 0;
       
  4515 		}
       
  4516 
       
  4517 		/* use prefetched values */
       
  4518 		rx_desc = next_rxd;
       
  4519 		buffer_info = next_buffer;
       
  4520 	}
       
  4521 	rx_ring->next_to_clean = i;
       
  4522 
       
  4523 	cleaned_count = E1000_DESC_UNUSED(rx_ring);
       
  4524 	if (cleaned_count)
       
  4525 		adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count);
       
  4526 
       
  4527 	adapter->total_rx_packets += total_rx_packets;
       
  4528 	adapter->total_rx_bytes += total_rx_bytes;
       
  4529 	netdev->stats.rx_bytes += total_rx_bytes;
       
  4530 	netdev->stats.rx_packets += total_rx_packets;
       
  4531 	return cleaned;
       
  4532 }
       
  4533 
       
  4534 /**
       
  4535  * e1000_alloc_jumbo_rx_buffers - Replace used jumbo receive buffers
       
  4536  * @adapter: address of board private structure
       
  4537  * @rx_ring: pointer to receive ring structure
       
  4538  * @cleaned_count: number of buffers to allocate this pass
       
  4539  **/
       
  4540 
       
  4541 static void
       
  4542 e1000_alloc_jumbo_rx_buffers(struct e1000_adapter *adapter,
       
  4543                              struct e1000_rx_ring *rx_ring, int cleaned_count)
       
  4544 {
       
  4545 	struct net_device *netdev = adapter->netdev;
       
  4546 	struct pci_dev *pdev = adapter->pdev;
       
  4547 	struct e1000_rx_desc *rx_desc;
       
  4548 	struct e1000_buffer *buffer_info;
       
  4549 	struct sk_buff *skb;
       
  4550 	unsigned int i;
       
  4551 	unsigned int bufsz = 256 - 16 /*for skb_reserve */ ;
       
  4552 
       
  4553 	i = rx_ring->next_to_use;
       
  4554 	buffer_info = &rx_ring->buffer_info[i];
       
  4555 
       
  4556 	while (cleaned_count--) {
       
  4557 		skb = buffer_info->skb;
       
  4558 		if (skb) {
       
  4559 			skb_trim(skb, 0);
       
  4560 			goto check_page;
       
  4561 		}
       
  4562 
       
  4563 		skb = netdev_alloc_skb_ip_align(netdev, bufsz);
       
  4564 		if (unlikely(!skb)) {
       
  4565 			/* Better luck next round */
       
  4566 			adapter->alloc_rx_buff_failed++;
       
  4567 			break;
       
  4568 		}
       
  4569 
       
  4570 		buffer_info->skb = skb;
       
  4571 		buffer_info->length = adapter->rx_buffer_len;
       
  4572 check_page:
       
  4573 		/* allocate a new page if necessary */
       
  4574 		if (!buffer_info->page) {
       
  4575 			buffer_info->page = alloc_page(GFP_ATOMIC);
       
  4576 			if (unlikely(!buffer_info->page)) {
       
  4577 				adapter->alloc_rx_buff_failed++;
       
  4578 				break;
       
  4579 			}
       
  4580 		}
       
  4581 
       
  4582 		if (!buffer_info->dma) {
       
  4583 			buffer_info->dma = dma_map_page(&pdev->dev,
       
  4584 			                                buffer_info->page, 0,
       
  4585 							buffer_info->length,
       
  4586 							DMA_FROM_DEVICE);
       
  4587 			if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
       
  4588 				put_page(buffer_info->page);
       
  4589 				dev_kfree_skb(skb);
       
  4590 				buffer_info->page = NULL;
       
  4591 				buffer_info->skb = NULL;
       
  4592 				buffer_info->dma = 0;
       
  4593 				adapter->alloc_rx_buff_failed++;
       
  4594 				break; /* while !buffer_info->skb */
       
  4595 			}
       
  4596 		}
       
  4597 
       
  4598 		rx_desc = E1000_RX_DESC(*rx_ring, i);
       
  4599 		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
       
  4600 
       
  4601 		if (unlikely(++i == rx_ring->count))
       
  4602 			i = 0;
       
  4603 		buffer_info = &rx_ring->buffer_info[i];
       
  4604 	}
       
  4605 
       
  4606 	if (likely(rx_ring->next_to_use != i)) {
       
  4607 		rx_ring->next_to_use = i;
       
  4608 		if (unlikely(i-- == 0))
       
  4609 			i = (rx_ring->count - 1);
       
  4610 
       
  4611 		/* Force memory writes to complete before letting h/w
       
  4612 		 * know there are new descriptors to fetch.  (Only
       
  4613 		 * applicable for weak-ordered memory model archs,
       
  4614 		 * such as IA-64). */
       
  4615 		wmb();
       
  4616 		writel(i, adapter->hw.hw_addr + rx_ring->rdt);
       
  4617 	}
       
  4618 }
       
  4619 
       
  4620 /**
       
  4621  * e1000_alloc_rx_buffers - Replace used receive buffers; legacy & extended
       
  4622  * @adapter: address of board private structure
       
  4623  **/
       
  4624 
       
  4625 static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,
       
  4626 				   struct e1000_rx_ring *rx_ring,
       
  4627 				   int cleaned_count)
       
  4628 {
       
  4629 	struct e1000_hw *hw = &adapter->hw;
       
  4630 	struct net_device *netdev = adapter->netdev;
       
  4631 	struct pci_dev *pdev = adapter->pdev;
       
  4632 	struct e1000_rx_desc *rx_desc;
       
  4633 	struct e1000_buffer *buffer_info;
       
  4634 	struct sk_buff *skb;
       
  4635 	unsigned int i;
       
  4636 	unsigned int bufsz = adapter->rx_buffer_len;
       
  4637 
       
  4638 	i = rx_ring->next_to_use;
       
  4639 	buffer_info = &rx_ring->buffer_info[i];
       
  4640 
       
  4641 	while (cleaned_count--) {
       
  4642 		skb = buffer_info->skb;
       
  4643 		if (skb) {
       
  4644 			skb_trim(skb, 0);
       
  4645 			goto map_skb;
       
  4646 		}
       
  4647 
       
  4648 		skb = netdev_alloc_skb_ip_align(netdev, bufsz);
       
  4649 		if (unlikely(!skb)) {
       
  4650 			/* Better luck next round */
       
  4651 			adapter->alloc_rx_buff_failed++;
       
  4652 			break;
       
  4653 		}
       
  4654 
       
  4655 		/* Fix for errata 23, can't cross 64kB boundary */
       
  4656 		if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
       
  4657 			struct sk_buff *oldskb = skb;
       
  4658 			e_err(rx_err, "skb align check failed: %u bytes at "
       
  4659 			      "%p\n", bufsz, skb->data);
       
  4660 			/* Try again, without freeing the previous */
       
  4661 			skb = netdev_alloc_skb_ip_align(netdev, bufsz);
       
  4662 			/* Failed allocation, critical failure */
       
  4663 			if (!skb) {
       
  4664 				dev_kfree_skb(oldskb);
       
  4665 				adapter->alloc_rx_buff_failed++;
       
  4666 				break;
       
  4667 			}
       
  4668 
       
  4669 			if (!e1000_check_64k_bound(adapter, skb->data, bufsz)) {
       
  4670 				/* give up */
       
  4671 				dev_kfree_skb(skb);
       
  4672 				dev_kfree_skb(oldskb);
       
  4673 				adapter->alloc_rx_buff_failed++;
       
  4674 				break; /* while !buffer_info->skb */
       
  4675 			}
       
  4676 
       
  4677 			/* Use new allocation */
       
  4678 			dev_kfree_skb(oldskb);
       
  4679 		}
       
  4680 		buffer_info->skb = skb;
       
  4681 		buffer_info->length = adapter->rx_buffer_len;
       
  4682 map_skb:
       
  4683 		buffer_info->dma = dma_map_single(&pdev->dev,
       
  4684 						  skb->data,
       
  4685 						  buffer_info->length,
       
  4686 						  DMA_FROM_DEVICE);
       
  4687 		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
       
  4688 			dev_kfree_skb(skb);
       
  4689 			buffer_info->skb = NULL;
       
  4690 			buffer_info->dma = 0;
       
  4691 			adapter->alloc_rx_buff_failed++;
       
  4692 			break; /* while !buffer_info->skb */
       
  4693 		}
       
  4694 
       
  4695 		/*
       
  4696 		 * XXX if it was allocated cleanly it will never map to a
       
  4697 		 * boundary crossing
       
  4698 		 */
       
  4699 
       
  4700 		/* Fix for errata 23, can't cross 64kB boundary */
       
  4701 		if (!e1000_check_64k_bound(adapter,
       
  4702 					(void *)(unsigned long)buffer_info->dma,
       
  4703 					adapter->rx_buffer_len)) {
       
  4704 			e_err(rx_err, "dma align check failed: %u bytes at "
       
  4705 			      "%p\n", adapter->rx_buffer_len,
       
  4706 			      (void *)(unsigned long)buffer_info->dma);
       
  4707 			dev_kfree_skb(skb);
       
  4708 			buffer_info->skb = NULL;
       
  4709 
       
  4710 			dma_unmap_single(&pdev->dev, buffer_info->dma,
       
  4711 					 adapter->rx_buffer_len,
       
  4712 					 DMA_FROM_DEVICE);
       
  4713 			buffer_info->dma = 0;
       
  4714 
       
  4715 			adapter->alloc_rx_buff_failed++;
       
  4716 			break; /* while !buffer_info->skb */
       
  4717 		}
       
  4718 		rx_desc = E1000_RX_DESC(*rx_ring, i);
       
  4719 		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
       
  4720 
       
  4721 		if (unlikely(++i == rx_ring->count))
       
  4722 			i = 0;
       
  4723 		buffer_info = &rx_ring->buffer_info[i];
       
  4724 	}
       
  4725 
       
  4726 	if (likely(rx_ring->next_to_use != i)) {
       
  4727 		rx_ring->next_to_use = i;
       
  4728 		if (unlikely(i-- == 0))
       
  4729 			i = (rx_ring->count - 1);
       
  4730 
       
  4731 		/* Force memory writes to complete before letting h/w
       
  4732 		 * know there are new descriptors to fetch.  (Only
       
  4733 		 * applicable for weak-ordered memory model archs,
       
  4734 		 * such as IA-64). */
       
  4735 		wmb();
       
  4736 		writel(i, hw->hw_addr + rx_ring->rdt);
       
  4737 	}
       
  4738 }
       
  4739 
       
  4740 /**
       
  4741  * e1000_smartspeed - Workaround for SmartSpeed on 82541 and 82547 controllers.
       
  4742  * @adapter:
       
  4743  **/
       
  4744 
       
  4745 static void e1000_smartspeed(struct e1000_adapter *adapter)
       
  4746 {
       
  4747 	struct e1000_hw *hw = &adapter->hw;
       
  4748 	u16 phy_status;
       
  4749 	u16 phy_ctrl;
       
  4750 
       
  4751 	if ((hw->phy_type != e1000_phy_igp) || !hw->autoneg ||
       
  4752 	   !(hw->autoneg_advertised & ADVERTISE_1000_FULL))
       
  4753 		return;
       
  4754 
       
  4755 	if (adapter->smartspeed == 0) {
       
  4756 		/* If Master/Slave config fault is asserted twice,
       
  4757 		 * we assume back-to-back */
       
  4758 		e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
       
  4759 		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
       
  4760 		e1000_read_phy_reg(hw, PHY_1000T_STATUS, &phy_status);
       
  4761 		if (!(phy_status & SR_1000T_MS_CONFIG_FAULT)) return;
       
  4762 		e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
       
  4763 		if (phy_ctrl & CR_1000T_MS_ENABLE) {
       
  4764 			phy_ctrl &= ~CR_1000T_MS_ENABLE;
       
  4765 			e1000_write_phy_reg(hw, PHY_1000T_CTRL,
       
  4766 					    phy_ctrl);
       
  4767 			adapter->smartspeed++;
       
  4768 			if (!e1000_phy_setup_autoneg(hw) &&
       
  4769 			   !e1000_read_phy_reg(hw, PHY_CTRL,
       
  4770 				   	       &phy_ctrl)) {
       
  4771 				phy_ctrl |= (MII_CR_AUTO_NEG_EN |
       
  4772 					     MII_CR_RESTART_AUTO_NEG);
       
  4773 				e1000_write_phy_reg(hw, PHY_CTRL,
       
  4774 						    phy_ctrl);
       
  4775 			}
       
  4776 		}
       
  4777 		return;
       
  4778 	} else if (adapter->smartspeed == E1000_SMARTSPEED_DOWNSHIFT) {
       
  4779 		/* If still no link, perhaps using 2/3 pair cable */
       
  4780 		e1000_read_phy_reg(hw, PHY_1000T_CTRL, &phy_ctrl);
       
  4781 		phy_ctrl |= CR_1000T_MS_ENABLE;
       
  4782 		e1000_write_phy_reg(hw, PHY_1000T_CTRL, phy_ctrl);
       
  4783 		if (!e1000_phy_setup_autoneg(hw) &&
       
  4784 		   !e1000_read_phy_reg(hw, PHY_CTRL, &phy_ctrl)) {
       
  4785 			phy_ctrl |= (MII_CR_AUTO_NEG_EN |
       
  4786 				     MII_CR_RESTART_AUTO_NEG);
       
  4787 			e1000_write_phy_reg(hw, PHY_CTRL, phy_ctrl);
       
  4788 		}
       
  4789 	}
       
  4790 	/* Restart process after E1000_SMARTSPEED_MAX iterations */
       
  4791 	if (adapter->smartspeed++ == E1000_SMARTSPEED_MAX)
       
  4792 		adapter->smartspeed = 0;
       
  4793 }
       
  4794 
       
  4795 /**
       
  4796  * e1000_ioctl -
       
  4797  * @netdev:
       
  4798  * @ifreq:
       
  4799  * @cmd:
       
  4800  **/
       
  4801 
       
  4802 static int e1000_ioctl(struct net_device *netdev, struct ifreq *ifr, int cmd)
       
  4803 {
       
  4804 	switch (cmd) {
       
  4805 	case SIOCGMIIPHY:
       
  4806 	case SIOCGMIIREG:
       
  4807 	case SIOCSMIIREG:
       
  4808 		return e1000_mii_ioctl(netdev, ifr, cmd);
       
  4809 	default:
       
  4810 		return -EOPNOTSUPP;
       
  4811 	}
       
  4812 }
       
  4813 
       
  4814 /**
       
  4815  * e1000_mii_ioctl -
       
  4816  * @netdev:
       
  4817  * @ifreq:
       
  4818  * @cmd:
       
  4819  **/
       
  4820 
       
  4821 static int e1000_mii_ioctl(struct net_device *netdev, struct ifreq *ifr,
       
  4822 			   int cmd)
       
  4823 {
       
  4824 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  4825 	struct e1000_hw *hw = &adapter->hw;
       
  4826 	struct mii_ioctl_data *data = if_mii(ifr);
       
  4827 	int retval;
       
  4828 	u16 mii_reg;
       
  4829 	unsigned long flags;
       
  4830 
       
  4831 	if (hw->media_type != e1000_media_type_copper)
       
  4832 		return -EOPNOTSUPP;
       
  4833 
       
  4834 	switch (cmd) {
       
  4835 	case SIOCGMIIPHY:
       
  4836 		data->phy_id = hw->phy_addr;
       
  4837 		break;
       
  4838 	case SIOCGMIIREG:
       
  4839 		if (adapter->ecdev) {
       
  4840 			return -EPERM;
       
  4841 		}
       
  4842 		spin_lock_irqsave(&adapter->stats_lock, flags);
       
  4843 		if (e1000_read_phy_reg(hw, data->reg_num & 0x1F,
       
  4844 				   &data->val_out)) {
       
  4845 			spin_unlock_irqrestore(&adapter->stats_lock, flags);
       
  4846 			return -EIO;
       
  4847 		}
       
  4848 		spin_unlock_irqrestore(&adapter->stats_lock, flags);
       
  4849 		break;
       
  4850 	case SIOCSMIIREG:
       
  4851 		if (adapter->ecdev) {
       
  4852 			return -EPERM;
       
  4853 		}
       
  4854 		if (data->reg_num & ~(0x1F))
       
  4855 			return -EFAULT;
       
  4856 		mii_reg = data->val_in;
       
  4857 		spin_lock_irqsave(&adapter->stats_lock, flags);
       
  4858 		if (e1000_write_phy_reg(hw, data->reg_num,
       
  4859 					mii_reg)) {
       
  4860 			spin_unlock_irqrestore(&adapter->stats_lock, flags);
       
  4861 			return -EIO;
       
  4862 		}
       
  4863 		spin_unlock_irqrestore(&adapter->stats_lock, flags);
       
  4864 		if (hw->media_type == e1000_media_type_copper) {
       
  4865 			switch (data->reg_num) {
       
  4866 			case PHY_CTRL:
       
  4867 				if (mii_reg & MII_CR_POWER_DOWN)
       
  4868 					break;
       
  4869 				if (mii_reg & MII_CR_AUTO_NEG_EN) {
       
  4870 					hw->autoneg = 1;
       
  4871 					hw->autoneg_advertised = 0x2F;
       
  4872 				} else {
       
  4873 					u32 speed;
       
  4874 					if (mii_reg & 0x40)
       
  4875 						speed = SPEED_1000;
       
  4876 					else if (mii_reg & 0x2000)
       
  4877 						speed = SPEED_100;
       
  4878 					else
       
  4879 						speed = SPEED_10;
       
  4880 					retval = e1000_set_spd_dplx(
       
  4881 						adapter, speed,
       
  4882 						((mii_reg & 0x100)
       
  4883 						 ? DUPLEX_FULL :
       
  4884 						 DUPLEX_HALF));
       
  4885 					if (retval)
       
  4886 						return retval;
       
  4887 				}
       
  4888 				if (netif_running(adapter->netdev))
       
  4889 					e1000_reinit_locked(adapter);
       
  4890 				else
       
  4891 					e1000_reset(adapter);
       
  4892 				break;
       
  4893 			case M88E1000_PHY_SPEC_CTRL:
       
  4894 			case M88E1000_EXT_PHY_SPEC_CTRL:
       
  4895 				if (e1000_phy_reset(hw))
       
  4896 					return -EIO;
       
  4897 				break;
       
  4898 			}
       
  4899 		} else {
       
  4900 			switch (data->reg_num) {
       
  4901 			case PHY_CTRL:
       
  4902 				if (mii_reg & MII_CR_POWER_DOWN)
       
  4903 					break;
       
  4904 				if (netif_running(adapter->netdev))
       
  4905 					e1000_reinit_locked(adapter);
       
  4906 				else
       
  4907 					e1000_reset(adapter);
       
  4908 				break;
       
  4909 			}
       
  4910 		}
       
  4911 		break;
       
  4912 	default:
       
  4913 		return -EOPNOTSUPP;
       
  4914 	}
       
  4915 	return E1000_SUCCESS;
       
  4916 }
       
  4917 
       
  4918 void e1000_pci_set_mwi(struct e1000_hw *hw)
       
  4919 {
       
  4920 	struct e1000_adapter *adapter = hw->back;
       
  4921 	int ret_val = pci_set_mwi(adapter->pdev);
       
  4922 
       
  4923 	if (ret_val)
       
  4924 		e_err(probe, "Error in setting MWI\n");
       
  4925 }
       
  4926 
       
  4927 void e1000_pci_clear_mwi(struct e1000_hw *hw)
       
  4928 {
       
  4929 	struct e1000_adapter *adapter = hw->back;
       
  4930 
       
  4931 	pci_clear_mwi(adapter->pdev);
       
  4932 }
       
  4933 
       
  4934 int e1000_pcix_get_mmrbc(struct e1000_hw *hw)
       
  4935 {
       
  4936 	struct e1000_adapter *adapter = hw->back;
       
  4937 	return pcix_get_mmrbc(adapter->pdev);
       
  4938 }
       
  4939 
       
  4940 void e1000_pcix_set_mmrbc(struct e1000_hw *hw, int mmrbc)
       
  4941 {
       
  4942 	struct e1000_adapter *adapter = hw->back;
       
  4943 	pcix_set_mmrbc(adapter->pdev, mmrbc);
       
  4944 }
       
  4945 
       
  4946 void e1000_io_write(struct e1000_hw *hw, unsigned long port, u32 value)
       
  4947 {
       
  4948 	outl(value, port);
       
  4949 }
       
  4950 
       
  4951 static bool e1000_vlan_used(struct e1000_adapter *adapter)
       
  4952 {
       
  4953 	u16 vid;
       
  4954 
       
  4955 	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
       
  4956 		return true;
       
  4957 	return false;
       
  4958 }
       
  4959 
       
  4960 static void __e1000_vlan_mode(struct e1000_adapter *adapter,
       
  4961 			      netdev_features_t features)
       
  4962 {
       
  4963 	struct e1000_hw *hw = &adapter->hw;
       
  4964 	u32 ctrl;
       
  4965 
       
  4966 	ctrl = er32(CTRL);
       
  4967 	if (features & NETIF_F_HW_VLAN_RX) {
       
  4968 		/* enable VLAN tag insert/strip */
       
  4969 		ctrl |= E1000_CTRL_VME;
       
  4970 	} else {
       
  4971 		/* disable VLAN tag insert/strip */
       
  4972 		ctrl &= ~E1000_CTRL_VME;
       
  4973 	}
       
  4974 	ew32(CTRL, ctrl);
       
  4975 }
       
  4976 static void e1000_vlan_filter_on_off(struct e1000_adapter *adapter,
       
  4977 				     bool filter_on)
       
  4978 {
       
  4979 	struct e1000_hw *hw = &adapter->hw;
       
  4980 	u32 rctl;
       
  4981 
       
  4982 	if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  4983 		e1000_irq_disable(adapter);
       
  4984 
       
  4985 	__e1000_vlan_mode(adapter, adapter->netdev->features);
       
  4986 	if (filter_on) {
       
  4987 		/* enable VLAN receive filtering */
       
  4988 		rctl = er32(RCTL);
       
  4989 		rctl &= ~E1000_RCTL_CFIEN;
       
  4990 		if (!(adapter->netdev->flags & IFF_PROMISC))
       
  4991 			rctl |= E1000_RCTL_VFE;
       
  4992 		ew32(RCTL, rctl);
       
  4993 		e1000_update_mng_vlan(adapter);
       
  4994 	} else {
       
  4995 		/* disable VLAN receive filtering */
       
  4996 		rctl = er32(RCTL);
       
  4997 		rctl &= ~E1000_RCTL_VFE;
       
  4998 		ew32(RCTL, rctl);
       
  4999 	}
       
  5000 
       
  5001 	if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  5002 		e1000_irq_enable(adapter);
       
  5003 }
       
  5004 
       
  5005 static void e1000_vlan_mode(struct net_device *netdev,
       
  5006 			    netdev_features_t features)
       
  5007 {
       
  5008 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5009 
       
  5010 	if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  5011 		e1000_irq_disable(adapter);
       
  5012 
       
  5013 	__e1000_vlan_mode(adapter, features);
       
  5014 
       
  5015 	if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  5016 		e1000_irq_enable(adapter);
       
  5017 }
       
  5018 
       
  5019 static int e1000_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
       
  5020 {
       
  5021 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5022 	struct e1000_hw *hw = &adapter->hw;
       
  5023 	u32 vfta, index;
       
  5024 
       
  5025 	if ((hw->mng_cookie.status &
       
  5026 	     E1000_MNG_DHCP_COOKIE_STATUS_VLAN_SUPPORT) &&
       
  5027 	    (vid == adapter->mng_vlan_id))
       
  5028 		return 0;
       
  5029 
       
  5030 	if (!e1000_vlan_used(adapter))
       
  5031 		e1000_vlan_filter_on_off(adapter, true);
       
  5032 
       
  5033 	/* add VID to filter table */
       
  5034 	index = (vid >> 5) & 0x7F;
       
  5035 	vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
       
  5036 	vfta |= (1 << (vid & 0x1F));
       
  5037 	e1000_write_vfta(hw, index, vfta);
       
  5038 
       
  5039 	set_bit(vid, adapter->active_vlans);
       
  5040 
       
  5041 	return 0;
       
  5042 }
       
  5043 
       
  5044 static int e1000_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
       
  5045 {
       
  5046 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5047 	struct e1000_hw *hw = &adapter->hw;
       
  5048 	u32 vfta, index;
       
  5049 
       
  5050 	if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  5051 		e1000_irq_disable(adapter);
       
  5052 	if (!test_bit(__E1000_DOWN, &adapter->flags))
       
  5053 		e1000_irq_enable(adapter);
       
  5054 
       
  5055 	/* remove VID from filter table */
       
  5056 	index = (vid >> 5) & 0x7F;
       
  5057 	vfta = E1000_READ_REG_ARRAY(hw, VFTA, index);
       
  5058 	vfta &= ~(1 << (vid & 0x1F));
       
  5059 	e1000_write_vfta(hw, index, vfta);
       
  5060 
       
  5061 	clear_bit(vid, adapter->active_vlans);
       
  5062 
       
  5063 	if (!e1000_vlan_used(adapter))
       
  5064 		e1000_vlan_filter_on_off(adapter, false);
       
  5065 
       
  5066 	return 0;
       
  5067 }
       
  5068 
       
  5069 static void e1000_restore_vlan(struct e1000_adapter *adapter)
       
  5070 {
       
  5071 	u16 vid;
       
  5072 
       
  5073 	if (!e1000_vlan_used(adapter))
       
  5074 		return;
       
  5075 
       
  5076 	e1000_vlan_filter_on_off(adapter, true);
       
  5077 	for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
       
  5078 		e1000_vlan_rx_add_vid(adapter->netdev, vid);
       
  5079 }
       
  5080 
       
  5081 int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)
       
  5082 {
       
  5083 	struct e1000_hw *hw = &adapter->hw;
       
  5084 
       
  5085 	hw->autoneg = 0;
       
  5086 
       
  5087 	/* Make sure dplx is at most 1 bit and lsb of speed is not set
       
  5088 	 * for the switch() below to work */
       
  5089 	if ((spd & 1) || (dplx & ~1))
       
  5090 		goto err_inval;
       
  5091 
       
  5092 	/* Fiber NICs only allow 1000 gbps Full duplex */
       
  5093 	if ((hw->media_type == e1000_media_type_fiber) &&
       
  5094 	    spd != SPEED_1000 &&
       
  5095 	    dplx != DUPLEX_FULL)
       
  5096 		goto err_inval;
       
  5097 
       
  5098 	switch (spd + dplx) {
       
  5099 	case SPEED_10 + DUPLEX_HALF:
       
  5100 		hw->forced_speed_duplex = e1000_10_half;
       
  5101 		break;
       
  5102 	case SPEED_10 + DUPLEX_FULL:
       
  5103 		hw->forced_speed_duplex = e1000_10_full;
       
  5104 		break;
       
  5105 	case SPEED_100 + DUPLEX_HALF:
       
  5106 		hw->forced_speed_duplex = e1000_100_half;
       
  5107 		break;
       
  5108 	case SPEED_100 + DUPLEX_FULL:
       
  5109 		hw->forced_speed_duplex = e1000_100_full;
       
  5110 		break;
       
  5111 	case SPEED_1000 + DUPLEX_FULL:
       
  5112 		hw->autoneg = 1;
       
  5113 		hw->autoneg_advertised = ADVERTISE_1000_FULL;
       
  5114 		break;
       
  5115 	case SPEED_1000 + DUPLEX_HALF: /* not supported */
       
  5116 	default:
       
  5117 		goto err_inval;
       
  5118 	}
       
  5119 
       
  5120 	/* clear MDI, MDI(-X) override is only allowed when autoneg enabled */
       
  5121 	hw->mdix = AUTO_ALL_MODES;
       
  5122 
       
  5123 	return 0;
       
  5124 
       
  5125 err_inval:
       
  5126 	e_err(probe, "Unsupported Speed/Duplex configuration\n");
       
  5127 	return -EINVAL;
       
  5128 }
       
  5129 
       
  5130 static int __e1000_shutdown(struct pci_dev *pdev, bool *enable_wake)
       
  5131 {
       
  5132 	struct net_device *netdev = pci_get_drvdata(pdev);
       
  5133 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5134 	struct e1000_hw *hw = &adapter->hw;
       
  5135 	u32 ctrl, ctrl_ext, rctl, status;
       
  5136 	u32 wufc = adapter->wol;
       
  5137 #ifdef CONFIG_PM
       
  5138 	int retval = 0;
       
  5139 #endif
       
  5140 
       
  5141 	if (adapter->ecdev) {
       
  5142 		return -EBUSY;
       
  5143 	}
       
  5144 
       
  5145 	netif_device_detach(netdev);
       
  5146 
       
  5147 	if (netif_running(netdev)) {
       
  5148 		WARN_ON(test_bit(__E1000_RESETTING, &adapter->flags));
       
  5149 		e1000_down(adapter);
       
  5150 	}
       
  5151 
       
  5152 #ifdef CONFIG_PM
       
  5153 	retval = pci_save_state(pdev);
       
  5154 	if (retval)
       
  5155 		return retval;
       
  5156 #endif
       
  5157 
       
  5158 	status = er32(STATUS);
       
  5159 	if (status & E1000_STATUS_LU)
       
  5160 		wufc &= ~E1000_WUFC_LNKC;
       
  5161 
       
  5162 	if (wufc) {
       
  5163 		e1000_setup_rctl(adapter);
       
  5164 		e1000_set_rx_mode(netdev);
       
  5165 
       
  5166 		rctl = er32(RCTL);
       
  5167 
       
  5168 		/* turn on all-multi mode if wake on multicast is enabled */
       
  5169 		if (wufc & E1000_WUFC_MC)
       
  5170 			rctl |= E1000_RCTL_MPE;
       
  5171 
       
  5172 		/* enable receives in the hardware */
       
  5173 		ew32(RCTL, rctl | E1000_RCTL_EN);
       
  5174 
       
  5175 		if (hw->mac_type >= e1000_82540) {
       
  5176 			ctrl = er32(CTRL);
       
  5177 			/* advertise wake from D3Cold */
       
  5178 			#define E1000_CTRL_ADVD3WUC 0x00100000
       
  5179 			/* phy power management enable */
       
  5180 			#define E1000_CTRL_EN_PHY_PWR_MGMT 0x00200000
       
  5181 			ctrl |= E1000_CTRL_ADVD3WUC |
       
  5182 				E1000_CTRL_EN_PHY_PWR_MGMT;
       
  5183 			ew32(CTRL, ctrl);
       
  5184 		}
       
  5185 
       
  5186 		if (hw->media_type == e1000_media_type_fiber ||
       
  5187 		    hw->media_type == e1000_media_type_internal_serdes) {
       
  5188 			/* keep the laser running in D3 */
       
  5189 			ctrl_ext = er32(CTRL_EXT);
       
  5190 			ctrl_ext |= E1000_CTRL_EXT_SDP7_DATA;
       
  5191 			ew32(CTRL_EXT, ctrl_ext);
       
  5192 		}
       
  5193 
       
  5194 		ew32(WUC, E1000_WUC_PME_EN);
       
  5195 		ew32(WUFC, wufc);
       
  5196 	} else {
       
  5197 		ew32(WUC, 0);
       
  5198 		ew32(WUFC, 0);
       
  5199 	}
       
  5200 
       
  5201 	e1000_release_manageability(adapter);
       
  5202 
       
  5203 	*enable_wake = !!wufc;
       
  5204 
       
  5205 	/* make sure adapter isn't asleep if manageability is enabled */
       
  5206 	if (adapter->en_mng_pt)
       
  5207 		*enable_wake = true;
       
  5208 
       
  5209 	if (netif_running(netdev))
       
  5210 		e1000_free_irq(adapter);
       
  5211 
       
  5212 	pci_disable_device(pdev);
       
  5213 
       
  5214 	return 0;
       
  5215 }
       
  5216 
       
  5217 #ifdef CONFIG_PM
       
  5218 static int e1000_suspend(struct pci_dev *pdev, pm_message_t state)
       
  5219 {
       
  5220 	int retval;
       
  5221 	bool wake;
       
  5222 
       
  5223 	retval = __e1000_shutdown(pdev, &wake);
       
  5224 	if (retval)
       
  5225 		return retval;
       
  5226 
       
  5227 	if (wake) {
       
  5228 		pci_prepare_to_sleep(pdev);
       
  5229 	} else {
       
  5230 		pci_wake_from_d3(pdev, false);
       
  5231 		pci_set_power_state(pdev, PCI_D3hot);
       
  5232 	}
       
  5233 
       
  5234 	return 0;
       
  5235 }
       
  5236 
       
  5237 static int e1000_resume(struct pci_dev *pdev)
       
  5238 {
       
  5239 	struct net_device *netdev = pci_get_drvdata(pdev);
       
  5240 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5241 	struct e1000_hw *hw = &adapter->hw;
       
  5242 	u32 err;
       
  5243 
       
  5244 	if (adapter->ecdev) {
       
  5245 		return -EBUSY;
       
  5246 	}
       
  5247 
       
  5248 	pci_set_power_state(pdev, PCI_D0);
       
  5249 	pci_restore_state(pdev);
       
  5250 	pci_save_state(pdev);
       
  5251 
       
  5252 	if (adapter->need_ioport)
       
  5253 		err = pci_enable_device(pdev);
       
  5254 	else
       
  5255 		err = pci_enable_device_mem(pdev);
       
  5256 	if (err) {
       
  5257 		pr_err("Cannot enable PCI device from suspend\n");
       
  5258 		return err;
       
  5259 	}
       
  5260 	pci_set_master(pdev);
       
  5261 
       
  5262 	pci_enable_wake(pdev, PCI_D3hot, 0);
       
  5263 	pci_enable_wake(pdev, PCI_D3cold, 0);
       
  5264 
       
  5265 	if (netif_running(netdev)) {
       
  5266 		err = e1000_request_irq(adapter);
       
  5267 		if (err)
       
  5268 			return err;
       
  5269 	}
       
  5270 
       
  5271 	e1000_power_up_phy(adapter);
       
  5272 	e1000_reset(adapter);
       
  5273 	ew32(WUS, ~0);
       
  5274 
       
  5275 	e1000_init_manageability(adapter);
       
  5276 
       
  5277 	if (netif_running(netdev))
       
  5278 		e1000_up(adapter);
       
  5279 
       
  5280 	if (!adapter->ecdev) {
       
  5281 		netif_device_attach(netdev);
       
  5282 	}
       
  5283 
       
  5284 	return 0;
       
  5285 }
       
  5286 #endif
       
  5287 
       
  5288 static void e1000_shutdown(struct pci_dev *pdev)
       
  5289 {
       
  5290 	bool wake;
       
  5291 
       
  5292 	__e1000_shutdown(pdev, &wake);
       
  5293 
       
  5294 	if (system_state == SYSTEM_POWER_OFF) {
       
  5295 		pci_wake_from_d3(pdev, wake);
       
  5296 		pci_set_power_state(pdev, PCI_D3hot);
       
  5297 	}
       
  5298 }
       
  5299 
       
  5300 #ifdef CONFIG_NET_POLL_CONTROLLER
       
  5301 /*
       
  5302  * Polling 'interrupt' - used by things like netconsole to send skbs
       
  5303  * without having to re-enable interrupts. It's not called while
       
  5304  * the interrupt routine is executing.
       
  5305  */
       
  5306 static void e1000_netpoll(struct net_device *netdev)
       
  5307 {
       
  5308 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5309 
       
  5310 	disable_irq(adapter->pdev->irq);
       
  5311 	e1000_intr(adapter->pdev->irq, netdev);
       
  5312 	enable_irq(adapter->pdev->irq);
       
  5313 }
       
  5314 #endif
       
  5315 
       
  5316 /**
       
  5317  * e1000_io_error_detected - called when PCI error is detected
       
  5318  * @pdev: Pointer to PCI device
       
  5319  * @state: The current pci connection state
       
  5320  *
       
  5321  * This function is called after a PCI bus error affecting
       
  5322  * this device has been detected.
       
  5323  */
       
  5324 static pci_ers_result_t e1000_io_error_detected(struct pci_dev *pdev,
       
  5325 						pci_channel_state_t state)
       
  5326 {
       
  5327 	struct net_device *netdev = pci_get_drvdata(pdev);
       
  5328 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5329 
       
  5330 	netif_device_detach(netdev);
       
  5331 
       
  5332 	if (state == pci_channel_io_perm_failure)
       
  5333 		return PCI_ERS_RESULT_DISCONNECT;
       
  5334 
       
  5335 	if (netif_running(netdev))
       
  5336 		e1000_down(adapter);
       
  5337 	pci_disable_device(pdev);
       
  5338 
       
  5339 	/* Request a slot slot reset. */
       
  5340 	return PCI_ERS_RESULT_NEED_RESET;
       
  5341 }
       
  5342 
       
  5343 /**
       
  5344  * e1000_io_slot_reset - called after the pci bus has been reset.
       
  5345  * @pdev: Pointer to PCI device
       
  5346  *
       
  5347  * Restart the card from scratch, as if from a cold-boot. Implementation
       
  5348  * resembles the first-half of the e1000_resume routine.
       
  5349  */
       
  5350 static pci_ers_result_t e1000_io_slot_reset(struct pci_dev *pdev)
       
  5351 {
       
  5352 	struct net_device *netdev = pci_get_drvdata(pdev);
       
  5353 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5354 	struct e1000_hw *hw = &adapter->hw;
       
  5355 	int err;
       
  5356 
       
  5357 	if (adapter->need_ioport)
       
  5358 		err = pci_enable_device(pdev);
       
  5359 	else
       
  5360 		err = pci_enable_device_mem(pdev);
       
  5361 	if (err) {
       
  5362 		pr_err("Cannot re-enable PCI device after reset.\n");
       
  5363 		return PCI_ERS_RESULT_DISCONNECT;
       
  5364 	}
       
  5365 	pci_set_master(pdev);
       
  5366 
       
  5367 	pci_enable_wake(pdev, PCI_D3hot, 0);
       
  5368 	pci_enable_wake(pdev, PCI_D3cold, 0);
       
  5369 
       
  5370 	e1000_reset(adapter);
       
  5371 	ew32(WUS, ~0);
       
  5372 
       
  5373 	return PCI_ERS_RESULT_RECOVERED;
       
  5374 }
       
  5375 
       
  5376 /**
       
  5377  * e1000_io_resume - called when traffic can start flowing again.
       
  5378  * @pdev: Pointer to PCI device
       
  5379  *
       
  5380  * This callback is called when the error recovery driver tells us that
       
  5381  * its OK to resume normal operation. Implementation resembles the
       
  5382  * second-half of the e1000_resume routine.
       
  5383  */
       
  5384 static void e1000_io_resume(struct pci_dev *pdev)
       
  5385 {
       
  5386 	struct net_device *netdev = pci_get_drvdata(pdev);
       
  5387 	struct e1000_adapter *adapter = netdev_priv(netdev);
       
  5388 
       
  5389 	e1000_init_manageability(adapter);
       
  5390 
       
  5391 	if (netif_running(netdev)) {
       
  5392 		if (e1000_up(adapter)) {
       
  5393 			pr_info("can't bring device back up after reset\n");
       
  5394 			return;
       
  5395 		}
       
  5396 	}
       
  5397 
       
  5398 	netif_device_attach(netdev);
       
  5399 }
       
  5400 
       
  5401 /* e1000_main.c */